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