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