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