src/src/readconf.c

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