src/src/readconf.c

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