src/src/readconf.c

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