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