src/src/readconf.c

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