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