src/src/readconf.c

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