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