src/src/readconf.c

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