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