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