projects / exim.git / blob
? search:


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