src/src/readconf.c

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