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