src/src/readconf.c

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