src/src/readconf.c

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