src/src/readconf.c

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