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