src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2017 */
   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:         nothing
2324 */
2325
2326 static void
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 == NULL)
2340   {
2341   printf("%s is not a known option\n", name);
2342   return;
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) != 0)
2349   {
2350   if (no_labels)
2351     printf("%s\n", hidden);
2352   else
2353     printf("%s = %s\n", name, hidden);
2354   return;
2355   }
2356
2357 /* Else show the value of the option */
2358
2359 value = ol->value;
2360 if (options_block != NULL)
2361   {
2362   if ((ol->type & opt_public) == 0)
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 = *((uschar **)value);
2372   if (!no_labels) printf("%s = ", name);
2373   printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
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     ol2 = find_option(name2, oltop, last);
2449     if (ol2 != NULL)
2450       {
2451       void *value2 = ol2->value;
2452       if (options_block != NULL)
2453         value2 = (void *)(US options_block + (long int)value2);
2454       s = *((uschar **)value2);
2455       if (!no_labels) printf("%s = ", name);
2456       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2457       break;
2458       }
2459     }
2460
2461   /* Else fall through */
2462
2463   case opt_uid:
2464   if (!no_labels) printf("%s = ", name);
2465   if (! *get_set_flag(name, oltop, last, options_block))
2466     printf("\n");
2467   else
2468     {
2469     pw = getpwuid(*((uid_t *)value));
2470     if (pw == NULL)
2471       printf("%ld\n", (long int)(*((uid_t *)value)));
2472     else printf("%s\n", pw->pw_name);
2473     }
2474   break;
2475
2476   /* If the numerical value is unset, try for the string value */
2477
2478   case opt_expand_gid:
2479   if (! *get_set_flag(name, oltop, last, options_block))
2480     {
2481     sprintf(CS name2, "*expand_%.50s", name);
2482     ol2 = find_option(name2, oltop, last);
2483     if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2484       {
2485       void *value2 = ol2->value;
2486       if (options_block != NULL)
2487         value2 = (void *)(US options_block + (long int)value2);
2488       s = *((uschar **)value2);
2489       if (!no_labels) printf("%s = ", name);
2490       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2491       break;
2492       }
2493     }
2494
2495   /* Else fall through */
2496
2497   case opt_gid:
2498   if (!no_labels) printf("%s = ", name);
2499   if (! *get_set_flag(name, oltop, last, options_block))
2500     printf("\n");
2501   else
2502     {
2503     gr = getgrgid(*((int *)value));
2504     if (gr == NULL)
2505        printf("%ld\n", (long int)(*((int *)value)));
2506     else printf("%s\n", gr->gr_name);
2507     }
2508   break;
2509
2510   case opt_uidlist:
2511   uidlist = *((uid_t **)value);
2512   if (!no_labels) printf("%s =", name);
2513   if (uidlist != NULL)
2514     {
2515     int i;
2516     uschar sep = ' ';
2517     if (no_labels) sep = '\0';
2518     for (i = 1; i <= (int)(uidlist[0]); i++)
2519       {
2520       uschar *name = NULL;
2521       pw = getpwuid(uidlist[i]);
2522       if (pw != NULL) name = US pw->pw_name;
2523       if (sep != '\0') printf("%c", sep);
2524       if (name != NULL) printf("%s", name);
2525         else printf("%ld", (long int)(uidlist[i]));
2526       sep = ':';
2527       }
2528     }
2529   printf("\n");
2530   break;
2531
2532   case opt_gidlist:
2533   gidlist = *((gid_t **)value);
2534   if (!no_labels) printf("%s =", name);
2535   if (gidlist != NULL)
2536     {
2537     int i;
2538     uschar sep = ' ';
2539     if (no_labels) sep = '\0';
2540     for (i = 1; i <= (int)(gidlist[0]); i++)
2541       {
2542       uschar *name = NULL;
2543       gr = getgrgid(gidlist[i]);
2544       if (gr != NULL) name = US gr->gr_name;
2545       if (sep != '\0') printf("%c", sep);
2546       if (name != NULL) printf("%s", name);
2547         else printf("%ld", (long int)(gidlist[i]));
2548       sep = ':';
2549       }
2550     }
2551   printf("\n");
2552   break;
2553
2554   case opt_time:
2555   if (!no_labels) printf("%s = ", name);
2556   printf("%s\n", readconf_printtime(*((int *)value)));
2557   break;
2558
2559   case opt_timelist:
2560     {
2561     int i;
2562     int *list = (int *)value;
2563     if (!no_labels) printf("%s = ", name);
2564     for (i = 0; i < list[1]; i++)
2565       printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2566     printf("\n");
2567     }
2568   break;
2569
2570   case opt_bit:
2571   printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2572     "" : "no_", name);
2573   break;
2574
2575   case opt_expand_bool:
2576   sprintf(CS name2, "*expand_%.50s", name);
2577   ol2 = find_option(name2, oltop, last);
2578   if (ol2 != NULL && ol2->value != NULL)
2579     {
2580     void *value2 = ol2->value;
2581     if (options_block != NULL)
2582       value2 = (void *)(US options_block + (long int)value2);
2583     s = *((uschar **)value2);
2584     if (s != NULL)
2585       {
2586       if (!no_labels) printf("%s = ", name);
2587       printf("%s\n", string_printing(s));
2588       break;
2589       }
2590     /* s == NULL => string not set; fall through */
2591     }
2592
2593   /* Fall through */
2594
2595   case opt_bool:
2596   case opt_bool_verify:
2597   case opt_bool_set:
2598   printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2599   break;
2600   }
2601 }
2602
2603
2604
2605 /*************************************************
2606 *        Print value from main configuration     *
2607 *************************************************/
2608
2609 /* This function, called as a result of encountering the -bP option,
2610 causes the value of any main configuration variable to be output if the
2611 second argument is NULL. There are some special values:
2612
2613   all                print all main configuration options
2614   config_file        print the name of the configuration file
2615                      (configure_file will still work, for backward
2616                      compatibility)
2617   routers            print the routers' configurations
2618   transports         print the transports' configuration
2619   authenticators     print the authenticators' configuration
2620   macros             print the macros' configuration
2621   router_list        print a list of router names
2622   transport_list     print a list of transport names
2623   authenticator_list print a list of authentication mechanism names
2624   macro_list         print a list of macro names
2625   +name              print a named list item
2626   local_scan         print the local_scan options
2627   config             print the configuration as it is parsed
2628   environment        print the used execution environment
2629
2630 If the second argument is not NULL, it must be one of "router", "transport",
2631 "authenticator" or "macro" in which case the first argument identifies the
2632 driver whose options are to be printed.
2633
2634 Arguments:
2635   name        option name if type == NULL; else driver name
2636   type        NULL or driver type name, as described above
2637   no_labels   avoid the "foo = " at the start of an item
2638
2639 Returns:      nothing
2640 */
2641
2642 void
2643 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2644 {
2645 BOOL names_only = FALSE;
2646 optionlist *ol;
2647 optionlist *ol2 = NULL;
2648 driver_instance *d = NULL;
2649 macro_item *m;
2650 int size = 0;
2651
2652 if (type == NULL)
2653   {
2654   if (*name == '+')
2655     {
2656     int i;
2657     tree_node *t;
2658     BOOL found = FALSE;
2659     static uschar *types[] = { US"address", US"domain", US"host",
2660       US"localpart" };
2661     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2662       &hostlist_anchor, &localpartlist_anchor };
2663
2664     for (i = 0; i < 4; i++)
2665       {
2666       t = tree_search(*(anchors[i]), name+1);
2667       if (t != NULL)
2668         {
2669         found = TRUE;
2670         if (no_labels)
2671           printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2672         else
2673           printf("%slist %s = %s\n", types[i], name+1,
2674             ((namedlist_block *)(t->data.ptr))->string);
2675         }
2676       }
2677
2678     if (!found)
2679       printf("no address, domain, host, or local part list called \"%s\" "
2680         "exists\n", name+1);
2681
2682     return;
2683     }
2684
2685   if (  Ustrcmp(name, "configure_file") == 0
2686      || Ustrcmp(name, "config_file") == 0)
2687     {
2688     printf("%s\n", CS config_main_filename);
2689     return;
2690     }
2691
2692   if (Ustrcmp(name, "all") == 0)
2693     {
2694     for (ol = optionlist_config;
2695          ol < optionlist_config + nelem(optionlist_config); ol++)
2696       {
2697       if ((ol->type & opt_hidden) == 0)
2698         print_ol(ol, US ol->name, NULL,
2699             optionlist_config, nelem(optionlist_config),
2700             no_labels);
2701       }
2702     return;
2703     }
2704
2705   if (Ustrcmp(name, "local_scan") == 0)
2706     {
2707     #ifndef LOCAL_SCAN_HAS_OPTIONS
2708     printf("local_scan() options are not supported\n");
2709     #else
2710     for (ol = local_scan_options;
2711          ol < local_scan_options + local_scan_options_count; ol++)
2712       {
2713       print_ol(ol, US ol->name, NULL, local_scan_options,
2714         local_scan_options_count, no_labels);
2715       }
2716     #endif
2717     return;
2718     }
2719
2720   if (Ustrcmp(name, "config") == 0)
2721     {
2722     print_config(admin_user, no_labels);
2723     return;
2724     }
2725
2726   if (Ustrcmp(name, "routers") == 0)
2727     {
2728     type = US"router";
2729     name = NULL;
2730     }
2731   else if (Ustrcmp(name, "transports") == 0)
2732     {
2733     type = US"transport";
2734     name = NULL;
2735     }
2736
2737   else if (Ustrcmp(name, "authenticators") == 0)
2738     {
2739     type = US"authenticator";
2740     name = NULL;
2741     }
2742
2743   else if (Ustrcmp(name, "macros") == 0)
2744     {
2745     type = US"macro";
2746     name = NULL;
2747     }
2748
2749   else if (Ustrcmp(name, "router_list") == 0)
2750     {
2751     type = US"router";
2752     name = NULL;
2753     names_only = TRUE;
2754     }
2755
2756   else if (Ustrcmp(name, "transport_list") == 0)
2757     {
2758     type = US"transport";
2759     name = NULL;
2760     names_only = TRUE;
2761     }
2762
2763   else if (Ustrcmp(name, "authenticator_list") == 0)
2764     {
2765     type = US"authenticator";
2766     name = NULL;
2767     names_only = TRUE;
2768     }
2769
2770   else if (Ustrcmp(name, "macro_list") == 0)
2771     {
2772     type = US"macro";
2773     name = NULL;
2774     names_only = TRUE;
2775     }
2776
2777   else if (Ustrcmp(name, "environment") == 0)
2778     {
2779     if (environ)
2780       {
2781       uschar ** p;
2782       for (p = USS environ; *p; p++) ;
2783       qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2784
2785       for (p = USS environ; *p; p++)
2786         {
2787         uschar * q;
2788         if (no_labels && (q = Ustrchr(*p, '='))) *q  = '\0';
2789         puts(CS *p);
2790         }
2791       }
2792     return;
2793     }
2794
2795   else
2796     {
2797     print_ol(find_option(name, optionlist_config, nelem(optionlist_config)),
2798       name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2799     return;
2800     }
2801   }
2802
2803 /* Handle the options for a router or transport. Skip options that are flagged
2804 as hidden. Some of these are options with names starting with '*', used for
2805 internal alternative representations of other options (which the printing
2806 function will sort out). Others are synonyms kept for backward compatibility.
2807 */
2808
2809 if (Ustrcmp(type, "router") == 0)
2810   {
2811   d = (driver_instance *)routers;
2812   ol2 = optionlist_routers;
2813   size = optionlist_routers_size;
2814   }
2815 else if (Ustrcmp(type, "transport") == 0)
2816   {
2817   d = (driver_instance *)transports;
2818   ol2 = optionlist_transports;
2819   size = optionlist_transports_size;
2820   }
2821 else if (Ustrcmp(type, "authenticator") == 0)
2822   {
2823   d = (driver_instance *)auths;
2824   ol2 = optionlist_auths;
2825   size = optionlist_auths_size;
2826   }
2827
2828 else if (Ustrcmp(type, "macro") == 0)
2829   {
2830   /* People store passwords in macros and they were previously not available
2831   for printing.  So we have an admin_users restriction. */
2832   if (!admin_user)
2833     {
2834     fprintf(stderr, "exim: permission denied\n");
2835     exit(EXIT_FAILURE);
2836     }
2837
2838   if (name)
2839     if ((m = macro_search(name)))
2840       macro_print(m->tnode.name, m->tnode.data.ptr, (void *)(long)names_only);
2841     else
2842       printf("%s %s not found\n", type, name);
2843   else
2844     tree_walk(tree_macros, macro_print, (void *)(long)names_only);
2845
2846   return;
2847   }
2848
2849 if (names_only)
2850   {
2851   for (; d; d = d->next) printf("%s\n", CS d->name);
2852   return;
2853   }
2854
2855 /* Either search for a given driver, or print all of them */
2856
2857 for (; d; d = d->next)
2858   {
2859   if (!name)
2860     printf("\n%s %s:\n", d->name, type);
2861   else if (Ustrcmp(d->name, name) != 0)
2862     continue;
2863
2864   for (ol = ol2; ol < ol2 + size; ol++)
2865     if ((ol->type & opt_hidden) == 0)
2866       print_ol(ol, US ol->name, d, ol2, size, no_labels);
2867
2868   for (ol = d->info->options;
2869        ol < d->info->options + *(d->info->options_count); ol++)
2870     if ((ol->type & opt_hidden) == 0)
2871       print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2872
2873   if (name) return;
2874   }
2875 if (name) printf("%s %s not found\n", type, name);
2876 }
2877
2878
2879
2880 /*************************************************
2881 *          Read a named list item                *
2882 *************************************************/
2883
2884 /* This function reads a name and a list (i.e. string). The name is used to
2885 save the list in a tree, sorted by its name. Each entry also has a number,
2886 which can be used for caching tests, but if the string contains any expansion
2887 items other than $key, the number is set negative to inhibit caching. This
2888 mechanism is used for domain, host, and address lists that are referenced by
2889 the "+name" syntax.
2890
2891 Arguments:
2892   anchorp     points to the tree anchor
2893   numberp     points to the current number for this tree
2894   max         the maximum number permitted
2895   s           the text of the option line, starting immediately after the name
2896                 of the list type
2897   tname       the name of the list type, for messages
2898
2899 Returns:      nothing
2900 */
2901
2902 static void
2903 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2904   uschar *tname)
2905 {
2906 BOOL forcecache = FALSE;
2907 uschar *ss;
2908 tree_node *t;
2909 namedlist_block *nb = store_get(sizeof(namedlist_block));
2910
2911 if (Ustrncmp(s, "_cache", 6) == 0)
2912   {
2913   forcecache = TRUE;
2914   s += 6;
2915   }
2916
2917 if (!isspace(*s))
2918   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2919
2920 if (*numberp >= max)
2921  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2922    tname, max);
2923
2924 while (isspace(*s)) s++;
2925 ss = s;
2926 while (isalnum(*s) || *s == '_') s++;
2927 t = store_get(sizeof(tree_node) + s-ss);
2928 Ustrncpy(t->name, ss, s-ss);
2929 t->name[s-ss] = 0;
2930 while (isspace(*s)) s++;
2931
2932 if (!tree_insertnode(anchorp, t))
2933   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2934     "duplicate name \"%s\" for a named %s", t->name, tname);
2935
2936 t->data.ptr = nb;
2937 nb->number = *numberp;
2938 *numberp += 1;
2939
2940 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2941   "missing '=' after \"%s\"", t->name);
2942 while (isspace(*s)) s++;
2943 nb->string = read_string(s, t->name);
2944 nb->cache_data = NULL;
2945
2946 /* Check the string for any expansions; if any are found, mark this list
2947 uncacheable unless the user has explicited forced caching. */
2948
2949 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2950 }
2951
2952
2953
2954
2955 /*************************************************
2956 *        Unpick data for a rate limit            *
2957 *************************************************/
2958
2959 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2960 separate values.
2961
2962 Arguments:
2963   s            string, in the form t,b,f,l
2964                where t is the threshold (integer)
2965                b is the initial delay (time)
2966                f is the multiplicative factor (fixed point)
2967                k is the maximum time (time)
2968   threshold    where to store threshold
2969   base         where to store base in milliseconds
2970   factor       where to store factor in milliseconds
2971   limit        where to store limit
2972
2973 Returns:       nothing (panics on error)
2974 */
2975
2976 static void
2977 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2978   int *limit)
2979 {
2980 uschar bstring[16], lstring[16];
2981
2982 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2983     factor, lstring) == 4)
2984   {
2985   *base = readconf_readtime(bstring, 0, TRUE);
2986   *limit = readconf_readtime(lstring, 0, TRUE);
2987   if (*base >= 0 && *limit >= 0) return;
2988   }
2989 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2990 }
2991
2992
2993
2994
2995 /*************************************************
2996 *       Drop privs for checking TLS config      *
2997 *************************************************/
2998
2999 /* We want to validate TLS options during readconf, but do not want to be
3000 root when we call into the TLS library, in case of library linkage errors
3001 which cause segfaults; before this check, those were always done as the Exim
3002 runtime user and it makes sense to continue with that.
3003
3004 Assumes:  tls_require_ciphers has been set, if it will be
3005           exim_user has been set, if it will be
3006           exim_group has been set, if it will be
3007
3008 Returns:  bool for "okay"; false will cause caller to immediately exit.
3009 */
3010
3011 #ifdef SUPPORT_TLS
3012 static BOOL
3013 tls_dropprivs_validate_require_cipher(BOOL nowarn)
3014 {
3015 const uschar *errmsg;
3016 pid_t pid;
3017 int rc, status;
3018 void (*oldsignal)(int);
3019
3020 /* If TLS will never be used, no point checking ciphers */
3021
3022 if (  !tls_advertise_hosts
3023    || !*tls_advertise_hosts
3024    || Ustrcmp(tls_advertise_hosts, ":") == 0
3025    )
3026   return TRUE;
3027 else if (!nowarn && !tls_certificate)
3028   log_write(0, LOG_MAIN,
3029     "Warning: No server certificate defined; will use a selfsigned one.\n"
3030     " Suggested action: either install a certificate or change tls_advertise_hosts option");
3031
3032 oldsignal = signal(SIGCHLD, SIG_DFL);
3033
3034 fflush(NULL);
3035 if ((pid = fork()) < 0)
3036   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
3037
3038 if (pid == 0)
3039   {
3040   /* in some modes, will have dropped privilege already */
3041   if (!geteuid())
3042     exim_setugid(exim_uid, exim_gid, FALSE,
3043         US"calling tls_validate_require_cipher");
3044
3045   if ((errmsg = tls_validate_require_cipher()))
3046     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3047         "tls_require_ciphers invalid: %s", errmsg);
3048   fflush(NULL);
3049   _exit(0);
3050   }
3051
3052 do {
3053   rc = waitpid(pid, &status, 0);
3054 } while (rc < 0 && errno == EINTR);
3055
3056 DEBUG(D_tls)
3057   debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3058       (int)pid, status);
3059
3060 signal(SIGCHLD, oldsignal);
3061
3062 return status == 0;
3063 }
3064 #endif /* SUPPORT_TLS */
3065
3066
3067
3068
3069 /*************************************************
3070 *         Read main configuration options        *
3071 *************************************************/
3072
3073 /* This function is the first to be called for configuration reading. It
3074 opens the configuration file and reads general configuration settings until
3075 it reaches the end of the configuration section. The file is then left open so
3076 that the remaining configuration data can subsequently be read if needed for
3077 this run of Exim.
3078
3079 The configuration file must be owned either by root or exim, and be writeable
3080 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3081 in the config file, so the test is done on the compiled in values. A slight
3082 anomaly, to be carefully documented.
3083
3084 The name of the configuration file is taken from a list that is included in the
3085 binary of Exim. It can be altered from the command line, but if that is done,
3086 root privilege is immediately withdrawn unless the caller is root or exim.
3087 The first file on the list that exists is used.
3088
3089 For use on multiple systems that share file systems, first look for a
3090 configuration file whose name has the current node name on the end. If that is
3091 not found, try the generic name. For really contorted configurations, that run
3092 multiple Exims with different uid settings, first try adding the effective uid
3093 before the node name. These complications are going to waste resources on most
3094 systems. Therefore they are available only when requested by compile-time
3095 options. */
3096
3097 void
3098 readconf_main(BOOL nowarn)
3099 {
3100 int sep = 0;
3101 struct stat statbuf;
3102 uschar *s, *filename;
3103 const uschar *list = config_main_filelist;
3104
3105 /* Loop through the possible file names */
3106
3107 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3108   {
3109
3110   /* Cut out all the fancy processing unless specifically wanted */
3111
3112   #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3113   uschar *suffix = filename + Ustrlen(filename);
3114
3115   /* Try for the node-specific file if a node name exists */
3116
3117   #ifdef CONFIGURE_FILE_USE_NODE
3118   struct utsname uts;
3119   if (uname(&uts) >= 0)
3120     {
3121     #ifdef CONFIGURE_FILE_USE_EUID
3122     sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3123     config_file = Ufopen(filename, "rb");
3124     if (config_file == NULL)
3125     #endif  /* CONFIGURE_FILE_USE_EUID */
3126       {
3127       sprintf(CS suffix, ".%.256s", uts.nodename);
3128       config_file = Ufopen(filename, "rb");
3129       }
3130     }
3131   #endif  /* CONFIGURE_FILE_USE_NODE */
3132
3133   /* Otherwise, try the generic name, possibly with the euid added */
3134
3135   #ifdef CONFIGURE_FILE_USE_EUID
3136   if (config_file == NULL)
3137     {
3138     sprintf(CS suffix, ".%ld", (long int)original_euid);
3139     config_file = Ufopen(filename, "rb");
3140     }
3141   #endif  /* CONFIGURE_FILE_USE_EUID */
3142
3143   /* Finally, try the unadorned name */
3144
3145   if (config_file == NULL)
3146     {
3147     *suffix = 0;
3148     config_file = Ufopen(filename, "rb");
3149     }
3150   #else  /* if neither defined */
3151
3152   /* This is the common case when the fancy processing is not included. */
3153
3154   config_file = Ufopen(filename, "rb");
3155   #endif
3156
3157   /* If the file does not exist, continue to try any others. For any other
3158   error, break out (and die). */
3159
3160   if (config_file != NULL || errno != ENOENT) break;
3161   }
3162
3163 /* On success, save the name for verification; config_filename is used when
3164 logging configuration errors (it changes for .included files) whereas
3165 config_main_filename is the name shown by -bP. Failure to open a configuration
3166 file is a serious disaster. */
3167
3168 if (config_file)
3169   {
3170   uschar *last_slash = Ustrrchr(filename, '/');
3171   config_filename = config_main_filename = string_copy(filename);
3172
3173   /* The config_main_directory we need for the $config_dir expansion.
3174   config_main_filename we need for $config_file expansion.
3175   And config_dir is the directory of the current configuration, used for
3176   relative .includes. We do need to know it's name, as we change our working
3177   directory later. */
3178
3179   if (filename[0] == '/')
3180     config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3181   else
3182     {
3183       /* relative configuration file name: working dir + / + basename(filename) */
3184
3185       uschar buf[PATH_MAX];
3186       gstring * g;
3187
3188       if (os_getcwd(buf, PATH_MAX) == NULL)
3189         {
3190         perror("exim: getcwd");
3191         exit(EXIT_FAILURE);
3192         }
3193       g = string_cat(NULL, buf);
3194
3195       /* If the dir does not end with a "/", append one */
3196       if (g->s[g->ptr-1] != '/')
3197         g = string_catn(g, US"/", 1);
3198
3199       /* If the config file contains a "/", extract the directory part */
3200       if (last_slash)
3201         g = string_catn(g, filename, last_slash - filename);
3202
3203       config_main_directory = string_from_gstring(g);
3204     }
3205   config_directory = config_main_directory;
3206   }
3207 else
3208   {
3209   if (filename == NULL)
3210     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3211       "%s", config_main_filelist);
3212   else
3213     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3214       "configuration file %s", filename));
3215   }
3216
3217 /* Now, once we found and opened our configuration file, we change the directory
3218 to a safe place. Later we change to $spool_directory. */
3219
3220 if (Uchdir("/") < 0)
3221   {
3222   perror("exim: chdir `/': ");
3223   exit(EXIT_FAILURE);
3224   }
3225
3226 /* Check the status of the file we have opened, if we have retained root
3227 privileges and the file isn't /dev/null (which *should* be 0666). */
3228
3229 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3230   {
3231   if (fstat(fileno(config_file), &statbuf) != 0)
3232     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3233       big_buffer);
3234
3235   if ((statbuf.st_uid != root_uid                /* owner not root */
3236        #ifdef CONFIGURE_OWNER
3237        && statbuf.st_uid != config_uid           /* owner not the special one */
3238        #endif
3239          ) ||                                    /* or */
3240       (statbuf.st_gid != root_gid                /* group not root & */
3241        #ifdef CONFIGURE_GROUP
3242        && statbuf.st_gid != config_gid           /* group not the special one */
3243        #endif
3244        && (statbuf.st_mode & 020) != 0) ||       /* group writeable  */
3245                                                  /* or */
3246       ((statbuf.st_mode & 2) != 0))              /* world writeable  */
3247
3248     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3249       "wrong owner, group, or mode", big_buffer);
3250   }
3251
3252 /* Process the main configuration settings. They all begin with a lower case
3253 letter. If we see something starting with an upper case letter, it is taken as
3254 a macro definition. */
3255
3256 while ((s = get_config_line()))
3257   {
3258   if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3259     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3260       "found unexpected BOM (Byte Order Mark)");
3261
3262   if (isupper(s[0]))
3263     { if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE, US""); }
3264
3265   else if (Ustrncmp(s, "domainlist", 10) == 0)
3266     read_named_list(&domainlist_anchor, &domainlist_count,
3267       MAX_NAMED_LIST, s+10, US"domain list");
3268
3269   else if (Ustrncmp(s, "hostlist", 8) == 0)
3270     read_named_list(&hostlist_anchor, &hostlist_count,
3271       MAX_NAMED_LIST, s+8, US"host list");
3272
3273   else if (Ustrncmp(s, US"addresslist", 11) == 0)
3274     read_named_list(&addresslist_anchor, &addresslist_count,
3275       MAX_NAMED_LIST, s+11, US"address list");
3276
3277   else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3278     read_named_list(&localpartlist_anchor, &localpartlist_count,
3279       MAX_NAMED_LIST, s+13, US"local part list");
3280
3281   else
3282     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3283       NULL, US"main option \"%s\" unknown");
3284   }
3285
3286
3287 /* If local_sender_retain is set, local_from_check must be unset. */
3288
3289 if (local_sender_retain && local_from_check)
3290   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3291     "local_sender_retain are set; this combination is not allowed");
3292
3293 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3294 wanted. */
3295
3296 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3297
3298 /* The max retry interval must not be greater than 24 hours. */
3299
3300 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3301
3302 /* remote_max_parallel must be > 0 */
3303
3304 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3305
3306 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3307 start of a new SMTP message. */
3308
3309 freeze_tell_config = freeze_tell;
3310
3311 /* The primary host name may be required for expansion of spool_directory
3312 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3313 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3314 canonize it. Some people like upper case letters in their host names, so we
3315 don't force the case. */
3316
3317 if (primary_hostname == NULL)
3318   {
3319   const uschar *hostname;
3320   struct utsname uts;
3321   if (uname(&uts) < 0)
3322     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3323   hostname = US uts.nodename;
3324
3325   if (Ustrchr(hostname, '.') == NULL)
3326     {
3327     int af = AF_INET;
3328     struct hostent *hostdata;
3329
3330     #if HAVE_IPV6
3331     if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3332          match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3333             MCL_DOMAIN, TRUE, NULL) != OK))
3334       af = AF_INET6;
3335     #else
3336     af = AF_INET;
3337     #endif
3338
3339     for (;;)
3340       {
3341       #if HAVE_IPV6
3342         #if HAVE_GETIPNODEBYNAME
3343         int error_num;
3344         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3345         #else
3346         hostdata = gethostbyname2(CS hostname, af);
3347         #endif
3348       #else
3349       hostdata = gethostbyname(CS hostname);
3350       #endif
3351
3352       if (hostdata != NULL)
3353         {
3354         hostname = US hostdata->h_name;
3355         break;
3356         }
3357
3358       if (af == AF_INET) break;
3359       af = AF_INET;
3360       }
3361     }
3362
3363   primary_hostname = string_copy(hostname);
3364   }
3365
3366 /* Set up default value for smtp_active_hostname */
3367
3368 smtp_active_hostname = primary_hostname;
3369
3370 /* If spool_directory wasn't set in the build-time configuration, it must have
3371 got set above. Of course, writing to the log may not work if log_file_path is
3372 not set, but it will at least get to syslog or somewhere, with any luck. */
3373
3374 if (*spool_directory == 0)
3375   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3376     "proceed");
3377
3378 /* Expand the spool directory name; it may, for example, contain the primary
3379 host name. Same comment about failure. */
3380
3381 s = expand_string(spool_directory);
3382 if (s == NULL)
3383   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3384     "\"%s\": %s", spool_directory, expand_string_message);
3385 spool_directory = s;
3386
3387 /* Expand log_file_path, which must contain "%s" in any component that isn't
3388 the null string or "syslog". It is also allowed to contain one instance of %D
3389 or %M. However, it must NOT contain % followed by anything else. */
3390
3391 if (*log_file_path != 0)
3392   {
3393   const uschar *ss, *sss;
3394   int sep = ':';                       /* Fixed for log file path */
3395   s = expand_string(log_file_path);
3396   if (s == NULL)
3397     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3398       "\"%s\": %s", log_file_path, expand_string_message);
3399
3400   ss = s;
3401   while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3402     {
3403     uschar *t;
3404     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3405     t = Ustrstr(sss, "%s");
3406     if (t == NULL)
3407       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3408         "contain \"%%s\"", sss);
3409     *t = 'X';
3410     t = Ustrchr(sss, '%');
3411     if (t != NULL)
3412       {
3413       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3414         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3415           "unexpected \"%%\" character", s);
3416       }
3417     }
3418
3419   log_file_path = s;
3420   }
3421
3422 /* Interpret syslog_facility into an integer argument for 'ident' param to
3423 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3424 leading "log_". */
3425
3426 if (syslog_facility_str)
3427   {
3428   int i;
3429   uschar *s = syslog_facility_str;
3430
3431   if ((Ustrlen(syslog_facility_str) >= 4) &&
3432         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3433     s += 4;
3434
3435   for (i = 0; i < syslog_list_size; i++)
3436     if (strcmpic(s, syslog_list[i].name) == 0)
3437       {
3438       syslog_facility = syslog_list[i].value;
3439       break;
3440       }
3441
3442   if (i >= syslog_list_size)
3443     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3444       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3445   }
3446
3447 /* Expand pid_file_path */
3448
3449 if (*pid_file_path != 0)
3450   {
3451   if (!(s = expand_string(pid_file_path)))
3452     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3453       "\"%s\": %s", pid_file_path, expand_string_message);
3454   pid_file_path = s;
3455   }
3456
3457 /* Set default value of process_log_path */
3458
3459 if (!process_log_path || *process_log_path =='\0')
3460   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3461
3462 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3463 message. */
3464
3465 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3466
3467 /* Unpick the SMTP rate limiting options, if set */
3468
3469 if (smtp_ratelimit_mail)
3470   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3471     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3472
3473 if (smtp_ratelimit_rcpt)
3474   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3475     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3476
3477 /* The qualify domains default to the primary host name */
3478
3479 if (!qualify_domain_sender)
3480   qualify_domain_sender = primary_hostname;
3481 if (!qualify_domain_recipient)
3482   qualify_domain_recipient = qualify_domain_sender;
3483
3484 /* Setting system_filter_user in the configuration sets the gid as well if a
3485 name is given, but a numerical value does not. */
3486
3487 if (system_filter_uid_set && !system_filter_gid_set)
3488   {
3489   struct passwd *pw = getpwuid(system_filter_uid);
3490   if (!pw)
3491     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3492       (long int)system_filter_uid);
3493   system_filter_gid = pw->pw_gid;
3494   system_filter_gid_set = TRUE;
3495   }
3496
3497 /* If the errors_reply_to field is set, check that it is syntactically valid
3498 and ensure it contains a domain. */
3499
3500 if (errors_reply_to)
3501   {
3502   uschar *errmess;
3503   int start, end, domain;
3504   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3505     &start, &end, &domain, FALSE);
3506
3507   if (!recipient)
3508     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3509       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3510
3511   if (domain == 0)
3512     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3513       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3514   }
3515
3516 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3517 smtp_accept_max must also be set. */
3518
3519 if (smtp_accept_max == 0 &&
3520     (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3521   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3522     "smtp_accept_max must be set if smtp_accept_queue or "
3523     "smtp_accept_max_per_host is set");
3524
3525 /* Set up the host number if anything is specified. It is an expanded string
3526 so that it can be computed from the host name, for example. We do this last
3527 so as to ensure that everything else is set up before the expansion. */
3528
3529 if (host_number_string)
3530   {
3531   long int n;
3532   uschar *end;
3533   uschar *s = expand_string(host_number_string);
3534
3535   if (!s)
3536     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3537         "failed to expand localhost_number \"%s\": %s",
3538         host_number_string, expand_string_message);
3539   n = Ustrtol(s, &end, 0);
3540   while (isspace(*end)) end++;
3541   if (*end != 0)
3542     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3543       "localhost_number value is not a number: %s", s);
3544   if (n > LOCALHOST_MAX)
3545     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3546       "localhost_number is greater than the maximum allowed value (%d)",
3547         LOCALHOST_MAX);
3548   host_number = n;
3549   }
3550
3551 #ifdef SUPPORT_TLS
3552 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3553
3554 if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
3555   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3556     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3557     tls_verify_hosts ? "" : "try_");
3558
3559 /* This also checks that the library linkage is working and we can call
3560 routines in it, so call even if tls_require_ciphers is unset */
3561 if (!tls_dropprivs_validate_require_cipher(nowarn))
3562   exit(1);
3563
3564 /* Magic number: at time of writing, 1024 has been the long-standing value
3565 used by so many clients, and what Exim used to use always, that it makes
3566 sense to just min-clamp this max-clamp at that. */
3567 if (tls_dh_max_bits < 1024)
3568   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3569       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3570
3571 /* If openssl_options is set, validate it */
3572 if (openssl_options)
3573   {
3574 # ifdef USE_GNUTLS
3575   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3576     "openssl_options is set but we're using GnuTLS");
3577 # else
3578   long dummy;
3579   if (!tls_openssl_options_parse(openssl_options, &dummy))
3580     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3581       "openssl_options parse error: %s", openssl_options);
3582 # endif
3583   }
3584 #endif  /*SUPPORT_TLS*/
3585
3586 if (!nowarn && !keep_environment && environ && *environ)
3587   log_write(0, LOG_MAIN,
3588       "Warning: purging the environment.\n"
3589       " Suggested action: use keep_environment.");
3590 }
3591
3592
3593
3594 /*************************************************
3595 *          Initialize one driver                 *
3596 *************************************************/
3597
3598 /* This is called once the driver's generic options, if any, have been read.
3599 We can now find the driver, set up defaults for the private options, and
3600 unset any "set" bits in the private options table (which might have been
3601 set by another incarnation of the same driver).
3602
3603 Arguments:
3604   d                   pointer to driver instance block, with generic
3605                         options filled in
3606   drivers_available   vector of available drivers
3607   size_of_info        size of each block in drivers_available
3608   class               class of driver, for error message
3609
3610 Returns:              pointer to the driver info block
3611 */
3612
3613 static driver_info *
3614 init_driver(driver_instance *d, driver_info *drivers_available,
3615   int size_of_info, uschar *class)
3616 {
3617 driver_info *dd;
3618
3619 for (dd = drivers_available; dd->driver_name[0] != 0;
3620      dd = (driver_info *)((US dd) + size_of_info))
3621   {
3622   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3623     {
3624     int i;
3625     int len = dd->options_len;
3626     d->info = dd;
3627     d->options_block = store_get(len);
3628     memcpy(d->options_block, dd->options_block, len);
3629     for (i = 0; i < *(dd->options_count); i++)
3630       dd->options[i].type &= ~opt_set;
3631     return dd;
3632     }
3633   }
3634
3635 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3636   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3637
3638 return NULL;   /* never obeyed */
3639 }
3640
3641
3642
3643
3644 /*************************************************
3645 *             Initialize driver list             *
3646 *************************************************/
3647
3648 /* This function is called for routers, transports, and authentication
3649 mechanisms. It reads the data from the current point in the configuration file
3650 up to the end of the section, and sets up a chain of instance blocks according
3651 to the file's contents. The file will already have been opened by a call to
3652 readconf_main, and must be left open for subsequent reading of further data.
3653
3654 Any errors cause a panic crash. Note that the blocks with names driver_info and
3655 driver_instance must map the first portions of all the _info and _instance
3656 blocks for this shared code to work.
3657
3658 Arguments:
3659   class                      "router", "transport", or "authenticator"
3660   anchor                     &routers, &transports, &auths
3661   drivers_available          available drivers
3662   size_of_info               size of each info block
3663   instance_default           points to default data for an instance
3664   instance_size              size of instance block
3665   driver_optionlist          generic option list
3666   driver_optionlist_count    count of generic option list
3667
3668 Returns:                     nothing
3669 */
3670
3671 void
3672 readconf_driver_init(
3673   uschar *class,
3674   driver_instance **anchor,
3675   driver_info *drivers_available,
3676   int size_of_info,
3677   void *instance_default,
3678   int  instance_size,
3679   optionlist *driver_optionlist,
3680   int  driver_optionlist_count)
3681 {
3682 driver_instance **p = anchor;
3683 driver_instance *d = NULL;
3684 uschar *buffer;
3685
3686 while ((buffer = get_config_line()) != NULL)
3687   {
3688   uschar name[64];
3689   uschar *s;
3690
3691   /* Read the first name on the line and test for the start of a new driver. A
3692   macro definition indicates the end of the previous driver. If this isn't the
3693   start of a new driver, the line will be re-read. */
3694
3695   s = readconf_readname(name, sizeof(name), buffer);
3696
3697   /* Handle macro definition, first finishing off the initialization of the
3698   previous driver, if any. */
3699
3700   if (isupper(*name) && *s == '=')
3701     {
3702     if (d)
3703       {
3704       if (!d->driver_name)
3705         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3706           "no driver defined for %s \"%s\"", class, d->name);
3707       (d->info->init)(d);
3708       d = NULL;
3709       }
3710     if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE, US"");
3711     continue;
3712     }
3713
3714   /* If the line starts with a name terminated by a colon, we are at the
3715   start of the definition of a new driver. The rest of the line must be
3716   blank. */
3717
3718   if (*s++ == ':')
3719     {
3720     int i;
3721
3722     /* Finish off initializing the previous driver. */
3723
3724     if (d)
3725       {
3726       if (!d->driver_name)
3727         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3728           "no driver defined for %s \"%s\"", class, d->name);
3729       (d->info->init)(d);
3730       }
3731
3732     /* Check that we haven't already got a driver of this name */
3733
3734     for (d = *anchor; d; d = d->next)
3735       if (Ustrcmp(name, d->name) == 0)
3736         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3737           "there are two %ss called \"%s\"", class, name);
3738
3739     /* Set up a new driver instance data block on the chain, with
3740     its default values installed. */
3741
3742     d = store_get(instance_size);
3743     memcpy(d, instance_default, instance_size);
3744     *p = d;
3745     p = &d->next;
3746     d->name = string_copy(name);
3747
3748     /* Clear out the "set" bits in the generic options */
3749
3750     for (i = 0; i < driver_optionlist_count; i++)
3751       driver_optionlist[i].type &= ~opt_set;
3752
3753     /* Check nothing more on this line, then do the next loop iteration. */
3754
3755     while (isspace(*s)) s++;
3756     if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3757     continue;
3758     }
3759
3760   /* Not the start of a new driver. Give an error if we have not set up a
3761   current driver yet. */
3762
3763   if (!d)
3764     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3765
3766   /* First look to see if this is a generic option; if it is "driver",
3767   initialize the driver. If is it not a generic option, we can look for a
3768   private option provided that the driver has been previously set up. */
3769
3770   if (readconf_handle_option(buffer, driver_optionlist,
3771         driver_optionlist_count, d, NULL))
3772     {
3773     if (!d->info && d->driver_name)
3774       init_driver(d, drivers_available, size_of_info, class);
3775     }
3776
3777   /* Handle private options - pass the generic block because some may
3778   live therein. A flag with each option indicates if it is in the public
3779   block. */
3780
3781   else if (d->info)
3782     readconf_handle_option(buffer, d->info->options,
3783       *(d->info->options_count), d, US"option \"%s\" unknown");
3784
3785   /* The option is not generic and the driver name has not yet been given. */
3786
3787   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3788     "(\"driver\" must be specified before any private options)", name);
3789   }
3790
3791 /* Run the initialization function for the final driver. */
3792
3793 if (d)
3794   {
3795   if (!d->driver_name)
3796     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3797       "no driver defined for %s \"%s\"", class, d->name);
3798   (d->info->init)(d);
3799   }
3800 }
3801
3802
3803
3804 /*************************************************
3805 *            Check driver dependency             *
3806 *************************************************/
3807
3808 /* This function is passed a driver instance and a string. It checks whether
3809 any of the string options for the driver contains the given string as an
3810 expansion variable.
3811
3812 Arguments:
3813   d        points to a driver instance block
3814   s        the string to search for
3815
3816 Returns:   TRUE if a dependency is found
3817 */
3818
3819 BOOL
3820 readconf_depends(driver_instance *d, uschar *s)
3821 {
3822 int count = *(d->info->options_count);
3823 optionlist *ol;
3824 uschar *ss;
3825
3826 for (ol = d->info->options; ol < d->info->options + count; ol++)
3827   {
3828   void *options_block;
3829   uschar *value;
3830   int type = ol->type & opt_mask;
3831   if (type != opt_stringptr) continue;
3832   options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3833   value = *(uschar **)(US options_block + (long int)(ol->value));
3834   if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3835     {
3836     if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3837       isalnum(ss[Ustrlen(s)])) continue;
3838     DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3839       d->name, ol->name, s);
3840     return TRUE;
3841     }
3842   }
3843
3844 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3845 return FALSE;
3846 }
3847
3848
3849
3850
3851 /*************************************************
3852 *      Decode an error type for retries          *
3853 *************************************************/
3854
3855 /* This function is global because it is also called from the main
3856 program when testing retry information. It decodes strings such as "quota_7d"
3857 into numerical error codes.
3858
3859 Arguments:
3860   pp           points to start of text
3861   p            points past end of text
3862   basic_errno  points to an int to receive the main error number
3863   more_errno   points to an int to receive the secondary error data
3864
3865 Returns:       NULL if decoded correctly; else points to error text
3866 */
3867
3868 uschar *
3869 readconf_retry_error(const uschar *pp, const uschar *p,
3870   int *basic_errno, int *more_errno)
3871 {
3872 int len;
3873 const uschar *q = pp;
3874 while (q < p && *q != '_') q++;
3875 len = q - pp;
3876
3877 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3878   {
3879   *basic_errno = ERRNO_EXIMQUOTA;
3880   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3881       return US"bad time value";
3882   }
3883
3884 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3885   {
3886   *basic_errno = ECONNREFUSED;
3887   if (q != p)
3888     {
3889     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3890     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3891     else return US"A or MX expected after \"refused\"";
3892     }
3893   }
3894
3895 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3896   {
3897   *basic_errno = ETIMEDOUT;
3898   if (q != p)
3899     {
3900     int i;
3901     int xlen = p - q - 1;
3902     const uschar *x = q + 1;
3903
3904     static uschar *extras[] =
3905       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3906     static int values[] =
3907       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3908
3909     for (i = 0; i < nelem(extras); i++)
3910       if (strncmpic(x, extras[i], xlen) == 0)
3911         {
3912         *more_errno = values[i];
3913         break;
3914         }
3915
3916     if (i >= nelem(extras))
3917       if (strncmpic(x, US"DNS", xlen) == 0)
3918         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3919           "available in retry rules (it has never worked) - treated as "
3920           "\"timeout\"");
3921       else
3922         return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3923     }
3924   }
3925
3926 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3927          strncmpic(pp, US"rcpt_4", 6) == 0 ||
3928          strncmpic(pp, US"data_4", 6) == 0)
3929   {
3930   BOOL bad = FALSE;
3931   int x = 255;                           /* means "any 4xx code" */
3932   if (p != pp + 8) bad = TRUE; else
3933     {
3934     int a = pp[6], b = pp[7];
3935     if (isdigit(a))
3936       {
3937       x = (a - '0') * 10;
3938       if (isdigit(b)) x += b - '0';
3939       else if (b == 'x') x += 100;
3940       else bad = TRUE;
3941       }
3942     else if (a != 'x' || b != 'x') bad = TRUE;
3943     }
3944
3945   if (bad)
3946     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3947       "x is literal and d is any digit", pp);
3948
3949   *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
3950                  *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3951   *more_errno = x << 8;
3952   }
3953
3954 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3955          strncmpic(q+1, US"failed", p-q-1) == 0)
3956   *basic_errno = ERRNO_AUTHFAIL;
3957
3958 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3959   *basic_errno = ERRNO_SMTPCLOSED;
3960
3961 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3962   *basic_errno = ERRNO_TLSREQUIRED;
3963
3964 else if (strncmpic(pp, US"lookup", p - pp) == 0)
3965   *basic_errno = ERRNO_UNKNOWNHOST;
3966
3967 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3968   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3969
3970 return NULL;
3971 }
3972
3973
3974
3975
3976 /*************************************************
3977 *                Read retry information          *
3978 *************************************************/
3979
3980 /* Each line of retry information contains:
3981
3982 .  A domain name pattern or an address pattern;
3983
3984 .  An error name, possibly with additional data, or *;
3985
3986 .  An optional sequence of retry items, each consisting of an identifying
3987    letter, a cutoff time, and optional parameters.
3988
3989 All this is decoded and placed into a control block. */
3990
3991
3992 /* Subroutine to read an argument, preceded by a comma and terminated
3993 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3994 1 = fixed point number (returned *1000).
3995
3996 Arguments:
3997   paddr     pointer to pointer to current character; updated
3998   type      0 => read a time; 1 => read a fixed point number
3999
4000 Returns:    time in seconds or fixed point number * 1000
4001 */
4002
4003 static int
4004 retry_arg(const uschar **paddr, int type)
4005 {
4006 const uschar *p = *paddr;
4007 const uschar *pp;
4008
4009 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4010
4011 while (isspace(*p)) p++;
4012 pp = p;
4013 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4014
4015 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4016   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4017
4018 *paddr = p;
4019 switch (type)
4020   {
4021   case 0: return readconf_readtime(pp, *p, FALSE);
4022   case 1: return readconf_readfixed(pp, *p);
4023   }
4024 return 0;    /* Keep picky compilers happy */
4025 }
4026
4027 /* The function proper */
4028
4029 void
4030 readconf_retries(void)
4031 {
4032 retry_config **chain = &retries;
4033 retry_config *next;
4034 const uschar *p;
4035
4036 while ((p = get_config_line()))
4037   {
4038   retry_rule **rchain;
4039   const uschar *pp;
4040   uschar *error;
4041
4042   next = store_get(sizeof(retry_config));
4043   next->next = NULL;
4044   *chain = next;
4045   chain = &(next->next);
4046   next->basic_errno = next->more_errno = 0;
4047   next->senders = NULL;
4048   next->rules = NULL;
4049   rchain = &(next->rules);
4050
4051   next->pattern = string_dequote(&p);
4052   while (isspace(*p)) p++;
4053   pp = p;
4054   while (mac_isgraph(*p)) p++;
4055   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4056     "missing error type in retry rule");
4057
4058   /* Test error names for things we understand. */
4059
4060   if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4061        &next->more_errno)))
4062     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4063
4064   /* There may be an optional address list of senders to be used as another
4065   constraint on the rule. This was added later, so the syntax is a bit of a
4066   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4067   an address list. */
4068
4069   while (isspace(*p)) p++;
4070   if (Ustrncmp(p, "senders", 7) == 0)
4071     {
4072     p += 7;
4073     while (isspace(*p)) p++;
4074     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4075       "\"=\" expected after \"senders\" in retry rule");
4076     while (isspace(*p)) p++;
4077     next->senders = string_dequote(&p);
4078     }
4079
4080   /* Now the retry rules. Keep the maximum timeout encountered. */
4081
4082   while (isspace(*p)) p++;
4083
4084   while (*p != 0)
4085     {
4086     retry_rule *rule = store_get(sizeof(retry_rule));
4087     *rchain = rule;
4088     rchain = &(rule->next);
4089     rule->next = NULL;
4090     rule->rule = toupper(*p++);
4091     rule->timeout = retry_arg(&p, 0);
4092     if (rule->timeout > retry_maximum_timeout)
4093       retry_maximum_timeout = rule->timeout;
4094
4095     switch (rule->rule)
4096       {
4097       case 'F':   /* Fixed interval */
4098         rule->p1 = retry_arg(&p, 0);
4099         break;
4100
4101       case 'G':   /* Geometrically increasing intervals */
4102       case 'H':   /* Ditto, but with randomness */
4103         rule->p1 = retry_arg(&p, 0);
4104         rule->p2 = retry_arg(&p, 1);
4105         break;
4106
4107       default:
4108         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4109         break;
4110       }
4111
4112     if (rule->timeout <= 0 || rule->p1 <= 0 ||
4113           (rule->rule != 'F' && rule->p2 < 1000))
4114       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4115         "bad parameters for retry rule");
4116
4117     while (isspace(*p)) p++;
4118     if (*p == ';')
4119       {
4120       p++;
4121       while (isspace(*p)) p++;
4122       }
4123     else if (*p != 0)
4124       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4125     }
4126   }
4127 }
4128
4129
4130
4131 /*************************************************
4132 *         Initialize authenticators              *
4133 *************************************************/
4134
4135 /* Read the authenticators section of the configuration file.
4136
4137 Arguments:   none
4138 Returns:     nothing
4139 */
4140
4141 static void
4142 auths_init(void)
4143 {
4144 auth_instance *au, *bu;
4145
4146 readconf_driver_init(US"authenticator",
4147   (driver_instance **)(&auths),      /* chain anchor */
4148   (driver_info *)auths_available,    /* available drivers */
4149   sizeof(auth_info),                 /* size of info block */
4150   &auth_defaults,                    /* default values for generic options */
4151   sizeof(auth_instance),             /* size of instance block */
4152   optionlist_auths,                  /* generic options */
4153   optionlist_auths_size);
4154
4155 for (au = auths; au; au = au->next)
4156   {
4157   if (!au->public_name)
4158     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4159       "the %s authenticator", au->name);
4160
4161   for (bu = au->next; bu; bu = bu->next)
4162     if (strcmpic(au->public_name, bu->public_name) == 0)
4163       if ((au->client && bu->client) || (au->server && bu->server))
4164         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4165           "(%s and %s) have the same public name (%s)",
4166           au->client ? US"client" : US"server", au->name, bu->name,
4167           au->public_name);
4168   }
4169 }
4170
4171
4172
4173
4174 /*************************************************
4175 *             Read ACL information               *
4176 *************************************************/
4177
4178 /* If this run of Exim is not doing something that involves receiving a
4179 message, we can just skip over the ACL information. No need to parse it.
4180
4181 First, we have a function for acl_read() to call back to get the next line. We
4182 need to remember the line we passed, because at the end it will contain the
4183 name of the next ACL. */
4184
4185 static uschar *acl_line;
4186
4187 static uschar *
4188 acl_callback(void)
4189 {
4190 acl_line = get_config_line();
4191 return acl_line;
4192 }
4193
4194
4195 /* Now the main function:
4196
4197 Arguments:    none
4198 Returns:      nothing
4199 */
4200
4201 static void
4202 readconf_acl(void)
4203 {
4204 uschar *p;
4205
4206 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4207 between ACLs. */
4208
4209 acl_line = get_config_line();
4210
4211 while(acl_line)
4212   {
4213   uschar name[64];
4214   tree_node *node;
4215   uschar *error;
4216
4217   p = readconf_readname(name, sizeof(name), acl_line);
4218   if (isupper(*name) && *p == '=')
4219     {
4220     if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE, US"");
4221     acl_line = get_config_line();
4222     continue;
4223     }
4224
4225   if (*p != ':' || name[0] == 0)
4226     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4227
4228   node = store_get(sizeof(tree_node) + Ustrlen(name));
4229   Ustrcpy(node->name, name);
4230   if (!tree_insertnode(&acl_anchor, node))
4231     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4232       "there are two ACLs called \"%s\"", name);
4233
4234   node->data.ptr = acl_read(acl_callback, &error);
4235
4236   if (node->data.ptr == NULL && error != NULL)
4237     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4238   }
4239 }
4240
4241
4242
4243 /*************************************************
4244 *     Read configuration for local_scan()        *
4245 *************************************************/
4246
4247 /* This function is called after "begin local_scan" is encountered in the
4248 configuration file. If the local_scan() function allows for configuration
4249 options, we can process them. Otherwise, we expire in a panic.
4250
4251 Arguments:  none
4252 Returns:    nothing
4253 */
4254
4255 static void
4256 local_scan_init(void)
4257 {
4258 #ifndef LOCAL_SCAN_HAS_OPTIONS
4259 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4260   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4261 #else
4262
4263 uschar *p;
4264 while ((p = get_config_line()))
4265   {
4266   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4267     NULL, US"local_scan option \"%s\" unknown");
4268   }
4269 #endif
4270 }
4271
4272
4273
4274 /*************************************************
4275 *     Read rest of configuration (after main)    *
4276 *************************************************/
4277
4278 /* This function reads the rest of the runtime configuration, after the main
4279 configuration. It is called only when actually needed. Each subsequent section
4280 of the configuration starts with a line of the form
4281
4282   begin name
4283
4284 where the name is "routers", "transports", etc. A section is terminated by
4285 hitting the next "begin" line, and the next name is left in next_section.
4286 Because it may confuse people as to whether the names are singular or plural,
4287 we add "s" if it's missing. There is always enough room in next_section for
4288 this. This function is basically just a switch.
4289
4290 Arguments:   none
4291 Returns:     nothing
4292 */
4293
4294 static uschar *section_list[] = {
4295   US"acls",
4296   US"authenticators",
4297   US"local_scans",
4298   US"retrys",
4299   US"rewrites",
4300   US"routers",
4301   US"transports"};
4302
4303 void
4304 readconf_rest(void)
4305 {
4306 int had = 0;
4307
4308 while(next_section[0] != 0)
4309   {
4310   int bit;
4311   int first = 0;
4312   int last = nelem(section_list);
4313   int mid = last/2;
4314   int n = Ustrlen(next_section);
4315
4316   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4317
4318   for (;;)
4319     {
4320     int c = strcmpic(next_section, section_list[mid]);
4321     if (c == 0) break;
4322     if (c > 0) first = mid + 1; else last = mid;
4323     if (first >= last)
4324       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4325         "\"%.*s\" is not a known configuration section name", n, next_section);
4326     mid = (last + first)/2;
4327     }
4328
4329   bit = 1 << mid;
4330   if (((had ^= bit) & bit) == 0)
4331     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4332       "\"%.*s\" section is repeated in the configuration file", n,
4333         next_section);
4334
4335   switch(mid)
4336     {
4337     case 0: readconf_acl(); break;
4338     case 1: auths_init(); break;
4339     case 2: local_scan_init(); break;
4340     case 3: readconf_retries(); break;
4341     case 4: readconf_rewrites(); break;
4342     case 5: route_init(); break;
4343     case 6: transport_init(); break;
4344     }
4345   }
4346
4347 (void)fclose(config_file);
4348 }
4349
4350 /* Init the storage for the pre-parsed config lines */
4351 void
4352 readconf_save_config(const uschar *s)
4353 {
4354 save_config_line(string_sprintf("# Exim Configuration (%s)",
4355   running_in_test_harness ? US"X" : s));
4356 }
4357
4358 static void
4359 save_config_position(const uschar *file, int line)
4360 {
4361 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4362 }
4363
4364 /* Append a pre-parsed logical line to the config lines store,
4365 this operates on a global (static) list that holds all the pre-parsed
4366 config lines, we do no further processing here, output formatting and
4367 honouring of <hide> or macros will be done during output */
4368
4369 static void
4370 save_config_line(const uschar* line)
4371 {
4372 static config_line_item *current;
4373 config_line_item *next;
4374
4375 next = (config_line_item*) store_get(sizeof(config_line_item));
4376 next->line = string_copy(line);
4377 next->next = NULL;
4378
4379 if (!config_lines) config_lines = next;
4380 else current->next = next;
4381
4382 current = next;
4383 }
4384
4385 /* List the parsed config lines, care about nice formatting and
4386 hide the <hide> values unless we're the admin user */
4387 void
4388 print_config(BOOL admin, BOOL terse)
4389 {
4390 config_line_item *i;
4391 const int TS = terse ? 0 : 2;
4392 int indent = 0;
4393
4394 for (i = config_lines; i; i = i->next)
4395   {
4396   uschar *current;
4397   uschar *p;
4398
4399   /* skip over to the first non-space */
4400   for (current = i->line; *current && isspace(*current); ++current)
4401     ;
4402
4403   if (*current == '\0')
4404     continue;
4405
4406   /* Collapse runs of spaces. We stop this if we encounter one of the
4407    * following characters: "'$, as this may indicate careful formatting */
4408   for (p = current; *p; ++p)
4409     {
4410     uschar *next;
4411     if (!isspace(*p)) continue;
4412     if (*p != ' ') *p = ' ';
4413
4414     for (next = p; isspace(*next); ++next)
4415       ;
4416
4417     if (next - p > 1)
4418       memmove(p+1, next, Ustrlen(next)+1);
4419
4420     if (*next == '"' || *next == '\'' || *next == '$')
4421       break;
4422     }
4423
4424   /* # lines */
4425   if (current[0] == '#')
4426     puts(CCS current);
4427
4428   /* begin lines are left aligned */
4429   else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4430     {
4431     if (!terse) puts("");
4432     puts(CCS current);
4433     indent = TS;
4434     }
4435
4436   /* router/acl/transport block names */
4437   else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4438     {
4439     if (!terse) puts("");
4440     printf("%*s%s\n", TS, "", current);
4441     indent = 2 * TS;
4442     }
4443
4444   /* hidden lines (all MACROS or lines prefixed with "hide") */
4445   else if (  !admin
4446           && (  isupper(*current)
4447              || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4448              )
4449           )
4450     {
4451     if ((p = Ustrchr(current, '=')))
4452       {
4453       *p = '\0';
4454       printf("%*s%s= %s\n", indent, "", current, hidden);
4455       }
4456     /* e.g.: hide split_spool_directory */
4457     else
4458       printf("%*s\n", indent, hidden);
4459     }
4460
4461   else
4462     /* rest is public */
4463     printf("%*s%s\n", indent, "", current);
4464   }
4465 }
4466
4467 #endif  /*!MACRO_PREDEF*/
4468 /* vi: aw ai sw=2
4469 */
4470 /* End of readconf.c */