1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
6 /* See the file NOTICE for conditions of use and distribution. */
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. */
15 # include "macro_predef.h"
18 static uschar * syslog_facility_str;
19 static void fn_smtp_receive_timeout(const uschar *, const uschar *);
21 /*************************************************
22 * Main configuration options *
23 *************************************************/
25 /* The list of options that can be set in the main configuration file. This
26 must be in alphabetic order because it is searched by binary chop. */
28 static optionlist optionlist_config[] = {
29 { "*set_exim_group", opt_bool|opt_hidden, &exim_gid_set },
30 { "*set_exim_user", opt_bool|opt_hidden, &exim_uid_set },
31 { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
32 { "*set_system_filter_user", opt_bool|opt_hidden, &system_filter_uid_set },
33 { "accept_8bitmime", opt_bool, &accept_8bitmime },
34 { "acl_not_smtp", opt_stringptr, &acl_not_smtp },
35 #ifdef WITH_CONTENT_SCAN
36 { "acl_not_smtp_mime", opt_stringptr, &acl_not_smtp_mime },
38 { "acl_not_smtp_start", opt_stringptr, &acl_not_smtp_start },
39 { "acl_smtp_auth", opt_stringptr, &acl_smtp_auth },
40 { "acl_smtp_connect", opt_stringptr, &acl_smtp_connect },
41 { "acl_smtp_data", opt_stringptr, &acl_smtp_data },
43 { "acl_smtp_data_prdr", opt_stringptr, &acl_smtp_data_prdr },
46 { "acl_smtp_dkim", opt_stringptr, &acl_smtp_dkim },
48 { "acl_smtp_etrn", opt_stringptr, &acl_smtp_etrn },
49 { "acl_smtp_expn", opt_stringptr, &acl_smtp_expn },
50 { "acl_smtp_helo", opt_stringptr, &acl_smtp_helo },
51 { "acl_smtp_mail", opt_stringptr, &acl_smtp_mail },
52 { "acl_smtp_mailauth", opt_stringptr, &acl_smtp_mailauth },
53 #ifdef WITH_CONTENT_SCAN
54 { "acl_smtp_mime", opt_stringptr, &acl_smtp_mime },
56 { "acl_smtp_notquit", opt_stringptr, &acl_smtp_notquit },
57 { "acl_smtp_predata", opt_stringptr, &acl_smtp_predata },
58 { "acl_smtp_quit", opt_stringptr, &acl_smtp_quit },
59 { "acl_smtp_rcpt", opt_stringptr, &acl_smtp_rcpt },
61 { "acl_smtp_starttls", opt_stringptr, &acl_smtp_starttls },
63 { "acl_smtp_vrfy", opt_stringptr, &acl_smtp_vrfy },
64 { "add_environment", opt_stringptr, &add_environment },
65 { "admin_groups", opt_gidlist, &admin_groups },
66 { "allow_domain_literals", opt_bool, &allow_domain_literals },
67 { "allow_mx_to_ip", opt_bool, &allow_mx_to_ip },
68 { "allow_utf8_domains", opt_bool, &allow_utf8_domains },
69 { "auth_advertise_hosts", opt_stringptr, &auth_advertise_hosts },
70 { "auto_thaw", opt_time, &auto_thaw },
71 #ifdef WITH_CONTENT_SCAN
72 { "av_scanner", opt_stringptr, &av_scanner },
74 { "bi_command", opt_stringptr, &bi_command },
75 #ifdef EXPERIMENTAL_BRIGHTMAIL
76 { "bmi_config_file", opt_stringptr, &bmi_config_file },
78 { "bounce_message_file", opt_stringptr, &bounce_message_file },
79 { "bounce_message_text", opt_stringptr, &bounce_message_text },
80 { "bounce_return_body", opt_bool, &bounce_return_body },
81 { "bounce_return_linesize_limit", opt_mkint, &bounce_return_linesize_limit },
82 { "bounce_return_message", opt_bool, &bounce_return_message },
83 { "bounce_return_size_limit", opt_mkint, &bounce_return_size_limit },
84 { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
85 { "callout_domain_negative_expire", opt_time, &callout_cache_domain_negative_expire },
86 { "callout_domain_positive_expire", opt_time, &callout_cache_domain_positive_expire },
87 { "callout_negative_expire", opt_time, &callout_cache_negative_expire },
88 { "callout_positive_expire", opt_time, &callout_cache_positive_expire },
89 { "callout_random_local_part",opt_stringptr, &callout_random_local_part },
90 { "check_log_inodes", opt_int, &check_log_inodes },
91 { "check_log_space", opt_Kint, &check_log_space },
92 { "check_rfc2047_length", opt_bool, &check_rfc2047_length },
93 { "check_spool_inodes", opt_int, &check_spool_inodes },
94 { "check_spool_space", opt_Kint, &check_spool_space },
95 { "chunking_advertise_hosts", opt_stringptr, &chunking_advertise_hosts },
96 { "commandline_checks_require_admin", opt_bool,&commandline_checks_require_admin },
97 { "daemon_smtp_port", opt_stringptr|opt_hidden, &daemon_smtp_port },
98 { "daemon_smtp_ports", opt_stringptr, &daemon_smtp_port },
99 { "daemon_startup_retries", opt_int, &daemon_startup_retries },
100 { "daemon_startup_sleep", opt_time, &daemon_startup_sleep },
101 #ifdef EXPERIMENTAL_DCC
102 { "dcc_direct_add_header", opt_bool, &dcc_direct_add_header },
103 { "dccifd_address", opt_stringptr, &dccifd_address },
104 { "dccifd_options", opt_stringptr, &dccifd_options },
106 { "debug_store", opt_bool, &debug_store },
107 { "delay_warning", opt_timelist, &delay_warning },
108 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
109 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
110 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
111 { "delivery_date_remove", opt_bool, &delivery_date_remove },
112 #ifdef ENABLE_DISABLE_FSYNC
113 { "disable_fsync", opt_bool, &disable_fsync },
115 { "disable_ipv6", opt_bool, &disable_ipv6 },
117 { "dkim_verify_signers", opt_stringptr, &dkim_verify_signers },
119 #ifdef EXPERIMENTAL_DMARC
120 { "dmarc_forensic_sender", opt_stringptr, &dmarc_forensic_sender },
121 { "dmarc_history_file", opt_stringptr, &dmarc_history_file },
122 { "dmarc_tld_file", opt_stringptr, &dmarc_tld_file },
124 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
125 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
126 { "dns_csa_search_limit", opt_int, &dns_csa_search_limit },
127 { "dns_csa_use_reverse", opt_bool, &dns_csa_use_reverse },
128 { "dns_dnssec_ok", opt_int, &dns_dnssec_ok },
129 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
130 { "dns_retrans", opt_time, &dns_retrans },
131 { "dns_retry", opt_int, &dns_retry },
132 { "dns_trust_aa", opt_stringptr, &dns_trust_aa },
133 { "dns_use_edns0", opt_int, &dns_use_edns0 },
134 /* This option is now a no-op, retained for compatibility */
135 { "drop_cr", opt_bool, &drop_cr },
136 /*********************************************************/
137 { "dsn_advertise_hosts", opt_stringptr, &dsn_advertise_hosts },
138 { "dsn_from", opt_stringptr, &dsn_from },
139 { "envelope_to_remove", opt_bool, &envelope_to_remove },
140 { "errors_copy", opt_stringptr, &errors_copy },
141 { "errors_reply_to", opt_stringptr, &errors_reply_to },
142 #ifndef DISABLE_EVENT
143 { "event_action", opt_stringptr, &event_action },
145 { "exim_group", opt_gid, &exim_gid },
146 { "exim_path", opt_stringptr, &exim_path },
147 { "exim_user", opt_uid, &exim_uid },
148 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
149 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
150 { "finduser_retries", opt_int, &finduser_retries },
151 { "freeze_tell", opt_stringptr, &freeze_tell },
152 { "gecos_name", opt_stringptr, &gecos_name },
153 { "gecos_pattern", opt_stringptr, &gecos_pattern },
155 { "gnutls_allow_auto_pkcs11", opt_bool, &gnutls_allow_auto_pkcs11 },
156 { "gnutls_compat_mode", opt_bool, &gnutls_compat_mode },
158 { "header_line_maxsize", opt_int, &header_line_maxsize },
159 { "header_maxsize", opt_int, &header_maxsize },
160 { "headers_charset", opt_stringptr, &headers_charset },
161 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
162 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
163 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
164 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
165 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
166 { "hold_domains", opt_stringptr, &hold_domains },
167 { "host_lookup", opt_stringptr, &host_lookup },
168 { "host_lookup_order", opt_stringptr, &host_lookup_order },
169 { "host_reject_connection", opt_stringptr, &host_reject_connection },
170 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
172 { "hosts_proxy", opt_stringptr, &hosts_proxy },
174 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
176 { "ibase_servers", opt_stringptr, &ibase_servers },
178 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
179 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
180 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
181 { "keep_environment", opt_stringptr, &keep_environment },
182 { "keep_malformed", opt_time, &keep_malformed },
184 { "ldap_ca_cert_dir", opt_stringptr, &eldap_ca_cert_dir },
185 { "ldap_ca_cert_file", opt_stringptr, &eldap_ca_cert_file },
186 { "ldap_cert_file", opt_stringptr, &eldap_cert_file },
187 { "ldap_cert_key", opt_stringptr, &eldap_cert_key },
188 { "ldap_cipher_suite", opt_stringptr, &eldap_cipher_suite },
189 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
190 { "ldap_require_cert", opt_stringptr, &eldap_require_cert },
191 { "ldap_start_tls", opt_bool, &eldap_start_tls },
192 { "ldap_version", opt_int, &eldap_version },
194 { "local_from_check", opt_bool, &local_from_check },
195 { "local_from_prefix", opt_stringptr, &local_from_prefix },
196 { "local_from_suffix", opt_stringptr, &local_from_suffix },
197 { "local_interfaces", opt_stringptr, &local_interfaces },
198 { "local_scan_timeout", opt_time, &local_scan_timeout },
199 { "local_sender_retain", opt_bool, &local_sender_retain },
200 { "localhost_number", opt_stringptr, &host_number_string },
201 { "log_file_path", opt_stringptr, &log_file_path },
202 { "log_selector", opt_stringptr, &log_selector_string },
203 { "log_timezone", opt_bool, &log_timezone },
204 { "lookup_open_max", opt_int, &lookup_open_max },
205 { "max_username_length", opt_int, &max_username_length },
206 { "message_body_newlines", opt_bool, &message_body_newlines },
207 { "message_body_visible", opt_mkint, &message_body_visible },
208 { "message_id_header_domain", opt_stringptr, &message_id_domain },
209 { "message_id_header_text", opt_stringptr, &message_id_text },
210 { "message_logs", opt_bool, &message_logs },
211 { "message_size_limit", opt_stringptr, &message_size_limit },
212 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
213 { "move_frozen_messages", opt_bool, &move_frozen_messages },
215 { "mua_wrapper", opt_bool, &mua_wrapper },
217 { "mysql_servers", opt_stringptr, &mysql_servers },
219 { "never_users", opt_uidlist, &never_users },
221 { "openssl_options", opt_stringptr, &openssl_options },
224 { "oracle_servers", opt_stringptr, &oracle_servers },
226 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
228 { "perl_at_start", opt_bool, &opt_perl_at_start },
229 { "perl_startup", opt_stringptr, &opt_perl_startup },
230 { "perl_taintmode", opt_bool, &opt_perl_taintmode },
233 { "pgsql_servers", opt_stringptr, &pgsql_servers },
235 { "pid_file_path", opt_stringptr, &pid_file_path },
236 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
238 { "prdr_enable", opt_bool, &prdr_enable },
240 { "preserve_message_logs", opt_bool, &preserve_message_logs },
241 { "primary_hostname", opt_stringptr, &primary_hostname },
242 { "print_topbitchars", opt_bool, &print_topbitchars },
243 { "process_log_path", opt_stringptr, &process_log_path },
244 { "prod_requires_admin", opt_bool, &prod_requires_admin },
245 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
246 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
247 { "queue_domains", opt_stringptr, &queue_domains },
248 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
249 { "queue_only", opt_bool, &queue_only },
250 { "queue_only_file", opt_stringptr, &queue_only_file },
251 { "queue_only_load", opt_fixed, &queue_only_load },
252 { "queue_only_load_latch", opt_bool, &queue_only_load_latch },
253 { "queue_only_override", opt_bool, &queue_only_override },
254 { "queue_run_in_order", opt_bool, &queue_run_in_order },
255 { "queue_run_max", opt_stringptr, &queue_run_max },
256 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
257 { "receive_timeout", opt_time, &receive_timeout },
258 { "received_header_text", opt_stringptr, &received_header_text },
259 { "received_headers_max", opt_int, &received_headers_max },
260 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
261 { "recipients_max", opt_int, &recipients_max },
262 { "recipients_max_reject", opt_bool, &recipients_max_reject },
264 { "redis_servers", opt_stringptr, &redis_servers },
266 { "remote_max_parallel", opt_int, &remote_max_parallel },
267 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
268 { "retry_data_expire", opt_time, &retry_data_expire },
269 { "retry_interval_max", opt_time, &retry_interval_max },
270 { "return_path_remove", opt_bool, &return_path_remove },
271 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
272 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
273 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
274 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
275 { "slow_lookup_log", opt_int, &slow_lookup_log },
276 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
277 { "smtp_accept_max", opt_int, &smtp_accept_max },
278 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
279 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
280 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
281 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
282 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
283 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
284 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
285 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
286 { "smtp_banner", opt_stringptr, &smtp_banner },
287 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
288 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
289 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
290 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
291 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
292 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
293 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
294 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
295 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
296 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
297 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
298 { "smtp_receive_timeout", opt_func, &fn_smtp_receive_timeout },
299 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
300 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
302 { "smtputf8_advertise_hosts", opt_stringptr, &smtputf8_advertise_hosts },
304 #ifdef WITH_CONTENT_SCAN
305 { "spamd_address", opt_stringptr, &spamd_address },
307 #ifdef EXPERIMENTAL_SPF
308 { "spf_guess", opt_stringptr, &spf_guess },
310 { "split_spool_directory", opt_bool, &split_spool_directory },
311 { "spool_directory", opt_stringptr, &spool_directory },
312 { "spool_wireformat", opt_bool, &spool_wireformat },
314 { "sqlite_lock_timeout", opt_int, &sqlite_lock_timeout },
316 #ifdef EXPERIMENTAL_SRS
317 { "srs_config", opt_stringptr, &srs_config },
318 { "srs_hashlength", opt_int, &srs_hashlength },
319 { "srs_hashmin", opt_int, &srs_hashmin },
320 { "srs_maxage", opt_int, &srs_maxage },
321 { "srs_secrets", opt_stringptr, &srs_secrets },
322 { "srs_usehash", opt_bool, &srs_usehash },
323 { "srs_usetimestamp", opt_bool, &srs_usetimestamp },
325 { "strict_acl_vars", opt_bool, &strict_acl_vars },
326 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
327 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
328 { "syslog_duplication", opt_bool, &syslog_duplication },
329 { "syslog_facility", opt_stringptr, &syslog_facility_str },
330 { "syslog_pid", opt_bool, &syslog_pid },
331 { "syslog_processname", opt_stringptr, &syslog_processname },
332 { "syslog_timestamp", opt_bool, &syslog_timestamp },
333 { "system_filter", opt_stringptr, &system_filter },
334 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
335 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
336 { "system_filter_group", opt_gid, &system_filter_gid },
337 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
338 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
339 { "system_filter_user", opt_uid, &system_filter_uid },
340 { "tcp_nodelay", opt_bool, &tcp_nodelay },
341 #ifdef USE_TCP_WRAPPERS
342 { "tcp_wrappers_daemon_name", opt_stringptr, &tcp_wrappers_daemon_name },
344 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
345 { "timezone", opt_stringptr, &timezone_string },
346 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
348 { "tls_certificate", opt_stringptr, &tls_certificate },
349 { "tls_crl", opt_stringptr, &tls_crl },
350 { "tls_dh_max_bits", opt_int, &tls_dh_max_bits },
351 { "tls_dhparam", opt_stringptr, &tls_dhparam },
352 { "tls_eccurve", opt_stringptr, &tls_eccurve },
353 # ifndef DISABLE_OCSP
354 { "tls_ocsp_file", opt_stringptr, &tls_ocsp_file },
356 { "tls_on_connect_ports", opt_stringptr, &tls_in.on_connect_ports },
357 { "tls_privatekey", opt_stringptr, &tls_privatekey },
358 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
359 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
360 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
361 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
362 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
364 { "trusted_groups", opt_gidlist, &trusted_groups },
365 { "trusted_users", opt_uidlist, &trusted_users },
366 { "unknown_login", opt_stringptr, &unknown_login },
367 { "unknown_username", opt_stringptr, &unknown_username },
368 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
369 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
370 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
371 { "warn_message_file", opt_stringptr, &warn_message_file },
372 { "write_rejectlog", opt_bool, &write_rejectlog }
375 static int optionlist_config_size = nelem(optionlist_config);
380 static void fn_smtp_receive_timeout(const uschar * name, const uschar * str) {/*Dummy*/}
385 options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN", NULL);
391 struct auth_info * ai;
394 options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
396 for (ai = auths_available; ai->driver_name[0]; ai++)
398 spf(buf, sizeof(buf), "_DRIVER_AUTHENTICATOR_%T", ai->driver_name);
399 builtin_macro_create(buf);
400 options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
405 #else /*!MACRO_PREDEF*/
407 extern char **environ;
409 static void save_config_line(const uschar* line);
410 static void save_config_position(const uschar *file, int line);
411 static void print_config(BOOL admin, BOOL terse);
414 #define CSTATE_STACK_SIZE 10
416 const uschar *config_directory = NULL;
419 /* Structure for chain (stack) of .included files */
421 typedef struct config_file_item {
422 struct config_file_item *next;
423 const uschar *filename;
424 const uschar *directory;
429 /* Structure for chain of configuration lines (-bP config) */
431 typedef struct config_line_item {
432 struct config_line_item *next;
436 static config_line_item* config_lines;
438 /* Structure of table of conditional words and their state transitions */
440 typedef struct cond_item {
448 /* Structure of table of syslog facility names and values */
450 typedef struct syslog_fac_item {
456 static const char * const hidden = "<value not displayable>";
458 /* Static variables */
460 static config_file_item *config_file_stack = NULL; /* For includes */
462 static uschar *syslog_facility_str = NULL;
463 static uschar next_section[24];
464 static uschar time_buffer[24];
466 /* State variables for conditional loading (.ifdef / .else / .endif) */
468 static int cstate = 0;
469 static int cstate_stack_ptr = -1;
470 static int cstate_stack[CSTATE_STACK_SIZE];
472 /* Table of state transitions for handling conditional inclusions. There are
473 four possible state transitions:
477 .elifdef true (or .else)
480 .endif just causes the previous cstate to be popped off the stack */
482 static int next_cstate[3][4] =
484 /* State 0: reading from file, or reading until next .else or .endif */
486 /* State 1: condition failed, skipping until next .else or .endif */
488 /* State 2: skipping until .endif */
492 /* Table of conditionals and the states to set. For each name, there are four
493 values: the length of the name (to save computing it each time), the state to
494 set if a macro was found in the line, the state to set if a macro was not found
495 in the line, and a stack manipulation setting which is:
497 -1 pull state value off the stack
498 0 don't alter the stack
499 +1 push value onto stack, before setting new state
502 static cond_item cond_list[] = {
503 { US"ifdef", 5, 0, 1, 1 },
504 { US"ifndef", 6, 1, 0, 1 },
505 { US"elifdef", 7, 2, 3, 0 },
506 { US"elifndef", 8, 3, 2, 0 },
507 { US"else", 4, 2, 2, 0 },
508 { US"endif", 5, 0, 0, -1 }
511 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
513 /* Table of syslog facility names and their values */
515 static syslog_fac_item syslog_list[] = {
516 { US"mail", LOG_MAIL },
517 { US"user", LOG_USER },
518 { US"news", LOG_NEWS },
519 { US"uucp", LOG_UUCP },
520 { US"local0", LOG_LOCAL0 },
521 { US"local1", LOG_LOCAL1 },
522 { US"local2", LOG_LOCAL2 },
523 { US"local3", LOG_LOCAL3 },
524 { US"local4", LOG_LOCAL4 },
525 { US"local5", LOG_LOCAL5 },
526 { US"local6", LOG_LOCAL6 },
527 { US"local7", LOG_LOCAL7 },
528 { US"daemon", LOG_DAEMON }
531 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
536 /*************************************************
537 * Find the name of an option *
538 *************************************************/
540 /* This function is to aid debugging. Various functions take arguments that are
541 pointer variables in the options table or in option tables for various drivers.
542 For debugging output, it is useful to be able to find the name of the option
543 which is currently being processed. This function finds it, if it exists, by
544 searching the table(s).
546 Arguments: a value that is presumed to be in the table above
547 Returns: the option name, or an empty string
551 readconf_find_option(void *p)
555 transport_instance *t;
557 for (i = 0; i < nelem(optionlist_config); i++)
558 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
560 for (r = routers; r; r = r->next)
562 router_info *ri = r->info;
563 for (i = 0; i < *ri->options_count; i++)
565 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
566 if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
567 return US ri->options[i].name;
571 for (t = transports; t; t = t->next)
573 transport_info *ti = t->info;
574 for (i = 0; i < *ti->options_count; i++)
576 optionlist * op = &ti->options[i];
577 if ((op->type & opt_mask) != opt_stringptr) continue;
578 if (p == ( op->type & opt_public
580 : (char *)t->options_block
582 + (long int)op->value)
593 /*************************************************
594 * Deal with an assignment to a macro *
595 *************************************************/
597 /* We have a new definition; append to the list.
600 name Name of the macro. Must be in storage persistent past the call
601 val Expansion result for the macro. Ditto persistence.
605 macro_create(const uschar * name, const uschar * val, BOOL command_line)
607 unsigned namelen = Ustrlen(name);
608 macro_item * m = store_get(sizeof(macro_item));
610 /* fprintf(stderr, "%s: '%s' '%s'\n", __FUNCTION__, name, val); */
612 m->command_line = command_line;
613 m->namelen = namelen;
615 m->replacement = val;
622 /* This function is called when a line that starts with an upper case letter is
623 encountered. The argument "line" should contain a complete logical line, and
624 start with the first letter of the macro name. The macro name and the
625 replacement text are extracted and stored. Redefinition of existing,
626 non-command line, macros is permitted using '==' instead of '='.
629 s points to the start of the logical line
635 read_macro_assignment(uschar *s)
642 while (isalnum(*s) || *s == '_')
644 if (namelen >= sizeof(name) - 1)
645 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
646 "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
647 name[namelen++] = *s++;
651 while (isspace(*s)) s++;
653 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
660 while (isspace(*s)) s++;
662 /* If an existing macro of the same name was defined on the command line, we
663 just skip this definition. It's an error to attempt to redefine a macro without
664 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
665 It is also an error to define a macro whose name begins with the name of a
666 previously defined macro. This is the requirement that make using a tree
667 for macros hard; we must check all macros for the substring. Perhaps a
668 sorted list, and a bsearch, would work?
669 Note: it is documented that the other way round works. */
671 for (m = macros; m; m = m->next)
673 if (Ustrcmp(m->name, name) == 0)
675 if (!m->command_line && !redef)
676 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
677 "defined (use \"==\" if you want to redefine it", name);
681 if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
682 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
683 "a macro because previously defined macro \"%s\" is a substring",
686 /* We cannot have this test, because it is documented that a substring
687 macro is permitted (there is even an example).
689 * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
690 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
691 * "a macro because it is a substring of previously defined macro \"%s\"",
696 /* Check for an overriding command-line definition. */
698 if (m && m->command_line) return;
700 /* Redefinition must refer to an existing macro. */
704 m->replacement = string_copy(s);
706 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
709 /* We have a new definition. */
711 (void) macro_create(string_copy(name), string_copy(s), FALSE);
718 /*************************************************
719 * Read configuration line *
720 *************************************************/
722 /* A logical line of text is read from the configuration file into the big
723 buffer, taking account of macros, .includes, and continuations. The size of
724 big_buffer is increased if necessary. The count of configuration lines is
725 maintained. Physical input lines starting with # (ignoring leading white space,
726 and after macro replacement) and empty logical lines are always ignored.
727 Leading and trailing spaces are removed.
729 If we hit a line of the form "begin xxxx", the xxxx is placed in the
730 next_section vector, and the function returns NULL, indicating the end of a
731 configuration section. On end-of-file, NULL is returned with next_section
736 Returns: a pointer to the first non-blank in the line,
737 or NULL if eof or end of section is reached
741 get_config_line(void)
743 int startoffset = 0; /* To first non-blank char in logical line */
744 int len = 0; /* Of logical line so far */
750 /* Loop for handling continuation lines, skipping comments, and dealing with
755 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
757 if (config_file_stack != NULL) /* EOF inside .include */
759 (void)fclose(config_file);
760 config_file = config_file_stack->file;
761 config_filename = config_file_stack->filename;
762 config_directory = config_file_stack->directory;
763 config_lineno = config_file_stack->lineno;
764 config_file_stack = config_file_stack->next;
766 save_config_position(config_filename, config_lineno);
770 /* EOF at top level */
772 if (cstate_stack_ptr >= 0)
773 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
774 "Unexpected end of configuration file: .endif missing");
776 if (len != 0) break; /* EOF after continuation */
777 next_section[0] = 0; /* EOF at start of logical line */
782 newlen = len + Ustrlen(big_buffer + len);
784 if (config_lines && config_lineno == 1)
785 save_config_position(config_filename, config_lineno);
787 /* Handle pathologically long physical lines - yes, it did happen - by
788 extending big_buffer at this point. The code also copes with very long
791 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
794 big_buffer_size += BIG_BUFFER_SIZE;
795 newbuffer = store_malloc(big_buffer_size);
797 /* This use of strcpy is OK because we know that the string in the old
798 buffer is shorter than the new buffer. */
800 Ustrcpy(newbuffer, big_buffer);
801 store_free(big_buffer);
802 big_buffer = newbuffer;
803 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
805 newlen += Ustrlen(big_buffer + newlen);
808 /* Find the true start of the physical line - leading spaces are always
811 ss = big_buffer + len;
812 while (isspace(*ss)) ss++;
814 /* Process the physical line for macros. If this is the start of the logical
815 line, skip over initial text at the start of the line if it starts with an
816 upper case character followed by a sequence of name characters and an equals
817 sign, because that is the definition of a new macro, and we don't do
818 replacement therein. */
821 if (len == 0 && isupper(*s))
823 while (isalnum(*s) || *s == '_') s++;
824 while (isspace(*s)) s++;
825 if (*s != '=') s = ss; /* Not a macro definition */
828 /* For each defined macro, scan the line (from after XXX= if present),
829 replacing all occurrences of the macro. */
832 for (m = macros; m; m = m->next)
837 while ((p = Ustrstr(t, m->name)) != NULL)
840 int replen = Ustrlen(m->replacement);
842 /* fprintf(stderr, "%s: matched '%s' in '%s'\n", __FUNCTION__, m->name, t); */
843 /* Expand the buffer if necessary */
845 while (newlen - m->namelen + replen + 1 > big_buffer_size)
847 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
848 uschar *newbuffer = store_malloc(newsize);
849 memcpy(newbuffer, big_buffer, newlen + 1);
850 p = newbuffer + (p - big_buffer);
851 s = newbuffer + (s - big_buffer);
852 ss = newbuffer + (ss - big_buffer);
853 t = newbuffer + (t - big_buffer);
854 big_buffer_size = newsize;
855 store_free(big_buffer);
856 big_buffer = newbuffer;
859 /* Shuffle the remaining characters up or down in the buffer before
860 copying in the replacement text. Don't rescan the replacement for this
864 if ((moveby = replen - m->namelen) != 0)
866 memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
869 Ustrncpy(p, m->replacement, replen);
875 /* An empty macro replacement at the start of a line could mean that ss no
876 longer points to the first non-blank character. */
878 while (isspace(*ss)) ss++;
880 /* Check for comment lines - these are physical lines. */
882 if (*ss == '#') continue;
884 /* Handle conditionals, which are also applied to physical lines. Conditions
885 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
886 expansion occured on the rest of the line. A preliminary test for the leading
887 '.' saves effort on most lines. */
893 /* Search the list of conditional directives */
895 for (i = 0; i < cond_list_size; i++)
898 cond_item *c = cond_list+i;
899 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
901 /* The following character must be white space or end of string */
903 n = ss[1 + c->namelen];
904 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
906 /* .ifdef and .ifndef push the current state onto the stack, then set
907 a new one from the table. Stack overflow is an error */
911 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
912 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
913 ".%s nested too deeply", c->name);
914 cstate_stack[++cstate_stack_ptr] = cstate;
915 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
918 /* For any of the others, stack underflow is an error. The next state
919 comes either from the stack (.endif) or from the table. */
923 if (cstate_stack_ptr < 0)
924 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
925 ".%s without matching .ifdef", c->name);
926 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
927 next_cstate[cstate][macro_found? c->action1 : c->action2];
930 /* Having dealt with a directive, break the loop */
935 /* If we have handled a conditional directive, continue with the next
936 physical line. Otherwise, fall through. */
938 if (i < cond_list_size) continue;
941 /* If the conditional state is not 0 (actively using these lines), ignore
944 if (cstate != 0) continue; /* Conditional skip */
946 /* Handle .include lines - these are also physical lines. */
948 if (Ustrncmp(ss, ".include", 8) == 0 &&
950 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
953 int include_if_exists = isspace(ss[8])? 0 : 10;
954 config_file_item *save;
957 ss += 9 + include_if_exists;
958 while (isspace(*ss)) ss++;
959 t = ss + Ustrlen(ss);
960 while (t > ss && isspace(t[-1])) t--;
961 if (*ss == '\"' && t[-1] == '\"')
968 /* We allow relative file names. For security reasons currently
969 relative names not allowed with .include_if_exists. For .include_if_exists
970 we need to check the permissions/ownership of the containing folder */
972 if (include_if_exists) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
973 "absolute path \"%s\"", ss);
978 ss = string_append(NULL, &size, &offset, 3, config_directory, "/", ss);
979 ss[offset] = '\0'; /* string_append() does not zero terminate the string! */
982 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
985 save_config_position(config_filename, config_lineno);
986 save = store_get(sizeof(config_file_item));
987 save->next = config_file_stack;
988 config_file_stack = save;
989 save->file = config_file;
990 save->filename = config_filename;
991 save->directory = config_directory;
992 save->lineno = config_lineno;
994 if (!(config_file = Ufopen(ss, "rb")))
995 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
996 "configuration file %s", ss);
998 config_filename = string_copy(ss);
999 config_directory = string_copyn(ss, CUstrrchr(ss, '/') - ss);
1004 /* If this is the start of the logical line, remember where the non-blank
1005 data starts. Otherwise shuffle down continuation lines to remove leading
1009 startoffset = ss - big_buffer;
1012 s = big_buffer + len;
1015 memmove(s, ss, (newlen - len) - (ss - s) + 1);
1020 /* Accept the new addition to the line. Remove trailing white space. */
1023 while (len > 0 && isspace(big_buffer[len-1])) len--;
1024 big_buffer[len] = 0;
1026 /* We are done if the line does not end in backslash and contains some data.
1027 Empty logical lines are ignored. For continuations, remove the backslash and
1028 go round the loop to read the continuation line. */
1032 if (big_buffer[len-1] != '\\') break; /* End of logical line */
1033 big_buffer[--len] = 0; /* Remove backslash */
1035 } /* Loop for reading multiple physical lines */
1037 /* We now have a logical line. Test for the end of a configuration section (or,
1038 more accurately, for the start of the next section). Place the name of the next
1039 section in next_section, and return NULL. If the name given is longer than
1040 next_section, truncate it. It will be unrecognized later, because all the known
1041 section names do fit. Leave space for pluralizing. */
1043 s = big_buffer + startoffset; /* First non-space character */
1046 save_config_line(s);
1048 if (strncmpic(s, US"begin ", 6) == 0)
1051 while (isspace(*s)) s++;
1052 if (big_buffer + len - s > sizeof(next_section) - 2)
1053 s[sizeof(next_section) - 2] = 0;
1054 Ustrcpy(next_section, s);
1058 /* Return the first non-blank character. */
1065 /*************************************************
1067 *************************************************/
1069 /* The yield is the pointer to the next uschar. Names longer than the
1070 output space are silently truncated. This function is also used from acl.c when
1074 name where to put the name
1078 Returns: new input pointer
1082 readconf_readname(uschar *name, int len, uschar *s)
1085 while (isspace(*s)) s++;
1088 while (isalnum(*s) || *s == '_')
1090 if (p < len-1) name[p++] = *s;
1095 while (isspace(*s)) s++;
1102 /*************************************************
1103 * Read a time value *
1104 *************************************************/
1106 /* This function is also called from outside, to read argument
1107 time values. The format of a time value is:
1109 [<n>w][<n>d][<n>h][<n>m][<n>s]
1111 as long as at least one is present. If a format error is encountered,
1112 return a negative value. The value must be terminated by the given
1117 terminator required terminating character
1118 return_msec if TRUE, allow fractional seconds and return milliseconds
1120 Returns: the time value, or -1 on syntax error
1121 value is seconds if return_msec is FALSE
1122 value is milliseconds if return_msec is TRUE
1126 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1134 if (!isdigit(*s)) return -1;
1135 (void)sscanf(CCS s, "%d%n", &value, &count);
1140 case 'w': value *= 7;
1141 case 'd': value *= 24;
1142 case 'h': value *= 60;
1143 case 'm': value *= 60;
1148 if (!return_msec) return -1;
1149 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1151 if (*s++ != 's') return -1;
1152 yield += (int)(fraction * 1000.0);
1158 if (return_msec) value *= 1000;
1160 if (*s == terminator) return yield;
1162 /* Control never reaches here. */
1167 /*************************************************
1168 * Read a fixed point value *
1169 *************************************************/
1171 /* The value is returned *1000
1175 terminator required terminator
1177 Returns: the value, or -1 on error
1181 readconf_readfixed(const uschar *s, int terminator)
1185 if (!isdigit(*s)) return -1;
1186 (void)sscanf(CS s, "%d%n", &value, &count);
1188 yield = value * 1000;
1192 while (isdigit((*(++s))))
1194 yield += (*s - '0') * m;
1199 return (*s == terminator)? yield : (-1);
1204 /*************************************************
1205 * Find option in list *
1206 *************************************************/
1208 /* The lists are always in order, so binary chop can be used.
1211 name the option name to search for
1212 ol the first entry in the option list
1213 last one more than the offset of the last entry in the option list
1215 Returns: pointer to an option entry, or NULL if not found
1219 find_option(uschar *name, optionlist *ol, int last)
1222 while (last > first)
1224 int middle = (first + last)/2;
1225 int c = Ustrcmp(name, ol[middle].name);
1227 if (c == 0) return ol + middle;
1228 else if (c > 0) first = middle + 1;
1236 /*************************************************
1237 * Find a set flag in option list *
1238 *************************************************/
1240 /* Because some versions of Unix make no restrictions on the values of uids and
1241 gids (even negative ones), we cannot represent "unset" by a special value.
1242 There is therefore a separate boolean variable for each one indicating whether
1243 a value is set or not. This function returns a pointer to the boolean, given
1244 the original option name. It is a major disaster if the flag cannot be found.
1247 name the name of the uid or gid option
1248 oltop points to the start of the relevant option list
1249 last one more than the offset of the last item in the option list
1250 data_block NULL when reading main options => data values in the option
1251 list are absolute addresses; otherwise they are byte offsets
1252 in data_block (used for driver options)
1254 Returns: a pointer to the boolean flag.
1258 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1262 sprintf(CS name2, "*set_%.50s", name);
1263 ol = find_option(name2, oltop, last);
1264 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1265 "Exim internal error: missing set flag for %s", name);
1266 return (data_block == NULL)? (BOOL *)(ol->value) :
1267 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1273 /*************************************************
1274 * Output extra characters message and die *
1275 *************************************************/
1277 /* Called when an option line has junk on the end. Sometimes this is because
1278 the sysadmin thinks comments are permitted.
1281 s points to the extra characters
1282 t1..t3 strings to insert in the log message
1284 Returns: doesn't return; dies
1288 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1290 uschar *comment = US"";
1291 if (*s == '#') comment = US" (# is comment only at line start)";
1292 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1293 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1298 /*************************************************
1299 * Read rewrite information *
1300 *************************************************/
1302 /* Each line of rewrite information contains:
1304 . A complete address in the form user@domain, possibly with
1305 leading * for each part; or alternatively, a regex.
1307 . A replacement string (which will be expanded).
1309 . An optional sequence of one-letter flags, indicating which
1310 headers etc. to apply this rule to.
1312 All this is decoded and placed into a control block. The OR of the flags is
1313 maintained in a common word.
1316 p points to the string that makes up the rule
1317 existflags points to the overall flag word
1318 isglobal TRUE if reading global rewrite rules
1320 Returns: the control block for the parsed rule.
1323 static rewrite_rule *
1324 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1326 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1329 next->key = string_dequote(&p);
1331 while (isspace(*p)) p++;
1333 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1334 "missing rewrite replacement string");
1337 next->replacement = string_dequote(&p);
1339 while (*p != 0) switch (*p++)
1341 case ' ': case '\t': break;
1343 case 'q': next->flags |= rewrite_quit; break;
1344 case 'w': next->flags |= rewrite_whole; break;
1346 case 'h': next->flags |= rewrite_all_headers; break;
1347 case 's': next->flags |= rewrite_sender; break;
1348 case 'f': next->flags |= rewrite_from; break;
1349 case 't': next->flags |= rewrite_to; break;
1350 case 'c': next->flags |= rewrite_cc; break;
1351 case 'b': next->flags |= rewrite_bcc; break;
1352 case 'r': next->flags |= rewrite_replyto; break;
1354 case 'E': next->flags |= rewrite_all_envelope; break;
1355 case 'F': next->flags |= rewrite_envfrom; break;
1356 case 'T': next->flags |= rewrite_envto; break;
1358 case 'Q': next->flags |= rewrite_qualify; break;
1359 case 'R': next->flags |= rewrite_repeat; break;
1362 next->flags |= rewrite_smtp;
1363 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1364 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1365 "rewrite rule has the S flag but is not a regular expression");
1369 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1370 "unknown rewrite flag character '%c' "
1371 "(could be missing quotes round replacement item)", p[-1]);
1375 /* If no action flags are set, set all the "normal" rewrites. */
1377 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1378 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1380 /* Remember which exist, for optimization, and return the rule */
1382 *existflags |= next->flags;
1389 /*************************************************
1390 * Read global rewrite information *
1391 *************************************************/
1393 /* Each line is a single rewrite rule; it is parsed into a control block
1394 by readconf_one_rewrite(), and its flags are ORed into the global flag
1395 word rewrite_existflags. */
1398 readconf_rewrites(void)
1400 rewrite_rule **chain = &global_rewrite_rules;
1403 while ((p = get_config_line()) != NULL)
1405 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1407 chain = &(next->next);
1413 /*************************************************
1415 *************************************************/
1417 /* Strings are read into the normal store pool. As long we aren't too
1418 near the end of the current block, the string will just use what is necessary
1419 on the top of the stacking pool, because string_cat() uses the extension
1423 s the rest of the input line
1424 name the option name (for errors)
1426 Returns: pointer to the string
1430 read_string(const uschar *s, const uschar *name)
1435 if (*s != '\"') return string_copy(s);
1438 yield = string_dequote(&s);
1440 if (s == ss+1 || s[-1] != '\"')
1441 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1442 "missing quote at end of string value for %s", name);
1444 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1450 /*************************************************
1451 * Custom-handler options *
1452 *************************************************/
1454 fn_smtp_receive_timeout(const uschar * name, const uschar * str)
1457 smtp_receive_timeout_s = string_copy(str);
1460 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1461 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1462 if (smtp_receive_timeout < 0)
1463 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1468 /*************************************************
1469 * Handle option line *
1470 *************************************************/
1472 /* This function is called from several places to process a line containing the
1473 setting of an option. The first argument is the line to be decoded; it has been
1474 checked not to be empty and not to start with '#'. Trailing newlines and white
1475 space have been removed. The second argument is a pointer to the list of
1476 variable names that are to be recognized, together with their types and
1477 locations, and the third argument gives the number of entries in the list.
1479 The fourth argument is a pointer to a data block. If it is NULL, then the data
1480 values in the options list are absolute addresses. Otherwise, they are byte
1481 offsets in the data block.
1483 String option data may continue onto several lines; this function reads further
1484 data from config_file if necessary.
1486 The yield of this function is normally zero. If a string continues onto
1487 multiple lines, then the data value is permitted to be followed by a comma
1488 or a semicolon (for use in drivers) and the yield is that character.
1491 buffer contains the configuration line to be handled
1492 oltop points to the start of the relevant option list
1493 last one more than the offset of the last item in the option list
1494 data_block NULL when reading main options => data values in the option
1495 list are absolute addresses; otherwise they are byte offsets
1496 in data_block when they have opt_public set; otherwise
1497 they are byte offsets in data_block->options_block.
1498 unknown_txt format string to use in panic message for unknown option;
1499 must contain %s for option name
1500 if given as NULL, don't panic on unknown option
1502 Returns: TRUE if an option was read successfully,
1503 FALSE false for an unknown option if unknown_txt == NULL,
1504 otherwise panic and die on an unknown option
1508 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1509 void *data_block, uschar *unknown_txt)
1513 int n, count, type, value;
1517 BOOL boolvalue = TRUE;
1518 BOOL freesptr = TRUE;
1519 optionlist *ol, *ol2;
1523 uschar *inttype = US"";
1526 uschar **str_target;
1530 /* There may be leading spaces; thereafter, we expect an option name starting
1533 while (isspace(*s)) s++;
1535 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1537 /* Read the name of the option, and skip any subsequent white space. If
1538 it turns out that what we read was "hide", set the flag indicating that
1539 this is a secure option, and loop to read the next word. */
1541 for (n = 0; n < 2; n++)
1543 while (isalnum(*s) || *s == '_')
1545 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1549 while (isspace(*s)) s++;
1550 if (Ustrcmp(name, "hide") != 0) break;
1551 issecure = opt_secure;
1555 /* Deal with "no_" or "not_" here for booleans */
1557 if (Ustrncmp(name, "no_", 3) == 0)
1563 if (Ustrncmp(name, "not_", 4) == 0)
1569 /* Search the list for the given name. A non-existent name, or an option that
1570 is set twice, is a disaster. */
1572 if (!(ol = find_option(name + offset, oltop, last)))
1574 if (unknown_txt == NULL) return FALSE;
1575 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1578 if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1579 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1580 "\"%s\" option set for the second time", name);
1582 ol->type |= opt_set | issecure;
1583 type = ol->type & opt_mask;
1585 /* Types with data values must be followed by '='; the "no[t]_" prefix
1586 applies only to boolean values. */
1588 if (type < opt_bool || type > opt_bool_last)
1591 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1592 "negation prefix applied to a non-boolean option");
1594 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1595 "unexpected end of line (data missing) after %s", name);
1597 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1600 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1601 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1602 ultimately expands to one of those values. */
1604 else if (*s != 0 && (offset != 0 || *s != '='))
1605 extra_chars_error(s, US"boolean option ", name, US"");
1607 /* Skip white space after = */
1609 if (*s == '=') while (isspace((*(++s))));
1611 /* If there is a data block and the opt_public flag is not set, change
1612 the data block pointer to the private options block. */
1614 if (data_block != NULL && (ol->type & opt_public) == 0)
1615 data_block = (void *)(((driver_instance *)data_block)->options_block);
1617 /* Now get the data according to the type. */
1621 /* If a string value is not enclosed in quotes, it consists of
1622 the rest of the current line, verbatim. Otherwise, string escapes
1625 A transport is specified as a string, which is then looked up in the
1626 list of transports. A search type is specified as one of a number of
1629 A set or rewrite rules for a driver is specified as a string, which is
1630 then parsed into a suitable chain of control blocks.
1632 Uids and gids are specified as strings which are then looked up in the
1633 passwd file. Lists of uids and gids are similarly specified as colon-
1634 separated strings. */
1639 case opt_expand_uid:
1640 case opt_expand_gid:
1645 reset_point = sptr = read_string(s, name);
1647 /* Having read a string, we now have several different ways of using it,
1648 depending on the data type, so do another switch. If keeping the actual
1649 string is not required (because it is interpreted), freesptr is set TRUE,
1650 and at the end we reset the pool. */
1654 /* If this was a string, set the variable to point to the new string,
1655 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1656 rules, we still keep the string (for printing), and parse the rules into a
1657 control block and flags word. */
1660 str_target = data_block ? USS (US data_block + (long int)(ol->value))
1662 if (ol->type & opt_rep_con)
1664 uschar * saved_condition;
1665 /* We already have a condition, we're conducting a crude hack to let
1666 multiple condition rules be chained together, despite storing them in
1668 *str_target = string_copy_malloc( (saved_condition = *str_target)
1669 ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1670 saved_condition, sptr)
1672 /* TODO(pdp): there is a memory leak here and just below
1673 when we set 3 or more conditions; I still don't
1674 understand the store mechanism enough to know
1675 what's the safe way to free content from an earlier store.
1676 AFAICT, stores stack, so freeing an early stored item also stores
1677 all data alloc'd after it. If we knew conditions were adjacent,
1678 we could survive that, but we don't. So I *think* we need to take
1679 another bit from opt_type to indicate "malloced"; this seems like
1680 quite a hack, especially for this one case. It also means that
1681 we can't ever reclaim the store from the *first* condition.
1683 Because we only do this once, near process start-up, I'm prepared to
1684 let this slide for the time being, even though it rankles. */
1686 else if (ol->type & opt_rep_str)
1688 uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1689 int sep_i = -(int)sep_o;
1690 const uschar * list = sptr;
1692 uschar * list_o = *str_target;
1693 int size = 0, len = 0;
1696 size = (len = Ustrlen(list_o)) + 1;
1698 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1699 list_o = string_append_listele(list_o, &size, &len, sep_o, s);
1701 *str_target = string_copy_malloc(list_o);
1712 *USS (US data_block + (long int)(ol->value)) = sptr;
1714 *USS (ol->value) = sptr;
1716 if (type == opt_rewrite)
1721 rewrite_rule **chain;
1724 sprintf(CS name2, "*%.50s_rules", name);
1725 ol2 = find_option(name2, oltop, last);
1726 sprintf(CS name2, "*%.50s_flags", name);
1727 ol3 = find_option(name2, oltop, last);
1729 if (ol2 == NULL || ol3 == NULL)
1730 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1731 "rewrite rules not available for driver");
1733 if (data_block == NULL)
1735 chain = (rewrite_rule **)(ol2->value);
1736 flagptr = (int *)(ol3->value);
1740 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1741 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1744 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1746 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1748 chain = &(next->next);
1751 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1752 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1753 "non-header rewrite - not allowed at transport time -");
1757 /* If it was an expanded uid, see if there is any expansion to be
1758 done by checking for the presence of a $ character. If there is, save it
1759 in the corresponding *expand_user option field. Otherwise, fall through
1760 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1763 case opt_expand_uid:
1764 sprintf(CS name2, "*expand_%.50s", name);
1765 ol2 = find_option(name2, oltop, last);
1768 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1770 if (data_block == NULL)
1771 *((uschar **)(ol2->value)) = ss;
1773 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1777 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1783 /* Look up a fixed uid, and also make use of the corresponding gid
1784 if a passwd entry is returned and the gid has not been set. */
1787 if (!route_finduser(sptr, &pw, &uid))
1788 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1789 if (data_block == NULL)
1790 *((uid_t *)(ol->value)) = uid;
1792 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1794 /* Set the flag indicating a fixed value is set */
1796 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1798 /* Handle matching gid if we have a passwd entry: done by finding the
1799 same name with terminating "user" changed to "group"; if not found,
1800 ignore. Also ignore if the value is already set. */
1802 if (pw == NULL) break;
1803 Ustrcpy(name+Ustrlen(name)-4, "group");
1804 ol2 = find_option(name, oltop, last);
1805 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1806 (ol2->type & opt_mask) == opt_expand_gid))
1808 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1811 if (data_block == NULL)
1812 *((gid_t *)(ol2->value)) = pw->pw_gid;
1814 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1820 /* If it was an expanded gid, see if there is any expansion to be
1821 done by checking for the presence of a $ character. If there is, save it
1822 in the corresponding *expand_user option field. Otherwise, fall through
1823 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1826 case opt_expand_gid:
1827 sprintf(CS name2, "*expand_%.50s", name);
1828 ol2 = find_option(name2, oltop, last);
1831 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1833 if (data_block == NULL)
1834 *((uschar **)(ol2->value)) = ss;
1836 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1840 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1846 /* Handle freestanding gid */
1849 if (!route_findgroup(sptr, &gid))
1850 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1851 if (data_block == NULL)
1852 *((gid_t *)(ol->value)) = gid;
1854 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1855 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1858 /* If it was a uid list, look up each individual entry, and build
1859 a vector of uids, with a count in the first element. Put the vector
1860 in malloc store so we can free the string. (We are reading into
1861 permanent store already.) */
1869 const uschar *op = expand_string (sptr);
1872 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1873 name, expand_string_message);
1876 if (*p != 0) count++;
1877 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1878 list = store_malloc(count*sizeof(uid_t));
1879 list[ptr++] = (uid_t)(count - 1);
1881 if (data_block == NULL)
1882 *((uid_t **)(ol->value)) = list;
1884 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1890 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1891 if (!route_finduser(big_buffer, NULL, &uid))
1892 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1899 /* If it was a gid list, look up each individual entry, and build
1900 a vector of gids, with a count in the first element. Put the vector
1901 in malloc store so we can free the string. (We are reading into permanent
1910 const uschar *op = expand_string (sptr);
1913 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1914 name, expand_string_message);
1917 if (*p != 0) count++;
1918 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1919 list = store_malloc(count*sizeof(gid_t));
1920 list[ptr++] = (gid_t)(count - 1);
1922 if (data_block == NULL)
1923 *((gid_t **)(ol->value)) = list;
1925 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1931 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1932 if (!route_findgroup(big_buffer, &gid))
1933 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1941 /* Release store if the value of the string doesn't need to be kept. */
1943 if (freesptr) store_reset(reset_point);
1946 /* Expanded boolean: if no characters follow, or if there are no dollar
1947 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1948 save the string for later expansion in the alternate place. */
1950 case opt_expand_bool:
1951 if (*s != 0 && Ustrchr(s, '$') != 0)
1953 sprintf(CS name2, "*expand_%.50s", name);
1954 ol2 = find_option(name2, oltop, last);
1957 reset_point = sptr = read_string(s, name);
1958 if (data_block == NULL)
1959 *((uschar **)(ol2->value)) = sptr;
1961 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1968 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1969 look for yes/not/true/false. Some booleans are stored in a single bit in
1970 a single int. There's a special fudge for verify settings; without a suffix
1971 they set both xx_sender and xx_recipient. The table points to the sender
1972 value; search subsequently for the recipient. There's another special case:
1973 opt_bool_set also notes when a boolean has been set. */
1977 case opt_bool_verify:
1981 s = readconf_readname(name2, 64, s);
1982 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1984 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1986 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1987 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1988 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1989 US"for boolean option ", name);
1992 /* Handle single-bit type. */
1994 if (type == opt_bit)
1996 int bit = 1 << ((ol->type >> 16) & 31);
1997 int *ptr = (data_block == NULL)?
1998 (int *)(ol->value) :
1999 (int *)((uschar *)data_block + (long int)ol->value);
2000 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
2004 /* Handle full BOOL types */
2006 if (data_block == NULL)
2007 *((BOOL *)(ol->value)) = boolvalue;
2009 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
2013 if (type == opt_bool_verify)
2015 sprintf(CS name2, "%.50s_recipient", name + offset);
2016 ol2 = find_option(name2, oltop, last);
2019 if (data_block == NULL)
2020 *((BOOL *)(ol2->value)) = boolvalue;
2022 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
2026 /* Note that opt_bool_set type is set, if there is somewhere to do so */
2028 else if (type == opt_bool_set)
2030 sprintf(CS name2, "*set_%.50s", name + offset);
2031 ol2 = find_option(name2, oltop, last);
2034 if (data_block == NULL)
2035 *((BOOL *)(ol2->value)) = TRUE;
2037 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
2046 inttype = US"octal ";
2048 /* Integer: a simple(ish) case; allow octal and hex formats, and
2049 suffixes K, M and G. The different types affect output, not input. */
2058 lvalue = strtol(CS s, CSS &endptr, intbase);
2061 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2064 if (errno != ERANGE)
2065 if (tolower(*endptr) == 'k')
2067 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
2068 else lvalue *= 1024;
2071 else if (tolower(*endptr) == 'm')
2073 if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
2075 else lvalue *= 1024*1024;
2078 else if (tolower(*endptr) == 'g')
2080 if (lvalue > INT_MAX/(1024*1024*1024) || lvalue < INT_MIN/(1024*1024*1024))
2082 else lvalue *= 1024*1024*1024;
2086 if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2087 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2088 "absolute value of integer \"%s\" is too large (overflow)", s);
2090 while (isspace(*endptr)) endptr++;
2092 extra_chars_error(endptr, inttype, US"integer value for ", name);
2094 value = (int)lvalue;
2097 if (data_block == NULL)
2098 *((int *)(ol->value)) = value;
2100 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2103 /* Integer held in K: again, allow octal and hex formats, and suffixes K, M
2105 /*XXX consider moving to int_eximarith_t (but mind the overflow test 0415) */
2111 value = strtol(CS s, CSS &endptr, intbase);
2114 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2117 if (errno != ERANGE)
2118 if (tolower(*endptr) == 'g')
2120 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
2126 else if (tolower(*endptr) == 'm')
2128 if (value > INT_MAX/1024 || value < INT_MIN/1024)
2134 else if (tolower(*endptr) == 'k')
2137 value = (value + 512)/1024;
2139 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2140 "absolute value of integer \"%s\" is too large (overflow)", s);
2142 while (isspace(*endptr)) endptr++;
2144 extra_chars_error(endptr, inttype, US"integer value for ", name);
2147 if (data_block == NULL)
2148 *((int *)(ol->value)) = value;
2150 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2153 /* Fixed-point number: held to 3 decimal places. */
2156 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2157 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2158 "fixed-point number expected for %s", name);
2160 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2161 "integer \"%s\" is too large (overflow)", s);
2165 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2166 "integer \"%s\" is too large (overflow)", s);
2168 /* We get a coverity error here for using count, as it derived
2169 from the tainted buffer pointed to by s, as parsed by sscanf().
2170 By the definition of sscanf we must be accessing between start
2171 and end of s (assuming it is nul-terminated...) so ignore the error. */
2172 /* coverity[tainted_data] */
2173 if (s[count] == '.')
2176 while (isdigit(s[++count]))
2178 value += (s[count] - '0') * d;
2183 while (isspace(s[count])) count++;
2186 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2188 if (data_block == NULL)
2189 *((int *)(ol->value)) = value;
2191 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2194 /* There's a special routine to read time values. */
2197 value = readconf_readtime(s, 0, FALSE);
2199 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2201 if (data_block == NULL)
2202 *((int *)(ol->value)) = value;
2204 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2207 /* A time list is a list of colon-separated times, with the first
2208 element holding the size of the list and the second the number of
2214 int *list = (data_block == NULL)?
2215 (int *)(ol->value) :
2216 (int *)((uschar *)data_block + (long int)(ol->value));
2218 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2221 uschar *snext = Ustrchr(s, ':');
2225 while (ss > s && isspace(ss[-1])) ss--;
2228 value = readconf_readtime(s, terminator, FALSE);
2230 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2232 if (count > 1 && value <= list[count])
2233 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2234 "time value out of order for %s", name);
2235 list[count+1] = value;
2236 if (snext == NULL) break;
2238 while (isspace(*s)) s++;
2241 if (count > list[0] - 2)
2242 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2244 if (count > 0 && list[2] == 0) count = 0;
2251 void (*fn)() = ol->value;
2262 /*************************************************
2263 * Print a time value *
2264 *************************************************/
2267 Argument: a time value in seconds
2268 Returns: pointer to a fixed buffer containing the time as a string,
2269 in readconf_readtime() format
2273 readconf_printtime(int t)
2276 uschar *p = time_buffer;
2293 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2294 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2295 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2296 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2297 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2304 /*************************************************
2305 * Print an individual option value *
2306 *************************************************/
2308 /* This is used by the -bP option, so prints to the standard output.
2309 The entire options list is passed in as an argument, because some options come
2310 in pairs - typically uid/gid settings, which can either be explicit numerical
2311 values, or strings to be expanded later. If the numerical value is unset,
2312 search for "*expand_<name>" to see if there is a string equivalent.
2315 ol option entry, or NULL for an unknown option
2317 options_block NULL for main configuration options; otherwise points to
2318 a driver block; if the option doesn't have opt_public
2319 set, then options_block->options_block is where the item
2321 oltop points to the option list in which ol exists
2322 last one more than the offset of the last entry in optop
2323 no_labels do not show "foo = " at the start.
2329 print_ol(optionlist *ol, uschar *name, void *options_block,
2330 optionlist *oltop, int last, BOOL no_labels)
2343 printf("%s is not a known option\n", name);
2347 /* Non-admin callers cannot see options that have been flagged secure by the
2350 if (!admin_user && (ol->type & opt_secure) != 0)
2353 printf("%s\n", hidden);
2355 printf("%s = %s\n", name, hidden);
2359 /* Else show the value of the option */
2362 if (options_block != NULL)
2364 if ((ol->type & opt_public) == 0)
2365 options_block = (void *)(((driver_instance *)options_block)->options_block);
2366 value = (void *)((uschar *)options_block + (long int)value);
2369 switch(ol->type & opt_mask)
2372 case opt_rewrite: /* Show the text value */
2373 s = *((uschar **)value);
2374 if (!no_labels) printf("%s = ", name);
2375 printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
2379 if (!no_labels) printf("%s = ", name);
2380 printf("%d\n", *((int *)value));
2385 int x = *((int *)value);
2386 if (x != 0 && (x & 1023) == 0)
2390 if ((x & 1023) == 0)
2395 if (!no_labels) printf("%s = ", name);
2396 printf("%d%c\n", x, c);
2400 if (!no_labels) printf("%s = ", name);
2408 int x = *((int *)value);
2409 if (!no_labels) printf("%s = ", name);
2410 if (x == 0) printf("0\n");
2411 else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2412 else printf("%dK\n", x);
2417 if (!no_labels) printf("%s = ", name);
2418 printf("%#o\n", *((int *)value));
2421 /* Can be negative only when "unset", in which case integer */
2425 int x = *((int *)value);
2428 if (x < 0) printf("%s =\n", name); else
2430 if (!no_labels) printf("%s = ", name);
2431 printf("%d.", x/1000);
2444 /* If the numerical value is unset, try for the string value */
2446 case opt_expand_uid:
2447 if (! *get_set_flag(name, oltop, last, options_block))
2449 sprintf(CS name2, "*expand_%.50s", name);
2450 ol2 = find_option(name2, oltop, last);
2453 void *value2 = ol2->value;
2454 if (options_block != NULL)
2455 value2 = (void *)((uschar *)options_block + (long int)value2);
2456 s = *((uschar **)value2);
2457 if (!no_labels) printf("%s = ", name);
2458 printf("%s\n", (s == NULL)? US"" : string_printing(s));
2463 /* Else fall through */
2466 if (!no_labels) printf("%s = ", name);
2467 if (! *get_set_flag(name, oltop, last, options_block))
2471 pw = getpwuid(*((uid_t *)value));
2473 printf("%ld\n", (long int)(*((uid_t *)value)));
2474 else printf("%s\n", pw->pw_name);
2478 /* If the numerical value is unset, try for the string value */
2480 case opt_expand_gid:
2481 if (! *get_set_flag(name, oltop, last, options_block))
2483 sprintf(CS name2, "*expand_%.50s", name);
2484 ol2 = find_option(name2, oltop, last);
2485 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2487 void *value2 = ol2->value;
2488 if (options_block != NULL)
2489 value2 = (void *)((uschar *)options_block + (long int)value2);
2490 s = *((uschar **)value2);
2491 if (!no_labels) printf("%s = ", name);
2492 printf("%s\n", (s == NULL)? US"" : string_printing(s));
2497 /* Else fall through */
2500 if (!no_labels) printf("%s = ", name);
2501 if (! *get_set_flag(name, oltop, last, options_block))
2505 gr = getgrgid(*((int *)value));
2507 printf("%ld\n", (long int)(*((int *)value)));
2508 else printf("%s\n", gr->gr_name);
2513 uidlist = *((uid_t **)value);
2514 if (!no_labels) printf("%s =", name);
2515 if (uidlist != NULL)
2519 if (no_labels) sep = '\0';
2520 for (i = 1; i <= (int)(uidlist[0]); i++)
2522 uschar *name = NULL;
2523 pw = getpwuid(uidlist[i]);
2524 if (pw != NULL) name = US pw->pw_name;
2525 if (sep != '\0') printf("%c", sep);
2526 if (name != NULL) printf("%s", name);
2527 else printf("%ld", (long int)(uidlist[i]));
2535 gidlist = *((gid_t **)value);
2536 if (!no_labels) printf("%s =", name);
2537 if (gidlist != NULL)
2541 if (no_labels) sep = '\0';
2542 for (i = 1; i <= (int)(gidlist[0]); i++)
2544 uschar *name = NULL;
2545 gr = getgrgid(gidlist[i]);
2546 if (gr != NULL) name = US gr->gr_name;
2547 if (sep != '\0') printf("%c", sep);
2548 if (name != NULL) printf("%s", name);
2549 else printf("%ld", (long int)(gidlist[i]));
2557 if (!no_labels) printf("%s = ", name);
2558 printf("%s\n", readconf_printtime(*((int *)value)));
2564 int *list = (int *)value;
2565 if (!no_labels) printf("%s = ", name);
2566 for (i = 0; i < list[1]; i++)
2567 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2573 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2577 case opt_expand_bool:
2578 sprintf(CS name2, "*expand_%.50s", name);
2579 ol2 = find_option(name2, oltop, last);
2580 if (ol2 != NULL && ol2->value != NULL)
2582 void *value2 = ol2->value;
2583 if (options_block != NULL)
2584 value2 = (void *)((uschar *)options_block + (long int)value2);
2585 s = *((uschar **)value2);
2588 if (!no_labels) printf("%s = ", name);
2589 printf("%s\n", string_printing(s));
2592 /* s == NULL => string not set; fall through */
2598 case opt_bool_verify:
2600 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2607 /*************************************************
2608 * Print value from main configuration *
2609 *************************************************/
2611 /* This function, called as a result of encountering the -bP option,
2612 causes the value of any main configuration variable to be output if the
2613 second argument is NULL. There are some special values:
2615 all print all main configuration options
2616 config_file print the name of the configuration file
2617 (configure_file will still work, for backward
2619 routers print the routers' configurations
2620 transports print the transports' configuration
2621 authenticators print the authenticators' configuration
2622 macros print the macros' configuration
2623 router_list print a list of router names
2624 transport_list print a list of transport names
2625 authenticator_list print a list of authentication mechanism names
2626 macro_list print a list of macro names
2627 +name print a named list item
2628 local_scan print the local_scan options
2629 config print the configuration as it is parsed
2630 environment print the used execution environment
2632 If the second argument is not NULL, it must be one of "router", "transport",
2633 "authenticator" or "macro" in which case the first argument identifies the
2634 driver whose options are to be printed.
2637 name option name if type == NULL; else driver name
2638 type NULL or driver type name, as described above
2639 no_labels avoid the "foo = " at the start of an item
2645 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2647 BOOL names_only = FALSE;
2649 optionlist *ol2 = NULL;
2650 driver_instance *d = NULL;
2661 static uschar *types[] = { US"address", US"domain", US"host",
2663 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2664 &hostlist_anchor, &localpartlist_anchor };
2666 for (i = 0; i < 4; i++)
2668 t = tree_search(*(anchors[i]), name+1);
2673 printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2675 printf("%slist %s = %s\n", types[i], name+1,
2676 ((namedlist_block *)(t->data.ptr))->string);
2681 printf("no address, domain, host, or local part list called \"%s\" "
2682 "exists\n", name+1);
2687 if ( Ustrcmp(name, "configure_file") == 0
2688 || Ustrcmp(name, "config_file") == 0)
2690 printf("%s\n", CS config_main_filename);
2694 if (Ustrcmp(name, "all") == 0)
2696 for (ol = optionlist_config;
2697 ol < optionlist_config + nelem(optionlist_config); ol++)
2699 if ((ol->type & opt_hidden) == 0)
2700 print_ol(ol, US ol->name, NULL,
2701 optionlist_config, nelem(optionlist_config),
2707 if (Ustrcmp(name, "local_scan") == 0)
2709 #ifndef LOCAL_SCAN_HAS_OPTIONS
2710 printf("local_scan() options are not supported\n");
2712 for (ol = local_scan_options;
2713 ol < local_scan_options + local_scan_options_count; ol++)
2715 print_ol(ol, US ol->name, NULL, local_scan_options,
2716 local_scan_options_count, no_labels);
2722 if (Ustrcmp(name, "config") == 0)
2724 print_config(admin_user, no_labels);
2728 if (Ustrcmp(name, "routers") == 0)
2733 else if (Ustrcmp(name, "transports") == 0)
2735 type = US"transport";
2739 else if (Ustrcmp(name, "authenticators") == 0)
2741 type = US"authenticator";
2745 else if (Ustrcmp(name, "macros") == 0)
2751 else if (Ustrcmp(name, "router_list") == 0)
2758 else if (Ustrcmp(name, "transport_list") == 0)
2760 type = US"transport";
2765 else if (Ustrcmp(name, "authenticator_list") == 0)
2767 type = US"authenticator";
2772 else if (Ustrcmp(name, "macro_list") == 0)
2779 else if (Ustrcmp(name, "environment") == 0)
2784 for (p = USS environ; *p; p++) ;
2785 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2787 for (p = USS environ; *p; p++)
2790 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2799 print_ol(find_option(name, optionlist_config, nelem(optionlist_config)),
2800 name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2805 /* Handle the options for a router or transport. Skip options that are flagged
2806 as hidden. Some of these are options with names starting with '*', used for
2807 internal alternative representations of other options (which the printing
2808 function will sort out). Others are synonyms kept for backward compatibility.
2811 if (Ustrcmp(type, "router") == 0)
2813 d = (driver_instance *)routers;
2814 ol2 = optionlist_routers;
2815 size = optionlist_routers_size;
2817 else if (Ustrcmp(type, "transport") == 0)
2819 d = (driver_instance *)transports;
2820 ol2 = optionlist_transports;
2821 size = optionlist_transports_size;
2823 else if (Ustrcmp(type, "authenticator") == 0)
2825 d = (driver_instance *)auths;
2826 ol2 = optionlist_auths;
2827 size = optionlist_auths_size;
2830 else if (Ustrcmp(type, "macro") == 0)
2832 /* People store passwords in macros and they were previously not available
2833 for printing. So we have an admin_users restriction. */
2836 fprintf(stderr, "exim: permission denied\n");
2839 for (m = macros; m; m = m->next)
2840 if (!name || Ustrcmp(name, m->name) == 0)
2843 printf("%s\n", CS m->name);
2845 printf("%s=%s\n", CS m->name, CS m->replacement);
2850 printf("%s %s not found\n", type, name);
2856 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2860 /* Either search for a given driver, or print all of them */
2862 for (; d != NULL; d = d->next)
2865 printf("\n%s %s:\n", d->name, type);
2866 else if (Ustrcmp(d->name, name) != 0) continue;
2868 for (ol = ol2; ol < ol2 + size; ol++)
2870 if ((ol->type & opt_hidden) == 0)
2871 print_ol(ol, US ol->name, d, ol2, size, no_labels);
2874 for (ol = d->info->options;
2875 ol < d->info->options + *(d->info->options_count); ol++)
2877 if ((ol->type & opt_hidden) == 0)
2878 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2880 if (name != NULL) return;
2882 if (name != NULL) printf("%s %s not found\n", type, name);
2887 /*************************************************
2888 * Read a named list item *
2889 *************************************************/
2891 /* This function reads a name and a list (i.e. string). The name is used to
2892 save the list in a tree, sorted by its name. Each entry also has a number,
2893 which can be used for caching tests, but if the string contains any expansion
2894 items other than $key, the number is set negative to inhibit caching. This
2895 mechanism is used for domain, host, and address lists that are referenced by
2899 anchorp points to the tree anchor
2900 numberp points to the current number for this tree
2901 max the maximum number permitted
2902 s the text of the option line, starting immediately after the name
2904 tname the name of the list type, for messages
2910 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2913 BOOL forcecache = FALSE;
2916 namedlist_block *nb = store_get(sizeof(namedlist_block));
2918 if (Ustrncmp(s, "_cache", 6) == 0)
2925 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2927 if (*numberp >= max)
2928 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2931 while (isspace(*s)) s++;
2933 while (isalnum(*s) || *s == '_') s++;
2934 t = store_get(sizeof(tree_node) + s-ss);
2935 Ustrncpy(t->name, ss, s-ss);
2937 while (isspace(*s)) s++;
2939 if (!tree_insertnode(anchorp, t))
2940 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2941 "duplicate name \"%s\" for a named %s", t->name, tname);
2944 nb->number = *numberp;
2947 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2948 "missing '=' after \"%s\"", t->name);
2949 while (isspace(*s)) s++;
2950 nb->string = read_string(s, t->name);
2951 nb->cache_data = NULL;
2953 /* Check the string for any expansions; if any are found, mark this list
2954 uncacheable unless the user has explicited forced caching. */
2956 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2962 /*************************************************
2963 * Unpick data for a rate limit *
2964 *************************************************/
2966 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2970 s string, in the form t,b,f,l
2971 where t is the threshold (integer)
2972 b is the initial delay (time)
2973 f is the multiplicative factor (fixed point)
2974 k is the maximum time (time)
2975 threshold where to store threshold
2976 base where to store base in milliseconds
2977 factor where to store factor in milliseconds
2978 limit where to store limit
2980 Returns: nothing (panics on error)
2984 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2987 uschar bstring[16], lstring[16];
2989 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2990 factor, lstring) == 4)
2992 *base = readconf_readtime(bstring, 0, TRUE);
2993 *limit = readconf_readtime(lstring, 0, TRUE);
2994 if (*base >= 0 && *limit >= 0) return;
2996 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
3002 /*************************************************
3003 * Drop privs for checking TLS config *
3004 *************************************************/
3006 /* We want to validate TLS options during readconf, but do not want to be
3007 root when we call into the TLS library, in case of library linkage errors
3008 which cause segfaults; before this check, those were always done as the Exim
3009 runtime user and it makes sense to continue with that.
3011 Assumes: tls_require_ciphers has been set, if it will be
3012 exim_user has been set, if it will be
3013 exim_group has been set, if it will be
3015 Returns: bool for "okay"; false will cause caller to immediately exit.
3020 tls_dropprivs_validate_require_cipher(BOOL nowarn)
3022 const uschar *errmsg;
3025 void (*oldsignal)(int);
3027 /* If TLS will never be used, no point checking ciphers */
3029 if ( !tls_advertise_hosts
3030 || !*tls_advertise_hosts
3031 || Ustrcmp(tls_advertise_hosts, ":") == 0
3034 else if (!nowarn && !tls_certificate)
3035 log_write(0, LOG_MAIN,
3036 "Warning: No server certificate defined; will use a selfsigned one.\n"
3037 " Suggested action: either install a certificate or change tls_advertise_hosts option");
3039 oldsignal = signal(SIGCHLD, SIG_DFL);
3042 if ((pid = fork()) < 0)
3043 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
3047 /* in some modes, will have dropped privilege already */
3049 exim_setugid(exim_uid, exim_gid, FALSE,
3050 US"calling tls_validate_require_cipher");
3052 if ((errmsg = tls_validate_require_cipher()))
3053 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3054 "tls_require_ciphers invalid: %s", errmsg);
3060 rc = waitpid(pid, &status, 0);
3061 } while (rc < 0 && errno == EINTR);
3064 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3067 signal(SIGCHLD, oldsignal);
3071 #endif /* SUPPORT_TLS */
3076 /*************************************************
3077 * Read main configuration options *
3078 *************************************************/
3080 /* This function is the first to be called for configuration reading. It
3081 opens the configuration file and reads general configuration settings until
3082 it reaches the end of the configuration section. The file is then left open so
3083 that the remaining configuration data can subsequently be read if needed for
3086 The configuration file must be owned either by root or exim, and be writeable
3087 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3088 in the config file, so the test is done on the compiled in values. A slight
3089 anomaly, to be carefully documented.
3091 The name of the configuration file is taken from a list that is included in the
3092 binary of Exim. It can be altered from the command line, but if that is done,
3093 root privilege is immediately withdrawn unless the caller is root or exim.
3094 The first file on the list that exists is used.
3096 For use on multiple systems that share file systems, first look for a
3097 configuration file whose name has the current node name on the end. If that is
3098 not found, try the generic name. For really contorted configurations, that run
3099 multiple Exims with different uid settings, first try adding the effective uid
3100 before the node name. These complications are going to waste resources on most
3101 systems. Therefore they are available only when requested by compile-time
3105 readconf_main(BOOL nowarn)
3108 struct stat statbuf;
3109 uschar *s, *filename;
3110 const uschar *list = config_main_filelist;
3112 /* Loop through the possible file names */
3114 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3117 /* Cut out all the fancy processing unless specifically wanted */
3119 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3120 uschar *suffix = filename + Ustrlen(filename);
3122 /* Try for the node-specific file if a node name exists */
3124 #ifdef CONFIGURE_FILE_USE_NODE
3126 if (uname(&uts) >= 0)
3128 #ifdef CONFIGURE_FILE_USE_EUID
3129 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3130 config_file = Ufopen(filename, "rb");
3131 if (config_file == NULL)
3132 #endif /* CONFIGURE_FILE_USE_EUID */
3134 sprintf(CS suffix, ".%.256s", uts.nodename);
3135 config_file = Ufopen(filename, "rb");
3138 #endif /* CONFIGURE_FILE_USE_NODE */
3140 /* Otherwise, try the generic name, possibly with the euid added */
3142 #ifdef CONFIGURE_FILE_USE_EUID
3143 if (config_file == NULL)
3145 sprintf(CS suffix, ".%ld", (long int)original_euid);
3146 config_file = Ufopen(filename, "rb");
3148 #endif /* CONFIGURE_FILE_USE_EUID */
3150 /* Finally, try the unadorned name */
3152 if (config_file == NULL)
3155 config_file = Ufopen(filename, "rb");
3157 #else /* if neither defined */
3159 /* This is the common case when the fancy processing is not included. */
3161 config_file = Ufopen(filename, "rb");
3164 /* If the file does not exist, continue to try any others. For any other
3165 error, break out (and die). */
3167 if (config_file != NULL || errno != ENOENT) break;
3170 /* On success, save the name for verification; config_filename is used when
3171 logging configuration errors (it changes for .included files) whereas
3172 config_main_filename is the name shown by -bP. Failure to open a configuration
3173 file is a serious disaster. */
3177 uschar *last_slash = Ustrrchr(filename, '/');
3178 config_filename = config_main_filename = string_copy(filename);
3180 /* The config_main_directory we need for the $config_dir expansion.
3181 config_main_filename we need for $config_file expansion.
3182 And config_dir is the directory of the current configuration, used for
3183 relative .includes. We do need to know it's name, as we change our working
3186 if (filename[0] == '/')
3187 config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3190 /* relative configuration file name: working dir + / + basename(filename) */
3192 uschar buf[PATH_MAX];
3196 if (os_getcwd(buf, PATH_MAX) == NULL)
3198 perror("exim: getcwd");
3201 config_main_directory = string_cat(NULL, &size, &offset, buf);
3203 /* If the dir does not end with a "/", append one */
3204 if (config_main_directory[offset-1] != '/')
3205 config_main_directory = string_catn(config_main_directory, &size, &offset, US"/", 1);
3207 /* If the config file contains a "/", extract the directory part */
3209 config_main_directory = string_catn(config_main_directory, &size, &offset, filename, last_slash - filename);
3211 config_main_directory[offset] = '\0';
3213 config_directory = config_main_directory;
3217 if (filename == NULL)
3218 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3219 "%s", config_main_filelist);
3221 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3222 "configuration file %s", filename));
3225 /* Now, once we found and opened our configuration file, we change the directory
3226 to a safe place. Later we change to $spool_directory. */
3228 if (Uchdir("/") < 0)
3230 perror("exim: chdir `/': ");
3234 /* Check the status of the file we have opened, if we have retained root
3235 privileges and the file isn't /dev/null (which *should* be 0666). */
3237 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3239 if (fstat(fileno(config_file), &statbuf) != 0)
3240 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3243 if ((statbuf.st_uid != root_uid /* owner not root */
3244 #ifdef CONFIGURE_OWNER
3245 && statbuf.st_uid != config_uid /* owner not the special one */
3248 (statbuf.st_gid != root_gid /* group not root & */
3249 #ifdef CONFIGURE_GROUP
3250 && statbuf.st_gid != config_gid /* group not the special one */
3252 && (statbuf.st_mode & 020) != 0) || /* group writeable */
3254 ((statbuf.st_mode & 2) != 0)) /* world writeable */
3256 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3257 "wrong owner, group, or mode", big_buffer);
3260 /* Process the main configuration settings. They all begin with a lower case
3261 letter. If we see something starting with an upper case letter, it is taken as
3262 a macro definition. */
3264 while ((s = get_config_line()) != NULL)
3267 if (config_lineno == 1 && Ustrstr(s, "\xef\xbb\xbf") == s)
3268 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3269 "found unexpected BOM (Byte Order Mark)");
3271 if (isupper(s[0])) read_macro_assignment(s);
3273 else if (Ustrncmp(s, "domainlist", 10) == 0)
3274 read_named_list(&domainlist_anchor, &domainlist_count,
3275 MAX_NAMED_LIST, s+10, US"domain list");
3277 else if (Ustrncmp(s, "hostlist", 8) == 0)
3278 read_named_list(&hostlist_anchor, &hostlist_count,
3279 MAX_NAMED_LIST, s+8, US"host list");
3281 else if (Ustrncmp(s, US"addresslist", 11) == 0)
3282 read_named_list(&addresslist_anchor, &addresslist_count,
3283 MAX_NAMED_LIST, s+11, US"address list");
3285 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3286 read_named_list(&localpartlist_anchor, &localpartlist_count,
3287 MAX_NAMED_LIST, s+13, US"local part list");
3290 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3291 NULL, US"main option \"%s\" unknown");
3295 /* If local_sender_retain is set, local_from_check must be unset. */
3297 if (local_sender_retain && local_from_check)
3298 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3299 "local_sender_retain are set; this combination is not allowed");
3301 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3304 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3306 /* The max retry interval must not be greater than 24 hours. */
3308 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3310 /* remote_max_parallel must be > 0 */
3312 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3314 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3315 start of a new SMTP message. */
3317 freeze_tell_config = freeze_tell;
3319 /* The primary host name may be required for expansion of spool_directory
3320 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3321 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3322 canonize it. Some people like upper case letters in their host names, so we
3323 don't force the case. */
3325 if (primary_hostname == NULL)
3327 const uschar *hostname;
3329 if (uname(&uts) < 0)
3330 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3331 hostname = US uts.nodename;
3333 if (Ustrchr(hostname, '.') == NULL)
3336 struct hostent *hostdata;
3339 if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3340 match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3341 MCL_DOMAIN, TRUE, NULL) != OK))
3350 #if HAVE_GETIPNODEBYNAME
3352 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3354 hostdata = gethostbyname2(CS hostname, af);
3357 hostdata = gethostbyname(CS hostname);
3360 if (hostdata != NULL)
3362 hostname = US hostdata->h_name;
3366 if (af == AF_INET) break;
3371 primary_hostname = string_copy(hostname);
3374 /* Set up default value for smtp_active_hostname */
3376 smtp_active_hostname = primary_hostname;
3378 /* If spool_directory wasn't set in the build-time configuration, it must have
3379 got set above. Of course, writing to the log may not work if log_file_path is
3380 not set, but it will at least get to syslog or somewhere, with any luck. */
3382 if (*spool_directory == 0)
3383 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3386 /* Expand the spool directory name; it may, for example, contain the primary
3387 host name. Same comment about failure. */
3389 s = expand_string(spool_directory);
3391 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3392 "\"%s\": %s", spool_directory, expand_string_message);
3393 spool_directory = s;
3395 /* Expand log_file_path, which must contain "%s" in any component that isn't
3396 the null string or "syslog". It is also allowed to contain one instance of %D
3397 or %M. However, it must NOT contain % followed by anything else. */
3399 if (*log_file_path != 0)
3401 const uschar *ss, *sss;
3402 int sep = ':'; /* Fixed for log file path */
3403 s = expand_string(log_file_path);
3405 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3406 "\"%s\": %s", log_file_path, expand_string_message);
3409 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3412 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3413 t = Ustrstr(sss, "%s");
3415 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3416 "contain \"%%s\"", sss);
3418 t = Ustrchr(sss, '%');
3421 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3422 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3423 "unexpected \"%%\" character", s);
3430 /* Interpret syslog_facility into an integer argument for 'ident' param to
3431 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3434 if (syslog_facility_str != NULL)
3437 uschar *s = syslog_facility_str;
3439 if ((Ustrlen(syslog_facility_str) >= 4) &&
3440 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3443 for (i = 0; i < syslog_list_size; i++)
3445 if (strcmpic(s, syslog_list[i].name) == 0)
3447 syslog_facility = syslog_list[i].value;
3452 if (i >= syslog_list_size)
3454 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3455 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3459 /* Expand pid_file_path */
3461 if (*pid_file_path != 0)
3463 s = expand_string(pid_file_path);
3465 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3466 "\"%s\": %s", pid_file_path, expand_string_message);
3470 /* Set default value of process_log_path */
3472 if (process_log_path == NULL || *process_log_path =='\0')
3473 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3475 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3478 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3480 /* Unpick the SMTP rate limiting options, if set */
3482 if (smtp_ratelimit_mail != NULL)
3484 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3485 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3488 if (smtp_ratelimit_rcpt != NULL)
3490 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3491 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3494 /* The qualify domains default to the primary host name */
3496 if (qualify_domain_sender == NULL)
3497 qualify_domain_sender = primary_hostname;
3498 if (qualify_domain_recipient == NULL)
3499 qualify_domain_recipient = qualify_domain_sender;
3501 /* Setting system_filter_user in the configuration sets the gid as well if a
3502 name is given, but a numerical value does not. */
3504 if (system_filter_uid_set && !system_filter_gid_set)
3506 struct passwd *pw = getpwuid(system_filter_uid);
3508 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3509 (long int)system_filter_uid);
3510 system_filter_gid = pw->pw_gid;
3511 system_filter_gid_set = TRUE;
3514 /* If the errors_reply_to field is set, check that it is syntactically valid
3515 and ensure it contains a domain. */
3517 if (errors_reply_to != NULL)
3520 int start, end, domain;
3521 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3522 &start, &end, &domain, FALSE);
3524 if (recipient == NULL)
3525 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3526 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3529 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3530 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3533 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3534 smtp_accept_max must also be set. */
3536 if (smtp_accept_max == 0 &&
3537 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3538 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3539 "smtp_accept_max must be set if smtp_accept_queue or "
3540 "smtp_accept_max_per_host is set");
3542 /* Set up the host number if anything is specified. It is an expanded string
3543 so that it can be computed from the host name, for example. We do this last
3544 so as to ensure that everything else is set up before the expansion. */
3546 if (host_number_string != NULL)
3550 uschar *s = expand_string(host_number_string);
3552 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3553 "failed to expand localhost_number \"%s\": %s",
3554 host_number_string, expand_string_message);
3555 n = Ustrtol(s, &end, 0);
3556 while (isspace(*end)) end++;
3558 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3559 "localhost_number value is not a number: %s", s);
3560 if (n > LOCALHOST_MAX)
3561 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3562 "localhost_number is greater than the maximum allowed value (%d)",
3568 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3570 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3571 tls_verify_certificates == NULL)
3572 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3573 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3574 (tls_verify_hosts != NULL)? "" : "try_");
3576 /* This also checks that the library linkage is working and we can call
3577 routines in it, so call even if tls_require_ciphers is unset */
3578 if (!tls_dropprivs_validate_require_cipher(nowarn))
3581 /* Magic number: at time of writing, 1024 has been the long-standing value
3582 used by so many clients, and what Exim used to use always, that it makes
3583 sense to just min-clamp this max-clamp at that. */
3584 if (tls_dh_max_bits < 1024)
3585 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3586 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3588 /* If openssl_options is set, validate it */
3589 if (openssl_options)
3592 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3593 "openssl_options is set but we're using GnuTLS");
3596 if (!tls_openssl_options_parse(openssl_options, &dummy))
3597 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3598 "openssl_options parse error: %s", openssl_options);
3601 #endif /*SUPPORT_TLS*/
3603 if (!nowarn && !keep_environment && environ && *environ)
3604 log_write(0, LOG_MAIN,
3605 "Warning: purging the environment.\n"
3606 " Suggested action: use keep_environment.");
3611 /*************************************************
3612 * Initialize one driver *
3613 *************************************************/
3615 /* This is called once the driver's generic options, if any, have been read.
3616 We can now find the driver, set up defaults for the private options, and
3617 unset any "set" bits in the private options table (which might have been
3618 set by another incarnation of the same driver).
3621 d pointer to driver instance block, with generic
3623 drivers_available vector of available drivers
3624 size_of_info size of each block in drivers_available
3625 class class of driver, for error message
3627 Returns: pointer to the driver info block
3630 static driver_info *
3631 init_driver(driver_instance *d, driver_info *drivers_available,
3632 int size_of_info, uschar *class)
3636 for (dd = drivers_available; dd->driver_name[0] != 0;
3637 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3639 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3642 int len = dd->options_len;
3644 d->options_block = store_get(len);
3645 memcpy(d->options_block, dd->options_block, len);
3646 for (i = 0; i < *(dd->options_count); i++)
3647 dd->options[i].type &= ~opt_set;
3652 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3653 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3655 return NULL; /* never obeyed */
3661 /*************************************************
3662 * Initialize driver list *
3663 *************************************************/
3665 /* This function is called for routers, transports, and authentication
3666 mechanisms. It reads the data from the current point in the configuration file
3667 up to the end of the section, and sets up a chain of instance blocks according
3668 to the file's contents. The file will already have been opened by a call to
3669 readconf_main, and must be left open for subsequent reading of further data.
3671 Any errors cause a panic crash. Note that the blocks with names driver_info and
3672 driver_instance must map the first portions of all the _info and _instance
3673 blocks for this shared code to work.
3676 class "router", "transport", or "authenticator"
3677 anchor &routers, &transports, &auths
3678 drivers_available available drivers
3679 size_of_info size of each info block
3680 instance_default points to default data for an instance
3681 instance_size size of instance block
3682 driver_optionlist generic option list
3683 driver_optionlist_count count of generic option list
3689 readconf_driver_init(
3691 driver_instance **anchor,
3692 driver_info *drivers_available,
3694 void *instance_default,
3696 optionlist *driver_optionlist,
3697 int driver_optionlist_count)
3699 driver_instance **p = anchor;
3700 driver_instance *d = NULL;
3703 while ((buffer = get_config_line()) != NULL)
3708 /* Read the first name on the line and test for the start of a new driver. A
3709 macro definition indicates the end of the previous driver. If this isn't the
3710 start of a new driver, the line will be re-read. */
3712 s = readconf_readname(name, sizeof(name), buffer);
3714 /* Handle macro definition, first finishing off the initialization of the
3715 previous driver, if any. */
3717 if (isupper(*name) && *s == '=')
3721 if (!d->driver_name)
3722 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3723 "no driver defined for %s \"%s\"", class, d->name);
3727 read_macro_assignment(buffer);
3731 /* If the line starts with a name terminated by a colon, we are at the
3732 start of the definition of a new driver. The rest of the line must be
3739 /* Finish off initializing the previous driver. */
3743 if (!d->driver_name)
3744 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3745 "no driver defined for %s \"%s\"", class, d->name);
3749 /* Check that we haven't already got a driver of this name */
3751 for (d = *anchor; d; d = d->next)
3752 if (Ustrcmp(name, d->name) == 0)
3753 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3754 "there are two %ss called \"%s\"", class, name);
3756 /* Set up a new driver instance data block on the chain, with
3757 its default values installed. */
3759 d = store_get(instance_size);
3760 memcpy(d, instance_default, instance_size);
3763 d->name = string_copy(name);
3765 /* Clear out the "set" bits in the generic options */
3767 for (i = 0; i < driver_optionlist_count; i++)
3768 driver_optionlist[i].type &= ~opt_set;
3770 /* Check nothing more on this line, then do the next loop iteration. */
3772 while (isspace(*s)) s++;
3773 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3777 /* Not the start of a new driver. Give an error if we have not set up a
3778 current driver yet. */
3781 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3783 /* First look to see if this is a generic option; if it is "driver",
3784 initialize the driver. If is it not a generic option, we can look for a
3785 private option provided that the driver has been previously set up. */
3787 if (readconf_handle_option(buffer, driver_optionlist,
3788 driver_optionlist_count, d, NULL))
3790 if (!d->info && d->driver_name)
3791 init_driver(d, drivers_available, size_of_info, class);
3794 /* Handle private options - pass the generic block because some may
3795 live therein. A flag with each option indicates if it is in the public
3799 readconf_handle_option(buffer, d->info->options,
3800 *(d->info->options_count), d, US"option \"%s\" unknown");
3802 /* The option is not generic and the driver name has not yet been given. */
3804 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3805 "(\"driver\" must be specified before any private options)", name);
3808 /* Run the initialization function for the final driver. */
3812 if (!d->driver_name)
3813 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3814 "no driver defined for %s \"%s\"", class, d->name);
3821 /*************************************************
3822 * Check driver dependency *
3823 *************************************************/
3825 /* This function is passed a driver instance and a string. It checks whether
3826 any of the string options for the driver contains the given string as an
3830 d points to a driver instance block
3831 s the string to search for
3833 Returns: TRUE if a dependency is found
3837 readconf_depends(driver_instance *d, uschar *s)
3839 int count = *(d->info->options_count);
3843 for (ol = d->info->options; ol < d->info->options + count; ol++)
3845 void *options_block;
3847 int type = ol->type & opt_mask;
3848 if (type != opt_stringptr) continue;
3849 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3850 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3851 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3853 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3854 isalnum(ss[Ustrlen(s)])) continue;
3855 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3856 d->name, ol->name, s);
3861 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3868 /*************************************************
3869 * Decode an error type for retries *
3870 *************************************************/
3872 /* This function is global because it is also called from the main
3873 program when testing retry information. It decodes strings such as "quota_7d"
3874 into numerical error codes.
3877 pp points to start of text
3878 p points past end of text
3879 basic_errno points to an int to receive the main error number
3880 more_errno points to an int to receive the secondary error data
3882 Returns: NULL if decoded correctly; else points to error text
3886 readconf_retry_error(const uschar *pp, const uschar *p,
3887 int *basic_errno, int *more_errno)
3890 const uschar *q = pp;
3891 while (q < p && *q != '_') q++;
3894 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3896 *basic_errno = ERRNO_EXIMQUOTA;
3897 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3898 return US"bad time value";
3901 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3903 *basic_errno = ECONNREFUSED;
3906 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3907 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3908 else return US"A or MX expected after \"refused\"";
3912 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3914 *basic_errno = ETIMEDOUT;
3918 int xlen = p - q - 1;
3919 const uschar *x = q + 1;
3921 static uschar *extras[] =
3922 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
3923 static int values[] =
3924 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3926 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3927 if (strncmpic(x, extras[i], xlen) == 0)
3929 *more_errno = values[i];
3933 if (i >= sizeof(extras)/sizeof(uschar *))
3934 if (strncmpic(x, US"DNS", xlen) == 0)
3935 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3936 "available in retry rules (it has never worked) - treated as "
3939 return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3943 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3944 strncmpic(pp, US"rcpt_4", 6) == 0 ||
3945 strncmpic(pp, US"data_4", 6) == 0)
3948 int x = 255; /* means "any 4xx code" */
3949 if (p != pp + 8) bad = TRUE; else
3951 int a = pp[6], b = pp[7];
3955 if (isdigit(b)) x += b - '0';
3956 else if (b == 'x') x += 100;
3959 else if (a != 'x' || b != 'x') bad = TRUE;
3963 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3964 "x is literal and d is any digit", pp);
3966 *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
3967 *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3968 *more_errno = x << 8;
3971 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3972 strncmpic(q+1, US"failed", p-q-1) == 0)
3973 *basic_errno = ERRNO_AUTHFAIL;
3975 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3976 *basic_errno = ERRNO_SMTPCLOSED;
3978 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3979 *basic_errno = ERRNO_TLSREQUIRED;
3981 else if (strncmpic(pp, US"lookup", p - pp) == 0)
3982 *basic_errno = ERRNO_UNKNOWNHOST;
3984 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3985 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3993 /*************************************************
3994 * Read retry information *
3995 *************************************************/
3997 /* Each line of retry information contains:
3999 . A domain name pattern or an address pattern;
4001 . An error name, possibly with additional data, or *;
4003 . An optional sequence of retry items, each consisting of an identifying
4004 letter, a cutoff time, and optional parameters.
4006 All this is decoded and placed into a control block. */
4009 /* Subroutine to read an argument, preceded by a comma and terminated
4010 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4011 1 = fixed point number (returned *1000).
4014 paddr pointer to pointer to current character; updated
4015 type 0 => read a time; 1 => read a fixed point number
4017 Returns: time in seconds or fixed point number * 1000
4021 retry_arg(const uschar **paddr, int type)
4023 const uschar *p = *paddr;
4026 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4028 while (isspace(*p)) p++;
4030 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4032 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4033 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4038 case 0: return readconf_readtime(pp, *p, FALSE);
4039 case 1: return readconf_readfixed(pp, *p);
4041 return 0; /* Keep picky compilers happy */
4044 /* The function proper */
4047 readconf_retries(void)
4049 retry_config **chain = &retries;
4053 while ((p = get_config_line()))
4055 retry_rule **rchain;
4059 next = store_get(sizeof(retry_config));
4062 chain = &(next->next);
4063 next->basic_errno = next->more_errno = 0;
4064 next->senders = NULL;
4066 rchain = &(next->rules);
4068 next->pattern = string_dequote(&p);
4069 while (isspace(*p)) p++;
4071 while (mac_isgraph(*p)) p++;
4072 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4073 "missing error type in retry rule");
4075 /* Test error names for things we understand. */
4077 if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4078 &next->more_errno)))
4079 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4081 /* There may be an optional address list of senders to be used as another
4082 constraint on the rule. This was added later, so the syntax is a bit of a
4083 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4086 while (isspace(*p)) p++;
4087 if (Ustrncmp(p, "senders", 7) == 0)
4090 while (isspace(*p)) p++;
4091 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4092 "\"=\" expected after \"senders\" in retry rule");
4093 while (isspace(*p)) p++;
4094 next->senders = string_dequote(&p);
4097 /* Now the retry rules. Keep the maximum timeout encountered. */
4099 while (isspace(*p)) p++;
4103 retry_rule *rule = store_get(sizeof(retry_rule));
4105 rchain = &(rule->next);
4107 rule->rule = toupper(*p++);
4108 rule->timeout = retry_arg(&p, 0);
4109 if (rule->timeout > retry_maximum_timeout)
4110 retry_maximum_timeout = rule->timeout;
4114 case 'F': /* Fixed interval */
4115 rule->p1 = retry_arg(&p, 0);
4118 case 'G': /* Geometrically increasing intervals */
4119 case 'H': /* Ditto, but with randomness */
4120 rule->p1 = retry_arg(&p, 0);
4121 rule->p2 = retry_arg(&p, 1);
4125 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4129 if (rule->timeout <= 0 || rule->p1 <= 0 ||
4130 (rule->rule != 'F' && rule->p2 < 1000))
4131 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4132 "bad parameters for retry rule");
4134 while (isspace(*p)) p++;
4138 while (isspace(*p)) p++;
4141 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4148 /*************************************************
4149 * Initialize authenticators *
4150 *************************************************/
4152 /* Read the authenticators section of the configuration file.
4161 auth_instance *au, *bu;
4163 readconf_driver_init(US"authenticator",
4164 (driver_instance **)(&auths), /* chain anchor */
4165 (driver_info *)auths_available, /* available drivers */
4166 sizeof(auth_info), /* size of info block */
4167 &auth_defaults, /* default values for generic options */
4168 sizeof(auth_instance), /* size of instance block */
4169 optionlist_auths, /* generic options */
4170 optionlist_auths_size);
4172 for (au = auths; au; au = au->next)
4174 if (!au->public_name)
4175 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4176 "the %s authenticator", au->name);
4178 for (bu = au->next; bu; bu = bu->next)
4179 if (strcmpic(au->public_name, bu->public_name) == 0)
4180 if ((au->client && bu->client) || (au->server && bu->server))
4181 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4182 "(%s and %s) have the same public name (%s)",
4183 au->client ? US"client" : US"server", au->name, bu->name,
4191 /*************************************************
4192 * Read ACL information *
4193 *************************************************/
4195 /* If this run of Exim is not doing something that involves receiving a
4196 message, we can just skip over the ACL information. No need to parse it.
4198 First, we have a function for acl_read() to call back to get the next line. We
4199 need to remember the line we passed, because at the end it will contain the
4200 name of the next ACL. */
4202 static uschar *acl_line;
4207 acl_line = get_config_line();
4212 /* Now the main function:
4223 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4226 acl_line = get_config_line();
4228 while(acl_line != NULL)
4234 p = readconf_readname(name, sizeof(name), acl_line);
4235 if (isupper(*name) && *p == '=')
4237 read_macro_assignment(acl_line);
4238 acl_line = get_config_line();
4242 if (*p != ':' || name[0] == 0)
4243 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4245 node = store_get(sizeof(tree_node) + Ustrlen(name));
4246 Ustrcpy(node->name, name);
4247 if (!tree_insertnode(&acl_anchor, node))
4248 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4249 "there are two ACLs called \"%s\"", name);
4251 node->data.ptr = acl_read(acl_callback, &error);
4253 if (node->data.ptr == NULL && error != NULL)
4254 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4260 /*************************************************
4261 * Read configuration for local_scan() *
4262 *************************************************/
4264 /* This function is called after "begin local_scan" is encountered in the
4265 configuration file. If the local_scan() function allows for configuration
4266 options, we can process them. Otherwise, we expire in a panic.
4273 local_scan_init(void)
4275 #ifndef LOCAL_SCAN_HAS_OPTIONS
4276 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4277 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4281 while ((p = get_config_line()) != NULL)
4283 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4284 NULL, US"local_scan option \"%s\" unknown");
4291 /*************************************************
4292 * Read rest of configuration (after main) *
4293 *************************************************/
4295 /* This function reads the rest of the runtime configuration, after the main
4296 configuration. It is called only when actually needed. Each subsequent section
4297 of the configuration starts with a line of the form
4301 where the name is "routers", "transports", etc. A section is terminated by
4302 hitting the next "begin" line, and the next name is left in next_section.
4303 Because it may confuse people as to whether the names are singular or plural,
4304 we add "s" if it's missing. There is always enough room in next_section for
4305 this. This function is basically just a switch.
4311 static uschar *section_list[] = {
4325 while(next_section[0] != 0)
4329 int last = sizeof(section_list) / sizeof(uschar *);
4331 int n = Ustrlen(next_section);
4333 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4337 int c = strcmpic(next_section, section_list[mid]);
4339 if (c > 0) first = mid + 1; else last = mid;
4341 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4342 "\"%.*s\" is not a known configuration section name", n, next_section);
4343 mid = (last + first)/2;
4347 if (((had ^= bit) & bit) == 0)
4348 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4349 "\"%.*s\" section is repeated in the configuration file", n,
4354 case 0: readconf_acl(); break;
4355 case 1: auths_init(); break;
4356 case 2: local_scan_init(); break;
4357 case 3: readconf_retries(); break;
4358 case 4: readconf_rewrites(); break;
4359 case 5: route_init(); break;
4360 case 6: transport_init(); break;
4364 (void)fclose(config_file);
4367 /* Init the storage for the pre-parsed config lines */
4369 readconf_save_config(const uschar *s)
4371 save_config_line(string_sprintf("# Exim Configuration (%s)",
4372 running_in_test_harness ? US"X" : s));
4376 save_config_position(const uschar *file, int line)
4378 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4381 /* Append a pre-parsed logical line to the config lines store,
4382 this operates on a global (static) list that holds all the pre-parsed
4383 config lines, we do no further processing here, output formatting and
4384 honouring of <hide> or macros will be done during output */
4386 save_config_line(const uschar* line)
4388 static config_line_item *current;
4389 config_line_item *next;
4391 next = (config_line_item*) store_get(sizeof(config_line_item));
4392 next->line = string_copy(line);
4395 if (!config_lines) config_lines = next;
4396 else current->next = next;
4401 /* List the parsed config lines, care about nice formatting and
4402 hide the <hide> values unless we're the admin user */
4404 print_config(BOOL admin, BOOL terse)
4406 config_line_item *i;
4407 const int TS = terse ? 0 : 2;
4410 for (i = config_lines; i; i = i->next)
4415 /* skip over to the first non-space */
4416 for (current = i->line; *current && isspace(*current); ++current)
4419 if (*current == '\0')
4422 /* Collapse runs of spaces. We stop this if we encounter one of the
4423 * following characters: "'$, as this may indicate careful formatting */
4424 for (p = current; *p; ++p)
4427 if (!isspace(*p)) continue;
4428 if (*p != ' ') *p = ' ';
4430 for (next = p; isspace(*next); ++next)
4434 memmove(p+1, next, Ustrlen(next)+1);
4436 if (*next == '"' || *next == '\'' || *next == '$')
4441 if (current[0] == '#')
4444 /* begin lines are left aligned */
4445 else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4447 if (!terse) puts("");
4452 /* router/acl/transport block names */
4453 else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4455 if (!terse) puts("");
4456 printf("%*s%s\n", TS, "", current);
4460 /* hidden lines (all MACROS or lines prefixed with "hide") */
4462 && ( isupper(*current)
4463 || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4467 if ((p = Ustrchr(current, '=')))
4470 printf("%*s%s= %s\n", indent, "", current, hidden);
4472 /* e.g.: hide split_spool_directory */
4474 printf("%*s\n", indent, hidden);
4478 /* rest is public */
4479 printf("%*s%s\n", indent, "", current);
4483 #endif /*!MACRO_PREDEF*/
4486 /* End of readconf.c */