src/src/readconf.c

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