src/src/readconf.c

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