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_MAILDR", 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   errmsg = tls_validate_require_cipher();
3255   if (errmsg)
3256     {
3257     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3258         "tls_require_ciphers invalid: %s", errmsg);
3259     }
3260   fflush(NULL);
3261   _exit(0);
3262   }
3263
3264 do {
3265   rc = waitpid(pid, &status, 0);
3266 } while (rc < 0 && errno == EINTR);
3267
3268 DEBUG(D_tls)
3269   debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3270       (int)pid, status);
3271
3272 signal(SIGCHLD, oldsignal);
3273
3274 return status == 0;
3275 }
3276 #endif /* SUPPORT_TLS */
3277
3278
3279
3280
3281 /*************************************************
3282 *         Read main configuration options        *
3283 *************************************************/
3284
3285 /* This function is the first to be called for configuration reading. It
3286 opens the configuration file and reads general configuration settings until
3287 it reaches the end of the configuration section. The file is then left open so
3288 that the remaining configuration data can subsequently be read if needed for
3289 this run of Exim.
3290
3291 The configuration file must be owned either by root or exim, and be writeable
3292 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3293 in the config file, so the test is done on the compiled in values. A slight
3294 anomaly, to be carefully documented.
3295
3296 The name of the configuration file is taken from a list that is included in the
3297 binary of Exim. It can be altered from the command line, but if that is done,
3298 root privilege is immediately withdrawn unless the caller is root or exim.
3299 The first file on the list that exists is used.
3300
3301 For use on multiple systems that share file systems, first look for a
3302 configuration file whose name has the current node name on the end. If that is
3303 not found, try the generic name. For really contorted configurations, that run
3304 multiple Exims with different uid settings, first try adding the effective uid
3305 before the node name. These complications are going to waste resources on most
3306 systems. Therefore they are available only when requested by compile-time
3307 options. */
3308
3309 void
3310 readconf_main(BOOL nowarn)
3311 {
3312 int sep = 0;
3313 struct stat statbuf;
3314 uschar *s, *filename;
3315 const uschar *list = config_main_filelist;
3316
3317 /* Loop through the possible file names */
3318
3319 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3320   {
3321
3322   /* Cut out all the fancy processing unless specifically wanted */
3323
3324   #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3325   uschar *suffix = filename + Ustrlen(filename);
3326
3327   /* Try for the node-specific file if a node name exists */
3328
3329   #ifdef CONFIGURE_FILE_USE_NODE
3330   struct utsname uts;
3331   if (uname(&uts) >= 0)
3332     {
3333     #ifdef CONFIGURE_FILE_USE_EUID
3334     sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3335     config_file = Ufopen(filename, "rb");
3336     if (config_file == NULL)
3337     #endif  /* CONFIGURE_FILE_USE_EUID */
3338       {
3339       sprintf(CS suffix, ".%.256s", uts.nodename);
3340       config_file = Ufopen(filename, "rb");
3341       }
3342     }
3343   #endif  /* CONFIGURE_FILE_USE_NODE */
3344
3345   /* Otherwise, try the generic name, possibly with the euid added */
3346
3347   #ifdef CONFIGURE_FILE_USE_EUID
3348   if (config_file == NULL)
3349     {
3350     sprintf(CS suffix, ".%ld", (long int)original_euid);
3351     config_file = Ufopen(filename, "rb");
3352     }
3353   #endif  /* CONFIGURE_FILE_USE_EUID */
3354
3355   /* Finally, try the unadorned name */
3356
3357   if (config_file == NULL)
3358     {
3359     *suffix = 0;
3360     config_file = Ufopen(filename, "rb");
3361     }
3362   #else  /* if neither defined */
3363
3364   /* This is the common case when the fancy processing is not included. */
3365
3366   config_file = Ufopen(filename, "rb");
3367   #endif
3368
3369   /* If the file does not exist, continue to try any others. For any other
3370   error, break out (and die). */
3371
3372   if (config_file != NULL || errno != ENOENT) break;
3373   }
3374
3375 /* On success, save the name for verification; config_filename is used when
3376 logging configuration errors (it changes for .included files) whereas
3377 config_main_filename is the name shown by -bP. Failure to open a configuration
3378 file is a serious disaster. */
3379
3380 if (config_file)
3381   {
3382   uschar *last_slash = Ustrrchr(filename, '/');
3383   config_filename = config_main_filename = string_copy(filename);
3384
3385   /* The config_main_directory we need for the $config_dir expansion.
3386   config_main_filename we need for $config_file expansion.
3387   And config_dir is the directory of the current configuration, used for
3388   relative .includes. We do need to know it's name, as we change our working
3389   directory later. */
3390
3391   if (filename[0] == '/')
3392     config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3393   else
3394     {
3395       /* relative configuration file name: working dir + / + basename(filename) */
3396
3397       char buf[PATH_MAX];
3398       int offset = 0;
3399       int size = 0;
3400
3401       if (getcwd(buf, PATH_MAX) == NULL)
3402         {
3403         perror("exim: getcwd");
3404         exit(EXIT_FAILURE);
3405         }
3406       config_main_directory = string_cat(NULL, &size, &offset, buf);
3407
3408       /* If the dir does not end with a "/", append one */
3409       if (config_main_directory[offset-1] != '/')
3410         config_main_directory = string_catn(config_main_directory, &size, &offset, US"/", 1);
3411
3412       /* If the config file contains a "/", extract the directory part */
3413       if (last_slash)
3414         config_main_directory = string_catn(config_main_directory, &size, &offset, filename, last_slash - filename);
3415
3416       config_main_directory[offset] = '\0';
3417     }
3418   config_directory = config_main_directory;
3419   }
3420 else
3421   {
3422   if (filename == NULL)
3423     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3424       "%s", config_main_filelist);
3425   else
3426     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3427       "configuration file %s", filename));
3428   }
3429
3430 /* Now, once we found and opened our configuration file, we change the directory
3431 to a safe place. Later we change to $spool_directory. */
3432
3433 if (Uchdir("/") < 0)
3434   {
3435   perror("exim: chdir `/': ");
3436   exit(EXIT_FAILURE);
3437   }
3438
3439 /* Check the status of the file we have opened, if we have retained root
3440 privileges and the file isn't /dev/null (which *should* be 0666). */
3441
3442 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3443   {
3444   if (fstat(fileno(config_file), &statbuf) != 0)
3445     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3446       big_buffer);
3447
3448   if ((statbuf.st_uid != root_uid                /* owner not root */
3449        #ifdef CONFIGURE_OWNER
3450        && statbuf.st_uid != config_uid           /* owner not the special one */
3451        #endif
3452          ) ||                                    /* or */
3453       (statbuf.st_gid != root_gid                /* group not root & */
3454        #ifdef CONFIGURE_GROUP
3455        && statbuf.st_gid != config_gid           /* group not the special one */
3456        #endif
3457        && (statbuf.st_mode & 020) != 0) ||       /* group writeable  */
3458                                                  /* or */
3459       ((statbuf.st_mode & 2) != 0))              /* world writeable  */
3460
3461     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3462       "wrong owner, group, or mode", big_buffer);
3463   }
3464
3465 /* Process the main configuration settings. They all begin with a lower case
3466 letter. If we see something starting with an upper case letter, it is taken as
3467 a macro definition. */
3468
3469 while ((s = get_config_line()) != NULL)
3470   {
3471   if (isupper(s[0])) read_macro_assignment(s);
3472
3473   else if (Ustrncmp(s, "domainlist", 10) == 0)
3474     read_named_list(&domainlist_anchor, &domainlist_count,
3475       MAX_NAMED_LIST, s+10, US"domain list");
3476
3477   else if (Ustrncmp(s, "hostlist", 8) == 0)
3478     read_named_list(&hostlist_anchor, &hostlist_count,
3479       MAX_NAMED_LIST, s+8, US"host list");
3480
3481   else if (Ustrncmp(s, US"addresslist", 11) == 0)
3482     read_named_list(&addresslist_anchor, &addresslist_count,
3483       MAX_NAMED_LIST, s+11, US"address list");
3484
3485   else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3486     read_named_list(&localpartlist_anchor, &localpartlist_count,
3487       MAX_NAMED_LIST, s+13, US"local part list");
3488
3489   else
3490     (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3491       NULL, US"main option \"%s\" unknown");
3492   }
3493
3494
3495 /* If local_sender_retain is set, local_from_check must be unset. */
3496
3497 if (local_sender_retain && local_from_check)
3498   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3499     "local_sender_retain are set; this combination is not allowed");
3500
3501 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3502 wanted. */
3503
3504 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3505
3506 /* The max retry interval must not be greater than 24 hours. */
3507
3508 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3509
3510 /* remote_max_parallel must be > 0 */
3511
3512 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3513
3514 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3515 start of a new SMTP message. */
3516
3517 freeze_tell_config = freeze_tell;
3518
3519 /* The primary host name may be required for expansion of spool_directory
3520 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3521 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3522 canonize it. Some people like upper case letters in their host names, so we
3523 don't force the case. */
3524
3525 if (primary_hostname == NULL)
3526   {
3527   const uschar *hostname;
3528   struct utsname uts;
3529   if (uname(&uts) < 0)
3530     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3531   hostname = US uts.nodename;
3532
3533   if (Ustrchr(hostname, '.') == NULL)
3534     {
3535     int af = AF_INET;
3536     struct hostent *hostdata;
3537
3538     #if HAVE_IPV6
3539     if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3540          match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3541             MCL_DOMAIN, TRUE, NULL) != OK))
3542       af = AF_INET6;
3543     #else
3544     af = AF_INET;
3545     #endif
3546
3547     for (;;)
3548       {
3549       #if HAVE_IPV6
3550         #if HAVE_GETIPNODEBYNAME
3551         int error_num;
3552         hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3553         #else
3554         hostdata = gethostbyname2(CS hostname, af);
3555         #endif
3556       #else
3557       hostdata = gethostbyname(CS hostname);
3558       #endif
3559
3560       if (hostdata != NULL)
3561         {
3562         hostname = US hostdata->h_name;
3563         break;
3564         }
3565
3566       if (af == AF_INET) break;
3567       af = AF_INET;
3568       }
3569     }
3570
3571   primary_hostname = string_copy(hostname);
3572   }
3573
3574 /* Set up default value for smtp_active_hostname */
3575
3576 smtp_active_hostname = primary_hostname;
3577
3578 /* If spool_directory wasn't set in the build-time configuration, it must have
3579 got set above. Of course, writing to the log may not work if log_file_path is
3580 not set, but it will at least get to syslog or somewhere, with any luck. */
3581
3582 if (*spool_directory == 0)
3583   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3584     "proceed");
3585
3586 /* Expand the spool directory name; it may, for example, contain the primary
3587 host name. Same comment about failure. */
3588
3589 s = expand_string(spool_directory);
3590 if (s == NULL)
3591   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3592     "\"%s\": %s", spool_directory, expand_string_message);
3593 spool_directory = s;
3594
3595 /* Expand log_file_path, which must contain "%s" in any component that isn't
3596 the null string or "syslog". It is also allowed to contain one instance of %D
3597 or %M. However, it must NOT contain % followed by anything else. */
3598
3599 if (*log_file_path != 0)
3600   {
3601   const uschar *ss, *sss;
3602   int sep = ':';                       /* Fixed for log file path */
3603   s = expand_string(log_file_path);
3604   if (s == NULL)
3605     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3606       "\"%s\": %s", log_file_path, expand_string_message);
3607
3608   ss = s;
3609   while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3610     {
3611     uschar *t;
3612     if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3613     t = Ustrstr(sss, "%s");
3614     if (t == NULL)
3615       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3616         "contain \"%%s\"", sss);
3617     *t = 'X';
3618     t = Ustrchr(sss, '%');
3619     if (t != NULL)
3620       {
3621       if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3622         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3623           "unexpected \"%%\" character", s);
3624       }
3625     }
3626
3627   log_file_path = s;
3628   }
3629
3630 /* Interpret syslog_facility into an integer argument for 'ident' param to
3631 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3632 leading "log_". */
3633
3634 if (syslog_facility_str != NULL)
3635   {
3636   int i;
3637   uschar *s = syslog_facility_str;
3638
3639   if ((Ustrlen(syslog_facility_str) >= 4) &&
3640         (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3641     s += 4;
3642
3643   for (i = 0; i < syslog_list_size; i++)
3644     {
3645     if (strcmpic(s, syslog_list[i].name) == 0)
3646       {
3647       syslog_facility = syslog_list[i].value;
3648       break;
3649       }
3650     }
3651
3652   if (i >= syslog_list_size)
3653     {
3654     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3655       "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3656     }
3657   }
3658
3659 /* Expand pid_file_path */
3660
3661 if (*pid_file_path != 0)
3662   {
3663   s = expand_string(pid_file_path);
3664   if (s == NULL)
3665     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3666       "\"%s\": %s", pid_file_path, expand_string_message);
3667   pid_file_path = s;
3668   }
3669
3670 /* Set default value of process_log_path */
3671
3672 if (process_log_path == NULL || *process_log_path =='\0')
3673   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3674
3675 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3676 message. */
3677
3678 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3679
3680 /* Unpick the SMTP rate limiting options, if set */
3681
3682 if (smtp_ratelimit_mail != NULL)
3683   {
3684   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3685     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3686   }
3687
3688 if (smtp_ratelimit_rcpt != NULL)
3689   {
3690   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3691     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3692   }
3693
3694 /* The qualify domains default to the primary host name */
3695
3696 if (qualify_domain_sender == NULL)
3697   qualify_domain_sender = primary_hostname;
3698 if (qualify_domain_recipient == NULL)
3699   qualify_domain_recipient = qualify_domain_sender;
3700
3701 /* Setting system_filter_user in the configuration sets the gid as well if a
3702 name is given, but a numerical value does not. */
3703
3704 if (system_filter_uid_set && !system_filter_gid_set)
3705   {
3706   struct passwd *pw = getpwuid(system_filter_uid);
3707   if (pw == NULL)
3708     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3709       (long int)system_filter_uid);
3710   system_filter_gid = pw->pw_gid;
3711   system_filter_gid_set = TRUE;
3712   }
3713
3714 /* If the errors_reply_to field is set, check that it is syntactically valid
3715 and ensure it contains a domain. */
3716
3717 if (errors_reply_to != NULL)
3718   {
3719   uschar *errmess;
3720   int start, end, domain;
3721   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3722     &start, &end, &domain, FALSE);
3723
3724   if (recipient == NULL)
3725     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3726       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3727
3728   if (domain == 0)
3729     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3730       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3731   }
3732
3733 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3734 smtp_accept_max must also be set. */
3735
3736 if (smtp_accept_max == 0 &&
3737     (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3738   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3739     "smtp_accept_max must be set if smtp_accept_queue or "
3740     "smtp_accept_max_per_host is set");
3741
3742 /* Set up the host number if anything is specified. It is an expanded string
3743 so that it can be computed from the host name, for example. We do this last
3744 so as to ensure that everything else is set up before the expansion. */
3745
3746 if (host_number_string != NULL)
3747   {
3748   long int n;
3749   uschar *end;
3750   uschar *s = expand_string(host_number_string);
3751   if (s == NULL)
3752     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3753         "failed to expand localhost_number \"%s\": %s",
3754         host_number_string, expand_string_message);
3755   n = Ustrtol(s, &end, 0);
3756   while (isspace(*end)) end++;
3757   if (*end != 0)
3758     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3759       "localhost_number value is not a number: %s", s);
3760   if (n > LOCALHOST_MAX)
3761     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3762       "localhost_number is greater than the maximum allowed value (%d)",
3763         LOCALHOST_MAX);
3764   host_number = n;
3765   }
3766
3767 #ifdef SUPPORT_TLS
3768 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3769
3770 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3771      tls_verify_certificates == NULL)
3772   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3773     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3774     (tls_verify_hosts != NULL)? "" : "try_");
3775
3776 /* This also checks that the library linkage is working and we can call
3777 routines in it, so call even if tls_require_ciphers is unset */
3778 if (!tls_dropprivs_validate_require_cipher(nowarn))
3779   exit(1);
3780
3781 /* Magic number: at time of writing, 1024 has been the long-standing value
3782 used by so many clients, and what Exim used to use always, that it makes
3783 sense to just min-clamp this max-clamp at that. */
3784 if (tls_dh_max_bits < 1024)
3785   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3786       "tls_dh_max_bits is too small, must be at least 1024 for interop");
3787
3788 /* If openssl_options is set, validate it */
3789 if (openssl_options != NULL)
3790   {
3791 # ifdef USE_GNUTLS
3792   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3793     "openssl_options is set but we're using GnuTLS");
3794 # else
3795   long dummy;
3796   if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3797     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3798       "openssl_options parse error: %s", openssl_options);
3799 # endif
3800   }
3801 #endif  /*SUPPORT_TLS*/
3802
3803 if (!nowarn && !keep_environment && environ && *environ)
3804   log_write(0, LOG_MAIN,
3805       "Warning: purging the environment.\n"
3806       " Suggested action: use keep_environment.");
3807 }
3808
3809
3810
3811 /*************************************************
3812 *          Initialize one driver                 *
3813 *************************************************/
3814
3815 /* This is called once the driver's generic options, if any, have been read.
3816 We can now find the driver, set up defaults for the private options, and
3817 unset any "set" bits in the private options table (which might have been
3818 set by another incarnation of the same driver).
3819
3820 Arguments:
3821   d                   pointer to driver instance block, with generic
3822                         options filled in
3823   drivers_available   vector of available drivers
3824   size_of_info        size of each block in drivers_available
3825   class               class of driver, for error message
3826
3827 Returns:              pointer to the driver info block
3828 */
3829
3830 static driver_info *
3831 init_driver(driver_instance *d, driver_info *drivers_available,
3832   int size_of_info, uschar *class)
3833 {
3834 driver_info *dd;
3835
3836 for (dd = drivers_available; dd->driver_name[0] != 0;
3837      dd = (driver_info *)(((uschar *)dd) + size_of_info))
3838   {
3839   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3840     {
3841     int i;
3842     int len = dd->options_len;
3843     d->info = dd;
3844     d->options_block = store_get(len);
3845     memcpy(d->options_block, dd->options_block, len);
3846     for (i = 0; i < *(dd->options_count); i++)
3847       dd->options[i].type &= ~opt_set;
3848     return dd;
3849     }
3850   }
3851
3852 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3853   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3854
3855 return NULL;   /* never obeyed */
3856 }
3857
3858
3859
3860
3861 /*************************************************
3862 *             Initialize driver list             *
3863 *************************************************/
3864
3865 /* This function is called for routers, transports, and authentication
3866 mechanisms. It reads the data from the current point in the configuration file
3867 up to the end of the section, and sets up a chain of instance blocks according
3868 to the file's contents. The file will already have been opened by a call to
3869 readconf_main, and must be left open for subsequent reading of further data.
3870
3871 Any errors cause a panic crash. Note that the blocks with names driver_info and
3872 driver_instance must map the first portions of all the _info and _instance
3873 blocks for this shared code to work.
3874
3875 Arguments:
3876   class                      "router", "transport", or "authenticator"
3877   anchor                     &routers, &transports, &auths
3878   drivers_available          available drivers
3879   size_of_info               size of each info block
3880   instance_default           points to default data for an instance
3881   instance_size              size of instance block
3882   driver_optionlist          generic option list
3883   driver_optionlist_count    count of generic option list
3884
3885 Returns:                     nothing
3886 */
3887
3888 void
3889 readconf_driver_init(
3890   uschar *class,
3891   driver_instance **anchor,
3892   driver_info *drivers_available,
3893   int size_of_info,
3894   void *instance_default,
3895   int  instance_size,
3896   optionlist *driver_optionlist,
3897   int  driver_optionlist_count)
3898 {
3899 driver_instance **p = anchor;
3900 driver_instance *d = NULL;
3901 uschar *buffer;
3902
3903 while ((buffer = get_config_line()) != NULL)
3904   {
3905   uschar name[64];
3906   uschar *s;
3907
3908   /* Read the first name on the line and test for the start of a new driver. A
3909   macro definition indicates the end of the previous driver. If this isn't the
3910   start of a new driver, the line will be re-read. */
3911
3912   s = readconf_readname(name, sizeof(name), buffer);
3913
3914   /* Handle macro definition, first finishing off the initialization of the
3915   previous driver, if any. */
3916
3917   if (isupper(*name) && *s == '=')
3918     {
3919     if (d)
3920       {
3921       if (!d->driver_name)
3922         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3923           "no driver defined for %s \"%s\"", class, d->name);
3924       (d->info->init)(d);
3925       d = NULL;
3926       }
3927     read_macro_assignment(buffer);
3928     continue;
3929     }
3930
3931   /* If the line starts with a name terminated by a colon, we are at the
3932   start of the definition of a new driver. The rest of the line must be
3933   blank. */
3934
3935   if (*s++ == ':')
3936     {
3937     int i;
3938
3939     /* Finish off initializing the previous driver. */
3940
3941     if (d)
3942       {
3943       if (!d->driver_name)
3944         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3945           "no driver defined for %s \"%s\"", class, d->name);
3946       (d->info->init)(d);
3947       }
3948
3949     /* Check that we haven't already got a driver of this name */
3950
3951     for (d = *anchor; d; d = d->next)
3952       if (Ustrcmp(name, d->name) == 0)
3953         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3954           "there are two %ss called \"%s\"", class, name);
3955
3956     /* Set up a new driver instance data block on the chain, with
3957     its default values installed. */
3958
3959     d = store_get(instance_size);
3960     memcpy(d, instance_default, instance_size);
3961     *p = d;
3962     p = &d->next;
3963     d->name = string_copy(name);
3964
3965     /* Clear out the "set" bits in the generic options */
3966
3967     for (i = 0; i < driver_optionlist_count; i++)
3968       driver_optionlist[i].type &= ~opt_set;
3969
3970     /* Check nothing more on this line, then do the next loop iteration. */
3971
3972     while (isspace(*s)) s++;
3973     if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3974     continue;
3975     }
3976
3977   /* Not the start of a new driver. Give an error if we have not set up a
3978   current driver yet. */
3979
3980   if (!d)
3981     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3982
3983   /* First look to see if this is a generic option; if it is "driver",
3984   initialize the driver. If is it not a generic option, we can look for a
3985   private option provided that the driver has been previously set up. */
3986
3987   if (readconf_handle_option(buffer, driver_optionlist,
3988         driver_optionlist_count, d, NULL))
3989     {
3990     if (!d->info && d->driver_name)
3991       init_driver(d, drivers_available, size_of_info, class);
3992     }
3993
3994   /* Handle private options - pass the generic block because some may
3995   live therein. A flag with each option indicates if it is in the public
3996   block. */
3997
3998   else if (d->info)
3999     readconf_handle_option(buffer, d->info->options,
4000       *(d->info->options_count), d, US"option \"%s\" unknown");
4001
4002   /* The option is not generic and the driver name has not yet been given. */
4003
4004   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
4005     "(\"driver\" must be specified before any private options)", name);
4006   }
4007
4008 /* Run the initialization function for the final driver. */
4009
4010 if (d)
4011   {
4012   if (!d->driver_name)
4013     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
4014       "no driver defined for %s \"%s\"", class, d->name);
4015   (d->info->init)(d);
4016   }
4017 }
4018
4019
4020
4021 /*************************************************
4022 *            Check driver dependency             *
4023 *************************************************/
4024
4025 /* This function is passed a driver instance and a string. It checks whether
4026 any of the string options for the driver contains the given string as an
4027 expansion variable.
4028
4029 Arguments:
4030   d        points to a driver instance block
4031   s        the string to search for
4032
4033 Returns:   TRUE if a dependency is found
4034 */
4035
4036 BOOL
4037 readconf_depends(driver_instance *d, uschar *s)
4038 {
4039 int count = *(d->info->options_count);
4040 optionlist *ol;
4041 uschar *ss;
4042
4043 for (ol = d->info->options; ol < d->info->options + count; ol++)
4044   {
4045   void *options_block;
4046   uschar *value;
4047   int type = ol->type & opt_mask;
4048   if (type != opt_stringptr) continue;
4049   options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
4050   value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
4051   if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
4052     {
4053     if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
4054       isalnum(ss[Ustrlen(s)])) continue;
4055     DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
4056       d->name, ol->name, s);
4057     return TRUE;
4058     }
4059   }
4060
4061 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
4062 return FALSE;
4063 }
4064
4065
4066
4067
4068 /*************************************************
4069 *      Decode an error type for retries          *
4070 *************************************************/
4071
4072 /* This function is global because it is also called from the main
4073 program when testing retry information. It decodes strings such as "quota_7d"
4074 into numerical error codes.
4075
4076 Arguments:
4077   pp           points to start of text
4078   p            points past end of text
4079   basic_errno  points to an int to receive the main error number
4080   more_errno   points to an int to receive the secondary error data
4081
4082 Returns:       NULL if decoded correctly; else points to error text
4083 */
4084
4085 uschar *
4086 readconf_retry_error(const uschar *pp, const uschar *p,
4087   int *basic_errno, int *more_errno)
4088 {
4089 int len;
4090 const uschar *q = pp;
4091 while (q < p && *q != '_') q++;
4092 len = q - pp;
4093
4094 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
4095   {
4096   *basic_errno = ERRNO_EXIMQUOTA;
4097   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
4098       return US"bad time value";
4099   }
4100
4101 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
4102   {
4103   *basic_errno = ECONNREFUSED;
4104   if (q != p)
4105     {
4106     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
4107     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
4108     else return US"A or MX expected after \"refused\"";
4109     }
4110   }
4111
4112 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
4113   {
4114   *basic_errno = ETIMEDOUT;
4115   if (q != p)
4116     {
4117     int i;
4118     int xlen = p - q - 1;
4119     const uschar *x = q + 1;
4120
4121     static uschar *extras[] =
4122       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
4123     static int values[] =
4124       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
4125
4126     for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
4127       if (strncmpic(x, extras[i], xlen) == 0)
4128         {
4129         *more_errno = values[i];
4130         break;
4131         }
4132
4133     if (i >= sizeof(extras)/sizeof(uschar *))
4134       if (strncmpic(x, US"DNS", xlen) == 0)
4135         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
4136           "available in retry rules (it has never worked) - treated as "
4137           "\"timeout\"");
4138       else
4139         return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
4140     }
4141   }
4142
4143 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
4144          strncmpic(pp, US"rcpt_4", 6) == 0 ||
4145          strncmpic(pp, US"data_4", 6) == 0)
4146   {
4147   BOOL bad = FALSE;
4148   int x = 255;                           /* means "any 4xx code" */
4149   if (p != pp + 8) bad = TRUE; else
4150     {
4151     int a = pp[6], b = pp[7];
4152     if (isdigit(a))
4153       {
4154       x = (a - '0') * 10;
4155       if (isdigit(b)) x += b - '0';
4156       else if (b == 'x') x += 100;
4157       else bad = TRUE;
4158       }
4159     else if (a != 'x' || b != 'x') bad = TRUE;
4160     }
4161
4162   if (bad)
4163     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
4164       "x is literal and d is any digit", pp);
4165
4166   *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
4167                  *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
4168   *more_errno = x << 8;
4169   }
4170
4171 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
4172          strncmpic(q+1, US"failed", p-q-1) == 0)
4173   *basic_errno = ERRNO_AUTHFAIL;
4174
4175 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
4176   *basic_errno = ERRNO_SMTPCLOSED;
4177
4178 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
4179   *basic_errno = ERRNO_TLSREQUIRED;
4180
4181 else if (strncmpic(pp, US"lookup", p - pp) == 0)
4182   *basic_errno = ERRNO_UNKNOWNHOST;
4183
4184 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4185   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4186
4187 return NULL;
4188 }
4189
4190
4191
4192
4193 /*************************************************
4194 *                Read retry information          *
4195 *************************************************/
4196
4197 /* Each line of retry information contains:
4198
4199 .  A domain name pattern or an address pattern;
4200
4201 .  An error name, possibly with additional data, or *;
4202
4203 .  An optional sequence of retry items, each consisting of an identifying
4204    letter, a cutoff time, and optional parameters.
4205
4206 All this is decoded and placed into a control block. */
4207
4208
4209 /* Subroutine to read an argument, preceded by a comma and terminated
4210 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4211 1 = fixed point number (returned *1000).
4212
4213 Arguments:
4214   paddr     pointer to pointer to current character; updated
4215   type      0 => read a time; 1 => read a fixed point number
4216
4217 Returns:    time in seconds or fixed point number * 1000
4218 */
4219
4220 static int
4221 retry_arg(const uschar **paddr, int type)
4222 {
4223 const uschar *p = *paddr;
4224 const uschar *pp;
4225
4226 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4227
4228 while (isspace(*p)) p++;
4229 pp = p;
4230 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4231
4232 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4233   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4234
4235 *paddr = p;
4236 switch (type)
4237   {
4238   case 0: return readconf_readtime(pp, *p, FALSE);
4239   case 1: return readconf_readfixed(pp, *p);
4240   }
4241 return 0;    /* Keep picky compilers happy */
4242 }
4243
4244 /* The function proper */
4245
4246 void
4247 readconf_retries(void)
4248 {
4249 retry_config **chain = &retries;
4250 retry_config *next;
4251 const uschar *p;
4252
4253 while ((p = get_config_line()))
4254   {
4255   retry_rule **rchain;
4256   const uschar *pp;
4257   uschar *error;
4258
4259   next = store_get(sizeof(retry_config));
4260   next->next = NULL;
4261   *chain = next;
4262   chain = &(next->next);
4263   next->basic_errno = next->more_errno = 0;
4264   next->senders = NULL;
4265   next->rules = NULL;
4266   rchain = &(next->rules);
4267
4268   next->pattern = string_dequote(&p);
4269   while (isspace(*p)) p++;
4270   pp = p;
4271   while (mac_isgraph(*p)) p++;
4272   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4273     "missing error type in retry rule");
4274
4275   /* Test error names for things we understand. */
4276
4277   if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4278        &next->more_errno)))
4279     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4280
4281   /* There may be an optional address list of senders to be used as another
4282   constraint on the rule. This was added later, so the syntax is a bit of a
4283   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4284   an address list. */
4285
4286   while (isspace(*p)) p++;
4287   if (Ustrncmp(p, "senders", 7) == 0)
4288     {
4289     p += 7;
4290     while (isspace(*p)) p++;
4291     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4292       "\"=\" expected after \"senders\" in retry rule");
4293     while (isspace(*p)) p++;
4294     next->senders = string_dequote(&p);
4295     }
4296
4297   /* Now the retry rules. Keep the maximum timeout encountered. */
4298
4299   while (isspace(*p)) p++;
4300
4301   while (*p != 0)
4302     {
4303     retry_rule *rule = store_get(sizeof(retry_rule));
4304     *rchain = rule;
4305     rchain = &(rule->next);
4306     rule->next = NULL;
4307     rule->rule = toupper(*p++);
4308     rule->timeout = retry_arg(&p, 0);
4309     if (rule->timeout > retry_maximum_timeout)
4310       retry_maximum_timeout = rule->timeout;
4311
4312     switch (rule->rule)
4313       {
4314       case 'F':   /* Fixed interval */
4315         rule->p1 = retry_arg(&p, 0);
4316         break;
4317
4318       case 'G':   /* Geometrically increasing intervals */
4319       case 'H':   /* Ditto, but with randomness */
4320         rule->p1 = retry_arg(&p, 0);
4321         rule->p2 = retry_arg(&p, 1);
4322         break;
4323
4324       default:
4325         log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4326         break;
4327       }
4328
4329     if (rule->timeout <= 0 || rule->p1 <= 0 ||
4330           (rule->rule != 'F' && rule->p2 < 1000))
4331       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4332         "bad parameters for retry rule");
4333
4334     while (isspace(*p)) p++;
4335     if (*p == ';')
4336       {
4337       p++;
4338       while (isspace(*p)) p++;
4339       }
4340     else if (*p != 0)
4341       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4342     }
4343   }
4344 }
4345
4346
4347
4348 /*************************************************
4349 *         Initialize authenticators              *
4350 *************************************************/
4351
4352 static void
4353 readconf_options_auths(void)
4354 {
4355 struct auth_info * ai;
4356
4357 readconf_options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
4358
4359 for (ai = auths_available; ai->driver_name[0]; ai++)
4360   {
4361   macro_create(string_sprintf("_DRIVER_AUTHENTICATOR_%T", ai->driver_name), US"y", FALSE, TRUE);
4362   readconf_options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
4363   }
4364 }
4365
4366
4367 /* Read the authenticators section of the configuration file.
4368
4369 Arguments:   none
4370 Returns:     nothing
4371 */
4372
4373 static void
4374 auths_init(void)
4375 {
4376 auth_instance *au, *bu;
4377
4378 readconf_driver_init(US"authenticator",
4379   (driver_instance **)(&auths),      /* chain anchor */
4380   (driver_info *)auths_available,    /* available drivers */
4381   sizeof(auth_info),                 /* size of info block */
4382   &auth_defaults,                    /* default values for generic options */
4383   sizeof(auth_instance),             /* size of instance block */
4384   optionlist_auths,                  /* generic options */
4385   optionlist_auths_size);
4386
4387 for (au = auths; au; au = au->next)
4388   {
4389   if (!au->public_name)
4390     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4391       "the %s authenticator", au->name);
4392
4393   for (bu = au->next; bu; bu = bu->next)
4394     if (strcmpic(au->public_name, bu->public_name) == 0)
4395       if ((au->client && bu->client) || (au->server && bu->server))
4396         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4397           "(%s and %s) have the same public name (%s)",
4398           au->client ? US"client" : US"server", au->name, bu->name,
4399           au->public_name);
4400   }
4401 }
4402
4403
4404
4405
4406 /*************************************************
4407 *             Read ACL information               *
4408 *************************************************/
4409
4410 /* If this run of Exim is not doing something that involves receiving a
4411 message, we can just skip over the ACL information. No need to parse it.
4412
4413 First, we have a function for acl_read() to call back to get the next line. We
4414 need to remember the line we passed, because at the end it will contain the
4415 name of the next ACL. */
4416
4417 static uschar *acl_line;
4418
4419 static uschar *
4420 acl_callback(void)
4421 {
4422 acl_line = get_config_line();
4423 return acl_line;
4424 }
4425
4426
4427 /* Now the main function:
4428
4429 Arguments:    none
4430 Returns:      nothing
4431 */
4432
4433 static void
4434 readconf_acl(void)
4435 {
4436 uschar *p;
4437
4438 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4439 between ACLs. */
4440
4441 acl_line = get_config_line();
4442
4443 while(acl_line != NULL)
4444   {
4445   uschar name[64];
4446   tree_node *node;
4447   uschar *error;
4448
4449   p = readconf_readname(name, sizeof(name), acl_line);
4450   if (isupper(*name) && *p == '=')
4451     {
4452     read_macro_assignment(acl_line);
4453     acl_line = get_config_line();
4454     continue;
4455     }
4456
4457   if (*p != ':' || name[0] == 0)
4458     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4459
4460   node = store_get(sizeof(tree_node) + Ustrlen(name));
4461   Ustrcpy(node->name, name);
4462   if (!tree_insertnode(&acl_anchor, node))
4463     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4464       "there are two ACLs called \"%s\"", name);
4465
4466   node->data.ptr = acl_read(acl_callback, &error);
4467
4468   if (node->data.ptr == NULL && error != NULL)
4469     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4470   }
4471 }
4472
4473
4474
4475 /*************************************************
4476 *     Read configuration for local_scan()        *
4477 *************************************************/
4478
4479 /* This function is called after "begin local_scan" is encountered in the
4480 configuration file. If the local_scan() function allows for configuration
4481 options, we can process them. Otherwise, we expire in a panic.
4482
4483 Arguments:  none
4484 Returns:    nothing
4485 */
4486
4487 static void
4488 local_scan_init(void)
4489 {
4490 #ifndef LOCAL_SCAN_HAS_OPTIONS
4491 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4492   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4493 #else
4494
4495 uschar *p;
4496 while ((p = get_config_line()) != NULL)
4497   {
4498   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4499     NULL, US"local_scan option \"%s\" unknown");
4500   }
4501 #endif
4502 }
4503
4504
4505
4506 /*************************************************
4507 *     Read rest of configuration (after main)    *
4508 *************************************************/
4509
4510 /* This function reads the rest of the runtime configuration, after the main
4511 configuration. It is called only when actually needed. Each subsequent section
4512 of the configuration starts with a line of the form
4513
4514   begin name
4515
4516 where the name is "routers", "transports", etc. A section is terminated by
4517 hitting the next "begin" line, and the next name is left in next_section.
4518 Because it may confuse people as to whether the names are singular or plural,
4519 we add "s" if it's missing. There is always enough room in next_section for
4520 this. This function is basically just a switch.
4521
4522 Arguments:   none
4523 Returns:     nothing
4524 */
4525
4526 static uschar *section_list[] = {
4527   US"acls",
4528   US"authenticators",
4529   US"local_scans",
4530   US"retrys",
4531   US"rewrites",
4532   US"routers",
4533   US"transports"};
4534
4535 void
4536 readconf_rest(void)
4537 {
4538 int had = 0;
4539
4540 while(next_section[0] != 0)
4541   {
4542   int bit;
4543   int first = 0;
4544   int last = sizeof(section_list) / sizeof(uschar *);
4545   int mid = last/2;
4546   int n = Ustrlen(next_section);
4547
4548   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4549
4550   for (;;)
4551     {
4552     int c = strcmpic(next_section, section_list[mid]);
4553     if (c == 0) break;
4554     if (c > 0) first = mid + 1; else last = mid;
4555     if (first >= last)
4556       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4557         "\"%.*s\" is not a known configuration section name", n, next_section);
4558     mid = (last + first)/2;
4559     }
4560
4561   bit = 1 << mid;
4562   if (((had ^= bit) & bit) == 0)
4563     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4564       "\"%.*s\" section is repeated in the configuration file", n,
4565         next_section);
4566
4567   switch(mid)
4568     {
4569     case 0: readconf_acl(); break;
4570     case 1: auths_init(); break;
4571     case 2: local_scan_init(); break;
4572     case 3: readconf_retries(); break;
4573     case 4: readconf_rewrites(); break;
4574     case 5: route_init(); break;
4575     case 6: transport_init(); break;
4576     }
4577   }
4578
4579 (void)fclose(config_file);
4580 }
4581
4582 /* Init the storage for the pre-parsed config lines */
4583 void
4584 readconf_save_config(const uschar *s)
4585 {
4586   save_config_line(string_sprintf("# Exim Configuration (%s)",
4587     running_in_test_harness ? US"X" : s));
4588 }
4589
4590 static void
4591 save_config_position(const uschar *file, int line)
4592 {
4593   save_config_line(string_sprintf("# %d \"%s\"", line, file));
4594 }
4595
4596 /* Append a pre-parsed logical line to the config lines store,
4597 this operates on a global (static) list that holds all the pre-parsed
4598 config lines, we do no further processing here, output formatting and
4599 honouring of <hide> or macros will be done during output */
4600 static void
4601 save_config_line(const uschar* line)
4602 {
4603 static config_line_item *current;
4604 config_line_item *next;
4605
4606 next = (config_line_item*) store_get(sizeof(config_line_item));
4607 next->line = string_copy(line);
4608 next->next = NULL;
4609
4610 if (!config_lines) config_lines = next;
4611 else current->next = next;
4612
4613 current = next;
4614 }
4615
4616 /* List the parsed config lines, care about nice formatting and
4617 hide the <hide> values unless we're the admin user */
4618 void
4619 print_config(BOOL admin, BOOL terse)
4620 {
4621 config_line_item *i;
4622 const int TS = terse ? 0 : 2;
4623 int indent = 0;
4624
4625 for (i = config_lines; i; i = i->next)
4626   {
4627   uschar *current;
4628   uschar *p;
4629
4630   /* skip over to the first non-space */
4631   for (current = i->line; *current && isspace(*current); ++current)
4632     ;
4633
4634   if (*current == '\0')
4635     continue;
4636
4637   /* Collapse runs of spaces. We stop this if we encounter one of the
4638    * following characters: "'$, as this may indicate careful formatting */
4639   for (p = current; *p; ++p)
4640     {
4641     uschar *next;
4642     if (!isspace(*p)) continue;
4643     if (*p != ' ') *p = ' ';
4644
4645     for (next = p; isspace(*next); ++next)
4646       ;
4647
4648     if (next - p > 1)
4649       memmove(p+1, next, Ustrlen(next)+1);
4650
4651     if (*next == '"' || *next == '\'' || *next == '$')
4652       break;
4653     }
4654
4655   /* # lines */
4656   if (current[0] == '#')
4657     puts(CCS current);
4658
4659   /* begin lines are left aligned */
4660   else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4661     {
4662     if (!terse) puts("");
4663     puts(CCS current);
4664     indent = TS;
4665     }
4666
4667   /* router/acl/transport block names */
4668   else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4669     {
4670     if (!terse) puts("");
4671     printf("%*s%s\n", TS, "", current);
4672     indent = 2 * TS;
4673     }
4674
4675   /* hidden lines (all MACROS or lines prefixed with "hide") */
4676   else if (  !admin
4677           && (  isupper(*current)
4678              || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4679              )
4680           )
4681     {
4682     if ((p = Ustrchr(current, '=')))
4683       {
4684       *p = '\0';
4685       printf("%*s%s= %s\n", indent, "", current, hidden);
4686       }
4687     /* e.g.: hide split_spool_directory */
4688     else
4689       printf("%*s\n", indent, hidden);
4690     }
4691
4692   else
4693     /* rest is public */
4694     printf("%*s%s\n", indent, "", current);
4695   }
4696 }
4697
4698 /* vi: aw ai sw=2
4699 */
4700 /* End of readconf.c */