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