src/src/readconf.c

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