src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10 /* Functions for reading the configuration file, and for displaying
  11 overall configuration values. Thanks to Brian Candler for the original
  12 implementation of the conditional .ifdef etc. */
  13
  14 #include "exim.h"
  15
  16 #ifdef MACRO_PREDEF
  17 # include "macro_predef.h"
  18 #endif
  19
  20 #define READCONF_DEBUG  if (FALSE)      /* Change to TRUE to enable */
  21
  22
  23 static uschar * syslog_facility_str;
  24 static void fn_smtp_receive_timeout(const uschar *, const uschar *, unsigned);
  25
  26 /*************************************************
  27 *           Main configuration options           *
  28 *************************************************/
  29
  30 /* The list of options that can be set in the main configuration file. This
  31 must be in alphabetic order because it is searched by binary chop. */
  32
  33 static optionlist optionlist_config[] = {
  34   { "*set_exim_group",          opt_bool|opt_hidden, {&exim_gid_set} },
  35   { "*set_exim_user",           opt_bool|opt_hidden, {&exim_uid_set} },
  36   { "*set_system_filter_group", opt_bool|opt_hidden, {&system_filter_gid_set} },
  37   { "*set_system_filter_user",  opt_bool|opt_hidden, {&system_filter_uid_set} },
  38   { "accept_8bitmime",          opt_bool,        {&accept_8bitmime} },
  39   { "acl_not_smtp",             opt_stringptr,   {&acl_not_smtp} },
  40 #ifdef WITH_CONTENT_SCAN
  41   { "acl_not_smtp_mime",        opt_stringptr,   {&acl_not_smtp_mime} },
  42 #endif
  43   { "acl_not_smtp_start",       opt_stringptr,   {&acl_not_smtp_start} },
  44   { "acl_smtp_auth",            opt_stringptr,   {&acl_smtp_auth} },
  45   { "acl_smtp_connect",         opt_stringptr,   {&acl_smtp_connect} },
  46   { "acl_smtp_data",            opt_stringptr,   {&acl_smtp_data} },
  47 #ifndef DISABLE_PRDR
  48   { "acl_smtp_data_prdr",       opt_stringptr,   {&acl_smtp_data_prdr} },
  49 #endif
  50 #ifndef DISABLE_DKIM
  51   { "acl_smtp_dkim",            opt_stringptr,   {&acl_smtp_dkim} },
  52 #endif
  53   { "acl_smtp_etrn",            opt_stringptr,   {&acl_smtp_etrn} },
  54   { "acl_smtp_expn",            opt_stringptr,   {&acl_smtp_expn} },
  55   { "acl_smtp_helo",            opt_stringptr,   {&acl_smtp_helo} },
  56   { "acl_smtp_mail",            opt_stringptr,   {&acl_smtp_mail} },
  57   { "acl_smtp_mailauth",        opt_stringptr,   {&acl_smtp_mailauth} },
  58 #ifdef WITH_CONTENT_SCAN
  59   { "acl_smtp_mime",            opt_stringptr,   {&acl_smtp_mime} },
  60 #endif
  61   { "acl_smtp_notquit",         opt_stringptr,   {&acl_smtp_notquit} },
  62   { "acl_smtp_predata",         opt_stringptr,   {&acl_smtp_predata} },
  63   { "acl_smtp_quit",            opt_stringptr,   {&acl_smtp_quit} },
  64   { "acl_smtp_rcpt",            opt_stringptr,   {&acl_smtp_rcpt} },
  65 #ifndef DISABLE_TLS
  66   { "acl_smtp_starttls",        opt_stringptr,   {&acl_smtp_starttls} },
  67 #endif
  68   { "acl_smtp_vrfy",            opt_stringptr,   {&acl_smtp_vrfy} },
  69 #ifndef DISABLE_WELLKNOWN
  70   { "acl_smtp_wellknown",       opt_stringptr,   {&acl_smtp_wellknown} },
  71 #endif
  72   { "add_environment",          opt_stringptr,   {&add_environment} },
  73   { "admin_groups",             opt_gidlist,     {&admin_groups} },
  74   { "allow_domain_literals",    opt_bool,        {&allow_domain_literals} },
  75   { "allow_mx_to_ip",           opt_bool,        {&allow_mx_to_ip} },
  76   { "allow_utf8_domains",       opt_bool,        {&allow_utf8_domains} },
  77   { "auth_advertise_hosts",     opt_stringptr,   {&auth_advertise_hosts} },
  78   { "auto_thaw",                opt_time,        {&auto_thaw} },
  79 #ifdef WITH_CONTENT_SCAN
  80   { "av_scanner",               opt_stringptr,   {&av_scanner} },
  81 #endif
  82   { "bi_command",               opt_stringptr,   {&bi_command} },
  83 #ifdef EXPERIMENTAL_BRIGHTMAIL
  84   { "bmi_config_file",          opt_stringptr,   {&bmi_config_file} },
  85 #endif
  86   { "bounce_message_file",      opt_stringptr,   {&bounce_message_file} },
  87   { "bounce_message_text",      opt_stringptr,   {&bounce_message_text} },
  88   { "bounce_return_body",       opt_bool,        {&bounce_return_body} },
  89   { "bounce_return_linesize_limit", opt_mkint,   {&bounce_return_linesize_limit} },
  90   { "bounce_return_message",    opt_bool,        {&bounce_return_message} },
  91   { "bounce_return_size_limit", opt_mkint,       {&bounce_return_size_limit} },
  92   { "bounce_sender_authentication",opt_stringptr,{&bounce_sender_authentication} },
  93   { "callout_domain_negative_expire", opt_time,  {&callout_cache_domain_negative_expire} },
  94   { "callout_domain_positive_expire", opt_time,  {&callout_cache_domain_positive_expire} },
  95   { "callout_negative_expire",  opt_time,        {&callout_cache_negative_expire} },
  96   { "callout_positive_expire",  opt_time,        {&callout_cache_positive_expire} },
  97   { "callout_random_local_part",opt_stringptr,   {&callout_random_local_part} },
  98   { "check_log_inodes",         opt_int,         {&check_log_inodes} },
  99   { "check_log_space",          opt_Kint,        {&check_log_space} },
 100   { "check_rfc2047_length",     opt_bool,        {&check_rfc2047_length} },
 101   { "check_spool_inodes",       opt_int,         {&check_spool_inodes} },
 102   { "check_spool_space",        opt_Kint,        {&check_spool_space} },
 103   { "chunking_advertise_hosts", opt_stringptr,   {&chunking_advertise_hosts} },
 104   { "commandline_checks_require_admin", opt_bool,{&commandline_checks_require_admin} },
 105   { "daemon_smtp_port",         opt_stringptr|opt_hidden, {&daemon_smtp_port} },
 106   { "daemon_smtp_ports",        opt_stringptr,   {&daemon_smtp_port} },
 107   { "daemon_startup_retries",   opt_int,         {&daemon_startup_retries} },
 108   { "daemon_startup_sleep",     opt_time,        {&daemon_startup_sleep} },
 109 #ifdef EXPERIMENTAL_DCC
 110   { "dcc_direct_add_header",    opt_bool,        {&dcc_direct_add_header} },
 111   { "dccifd_address",           opt_stringptr,   {&dccifd_address} },
 112   { "dccifd_options",           opt_stringptr,   {&dccifd_options} },
 113 #endif
 114   { "debug_store",              opt_bool,        {&debug_store} },
 115   { "delay_warning",            opt_timelist,    {&delay_warning} },
 116   { "delay_warning_condition",  opt_stringptr,   {&delay_warning_condition} },
 117   { "deliver_drop_privilege",   opt_bool,        {&deliver_drop_privilege} },
 118   { "deliver_queue_load_max",   opt_fixed,       {&deliver_queue_load_max} },
 119   { "delivery_date_remove",     opt_bool,        {&delivery_date_remove} },
 120 #ifdef ENABLE_DISABLE_FSYNC
 121   { "disable_fsync",            opt_bool,        {&disable_fsync} },
 122 #endif
 123   { "disable_ipv6",             opt_bool,        {&disable_ipv6} },
 124 #ifndef DISABLE_DKIM
 125   { "dkim_verify_hashes",       opt_stringptr,   {&dkim_verify_hashes} },
 126   { "dkim_verify_keytypes",     opt_stringptr,   {&dkim_verify_keytypes} },
 127   { "dkim_verify_min_keysizes", opt_stringptr,   {&dkim_verify_min_keysizes} },
 128   { "dkim_verify_minimal",      opt_bool,        {&dkim_verify_minimal} },
 129   { "dkim_verify_signers",      opt_stringptr,   {&dkim_verify_signers} },
 130 #endif
 131 #ifdef SUPPORT_DMARC
 132   { "dmarc_forensic_sender",    opt_stringptr,   {&dmarc_forensic_sender} },
 133   { "dmarc_history_file",       opt_stringptr,   {&dmarc_history_file} },
 134   { "dmarc_tld_file",           opt_stringptr,   {&dmarc_tld_file} },
 135 #endif
 136   { "dns_again_means_nonexist", opt_stringptr,   {&dns_again_means_nonexist} },
 137   { "dns_check_names_pattern",  opt_stringptr,   {&check_dns_names_pattern} },
 138   { "dns_cname_loops",          opt_int,         {&dns_cname_loops} },
 139   { "dns_csa_search_limit",     opt_int,         {&dns_csa_search_limit} },
 140   { "dns_csa_use_reverse",      opt_bool,        {&dns_csa_use_reverse} },
 141   { "dns_dnssec_ok",            opt_int,         {&dns_dnssec_ok} },
 142   { "dns_ipv4_lookup",          opt_stringptr,   {&dns_ipv4_lookup} },
 143   { "dns_retrans",              opt_time,        {&dns_retrans} },
 144   { "dns_retry",                opt_int,         {&dns_retry} },
 145   { "dns_trust_aa",             opt_stringptr,   {&dns_trust_aa} },
 146   { "dns_use_edns0",            opt_int,         {&dns_use_edns0} },
 147  /* This option is now a no-op, retained for compatibility */
 148   { "drop_cr",                  opt_bool,        {&drop_cr} },
 149 /*********************************************************/
 150   { "dsn_advertise_hosts",      opt_stringptr,   {&dsn_advertise_hosts} },
 151   { "dsn_from",                 opt_stringptr,   {&dsn_from} },
 152   { "envelope_to_remove",       opt_bool,        {&envelope_to_remove} },
 153   { "errors_copy",              opt_stringptr,   {&errors_copy} },
 154   { "errors_reply_to",          opt_stringptr,   {&errors_reply_to} },
 155 #ifndef DISABLE_EVENT
 156   { "event_action",             opt_stringptr,   {&event_action} },
 157 #endif
 158   { "exim_group",               opt_gid,         {&exim_gid} },
 159   { "exim_path",                opt_stringptr,   {&exim_path} },
 160   { "exim_user",                opt_uid,         {&exim_uid} },
 161   { "exim_version",             opt_stringptr,   {&version_string} },
 162   { "extra_local_interfaces",   opt_stringptr,   {&extra_local_interfaces} },
 163   { "extract_addresses_remove_arguments", opt_bool, {&extract_addresses_remove_arguments} },
 164   { "finduser_retries",         opt_int,         {&finduser_retries} },
 165   { "freeze_tell",              opt_stringptr,   {&freeze_tell} },
 166   { "gecos_name",               opt_stringptr,   {&gecos_name} },
 167   { "gecos_pattern",            opt_stringptr,   {&gecos_pattern} },
 168 #ifndef DISABLE_TLS
 169   { "gnutls_allow_auto_pkcs11", opt_bool,        {&gnutls_allow_auto_pkcs11} },
 170   { "gnutls_compat_mode",       opt_bool,        {&gnutls_compat_mode} },
 171 #endif
 172   { "header_line_maxsize",      opt_int,         {&header_line_maxsize} },
 173   { "header_maxsize",           opt_int,         {&header_maxsize} },
 174   { "headers_charset",          opt_stringptr,   {&headers_charset} },
 175   { "helo_accept_junk_hosts",   opt_stringptr,   {&helo_accept_junk_hosts} },
 176   { "helo_allow_chars",         opt_stringptr,   {&helo_allow_chars} },
 177   { "helo_lookup_domains",      opt_stringptr,   {&helo_lookup_domains} },
 178   { "helo_try_verify_hosts",    opt_stringptr,   {&helo_try_verify_hosts} },
 179   { "helo_verify_hosts",        opt_stringptr,   {&helo_verify_hosts} },
 180   { "hold_domains",             opt_stringptr,   {&hold_domains} },
 181   { "host_lookup",              opt_stringptr,   {&host_lookup} },
 182   { "host_lookup_order",        opt_stringptr,   {&host_lookup_order} },
 183   { "host_reject_connection",   opt_stringptr,   {&host_reject_connection} },
 184   { "hosts_connection_nolog",   opt_stringptr,   {&hosts_connection_nolog} },
 185 #ifdef SUPPORT_PROXY
 186   { "hosts_proxy",              opt_stringptr,   {&hosts_proxy} },
 187 #endif
 188 #ifndef DISABLE_TLS
 189   { "hosts_require_alpn",       opt_stringptr,   {&hosts_require_alpn} },
 190 #endif
 191   { "hosts_require_helo",       opt_stringptr,   {&hosts_require_helo} },
 192   { "hosts_treat_as_local",     opt_stringptr,   {&hosts_treat_as_local} },
 193 #ifdef EXPERIMENTAL_XCLIENT
 194   { "hosts_xclient",            opt_stringptr,   {&hosts_xclient} },
 195 #endif
 196 #ifdef LOOKUP_IBASE
 197   { "ibase_servers",            opt_stringptr,   {&ibase_servers} },
 198 #endif
 199   { "ignore_bounce_errors_after", opt_time,      {&ignore_bounce_errors_after} },
 200   { "ignore_fromline_hosts",    opt_stringptr,   {&ignore_fromline_hosts} },
 201   { "ignore_fromline_local",    opt_bool,        {&ignore_fromline_local} },
 202   { "keep_environment",         opt_stringptr,   {&keep_environment} },
 203   { "keep_malformed",           opt_time,        {&keep_malformed} },
 204 #ifdef LOOKUP_LDAP
 205   { "ldap_ca_cert_dir",         opt_stringptr,   {&eldap_ca_cert_dir} },
 206   { "ldap_ca_cert_file",        opt_stringptr,   {&eldap_ca_cert_file} },
 207   { "ldap_cert_file",           opt_stringptr,   {&eldap_cert_file} },
 208   { "ldap_cert_key",            opt_stringptr,   {&eldap_cert_key} },
 209   { "ldap_cipher_suite",        opt_stringptr,   {&eldap_cipher_suite} },
 210   { "ldap_default_servers",     opt_stringptr,   {&eldap_default_servers} },
 211   { "ldap_require_cert",        opt_stringptr,   {&eldap_require_cert} },
 212   { "ldap_start_tls",           opt_bool,        {&eldap_start_tls} },
 213   { "ldap_version",             opt_int,         {&eldap_version} },
 214 #endif
 215 #ifndef DISABLE_ESMTP_LIMITS
 216   { "limits_advertise_hosts", opt_stringptr, {&limits_advertise_hosts} },
 217 #endif
 218   { "local_from_check",         opt_bool,        {&local_from_check} },
 219   { "local_from_prefix",        opt_stringptr,   {&local_from_prefix} },
 220   { "local_from_suffix",        opt_stringptr,   {&local_from_suffix} },
 221   { "local_interfaces",         opt_stringptr,   {&local_interfaces} },
 222 #ifdef HAVE_LOCAL_SCAN
 223   { "local_scan_timeout",       opt_time,        {&local_scan_timeout} },
 224 #endif
 225   { "local_sender_retain",      opt_bool,        {&local_sender_retain} },
 226   { "localhost_number",         opt_stringptr,   {&host_number_string} },
 227   { "log_file_path",            opt_stringptr,   {&log_file_path} },
 228   { "log_selector",             opt_stringptr,   {&log_selector_string} },
 229   { "log_timezone",             opt_bool,        {&log_timezone} },
 230   { "lookup_open_max",          opt_int,         {&lookup_open_max} },
 231   { "max_username_length",      opt_int,         {&max_username_length} },
 232   { "message_body_newlines",    opt_bool,        {&message_body_newlines} },
 233   { "message_body_visible",     opt_mkint,       {&message_body_visible} },
 234   { "message_id_header_domain", opt_stringptr,   {&message_id_domain} },
 235   { "message_id_header_text",   opt_stringptr,   {&message_id_text} },
 236   { "message_logs",             opt_bool,        {&message_logs} },
 237   { "message_size_limit",       opt_stringptr,   {&message_size_limit} },
 238 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
 239   { "move_frozen_messages",     opt_bool,        {&move_frozen_messages} },
 240 #endif
 241   { "mua_wrapper",              opt_bool,        {&mua_wrapper} },
 242 #ifdef LOOKUP_MYSQL
 243   { "mysql_servers",            opt_stringptr,   {&mysql_servers} },
 244 #endif
 245   { "never_users",              opt_uidlist,     {&never_users} },
 246   { "notifier_socket",          opt_stringptr,   {&notifier_socket} },
 247 #ifndef DISABLE_TLS
 248   { "openssl_options",          opt_stringptr,   {&openssl_options} },
 249 #endif
 250 #ifdef LOOKUP_ORACLE
 251   { "oracle_servers",           opt_stringptr,   {&oracle_servers} },
 252 #endif
 253   { "panic_coredump",           opt_bool,        {&panic_coredump} },
 254   { "percent_hack_domains",     opt_stringptr,   {&percent_hack_domains} },
 255 #ifdef EXIM_PERL
 256   { "perl_at_start",            opt_bool,        {&opt_perl_at_start} },
 257   { "perl_startup",             opt_stringptr,   {&opt_perl_startup} },
 258   { "perl_taintmode",           opt_bool,        {&opt_perl_taintmode} },
 259 #endif
 260 #ifdef LOOKUP_PGSQL
 261   { "pgsql_servers",            opt_stringptr,   {&pgsql_servers} },
 262 #endif
 263   { "pid_file_path",            opt_stringptr,   {&pid_file_path} },
 264   { "pipelining_advertise_hosts", opt_stringptr, {&pipelining_advertise_hosts} },
 265 #ifndef DISABLE_PIPE_CONNECT
 266   { "pipelining_connect_advertise_hosts", opt_stringptr,
 267                                                  {&pipe_connect_advertise_hosts} },
 268 #endif
 269 #ifndef DISABLE_PRDR
 270   { "prdr_enable",              opt_bool,        {&prdr_enable} },
 271 #endif
 272   { "preserve_message_logs",    opt_bool,        {&preserve_message_logs} },
 273   { "primary_hostname",         opt_stringptr,   {&primary_hostname} },
 274   { "print_topbitchars",        opt_bool,        {&print_topbitchars} },
 275   { "process_log_path",         opt_stringptr,   {&process_log_path} },
 276   { "prod_requires_admin",      opt_bool,        {&prod_requires_admin} },
 277 #ifdef SUPPORT_PROXY
 278   { "proxy_protocol_timeout",   opt_time,        {&proxy_protocol_timeout} },
 279 #endif
 280   { "qualify_domain",           opt_stringptr,   {&qualify_domain_sender} },
 281   { "qualify_recipient",        opt_stringptr,   {&qualify_domain_recipient} },
 282   { "queue_domains",            opt_stringptr,   {&queue_domains} },
 283 #ifndef DISABLE_QUEUE_RAMP
 284   { "queue_fast_ramp",          opt_bool,        {&queue_fast_ramp} },
 285 #endif
 286   { "queue_list_requires_admin",opt_bool,        {&queue_list_requires_admin} },
 287   { "queue_only",               opt_bool,        {&queue_only} },
 288   { "queue_only_file",          opt_stringptr,   {&queue_only_file} },
 289   { "queue_only_load",          opt_fixed,       {&queue_only_load} },
 290   { "queue_only_load_latch",    opt_bool,        {&queue_only_load_latch} },
 291   { "queue_only_override",      opt_bool,        {&queue_only_override} },
 292   { "queue_run_in_order",       opt_bool,        {&queue_run_in_order} },
 293   { "queue_run_max",            opt_stringptr,   {&queue_run_max} },
 294   { "queue_smtp_domains",       opt_stringptr,   {&queue_smtp_domains} },
 295   { "receive_timeout",          opt_time,        {&receive_timeout} },
 296   { "received_header_text",     opt_stringptr,   {&received_header_text} },
 297   { "received_headers_max",     opt_int,         {&received_headers_max} },
 298   { "recipient_unqualified_hosts", opt_stringptr, {&recipient_unqualified_hosts} },
 299   { "recipients_max",           opt_stringptr,   {&recipients_max} },
 300   { "recipients_max_reject",    opt_bool,        {&recipients_max_reject} },
 301 #ifdef LOOKUP_REDIS
 302   { "redis_servers",            opt_stringptr,   {&redis_servers} },
 303 #endif
 304   { "remote_max_parallel",      opt_int,         {&remote_max_parallel} },
 305   { "remote_sort_domains",      opt_stringptr,   {&remote_sort_domains} },
 306   { "retry_data_expire",        opt_time,        {&retry_data_expire} },
 307   { "retry_interval_max",       opt_time,        {&retry_interval_max} },
 308   { "return_path_remove",       opt_bool,        {&return_path_remove} },
 309   { "return_size_limit",        opt_mkint|opt_hidden, {&bounce_return_size_limit} },
 310   { "rfc1413_hosts",            opt_stringptr,   {&rfc1413_hosts} },
 311   { "rfc1413_query_timeout",    opt_time,        {&rfc1413_query_timeout} },
 312   { "sender_unqualified_hosts", opt_stringptr,   {&sender_unqualified_hosts} },
 313   { "slow_lookup_log",          opt_int,         {&slow_lookup_log} },
 314   { "smtp_accept_keepalive",    opt_bool,        {&smtp_accept_keepalive} },
 315   { "smtp_accept_max",          opt_int,         {&smtp_accept_max} },
 316   { "smtp_accept_max_nonmail",  opt_int,         {&smtp_accept_max_nonmail} },
 317   { "smtp_accept_max_nonmail_hosts", opt_stringptr, {&smtp_accept_max_nonmail_hosts} },
 318   { "smtp_accept_max_per_connection", opt_stringptr,   {&smtp_accept_max_per_connection} },
 319   { "smtp_accept_max_per_host", opt_stringptr,   {&smtp_accept_max_per_host} },
 320   { "smtp_accept_queue",        opt_int,         {&smtp_accept_queue} },
 321   { "smtp_accept_queue_per_connection", opt_int, {&smtp_accept_queue_per_connection} },
 322   { "smtp_accept_reserve",      opt_int,         {&smtp_accept_reserve} },
 323   { "smtp_active_hostname",     opt_stringptr,   {&raw_active_hostname} },
 324   { "smtp_backlog_monitor",     opt_int,         {&smtp_backlog_monitor} },
 325   { "smtp_banner",              opt_stringptr,   {&smtp_banner} },
 326   { "smtp_check_spool_space",   opt_bool,        {&smtp_check_spool_space} },
 327   { "smtp_connect_backlog",     opt_int,         {&smtp_connect_backlog} },
 328   { "smtp_enforce_sync",        opt_bool,        {&smtp_enforce_sync} },
 329   { "smtp_etrn_command",        opt_stringptr,   {&smtp_etrn_command} },
 330   { "smtp_etrn_serialize",      opt_bool,        {&smtp_etrn_serialize} },
 331   { "smtp_load_reserve",        opt_fixed,       {&smtp_load_reserve} },
 332   { "smtp_max_synprot_errors",  opt_int,         {&smtp_max_synprot_errors} },
 333   { "smtp_max_unknown_commands",opt_int,         {&smtp_max_unknown_commands} },
 334   { "smtp_ratelimit_hosts",     opt_stringptr,   {&smtp_ratelimit_hosts} },
 335   { "smtp_ratelimit_mail",      opt_stringptr,   {&smtp_ratelimit_mail} },
 336   { "smtp_ratelimit_rcpt",      opt_stringptr,   {&smtp_ratelimit_rcpt} },
 337   { "smtp_receive_timeout",     opt_func,        {.fn = &fn_smtp_receive_timeout} },
 338   { "smtp_reserve_hosts",       opt_stringptr,   {&smtp_reserve_hosts} },
 339   { "smtp_return_error_details",opt_bool,        {&smtp_return_error_details} },
 340 #ifdef SUPPORT_I18N
 341   { "smtputf8_advertise_hosts", opt_stringptr,   {&smtputf8_advertise_hosts} },
 342 #endif
 343 #ifdef WITH_CONTENT_SCAN
 344   { "spamd_address",            opt_stringptr,   {&spamd_address} },
 345 #endif
 346 #ifdef SUPPORT_SPF
 347   { "spf_guess",                opt_stringptr,   {&spf_guess} },
 348   { "spf_smtp_comment_template",opt_stringptr,   {&spf_smtp_comment_template} },
 349 #endif
 350   { "split_spool_directory",    opt_bool,        {&split_spool_directory} },
 351   { "spool_directory",          opt_stringptr,   {&spool_directory} },
 352   { "spool_wireformat",         opt_bool,        {&spool_wireformat} },
 353 #ifdef LOOKUP_SQLITE
 354   { "sqlite_dbfile",            opt_stringptr,   {&sqlite_dbfile} },
 355   { "sqlite_lock_timeout",      opt_int,         {&sqlite_lock_timeout} },
 356 #endif
 357   { "strict_acl_vars",          opt_bool,        {&strict_acl_vars} },
 358   { "strip_excess_angle_brackets", opt_bool,     {&strip_excess_angle_brackets} },
 359   { "strip_trailing_dot",       opt_bool,        {&strip_trailing_dot} },
 360   { "syslog_duplication",       opt_bool,        {&syslog_duplication} },
 361   { "syslog_facility",          opt_stringptr,   {&syslog_facility_str} },
 362   { "syslog_pid",               opt_bool,        {&syslog_pid} },
 363   { "syslog_processname",       opt_stringptr,   {&syslog_processname} },
 364   { "syslog_timestamp",         opt_bool,        {&syslog_timestamp} },
 365   { "system_filter",            opt_stringptr,   {&system_filter} },
 366   { "system_filter_directory_transport", opt_stringptr,{&system_filter_directory_transport} },
 367   { "system_filter_file_transport",opt_stringptr,{&system_filter_file_transport} },
 368   { "system_filter_group",      opt_gid,         {&system_filter_gid} },
 369   { "system_filter_pipe_transport",opt_stringptr,{&system_filter_pipe_transport} },
 370   { "system_filter_reply_transport",opt_stringptr,{&system_filter_reply_transport} },
 371   { "system_filter_user",       opt_uid,         {&system_filter_uid} },
 372   { "tcp_nodelay",              opt_bool,        {&tcp_nodelay} },
 373 #ifdef USE_TCP_WRAPPERS
 374   { "tcp_wrappers_daemon_name", opt_stringptr,   {&tcp_wrappers_daemon_name} },
 375 #endif
 376   { "timeout_frozen_after",     opt_time,        {&timeout_frozen_after} },
 377   { "timezone",                 opt_stringptr,   {&timezone_string} },
 378   { "tls_advertise_hosts",      opt_stringptr,   {&tls_advertise_hosts} },
 379 #ifndef DISABLE_TLS
 380   { "tls_alpn",                 opt_stringptr,   {&tls_alpn} },
 381   { "tls_certificate",          opt_stringptr,   {&tls_certificate} },
 382   { "tls_crl",                  opt_stringptr,   {&tls_crl} },
 383   { "tls_dh_max_bits",          opt_int,         {&tls_dh_max_bits} },
 384   { "tls_dhparam",              opt_stringptr,   {&tls_dhparam} },
 385   { "tls_eccurve",              opt_stringptr,   {&tls_eccurve} },
 386 # ifndef DISABLE_OCSP
 387   { "tls_ocsp_file",            opt_stringptr,   {&tls_ocsp_file} },
 388 # endif
 389   { "tls_on_connect_ports",     opt_stringptr,   {&tls_in.on_connect_ports} },
 390   { "tls_privatekey",           opt_stringptr,   {&tls_privatekey} },
 391   { "tls_remember_esmtp",       opt_bool,        {&tls_remember_esmtp} },
 392   { "tls_require_ciphers",      opt_stringptr,   {&tls_require_ciphers} },
 393 # ifndef DISABLE_TLS_RESUME
 394   { "tls_resumption_hosts",     opt_stringptr,   {&tls_resumption_hosts} },
 395 # endif
 396   { "tls_try_verify_hosts",     opt_stringptr,   {&tls_try_verify_hosts} },
 397   { "tls_verify_certificates",  opt_stringptr,   {&tls_verify_certificates} },
 398   { "tls_verify_hosts",         opt_stringptr,   {&tls_verify_hosts} },
 399 #endif
 400   { "trusted_groups",           opt_gidlist,     {&trusted_groups} },
 401   { "trusted_users",            opt_uidlist,     {&trusted_users} },
 402   { "unknown_login",            opt_stringptr,   {&unknown_login} },
 403   { "unknown_username",         opt_stringptr,   {&unknown_username} },
 404   { "untrusted_set_sender",     opt_stringptr,   {&untrusted_set_sender} },
 405   { "uucp_from_pattern",        opt_stringptr,   {&uucp_from_pattern} },
 406   { "uucp_from_sender",         opt_stringptr,   {&uucp_from_sender} },
 407   { "warn_message_file",        opt_stringptr,   {&warn_message_file} },
 408 #ifndef DISABLE_WELLKNOWN
 409   { "wellknown_advertise_hosts",opt_stringptr,   {&wellknown_advertise_hosts} },
 410 #endif
 411   { "write_rejectlog",          opt_bool,        {&write_rejectlog} },
 412 };
 413
 414 #ifndef MACRO_PREDEF
 415 static int optionlist_config_size = nelem(optionlist_config);
 416 #endif
 417
 418
 419 #ifdef MACRO_PREDEF
 420
 421 static void
 422 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags) {/*Dummy*/}
 423
 424 void
 425 options_main(void)
 426 {
 427 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
 428 }
 429
 430 void
 431 options_auths(void)
 432 {
 433 uschar buf[EXIM_DRIVERNAME_MAX];
 434
 435 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
 436
 437 for (struct auth_info * ai = auths_available; ai->driver_name[0]; ai++)
 438   {
 439   spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
 440   builtin_macro_create(buf);
 441   options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
 442
 443   if (ai->macros_create) (ai->macros_create)();
 444   }
 445 }
 446
 447 void
 448 options_logging(void)
 449 {
 450 uschar buf[EXIM_DRIVERNAME_MAX];
 451
 452 for (bit_table * bp = log_options; bp < log_options + log_options_count; bp++)
 453   {
 454   spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
 455   builtin_macro_create(buf);
 456   }
 457 }
 458
 459
 460 #else   /*!MACRO_PREDEF*/
 461
 462 extern char **environ;
 463
 464 static void save_config_line(const uschar* line);
 465 static void save_config_position(const uschar *file, int line);
 466 static void print_config(BOOL admin, BOOL terse);
 467
 468
 469 #define CSTATE_STACK_SIZE 10
 470
 471 const uschar *config_directory = NULL;
 472
 473
 474 /* Structure for chain (stack) of .included files */
 475
 476 typedef struct config_file_item {
 477   struct config_file_item *next;
 478   const uschar *filename;
 479   const uschar *directory;
 480   FILE *file;
 481   int lineno;
 482 } config_file_item;
 483
 484 /* Structure for chain of configuration lines (-bP config) */
 485
 486 typedef struct config_line_item {
 487   struct config_line_item *next;
 488   uschar *line;
 489 } config_line_item;
 490
 491 static config_line_item* config_lines;
 492
 493 /* Structure of table of conditional words and their state transitions */
 494
 495 typedef struct cond_item {
 496   uschar *name;
 497   int    namelen;
 498   int    action1;
 499   int    action2;
 500   int    pushpop;
 501 } cond_item;
 502
 503 /* Structure of table of syslog facility names and values */
 504
 505 typedef struct syslog_fac_item {
 506   uschar *name;
 507   int    value;
 508 } syslog_fac_item;
 509
 510 /* constants */
 511 static const uschar * const hidden = US"<value not displayable>";
 512
 513 /* Static variables */
 514
 515 static config_file_item *config_file_stack = NULL;  /* For includes */
 516
 517 static uschar *syslog_facility_str  = NULL;
 518 static uschar next_section[24];
 519 static uschar time_buffer[24];
 520
 521 /* State variables for conditional loading (.ifdef / .else / .endif) */
 522
 523 static int cstate = 0;
 524 static int cstate_stack_ptr = -1;
 525 static int cstate_stack[CSTATE_STACK_SIZE];
 526
 527 /* Table of state transitions for handling conditional inclusions. There are
 528 four possible state transitions:
 529
 530   .ifdef true
 531   .ifdef false
 532   .elifdef true  (or .else)
 533   .elifdef false
 534
 535 .endif just causes the previous cstate to be popped off the stack */
 536
 537 static int next_cstate[3][4] =
 538   {
 539   /* State 0: reading from file, or reading until next .else or .endif */
 540   { 0, 1, 2, 2 },
 541   /* State 1: condition failed, skipping until next .else or .endif */
 542   { 2, 2, 0, 1 },
 543   /* State 2: skipping until .endif */
 544   { 2, 2, 2, 2 },
 545   };
 546
 547 /* Table of conditionals and the states to set. For each name, there are four
 548 values: the length of the name (to save computing it each time), the state to
 549 set if a macro was found in the line, the state to set if a macro was not found
 550 in the line, and a stack manipulation setting which is:
 551
 552   -1   pull state value off the stack
 553    0   don't alter the stack
 554   +1   push value onto stack, before setting new state
 555 */
 556
 557 static cond_item cond_list[] = {
 558   { US"ifdef",    5, 0, 1,  1 },
 559   { US"ifndef",   6, 1, 0,  1 },
 560   { US"elifdef",  7, 2, 3,  0 },
 561   { US"elifndef", 8, 3, 2,  0 },
 562   { US"else",     4, 2, 2,  0 },
 563   { US"endif",    5, 0, 0, -1 }
 564 };
 565
 566 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
 567
 568 /* Table of syslog facility names and their values */
 569
 570 static syslog_fac_item syslog_list[] = {
 571   { US"mail",   LOG_MAIL },
 572   { US"user",   LOG_USER },
 573   { US"news",   LOG_NEWS },
 574   { US"uucp",   LOG_UUCP },
 575   { US"local0", LOG_LOCAL0 },
 576   { US"local1", LOG_LOCAL1 },
 577   { US"local2", LOG_LOCAL2 },
 578   { US"local3", LOG_LOCAL3 },
 579   { US"local4", LOG_LOCAL4 },
 580   { US"local5", LOG_LOCAL5 },
 581   { US"local6", LOG_LOCAL6 },
 582   { US"local7", LOG_LOCAL7 },
 583   { US"daemon", LOG_DAEMON }
 584 };
 585
 586 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 587
 588
 589 #define opt_fn_print            BIT(0)
 590 #define opt_fn_print_label      BIT(1)
 591
 592
 593 /*************************************************
 594 *         Find the name of an option             *
 595 *************************************************/
 596
 597 /* This function is to aid debugging. Various functions take arguments that are
 598 pointer variables in the options table or in option tables for various drivers.
 599 For debugging output, it is useful to be able to find the name of the option
 600 which is currently being processed. This function finds it, if it exists, by
 601 searching the table(s) for a value with the given content.
 602
 603 Arguments:   a value that is presumed to be in the table above
 604 Returns:     the option name, or an empty string
 605 */
 606
 607 const uschar *
 608 readconf_find_option(void * listptr)
 609 {
 610 uschar * list = * USS listptr;
 611 const uschar * name = NULL, * drname = NULL;
 612
 613 for (optionlist * o = optionlist_config;               /* main-config options */
 614      o < optionlist_config + optionlist_config_size; o++)
 615   if (listptr == o->v.value)
 616     return US o->name;
 617
 618 for (router_instance * r = routers; r; r = r->next)
 619   if (router_name && Ustrcmp(r->name, router_name) == 0)
 620   {
 621   const router_info * ri = r->info;
 622
 623   /* Check for a listptr match first */
 624
 625   for (optionlist * o = optionlist_routers;             /* generic options */
 626       o < optionlist_routers + optionlist_routers_size; o++)
 627     if (  (o->type & opt_mask) == opt_stringptr
 628        && listptr == CS r + o->v.offset)
 629       return US o->name;
 630
 631   for (optionlist * o = ri->options;                    /* private options */
 632       o < ri->options + *ri->options_count; o++)
 633     if (  (o->type & opt_mask) == opt_stringptr
 634        && listptr == CS (r->options_block) + o->v.offset)
 635       return US o->name;
 636
 637   /* Check for a list addr match, unless null */
 638
 639   if (!list) continue;
 640
 641   for (optionlist * o = optionlist_routers;             /* generic options */
 642       o < optionlist_routers + optionlist_routers_size; o++)
 643     if (  (o->type & opt_mask) == opt_stringptr
 644        && list == * USS(CS r + o->v.offset))
 645       if (name) return string_sprintf("DUP: %s %s vs. %s %s",
 646         drname, name, r->name, o->name);
 647       else { name = US o->name; drname = r->name; }
 648
 649   for (optionlist * o = ri->options;                    /* private options */
 650       o < ri->options + *ri->options_count; o++)
 651     if (  (o->type & opt_mask) == opt_stringptr
 652        && list == * USS(CS (r->options_block) + o->v.offset))
 653       if (name) return string_sprintf("DUP: %s %s vs. %s %s",
 654         drname, name, r->name, o->name);
 655       else { name = US o->name; drname = r->name; }
 656   }
 657
 658 for (transport_instance * t = transports; t; t = t->next)
 659   if (transport_name && Ustrcmp(t->name, transport_name) == 0)
 660   {
 661   const transport_info * ti = t->info;
 662
 663   /* Check for a listptr match first */
 664
 665   for (optionlist * o = optionlist_transports;          /* generic options */
 666       o < optionlist_transports + optionlist_transports_size; o++)
 667     if (  (o->type & opt_mask) == opt_stringptr
 668        && listptr == CS t + o->v.offset)
 669       return US o->name;
 670
 671   for (optionlist * o = ti->options;                    /* private options */
 672       o < ti->options + *ti->options_count; o++)
 673     if (  (o->type & opt_mask) == opt_stringptr
 674        && listptr == CS t->options_block + o->v.offset)
 675       return US o->name;
 676
 677   /* Check for a list addr match, unless null */
 678
 679   if (!list) continue;
 680
 681   for (optionlist * o = optionlist_transports;          /* generic options */
 682       o < optionlist_transports + optionlist_transports_size; o++)
 683     if (  (o->type & opt_mask) == opt_stringptr
 684        && list == * USS(CS t + o->v.offset))
 685       if (name) return string_sprintf("DUP: %s %s vs. %s %s",
 686         drname, name, t->name, o->name);
 687       else { name = US o->name; drname = t->name; }
 688
 689   for (optionlist * o = ti->options;                    /* private options */
 690       o < ti->options + *ti->options_count; o++)
 691     if (  (o->type & opt_mask) == opt_stringptr
 692        && list == * USS(CS t->options_block + o->v.offset))
 693       if (name) return string_sprintf("DUP: %s %s vs. %s %s",
 694         drname, name, t->name, o->name);
 695       else { name = US o->name; drname = t->name; }
 696   }
 697
 698 return name ? name : US"";
 699 }
 700
 701
 702
 703
 704 /*************************************************
 705 *       Deal with an assignment to a macro       *
 706 *************************************************/
 707
 708 /* We have a new definition; append to the list.
 709
 710 Args:
 711  name   Name of the macro; will be copied
 712  val    Expansion result for the macro; will be copied
 713 */
 714
 715 macro_item *
 716 macro_create(const uschar * name, const uschar * val, BOOL command_line)
 717 {
 718 macro_item * m = store_get(sizeof(macro_item), GET_UNTAINTED);
 719
 720 READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
 721 m->next = NULL;
 722 m->command_line = command_line;
 723 m->namelen = Ustrlen(name);
 724 m->replen = Ustrlen(val);
 725 m->name = string_copy(name);
 726 m->replacement = string_copy(val);
 727 if (mlast)
 728   mlast->next = m;
 729 else
 730   macros = m;
 731 mlast = m;
 732 if (!macros_user)
 733   macros_user = m;
 734 return m;
 735 }
 736
 737
 738 /* This function is called when a line that starts with an upper case letter is
 739 encountered. The argument "line" should contain a complete logical line, and
 740 start with the first letter of the macro name. The macro name and the
 741 replacement text are extracted and stored. Redefinition of existing,
 742 non-command line, macros is permitted using '==' instead of '='.
 743
 744 Arguments:
 745   s            points to the start of the logical line
 746
 747 Returns:       FALSE iff fatal error
 748 */
 749
 750 BOOL
 751 macro_read_assignment(uschar *s)
 752 {
 753 uschar name[EXIM_DRIVERNAME_MAX];
 754 int namelen = 0;
 755 BOOL redef = FALSE;
 756 macro_item *m;
 757
 758 while (isalnum(*s) || *s == '_')
 759   {
 760   if (namelen >= sizeof(name) - 1)
 761     {
 762     log_write(0, LOG_PANIC|LOG_CONFIG_IN,
 763       "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
 764     return FALSE;
 765     }
 766   name[namelen++] = *s++;
 767   }
 768 name[namelen] = 0;
 769
 770 Uskip_whitespace(&s);
 771 if (*s++ != '=')
 772   {
 773   log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
 774   return FALSE;
 775   }
 776
 777 if (*s == '=')
 778   {
 779   redef = TRUE;
 780   s++;
 781   }
 782 Uskip_whitespace(&s);
 783
 784 /* If an existing macro of the same name was defined on the command line, we
 785 just skip this definition. It's an error to attempt to redefine a macro without
 786 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
 787 It is also an error to define a macro whose name begins with the name of a
 788 previously defined macro.  This is the requirement that make using a tree
 789 for macros hard; we must check all macros for the substring.  Perhaps a
 790 sorted list, and a bsearch, would work?
 791 Note: it is documented that the other way round works. */
 792
 793 for (m = macros; m; m = m->next)
 794   {
 795   if (Ustrcmp(m->name, name) == 0)
 796     {
 797     if (!m->command_line && !redef)
 798       {
 799       log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
 800        "defined (use \"==\" if you want to redefine it)", name);
 801       return FALSE;
 802       }
 803     break;
 804     }
 805
 806   if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
 807     {
 808     log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
 809       "a macro because previously defined macro \"%s\" is a substring",
 810       name, m->name);
 811     return FALSE;
 812     }
 813
 814   /* We cannot have this test, because it is documented that a substring
 815   macro is permitted (there is even an example).
 816   *
 817   * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
 818   *   log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
 819   *     "a macro because it is a substring of previously defined macro \"%s\"",
 820   *     name, m->name);
 821   */
 822   }
 823
 824 /* Check for an overriding command-line definition. */
 825
 826 if (m && m->command_line) return TRUE;
 827
 828 /* Redefinition must refer to an existing macro. */
 829
 830 if (redef)
 831   if (m)
 832     {
 833     m->replen = Ustrlen(s);
 834     m->replacement = string_copy(s);
 835     }
 836   else
 837     {
 838     log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
 839       "\"%s\"", name);
 840     return FALSE;
 841     }
 842
 843 /* We have a new definition. */
 844 else
 845   (void) macro_create(name, s, FALSE);
 846 return TRUE;
 847 }
 848
 849
 850
 851
 852
 853 /* Process line for macros. The line is in big_buffer starting at offset len.
 854 Expand big_buffer if needed.  Handle definitions of new macros, and
 855 macro expansions, rewriting the line in the buffer.
 856
 857 Arguments:
 858  len            Offset in buffer of start of line
 859  newlen         Pointer to offset of end of line, updated on return
 860  macro_found    Pointer to return that a macro was expanded
 861
 862 Return: pointer to first nonblank char in line
 863 */
 864
 865 uschar *
 866 macros_expand(int len, int * newlen, BOOL * macro_found)
 867 {
 868 uschar * ss = big_buffer + len;
 869 uschar * s;
 870
 871 /* Find the true start of the physical line - leading spaces are always
 872 ignored. */
 873
 874 Uskip_whitespace(&ss);
 875
 876 /* Process the physical line for macros. If this is the start of the logical
 877 line, skip over initial text at the start of the line if it starts with an
 878 upper case character followed by a sequence of name characters and an equals
 879 sign, because that is the definition of a new macro, and we don't do
 880 replacement therein. */
 881
 882 s = ss;
 883 if (len == 0 && isupper(*s))
 884   {
 885   while (isalnum(*s) || *s == '_') s++;
 886   if (Uskip_whitespace(&s) != '=') s = ss;          /* Not a macro definition */
 887   }
 888
 889 /* Skip leading chars which cannot start a macro name, to avoid multiple
 890 pointless rescans in Ustrstr calls. */
 891
 892 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
 893
 894 /* For each defined macro, scan the line (from after XXX= if present),
 895 replacing all occurrences of the macro. */
 896
 897 *macro_found = FALSE;
 898 if (*s) for (macro_item * m = *s == '_' ? macros : macros_user; m; m = m->next)
 899   {
 900   uschar * p, *pp;
 901   uschar * t;
 902
 903   while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
 904   if (!*s) break;
 905
 906   t = s;
 907   while ((p = Ustrstr(t, m->name)) != NULL)
 908     {
 909     int moveby;
 910
 911     READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
 912       m->name, (int) Ustrlen(ss)-1, ss);
 913     /* Expand the buffer if necessary */
 914
 915     while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
 916       {
 917       int newsize = big_buffer_size + BIG_BUFFER_SIZE;
 918       uschar *newbuffer = store_malloc(newsize);
 919       memcpy(newbuffer, big_buffer, *newlen + 1);
 920       p = newbuffer  + (p - big_buffer);
 921       s = newbuffer  + (s - big_buffer);
 922       ss = newbuffer + (ss - big_buffer);
 923       t = newbuffer  + (t - big_buffer);
 924       big_buffer_size = newsize;
 925       store_free(big_buffer);
 926       big_buffer = newbuffer;
 927       }
 928
 929     /* Shuffle the remaining characters up or down in the buffer before
 930     copying in the replacement text. Don't rescan the replacement for this
 931     same macro. */
 932
 933     pp = p + m->namelen;
 934     if ((moveby = m->replen - m->namelen) != 0)
 935       {
 936       memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
 937       *newlen += moveby;
 938       }
 939     Ustrncpy(p, m->replacement, m->replen);
 940     t = p + m->replen;
 941     while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
 942     *macro_found = TRUE;
 943     }
 944   }
 945
 946 /* An empty macro replacement at the start of a line could mean that ss no
 947 longer points to the first non-blank character. */
 948
 949 Uskip_whitespace(&ss);
 950 return ss;
 951 }
 952
 953 /*************************************************
 954 *            Read configuration line             *
 955 *************************************************/
 956
 957 /* A logical line of text is read from the configuration file into the big
 958 buffer, taking account of macros, .includes, and continuations. The size of
 959 big_buffer is increased if necessary. The count of configuration lines is
 960 maintained. Physical input lines starting with # (ignoring leading white space,
 961 and after macro replacement) and empty logical lines are always ignored.
 962 Leading and trailing spaces are removed.
 963
 964 If we hit a line of the form "begin xxxx", the xxxx is placed in the
 965 next_section vector, and the function returns NULL, indicating the end of a
 966 configuration section. On end-of-file, NULL is returned with next_section
 967 empty.
 968
 969 Arguments:      none
 970
 971 Returns:        a pointer to the first non-blank in the line,
 972                 or NULL if eof or end of section is reached
 973 */
 974
 975 static uschar *
 976 get_config_line(void)
 977 {
 978 int startoffset = 0;         /* To first non-blank char in logical line */
 979 int len = 0;                 /* Of logical line so far */
 980 int newlen;
 981 uschar *s, *ss;
 982 BOOL macro_found;
 983
 984 /* Loop for handling continuation lines, skipping comments, and dealing with
 985 .include files. */
 986
 987 for (;;)
 988   {
 989   if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
 990     {
 991     if (config_file_stack != NULL)    /* EOF inside .include */
 992       {
 993       (void)fclose(config_file);
 994       config_file = config_file_stack->file;
 995       config_filename = config_file_stack->filename;
 996       config_directory = config_file_stack->directory;
 997       config_lineno = config_file_stack->lineno;
 998       config_file_stack = config_file_stack->next;
 999       if (config_lines)
1000         save_config_position(config_filename, config_lineno);
1001       continue;
1002       }
1003
1004     /* EOF at top level */
1005
1006     if (cstate_stack_ptr >= 0)
1007       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1008         "Unexpected end of configuration file: .endif missing");
1009
1010     if (len != 0) break;        /* EOF after continuation */
1011     next_section[0] = 0;        /* EOF at start of logical line */
1012     return NULL;
1013     }
1014
1015   config_lineno++;
1016   newlen = len + Ustrlen(big_buffer + len);
1017
1018   if (config_lines && config_lineno == 1)
1019     save_config_position(config_filename, config_lineno);
1020
1021   /* Handle pathologically long physical lines - yes, it did happen - by
1022   extending big_buffer at this point. The code also copes with very long
1023   logical lines. */
1024
1025   while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
1026     {
1027     uschar *newbuffer;
1028     big_buffer_size += BIG_BUFFER_SIZE;
1029     newbuffer = store_malloc(big_buffer_size);
1030
1031     /* This use of strcpy is OK because we know that the string in the old
1032     buffer is shorter than the new buffer. */
1033
1034     Ustrcpy(newbuffer, big_buffer);
1035     store_free(big_buffer);
1036     big_buffer = newbuffer;
1037     if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
1038       break;
1039     newlen += Ustrlen(big_buffer + newlen);
1040     }
1041
1042   ss = macros_expand(len, &newlen, &macro_found);
1043
1044   /* Check for comment lines - these are physical lines. */
1045
1046   if (*ss == '#') continue;
1047
1048   /* Handle conditionals, which are also applied to physical lines. Conditions
1049   are of the form ".ifdef ANYTEXT" and are treated as true if any macro
1050   expansion occurred on the rest of the line. A preliminary test for the leading
1051   '.' saves effort on most lines. */
1052
1053   if (*ss == '.')
1054     {
1055     int i;
1056
1057     /* Search the list of conditional directives */
1058
1059     for (i = 0; i < cond_list_size; i++)
1060       {
1061       int n;
1062       cond_item *c = cond_list+i;
1063       if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
1064
1065       /* The following character must be white space or end of string */
1066
1067       n = ss[1 + c->namelen];
1068       if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
1069
1070       /* .ifdef and .ifndef push the current state onto the stack, then set
1071       a new one from the table. Stack overflow is an error */
1072
1073       if (c->pushpop > 0)
1074         {
1075         if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
1076           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1077             ".%s nested too deeply", c->name);
1078         cstate_stack[++cstate_stack_ptr] = cstate;
1079         cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
1080         }
1081
1082       /* For any of the others, stack underflow is an error. The next state
1083       comes either from the stack (.endif) or from the table. */
1084
1085       else
1086         {
1087         if (cstate_stack_ptr < 0)
1088           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1089             ".%s without matching .ifdef", c->name);
1090         cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
1091           next_cstate[cstate][macro_found? c->action1 : c->action2];
1092         }
1093
1094       /* Having dealt with a directive, break the loop */
1095
1096       break;
1097       }
1098
1099     /* If we have handled a conditional directive, continue with the next
1100     physical line. Otherwise, fall through. */
1101
1102     if (i < cond_list_size) continue;
1103     }
1104
1105   /* If the conditional state is not 0 (actively using these lines), ignore
1106   this input line. */
1107
1108   if (cstate != 0) continue;  /* Conditional skip */
1109
1110   /* Handle .include lines - these are also physical lines. */
1111
1112   if (Ustrncmp(ss, ".include", 8) == 0 &&
1113        (isspace(ss[8]) ||
1114          (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
1115     {
1116     uschar *t;
1117     int include_if_exists = isspace(ss[8]) ? 0 : 10;
1118     config_file_item *save;
1119     struct stat statbuf;
1120
1121     ss += 9 + include_if_exists;
1122     Uskip_whitespace(&ss);
1123     t = ss + Ustrlen(ss);
1124     while (t > ss && isspace(t[-1])) t--;
1125     if (*ss == '\"' && t[-1] == '\"')
1126       {
1127       ss++;
1128       t--;
1129       }
1130     *t = 0;
1131
1132     /* We allow relative file names. For security reasons currently
1133     relative names not allowed with .include_if_exists. For .include_if_exists
1134     we need to check the permissions/ownership of the containing folder */
1135     if (*ss != '/')
1136       if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
1137           "absolute path \"%s\"", ss);
1138       else
1139         {
1140         gstring * g = string_append(NULL, 3, config_directory, "/", ss);
1141         ss = string_from_gstring(g);
1142         }
1143
1144     if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1145
1146     if (config_lines)
1147       save_config_position(config_filename, config_lineno);
1148     save = store_get(sizeof(config_file_item), GET_UNTAINTED);
1149     save->next = config_file_stack;
1150     config_file_stack = save;
1151     save->file = config_file;
1152     save->filename = config_filename;
1153     save->directory = config_directory;
1154     save->lineno = config_lineno;
1155
1156     if (!(config_file = Ufopen(ss, "rb")))
1157       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1158         "configuration file %s", ss);
1159
1160     config_filename = string_copy(ss);
1161     config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1162     config_lineno = 0;
1163     continue;
1164     }
1165
1166   /* If this is the start of the logical line, remember where the non-blank
1167   data starts. Otherwise shuffle down continuation lines to remove leading
1168   white space. */
1169
1170   if (len == 0)
1171     startoffset = ss - big_buffer;
1172   else
1173     {
1174     s = big_buffer + len;
1175     if (ss > s)
1176       {
1177       memmove(s, ss, (newlen - len) -  (ss - s) + 1);
1178       newlen -= ss - s;
1179       }
1180     }
1181
1182   /* Accept the new addition to the line. Remove trailing white space. */
1183
1184   len = newlen;
1185   while (len > 0 && isspace(big_buffer[len-1])) len--;
1186   big_buffer[len] = 0;
1187
1188   /* We are done if the line does not end in backslash and contains some data.
1189   Empty logical lines are ignored. For continuations, remove the backslash and
1190   go round the loop to read the continuation line. */
1191
1192   if (len > 0)
1193     {
1194     if (big_buffer[len-1] != '\\') break;   /* End of logical line */
1195     big_buffer[--len] = 0;                  /* Remove backslash */
1196     }
1197   }     /* Loop for reading multiple physical lines */
1198
1199 /* We now have a logical line. Test for the end of a configuration section (or,
1200 more accurately, for the start of the next section). Place the name of the next
1201 section in next_section, and return NULL. If the name given is longer than
1202 next_section, truncate it. It will be unrecognized later, because all the known
1203 section names do fit. Leave space for pluralizing. */
1204
1205 s = big_buffer + startoffset;            /* First non-space character */
1206
1207 if (config_lines)
1208   save_config_line(s);
1209
1210 if (strncmpic(s, US"begin ", 6) == 0)
1211   {
1212   s += 6;
1213   Uskip_whitespace(&s);
1214   if (big_buffer + len - s > sizeof(next_section) - 2)
1215     s[sizeof(next_section) - 2] = 0;
1216   Ustrcpy(next_section, s);
1217   return NULL;
1218   }
1219
1220 /* Return the first non-blank character. */
1221
1222 return s;
1223 }
1224
1225
1226
1227 /*************************************************
1228 *             Read a name                        *
1229 *************************************************/
1230
1231 /* The yield is the pointer to the next uschar. Names longer than the
1232 output space are silently truncated. This function is also used from acl.c when
1233 parsing ACLs.
1234
1235 Arguments:
1236   name      where to put the name
1237   len       length of name
1238   s         input pointer
1239
1240 Returns:    new input pointer
1241 */
1242
1243 const uschar *
1244 readconf_readname(uschar * name, int len, const uschar * s)
1245 {
1246 int p = 0;
1247 BOOL broken = FALSE;
1248
1249 if (isalpha(Uskip_whitespace(&s)))
1250   while (isalnum(*s) || *s == '_')
1251     {
1252     if (p < len-1) name[p++] = *s;
1253     else {
1254       broken = TRUE;
1255       break;
1256     }
1257     s++;
1258     }
1259
1260 name[p] = 0;
1261 if (broken) {
1262   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1263             "exim item name too long (>%d), unable to use \"%s\" (truncated)",
1264             len, name);
1265 }
1266 Uskip_whitespace(&s);
1267 return s;
1268 }
1269
1270
1271
1272
1273 /*************************************************
1274 *          Read a time value                     *
1275 *************************************************/
1276
1277 /* This function is also called from outside, to read argument
1278 time values. The format of a time value is:
1279
1280   [<n>w][<n>d][<n>h][<n>m][<n>s]
1281
1282 as long as at least one is present. If a format error is encountered,
1283 return a negative value. The value must be terminated by the given
1284 terminator.
1285
1286 Arguments:
1287   s             input pointer
1288   terminator    required terminating character
1289   return_msec   if TRUE, allow fractional seconds and return milliseconds
1290
1291 Returns:        the time value, or -1 on syntax error
1292                 value is seconds if return_msec is FALSE
1293                 value is milliseconds if return_msec is TRUE
1294 */
1295
1296 int
1297 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1298 {
1299 int yield = 0;
1300 for (;;)
1301   {
1302   int value, count;
1303   double fraction;
1304
1305   if (!isdigit(*s)) return -1;
1306   (void)sscanf(CCS s, "%d%n", &value, &count);
1307   s += count;
1308
1309   switch (*s)
1310     {
1311     case 'w': value *= 7;
1312     case 'd': value *= 24;
1313     case 'h': value *= 60;
1314     case 'm': value *= 60;
1315     case 's': s++;
1316     break;
1317
1318     case '.':
1319     if (!return_msec) return -1;
1320     (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1321     s += count;
1322     if (*s++ != 's') return -1;
1323     yield += (int)(fraction * 1000.0);
1324     break;
1325
1326     default: return -1;
1327     }
1328
1329   if (return_msec) value *= 1000;
1330   yield += value;
1331   if (*s == terminator) return yield;
1332   }
1333 /* Control never reaches here. */
1334 }
1335
1336
1337
1338 /*************************************************
1339 *          Read a fixed point value              *
1340 *************************************************/
1341
1342 /* The value is returned *1000
1343
1344 Arguments:
1345   s           input pointer
1346   terminator  required terminator
1347
1348 Returns:      the value, or -1 on error
1349 */
1350
1351 static int
1352 readconf_readfixed(const uschar *s, int terminator)
1353 {
1354 int yield = 0;
1355 int value, count;
1356 if (!isdigit(*s)) return -1;
1357 (void)sscanf(CS  s, "%d%n", &value, &count);
1358 s += count;
1359 yield = value * 1000;
1360 if (*s == '.')
1361   {
1362   int m = 100;
1363   while (isdigit((*(++s))))
1364     {
1365     yield += (*s - '0') * m;
1366     m /= 10;
1367     }
1368   }
1369
1370 return (*s == terminator)? yield : (-1);
1371 }
1372
1373
1374
1375 /*************************************************
1376 *            Find option in list                 *
1377 *************************************************/
1378
1379 /* The lists are always in order, so binary chop can be used.
1380
1381 Arguments:
1382   name      the option name to search for
1383   ol        the first entry in the option list
1384   last      one more than the offset of the last entry in the option list
1385
1386 Returns:    pointer to an option entry, or NULL if not found
1387 */
1388
1389 static optionlist *
1390 find_option(const uschar *name, optionlist *ol, int last)
1391 {
1392 int first = 0;
1393 while (last > first)
1394   {
1395   int middle = (first + last)/2;
1396   int c = Ustrcmp(name, ol[middle].name);
1397
1398   if (c == 0) return ol + middle;
1399   else if (c > 0) first = middle + 1;
1400   else last = middle;
1401   }
1402 return NULL;
1403 }
1404
1405
1406
1407 /*************************************************
1408 *      Find a set flag in option list            *
1409 *************************************************/
1410
1411 /* Because some versions of Unix make no restrictions on the values of uids and
1412 gids (even negative ones), we cannot represent "unset" by a special value.
1413 There is therefore a separate boolean variable for each one indicating whether
1414 a value is set or not. This function returns a pointer to the boolean, given
1415 the original option name. It is a major disaster if the flag cannot be found.
1416
1417 Arguments:
1418   name          the name of the uid or gid option
1419   oltop         points to the start of the relevant option list
1420   last          one more than the offset of the last item in the option list
1421   data_block    NULL when reading main options => data values in the option
1422                   list are absolute addresses; otherwise they are byte offsets
1423                   in data_block (used for driver options)
1424
1425 Returns:        a pointer to the boolean flag.
1426 */
1427
1428 static BOOL *
1429 get_set_flag(const uschar *name, optionlist *oltop, int last, void *data_block)
1430 {
1431 optionlist *ol;
1432 uschar name2[EXIM_DRIVERNAME_MAX];
1433 sprintf(CS name2, "*set_%.50s", name);
1434 if (!(ol = find_option(name2, oltop, last)))
1435   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1436     "Exim internal error: missing set flag for %s", name);
1437 return data_block
1438   ? (BOOL *)(US data_block + ol->v.offset) : (BOOL *)ol->v.value;
1439 }
1440
1441
1442
1443
1444 /*************************************************
1445 *    Output extra characters message and die     *
1446 *************************************************/
1447
1448 /* Called when an option line has junk on the end. Sometimes this is because
1449 the sysadmin thinks comments are permitted.
1450
1451 Arguments:
1452   s          points to the extra characters
1453   t1..t3     strings to insert in the log message
1454
1455 Returns:     doesn't return; dies
1456 */
1457
1458 static void
1459 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1460 {
1461 uschar *comment = US"";
1462 if (*s == '#') comment = US" (# is comment only at line start)";
1463 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1464   "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1465 }
1466
1467
1468
1469 /*************************************************
1470 *              Read rewrite information          *
1471 *************************************************/
1472
1473 /* Each line of rewrite information contains:
1474
1475 .  A complete address in the form user@domain, possibly with
1476    leading * for each part; or alternatively, a regex.
1477
1478 .  A replacement string (which will be expanded).
1479
1480 .  An optional sequence of one-letter flags, indicating which
1481    headers etc. to apply this rule to.
1482
1483 All this is decoded and placed into a control block. The OR of the flags is
1484 maintained in a common word.
1485
1486 Arguments:
1487   p           points to the string that makes up the rule
1488   existflags  points to the overall flag word
1489   isglobal    TRUE if reading global rewrite rules
1490
1491 Returns:      the control block for the parsed rule.
1492 */
1493
1494 static rewrite_rule *
1495 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1496 {
1497 rewrite_rule * next = store_get(sizeof(rewrite_rule), GET_UNTAINTED);
1498
1499 next->next = NULL;
1500 next->key = string_dequote(&p);
1501
1502 Uskip_whitespace(&p);
1503 if (!*p)
1504   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1505     "missing rewrite replacement string");
1506
1507 next->flags = 0;
1508 next->replacement = string_dequote(&p);
1509
1510 while (*p) switch (*p++)
1511   {
1512   case ' ': case '\t': break;
1513
1514   case 'q': next->flags |= rewrite_quit; break;
1515   case 'w': next->flags |= rewrite_whole; break;
1516
1517   case 'h': next->flags |= rewrite_all_headers; break;
1518   case 's': next->flags |= rewrite_sender; break;
1519   case 'f': next->flags |= rewrite_from; break;
1520   case 't': next->flags |= rewrite_to;   break;
1521   case 'c': next->flags |= rewrite_cc;   break;
1522   case 'b': next->flags |= rewrite_bcc;  break;
1523   case 'r': next->flags |= rewrite_replyto; break;
1524
1525   case 'E': next->flags |= rewrite_all_envelope; break;
1526   case 'F': next->flags |= rewrite_envfrom; break;
1527   case 'T': next->flags |= rewrite_envto; break;
1528
1529   case 'Q': next->flags |= rewrite_qualify; break;
1530   case 'R': next->flags |= rewrite_repeat; break;
1531
1532   case 'S':
1533   next->flags |= rewrite_smtp;
1534   if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1535     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1536       "rewrite rule has the S flag but is not a regular expression");
1537   break;
1538
1539   default:
1540   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1541     "unknown rewrite flag character '%c' "
1542     "(could be missing quotes round replacement item)", p[-1]);
1543   break;
1544   }
1545
1546 /* If no action flags are set, set all the "normal" rewrites. */
1547
1548 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1549   next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1550
1551 /* Remember which exist, for optimization, and return the rule */
1552
1553 *existflags |= next->flags;
1554 return next;
1555 }
1556
1557
1558
1559
1560 /*************************************************
1561 *          Read global rewrite information       *
1562 *************************************************/
1563
1564 /* Each line is a single rewrite rule; it is parsed into a control block
1565 by readconf_one_rewrite(), and its flags are ORed into the global flag
1566 word rewrite_existflags. */
1567
1568 void
1569 readconf_rewrites(void)
1570 {
1571 rewrite_rule **chain = &global_rewrite_rules;
1572 uschar *p;
1573
1574 while ((p = get_config_line()) != NULL)
1575   {
1576   rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1577   *chain = next;
1578   chain = &(next->next);
1579   }
1580 }
1581
1582
1583
1584 /*************************************************
1585 *               Read a string                    *
1586 *************************************************/
1587
1588 /* Strings are read into the normal store pool. As long we aren't too
1589 near the end of the current block, the string will just use what is necessary
1590 on the top of the stacking pool, because string_cat() uses the extension
1591 mechanism.
1592
1593 Argument:
1594   s         the rest of the input line
1595   name      the option name (for errors)
1596
1597 Returns:    pointer to the string
1598 */
1599
1600 static uschar *
1601 read_string(const uschar *s, const uschar *name)
1602 {
1603 uschar *yield;
1604 const uschar *ss;
1605
1606 if (*s != '\"') return string_copy(s);
1607
1608 ss = s;
1609 yield = string_dequote(&s);
1610
1611 if (s == ss+1 || s[-1] != '\"')
1612   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1613     "missing quote at end of string value for %s", name);
1614
1615 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1616
1617 return yield;
1618 }
1619
1620
1621 /*************************************************
1622 *            Custom-handler options              *
1623 *************************************************/
1624 static void
1625 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags)
1626 {
1627 if (flags & opt_fn_print)
1628   {
1629   if (flags & opt_fn_print_label) printf("%s = ", name);
1630   printf("%s\n", smtp_receive_timeout_s
1631     ? string_printing2(smtp_receive_timeout_s, SP_TAB)
1632     : readconf_printtime(smtp_receive_timeout));
1633   }
1634 else if (*str == '$')
1635   smtp_receive_timeout_s = string_copy(str);
1636 else
1637   {
1638   /* "smtp_receive_timeout",     opt_time,        &smtp_receive_timeout */
1639   smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1640   if (smtp_receive_timeout < 0)
1641     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1642       name);
1643   }
1644 }
1645
1646 /*************************************************
1647 *            Handle option line                  *
1648 *************************************************/
1649
1650 /* This function is called from several places to process a line containing the
1651 setting of an option. The first argument is the line to be decoded; it has been
1652 checked not to be empty and not to start with '#'. Trailing newlines and white
1653 space have been removed. The second argument is a pointer to the list of
1654 variable names that are to be recognized, together with their types and
1655 locations, and the third argument gives the number of entries in the list.
1656
1657 The fourth argument is a pointer to a data block. If it is NULL, then the data
1658 values in the options list are absolute addresses. Otherwise, they are byte
1659 offsets in the data block.
1660
1661 String option data may continue onto several lines; this function reads further
1662 data from config_file if necessary.
1663
1664 The yield of this function is normally zero. If a string continues onto
1665 multiple lines, then the data value is permitted to be followed by a comma
1666 or a semicolon (for use in drivers) and the yield is that character.
1667
1668 Arguments:
1669   buffer        contains the configuration line to be handled
1670   oltop         points to the start of the relevant option list
1671   last          one more than the offset of the last item in the option list
1672   data_block    NULL when reading main options => data values in the option
1673                   list are absolute addresses; otherwise they are byte offsets
1674                   in data_block when they have opt_public set; otherwise
1675                   they are byte offsets in data_block->options_block.
1676   unknown_txt   format string to use in panic message for unknown option;
1677                   must contain %s for option name
1678                 if given as NULL, don't panic on unknown option
1679
1680 Returns:        TRUE if an option was read successfully,
1681                 FALSE false for an unknown option if unknown_txt == NULL,
1682                   otherwise panic and die on an unknown option
1683 */
1684
1685 static BOOL
1686 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1687   void *data_block, uschar *unknown_txt)
1688 {
1689 int ptr = 0;
1690 int offset = 0;
1691 int count, type, value;
1692 int issecure = 0;
1693 uid_t uid;
1694 gid_t gid;
1695 BOOL boolvalue = TRUE;
1696 BOOL freesptr = TRUE;
1697 optionlist *ol, *ol2;
1698 struct passwd *pw;
1699 rmark reset_point;
1700 int intbase = 0;
1701 uschar *inttype = US"";
1702 uschar *sptr;
1703 const uschar * s = buffer;
1704 uschar **str_target;
1705 uschar name[EXIM_DRIVERNAME_MAX];
1706 uschar name2[EXIM_DRIVERNAME_MAX];
1707
1708 /* There may be leading spaces; thereafter, we expect an option name starting
1709 with a letter. */
1710
1711 if (!isalpha( Uskip_whitespace(&s) ))
1712   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1713
1714 /* Read the name of the option, and skip any subsequent white space. If
1715 it turns out that what we read was "hide", set the flag indicating that
1716 this is a secure option, and loop to read the next word. */
1717
1718 for (int n = 0; n < 2; n++)
1719   {
1720   while (isalnum(*s) || *s == '_')
1721     {
1722     if (ptr < sizeof(name)-1) name[ptr++] = *s;
1723     s++;
1724     }
1725   name[ptr] = 0;
1726   Uskip_whitespace(&s);
1727   if (Ustrcmp(name, "hide") != 0) break;
1728   issecure = opt_secure;
1729   ptr = 0;
1730   }
1731
1732 /* Deal with "no_" or "not_" here for booleans */
1733
1734 if (Ustrncmp(name, "no_", 3) == 0)
1735   {
1736   boolvalue = FALSE;
1737   offset = 3;
1738   }
1739
1740 if (Ustrncmp(name, "not_", 4) == 0)
1741   {
1742   boolvalue = FALSE;
1743   offset = 4;
1744   }
1745
1746 /* Search the list for the given name. A non-existent name, or an option that
1747 is set twice, is a disaster. */
1748
1749 if (!(ol = find_option(name + offset, oltop, last)))
1750   {
1751   if (!unknown_txt) return FALSE;
1752   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1753   }
1754
1755 if ((ol->type & opt_set)  && !(ol->type & (opt_rep_con | opt_rep_str)))
1756   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1757     "\"%s\" option set for the second time", name);
1758
1759 ol->type |= opt_set | issecure;
1760 type = ol->type & opt_mask;
1761
1762 /* Types with data values must be followed by '='; the "no[t]_" prefix
1763 applies only to boolean values. */
1764
1765 if (type < opt_bool || type > opt_bool_last)
1766   {
1767   if (offset != 0)
1768     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1769       "negation prefix applied to a non-boolean option");
1770   if (!*s)
1771     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1772       "unexpected end of line (data missing) after %s", name);
1773   if (*s != '=')
1774     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1775   }
1776
1777 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1778 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1779 ultimately expands to one of those values. */
1780
1781 else if (*s && (offset != 0 || *s != '='))
1782   extra_chars_error(s, US"boolean option ", name, US"");
1783
1784 /* Skip white space after = */
1785
1786 if (*s == '=') while (isspace(*++s));
1787
1788 /* If there is a data block and the opt_public flag is not set, change
1789 the data block pointer to the private options block. */
1790
1791 if (data_block && !(ol->type & opt_public))
1792   data_block = (void *)(((driver_instance *)data_block)->options_block);
1793
1794 /* Now get the data according to the type. */
1795
1796 switch (type)
1797   {
1798   /* If a string value is not enclosed in quotes, it consists of
1799   the rest of the current line, verbatim. Otherwise, string escapes
1800   are processed.
1801
1802   A transport is specified as a string, which is then looked up in the
1803   list of transports. A search type is specified as one of a number of
1804   known strings.
1805
1806   A set or rewrite rules for a driver is specified as a string, which is
1807   then parsed into a suitable chain of control blocks.
1808
1809   Uids and gids are specified as strings which are then looked up in the
1810   passwd file. Lists of uids and gids are similarly specified as colon-
1811   separated strings. */
1812
1813   case opt_stringptr:
1814   case opt_uid:
1815   case opt_gid:
1816   case opt_expand_uid:
1817   case opt_expand_gid:
1818   case opt_uidlist:
1819   case opt_gidlist:
1820   case opt_rewrite:
1821
1822     reset_point = store_mark();
1823     sptr = read_string(s, name);
1824
1825     /* Having read a string, we now have several different ways of using it,
1826     depending on the data type, so do another switch. If keeping the actual
1827     string is not required (because it is interpreted), freesptr is set TRUE,
1828     and at the end we reset the pool. */
1829
1830     switch (type)
1831       {
1832       /* If this was a string, set the variable to point to the new string,
1833       and set the flag so its store isn't reclaimed. If it was a list of rewrite
1834       rules, we still keep the string (for printing), and parse the rules into a
1835       control block and flags word. */
1836
1837       case opt_stringptr:
1838         str_target = data_block ? USS (US data_block + ol->v.offset)
1839                                 : USS ol->v.value;
1840         if (ol->type & opt_rep_con)
1841           {
1842           uschar * saved_condition;
1843           /* We already have a condition, we're conducting a crude hack to let
1844           multiple condition rules be chained together, despite storing them in
1845           text form. */
1846           *str_target = string_copy_perm( (saved_condition = *str_target)
1847             ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1848                 saved_condition, sptr)
1849             : sptr,
1850             FALSE);
1851           /* TODO(pdp): there is a memory leak here and just below
1852           when we set 3 or more conditions; I still don't
1853           understand the store mechanism enough to know
1854           what's the safe way to free content from an earlier store.
1855           AFAICT, stores stack, so freeing an early stored item also stores
1856           all data alloc'd after it.  If we knew conditions were adjacent,
1857           we could survive that, but we don't.  So I *think* we need to take
1858           another bit from opt_type to indicate "malloced"; this seems like
1859           quite a hack, especially for this one case.  It also means that
1860           we can't ever reclaim the store from the *first* condition.
1861
1862           Because we only do this once, near process start-up, I'm prepared to
1863           let this slide for the time being, even though it rankles.  */
1864           }
1865         else if (ol->type & opt_rep_str)
1866           {
1867           uschar sep_o =
1868             Ustrncmp(name, "headers_add", 11) == 0      ? '\n'
1869             : Ustrncmp(name, "set", 3) == 0             ? ';'
1870             : ':';
1871           int    sep_i = -(int)sep_o;
1872           const uschar * list = sptr;
1873           uschar * s;
1874           gstring * list_o = NULL;
1875
1876           if (*str_target)
1877             {
1878             list_o = string_get(Ustrlen(*str_target) + Ustrlen(sptr));
1879             list_o = string_cat(list_o, *str_target);
1880             }
1881
1882           while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1883             list_o = string_append_listele(list_o, sep_o, s);
1884
1885           if (list_o)
1886             *str_target = string_copy_perm(string_from_gstring(list_o), FALSE);
1887           }
1888         else
1889           {
1890           *str_target = sptr;
1891           freesptr = FALSE;
1892           }
1893         break;
1894
1895       case opt_rewrite:
1896         if (data_block)
1897           *USS (US data_block + ol->v.offset) = sptr;
1898         else
1899           *USS ol->v.value = sptr;
1900         freesptr = FALSE;
1901         if (type == opt_rewrite)
1902           {
1903           int sep = 0;
1904           int *flagptr;
1905           uschar *p = sptr;
1906           rewrite_rule **chain;
1907           optionlist *ol3;
1908
1909           sprintf(CS name2, "*%.50s_rules", name);
1910           ol2 = find_option(name2, oltop, last);
1911           sprintf(CS name2, "*%.50s_flags", name);
1912           ol3 = find_option(name2, oltop, last);
1913
1914           if (!ol2 || !ol3)
1915             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1916               "rewrite rules not available for driver");
1917
1918           if (data_block)
1919             {
1920             chain = (rewrite_rule **)(US data_block + ol2->v.offset);
1921             flagptr = (int *)(US data_block + ol3->v.offset);
1922             }
1923           else
1924             {
1925             chain = (rewrite_rule **)ol2->v.value;
1926             flagptr = (int *)ol3->v.value;
1927             }
1928
1929           /* This will trap if sptr is tainted. Not sure if that can happen */
1930           while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1931             {
1932             rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1933             *chain = next;
1934             chain = &(next->next);
1935             }
1936
1937           if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1938             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1939               "non-header rewrite - not allowed at transport time -");
1940           }
1941         break;
1942
1943       /* If it was an expanded uid, see if there is any expansion to be
1944       done by checking for the presence of a $ character. If there is, save it
1945       in the corresponding *expand_user option field. Otherwise, fall through
1946       to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1947       of data. */
1948
1949       case opt_expand_uid:
1950         sprintf(CS name2, "*expand_%.50s", name);
1951         if ((ol2 = find_option(name2, oltop, last)))
1952           {
1953           uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1954
1955           if (data_block)
1956             *(USS(US data_block + ol2->v.offset)) = ss;
1957           else
1958             *(USS ol2->v.value) = ss;
1959
1960           if (ss)
1961             {
1962             *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1963             freesptr = FALSE;
1964             break;
1965             }
1966           }
1967
1968       /* Look up a fixed uid, and also make use of the corresponding gid
1969       if a passwd entry is returned and the gid has not been set. */
1970
1971       case opt_uid:
1972         if (!route_finduser(sptr, &pw, &uid))
1973           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1974         if (data_block)
1975           *(uid_t *)(US data_block + ol->v.offset) = uid;
1976         else
1977           *(uid_t *)ol->v.value = uid;
1978
1979         /* Set the flag indicating a fixed value is set */
1980
1981         *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1982
1983         /* Handle matching gid if we have a passwd entry: done by finding the
1984         same name with terminating "user" changed to "group"; if not found,
1985         ignore. Also ignore if the value is already set. */
1986
1987         if (pw == NULL) break;
1988         Ustrcpy(name+Ustrlen(name)-4, US"group");
1989         ol2 = find_option(name, oltop, last);
1990         if (ol2 && ((ol2->type & opt_mask) == opt_gid ||
1991             (ol2->type & opt_mask) == opt_expand_gid))
1992           {
1993           BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1994           if (!*set_flag)
1995             {
1996             if (data_block)
1997               *((gid_t *)(US data_block + ol2->v.offset)) = pw->pw_gid;
1998             else
1999               *((gid_t *)ol2->v.value) = pw->pw_gid;
2000             *set_flag = TRUE;
2001             }
2002           }
2003         break;
2004
2005       /* If it was an expanded gid, see if there is any expansion to be
2006       done by checking for the presence of a $ character. If there is, save it
2007       in the corresponding *expand_user option field. Otherwise, fall through
2008       to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
2009       of data. */
2010
2011       case opt_expand_gid:
2012         sprintf(CS name2, "*expand_%.50s", name);
2013         if ((ol2 = find_option(name2, oltop, last)))
2014           {
2015           uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
2016
2017           if (data_block)
2018             *(USS(US data_block + ol2->v.offset)) = ss;
2019           else
2020             *(USS ol2->v.value) = ss;
2021
2022           if (ss)
2023             {
2024             *(get_set_flag(name, oltop, last, data_block)) = FALSE;
2025             freesptr = FALSE;
2026             break;
2027             }
2028           }
2029
2030       /* Handle freestanding gid */
2031
2032       case opt_gid:
2033         if (!route_findgroup(sptr, &gid))
2034           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
2035         if (data_block)
2036           *((gid_t *)(US data_block + ol->v.offset)) = gid;
2037         else
2038           *((gid_t *)ol->v.value) = gid;
2039         *(get_set_flag(name, oltop, last, data_block)) = TRUE;
2040         break;
2041
2042       /* If it was a uid list, look up each individual entry, and build
2043       a vector of uids, with a count in the first element. Put the vector
2044       in malloc store so we can free the string. (We are reading into
2045       permanent store already.) */
2046
2047       case opt_uidlist:
2048         {
2049         int count = 1;
2050         uid_t *list;
2051         int ptr = 0;
2052         const uschar *p;
2053         const uschar *op = expand_string (sptr);
2054
2055         if (op == NULL)
2056           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2057             name, expand_string_message);
2058
2059         p = op;
2060         if (*p != 0) count++;
2061         while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2062         list = store_malloc(count*sizeof(uid_t));
2063         list[ptr++] = (uid_t)(count - 1);
2064
2065         if (data_block)
2066           *((uid_t **)(US data_block + ol->v.offset)) = list;
2067         else
2068           *((uid_t **)ol->v.value) = list;
2069
2070         p = op;
2071         while (count-- > 1)
2072           {
2073           int sep = 0;
2074           /* If p is tainted we trap.  Not sure that can happen */
2075           (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2076           if (!route_finduser(big_buffer, NULL, &uid))
2077             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
2078               big_buffer);
2079           list[ptr++] = uid;
2080           }
2081         break;
2082         }
2083
2084       /* If it was a gid list, look up each individual entry, and build
2085       a vector of gids, with a count in the first element. Put the vector
2086       in malloc store so we can free the string. (We are reading into permanent
2087       store already.) */
2088
2089       case opt_gidlist:
2090         {
2091         int count = 1;
2092         gid_t *list;
2093         int ptr = 0;
2094         const uschar *p;
2095         const uschar *op = expand_string (sptr);
2096
2097         if (!op)
2098           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2099             name, expand_string_message);
2100
2101         p = op;
2102         if (*p != 0) count++;
2103         while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2104         list = store_malloc(count*sizeof(gid_t));
2105         list[ptr++] = (gid_t)(count - 1);
2106
2107         if (data_block)
2108           *((gid_t **)(US data_block + ol->v.offset)) = list;
2109         else
2110           *((gid_t **)ol->v.value) = list;
2111
2112         p = op;
2113         while (count-- > 1)
2114           {
2115           int sep = 0;
2116           /* If p is tainted we trap.  Not sure that can happen */
2117           (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2118           if (!route_findgroup(big_buffer, &gid))
2119             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2120               big_buffer);
2121           list[ptr++] = gid;
2122           }
2123         break;
2124         }
2125       }
2126
2127     /* Release store if the value of the string doesn't need to be kept. */
2128
2129     if (freesptr) reset_point = store_reset(reset_point);
2130     break;
2131
2132   /* Expanded boolean: if no characters follow, or if there are no dollar
2133   characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2134   save the string for later expansion in the alternate place. */
2135
2136   case opt_expand_bool:
2137     if (*s && Ustrchr(s, '$') != 0)
2138       {
2139       sprintf(CS name2, "*expand_%.50s", name);
2140       if ((ol2 = find_option(name2, oltop, last)))
2141         {
2142         reset_point = store_mark();
2143         sptr = read_string(s, name);
2144         if (data_block)
2145           *(USS(US data_block + ol2->v.offset)) = sptr;
2146         else
2147           *(USS ol2->v.value) = sptr;
2148         freesptr = FALSE;
2149         break;
2150         }
2151       }
2152     /* Fall through */
2153
2154   /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2155   look for yes/not/true/false. Some booleans are stored in a single bit in
2156   a single int. There's a special fudge for verify settings; without a suffix
2157   they set both xx_sender and xx_recipient. The table points to the sender
2158   value; search subsequently for the recipient. There's another special case:
2159   opt_bool_set also notes when a boolean has been set. */
2160
2161   case opt_bool:
2162   case opt_bit:
2163   case opt_bool_verify:
2164   case opt_bool_set:
2165     if (*s)
2166       {
2167       s = readconf_readname(name2, EXIM_DRIVERNAME_MAX, s);
2168       if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2169         boolvalue = TRUE;
2170       else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2171         boolvalue = FALSE;
2172       else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2173         "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2174       if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2175         US"for boolean option ", name);
2176       }
2177
2178     /* Handle single-bit type. */
2179
2180     if (type == opt_bit)
2181       {
2182       int bit = 1 << ((ol->type >> 16) & 31);
2183       int * ptr = data_block
2184         ? (int *)(US data_block + ol->v.offset)
2185         : (int *)ol->v.value;
2186       if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2187       break;
2188       }
2189
2190     /* Handle full BOOL types */
2191
2192     if (data_block)
2193       *((BOOL *)(US data_block + ol->v.offset)) = boolvalue;
2194     else
2195       *((BOOL *)ol->v.value) = boolvalue;
2196
2197     /* Verify fudge */
2198
2199     if (type == opt_bool_verify)
2200       {
2201       sprintf(CS name2, "%.50s_recipient", name + offset);
2202       if ((ol2 = find_option(name2, oltop, last)))
2203         if (data_block)
2204           *((BOOL *)(US data_block + ol2->v.offset)) = boolvalue;
2205         else
2206           *((BOOL *)ol2->v.value) = boolvalue;
2207       }
2208
2209     /* Note that opt_bool_set type is set, if there is somewhere to do so */
2210
2211     else if (type == opt_bool_set)
2212       {
2213       sprintf(CS name2, "*set_%.50s", name + offset);
2214       if ((ol2 = find_option(name2, oltop, last)))
2215         if (data_block)
2216           *((BOOL *)(US data_block + ol2->v.offset)) = TRUE;
2217         else
2218           *((BOOL *)ol2->v.value) = TRUE;
2219       }
2220     break;
2221
2222   /* Octal integer */
2223
2224   case opt_octint:
2225     intbase = 8;
2226     inttype = US"octal ";
2227
2228   /*  Integer: a simple(ish) case; allow octal and hex formats, and
2229   suffixes K, M, G, and T.  The different types affect output, not input. */
2230
2231   case opt_mkint:
2232   case opt_int:
2233      {
2234       uschar *endptr;
2235       long int lvalue;
2236
2237       errno = 0;
2238       lvalue = strtol(CS s, CSS &endptr, intbase);
2239
2240       if (endptr == s)
2241         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2242           inttype, name);
2243
2244       if (errno != ERANGE && *endptr)
2245         {
2246         uschar * mp = US"TtGgMmKk\0";   /* YyZzEePpTtGgMmKk */
2247
2248         if ((mp = Ustrchr(mp, *endptr)))
2249           {
2250           endptr++;
2251           do
2252             {
2253             if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024)
2254               {
2255               errno = ERANGE;
2256               break;
2257               }
2258             lvalue *= 1024;
2259             }
2260           while (*(mp += 2));
2261           }
2262         }
2263
2264       if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2265         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2266           "absolute value of integer \"%s\" is too large (overflow)", s);
2267
2268       if (Uskip_whitespace(&endptr))
2269         extra_chars_error(endptr, inttype, US"integer value for ", name);
2270
2271       value = (int)lvalue;
2272      }
2273
2274     if (data_block)
2275       *(int *)(US data_block + ol->v.offset) = value;
2276     else
2277       *(int *)ol->v.value = value;
2278     break;
2279
2280   /*  Integer held in K: again, allow formats and suffixes as above. */
2281
2282   case opt_Kint:
2283     {
2284     uschar *endptr;
2285     errno = 0;
2286     int_eximarith_t lvalue = strtol(CS s, CSS &endptr, intbase);
2287
2288     if (endptr == s)
2289       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2290         inttype, name);
2291
2292     if (errno != ERANGE && *endptr)
2293       {
2294       uschar * mp = US"ZzEePpTtGgMmKk\0";       /* YyZzEePpTtGgMmKk */
2295
2296       if ((mp = Ustrchr(mp, *endptr)))
2297         {
2298         endptr++;
2299         while (*(mp += 2))
2300           {
2301           if (lvalue > EXIM_ARITH_MAX/1024 || lvalue < EXIM_ARITH_MIN/1024)
2302             {
2303             errno = ERANGE;
2304             break;
2305             }
2306           lvalue *= 1024;
2307           }
2308         }
2309       else
2310         lvalue = (lvalue + 512)/1024;
2311       }
2312
2313     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2314       "absolute value of integer \"%s\" is too large (overflow)", s);
2315
2316     if (Uskip_whitespace(&endptr))
2317       extra_chars_error(endptr, inttype, US"integer value for ", name);
2318
2319     if (data_block)
2320       *(int_eximarith_t *)(US data_block + ol->v.offset) = lvalue;
2321     else
2322       *(int_eximarith_t *)ol->v.value = lvalue;
2323     break;
2324     }
2325
2326   /*  Fixed-point number: held to 3 decimal places. */
2327
2328   case opt_fixed:
2329     if (sscanf(CS s, "%d%n", &value, &count) != 1)
2330       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2331         "fixed-point number expected for %s", name);
2332
2333     if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2334       "integer \"%s\" is too large (overflow)", s);
2335
2336     value *= 1000;
2337
2338     if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2339       "integer \"%s\" is too large (overflow)", s);
2340
2341     /* We get a coverity error here for using count, as it derived
2342     from the tainted buffer pointed to by s, as parsed by sscanf().
2343     By the definition of sscanf we must be accessing between start
2344     and end of s (assuming it is nul-terminated...) so ignore the error.  */
2345     /* coverity[tainted_data] */
2346     if (s[count] == '.')
2347       {
2348       int d = 100;
2349       while (isdigit(s[++count]))
2350         {
2351         value += (s[count] - '0') * d;
2352         d /= 10;
2353         }
2354       }
2355
2356     while (isspace(s[count])) count++;
2357
2358     if (s[count] != 0)
2359       extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2360
2361     if (data_block)
2362       *((int *)(US data_block + ol->v.offset)) = value;
2363     else
2364       *((int *)ol->v.value) = value;
2365     break;
2366
2367   /* There's a special routine to read time values. */
2368
2369   case opt_time:
2370     value = readconf_readtime(s, 0, FALSE);
2371     if (value < 0)
2372       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2373         name);
2374     if (data_block)
2375       *((int *)(US data_block + ol->v.offset)) = value;
2376     else
2377       *((int *)ol->v.value) = value;
2378     break;
2379
2380   /* A time list is a list of colon-separated times, with the first
2381   element holding the size of the list and the second the number of
2382   entries used. */
2383
2384   case opt_timelist:
2385     {
2386     int count = 0;
2387     int * list = data_block
2388       ? (int *)(US data_block + ol->v.offset)
2389       : (int *)ol->v.value;
2390
2391     if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2392       {
2393       int terminator = 0;
2394       uschar *snext = Ustrchr(s, ':');
2395       if (snext != NULL)
2396         {
2397         uschar *ss = snext;
2398         while (ss > s && isspace(ss[-1])) ss--;
2399         terminator = *ss;
2400         }
2401       value = readconf_readtime(s, terminator, FALSE);
2402       if (value < 0)
2403         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2404           name);
2405       if (count > 1 && value <= list[count])
2406         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2407           "time value out of order for %s", name);
2408       list[count+1] = value;
2409       if (snext == NULL) break;
2410       s = snext + 1;
2411       Uskip_whitespace(&s);
2412       }
2413
2414     if (count > list[0] - 2)
2415       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2416         name);
2417     if (count > 0 && list[2] == 0) count = 0;
2418     list[1] = count;
2419     break;
2420     }
2421
2422   case opt_func:
2423     ol->v.fn(name, s, 0);
2424     break;
2425   }
2426
2427 return TRUE;
2428 }
2429
2430
2431
2432 /*************************************************
2433 *               Print a time value               *
2434 *************************************************/
2435
2436 /*
2437 Argument:  a time value in seconds
2438 Returns:   pointer to a fixed buffer containing the time as a string,
2439            in readconf_readtime() format
2440 */
2441
2442 uschar *
2443 readconf_printtime(int t)
2444 {
2445 int s, m, h, d, w;
2446 uschar *p = time_buffer;
2447
2448 if (t < 0) *p++ = '-', t = -t;
2449
2450 s = t % 60;
2451 t /= 60;
2452 m = t % 60;
2453 t /= 60;
2454 h = t % 24;
2455 t /= 24;
2456 d = t % 7;
2457 w = t/7;
2458
2459 if (w > 0) p += sprintf(CS p, "%dw", w);
2460 if (d > 0) p += sprintf(CS p, "%dd", d);
2461 if (h > 0) p += sprintf(CS p, "%dh", h);
2462 if (m > 0) p += sprintf(CS p, "%dm", m);
2463 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2464
2465 return time_buffer;
2466 }
2467
2468
2469
2470 /*************************************************
2471 *      Print an individual option value          *
2472 *************************************************/
2473
2474 /* This is used by the -bP option, so prints to the standard output.
2475 The entire options list is passed in as an argument, because some options come
2476 in pairs - typically uid/gid settings, which can either be explicit numerical
2477 values, or strings to be expanded later. If the numerical value is unset,
2478 search for "*expand_<name>" to see if there is a string equivalent.
2479
2480 Arguments:
2481   ol             option entry, or NULL for an unknown option
2482   name           option name
2483   options_block  NULL for main configuration options; otherwise points to
2484                    a driver block; if the option doesn't have opt_public
2485                    set, then options_block->options_block is where the item
2486                    resides.
2487   oltop          points to the option list in which ol exists
2488   last           one more than the offset of the last entry in optop
2489   no_labels      do not show "foo = " at the start.
2490
2491 Returns:         boolean success
2492 */
2493
2494 static BOOL
2495 print_ol(optionlist *ol, const uschar *name, void *options_block,
2496   optionlist *oltop, int last, BOOL no_labels)
2497 {
2498 struct passwd *pw;
2499 struct group *gr;
2500 optionlist *ol2;
2501 void *value;
2502 uid_t *uidlist;
2503 gid_t *gidlist;
2504 uschar *s;
2505 uschar name2[EXIM_DRIVERNAME_MAX];
2506
2507 if (!ol)
2508   {
2509   printf("%s is not a known option\n", name);
2510   return FALSE;
2511   }
2512
2513 /* Non-admin callers cannot see options that have been flagged secure by the
2514 "hide" prefix. */
2515
2516 if (!f.admin_user && ol->type & opt_secure)
2517   {
2518   if (no_labels)
2519     printf("%s\n", CCS hidden);
2520   else
2521     printf("%s = %s\n", name, CCS hidden);
2522   return TRUE;
2523   }
2524
2525 /* Else show the value of the option */
2526
2527 value = ol->v.value;
2528 if (options_block)
2529   {
2530   if (!(ol->type & opt_public))
2531     options_block = (void *)(((driver_instance *)options_block)->options_block);
2532   value = (void *)(US options_block + (long int)value);
2533   }
2534
2535 switch(ol->type & opt_mask)
2536   {
2537   case opt_stringptr:
2538   case opt_rewrite:        /* Show the text value */
2539     s = *(USS value);
2540     if (!no_labels) printf("%s = ", name);
2541     printf("%s\n", s ? string_printing2(s, SP_TAB) : US"");
2542     break;
2543
2544   case opt_int:
2545     if (!no_labels) printf("%s = ", name);
2546     printf("%d\n", *((int *)value));
2547     break;
2548
2549   case opt_mkint:
2550     {
2551     int x = *((int *)value);
2552     if (x != 0 && (x & 1023) == 0)
2553       {
2554       int c = 'K';
2555       x >>= 10;
2556       if ((x & 1023) == 0)
2557         {
2558         c = 'M';
2559         x >>= 10;
2560         }
2561       if (!no_labels) printf("%s = ", name);
2562       printf("%d%c\n", x, c);
2563       }
2564     else
2565       {
2566       if (!no_labels) printf("%s = ", name);
2567       printf("%d\n", x);
2568       }
2569     }
2570     break;
2571
2572   case opt_Kint:
2573     {
2574     int_eximarith_t x = *((int_eximarith_t *)value);
2575     if (!no_labels) printf("%s = ", name);
2576     if (x == 0) printf("0\n");
2577     else if ((x & ((1<<30)-1)) == 0) printf(PR_EXIM_ARITH "T\n", x >> 30);
2578     else if ((x & ((1<<20)-1)) == 0) printf(PR_EXIM_ARITH "G\n", x >> 20);
2579     else if ((x & ((1<<10)-1)) == 0) printf(PR_EXIM_ARITH "M\n", x >> 10);
2580     else printf(PR_EXIM_ARITH "K\n", x);
2581     }
2582     break;
2583
2584   case opt_octint:
2585     if (!no_labels) printf("%s = ", name);
2586     printf("%#o\n", *((int *)value));
2587     break;
2588
2589   /* Can be negative only when "unset", in which case integer */
2590
2591   case opt_fixed:
2592     {
2593     int x = *((int *)value);
2594     int f = x % 1000;
2595     int d = 100;
2596     if (x < 0) printf("%s =\n", name); else
2597       {
2598       if (!no_labels) printf("%s = ", name);
2599       printf("%d.", x/1000);
2600       do
2601         {
2602         printf("%d", f/d);
2603         f %= d;
2604         d /= 10;
2605         }
2606       while (f != 0);
2607       printf("\n");
2608       }
2609     }
2610     break;
2611
2612   /* If the numerical value is unset, try for the string value */
2613
2614   case opt_expand_uid:
2615     if (! *get_set_flag(name, oltop, last, options_block))
2616       {
2617       sprintf(CS name2, "*expand_%.50s", name);
2618       if ((ol2 = find_option(name2, oltop, last)))
2619         {
2620         if (options_block)
2621           s = *USS (US options_block + ol2->v.offset);
2622         else
2623           s = *USS ol2->v.value;
2624         if (!no_labels) printf("%s = ", name);
2625         printf("%s\n", s ? string_printing(s) : US"");
2626         break;
2627         }
2628       }
2629
2630     /* Else fall through */
2631
2632   case opt_uid:
2633     if (!no_labels) printf("%s = ", name);
2634     if (! *get_set_flag(name, oltop, last, options_block))
2635       printf("\n");
2636     else
2637       if ((pw = getpwuid(*((uid_t *)value))))
2638         printf("%s\n", pw->pw_name);
2639       else
2640         printf("%ld\n", (long int)(*((uid_t *)value)));
2641     break;
2642
2643   /* If the numerical value is unset, try for the string value */
2644
2645   case opt_expand_gid:
2646     if (! *get_set_flag(name, oltop, last, options_block))
2647       {
2648       sprintf(CS name2, "*expand_%.50s", name);
2649       if (  (ol2 = find_option(name2, oltop, last))
2650          && (ol2->type & opt_mask) == opt_stringptr)
2651         {
2652         if (options_block)
2653           s = *USS (US options_block + ol2->v.offset);
2654         else
2655           s = *USS ol2->v.value;
2656         if (!no_labels) printf("%s = ", name);
2657         printf("%s\n", s ? string_printing(s) : US"");
2658         break;
2659         }
2660       }
2661
2662     /* Else fall through */
2663
2664   case opt_gid:
2665     if (!no_labels) printf("%s = ", name);
2666     if (! *get_set_flag(name, oltop, last, options_block))
2667       printf("\n");
2668     else
2669       if ((gr = getgrgid(*((int *)value))))
2670         printf("%s\n", gr->gr_name);
2671       else
2672          printf("%ld\n", (long int)(*((int *)value)));
2673     break;
2674
2675   case opt_uidlist:
2676     uidlist = *((uid_t **)value);
2677     if (!no_labels) printf("%s =", name);
2678     if (uidlist)
2679       {
2680       uschar sep = no_labels ? '\0' : ' ';
2681       for (int i = 1; i <= (int)(uidlist[0]); i++)
2682         {
2683         uschar *name = NULL;
2684         if ((pw = getpwuid(uidlist[i]))) name = US pw->pw_name;
2685         if (sep != '\0') printf("%c", sep);
2686         if (name) printf("%s", name);
2687         else printf("%ld", (long int)(uidlist[i]));
2688         sep = ':';
2689         }
2690       }
2691     printf("\n");
2692     break;
2693
2694   case opt_gidlist:
2695     gidlist = *((gid_t **)value);
2696     if (!no_labels) printf("%s =", name);
2697     if (gidlist)
2698       {
2699       uschar sep = no_labels ? '\0' : ' ';
2700       for (int i = 1; i <= (int)(gidlist[0]); i++)
2701         {
2702         uschar *name = NULL;
2703         if ((gr = getgrgid(gidlist[i]))) name = US gr->gr_name;
2704         if (sep != '\0') printf("%c", sep);
2705         if (name) printf("%s", name);
2706         else printf("%ld", (long int)(gidlist[i]));
2707         sep = ':';
2708         }
2709       }
2710     printf("\n");
2711     break;
2712
2713   case opt_time:
2714     if (!no_labels) printf("%s = ", name);
2715     printf("%s\n", readconf_printtime(*((int *)value)));
2716     break;
2717
2718   case opt_timelist:
2719     {
2720     int *list = (int *)value;
2721     if (!no_labels) printf("%s = ", name);
2722     for (int i = 0; i < list[1]; i++)
2723       printf("%s%s", i == 0 ? "" : ":", readconf_printtime(list[i+2]));
2724     printf("\n");
2725     }
2726     break;
2727
2728   case opt_bit:
2729     printf("%s%s\n", (*((int *)value)) & (1 << ((ol->type >> 16) & 31))
2730       ? "" : "no_", name);
2731     break;
2732
2733   case opt_expand_bool:
2734     sprintf(CS name2, "*expand_%.50s", name);
2735     if ((ol2 = find_option(name2, oltop, last)) && ol2->v.value)
2736       {
2737       if (options_block)
2738         s = *USS (US options_block + ol2->v.offset);
2739       else
2740         s = *USS ol2->v.value;
2741       if (s)
2742         {
2743         if (!no_labels) printf("%s = ", name);
2744         printf("%s\n", string_printing(s));
2745         break;
2746         }
2747       /* s == NULL => string not set; fall through */
2748       }
2749
2750     /* Fall through */
2751
2752   case opt_bool:
2753   case opt_bool_verify:
2754   case opt_bool_set:
2755     printf("%s%s\n", *((BOOL *)value) ? "" : "no_", name);
2756     break;
2757
2758   case opt_func:
2759     ol->v.fn(name, NULL, no_labels ? opt_fn_print : opt_fn_print|opt_fn_print_label);
2760     break;
2761   }
2762 return TRUE;
2763 }
2764
2765
2766
2767 /*************************************************
2768 *        Print value from main configuration     *
2769 *************************************************/
2770
2771 /* This function, called as a result of encountering the -bP option,
2772 causes the value of any main configuration variable to be output if the
2773 second argument is NULL. There are some special values:
2774
2775   all                print all main configuration options
2776   config_file        print the name of the configuration file
2777                      (configure_file will still work, for backward
2778                      compatibility)
2779   routers            print the routers' configurations
2780   transports         print the transports' configuration
2781   authenticators     print the authenticators' configuration
2782   macros             print the macros' configuration
2783   router_list        print a list of router names
2784   transport_list     print a list of transport names
2785   authenticator_list print a list of authentication mechanism names
2786   macro_list         print a list of macro names
2787   +name              print a named list item
2788   local_scan         print the local_scan options
2789   config             print the configuration as it is parsed
2790   environment        print the used execution environment
2791
2792 If the second argument is not NULL, it must be one of "router", "transport",
2793 "authenticator" or "macro" in which case the first argument identifies the
2794 driver whose options are to be printed.
2795
2796 Arguments:
2797   name        option name if type == NULL; else driver name
2798   type        NULL or driver type name, as described above
2799   no_labels   avoid the "foo = " at the start of an item
2800
2801 Returns:      Boolean success
2802 */
2803
2804 BOOL
2805 readconf_print(const uschar * name, const uschar * type, BOOL no_labels)
2806 {
2807 BOOL names_only = FALSE;
2808 optionlist *ol2 = NULL;
2809 driver_instance *d = NULL;
2810 int size = 0;
2811
2812 if (!type)
2813   {
2814   if (*name == '+')
2815     {
2816     tree_node *t;
2817     BOOL found = FALSE;
2818     static uschar *types[] = { US"address", US"domain", US"host",
2819       US"localpart" };
2820     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2821       &hostlist_anchor, &localpartlist_anchor };
2822
2823     for (int i = 0; i < 4; i++)
2824       if ((t = tree_search(*(anchors[i]), name+1)))
2825         {
2826         namedlist_block * nb = t->data.ptr;
2827         const uschar * s = nb->hide ? hidden : nb->string;
2828         found = TRUE;
2829         if (no_labels)
2830           printf("%s\n", CCS s);
2831         else
2832           printf("%slist %s = %s\n", types[i], name+1, CCS s);
2833         }
2834
2835     if (!found)
2836       printf("no address, domain, host, or local part list called \"%s\" "
2837         "exists\n", name+1);
2838
2839     return found;
2840     }
2841
2842   if (  Ustrcmp(name, "configure_file") == 0
2843      || Ustrcmp(name, "config_file") == 0)
2844     {
2845     printf("%s\n", CS config_main_filename);
2846     return TRUE;
2847     }
2848
2849   if (Ustrcmp(name, "all") == 0)
2850     {
2851     for (optionlist * ol = optionlist_config;
2852          ol < optionlist_config + nelem(optionlist_config); ol++)
2853       if (!(ol->type & opt_hidden))
2854         (void) print_ol(ol, US ol->name, NULL,
2855                   optionlist_config, nelem(optionlist_config),
2856                   no_labels);
2857     return TRUE;
2858     }
2859
2860   if (Ustrcmp(name, "local_scan") == 0)
2861     {
2862 #ifndef LOCAL_SCAN_HAS_OPTIONS
2863     printf("local_scan() options are not supported\n");
2864     return FALSE;
2865 #else
2866     for (optionlist * ol = local_scan_options;
2867          ol < local_scan_options + local_scan_options_count; ol++)
2868       (void) print_ol(ol, US ol->name, NULL, local_scan_options,
2869                   local_scan_options_count, no_labels);
2870     return TRUE;
2871 #endif
2872     }
2873
2874   if (Ustrcmp(name, "config") == 0)
2875     {
2876     print_config(f.admin_user, no_labels);
2877     return TRUE;
2878     }
2879
2880   if (Ustrcmp(name, "routers") == 0)
2881     {
2882     type = US"router";
2883     name = NULL;
2884     }
2885   else if (Ustrcmp(name, "transports") == 0)
2886     {
2887     type = US"transport";
2888     name = NULL;
2889     }
2890   else if (Ustrcmp(name, "authenticators") == 0)
2891     {
2892     type = US"authenticator";
2893     name = NULL;
2894     }
2895   else if (Ustrcmp(name, "macros") == 0)
2896     {
2897     type = US"macro";
2898     name = NULL;
2899     }
2900   else if (Ustrcmp(name, "router_list") == 0)
2901     {
2902     type = US"router";
2903     name = NULL;
2904     names_only = TRUE;
2905     }
2906   else if (Ustrcmp(name, "transport_list") == 0)
2907     {
2908     type = US"transport";
2909     name = NULL;
2910     names_only = TRUE;
2911     }
2912   else if (Ustrcmp(name, "authenticator_list") == 0)
2913     {
2914     type = US"authenticator";
2915     name = NULL;
2916     names_only = TRUE;
2917     }
2918   else if (Ustrcmp(name, "macro_list") == 0)
2919     {
2920     type = US"macro";
2921     name = NULL;
2922     names_only = TRUE;
2923     }
2924   else if (Ustrcmp(name, "environment") == 0)
2925     {
2926     if (environ)
2927       {
2928       uschar ** p;
2929       for (p = USS environ; *p; p++) ;
2930       qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2931
2932       for (p = USS environ; *p; p++)
2933         {
2934         uschar * q;
2935         if (no_labels && (q = Ustrchr(*p, '='))) *q  = '\0';
2936         puts(CS *p);
2937         }
2938       }
2939     return TRUE;
2940     }
2941
2942   else
2943     return print_ol(find_option(name,
2944                       optionlist_config, nelem(optionlist_config)),
2945       name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2946   }
2947
2948 /* Handle the options for a router or transport. Skip options that are flagged
2949 as hidden. Some of these are options with names starting with '*', used for
2950 internal alternative representations of other options (which the printing
2951 function will sort out). Others are synonyms kept for backward compatibility.
2952 */
2953
2954 if (Ustrcmp(type, "router") == 0)
2955   {
2956   d = (driver_instance *)routers;
2957   ol2 = optionlist_routers;
2958   size = optionlist_routers_size;
2959   }
2960 else if (Ustrcmp(type, "transport") == 0)
2961   {
2962   d = (driver_instance *)transports;
2963   ol2 = optionlist_transports;
2964   size = optionlist_transports_size;
2965   }
2966 else if (Ustrcmp(type, "authenticator") == 0)
2967   {
2968   d = (driver_instance *)auths;
2969   ol2 = optionlist_auths;
2970   size = optionlist_auths_size;
2971   }
2972
2973 else if (Ustrcmp(type, "macro") == 0)
2974   {
2975   /* People store passwords in macros and they were previously not available
2976   for printing.  So we have an admin_users restriction. */
2977   if (!f.admin_user)
2978     {
2979     fprintf(stderr, "exim: permission denied; not admin\n");
2980     return FALSE;
2981     }
2982   for (macro_item * m = macros; m; m = m->next)
2983     if (!name || Ustrcmp(name, m->name) == 0)
2984       {
2985       if (names_only)
2986         printf("%s\n", CS m->name);
2987       else if (no_labels)
2988         printf("%s\n", CS m->replacement);
2989       else
2990         printf("%s=%s\n", CS m->name, CS m->replacement);
2991       if (name)
2992         return TRUE;
2993       }
2994   if (!name) return TRUE;
2995
2996   printf("%s %s not found\n", type, name);
2997   return FALSE;
2998   }
2999
3000 if (names_only)
3001   {
3002   for (; d; d = d->next) printf("%s\n", CS d->name);
3003   return TRUE;
3004   }
3005
3006 /* Either search for a given driver, or print all of them */
3007
3008 for (; d; d = d->next)
3009   {
3010   BOOL rc = FALSE;
3011   if (!name)
3012     printf("\n%s %s:\n", d->name, type);
3013   else if (Ustrcmp(d->name, name) != 0) continue;
3014
3015   for (optionlist * ol = ol2; ol < ol2 + size; ol++)
3016     if (!(ol->type & opt_hidden))
3017       rc |= print_ol(ol, US ol->name, d, ol2, size, no_labels);
3018
3019   for (optionlist * ol = d->info->options;
3020        ol < d->info->options + *(d->info->options_count); ol++)
3021     if (!(ol->type & opt_hidden))
3022       rc |= print_ol(ol, US ol->name, d, d->info->options,
3023                     *d->info->options_count, no_labels);
3024
3025   if (name) return rc;
3026   }
3027 if (!name) return TRUE;
3028
3029 printf("%s %s not found\n", type, name);
3030 return FALSE;
3031 }
3032
3033
3034
3035 /*************************************************
3036 *          Read a named list item                *
3037 *************************************************/
3038
3039 /* This function reads a name and a list (i.e. string). The name is used to
3040 save the list in a tree, sorted by its name. Each entry also has a number,
3041 which can be used for caching tests, but if the string contains any expansion
3042 items other than $key, the number is set negative to inhibit caching. This
3043 mechanism is used for domain, host, and address lists that are referenced by
3044 the "+name" syntax.
3045
3046 Arguments:
3047   anchorp     points to the tree anchor
3048   numberp     points to the current number for this tree
3049   max         the maximum number permitted
3050   s           the text of the option line, starting immediately after the name
3051                 of the list type
3052   tname       the name of the list type, for messages
3053   hide        do not output value on "-bP"
3054
3055 Returns:      nothing
3056 */
3057
3058 static void
3059 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
3060   uschar *tname, BOOL hide)
3061 {
3062 BOOL forcecache = FALSE;
3063 uschar *ss;
3064 tree_node *t;
3065 namedlist_block * nb = store_get_perm(sizeof(namedlist_block), FALSE);
3066
3067 if (Ustrncmp(s, "_cache", 6) == 0)
3068   {
3069   forcecache = TRUE;
3070   s += 6;
3071   }
3072
3073 if (!isspace(*s))
3074   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
3075
3076 if (*numberp >= max)
3077  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
3078    tname, max);
3079
3080 Uskip_whitespace(&s);
3081 ss = s;
3082 while (isalnum(*s) || *s == '_') s++;
3083 t = store_get(sizeof(tree_node) + s-ss, ss);
3084 Ustrncpy(t->name, ss, s-ss);
3085 t->name[s-ss] = 0;
3086 Uskip_whitespace(&s);
3087
3088 if (!tree_insertnode(anchorp, t))
3089   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3090     "duplicate name \"%s\" for a named %s", t->name, tname);
3091
3092 t->data.ptr = nb;
3093 nb->number = *numberp;
3094 *numberp += 1;
3095 nb->hide = hide;
3096
3097 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3098   "missing '=' after \"%s\"", t->name);
3099 Uskip_whitespace(&s);
3100 nb->string = read_string(s, t->name);
3101 nb->cache_data = NULL;
3102
3103 /* Check the string for any expansions; if any are found, mark this list
3104 uncacheable unless the user has explicited forced caching. */
3105
3106 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
3107 }
3108
3109
3110
3111
3112 /*************************************************
3113 *        Unpick data for a rate limit            *
3114 *************************************************/
3115
3116 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
3117 separate values.
3118
3119 Arguments:
3120   s            string, in the form t,b,f,l
3121                where t is the threshold (integer)
3122                b is the initial delay (time)
3123                f is the multiplicative factor (fixed point)
3124                k is the maximum time (time)
3125   threshold    where to store threshold
3126   base         where to store base in milliseconds
3127   factor       where to store factor in milliseconds
3128   limit        where to store limit
3129
3130 Returns:       nothing (panics on error)
3131 */
3132
3133 static void
3134 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
3135   int *limit)
3136 {
3137 uschar bstring[16], lstring[16];
3138
3139 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
3140     factor, lstring) == 4)
3141   {
3142   *base = readconf_readtime(bstring, 0, TRUE);
3143   *limit = readconf_readtime(lstring, 0, TRUE);
3144   if (*base >= 0 && *limit >= 0) return;
3145   }
3146 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3147 }
3148
3149
3150
3151
3152 /*************************************************
3153 *         Read main configuration options        *
3154 *************************************************/
3155
3156 /* This function is the first to be called for configuration reading. It
3157 opens the configuration file and reads general configuration settings until
3158 it reaches the end of the configuration section. The file is then left open so
3159 that the remaining configuration data can subsequently be read if needed for
3160 this run of Exim.
3161
3162 The configuration file must be owned either by root or exim, and be writeable
3163 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3164 in the config file, so the test is done on the compiled in values. A slight
3165 anomaly, to be carefully documented.
3166
3167 The name of the configuration file is taken from a list that is included in the
3168 binary of Exim. It can be altered from the command line, but if that is done,
3169 root privilege is immediately withdrawn unless the caller is root or exim.
3170 The first file on the list that exists is used.
3171
3172 For use on multiple systems that share file systems, first look for a
3173 configuration file whose name has the current node name on the end. If that is
3174 not found, try the generic name. For really contorted configurations, that run
3175 multiple Exims with different uid settings, first try adding the effective uid
3176 before the node name. These complications are going to waste resources on most
3177 systems. Therefore they are available only when requested by compile-time
3178 options. */
3179
3180 void
3181 readconf_main(BOOL nowarn)
3182 {
3183 int sep = 0;
3184 struct stat statbuf;
3185 uschar * s, * filename;
3186 const uschar * list = config_main_filelist;
3187
3188 /* Loop through the possible file names */
3189
3190 /* Should never be a tainted list */
3191 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3192   {
3193
3194   /* Cut out all the fancy processing unless specifically wanted */
3195
3196 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3197   uschar *suffix = filename + Ustrlen(filename);
3198
3199   /* Try for the node-specific file if a node name exists */
3200
3201 # ifdef CONFIGURE_FILE_USE_NODE
3202   struct utsname uts;
3203   if (uname(&uts) >= 0)
3204     {
3205 #  ifdef CONFIGURE_FILE_USE_EUID
3206     sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3207     if (!(config_file = Ufopen(filename, "rb")))
3208 #  endif  /* CONFIGURE_FILE_USE_EUID */
3209       {
3210       sprintf(CS suffix, ".%.256s", uts.nodename);
3211       config_file = Ufopen(filename, "rb");
3212       }
3213     }
3214 # endif  /* CONFIGURE_FILE_USE_NODE */
3215
3216   /* Otherwise, try the generic name, possibly with the euid added */
3217
3218 # ifdef CONFIGURE_FILE_USE_EUID
3219   if (!config_file)
3220     {
3221     sprintf(CS suffix, ".%ld", (long int)original_euid);
3222     config_file = Ufopen(filename, "rb");
3223     }
3224 # endif  /* CONFIGURE_FILE_USE_EUID */
3225
3226   /* Finally, try the unadorned name */
3227
3228   if (!config_file)
3229     {
3230     *suffix = 0;
3231     config_file = Ufopen(filename, "rb");
3232     }
3233 #else  /* if neither defined */
3234
3235   /* This is the common case when the fancy processing is not included. */
3236
3237   config_file = Ufopen(filename, "rb");
3238 #endif
3239
3240   /* If the file does not exist, continue to try any others. For any other
3241   error, break out (and die). */
3242
3243   if (config_file || errno != ENOENT) break;
3244   }
3245
3246 /* On success, save the name for verification; config_filename is used when
3247 logging configuration errors (it changes for .included files) whereas
3248 config_main_filename is the name shown by -bP. Failure to open a configuration
3249 file is a serious disaster. */
3250
3251 if (config_file)
3252   {
3253   uschar *last_slash = Ustrrchr(filename, '/');
3254   config_filename = config_main_filename = string_copy(filename);
3255
3256   /* The config_main_directory we need for the $config_dir expansion.
3257   config_main_filename we need for $config_file expansion.
3258   And config_dir is the directory of the current configuration, used for
3259   relative .includes. We do need to know it's name, as we change our working
3260   directory later. */
3261
3262   if (filename[0] == '/')
3263     config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3264   else
3265     {
3266     /* relative configuration file name: working dir + / + basename(filename) */
3267
3268     uschar buf[PATH_MAX];
3269     gstring * g;
3270
3271     if (os_getcwd(buf, PATH_MAX) == NULL)
3272       {
3273       perror("exim: getcwd");
3274       exit(EXIT_FAILURE);
3275       }
3276     g = string_cat(NULL, buf);
3277
3278     /* If the dir does not end with a "/", append one */
3279     if (gstring_last_char(g) != '/')
3280       g = string_catn(g, US"/", 1);
3281
3282     /* If the config file contains a "/", extract the directory part */
3283     if (last_slash)
3284       g = string_catn(g, filename, last_slash - filename);
3285
3286     config_main_directory = string_from_gstring(g);
3287     }
3288   config_directory = config_main_directory;
3289   }
3290 else
3291   if (!filename)
3292     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3293       "%s", config_main_filelist);
3294   else
3295     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
3296       string_open_failed("configuration file %s", filename));
3297
3298 /* Now, once we found and opened our configuration file, we change the directory
3299 to a safe place. Later we change to $spool_directory. */
3300
3301 if (Uchdir("/") < 0)
3302   {
3303   perror("exim: chdir `/': ");
3304   exit(EXIT_FAILURE);
3305   }
3306
3307 /* Check the status of the file we have opened, if we have retained root
3308 privileges and the file isn't /dev/null (which *should* be 0666). */
3309
3310 if (f.trusted_config && Ustrcmp(filename, US"/dev/null"))
3311   {
3312   if (fstat(fileno(config_file), &statbuf) != 0)
3313     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3314       big_buffer);
3315
3316   if (    statbuf.st_uid != root_uid            /* owner not root */
3317 #ifdef CONFIGURE_OWNER
3318        && statbuf.st_uid != config_uid          /* owner not the special one */
3319 #endif
3320      ||                                         /* or */
3321           statbuf.st_gid != root_gid            /* group not root & */
3322 #ifdef CONFIGURE_GROUP
3323        && statbuf.st_gid != config_gid          /* group not the special one */
3324 #endif
3325        && (statbuf.st_mode & 020) != 0          /* group writeable  */
3326      ||                                         /* or */
3327        (statbuf.st_mode & 2) != 0               /* world writeable  */
3328      )
3329     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3330       "wrong owner, group, or mode", big_buffer);
3331
3332   /* Do a dummy store-allocation of a size related to the (toplevel) file size.
3333   This assumes we will need this much storage to handle all the allocations
3334   during startup; it won't help when .include is being used.  When it does, it
3335   will cut down on the number of store blocks (and malloc calls, and sbrk
3336   syscalls).  It also assume we're on the relevant pool. */
3337
3338   if (statbuf.st_size > 8192)
3339     {
3340     rmark r = store_mark();
3341     void * dummy = store_get((int)statbuf.st_size, GET_UNTAINTED);
3342     store_reset(r);
3343     }
3344   }
3345
3346 /* Process the main configuration settings. They all begin with a lower case
3347 letter. If we see something starting with an upper case letter, it is taken as
3348 a macro definition. */
3349
3350 while ((s = get_config_line()))
3351   {
3352   BOOL hide;
3353   uschar * t;
3354
3355   if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3356     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3357       "found unexpected BOM (Byte Order Mark)");
3358
3359   if (isupper(*s))
3360     {
3361     if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE);
3362     continue;
3363     }
3364
3365   t = (hide = Ustrncmp(s, "hide", 4) == 0 && isspace(s[4])) ? s + 5 : s;
3366
3367   if (Ustrncmp(t, "domainlist", 10) == 0)
3368     read_named_list(&domainlist_anchor, &domainlist_count,
3369       MAX_NAMED_LIST, t+10, US"domain list", hide);
3370
3371   else if (Ustrncmp(t, "hostlist", 8) == 0)
3372     read_named_list(&hostlist_anchor, &hostlist_count,
3373       MAX_NAMED_LIST, t+8, US"host list", hide);
3374
3375   else if (Ustrncmp(t, "addresslist", 11) == 0)
3376     read_named_list(&addresslist_anchor, &addresslist_count,
3377       MAX_NAMED_LIST, t+11, US"address list", hide);
3378
3379   else if (Ustrncmp(t, "localpartlist", 13) == 0)
3380     read_named_list(&localpartlist_anchor, &localpartlist_count,
3381       MAX_NAMED_LIST, t+13, US"local part list", hide);
3382
3383   else
3384     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3385       NULL, US"main option \"%s\" unknown");
3386   }
3387
3388
3389 /* If local_sender_retain is set, local_from_check must be unset. */
3390
3391 if (local_sender_retain && local_from_check)
3392   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3393     "local_sender_retain are set; this combination is not allowed");
3394
3395 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3396 wanted. */
3397
3398 if (timezone_string && !*timezone_string) timezone_string = NULL;
3399
3400 /* The max retry interval must not be greater than 24 hours. */
3401
3402 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3403
3404 /* remote_max_parallel must be > 0 */
3405
3406 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3407
3408 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3409 start of a new SMTP message. */
3410
3411 freeze_tell_config = freeze_tell;
3412
3413 /* The primary host name may be required for expansion of spool_directory
3414 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3415 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3416 canonize it. Some people like upper case letters in their host names, so we
3417 don't force the case. */
3418
3419 if (!primary_hostname)
3420   {
3421   const uschar * hostname;
3422   struct utsname uts;
3423
3424   if (uname(&uts) < 0)
3425     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3426   hostname = US uts.nodename;
3427
3428   if (Ustrchr(hostname, '.') == NULL)
3429     {
3430     int af = AF_INET;
3431     struct hostent *hostdata;
3432
3433 #if HAVE_IPV6
3434     if (  !disable_ipv6
3435        && (  !dns_ipv4_lookup
3436           || match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3437             MCL_DOMAIN, TRUE, NULL) != OK))
3438       af = AF_INET6;
3439 #endif
3440
3441     for (;;)
3442       {
3443 #if HAVE_IPV6
3444 # if HAVE_GETIPNODEBYNAME
3445         int error_num;
3446         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3447         #else
3448         hostdata = gethostbyname2(CS hostname, af);
3449 # endif
3450 #else
3451       hostdata = gethostbyname(CS hostname);
3452 #endif
3453
3454       if (hostdata)
3455         { hostname = US hostdata->h_name; break; }
3456
3457       if (af == AF_INET) break;
3458       af = AF_INET;
3459       }
3460     }
3461
3462   primary_hostname = string_copy(hostname);
3463   }
3464
3465 /* Set up default value for smtp_active_hostname */
3466
3467 smtp_active_hostname = primary_hostname;
3468
3469 /* If spool_directory wasn't set in the build-time configuration, it must have
3470 got set above. Of course, writing to the log may not work if log_file_path is
3471 not set, but it will at least get to syslog or somewhere, with any luck. */
3472
3473 if (!*spool_directory)
3474   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3475     "proceed");
3476
3477 /* Expand the spool directory name; it may, for example, contain the primary
3478 host name. Same comment about failure. */
3479
3480 if (!(s = expand_string(spool_directory)))
3481   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3482     "\"%s\": %s", spool_directory, expand_string_message);
3483 spool_directory = s;
3484
3485 /* Expand log_file_path, which must contain "%s" in any component that isn't
3486 the null string or "syslog". It is also allowed to contain one instance of %D
3487 or %M. However, it must NOT contain % followed by anything else. */
3488
3489 if (*log_file_path)
3490   {
3491   const uschar *ss, *sss;
3492   int sep = ':';                       /* Fixed for log file path */
3493   if (!(s = expand_string(log_file_path)))
3494     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3495       "\"%s\": %s", log_file_path, expand_string_message);
3496
3497   ss = s;
3498   /* should never be a tainted list */
3499   while ((sss = string_nextinlist(&ss, &sep, big_buffer, big_buffer_size)))
3500     {
3501     uschar *t;
3502     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3503     if (!(t = Ustrstr(sss, "%s")))
3504       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3505         "contain \"%%s\"", sss);
3506     *t = 'X';
3507     if ((t = Ustrchr(sss, '%')))
3508       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3509         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3510           "unexpected \"%%\" character", s);
3511     }
3512
3513   log_file_path = s;
3514   }
3515
3516 /* Interpret syslog_facility into an integer argument for 'ident' param to
3517 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3518 leading "log_". */
3519
3520 if (syslog_facility_str)
3521   {
3522   int i;
3523   uschar * s = syslog_facility_str;
3524
3525   if ((Ustrlen(syslog_facility_str) >= 4) &&
3526         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3527     s += 4;
3528
3529   for (i = 0; i < syslog_list_size; i++)
3530     if (strcmpic(s, syslog_list[i].name) == 0)
3531       {
3532       syslog_facility = syslog_list[i].value;
3533       break;
3534       }
3535
3536   if (i >= syslog_list_size)
3537     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3538       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3539   }
3540
3541 /* Expand pid_file_path */
3542
3543 if (*pid_file_path)
3544   {
3545   const uschar * t = expand_cstring(pid_file_path);
3546   if (!t)
3547     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3548       "\"%s\": %s", pid_file_path, expand_string_message);
3549   pid_file_path = t;
3550   }
3551
3552 /* Set default value of process_log_path */
3553
3554 if (!process_log_path || !*process_log_path)
3555   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3556
3557 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3558 message. */
3559
3560 regex_From = regex_must_compile(uucp_from_pattern, MCS_NOFLAGS, TRUE);
3561
3562 /* Unpick the SMTP rate limiting options, if set */
3563
3564 if (smtp_ratelimit_mail)
3565   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3566     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3567
3568 if (smtp_ratelimit_rcpt)
3569   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3570     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3571
3572 /* The qualify domains default to the primary host name */
3573
3574 if (!qualify_domain_sender)
3575   qualify_domain_sender = primary_hostname;
3576 if (!qualify_domain_recipient)
3577   qualify_domain_recipient = qualify_domain_sender;
3578
3579 /* Setting system_filter_user in the configuration sets the gid as well if a
3580 name is given, but a numerical value does not. */
3581
3582 if (system_filter_uid_set && !system_filter_gid_set)
3583   {
3584   struct passwd *pw = getpwuid(system_filter_uid);
3585   if (!pw)
3586     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3587       (long int)system_filter_uid);
3588   system_filter_gid = pw->pw_gid;
3589   system_filter_gid_set = TRUE;
3590   }
3591
3592 /* If the errors_reply_to field is set, check that it is syntactically valid
3593 and ensure it contains a domain. */
3594
3595 if (errors_reply_to)
3596   {
3597   uschar *errmess;
3598   int start, end, domain;
3599   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3600     &start, &end, &domain, FALSE);
3601
3602   if (!recipient)
3603     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3604       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3605
3606   if (!domain)
3607     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3608       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3609   }
3610
3611 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3612 smtp_accept_max must also be set. */
3613
3614 if (smtp_accept_max == 0 && (smtp_accept_queue > 0 || smtp_accept_max_per_host))
3615   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3616     "smtp_accept_max must be set if smtp_accept_queue or "
3617     "smtp_accept_max_per_host is set");
3618
3619 /* Set up the host number if anything is specified. It is an expanded string
3620 so that it can be computed from the host name, for example. We do this last
3621 so as to ensure that everything else is set up before the expansion. */
3622
3623 if (host_number_string)
3624   {
3625   long int n;
3626   uschar *end;
3627   uschar *s = expand_string(host_number_string);
3628
3629   if (!s)
3630     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3631         "failed to expand localhost_number \"%s\": %s",
3632         host_number_string, expand_string_message);
3633   n = Ustrtol(s, &end, 0);
3634   if (Uskip_whitespace(&end))
3635     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3636       "localhost_number value is not a number: %s", s);
3637   if (n > LOCALHOST_MAX)
3638     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3639       "localhost_number is greater than the maximum allowed value (%d)",
3640         LOCALHOST_MAX);
3641   host_number = n;
3642   }
3643
3644 #ifndef DISABLE_TLS
3645 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3646
3647 if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
3648   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3649     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3650     tls_verify_hosts ? "" : "try_");
3651
3652 /* Magic number: at time of writing, 1024 has been the long-standing value
3653 used by so many clients, and what Exim used to use always, that it makes
3654 sense to just min-clamp this max-clamp at that. */
3655 if (tls_dh_max_bits < 1024)
3656   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3657       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3658
3659 /* If openssl_options is set, validate it */
3660 if (openssl_options)
3661   {
3662 # ifdef USE_GNUTLS
3663   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3664     "openssl_options is set but we're using GnuTLS");
3665 # else
3666   long dummy;
3667   if (!tls_openssl_options_parse(openssl_options, &dummy))
3668     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3669       "openssl_options parse error: %s", openssl_options);
3670 # endif
3671   }
3672 #endif  /*DISABLE_TLS*/
3673
3674 if (!nowarn && !keep_environment && environ && *environ)
3675   log_write(0, LOG_MAIN,
3676       "Warning: purging the environment.\n"
3677       " Suggested action: use keep_environment.");
3678 }
3679
3680
3681
3682 /*************************************************
3683 *          Initialize one driver                 *
3684 *************************************************/
3685
3686 /* This is called once the driver's generic options, if any, have been read.
3687 We can now find the driver, set up defaults for the private options, and
3688 unset any "set" bits in the private options table (which might have been
3689 set by another incarnation of the same driver).
3690
3691 Arguments:
3692   d                   pointer to driver instance block, with generic
3693                         options filled in
3694   drivers_available   vector of available drivers
3695   size_of_info        size of each block in drivers_available
3696   class               class of driver, for error message
3697
3698 Returns:              pointer to the driver info block
3699 */
3700
3701 static driver_info *
3702 init_driver(driver_instance *d, driver_info *drivers_available,
3703   int size_of_info, uschar *class)
3704 {
3705 for (driver_info * dd = drivers_available; dd->driver_name[0] != 0;
3706      dd = (driver_info *)((US dd) + size_of_info))
3707   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3708     {
3709     int len = dd->options_len;
3710     d->info = dd;
3711     d->options_block = store_get_perm(len, FALSE);
3712     memcpy(d->options_block, dd->options_block, len);
3713     for (int i = 0; i < *(dd->options_count); i++)
3714       dd->options[i].type &= ~opt_set;
3715     return dd;
3716     }
3717
3718 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3719   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3720
3721 return NULL;   /* never obeyed */
3722 }
3723
3724
3725
3726
3727 static void
3728 driver_init_fini(driver_instance * d, const uschar * class)
3729 {
3730 if (!d->driver_name)
3731   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3732     "no driver defined for %s \"%s\"", class, d->name);
3733 (d->info->init)(d);
3734 }
3735
3736
3737 /*************************************************
3738 *             Initialize driver list             *
3739 *************************************************/
3740
3741 /* This function is called for routers, transports, and authentication
3742 mechanisms. It reads the data from the current point in the configuration file
3743 up to the end of the section, and sets up a chain of instance blocks according
3744 to the file's contents. The file will already have been opened by a call to
3745 readconf_main, and must be left open for subsequent reading of further data.
3746
3747 Any errors cause a panic crash. Note that the blocks with names driver_info and
3748 driver_instance must map the first portions of all the _info and _instance
3749 blocks for this shared code to work.
3750
3751 Arguments:
3752   class                      "router", "transport", or "authenticator"
3753   anchor                     &routers, &transports, &auths
3754   drivers_available          available drivers
3755   size_of_info               size of each info block
3756   instance_default           points to default data for an instance
3757   instance_size              size of instance block
3758   driver_optionlist          generic option list
3759   driver_optionlist_count    count of generic option list
3760
3761 Returns:                     nothing
3762 */
3763
3764 void
3765 readconf_driver_init(
3766   uschar *class,
3767   driver_instance **anchor,
3768   driver_info *drivers_available,
3769   int size_of_info,
3770   void *instance_default,
3771   int  instance_size,
3772   optionlist *driver_optionlist,
3773   int  driver_optionlist_count)
3774 {
3775 driver_instance ** p = anchor;
3776 driver_instance * d = NULL;
3777 uschar * buffer;
3778
3779 while ((buffer = get_config_line()))
3780   {
3781   uschar name[EXIM_DRIVERNAME_MAX];
3782   const uschar * s;
3783
3784   /* Read the first name on the line and test for the start of a new driver. A
3785   macro definition indicates the end of the previous driver. If this isn't the
3786   start of a new driver, the line will be re-read. */
3787
3788   s = readconf_readname(name, sizeof(name), buffer);
3789
3790   /* Handle macro definition, first finishing off the initialization of the
3791   previous driver, if any. */
3792
3793   if (isupper(*name) && *s == '=')
3794     {
3795     if (d)
3796       {
3797       /* s is using big_buffer, so this call had better not */
3798       driver_init_fini(d, class);
3799       d = NULL;
3800       }
3801     if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE);
3802     continue;
3803     }
3804
3805   /* If the line starts with a name terminated by a colon, we are at the
3806   start of the definition of a new driver. The rest of the line must be
3807   blank. */
3808
3809   if (*s++ == ':')
3810     {
3811     /* Finish off initializing the previous driver. */
3812
3813     if (d)
3814       driver_init_fini(d, class);
3815
3816     /* Check that we haven't already got a driver of this name */
3817
3818     for (d = *anchor; d; d = d->next)
3819       if (Ustrcmp(name, d->name) == 0)
3820         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3821           "there are two %ss called \"%s\"", class, name);
3822
3823     /* Set up a new driver instance data block on the chain, with
3824     its default values installed. */
3825
3826     d = store_get_perm(instance_size, FALSE);
3827     memcpy(d, instance_default, instance_size);
3828     *p = d;
3829     p = &d->next;
3830     d->name = string_copy(name);
3831     d->srcfile = config_filename;
3832     d->srcline = config_lineno;
3833
3834     /* Clear out the "set" bits in the generic options */
3835
3836     for (int i = 0; i < driver_optionlist_count; i++)
3837       driver_optionlist[i].type &= ~opt_set;
3838
3839     /* Check nothing more on this line, then do the next loop iteration. */
3840
3841     Uskip_whitespace(&s);
3842     if (*s) extra_chars_error(s, US"driver name ", name, US"");
3843     continue;
3844     }
3845
3846   /* Not the start of a new driver. Give an error if we have not set up a
3847   current driver yet. */
3848
3849   if (!d)
3850     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3851
3852   /* First look to see if this is a generic option; if it is "driver",
3853   initialize the driver. If is it not a generic option, we can look for a
3854   private option provided that the driver has been previously set up. */
3855
3856   if (readconf_handle_option(buffer, driver_optionlist,
3857         driver_optionlist_count, d, NULL))
3858     {
3859     if (!d->info && d->driver_name)
3860       init_driver(d, drivers_available, size_of_info, class);
3861     }
3862
3863   /* Handle private options - pass the generic block because some may
3864   live therein. A flag with each option indicates if it is in the public
3865   block. */
3866
3867   else if (d->info)
3868     readconf_handle_option(buffer, d->info->options,
3869       *(d->info->options_count), d, US"option \"%s\" unknown");
3870
3871   /* The option is not generic and the driver name has not yet been given. */
3872
3873   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3874     "(\"driver\" must be specified before any private options)", name);
3875   }
3876
3877 /* Run the initialization function for the final driver. */
3878
3879 if (d)
3880   driver_init_fini(d, class);
3881 }
3882
3883
3884
3885 /*************************************************
3886 *            Check driver dependency             *
3887 *************************************************/
3888
3889 /* This function is passed a driver instance and a string. It checks whether
3890 any of the string options for the driver contains the given string as an
3891 expansion variable.
3892
3893 Arguments:
3894   d        points to a driver instance block
3895   s        the string to search for
3896
3897 Returns:   TRUE if a dependency is found
3898 */
3899
3900 BOOL
3901 readconf_depends(driver_instance *d, uschar *s)
3902 {
3903 int count = *(d->info->options_count);
3904 uschar *ss;
3905
3906 for (optionlist * ol = d->info->options; ol < d->info->options + count; ol++)
3907   if ((ol->type & opt_mask) == opt_stringptr)
3908     {
3909     void * options_block = ol->type & opt_public ? (void *)d : d->options_block;
3910     uschar * value = *USS(US options_block + ol->v.offset);
3911
3912     if (value && (ss = Ustrstr(value, s)) != NULL)
3913       {
3914       if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3915         isalnum(ss[Ustrlen(s)])) continue;
3916       DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3917         d->name, ol->name, s);
3918       return TRUE;
3919       }
3920     }
3921
3922 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3923 return FALSE;
3924 }
3925
3926
3927
3928
3929 /*************************************************
3930 *      Decode an error type for retries          *
3931 *************************************************/
3932
3933 /* This function is global because it is also called from the main
3934 program when testing retry information. It decodes strings such as "quota_7d"
3935 into numerical error codes.
3936
3937 Arguments:
3938   pp           points to start of text
3939   p            points past end of text
3940   basic_errno  points to an int to receive the main error number
3941   more_errno   points to an int to receive the secondary error data
3942
3943 Returns:       NULL if decoded correctly; else points to error text
3944 */
3945
3946 uschar *
3947 readconf_retry_error(const uschar *pp, const uschar *p,
3948   int *basic_errno, int *more_errno)
3949 {
3950 int len;
3951 const uschar *q = pp;
3952 while (q < p && *q != '_') q++;
3953 len = q - pp;
3954
3955 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3956   {
3957   *basic_errno = ERRNO_EXIMQUOTA;
3958   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3959       return US"bad time value";
3960   }
3961
3962 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3963   {
3964   *basic_errno = ECONNREFUSED;
3965   if (q != p)
3966     {
3967     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3968     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3969     else return US"A or MX expected after \"refused\"";
3970     }
3971   }
3972
3973 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3974   {
3975   *basic_errno = ETIMEDOUT;
3976   if (q != p)
3977     {
3978     int i;
3979     int xlen = p - q - 1;
3980     const uschar *x = q + 1;
3981
3982     static uschar *extras[] =
3983       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3984     static int values[] =
3985       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3986
3987     for (i = 0; i < nelem(extras); i++)
3988       if (strncmpic(x, extras[i], xlen) == 0)
3989         {
3990         *more_errno = values[i];
3991         break;
3992         }
3993
3994     if (i >= nelem(extras))
3995       if (strncmpic(x, US"DNS", xlen) == 0)
3996         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3997           "available in retry rules (it has never worked) - treated as "
3998           "\"timeout\"");
3999       else
4000         return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
4001     }
4002   }
4003
4004 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
4005          strncmpic(pp, US"rcpt_4", 6) == 0 ||
4006          strncmpic(pp, US"data_4", 6) == 0)
4007   {
4008   BOOL bad = FALSE;
4009   int x = 255;                           /* means "any 4xx code" */
4010   if (p != pp + 8) bad = TRUE; else
4011     {
4012     int a = pp[6], b = pp[7];
4013     if (isdigit(a))
4014       {
4015       x = (a - '0') * 10;
4016       if (isdigit(b)) x += b - '0';
4017       else if (b == 'x') x += 100;
4018       else bad = TRUE;
4019       }
4020     else if (a != 'x' || b != 'x') bad = TRUE;
4021     }
4022
4023   if (bad)
4024     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
4025       "x is literal and d is any digit", pp);
4026
4027   *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
4028                  *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
4029   *more_errno = x << 8;
4030   }
4031
4032 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
4033          strncmpic(q+1, US"failed", p-q-1) == 0)
4034   *basic_errno = ERRNO_AUTHFAIL;
4035
4036 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
4037   *basic_errno = ERRNO_SMTPCLOSED;
4038
4039 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
4040   *basic_errno = ERRNO_TLSREQUIRED;
4041
4042 else if (strncmpic(pp, US"lookup", p - pp) == 0)
4043   *basic_errno = ERRNO_UNKNOWNHOST;
4044
4045 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4046   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4047
4048 return NULL;
4049 }
4050
4051
4052
4053
4054 /*************************************************
4055 *                Read retry information          *
4056 *************************************************/
4057
4058 /* Each line of retry information contains:
4059
4060 .  A domain name pattern or an address pattern;
4061
4062 .  An error name, possibly with additional data, or *;
4063
4064 .  An optional sequence of retry items, each consisting of an identifying
4065    letter, a cutoff time, and optional parameters.
4066
4067 All this is decoded and placed into a control block. */
4068
4069
4070 /* Subroutine to read an argument, preceded by a comma and terminated
4071 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4072 1 = fixed point number (returned *1000).
4073
4074 Arguments:
4075   paddr     pointer to pointer to current character; updated
4076   type      0 => read a time; 1 => read a fixed point number
4077
4078 Returns:    time in seconds or fixed point number * 1000
4079 */
4080
4081 static int
4082 retry_arg(const uschar ** paddr, int type)
4083 {
4084 const uschar * p = *paddr, * pp;
4085
4086 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4087
4088 Uskip_whitespace(&p);
4089 pp = p;
4090 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4091
4092 if (*p && !isspace(*p) && *p != ',' && *p != ';')
4093   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4094
4095 *paddr = p;
4096 switch (type)
4097   {
4098   case 0: return readconf_readtime(pp, *p, FALSE);
4099   case 1: return readconf_readfixed(pp, *p);
4100   }
4101 return 0;    /* Keep picky compilers happy */
4102 }
4103
4104 /* The function proper */
4105
4106 void
4107 readconf_retries(void)
4108 {
4109 retry_config **chain = &retries;
4110 retry_config *next;
4111 const uschar *p;
4112
4113 while ((p = get_config_line()))
4114   {
4115   retry_rule **rchain;
4116   const uschar *pp;
4117   uschar *error;
4118
4119   next = store_get(sizeof(retry_config), GET_UNTAINTED);
4120   next->next = NULL;
4121   *chain = next;
4122   chain = &(next->next);
4123   next->basic_errno = next->more_errno = 0;
4124   next->senders = NULL;
4125   next->rules = NULL;
4126   rchain = &(next->rules);
4127
4128   next->pattern = string_dequote(&p);
4129   Uskip_whitespace(&p);
4130   pp = p;
4131   while (mac_isgraph(*p)) p++;
4132   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4133     "missing error type in retry rule");
4134
4135   /* Test error names for things we understand. */
4136
4137   if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4138        &next->more_errno)))
4139     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4140
4141   /* There may be an optional address list of senders to be used as another
4142   constraint on the rule. This was added later, so the syntax is a bit of a
4143   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4144   an address list. */
4145
4146   Uskip_whitespace(&p);
4147   if (Ustrncmp(p, "senders", 7) == 0)
4148     {
4149     p += 7;
4150     Uskip_whitespace(&p);
4151     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4152       "\"=\" expected after \"senders\" in retry rule");
4153     Uskip_whitespace(&p);
4154     next->senders = string_dequote(&p);
4155     }
4156
4157   /* Now the retry rules. Keep the maximum timeout encountered. */
4158
4159   Uskip_whitespace(&p);
4160
4161   while (*p)
4162     {
4163     retry_rule * rule = store_get(sizeof(retry_rule), GET_UNTAINTED);
4164     *rchain = rule;
4165     rchain = &(rule->next);
4166     rule->next = NULL;
4167     rule->rule = toupper(*p++);
4168     rule->timeout = retry_arg(&p, 0);
4169     if (rule->timeout > retry_maximum_timeout)
4170       retry_maximum_timeout = rule->timeout;
4171
4172     switch (rule->rule)
4173       {
4174       case 'F':   /* Fixed interval */
4175         rule->p1 = retry_arg(&p, 0);
4176         break;
4177
4178       case 'G':   /* Geometrically increasing intervals */
4179       case 'H':   /* Ditto, but with randomness */
4180         rule->p1 = retry_arg(&p, 0);
4181         rule->p2 = retry_arg(&p, 1);
4182         break;
4183
4184       default:
4185         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4186         break;
4187       }
4188
4189     if (rule->timeout <= 0 || rule->p1 <= 0 ||
4190           (rule->rule != 'F' && rule->p2 < 1000))
4191       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4192         "bad parameters for retry rule");
4193
4194     if (Uskip_whitespace(&p) == ';')
4195       {
4196       p++;
4197       Uskip_whitespace(&p);
4198       }
4199     else if (*p)
4200       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4201     }
4202   }
4203 }
4204
4205
4206
4207 /*************************************************
4208 *         Initialize authenticators              *
4209 *************************************************/
4210
4211 /* Read the authenticators section of the configuration file.
4212
4213 Arguments:   none
4214 Returns:     nothing
4215 */
4216
4217 static void
4218 auths_init(void)
4219 {
4220 #ifndef DISABLE_PIPE_CONNECT
4221 int nauths = 0;
4222 #endif
4223
4224 readconf_driver_init(US"authenticator",
4225   (driver_instance **)(&auths),      /* chain anchor */
4226   (driver_info *)auths_available,    /* available drivers */
4227   sizeof(auth_info),                 /* size of info block */
4228   &auth_defaults,                    /* default values for generic options */
4229   sizeof(auth_instance),             /* size of instance block */
4230   optionlist_auths,                  /* generic options */
4231   optionlist_auths_size);
4232
4233 for (auth_instance * au = auths; au; au = au->next)
4234   {
4235   if (!au->public_name)
4236     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4237       "the %s authenticator", au->name);
4238
4239   for (auth_instance * bu = au->next; bu; bu = bu->next)
4240     if (strcmpic(au->public_name, bu->public_name) == 0)
4241       if (  au->client && bu->client
4242          || au->server && bu->server)
4243         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4244           "(%s and %s) have the same public name (%s)",
4245           au->client && bu->client ? US"client" : US"server",
4246           au->name, bu->name, au->public_name);
4247 #ifndef DISABLE_PIPE_CONNECT
4248   nauths++;
4249 #endif
4250   }
4251 #ifndef DISABLE_PIPE_CONNECT
4252 f.smtp_in_early_pipe_no_auth = nauths > 16;
4253 #endif
4254 }
4255
4256
4257 /* For error messages, a string describing the config location associated
4258 with current processing.  NULL if we are not in an authenticator. */
4259
4260 uschar *
4261 authenticator_current_name(void)
4262 {
4263 if (!authenticator_name) return NULL;
4264 return string_sprintf(" (authenticator %s, %s %d)", authenticator_name, driver_srcfile, driver_srcline);
4265 }
4266
4267
4268
4269
4270
4271 /*************************************************
4272 *             Read ACL information               *
4273 *************************************************/
4274
4275 /* If this run of Exim is not doing something that involves receiving a
4276 message, we can just skip over the ACL information. No need to parse it.
4277
4278 First, we have a function for acl_read() to call back to get the next line. We
4279 need to remember the line we passed, because at the end it will contain the
4280 name of the next ACL. */
4281
4282 static uschar *acl_line;
4283
4284 static uschar *
4285 acl_callback(void)
4286 {
4287 acl_line = get_config_line();
4288 return acl_line;
4289 }
4290
4291
4292 /* Now the main function:
4293
4294 Arguments:    none
4295 Returns:      nothing
4296 */
4297
4298 static void
4299 readconf_acl(void)
4300 {
4301 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4302 between ACLs. */
4303
4304 acl_line = get_config_line();
4305
4306 while(acl_line)
4307   {
4308   uschar name[EXIM_DRIVERNAME_MAX];
4309   tree_node * node;
4310   uschar * error;
4311   const uschar * p = readconf_readname(name, sizeof(name), acl_line);
4312
4313   if (isupper(*name) && *p == '=')
4314     {
4315     if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
4316     acl_line = get_config_line();
4317     continue;
4318     }
4319
4320   if (*p != ':' || name[0] == 0)
4321     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4322
4323   node = store_get_perm(sizeof(tree_node) + Ustrlen(name), name);
4324   Ustrcpy(node->name, name);
4325   if (!tree_insertnode(&acl_anchor, node))
4326     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4327       "there are two ACLs called \"%s\"", name);
4328
4329   node->data.ptr = acl_read(acl_callback, &error);
4330
4331   if (node->data.ptr == NULL && error != NULL)
4332     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4333   }
4334 }
4335
4336
4337
4338 /*************************************************
4339 *     Read configuration for local_scan()        *
4340 *************************************************/
4341
4342 /* This function is called after "begin local_scan" is encountered in the
4343 configuration file. If the local_scan() function allows for configuration
4344 options, we can process them. Otherwise, we expire in a panic.
4345
4346 Arguments:  none
4347 Returns:    nothing
4348 */
4349
4350 static void
4351 local_scan_init(void)
4352 {
4353 #ifndef LOCAL_SCAN_HAS_OPTIONS
4354 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4355   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4356 #else
4357
4358 uschar *p;
4359 while ((p = get_config_line()))
4360   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4361     NULL, US"local_scan option \"%s\" unknown");
4362 #endif
4363 }
4364
4365
4366
4367 /*************************************************
4368 *     Read rest of configuration (after main)    *
4369 *************************************************/
4370
4371 /* This function reads the rest of the runtime configuration, after the main
4372 configuration. It is called only when actually needed. Each subsequent section
4373 of the configuration starts with a line of the form
4374
4375   begin name
4376
4377 where the name is "routers", "transports", etc. A section is terminated by
4378 hitting the next "begin" line, and the next name is left in next_section.
4379 Because it may confuse people as to whether the names are singular or plural,
4380 we add "s" if it's missing. There is always enough room in next_section for
4381 this. This function is basically just a switch.
4382
4383 Arguments:   none
4384 Returns:     nothing
4385 */
4386
4387 static uschar *section_list[] = {
4388   US"acls",
4389   US"authenticators",
4390   US"local_scans",
4391   US"retrys",
4392   US"rewrites",
4393   US"routers",
4394   US"transports"};
4395
4396 void
4397 readconf_rest(void)
4398 {
4399 int had = 0;
4400
4401 while(next_section[0] != 0)
4402   {
4403   int bit;
4404   int first = 0;
4405   int last = nelem(section_list);
4406   int mid = last/2;
4407   int n = Ustrlen(next_section);
4408
4409   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
4410
4411   for (;;)
4412     {
4413     int c = strcmpic(next_section, section_list[mid]);
4414     if (c == 0) break;
4415     if (c > 0) first = mid + 1; else last = mid;
4416     if (first >= last)
4417       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4418         "\"%.*s\" is not a known configuration section name", n, next_section);
4419     mid = (last + first)/2;
4420     }
4421
4422   bit = 1 << mid;
4423   if (((had ^= bit) & bit) == 0)
4424     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4425       "\"%.*s\" section is repeated in the configuration file", n,
4426         next_section);
4427
4428   switch(mid)
4429     {
4430     case 0: readconf_acl(); break;
4431     case 1: auths_init(); break;
4432     case 2: local_scan_init(); break;
4433     case 3: readconf_retries(); break;
4434     case 4: readconf_rewrites(); break;
4435     case 5: route_init(); break;
4436     case 6: transport_init(); break;
4437     }
4438   }
4439
4440 (void)fclose(config_file);
4441 }
4442
4443 /* Init the storage for the pre-parsed config lines */
4444 void
4445 readconf_save_config(const uschar *s)
4446 {
4447 save_config_line(string_sprintf("# Exim Configuration (%s)",
4448   f.running_in_test_harness ? US"X" : s));
4449 }
4450
4451 static void
4452 save_config_position(const uschar *file, int line)
4453 {
4454 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4455 }
4456
4457 /* Append a pre-parsed logical line to the config lines store,
4458 this operates on a global (static) list that holds all the pre-parsed
4459 config lines, we do no further processing here, output formatting and
4460 honouring of <hide> or macros will be done during output */
4461
4462 static void
4463 save_config_line(const uschar* line)
4464 {
4465 static config_line_item *current;
4466 config_line_item *next;
4467
4468 next = (config_line_item*) store_get(sizeof(config_line_item), GET_UNTAINTED);
4469 next->line = string_copy(line);
4470 next->next = NULL;
4471
4472 if (!config_lines) config_lines = next;
4473 else current->next = next;
4474
4475 current = next;
4476 }
4477
4478 /* List the parsed config lines, care about nice formatting and
4479 hide the <hide> values unless we're the admin user */
4480 void
4481 print_config(BOOL admin, BOOL terse)
4482 {
4483 const int TS = terse ? 0 : 2;
4484 int indent = 0;
4485 rmark r = NULL;
4486
4487 for (const config_line_item * i = config_lines; i; i = i->next)
4488   {
4489   uschar * current, * p;
4490
4491   if (r) store_reset(r);
4492   r = store_mark();
4493
4494   /* skip over to the first non-space */
4495   current = string_copy(i->line);
4496   if (!Uskip_whitespace(&current))
4497     continue;
4498
4499   /* Collapse runs of spaces. We stop this if we encounter one of the
4500   following characters: "'$, as this may indicate careful formatting */
4501
4502   for (p = current; *p; p++) if (isspace(*p))
4503     {
4504     uschar * next = p;
4505     if (*p != ' ') *p = ' ';
4506
4507     Uskip_whitespace(&p);
4508
4509     if (next - p > 1)
4510       memmove(p+1, next, Ustrlen(next)+1);
4511
4512     if (*next == '"' || *next == '\'' || *next == '$')
4513       break;
4514     }
4515
4516   /* # lines */
4517   if (current[0] == '#')
4518     puts(CCS current);
4519
4520   /* begin lines are left aligned */
4521   else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4522     {
4523     if (!terse) puts("");
4524     puts(CCS current);
4525     indent = TS;
4526     }
4527
4528   /* router/acl/transport block names */
4529   else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4530     {
4531     if (!terse) puts("");
4532     printf("%*s%s\n", TS, "", current);
4533     indent = 2 * TS;
4534     }
4535
4536   /* hidden lines (all MACROS or lines prefixed with "hide") */
4537   else if (  !admin
4538           && (  isupper(*current)
4539              || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4540              )
4541           )
4542     {
4543     if ((p = Ustrchr(current, '=')))
4544       {
4545       *p = '\0';
4546       printf("%*s%s= %s\n", indent, "", current, CCS hidden);
4547       }
4548     /* e.g.: hide split_spool_directory */
4549     else
4550       printf("%*s\n", indent, CCS hidden);
4551     }
4552
4553   else
4554     /* rest is public */
4555     printf("%*s%s\n", indent, "", current);
4556   }
4557 if (r) store_reset(r);
4558 }
4559
4560 #endif  /*!MACRO_PREDEF*/
4561 /* vi: aw ai sw=2
4562 */
4563 /* End of readconf.c */