src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
   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 EXPERIMENTAL_XCLIENT
 191   { "hosts_xclient",            opt_stringptr,   {&hosts_xclient} },
 192 #endif
 193 #ifdef LOOKUP_IBASE
 194   { "ibase_servers",            opt_stringptr,   {&ibase_servers} },
 195 #endif
 196   { "ignore_bounce_errors_after", opt_time,      {&ignore_bounce_errors_after} },
 197   { "ignore_fromline_hosts",    opt_stringptr,   {&ignore_fromline_hosts} },
 198   { "ignore_fromline_local",    opt_bool,        {&ignore_fromline_local} },
 199   { "keep_environment",         opt_stringptr,   {&keep_environment} },
 200   { "keep_malformed",           opt_time,        {&keep_malformed} },
 201 #ifdef LOOKUP_LDAP
 202   { "ldap_ca_cert_dir",         opt_stringptr,   {&eldap_ca_cert_dir} },
 203   { "ldap_ca_cert_file",        opt_stringptr,   {&eldap_ca_cert_file} },
 204   { "ldap_cert_file",           opt_stringptr,   {&eldap_cert_file} },
 205   { "ldap_cert_key",            opt_stringptr,   {&eldap_cert_key} },
 206   { "ldap_cipher_suite",        opt_stringptr,   {&eldap_cipher_suite} },
 207   { "ldap_default_servers",     opt_stringptr,   {&eldap_default_servers} },
 208   { "ldap_require_cert",        opt_stringptr,   {&eldap_require_cert} },
 209   { "ldap_start_tls",           opt_bool,        {&eldap_start_tls} },
 210   { "ldap_version",             opt_int,         {&eldap_version} },
 211 #endif
 212 #ifndef DISABLE_ESMTP_LIMITS
 213   { "limits_advertise_hosts", opt_stringptr, {&limits_advertise_hosts} },
 214 #endif
 215   { "local_from_check",         opt_bool,        {&local_from_check} },
 216   { "local_from_prefix",        opt_stringptr,   {&local_from_prefix} },
 217   { "local_from_suffix",        opt_stringptr,   {&local_from_suffix} },
 218   { "local_interfaces",         opt_stringptr,   {&local_interfaces} },
 219 #ifdef HAVE_LOCAL_SCAN
 220   { "local_scan_timeout",       opt_time,        {&local_scan_timeout} },
 221 #endif
 222   { "local_sender_retain",      opt_bool,        {&local_sender_retain} },
 223   { "localhost_number",         opt_stringptr,   {&host_number_string} },
 224   { "log_file_path",            opt_stringptr,   {&log_file_path} },
 225   { "log_selector",             opt_stringptr,   {&log_selector_string} },
 226   { "log_timezone",             opt_bool,        {&log_timezone} },
 227   { "lookup_open_max",          opt_int,         {&lookup_open_max} },
 228   { "max_username_length",      opt_int,         {&max_username_length} },
 229   { "message_body_newlines",    opt_bool,        {&message_body_newlines} },
 230   { "message_body_visible",     opt_mkint,       {&message_body_visible} },
 231   { "message_id_header_domain", opt_stringptr,   {&message_id_domain} },
 232   { "message_id_header_text",   opt_stringptr,   {&message_id_text} },
 233   { "message_logs",             opt_bool,        {&message_logs} },
 234   { "message_size_limit",       opt_stringptr,   {&message_size_limit} },
 235 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
 236   { "move_frozen_messages",     opt_bool,        {&move_frozen_messages} },
 237 #endif
 238   { "mua_wrapper",              opt_bool,        {&mua_wrapper} },
 239 #ifdef LOOKUP_MYSQL
 240   { "mysql_servers",            opt_stringptr,   {&mysql_servers} },
 241 #endif
 242   { "never_users",              opt_uidlist,     {&never_users} },
 243   { "notifier_socket",          opt_stringptr,   {&notifier_socket} },
 244 #ifndef DISABLE_TLS
 245   { "openssl_options",          opt_stringptr,   {&openssl_options} },
 246 #endif
 247 #ifdef LOOKUP_ORACLE
 248   { "oracle_servers",           opt_stringptr,   {&oracle_servers} },
 249 #endif
 250   { "panic_coredump",           opt_bool,        {&panic_coredump} },
 251   { "percent_hack_domains",     opt_stringptr,   {&percent_hack_domains} },
 252 #ifdef EXIM_PERL
 253   { "perl_at_start",            opt_bool,        {&opt_perl_at_start} },
 254   { "perl_startup",             opt_stringptr,   {&opt_perl_startup} },
 255   { "perl_taintmode",           opt_bool,        {&opt_perl_taintmode} },
 256 #endif
 257 #ifdef LOOKUP_PGSQL
 258   { "pgsql_servers",            opt_stringptr,   {&pgsql_servers} },
 259 #endif
 260   { "pid_file_path",            opt_stringptr,   {&pid_file_path} },
 261   { "pipelining_advertise_hosts", opt_stringptr, {&pipelining_advertise_hosts} },
 262 #ifndef DISABLE_PIPE_CONNECT
 263   { "pipelining_connect_advertise_hosts", opt_stringptr,
 264                                                  {&pipe_connect_advertise_hosts} },
 265 #endif
 266 #ifndef DISABLE_PRDR
 267   { "prdr_enable",              opt_bool,        {&prdr_enable} },
 268 #endif
 269   { "preserve_message_logs",    opt_bool,        {&preserve_message_logs} },
 270   { "primary_hostname",         opt_stringptr,   {&primary_hostname} },
 271   { "print_topbitchars",        opt_bool,        {&print_topbitchars} },
 272   { "process_log_path",         opt_stringptr,   {&process_log_path} },
 273   { "prod_requires_admin",      opt_bool,        {&prod_requires_admin} },
 274 #ifdef SUPPORT_PROXY
 275   { "proxy_protocol_timeout",   opt_time,        {&proxy_protocol_timeout} },
 276 #endif
 277   { "qualify_domain",           opt_stringptr,   {&qualify_domain_sender} },
 278   { "qualify_recipient",        opt_stringptr,   {&qualify_domain_recipient} },
 279   { "queue_domains",            opt_stringptr,   {&queue_domains} },
 280 #ifndef DISABLE_QUEUE_RAMP
 281   { "queue_fast_ramp",          opt_bool,        {&queue_fast_ramp} },
 282 #endif
 283   { "queue_list_requires_admin",opt_bool,        {&queue_list_requires_admin} },
 284   { "queue_only",               opt_bool,        {&queue_only} },
 285   { "queue_only_file",          opt_stringptr,   {&queue_only_file} },
 286   { "queue_only_load",          opt_fixed,       {&queue_only_load} },
 287   { "queue_only_load_latch",    opt_bool,        {&queue_only_load_latch} },
 288   { "queue_only_override",      opt_bool,        {&queue_only_override} },
 289   { "queue_run_in_order",       opt_bool,        {&queue_run_in_order} },
 290   { "queue_run_max",            opt_stringptr,   {&queue_run_max} },
 291   { "queue_smtp_domains",       opt_stringptr,   {&queue_smtp_domains} },
 292   { "receive_timeout",          opt_time,        {&receive_timeout} },
 293   { "received_header_text",     opt_stringptr,   {&received_header_text} },
 294   { "received_headers_max",     opt_int,         {&received_headers_max} },
 295   { "recipient_unqualified_hosts", opt_stringptr, {&recipient_unqualified_hosts} },
 296   { "recipients_max",           opt_stringptr,   {&recipients_max} },
 297   { "recipients_max_reject",    opt_bool,        {&recipients_max_reject} },
 298 #ifdef LOOKUP_REDIS
 299   { "redis_servers",            opt_stringptr,   {&redis_servers} },
 300 #endif
 301   { "remote_max_parallel",      opt_int,         {&remote_max_parallel} },
 302   { "remote_sort_domains",      opt_stringptr,   {&remote_sort_domains} },
 303   { "retry_data_expire",        opt_time,        {&retry_data_expire} },
 304   { "retry_interval_max",       opt_time,        {&retry_interval_max} },
 305   { "return_path_remove",       opt_bool,        {&return_path_remove} },
 306   { "return_size_limit",        opt_mkint|opt_hidden, {&bounce_return_size_limit} },
 307   { "rfc1413_hosts",            opt_stringptr,   {&rfc1413_hosts} },
 308   { "rfc1413_query_timeout",    opt_time,        {&rfc1413_query_timeout} },
 309   { "sender_unqualified_hosts", opt_stringptr,   {&sender_unqualified_hosts} },
 310   { "slow_lookup_log",          opt_int,         {&slow_lookup_log} },
 311   { "smtp_accept_keepalive",    opt_bool,        {&smtp_accept_keepalive} },
 312   { "smtp_accept_max",          opt_int,         {&smtp_accept_max} },
 313   { "smtp_accept_max_nonmail",  opt_int,         {&smtp_accept_max_nonmail} },
 314   { "smtp_accept_max_nonmail_hosts", opt_stringptr, {&smtp_accept_max_nonmail_hosts} },
 315   { "smtp_accept_max_per_connection", opt_stringptr,   {&smtp_accept_max_per_connection} },
 316   { "smtp_accept_max_per_host", opt_stringptr,   {&smtp_accept_max_per_host} },
 317   { "smtp_accept_queue",        opt_int,         {&smtp_accept_queue} },
 318   { "smtp_accept_queue_per_connection", opt_int, {&smtp_accept_queue_per_connection} },
 319   { "smtp_accept_reserve",      opt_int,         {&smtp_accept_reserve} },
 320   { "smtp_active_hostname",     opt_stringptr,   {&raw_active_hostname} },
 321   { "smtp_backlog_monitor",     opt_int,         {&smtp_backlog_monitor} },
 322   { "smtp_banner",              opt_stringptr,   {&smtp_banner} },
 323   { "smtp_check_spool_space",   opt_bool,        {&smtp_check_spool_space} },
 324   { "smtp_connect_backlog",     opt_int,         {&smtp_connect_backlog} },
 325   { "smtp_enforce_sync",        opt_bool,        {&smtp_enforce_sync} },
 326   { "smtp_etrn_command",        opt_stringptr,   {&smtp_etrn_command} },
 327   { "smtp_etrn_serialize",      opt_bool,        {&smtp_etrn_serialize} },
 328   { "smtp_load_reserve",        opt_fixed,       {&smtp_load_reserve} },
 329   { "smtp_max_synprot_errors",  opt_int,         {&smtp_max_synprot_errors} },
 330   { "smtp_max_unknown_commands",opt_int,         {&smtp_max_unknown_commands} },
 331   { "smtp_ratelimit_hosts",     opt_stringptr,   {&smtp_ratelimit_hosts} },
 332   { "smtp_ratelimit_mail",      opt_stringptr,   {&smtp_ratelimit_mail} },
 333   { "smtp_ratelimit_rcpt",      opt_stringptr,   {&smtp_ratelimit_rcpt} },
 334   { "smtp_receive_timeout",     opt_func,        {.fn = &fn_smtp_receive_timeout} },
 335   { "smtp_reserve_hosts",       opt_stringptr,   {&smtp_reserve_hosts} },
 336   { "smtp_return_error_details",opt_bool,        {&smtp_return_error_details} },
 337 #ifdef SUPPORT_I18N
 338   { "smtputf8_advertise_hosts", opt_stringptr,   {&smtputf8_advertise_hosts} },
 339 #endif
 340 #ifdef WITH_CONTENT_SCAN
 341   { "spamd_address",            opt_stringptr,   {&spamd_address} },
 342 #endif
 343 #ifdef SUPPORT_SPF
 344   { "spf_guess",                opt_stringptr,   {&spf_guess} },
 345   { "spf_smtp_comment_template",opt_stringptr,   {&spf_smtp_comment_template} },
 346 #endif
 347   { "split_spool_directory",    opt_bool,        {&split_spool_directory} },
 348   { "spool_directory",          opt_stringptr,   {&spool_directory} },
 349   { "spool_wireformat",         opt_bool,        {&spool_wireformat} },
 350 #ifdef LOOKUP_SQLITE
 351   { "sqlite_dbfile",            opt_stringptr,   {&sqlite_dbfile} },
 352   { "sqlite_lock_timeout",      opt_int,         {&sqlite_lock_timeout} },
 353 #endif
 354   { "strict_acl_vars",          opt_bool,        {&strict_acl_vars} },
 355   { "strip_excess_angle_brackets", opt_bool,     {&strip_excess_angle_brackets} },
 356   { "strip_trailing_dot",       opt_bool,        {&strip_trailing_dot} },
 357   { "syslog_duplication",       opt_bool,        {&syslog_duplication} },
 358   { "syslog_facility",          opt_stringptr,   {&syslog_facility_str} },
 359   { "syslog_pid",               opt_bool,        {&syslog_pid} },
 360   { "syslog_processname",       opt_stringptr,   {&syslog_processname} },
 361   { "syslog_timestamp",         opt_bool,        {&syslog_timestamp} },
 362   { "system_filter",            opt_stringptr,   {&system_filter} },
 363   { "system_filter_directory_transport", opt_stringptr,{&system_filter_directory_transport} },
 364   { "system_filter_file_transport",opt_stringptr,{&system_filter_file_transport} },
 365   { "system_filter_group",      opt_gid,         {&system_filter_gid} },
 366   { "system_filter_pipe_transport",opt_stringptr,{&system_filter_pipe_transport} },
 367   { "system_filter_reply_transport",opt_stringptr,{&system_filter_reply_transport} },
 368   { "system_filter_user",       opt_uid,         {&system_filter_uid} },
 369   { "tcp_nodelay",              opt_bool,        {&tcp_nodelay} },
 370 #ifdef USE_TCP_WRAPPERS
 371   { "tcp_wrappers_daemon_name", opt_stringptr,   {&tcp_wrappers_daemon_name} },
 372 #endif
 373   { "timeout_frozen_after",     opt_time,        {&timeout_frozen_after} },
 374   { "timezone",                 opt_stringptr,   {&timezone_string} },
 375   { "tls_advertise_hosts",      opt_stringptr,   {&tls_advertise_hosts} },
 376 #ifndef DISABLE_TLS
 377   { "tls_alpn",                 opt_stringptr,   {&tls_alpn} },
 378   { "tls_certificate",          opt_stringptr,   {&tls_certificate} },
 379   { "tls_crl",                  opt_stringptr,   {&tls_crl} },
 380   { "tls_dh_max_bits",          opt_int,         {&tls_dh_max_bits} },
 381   { "tls_dhparam",              opt_stringptr,   {&tls_dhparam} },
 382   { "tls_eccurve",              opt_stringptr,   {&tls_eccurve} },
 383 # ifndef DISABLE_OCSP
 384   { "tls_ocsp_file",            opt_stringptr,   {&tls_ocsp_file} },
 385 # endif
 386   { "tls_on_connect_ports",     opt_stringptr,   {&tls_in.on_connect_ports} },
 387   { "tls_privatekey",           opt_stringptr,   {&tls_privatekey} },
 388   { "tls_remember_esmtp",       opt_bool,        {&tls_remember_esmtp} },
 389   { "tls_require_ciphers",      opt_stringptr,   {&tls_require_ciphers} },
 390 # ifndef DISABLE_TLS_RESUME
 391   { "tls_resumption_hosts",     opt_stringptr,   {&tls_resumption_hosts} },
 392 # endif
 393   { "tls_try_verify_hosts",     opt_stringptr,   {&tls_try_verify_hosts} },
 394   { "tls_verify_certificates",  opt_stringptr,   {&tls_verify_certificates} },
 395   { "tls_verify_hosts",         opt_stringptr,   {&tls_verify_hosts} },
 396 #endif
 397   { "trusted_groups",           opt_gidlist,     {&trusted_groups} },
 398   { "trusted_users",            opt_uidlist,     {&trusted_users} },
 399   { "unknown_login",            opt_stringptr,   {&unknown_login} },
 400   { "unknown_username",         opt_stringptr,   {&unknown_username} },
 401   { "untrusted_set_sender",     opt_stringptr,   {&untrusted_set_sender} },
 402   { "uucp_from_pattern",        opt_stringptr,   {&uucp_from_pattern} },
 403   { "uucp_from_sender",         opt_stringptr,   {&uucp_from_sender} },
 404   { "warn_message_file",        opt_stringptr,   {&warn_message_file} },
 405   { "write_rejectlog",          opt_bool,        {&write_rejectlog} },
 406 };
 407
 408 #ifndef MACRO_PREDEF
 409 static int optionlist_config_size = nelem(optionlist_config);
 410 #endif
 411
 412
 413 #ifdef MACRO_PREDEF
 414
 415 static void
 416 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags) {/*Dummy*/}
 417
 418 void
 419 options_main(void)
 420 {
 421 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
 422 }
 423
 424 void
 425 options_auths(void)
 426 {
 427 uschar buf[EXIM_DRIVERNAME_MAX];
 428
 429 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
 430
 431 for (struct auth_info * ai = auths_available; ai->driver_name[0]; ai++)
 432   {
 433   spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
 434   builtin_macro_create(buf);
 435   options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
 436
 437   if (ai->macros_create) (ai->macros_create)();
 438   }
 439 }
 440
 441 void
 442 options_logging(void)
 443 {
 444 uschar buf[EXIM_DRIVERNAME_MAX];
 445
 446 for (bit_table * bp = log_options; bp < log_options + log_options_count; bp++)
 447   {
 448   spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
 449   builtin_macro_create(buf);
 450   }
 451 }
 452
 453
 454 #else   /*!MACRO_PREDEF*/
 455
 456 extern char **environ;
 457
 458 static void save_config_line(const uschar* line);
 459 static void save_config_position(const uschar *file, int line);
 460 static void print_config(BOOL admin, BOOL terse);
 461
 462
 463 #define CSTATE_STACK_SIZE 10
 464
 465 const uschar *config_directory = NULL;
 466
 467
 468 /* Structure for chain (stack) of .included files */
 469
 470 typedef struct config_file_item {
 471   struct config_file_item *next;
 472   const uschar *filename;
 473   const uschar *directory;
 474   FILE *file;
 475   int lineno;
 476 } config_file_item;
 477
 478 /* Structure for chain of configuration lines (-bP config) */
 479
 480 typedef struct config_line_item {
 481   struct config_line_item *next;
 482   uschar *line;
 483 } config_line_item;
 484
 485 static config_line_item* config_lines;
 486
 487 /* Structure of table of conditional words and their state transitions */
 488
 489 typedef struct cond_item {
 490   uschar *name;
 491   int    namelen;
 492   int    action1;
 493   int    action2;
 494   int    pushpop;
 495 } cond_item;
 496
 497 /* Structure of table of syslog facility names and values */
 498
 499 typedef struct syslog_fac_item {
 500   uschar *name;
 501   int    value;
 502 } syslog_fac_item;
 503
 504 /* constants */
 505 static const uschar * const hidden = US"<value not displayable>";
 506
 507 /* Static variables */
 508
 509 static config_file_item *config_file_stack = NULL;  /* For includes */
 510
 511 static uschar *syslog_facility_str  = NULL;
 512 static uschar next_section[24];
 513 static uschar time_buffer[24];
 514
 515 /* State variables for conditional loading (.ifdef / .else / .endif) */
 516
 517 static int cstate = 0;
 518 static int cstate_stack_ptr = -1;
 519 static int cstate_stack[CSTATE_STACK_SIZE];
 520
 521 /* Table of state transitions for handling conditional inclusions. There are
 522 four possible state transitions:
 523
 524   .ifdef true
 525   .ifdef false
 526   .elifdef true  (or .else)
 527   .elifdef false
 528
 529 .endif just causes the previous cstate to be popped off the stack */
 530
 531 static int next_cstate[3][4] =
 532   {
 533   /* State 0: reading from file, or reading until next .else or .endif */
 534   { 0, 1, 2, 2 },
 535   /* State 1: condition failed, skipping until next .else or .endif */
 536   { 2, 2, 0, 1 },
 537   /* State 2: skipping until .endif */
 538   { 2, 2, 2, 2 },
 539   };
 540
 541 /* Table of conditionals and the states to set. For each name, there are four
 542 values: the length of the name (to save computing it each time), the state to
 543 set if a macro was found in the line, the state to set if a macro was not found
 544 in the line, and a stack manipulation setting which is:
 545
 546   -1   pull state value off the stack
 547    0   don't alter the stack
 548   +1   push value onto stack, before setting new state
 549 */
 550
 551 static cond_item cond_list[] = {
 552   { US"ifdef",    5, 0, 1,  1 },
 553   { US"ifndef",   6, 1, 0,  1 },
 554   { US"elifdef",  7, 2, 3,  0 },
 555   { US"elifndef", 8, 3, 2,  0 },
 556   { US"else",     4, 2, 2,  0 },
 557   { US"endif",    5, 0, 0, -1 }
 558 };
 559
 560 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
 561
 562 /* Table of syslog facility names and their values */
 563
 564 static syslog_fac_item syslog_list[] = {
 565   { US"mail",   LOG_MAIL },
 566   { US"user",   LOG_USER },
 567   { US"news",   LOG_NEWS },
 568   { US"uucp",   LOG_UUCP },
 569   { US"local0", LOG_LOCAL0 },
 570   { US"local1", LOG_LOCAL1 },
 571   { US"local2", LOG_LOCAL2 },
 572   { US"local3", LOG_LOCAL3 },
 573   { US"local4", LOG_LOCAL4 },
 574   { US"local5", LOG_LOCAL5 },
 575   { US"local6", LOG_LOCAL6 },
 576   { US"local7", LOG_LOCAL7 },
 577   { US"daemon", LOG_DAEMON }
 578 };
 579
 580 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 581
 582
 583 #define opt_fn_print            BIT(0)
 584 #define opt_fn_print_label      BIT(1)
 585
 586
 587 /*************************************************
 588 *         Find the name of an option             *
 589 *************************************************/
 590
 591 /* This function is to aid debugging. Various functions take arguments that are
 592 pointer variables in the options table or in option tables for various drivers.
 593 For debugging output, it is useful to be able to find the name of the option
 594 which is currently being processed. This function finds it, if it exists, by
 595 searching the table(s).
 596
 597 Arguments:   a value that is presumed to be in the table above
 598 Returns:     the option name, or an empty string
 599 */
 600
 601 uschar *
 602 readconf_find_option(void *p)
 603 {
 604 for (int i = 0; i < nelem(optionlist_config); i++)
 605   if (p == optionlist_config[i].v.value) return US optionlist_config[i].name;
 606
 607 for (router_instance * r = routers; r; r = r->next)
 608   {
 609   router_info *ri = r->info;
 610   for (int i = 0; i < *ri->options_count; i++)
 611     {
 612     if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
 613     if (p == CS (r->options_block) + ri->options[i].v.offset)
 614       return US ri->options[i].name;
 615     }
 616   }
 617
 618 for (transport_instance * t = transports; t; t = t->next)
 619   {
 620   transport_info *ti = t->info;
 621   for (int i = 0; i < *ti->options_count; i++)
 622     {
 623     optionlist * op = &ti->options[i];
 624     if ((op->type & opt_mask) != opt_stringptr) continue;
 625     if (p == (  op->type & opt_public
 626              ? CS t
 627              : CS t->options_block
 628              )
 629              + op->v.offset)
 630         return US op->name;
 631     }
 632   }
 633
 634 return US"";
 635 }
 636
 637
 638
 639
 640 /*************************************************
 641 *       Deal with an assignment to a macro       *
 642 *************************************************/
 643
 644 /* We have a new definition; append to the list.
 645
 646 Args:
 647  name   Name of the macro; will be copied
 648  val    Expansion result for the macro; will be copied
 649 */
 650
 651 macro_item *
 652 macro_create(const uschar * name, const uschar * val, BOOL command_line)
 653 {
 654 macro_item * m = store_get(sizeof(macro_item), GET_UNTAINTED);
 655
 656 READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
 657 m->next = NULL;
 658 m->command_line = command_line;
 659 m->namelen = Ustrlen(name);
 660 m->replen = Ustrlen(val);
 661 m->name = string_copy(name);
 662 m->replacement = string_copy(val);
 663 if (mlast)
 664   mlast->next = m;
 665 else
 666   macros = m;
 667 mlast = m;
 668 if (!macros_user)
 669   macros_user = m;
 670 return m;
 671 }
 672
 673
 674 /* This function is called when a line that starts with an upper case letter is
 675 encountered. The argument "line" should contain a complete logical line, and
 676 start with the first letter of the macro name. The macro name and the
 677 replacement text are extracted and stored. Redefinition of existing,
 678 non-command line, macros is permitted using '==' instead of '='.
 679
 680 Arguments:
 681   s            points to the start of the logical line
 682
 683 Returns:       FALSE iff fatal error
 684 */
 685
 686 BOOL
 687 macro_read_assignment(uschar *s)
 688 {
 689 uschar name[EXIM_DRIVERNAME_MAX];
 690 int namelen = 0;
 691 BOOL redef = FALSE;
 692 macro_item *m;
 693
 694 while (isalnum(*s) || *s == '_')
 695   {
 696   if (namelen >= sizeof(name) - 1)
 697     {
 698     log_write(0, LOG_PANIC|LOG_CONFIG_IN,
 699       "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
 700     return FALSE;
 701     }
 702   name[namelen++] = *s++;
 703   }
 704 name[namelen] = 0;
 705
 706 Uskip_whitespace(&s);
 707 if (*s++ != '=')
 708   {
 709   log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
 710   return FALSE;
 711   }
 712
 713 if (*s == '=')
 714   {
 715   redef = TRUE;
 716   s++;
 717   }
 718 Uskip_whitespace(&s);
 719
 720 /* If an existing macro of the same name was defined on the command line, we
 721 just skip this definition. It's an error to attempt to redefine a macro without
 722 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
 723 It is also an error to define a macro whose name begins with the name of a
 724 previously defined macro.  This is the requirement that make using a tree
 725 for macros hard; we must check all macros for the substring.  Perhaps a
 726 sorted list, and a bsearch, would work?
 727 Note: it is documented that the other way round works. */
 728
 729 for (m = macros; m; m = m->next)
 730   {
 731   if (Ustrcmp(m->name, name) == 0)
 732     {
 733     if (!m->command_line && !redef)
 734       {
 735       log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
 736        "defined (use \"==\" if you want to redefine it)", name);
 737       return FALSE;
 738       }
 739     break;
 740     }
 741
 742   if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
 743     {
 744     log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
 745       "a macro because previously defined macro \"%s\" is a substring",
 746       name, m->name);
 747     return FALSE;
 748     }
 749
 750   /* We cannot have this test, because it is documented that a substring
 751   macro is permitted (there is even an example).
 752   *
 753   * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
 754   *   log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
 755   *     "a macro because it is a substring of previously defined macro \"%s\"",
 756   *     name, m->name);
 757   */
 758   }
 759
 760 /* Check for an overriding command-line definition. */
 761
 762 if (m && m->command_line) return TRUE;
 763
 764 /* Redefinition must refer to an existing macro. */
 765
 766 if (redef)
 767   if (m)
 768     {
 769     m->replen = Ustrlen(s);
 770     m->replacement = string_copy(s);
 771     }
 772   else
 773     {
 774     log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
 775       "\"%s\"", name);
 776     return FALSE;
 777     }
 778
 779 /* We have a new definition. */
 780 else
 781   (void) macro_create(name, s, FALSE);
 782 return TRUE;
 783 }
 784
 785
 786
 787
 788
 789 /* Process line for macros. The line is in big_buffer starting at offset len.
 790 Expand big_buffer if needed.  Handle definitions of new macros, and
 791 macro expansions, rewriting the line in the buffer.
 792
 793 Arguments:
 794  len            Offset in buffer of start of line
 795  newlen         Pointer to offset of end of line, updated on return
 796  macro_found    Pointer to return that a macro was expanded
 797
 798 Return: pointer to first nonblank char in line
 799 */
 800
 801 uschar *
 802 macros_expand(int len, int * newlen, BOOL * macro_found)
 803 {
 804 uschar * ss = big_buffer + len;
 805 uschar * s;
 806
 807 /* Find the true start of the physical line - leading spaces are always
 808 ignored. */
 809
 810 Uskip_whitespace(&ss);
 811
 812 /* Process the physical line for macros. If this is the start of the logical
 813 line, skip over initial text at the start of the line if it starts with an
 814 upper case character followed by a sequence of name characters and an equals
 815 sign, because that is the definition of a new macro, and we don't do
 816 replacement therein. */
 817
 818 s = ss;
 819 if (len == 0 && isupper(*s))
 820   {
 821   while (isalnum(*s) || *s == '_') s++;
 822   if (Uskip_whitespace(&s) != '=') s = ss;          /* Not a macro definition */
 823   }
 824
 825 /* Skip leading chars which cannot start a macro name, to avoid multiple
 826 pointless rescans in Ustrstr calls. */
 827
 828 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
 829
 830 /* For each defined macro, scan the line (from after XXX= if present),
 831 replacing all occurrences of the macro. */
 832
 833 *macro_found = FALSE;
 834 if (*s) for (macro_item * m = *s == '_' ? macros : macros_user; m; m = m->next)
 835   {
 836   uschar * p, *pp;
 837   uschar * t;
 838
 839   while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
 840   if (!*s) break;
 841
 842   t = s;
 843   while ((p = Ustrstr(t, m->name)) != NULL)
 844     {
 845     int moveby;
 846
 847     READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
 848       m->name, (int) Ustrlen(ss)-1, ss);
 849     /* Expand the buffer if necessary */
 850
 851     while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
 852       {
 853       int newsize = big_buffer_size + BIG_BUFFER_SIZE;
 854       uschar *newbuffer = store_malloc(newsize);
 855       memcpy(newbuffer, big_buffer, *newlen + 1);
 856       p = newbuffer  + (p - big_buffer);
 857       s = newbuffer  + (s - big_buffer);
 858       ss = newbuffer + (ss - big_buffer);
 859       t = newbuffer  + (t - big_buffer);
 860       big_buffer_size = newsize;
 861       store_free(big_buffer);
 862       big_buffer = newbuffer;
 863       }
 864
 865     /* Shuffle the remaining characters up or down in the buffer before
 866     copying in the replacement text. Don't rescan the replacement for this
 867     same macro. */
 868
 869     pp = p + m->namelen;
 870     if ((moveby = m->replen - m->namelen) != 0)
 871       {
 872       memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
 873       *newlen += moveby;
 874       }
 875     Ustrncpy(p, m->replacement, m->replen);
 876     t = p + m->replen;
 877     while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
 878     *macro_found = TRUE;
 879     }
 880   }
 881
 882 /* An empty macro replacement at the start of a line could mean that ss no
 883 longer points to the first non-blank character. */
 884
 885 Uskip_whitespace(&ss);
 886 return ss;
 887 }
 888
 889 /*************************************************
 890 *            Read configuration line             *
 891 *************************************************/
 892
 893 /* A logical line of text is read from the configuration file into the big
 894 buffer, taking account of macros, .includes, and continuations. The size of
 895 big_buffer is increased if necessary. The count of configuration lines is
 896 maintained. Physical input lines starting with # (ignoring leading white space,
 897 and after macro replacement) and empty logical lines are always ignored.
 898 Leading and trailing spaces are removed.
 899
 900 If we hit a line of the form "begin xxxx", the xxxx is placed in the
 901 next_section vector, and the function returns NULL, indicating the end of a
 902 configuration section. On end-of-file, NULL is returned with next_section
 903 empty.
 904
 905 Arguments:      none
 906
 907 Returns:        a pointer to the first non-blank in the line,
 908                 or NULL if eof or end of section is reached
 909 */
 910
 911 static uschar *
 912 get_config_line(void)
 913 {
 914 int startoffset = 0;         /* To first non-blank char in logical line */
 915 int len = 0;                 /* Of logical line so far */
 916 int newlen;
 917 uschar *s, *ss;
 918 BOOL macro_found;
 919
 920 /* Loop for handling continuation lines, skipping comments, and dealing with
 921 .include files. */
 922
 923 for (;;)
 924   {
 925   if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
 926     {
 927     if (config_file_stack != NULL)    /* EOF inside .include */
 928       {
 929       (void)fclose(config_file);
 930       config_file = config_file_stack->file;
 931       config_filename = config_file_stack->filename;
 932       config_directory = config_file_stack->directory;
 933       config_lineno = config_file_stack->lineno;
 934       config_file_stack = config_file_stack->next;
 935       if (config_lines)
 936         save_config_position(config_filename, config_lineno);
 937       continue;
 938       }
 939
 940     /* EOF at top level */
 941
 942     if (cstate_stack_ptr >= 0)
 943       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
 944         "Unexpected end of configuration file: .endif missing");
 945
 946     if (len != 0) break;        /* EOF after continuation */
 947     next_section[0] = 0;        /* EOF at start of logical line */
 948     return NULL;
 949     }
 950
 951   config_lineno++;
 952   newlen = len + Ustrlen(big_buffer + len);
 953
 954   if (config_lines && config_lineno == 1)
 955     save_config_position(config_filename, config_lineno);
 956
 957   /* Handle pathologically long physical lines - yes, it did happen - by
 958   extending big_buffer at this point. The code also copes with very long
 959   logical lines. */
 960
 961   while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
 962     {
 963     uschar *newbuffer;
 964     big_buffer_size += BIG_BUFFER_SIZE;
 965     newbuffer = store_malloc(big_buffer_size);
 966
 967     /* This use of strcpy is OK because we know that the string in the old
 968     buffer is shorter than the new buffer. */
 969
 970     Ustrcpy(newbuffer, big_buffer);
 971     store_free(big_buffer);
 972     big_buffer = newbuffer;
 973     if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
 974       break;
 975     newlen += Ustrlen(big_buffer + newlen);
 976     }
 977
 978   ss = macros_expand(len, &newlen, &macro_found);
 979
 980   /* Check for comment lines - these are physical lines. */
 981
 982   if (*ss == '#') continue;
 983
 984   /* Handle conditionals, which are also applied to physical lines. Conditions
 985   are of the form ".ifdef ANYTEXT" and are treated as true if any macro
 986   expansion occurred on the rest of the line. A preliminary test for the leading
 987   '.' saves effort on most lines. */
 988
 989   if (*ss == '.')
 990     {
 991     int i;
 992
 993     /* Search the list of conditional directives */
 994
 995     for (i = 0; i < cond_list_size; i++)
 996       {
 997       int n;
 998       cond_item *c = cond_list+i;
 999       if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
1000
1001       /* The following character must be white space or end of string */
1002
1003       n = ss[1 + c->namelen];
1004       if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
1005
1006       /* .ifdef and .ifndef push the current state onto the stack, then set
1007       a new one from the table. Stack overflow is an error */
1008
1009       if (c->pushpop > 0)
1010         {
1011         if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
1012           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1013             ".%s nested too deeply", c->name);
1014         cstate_stack[++cstate_stack_ptr] = cstate;
1015         cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
1016         }
1017
1018       /* For any of the others, stack underflow is an error. The next state
1019       comes either from the stack (.endif) or from the table. */
1020
1021       else
1022         {
1023         if (cstate_stack_ptr < 0)
1024           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1025             ".%s without matching .ifdef", c->name);
1026         cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
1027           next_cstate[cstate][macro_found? c->action1 : c->action2];
1028         }
1029
1030       /* Having dealt with a directive, break the loop */
1031
1032       break;
1033       }
1034
1035     /* If we have handled a conditional directive, continue with the next
1036     physical line. Otherwise, fall through. */
1037
1038     if (i < cond_list_size) continue;
1039     }
1040
1041   /* If the conditional state is not 0 (actively using these lines), ignore
1042   this input line. */
1043
1044   if (cstate != 0) continue;  /* Conditional skip */
1045
1046   /* Handle .include lines - these are also physical lines. */
1047
1048   if (Ustrncmp(ss, ".include", 8) == 0 &&
1049        (isspace(ss[8]) ||
1050          (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
1051     {
1052     uschar *t;
1053     int include_if_exists = isspace(ss[8]) ? 0 : 10;
1054     config_file_item *save;
1055     struct stat statbuf;
1056
1057     ss += 9 + include_if_exists;
1058     Uskip_whitespace(&ss);
1059     t = ss + Ustrlen(ss);
1060     while (t > ss && isspace(t[-1])) t--;
1061     if (*ss == '\"' && t[-1] == '\"')
1062       {
1063       ss++;
1064       t--;
1065       }
1066     *t = 0;
1067
1068     /* We allow relative file names. For security reasons currently
1069     relative names not allowed with .include_if_exists. For .include_if_exists
1070     we need to check the permissions/ownership of the containing folder */
1071     if (*ss != '/')
1072       if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
1073           "absolute path \"%s\"", ss);
1074       else
1075         {
1076         gstring * g = string_append(NULL, 3, config_directory, "/", ss);
1077         ss = string_from_gstring(g);
1078         }
1079
1080     if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1081
1082     if (config_lines)
1083       save_config_position(config_filename, config_lineno);
1084     save = store_get(sizeof(config_file_item), GET_UNTAINTED);
1085     save->next = config_file_stack;
1086     config_file_stack = save;
1087     save->file = config_file;
1088     save->filename = config_filename;
1089     save->directory = config_directory;
1090     save->lineno = config_lineno;
1091
1092     if (!(config_file = Ufopen(ss, "rb")))
1093       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1094         "configuration file %s", ss);
1095
1096     config_filename = string_copy(ss);
1097     config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1098     config_lineno = 0;
1099     continue;
1100     }
1101
1102   /* If this is the start of the logical line, remember where the non-blank
1103   data starts. Otherwise shuffle down continuation lines to remove leading
1104   white space. */
1105
1106   if (len == 0)
1107     startoffset = ss - big_buffer;
1108   else
1109     {
1110     s = big_buffer + len;
1111     if (ss > s)
1112       {
1113       memmove(s, ss, (newlen - len) -  (ss - s) + 1);
1114       newlen -= ss - s;
1115       }
1116     }
1117
1118   /* Accept the new addition to the line. Remove trailing white space. */
1119
1120   len = newlen;
1121   while (len > 0 && isspace(big_buffer[len-1])) len--;
1122   big_buffer[len] = 0;
1123
1124   /* We are done if the line does not end in backslash and contains some data.
1125   Empty logical lines are ignored. For continuations, remove the backslash and
1126   go round the loop to read the continuation line. */
1127
1128   if (len > 0)
1129     {
1130     if (big_buffer[len-1] != '\\') break;   /* End of logical line */
1131     big_buffer[--len] = 0;                  /* Remove backslash */
1132     }
1133   }     /* Loop for reading multiple physical lines */
1134
1135 /* We now have a logical line. Test for the end of a configuration section (or,
1136 more accurately, for the start of the next section). Place the name of the next
1137 section in next_section, and return NULL. If the name given is longer than
1138 next_section, truncate it. It will be unrecognized later, because all the known
1139 section names do fit. Leave space for pluralizing. */
1140
1141 s = big_buffer + startoffset;            /* First non-space character */
1142
1143 if (config_lines)
1144   save_config_line(s);
1145
1146 if (strncmpic(s, US"begin ", 6) == 0)
1147   {
1148   s += 6;
1149   Uskip_whitespace(&s);
1150   if (big_buffer + len - s > sizeof(next_section) - 2)
1151     s[sizeof(next_section) - 2] = 0;
1152   Ustrcpy(next_section, s);
1153   return NULL;
1154   }
1155
1156 /* Return the first non-blank character. */
1157
1158 return s;
1159 }
1160
1161
1162
1163 /*************************************************
1164 *             Read a name                        *
1165 *************************************************/
1166
1167 /* The yield is the pointer to the next uschar. Names longer than the
1168 output space are silently truncated. This function is also used from acl.c when
1169 parsing ACLs.
1170
1171 Arguments:
1172   name      where to put the name
1173   len       length of name
1174   s         input pointer
1175
1176 Returns:    new input pointer
1177 */
1178
1179 const uschar *
1180 readconf_readname(uschar * name, int len, const uschar * s)
1181 {
1182 int p = 0;
1183 BOOL broken = FALSE;
1184
1185 if (isalpha(Uskip_whitespace(&s)))
1186   while (isalnum(*s) || *s == '_')
1187     {
1188     if (p < len-1) name[p++] = *s;
1189     else {
1190       broken = TRUE;
1191       break;
1192     }
1193     s++;
1194     }
1195
1196 name[p] = 0;
1197 if (broken) {
1198   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1199             "exim item name too long (>%d), unable to use \"%s\" (truncated)",
1200             len, name);
1201 }
1202 Uskip_whitespace(&s);
1203 return s;
1204 }
1205
1206
1207
1208
1209 /*************************************************
1210 *          Read a time value                     *
1211 *************************************************/
1212
1213 /* This function is also called from outside, to read argument
1214 time values. The format of a time value is:
1215
1216   [<n>w][<n>d][<n>h][<n>m][<n>s]
1217
1218 as long as at least one is present. If a format error is encountered,
1219 return a negative value. The value must be terminated by the given
1220 terminator.
1221
1222 Arguments:
1223   s             input pointer
1224   terminator    required terminating character
1225   return_msec   if TRUE, allow fractional seconds and return milliseconds
1226
1227 Returns:        the time value, or -1 on syntax error
1228                 value is seconds if return_msec is FALSE
1229                 value is milliseconds if return_msec is TRUE
1230 */
1231
1232 int
1233 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1234 {
1235 int yield = 0;
1236 for (;;)
1237   {
1238   int value, count;
1239   double fraction;
1240
1241   if (!isdigit(*s)) return -1;
1242   (void)sscanf(CCS s, "%d%n", &value, &count);
1243   s += count;
1244
1245   switch (*s)
1246     {
1247     case 'w': value *= 7;
1248     case 'd': value *= 24;
1249     case 'h': value *= 60;
1250     case 'm': value *= 60;
1251     case 's': s++;
1252     break;
1253
1254     case '.':
1255     if (!return_msec) return -1;
1256     (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1257     s += count;
1258     if (*s++ != 's') return -1;
1259     yield += (int)(fraction * 1000.0);
1260     break;
1261
1262     default: return -1;
1263     }
1264
1265   if (return_msec) value *= 1000;
1266   yield += value;
1267   if (*s == terminator) return yield;
1268   }
1269 /* Control never reaches here. */
1270 }
1271
1272
1273
1274 /*************************************************
1275 *          Read a fixed point value              *
1276 *************************************************/
1277
1278 /* The value is returned *1000
1279
1280 Arguments:
1281   s           input pointer
1282   terminator  required terminator
1283
1284 Returns:      the value, or -1 on error
1285 */
1286
1287 static int
1288 readconf_readfixed(const uschar *s, int terminator)
1289 {
1290 int yield = 0;
1291 int value, count;
1292 if (!isdigit(*s)) return -1;
1293 (void)sscanf(CS  s, "%d%n", &value, &count);
1294 s += count;
1295 yield = value * 1000;
1296 if (*s == '.')
1297   {
1298   int m = 100;
1299   while (isdigit((*(++s))))
1300     {
1301     yield += (*s - '0') * m;
1302     m /= 10;
1303     }
1304   }
1305
1306 return (*s == terminator)? yield : (-1);
1307 }
1308
1309
1310
1311 /*************************************************
1312 *            Find option in list                 *
1313 *************************************************/
1314
1315 /* The lists are always in order, so binary chop can be used.
1316
1317 Arguments:
1318   name      the option name to search for
1319   ol        the first entry in the option list
1320   last      one more than the offset of the last entry in the option list
1321
1322 Returns:    pointer to an option entry, or NULL if not found
1323 */
1324
1325 static optionlist *
1326 find_option(const uschar *name, optionlist *ol, int last)
1327 {
1328 int first = 0;
1329 while (last > first)
1330   {
1331   int middle = (first + last)/2;
1332   int c = Ustrcmp(name, ol[middle].name);
1333
1334   if (c == 0) return ol + middle;
1335   else if (c > 0) first = middle + 1;
1336   else last = middle;
1337   }
1338 return NULL;
1339 }
1340
1341
1342
1343 /*************************************************
1344 *      Find a set flag in option list            *
1345 *************************************************/
1346
1347 /* Because some versions of Unix make no restrictions on the values of uids and
1348 gids (even negative ones), we cannot represent "unset" by a special value.
1349 There is therefore a separate boolean variable for each one indicating whether
1350 a value is set or not. This function returns a pointer to the boolean, given
1351 the original option name. It is a major disaster if the flag cannot be found.
1352
1353 Arguments:
1354   name          the name of the uid or gid option
1355   oltop         points to the start of the relevant option list
1356   last          one more than the offset of the last item in the option list
1357   data_block    NULL when reading main options => data values in the option
1358                   list are absolute addresses; otherwise they are byte offsets
1359                   in data_block (used for driver options)
1360
1361 Returns:        a pointer to the boolean flag.
1362 */
1363
1364 static BOOL *
1365 get_set_flag(const uschar *name, optionlist *oltop, int last, void *data_block)
1366 {
1367 optionlist *ol;
1368 uschar name2[EXIM_DRIVERNAME_MAX];
1369 sprintf(CS name2, "*set_%.50s", name);
1370 if (!(ol = find_option(name2, oltop, last)))
1371   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1372     "Exim internal error: missing set flag for %s", name);
1373 return data_block
1374   ? (BOOL *)(US data_block + ol->v.offset) : (BOOL *)ol->v.value;
1375 }
1376
1377
1378
1379
1380 /*************************************************
1381 *    Output extra characters message and die     *
1382 *************************************************/
1383
1384 /* Called when an option line has junk on the end. Sometimes this is because
1385 the sysadmin thinks comments are permitted.
1386
1387 Arguments:
1388   s          points to the extra characters
1389   t1..t3     strings to insert in the log message
1390
1391 Returns:     doesn't return; dies
1392 */
1393
1394 static void
1395 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1396 {
1397 uschar *comment = US"";
1398 if (*s == '#') comment = US" (# is comment only at line start)";
1399 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1400   "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1401 }
1402
1403
1404
1405 /*************************************************
1406 *              Read rewrite information          *
1407 *************************************************/
1408
1409 /* Each line of rewrite information contains:
1410
1411 .  A complete address in the form user@domain, possibly with
1412    leading * for each part; or alternatively, a regex.
1413
1414 .  A replacement string (which will be expanded).
1415
1416 .  An optional sequence of one-letter flags, indicating which
1417    headers etc. to apply this rule to.
1418
1419 All this is decoded and placed into a control block. The OR of the flags is
1420 maintained in a common word.
1421
1422 Arguments:
1423   p           points to the string that makes up the rule
1424   existflags  points to the overall flag word
1425   isglobal    TRUE if reading global rewrite rules
1426
1427 Returns:      the control block for the parsed rule.
1428 */
1429
1430 static rewrite_rule *
1431 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1432 {
1433 rewrite_rule * next = store_get(sizeof(rewrite_rule), GET_UNTAINTED);
1434
1435 next->next = NULL;
1436 next->key = string_dequote(&p);
1437
1438 Uskip_whitespace(&p);
1439 if (!*p)
1440   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1441     "missing rewrite replacement string");
1442
1443 next->flags = 0;
1444 next->replacement = string_dequote(&p);
1445
1446 while (*p) switch (*p++)
1447   {
1448   case ' ': case '\t': break;
1449
1450   case 'q': next->flags |= rewrite_quit; break;
1451   case 'w': next->flags |= rewrite_whole; break;
1452
1453   case 'h': next->flags |= rewrite_all_headers; break;
1454   case 's': next->flags |= rewrite_sender; break;
1455   case 'f': next->flags |= rewrite_from; break;
1456   case 't': next->flags |= rewrite_to;   break;
1457   case 'c': next->flags |= rewrite_cc;   break;
1458   case 'b': next->flags |= rewrite_bcc;  break;
1459   case 'r': next->flags |= rewrite_replyto; break;
1460
1461   case 'E': next->flags |= rewrite_all_envelope; break;
1462   case 'F': next->flags |= rewrite_envfrom; break;
1463   case 'T': next->flags |= rewrite_envto; break;
1464
1465   case 'Q': next->flags |= rewrite_qualify; break;
1466   case 'R': next->flags |= rewrite_repeat; break;
1467
1468   case 'S':
1469   next->flags |= rewrite_smtp;
1470   if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1471     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1472       "rewrite rule has the S flag but is not a regular expression");
1473   break;
1474
1475   default:
1476   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1477     "unknown rewrite flag character '%c' "
1478     "(could be missing quotes round replacement item)", p[-1]);
1479   break;
1480   }
1481
1482 /* If no action flags are set, set all the "normal" rewrites. */
1483
1484 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1485   next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1486
1487 /* Remember which exist, for optimization, and return the rule */
1488
1489 *existflags |= next->flags;
1490 return next;
1491 }
1492
1493
1494
1495
1496 /*************************************************
1497 *          Read global rewrite information       *
1498 *************************************************/
1499
1500 /* Each line is a single rewrite rule; it is parsed into a control block
1501 by readconf_one_rewrite(), and its flags are ORed into the global flag
1502 word rewrite_existflags. */
1503
1504 void
1505 readconf_rewrites(void)
1506 {
1507 rewrite_rule **chain = &global_rewrite_rules;
1508 uschar *p;
1509
1510 while ((p = get_config_line()) != NULL)
1511   {
1512   rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1513   *chain = next;
1514   chain = &(next->next);
1515   }
1516 }
1517
1518
1519
1520 /*************************************************
1521 *               Read a string                    *
1522 *************************************************/
1523
1524 /* Strings are read into the normal store pool. As long we aren't too
1525 near the end of the current block, the string will just use what is necessary
1526 on the top of the stacking pool, because string_cat() uses the extension
1527 mechanism.
1528
1529 Argument:
1530   s         the rest of the input line
1531   name      the option name (for errors)
1532
1533 Returns:    pointer to the string
1534 */
1535
1536 static uschar *
1537 read_string(const uschar *s, const uschar *name)
1538 {
1539 uschar *yield;
1540 const uschar *ss;
1541
1542 if (*s != '\"') return string_copy(s);
1543
1544 ss = s;
1545 yield = string_dequote(&s);
1546
1547 if (s == ss+1 || s[-1] != '\"')
1548   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1549     "missing quote at end of string value for %s", name);
1550
1551 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1552
1553 return yield;
1554 }
1555
1556
1557 /*************************************************
1558 *            Custom-handler options              *
1559 *************************************************/
1560 static void
1561 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags)
1562 {
1563 if (flags & opt_fn_print)
1564   {
1565   if (flags & opt_fn_print_label) printf("%s = ", name);
1566   printf("%s\n", smtp_receive_timeout_s
1567     ? string_printing2(smtp_receive_timeout_s, SP_TAB)
1568     : readconf_printtime(smtp_receive_timeout));
1569   }
1570 else if (*str == '$')
1571   smtp_receive_timeout_s = string_copy(str);
1572 else
1573   {
1574   /* "smtp_receive_timeout",     opt_time,        &smtp_receive_timeout */
1575   smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1576   if (smtp_receive_timeout < 0)
1577     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1578       name);
1579   }
1580 }
1581
1582 /*************************************************
1583 *            Handle option line                  *
1584 *************************************************/
1585
1586 /* This function is called from several places to process a line containing the
1587 setting of an option. The first argument is the line to be decoded; it has been
1588 checked not to be empty and not to start with '#'. Trailing newlines and white
1589 space have been removed. The second argument is a pointer to the list of
1590 variable names that are to be recognized, together with their types and
1591 locations, and the third argument gives the number of entries in the list.
1592
1593 The fourth argument is a pointer to a data block. If it is NULL, then the data
1594 values in the options list are absolute addresses. Otherwise, they are byte
1595 offsets in the data block.
1596
1597 String option data may continue onto several lines; this function reads further
1598 data from config_file if necessary.
1599
1600 The yield of this function is normally zero. If a string continues onto
1601 multiple lines, then the data value is permitted to be followed by a comma
1602 or a semicolon (for use in drivers) and the yield is that character.
1603
1604 Arguments:
1605   buffer        contains the configuration line to be handled
1606   oltop         points to the start of the relevant option list
1607   last          one more than the offset of the last item in the option list
1608   data_block    NULL when reading main options => data values in the option
1609                   list are absolute addresses; otherwise they are byte offsets
1610                   in data_block when they have opt_public set; otherwise
1611                   they are byte offsets in data_block->options_block.
1612   unknown_txt   format string to use in panic message for unknown option;
1613                   must contain %s for option name
1614                 if given as NULL, don't panic on unknown option
1615
1616 Returns:        TRUE if an option was read successfully,
1617                 FALSE false for an unknown option if unknown_txt == NULL,
1618                   otherwise panic and die on an unknown option
1619 */
1620
1621 static BOOL
1622 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1623   void *data_block, uschar *unknown_txt)
1624 {
1625 int ptr = 0;
1626 int offset = 0;
1627 int count, type, value;
1628 int issecure = 0;
1629 uid_t uid;
1630 gid_t gid;
1631 BOOL boolvalue = TRUE;
1632 BOOL freesptr = TRUE;
1633 optionlist *ol, *ol2;
1634 struct passwd *pw;
1635 rmark reset_point;
1636 int intbase = 0;
1637 uschar *inttype = US"";
1638 uschar *sptr;
1639 const uschar * s = buffer;
1640 uschar **str_target;
1641 uschar name[EXIM_DRIVERNAME_MAX];
1642 uschar name2[EXIM_DRIVERNAME_MAX];
1643
1644 /* There may be leading spaces; thereafter, we expect an option name starting
1645 with a letter. */
1646
1647 if (!isalpha( Uskip_whitespace(&s) ))
1648   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1649
1650 /* Read the name of the option, and skip any subsequent white space. If
1651 it turns out that what we read was "hide", set the flag indicating that
1652 this is a secure option, and loop to read the next word. */
1653
1654 for (int n = 0; n < 2; n++)
1655   {
1656   while (isalnum(*s) || *s == '_')
1657     {
1658     if (ptr < sizeof(name)-1) name[ptr++] = *s;
1659     s++;
1660     }
1661   name[ptr] = 0;
1662   Uskip_whitespace(&s);
1663   if (Ustrcmp(name, "hide") != 0) break;
1664   issecure = opt_secure;
1665   ptr = 0;
1666   }
1667
1668 /* Deal with "no_" or "not_" here for booleans */
1669
1670 if (Ustrncmp(name, "no_", 3) == 0)
1671   {
1672   boolvalue = FALSE;
1673   offset = 3;
1674   }
1675
1676 if (Ustrncmp(name, "not_", 4) == 0)
1677   {
1678   boolvalue = FALSE;
1679   offset = 4;
1680   }
1681
1682 /* Search the list for the given name. A non-existent name, or an option that
1683 is set twice, is a disaster. */
1684
1685 if (!(ol = find_option(name + offset, oltop, last)))
1686   {
1687   if (!unknown_txt) return FALSE;
1688   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1689   }
1690
1691 if ((ol->type & opt_set)  && !(ol->type & (opt_rep_con | opt_rep_str)))
1692   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1693     "\"%s\" option set for the second time", name);
1694
1695 ol->type |= opt_set | issecure;
1696 type = ol->type & opt_mask;
1697
1698 /* Types with data values must be followed by '='; the "no[t]_" prefix
1699 applies only to boolean values. */
1700
1701 if (type < opt_bool || type > opt_bool_last)
1702   {
1703   if (offset != 0)
1704     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1705       "negation prefix applied to a non-boolean option");
1706   if (!*s)
1707     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1708       "unexpected end of line (data missing) after %s", name);
1709   if (*s != '=')
1710     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1711   }
1712
1713 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1714 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1715 ultimately expands to one of those values. */
1716
1717 else if (*s && (offset != 0 || *s != '='))
1718   extra_chars_error(s, US"boolean option ", name, US"");
1719
1720 /* Skip white space after = */
1721
1722 if (*s == '=') while (isspace(*++s));
1723
1724 /* If there is a data block and the opt_public flag is not set, change
1725 the data block pointer to the private options block. */
1726
1727 if (data_block && !(ol->type & opt_public))
1728   data_block = (void *)(((driver_instance *)data_block)->options_block);
1729
1730 /* Now get the data according to the type. */
1731
1732 switch (type)
1733   {
1734   /* If a string value is not enclosed in quotes, it consists of
1735   the rest of the current line, verbatim. Otherwise, string escapes
1736   are processed.
1737
1738   A transport is specified as a string, which is then looked up in the
1739   list of transports. A search type is specified as one of a number of
1740   known strings.
1741
1742   A set or rewrite rules for a driver is specified as a string, which is
1743   then parsed into a suitable chain of control blocks.
1744
1745   Uids and gids are specified as strings which are then looked up in the
1746   passwd file. Lists of uids and gids are similarly specified as colon-
1747   separated strings. */
1748
1749   case opt_stringptr:
1750   case opt_uid:
1751   case opt_gid:
1752   case opt_expand_uid:
1753   case opt_expand_gid:
1754   case opt_uidlist:
1755   case opt_gidlist:
1756   case opt_rewrite:
1757
1758     reset_point = store_mark();
1759     sptr = read_string(s, name);
1760
1761     /* Having read a string, we now have several different ways of using it,
1762     depending on the data type, so do another switch. If keeping the actual
1763     string is not required (because it is interpreted), freesptr is set TRUE,
1764     and at the end we reset the pool. */
1765
1766     switch (type)
1767       {
1768       /* If this was a string, set the variable to point to the new string,
1769       and set the flag so its store isn't reclaimed. If it was a list of rewrite
1770       rules, we still keep the string (for printing), and parse the rules into a
1771       control block and flags word. */
1772
1773       case opt_stringptr:
1774         str_target = data_block ? USS (US data_block + ol->v.offset)
1775                                 : USS ol->v.value;
1776         if (ol->type & opt_rep_con)
1777           {
1778           uschar * saved_condition;
1779           /* We already have a condition, we're conducting a crude hack to let
1780           multiple condition rules be chained together, despite storing them in
1781           text form. */
1782           *str_target = string_copy_perm( (saved_condition = *str_target)
1783             ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1784                 saved_condition, sptr)
1785             : sptr,
1786             FALSE);
1787           /* TODO(pdp): there is a memory leak here and just below
1788           when we set 3 or more conditions; I still don't
1789           understand the store mechanism enough to know
1790           what's the safe way to free content from an earlier store.
1791           AFAICT, stores stack, so freeing an early stored item also stores
1792           all data alloc'd after it.  If we knew conditions were adjacent,
1793           we could survive that, but we don't.  So I *think* we need to take
1794           another bit from opt_type to indicate "malloced"; this seems like
1795           quite a hack, especially for this one case.  It also means that
1796           we can't ever reclaim the store from the *first* condition.
1797
1798           Because we only do this once, near process start-up, I'm prepared to
1799           let this slide for the time being, even though it rankles.  */
1800           }
1801         else if (ol->type & opt_rep_str)
1802           {
1803           uschar sep_o =
1804             Ustrncmp(name, "headers_add", 11) == 0      ? '\n'
1805             : Ustrncmp(name, "set", 3) == 0             ? ';'
1806             : ':';
1807           int    sep_i = -(int)sep_o;
1808           const uschar * list = sptr;
1809           uschar * s;
1810           gstring * list_o = NULL;
1811
1812           if (*str_target)
1813             {
1814             list_o = string_get(Ustrlen(*str_target) + Ustrlen(sptr));
1815             list_o = string_cat(list_o, *str_target);
1816             }
1817
1818           while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1819             list_o = string_append_listele(list_o, sep_o, s);
1820
1821           if (list_o)
1822             *str_target = string_copy_perm(string_from_gstring(list_o), FALSE);
1823           }
1824         else
1825           {
1826           *str_target = sptr;
1827           freesptr = FALSE;
1828           }
1829         break;
1830
1831       case opt_rewrite:
1832         if (data_block)
1833           *USS (US data_block + ol->v.offset) = sptr;
1834         else
1835           *USS ol->v.value = sptr;
1836         freesptr = FALSE;
1837         if (type == opt_rewrite)
1838           {
1839           int sep = 0;
1840           int *flagptr;
1841           uschar *p = sptr;
1842           rewrite_rule **chain;
1843           optionlist *ol3;
1844
1845           sprintf(CS name2, "*%.50s_rules", name);
1846           ol2 = find_option(name2, oltop, last);
1847           sprintf(CS name2, "*%.50s_flags", name);
1848           ol3 = find_option(name2, oltop, last);
1849
1850           if (!ol2 || !ol3)
1851             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1852               "rewrite rules not available for driver");
1853
1854           if (data_block)
1855             {
1856             chain = (rewrite_rule **)(US data_block + ol2->v.offset);
1857             flagptr = (int *)(US data_block + ol3->v.offset);
1858             }
1859           else
1860             {
1861             chain = (rewrite_rule **)ol2->v.value;
1862             flagptr = (int *)ol3->v.value;
1863             }
1864
1865           /* This will trap if sptr is tainted. Not sure if that can happen */
1866           while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1867             {
1868             rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1869             *chain = next;
1870             chain = &(next->next);
1871             }
1872
1873           if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1874             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1875               "non-header rewrite - not allowed at transport time -");
1876           }
1877         break;
1878
1879       /* If it was an expanded uid, see if there is any expansion to be
1880       done by checking for the presence of a $ character. If there is, save it
1881       in the corresponding *expand_user option field. Otherwise, fall through
1882       to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1883       of data. */
1884
1885       case opt_expand_uid:
1886         sprintf(CS name2, "*expand_%.50s", name);
1887         if ((ol2 = find_option(name2, oltop, last)))
1888           {
1889           uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1890
1891           if (data_block)
1892             *(USS(US data_block + ol2->v.offset)) = ss;
1893           else
1894             *(USS ol2->v.value) = ss;
1895
1896           if (ss)
1897             {
1898             *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1899             freesptr = FALSE;
1900             break;
1901             }
1902           }
1903
1904       /* Look up a fixed uid, and also make use of the corresponding gid
1905       if a passwd entry is returned and the gid has not been set. */
1906
1907       case opt_uid:
1908         if (!route_finduser(sptr, &pw, &uid))
1909           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1910         if (data_block)
1911           *(uid_t *)(US data_block + ol->v.offset) = uid;
1912         else
1913           *(uid_t *)ol->v.value = uid;
1914
1915         /* Set the flag indicating a fixed value is set */
1916
1917         *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1918
1919         /* Handle matching gid if we have a passwd entry: done by finding the
1920         same name with terminating "user" changed to "group"; if not found,
1921         ignore. Also ignore if the value is already set. */
1922
1923         if (pw == NULL) break;
1924         Ustrcpy(name+Ustrlen(name)-4, US"group");
1925         ol2 = find_option(name, oltop, last);
1926         if (ol2 && ((ol2->type & opt_mask) == opt_gid ||
1927             (ol2->type & opt_mask) == opt_expand_gid))
1928           {
1929           BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1930           if (!*set_flag)
1931             {
1932             if (data_block)
1933               *((gid_t *)(US data_block + ol2->v.offset)) = pw->pw_gid;
1934             else
1935               *((gid_t *)ol2->v.value) = pw->pw_gid;
1936             *set_flag = TRUE;
1937             }
1938           }
1939         break;
1940
1941       /* If it was an expanded gid, see if there is any expansion to be
1942       done by checking for the presence of a $ character. If there is, save it
1943       in the corresponding *expand_user option field. Otherwise, fall through
1944       to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1945       of data. */
1946
1947       case opt_expand_gid:
1948         sprintf(CS name2, "*expand_%.50s", name);
1949         if ((ol2 = find_option(name2, oltop, last)))
1950           {
1951           uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1952
1953           if (data_block)
1954             *(USS(US data_block + ol2->v.offset)) = ss;
1955           else
1956             *(USS ol2->v.value) = ss;
1957
1958           if (ss)
1959             {
1960             *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1961             freesptr = FALSE;
1962             break;
1963             }
1964           }
1965
1966       /* Handle freestanding gid */
1967
1968       case opt_gid:
1969         if (!route_findgroup(sptr, &gid))
1970           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1971         if (data_block)
1972           *((gid_t *)(US data_block + ol->v.offset)) = gid;
1973         else
1974           *((gid_t *)ol->v.value) = gid;
1975         *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1976         break;
1977
1978       /* If it was a uid list, look up each individual entry, and build
1979       a vector of uids, with a count in the first element. Put the vector
1980       in malloc store so we can free the string. (We are reading into
1981       permanent store already.) */
1982
1983       case opt_uidlist:
1984         {
1985         int count = 1;
1986         uid_t *list;
1987         int ptr = 0;
1988         const uschar *p;
1989         const uschar *op = expand_string (sptr);
1990
1991         if (op == NULL)
1992           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1993             name, expand_string_message);
1994
1995         p = op;
1996         if (*p != 0) count++;
1997         while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1998         list = store_malloc(count*sizeof(uid_t));
1999         list[ptr++] = (uid_t)(count - 1);
2000
2001         if (data_block)
2002           *((uid_t **)(US data_block + ol->v.offset)) = list;
2003         else
2004           *((uid_t **)ol->v.value) = list;
2005
2006         p = op;
2007         while (count-- > 1)
2008           {
2009           int sep = 0;
2010           /* If p is tainted we trap.  Not sure that can happen */
2011           (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2012           if (!route_finduser(big_buffer, NULL, &uid))
2013             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
2014               big_buffer);
2015           list[ptr++] = uid;
2016           }
2017         break;
2018         }
2019
2020       /* If it was a gid list, look up each individual entry, and build
2021       a vector of gids, with a count in the first element. Put the vector
2022       in malloc store so we can free the string. (We are reading into permanent
2023       store already.) */
2024
2025       case opt_gidlist:
2026         {
2027         int count = 1;
2028         gid_t *list;
2029         int ptr = 0;
2030         const uschar *p;
2031         const uschar *op = expand_string (sptr);
2032
2033         if (!op)
2034           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2035             name, expand_string_message);
2036
2037         p = op;
2038         if (*p != 0) count++;
2039         while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2040         list = store_malloc(count*sizeof(gid_t));
2041         list[ptr++] = (gid_t)(count - 1);
2042
2043         if (data_block)
2044           *((gid_t **)(US data_block + ol->v.offset)) = list;
2045         else
2046           *((gid_t **)ol->v.value) = list;
2047
2048         p = op;
2049         while (count-- > 1)
2050           {
2051           int sep = 0;
2052           /* If p is tainted we trap.  Not sure that can happen */
2053           (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2054           if (!route_findgroup(big_buffer, &gid))
2055             log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2056               big_buffer);
2057           list[ptr++] = gid;
2058           }
2059         break;
2060         }
2061       }
2062
2063     /* Release store if the value of the string doesn't need to be kept. */
2064
2065     if (freesptr) reset_point = store_reset(reset_point);
2066     break;
2067
2068   /* Expanded boolean: if no characters follow, or if there are no dollar
2069   characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2070   save the string for later expansion in the alternate place. */
2071
2072   case opt_expand_bool:
2073     if (*s && Ustrchr(s, '$') != 0)
2074       {
2075       sprintf(CS name2, "*expand_%.50s", name);
2076       if ((ol2 = find_option(name2, oltop, last)))
2077         {
2078         reset_point = store_mark();
2079         sptr = read_string(s, name);
2080         if (data_block)
2081           *(USS(US data_block + ol2->v.offset)) = sptr;
2082         else
2083           *(USS ol2->v.value) = sptr;
2084         freesptr = FALSE;
2085         break;
2086         }
2087       }
2088     /* Fall through */
2089
2090   /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2091   look for yes/not/true/false. Some booleans are stored in a single bit in
2092   a single int. There's a special fudge for verify settings; without a suffix
2093   they set both xx_sender and xx_recipient. The table points to the sender
2094   value; search subsequently for the recipient. There's another special case:
2095   opt_bool_set also notes when a boolean has been set. */
2096
2097   case opt_bool:
2098   case opt_bit:
2099   case opt_bool_verify:
2100   case opt_bool_set:
2101     if (*s)
2102       {
2103       s = readconf_readname(name2, EXIM_DRIVERNAME_MAX, s);
2104       if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2105         boolvalue = TRUE;
2106       else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2107         boolvalue = FALSE;
2108       else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2109         "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2110       if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2111         US"for boolean option ", name);
2112       }
2113
2114     /* Handle single-bit type. */
2115
2116     if (type == opt_bit)
2117       {
2118       int bit = 1 << ((ol->type >> 16) & 31);
2119       int * ptr = data_block
2120         ? (int *)(US data_block + ol->v.offset)
2121         : (int *)ol->v.value;
2122       if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2123       break;
2124       }
2125
2126     /* Handle full BOOL types */
2127
2128     if (data_block)
2129       *((BOOL *)(US data_block + ol->v.offset)) = boolvalue;
2130     else
2131       *((BOOL *)ol->v.value) = boolvalue;
2132
2133     /* Verify fudge */
2134
2135     if (type == opt_bool_verify)
2136       {
2137       sprintf(CS name2, "%.50s_recipient", name + offset);
2138       if ((ol2 = find_option(name2, oltop, last)))
2139         if (data_block)
2140           *((BOOL *)(US data_block + ol2->v.offset)) = boolvalue;
2141         else
2142           *((BOOL *)ol2->v.value) = boolvalue;
2143       }
2144
2145     /* Note that opt_bool_set type is set, if there is somewhere to do so */
2146
2147     else if (type == opt_bool_set)
2148       {
2149       sprintf(CS name2, "*set_%.50s", name + offset);
2150       if ((ol2 = find_option(name2, oltop, last)))
2151         if (data_block)
2152           *((BOOL *)(US data_block + ol2->v.offset)) = TRUE;
2153         else
2154           *((BOOL *)ol2->v.value) = TRUE;
2155       }
2156     break;
2157
2158   /* Octal integer */
2159
2160   case opt_octint:
2161     intbase = 8;
2162     inttype = US"octal ";
2163
2164   /*  Integer: a simple(ish) case; allow octal and hex formats, and
2165   suffixes K, M, G, and T.  The different types affect output, not input. */
2166
2167   case opt_mkint:
2168   case opt_int:
2169      {
2170       uschar *endptr;
2171       long int lvalue;
2172
2173       errno = 0;
2174       lvalue = strtol(CS s, CSS &endptr, intbase);
2175
2176       if (endptr == s)
2177         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2178           inttype, name);
2179
2180       if (errno != ERANGE && *endptr)
2181         {
2182         uschar * mp = US"TtGgMmKk\0";   /* YyZzEePpTtGgMmKk */
2183
2184         if ((mp = Ustrchr(mp, *endptr)))
2185           {
2186           endptr++;
2187           do
2188             {
2189             if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024)
2190               {
2191               errno = ERANGE;
2192               break;
2193               }
2194             lvalue *= 1024;
2195             }
2196           while (*(mp += 2));
2197           }
2198         }
2199
2200       if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2201         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2202           "absolute value of integer \"%s\" is too large (overflow)", s);
2203
2204       if (Uskip_whitespace(&endptr))
2205         extra_chars_error(endptr, inttype, US"integer value for ", name);
2206
2207       value = (int)lvalue;
2208      }
2209
2210     if (data_block)
2211       *(int *)(US data_block + ol->v.offset) = value;
2212     else
2213       *(int *)ol->v.value = value;
2214     break;
2215
2216   /*  Integer held in K: again, allow formats and suffixes as above. */
2217
2218   case opt_Kint:
2219     {
2220     uschar *endptr;
2221     errno = 0;
2222     int_eximarith_t lvalue = strtol(CS s, CSS &endptr, intbase);
2223
2224     if (endptr == s)
2225       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2226         inttype, name);
2227
2228     if (errno != ERANGE && *endptr)
2229       {
2230       uschar * mp = US"ZzEePpTtGgMmKk\0";       /* YyZzEePpTtGgMmKk */
2231
2232       if ((mp = Ustrchr(mp, *endptr)))
2233         {
2234         endptr++;
2235         while (*(mp += 2))
2236           {
2237           if (lvalue > EXIM_ARITH_MAX/1024 || lvalue < EXIM_ARITH_MIN/1024)
2238             {
2239             errno = ERANGE;
2240             break;
2241             }
2242           lvalue *= 1024;
2243           }
2244         }
2245       else
2246         lvalue = (lvalue + 512)/1024;
2247       }
2248
2249     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2250       "absolute value of integer \"%s\" is too large (overflow)", s);
2251
2252     if (Uskip_whitespace(&endptr))
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       Uskip_whitespace(&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, const 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; not admin\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   const uschar * t = expand_cstring(pid_file_path);
3482   if (!t)
3483     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3484       "\"%s\": %s", pid_file_path, expand_string_message);
3485   pid_file_path = t;
3486   }
3487
3488 /* Set default value of process_log_path */
3489
3490 if (!process_log_path || !*process_log_path)
3491   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3492
3493 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3494 message. */
3495
3496 regex_From = regex_must_compile(uucp_from_pattern, MCS_NOFLAGS, TRUE);
3497
3498 /* Unpick the SMTP rate limiting options, if set */
3499
3500 if (smtp_ratelimit_mail)
3501   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3502     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3503
3504 if (smtp_ratelimit_rcpt)
3505   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3506     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3507
3508 /* The qualify domains default to the primary host name */
3509
3510 if (!qualify_domain_sender)
3511   qualify_domain_sender = primary_hostname;
3512 if (!qualify_domain_recipient)
3513   qualify_domain_recipient = qualify_domain_sender;
3514
3515 /* Setting system_filter_user in the configuration sets the gid as well if a
3516 name is given, but a numerical value does not. */
3517
3518 if (system_filter_uid_set && !system_filter_gid_set)
3519   {
3520   struct passwd *pw = getpwuid(system_filter_uid);
3521   if (!pw)
3522     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3523       (long int)system_filter_uid);
3524   system_filter_gid = pw->pw_gid;
3525   system_filter_gid_set = TRUE;
3526   }
3527
3528 /* If the errors_reply_to field is set, check that it is syntactically valid
3529 and ensure it contains a domain. */
3530
3531 if (errors_reply_to)
3532   {
3533   uschar *errmess;
3534   int start, end, domain;
3535   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3536     &start, &end, &domain, FALSE);
3537
3538   if (!recipient)
3539     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3540       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3541
3542   if (!domain)
3543     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3544       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3545   }
3546
3547 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3548 smtp_accept_max must also be set. */
3549
3550 if (smtp_accept_max == 0 && (smtp_accept_queue > 0 || smtp_accept_max_per_host))
3551   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3552     "smtp_accept_max must be set if smtp_accept_queue or "
3553     "smtp_accept_max_per_host is set");
3554
3555 /* Set up the host number if anything is specified. It is an expanded string
3556 so that it can be computed from the host name, for example. We do this last
3557 so as to ensure that everything else is set up before the expansion. */
3558
3559 if (host_number_string)
3560   {
3561   long int n;
3562   uschar *end;
3563   uschar *s = expand_string(host_number_string);
3564
3565   if (!s)
3566     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3567         "failed to expand localhost_number \"%s\": %s",
3568         host_number_string, expand_string_message);
3569   n = Ustrtol(s, &end, 0);
3570   if (Uskip_whitespace(&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, * pp;
4021
4022 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4023
4024 Uskip_whitespace(&p);
4025 pp = p;
4026 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4027
4028 if (*p && !isspace(*p) && *p != ',' && *p != ';')
4029   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4030
4031 *paddr = p;
4032 switch (type)
4033   {
4034   case 0: return readconf_readtime(pp, *p, FALSE);
4035   case 1: return readconf_readfixed(pp, *p);
4036   }
4037 return 0;    /* Keep picky compilers happy */
4038 }
4039
4040 /* The function proper */
4041
4042 void
4043 readconf_retries(void)
4044 {
4045 retry_config **chain = &retries;
4046 retry_config *next;
4047 const uschar *p;
4048
4049 while ((p = get_config_line()))
4050   {
4051   retry_rule **rchain;
4052   const uschar *pp;
4053   uschar *error;
4054
4055   next = store_get(sizeof(retry_config), GET_UNTAINTED);
4056   next->next = NULL;
4057   *chain = next;
4058   chain = &(next->next);
4059   next->basic_errno = next->more_errno = 0;
4060   next->senders = NULL;
4061   next->rules = NULL;
4062   rchain = &(next->rules);
4063
4064   next->pattern = string_dequote(&p);
4065   Uskip_whitespace(&p);
4066   pp = p;
4067   while (mac_isgraph(*p)) p++;
4068   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4069     "missing error type in retry rule");
4070
4071   /* Test error names for things we understand. */
4072
4073   if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4074        &next->more_errno)))
4075     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4076
4077   /* There may be an optional address list of senders to be used as another
4078   constraint on the rule. This was added later, so the syntax is a bit of a
4079   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4080   an address list. */
4081
4082   Uskip_whitespace(&p);
4083   if (Ustrncmp(p, "senders", 7) == 0)
4084     {
4085     p += 7;
4086     Uskip_whitespace(&p);
4087     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4088       "\"=\" expected after \"senders\" in retry rule");
4089     Uskip_whitespace(&p);
4090     next->senders = string_dequote(&p);
4091     }
4092
4093   /* Now the retry rules. Keep the maximum timeout encountered. */
4094
4095   Uskip_whitespace(&p);
4096
4097   while (*p)
4098     {
4099     retry_rule * rule = store_get(sizeof(retry_rule), GET_UNTAINTED);
4100     *rchain = rule;
4101     rchain = &(rule->next);
4102     rule->next = NULL;
4103     rule->rule = toupper(*p++);
4104     rule->timeout = retry_arg(&p, 0);
4105     if (rule->timeout > retry_maximum_timeout)
4106       retry_maximum_timeout = rule->timeout;
4107
4108     switch (rule->rule)
4109       {
4110       case 'F':   /* Fixed interval */
4111         rule->p1 = retry_arg(&p, 0);
4112         break;
4113
4114       case 'G':   /* Geometrically increasing intervals */
4115       case 'H':   /* Ditto, but with randomness */
4116         rule->p1 = retry_arg(&p, 0);
4117         rule->p2 = retry_arg(&p, 1);
4118         break;
4119
4120       default:
4121         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4122         break;
4123       }
4124
4125     if (rule->timeout <= 0 || rule->p1 <= 0 ||
4126           (rule->rule != 'F' && rule->p2 < 1000))
4127       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4128         "bad parameters for retry rule");
4129
4130     if (Uskip_whitespace(&p) == ';')
4131       {
4132       p++;
4133       Uskip_whitespace(&p);
4134       }
4135     else if (*p)
4136       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4137     }
4138   }
4139 }
4140
4141
4142
4143 /*************************************************
4144 *         Initialize authenticators              *
4145 *************************************************/
4146
4147 /* Read the authenticators section of the configuration file.
4148
4149 Arguments:   none
4150 Returns:     nothing
4151 */
4152
4153 static void
4154 auths_init(void)
4155 {
4156 #ifndef DISABLE_PIPE_CONNECT
4157 int nauths = 0;
4158 #endif
4159
4160 readconf_driver_init(US"authenticator",
4161   (driver_instance **)(&auths),      /* chain anchor */
4162   (driver_info *)auths_available,    /* available drivers */
4163   sizeof(auth_info),                 /* size of info block */
4164   &auth_defaults,                    /* default values for generic options */
4165   sizeof(auth_instance),             /* size of instance block */
4166   optionlist_auths,                  /* generic options */
4167   optionlist_auths_size);
4168
4169 for (auth_instance * au = auths; au; au = au->next)
4170   {
4171   if (!au->public_name)
4172     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4173       "the %s authenticator", au->name);
4174
4175   for (auth_instance * bu = au->next; bu; bu = bu->next)
4176     if (strcmpic(au->public_name, bu->public_name) == 0)
4177       if (  au->client && bu->client
4178          || au->server && bu->server)
4179         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4180           "(%s and %s) have the same public name (%s)",
4181           au->client && bu->client ? US"client" : US"server",
4182           au->name, bu->name, au->public_name);
4183 #ifndef DISABLE_PIPE_CONNECT
4184   nauths++;
4185 #endif
4186   }
4187 #ifndef DISABLE_PIPE_CONNECT
4188 f.smtp_in_early_pipe_no_auth = nauths > 16;
4189 #endif
4190 }
4191
4192
4193 /* For error messages, a string describing the config location associated
4194 with current processing.  NULL if we are not in an authenticator. */
4195
4196 uschar *
4197 authenticator_current_name(void)
4198 {
4199 if (!authenticator_name) return NULL;
4200 return string_sprintf(" (authenticator %s, %s %d)", authenticator_name, driver_srcfile, driver_srcline);
4201 }
4202
4203
4204
4205
4206
4207 /*************************************************
4208 *             Read ACL information               *
4209 *************************************************/
4210
4211 /* If this run of Exim is not doing something that involves receiving a
4212 message, we can just skip over the ACL information. No need to parse it.
4213
4214 First, we have a function for acl_read() to call back to get the next line. We
4215 need to remember the line we passed, because at the end it will contain the
4216 name of the next ACL. */
4217
4218 static uschar *acl_line;
4219
4220 static uschar *
4221 acl_callback(void)
4222 {
4223 acl_line = get_config_line();
4224 return acl_line;
4225 }
4226
4227
4228 /* Now the main function:
4229
4230 Arguments:    none
4231 Returns:      nothing
4232 */
4233
4234 static void
4235 readconf_acl(void)
4236 {
4237 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4238 between ACLs. */
4239
4240 acl_line = get_config_line();
4241
4242 while(acl_line)
4243   {
4244   uschar name[EXIM_DRIVERNAME_MAX];
4245   tree_node * node;
4246   uschar * error;
4247   const uschar * p = readconf_readname(name, sizeof(name), acl_line);
4248
4249   if (isupper(*name) && *p == '=')
4250     {
4251     if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
4252     acl_line = get_config_line();
4253     continue;
4254     }
4255
4256   if (*p != ':' || name[0] == 0)
4257     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4258
4259   node = store_get_perm(sizeof(tree_node) + Ustrlen(name), name);
4260   Ustrcpy(node->name, name);
4261   if (!tree_insertnode(&acl_anchor, node))
4262     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4263       "there are two ACLs called \"%s\"", name);
4264
4265   node->data.ptr = acl_read(acl_callback, &error);
4266
4267   if (node->data.ptr == NULL && error != NULL)
4268     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4269   }
4270 }
4271
4272
4273
4274 /*************************************************
4275 *     Read configuration for local_scan()        *
4276 *************************************************/
4277
4278 /* This function is called after "begin local_scan" is encountered in the
4279 configuration file. If the local_scan() function allows for configuration
4280 options, we can process them. Otherwise, we expire in a panic.
4281
4282 Arguments:  none
4283 Returns:    nothing
4284 */
4285
4286 static void
4287 local_scan_init(void)
4288 {
4289 #ifndef LOCAL_SCAN_HAS_OPTIONS
4290 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4291   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4292 #else
4293
4294 uschar *p;
4295 while ((p = get_config_line()))
4296   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4297     NULL, US"local_scan option \"%s\" unknown");
4298 #endif
4299 }
4300
4301
4302
4303 /*************************************************
4304 *     Read rest of configuration (after main)    *
4305 *************************************************/
4306
4307 /* This function reads the rest of the runtime configuration, after the main
4308 configuration. It is called only when actually needed. Each subsequent section
4309 of the configuration starts with a line of the form
4310
4311   begin name
4312
4313 where the name is "routers", "transports", etc. A section is terminated by
4314 hitting the next "begin" line, and the next name is left in next_section.
4315 Because it may confuse people as to whether the names are singular or plural,
4316 we add "s" if it's missing. There is always enough room in next_section for
4317 this. This function is basically just a switch.
4318
4319 Arguments:   none
4320 Returns:     nothing
4321 */
4322
4323 static uschar *section_list[] = {
4324   US"acls",
4325   US"authenticators",
4326   US"local_scans",
4327   US"retrys",
4328   US"rewrites",
4329   US"routers",
4330   US"transports"};
4331
4332 void
4333 readconf_rest(void)
4334 {
4335 int had = 0;
4336
4337 while(next_section[0] != 0)
4338   {
4339   int bit;
4340   int first = 0;
4341   int last = nelem(section_list);
4342   int mid = last/2;
4343   int n = Ustrlen(next_section);
4344
4345   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
4346
4347   for (;;)
4348     {
4349     int c = strcmpic(next_section, section_list[mid]);
4350     if (c == 0) break;
4351     if (c > 0) first = mid + 1; else last = mid;
4352     if (first >= last)
4353       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4354         "\"%.*s\" is not a known configuration section name", n, next_section);
4355     mid = (last + first)/2;
4356     }
4357
4358   bit = 1 << mid;
4359   if (((had ^= bit) & bit) == 0)
4360     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4361       "\"%.*s\" section is repeated in the configuration file", n,
4362         next_section);
4363
4364   switch(mid)
4365     {
4366     case 0: readconf_acl(); break;
4367     case 1: auths_init(); break;
4368     case 2: local_scan_init(); break;
4369     case 3: readconf_retries(); break;
4370     case 4: readconf_rewrites(); break;
4371     case 5: route_init(); break;
4372     case 6: transport_init(); break;
4373     }
4374   }
4375
4376 (void)fclose(config_file);
4377 }
4378
4379 /* Init the storage for the pre-parsed config lines */
4380 void
4381 readconf_save_config(const uschar *s)
4382 {
4383 save_config_line(string_sprintf("# Exim Configuration (%s)",
4384   f.running_in_test_harness ? US"X" : s));
4385 }
4386
4387 static void
4388 save_config_position(const uschar *file, int line)
4389 {
4390 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4391 }
4392
4393 /* Append a pre-parsed logical line to the config lines store,
4394 this operates on a global (static) list that holds all the pre-parsed
4395 config lines, we do no further processing here, output formatting and
4396 honouring of <hide> or macros will be done during output */
4397
4398 static void
4399 save_config_line(const uschar* line)
4400 {
4401 static config_line_item *current;
4402 config_line_item *next;
4403
4404 next = (config_line_item*) store_get(sizeof(config_line_item), GET_UNTAINTED);
4405 next->line = string_copy(line);
4406 next->next = NULL;
4407
4408 if (!config_lines) config_lines = next;
4409 else current->next = next;
4410
4411 current = next;
4412 }
4413
4414 /* List the parsed config lines, care about nice formatting and
4415 hide the <hide> values unless we're the admin user */
4416 void
4417 print_config(BOOL admin, BOOL terse)
4418 {
4419 const int TS = terse ? 0 : 2;
4420 int indent = 0;
4421 rmark r = NULL;
4422
4423 for (const config_line_item * i = config_lines; i; i = i->next)
4424   {
4425   uschar * current, * p;
4426
4427   if (r) store_reset(r);
4428   r = store_mark();
4429
4430   /* skip over to the first non-space */
4431   current = string_copy(i->line);
4432   if (!Uskip_whitespace(&current))
4433     continue;
4434
4435   /* Collapse runs of spaces. We stop this if we encounter one of the
4436   following characters: "'$, as this may indicate careful formatting */
4437
4438   for (p = current; *p; p++) if (isspace(*p))
4439     {
4440     uschar * next = p;
4441     if (*p != ' ') *p = ' ';
4442
4443     Uskip_whitespace(&p);
4444
4445     if (next - p > 1)
4446       memmove(p+1, next, Ustrlen(next)+1);
4447
4448     if (*next == '"' || *next == '\'' || *next == '$')
4449       break;
4450     }
4451
4452   /* # lines */
4453   if (current[0] == '#')
4454     puts(CCS current);
4455
4456   /* begin lines are left aligned */
4457   else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4458     {
4459     if (!terse) puts("");
4460     puts(CCS current);
4461     indent = TS;
4462     }
4463
4464   /* router/acl/transport block names */
4465   else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4466     {
4467     if (!terse) puts("");
4468     printf("%*s%s\n", TS, "", current);
4469     indent = 2 * TS;
4470     }
4471
4472   /* hidden lines (all MACROS or lines prefixed with "hide") */
4473   else if (  !admin
4474           && (  isupper(*current)
4475              || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4476              )
4477           )
4478     {
4479     if ((p = Ustrchr(current, '=')))
4480       {
4481       *p = '\0';
4482       printf("%*s%s= %s\n", indent, "", current, CCS hidden);
4483       }
4484     /* e.g.: hide split_spool_directory */
4485     else
4486       printf("%*s\n", indent, CCS hidden);
4487     }
4488
4489   else
4490     /* rest is public */
4491     printf("%*s%s\n", indent, "", current);
4492   }
4493 if (r) store_reset(r);
4494 }
4495
4496 #endif  /*!MACRO_PREDEF*/
4497 /* vi: aw ai sw=2
4498 */
4499 /* End of readconf.c */