src/src/readconf.c

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