src/src/readconf.c

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