src/src/readconf.c

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