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