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(const 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(const uschar *s, const uschar *t1, const uschar *t2, const 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(const 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(const uschar *s, const uschar *name)
1337 {
1338 uschar *yield;
1339 const 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 if (*str == '$')
1363   smtp_receive_timeout_s = string_copy(str);
1364 else
1365   {
1366   /* "smtp_receive_timeout",     opt_time,        &smtp_receive_timeout */
1367   smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1368   if (smtp_receive_timeout < 0)
1369     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1370       name);
1371   }
1372 }
1373
1374 /*************************************************
1375 *            Handle option line                  *
1376 *************************************************/
1377
1378 /* This function is called from several places to process a line containing the
1379 setting of an option. The first argument is the line to be decoded; it has been
1380 checked not to be empty and not to start with '#'. Trailing newlines and white
1381 space have been removed. The second argument is a pointer to the list of
1382 variable names that are to be recognized, together with their types and
1383 locations, and the third argument gives the number of entries in the list.
1384
1385 The fourth argument is a pointer to a data block. If it is NULL, then the data
1386 values in the options list are absolute addresses. Otherwise, they are byte
1387 offsets in the data block.
1388
1389 String option data may continue onto several lines; this function reads further
1390 data from config_file if necessary.
1391
1392 The yield of this function is normally zero. If a string continues onto
1393 multiple lines, then the data value is permitted to be followed by a comma
1394 or a semicolon (for use in drivers) and the yield is that character.
1395
1396 Arguments:
1397   buffer        contains the configuration line to be handled
1398   oltop         points to the start of the relevant option list
1399   last          one more than the offset of the last item in the option list
1400   data_block    NULL when reading main options => data values in the option
1401                   list are absolute addresses; otherwise they are byte offsets
1402                   in data_block when they have opt_public set; otherwise
1403                   they are byte offsets in data_block->options_block.
1404   unknown_txt   format string to use in panic message for unknown option;
1405                   must contain %s for option name
1406                 if given as NULL, don't panic on unknown option
1407
1408 Returns:        TRUE if an option was read successfully,
1409                 FALSE false for an unknown option if unknown_txt == NULL,
1410                   otherwise panic and die on an unknown option
1411 */
1412
1413 static BOOL
1414 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1415   void *data_block, uschar *unknown_txt)
1416 {
1417 int ptr = 0;
1418 int offset = 0;
1419 int n, count, type, value;
1420 int issecure = 0;
1421 uid_t uid;
1422 gid_t gid;
1423 BOOL boolvalue = TRUE;
1424 BOOL freesptr = TRUE;
1425 optionlist *ol, *ol2;
1426 struct passwd *pw;
1427 void *reset_point;
1428 int intbase = 0;
1429 uschar *inttype = US"";
1430 uschar *sptr;
1431 uschar *s = buffer;
1432 uschar *saved_condition, *strtemp;
1433 uschar **str_target;
1434 uschar name[64];
1435 uschar name2[64];
1436
1437 /* There may be leading spaces; thereafter, we expect an option name starting
1438 with a letter. */
1439
1440 while (isspace(*s)) s++;
1441 if (!isalpha(*s))
1442   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1443
1444 /* Read the name of the option, and skip any subsequent white space. If
1445 it turns out that what we read was "hide", set the flag indicating that
1446 this is a secure option, and loop to read the next word. */
1447
1448 for (n = 0; n < 2; n++)
1449   {
1450   while (isalnum(*s) || *s == '_')
1451     {
1452     if (ptr < sizeof(name)-1) name[ptr++] = *s;
1453     s++;
1454     }
1455   name[ptr] = 0;
1456   while (isspace(*s)) s++;
1457   if (Ustrcmp(name, "hide") != 0) break;
1458   issecure = opt_secure;
1459   ptr = 0;
1460   }
1461
1462 /* Deal with "no_" or "not_" here for booleans */
1463
1464 if (Ustrncmp(name, "no_", 3) == 0)
1465   {
1466   boolvalue = FALSE;
1467   offset = 3;
1468   }
1469
1470 if (Ustrncmp(name, "not_", 4) == 0)
1471   {
1472   boolvalue = FALSE;
1473   offset = 4;
1474   }
1475
1476 /* Search the list for the given name. A non-existent name, or an option that
1477 is set twice, is a disaster. */
1478
1479 ol = find_option(name + offset, oltop, last);
1480
1481 if (ol == NULL)
1482   {
1483   if (unknown_txt == NULL) return FALSE;
1484   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1485   }
1486
1487 if ((ol->type & opt_set)  && !(ol->type & (opt_rep_con | opt_rep_str)))
1488   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1489     "\"%s\" option set for the second time", name);
1490
1491 ol->type |= opt_set | issecure;
1492 type = ol->type & opt_mask;
1493
1494 /* Types with data values must be followed by '='; the "no[t]_" prefix
1495 applies only to boolean values. */
1496
1497 if (type < opt_bool || type > opt_bool_last)
1498   {
1499   if (offset != 0)
1500     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1501       "negation prefix applied to a non-boolean option");
1502   if (*s == 0)
1503     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1504       "unexpected end of line (data missing) after %s", name);
1505   if (*s != '=')
1506     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1507   }
1508
1509 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1510 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1511 ultimately expands to one of those values. */
1512
1513 else if (*s != 0 && (offset != 0 || *s != '='))
1514   extra_chars_error(s, US"boolean option ", name, US"");
1515
1516 /* Skip white space after = */
1517
1518 if (*s == '=') while (isspace((*(++s))));
1519
1520 /* If there is a data block and the opt_public flag is not set, change
1521 the data block pointer to the private options block. */
1522
1523 if (data_block != NULL && (ol->type & opt_public) == 0)
1524   data_block = (void *)(((driver_instance *)data_block)->options_block);
1525
1526 /* Now get the data according to the type. */
1527
1528 switch (type)
1529   {
1530   /* If a string value is not enclosed in quotes, it consists of
1531   the rest of the current line, verbatim. Otherwise, string escapes
1532   are processed.
1533
1534   A transport is specified as a string, which is then looked up in the
1535   list of transports. A search type is specified as one of a number of
1536   known strings.
1537
1538   A set or rewrite rules for a driver is specified as a string, which is
1539   then parsed into a suitable chain of control blocks.
1540
1541   Uids and gids are specified as strings which are then looked up in the
1542   passwd file. Lists of uids and gids are similarly specified as colon-
1543   separated strings. */
1544
1545   case opt_stringptr:
1546   case opt_uid:
1547   case opt_gid:
1548   case opt_expand_uid:
1549   case opt_expand_gid:
1550   case opt_uidlist:
1551   case opt_gidlist:
1552   case opt_rewrite:
1553
1554   reset_point = sptr = read_string(s, name);
1555
1556   /* Having read a string, we now have several different ways of using it,
1557   depending on the data type, so do another switch. If keeping the actual
1558   string is not required (because it is interpreted), freesptr is set TRUE,
1559   and at the end we reset the pool. */
1560
1561   switch (type)
1562     {
1563     /* If this was a string, set the variable to point to the new string,
1564     and set the flag so its store isn't reclaimed. If it was a list of rewrite
1565     rules, we still keep the string (for printing), and parse the rules into a
1566     control block and flags word. */
1567
1568     case opt_stringptr:
1569     if (data_block == NULL)
1570       str_target = (uschar **)(ol->value);
1571     else
1572       str_target = (uschar **)((uschar *)data_block + (long int)(ol->value));
1573     if (ol->type & opt_rep_con)
1574       {
1575       /* We already have a condition, we're conducting a crude hack to let
1576       multiple condition rules be chained together, despite storing them in
1577       text form. */
1578       saved_condition = *str_target;
1579       strtemp = string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1580           saved_condition, sptr);
1581       *str_target = string_copy_malloc(strtemp);
1582       /* TODO(pdp): there is a memory leak here and just below
1583       when we set 3 or more conditions; I still don't
1584       understand the store mechanism enough to know
1585       what's the safe way to free content from an earlier store.
1586       AFAICT, stores stack, so freeing an early stored item also stores
1587       all data alloc'd after it.  If we knew conditions were adjacent,
1588       we could survive that, but we don't.  So I *think* we need to take
1589       another bit from opt_type to indicate "malloced"; this seems like
1590       quite a hack, especially for this one case.  It also means that
1591       we can't ever reclaim the store from the *first* condition.
1592
1593       Because we only do this once, near process start-up, I'm prepared to
1594       let this slide for the time being, even though it rankles.  */
1595       }
1596     else if (ol->type & opt_rep_str)
1597       {
1598       uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1599       int    sep_i = -(int)sep_o;
1600       const uschar * list = sptr;
1601       uschar * s;
1602       uschar * list_o = *str_target;
1603
1604       while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1605         list_o = string_append_listele(list_o, sep_o, s);
1606       if (list_o)
1607         *str_target = string_copy_malloc(list_o);
1608       }
1609     else
1610       {
1611       *str_target = sptr;
1612       freesptr = FALSE;
1613       }
1614     break;
1615
1616     case opt_rewrite:
1617     if (data_block == NULL)
1618       *((uschar **)(ol->value)) = sptr;
1619     else
1620       *((uschar **)((uschar *)data_block + (long int)(ol->value))) = sptr;
1621     freesptr = FALSE;
1622     if (type == opt_rewrite)
1623       {
1624       int sep = 0;
1625       int *flagptr;
1626       uschar *p = sptr;
1627       rewrite_rule **chain;
1628       optionlist *ol3;
1629
1630       sprintf(CS name2, "*%.50s_rules", name);
1631       ol2 = find_option(name2, oltop, last);
1632       sprintf(CS name2, "*%.50s_flags", name);
1633       ol3 = find_option(name2, oltop, last);
1634
1635       if (ol2 == NULL || ol3 == NULL)
1636         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1637           "rewrite rules not available for driver");
1638
1639       if (data_block == NULL)
1640         {
1641         chain = (rewrite_rule **)(ol2->value);
1642         flagptr = (int *)(ol3->value);
1643         }
1644       else
1645         {
1646         chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1647         flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1648         }
1649
1650       while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1651         {
1652         rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1653         *chain = next;
1654         chain = &(next->next);
1655         }
1656
1657       if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1658         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1659           "non-header rewrite - not allowed at transport time -");
1660       }
1661     break;
1662
1663     /* If it was an expanded uid, see if there is any expansion to be
1664     done by checking for the presence of a $ character. If there is, save it
1665     in the corresponding *expand_user option field. Otherwise, fall through
1666     to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1667     of data. */
1668
1669     case opt_expand_uid:
1670     sprintf(CS name2, "*expand_%.50s", name);
1671     ol2 = find_option(name2, oltop, last);
1672     if (ol2 != NULL)
1673       {
1674       uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1675
1676       if (data_block == NULL)
1677         *((uschar **)(ol2->value)) = ss;
1678       else
1679         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1680
1681       if (ss != NULL)
1682         {
1683         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1684         freesptr = FALSE;
1685         break;
1686         }
1687       }
1688
1689     /* Look up a fixed uid, and also make use of the corresponding gid
1690     if a passwd entry is returned and the gid has not been set. */
1691
1692     case opt_uid:
1693     if (!route_finduser(sptr, &pw, &uid))
1694       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1695     if (data_block == NULL)
1696       *((uid_t *)(ol->value)) = uid;
1697     else
1698       *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1699
1700     /* Set the flag indicating a fixed value is set */
1701
1702     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1703
1704     /* Handle matching gid if we have a passwd entry: done by finding the
1705     same name with terminating "user" changed to "group"; if not found,
1706     ignore. Also ignore if the value is already set. */
1707
1708     if (pw == NULL) break;
1709     Ustrcpy(name+Ustrlen(name)-4, "group");
1710     ol2 = find_option(name, oltop, last);
1711     if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1712         (ol2->type & opt_mask) == opt_expand_gid))
1713       {
1714       BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1715       if (! *set_flag)
1716         {
1717         if (data_block == NULL)
1718           *((gid_t *)(ol2->value)) = pw->pw_gid;
1719         else
1720           *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1721         *set_flag = TRUE;
1722         }
1723       }
1724     break;
1725
1726     /* If it was an expanded gid, see if there is any expansion to be
1727     done by checking for the presence of a $ character. If there is, save it
1728     in the corresponding *expand_user option field. Otherwise, fall through
1729     to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1730     of data. */
1731
1732     case opt_expand_gid:
1733     sprintf(CS name2, "*expand_%.50s", name);
1734     ol2 = find_option(name2, oltop, last);
1735     if (ol2 != NULL)
1736       {
1737       uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1738
1739       if (data_block == NULL)
1740         *((uschar **)(ol2->value)) = ss;
1741       else
1742         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1743
1744       if (ss != NULL)
1745         {
1746         *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1747         freesptr = FALSE;
1748         break;
1749         }
1750       }
1751
1752     /* Handle freestanding gid */
1753
1754     case opt_gid:
1755     if (!route_findgroup(sptr, &gid))
1756       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1757     if (data_block == NULL)
1758       *((gid_t *)(ol->value)) = gid;
1759     else
1760       *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1761     *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1762     break;
1763
1764     /* If it was a uid list, look up each individual entry, and build
1765     a vector of uids, with a count in the first element. Put the vector
1766     in malloc store so we can free the string. (We are reading into
1767     permanent store already.) */
1768
1769     case opt_uidlist:
1770       {
1771       int count = 1;
1772       uid_t *list;
1773       int ptr = 0;
1774       const uschar *p;
1775       const uschar *op = expand_string (sptr);
1776
1777       if (op == NULL)
1778         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1779           name, expand_string_message);
1780
1781       p = op;
1782       if (*p != 0) count++;
1783       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1784       list = store_malloc(count*sizeof(uid_t));
1785       list[ptr++] = (uid_t)(count - 1);
1786
1787       if (data_block == NULL)
1788         *((uid_t **)(ol->value)) = list;
1789       else
1790         *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1791
1792       p = op;
1793       while (count-- > 1)
1794         {
1795         int sep = 0;
1796         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1797         if (!route_finduser(big_buffer, NULL, &uid))
1798           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1799             big_buffer);
1800         list[ptr++] = uid;
1801         }
1802       }
1803     break;
1804
1805     /* If it was a gid list, look up each individual entry, and build
1806     a vector of gids, with a count in the first element. Put the vector
1807     in malloc store so we can free the string. (We are reading into permanent
1808     store already.) */
1809
1810     case opt_gidlist:
1811       {
1812       int count = 1;
1813       gid_t *list;
1814       int ptr = 0;
1815       const uschar *p;
1816       const uschar *op = expand_string (sptr);
1817
1818       if (op == NULL)
1819         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1820           name, expand_string_message);
1821
1822       p = op;
1823       if (*p != 0) count++;
1824       while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1825       list = store_malloc(count*sizeof(gid_t));
1826       list[ptr++] = (gid_t)(count - 1);
1827
1828       if (data_block == NULL)
1829         *((gid_t **)(ol->value)) = list;
1830       else
1831         *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1832
1833       p = op;
1834       while (count-- > 1)
1835         {
1836         int sep = 0;
1837         (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1838         if (!route_findgroup(big_buffer, &gid))
1839           log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1840             big_buffer);
1841         list[ptr++] = gid;
1842         }
1843       }
1844     break;
1845     }
1846
1847   /* Release store if the value of the string doesn't need to be kept. */
1848
1849   if (freesptr) store_reset(reset_point);
1850   break;
1851
1852   /* Expanded boolean: if no characters follow, or if there are no dollar
1853   characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1854   save the string for later expansion in the alternate place. */
1855
1856   case opt_expand_bool:
1857   if (*s != 0 && Ustrchr(s, '$') != 0)
1858     {
1859     sprintf(CS name2, "*expand_%.50s", name);
1860     ol2 = find_option(name2, oltop, last);
1861     if (ol2 != NULL)
1862       {
1863       reset_point = sptr = read_string(s, name);
1864       if (data_block == NULL)
1865         *((uschar **)(ol2->value)) = sptr;
1866       else
1867         *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1868       freesptr = FALSE;
1869       break;
1870       }
1871     }
1872   /* Fall through */
1873
1874   /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1875   look for yes/not/true/false. Some booleans are stored in a single bit in
1876   a single int. There's a special fudge for verify settings; without a suffix
1877   they set both xx_sender and xx_recipient. The table points to the sender
1878   value; search subsequently for the recipient. There's another special case:
1879   opt_bool_set also notes when a boolean has been set. */
1880
1881   case opt_bool:
1882   case opt_bit:
1883   case opt_bool_verify:
1884   case opt_bool_set:
1885   if (*s != 0)
1886     {
1887     s = readconf_readname(name2, 64, s);
1888     if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1889       boolvalue = TRUE;
1890     else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1891       boolvalue = FALSE;
1892     else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1893       "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1894     if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1895       US"for boolean option ", name);
1896     }
1897
1898   /* Handle single-bit type. */
1899
1900   if (type == opt_bit)
1901     {
1902     int bit = 1 << ((ol->type >> 16) & 31);
1903     int *ptr = (data_block == NULL)?
1904       (int *)(ol->value) :
1905       (int *)((uschar *)data_block + (long int)ol->value);
1906     if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1907     break;
1908     }
1909
1910   /* Handle full BOOL types */
1911
1912   if (data_block == NULL)
1913     *((BOOL *)(ol->value)) = boolvalue;
1914   else
1915     *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1916
1917   /* Verify fudge */
1918
1919   if (type == opt_bool_verify)
1920     {
1921     sprintf(CS name2, "%.50s_recipient", name + offset);
1922     ol2 = find_option(name2, oltop, last);
1923     if (ol2 != NULL)
1924       {
1925       if (data_block == NULL)
1926         *((BOOL *)(ol2->value)) = boolvalue;
1927       else
1928         *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1929       }
1930     }
1931
1932   /* Note that opt_bool_set type is set, if there is somewhere to do so */
1933
1934   else if (type == opt_bool_set)
1935     {
1936     sprintf(CS name2, "*set_%.50s", name + offset);
1937     ol2 = find_option(name2, oltop, last);
1938     if (ol2 != NULL)
1939       {
1940       if (data_block == NULL)
1941         *((BOOL *)(ol2->value)) = TRUE;
1942       else
1943         *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1944       }
1945     }
1946   break;
1947
1948   /* Octal integer */
1949
1950   case opt_octint:
1951   intbase = 8;
1952   inttype = US"octal ";
1953
1954   /*  Integer: a simple(ish) case; allow octal and hex formats, and
1955   suffixes K and M. The different types affect output, not input. */
1956
1957   case opt_mkint:
1958   case opt_int:
1959     {
1960     uschar *endptr;
1961     long int lvalue;
1962
1963     errno = 0;
1964     lvalue = strtol(CS s, CSS &endptr, intbase);
1965
1966     if (endptr == s)
1967       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1968         inttype, name);
1969
1970     if (errno != ERANGE)
1971       {
1972       if (tolower(*endptr) == 'k')
1973         {
1974         if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
1975           else lvalue *= 1024;
1976         endptr++;
1977         }
1978       else if (tolower(*endptr) == 'm')
1979         {
1980         if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
1981           errno = ERANGE;
1982         else lvalue *= 1024*1024;
1983         endptr++;
1984         }
1985       }
1986
1987     if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
1988       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1989         "absolute value of integer \"%s\" is too large (overflow)", s);
1990
1991     while (isspace(*endptr)) endptr++;
1992     if (*endptr != 0)
1993       extra_chars_error(endptr, inttype, US"integer value for ", name);
1994
1995     value = (int)lvalue;
1996     }
1997
1998   if (data_block == NULL)
1999     *((int *)(ol->value)) = value;
2000   else
2001     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2002   break;
2003
2004   /*  Integer held in K: again, allow octal and hex formats, and suffixes K and
2005   M. */
2006
2007   case opt_Kint:
2008     {
2009     uschar *endptr;
2010     errno = 0;
2011     value = strtol(CS s, CSS &endptr, intbase);
2012
2013     if (endptr == s)
2014       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2015         inttype, name);
2016
2017     if (errno != ERANGE)
2018       {
2019       if (tolower(*endptr) == 'm')
2020         {
2021         if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
2022           else value *= 1024;
2023         endptr++;
2024         }
2025       else if (tolower(*endptr) == 'k')
2026         {
2027         endptr++;
2028         }
2029       else
2030         {
2031         value = (value + 512)/1024;
2032         }
2033       }
2034
2035     if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2036       "absolute value of integer \"%s\" is too large (overflow)", s);
2037
2038     while (isspace(*endptr)) endptr++;
2039     if (*endptr != 0)
2040       extra_chars_error(endptr, inttype, US"integer value for ", name);
2041     }
2042
2043   if (data_block == NULL)
2044     *((int *)(ol->value)) = value;
2045   else
2046     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2047   break;
2048
2049   /*  Fixed-point number: held to 3 decimal places. */
2050
2051   case opt_fixed:
2052   if (sscanf(CS s, "%d%n", &value, &count) != 1)
2053     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2054       "fixed-point number expected for %s", name);
2055
2056   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2057     "integer \"%s\" is too large (overflow)", s);
2058
2059   value *= 1000;
2060
2061   if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2062     "integer \"%s\" is too large (overflow)", s);
2063
2064   if (s[count] == '.')
2065     {
2066     int d = 100;
2067     while (isdigit(s[++count]))
2068       {
2069       value += (s[count] - '0') * d;
2070       d /= 10;
2071       }
2072     }
2073
2074   while (isspace(s[count])) count++;
2075
2076   if (s[count] != 0)
2077     extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2078
2079   if (data_block == NULL)
2080     *((int *)(ol->value)) = value;
2081   else
2082     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2083   break;
2084
2085   /* There's a special routine to read time values. */
2086
2087   case opt_time:
2088   value = readconf_readtime(s, 0, FALSE);
2089   if (value < 0)
2090     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2091       name);
2092   if (data_block == NULL)
2093     *((int *)(ol->value)) = value;
2094   else
2095     *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2096   break;
2097
2098   /* A time list is a list of colon-separated times, with the first
2099   element holding the size of the list and the second the number of
2100   entries used. */
2101
2102   case opt_timelist:
2103     {
2104     int count = 0;
2105     int *list = (data_block == NULL)?
2106       (int *)(ol->value) :
2107       (int *)((uschar *)data_block + (long int)(ol->value));
2108
2109     if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2110       {
2111       int terminator = 0;
2112       uschar *snext = Ustrchr(s, ':');
2113       if (snext != NULL)
2114         {
2115         uschar *ss = snext;
2116         while (ss > s && isspace(ss[-1])) ss--;
2117         terminator = *ss;
2118         }
2119       value = readconf_readtime(s, terminator, FALSE);
2120       if (value < 0)
2121         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2122           name);
2123       if (count > 1 && value <= list[count])
2124         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2125           "time value out of order for %s", name);
2126       list[count+1] = value;
2127       if (snext == NULL) break;
2128       s = snext + 1;
2129       while (isspace(*s)) s++;
2130       }
2131
2132     if (count > list[0] - 2)
2133       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2134         name);
2135     if (count > 0 && list[2] == 0) count = 0;
2136     list[1] = count;
2137     break;
2138     }
2139
2140   case opt_func:
2141     {
2142     void (*fn)() = ol->value;
2143     fn(name, s);
2144     break;
2145     }
2146   }
2147
2148 return TRUE;
2149 }
2150
2151
2152
2153 /*************************************************
2154 *               Print a time value               *
2155 *************************************************/
2156
2157 /*
2158 Argument:  a time value in seconds
2159 Returns:   pointer to a fixed buffer containing the time as a string,
2160            in readconf_readtime() format
2161 */
2162
2163 uschar *
2164 readconf_printtime(int t)
2165 {
2166 int s, m, h, d, w;
2167 uschar *p = time_buffer;
2168
2169 if (t < 0)
2170   {
2171   *p++ = '-';
2172   t = -t;
2173   }
2174
2175 s = t % 60;
2176 t /= 60;
2177 m = t % 60;
2178 t /= 60;
2179 h = t % 24;
2180 t /= 24;
2181 d = t % 7;
2182 w = t/7;
2183
2184 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2185 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2186 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2187 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2188 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2189
2190 return time_buffer;
2191 }
2192
2193
2194
2195 /*************************************************
2196 *      Print an individual option value          *
2197 *************************************************/
2198
2199 /* This is used by the -bP option, so prints to the standard output.
2200 The entire options list is passed in as an argument, because some options come
2201 in pairs - typically uid/gid settings, which can either be explicit numerical
2202 values, or strings to be expanded later. If the numerical value is unset,
2203 search for "*expand_<name>" to see if there is a string equivalent.
2204
2205 Arguments:
2206   ol             option entry, or NULL for an unknown option
2207   name           option name
2208   options_block  NULL for main configuration options; otherwise points to
2209                    a driver block; if the option doesn't have opt_public
2210                    set, then options_block->options_block is where the item
2211                    resides.
2212   oltop          points to the option list in which ol exists
2213   last           one more than the offset of the last entry in optop
2214   no_labels      do not show "foo = " at the start.
2215
2216 Returns:         nothing
2217 */
2218
2219 static void
2220 print_ol(optionlist *ol, uschar *name, void *options_block,
2221   optionlist *oltop, int last, BOOL no_labels)
2222 {
2223 struct passwd *pw;
2224 struct group *gr;
2225 optionlist *ol2;
2226 void *value;
2227 uid_t *uidlist;
2228 gid_t *gidlist;
2229 uschar *s;
2230 uschar name2[64];
2231
2232 if (ol == NULL)
2233   {
2234   printf("%s is not a known option\n", name);
2235   return;
2236   }
2237
2238 /* Non-admin callers cannot see options that have been flagged secure by the
2239 "hide" prefix. */
2240
2241 if (!admin_user && (ol->type & opt_secure) != 0)
2242   {
2243   const char * const hidden = "<value not displayable>";
2244   if (no_labels)
2245     printf("%s\n", hidden);
2246   else
2247     printf("%s = %s\n", name, hidden);
2248   return;
2249   }
2250
2251 /* Else show the value of the option */
2252
2253 value = ol->value;
2254 if (options_block != NULL)
2255   {
2256   if ((ol->type & opt_public) == 0)
2257     options_block = (void *)(((driver_instance *)options_block)->options_block);
2258   value = (void *)((uschar *)options_block + (long int)value);
2259   }
2260
2261 switch(ol->type & opt_mask)
2262   {
2263   case opt_stringptr:
2264   case opt_rewrite:        /* Show the text value */
2265   s = *((uschar **)value);
2266   if (!no_labels) printf("%s = ", name);
2267   printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
2268   break;
2269
2270   case opt_int:
2271   if (!no_labels) printf("%s = ", name);
2272   printf("%d\n", *((int *)value));
2273   break;
2274
2275   case opt_mkint:
2276     {
2277     int x = *((int *)value);
2278     if (x != 0 && (x & 1023) == 0)
2279       {
2280       int c = 'K';
2281       x >>= 10;
2282       if ((x & 1023) == 0)
2283         {
2284         c = 'M';
2285         x >>= 10;
2286         }
2287       if (!no_labels) printf("%s = ", name);
2288       printf("%d%c\n", x, c);
2289       }
2290     else
2291       {
2292       if (!no_labels) printf("%s = ", name);
2293       printf("%d\n", x);
2294       }
2295     }
2296   break;
2297
2298   case opt_Kint:
2299     {
2300     int x = *((int *)value);
2301     if (!no_labels) printf("%s = ", name);
2302     if (x == 0) printf("0\n");
2303       else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2304         else printf("%dK\n", x);
2305     }
2306   break;
2307
2308   case opt_octint:
2309   if (!no_labels) printf("%s = ", name);
2310   printf("%#o\n", *((int *)value));
2311   break;
2312
2313   /* Can be negative only when "unset", in which case integer */
2314
2315   case opt_fixed:
2316     {
2317     int x = *((int *)value);
2318     int f = x % 1000;
2319     int d = 100;
2320     if (x < 0) printf("%s =\n", name); else
2321       {
2322       if (!no_labels) printf("%s = ", name);
2323       printf("%d.", x/1000);
2324       do
2325         {
2326         printf("%d", f/d);
2327         f %= d;
2328         d /= 10;
2329         }
2330       while (f != 0);
2331       printf("\n");
2332       }
2333     }
2334   break;
2335
2336   /* If the numerical value is unset, try for the string value */
2337
2338   case opt_expand_uid:
2339   if (! *get_set_flag(name, oltop, last, options_block))
2340     {
2341     sprintf(CS name2, "*expand_%.50s", name);
2342     ol2 = find_option(name2, oltop, last);
2343     if (ol2 != NULL)
2344       {
2345       void *value2 = ol2->value;
2346       if (options_block != NULL)
2347         value2 = (void *)((uschar *)options_block + (long int)value2);
2348       s = *((uschar **)value2);
2349       if (!no_labels) printf("%s = ", name);
2350       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2351       break;
2352       }
2353     }
2354
2355   /* Else fall through */
2356
2357   case opt_uid:
2358   if (!no_labels) printf("%s = ", name);
2359   if (! *get_set_flag(name, oltop, last, options_block))
2360     printf("\n");
2361   else
2362     {
2363     pw = getpwuid(*((uid_t *)value));
2364     if (pw == NULL)
2365       printf("%ld\n", (long int)(*((uid_t *)value)));
2366     else printf("%s\n", pw->pw_name);
2367     }
2368   break;
2369
2370   /* If the numerical value is unset, try for the string value */
2371
2372   case opt_expand_gid:
2373   if (! *get_set_flag(name, oltop, last, options_block))
2374     {
2375     sprintf(CS name2, "*expand_%.50s", name);
2376     ol2 = find_option(name2, oltop, last);
2377     if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2378       {
2379       void *value2 = ol2->value;
2380       if (options_block != NULL)
2381         value2 = (void *)((uschar *)options_block + (long int)value2);
2382       s = *((uschar **)value2);
2383       if (!no_labels) printf("%s = ", name);
2384       printf("%s\n", (s == NULL)? US"" : string_printing(s));
2385       break;
2386       }
2387     }
2388
2389   /* Else fall through */
2390
2391   case opt_gid:
2392   if (!no_labels) printf("%s = ", name);
2393   if (! *get_set_flag(name, oltop, last, options_block))
2394     printf("\n");
2395   else
2396     {
2397     gr = getgrgid(*((int *)value));
2398     if (gr == NULL)
2399        printf("%ld\n", (long int)(*((int *)value)));
2400     else printf("%s\n", gr->gr_name);
2401     }
2402   break;
2403
2404   case opt_uidlist:
2405   uidlist = *((uid_t **)value);
2406   if (!no_labels) printf("%s =", name);
2407   if (uidlist != NULL)
2408     {
2409     int i;
2410     uschar sep = ' ';
2411     if (no_labels) sep = '\0';
2412     for (i = 1; i <= (int)(uidlist[0]); i++)
2413       {
2414       uschar *name = NULL;
2415       pw = getpwuid(uidlist[i]);
2416       if (pw != NULL) name = US pw->pw_name;
2417       if (sep != '\0') printf("%c", sep);
2418       if (name != NULL) printf("%s", name);
2419         else printf("%ld", (long int)(uidlist[i]));
2420       sep = ':';
2421       }
2422     }
2423   printf("\n");
2424   break;
2425
2426   case opt_gidlist:
2427   gidlist = *((gid_t **)value);
2428   if (!no_labels) printf("%s =", name);
2429   if (gidlist != NULL)
2430     {
2431     int i;
2432     uschar sep = ' ';
2433     if (no_labels) sep = '\0';
2434     for (i = 1; i <= (int)(gidlist[0]); i++)
2435       {
2436       uschar *name = NULL;
2437       gr = getgrgid(gidlist[i]);
2438       if (gr != NULL) name = US gr->gr_name;
2439       if (sep != '\0') printf("%c", sep);
2440       if (name != NULL) printf("%s", name);
2441         else printf("%ld", (long int)(gidlist[i]));
2442       sep = ':';
2443       }
2444     }
2445   printf("\n");
2446   break;
2447
2448   case opt_time:
2449   if (!no_labels) printf("%s = ", name);
2450   printf("%s\n", readconf_printtime(*((int *)value)));
2451   break;
2452
2453   case opt_timelist:
2454     {
2455     int i;
2456     int *list = (int *)value;
2457     if (!no_labels) printf("%s = ", name);
2458     for (i = 0; i < list[1]; i++)
2459       printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2460     printf("\n");
2461     }
2462   break;
2463
2464   case opt_bit:
2465   printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2466     "" : "no_", name);
2467   break;
2468
2469   case opt_expand_bool:
2470   sprintf(CS name2, "*expand_%.50s", name);
2471   ol2 = find_option(name2, oltop, last);
2472   if (ol2 != NULL && ol2->value != NULL)
2473     {
2474     void *value2 = ol2->value;
2475     if (options_block != NULL)
2476       value2 = (void *)((uschar *)options_block + (long int)value2);
2477     s = *((uschar **)value2);
2478     if (s != NULL)
2479       {
2480       if (!no_labels) printf("%s = ", name);
2481       printf("%s\n", string_printing(s));
2482       break;
2483       }
2484     /* s == NULL => string not set; fall through */
2485     }
2486
2487   /* Fall through */
2488
2489   case opt_bool:
2490   case opt_bool_verify:
2491   case opt_bool_set:
2492   printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2493   break;
2494   }
2495 }
2496
2497
2498
2499 /*************************************************
2500 *        Print value from main configuration     *
2501 *************************************************/
2502
2503 /* This function, called as a result of encountering the -bP option,
2504 causes the value of any main configuration variable to be output if the
2505 second argument is NULL. There are some special values:
2506
2507   all                print all main configuration options
2508   configure_file     print the name of the configuration file
2509   routers            print the routers' configurations
2510   transports         print the transports' configuration
2511   authenticators     print the authenticators' configuration
2512   macros             print the macros' configuration
2513   router_list        print a list of router names
2514   transport_list     print a list of transport names
2515   authenticator_list print a list of authentication mechanism names
2516   macro_list         print a list of macro names
2517   +name              print a named list item
2518   local_scan         print the local_scan options
2519
2520 If the second argument is not NULL, it must be one of "router", "transport",
2521 "authenticator" or "macro" in which case the first argument identifies the
2522 driver whose options are to be printed.
2523
2524 Arguments:
2525   name        option name if type == NULL; else driver name
2526   type        NULL or driver type name, as described above
2527   no_labels   avoid the "foo = " at the start of an item
2528
2529 Returns:      nothing
2530 */
2531
2532 void
2533 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2534 {
2535 BOOL names_only = FALSE;
2536 optionlist *ol;
2537 optionlist *ol2 = NULL;
2538 driver_instance *d = NULL;
2539 macro_item *m;
2540 int size = 0;
2541
2542 if (type == NULL)
2543   {
2544   if (*name == '+')
2545     {
2546     int i;
2547     tree_node *t;
2548     BOOL found = FALSE;
2549     static uschar *types[] = { US"address", US"domain", US"host",
2550       US"localpart" };
2551     static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2552       &hostlist_anchor, &localpartlist_anchor };
2553
2554     for (i = 0; i < 4; i++)
2555       {
2556       t = tree_search(*(anchors[i]), name+1);
2557       if (t != NULL)
2558         {
2559         found = TRUE;
2560         if (no_labels)
2561           printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2562         else
2563           printf("%slist %s = %s\n", types[i], name+1,
2564             ((namedlist_block *)(t->data.ptr))->string);
2565         }
2566       }
2567
2568     if (!found)
2569       printf("no address, domain, host, or local part list called \"%s\" "
2570         "exists\n", name+1);
2571
2572     return;
2573     }
2574
2575   if (Ustrcmp(name, "configure_file") == 0)
2576     {
2577     printf("%s\n", CS config_main_filename);
2578     return;
2579     }
2580
2581   if (Ustrcmp(name, "all") == 0)
2582     {
2583     for (ol = optionlist_config;
2584          ol < optionlist_config + optionlist_config_size; ol++)
2585       {
2586       if ((ol->type & opt_hidden) == 0)
2587         print_ol(ol, US ol->name, NULL,
2588             optionlist_config, optionlist_config_size,
2589             no_labels);
2590       }
2591     return;
2592     }
2593
2594   if (Ustrcmp(name, "local_scan") == 0)
2595     {
2596     #ifndef LOCAL_SCAN_HAS_OPTIONS
2597     printf("local_scan() options are not supported\n");
2598     #else
2599     for (ol = local_scan_options;
2600          ol < local_scan_options + local_scan_options_count; ol++)
2601       {
2602       print_ol(ol, US ol->name, NULL, local_scan_options,
2603         local_scan_options_count, no_labels);
2604       }
2605     #endif
2606     return;
2607     }
2608
2609   if (Ustrcmp(name, "routers") == 0)
2610     {
2611     type = US"router";
2612     name = NULL;
2613     }
2614   else if (Ustrcmp(name, "transports") == 0)
2615     {
2616     type = US"transport";
2617     name = NULL;
2618     }
2619
2620   else if (Ustrcmp(name, "authenticators") == 0)
2621     {
2622     type = US"authenticator";
2623     name = NULL;
2624     }
2625
2626   else if (Ustrcmp(name, "macros") == 0)
2627     {
2628     type = US"macro";
2629     name = NULL;
2630     }
2631
2632   else if (Ustrcmp(name, "router_list") == 0)
2633     {
2634     type = US"router";
2635     name = NULL;
2636     names_only = TRUE;
2637     }
2638
2639   else if (Ustrcmp(name, "transport_list") == 0)
2640     {
2641     type = US"transport";
2642     name = NULL;
2643     names_only = TRUE;
2644     }
2645
2646   else if (Ustrcmp(name, "authenticator_list") == 0)
2647     {
2648     type = US"authenticator";
2649     name = NULL;
2650     names_only = TRUE;
2651     }
2652
2653   else if (Ustrcmp(name, "macro_list") == 0)
2654     {
2655     type = US"macro";
2656     name = NULL;
2657     names_only = TRUE;
2658     }
2659
2660   else
2661     {
2662     print_ol(find_option(name, optionlist_config, optionlist_config_size),
2663       name, NULL, optionlist_config, optionlist_config_size, no_labels);
2664     return;
2665     }
2666   }
2667
2668 /* Handle the options for a router or transport. Skip options that are flagged
2669 as hidden. Some of these are options with names starting with '*', used for
2670 internal alternative representations of other options (which the printing
2671 function will sort out). Others are synonyms kept for backward compatibility.
2672 */
2673
2674 if (Ustrcmp(type, "router") == 0)
2675   {
2676   d = (driver_instance *)routers;
2677   ol2 = optionlist_routers;
2678   size = optionlist_routers_size;
2679   }
2680 else if (Ustrcmp(type, "transport") == 0)
2681   {
2682   d = (driver_instance *)transports;
2683   ol2 = optionlist_transports;
2684   size = optionlist_transports_size;
2685   }
2686 else if (Ustrcmp(type, "authenticator") == 0)
2687   {
2688   d = (driver_instance *)auths;
2689   ol2 = optionlist_auths;
2690   size = optionlist_auths_size;
2691   }
2692
2693 else if (Ustrcmp(type, "macro") == 0)
2694   {
2695   /* People store passwords in macros and they were previously not available
2696   for printing.  So we have an admin_users restriction. */
2697   if (!admin_user)
2698     {
2699     fprintf(stderr, "exim: permission denied\n");
2700     exit(EXIT_FAILURE);
2701     }
2702   for (m = macros; m != NULL; m = m->next)
2703     {
2704     if (name == NULL || Ustrcmp(name, m->name) == 0)
2705       {
2706       if (names_only)
2707         printf("%s\n", CS m->name);
2708       else
2709         printf("%s=%s\n", CS m->name, CS m->replacement);
2710       if (name != NULL)
2711         return;
2712       }
2713     }
2714   if (name != NULL)
2715     printf("%s %s not found\n", type, name);
2716   return;
2717   }
2718
2719 if (names_only)
2720   {
2721   for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2722   return;
2723   }
2724
2725 /* Either search for a given driver, or print all of them */
2726
2727 for (; d != NULL; d = d->next)
2728   {
2729   if (name == NULL)
2730     printf("\n%s %s:\n", d->name, type);
2731   else if (Ustrcmp(d->name, name) != 0) continue;
2732
2733   for (ol = ol2; ol < ol2 + size; ol++)
2734     {
2735     if ((ol->type & opt_hidden) == 0)
2736       print_ol(ol, US ol->name, d, ol2, size, no_labels);
2737     }
2738
2739   for (ol = d->info->options;
2740        ol < d->info->options + *(d->info->options_count); ol++)
2741     {
2742     if ((ol->type & opt_hidden) == 0)
2743       print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2744     }
2745   if (name != NULL) return;
2746   }
2747 if (name != NULL) printf("%s %s not found\n", type, name);
2748 }
2749
2750
2751
2752 /*************************************************
2753 *          Read a named list item                *
2754 *************************************************/
2755
2756 /* This function reads a name and a list (i.e. string). The name is used to
2757 save the list in a tree, sorted by its name. Each entry also has a number,
2758 which can be used for caching tests, but if the string contains any expansion
2759 items other than $key, the number is set negative to inhibit caching. This
2760 mechanism is used for domain, host, and address lists that are referenced by
2761 the "+name" syntax.
2762
2763 Arguments:
2764   anchorp     points to the tree anchor
2765   numberp     points to the current number for this tree
2766   max         the maximum number permitted
2767   s           the text of the option line, starting immediately after the name
2768                 of the list type
2769   tname       the name of the list type, for messages
2770
2771 Returns:      nothing
2772 */
2773
2774 static void
2775 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2776   uschar *tname)
2777 {
2778 BOOL forcecache = FALSE;
2779 uschar *ss;
2780 tree_node *t;
2781 namedlist_block *nb = store_get(sizeof(namedlist_block));
2782
2783 if (Ustrncmp(s, "_cache", 6) == 0)
2784   {
2785   forcecache = TRUE;
2786   s += 6;
2787   }
2788
2789 if (!isspace(*s))
2790   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2791
2792 if (*numberp >= max)
2793  log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2794    tname, max);
2795
2796 while (isspace(*s)) s++;
2797 ss = s;
2798 while (isalnum(*s) || *s == '_') s++;
2799 t = store_get(sizeof(tree_node) + s-ss);
2800 Ustrncpy(t->name, ss, s-ss);
2801 t->name[s-ss] = 0;
2802 while (isspace(*s)) s++;
2803
2804 if (!tree_insertnode(anchorp, t))
2805   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2806     "duplicate name \"%s\" for a named %s", t->name, tname);
2807
2808 t->data.ptr = nb;
2809 nb->number = *numberp;
2810 *numberp += 1;
2811
2812 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2813   "missing '=' after \"%s\"", t->name);
2814 while (isspace(*s)) s++;
2815 nb->string = read_string(s, t->name);
2816 nb->cache_data = NULL;
2817
2818 /* Check the string for any expansions; if any are found, mark this list
2819 uncacheable unless the user has explicited forced caching. */
2820
2821 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2822 }
2823
2824
2825
2826
2827 /*************************************************
2828 *        Unpick data for a rate limit            *
2829 *************************************************/
2830
2831 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2832 separate values.
2833
2834 Arguments:
2835   s            string, in the form t,b,f,l
2836                where t is the threshold (integer)
2837                b is the initial delay (time)
2838                f is the multiplicative factor (fixed point)
2839                k is the maximum time (time)
2840   threshold    where to store threshold
2841   base         where to store base in milliseconds
2842   factor       where to store factor in milliseconds
2843   limit        where to store limit
2844
2845 Returns:       nothing (panics on error)
2846 */
2847
2848 static void
2849 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2850   int *limit)
2851 {
2852 uschar bstring[16], lstring[16];
2853
2854 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2855     factor, lstring) == 4)
2856   {
2857   *base = readconf_readtime(bstring, 0, TRUE);
2858   *limit = readconf_readtime(lstring, 0, TRUE);
2859   if (*base >= 0 && *limit >= 0) return;
2860   }
2861 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2862 }
2863
2864
2865
2866
2867 /*************************************************
2868 *       Drop privs for checking TLS config      *
2869 *************************************************/
2870
2871 /* We want to validate TLS options during readconf, but do not want to be
2872 root when we call into the TLS library, in case of library linkage errors
2873 which cause segfaults; before this check, those were always done as the Exim
2874 runtime user and it makes sense to continue with that.
2875
2876 Assumes:  tls_require_ciphers has been set, if it will be
2877           exim_user has been set, if it will be
2878           exim_group has been set, if it will be
2879
2880 Returns:  bool for "okay"; false will cause caller to immediately exit.
2881 */
2882
2883 #ifdef SUPPORT_TLS
2884 static BOOL
2885 tls_dropprivs_validate_require_cipher(void)
2886 {
2887 const uschar *errmsg;
2888 pid_t pid;
2889 int rc, status;
2890 void (*oldsignal)(int);
2891
2892 oldsignal = signal(SIGCHLD, SIG_DFL);
2893
2894 fflush(NULL);
2895 if ((pid = fork()) < 0)
2896   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
2897
2898 if (pid == 0)
2899   {
2900   /* in some modes, will have dropped privilege already */
2901   if (!geteuid())
2902     exim_setugid(exim_uid, exim_gid, FALSE,
2903         US"calling tls_validate_require_cipher");
2904
2905   errmsg = tls_validate_require_cipher();
2906   if (errmsg)
2907     {
2908     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2909         "tls_require_ciphers invalid: %s", errmsg);
2910     }
2911   fflush(NULL);
2912   _exit(0);
2913   }
2914
2915 do {
2916   rc = waitpid(pid, &status, 0);
2917 } while (rc < 0 && errno == EINTR);
2918
2919 DEBUG(D_tls)
2920   debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
2921       (int)pid, status);
2922
2923 signal(SIGCHLD, oldsignal);
2924
2925 return status == 0;
2926 }
2927 #endif /* SUPPORT_TLS */
2928
2929
2930
2931
2932 /*************************************************
2933 *         Read main configuration options        *
2934 *************************************************/
2935
2936 /* This function is the first to be called for configuration reading. It
2937 opens the configuration file and reads general configuration settings until
2938 it reaches the end of the configuration section. The file is then left open so
2939 that the remaining configuration data can subsequently be read if needed for
2940 this run of Exim.
2941
2942 The configuration file must be owned either by root or exim, and be writeable
2943 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
2944 in the config file, so the test is done on the compiled in values. A slight
2945 anomaly, to be carefully documented.
2946
2947 The name of the configuration file is taken from a list that is included in the
2948 binary of Exim. It can be altered from the command line, but if that is done,
2949 root privilege is immediately withdrawn unless the caller is root or exim.
2950 The first file on the list that exists is used.
2951
2952 For use on multiple systems that share file systems, first look for a
2953 configuration file whose name has the current node name on the end. If that is
2954 not found, try the generic name. For really contorted configurations, that run
2955 multiple Exims with different uid settings, first try adding the effective uid
2956 before the node name. These complications are going to waste resources on most
2957 systems. Therefore they are available only when requested by compile-time
2958 options. */
2959
2960 void
2961 readconf_main(void)
2962 {
2963 int sep = 0;
2964 struct stat statbuf;
2965 uschar *s, *filename;
2966 const uschar *list = config_main_filelist;
2967
2968 /* Loop through the possible file names */
2969
2970 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
2971        != NULL)
2972   {
2973   /* Cut out all the fancy processing unless specifically wanted */
2974
2975   #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
2976   uschar *suffix = filename + Ustrlen(filename);
2977
2978   /* Try for the node-specific file if a node name exists */
2979
2980   #ifdef CONFIGURE_FILE_USE_NODE
2981   struct utsname uts;
2982   if (uname(&uts) >= 0)
2983     {
2984     #ifdef CONFIGURE_FILE_USE_EUID
2985     sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
2986     config_file = Ufopen(filename, "rb");
2987     if (config_file == NULL)
2988     #endif  /* CONFIGURE_FILE_USE_EUID */
2989       {
2990       sprintf(CS suffix, ".%.256s", uts.nodename);
2991       config_file = Ufopen(filename, "rb");
2992       }
2993     }
2994   #endif  /* CONFIGURE_FILE_USE_NODE */
2995
2996   /* Otherwise, try the generic name, possibly with the euid added */
2997
2998   #ifdef CONFIGURE_FILE_USE_EUID
2999   if (config_file == NULL)
3000     {
3001     sprintf(CS suffix, ".%ld", (long int)original_euid);
3002     config_file = Ufopen(filename, "rb");
3003     }
3004   #endif  /* CONFIGURE_FILE_USE_EUID */
3005
3006   /* Finally, try the unadorned name */
3007
3008   if (config_file == NULL)
3009     {
3010     *suffix = 0;
3011     config_file = Ufopen(filename, "rb");
3012     }
3013   #else  /* if neither defined */
3014
3015   /* This is the common case when the fancy processing is not included. */
3016
3017   config_file = Ufopen(filename, "rb");
3018   #endif
3019
3020   /* If the file does not exist, continue to try any others. For any other
3021   error, break out (and die). */
3022
3023   if (config_file != NULL || errno != ENOENT) break;
3024   }
3025
3026 /* On success, save the name for verification; config_filename is used when
3027 logging configuration errors (it changes for .included files) whereas
3028 config_main_filename is the name shown by -bP. Failure to open a configuration
3029 file is a serious disaster. */
3030
3031 if (config_file != NULL)
3032   {
3033   uschar *p;
3034   config_filename = config_main_filename = string_copy(filename);
3035
3036   p = Ustrrchr(filename, '/');
3037   config_main_directory = p ? string_copyn(filename, p - filename)
3038                             : string_copy(US".");
3039   }
3040 else
3041   {
3042   if (filename == NULL)
3043     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3044       "%s", config_main_filelist);
3045   else
3046     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3047       "configuration file %s", filename));
3048   }
3049
3050 /* Check the status of the file we have opened, if we have retained root
3051 privileges and the file isn't /dev/null (which *should* be 0666). */
3052
3053 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3054   {
3055   if (fstat(fileno(config_file), &statbuf) != 0)
3056     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3057       big_buffer);
3058
3059   if ((statbuf.st_uid != root_uid                /* owner not root */
3060        #ifdef CONFIGURE_OWNER
3061        && statbuf.st_uid != config_uid           /* owner not the special one */
3062        #endif
3063          ) ||                                    /* or */
3064       (statbuf.st_gid != root_gid                /* group not root & */
3065        #ifdef CONFIGURE_GROUP
3066        && statbuf.st_gid != config_gid           /* group not the special one */
3067        #endif
3068        && (statbuf.st_mode & 020) != 0) ||       /* group writeable  */
3069                                                  /* or */
3070       ((statbuf.st_mode & 2) != 0))              /* world writeable  */
3071
3072     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3073       "wrong owner, group, or mode", big_buffer);
3074   }
3075
3076 /* Process the main configuration settings. They all begin with a lower case
3077 letter. If we see something starting with an upper case letter, it is taken as
3078 a macro definition. */
3079
3080 while ((s = get_config_line()) != NULL)
3081   {
3082   if (isupper(s[0])) read_macro_assignment(s);
3083
3084   else if (Ustrncmp(s, "domainlist", 10) == 0)
3085     read_named_list(&domainlist_anchor, &domainlist_count,
3086       MAX_NAMED_LIST, s+10, US"domain list");
3087
3088   else if (Ustrncmp(s, "hostlist", 8) == 0)
3089     read_named_list(&hostlist_anchor, &hostlist_count,
3090       MAX_NAMED_LIST, s+8, US"host list");
3091
3092   else if (Ustrncmp(s, US"addresslist", 11) == 0)
3093     read_named_list(&addresslist_anchor, &addresslist_count,
3094       MAX_NAMED_LIST, s+11, US"address list");
3095
3096   else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3097     read_named_list(&localpartlist_anchor, &localpartlist_count,
3098       MAX_NAMED_LIST, s+13, US"local part list");
3099
3100   else
3101     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3102       NULL, US"main option \"%s\" unknown");
3103   }
3104
3105
3106 /* If local_sender_retain is set, local_from_check must be unset. */
3107
3108 if (local_sender_retain && local_from_check)
3109   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3110     "local_sender_retain are set; this combination is not allowed");
3111
3112 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3113 wanted. */
3114
3115 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3116
3117 /* The max retry interval must not be greater than 24 hours. */
3118
3119 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3120
3121 /* remote_max_parallel must be > 0 */
3122
3123 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3124
3125 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3126 start of a new SMTP message. */
3127
3128 freeze_tell_config = freeze_tell;
3129
3130 /* The primary host name may be required for expansion of spool_directory
3131 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3132 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3133 canonize it. Some people like upper case letters in their host names, so we
3134 don't force the case. */
3135
3136 if (primary_hostname == NULL)
3137   {
3138   const uschar *hostname;
3139   struct utsname uts;
3140   if (uname(&uts) < 0)
3141     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3142   hostname = US uts.nodename;
3143
3144   if (Ustrchr(hostname, '.') == NULL)
3145     {
3146     int af = AF_INET;
3147     struct hostent *hostdata;
3148
3149     #if HAVE_IPV6
3150     if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3151          match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3152             MCL_DOMAIN, TRUE, NULL) != OK))
3153       af = AF_INET6;
3154     #else
3155     af = AF_INET;
3156     #endif
3157
3158     for (;;)
3159       {
3160       #if HAVE_IPV6
3161         #if HAVE_GETIPNODEBYNAME
3162         int error_num;
3163         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3164         #else
3165         hostdata = gethostbyname2(CS hostname, af);
3166         #endif
3167       #else
3168       hostdata = gethostbyname(CS hostname);
3169       #endif
3170
3171       if (hostdata != NULL)
3172         {
3173         hostname = US hostdata->h_name;
3174         break;
3175         }
3176
3177       if (af == AF_INET) break;
3178       af = AF_INET;
3179       }
3180     }
3181
3182   primary_hostname = string_copy(hostname);
3183   }
3184
3185 /* Set up default value for smtp_active_hostname */
3186
3187 smtp_active_hostname = primary_hostname;
3188
3189 /* If spool_directory wasn't set in the build-time configuration, it must have
3190 got set above. Of course, writing to the log may not work if log_file_path is
3191 not set, but it will at least get to syslog or somewhere, with any luck. */
3192
3193 if (*spool_directory == 0)
3194   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3195     "proceed");
3196
3197 /* Expand the spool directory name; it may, for example, contain the primary
3198 host name. Same comment about failure. */
3199
3200 s = expand_string(spool_directory);
3201 if (s == NULL)
3202   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3203     "\"%s\": %s", spool_directory, expand_string_message);
3204 spool_directory = s;
3205
3206 /* Expand log_file_path, which must contain "%s" in any component that isn't
3207 the null string or "syslog". It is also allowed to contain one instance of %D
3208 or %M. However, it must NOT contain % followed by anything else. */
3209
3210 if (*log_file_path != 0)
3211   {
3212   const uschar *ss, *sss;
3213   int sep = ':';                       /* Fixed for log file path */
3214   s = expand_string(log_file_path);
3215   if (s == NULL)
3216     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3217       "\"%s\": %s", log_file_path, expand_string_message);
3218
3219   ss = s;
3220   while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3221     {
3222     uschar *t;
3223     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3224     t = Ustrstr(sss, "%s");
3225     if (t == NULL)
3226       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3227         "contain \"%%s\"", sss);
3228     *t = 'X';
3229     t = Ustrchr(sss, '%');
3230     if (t != NULL)
3231       {
3232       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3233         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3234           "unexpected \"%%\" character", s);
3235       }
3236     }
3237
3238   log_file_path = s;
3239   }
3240
3241 /* Interpret syslog_facility into an integer argument for 'ident' param to
3242 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3243 leading "log_". */
3244
3245 if (syslog_facility_str != NULL)
3246   {
3247   int i;
3248   uschar *s = syslog_facility_str;
3249
3250   if ((Ustrlen(syslog_facility_str) >= 4) &&
3251         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3252     s += 4;
3253
3254   for (i = 0; i < syslog_list_size; i++)
3255     {
3256     if (strcmpic(s, syslog_list[i].name) == 0)
3257       {
3258       syslog_facility = syslog_list[i].value;
3259       break;
3260       }
3261     }
3262
3263   if (i >= syslog_list_size)
3264     {
3265     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3266       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3267     }
3268   }
3269
3270 /* Expand pid_file_path */
3271
3272 if (*pid_file_path != 0)
3273   {
3274   s = expand_string(pid_file_path);
3275   if (s == NULL)
3276     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3277       "\"%s\": %s", pid_file_path, expand_string_message);
3278   pid_file_path = s;
3279   }
3280
3281 /* Set default value of process_log_path */
3282
3283 if (process_log_path == NULL || *process_log_path =='\0')
3284   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3285
3286 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3287 message. */
3288
3289 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3290
3291 /* Unpick the SMTP rate limiting options, if set */
3292
3293 if (smtp_ratelimit_mail != NULL)
3294   {
3295   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3296     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3297   }
3298
3299 if (smtp_ratelimit_rcpt != NULL)
3300   {
3301   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3302     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3303   }
3304
3305 /* The qualify domains default to the primary host name */
3306
3307 if (qualify_domain_sender == NULL)
3308   qualify_domain_sender = primary_hostname;
3309 if (qualify_domain_recipient == NULL)
3310   qualify_domain_recipient = qualify_domain_sender;
3311
3312 /* Setting system_filter_user in the configuration sets the gid as well if a
3313 name is given, but a numerical value does not. */
3314
3315 if (system_filter_uid_set && !system_filter_gid_set)
3316   {
3317   struct passwd *pw = getpwuid(system_filter_uid);
3318   if (pw == NULL)
3319     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3320       (long int)system_filter_uid);
3321   system_filter_gid = pw->pw_gid;
3322   system_filter_gid_set = TRUE;
3323   }
3324
3325 /* If the errors_reply_to field is set, check that it is syntactically valid
3326 and ensure it contains a domain. */
3327
3328 if (errors_reply_to != NULL)
3329   {
3330   uschar *errmess;
3331   int start, end, domain;
3332   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3333     &start, &end, &domain, FALSE);
3334
3335   if (recipient == NULL)
3336     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3337       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3338
3339   if (domain == 0)
3340     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3341       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3342   }
3343
3344 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3345 smtp_accept_max must also be set. */
3346
3347 if (smtp_accept_max == 0 &&
3348     (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3349   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3350     "smtp_accept_max must be set if smtp_accept_queue or "
3351     "smtp_accept_max_per_host is set");
3352
3353 /* Set up the host number if anything is specified. It is an expanded string
3354 so that it can be computed from the host name, for example. We do this last
3355 so as to ensure that everything else is set up before the expansion. */
3356
3357 if (host_number_string != NULL)
3358   {
3359   long int n;
3360   uschar *end;
3361   uschar *s = expand_string(host_number_string);
3362   if (s == NULL)
3363     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3364         "failed to expand localhost_number \"%s\": %s",
3365         host_number_string, expand_string_message);
3366   n = Ustrtol(s, &end, 0);
3367   while (isspace(*end)) end++;
3368   if (*end != 0)
3369     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3370       "localhost_number value is not a number: %s", s);
3371   if (n > LOCALHOST_MAX)
3372     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3373       "localhost_number is greater than the maximum allowed value (%d)",
3374         LOCALHOST_MAX);
3375   host_number = n;
3376   }
3377
3378 #ifdef SUPPORT_TLS
3379 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3380
3381 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3382      tls_verify_certificates == NULL)
3383   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3384     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3385     (tls_verify_hosts != NULL)? "" : "try_");
3386
3387 /* This also checks that the library linkage is working and we can call
3388 routines in it, so call even if tls_require_ciphers is unset */
3389 if (!tls_dropprivs_validate_require_cipher())
3390   exit(1);
3391
3392 /* Magic number: at time of writing, 1024 has been the long-standing value
3393 used by so many clients, and what Exim used to use always, that it makes
3394 sense to just min-clamp this max-clamp at that. */
3395 if (tls_dh_max_bits < 1024)
3396   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3397       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3398
3399 /* If openssl_options is set, validate it */
3400 if (openssl_options != NULL)
3401   {
3402 # ifdef USE_GNUTLS
3403   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3404     "openssl_options is set but we're using GnuTLS");
3405 # else
3406   long dummy;
3407   if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3408     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3409       "openssl_options parse error: %s", openssl_options);
3410 # endif
3411   }
3412
3413 if (gnutls_require_kx || gnutls_require_mac || gnutls_require_proto)
3414   log_write(0, LOG_MAIN, "WARNING: main options"
3415       " gnutls_require_kx, gnutls_require_mac and gnutls_require_protocols"
3416       " are obsolete\n");
3417 #endif  /*SUPPORT_TLS*/
3418 }
3419
3420
3421
3422 /*************************************************
3423 *          Initialize one driver                 *
3424 *************************************************/
3425
3426 /* This is called once the driver's generic options, if any, have been read.
3427 We can now find the driver, set up defaults for the private options, and
3428 unset any "set" bits in the private options table (which might have been
3429 set by another incarnation of the same driver).
3430
3431 Arguments:
3432   d                   pointer to driver instance block, with generic
3433                         options filled in
3434   drivers_available   vector of available drivers
3435   size_of_info        size of each block in drivers_available
3436   class               class of driver, for error message
3437
3438 Returns:              pointer to the driver info block
3439 */
3440
3441 static driver_info *
3442 init_driver(driver_instance *d, driver_info *drivers_available,
3443   int size_of_info, uschar *class)
3444 {
3445 driver_info *dd;
3446
3447 for (dd = drivers_available; dd->driver_name[0] != 0;
3448      dd = (driver_info *)(((uschar *)dd) + size_of_info))
3449   {
3450   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3451     {
3452     int i;
3453     int len = dd->options_len;
3454     d->info = dd;
3455     d->options_block = store_get(len);
3456     memcpy(d->options_block, dd->options_block, len);
3457     for (i = 0; i < *(dd->options_count); i++)
3458       dd->options[i].type &= ~opt_set;
3459     return dd;
3460     }
3461   }
3462
3463 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3464   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3465
3466 return NULL;   /* never obeyed */
3467 }
3468
3469
3470
3471
3472 /*************************************************
3473 *             Initialize driver list             *
3474 *************************************************/
3475
3476 /* This function is called for routers, transports, and authentication
3477 mechanisms. It reads the data from the current point in the configuration file
3478 up to the end of the section, and sets up a chain of instance blocks according
3479 to the file's contents. The file will already have been opened by a call to
3480 readconf_main, and must be left open for subsequent reading of further data.
3481
3482 Any errors cause a panic crash. Note that the blocks with names driver_info and
3483 driver_instance must map the first portions of all the _info and _instance
3484 blocks for this shared code to work.
3485
3486 Arguments:
3487   class                      "router", "transport", or "authenticator"
3488   anchor                     &routers, &transports, &auths
3489   drivers_available          available drivers
3490   size_of_info               size of each info block
3491   instance_default           points to default data for an instance
3492   instance_size              size of instance block
3493   driver_optionlist          generic option list
3494   driver_optionlist_count    count of generic option list
3495
3496 Returns:                     nothing
3497 */
3498
3499 void
3500 readconf_driver_init(
3501   uschar *class,
3502   driver_instance **anchor,
3503   driver_info *drivers_available,
3504   int size_of_info,
3505   void *instance_default,
3506   int  instance_size,
3507   optionlist *driver_optionlist,
3508   int  driver_optionlist_count)
3509 {
3510 driver_instance **p = anchor;
3511 driver_instance *d = NULL;
3512 uschar *buffer;
3513
3514 while ((buffer = get_config_line()) != NULL)
3515   {
3516   uschar name[64];
3517   uschar *s;
3518
3519   /* Read the first name on the line and test for the start of a new driver. A
3520   macro definition indicates the end of the previous driver. If this isn't the
3521   start of a new driver, the line will be re-read. */
3522
3523   s = readconf_readname(name, sizeof(name), buffer);
3524
3525   /* Handle macro definition, first finishing off the initialization of the
3526   previous driver, if any. */
3527
3528   if (isupper(*name) && *s == '=')
3529     {
3530     if (d != NULL)
3531       {
3532       if (d->driver_name == NULL)
3533         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3534           "no driver defined for %s \"%s\"", class, d->name);
3535       (d->info->init)(d);
3536       d = NULL;
3537       }
3538     read_macro_assignment(buffer);
3539     continue;
3540     }
3541
3542   /* If the line starts with a name terminated by a colon, we are at the
3543   start of the definition of a new driver. The rest of the line must be
3544   blank. */
3545
3546   if (*s++ == ':')
3547     {
3548     int i;
3549
3550     /* Finish off initializing the previous driver. */
3551
3552     if (d != NULL)
3553       {
3554       if (d->driver_name == NULL)
3555         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3556           "no driver defined for %s \"%s\"", class, d->name);
3557       (d->info->init)(d);
3558       }
3559
3560     /* Check that we haven't already got a driver of this name */
3561
3562     for (d = *anchor; d != NULL; d = d->next)
3563       if (Ustrcmp(name, d->name) == 0)
3564         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3565           "there are two %ss called \"%s\"", class, name);
3566
3567     /* Set up a new driver instance data block on the chain, with
3568     its default values installed. */
3569
3570     d = store_get(instance_size);
3571     memcpy(d, instance_default, instance_size);
3572     *p = d;
3573     p = &(d->next);
3574     d->name = string_copy(name);
3575
3576     /* Clear out the "set" bits in the generic options */
3577
3578     for (i = 0; i < driver_optionlist_count; i++)
3579       driver_optionlist[i].type &= ~opt_set;
3580
3581     /* Check nothing more on this line, then do the next loop iteration. */
3582
3583     while (isspace(*s)) s++;
3584     if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3585     continue;
3586     }
3587
3588   /* Not the start of a new driver. Give an error if we have not set up a
3589   current driver yet. */
3590
3591   if (d == NULL) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3592     "%s name missing", class);
3593
3594   /* First look to see if this is a generic option; if it is "driver",
3595   initialize the driver. If is it not a generic option, we can look for a
3596   private option provided that the driver has been previously set up. */
3597
3598   if (readconf_handle_option(buffer, driver_optionlist,
3599         driver_optionlist_count, d, NULL))
3600     {
3601     if (d->info == NULL && d->driver_name != NULL)
3602       init_driver(d, drivers_available, size_of_info, class);
3603     }
3604
3605   /* Handle private options - pass the generic block because some may
3606   live therein. A flag with each option indicates if it is in the public
3607   block. */
3608
3609   else if (d->info != NULL)
3610     {
3611     readconf_handle_option(buffer, d->info->options,
3612       *(d->info->options_count), d, US"option \"%s\" unknown");
3613     }
3614
3615   /* The option is not generic and the driver name has not yet been given. */
3616
3617   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3618     "(\"driver\" must be specified before any private options)", name);
3619   }
3620
3621 /* Run the initialization function for the final driver. */
3622
3623 if (d != NULL)
3624   {
3625   if (d->driver_name == NULL)
3626     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3627       "no driver defined for %s \"%s\"", class, d->name);
3628   (d->info->init)(d);
3629   }
3630 }
3631
3632
3633
3634 /*************************************************
3635 *            Check driver dependency             *
3636 *************************************************/
3637
3638 /* This function is passed a driver instance and a string. It checks whether
3639 any of the string options for the driver contains the given string as an
3640 expansion variable.
3641
3642 Arguments:
3643   d        points to a driver instance block
3644   s        the string to search for
3645
3646 Returns:   TRUE if a dependency is found
3647 */
3648
3649 BOOL
3650 readconf_depends(driver_instance *d, uschar *s)
3651 {
3652 int count = *(d->info->options_count);
3653 optionlist *ol;
3654 uschar *ss;
3655
3656 for (ol = d->info->options; ol < d->info->options + count; ol++)
3657   {
3658   void *options_block;
3659   uschar *value;
3660   int type = ol->type & opt_mask;
3661   if (type != opt_stringptr) continue;
3662   options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3663   value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3664   if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3665     {
3666     if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3667       isalnum(ss[Ustrlen(s)])) continue;
3668     DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3669       d->name, ol->name, s);
3670     return TRUE;
3671     }
3672   }
3673
3674 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3675 return FALSE;
3676 }
3677
3678
3679
3680
3681 /*************************************************
3682 *      Decode an error type for retries          *
3683 *************************************************/
3684
3685 /* This function is global because it is also called from the main
3686 program when testing retry information. It decodes strings such as "quota_7d"
3687 into numerical error codes.
3688
3689 Arguments:
3690   pp           points to start of text
3691   p            points past end of text
3692   basic_errno  points to an int to receive the main error number
3693   more_errno   points to an int to receive the secondary error data
3694
3695 Returns:       NULL if decoded correctly; else points to error text
3696 */
3697
3698 uschar *
3699 readconf_retry_error(const uschar *pp, const uschar *p, int *basic_errno, int *more_errno)
3700 {
3701 int len;
3702 const uschar *q = pp;
3703 while (q < p && *q != '_') q++;
3704 len = q - pp;
3705
3706 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3707   {
3708   *basic_errno = ERRNO_EXIMQUOTA;
3709   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3710       return US"bad time value";
3711   }
3712
3713 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3714   {
3715   *basic_errno = ECONNREFUSED;
3716   if (q != p)
3717     {
3718     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3719     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3720     else return US"A or MX expected after \"refused\"";
3721     }
3722   }
3723
3724 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3725   {
3726   *basic_errno = ETIMEDOUT;
3727   if (q != p)
3728     {
3729     int i;
3730     int xlen = p - q - 1;
3731     const uschar *x = q + 1;
3732
3733     static uschar *extras[] =
3734       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3735     static int values[] =
3736       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3737
3738     for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3739       {
3740       if (strncmpic(x, extras[i], xlen) == 0)
3741         {
3742         *more_errno = values[i];
3743         break;
3744         }
3745       }
3746
3747     if (i >= sizeof(extras)/sizeof(uschar *))
3748       {
3749       if (strncmpic(x, US"DNS", xlen) == 0)
3750         {
3751         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3752           "available in retry rules (it has never worked) - treated as "
3753           "\"timeout\"");
3754         }
3755       else return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3756       }
3757     }
3758   }
3759
3760 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3761          strncmpic(pp, US"rcpt_4", 6) == 0 ||
3762          strncmpic(pp, US"data_4", 6) == 0)
3763   {
3764   BOOL bad = FALSE;
3765   int x = 255;                           /* means "any 4xx code" */
3766   if (p != pp + 8) bad = TRUE; else
3767     {
3768     int a = pp[6], b = pp[7];
3769     if (isdigit(a))
3770       {
3771       x = (a - '0') * 10;
3772       if (isdigit(b)) x += b - '0';
3773       else if (b == 'x') x += 100;
3774       else bad = TRUE;
3775       }
3776     else if (a != 'x' || b != 'x') bad = TRUE;
3777     }
3778
3779   if (bad)
3780     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3781       "x is literal and d is any digit", pp);
3782
3783   *basic_errno = (*pp == 'm')? ERRNO_MAIL4XX :
3784                  (*pp == 'r')? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3785   *more_errno = x << 8;
3786   }
3787
3788 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3789          strncmpic(q+1, US"failed", p-q-1) == 0)
3790   *basic_errno = ERRNO_AUTHFAIL;
3791
3792 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3793   *basic_errno = ERRNO_SMTPCLOSED;
3794
3795 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3796   *basic_errno = ERRNO_TLSREQUIRED;
3797
3798 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3799   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3800
3801 return NULL;
3802 }
3803
3804
3805
3806
3807 /*************************************************
3808 *                Read retry information          *
3809 *************************************************/
3810
3811 /* Each line of retry information contains:
3812
3813 .  A domain name pattern or an address pattern;
3814
3815 .  An error name, possibly with additional data, or *;
3816
3817 .  An optional sequence of retry items, each consisting of an identifying
3818    letter, a cutoff time, and optional parameters.
3819
3820 All this is decoded and placed into a control block. */
3821
3822
3823 /* Subroutine to read an argument, preceded by a comma and terminated
3824 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3825 1 = fixed point number (returned *1000).
3826
3827 Arguments:
3828   paddr     pointer to pointer to current character; updated
3829   type      0 => read a time; 1 => read a fixed point number
3830
3831 Returns:    time in seconds or fixed point number * 1000
3832 */
3833
3834 static int
3835 retry_arg(const uschar **paddr, int type)
3836 {
3837 const uschar *p = *paddr;
3838 const uschar *pp;
3839
3840 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3841
3842 while (isspace(*p)) p++;
3843 pp = p;
3844 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3845
3846 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3847   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3848
3849 *paddr = p;
3850 switch (type)
3851   {
3852   case 0:
3853   return readconf_readtime(pp, *p, FALSE);
3854   case 1:
3855   return readconf_readfixed(pp, *p);
3856   }
3857 return 0;    /* Keep picky compilers happy */
3858 }
3859
3860 /* The function proper */
3861
3862 void
3863 readconf_retries(void)
3864 {
3865 retry_config **chain = &retries;
3866 retry_config *next;
3867 const uschar *p;
3868
3869 while ((p = get_config_line()) != NULL)
3870   {
3871   retry_rule **rchain;
3872   const uschar *pp;
3873   uschar *error;
3874
3875   next = store_get(sizeof(retry_config));
3876   next->next = NULL;
3877   *chain = next;
3878   chain = &(next->next);
3879   next->basic_errno = next->more_errno = 0;
3880   next->senders = NULL;
3881   next->rules = NULL;
3882   rchain = &(next->rules);
3883
3884   next->pattern = string_dequote(&p);
3885   while (isspace(*p)) p++;
3886   pp = p;
3887   while (mac_isgraph(*p)) p++;
3888   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3889     "missing error type in retry rule");
3890
3891   /* Test error names for things we understand. */
3892
3893   if ((error = readconf_retry_error(pp, p, &(next->basic_errno),
3894        &(next->more_errno))) != NULL)
3895     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3896
3897   /* There may be an optional address list of senders to be used as another
3898   constraint on the rule. This was added later, so the syntax is a bit of a
3899   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3900   an address list. */
3901
3902   while (isspace(*p)) p++;
3903   if (Ustrncmp(p, "senders", 7) == 0)
3904     {
3905     p += 7;
3906     while (isspace(*p)) p++;
3907     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3908       "\"=\" expected after \"senders\" in retry rule");
3909     while (isspace(*p)) p++;
3910     next->senders = string_dequote(&p);
3911     }
3912
3913   /* Now the retry rules. Keep the maximum timeout encountered. */
3914
3915   while (isspace(*p)) p++;
3916
3917   while (*p != 0)
3918     {
3919     retry_rule *rule = store_get(sizeof(retry_rule));
3920     *rchain = rule;
3921     rchain = &(rule->next);
3922     rule->next = NULL;
3923     rule->rule = toupper(*p++);
3924     rule->timeout = retry_arg(&p, 0);
3925     if (rule->timeout > retry_maximum_timeout)
3926       retry_maximum_timeout = rule->timeout;
3927
3928     switch (rule->rule)
3929       {
3930       case 'F':   /* Fixed interval */
3931       rule->p1 = retry_arg(&p, 0);
3932       break;
3933
3934       case 'G':   /* Geometrically increasing intervals */
3935       case 'H':   /* Ditto, but with randomness */
3936       rule->p1 = retry_arg(&p, 0);
3937       rule->p2 = retry_arg(&p, 1);
3938       break;
3939
3940       default:
3941       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
3942       break;
3943       }
3944
3945     if (rule->timeout <= 0 || rule->p1 <= 0 ||
3946           (rule->rule != 'F' && rule->p2 < 1000))
3947       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3948         "bad parameters for retry rule");
3949
3950     while (isspace(*p)) p++;
3951     if (*p == ';')
3952       {
3953       p++;
3954       while (isspace(*p)) p++;
3955       }
3956     else if (*p != 0)
3957       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
3958     }
3959   }
3960 }
3961
3962
3963
3964 /*************************************************
3965 *         Initialize authenticators              *
3966 *************************************************/
3967
3968 /* Read the authenticators section of the configuration file.
3969
3970 Arguments:   none
3971 Returns:     nothing
3972 */
3973
3974 static void
3975 auths_init(void)
3976 {
3977 auth_instance *au, *bu;
3978 readconf_driver_init(US"authenticator",
3979   (driver_instance **)(&auths),      /* chain anchor */
3980   (driver_info *)auths_available,    /* available drivers */
3981   sizeof(auth_info),                 /* size of info block */
3982   &auth_defaults,                    /* default values for generic options */
3983   sizeof(auth_instance),             /* size of instance block */
3984   optionlist_auths,                  /* generic options */
3985   optionlist_auths_size);
3986
3987 for (au = auths; au != NULL; au = au->next)
3988   {
3989   if (au->public_name == NULL)
3990     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
3991       "the %s authenticator", au->name);
3992   for (bu = au->next; bu != NULL; bu = bu->next)
3993     {
3994     if (strcmpic(au->public_name, bu->public_name) == 0)
3995       {
3996       if ((au->client && bu->client) || (au->server && bu->server))
3997         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
3998           "(%s and %s) have the same public name (%s)",
3999           (au->client)? US"client" : US"server", au->name, bu->name,
4000           au->public_name);
4001       }
4002     }
4003   }
4004 }
4005
4006
4007
4008
4009 /*************************************************
4010 *             Read ACL information               *
4011 *************************************************/
4012
4013 /* If this run of Exim is not doing something that involves receiving a
4014 message, we can just skip over the ACL information. No need to parse it.
4015
4016 First, we have a function for acl_read() to call back to get the next line. We
4017 need to remember the line we passed, because at the end it will contain the
4018 name of the next ACL. */
4019
4020 static uschar *acl_line;
4021
4022 static uschar *
4023 acl_callback(void)
4024 {
4025 acl_line = get_config_line();
4026 return acl_line;
4027 }
4028
4029
4030 /* Now the main function:
4031
4032 Arguments:    none
4033 Returns:      nothing
4034 */
4035
4036 static void
4037 readconf_acl(void)
4038 {
4039 uschar *p;
4040
4041 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4042 between ACLs. */
4043
4044 acl_line = get_config_line();
4045
4046 while(acl_line != NULL)
4047   {
4048   uschar name[64];
4049   tree_node *node;
4050   uschar *error;
4051
4052   p = readconf_readname(name, sizeof(name), acl_line);
4053   if (isupper(*name) && *p == '=')
4054     {
4055     read_macro_assignment(acl_line);
4056     acl_line = get_config_line();
4057     continue;
4058     }
4059
4060   if (*p != ':' || name[0] == 0)
4061     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4062
4063   node = store_get(sizeof(tree_node) + Ustrlen(name));
4064   Ustrcpy(node->name, name);
4065   if (!tree_insertnode(&acl_anchor, node))
4066     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4067       "there are two ACLs called \"%s\"", name);
4068
4069   node->data.ptr = acl_read(acl_callback, &error);
4070
4071   if (node->data.ptr == NULL && error != NULL)
4072     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4073   }
4074 }
4075
4076
4077
4078 /*************************************************
4079 *     Read configuration for local_scan()        *
4080 *************************************************/
4081
4082 /* This function is called after "begin local_scan" is encountered in the
4083 configuration file. If the local_scan() function allows for configuration
4084 options, we can process them. Otherwise, we expire in a panic.
4085
4086 Arguments:  none
4087 Returns:    nothing
4088 */
4089
4090 static void
4091 local_scan_init(void)
4092 {
4093 #ifndef LOCAL_SCAN_HAS_OPTIONS
4094 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4095   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4096 #else
4097
4098 uschar *p;
4099 while ((p = get_config_line()) != NULL)
4100   {
4101   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4102     NULL, US"local_scan option \"%s\" unknown");
4103   }
4104 #endif
4105 }
4106
4107
4108
4109 /*************************************************
4110 *     Read rest of configuration (after main)    *
4111 *************************************************/
4112
4113 /* This function reads the rest of the runtime configuration, after the main
4114 configuration. It is called only when actually needed. Each subsequent section
4115 of the configuration starts with a line of the form
4116
4117   begin name
4118
4119 where the name is "routers", "transports", etc. A section is terminated by
4120 hitting the next "begin" line, and the next name is left in next_section.
4121 Because it may confuse people as to whether the names are singular or plural,
4122 we add "s" if it's missing. There is always enough room in next_section for
4123 this. This function is basically just a switch.
4124
4125 Arguments:   none
4126 Returns:     nothing
4127 */
4128
4129 static uschar *section_list[] = {
4130   US"acls",
4131   US"authenticators",
4132   US"local_scans",
4133   US"retrys",
4134   US"rewrites",
4135   US"routers",
4136   US"transports"};
4137
4138 void
4139 readconf_rest(void)
4140 {
4141 int had = 0;
4142
4143 while(next_section[0] != 0)
4144   {
4145   int bit;
4146   int first = 0;
4147   int last = sizeof(section_list) / sizeof(uschar *);
4148   int mid = last/2;
4149   int n = Ustrlen(next_section);
4150
4151   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4152
4153   for (;;)
4154     {
4155     int c = strcmpic(next_section, section_list[mid]);
4156     if (c == 0) break;
4157     if (c > 0) first = mid + 1; else last = mid;
4158     if (first >= last)
4159       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4160         "\"%.*s\" is not a known configuration section name", n, next_section);
4161     mid = (last + first)/2;
4162     }
4163
4164   bit = 1 << mid;
4165   if (((had ^= bit) & bit) == 0)
4166     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4167       "\"%.*s\" section is repeated in the configuration file", n,
4168         next_section);
4169
4170   switch(mid)
4171     {
4172     case 0: readconf_acl(); break;
4173     case 1: auths_init(); break;
4174     case 2: local_scan_init(); break;
4175     case 3: readconf_retries(); break;
4176     case 4: readconf_rewrites(); break;
4177     case 5: route_init(); break;
4178     case 6: transport_init(); break;
4179     }
4180   }
4181
4182 (void)fclose(config_file);
4183 }
4184
4185 /* vi: aw ai sw=2
4186 */
4187 /* End of readconf.c */