src/src/readconf.c

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