src/src/readconf.c

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