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