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