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