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