1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 - 2021 */
7 /* See the file NOTICE for conditions of use and distribution. */
9 /* Functions for reading the configuration file, and for displaying
10 overall configuration values. Thanks to Brian Candler for the original
11 implementation of the conditional .ifdef etc. */
16 # include "macro_predef.h"
19 #define READCONF_DEBUG if (FALSE) /* Change to TRUE to enable */
22 static uschar * syslog_facility_str;
23 static void fn_smtp_receive_timeout(const uschar *, const uschar *, unsigned);
25 /*************************************************
26 * Main configuration options *
27 *************************************************/
29 /* The list of options that can be set in the main configuration file. This
30 must be in alphabetic order because it is searched by binary chop. */
32 static optionlist optionlist_config[] = {
33 { "*set_exim_group", opt_bool|opt_hidden, {&exim_gid_set} },
34 { "*set_exim_user", opt_bool|opt_hidden, {&exim_uid_set} },
35 { "*set_system_filter_group", opt_bool|opt_hidden, {&system_filter_gid_set} },
36 { "*set_system_filter_user", opt_bool|opt_hidden, {&system_filter_uid_set} },
37 { "accept_8bitmime", opt_bool, {&accept_8bitmime} },
38 { "acl_not_smtp", opt_stringptr, {&acl_not_smtp} },
39 #ifdef WITH_CONTENT_SCAN
40 { "acl_not_smtp_mime", opt_stringptr, {&acl_not_smtp_mime} },
42 { "acl_not_smtp_start", opt_stringptr, {&acl_not_smtp_start} },
43 { "acl_smtp_auth", opt_stringptr, {&acl_smtp_auth} },
44 { "acl_smtp_connect", opt_stringptr, {&acl_smtp_connect} },
45 { "acl_smtp_data", opt_stringptr, {&acl_smtp_data} },
47 { "acl_smtp_data_prdr", opt_stringptr, {&acl_smtp_data_prdr} },
50 { "acl_smtp_dkim", opt_stringptr, {&acl_smtp_dkim} },
52 { "acl_smtp_etrn", opt_stringptr, {&acl_smtp_etrn} },
53 { "acl_smtp_expn", opt_stringptr, {&acl_smtp_expn} },
54 { "acl_smtp_helo", opt_stringptr, {&acl_smtp_helo} },
55 { "acl_smtp_mail", opt_stringptr, {&acl_smtp_mail} },
56 { "acl_smtp_mailauth", opt_stringptr, {&acl_smtp_mailauth} },
57 #ifdef WITH_CONTENT_SCAN
58 { "acl_smtp_mime", opt_stringptr, {&acl_smtp_mime} },
60 { "acl_smtp_notquit", opt_stringptr, {&acl_smtp_notquit} },
61 { "acl_smtp_predata", opt_stringptr, {&acl_smtp_predata} },
62 { "acl_smtp_quit", opt_stringptr, {&acl_smtp_quit} },
63 { "acl_smtp_rcpt", opt_stringptr, {&acl_smtp_rcpt} },
65 { "acl_smtp_starttls", opt_stringptr, {&acl_smtp_starttls} },
67 { "acl_smtp_vrfy", opt_stringptr, {&acl_smtp_vrfy} },
68 { "add_environment", opt_stringptr, {&add_environment} },
69 { "admin_groups", opt_gidlist, {&admin_groups} },
70 { "allow_domain_literals", opt_bool, {&allow_domain_literals} },
71 #ifdef ALLOW_INSECURE_TAINTED_DATA
72 { "allow_insecure_tainted_data", opt_bool, {&allow_insecure_tainted_data} },
74 { "allow_mx_to_ip", opt_bool, {&allow_mx_to_ip} },
75 { "allow_utf8_domains", opt_bool, {&allow_utf8_domains} },
76 { "auth_advertise_hosts", opt_stringptr, {&auth_advertise_hosts} },
77 { "auto_thaw", opt_time, {&auto_thaw} },
78 #ifdef WITH_CONTENT_SCAN
79 { "av_scanner", opt_stringptr, {&av_scanner} },
81 { "bi_command", opt_stringptr, {&bi_command} },
82 #ifdef EXPERIMENTAL_BRIGHTMAIL
83 { "bmi_config_file", opt_stringptr, {&bmi_config_file} },
85 { "bounce_message_file", opt_stringptr, {&bounce_message_file} },
86 { "bounce_message_text", opt_stringptr, {&bounce_message_text} },
87 { "bounce_return_body", opt_bool, {&bounce_return_body} },
88 { "bounce_return_linesize_limit", opt_mkint, {&bounce_return_linesize_limit} },
89 { "bounce_return_message", opt_bool, {&bounce_return_message} },
90 { "bounce_return_size_limit", opt_mkint, {&bounce_return_size_limit} },
91 { "bounce_sender_authentication",opt_stringptr,{&bounce_sender_authentication} },
92 { "callout_domain_negative_expire", opt_time, {&callout_cache_domain_negative_expire} },
93 { "callout_domain_positive_expire", opt_time, {&callout_cache_domain_positive_expire} },
94 { "callout_negative_expire", opt_time, {&callout_cache_negative_expire} },
95 { "callout_positive_expire", opt_time, {&callout_cache_positive_expire} },
96 { "callout_random_local_part",opt_stringptr, {&callout_random_local_part} },
97 { "check_log_inodes", opt_int, {&check_log_inodes} },
98 { "check_log_space", opt_Kint, {&check_log_space} },
99 { "check_rfc2047_length", opt_bool, {&check_rfc2047_length} },
100 { "check_spool_inodes", opt_int, {&check_spool_inodes} },
101 { "check_spool_space", opt_Kint, {&check_spool_space} },
102 { "chunking_advertise_hosts", opt_stringptr, {&chunking_advertise_hosts} },
103 { "commandline_checks_require_admin", opt_bool,{&commandline_checks_require_admin} },
104 { "daemon_smtp_port", opt_stringptr|opt_hidden, {&daemon_smtp_port} },
105 { "daemon_smtp_ports", opt_stringptr, {&daemon_smtp_port} },
106 { "daemon_startup_retries", opt_int, {&daemon_startup_retries} },
107 { "daemon_startup_sleep", opt_time, {&daemon_startup_sleep} },
108 #ifdef EXPERIMENTAL_DCC
109 { "dcc_direct_add_header", opt_bool, {&dcc_direct_add_header} },
110 { "dccifd_address", opt_stringptr, {&dccifd_address} },
111 { "dccifd_options", opt_stringptr, {&dccifd_options} },
113 { "debug_store", opt_bool, {&debug_store} },
114 { "delay_warning", opt_timelist, {&delay_warning} },
115 { "delay_warning_condition", opt_stringptr, {&delay_warning_condition} },
116 { "deliver_drop_privilege", opt_bool, {&deliver_drop_privilege} },
117 { "deliver_queue_load_max", opt_fixed, {&deliver_queue_load_max} },
118 { "delivery_date_remove", opt_bool, {&delivery_date_remove} },
119 #ifdef ENABLE_DISABLE_FSYNC
120 { "disable_fsync", opt_bool, {&disable_fsync} },
122 { "disable_ipv6", opt_bool, {&disable_ipv6} },
124 { "dkim_verify_hashes", opt_stringptr, {&dkim_verify_hashes} },
125 { "dkim_verify_keytypes", opt_stringptr, {&dkim_verify_keytypes} },
126 { "dkim_verify_min_keysizes", opt_stringptr, {&dkim_verify_min_keysizes} },
127 { "dkim_verify_minimal", opt_bool, {&dkim_verify_minimal} },
128 { "dkim_verify_signers", opt_stringptr, {&dkim_verify_signers} },
131 { "dmarc_forensic_sender", opt_stringptr, {&dmarc_forensic_sender} },
132 { "dmarc_history_file", opt_stringptr, {&dmarc_history_file} },
133 { "dmarc_tld_file", opt_stringptr, {&dmarc_tld_file} },
135 { "dns_again_means_nonexist", opt_stringptr, {&dns_again_means_nonexist} },
136 { "dns_check_names_pattern", opt_stringptr, {&check_dns_names_pattern} },
137 { "dns_cname_loops", opt_int, {&dns_cname_loops} },
138 { "dns_csa_search_limit", opt_int, {&dns_csa_search_limit} },
139 { "dns_csa_use_reverse", opt_bool, {&dns_csa_use_reverse} },
140 { "dns_dnssec_ok", opt_int, {&dns_dnssec_ok} },
141 { "dns_ipv4_lookup", opt_stringptr, {&dns_ipv4_lookup} },
142 { "dns_retrans", opt_time, {&dns_retrans} },
143 { "dns_retry", opt_int, {&dns_retry} },
144 { "dns_trust_aa", opt_stringptr, {&dns_trust_aa} },
145 { "dns_use_edns0", opt_int, {&dns_use_edns0} },
146 /* This option is now a no-op, retained for compatibility */
147 { "drop_cr", opt_bool, {&drop_cr} },
148 /*********************************************************/
149 { "dsn_advertise_hosts", opt_stringptr, {&dsn_advertise_hosts} },
150 { "dsn_from", opt_stringptr, {&dsn_from} },
151 { "envelope_to_remove", opt_bool, {&envelope_to_remove} },
152 { "errors_copy", opt_stringptr, {&errors_copy} },
153 { "errors_reply_to", opt_stringptr, {&errors_reply_to} },
154 #ifndef DISABLE_EVENT
155 { "event_action", opt_stringptr, {&event_action} },
157 { "exim_group", opt_gid, {&exim_gid} },
158 { "exim_path", opt_stringptr, {&exim_path} },
159 { "exim_user", opt_uid, {&exim_uid} },
160 { "exim_version", opt_stringptr, {&version_string} },
161 { "extra_local_interfaces", opt_stringptr, {&extra_local_interfaces} },
162 { "extract_addresses_remove_arguments", opt_bool, {&extract_addresses_remove_arguments} },
163 { "finduser_retries", opt_int, {&finduser_retries} },
164 { "freeze_tell", opt_stringptr, {&freeze_tell} },
165 { "gecos_name", opt_stringptr, {&gecos_name} },
166 { "gecos_pattern", opt_stringptr, {&gecos_pattern} },
168 { "gnutls_allow_auto_pkcs11", opt_bool, {&gnutls_allow_auto_pkcs11} },
169 { "gnutls_compat_mode", opt_bool, {&gnutls_compat_mode} },
171 { "header_line_maxsize", opt_int, {&header_line_maxsize} },
172 { "header_maxsize", opt_int, {&header_maxsize} },
173 { "headers_charset", opt_stringptr, {&headers_charset} },
174 { "helo_accept_junk_hosts", opt_stringptr, {&helo_accept_junk_hosts} },
175 { "helo_allow_chars", opt_stringptr, {&helo_allow_chars} },
176 { "helo_lookup_domains", opt_stringptr, {&helo_lookup_domains} },
177 { "helo_try_verify_hosts", opt_stringptr, {&helo_try_verify_hosts} },
178 { "helo_verify_hosts", opt_stringptr, {&helo_verify_hosts} },
179 { "hold_domains", opt_stringptr, {&hold_domains} },
180 { "host_lookup", opt_stringptr, {&host_lookup} },
181 { "host_lookup_order", opt_stringptr, {&host_lookup_order} },
182 { "host_reject_connection", opt_stringptr, {&host_reject_connection} },
183 { "hosts_connection_nolog", opt_stringptr, {&hosts_connection_nolog} },
185 { "hosts_proxy", opt_stringptr, {&hosts_proxy} },
188 { "hosts_require_alpn", opt_stringptr, {&hosts_require_alpn} },
190 { "hosts_require_helo", opt_stringptr, {&hosts_require_helo} },
191 { "hosts_treat_as_local", opt_stringptr, {&hosts_treat_as_local} },
193 { "ibase_servers", opt_stringptr, {&ibase_servers} },
195 { "ignore_bounce_errors_after", opt_time, {&ignore_bounce_errors_after} },
196 { "ignore_fromline_hosts", opt_stringptr, {&ignore_fromline_hosts} },
197 { "ignore_fromline_local", opt_bool, {&ignore_fromline_local} },
198 { "keep_environment", opt_stringptr, {&keep_environment} },
199 { "keep_malformed", opt_time, {&keep_malformed} },
201 { "ldap_ca_cert_dir", opt_stringptr, {&eldap_ca_cert_dir} },
202 { "ldap_ca_cert_file", opt_stringptr, {&eldap_ca_cert_file} },
203 { "ldap_cert_file", opt_stringptr, {&eldap_cert_file} },
204 { "ldap_cert_key", opt_stringptr, {&eldap_cert_key} },
205 { "ldap_cipher_suite", opt_stringptr, {&eldap_cipher_suite} },
206 { "ldap_default_servers", opt_stringptr, {&eldap_default_servers} },
207 { "ldap_require_cert", opt_stringptr, {&eldap_require_cert} },
208 { "ldap_start_tls", opt_bool, {&eldap_start_tls} },
209 { "ldap_version", opt_int, {&eldap_version} },
211 #ifdef EXPERIMENTAL_ESMTP_LIMITS
212 { "limits_advertise_hosts", opt_stringptr, {&limits_advertise_hosts} },
214 { "local_from_check", opt_bool, {&local_from_check} },
215 { "local_from_prefix", opt_stringptr, {&local_from_prefix} },
216 { "local_from_suffix", opt_stringptr, {&local_from_suffix} },
217 { "local_interfaces", opt_stringptr, {&local_interfaces} },
218 #ifdef HAVE_LOCAL_SCAN
219 { "local_scan_timeout", opt_time, {&local_scan_timeout} },
221 { "local_sender_retain", opt_bool, {&local_sender_retain} },
222 { "localhost_number", opt_stringptr, {&host_number_string} },
223 { "log_file_path", opt_stringptr, {&log_file_path} },
224 { "log_selector", opt_stringptr, {&log_selector_string} },
225 { "log_timezone", opt_bool, {&log_timezone} },
226 { "lookup_open_max", opt_int, {&lookup_open_max} },
227 { "max_username_length", opt_int, {&max_username_length} },
228 { "message_body_newlines", opt_bool, {&message_body_newlines} },
229 { "message_body_visible", opt_mkint, {&message_body_visible} },
230 { "message_id_header_domain", opt_stringptr, {&message_id_domain} },
231 { "message_id_header_text", opt_stringptr, {&message_id_text} },
232 { "message_logs", opt_bool, {&message_logs} },
233 { "message_size_limit", opt_stringptr, {&message_size_limit} },
234 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
235 { "move_frozen_messages", opt_bool, {&move_frozen_messages} },
237 { "mua_wrapper", opt_bool, {&mua_wrapper} },
239 { "mysql_servers", opt_stringptr, {&mysql_servers} },
241 { "never_users", opt_uidlist, {&never_users} },
242 { "notifier_socket", opt_stringptr, {¬ifier_socket} },
244 { "openssl_options", opt_stringptr, {&openssl_options} },
247 { "oracle_servers", opt_stringptr, {&oracle_servers} },
249 { "percent_hack_domains", opt_stringptr, {&percent_hack_domains} },
251 { "perl_at_start", opt_bool, {&opt_perl_at_start} },
252 { "perl_startup", opt_stringptr, {&opt_perl_startup} },
253 { "perl_taintmode", opt_bool, {&opt_perl_taintmode} },
256 { "pgsql_servers", opt_stringptr, {&pgsql_servers} },
258 { "pid_file_path", opt_stringptr, {&pid_file_path} },
259 { "pipelining_advertise_hosts", opt_stringptr, {&pipelining_advertise_hosts} },
260 #ifndef DISABLE_PIPE_CONNECT
261 { "pipelining_connect_advertise_hosts", opt_stringptr,
262 {&pipe_connect_advertise_hosts} },
265 { "prdr_enable", opt_bool, {&prdr_enable} },
267 { "preserve_message_logs", opt_bool, {&preserve_message_logs} },
268 { "primary_hostname", opt_stringptr, {&primary_hostname} },
269 { "print_topbitchars", opt_bool, {&print_topbitchars} },
270 { "process_log_path", opt_stringptr, {&process_log_path} },
271 { "prod_requires_admin", opt_bool, {&prod_requires_admin} },
273 { "proxy_protocol_timeout", opt_time, {&proxy_protocol_timeout} },
275 { "qualify_domain", opt_stringptr, {&qualify_domain_sender} },
276 { "qualify_recipient", opt_stringptr, {&qualify_domain_recipient} },
277 { "queue_domains", opt_stringptr, {&queue_domains} },
278 #ifndef DISABLE_QUEUE_RAMP
279 { "queue_fast_ramp", opt_bool, {&queue_fast_ramp} },
281 { "queue_list_requires_admin",opt_bool, {&queue_list_requires_admin} },
282 { "queue_only", opt_bool, {&queue_only} },
283 { "queue_only_file", opt_stringptr, {&queue_only_file} },
284 { "queue_only_load", opt_fixed, {&queue_only_load} },
285 { "queue_only_load_latch", opt_bool, {&queue_only_load_latch} },
286 { "queue_only_override", opt_bool, {&queue_only_override} },
287 { "queue_run_in_order", opt_bool, {&queue_run_in_order} },
288 { "queue_run_max", opt_stringptr, {&queue_run_max} },
289 { "queue_smtp_domains", opt_stringptr, {&queue_smtp_domains} },
290 { "receive_timeout", opt_time, {&receive_timeout} },
291 { "received_header_text", opt_stringptr, {&received_header_text} },
292 { "received_headers_max", opt_int, {&received_headers_max} },
293 { "recipient_unqualified_hosts", opt_stringptr, {&recipient_unqualified_hosts} },
294 { "recipients_max", opt_int, {&recipients_max} },
295 { "recipients_max_reject", opt_bool, {&recipients_max_reject} },
297 { "redis_servers", opt_stringptr, {&redis_servers} },
299 { "remote_max_parallel", opt_int, {&remote_max_parallel} },
300 { "remote_sort_domains", opt_stringptr, {&remote_sort_domains} },
301 { "retry_data_expire", opt_time, {&retry_data_expire} },
302 { "retry_interval_max", opt_time, {&retry_interval_max} },
303 { "return_path_remove", opt_bool, {&return_path_remove} },
304 { "return_size_limit", opt_mkint|opt_hidden, {&bounce_return_size_limit} },
305 { "rfc1413_hosts", opt_stringptr, {&rfc1413_hosts} },
306 { "rfc1413_query_timeout", opt_time, {&rfc1413_query_timeout} },
307 { "sender_unqualified_hosts", opt_stringptr, {&sender_unqualified_hosts} },
308 { "slow_lookup_log", opt_int, {&slow_lookup_log} },
309 { "smtp_accept_keepalive", opt_bool, {&smtp_accept_keepalive} },
310 { "smtp_accept_max", opt_int, {&smtp_accept_max} },
311 { "smtp_accept_max_nonmail", opt_int, {&smtp_accept_max_nonmail} },
312 { "smtp_accept_max_nonmail_hosts", opt_stringptr, {&smtp_accept_max_nonmail_hosts} },
313 { "smtp_accept_max_per_connection", opt_stringptr, {&smtp_accept_max_per_connection} },
314 { "smtp_accept_max_per_host", opt_stringptr, {&smtp_accept_max_per_host} },
315 { "smtp_accept_queue", opt_int, {&smtp_accept_queue} },
316 { "smtp_accept_queue_per_connection", opt_int, {&smtp_accept_queue_per_connection} },
317 { "smtp_accept_reserve", opt_int, {&smtp_accept_reserve} },
318 { "smtp_active_hostname", opt_stringptr, {&raw_active_hostname} },
319 { "smtp_backlog_monitor", opt_int, {&smtp_backlog_monitor} },
320 { "smtp_banner", opt_stringptr, {&smtp_banner} },
321 { "smtp_check_spool_space", opt_bool, {&smtp_check_spool_space} },
322 { "smtp_connect_backlog", opt_int, {&smtp_connect_backlog} },
323 { "smtp_enforce_sync", opt_bool, {&smtp_enforce_sync} },
324 { "smtp_etrn_command", opt_stringptr, {&smtp_etrn_command} },
325 { "smtp_etrn_serialize", opt_bool, {&smtp_etrn_serialize} },
326 { "smtp_load_reserve", opt_fixed, {&smtp_load_reserve} },
327 { "smtp_max_synprot_errors", opt_int, {&smtp_max_synprot_errors} },
328 { "smtp_max_unknown_commands",opt_int, {&smtp_max_unknown_commands} },
329 { "smtp_ratelimit_hosts", opt_stringptr, {&smtp_ratelimit_hosts} },
330 { "smtp_ratelimit_mail", opt_stringptr, {&smtp_ratelimit_mail} },
331 { "smtp_ratelimit_rcpt", opt_stringptr, {&smtp_ratelimit_rcpt} },
332 { "smtp_receive_timeout", opt_func, {.fn = &fn_smtp_receive_timeout} },
333 { "smtp_reserve_hosts", opt_stringptr, {&smtp_reserve_hosts} },
334 { "smtp_return_error_details",opt_bool, {&smtp_return_error_details} },
336 { "smtputf8_advertise_hosts", opt_stringptr, {&smtputf8_advertise_hosts} },
338 #ifdef WITH_CONTENT_SCAN
339 { "spamd_address", opt_stringptr, {&spamd_address} },
342 { "spf_guess", opt_stringptr, {&spf_guess} },
343 { "spf_smtp_comment_template",opt_stringptr, {&spf_smtp_comment_template} },
345 { "split_spool_directory", opt_bool, {&split_spool_directory} },
346 { "spool_directory", opt_stringptr, {&spool_directory} },
347 { "spool_wireformat", opt_bool, {&spool_wireformat} },
349 { "sqlite_dbfile", opt_stringptr, {&sqlite_dbfile} },
350 { "sqlite_lock_timeout", opt_int, {&sqlite_lock_timeout} },
352 { "strict_acl_vars", opt_bool, {&strict_acl_vars} },
353 { "strip_excess_angle_brackets", opt_bool, {&strip_excess_angle_brackets} },
354 { "strip_trailing_dot", opt_bool, {&strip_trailing_dot} },
355 { "syslog_duplication", opt_bool, {&syslog_duplication} },
356 { "syslog_facility", opt_stringptr, {&syslog_facility_str} },
357 { "syslog_pid", opt_bool, {&syslog_pid} },
358 { "syslog_processname", opt_stringptr, {&syslog_processname} },
359 { "syslog_timestamp", opt_bool, {&syslog_timestamp} },
360 { "system_filter", opt_stringptr, {&system_filter} },
361 { "system_filter_directory_transport", opt_stringptr,{&system_filter_directory_transport} },
362 { "system_filter_file_transport",opt_stringptr,{&system_filter_file_transport} },
363 { "system_filter_group", opt_gid, {&system_filter_gid} },
364 { "system_filter_pipe_transport",opt_stringptr,{&system_filter_pipe_transport} },
365 { "system_filter_reply_transport",opt_stringptr,{&system_filter_reply_transport} },
366 { "system_filter_user", opt_uid, {&system_filter_uid} },
367 { "tcp_nodelay", opt_bool, {&tcp_nodelay} },
368 #ifdef USE_TCP_WRAPPERS
369 { "tcp_wrappers_daemon_name", opt_stringptr, {&tcp_wrappers_daemon_name} },
371 { "timeout_frozen_after", opt_time, {&timeout_frozen_after} },
372 { "timezone", opt_stringptr, {&timezone_string} },
373 { "tls_advertise_hosts", opt_stringptr, {&tls_advertise_hosts} },
375 { "tls_alpn", opt_stringptr, {&tls_alpn} },
376 { "tls_certificate", opt_stringptr, {&tls_certificate} },
377 { "tls_crl", opt_stringptr, {&tls_crl} },
378 { "tls_dh_max_bits", opt_int, {&tls_dh_max_bits} },
379 { "tls_dhparam", opt_stringptr, {&tls_dhparam} },
380 { "tls_eccurve", opt_stringptr, {&tls_eccurve} },
381 # ifndef DISABLE_OCSP
382 { "tls_ocsp_file", opt_stringptr, {&tls_ocsp_file} },
384 { "tls_on_connect_ports", opt_stringptr, {&tls_in.on_connect_ports} },
385 { "tls_privatekey", opt_stringptr, {&tls_privatekey} },
386 { "tls_remember_esmtp", opt_bool, {&tls_remember_esmtp} },
387 { "tls_require_ciphers", opt_stringptr, {&tls_require_ciphers} },
388 # ifndef DISABLE_TLS_RESUME
389 { "tls_resumption_hosts", opt_stringptr, {&tls_resumption_hosts} },
391 { "tls_try_verify_hosts", opt_stringptr, {&tls_try_verify_hosts} },
392 { "tls_verify_certificates", opt_stringptr, {&tls_verify_certificates} },
393 { "tls_verify_hosts", opt_stringptr, {&tls_verify_hosts} },
395 { "trusted_groups", opt_gidlist, {&trusted_groups} },
396 { "trusted_users", opt_uidlist, {&trusted_users} },
397 { "unknown_login", opt_stringptr, {&unknown_login} },
398 { "unknown_username", opt_stringptr, {&unknown_username} },
399 { "untrusted_set_sender", opt_stringptr, {&untrusted_set_sender} },
400 { "uucp_from_pattern", opt_stringptr, {&uucp_from_pattern} },
401 { "uucp_from_sender", opt_stringptr, {&uucp_from_sender} },
402 { "warn_message_file", opt_stringptr, {&warn_message_file} },
403 { "write_rejectlog", opt_bool, {&write_rejectlog} }
407 static int optionlist_config_size = nelem(optionlist_config);
414 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags) {/*Dummy*/}
419 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
425 uschar buf[EXIM_DRIVERNAME_MAX];
427 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
429 for (struct auth_info * ai = auths_available; ai->driver_name[0]; ai++)
431 spf(buf, sizeof(buf), US"_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
432 builtin_macro_create(buf);
433 options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
435 if (ai->macros_create) (ai->macros_create)();
440 options_logging(void)
442 uschar buf[EXIM_DRIVERNAME_MAX];
444 for (bit_table * bp = log_options; bp < log_options + log_options_count; bp++)
446 spf(buf, sizeof(buf), US"_LOG_%T", bp->name);
447 builtin_macro_create(buf);
452 #else /*!MACRO_PREDEF*/
454 extern char **environ;
456 static void save_config_line(const uschar* line);
457 static void save_config_position(const uschar *file, int line);
458 static void print_config(BOOL admin, BOOL terse);
461 #define CSTATE_STACK_SIZE 10
463 const uschar *config_directory = NULL;
466 /* Structure for chain (stack) of .included files */
468 typedef struct config_file_item {
469 struct config_file_item *next;
470 const uschar *filename;
471 const uschar *directory;
476 /* Structure for chain of configuration lines (-bP config) */
478 typedef struct config_line_item {
479 struct config_line_item *next;
483 static config_line_item* config_lines;
485 /* Structure of table of conditional words and their state transitions */
487 typedef struct cond_item {
495 /* Structure of table of syslog facility names and values */
497 typedef struct syslog_fac_item {
503 static const uschar * const hidden = US"<value not displayable>";
505 /* Static variables */
507 static config_file_item *config_file_stack = NULL; /* For includes */
509 static uschar *syslog_facility_str = NULL;
510 static uschar next_section[24];
511 static uschar time_buffer[24];
513 /* State variables for conditional loading (.ifdef / .else / .endif) */
515 static int cstate = 0;
516 static int cstate_stack_ptr = -1;
517 static int cstate_stack[CSTATE_STACK_SIZE];
519 /* Table of state transitions for handling conditional inclusions. There are
520 four possible state transitions:
524 .elifdef true (or .else)
527 .endif just causes the previous cstate to be popped off the stack */
529 static int next_cstate[3][4] =
531 /* State 0: reading from file, or reading until next .else or .endif */
533 /* State 1: condition failed, skipping until next .else or .endif */
535 /* State 2: skipping until .endif */
539 /* Table of conditionals and the states to set. For each name, there are four
540 values: the length of the name (to save computing it each time), the state to
541 set if a macro was found in the line, the state to set if a macro was not found
542 in the line, and a stack manipulation setting which is:
544 -1 pull state value off the stack
545 0 don't alter the stack
546 +1 push value onto stack, before setting new state
549 static cond_item cond_list[] = {
550 { US"ifdef", 5, 0, 1, 1 },
551 { US"ifndef", 6, 1, 0, 1 },
552 { US"elifdef", 7, 2, 3, 0 },
553 { US"elifndef", 8, 3, 2, 0 },
554 { US"else", 4, 2, 2, 0 },
555 { US"endif", 5, 0, 0, -1 }
558 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
560 /* Table of syslog facility names and their values */
562 static syslog_fac_item syslog_list[] = {
563 { US"mail", LOG_MAIL },
564 { US"user", LOG_USER },
565 { US"news", LOG_NEWS },
566 { US"uucp", LOG_UUCP },
567 { US"local0", LOG_LOCAL0 },
568 { US"local1", LOG_LOCAL1 },
569 { US"local2", LOG_LOCAL2 },
570 { US"local3", LOG_LOCAL3 },
571 { US"local4", LOG_LOCAL4 },
572 { US"local5", LOG_LOCAL5 },
573 { US"local6", LOG_LOCAL6 },
574 { US"local7", LOG_LOCAL7 },
575 { US"daemon", LOG_DAEMON }
578 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
581 #define opt_fn_print BIT(0)
582 #define opt_fn_print_label BIT(1)
585 /*************************************************
586 * Find the name of an option *
587 *************************************************/
589 /* This function is to aid debugging. Various functions take arguments that are
590 pointer variables in the options table or in option tables for various drivers.
591 For debugging output, it is useful to be able to find the name of the option
592 which is currently being processed. This function finds it, if it exists, by
593 searching the table(s).
595 Arguments: a value that is presumed to be in the table above
596 Returns: the option name, or an empty string
600 readconf_find_option(void *p)
602 for (int i = 0; i < nelem(optionlist_config); i++)
603 if (p == optionlist_config[i].v.value) return US optionlist_config[i].name;
605 for (router_instance * r = routers; r; r = r->next)
607 router_info *ri = r->info;
608 for (int i = 0; i < *ri->options_count; i++)
610 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
611 if (p == CS (r->options_block) + ri->options[i].v.offset)
612 return US ri->options[i].name;
616 for (transport_instance * t = transports; t; t = t->next)
618 transport_info *ti = t->info;
619 for (int i = 0; i < *ti->options_count; i++)
621 optionlist * op = &ti->options[i];
622 if ((op->type & opt_mask) != opt_stringptr) continue;
623 if (p == ( op->type & opt_public
625 : CS t->options_block
638 /*************************************************
639 * Deal with an assignment to a macro *
640 *************************************************/
642 /* We have a new definition; append to the list.
645 name Name of the macro; will be copied
646 val Expansion result for the macro; will be copied
650 macro_create(const uschar * name, const uschar * val, BOOL command_line)
652 macro_item * m = store_get(sizeof(macro_item), FALSE);
654 READCONF_DEBUG fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val);
656 m->command_line = command_line;
657 m->namelen = Ustrlen(name);
658 m->replen = Ustrlen(val);
659 m->name = string_copy(name);
660 m->replacement = string_copy(val);
672 /* This function is called when a line that starts with an upper case letter is
673 encountered. The argument "line" should contain a complete logical line, and
674 start with the first letter of the macro name. The macro name and the
675 replacement text are extracted and stored. Redefinition of existing,
676 non-command line, macros is permitted using '==' instead of '='.
679 s points to the start of the logical line
681 Returns: FALSE iff fatal error
685 macro_read_assignment(uschar *s)
687 uschar name[EXIM_DRIVERNAME_MAX];
692 while (isalnum(*s) || *s == '_')
694 if (namelen >= sizeof(name) - 1)
696 log_write(0, LOG_PANIC|LOG_CONFIG_IN,
697 "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
700 name[namelen++] = *s++;
704 Uskip_whitespace(&s);
707 log_write(0, LOG_PANIC|LOG_CONFIG_IN, "malformed macro definition");
716 Uskip_whitespace(&s);
718 /* If an existing macro of the same name was defined on the command line, we
719 just skip this definition. It's an error to attempt to redefine a macro without
720 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
721 It is also an error to define a macro whose name begins with the name of a
722 previously defined macro. This is the requirement that make using a tree
723 for macros hard; we must check all macros for the substring. Perhaps a
724 sorted list, and a bsearch, would work?
725 Note: it is documented that the other way round works. */
727 for (m = macros; m; m = m->next)
729 if (Ustrcmp(m->name, name) == 0)
731 if (!m->command_line && !redef)
733 log_write(0, LOG_CONFIG|LOG_PANIC, "macro \"%s\" is already "
734 "defined (use \"==\" if you want to redefine it)", name);
740 if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
742 log_write(0, LOG_CONFIG|LOG_PANIC, "\"%s\" cannot be defined as "
743 "a macro because previously defined macro \"%s\" is a substring",
748 /* We cannot have this test, because it is documented that a substring
749 macro is permitted (there is even an example).
751 * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
752 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
753 * "a macro because it is a substring of previously defined macro \"%s\"",
758 /* Check for an overriding command-line definition. */
760 if (m && m->command_line) return TRUE;
762 /* Redefinition must refer to an existing macro. */
767 m->replen = Ustrlen(s);
768 m->replacement = string_copy(s);
772 log_write(0, LOG_CONFIG|LOG_PANIC, "can't redefine an undefined macro "
777 /* We have a new definition. */
779 (void) macro_create(name, s, FALSE);
787 /* Process line for macros. The line is in big_buffer starting at offset len.
788 Expand big_buffer if needed. Handle definitions of new macros, and
789 macro expansions, rewriting the line in the buffer.
792 len Offset in buffer of start of line
793 newlen Pointer to offset of end of line, updated on return
794 macro_found Pointer to return that a macro was expanded
796 Return: pointer to first nonblank char in line
800 macros_expand(int len, int * newlen, BOOL * macro_found)
802 uschar * ss = big_buffer + len;
805 /* Find the true start of the physical line - leading spaces are always
808 Uskip_whitespace(&ss);
810 /* Process the physical line for macros. If this is the start of the logical
811 line, skip over initial text at the start of the line if it starts with an
812 upper case character followed by a sequence of name characters and an equals
813 sign, because that is the definition of a new macro, and we don't do
814 replacement therein. */
817 if (len == 0 && isupper(*s))
819 while (isalnum(*s) || *s == '_') s++;
820 if (Uskip_whitespace(&s) != '=') s = ss; /* Not a macro definition */
823 /* Skip leading chars which cannot start a macro name, to avoid multiple
824 pointless rescans in Ustrstr calls. */
826 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
828 /* For each defined macro, scan the line (from after XXX= if present),
829 replacing all occurrences of the macro. */
831 *macro_found = FALSE;
832 if (*s) for (macro_item * m = *s == '_' ? macros : macros_user; m; m = m->next)
837 while (*s && !isupper(*s) && !(*s == '_' && isupper(s[1]))) s++;
841 while ((p = Ustrstr(t, m->name)) != NULL)
845 READCONF_DEBUG fprintf(stderr, "%s: matched '%s' in '%.*s'\n", __FUNCTION__,
846 m->name, (int) Ustrlen(ss)-1, ss);
847 /* Expand the buffer if necessary */
849 while (*newlen - m->namelen + m->replen + 1 > big_buffer_size)
851 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
852 uschar *newbuffer = store_malloc(newsize);
853 memcpy(newbuffer, big_buffer, *newlen + 1);
854 p = newbuffer + (p - big_buffer);
855 s = newbuffer + (s - big_buffer);
856 ss = newbuffer + (ss - big_buffer);
857 t = newbuffer + (t - big_buffer);
858 big_buffer_size = newsize;
859 store_free(big_buffer);
860 big_buffer = newbuffer;
863 /* Shuffle the remaining characters up or down in the buffer before
864 copying in the replacement text. Don't rescan the replacement for this
868 if ((moveby = m->replen - m->namelen) != 0)
870 memmove(p + m->replen, pp, (big_buffer + *newlen) - pp + 1);
873 Ustrncpy(p, m->replacement, m->replen);
875 while (*t && !isupper(*t) && !(*t == '_' && isupper(t[1]))) t++;
880 /* An empty macro replacement at the start of a line could mean that ss no
881 longer points to the first non-blank character. */
883 Uskip_whitespace(&ss);
887 /*************************************************
888 * Read configuration line *
889 *************************************************/
891 /* A logical line of text is read from the configuration file into the big
892 buffer, taking account of macros, .includes, and continuations. The size of
893 big_buffer is increased if necessary. The count of configuration lines is
894 maintained. Physical input lines starting with # (ignoring leading white space,
895 and after macro replacement) and empty logical lines are always ignored.
896 Leading and trailing spaces are removed.
898 If we hit a line of the form "begin xxxx", the xxxx is placed in the
899 next_section vector, and the function returns NULL, indicating the end of a
900 configuration section. On end-of-file, NULL is returned with next_section
905 Returns: a pointer to the first non-blank in the line,
906 or NULL if eof or end of section is reached
910 get_config_line(void)
912 int startoffset = 0; /* To first non-blank char in logical line */
913 int len = 0; /* Of logical line so far */
918 /* Loop for handling continuation lines, skipping comments, and dealing with
923 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
925 if (config_file_stack != NULL) /* EOF inside .include */
927 (void)fclose(config_file);
928 config_file = config_file_stack->file;
929 config_filename = config_file_stack->filename;
930 config_directory = config_file_stack->directory;
931 config_lineno = config_file_stack->lineno;
932 config_file_stack = config_file_stack->next;
934 save_config_position(config_filename, config_lineno);
938 /* EOF at top level */
940 if (cstate_stack_ptr >= 0)
941 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
942 "Unexpected end of configuration file: .endif missing");
944 if (len != 0) break; /* EOF after continuation */
945 next_section[0] = 0; /* EOF at start of logical line */
950 newlen = len + Ustrlen(big_buffer + len);
952 if (config_lines && config_lineno == 1)
953 save_config_position(config_filename, config_lineno);
955 /* Handle pathologically long physical lines - yes, it did happen - by
956 extending big_buffer at this point. The code also copes with very long
959 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
962 big_buffer_size += BIG_BUFFER_SIZE;
963 newbuffer = store_malloc(big_buffer_size);
965 /* This use of strcpy is OK because we know that the string in the old
966 buffer is shorter than the new buffer. */
968 Ustrcpy(newbuffer, big_buffer);
969 store_free(big_buffer);
970 big_buffer = newbuffer;
971 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
973 newlen += Ustrlen(big_buffer + newlen);
976 ss = macros_expand(len, &newlen, ¯o_found);
978 /* Check for comment lines - these are physical lines. */
980 if (*ss == '#') continue;
982 /* Handle conditionals, which are also applied to physical lines. Conditions
983 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
984 expansion occurred on the rest of the line. A preliminary test for the leading
985 '.' saves effort on most lines. */
991 /* Search the list of conditional directives */
993 for (i = 0; i < cond_list_size; i++)
996 cond_item *c = cond_list+i;
997 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
999 /* The following character must be white space or end of string */
1001 n = ss[1 + c->namelen];
1002 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
1004 /* .ifdef and .ifndef push the current state onto the stack, then set
1005 a new one from the table. Stack overflow is an error */
1009 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
1010 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1011 ".%s nested too deeply", c->name);
1012 cstate_stack[++cstate_stack_ptr] = cstate;
1013 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
1016 /* For any of the others, stack underflow is an error. The next state
1017 comes either from the stack (.endif) or from the table. */
1021 if (cstate_stack_ptr < 0)
1022 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1023 ".%s without matching .ifdef", c->name);
1024 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
1025 next_cstate[cstate][macro_found? c->action1 : c->action2];
1028 /* Having dealt with a directive, break the loop */
1033 /* If we have handled a conditional directive, continue with the next
1034 physical line. Otherwise, fall through. */
1036 if (i < cond_list_size) continue;
1039 /* If the conditional state is not 0 (actively using these lines), ignore
1042 if (cstate != 0) continue; /* Conditional skip */
1044 /* Handle .include lines - these are also physical lines. */
1046 if (Ustrncmp(ss, ".include", 8) == 0 &&
1048 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
1051 int include_if_exists = isspace(ss[8])? 0 : 10;
1052 config_file_item *save;
1053 struct stat statbuf;
1055 ss += 9 + include_if_exists;
1056 Uskip_whitespace(&ss);
1057 t = ss + Ustrlen(ss);
1058 while (t > ss && isspace(t[-1])) t--;
1059 if (*ss == '\"' && t[-1] == '\"')
1066 /* We allow relative file names. For security reasons currently
1067 relative names not allowed with .include_if_exists. For .include_if_exists
1068 we need to check the permissions/ownership of the containing folder */
1070 if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
1071 "absolute path \"%s\"", ss);
1074 gstring * g = string_append(NULL, 3, config_directory, "/", ss);
1075 ss = string_from_gstring(g);
1078 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
1081 save_config_position(config_filename, config_lineno);
1082 save = store_get(sizeof(config_file_item), FALSE);
1083 save->next = config_file_stack;
1084 config_file_stack = save;
1085 save->file = config_file;
1086 save->filename = config_filename;
1087 save->directory = config_directory;
1088 save->lineno = config_lineno;
1090 if (!(config_file = Ufopen(ss, "rb")))
1091 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
1092 "configuration file %s", ss);
1094 config_filename = string_copy(ss);
1095 config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1100 /* If this is the start of the logical line, remember where the non-blank
1101 data starts. Otherwise shuffle down continuation lines to remove leading
1105 startoffset = ss - big_buffer;
1108 s = big_buffer + len;
1111 memmove(s, ss, (newlen - len) - (ss - s) + 1);
1116 /* Accept the new addition to the line. Remove trailing white space. */
1119 while (len > 0 && isspace(big_buffer[len-1])) len--;
1120 big_buffer[len] = 0;
1122 /* We are done if the line does not end in backslash and contains some data.
1123 Empty logical lines are ignored. For continuations, remove the backslash and
1124 go round the loop to read the continuation line. */
1128 if (big_buffer[len-1] != '\\') break; /* End of logical line */
1129 big_buffer[--len] = 0; /* Remove backslash */
1131 } /* Loop for reading multiple physical lines */
1133 /* We now have a logical line. Test for the end of a configuration section (or,
1134 more accurately, for the start of the next section). Place the name of the next
1135 section in next_section, and return NULL. If the name given is longer than
1136 next_section, truncate it. It will be unrecognized later, because all the known
1137 section names do fit. Leave space for pluralizing. */
1139 s = big_buffer + startoffset; /* First non-space character */
1142 save_config_line(s);
1144 if (strncmpic(s, US"begin ", 6) == 0)
1147 Uskip_whitespace(&s);
1148 if (big_buffer + len - s > sizeof(next_section) - 2)
1149 s[sizeof(next_section) - 2] = 0;
1150 Ustrcpy(next_section, s);
1154 /* Return the first non-blank character. */
1161 /*************************************************
1163 *************************************************/
1165 /* The yield is the pointer to the next uschar. Names longer than the
1166 output space are silently truncated. This function is also used from acl.c when
1170 name where to put the name
1174 Returns: new input pointer
1178 readconf_readname(uschar *name, int len, uschar *s)
1181 BOOL broken = FALSE;
1183 if (isalpha(Uskip_whitespace(&s)))
1184 while (isalnum(*s) || *s == '_')
1186 if (p < len-1) name[p++] = *s;
1196 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1197 "exim item name too long (>%d), unable to use \"%s\" (truncated)",
1200 Uskip_whitespace(&s);
1207 /*************************************************
1208 * Read a time value *
1209 *************************************************/
1211 /* This function is also called from outside, to read argument
1212 time values. The format of a time value is:
1214 [<n>w][<n>d][<n>h][<n>m][<n>s]
1216 as long as at least one is present. If a format error is encountered,
1217 return a negative value. The value must be terminated by the given
1222 terminator required terminating character
1223 return_msec if TRUE, allow fractional seconds and return milliseconds
1225 Returns: the time value, or -1 on syntax error
1226 value is seconds if return_msec is FALSE
1227 value is milliseconds if return_msec is TRUE
1231 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1239 if (!isdigit(*s)) return -1;
1240 (void)sscanf(CCS s, "%d%n", &value, &count);
1245 case 'w': value *= 7;
1246 case 'd': value *= 24;
1247 case 'h': value *= 60;
1248 case 'm': value *= 60;
1253 if (!return_msec) return -1;
1254 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1256 if (*s++ != 's') return -1;
1257 yield += (int)(fraction * 1000.0);
1263 if (return_msec) value *= 1000;
1265 if (*s == terminator) return yield;
1267 /* Control never reaches here. */
1272 /*************************************************
1273 * Read a fixed point value *
1274 *************************************************/
1276 /* The value is returned *1000
1280 terminator required terminator
1282 Returns: the value, or -1 on error
1286 readconf_readfixed(const uschar *s, int terminator)
1290 if (!isdigit(*s)) return -1;
1291 (void)sscanf(CS s, "%d%n", &value, &count);
1293 yield = value * 1000;
1297 while (isdigit((*(++s))))
1299 yield += (*s - '0') * m;
1304 return (*s == terminator)? yield : (-1);
1309 /*************************************************
1310 * Find option in list *
1311 *************************************************/
1313 /* The lists are always in order, so binary chop can be used.
1316 name the option name to search for
1317 ol the first entry in the option list
1318 last one more than the offset of the last entry in the option list
1320 Returns: pointer to an option entry, or NULL if not found
1324 find_option(const uschar *name, optionlist *ol, int last)
1327 while (last > first)
1329 int middle = (first + last)/2;
1330 int c = Ustrcmp(name, ol[middle].name);
1332 if (c == 0) return ol + middle;
1333 else if (c > 0) first = middle + 1;
1341 /*************************************************
1342 * Find a set flag in option list *
1343 *************************************************/
1345 /* Because some versions of Unix make no restrictions on the values of uids and
1346 gids (even negative ones), we cannot represent "unset" by a special value.
1347 There is therefore a separate boolean variable for each one indicating whether
1348 a value is set or not. This function returns a pointer to the boolean, given
1349 the original option name. It is a major disaster if the flag cannot be found.
1352 name the name of the uid or gid option
1353 oltop points to the start of the relevant option list
1354 last one more than the offset of the last item in the option list
1355 data_block NULL when reading main options => data values in the option
1356 list are absolute addresses; otherwise they are byte offsets
1357 in data_block (used for driver options)
1359 Returns: a pointer to the boolean flag.
1363 get_set_flag(const uschar *name, optionlist *oltop, int last, void *data_block)
1366 uschar name2[EXIM_DRIVERNAME_MAX];
1367 sprintf(CS name2, "*set_%.50s", name);
1368 if (!(ol = find_option(name2, oltop, last)))
1369 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1370 "Exim internal error: missing set flag for %s", name);
1372 ? (BOOL *)(US data_block + ol->v.offset) : (BOOL *)ol->v.value;
1378 /*************************************************
1379 * Output extra characters message and die *
1380 *************************************************/
1382 /* Called when an option line has junk on the end. Sometimes this is because
1383 the sysadmin thinks comments are permitted.
1386 s points to the extra characters
1387 t1..t3 strings to insert in the log message
1389 Returns: doesn't return; dies
1393 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1395 uschar *comment = US"";
1396 if (*s == '#') comment = US" (# is comment only at line start)";
1397 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1398 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1403 /*************************************************
1404 * Read rewrite information *
1405 *************************************************/
1407 /* Each line of rewrite information contains:
1409 . A complete address in the form user@domain, possibly with
1410 leading * for each part; or alternatively, a regex.
1412 . A replacement string (which will be expanded).
1414 . An optional sequence of one-letter flags, indicating which
1415 headers etc. to apply this rule to.
1417 All this is decoded and placed into a control block. The OR of the flags is
1418 maintained in a common word.
1421 p points to the string that makes up the rule
1422 existflags points to the overall flag word
1423 isglobal TRUE if reading global rewrite rules
1425 Returns: the control block for the parsed rule.
1428 static rewrite_rule *
1429 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1431 rewrite_rule *next = store_get(sizeof(rewrite_rule), FALSE);
1434 next->key = string_dequote(&p);
1436 Uskip_whitespace(&p);
1438 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1439 "missing rewrite replacement string");
1442 next->replacement = string_dequote(&p);
1444 while (*p) switch (*p++)
1446 case ' ': case '\t': break;
1448 case 'q': next->flags |= rewrite_quit; break;
1449 case 'w': next->flags |= rewrite_whole; break;
1451 case 'h': next->flags |= rewrite_all_headers; break;
1452 case 's': next->flags |= rewrite_sender; break;
1453 case 'f': next->flags |= rewrite_from; break;
1454 case 't': next->flags |= rewrite_to; break;
1455 case 'c': next->flags |= rewrite_cc; break;
1456 case 'b': next->flags |= rewrite_bcc; break;
1457 case 'r': next->flags |= rewrite_replyto; break;
1459 case 'E': next->flags |= rewrite_all_envelope; break;
1460 case 'F': next->flags |= rewrite_envfrom; break;
1461 case 'T': next->flags |= rewrite_envto; break;
1463 case 'Q': next->flags |= rewrite_qualify; break;
1464 case 'R': next->flags |= rewrite_repeat; break;
1467 next->flags |= rewrite_smtp;
1468 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1469 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1470 "rewrite rule has the S flag but is not a regular expression");
1474 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1475 "unknown rewrite flag character '%c' "
1476 "(could be missing quotes round replacement item)", p[-1]);
1480 /* If no action flags are set, set all the "normal" rewrites. */
1482 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1483 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1485 /* Remember which exist, for optimization, and return the rule */
1487 *existflags |= next->flags;
1494 /*************************************************
1495 * Read global rewrite information *
1496 *************************************************/
1498 /* Each line is a single rewrite rule; it is parsed into a control block
1499 by readconf_one_rewrite(), and its flags are ORed into the global flag
1500 word rewrite_existflags. */
1503 readconf_rewrites(void)
1505 rewrite_rule **chain = &global_rewrite_rules;
1508 while ((p = get_config_line()) != NULL)
1510 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1512 chain = &(next->next);
1518 /*************************************************
1520 *************************************************/
1522 /* Strings are read into the normal store pool. As long we aren't too
1523 near the end of the current block, the string will just use what is necessary
1524 on the top of the stacking pool, because string_cat() uses the extension
1528 s the rest of the input line
1529 name the option name (for errors)
1531 Returns: pointer to the string
1535 read_string(const uschar *s, const uschar *name)
1540 if (*s != '\"') return string_copy(s);
1543 yield = string_dequote(&s);
1545 if (s == ss+1 || s[-1] != '\"')
1546 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1547 "missing quote at end of string value for %s", name);
1549 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1555 /*************************************************
1556 * Custom-handler options *
1557 *************************************************/
1559 fn_smtp_receive_timeout(const uschar * name, const uschar * str, unsigned flags)
1561 if (flags & opt_fn_print)
1563 if (flags & opt_fn_print_label) printf("%s = ", name);
1564 printf("%s\n", smtp_receive_timeout_s
1565 ? string_printing2(smtp_receive_timeout_s, SP_TAB)
1566 : readconf_printtime(smtp_receive_timeout));
1568 else if (*str == '$')
1569 smtp_receive_timeout_s = string_copy(str);
1572 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1573 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1574 if (smtp_receive_timeout < 0)
1575 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1580 /*************************************************
1581 * Handle option line *
1582 *************************************************/
1584 /* This function is called from several places to process a line containing the
1585 setting of an option. The first argument is the line to be decoded; it has been
1586 checked not to be empty and not to start with '#'. Trailing newlines and white
1587 space have been removed. The second argument is a pointer to the list of
1588 variable names that are to be recognized, together with their types and
1589 locations, and the third argument gives the number of entries in the list.
1591 The fourth argument is a pointer to a data block. If it is NULL, then the data
1592 values in the options list are absolute addresses. Otherwise, they are byte
1593 offsets in the data block.
1595 String option data may continue onto several lines; this function reads further
1596 data from config_file if necessary.
1598 The yield of this function is normally zero. If a string continues onto
1599 multiple lines, then the data value is permitted to be followed by a comma
1600 or a semicolon (for use in drivers) and the yield is that character.
1603 buffer contains the configuration line to be handled
1604 oltop points to the start of the relevant option list
1605 last one more than the offset of the last item in the option list
1606 data_block NULL when reading main options => data values in the option
1607 list are absolute addresses; otherwise they are byte offsets
1608 in data_block when they have opt_public set; otherwise
1609 they are byte offsets in data_block->options_block.
1610 unknown_txt format string to use in panic message for unknown option;
1611 must contain %s for option name
1612 if given as NULL, don't panic on unknown option
1614 Returns: TRUE if an option was read successfully,
1615 FALSE false for an unknown option if unknown_txt == NULL,
1616 otherwise panic and die on an unknown option
1620 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1621 void *data_block, uschar *unknown_txt)
1625 int count, type, value;
1629 BOOL boolvalue = TRUE;
1630 BOOL freesptr = TRUE;
1631 optionlist *ol, *ol2;
1635 uschar *inttype = US"";
1638 uschar **str_target;
1639 uschar name[EXIM_DRIVERNAME_MAX];
1640 uschar name2[EXIM_DRIVERNAME_MAX];
1642 /* There may be leading spaces; thereafter, we expect an option name starting
1645 while (isspace(*s)) s++;
1647 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1649 /* Read the name of the option, and skip any subsequent white space. If
1650 it turns out that what we read was "hide", set the flag indicating that
1651 this is a secure option, and loop to read the next word. */
1653 for (int n = 0; n < 2; n++)
1655 while (isalnum(*s) || *s == '_')
1657 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1661 while (isspace(*s)) s++;
1662 if (Ustrcmp(name, "hide") != 0) break;
1663 issecure = opt_secure;
1667 /* Deal with "no_" or "not_" here for booleans */
1669 if (Ustrncmp(name, "no_", 3) == 0)
1675 if (Ustrncmp(name, "not_", 4) == 0)
1681 /* Search the list for the given name. A non-existent name, or an option that
1682 is set twice, is a disaster. */
1684 if (!(ol = find_option(name + offset, oltop, last)))
1686 if (!unknown_txt) return FALSE;
1687 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1690 if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1691 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1692 "\"%s\" option set for the second time", name);
1694 ol->type |= opt_set | issecure;
1695 type = ol->type & opt_mask;
1697 /* Types with data values must be followed by '='; the "no[t]_" prefix
1698 applies only to boolean values. */
1700 if (type < opt_bool || type > opt_bool_last)
1703 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1704 "negation prefix applied to a non-boolean option");
1706 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1707 "unexpected end of line (data missing) after %s", name);
1709 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1712 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1713 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1714 ultimately expands to one of those values. */
1716 else if (*s && (offset != 0 || *s != '='))
1717 extra_chars_error(s, US"boolean option ", name, US"");
1719 /* Skip white space after = */
1721 if (*s == '=') while (isspace((*(++s))));
1723 /* If there is a data block and the opt_public flag is not set, change
1724 the data block pointer to the private options block. */
1726 if (data_block && !(ol->type & opt_public))
1727 data_block = (void *)(((driver_instance *)data_block)->options_block);
1729 /* Now get the data according to the type. */
1733 /* If a string value is not enclosed in quotes, it consists of
1734 the rest of the current line, verbatim. Otherwise, string escapes
1737 A transport is specified as a string, which is then looked up in the
1738 list of transports. A search type is specified as one of a number of
1741 A set or rewrite rules for a driver is specified as a string, which is
1742 then parsed into a suitable chain of control blocks.
1744 Uids and gids are specified as strings which are then looked up in the
1745 passwd file. Lists of uids and gids are similarly specified as colon-
1746 separated strings. */
1751 case opt_expand_uid:
1752 case opt_expand_gid:
1757 reset_point = store_mark();
1758 sptr = read_string(s, name);
1760 /* Having read a string, we now have several different ways of using it,
1761 depending on the data type, so do another switch. If keeping the actual
1762 string is not required (because it is interpreted), freesptr is set TRUE,
1763 and at the end we reset the pool. */
1767 /* If this was a string, set the variable to point to the new string,
1768 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1769 rules, we still keep the string (for printing), and parse the rules into a
1770 control block and flags word. */
1773 str_target = data_block ? USS (US data_block + ol->v.offset)
1775 if (ol->type & opt_rep_con)
1777 uschar * saved_condition;
1778 /* We already have a condition, we're conducting a crude hack to let
1779 multiple condition rules be chained together, despite storing them in
1781 *str_target = string_copy_perm( (saved_condition = *str_target)
1782 ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1783 saved_condition, sptr)
1786 /* TODO(pdp): there is a memory leak here and just below
1787 when we set 3 or more conditions; I still don't
1788 understand the store mechanism enough to know
1789 what's the safe way to free content from an earlier store.
1790 AFAICT, stores stack, so freeing an early stored item also stores
1791 all data alloc'd after it. If we knew conditions were adjacent,
1792 we could survive that, but we don't. So I *think* we need to take
1793 another bit from opt_type to indicate "malloced"; this seems like
1794 quite a hack, especially for this one case. It also means that
1795 we can't ever reclaim the store from the *first* condition.
1797 Because we only do this once, near process start-up, I'm prepared to
1798 let this slide for the time being, even though it rankles. */
1800 else if (ol->type & opt_rep_str)
1803 Ustrncmp(name, "headers_add", 11) == 0 ? '\n'
1804 : Ustrncmp(name, "set", 3) == 0 ? ';'
1806 int sep_i = -(int)sep_o;
1807 const uschar * list = sptr;
1809 gstring * list_o = NULL;
1813 list_o = string_get(Ustrlen(*str_target) + Ustrlen(sptr));
1814 list_o = string_cat(list_o, *str_target);
1817 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1818 list_o = string_append_listele(list_o, sep_o, s);
1821 *str_target = string_copy_perm(string_from_gstring(list_o), FALSE);
1832 *USS (US data_block + ol->v.offset) = sptr;
1834 *USS ol->v.value = sptr;
1836 if (type == opt_rewrite)
1841 rewrite_rule **chain;
1844 sprintf(CS name2, "*%.50s_rules", name);
1845 ol2 = find_option(name2, oltop, last);
1846 sprintf(CS name2, "*%.50s_flags", name);
1847 ol3 = find_option(name2, oltop, last);
1850 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1851 "rewrite rules not available for driver");
1855 chain = (rewrite_rule **)(US data_block + ol2->v.offset);
1856 flagptr = (int *)(US data_block + ol3->v.offset);
1860 chain = (rewrite_rule **)ol2->v.value;
1861 flagptr = (int *)ol3->v.value;
1864 /* This will trap if sptr is tainted. Not sure if that can happen */
1865 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1867 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1869 chain = &(next->next);
1872 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1873 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1874 "non-header rewrite - not allowed at transport time -");
1878 /* If it was an expanded uid, see if there is any expansion to be
1879 done by checking for the presence of a $ character. If there is, save it
1880 in the corresponding *expand_user option field. Otherwise, fall through
1881 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1884 case opt_expand_uid:
1885 sprintf(CS name2, "*expand_%.50s", name);
1886 if ((ol2 = find_option(name2, oltop, last)))
1888 uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1891 *(USS(US data_block + ol2->v.offset)) = ss;
1893 *(USS ol2->v.value) = ss;
1897 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1903 /* Look up a fixed uid, and also make use of the corresponding gid
1904 if a passwd entry is returned and the gid has not been set. */
1907 if (!route_finduser(sptr, &pw, &uid))
1908 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1910 *(uid_t *)(US data_block + ol->v.offset) = uid;
1912 *(uid_t *)ol->v.value = uid;
1914 /* Set the flag indicating a fixed value is set */
1916 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1918 /* Handle matching gid if we have a passwd entry: done by finding the
1919 same name with terminating "user" changed to "group"; if not found,
1920 ignore. Also ignore if the value is already set. */
1922 if (pw == NULL) break;
1923 Ustrcpy(name+Ustrlen(name)-4, US"group");
1924 ol2 = find_option(name, oltop, last);
1925 if (ol2 && ((ol2->type & opt_mask) == opt_gid ||
1926 (ol2->type & opt_mask) == opt_expand_gid))
1928 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1932 *((gid_t *)(US data_block + ol2->v.offset)) = pw->pw_gid;
1934 *((gid_t *)ol2->v.value) = pw->pw_gid;
1940 /* If it was an expanded gid, see if there is any expansion to be
1941 done by checking for the presence of a $ character. If there is, save it
1942 in the corresponding *expand_user option field. Otherwise, fall through
1943 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1946 case opt_expand_gid:
1947 sprintf(CS name2, "*expand_%.50s", name);
1948 if ((ol2 = find_option(name2, oltop, last)))
1950 uschar *ss = (Ustrchr(sptr, '$') != NULL) ? sptr : NULL;
1953 *(USS(US data_block + ol2->v.offset)) = ss;
1955 *(USS ol2->v.value) = ss;
1959 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1965 /* Handle freestanding gid */
1968 if (!route_findgroup(sptr, &gid))
1969 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1971 *((gid_t *)(US data_block + ol->v.offset)) = gid;
1973 *((gid_t *)ol->v.value) = gid;
1974 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1977 /* If it was a uid list, look up each individual entry, and build
1978 a vector of uids, with a count in the first element. Put the vector
1979 in malloc store so we can free the string. (We are reading into
1980 permanent store already.) */
1988 const uschar *op = expand_string (sptr);
1991 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1992 name, expand_string_message);
1995 if (*p != 0) count++;
1996 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1997 list = store_malloc(count*sizeof(uid_t));
1998 list[ptr++] = (uid_t)(count - 1);
2001 *((uid_t **)(US data_block + ol->v.offset)) = list;
2003 *((uid_t **)ol->v.value) = list;
2009 /* If p is tainted we trap. Not sure that can happen */
2010 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2011 if (!route_finduser(big_buffer, NULL, &uid))
2012 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
2019 /* If it was a gid list, look up each individual entry, and build
2020 a vector of gids, with a count in the first element. Put the vector
2021 in malloc store so we can free the string. (We are reading into permanent
2030 const uschar *op = expand_string (sptr);
2033 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
2034 name, expand_string_message);
2037 if (*p != 0) count++;
2038 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
2039 list = store_malloc(count*sizeof(gid_t));
2040 list[ptr++] = (gid_t)(count - 1);
2043 *((gid_t **)(US data_block + ol->v.offset)) = list;
2045 *((gid_t **)ol->v.value) = list;
2051 /* If p is tainted we trap. Not sure that can happen */
2052 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
2053 if (!route_findgroup(big_buffer, &gid))
2054 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
2062 /* Release store if the value of the string doesn't need to be kept. */
2064 if (freesptr) reset_point = store_reset(reset_point);
2067 /* Expanded boolean: if no characters follow, or if there are no dollar
2068 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
2069 save the string for later expansion in the alternate place. */
2071 case opt_expand_bool:
2072 if (*s && Ustrchr(s, '$') != 0)
2074 sprintf(CS name2, "*expand_%.50s", name);
2075 if ((ol2 = find_option(name2, oltop, last)))
2077 reset_point = store_mark();
2078 sptr = read_string(s, name);
2080 *(USS(US data_block + ol2->v.offset)) = sptr;
2082 *(USS ol2->v.value) = sptr;
2089 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
2090 look for yes/not/true/false. Some booleans are stored in a single bit in
2091 a single int. There's a special fudge for verify settings; without a suffix
2092 they set both xx_sender and xx_recipient. The table points to the sender
2093 value; search subsequently for the recipient. There's another special case:
2094 opt_bool_set also notes when a boolean has been set. */
2098 case opt_bool_verify:
2102 s = readconf_readname(name2, EXIM_DRIVERNAME_MAX, s);
2103 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
2105 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
2107 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2108 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
2109 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
2110 US"for boolean option ", name);
2113 /* Handle single-bit type. */
2115 if (type == opt_bit)
2117 int bit = 1 << ((ol->type >> 16) & 31);
2118 int * ptr = data_block
2119 ? (int *)(US data_block + ol->v.offset)
2120 : (int *)ol->v.value;
2121 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2125 /* Handle full BOOL types */
2128 *((BOOL *)(US data_block + ol->v.offset)) = boolvalue;
2130 *((BOOL *)ol->v.value) = boolvalue;
2134 if (type == opt_bool_verify)
2136 sprintf(CS name2, "%.50s_recipient", name + offset);
2137 if ((ol2 = find_option(name2, oltop, last)))
2139 *((BOOL *)(US data_block + ol2->v.offset)) = boolvalue;
2141 *((BOOL *)ol2->v.value) = boolvalue;
2144 /* Note that opt_bool_set type is set, if there is somewhere to do so */
2146 else if (type == opt_bool_set)
2148 sprintf(CS name2, "*set_%.50s", name + offset);
2149 if ((ol2 = find_option(name2, oltop, last)))
2151 *((BOOL *)(US data_block + ol2->v.offset)) = TRUE;
2153 *((BOOL *)ol2->v.value) = TRUE;
2161 inttype = US"octal ";
2163 /* Integer: a simple(ish) case; allow octal and hex formats, and
2164 suffixes K, M, G, and T. The different types affect output, not input. */
2173 lvalue = strtol(CS s, CSS &endptr, intbase);
2176 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2179 if (errno != ERANGE && *endptr)
2181 uschar * mp = US"TtGgMmKk\0"; /* YyZzEePpTtGgMmKk */
2183 if ((mp = Ustrchr(mp, *endptr)))
2188 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024)
2199 if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2200 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2201 "absolute value of integer \"%s\" is too large (overflow)", s);
2203 while (isspace(*endptr)) endptr++;
2205 extra_chars_error(endptr, inttype, US"integer value for ", name);
2207 value = (int)lvalue;
2211 *(int *)(US data_block + ol->v.offset) = value;
2213 *(int *)ol->v.value = value;
2216 /* Integer held in K: again, allow formats and suffixes as above. */
2222 int_eximarith_t lvalue = strtol(CS s, CSS &endptr, intbase);
2225 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2228 if (errno != ERANGE && *endptr)
2230 uschar * mp = US"ZzEePpTtGgMmKk\0"; /* YyZzEePpTtGgMmKk */
2232 if ((mp = Ustrchr(mp, *endptr)))
2237 if (lvalue > EXIM_ARITH_MAX/1024 || lvalue < EXIM_ARITH_MIN/1024)
2246 lvalue = (lvalue + 512)/1024;
2249 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2250 "absolute value of integer \"%s\" is too large (overflow)", s);
2252 while (isspace(*endptr)) endptr++;
2254 extra_chars_error(endptr, inttype, US"integer value for ", name);
2257 *(int_eximarith_t *)(US data_block + ol->v.offset) = lvalue;
2259 *(int_eximarith_t *)ol->v.value = lvalue;
2263 /* Fixed-point number: held to 3 decimal places. */
2266 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2267 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2268 "fixed-point number expected for %s", name);
2270 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2271 "integer \"%s\" is too large (overflow)", s);
2275 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2276 "integer \"%s\" is too large (overflow)", s);
2278 /* We get a coverity error here for using count, as it derived
2279 from the tainted buffer pointed to by s, as parsed by sscanf().
2280 By the definition of sscanf we must be accessing between start
2281 and end of s (assuming it is nul-terminated...) so ignore the error. */
2282 /* coverity[tainted_data] */
2283 if (s[count] == '.')
2286 while (isdigit(s[++count]))
2288 value += (s[count] - '0') * d;
2293 while (isspace(s[count])) count++;
2296 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2299 *((int *)(US data_block + ol->v.offset)) = value;
2301 *((int *)ol->v.value) = value;
2304 /* There's a special routine to read time values. */
2307 value = readconf_readtime(s, 0, FALSE);
2309 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2312 *((int *)(US data_block + ol->v.offset)) = value;
2314 *((int *)ol->v.value) = value;
2317 /* A time list is a list of colon-separated times, with the first
2318 element holding the size of the list and the second the number of
2324 int * list = data_block
2325 ? (int *)(US data_block + ol->v.offset)
2326 : (int *)ol->v.value;
2328 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2331 uschar *snext = Ustrchr(s, ':');
2335 while (ss > s && isspace(ss[-1])) ss--;
2338 value = readconf_readtime(s, terminator, FALSE);
2340 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2342 if (count > 1 && value <= list[count])
2343 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2344 "time value out of order for %s", name);
2345 list[count+1] = value;
2346 if (snext == NULL) break;
2348 while (isspace(*s)) s++;
2351 if (count > list[0] - 2)
2352 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2354 if (count > 0 && list[2] == 0) count = 0;
2361 void (*fn)() = ol->v.fn;
2372 /*************************************************
2373 * Print a time value *
2374 *************************************************/
2377 Argument: a time value in seconds
2378 Returns: pointer to a fixed buffer containing the time as a string,
2379 in readconf_readtime() format
2383 readconf_printtime(int t)
2386 uschar *p = time_buffer;
2403 if (w > 0) p += sprintf(CS p, "%dw", w);
2404 if (d > 0) p += sprintf(CS p, "%dd", d);
2405 if (h > 0) p += sprintf(CS p, "%dh", h);
2406 if (m > 0) p += sprintf(CS p, "%dm", m);
2407 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2414 /*************************************************
2415 * Print an individual option value *
2416 *************************************************/
2418 /* This is used by the -bP option, so prints to the standard output.
2419 The entire options list is passed in as an argument, because some options come
2420 in pairs - typically uid/gid settings, which can either be explicit numerical
2421 values, or strings to be expanded later. If the numerical value is unset,
2422 search for "*expand_<name>" to see if there is a string equivalent.
2425 ol option entry, or NULL for an unknown option
2427 options_block NULL for main configuration options; otherwise points to
2428 a driver block; if the option doesn't have opt_public
2429 set, then options_block->options_block is where the item
2431 oltop points to the option list in which ol exists
2432 last one more than the offset of the last entry in optop
2433 no_labels do not show "foo = " at the start.
2435 Returns: boolean success
2439 print_ol(optionlist *ol, const uschar *name, void *options_block,
2440 optionlist *oltop, int last, BOOL no_labels)
2449 uschar name2[EXIM_DRIVERNAME_MAX];
2453 printf("%s is not a known option\n", name);
2457 /* Non-admin callers cannot see options that have been flagged secure by the
2460 if (!f.admin_user && ol->type & opt_secure)
2463 printf("%s\n", CCS hidden);
2465 printf("%s = %s\n", name, CCS hidden);
2469 /* Else show the value of the option */
2471 value = ol->v.value;
2474 if (!(ol->type & opt_public))
2475 options_block = (void *)(((driver_instance *)options_block)->options_block);
2476 value = (void *)(US options_block + (long int)value);
2479 switch(ol->type & opt_mask)
2482 case opt_rewrite: /* Show the text value */
2484 if (!no_labels) printf("%s = ", name);
2485 printf("%s\n", s ? string_printing2(s, SP_TAB) : US"");
2489 if (!no_labels) printf("%s = ", name);
2490 printf("%d\n", *((int *)value));
2495 int x = *((int *)value);
2496 if (x != 0 && (x & 1023) == 0)
2500 if ((x & 1023) == 0)
2505 if (!no_labels) printf("%s = ", name);
2506 printf("%d%c\n", x, c);
2510 if (!no_labels) printf("%s = ", name);
2518 int_eximarith_t x = *((int_eximarith_t *)value);
2519 if (!no_labels) printf("%s = ", name);
2520 if (x == 0) printf("0\n");
2521 else if ((x & ((1<<30)-1)) == 0) printf(PR_EXIM_ARITH "T\n", x >> 30);
2522 else if ((x & ((1<<20)-1)) == 0) printf(PR_EXIM_ARITH "G\n", x >> 20);
2523 else if ((x & ((1<<10)-1)) == 0) printf(PR_EXIM_ARITH "M\n", x >> 10);
2524 else printf(PR_EXIM_ARITH "K\n", x);
2529 if (!no_labels) printf("%s = ", name);
2530 printf("%#o\n", *((int *)value));
2533 /* Can be negative only when "unset", in which case integer */
2537 int x = *((int *)value);
2540 if (x < 0) printf("%s =\n", name); else
2542 if (!no_labels) printf("%s = ", name);
2543 printf("%d.", x/1000);
2556 /* If the numerical value is unset, try for the string value */
2558 case opt_expand_uid:
2559 if (! *get_set_flag(name, oltop, last, options_block))
2561 sprintf(CS name2, "*expand_%.50s", name);
2562 if ((ol2 = find_option(name2, oltop, last)))
2565 s = *USS (US options_block + ol2->v.offset);
2567 s = *USS ol2->v.value;
2568 if (!no_labels) printf("%s = ", name);
2569 printf("%s\n", s ? string_printing(s) : US"");
2574 /* Else fall through */
2577 if (!no_labels) printf("%s = ", name);
2578 if (! *get_set_flag(name, oltop, last, options_block))
2581 if ((pw = getpwuid(*((uid_t *)value))))
2582 printf("%s\n", pw->pw_name);
2584 printf("%ld\n", (long int)(*((uid_t *)value)));
2587 /* If the numerical value is unset, try for the string value */
2589 case opt_expand_gid:
2590 if (! *get_set_flag(name, oltop, last, options_block))
2592 sprintf(CS name2, "*expand_%.50s", name);
2593 if ( (ol2 = find_option(name2, oltop, last))
2594 && (ol2->type & opt_mask) == opt_stringptr)
2597 s = *USS (US options_block + ol2->v.offset);
2599 s = *USS ol2->v.value;
2600 if (!no_labels) printf("%s = ", name);
2601 printf("%s\n", s ? string_printing(s) : US"");
2606 /* Else fall through */
2609 if (!no_labels) printf("%s = ", name);
2610 if (! *get_set_flag(name, oltop, last, options_block))
2613 if ((gr = getgrgid(*((int *)value))))
2614 printf("%s\n", gr->gr_name);
2616 printf("%ld\n", (long int)(*((int *)value)));
2620 uidlist = *((uid_t **)value);
2621 if (!no_labels) printf("%s =", name);
2624 uschar sep = no_labels ? '\0' : ' ';
2625 for (int i = 1; i <= (int)(uidlist[0]); i++)
2627 uschar *name = NULL;
2628 if ((pw = getpwuid(uidlist[i]))) name = US pw->pw_name;
2629 if (sep != '\0') printf("%c", sep);
2630 if (name) printf("%s", name);
2631 else printf("%ld", (long int)(uidlist[i]));
2639 gidlist = *((gid_t **)value);
2640 if (!no_labels) printf("%s =", name);
2643 uschar sep = no_labels ? '\0' : ' ';
2644 for (int i = 1; i <= (int)(gidlist[0]); i++)
2646 uschar *name = NULL;
2647 if ((gr = getgrgid(gidlist[i]))) name = US gr->gr_name;
2648 if (sep != '\0') printf("%c", sep);
2649 if (name) printf("%s", name);
2650 else printf("%ld", (long int)(gidlist[i]));
2658 if (!no_labels) printf("%s = ", name);
2659 printf("%s\n", readconf_printtime(*((int *)value)));
2664 int *list = (int *)value;
2665 if (!no_labels) printf("%s = ", name);
2666 for (int i = 0; i < list[1]; i++)
2667 printf("%s%s", i == 0 ? "" : ":", readconf_printtime(list[i+2]));
2673 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2677 case opt_expand_bool:
2678 sprintf(CS name2, "*expand_%.50s", name);
2679 if ((ol2 = find_option(name2, oltop, last)) && ol2->v.value)
2682 s = *USS (US options_block + ol2->v.offset);
2684 s = *USS ol2->v.value;
2687 if (!no_labels) printf("%s = ", name);
2688 printf("%s\n", string_printing(s));
2691 /* s == NULL => string not set; fall through */
2697 case opt_bool_verify:
2699 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2703 ol->v.fn(name, NULL, no_labels ? opt_fn_print : opt_fn_print|opt_fn_print_label);
2711 /*************************************************
2712 * Print value from main configuration *
2713 *************************************************/
2715 /* This function, called as a result of encountering the -bP option,
2716 causes the value of any main configuration variable to be output if the
2717 second argument is NULL. There are some special values:
2719 all print all main configuration options
2720 config_file print the name of the configuration file
2721 (configure_file will still work, for backward
2723 routers print the routers' configurations
2724 transports print the transports' configuration
2725 authenticators print the authenticators' configuration
2726 macros print the macros' configuration
2727 router_list print a list of router names
2728 transport_list print a list of transport names
2729 authenticator_list print a list of authentication mechanism names
2730 macro_list print a list of macro names
2731 +name print a named list item
2732 local_scan print the local_scan options
2733 config print the configuration as it is parsed
2734 environment print the used execution environment
2736 If the second argument is not NULL, it must be one of "router", "transport",
2737 "authenticator" or "macro" in which case the first argument identifies the
2738 driver whose options are to be printed.
2741 name option name if type == NULL; else driver name
2742 type NULL or driver type name, as described above
2743 no_labels avoid the "foo = " at the start of an item
2745 Returns: Boolean success
2749 readconf_print(const uschar *name, uschar *type, BOOL no_labels)
2751 BOOL names_only = FALSE;
2752 optionlist *ol2 = NULL;
2753 driver_instance *d = NULL;
2762 static uschar *types[] = { US"address", US"domain", US"host",
2764 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2765 &hostlist_anchor, &localpartlist_anchor };
2767 for (int i = 0; i < 4; i++)
2768 if ((t = tree_search(*(anchors[i]), name+1)))
2770 namedlist_block * nb = t->data.ptr;
2771 const uschar * s = nb->hide ? hidden : nb->string;
2774 printf("%s\n", CCS s);
2776 printf("%slist %s = %s\n", types[i], name+1, CCS s);
2780 printf("no address, domain, host, or local part list called \"%s\" "
2781 "exists\n", name+1);
2786 if ( Ustrcmp(name, "configure_file") == 0
2787 || Ustrcmp(name, "config_file") == 0)
2789 printf("%s\n", CS config_main_filename);
2793 if (Ustrcmp(name, "all") == 0)
2795 for (optionlist * ol = optionlist_config;
2796 ol < optionlist_config + nelem(optionlist_config); ol++)
2797 if (!(ol->type & opt_hidden))
2798 (void) print_ol(ol, US ol->name, NULL,
2799 optionlist_config, nelem(optionlist_config),
2804 if (Ustrcmp(name, "local_scan") == 0)
2806 #ifndef LOCAL_SCAN_HAS_OPTIONS
2807 printf("local_scan() options are not supported\n");
2810 for (optionlist * ol = local_scan_options;
2811 ol < local_scan_options + local_scan_options_count; ol++)
2812 (void) print_ol(ol, US ol->name, NULL, local_scan_options,
2813 local_scan_options_count, no_labels);
2818 if (Ustrcmp(name, "config") == 0)
2820 print_config(f.admin_user, no_labels);
2824 if (Ustrcmp(name, "routers") == 0)
2829 else if (Ustrcmp(name, "transports") == 0)
2831 type = US"transport";
2834 else if (Ustrcmp(name, "authenticators") == 0)
2836 type = US"authenticator";
2839 else if (Ustrcmp(name, "macros") == 0)
2844 else if (Ustrcmp(name, "router_list") == 0)
2850 else if (Ustrcmp(name, "transport_list") == 0)
2852 type = US"transport";
2856 else if (Ustrcmp(name, "authenticator_list") == 0)
2858 type = US"authenticator";
2862 else if (Ustrcmp(name, "macro_list") == 0)
2868 else if (Ustrcmp(name, "environment") == 0)
2873 for (p = USS environ; *p; p++) ;
2874 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2876 for (p = USS environ; *p; p++)
2879 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2887 return print_ol(find_option(name,
2888 optionlist_config, nelem(optionlist_config)),
2889 name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2892 /* Handle the options for a router or transport. Skip options that are flagged
2893 as hidden. Some of these are options with names starting with '*', used for
2894 internal alternative representations of other options (which the printing
2895 function will sort out). Others are synonyms kept for backward compatibility.
2898 if (Ustrcmp(type, "router") == 0)
2900 d = (driver_instance *)routers;
2901 ol2 = optionlist_routers;
2902 size = optionlist_routers_size;
2904 else if (Ustrcmp(type, "transport") == 0)
2906 d = (driver_instance *)transports;
2907 ol2 = optionlist_transports;
2908 size = optionlist_transports_size;
2910 else if (Ustrcmp(type, "authenticator") == 0)
2912 d = (driver_instance *)auths;
2913 ol2 = optionlist_auths;
2914 size = optionlist_auths_size;
2917 else if (Ustrcmp(type, "macro") == 0)
2919 /* People store passwords in macros and they were previously not available
2920 for printing. So we have an admin_users restriction. */
2923 fprintf(stderr, "exim: permission denied\n");
2926 for (macro_item * m = macros; m; m = m->next)
2927 if (!name || Ustrcmp(name, m->name) == 0)
2930 printf("%s\n", CS m->name);
2932 printf("%s\n", CS m->replacement);
2934 printf("%s=%s\n", CS m->name, CS m->replacement);
2938 if (!name) return TRUE;
2940 printf("%s %s not found\n", type, name);
2946 for (; d; d = d->next) printf("%s\n", CS d->name);
2950 /* Either search for a given driver, or print all of them */
2952 for (; d; d = d->next)
2956 printf("\n%s %s:\n", d->name, type);
2957 else if (Ustrcmp(d->name, name) != 0) continue;
2959 for (optionlist * ol = ol2; ol < ol2 + size; ol++)
2960 if (!(ol->type & opt_hidden))
2961 rc |= print_ol(ol, US ol->name, d, ol2, size, no_labels);
2963 for (optionlist * ol = d->info->options;
2964 ol < d->info->options + *(d->info->options_count); ol++)
2965 if (!(ol->type & opt_hidden))
2966 rc |= print_ol(ol, US ol->name, d, d->info->options,
2967 *d->info->options_count, no_labels);
2969 if (name) return rc;
2971 if (!name) return TRUE;
2973 printf("%s %s not found\n", type, name);
2979 /*************************************************
2980 * Read a named list item *
2981 *************************************************/
2983 /* This function reads a name and a list (i.e. string). The name is used to
2984 save the list in a tree, sorted by its name. Each entry also has a number,
2985 which can be used for caching tests, but if the string contains any expansion
2986 items other than $key, the number is set negative to inhibit caching. This
2987 mechanism is used for domain, host, and address lists that are referenced by
2991 anchorp points to the tree anchor
2992 numberp points to the current number for this tree
2993 max the maximum number permitted
2994 s the text of the option line, starting immediately after the name
2996 tname the name of the list type, for messages
2997 hide do not output value on "-bP"
3003 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
3004 uschar *tname, BOOL hide)
3006 BOOL forcecache = FALSE;
3009 namedlist_block * nb = store_get_perm(sizeof(namedlist_block), FALSE);
3011 if (Ustrncmp(s, "_cache", 6) == 0)
3018 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
3020 if (*numberp >= max)
3021 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
3024 Uskip_whitespace(&s);
3026 while (isalnum(*s) || *s == '_') s++;
3027 t = store_get(sizeof(tree_node) + s-ss, is_tainted(ss));
3028 Ustrncpy(t->name, ss, s-ss);
3030 Uskip_whitespace(&s);
3032 if (!tree_insertnode(anchorp, t))
3033 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3034 "duplicate name \"%s\" for a named %s", t->name, tname);
3037 nb->number = *numberp;
3041 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3042 "missing '=' after \"%s\"", t->name);
3043 Uskip_whitespace(&s);
3044 nb->string = read_string(s, t->name);
3045 nb->cache_data = NULL;
3047 /* Check the string for any expansions; if any are found, mark this list
3048 uncacheable unless the user has explicited forced caching. */
3050 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
3056 /*************************************************
3057 * Unpick data for a rate limit *
3058 *************************************************/
3060 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
3064 s string, in the form t,b,f,l
3065 where t is the threshold (integer)
3066 b is the initial delay (time)
3067 f is the multiplicative factor (fixed point)
3068 k is the maximum time (time)
3069 threshold where to store threshold
3070 base where to store base in milliseconds
3071 factor where to store factor in milliseconds
3072 limit where to store limit
3074 Returns: nothing (panics on error)
3078 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
3081 uschar bstring[16], lstring[16];
3083 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
3084 factor, lstring) == 4)
3086 *base = readconf_readtime(bstring, 0, TRUE);
3087 *limit = readconf_readtime(lstring, 0, TRUE);
3088 if (*base >= 0 && *limit >= 0) return;
3090 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3096 /*************************************************
3097 * Read main configuration options *
3098 *************************************************/
3100 /* This function is the first to be called for configuration reading. It
3101 opens the configuration file and reads general configuration settings until
3102 it reaches the end of the configuration section. The file is then left open so
3103 that the remaining configuration data can subsequently be read if needed for
3106 The configuration file must be owned either by root or exim, and be writeable
3107 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3108 in the config file, so the test is done on the compiled in values. A slight
3109 anomaly, to be carefully documented.
3111 The name of the configuration file is taken from a list that is included in the
3112 binary of Exim. It can be altered from the command line, but if that is done,
3113 root privilege is immediately withdrawn unless the caller is root or exim.
3114 The first file on the list that exists is used.
3116 For use on multiple systems that share file systems, first look for a
3117 configuration file whose name has the current node name on the end. If that is
3118 not found, try the generic name. For really contorted configurations, that run
3119 multiple Exims with different uid settings, first try adding the effective uid
3120 before the node name. These complications are going to waste resources on most
3121 systems. Therefore they are available only when requested by compile-time
3125 readconf_main(BOOL nowarn)
3128 struct stat statbuf;
3129 uschar *s, *filename;
3130 const uschar *list = config_main_filelist;
3132 /* Loop through the possible file names */
3134 /* Should never be a tainted list */
3135 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3138 /* Cut out all the fancy processing unless specifically wanted */
3140 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3141 uschar *suffix = filename + Ustrlen(filename);
3143 /* Try for the node-specific file if a node name exists */
3145 # ifdef CONFIGURE_FILE_USE_NODE
3147 if (uname(&uts) >= 0)
3149 # ifdef CONFIGURE_FILE_USE_EUID
3150 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3151 if (!(config_file = Ufopen(filename, "rb")))
3152 # endif /* CONFIGURE_FILE_USE_EUID */
3154 sprintf(CS suffix, ".%.256s", uts.nodename);
3155 config_file = Ufopen(filename, "rb");
3158 # endif /* CONFIGURE_FILE_USE_NODE */
3160 /* Otherwise, try the generic name, possibly with the euid added */
3162 # ifdef CONFIGURE_FILE_USE_EUID
3165 sprintf(CS suffix, ".%ld", (long int)original_euid);
3166 config_file = Ufopen(filename, "rb");
3168 # endif /* CONFIGURE_FILE_USE_EUID */
3170 /* Finally, try the unadorned name */
3175 config_file = Ufopen(filename, "rb");
3177 #else /* if neither defined */
3179 /* This is the common case when the fancy processing is not included. */
3181 config_file = Ufopen(filename, "rb");
3184 /* If the file does not exist, continue to try any others. For any other
3185 error, break out (and die). */
3187 if (config_file || errno != ENOENT) break;
3190 /* On success, save the name for verification; config_filename is used when
3191 logging configuration errors (it changes for .included files) whereas
3192 config_main_filename is the name shown by -bP. Failure to open a configuration
3193 file is a serious disaster. */
3197 uschar *last_slash = Ustrrchr(filename, '/');
3198 config_filename = config_main_filename = string_copy(filename);
3200 /* The config_main_directory we need for the $config_dir expansion.
3201 config_main_filename we need for $config_file expansion.
3202 And config_dir is the directory of the current configuration, used for
3203 relative .includes. We do need to know it's name, as we change our working
3206 if (filename[0] == '/')
3207 config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3210 /* relative configuration file name: working dir + / + basename(filename) */
3212 uschar buf[PATH_MAX];
3215 if (os_getcwd(buf, PATH_MAX) == NULL)
3217 perror("exim: getcwd");
3220 g = string_cat(NULL, buf);
3222 /* If the dir does not end with a "/", append one */
3223 if (g->s[g->ptr-1] != '/')
3224 g = string_catn(g, US"/", 1);
3226 /* If the config file contains a "/", extract the directory part */
3228 g = string_catn(g, filename, last_slash - filename);
3230 config_main_directory = string_from_gstring(g);
3232 config_directory = config_main_directory;
3236 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3237 "%s", config_main_filelist);
3239 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
3240 string_open_failed("configuration file %s", filename));
3242 /* Now, once we found and opened our configuration file, we change the directory
3243 to a safe place. Later we change to $spool_directory. */
3245 if (Uchdir("/") < 0)
3247 perror("exim: chdir `/': ");
3251 /* Check the status of the file we have opened, if we have retained root
3252 privileges and the file isn't /dev/null (which *should* be 0666). */
3254 if (f.trusted_config && Ustrcmp(filename, US"/dev/null"))
3256 if (fstat(fileno(config_file), &statbuf) != 0)
3257 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3260 if ( statbuf.st_uid != root_uid /* owner not root */
3261 #ifdef CONFIGURE_OWNER
3262 && statbuf.st_uid != config_uid /* owner not the special one */
3265 statbuf.st_gid != root_gid /* group not root & */
3266 #ifdef CONFIGURE_GROUP
3267 && statbuf.st_gid != config_gid /* group not the special one */
3269 && (statbuf.st_mode & 020) != 0 /* group writeable */
3271 (statbuf.st_mode & 2) != 0 /* world writeable */
3273 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3274 "wrong owner, group, or mode", big_buffer);
3276 /* Do a dummy store-allocation of a size related to the (toplevel) file size.
3277 This assumes we will need this much storage to handle all the allocations
3278 during startup; it won't help when .include is being used. When it does, it
3279 will cut down on the number of store blocks (and malloc calls, and sbrk
3280 syscalls). It also assume we're on the relevant pool. */
3282 if (statbuf.st_size > 8192)
3284 rmark r = store_mark();
3285 void * dummy = store_get((int)statbuf.st_size, FALSE);
3290 /* Process the main configuration settings. They all begin with a lower case
3291 letter. If we see something starting with an upper case letter, it is taken as
3292 a macro definition. */
3294 while ((s = get_config_line()))
3299 if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3300 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3301 "found unexpected BOM (Byte Order Mark)");
3305 if (!macro_read_assignment(s)) exim_exit(EXIT_FAILURE);
3309 t = (hide = Ustrncmp(s, "hide", 4) == 0 && isspace(s[4])) ? s + 5 : s;
3311 if (Ustrncmp(t, "domainlist", 10) == 0)
3312 read_named_list(&domainlist_anchor, &domainlist_count,
3313 MAX_NAMED_LIST, t+10, US"domain list", hide);
3315 else if (Ustrncmp(t, "hostlist", 8) == 0)
3316 read_named_list(&hostlist_anchor, &hostlist_count,
3317 MAX_NAMED_LIST, t+8, US"host list", hide);
3319 else if (Ustrncmp(t, "addresslist", 11) == 0)
3320 read_named_list(&addresslist_anchor, &addresslist_count,
3321 MAX_NAMED_LIST, t+11, US"address list", hide);
3323 else if (Ustrncmp(t, "localpartlist", 13) == 0)
3324 read_named_list(&localpartlist_anchor, &localpartlist_count,
3325 MAX_NAMED_LIST, t+13, US"local part list", hide);
3328 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3329 NULL, US"main option \"%s\" unknown");
3333 /* If local_sender_retain is set, local_from_check must be unset. */
3335 if (local_sender_retain && local_from_check)
3336 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3337 "local_sender_retain are set; this combination is not allowed");
3339 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3342 if (timezone_string && !*timezone_string) timezone_string = NULL;
3344 /* The max retry interval must not be greater than 24 hours. */
3346 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3348 /* remote_max_parallel must be > 0 */
3350 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3352 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3353 start of a new SMTP message. */
3355 freeze_tell_config = freeze_tell;
3357 /* The primary host name may be required for expansion of spool_directory
3358 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3359 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3360 canonize it. Some people like upper case letters in their host names, so we
3361 don't force the case. */
3363 if (!primary_hostname)
3365 const uschar * hostname;
3368 if (uname(&uts) < 0)
3369 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3370 hostname = US uts.nodename;
3372 if (Ustrchr(hostname, '.') == NULL)
3375 struct hostent *hostdata;
3379 && ( !dns_ipv4_lookup
3380 || match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3381 MCL_DOMAIN, TRUE, NULL) != OK))
3388 # if HAVE_GETIPNODEBYNAME
3390 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3392 hostdata = gethostbyname2(CS hostname, af);
3395 hostdata = gethostbyname(CS hostname);
3399 { hostname = US hostdata->h_name; break; }
3401 if (af == AF_INET) break;
3406 primary_hostname = string_copy(hostname);
3409 /* Set up default value for smtp_active_hostname */
3411 smtp_active_hostname = primary_hostname;
3413 /* If spool_directory wasn't set in the build-time configuration, it must have
3414 got set above. Of course, writing to the log may not work if log_file_path is
3415 not set, but it will at least get to syslog or somewhere, with any luck. */
3417 if (!*spool_directory)
3418 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3421 /* Expand the spool directory name; it may, for example, contain the primary
3422 host name. Same comment about failure. */
3424 if (!(s = expand_string(spool_directory)))
3425 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3426 "\"%s\": %s", spool_directory, expand_string_message);
3427 spool_directory = s;
3429 /* Expand log_file_path, which must contain "%s" in any component that isn't
3430 the null string or "syslog". It is also allowed to contain one instance of %D
3431 or %M. However, it must NOT contain % followed by anything else. */
3435 const uschar *ss, *sss;
3436 int sep = ':'; /* Fixed for log file path */
3437 if (!(s = expand_string(log_file_path)))
3438 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3439 "\"%s\": %s", log_file_path, expand_string_message);
3442 /* should never be a tainted list */
3443 while ((sss = string_nextinlist(&ss, &sep, big_buffer, big_buffer_size)))
3446 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3447 if (!(t = Ustrstr(sss, "%s")))
3448 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3449 "contain \"%%s\"", sss);
3451 if ((t = Ustrchr(sss, '%')))
3452 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3453 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3454 "unexpected \"%%\" character", s);
3460 /* Interpret syslog_facility into an integer argument for 'ident' param to
3461 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3464 if (syslog_facility_str)
3467 uschar *s = syslog_facility_str;
3469 if ((Ustrlen(syslog_facility_str) >= 4) &&
3470 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3473 for (i = 0; i < syslog_list_size; i++)
3474 if (strcmpic(s, syslog_list[i].name) == 0)
3476 syslog_facility = syslog_list[i].value;
3480 if (i >= syslog_list_size)
3481 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3482 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3485 /* Expand pid_file_path */
3489 if (!(s = expand_string(pid_file_path)))
3490 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3491 "\"%s\": %s", pid_file_path, expand_string_message);
3495 /* Set default value of process_log_path */
3497 if (!process_log_path || !*process_log_path)
3498 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3500 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3503 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3505 /* Unpick the SMTP rate limiting options, if set */
3507 if (smtp_ratelimit_mail)
3508 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3509 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3511 if (smtp_ratelimit_rcpt)
3512 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3513 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3515 /* The qualify domains default to the primary host name */
3517 if (!qualify_domain_sender)
3518 qualify_domain_sender = primary_hostname;
3519 if (!qualify_domain_recipient)
3520 qualify_domain_recipient = qualify_domain_sender;
3522 /* Setting system_filter_user in the configuration sets the gid as well if a
3523 name is given, but a numerical value does not. */
3525 if (system_filter_uid_set && !system_filter_gid_set)
3527 struct passwd *pw = getpwuid(system_filter_uid);
3529 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3530 (long int)system_filter_uid);
3531 system_filter_gid = pw->pw_gid;
3532 system_filter_gid_set = TRUE;
3535 /* If the errors_reply_to field is set, check that it is syntactically valid
3536 and ensure it contains a domain. */
3538 if (errors_reply_to)
3541 int start, end, domain;
3542 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3543 &start, &end, &domain, FALSE);
3546 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3547 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3550 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3551 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3554 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3555 smtp_accept_max must also be set. */
3557 if (smtp_accept_max == 0 && (smtp_accept_queue > 0 || smtp_accept_max_per_host))
3558 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3559 "smtp_accept_max must be set if smtp_accept_queue or "
3560 "smtp_accept_max_per_host is set");
3562 /* Set up the host number if anything is specified. It is an expanded string
3563 so that it can be computed from the host name, for example. We do this last
3564 so as to ensure that everything else is set up before the expansion. */
3566 if (host_number_string)
3570 uschar *s = expand_string(host_number_string);
3573 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3574 "failed to expand localhost_number \"%s\": %s",
3575 host_number_string, expand_string_message);
3576 n = Ustrtol(s, &end, 0);
3577 while (isspace(*end)) end++;
3579 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3580 "localhost_number value is not a number: %s", s);
3581 if (n > LOCALHOST_MAX)
3582 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3583 "localhost_number is greater than the maximum allowed value (%d)",
3589 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3591 if ((tls_verify_hosts || tls_try_verify_hosts) && !tls_verify_certificates)
3592 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3593 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3594 tls_verify_hosts ? "" : "try_");
3596 /* Magic number: at time of writing, 1024 has been the long-standing value
3597 used by so many clients, and what Exim used to use always, that it makes
3598 sense to just min-clamp this max-clamp at that. */
3599 if (tls_dh_max_bits < 1024)
3600 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3601 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3603 /* If openssl_options is set, validate it */
3604 if (openssl_options)
3607 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3608 "openssl_options is set but we're using GnuTLS");
3611 if (!tls_openssl_options_parse(openssl_options, &dummy))
3612 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3613 "openssl_options parse error: %s", openssl_options);
3616 #endif /*DISABLE_TLS*/
3618 if (!nowarn && !keep_environment && environ && *environ)
3619 log_write(0, LOG_MAIN,
3620 "Warning: purging the environment.\n"
3621 " Suggested action: use keep_environment.");
3626 /*************************************************
3627 * Initialize one driver *
3628 *************************************************/
3630 /* This is called once the driver's generic options, if any, have been read.
3631 We can now find the driver, set up defaults for the private options, and
3632 unset any "set" bits in the private options table (which might have been
3633 set by another incarnation of the same driver).
3636 d pointer to driver instance block, with generic
3638 drivers_available vector of available drivers
3639 size_of_info size of each block in drivers_available
3640 class class of driver, for error message
3642 Returns: pointer to the driver info block
3645 static driver_info *
3646 init_driver(driver_instance *d, driver_info *drivers_available,
3647 int size_of_info, uschar *class)
3649 for (driver_info * dd = drivers_available; dd->driver_name[0] != 0;
3650 dd = (driver_info *)((US dd) + size_of_info))
3651 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3653 int len = dd->options_len;
3655 d->options_block = store_get_perm(len, FALSE);
3656 memcpy(d->options_block, dd->options_block, len);
3657 for (int i = 0; i < *(dd->options_count); i++)
3658 dd->options[i].type &= ~opt_set;
3662 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3663 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3665 return NULL; /* never obeyed */
3672 driver_init_fini(driver_instance * d, const uschar * class)
3674 if (!d->driver_name)
3675 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3676 "no driver defined for %s \"%s\"", class, d->name);
3681 /*************************************************
3682 * Initialize driver list *
3683 *************************************************/
3685 /* This function is called for routers, transports, and authentication
3686 mechanisms. It reads the data from the current point in the configuration file
3687 up to the end of the section, and sets up a chain of instance blocks according
3688 to the file's contents. The file will already have been opened by a call to
3689 readconf_main, and must be left open for subsequent reading of further data.
3691 Any errors cause a panic crash. Note that the blocks with names driver_info and
3692 driver_instance must map the first portions of all the _info and _instance
3693 blocks for this shared code to work.
3696 class "router", "transport", or "authenticator"
3697 anchor &routers, &transports, &auths
3698 drivers_available available drivers
3699 size_of_info size of each info block
3700 instance_default points to default data for an instance
3701 instance_size size of instance block
3702 driver_optionlist generic option list
3703 driver_optionlist_count count of generic option list
3709 readconf_driver_init(
3711 driver_instance **anchor,
3712 driver_info *drivers_available,
3714 void *instance_default,
3716 optionlist *driver_optionlist,
3717 int driver_optionlist_count)
3719 driver_instance **p = anchor;
3720 driver_instance *d = NULL;
3723 while ((buffer = get_config_line()))
3725 uschar name[EXIM_DRIVERNAME_MAX];
3728 /* Read the first name on the line and test for the start of a new driver. A
3729 macro definition indicates the end of the previous driver. If this isn't the
3730 start of a new driver, the line will be re-read. */
3732 s = readconf_readname(name, sizeof(name), buffer);
3734 /* Handle macro definition, first finishing off the initialization of the
3735 previous driver, if any. */
3737 if (isupper(*name) && *s == '=')
3741 /* s is using big_buffer, so this call had better not */
3742 driver_init_fini(d, class);
3745 if (!macro_read_assignment(buffer)) exim_exit(EXIT_FAILURE);
3749 /* If the line starts with a name terminated by a colon, we are at the
3750 start of the definition of a new driver. The rest of the line must be
3755 /* Finish off initializing the previous driver. */
3758 driver_init_fini(d, class);
3760 /* Check that we haven't already got a driver of this name */
3762 for (d = *anchor; d; d = d->next)
3763 if (Ustrcmp(name, d->name) == 0)
3764 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3765 "there are two %ss called \"%s\"", class, name);
3767 /* Set up a new driver instance data block on the chain, with
3768 its default values installed. */
3770 d = store_get_perm(instance_size, FALSE);
3771 memcpy(d, instance_default, instance_size);
3774 d->name = string_copy(name);
3776 /* Clear out the "set" bits in the generic options */
3778 for (int i = 0; i < driver_optionlist_count; i++)
3779 driver_optionlist[i].type &= ~opt_set;
3781 /* Check nothing more on this line, then do the next loop iteration. */
3783 Uskip_whitespace(&s);
3784 if (*s) extra_chars_error(s, US"driver name ", name, US"");
3788 /* Not the start of a new driver. Give an error if we have not set up a
3789 current driver yet. */
3792 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3794 /* First look to see if this is a generic option; if it is "driver",
3795 initialize the driver. If is it not a generic option, we can look for a
3796 private option provided that the driver has been previously set up. */
3798 if (readconf_handle_option(buffer, driver_optionlist,
3799 driver_optionlist_count, d, NULL))
3801 if (!d->info && d->driver_name)
3802 init_driver(d, drivers_available, size_of_info, class);
3805 /* Handle private options - pass the generic block because some may
3806 live therein. A flag with each option indicates if it is in the public
3810 readconf_handle_option(buffer, d->info->options,
3811 *(d->info->options_count), d, US"option \"%s\" unknown");
3813 /* The option is not generic and the driver name has not yet been given. */
3815 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3816 "(\"driver\" must be specified before any private options)", name);
3819 /* Run the initialization function for the final driver. */
3822 driver_init_fini(d, class);
3827 /*************************************************
3828 * Check driver dependency *
3829 *************************************************/
3831 /* This function is passed a driver instance and a string. It checks whether
3832 any of the string options for the driver contains the given string as an
3836 d points to a driver instance block
3837 s the string to search for
3839 Returns: TRUE if a dependency is found
3843 readconf_depends(driver_instance *d, uschar *s)
3845 int count = *(d->info->options_count);
3848 for (optionlist * ol = d->info->options; ol < d->info->options + count; ol++)
3849 if ((ol->type & opt_mask) == opt_stringptr)
3851 void * options_block = ol->type & opt_public ? (void *)d : d->options_block;
3852 uschar * value = *USS(US options_block + ol->v.offset);
3854 if (value && (ss = Ustrstr(value, s)) != NULL)
3856 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3857 isalnum(ss[Ustrlen(s)])) continue;
3858 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3859 d->name, ol->name, s);
3864 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3871 /*************************************************
3872 * Decode an error type for retries *
3873 *************************************************/
3875 /* This function is global because it is also called from the main
3876 program when testing retry information. It decodes strings such as "quota_7d"
3877 into numerical error codes.
3880 pp points to start of text
3881 p points past end of text
3882 basic_errno points to an int to receive the main error number
3883 more_errno points to an int to receive the secondary error data
3885 Returns: NULL if decoded correctly; else points to error text
3889 readconf_retry_error(const uschar *pp, const uschar *p,
3890 int *basic_errno, int *more_errno)
3893 const uschar *q = pp;
3894 while (q < p && *q != '_') q++;
3897 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3899 *basic_errno = ERRNO_EXIMQUOTA;
3900 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3901 return US"bad time value";
3904 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3906 *basic_errno = ECONNREFUSED;
3909 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3910 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3911 else return US"A or MX expected after \"refused\"";
3915 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3917 *basic_errno = ETIMEDOUT;
3921 int xlen = p - q - 1;
3922 const uschar *x = q + 1;
3924 static uschar *extras[] =
3925 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
3926 static int values[] =
3927 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3929 for (i = 0; i < nelem(extras); i++)
3930 if (strncmpic(x, extras[i], xlen) == 0)
3932 *more_errno = values[i];
3936 if (i >= nelem(extras))
3937 if (strncmpic(x, US"DNS", xlen) == 0)
3938 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3939 "available in retry rules (it has never worked) - treated as "
3942 return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3946 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3947 strncmpic(pp, US"rcpt_4", 6) == 0 ||
3948 strncmpic(pp, US"data_4", 6) == 0)
3951 int x = 255; /* means "any 4xx code" */
3952 if (p != pp + 8) bad = TRUE; else
3954 int a = pp[6], b = pp[7];
3958 if (isdigit(b)) x += b - '0';
3959 else if (b == 'x') x += 100;
3962 else if (a != 'x' || b != 'x') bad = TRUE;
3966 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3967 "x is literal and d is any digit", pp);
3969 *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
3970 *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3971 *more_errno = x << 8;
3974 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3975 strncmpic(q+1, US"failed", p-q-1) == 0)
3976 *basic_errno = ERRNO_AUTHFAIL;
3978 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3979 *basic_errno = ERRNO_SMTPCLOSED;
3981 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3982 *basic_errno = ERRNO_TLSREQUIRED;
3984 else if (strncmpic(pp, US"lookup", p - pp) == 0)
3985 *basic_errno = ERRNO_UNKNOWNHOST;
3987 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3988 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3996 /*************************************************
3997 * Read retry information *
3998 *************************************************/
4000 /* Each line of retry information contains:
4002 . A domain name pattern or an address pattern;
4004 . An error name, possibly with additional data, or *;
4006 . An optional sequence of retry items, each consisting of an identifying
4007 letter, a cutoff time, and optional parameters.
4009 All this is decoded and placed into a control block. */
4012 /* Subroutine to read an argument, preceded by a comma and terminated
4013 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4014 1 = fixed point number (returned *1000).
4017 paddr pointer to pointer to current character; updated
4018 type 0 => read a time; 1 => read a fixed point number
4020 Returns: time in seconds or fixed point number * 1000
4024 retry_arg(const uschar **paddr, int type)
4026 const uschar *p = *paddr;
4029 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4031 Uskip_whitespace(&p);
4033 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4035 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4036 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4041 case 0: return readconf_readtime(pp, *p, FALSE);
4042 case 1: return readconf_readfixed(pp, *p);
4044 return 0; /* Keep picky compilers happy */
4047 /* The function proper */
4050 readconf_retries(void)
4052 retry_config **chain = &retries;
4056 while ((p = get_config_line()))
4058 retry_rule **rchain;
4062 next = store_get(sizeof(retry_config), FALSE);
4065 chain = &(next->next);
4066 next->basic_errno = next->more_errno = 0;
4067 next->senders = NULL;
4069 rchain = &(next->rules);
4071 next->pattern = string_dequote(&p);
4072 Uskip_whitespace(&p);
4074 while (mac_isgraph(*p)) p++;
4075 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4076 "missing error type in retry rule");
4078 /* Test error names for things we understand. */
4080 if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4081 &next->more_errno)))
4082 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4084 /* There may be an optional address list of senders to be used as another
4085 constraint on the rule. This was added later, so the syntax is a bit of a
4086 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4089 Uskip_whitespace(&p);
4090 if (Ustrncmp(p, "senders", 7) == 0)
4093 Uskip_whitespace(&p);
4094 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4095 "\"=\" expected after \"senders\" in retry rule");
4096 Uskip_whitespace(&p);
4097 next->senders = string_dequote(&p);
4100 /* Now the retry rules. Keep the maximum timeout encountered. */
4102 Uskip_whitespace(&p);
4106 retry_rule *rule = store_get(sizeof(retry_rule), FALSE);
4108 rchain = &(rule->next);
4110 rule->rule = toupper(*p++);
4111 rule->timeout = retry_arg(&p, 0);
4112 if (rule->timeout > retry_maximum_timeout)
4113 retry_maximum_timeout = rule->timeout;
4117 case 'F': /* Fixed interval */
4118 rule->p1 = retry_arg(&p, 0);
4121 case 'G': /* Geometrically increasing intervals */
4122 case 'H': /* Ditto, but with randomness */
4123 rule->p1 = retry_arg(&p, 0);
4124 rule->p2 = retry_arg(&p, 1);
4128 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4132 if (rule->timeout <= 0 || rule->p1 <= 0 ||
4133 (rule->rule != 'F' && rule->p2 < 1000))
4134 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4135 "bad parameters for retry rule");
4137 if (Uskip_whitespace(&p) == ';')
4140 Uskip_whitespace(&p);
4143 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4150 /*************************************************
4151 * Initialize authenticators *
4152 *************************************************/
4154 /* Read the authenticators section of the configuration file.
4163 #ifndef DISABLE_PIPE_CONNECT
4167 readconf_driver_init(US"authenticator",
4168 (driver_instance **)(&auths), /* chain anchor */
4169 (driver_info *)auths_available, /* available drivers */
4170 sizeof(auth_info), /* size of info block */
4171 &auth_defaults, /* default values for generic options */
4172 sizeof(auth_instance), /* size of instance block */
4173 optionlist_auths, /* generic options */
4174 optionlist_auths_size);
4176 for (auth_instance * au = auths; au; au = au->next)
4178 if (!au->public_name)
4179 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4180 "the %s authenticator", au->name);
4182 for (auth_instance * bu = au->next; bu; bu = bu->next)
4183 if (strcmpic(au->public_name, bu->public_name) == 0)
4184 if ( au->client && bu->client
4185 || au->server && bu->server)
4186 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4187 "(%s and %s) have the same public name (%s)",
4188 au->client && bu->client ? US"client" : US"server",
4189 au->name, bu->name, au->public_name);
4190 #ifndef DISABLE_PIPE_CONNECT
4194 #ifndef DISABLE_PIPE_CONNECT
4195 f.smtp_in_early_pipe_no_auth = nauths > 16;
4202 /*************************************************
4203 * Read ACL information *
4204 *************************************************/
4206 /* If this run of Exim is not doing something that involves receiving a
4207 message, we can just skip over the ACL information. No need to parse it.
4209 First, we have a function for acl_read() to call back to get the next line. We
4210 need to remember the line we passed, because at the end it will contain the
4211 name of the next ACL. */
4213 static uschar *acl_line;
4218 acl_line = get_config_line();
4223 /* Now the main function:
4234 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4237 acl_line = get_config_line();
4241 uschar name[EXIM_DRIVERNAME_MAX];
4245 p = readconf_readname(name, sizeof(name), acl_line);
4246 if (isupper(*name) && *p == '=')
4248 if (!macro_read_assignment(acl_line)) exim_exit(EXIT_FAILURE);
4249 acl_line = get_config_line();
4253 if (*p != ':' || name[0] == 0)
4254 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4256 node = store_get_perm(sizeof(tree_node) + Ustrlen(name), is_tainted(name));
4257 Ustrcpy(node->name, name);
4258 if (!tree_insertnode(&acl_anchor, node))
4259 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4260 "there are two ACLs called \"%s\"", name);
4262 node->data.ptr = acl_read(acl_callback, &error);
4264 if (node->data.ptr == NULL && error != NULL)
4265 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4271 /*************************************************
4272 * Read configuration for local_scan() *
4273 *************************************************/
4275 /* This function is called after "begin local_scan" is encountered in the
4276 configuration file. If the local_scan() function allows for configuration
4277 options, we can process them. Otherwise, we expire in a panic.
4284 local_scan_init(void)
4286 #ifndef LOCAL_SCAN_HAS_OPTIONS
4287 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4288 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4292 while ((p = get_config_line()))
4293 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4294 NULL, US"local_scan option \"%s\" unknown");
4300 /*************************************************
4301 * Read rest of configuration (after main) *
4302 *************************************************/
4304 /* This function reads the rest of the runtime configuration, after the main
4305 configuration. It is called only when actually needed. Each subsequent section
4306 of the configuration starts with a line of the form
4310 where the name is "routers", "transports", etc. A section is terminated by
4311 hitting the next "begin" line, and the next name is left in next_section.
4312 Because it may confuse people as to whether the names are singular or plural,
4313 we add "s" if it's missing. There is always enough room in next_section for
4314 this. This function is basically just a switch.
4320 static uschar *section_list[] = {
4334 while(next_section[0] != 0)
4338 int last = nelem(section_list);
4340 int n = Ustrlen(next_section);
4342 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, US"s");
4346 int c = strcmpic(next_section, section_list[mid]);
4348 if (c > 0) first = mid + 1; else last = mid;
4350 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4351 "\"%.*s\" is not a known configuration section name", n, next_section);
4352 mid = (last + first)/2;
4356 if (((had ^= bit) & bit) == 0)
4357 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4358 "\"%.*s\" section is repeated in the configuration file", n,
4363 case 0: readconf_acl(); break;
4364 case 1: auths_init(); break;
4365 case 2: local_scan_init(); break;
4366 case 3: readconf_retries(); break;
4367 case 4: readconf_rewrites(); break;
4368 case 5: route_init(); break;
4369 case 6: transport_init(); break;
4373 (void)fclose(config_file);
4376 /* Init the storage for the pre-parsed config lines */
4378 readconf_save_config(const uschar *s)
4380 save_config_line(string_sprintf("# Exim Configuration (%s)",
4381 f.running_in_test_harness ? US"X" : s));
4385 save_config_position(const uschar *file, int line)
4387 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4390 /* Append a pre-parsed logical line to the config lines store,
4391 this operates on a global (static) list that holds all the pre-parsed
4392 config lines, we do no further processing here, output formatting and
4393 honouring of <hide> or macros will be done during output */
4396 save_config_line(const uschar* line)
4398 static config_line_item *current;
4399 config_line_item *next;
4401 next = (config_line_item*) store_get(sizeof(config_line_item), FALSE);
4402 next->line = string_copy(line);
4405 if (!config_lines) config_lines = next;
4406 else current->next = next;
4411 /* List the parsed config lines, care about nice formatting and
4412 hide the <hide> values unless we're the admin user */
4414 print_config(BOOL admin, BOOL terse)
4416 const int TS = terse ? 0 : 2;
4420 for (const config_line_item * i = config_lines; i; i = i->next)
4422 uschar * current, * p;
4424 if (r) store_reset(r);
4427 /* skip over to the first non-space */
4428 for (current = string_copy(i->line); *current && isspace(*current); ++current)
4434 /* Collapse runs of spaces. We stop this if we encounter one of the
4435 following characters: "'$, as this may indicate careful formatting */
4437 for (p = current; *p; p++) if (isspace(*p))
4440 if (*p != ' ') *p = ' ';
4442 for (next = p; isspace(*next); ++next)
4446 memmove(p+1, next, Ustrlen(next)+1);
4448 if (*next == '"' || *next == '\'' || *next == '$')
4453 if (current[0] == '#')
4456 /* begin lines are left aligned */
4457 else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4459 if (!terse) puts("");
4464 /* router/acl/transport block names */
4465 else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4467 if (!terse) puts("");
4468 printf("%*s%s\n", TS, "", current);
4472 /* hidden lines (all MACROS or lines prefixed with "hide") */
4474 && ( isupper(*current)
4475 || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4479 if ((p = Ustrchr(current, '=')))
4482 printf("%*s%s= %s\n", indent, "", current, CCS hidden);
4484 /* e.g.: hide split_spool_directory */
4486 printf("%*s\n", indent, CCS hidden);
4490 /* rest is public */
4491 printf("%*s%s\n", indent, "", current);
4493 if (r) store_reset(r);
4496 #endif /*!MACRO_PREDEF*/
4499 /* End of readconf.c */