src/src/readconf.c

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