src/src/readconf.c

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