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(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     config_file = Ufopen(filename, "rb");
3157     if (config_file == NULL)
3158     #endif  /* CONFIGURE_FILE_USE_EUID */
3159       {
3160       sprintf(CS suffix, ".%.256s", uts.nodename);
3161       config_file = Ufopen(filename, "rb");
3162       }
3163     }
3164   #endif  /* CONFIGURE_FILE_USE_NODE */
3165
3166   /* Otherwise, try the generic name, possibly with the euid added */
3167
3168   #ifdef CONFIGURE_FILE_USE_EUID
3169   if (config_file == NULL)
3170     {
3171     sprintf(CS suffix, ".%ld", (long int)original_euid);
3172     config_file = Ufopen(filename, "rb");
3173     }
3174   #endif  /* CONFIGURE_FILE_USE_EUID */
3175
3176   /* Finally, try the unadorned name */
3177
3178   if (config_file == NULL)
3179     {
3180     *suffix = 0;
3181     config_file = Ufopen(filename, "rb");
3182     }
3183   #else  /* if neither defined */
3184
3185   /* This is the common case when the fancy processing is not included. */
3186
3187   config_file = Ufopen(filename, "rb");
3188   #endif
3189
3190   /* If the file does not exist, continue to try any others. For any other
3191   error, break out (and die). */
3192
3193   if (config_file != NULL || errno != ENOENT) break;
3194   }
3195
3196 /* On success, save the name for verification; config_filename is used when
3197 logging configuration errors (it changes for .included files) whereas
3198 config_main_filename is the name shown by -bP. Failure to open a configuration
3199 file is a serious disaster. */
3200
3201 if (config_file)
3202   {
3203   uschar *last_slash = Ustrrchr(filename, '/');
3204   config_filename = config_main_filename = string_copy(filename);
3205
3206   /* The config_main_directory we need for the $config_dir expansion.
3207   config_main_filename we need for $config_file expansion.
3208   And config_dir is the directory of the current configuration, used for
3209   relative .includes. We do need to know it's name, as we change our working
3210   directory later. */
3211
3212   if (filename[0] == '/')
3213     config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3214   else
3215     {
3216       /* relative configuration file name: working dir + / + basename(filename) */
3217
3218       uschar buf[PATH_MAX];
3219       gstring * g;
3220
3221       if (os_getcwd(buf, PATH_MAX) == NULL)
3222         {
3223         perror("exim: getcwd");
3224         exit(EXIT_FAILURE);
3225         }
3226       g = string_cat(NULL, buf);
3227
3228       /* If the dir does not end with a "/", append one */
3229       if (g->s[g->ptr-1] != '/')
3230         g = string_catn(g, US"/", 1);
3231
3232       /* If the config file contains a "/", extract the directory part */
3233       if (last_slash)
3234         g = string_catn(g, filename, last_slash - filename);
3235
3236       config_main_directory = string_from_gstring(g);
3237     }
3238   config_directory = config_main_directory;
3239   }
3240 else
3241   {
3242   if (!filename)
3243     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3244       "%s", config_main_filelist);
3245   else
3246     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
3247       string_open_failed("configuration file %s", filename));
3248   }
3249
3250 /* Now, once we found and opened our configuration file, we change the directory
3251 to a safe place. Later we change to $spool_directory. */
3252
3253 if (Uchdir("/") < 0)
3254   {
3255   perror("exim: chdir `/': ");
3256   exit(EXIT_FAILURE);
3257   }
3258
3259 /* Check the status of the file we have opened, if we have retained root
3260 privileges and the file isn't /dev/null (which *should* be 0666). */
3261
3262 if (f.trusted_config && Ustrcmp(filename, US"/dev/null"))
3263   {
3264   if (fstat(fileno(config_file), &statbuf) != 0)
3265     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3266       big_buffer);
3267
3268   if ((statbuf.st_uid != root_uid                /* owner not root */
3269        #ifdef CONFIGURE_OWNER
3270        && statbuf.st_uid != config_uid           /* owner not the special one */
3271        #endif
3272          ) ||                                    /* or */
3273       (statbuf.st_gid != root_gid                /* group not root & */
3274        #ifdef CONFIGURE_GROUP
3275        && statbuf.st_gid != config_gid           /* group not the special one */
3276        #endif
3277        && (statbuf.st_mode & 020) != 0) ||       /* group writeable  */
3278                                                  /* or */
3279       ((statbuf.st_mode & 2) != 0))              /* world writeable  */
3280
3281     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3282       "wrong owner, group, or mode", big_buffer);
3283
3284   /* Do a dummy store-allocation of a size related to the (toplevel) file size.
3285   This assumes we will need this much storage to handle all the allocations
3286   during startup; it won't help when .include is being used.  When it does, it
3287   will cut down on the number of store blocks (and malloc calls, and sbrk
3288   syscalls).  It also assume we're on the relevant pool. */
3289
3290   if (statbuf.st_size > 8192)
3291     {
3292     rmark r = store_mark();
3293     void * dummy = store_get((int)statbuf.st_size, FALSE);
3294     store_reset(r);
3295     }
3296   }
3297
3298 /* Process the main configuration settings. They all begin with a lower case
3299 letter. If we see something starting with an upper case letter, it is taken as
3300 a macro definition. */
3301
3302 while ((s = get_config_line()))
3303   {
3304   BOOL hide;
3305   uschar * t;
3306
3307   if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3308     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3309       "found unexpected BOM (Byte Order Mark)");
3310
3311   if (isupper(*s))
3312     {
3313     if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE);
3314     continue;
3315     }
3316
3317   t = (hide = Ustrncmp(s, "hide", 4) == 0 && isspace(s[4])) ? s + 5 : s;
3318
3319   if (Ustrncmp(t, "domainlist", 10) == 0)
3320     read_named_list(&domainlist_anchor, &domainlist_count,
3321       MAX_NAMED_LIST, t+10, US"domain list", hide);
3322
3323   else if (Ustrncmp(t, "hostlist", 8) == 0)
3324     read_named_list(&hostlist_anchor, &hostlist_count,
3325       MAX_NAMED_LIST, t+8, US"host list", hide);
3326
3327   else if (Ustrncmp(t, US"addresslist", 11) == 0)
3328     read_named_list(&addresslist_anchor, &addresslist_count,
3329       MAX_NAMED_LIST, t+11, US"address list", hide);
3330
3331   else if (Ustrncmp(t, US"localpartlist", 13) == 0)
3332     read_named_list(&localpartlist_anchor, &localpartlist_count,
3333       MAX_NAMED_LIST, t+13, US"local part list", hide);
3334
3335   else
3336     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3337       NULL, US"main option \"%s\" unknown");
3338   }
3339
3340
3341 /* If local_sender_retain is set, local_from_check must be unset. */
3342
3343 if (local_sender_retain && local_from_check)
3344   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3345     "local_sender_retain are set; this combination is not allowed");
3346
3347 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3348 wanted. */
3349
3350 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3351
3352 /* The max retry interval must not be greater than 24 hours. */
3353
3354 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3355
3356 /* remote_max_parallel must be > 0 */
3357
3358 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3359
3360 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3361 start of a new SMTP message. */
3362
3363 freeze_tell_config = freeze_tell;
3364
3365 /* The primary host name may be required for expansion of spool_directory
3366 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3367 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3368 canonize it. Some people like upper case letters in their host names, so we
3369 don't force the case. */
3370
3371 if (!primary_hostname)
3372   {
3373   const uschar * hostname;
3374   struct utsname uts;
3375
3376   if (uname(&uts) < 0)
3377     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3378   hostname = US uts.nodename;
3379
3380   if (Ustrchr(hostname, '.') == NULL)
3381     {
3382     int af = AF_INET;
3383     struct hostent *hostdata;
3384
3385 #if HAVE_IPV6
3386     if (  !disable_ipv6
3387        && (  !dns_ipv4_lookup
3388           || match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3389             MCL_DOMAIN, TRUE, NULL) != OK))
3390       af = AF_INET6;
3391 #endif
3392
3393     for (;;)
3394       {
3395 #if HAVE_IPV6
3396 # if HAVE_GETIPNODEBYNAME
3397         int error_num;
3398         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3399         #else
3400         hostdata = gethostbyname2(CS hostname, af);
3401 # endif
3402 #else
3403       hostdata = gethostbyname(CS hostname);
3404 #endif
3405
3406       if (hostdata)
3407         { hostname = US hostdata->h_name; break; }
3408
3409       if (af == AF_INET) break;
3410       af = AF_INET;
3411       }
3412     }
3413
3414   primary_hostname = string_copy(hostname);
3415   }
3416
3417 /* Set up default value for smtp_active_hostname */
3418
3419 smtp_active_hostname = primary_hostname;
3420
3421 /* If spool_directory wasn't set in the build-time configuration, it must have
3422 got set above. Of course, writing to the log may not work if log_file_path is
3423 not set, but it will at least get to syslog or somewhere, with any luck. */
3424
3425 if (!*spool_directory)
3426   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3427     "proceed");
3428
3429 /* Expand the spool directory name; it may, for example, contain the primary
3430 host name. Same comment about failure. */
3431
3432 if (!(s = expand_string(spool_directory)))
3433   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3434     "\"%s\": %s", spool_directory, expand_string_message);
3435 spool_directory = s;
3436
3437 /* Expand log_file_path, which must contain "%s" in any component that isn't
3438 the null string or "syslog". It is also allowed to contain one instance of %D
3439 or %M. However, it must NOT contain % followed by anything else. */
3440
3441 if (*log_file_path)
3442   {
3443   const uschar *ss, *sss;
3444   int sep = ':';                       /* Fixed for log file path */
3445   if (!(s = expand_string(log_file_path)))
3446     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3447       "\"%s\": %s", log_file_path, expand_string_message);
3448
3449   ss = s;
3450   /* should never be a tainted list */
3451   while ((sss = string_nextinlist(&ss, &sep, big_buffer, big_buffer_size)))
3452     {
3453     uschar *t;
3454     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3455     if (!(t = Ustrstr(sss, "%s")))
3456       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3457         "contain \"%%s\"", sss);
3458     *t = 'X';
3459     if ((t = Ustrchr(sss, '%')))
3460       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3461         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3462           "unexpected \"%%\" character", s);
3463     }
3464
3465   log_file_path = s;
3466   }
3467
3468 /* Interpret syslog_facility into an integer argument for 'ident' param to
3469 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3470 leading "log_". */
3471
3472 if (syslog_facility_str)
3473   {
3474   int i;
3475   uschar *s = syslog_facility_str;
3476
3477   if ((Ustrlen(syslog_facility_str) >= 4) &&
3478         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3479     s += 4;
3480
3481   for (i = 0; i < syslog_list_size; i++)
3482     if (strcmpic(s, syslog_list[i].name) == 0)
3483       {
3484       syslog_facility = syslog_list[i].value;
3485       break;
3486       }
3487
3488   if (i >= syslog_list_size)
3489     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3490       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3491   }
3492
3493 /* Expand pid_file_path */
3494
3495 if (*pid_file_path != 0)
3496   {
3497   if (!(s = expand_string(pid_file_path)))
3498     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3499       "\"%s\": %s", pid_file_path, expand_string_message);
3500   pid_file_path = s;
3501   }
3502
3503 /* Set default value of process_log_path */
3504
3505 if (!process_log_path || *process_log_path =='\0')
3506   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3507
3508 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3509 message. */
3510
3511 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3512
3513 /* Unpick the SMTP rate limiting options, if set */
3514
3515 if (smtp_ratelimit_mail)
3516   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3517     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3518
3519 if (smtp_ratelimit_rcpt)
3520   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3521     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3522
3523 /* The qualify domains default to the primary host name */
3524
3525 if (!qualify_domain_sender)
3526   qualify_domain_sender = primary_hostname;
3527 if (!qualify_domain_recipient)
3528   qualify_domain_recipient = qualify_domain_sender;
3529
3530 /* Setting system_filter_user in the configuration sets the gid as well if a
3531 name is given, but a numerical value does not. */
3532
3533 if (system_filter_uid_set && !system_filter_gid_set)
3534   {
3535   struct passwd *pw = getpwuid(system_filter_uid);
3536   if (!pw)
3537     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3538       (long int)system_filter_uid);
3539   system_filter_gid = pw->pw_gid;
3540   system_filter_gid_set = TRUE;
3541   }
3542
3543 /* If the errors_reply_to field is set, check that it is syntactically valid
3544 and ensure it contains a domain. */
3545
3546 if (errors_reply_to)
3547   {
3548   uschar *errmess;
3549   int start, end, domain;
3550   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3551     &start, &end, &domain, FALSE);
3552
3553   if (!recipient)
3554     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3555       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3556
3557   if (domain == 0)
3558     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3559       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3560   }
3561
3562 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3563 smtp_accept_max must also be set. */
3564
3565 if (smtp_accept_max == 0 &&
3566     (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3567   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3568     "smtp_accept_max must be set if smtp_accept_queue or "
3569     "smtp_accept_max_per_host is set");
3570
3571 /* Set up the host number if anything is specified. It is an expanded string
3572 so that it can be computed from the host name, for example. We do this last
3573 so as to ensure that everything else is set up before the expansion. */
3574
3575 if (host_number_string)
3576   {
3577   long int n;
3578   uschar *end;
3579   uschar *s = expand_string(host_number_string);
3580
3581   if (!s)
3582     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3583         "failed to expand localhost_number \"%s\": %s",
3584         host_number_string, expand_string_message);
3585   n = Ustrtol(s, &end, 0);
3586   while (isspace(*end)) end++;
3587   if (*end != 0)
3588     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3589       "localhost_number value is not a number: %s", s);
3590   if (n > LOCALHOST_MAX)
3591     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3592       "localhost_number is greater than the maximum allowed value (%d)",
3593         LOCALHOST_MAX);
3594   host_number = n;
3595   }
3596
3597 #ifndef DISABLE_TLS
3598 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3599
3600 if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
3601   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3602     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3603     tls_verify_hosts ? "" : "try_");
3604
3605 /* Magic number: at time of writing, 1024 has been the long-standing value
3606 used by so many clients, and what Exim used to use always, that it makes
3607 sense to just min-clamp this max-clamp at that. */
3608 if (tls_dh_max_bits < 1024)
3609   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3610       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3611
3612 /* If openssl_options is set, validate it */
3613 if (openssl_options)
3614   {
3615 # ifdef USE_GNUTLS
3616   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3617     "openssl_options is set but we're using GnuTLS");
3618 # else
3619   long dummy;
3620   if (!tls_openssl_options_parse(openssl_options, &dummy))
3621     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3622       "openssl_options parse error: %s", openssl_options);
3623 # endif
3624   }
3625 #endif  /*DISABLE_TLS*/
3626
3627 if (!nowarn && !keep_environment && environ && *environ)
3628   log_write(0, LOG_MAIN,
3629       "Warning: purging the environment.\n"
3630       " Suggested action: use keep_environment.");
3631 }
3632
3633
3634
3635 /*************************************************
3636 *          Initialize one driver                 *
3637 *************************************************/
3638
3639 /* This is called once the driver's generic options, if any, have been read.
3640 We can now find the driver, set up defaults for the private options, and
3641 unset any "set" bits in the private options table (which might have been
3642 set by another incarnation of the same driver).
3643
3644 Arguments:
3645   d                   pointer to driver instance block, with generic
3646                         options filled in
3647   drivers_available   vector of available drivers
3648   size_of_info        size of each block in drivers_available
3649   class               class of driver, for error message
3650
3651 Returns:              pointer to the driver info block
3652 */
3653
3654 static driver_info *
3655 init_driver(driver_instance *d, driver_info *drivers_available,
3656   int size_of_info, uschar *class)
3657 {
3658 for (driver_info * dd = drivers_available; dd->driver_name[0] != 0;
3659      dd = (driver_info *)((US dd) + size_of_info))
3660   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3661     {
3662     int len = dd->options_len;
3663     d->info = dd;
3664     d->options_block = store_get(len, FALSE);
3665     memcpy(d->options_block, dd->options_block, len);
3666     for (int i = 0; i < *(dd->options_count); i++)
3667       dd->options[i].type &= ~opt_set;
3668     return dd;
3669     }
3670
3671 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3672   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3673
3674 return NULL;   /* never obeyed */
3675 }
3676
3677
3678
3679
3680 /*************************************************
3681 *             Initialize driver list             *
3682 *************************************************/
3683
3684 /* This function is called for routers, transports, and authentication
3685 mechanisms. It reads the data from the current point in the configuration file
3686 up to the end of the section, and sets up a chain of instance blocks according
3687 to the file's contents. The file will already have been opened by a call to
3688 readconf_main, and must be left open for subsequent reading of further data.
3689
3690 Any errors cause a panic crash. Note that the blocks with names driver_info and
3691 driver_instance must map the first portions of all the _info and _instance
3692 blocks for this shared code to work.
3693
3694 Arguments:
3695   class                      "router", "transport", or "authenticator"
3696   anchor                     &routers, &transports, &auths
3697   drivers_available          available drivers
3698   size_of_info               size of each info block
3699   instance_default           points to default data for an instance
3700   instance_size              size of instance block
3701   driver_optionlist          generic option list
3702   driver_optionlist_count    count of generic option list
3703
3704 Returns:                     nothing
3705 */
3706
3707 void
3708 readconf_driver_init(
3709   uschar *class,
3710   driver_instance **anchor,
3711   driver_info *drivers_available,
3712   int size_of_info,
3713   void *instance_default,
3714   int  instance_size,
3715   optionlist *driver_optionlist,
3716   int  driver_optionlist_count)
3717 {
3718 driver_instance **p = anchor;
3719 driver_instance *d = NULL;
3720 uschar *buffer;
3721
3722 while ((buffer = get_config_line()))
3723   {
3724   uschar name[EXIM_DRIVERNAME_MAX];
3725   uschar *s;
3726
3727   /* Read the first name on the line and test for the start of a new driver. A
3728   macro definition indicates the end of the previous driver. If this isn't the
3729   start of a new driver, the line will be re-read. */
3730
3731   s = readconf_readname(name, sizeof(name), buffer);
3732
3733   /* Handle macro definition, first finishing off the initialization of the
3734   previous driver, if any. */
3735
3736   if (isupper(*name) && *s == '=')
3737     {
3738     if (d)
3739       {
3740       if (!d->driver_name)
3741         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3742           "no driver defined for %s \"%s\"", class, d->name);
3743       /* s is using big_buffer, so this call had better not */
3744       (d->info->init)(d);
3745       d = NULL;
3746       }
3747     if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE);
3748     continue;
3749     }
3750
3751   /* If the line starts with a name terminated by a colon, we are at the
3752   start of the definition of a new driver. The rest of the line must be
3753   blank. */
3754
3755   if (*s++ == ':')
3756     {
3757     /* Finish off initializing the previous driver. */
3758
3759     if (d)
3760       {
3761       if (!d->driver_name)
3762         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3763           "no driver defined for %s \"%s\"", class, d->name);
3764       (d->info->init)(d);
3765       }
3766
3767     /* Check that we haven't already got a driver of this name */
3768
3769     for (d = *anchor; d; d = d->next)
3770       if (Ustrcmp(name, d->name) == 0)
3771         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3772           "there are two %ss called \"%s\"", class, name);
3773
3774     /* Set up a new driver instance data block on the chain, with
3775     its default values installed. */
3776
3777     d = store_get(instance_size, FALSE);
3778     memcpy(d, instance_default, instance_size);
3779     *p = d;
3780     p = &d->next;
3781     d->name = string_copy(name);
3782
3783     /* Clear out the "set" bits in the generic options */
3784
3785     for (int i = 0; i < driver_optionlist_count; i++)
3786       driver_optionlist[i].type &= ~opt_set;
3787
3788     /* Check nothing more on this line, then do the next loop iteration. */
3789
3790     Uskip_whitespace(&s);
3791     if (*s) extra_chars_error(s, US"driver name ", name, US"");
3792     continue;
3793     }
3794
3795   /* Not the start of a new driver. Give an error if we have not set up a
3796   current driver yet. */
3797
3798   if (!d)
3799     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3800
3801   /* First look to see if this is a generic option; if it is "driver",
3802   initialize the driver. If is it not a generic option, we can look for a
3803   private option provided that the driver has been previously set up. */
3804
3805   if (readconf_handle_option(buffer, driver_optionlist,
3806         driver_optionlist_count, d, NULL))
3807     {
3808     if (!d->info && d->driver_name)
3809       init_driver(d, drivers_available, size_of_info, class);
3810     }
3811
3812   /* Handle private options - pass the generic block because some may
3813   live therein. A flag with each option indicates if it is in the public
3814   block. */
3815
3816   else if (d->info)
3817     readconf_handle_option(buffer, d->info->options,
3818       *(d->info->options_count), d, US"option \"%s\" unknown");
3819
3820   /* The option is not generic and the driver name has not yet been given. */
3821
3822   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3823     "(\"driver\" must be specified before any private options)", name);
3824   }
3825
3826 /* Run the initialization function for the final driver. */
3827
3828 if (d)
3829   {
3830   if (!d->driver_name)
3831     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3832       "no driver defined for %s \"%s\"", class, d->name);
3833   (d->info->init)(d);
3834   }
3835 }
3836
3837
3838
3839 /*************************************************
3840 *            Check driver dependency             *
3841 *************************************************/
3842
3843 /* This function is passed a driver instance and a string. It checks whether
3844 any of the string options for the driver contains the given string as an
3845 expansion variable.
3846
3847 Arguments:
3848   d        points to a driver instance block
3849   s        the string to search for
3850
3851 Returns:   TRUE if a dependency is found
3852 */
3853
3854 BOOL
3855 readconf_depends(driver_instance *d, uschar *s)
3856 {
3857 int count = *(d->info->options_count);
3858 uschar *ss;
3859
3860 for (optionlist * ol = d->info->options; ol < d->info->options + count; ol++)
3861   if ((ol->type & opt_mask) == opt_stringptr)
3862     {
3863     void * options_block = ol->type & opt_public ? (void *)d : d->options_block;
3864     uschar * value = *USS(US options_block + ol->v.offset);
3865
3866     if (value && (ss = Ustrstr(value, s)) != NULL)
3867       {
3868       if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3869         isalnum(ss[Ustrlen(s)])) continue;
3870       DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3871         d->name, ol->name, s);
3872       return TRUE;
3873       }
3874     }
3875
3876 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3877 return FALSE;
3878 }
3879
3880
3881
3882
3883 /*************************************************
3884 *      Decode an error type for retries          *
3885 *************************************************/
3886
3887 /* This function is global because it is also called from the main
3888 program when testing retry information. It decodes strings such as "quota_7d"
3889 into numerical error codes.
3890
3891 Arguments:
3892   pp           points to start of text
3893   p            points past end of text
3894   basic_errno  points to an int to receive the main error number
3895   more_errno   points to an int to receive the secondary error data
3896
3897 Returns:       NULL if decoded correctly; else points to error text
3898 */
3899
3900 uschar *
3901 readconf_retry_error(const uschar *pp, const uschar *p,
3902   int *basic_errno, int *more_errno)
3903 {
3904 int len;
3905 const uschar *q = pp;
3906 while (q < p && *q != '_') q++;
3907 len = q - pp;
3908
3909 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3910   {
3911   *basic_errno = ERRNO_EXIMQUOTA;
3912   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3913       return US"bad time value";
3914   }
3915
3916 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3917   {
3918   *basic_errno = ECONNREFUSED;
3919   if (q != p)
3920     {
3921     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3922     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3923     else return US"A or MX expected after \"refused\"";
3924     }
3925   }
3926
3927 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3928   {
3929   *basic_errno = ETIMEDOUT;
3930   if (q != p)
3931     {
3932     int i;
3933     int xlen = p - q - 1;
3934     const uschar *x = q + 1;
3935
3936     static uschar *extras[] =
3937       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3938     static int values[] =
3939       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3940
3941     for (i = 0; i < nelem(extras); i++)
3942       if (strncmpic(x, extras[i], xlen) == 0)
3943         {
3944         *more_errno = values[i];
3945         break;
3946         }
3947
3948     if (i >= nelem(extras))
3949       if (strncmpic(x, US"DNS", xlen) == 0)
3950         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3951           "available in retry rules (it has never worked) - treated as "
3952           "\"timeout\"");
3953       else
3954         return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3955     }
3956   }
3957
3958 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3959          strncmpic(pp, US"rcpt_4", 6) == 0 ||
3960          strncmpic(pp, US"data_4", 6) == 0)
3961   {
3962   BOOL bad = FALSE;
3963   int x = 255;                           /* means "any 4xx code" */
3964   if (p != pp + 8) bad = TRUE; else
3965     {
3966     int a = pp[6], b = pp[7];
3967     if (isdigit(a))
3968       {
3969       x = (a - '0') * 10;
3970       if (isdigit(b)) x += b - '0';
3971       else if (b == 'x') x += 100;
3972       else bad = TRUE;
3973       }
3974     else if (a != 'x' || b != 'x') bad = TRUE;
3975     }
3976
3977   if (bad)
3978     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3979       "x is literal and d is any digit", pp);
3980
3981   *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
3982                  *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3983   *more_errno = x << 8;
3984   }
3985
3986 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3987          strncmpic(q+1, US"failed", p-q-1) == 0)
3988   *basic_errno = ERRNO_AUTHFAIL;
3989
3990 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3991   *basic_errno = ERRNO_SMTPCLOSED;
3992
3993 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3994   *basic_errno = ERRNO_TLSREQUIRED;
3995
3996 else if (strncmpic(pp, US"lookup", p - pp) == 0)
3997   *basic_errno = ERRNO_UNKNOWNHOST;
3998
3999 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4000   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4001
4002 return NULL;
4003 }
4004
4005
4006
4007
4008 /*************************************************
4009 *                Read retry information          *
4010 *************************************************/
4011
4012 /* Each line of retry information contains:
4013
4014 .  A domain name pattern or an address pattern;
4015
4016 .  An error name, possibly with additional data, or *;
4017
4018 .  An optional sequence of retry items, each consisting of an identifying
4019    letter, a cutoff time, and optional parameters.
4020
4021 All this is decoded and placed into a control block. */
4022
4023
4024 /* Subroutine to read an argument, preceded by a comma and terminated
4025 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4026 1 = fixed point number (returned *1000).
4027
4028 Arguments:
4029   paddr     pointer to pointer to current character; updated
4030   type      0 => read a time; 1 => read a fixed point number
4031
4032 Returns:    time in seconds or fixed point number * 1000
4033 */
4034
4035 static int
4036 retry_arg(const uschar **paddr, int type)
4037 {
4038 const uschar *p = *paddr;
4039 const uschar *pp;
4040
4041 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4042
4043 Uskip_whitespace(&p);
4044 pp = p;
4045 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4046
4047 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4048   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4049
4050 *paddr = p;
4051 switch (type)
4052   {
4053   case 0: return readconf_readtime(pp, *p, FALSE);
4054   case 1: return readconf_readfixed(pp, *p);
4055   }
4056 return 0;    /* Keep picky compilers happy */
4057 }
4058
4059 /* The function proper */
4060
4061 void
4062 readconf_retries(void)
4063 {
4064 retry_config **chain = &retries;
4065 retry_config *next;
4066 const uschar *p;
4067
4068 while ((p = get_config_line()))
4069   {
4070   retry_rule **rchain;
4071   const uschar *pp;
4072   uschar *error;
4073
4074   next = store_get(sizeof(retry_config), FALSE);
4075   next->next = NULL;
4076   *chain = next;
4077   chain = &(next->next);
4078   next->basic_errno = next->more_errno = 0;
4079   next->senders = NULL;
4080   next->rules = NULL;
4081   rchain = &(next->rules);
4082
4083   next->pattern = string_dequote(&p);
4084   Uskip_whitespace(&p);
4085   pp = p;
4086   while (mac_isgraph(*p)) p++;
4087   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4088     "missing error type in retry rule");
4089
4090   /* Test error names for things we understand. */
4091
4092   if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4093        &next->more_errno)))
4094     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4095
4096   /* There may be an optional address list of senders to be used as another
4097   constraint on the rule. This was added later, so the syntax is a bit of a
4098   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4099   an address list. */
4100
4101   Uskip_whitespace(&p);
4102   if (Ustrncmp(p, "senders", 7) == 0)
4103     {
4104     p += 7;
4105     Uskip_whitespace(&p);
4106     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4107       "\"=\" expected after \"senders\" in retry rule");
4108     Uskip_whitespace(&p);
4109     next->senders = string_dequote(&p);
4110     }
4111
4112   /* Now the retry rules. Keep the maximum timeout encountered. */
4113
4114   Uskip_whitespace(&p);
4115
4116   while (*p)
4117     {
4118     retry_rule *rule = store_get(sizeof(retry_rule), FALSE);
4119     *rchain = rule;
4120     rchain = &(rule->next);
4121     rule->next = NULL;
4122     rule->rule = toupper(*p++);
4123     rule->timeout = retry_arg(&p, 0);
4124     if (rule->timeout > retry_maximum_timeout)
4125       retry_maximum_timeout = rule->timeout;
4126
4127     switch (rule->rule)
4128       {
4129       case 'F':   /* Fixed interval */
4130         rule->p1 = retry_arg(&p, 0);
4131         break;
4132
4133       case 'G':   /* Geometrically increasing intervals */
4134       case 'H':   /* Ditto, but with randomness */
4135         rule->p1 = retry_arg(&p, 0);
4136         rule->p2 = retry_arg(&p, 1);
4137         break;
4138
4139       default:
4140         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4141         break;
4142       }
4143
4144     if (rule->timeout <= 0 || rule->p1 <= 0 ||
4145           (rule->rule != 'F' && rule->p2 < 1000))
4146       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4147         "bad parameters for retry rule");
4148
4149     if (Uskip_whitespace(&p) == ';')
4150       {
4151       p++;
4152       Uskip_whitespace(&p);
4153       }
4154     else if (*p)
4155       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4156     }
4157   }
4158 }
4159
4160
4161
4162 /*************************************************
4163 *         Initialize authenticators              *
4164 *************************************************/
4165
4166 /* Read the authenticators section of the configuration file.
4167
4168 Arguments:   none
4169 Returns:     nothing
4170 */
4171
4172 static void
4173 auths_init(void)
4174 {
4175 #ifndef DISABLE_PIPE_CONNECT
4176 int nauths = 0;
4177 #endif
4178
4179 readconf_driver_init(US"authenticator",
4180   (driver_instance **)(&auths),      /* chain anchor */
4181   (driver_info *)auths_available,    /* available drivers */
4182   sizeof(auth_info),                 /* size of info block */
4183   &auth_defaults,                    /* default values for generic options */
4184   sizeof(auth_instance),             /* size of instance block */
4185   optionlist_auths,                  /* generic options */
4186   optionlist_auths_size);
4187
4188 for (auth_instance * au = auths; au; au = au->next)
4189   {
4190   if (!au->public_name)
4191     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4192       "the %s authenticator", au->name);
4193
4194   for (auth_instance * bu = au->next; bu; bu = bu->next)
4195     if (strcmpic(au->public_name, bu->public_name) == 0)
4196       if ((au->client && bu->client) || (au->server && bu->server))
4197         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4198           "(%s and %s) have the same public name (%s)",
4199           au->client ? US"client" : US"server", au->name, bu->name,
4200           au->public_name);
4201 #ifndef DISABLE_PIPE_CONNECT
4202   nauths++;
4203 #endif
4204   }
4205 #ifndef DISABLE_PIPE_CONNECT
4206 f.smtp_in_early_pipe_no_auth = nauths > 16;
4207 #endif
4208 }
4209
4210
4211
4212
4213 /*************************************************
4214 *             Read ACL information               *
4215 *************************************************/
4216
4217 /* If this run of Exim is not doing something that involves receiving a
4218 message, we can just skip over the ACL information. No need to parse it.
4219
4220 First, we have a function for acl_read() to call back to get the next line. We
4221 need to remember the line we passed, because at the end it will contain the
4222 name of the next ACL. */
4223
4224 static uschar *acl_line;
4225
4226 static uschar *
4227 acl_callback(void)
4228 {
4229 acl_line = get_config_line();
4230 return acl_line;
4231 }
4232
4233
4234 /* Now the main function:
4235
4236 Arguments:    none
4237 Returns:      nothing
4238 */
4239
4240 static void
4241 readconf_acl(void)
4242 {
4243 uschar *p;
4244
4245 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4246 between ACLs. */
4247
4248 acl_line = get_config_line();
4249
4250 while(acl_line)
4251   {
4252   uschar name[EXIM_DRIVERNAME_MAX];
4253   tree_node *node;
4254   uschar *error;
4255
4256   p = readconf_readname(name, sizeof(name), acl_line);
4257   if (isupper(*name) && *p == '=')
4258     {
4259     if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
4260     acl_line = get_config_line();
4261     continue;
4262     }
4263
4264   if (*p != ':' || name[0] == 0)
4265     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4266
4267   node = store_get(sizeof(tree_node) + Ustrlen(name), is_tainted(name));
4268   Ustrcpy(node->name, name);
4269   if (!tree_insertnode(&acl_anchor, node))
4270     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4271       "there are two ACLs called \"%s\"", name);
4272
4273   node->data.ptr = acl_read(acl_callback, &error);
4274
4275   if (node->data.ptr == NULL && error != NULL)
4276     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4277   }
4278 }
4279
4280
4281
4282 /*************************************************
4283 *     Read configuration for local_scan()        *
4284 *************************************************/
4285
4286 /* This function is called after "begin local_scan" is encountered in the
4287 configuration file. If the local_scan() function allows for configuration
4288 options, we can process them. Otherwise, we expire in a panic.
4289
4290 Arguments:  none
4291 Returns:    nothing
4292 */
4293
4294 static void
4295 local_scan_init(void)
4296 {
4297 #ifndef LOCAL_SCAN_HAS_OPTIONS
4298 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4299   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4300 #else
4301
4302 uschar *p;
4303 while ((p = get_config_line()))
4304   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4305     NULL, US"local_scan option \"%s\" unknown");
4306 #endif
4307 }
4308
4309
4310
4311 /*************************************************
4312 *     Read rest of configuration (after main)    *
4313 *************************************************/
4314
4315 /* This function reads the rest of the runtime configuration, after the main
4316 configuration. It is called only when actually needed. Each subsequent section
4317 of the configuration starts with a line of the form
4318
4319   begin name
4320
4321 where the name is "routers", "transports", etc. A section is terminated by
4322 hitting the next "begin" line, and the next name is left in next_section.
4323 Because it may confuse people as to whether the names are singular or plural,
4324 we add "s" if it's missing. There is always enough room in next_section for
4325 this. This function is basically just a switch.
4326
4327 Arguments:   none
4328 Returns:     nothing
4329 */
4330
4331 static uschar *section_list[] = {
4332   US"acls",
4333   US"authenticators",
4334   US"local_scans",
4335   US"retrys",
4336   US"rewrites",
4337   US"routers",
4338   US"transports"};
4339
4340 void
4341 readconf_rest(void)
4342 {
4343 int had = 0;
4344
4345 while(next_section[0] != 0)
4346   {
4347   int bit;
4348   int first = 0;
4349   int last = nelem(section_list);
4350   int mid = last/2;
4351   int n = Ustrlen(next_section);
4352
4353   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
4354
4355   for (;;)
4356     {
4357     int c = strcmpic(next_section, section_list[mid]);
4358     if (c == 0) break;
4359     if (c > 0) first = mid + 1; else last = mid;
4360     if (first >= last)
4361       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4362         "\"%.*s\" is not a known configuration section name", n, next_section);
4363     mid = (last + first)/2;
4364     }
4365
4366   bit = 1 << mid;
4367   if (((had ^= bit) & bit) == 0)
4368     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4369       "\"%.*s\" section is repeated in the configuration file", n,
4370         next_section);
4371
4372   switch(mid)
4373     {
4374     case 0: readconf_acl(); break;
4375     case 1: auths_init(); break;
4376     case 2: local_scan_init(); break;
4377     case 3: readconf_retries(); break;
4378     case 4: readconf_rewrites(); break;
4379     case 5: route_init(); break;
4380     case 6: transport_init(); break;
4381     }
4382   }
4383
4384 (void)fclose(config_file);
4385 }
4386
4387 /* Init the storage for the pre-parsed config lines */
4388 void
4389 readconf_save_config(const uschar *s)
4390 {
4391 save_config_line(string_sprintf("# Exim Configuration (%s)",
4392   f.running_in_test_harness ? US"X" : s));
4393 }
4394
4395 static void
4396 save_config_position(const uschar *file, int line)
4397 {
4398 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4399 }
4400
4401 /* Append a pre-parsed logical line to the config lines store,
4402 this operates on a global (static) list that holds all the pre-parsed
4403 config lines, we do no further processing here, output formatting and
4404 honouring of <hide> or macros will be done during output */
4405
4406 static void
4407 save_config_line(const uschar* line)
4408 {
4409 static config_line_item *current;
4410 config_line_item *next;
4411
4412 next = (config_line_item*) store_get(sizeof(config_line_item), FALSE);
4413 next->line = string_copy(line);
4414 next->next = NULL;
4415
4416 if (!config_lines) config_lines = next;
4417 else current->next = next;
4418
4419 current = next;
4420 }
4421
4422 /* List the parsed config lines, care about nice formatting and
4423 hide the <hide> values unless we're the admin user */
4424 void
4425 print_config(BOOL admin, BOOL terse)
4426 {
4427 const int TS = terse ? 0 : 2;
4428 int indent = 0;
4429
4430 for (config_line_item * i = config_lines; i; i = i->next)
4431   {
4432   uschar *current;
4433   uschar *p;
4434
4435   /* skip over to the first non-space */
4436   for (current = i->line; *current && isspace(*current); ++current)
4437     ;
4438
4439   if (*current == '\0')
4440     continue;
4441
4442   /* Collapse runs of spaces. We stop this if we encounter one of the
4443    * following characters: "'$, as this may indicate careful formatting */
4444   for (p = current; *p; ++p)
4445     {
4446     uschar *next;
4447     if (!isspace(*p)) continue;
4448     if (*p != ' ') *p = ' ';
4449
4450     for (next = p; isspace(*next); ++next)
4451       ;
4452
4453     if (next - p > 1)
4454       memmove(p+1, next, Ustrlen(next)+1);
4455
4456     if (*next == '"' || *next == '\'' || *next == '$')
4457       break;
4458     }
4459
4460   /* # lines */
4461   if (current[0] == '#')
4462     puts(CCS current);
4463
4464   /* begin lines are left aligned */
4465   else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4466     {
4467     if (!terse) puts("");
4468     puts(CCS current);
4469     indent = TS;
4470     }
4471
4472   /* router/acl/transport block names */
4473   else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4474     {
4475     if (!terse) puts("");
4476     printf("%*s%s\n", TS, "", current);
4477     indent = 2 * TS;
4478     }
4479
4480   /* hidden lines (all MACROS or lines prefixed with "hide") */
4481   else if (  !admin
4482           && (  isupper(*current)
4483              || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4484              )
4485           )
4486     {
4487     if ((p = Ustrchr(current, '=')))
4488       {
4489       *p = '\0';
4490       printf("%*s%s= %s\n", indent, "", current, CCS hidden);
4491       }
4492     /* e.g.: hide split_spool_directory */
4493     else
4494       printf("%*s\n", indent, CCS hidden);
4495     }
4496
4497   else
4498     /* rest is public */
4499     printf("%*s%s\n", indent, "", current);
4500   }
4501 }
4502
4503 #endif  /*!MACRO_PREDEF*/
4504 /* vi: aw ai sw=2
4505 */
4506 /* End of readconf.c */