src/src/readconf.c

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