src/src/readconf.c

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