src/src/readconf.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Functions for reading the configuration file, and for displaying
   9 overall configuration values. Thanks to Brian Candler for the original
  10 implementation of the conditional .ifdef etc. */
  11
  12 #include "exim.h"
  13
  14 #define CSTATE_STACK_SIZE 10
  15
  16
  17 /* Structure for chain (stack) of .included files */
  18
  19 typedef struct config_file_item {
  20   struct config_file_item *next;
  21   uschar *filename;
  22   FILE *file;
  23   int lineno;
  24 } config_file_item;
  25
  26 /* Structure of table of conditional words and their state transitions */
  27
  28 typedef struct cond_item {
  29   uschar *name;
  30   int    namelen;
  31   int    action1;
  32   int    action2;
  33   int    pushpop;
  34 } cond_item;
  35
  36 /* Structure of table of syslog facility names and values */
  37
  38 typedef struct syslog_fac_item {
  39   uschar *name;
  40   int    value;
  41 } syslog_fac_item;
  42
  43
  44 /* Static variables */
  45
  46 static config_file_item *config_file_stack = NULL;  /* For includes */
  47
  48 static uschar *syslog_facility_str  = NULL;
  49 static uschar next_section[24];
  50 static uschar time_buffer[24];
  51
  52 /* State variables for conditional loading (.ifdef / .else / .endif) */
  53
  54 static int cstate = 0;
  55 static int cstate_stack_ptr = -1;
  56 static int cstate_stack[CSTATE_STACK_SIZE];
  57
  58 /* Table of state transitions for handling conditional inclusions. There are
  59 four possible state transitions:
  60
  61   .ifdef true
  62   .ifdef false
  63   .elifdef true  (or .else)
  64   .elifdef false
  65
  66 .endif just causes the previous cstate to be popped off the stack */
  67
  68 static int next_cstate[3][4] =
  69   {
  70   /* State 0: reading from file, or reading until next .else or .endif */
  71   { 0, 1, 2, 2 },
  72   /* State 1: condition failed, skipping until next .else or .endif */
  73   { 2, 2, 0, 1 },
  74   /* State 2: skipping until .endif */
  75   { 2, 2, 2, 2 },
  76   };
  77
  78 /* Table of conditionals and the states to set. For each name, there are four
  79 values: the length of the name (to save computing it each time), the state to
  80 set if a macro was found in the line, the state to set if a macro was not found
  81 in the line, and a stack manipulation setting which is:
  82
  83   -1   pull state value off the stack
  84    0   don't alter the stack
  85   +1   push value onto stack, before setting new state
  86 */
  87
  88 static cond_item cond_list[] = {
  89   { US"ifdef",    5, 0, 1,  1 },
  90   { US"ifndef",   6, 1, 0,  1 },
  91   { US"elifdef",  7, 2, 3,  0 },
  92   { US"elifndef", 8, 3, 2,  0 },
  93   { US"else",     4, 2, 2,  0 },
  94   { US"endif",    5, 0, 0, -1 }
  95 };
  96
  97 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
  98
  99 /* Table of syslog facility names and their values */
 100
 101 static syslog_fac_item syslog_list[] = {
 102   { US"mail",   LOG_MAIL },
 103   { US"user",   LOG_USER },
 104   { US"news",   LOG_NEWS },
 105   { US"uucp",   LOG_UUCP },
 106   { US"local0", LOG_LOCAL0 },
 107   { US"local1", LOG_LOCAL1 },
 108   { US"local2", LOG_LOCAL2 },
 109   { US"local3", LOG_LOCAL3 },
 110   { US"local4", LOG_LOCAL4 },
 111   { US"local5", LOG_LOCAL5 },
 112   { US"local6", LOG_LOCAL6 },
 113   { US"local7", LOG_LOCAL7 },
 114   { US"daemon", LOG_DAEMON }
 115 };
 116
 117 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
 118
 119
 120
 121
 122 /*************************************************
 123 *           Main configuration options           *
 124 *************************************************/
 125
 126 /* The list of options that can be set in the main configuration file. This
 127 must be in alphabetic order because it is searched by binary chop. */
 128
 129 static optionlist optionlist_config[] = {
 130   { "*set_exim_group",          opt_bool|opt_hidden, &exim_gid_set },
 131   { "*set_exim_user",           opt_bool|opt_hidden, &exim_uid_set },
 132   { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
 133   { "*set_system_filter_user",  opt_bool|opt_hidden, &system_filter_uid_set },
 134   { "accept_8bitmime",          opt_bool,        &accept_8bitmime },
 135   { "acl_not_smtp",             opt_stringptr,   &acl_not_smtp },
 136 #ifdef WITH_CONTENT_SCAN
 137   { "acl_not_smtp_mime",        opt_stringptr,   &acl_not_smtp_mime },
 138 #endif
 139   { "acl_not_smtp_start",       opt_stringptr,   &acl_not_smtp_start },
 140   { "acl_smtp_auth",            opt_stringptr,   &acl_smtp_auth },
 141   { "acl_smtp_connect",         opt_stringptr,   &acl_smtp_connect },
 142   { "acl_smtp_data",            opt_stringptr,   &acl_smtp_data },
 143 #ifndef DISABLE_DKIM
 144   { "acl_smtp_dkim",            opt_stringptr,   &acl_smtp_dkim },
 145 #endif
 146   { "acl_smtp_etrn",            opt_stringptr,   &acl_smtp_etrn },
 147   { "acl_smtp_expn",            opt_stringptr,   &acl_smtp_expn },
 148   { "acl_smtp_helo",            opt_stringptr,   &acl_smtp_helo },
 149   { "acl_smtp_mail",            opt_stringptr,   &acl_smtp_mail },
 150   { "acl_smtp_mailauth",        opt_stringptr,   &acl_smtp_mailauth },
 151 #ifdef WITH_CONTENT_SCAN
 152   { "acl_smtp_mime",            opt_stringptr,   &acl_smtp_mime },
 153 #endif
 154   { "acl_smtp_notquit",         opt_stringptr,   &acl_smtp_notquit },
 155   { "acl_smtp_predata",         opt_stringptr,   &acl_smtp_predata },
 156   { "acl_smtp_quit",            opt_stringptr,   &acl_smtp_quit },
 157   { "acl_smtp_rcpt",            opt_stringptr,   &acl_smtp_rcpt },
 158 #ifdef SUPPORT_TLS
 159   { "acl_smtp_starttls",        opt_stringptr,   &acl_smtp_starttls },
 160 #endif
 161   { "acl_smtp_vrfy",            opt_stringptr,   &acl_smtp_vrfy },
 162   { "admin_groups",             opt_gidlist,     &admin_groups },
 163   { "allow_domain_literals",    opt_bool,        &allow_domain_literals },
 164   { "allow_mx_to_ip",           opt_bool,        &allow_mx_to_ip },
 165   { "allow_utf8_domains",       opt_bool,        &allow_utf8_domains },
 166   { "auth_advertise_hosts",     opt_stringptr,   &auth_advertise_hosts },
 167   { "auto_thaw",                opt_time,        &auto_thaw },
 168 #ifdef WITH_CONTENT_SCAN
 169   { "av_scanner",               opt_stringptr,   &av_scanner },
 170 #endif
 171   { "bi_command",               opt_stringptr,   &bi_command },
 172 #ifdef EXPERIMENTAL_BRIGHTMAIL
 173   { "bmi_config_file",          opt_stringptr,   &bmi_config_file },
 174 #endif
 175   { "bounce_message_file",      opt_stringptr,   &bounce_message_file },
 176   { "bounce_message_text",      opt_stringptr,   &bounce_message_text },
 177   { "bounce_return_body",       opt_bool,        &bounce_return_body },
 178   { "bounce_return_message",    opt_bool,        &bounce_return_message },
 179   { "bounce_return_size_limit", opt_mkint,       &bounce_return_size_limit },
 180   { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
 181   { "callout_domain_negative_expire", opt_time,  &callout_cache_domain_negative_expire },
 182   { "callout_domain_positive_expire", opt_time,  &callout_cache_domain_positive_expire },
 183   { "callout_negative_expire",  opt_time,        &callout_cache_negative_expire },
 184   { "callout_positive_expire",  opt_time,        &callout_cache_positive_expire },
 185   { "callout_random_local_part",opt_stringptr,   &callout_random_local_part },
 186   { "check_log_inodes",         opt_int,         &check_log_inodes },
 187   { "check_log_space",          opt_Kint,        &check_log_space },
 188   { "check_rfc2047_length",     opt_bool,        &check_rfc2047_length },
 189   { "check_spool_inodes",       opt_int,         &check_spool_inodes },
 190   { "check_spool_space",        opt_Kint,        &check_spool_space },
 191   { "daemon_smtp_port",         opt_stringptr|opt_hidden, &daemon_smtp_port },
 192   { "daemon_smtp_ports",        opt_stringptr,   &daemon_smtp_port },
 193   { "daemon_startup_retries",   opt_int,         &daemon_startup_retries },
 194   { "daemon_startup_sleep",     opt_time,        &daemon_startup_sleep },
 195 #ifdef EXPERIMENTAL_DCC
 196   { "dcc_direct_add_header",    opt_bool,        &dcc_direct_add_header },
 197   { "dccifd_address",           opt_stringptr,   &dccifd_address },
 198   { "dccifd_options",           opt_stringptr,   &dccifd_options },
 199 #endif
 200   { "delay_warning",            opt_timelist,    &delay_warning },
 201   { "delay_warning_condition",  opt_stringptr,   &delay_warning_condition },
 202   { "deliver_drop_privilege",   opt_bool,        &deliver_drop_privilege },
 203   { "deliver_queue_load_max",   opt_fixed,       &deliver_queue_load_max },
 204   { "delivery_date_remove",     opt_bool,        &delivery_date_remove },
 205 #ifdef ENABLE_DISABLE_FSYNC
 206   { "disable_fsync",            opt_bool,        &disable_fsync },
 207 #endif
 208   { "disable_ipv6",             opt_bool,        &disable_ipv6 },
 209 #ifndef DISABLE_DKIM
 210   { "dkim_verify_signers",      opt_stringptr,   &dkim_verify_signers },
 211 #endif
 212   { "dns_again_means_nonexist", opt_stringptr,   &dns_again_means_nonexist },
 213   { "dns_check_names_pattern",  opt_stringptr,   &check_dns_names_pattern },
 214   { "dns_csa_search_limit",     opt_int,         &dns_csa_search_limit },
 215   { "dns_csa_use_reverse",      opt_bool,        &dns_csa_use_reverse },
 216   { "dns_ipv4_lookup",          opt_stringptr,   &dns_ipv4_lookup },
 217   { "dns_retrans",              opt_time,        &dns_retrans },
 218   { "dns_retry",                opt_int,         &dns_retry },
 219   { "dns_use_edns0",            opt_int,         &dns_use_edns0 },
 220  /* This option is now a no-op, retained for compability */
 221   { "drop_cr",                  opt_bool,        &drop_cr },
 222 /*********************************************************/
 223   { "dsn_from",                 opt_stringptr,   &dsn_from },
 224   { "envelope_to_remove",       opt_bool,        &envelope_to_remove },
 225   { "errors_copy",              opt_stringptr,   &errors_copy },
 226   { "errors_reply_to",          opt_stringptr,   &errors_reply_to },
 227   { "exim_group",               opt_gid,         &exim_gid },
 228   { "exim_path",                opt_stringptr,   &exim_path },
 229   { "exim_user",                opt_uid,         &exim_uid },
 230   { "extra_local_interfaces",   opt_stringptr,   &extra_local_interfaces },
 231   { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
 232   { "finduser_retries",         opt_int,         &finduser_retries },
 233   { "freeze_tell",              opt_stringptr,   &freeze_tell },
 234   { "gecos_name",               opt_stringptr,   &gecos_name },
 235   { "gecos_pattern",            opt_stringptr,   &gecos_pattern },
 236 #ifdef SUPPORT_TLS
 237   { "gnutls_compat_mode",       opt_bool,        &gnutls_compat_mode },
 238   /* These three gnutls_require_* options stopped working in Exim 4.78 */
 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 " SIZE_T_FMT " 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 /* Set default value of process_log_path */
3116
3117 if (process_log_path == NULL || *process_log_path =='\0')
3118   process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3119
3120 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3121 message. */
3122
3123 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3124
3125 /* Unpick the SMTP rate limiting options, if set */
3126
3127 if (smtp_ratelimit_mail != NULL)
3128   {
3129   unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3130     &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3131   }
3132
3133 if (smtp_ratelimit_rcpt != NULL)
3134   {
3135   unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3136     &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3137   }
3138
3139 /* The qualify domains default to the primary host name */
3140
3141 if (qualify_domain_sender == NULL)
3142   qualify_domain_sender = primary_hostname;
3143 if (qualify_domain_recipient == NULL)
3144   qualify_domain_recipient = qualify_domain_sender;
3145
3146 /* Setting system_filter_user in the configuration sets the gid as well if a
3147 name is given, but a numerical value does not. */
3148
3149 if (system_filter_uid_set && !system_filter_gid_set)
3150   {
3151   struct passwd *pw = getpwuid(system_filter_uid);
3152   if (pw == NULL)
3153     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3154       (long int)system_filter_uid);
3155   system_filter_gid = pw->pw_gid;
3156   system_filter_gid_set = TRUE;
3157   }
3158
3159 /* If the errors_reply_to field is set, check that it is syntactically valid
3160 and ensure it contains a domain. */
3161
3162 if (errors_reply_to != NULL)
3163   {
3164   uschar *errmess;
3165   int start, end, domain;
3166   uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3167     &start, &end, &domain, FALSE);
3168
3169   if (recipient == NULL)
3170     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3171       "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3172
3173   if (domain == 0)
3174     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3175       "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3176   }
3177
3178 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3179 smtp_accept_max must also be set. */
3180
3181 if (smtp_accept_max == 0 &&
3182     (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3183   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3184     "smtp_accept_max must be set if smtp_accept_queue or "
3185     "smtp_accept_max_per_host is set");
3186
3187 /* Set up the host number if anything is specified. It is an expanded string
3188 so that it can be computed from the host name, for example. We do this last
3189 so as to ensure that everything else is set up before the expansion. */
3190
3191 if (host_number_string != NULL)
3192   {
3193   long int n;
3194   uschar *end;
3195   uschar *s = expand_string(host_number_string);
3196   if (s == NULL)
3197     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3198         "failed to expand localhost_number \"%s\": %s",
3199         host_number_string, expand_string_message);
3200   n = Ustrtol(s, &end, 0);
3201   while (isspace(*end)) end++;
3202   if (*end != 0)
3203     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3204       "localhost_number value is not a number: %s", s);
3205   if (n > LOCALHOST_MAX)
3206     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3207       "localhost_number is greater than the maximum allowed value (%d)",
3208         LOCALHOST_MAX);
3209   host_number = n;
3210   }
3211
3212 #ifdef SUPPORT_TLS
3213 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3214
3215 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3216      tls_verify_certificates == NULL)
3217   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3218     "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3219     (tls_verify_hosts != NULL)? "" : "try_");
3220
3221 /* If openssl_options is set, validate it */
3222 if (openssl_options != NULL)
3223   {
3224 # ifdef USE_GNUTLS
3225   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3226     "openssl_options is set but we're using GnuTLS");
3227 # else
3228   long dummy;
3229   if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3230     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3231       "openssl_options parse error: %s", openssl_options);
3232 # endif
3233   }
3234 #endif
3235 }
3236
3237
3238
3239 /*************************************************
3240 *          Initialize one driver                 *
3241 *************************************************/
3242
3243 /* This is called once the driver's generic options, if any, have been read.
3244 We can now find the driver, set up defaults for the private options, and
3245 unset any "set" bits in the private options table (which might have been
3246 set by another incarnation of the same driver).
3247
3248 Arguments:
3249   d                   pointer to driver instance block, with generic
3250                         options filled in
3251   drivers_available   vector of available drivers
3252   size_of_info        size of each block in drivers_available
3253   class               class of driver, for error message
3254
3255 Returns:              pointer to the driver info block
3256 */
3257
3258 static driver_info *
3259 init_driver(driver_instance *d, driver_info *drivers_available,
3260   int size_of_info, uschar *class)
3261 {
3262 driver_info *dd;
3263
3264 for (dd = drivers_available; dd->driver_name[0] != 0;
3265      dd = (driver_info *)(((uschar *)dd) + size_of_info))
3266   {
3267   if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3268     {
3269     int i;
3270     int len = dd->options_len;
3271     d->info = dd;
3272     d->options_block = store_get(len);
3273     memcpy(d->options_block, dd->options_block, len);
3274     for (i = 0; i < *(dd->options_count); i++)
3275       dd->options[i].type &= ~opt_set;
3276     return dd;
3277     }
3278   }
3279
3280 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3281   "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3282
3283 return NULL;   /* never obeyed */
3284 }
3285
3286
3287
3288
3289 /*************************************************
3290 *             Initialize driver list             *
3291 *************************************************/
3292
3293 /* This function is called for routers, transports, and authentication
3294 mechanisms. It reads the data from the current point in the configuration file
3295 up to the end of the section, and sets up a chain of instance blocks according
3296 to the file's contents. The file will already have been opened by a call to
3297 readconf_main, and must be left open for subsequent reading of further data.
3298
3299 Any errors cause a panic crash. Note that the blocks with names driver_info and
3300 driver_instance must map the first portions of all the _info and _instance
3301 blocks for this shared code to work.
3302
3303 Arguments:
3304   class                      "router", "transport", or "authenticator"
3305   anchor                     &routers, &transports, &auths
3306   drivers_available          available drivers
3307   size_of_info               size of each info block
3308   instance_default           points to default data for an instance
3309   instance_size              size of instance block
3310   driver_optionlist          generic option list
3311   driver_optionlist_count    count of generic option list
3312
3313 Returns:                     nothing
3314 */
3315
3316 void
3317 readconf_driver_init(
3318   uschar *class,
3319   driver_instance **anchor,
3320   driver_info *drivers_available,
3321   int size_of_info,
3322   void *instance_default,
3323   int  instance_size,
3324   optionlist *driver_optionlist,
3325   int  driver_optionlist_count)
3326 {
3327 driver_instance **p = anchor;
3328 driver_instance *d = NULL;
3329 uschar *buffer;
3330
3331 while ((buffer = get_config_line()) != NULL)
3332   {
3333   uschar name[64];
3334   uschar *s;
3335
3336   /* Read the first name on the line and test for the start of a new driver. A
3337   macro definition indicates the end of the previous driver. If this isn't the
3338   start of a new driver, the line will be re-read. */
3339
3340   s = readconf_readname(name, sizeof(name), buffer);
3341
3342   /* Handle macro definition, first finishing off the initialization of the
3343   previous driver, if any. */
3344
3345   if (isupper(*name) && *s == '=')
3346     {
3347     if (d != NULL)
3348       {
3349       if (d->driver_name == NULL)
3350         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3351           "no driver defined for %s \"%s\"", class, d->name);
3352       (d->info->init)(d);
3353       d = NULL;
3354       }
3355     read_macro_assignment(buffer);
3356     continue;
3357     }
3358
3359   /* If the line starts with a name terminated by a colon, we are at the
3360   start of the definition of a new driver. The rest of the line must be
3361   blank. */
3362
3363   if (*s++ == ':')
3364     {
3365     int i;
3366
3367     /* Finish off initializing the previous driver. */
3368
3369     if (d != NULL)
3370       {
3371       if (d->driver_name == NULL)
3372         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3373           "no driver defined for %s \"%s\"", class, d->name);
3374       (d->info->init)(d);
3375       }
3376
3377     /* Check that we haven't already got a driver of this name */
3378
3379     for (d = *anchor; d != NULL; d = d->next)
3380       if (Ustrcmp(name, d->name) == 0)
3381         log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3382           "there are two %ss called \"%s\"", class, name);
3383
3384     /* Set up a new driver instance data block on the chain, with
3385     its default values installed. */
3386
3387     d = store_get(instance_size);
3388     memcpy(d, instance_default, instance_size);
3389     *p = d;
3390     p = &(d->next);
3391     d->name = string_copy(name);
3392
3393     /* Clear out the "set" bits in the generic options */
3394
3395     for (i = 0; i < driver_optionlist_count; i++)
3396       driver_optionlist[i].type &= ~opt_set;
3397
3398     /* Check nothing more on this line, then do the next loop iteration. */
3399
3400     while (isspace(*s)) s++;
3401     if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3402     continue;
3403     }
3404
3405   /* Not the start of a new driver. Give an error if we have not set up a
3406   current driver yet. */
3407
3408   if (d == NULL) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3409     "%s name missing", class);
3410
3411   /* First look to see if this is a generic option; if it is "driver",
3412   initialize the driver. If is it not a generic option, we can look for a
3413   private option provided that the driver has been previously set up. */
3414
3415   if (readconf_handle_option(buffer, driver_optionlist,
3416         driver_optionlist_count, d, NULL))
3417     {
3418     if (d->info == NULL && d->driver_name != NULL)
3419       init_driver(d, drivers_available, size_of_info, class);
3420     }
3421
3422   /* Handle private options - pass the generic block because some may
3423   live therein. A flag with each option indicates if it is in the public
3424   block. */
3425
3426   else if (d->info != NULL)
3427     {
3428     readconf_handle_option(buffer, d->info->options,
3429       *(d->info->options_count), d, US"option \"%s\" unknown");
3430     }
3431
3432   /* The option is not generic and the driver name has not yet been given. */
3433
3434   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3435     "(\"driver\" must be specified before any private options)", name);
3436   }
3437
3438 /* Run the initialization function for the final driver. */
3439
3440 if (d != NULL)
3441   {
3442   if (d->driver_name == NULL)
3443     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3444       "no driver defined for %s \"%s\"", class, d->name);
3445   (d->info->init)(d);
3446   }
3447 }
3448
3449
3450
3451 /*************************************************
3452 *            Check driver dependency             *
3453 *************************************************/
3454
3455 /* This function is passed a driver instance and a string. It checks whether
3456 any of the string options for the driver contains the given string as an
3457 expansion variable.
3458
3459 Arguments:
3460   d        points to a driver instance block
3461   s        the string to search for
3462
3463 Returns:   TRUE if a dependency is found
3464 */
3465
3466 BOOL
3467 readconf_depends(driver_instance *d, uschar *s)
3468 {
3469 int count = *(d->info->options_count);
3470 optionlist *ol;
3471 uschar *ss;
3472
3473 for (ol = d->info->options; ol < d->info->options + count; ol++)
3474   {
3475   void *options_block;
3476   uschar *value;
3477   int type = ol->type & opt_mask;
3478   if (type != opt_stringptr) continue;
3479   options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3480   value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3481   if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3482     {
3483     if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3484       isalnum(ss[Ustrlen(s)])) continue;
3485     DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3486       d->name, ol->name, s);
3487     return TRUE;
3488     }
3489   }
3490
3491 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3492 return FALSE;
3493 }
3494
3495
3496
3497
3498 /*************************************************
3499 *      Decode an error type for retries          *
3500 *************************************************/
3501
3502 /* This function is global because it is also called from the main
3503 program when testing retry information. It decodes strings such as "quota_7d"
3504 into numerical error codes.
3505
3506 Arguments:
3507   pp           points to start of text
3508   p            points past end of text
3509   basic_errno  points to an int to receive the main error number
3510   more_errno   points to an int to receive the secondary error data
3511
3512 Returns:       NULL if decoded correctly; else points to error text
3513 */
3514
3515 uschar *
3516 readconf_retry_error(uschar *pp, uschar *p, int *basic_errno, int *more_errno)
3517 {
3518 int len;
3519 uschar *q = pp;
3520 while (q < p && *q != '_') q++;
3521 len = q - pp;
3522
3523 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3524   {
3525   *basic_errno = ERRNO_EXIMQUOTA;
3526   if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3527       return US"bad time value";
3528   }
3529
3530 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3531   {
3532   *basic_errno = ECONNREFUSED;
3533   if (q != p)
3534     {
3535     if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3536     else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3537     else return US"A or MX expected after \"refused\"";
3538     }
3539   }
3540
3541 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3542   {
3543   *basic_errno = ETIMEDOUT;
3544   if (q != p)
3545     {
3546     int i;
3547     int xlen = p - q - 1;
3548     uschar *x = q + 1;
3549
3550     static uschar *extras[] =
3551       { US"A", US"MX", US"connect", US"connect_A",  US"connect_MX" };
3552     static int values[] =
3553       { 'A',   'M',    RTEF_CTOUT,  RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3554
3555     for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3556       {
3557       if (strncmpic(x, extras[i], xlen) == 0)
3558         {
3559         *more_errno = values[i];
3560         break;
3561         }
3562       }
3563
3564     if (i >= sizeof(extras)/sizeof(uschar *))
3565       {
3566       if (strncmpic(x, US"DNS", xlen) == 0)
3567         {
3568         log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3569           "available in retry rules (it has never worked) - treated as "
3570           "\"timeout\"");
3571         }
3572       else return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3573       }
3574     }
3575   }
3576
3577 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3578          strncmpic(pp, US"rcpt_4", 6) == 0 ||
3579          strncmpic(pp, US"data_4", 6) == 0)
3580   {
3581   BOOL bad = FALSE;
3582   int x = 255;                           /* means "any 4xx code" */
3583   if (p != pp + 8) bad = TRUE; else
3584     {
3585     int a = pp[6], b = pp[7];
3586     if (isdigit(a))
3587       {
3588       x = (a - '0') * 10;
3589       if (isdigit(b)) x += b - '0';
3590       else if (b == 'x') x += 100;
3591       else bad = TRUE;
3592       }
3593     else if (a != 'x' || b != 'x') bad = TRUE;
3594     }
3595
3596   if (bad)
3597     return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3598       "x is literal and d is any digit", pp);
3599
3600   *basic_errno = (*pp == 'm')? ERRNO_MAIL4XX :
3601                  (*pp == 'r')? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3602   *more_errno = x << 8;
3603   }
3604
3605 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3606          strncmpic(q+1, US"failed", p-q-1) == 0)
3607   *basic_errno = ERRNO_AUTHFAIL;
3608
3609 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3610   *basic_errno = ERRNO_SMTPCLOSED;
3611
3612 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3613   *basic_errno = ERRNO_TLSREQUIRED;
3614
3615 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3616   return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3617
3618 return NULL;
3619 }
3620
3621
3622
3623
3624 /*************************************************
3625 *                Read retry information          *
3626 *************************************************/
3627
3628 /* Each line of retry information contains:
3629
3630 .  A domain name pattern or an address pattern;
3631
3632 .  An error name, possibly with additional data, or *;
3633
3634 .  An optional sequence of retry items, each consisting of an identifying
3635    letter, a cutoff time, and optional parameters.
3636
3637 All this is decoded and placed into a control block. */
3638
3639
3640 /* Subroutine to read an argument, preceded by a comma and terminated
3641 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3642 1 = fixed point number (returned *1000).
3643
3644 Arguments:
3645   paddr     pointer to pointer to current character; updated
3646   type      0 => read a time; 1 => read a fixed point number
3647
3648 Returns:    time in seconds or fixed point number * 1000
3649 */
3650
3651 static int
3652 retry_arg(uschar **paddr, int type)
3653 {
3654 uschar *p = *paddr;
3655 uschar *pp;
3656
3657 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3658
3659 while (isspace(*p)) p++;
3660 pp = p;
3661 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3662
3663 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3664   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3665
3666 *paddr = p;
3667 switch (type)
3668   {
3669   case 0:
3670   return readconf_readtime(pp, *p, FALSE);
3671   case 1:
3672   return readconf_readfixed(pp, *p);
3673   }
3674 return 0;    /* Keep picky compilers happy */
3675 }
3676
3677 /* The function proper */
3678
3679 void
3680 readconf_retries(void)
3681 {
3682 retry_config **chain = &retries;
3683 retry_config *next;
3684 uschar *p;
3685
3686 while ((p = get_config_line()) != NULL)
3687   {
3688   retry_rule **rchain;
3689   uschar *pp, *error;
3690
3691   next = store_get(sizeof(retry_config));
3692   next->next = NULL;
3693   *chain = next;
3694   chain = &(next->next);
3695   next->basic_errno = next->more_errno = 0;
3696   next->senders = NULL;
3697   next->rules = NULL;
3698   rchain = &(next->rules);
3699
3700   next->pattern = string_dequote(&p);
3701   while (isspace(*p)) p++;
3702   pp = p;
3703   while (mac_isgraph(*p)) p++;
3704   if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3705     "missing error type");
3706
3707   /* Test error names for things we understand. */
3708
3709   if ((error = readconf_retry_error(pp, p, &(next->basic_errno),
3710        &(next->more_errno))) != NULL)
3711     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3712
3713   /* There may be an optional address list of senders to be used as another
3714   constraint on the rule. This was added later, so the syntax is a bit of a
3715   fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3716   an address list. */
3717
3718   while (isspace(*p)) p++;
3719   if (Ustrncmp(p, "senders", 7) == 0)
3720     {
3721     p += 7;
3722     while (isspace(*p)) p++;
3723     if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3724       "\"=\" expected after \"senders\" in retry rule");
3725     while (isspace(*p)) p++;
3726     next->senders = string_dequote(&p);
3727     }
3728
3729   /* Now the retry rules. Keep the maximum timeout encountered. */
3730
3731   while (isspace(*p)) p++;
3732
3733   while (*p != 0)
3734     {
3735     retry_rule *rule = store_get(sizeof(retry_rule));
3736     *rchain = rule;
3737     rchain = &(rule->next);
3738     rule->next = NULL;
3739     rule->rule = toupper(*p++);
3740     rule->timeout = retry_arg(&p, 0);
3741     if (rule->timeout > retry_maximum_timeout)
3742       retry_maximum_timeout = rule->timeout;
3743
3744     switch (rule->rule)
3745       {
3746       case 'F':   /* Fixed interval */
3747       rule->p1 = retry_arg(&p, 0);
3748       break;
3749
3750       case 'G':   /* Geometrically increasing intervals */
3751       case 'H':   /* Ditto, but with randomness */
3752       rule->p1 = retry_arg(&p, 0);
3753       rule->p2 = retry_arg(&p, 1);
3754       break;
3755
3756       default:
3757       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
3758       break;
3759       }
3760
3761     if (rule->timeout <= 0 || rule->p1 <= 0 ||
3762           (rule->rule != 'F' && rule->p2 < 1000))
3763       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3764         "bad parameters for retry rule");
3765
3766     while (isspace(*p)) p++;
3767     if (*p == ';')
3768       {
3769       p++;
3770       while (isspace(*p)) p++;
3771       }
3772     else if (*p != 0)
3773       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
3774     }
3775   }
3776 }
3777
3778
3779
3780 /*************************************************
3781 *         Initialize authenticators              *
3782 *************************************************/
3783
3784 /* Read the authenticators section of the configuration file.
3785
3786 Arguments:   none
3787 Returns:     nothing
3788 */
3789
3790 static void
3791 auths_init(void)
3792 {
3793 auth_instance *au, *bu;
3794 readconf_driver_init(US"authenticator",
3795   (driver_instance **)(&auths),      /* chain anchor */
3796   (driver_info *)auths_available,    /* available drivers */
3797   sizeof(auth_info),                 /* size of info block */
3798   &auth_defaults,                    /* default values for generic options */
3799   sizeof(auth_instance),             /* size of instance block */
3800   optionlist_auths,                  /* generic options */
3801   optionlist_auths_size);
3802
3803 for (au = auths; au != NULL; au = au->next)
3804   {
3805   if (au->public_name == NULL)
3806     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
3807       "the %s authenticator", au->name);
3808   for (bu = au->next; bu != NULL; bu = bu->next)
3809     {
3810     if (strcmpic(au->public_name, bu->public_name) == 0)
3811       {
3812       if ((au->client && bu->client) || (au->server && bu->server))
3813         log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
3814           "(%s and %s) have the same public name (%s)",
3815           (au->client)? US"client" : US"server", au->name, bu->name,
3816           au->public_name);
3817       }
3818     }
3819   }
3820 }
3821
3822
3823
3824
3825 /*************************************************
3826 *             Read ACL information               *
3827 *************************************************/
3828
3829 /* If this run of Exim is not doing something that involves receiving a
3830 message, we can just skip over the ACL information. No need to parse it.
3831
3832 First, we have a function for acl_read() to call back to get the next line. We
3833 need to remember the line we passed, because at the end it will contain the
3834 name of the next ACL. */
3835
3836 static uschar *acl_line;
3837
3838 static uschar *
3839 acl_callback(void)
3840 {
3841 acl_line = get_config_line();
3842 return acl_line;
3843 }
3844
3845
3846 /* Now the main function:
3847
3848 Arguments:
3849   skip        TRUE when this Exim process is doing something that will
3850               not need the ACL data
3851
3852 Returns:      nothing
3853 */
3854
3855 static void
3856 readconf_acl(BOOL skip)
3857 {
3858 uschar *p;
3859
3860 /* Not receiving messages, don't need to parse the ACL data */
3861
3862 if (skip)
3863   {
3864   DEBUG(D_acl) debug_printf("skipping ACL configuration - not needed\n");
3865   while ((p = get_config_line()) != NULL);
3866   return;
3867   }
3868
3869 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
3870 between ACLs. */
3871
3872 acl_line = get_config_line();
3873
3874 while(acl_line != NULL)
3875   {
3876   uschar name[64];
3877   tree_node *node;
3878   uschar *error;
3879
3880   p = readconf_readname(name, sizeof(name), acl_line);
3881   if (isupper(*name) && *p == '=')
3882     {
3883     read_macro_assignment(acl_line);
3884     acl_line = get_config_line();
3885     continue;
3886     }
3887
3888   if (*p != ':' || name[0] == 0)
3889     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
3890
3891   node = store_get(sizeof(tree_node) + Ustrlen(name));
3892   Ustrcpy(node->name, name);
3893   if (!tree_insertnode(&acl_anchor, node))
3894     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3895       "there are two ACLs called \"%s\"", name);
3896
3897   node->data.ptr = acl_read(acl_callback, &error);
3898
3899   if (node->data.ptr == NULL && error != NULL)
3900     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
3901   }
3902 }
3903
3904
3905
3906 /*************************************************
3907 *     Read configuration for local_scan()        *
3908 *************************************************/
3909
3910 /* This function is called after "begin local_scan" is encountered in the
3911 configuration file. If the local_scan() function allows for configuration
3912 options, we can process them. Otherwise, we expire in a panic.
3913
3914 Arguments:  none
3915 Returns:    nothing
3916 */
3917
3918 static void
3919 local_scan_init(void)
3920 {
3921 #ifndef LOCAL_SCAN_HAS_OPTIONS
3922 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
3923   "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
3924 #else
3925
3926 uschar *p;
3927 while ((p = get_config_line()) != NULL)
3928   {
3929   (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
3930     NULL, US"local_scan option \"%s\" unknown");
3931   }
3932 #endif
3933 }
3934
3935
3936
3937 /*************************************************
3938 *     Read rest of configuration (after main)    *
3939 *************************************************/
3940
3941 /* This function reads the rest of the runtime configuration, after the main
3942 configuration. It is called only when actually needed. Each subsequent section
3943 of the configuration starts with a line of the form
3944
3945   begin name
3946
3947 where the name is "routers", "transports", etc. A section is terminated by
3948 hitting the next "begin" line, and the next name is left in next_section.
3949 Because it may confuse people as to whether the names are singular or plural,
3950 we add "s" if it's missing. There is always enough room in next_section for
3951 this. This function is basically just a switch.
3952
3953 Arguments:
3954   skip_acl   TRUE if ACL information is not needed
3955
3956 Returns:     nothing
3957 */
3958
3959 static uschar *section_list[] = {
3960   US"acls",
3961   US"authenticators",
3962   US"local_scans",
3963   US"retrys",
3964   US"rewrites",
3965   US"routers",
3966   US"transports"};
3967
3968 void
3969 readconf_rest(BOOL skip_acl)
3970 {
3971 int had = 0;
3972
3973 while(next_section[0] != 0)
3974   {
3975   int bit;
3976   int first = 0;
3977   int last = sizeof(section_list) / sizeof(uschar *);
3978   int mid = last/2;
3979   int n = Ustrlen(next_section);
3980
3981   if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
3982
3983   for (;;)
3984     {
3985     int c = strcmpic(next_section, section_list[mid]);
3986     if (c == 0) break;
3987     if (c > 0) first = mid + 1; else last = mid;
3988     if (first >= last)
3989       log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3990         "\"%.*s\" is not a known configuration section name", n, next_section);
3991     mid = (last + first)/2;
3992     }
3993
3994   bit = 1 << mid;
3995   if (((had ^= bit) & bit) == 0)
3996     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3997       "\"%.*s\" section is repeated in the configuration file", n,
3998         next_section);
3999
4000   switch(mid)
4001     {
4002     case 0: readconf_acl(skip_acl); break;
4003     case 1: auths_init(); break;
4004     case 2: local_scan_init(); break;
4005     case 3: readconf_retries(); break;
4006     case 4: readconf_rewrites(); break;
4007     case 5: route_init(); break;
4008     case 6: transport_init(); break;
4009     }
4010   }
4011
4012 (void)fclose(config_file);
4013 }
4014
4015 /* End of readconf.c */