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. */
14 extern char **environ;
16 static void fn_smtp_receive_timeout(const uschar * name, const uschar * str);
17 static void save_config_line(const uschar* line);
18 static void save_config_position(const uschar *file, int line);
19 static void print_config(BOOL admin, BOOL terse);
22 #define CSTATE_STACK_SIZE 10
25 /* Structure for chain (stack) of .included files */
27 typedef struct config_file_item {
28 struct config_file_item *next;
34 /* Structure for chain of configuration lines (-bP config) */
36 typedef struct config_line_item {
37 struct config_line_item *next;
41 static config_line_item* config_lines;
43 /* Structure of table of conditional words and their state transitions */
45 typedef struct cond_item {
53 /* Structure of table of syslog facility names and values */
55 typedef struct syslog_fac_item {
61 static const char * const hidden = "<value not displayable>";
63 /* Static variables */
65 static config_file_item *config_file_stack = NULL; /* For includes */
67 static uschar *syslog_facility_str = NULL;
68 static uschar next_section[24];
69 static uschar time_buffer[24];
71 /* State variables for conditional loading (.ifdef / .else / .endif) */
73 static int cstate = 0;
74 static int cstate_stack_ptr = -1;
75 static int cstate_stack[CSTATE_STACK_SIZE];
77 /* Table of state transitions for handling conditional inclusions. There are
78 four possible state transitions:
82 .elifdef true (or .else)
85 .endif just causes the previous cstate to be popped off the stack */
87 static int next_cstate[3][4] =
89 /* State 0: reading from file, or reading until next .else or .endif */
91 /* State 1: condition failed, skipping until next .else or .endif */
93 /* State 2: skipping until .endif */
97 /* Table of conditionals and the states to set. For each name, there are four
98 values: the length of the name (to save computing it each time), the state to
99 set if a macro was found in the line, the state to set if a macro was not found
100 in the line, and a stack manipulation setting which is:
102 -1 pull state value off the stack
103 0 don't alter the stack
104 +1 push value onto stack, before setting new state
107 static cond_item cond_list[] = {
108 { US"ifdef", 5, 0, 1, 1 },
109 { US"ifndef", 6, 1, 0, 1 },
110 { US"elifdef", 7, 2, 3, 0 },
111 { US"elifndef", 8, 3, 2, 0 },
112 { US"else", 4, 2, 2, 0 },
113 { US"endif", 5, 0, 0, -1 }
116 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
118 /* Table of syslog facility names and their values */
120 static syslog_fac_item syslog_list[] = {
121 { US"mail", LOG_MAIL },
122 { US"user", LOG_USER },
123 { US"news", LOG_NEWS },
124 { US"uucp", LOG_UUCP },
125 { US"local0", LOG_LOCAL0 },
126 { US"local1", LOG_LOCAL1 },
127 { US"local2", LOG_LOCAL2 },
128 { US"local3", LOG_LOCAL3 },
129 { US"local4", LOG_LOCAL4 },
130 { US"local5", LOG_LOCAL5 },
131 { US"local6", LOG_LOCAL6 },
132 { US"local7", LOG_LOCAL7 },
133 { US"daemon", LOG_DAEMON }
136 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
141 /*************************************************
142 * Main configuration options *
143 *************************************************/
145 /* The list of options that can be set in the main configuration file. This
146 must be in alphabetic order because it is searched by binary chop. */
148 static optionlist optionlist_config[] = {
149 { "*set_exim_group", opt_bool|opt_hidden, &exim_gid_set },
150 { "*set_exim_user", opt_bool|opt_hidden, &exim_uid_set },
151 { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
152 { "*set_system_filter_user", opt_bool|opt_hidden, &system_filter_uid_set },
153 { "accept_8bitmime", opt_bool, &accept_8bitmime },
154 { "acl_not_smtp", opt_stringptr, &acl_not_smtp },
155 #ifdef WITH_CONTENT_SCAN
156 { "acl_not_smtp_mime", opt_stringptr, &acl_not_smtp_mime },
158 { "acl_not_smtp_start", opt_stringptr, &acl_not_smtp_start },
159 { "acl_smtp_auth", opt_stringptr, &acl_smtp_auth },
160 { "acl_smtp_connect", opt_stringptr, &acl_smtp_connect },
161 { "acl_smtp_data", opt_stringptr, &acl_smtp_data },
163 { "acl_smtp_data_prdr", opt_stringptr, &acl_smtp_data_prdr },
166 { "acl_smtp_dkim", opt_stringptr, &acl_smtp_dkim },
168 { "acl_smtp_etrn", opt_stringptr, &acl_smtp_etrn },
169 { "acl_smtp_expn", opt_stringptr, &acl_smtp_expn },
170 { "acl_smtp_helo", opt_stringptr, &acl_smtp_helo },
171 { "acl_smtp_mail", opt_stringptr, &acl_smtp_mail },
172 { "acl_smtp_mailauth", opt_stringptr, &acl_smtp_mailauth },
173 #ifdef WITH_CONTENT_SCAN
174 { "acl_smtp_mime", opt_stringptr, &acl_smtp_mime },
176 { "acl_smtp_notquit", opt_stringptr, &acl_smtp_notquit },
177 { "acl_smtp_predata", opt_stringptr, &acl_smtp_predata },
178 { "acl_smtp_quit", opt_stringptr, &acl_smtp_quit },
179 { "acl_smtp_rcpt", opt_stringptr, &acl_smtp_rcpt },
181 { "acl_smtp_starttls", opt_stringptr, &acl_smtp_starttls },
183 { "acl_smtp_vrfy", opt_stringptr, &acl_smtp_vrfy },
184 { "add_environment", opt_stringptr, &add_environment },
185 { "admin_groups", opt_gidlist, &admin_groups },
186 { "allow_domain_literals", opt_bool, &allow_domain_literals },
187 { "allow_mx_to_ip", opt_bool, &allow_mx_to_ip },
188 { "allow_utf8_domains", opt_bool, &allow_utf8_domains },
189 { "auth_advertise_hosts", opt_stringptr, &auth_advertise_hosts },
190 { "auto_thaw", opt_time, &auto_thaw },
191 #ifdef WITH_CONTENT_SCAN
192 { "av_scanner", opt_stringptr, &av_scanner },
194 { "bi_command", opt_stringptr, &bi_command },
195 #ifdef EXPERIMENTAL_BRIGHTMAIL
196 { "bmi_config_file", opt_stringptr, &bmi_config_file },
198 { "bounce_message_file", opt_stringptr, &bounce_message_file },
199 { "bounce_message_text", opt_stringptr, &bounce_message_text },
200 { "bounce_return_body", opt_bool, &bounce_return_body },
201 { "bounce_return_linesize_limit", opt_mkint, &bounce_return_linesize_limit },
202 { "bounce_return_message", opt_bool, &bounce_return_message },
203 { "bounce_return_size_limit", opt_mkint, &bounce_return_size_limit },
204 { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
205 { "callout_domain_negative_expire", opt_time, &callout_cache_domain_negative_expire },
206 { "callout_domain_positive_expire", opt_time, &callout_cache_domain_positive_expire },
207 { "callout_negative_expire", opt_time, &callout_cache_negative_expire },
208 { "callout_positive_expire", opt_time, &callout_cache_positive_expire },
209 { "callout_random_local_part",opt_stringptr, &callout_random_local_part },
210 { "check_log_inodes", opt_int, &check_log_inodes },
211 { "check_log_space", opt_Kint, &check_log_space },
212 { "check_rfc2047_length", opt_bool, &check_rfc2047_length },
213 { "check_spool_inodes", opt_int, &check_spool_inodes },
214 { "check_spool_space", opt_Kint, &check_spool_space },
215 { "daemon_smtp_port", opt_stringptr|opt_hidden, &daemon_smtp_port },
216 { "daemon_smtp_ports", opt_stringptr, &daemon_smtp_port },
217 { "daemon_startup_retries", opt_int, &daemon_startup_retries },
218 { "daemon_startup_sleep", opt_time, &daemon_startup_sleep },
219 #ifdef EXPERIMENTAL_DCC
220 { "dcc_direct_add_header", opt_bool, &dcc_direct_add_header },
221 { "dccifd_address", opt_stringptr, &dccifd_address },
222 { "dccifd_options", opt_stringptr, &dccifd_options },
224 { "delay_warning", opt_timelist, &delay_warning },
225 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
226 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
227 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
228 { "delivery_date_remove", opt_bool, &delivery_date_remove },
229 #ifdef ENABLE_DISABLE_FSYNC
230 { "disable_fsync", opt_bool, &disable_fsync },
232 { "disable_ipv6", opt_bool, &disable_ipv6 },
234 { "dkim_verify_signers", opt_stringptr, &dkim_verify_signers },
236 #ifdef EXPERIMENTAL_DMARC
237 { "dmarc_forensic_sender", opt_stringptr, &dmarc_forensic_sender },
238 { "dmarc_history_file", opt_stringptr, &dmarc_history_file },
239 { "dmarc_tld_file", opt_stringptr, &dmarc_tld_file },
241 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
242 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
243 { "dns_csa_search_limit", opt_int, &dns_csa_search_limit },
244 { "dns_csa_use_reverse", opt_bool, &dns_csa_use_reverse },
245 { "dns_dnssec_ok", opt_int, &dns_dnssec_ok },
246 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
247 { "dns_retrans", opt_time, &dns_retrans },
248 { "dns_retry", opt_int, &dns_retry },
249 { "dns_trust_aa", opt_stringptr, &dns_trust_aa },
250 { "dns_use_edns0", opt_int, &dns_use_edns0 },
251 /* This option is now a no-op, retained for compability */
252 { "drop_cr", opt_bool, &drop_cr },
253 /*********************************************************/
254 { "dsn_advertise_hosts", opt_stringptr, &dsn_advertise_hosts },
255 { "dsn_from", opt_stringptr, &dsn_from },
256 { "envelope_to_remove", opt_bool, &envelope_to_remove },
257 { "errors_copy", opt_stringptr, &errors_copy },
258 { "errors_reply_to", opt_stringptr, &errors_reply_to },
259 #ifndef DISABLE_EVENT
260 { "event_action", opt_stringptr, &event_action },
262 { "exim_group", opt_gid, &exim_gid },
263 { "exim_path", opt_stringptr, &exim_path },
264 { "exim_user", opt_uid, &exim_uid },
265 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
266 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
267 { "finduser_retries", opt_int, &finduser_retries },
268 { "freeze_tell", opt_stringptr, &freeze_tell },
269 { "gecos_name", opt_stringptr, &gecos_name },
270 { "gecos_pattern", opt_stringptr, &gecos_pattern },
272 { "gnutls_allow_auto_pkcs11", opt_bool, &gnutls_allow_auto_pkcs11 },
273 { "gnutls_compat_mode", opt_bool, &gnutls_compat_mode },
274 /* These three gnutls_require_* options stopped working in Exim 4.80 */
275 /* From 4.83 we log a warning; a future relase will remove them */
276 { "gnutls_require_kx", opt_stringptr, &gnutls_require_kx },
277 { "gnutls_require_mac", opt_stringptr, &gnutls_require_mac },
278 { "gnutls_require_protocols", opt_stringptr, &gnutls_require_proto },
280 { "header_line_maxsize", opt_int, &header_line_maxsize },
281 { "header_maxsize", opt_int, &header_maxsize },
282 { "headers_charset", opt_stringptr, &headers_charset },
283 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
284 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
285 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
286 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
287 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
288 { "hold_domains", opt_stringptr, &hold_domains },
289 { "host_lookup", opt_stringptr, &host_lookup },
290 { "host_lookup_order", opt_stringptr, &host_lookup_order },
291 { "host_reject_connection", opt_stringptr, &host_reject_connection },
292 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
294 { "hosts_proxy", opt_stringptr, &hosts_proxy },
296 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
298 { "ibase_servers", opt_stringptr, &ibase_servers },
300 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
301 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
302 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
303 { "keep_environment", opt_stringptr, &keep_environment },
304 { "keep_malformed", opt_time, &keep_malformed },
306 { "ldap_ca_cert_dir", opt_stringptr, &eldap_ca_cert_dir },
307 { "ldap_ca_cert_file", opt_stringptr, &eldap_ca_cert_file },
308 { "ldap_cert_file", opt_stringptr, &eldap_cert_file },
309 { "ldap_cert_key", opt_stringptr, &eldap_cert_key },
310 { "ldap_cipher_suite", opt_stringptr, &eldap_cipher_suite },
311 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
312 { "ldap_require_cert", opt_stringptr, &eldap_require_cert },
313 { "ldap_start_tls", opt_bool, &eldap_start_tls },
314 { "ldap_version", opt_int, &eldap_version },
316 { "local_from_check", opt_bool, &local_from_check },
317 { "local_from_prefix", opt_stringptr, &local_from_prefix },
318 { "local_from_suffix", opt_stringptr, &local_from_suffix },
319 { "local_interfaces", opt_stringptr, &local_interfaces },
320 { "local_scan_timeout", opt_time, &local_scan_timeout },
321 { "local_sender_retain", opt_bool, &local_sender_retain },
322 { "localhost_number", opt_stringptr, &host_number_string },
323 { "log_file_path", opt_stringptr, &log_file_path },
324 { "log_selector", opt_stringptr, &log_selector_string },
325 { "log_timezone", opt_bool, &log_timezone },
326 { "lookup_open_max", opt_int, &lookup_open_max },
327 { "max_username_length", opt_int, &max_username_length },
328 { "message_body_newlines", opt_bool, &message_body_newlines },
329 { "message_body_visible", opt_mkint, &message_body_visible },
330 { "message_id_header_domain", opt_stringptr, &message_id_domain },
331 { "message_id_header_text", opt_stringptr, &message_id_text },
332 { "message_logs", opt_bool, &message_logs },
333 { "message_size_limit", opt_stringptr, &message_size_limit },
334 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
335 { "move_frozen_messages", opt_bool, &move_frozen_messages },
337 { "mua_wrapper", opt_bool, &mua_wrapper },
339 { "mysql_servers", opt_stringptr, &mysql_servers },
341 { "never_users", opt_uidlist, &never_users },
343 { "openssl_options", opt_stringptr, &openssl_options },
346 { "oracle_servers", opt_stringptr, &oracle_servers },
348 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
350 { "perl_at_start", opt_bool, &opt_perl_at_start },
351 { "perl_startup", opt_stringptr, &opt_perl_startup },
352 { "perl_taintmode", opt_bool, &opt_perl_taintmode },
355 { "pgsql_servers", opt_stringptr, &pgsql_servers },
357 { "pid_file_path", opt_stringptr, &pid_file_path },
358 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
360 { "prdr_enable", opt_bool, &prdr_enable },
362 { "preserve_message_logs", opt_bool, &preserve_message_logs },
363 { "primary_hostname", opt_stringptr, &primary_hostname },
364 { "print_topbitchars", opt_bool, &print_topbitchars },
365 { "process_log_path", opt_stringptr, &process_log_path },
366 { "prod_requires_admin", opt_bool, &prod_requires_admin },
367 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
368 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
369 { "queue_domains", opt_stringptr, &queue_domains },
370 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
371 { "queue_only", opt_bool, &queue_only },
372 { "queue_only_file", opt_stringptr, &queue_only_file },
373 { "queue_only_load", opt_fixed, &queue_only_load },
374 { "queue_only_load_latch", opt_bool, &queue_only_load_latch },
375 { "queue_only_override", opt_bool, &queue_only_override },
376 { "queue_run_in_order", opt_bool, &queue_run_in_order },
377 { "queue_run_max", opt_int, &queue_run_max },
378 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
379 { "receive_timeout", opt_time, &receive_timeout },
380 { "received_header_text", opt_stringptr, &received_header_text },
381 { "received_headers_max", opt_int, &received_headers_max },
382 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
383 { "recipients_max", opt_int, &recipients_max },
384 { "recipients_max_reject", opt_bool, &recipients_max_reject },
386 { "redis_servers", opt_stringptr, &redis_servers },
388 { "remote_max_parallel", opt_int, &remote_max_parallel },
389 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
390 { "retry_data_expire", opt_time, &retry_data_expire },
391 { "retry_interval_max", opt_time, &retry_interval_max },
392 { "return_path_remove", opt_bool, &return_path_remove },
393 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
394 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
395 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
396 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
397 { "slow_lookup_log", opt_int, &slow_lookup_log },
398 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
399 { "smtp_accept_max", opt_int, &smtp_accept_max },
400 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
401 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
402 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
403 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
404 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
405 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
406 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
407 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
408 { "smtp_banner", opt_stringptr, &smtp_banner },
409 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
410 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
411 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
412 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
413 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
414 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
415 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
416 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
417 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
418 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
419 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
420 { "smtp_receive_timeout", opt_func, &fn_smtp_receive_timeout },
421 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
422 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
424 { "smtputf8_advertise_hosts", opt_stringptr, &smtputf8_advertise_hosts },
426 #ifdef WITH_CONTENT_SCAN
427 { "spamd_address", opt_stringptr, &spamd_address },
429 #ifdef EXPERIMENTAL_SPF
430 { "spf_guess", opt_stringptr, &spf_guess },
432 { "split_spool_directory", opt_bool, &split_spool_directory },
433 { "spool_directory", opt_stringptr, &spool_directory },
435 { "sqlite_lock_timeout", opt_int, &sqlite_lock_timeout },
437 #ifdef EXPERIMENTAL_SRS
438 { "srs_config", opt_stringptr, &srs_config },
439 { "srs_hashlength", opt_int, &srs_hashlength },
440 { "srs_hashmin", opt_int, &srs_hashmin },
441 { "srs_maxage", opt_int, &srs_maxage },
442 { "srs_secrets", opt_stringptr, &srs_secrets },
443 { "srs_usehash", opt_bool, &srs_usehash },
444 { "srs_usetimestamp", opt_bool, &srs_usetimestamp },
446 { "strict_acl_vars", opt_bool, &strict_acl_vars },
447 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
448 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
449 { "syslog_duplication", opt_bool, &syslog_duplication },
450 { "syslog_facility", opt_stringptr, &syslog_facility_str },
451 { "syslog_processname", opt_stringptr, &syslog_processname },
452 { "syslog_timestamp", opt_bool, &syslog_timestamp },
453 { "system_filter", opt_stringptr, &system_filter },
454 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
455 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
456 { "system_filter_group", opt_gid, &system_filter_gid },
457 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
458 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
459 { "system_filter_user", opt_uid, &system_filter_uid },
460 { "tcp_nodelay", opt_bool, &tcp_nodelay },
461 #ifdef USE_TCP_WRAPPERS
462 { "tcp_wrappers_daemon_name", opt_stringptr, &tcp_wrappers_daemon_name },
464 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
465 { "timezone", opt_stringptr, &timezone_string },
466 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
468 { "tls_certificate", opt_stringptr, &tls_certificate },
469 { "tls_crl", opt_stringptr, &tls_crl },
470 { "tls_dh_max_bits", opt_int, &tls_dh_max_bits },
471 { "tls_dhparam", opt_stringptr, &tls_dhparam },
472 { "tls_eccurve", opt_stringptr, &tls_eccurve },
473 # ifndef DISABLE_OCSP
474 { "tls_ocsp_file", opt_stringptr, &tls_ocsp_file },
476 { "tls_on_connect_ports", opt_stringptr, &tls_in.on_connect_ports },
477 { "tls_privatekey", opt_stringptr, &tls_privatekey },
478 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
479 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
480 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
481 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
482 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
484 { "trusted_groups", opt_gidlist, &trusted_groups },
485 { "trusted_users", opt_uidlist, &trusted_users },
486 { "unknown_login", opt_stringptr, &unknown_login },
487 { "unknown_username", opt_stringptr, &unknown_username },
488 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
489 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
490 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
491 { "warn_message_file", opt_stringptr, &warn_message_file },
492 { "write_rejectlog", opt_bool, &write_rejectlog }
495 static int optionlist_config_size =
496 sizeof(optionlist_config)/sizeof(optionlist);
500 /*************************************************
501 * Find the name of an option *
502 *************************************************/
504 /* This function is to aid debugging. Various functions take arguments that are
505 pointer variables in the options table or in option tables for various drivers.
506 For debugging output, it is useful to be able to find the name of the option
507 which is currently being processed. This function finds it, if it exists, by
508 searching the table(s).
510 Arguments: a value that is presumed to be in the table above
511 Returns: the option name, or an empty string
515 readconf_find_option(void *p)
519 transport_instance *t;
521 for (i = 0; i < optionlist_config_size; i++)
522 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
524 for (r = routers; r != NULL; r = r->next)
526 router_info *ri = r->info;
527 for (i = 0; i < *ri->options_count; i++)
529 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
530 if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
531 return US ri->options[i].name;
535 for (t = transports; t != NULL; t = t->next)
537 transport_info *ti = t->info;
538 for (i = 0; i < *ti->options_count; i++)
540 optionlist * op = &ti->options[i];
541 if ((op->type & opt_mask) != opt_stringptr) continue;
542 if (p == ( op->type & opt_public
544 : (char *)t->options_block
546 + (long int)op->value)
557 /*************************************************
558 * Deal with an assignment to a macro *
559 *************************************************/
561 /* This function is called when a line that starts with an upper case letter is
562 encountered. The argument "line" should contain a complete logical line, and
563 start with the first letter of the macro name. The macro name and the
564 replacement text are extracted and stored. Redefinition of existing,
565 non-command line, macros is permitted using '==' instead of '='.
568 s points to the start of the logical line
574 read_macro_assignment(uschar *s)
580 macro_item *mlast = NULL;
582 while (isalnum(*s) || *s == '_')
584 if (namelen >= sizeof(name) - 1)
585 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
586 "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
587 name[namelen++] = *s++;
591 while (isspace(*s)) s++;
593 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
600 while (isspace(*s)) s++;
602 /* If an existing macro of the same name was defined on the command line, we
603 just skip this definition. It's an error to attempt to redefine a macro without
604 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
605 It is also an error to define a macro whose name begins with the name of a
606 previously defined macro. Note: it is documented that the other way round
609 for (m = macros; m != NULL; m = m->next)
611 int len = Ustrlen(m->name);
613 if (Ustrcmp(m->name, name) == 0)
615 if (!m->command_line && !redef)
616 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
617 "defined (use \"==\" if you want to redefine it", name);
621 if (len < namelen && Ustrstr(name, m->name) != NULL)
622 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
623 "a macro because previously defined macro \"%s\" is a substring",
626 /* We cannot have this test, because it is documented that a substring
627 macro is permitted (there is even an example).
629 * if (len > namelen && Ustrstr(m->name, name) != NULL)
630 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
631 * "a macro because it is a substring of previously defined macro \"%s\"",
638 /* Check for an overriding command-line definition. */
640 if (m != NULL && m->command_line) return;
642 /* Redefinition must refer to an existing macro. */
647 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
651 /* We have a new definition. The macro_item structure includes a final vector
652 called "name" which is one byte long. Thus, adding "namelen" gives us enough
653 room to store the "name" string. */
657 m = store_get(sizeof(macro_item) + namelen);
658 if (macros == NULL) macros = m; else mlast->next = m;
659 Ustrncpy(m->name, name, namelen);
660 m->name[namelen] = 0;
662 m->command_line = FALSE;
665 /* Set the value of the new or redefined macro */
667 m->replacement = string_copy(s);
674 /*************************************************
675 * Read configuration line *
676 *************************************************/
678 /* A logical line of text is read from the configuration file into the big
679 buffer, taking account of macros, .includes, and continuations. The size of
680 big_buffer is increased if necessary. The count of configuration lines is
681 maintained. Physical input lines starting with # (ignoring leading white space,
682 and after macro replacement) and empty logical lines are always ignored.
683 Leading and trailing spaces are removed.
685 If we hit a line of the form "begin xxxx", the xxxx is placed in the
686 next_section vector, and the function returns NULL, indicating the end of a
687 configuration section. On end-of-file, NULL is returned with next_section
692 Returns: a pointer to the first non-blank in the line,
693 or NULL if eof or end of section is reached
697 get_config_line(void)
699 int startoffset = 0; /* To first non-blank char in logical line */
700 int len = 0; /* Of logical line so far */
706 /* Loop for handling continuation lines, skipping comments, and dealing with
711 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
713 if (config_file_stack != NULL) /* EOF inside .include */
715 (void)fclose(config_file);
716 config_file = config_file_stack->file;
717 config_filename = config_file_stack->filename;
718 config_lineno = config_file_stack->lineno;
719 config_file_stack = config_file_stack->next;
721 save_config_position(config_filename, config_lineno);
725 /* EOF at top level */
727 if (cstate_stack_ptr >= 0)
728 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
729 "Unexpected end of configuration file: .endif missing");
731 if (len != 0) break; /* EOF after continuation */
732 next_section[0] = 0; /* EOF at start of logical line */
737 newlen = len + Ustrlen(big_buffer + len);
739 if (config_lines && config_lineno == 1)
740 save_config_position(config_filename, config_lineno);
742 /* Handle pathologically long physical lines - yes, it did happen - by
743 extending big_buffer at this point. The code also copes with very long
746 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
749 big_buffer_size += BIG_BUFFER_SIZE;
750 newbuffer = store_malloc(big_buffer_size);
752 /* This use of strcpy is OK because we know that the string in the old
753 buffer is shorter than the new buffer. */
755 Ustrcpy(newbuffer, big_buffer);
756 store_free(big_buffer);
757 big_buffer = newbuffer;
758 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
760 newlen += Ustrlen(big_buffer + newlen);
763 /* Find the true start of the physical line - leading spaces are always
766 ss = big_buffer + len;
767 while (isspace(*ss)) ss++;
769 /* Process the physical line for macros. If this is the start of the logical
770 line, skip over initial text at the start of the line if it starts with an
771 upper case character followed by a sequence of name characters and an equals
772 sign, because that is the definition of a new macro, and we don't do
773 replacement therein. */
776 if (len == 0 && isupper(*s))
778 while (isalnum(*s) || *s == '_') s++;
779 while (isspace(*s)) s++;
780 if (*s != '=') s = ss; /* Not a macro definition */
783 /* For each defined macro, scan the line (from after XXX= if present),
784 replacing all occurrences of the macro. */
787 for (m = macros; m != NULL; m = m->next)
792 while ((p = Ustrstr(t, m->name)) != NULL)
795 int namelen = Ustrlen(m->name);
796 int replen = Ustrlen(m->replacement);
798 /* Expand the buffer if necessary */
800 while (newlen - namelen + replen + 1 > big_buffer_size)
802 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
803 uschar *newbuffer = store_malloc(newsize);
804 memcpy(newbuffer, big_buffer, newlen + 1);
805 p = newbuffer + (p - big_buffer);
806 s = newbuffer + (s - big_buffer);
807 ss = newbuffer + (ss - big_buffer);
808 t = newbuffer + (t - big_buffer);
809 big_buffer_size = newsize;
810 store_free(big_buffer);
811 big_buffer = newbuffer;
814 /* Shuffle the remaining characters up or down in the buffer before
815 copying in the replacement text. Don't rescan the replacement for this
819 moveby = replen - namelen;
822 memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
825 Ustrncpy(p, m->replacement, replen);
831 /* An empty macro replacement at the start of a line could mean that ss no
832 longer points to the first non-blank character. */
834 while (isspace(*ss)) ss++;
836 /* Check for comment lines - these are physical lines. */
838 if (*ss == '#') continue;
840 /* Handle conditionals, which are also applied to physical lines. Conditions
841 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
842 expansion occured on the rest of the line. A preliminary test for the leading
843 '.' saves effort on most lines. */
849 /* Search the list of conditional directives */
851 for (i = 0; i < cond_list_size; i++)
854 cond_item *c = cond_list+i;
855 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
857 /* The following character must be white space or end of string */
859 n = ss[1 + c->namelen];
860 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
862 /* .ifdef and .ifndef push the current state onto the stack, then set
863 a new one from the table. Stack overflow is an error */
867 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
868 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
869 ".%s nested too deeply", c->name);
870 cstate_stack[++cstate_stack_ptr] = cstate;
871 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
874 /* For any of the others, stack underflow is an error. The next state
875 comes either from the stack (.endif) or from the table. */
879 if (cstate_stack_ptr < 0)
880 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
881 ".%s without matching .ifdef", c->name);
882 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
883 next_cstate[cstate][macro_found? c->action1 : c->action2];
886 /* Having dealt with a directive, break the loop */
891 /* If we have handled a conditional directive, continue with the next
892 physical line. Otherwise, fall through. */
894 if (i < cond_list_size) continue;
897 /* If the conditional state is not 0 (actively using these lines), ignore
900 if (cstate != 0) continue; /* Conditional skip */
902 /* Handle .include lines - these are also physical lines. */
904 if (Ustrncmp(ss, ".include", 8) == 0 &&
906 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
909 int include_if_exists = isspace(ss[8])? 0 : 10;
910 config_file_item *save;
913 ss += 9 + include_if_exists;
914 while (isspace(*ss)) ss++;
915 t = ss + Ustrlen(ss);
916 while (t > ss && isspace(t[-1])) t--;
917 if (*ss == '\"' && t[-1] == '\"')
925 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
926 "absolute path \"%s\"", ss);
928 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
931 save_config_position(config_filename, config_lineno);
932 save = store_get(sizeof(config_file_item));
933 save->next = config_file_stack;
934 config_file_stack = save;
935 save->file = config_file;
936 save->filename = config_filename;
937 save->lineno = config_lineno;
939 config_file = Ufopen(ss, "rb");
940 if (config_file == NULL)
941 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
942 "configuration file %s", ss);
943 config_filename = string_copy(ss);
948 /* If this is the start of the logical line, remember where the non-blank
949 data starts. Otherwise shuffle down continuation lines to remove leading
953 startoffset = ss - big_buffer;
956 s = big_buffer + len;
959 memmove(s, ss, (newlen - len) - (ss - s) + 1);
964 /* Accept the new addition to the line. Remove trailing white space. */
967 while (len > 0 && isspace(big_buffer[len-1])) len--;
970 /* We are done if the line does not end in backslash and contains some data.
971 Empty logical lines are ignored. For continuations, remove the backslash and
972 go round the loop to read the continuation line. */
976 if (big_buffer[len-1] != '\\') break; /* End of logical line */
977 big_buffer[--len] = 0; /* Remove backslash */
979 } /* Loop for reading multiple physical lines */
981 /* We now have a logical line. Test for the end of a configuration section (or,
982 more accurately, for the start of the next section). Place the name of the next
983 section in next_section, and return NULL. If the name given is longer than
984 next_section, truncate it. It will be unrecognized later, because all the known
985 section names do fit. Leave space for pluralizing. */
987 s = big_buffer + startoffset; /* First non-space character */
992 if (strncmpic(s, US"begin ", 6) == 0)
995 while (isspace(*s)) s++;
996 if (big_buffer + len - s > sizeof(next_section) - 2)
997 s[sizeof(next_section) - 2] = 0;
998 Ustrcpy(next_section, s);
1002 /* Return the first non-blank character. */
1009 /*************************************************
1011 *************************************************/
1013 /* The yield is the pointer to the next uschar. Names longer than the
1014 output space are silently truncated. This function is also used from acl.c when
1018 name where to put the name
1022 Returns: new input pointer
1026 readconf_readname(uschar *name, int len, uschar *s)
1029 while (isspace(*s)) s++;
1032 while (isalnum(*s) || *s == '_')
1034 if (p < len-1) name[p++] = *s;
1039 while (isspace(*s)) s++;
1046 /*************************************************
1047 * Read a time value *
1048 *************************************************/
1050 /* This function is also called from outside, to read argument
1051 time values. The format of a time value is:
1053 [<n>w][<n>d][<n>h][<n>m][<n>s]
1055 as long as at least one is present. If a format error is encountered,
1056 return a negative value. The value must be terminated by the given
1061 terminator required terminating character
1062 return_msec if TRUE, allow fractional seconds and return milliseconds
1064 Returns: the time value, or -1 on syntax error
1065 value is seconds if return_msec is FALSE
1066 value is milliseconds if return_msec is TRUE
1070 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1078 if (!isdigit(*s)) return -1;
1079 (void)sscanf(CCS s, "%d%n", &value, &count);
1084 case 'w': value *= 7;
1085 case 'd': value *= 24;
1086 case 'h': value *= 60;
1087 case 'm': value *= 60;
1092 if (!return_msec) return -1;
1093 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1095 if (*s++ != 's') return -1;
1096 yield += (int)(fraction * 1000.0);
1102 if (return_msec) value *= 1000;
1104 if (*s == terminator) return yield;
1106 /* Control never reaches here. */
1111 /*************************************************
1112 * Read a fixed point value *
1113 *************************************************/
1115 /* The value is returned *1000
1119 terminator required terminator
1121 Returns: the value, or -1 on error
1125 readconf_readfixed(const uschar *s, int terminator)
1129 if (!isdigit(*s)) return -1;
1130 (void)sscanf(CS s, "%d%n", &value, &count);
1132 yield = value * 1000;
1136 while (isdigit((*(++s))))
1138 yield += (*s - '0') * m;
1143 return (*s == terminator)? yield : (-1);
1148 /*************************************************
1149 * Find option in list *
1150 *************************************************/
1152 /* The lists are always in order, so binary chop can be used.
1155 name the option name to search for
1156 ol the first entry in the option list
1157 last one more than the offset of the last entry in the option list
1159 Returns: pointer to an option entry, or NULL if not found
1163 find_option(uschar *name, optionlist *ol, int last)
1166 while (last > first)
1168 int middle = (first + last)/2;
1169 int c = Ustrcmp(name, ol[middle].name);
1170 if (c == 0) return ol + middle;
1171 else if (c > 0) first = middle + 1;
1179 /*************************************************
1180 * Find a set flag in option list *
1181 *************************************************/
1183 /* Because some versions of Unix make no restrictions on the values of uids and
1184 gids (even negative ones), we cannot represent "unset" by a special value.
1185 There is therefore a separate boolean variable for each one indicating whether
1186 a value is set or not. This function returns a pointer to the boolean, given
1187 the original option name. It is a major disaster if the flag cannot be found.
1190 name the name of the uid or gid option
1191 oltop points to the start of the relevant option list
1192 last one more than the offset of the last item in the option list
1193 data_block NULL when reading main options => data values in the option
1194 list are absolute addresses; otherwise they are byte offsets
1195 in data_block (used for driver options)
1197 Returns: a pointer to the boolean flag.
1201 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1205 sprintf(CS name2, "*set_%.50s", name);
1206 ol = find_option(name2, oltop, last);
1207 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1208 "Exim internal error: missing set flag for %s", name);
1209 return (data_block == NULL)? (BOOL *)(ol->value) :
1210 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1216 /*************************************************
1217 * Output extra characters message and die *
1218 *************************************************/
1220 /* Called when an option line has junk on the end. Sometimes this is because
1221 the sysadmin thinks comments are permitted.
1224 s points to the extra characters
1225 t1..t3 strings to insert in the log message
1227 Returns: doesn't return; dies
1231 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1233 uschar *comment = US"";
1234 if (*s == '#') comment = US" (# is comment only at line start)";
1235 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1236 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1241 /*************************************************
1242 * Read rewrite information *
1243 *************************************************/
1245 /* Each line of rewrite information contains:
1247 . A complete address in the form user@domain, possibly with
1248 leading * for each part; or alternatively, a regex.
1250 . A replacement string (which will be expanded).
1252 . An optional sequence of one-letter flags, indicating which
1253 headers etc. to apply this rule to.
1255 All this is decoded and placed into a control block. The OR of the flags is
1256 maintained in a common word.
1259 p points to the string that makes up the rule
1260 existflags points to the overall flag word
1261 isglobal TRUE if reading global rewrite rules
1263 Returns: the control block for the parsed rule.
1266 static rewrite_rule *
1267 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1269 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1272 next->key = string_dequote(&p);
1274 while (isspace(*p)) p++;
1276 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1277 "missing rewrite replacement string");
1280 next->replacement = string_dequote(&p);
1282 while (*p != 0) switch (*p++)
1284 case ' ': case '\t': break;
1286 case 'q': next->flags |= rewrite_quit; break;
1287 case 'w': next->flags |= rewrite_whole; break;
1289 case 'h': next->flags |= rewrite_all_headers; break;
1290 case 's': next->flags |= rewrite_sender; break;
1291 case 'f': next->flags |= rewrite_from; break;
1292 case 't': next->flags |= rewrite_to; break;
1293 case 'c': next->flags |= rewrite_cc; break;
1294 case 'b': next->flags |= rewrite_bcc; break;
1295 case 'r': next->flags |= rewrite_replyto; break;
1297 case 'E': next->flags |= rewrite_all_envelope; break;
1298 case 'F': next->flags |= rewrite_envfrom; break;
1299 case 'T': next->flags |= rewrite_envto; break;
1301 case 'Q': next->flags |= rewrite_qualify; break;
1302 case 'R': next->flags |= rewrite_repeat; break;
1305 next->flags |= rewrite_smtp;
1306 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1307 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1308 "rewrite rule has the S flag but is not a regular expression");
1312 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1313 "unknown rewrite flag character '%c' "
1314 "(could be missing quotes round replacement item)", p[-1]);
1318 /* If no action flags are set, set all the "normal" rewrites. */
1320 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1321 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1323 /* Remember which exist, for optimization, and return the rule */
1325 *existflags |= next->flags;
1332 /*************************************************
1333 * Read global rewrite information *
1334 *************************************************/
1336 /* Each line is a single rewrite rule; it is parsed into a control block
1337 by readconf_one_rewrite(), and its flags are ORed into the global flag
1338 word rewrite_existflags. */
1341 readconf_rewrites(void)
1343 rewrite_rule **chain = &global_rewrite_rules;
1346 while ((p = get_config_line()) != NULL)
1348 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1350 chain = &(next->next);
1356 /*************************************************
1358 *************************************************/
1360 /* Strings are read into the normal store pool. As long we aren't too
1361 near the end of the current block, the string will just use what is necessary
1362 on the top of the stacking pool, because string_cat() uses the extension
1366 s the rest of the input line
1367 name the option name (for errors)
1369 Returns: pointer to the string
1373 read_string(const uschar *s, const uschar *name)
1378 if (*s != '\"') return string_copy(s);
1381 yield = string_dequote(&s);
1383 if (s == ss+1 || s[-1] != '\"')
1384 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1385 "missing quote at end of string value for %s", name);
1387 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1393 /*************************************************
1394 * Custom-handler options *
1395 *************************************************/
1397 fn_smtp_receive_timeout(const uschar * name, const uschar * str)
1400 smtp_receive_timeout_s = string_copy(str);
1403 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1404 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1405 if (smtp_receive_timeout < 0)
1406 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1411 /*************************************************
1412 * Handle option line *
1413 *************************************************/
1415 /* This function is called from several places to process a line containing the
1416 setting of an option. The first argument is the line to be decoded; it has been
1417 checked not to be empty and not to start with '#'. Trailing newlines and white
1418 space have been removed. The second argument is a pointer to the list of
1419 variable names that are to be recognized, together with their types and
1420 locations, and the third argument gives the number of entries in the list.
1422 The fourth argument is a pointer to a data block. If it is NULL, then the data
1423 values in the options list are absolute addresses. Otherwise, they are byte
1424 offsets in the data block.
1426 String option data may continue onto several lines; this function reads further
1427 data from config_file if necessary.
1429 The yield of this function is normally zero. If a string continues onto
1430 multiple lines, then the data value is permitted to be followed by a comma
1431 or a semicolon (for use in drivers) and the yield is that character.
1434 buffer contains the configuration line to be handled
1435 oltop points to the start of the relevant option list
1436 last one more than the offset of the last item in the option list
1437 data_block NULL when reading main options => data values in the option
1438 list are absolute addresses; otherwise they are byte offsets
1439 in data_block when they have opt_public set; otherwise
1440 they are byte offsets in data_block->options_block.
1441 unknown_txt format string to use in panic message for unknown option;
1442 must contain %s for option name
1443 if given as NULL, don't panic on unknown option
1445 Returns: TRUE if an option was read successfully,
1446 FALSE false for an unknown option if unknown_txt == NULL,
1447 otherwise panic and die on an unknown option
1451 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1452 void *data_block, uschar *unknown_txt)
1456 int n, count, type, value;
1460 BOOL boolvalue = TRUE;
1461 BOOL freesptr = TRUE;
1462 optionlist *ol, *ol2;
1466 uschar *inttype = US"";
1469 uschar *saved_condition, *strtemp;
1470 uschar **str_target;
1474 /* There may be leading spaces; thereafter, we expect an option name starting
1477 while (isspace(*s)) s++;
1479 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1481 /* Read the name of the option, and skip any subsequent white space. If
1482 it turns out that what we read was "hide", set the flag indicating that
1483 this is a secure option, and loop to read the next word. */
1485 for (n = 0; n < 2; n++)
1487 while (isalnum(*s) || *s == '_')
1489 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1493 while (isspace(*s)) s++;
1494 if (Ustrcmp(name, "hide") != 0) break;
1495 issecure = opt_secure;
1499 /* Deal with "no_" or "not_" here for booleans */
1501 if (Ustrncmp(name, "no_", 3) == 0)
1507 if (Ustrncmp(name, "not_", 4) == 0)
1513 /* Search the list for the given name. A non-existent name, or an option that
1514 is set twice, is a disaster. */
1516 ol = find_option(name + offset, oltop, last);
1520 if (unknown_txt == NULL) return FALSE;
1521 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1524 if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1525 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1526 "\"%s\" option set for the second time", name);
1528 ol->type |= opt_set | issecure;
1529 type = ol->type & opt_mask;
1531 /* Types with data values must be followed by '='; the "no[t]_" prefix
1532 applies only to boolean values. */
1534 if (type < opt_bool || type > opt_bool_last)
1537 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1538 "negation prefix applied to a non-boolean option");
1540 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1541 "unexpected end of line (data missing) after %s", name);
1543 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1546 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1547 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1548 ultimately expands to one of those values. */
1550 else if (*s != 0 && (offset != 0 || *s != '='))
1551 extra_chars_error(s, US"boolean option ", name, US"");
1553 /* Skip white space after = */
1555 if (*s == '=') while (isspace((*(++s))));
1557 /* If there is a data block and the opt_public flag is not set, change
1558 the data block pointer to the private options block. */
1560 if (data_block != NULL && (ol->type & opt_public) == 0)
1561 data_block = (void *)(((driver_instance *)data_block)->options_block);
1563 /* Now get the data according to the type. */
1567 /* If a string value is not enclosed in quotes, it consists of
1568 the rest of the current line, verbatim. Otherwise, string escapes
1571 A transport is specified as a string, which is then looked up in the
1572 list of transports. A search type is specified as one of a number of
1575 A set or rewrite rules for a driver is specified as a string, which is
1576 then parsed into a suitable chain of control blocks.
1578 Uids and gids are specified as strings which are then looked up in the
1579 passwd file. Lists of uids and gids are similarly specified as colon-
1580 separated strings. */
1585 case opt_expand_uid:
1586 case opt_expand_gid:
1591 reset_point = sptr = read_string(s, name);
1593 /* Having read a string, we now have several different ways of using it,
1594 depending on the data type, so do another switch. If keeping the actual
1595 string is not required (because it is interpreted), freesptr is set TRUE,
1596 and at the end we reset the pool. */
1600 /* If this was a string, set the variable to point to the new string,
1601 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1602 rules, we still keep the string (for printing), and parse the rules into a
1603 control block and flags word. */
1606 if (data_block == NULL)
1607 str_target = (uschar **)(ol->value);
1609 str_target = (uschar **)((uschar *)data_block + (long int)(ol->value));
1610 if (ol->type & opt_rep_con)
1612 /* We already have a condition, we're conducting a crude hack to let
1613 multiple condition rules be chained together, despite storing them in
1615 saved_condition = *str_target;
1616 strtemp = string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1617 saved_condition, sptr);
1618 *str_target = string_copy_malloc(strtemp);
1619 /* TODO(pdp): there is a memory leak here and just below
1620 when we set 3 or more conditions; I still don't
1621 understand the store mechanism enough to know
1622 what's the safe way to free content from an earlier store.
1623 AFAICT, stores stack, so freeing an early stored item also stores
1624 all data alloc'd after it. If we knew conditions were adjacent,
1625 we could survive that, but we don't. So I *think* we need to take
1626 another bit from opt_type to indicate "malloced"; this seems like
1627 quite a hack, especially for this one case. It also means that
1628 we can't ever reclaim the store from the *first* condition.
1630 Because we only do this once, near process start-up, I'm prepared to
1631 let this slide for the time being, even though it rankles. */
1633 else if (ol->type & opt_rep_str)
1635 uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1636 int sep_i = -(int)sep_o;
1637 const uschar * list = sptr;
1639 uschar * list_o = *str_target;
1641 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1642 list_o = string_append_listele(list_o, sep_o, s);
1644 *str_target = string_copy_malloc(list_o);
1654 if (data_block == NULL)
1655 *((uschar **)(ol->value)) = sptr;
1657 *((uschar **)((uschar *)data_block + (long int)(ol->value))) = sptr;
1659 if (type == opt_rewrite)
1664 rewrite_rule **chain;
1667 sprintf(CS name2, "*%.50s_rules", name);
1668 ol2 = find_option(name2, oltop, last);
1669 sprintf(CS name2, "*%.50s_flags", name);
1670 ol3 = find_option(name2, oltop, last);
1672 if (ol2 == NULL || ol3 == NULL)
1673 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1674 "rewrite rules not available for driver");
1676 if (data_block == NULL)
1678 chain = (rewrite_rule **)(ol2->value);
1679 flagptr = (int *)(ol3->value);
1683 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1684 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1687 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1689 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1691 chain = &(next->next);
1694 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1695 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1696 "non-header rewrite - not allowed at transport time -");
1700 /* If it was an expanded uid, see if there is any expansion to be
1701 done by checking for the presence of a $ character. If there is, save it
1702 in the corresponding *expand_user option field. Otherwise, fall through
1703 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1706 case opt_expand_uid:
1707 sprintf(CS name2, "*expand_%.50s", name);
1708 ol2 = find_option(name2, oltop, last);
1711 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1713 if (data_block == NULL)
1714 *((uschar **)(ol2->value)) = ss;
1716 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1720 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1726 /* Look up a fixed uid, and also make use of the corresponding gid
1727 if a passwd entry is returned and the gid has not been set. */
1730 if (!route_finduser(sptr, &pw, &uid))
1731 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1732 if (data_block == NULL)
1733 *((uid_t *)(ol->value)) = uid;
1735 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1737 /* Set the flag indicating a fixed value is set */
1739 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1741 /* Handle matching gid if we have a passwd entry: done by finding the
1742 same name with terminating "user" changed to "group"; if not found,
1743 ignore. Also ignore if the value is already set. */
1745 if (pw == NULL) break;
1746 Ustrcpy(name+Ustrlen(name)-4, "group");
1747 ol2 = find_option(name, oltop, last);
1748 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1749 (ol2->type & opt_mask) == opt_expand_gid))
1751 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1754 if (data_block == NULL)
1755 *((gid_t *)(ol2->value)) = pw->pw_gid;
1757 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1763 /* If it was an expanded gid, see if there is any expansion to be
1764 done by checking for the presence of a $ character. If there is, save it
1765 in the corresponding *expand_user option field. Otherwise, fall through
1766 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1769 case opt_expand_gid:
1770 sprintf(CS name2, "*expand_%.50s", name);
1771 ol2 = find_option(name2, oltop, last);
1774 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1776 if (data_block == NULL)
1777 *((uschar **)(ol2->value)) = ss;
1779 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1783 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1789 /* Handle freestanding gid */
1792 if (!route_findgroup(sptr, &gid))
1793 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1794 if (data_block == NULL)
1795 *((gid_t *)(ol->value)) = gid;
1797 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1798 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1801 /* If it was a uid list, look up each individual entry, and build
1802 a vector of uids, with a count in the first element. Put the vector
1803 in malloc store so we can free the string. (We are reading into
1804 permanent store already.) */
1812 const uschar *op = expand_string (sptr);
1815 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1816 name, expand_string_message);
1819 if (*p != 0) count++;
1820 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1821 list = store_malloc(count*sizeof(uid_t));
1822 list[ptr++] = (uid_t)(count - 1);
1824 if (data_block == NULL)
1825 *((uid_t **)(ol->value)) = list;
1827 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1833 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1834 if (!route_finduser(big_buffer, NULL, &uid))
1835 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1842 /* If it was a gid list, look up each individual entry, and build
1843 a vector of gids, with a count in the first element. Put the vector
1844 in malloc store so we can free the string. (We are reading into permanent
1853 const uschar *op = expand_string (sptr);
1856 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1857 name, expand_string_message);
1860 if (*p != 0) count++;
1861 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1862 list = store_malloc(count*sizeof(gid_t));
1863 list[ptr++] = (gid_t)(count - 1);
1865 if (data_block == NULL)
1866 *((gid_t **)(ol->value)) = list;
1868 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1874 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1875 if (!route_findgroup(big_buffer, &gid))
1876 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1884 /* Release store if the value of the string doesn't need to be kept. */
1886 if (freesptr) store_reset(reset_point);
1889 /* Expanded boolean: if no characters follow, or if there are no dollar
1890 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1891 save the string for later expansion in the alternate place. */
1893 case opt_expand_bool:
1894 if (*s != 0 && Ustrchr(s, '$') != 0)
1896 sprintf(CS name2, "*expand_%.50s", name);
1897 ol2 = find_option(name2, oltop, last);
1900 reset_point = sptr = read_string(s, name);
1901 if (data_block == NULL)
1902 *((uschar **)(ol2->value)) = sptr;
1904 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1911 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1912 look for yes/not/true/false. Some booleans are stored in a single bit in
1913 a single int. There's a special fudge for verify settings; without a suffix
1914 they set both xx_sender and xx_recipient. The table points to the sender
1915 value; search subsequently for the recipient. There's another special case:
1916 opt_bool_set also notes when a boolean has been set. */
1920 case opt_bool_verify:
1924 s = readconf_readname(name2, 64, s);
1925 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1927 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1929 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1930 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1931 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1932 US"for boolean option ", name);
1935 /* Handle single-bit type. */
1937 if (type == opt_bit)
1939 int bit = 1 << ((ol->type >> 16) & 31);
1940 int *ptr = (data_block == NULL)?
1941 (int *)(ol->value) :
1942 (int *)((uschar *)data_block + (long int)ol->value);
1943 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1947 /* Handle full BOOL types */
1949 if (data_block == NULL)
1950 *((BOOL *)(ol->value)) = boolvalue;
1952 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1956 if (type == opt_bool_verify)
1958 sprintf(CS name2, "%.50s_recipient", name + offset);
1959 ol2 = find_option(name2, oltop, last);
1962 if (data_block == NULL)
1963 *((BOOL *)(ol2->value)) = boolvalue;
1965 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1969 /* Note that opt_bool_set type is set, if there is somewhere to do so */
1971 else if (type == opt_bool_set)
1973 sprintf(CS name2, "*set_%.50s", name + offset);
1974 ol2 = find_option(name2, oltop, last);
1977 if (data_block == NULL)
1978 *((BOOL *)(ol2->value)) = TRUE;
1980 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1989 inttype = US"octal ";
1991 /* Integer: a simple(ish) case; allow octal and hex formats, and
1992 suffixes K and M. The different types affect output, not input. */
2001 lvalue = strtol(CS s, CSS &endptr, intbase);
2004 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2007 if (errno != ERANGE)
2009 if (tolower(*endptr) == 'k')
2011 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
2012 else lvalue *= 1024;
2015 else if (tolower(*endptr) == 'm')
2017 if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
2019 else lvalue *= 1024*1024;
2024 if (errno == ERANGE || lvalue > INT_MAX || lvalue < INT_MIN)
2025 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2026 "absolute value of integer \"%s\" is too large (overflow)", s);
2028 while (isspace(*endptr)) endptr++;
2030 extra_chars_error(endptr, inttype, US"integer value for ", name);
2032 value = (int)lvalue;
2035 if (data_block == NULL)
2036 *((int *)(ol->value)) = value;
2038 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2041 /* Integer held in K: again, allow octal and hex formats, and suffixes K and
2043 /*XXX consider moving to int_eximarith_t (but mind the overflow test 0415) */
2049 value = strtol(CS s, CSS &endptr, intbase);
2052 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2055 if (errno != ERANGE)
2057 if (tolower(*endptr) == 'm')
2059 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
2063 else if (tolower(*endptr) == 'k')
2069 value = (value + 512)/1024;
2073 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2074 "absolute value of integer \"%s\" is too large (overflow)", s);
2076 while (isspace(*endptr)) endptr++;
2078 extra_chars_error(endptr, inttype, US"integer value for ", name);
2081 if (data_block == NULL)
2082 *((int *)(ol->value)) = value;
2084 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2087 /* Fixed-point number: held to 3 decimal places. */
2090 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2091 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2092 "fixed-point number expected for %s", name);
2094 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2095 "integer \"%s\" is too large (overflow)", s);
2099 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2100 "integer \"%s\" is too large (overflow)", s);
2102 if (s[count] == '.')
2105 while (isdigit(s[++count]))
2107 value += (s[count] - '0') * d;
2112 while (isspace(s[count])) count++;
2115 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2117 if (data_block == NULL)
2118 *((int *)(ol->value)) = value;
2120 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2123 /* There's a special routine to read time values. */
2126 value = readconf_readtime(s, 0, FALSE);
2128 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2130 if (data_block == NULL)
2131 *((int *)(ol->value)) = value;
2133 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2136 /* A time list is a list of colon-separated times, with the first
2137 element holding the size of the list and the second the number of
2143 int *list = (data_block == NULL)?
2144 (int *)(ol->value) :
2145 (int *)((uschar *)data_block + (long int)(ol->value));
2147 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2150 uschar *snext = Ustrchr(s, ':');
2154 while (ss > s && isspace(ss[-1])) ss--;
2157 value = readconf_readtime(s, terminator, FALSE);
2159 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2161 if (count > 1 && value <= list[count])
2162 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2163 "time value out of order for %s", name);
2164 list[count+1] = value;
2165 if (snext == NULL) break;
2167 while (isspace(*s)) s++;
2170 if (count > list[0] - 2)
2171 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2173 if (count > 0 && list[2] == 0) count = 0;
2180 void (*fn)() = ol->value;
2191 /*************************************************
2192 * Print a time value *
2193 *************************************************/
2196 Argument: a time value in seconds
2197 Returns: pointer to a fixed buffer containing the time as a string,
2198 in readconf_readtime() format
2202 readconf_printtime(int t)
2205 uschar *p = time_buffer;
2222 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2223 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2224 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2225 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2226 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2233 /*************************************************
2234 * Print an individual option value *
2235 *************************************************/
2237 /* This is used by the -bP option, so prints to the standard output.
2238 The entire options list is passed in as an argument, because some options come
2239 in pairs - typically uid/gid settings, which can either be explicit numerical
2240 values, or strings to be expanded later. If the numerical value is unset,
2241 search for "*expand_<name>" to see if there is a string equivalent.
2244 ol option entry, or NULL for an unknown option
2246 options_block NULL for main configuration options; otherwise points to
2247 a driver block; if the option doesn't have opt_public
2248 set, then options_block->options_block is where the item
2250 oltop points to the option list in which ol exists
2251 last one more than the offset of the last entry in optop
2252 no_labels do not show "foo = " at the start.
2258 print_ol(optionlist *ol, uschar *name, void *options_block,
2259 optionlist *oltop, int last, BOOL no_labels)
2272 printf("%s is not a known option\n", name);
2276 /* Non-admin callers cannot see options that have been flagged secure by the
2279 if (!admin_user && (ol->type & opt_secure) != 0)
2282 printf("%s\n", hidden);
2284 printf("%s = %s\n", name, hidden);
2288 /* Else show the value of the option */
2291 if (options_block != NULL)
2293 if ((ol->type & opt_public) == 0)
2294 options_block = (void *)(((driver_instance *)options_block)->options_block);
2295 value = (void *)((uschar *)options_block + (long int)value);
2298 switch(ol->type & opt_mask)
2301 case opt_rewrite: /* Show the text value */
2302 s = *((uschar **)value);
2303 if (!no_labels) printf("%s = ", name);
2304 printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
2308 if (!no_labels) printf("%s = ", name);
2309 printf("%d\n", *((int *)value));
2314 int x = *((int *)value);
2315 if (x != 0 && (x & 1023) == 0)
2319 if ((x & 1023) == 0)
2324 if (!no_labels) printf("%s = ", name);
2325 printf("%d%c\n", x, c);
2329 if (!no_labels) printf("%s = ", name);
2337 int x = *((int *)value);
2338 if (!no_labels) printf("%s = ", name);
2339 if (x == 0) printf("0\n");
2340 else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2341 else printf("%dK\n", x);
2346 if (!no_labels) printf("%s = ", name);
2347 printf("%#o\n", *((int *)value));
2350 /* Can be negative only when "unset", in which case integer */
2354 int x = *((int *)value);
2357 if (x < 0) printf("%s =\n", name); else
2359 if (!no_labels) printf("%s = ", name);
2360 printf("%d.", x/1000);
2373 /* If the numerical value is unset, try for the string value */
2375 case opt_expand_uid:
2376 if (! *get_set_flag(name, oltop, last, options_block))
2378 sprintf(CS name2, "*expand_%.50s", name);
2379 ol2 = find_option(name2, oltop, last);
2382 void *value2 = ol2->value;
2383 if (options_block != NULL)
2384 value2 = (void *)((uschar *)options_block + (long int)value2);
2385 s = *((uschar **)value2);
2386 if (!no_labels) printf("%s = ", name);
2387 printf("%s\n", (s == NULL)? US"" : string_printing(s));
2392 /* Else fall through */
2395 if (!no_labels) printf("%s = ", name);
2396 if (! *get_set_flag(name, oltop, last, options_block))
2400 pw = getpwuid(*((uid_t *)value));
2402 printf("%ld\n", (long int)(*((uid_t *)value)));
2403 else printf("%s\n", pw->pw_name);
2407 /* If the numerical value is unset, try for the string value */
2409 case opt_expand_gid:
2410 if (! *get_set_flag(name, oltop, last, options_block))
2412 sprintf(CS name2, "*expand_%.50s", name);
2413 ol2 = find_option(name2, oltop, last);
2414 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2416 void *value2 = ol2->value;
2417 if (options_block != NULL)
2418 value2 = (void *)((uschar *)options_block + (long int)value2);
2419 s = *((uschar **)value2);
2420 if (!no_labels) printf("%s = ", name);
2421 printf("%s\n", (s == NULL)? US"" : string_printing(s));
2426 /* Else fall through */
2429 if (!no_labels) printf("%s = ", name);
2430 if (! *get_set_flag(name, oltop, last, options_block))
2434 gr = getgrgid(*((int *)value));
2436 printf("%ld\n", (long int)(*((int *)value)));
2437 else printf("%s\n", gr->gr_name);
2442 uidlist = *((uid_t **)value);
2443 if (!no_labels) printf("%s =", name);
2444 if (uidlist != NULL)
2448 if (no_labels) sep = '\0';
2449 for (i = 1; i <= (int)(uidlist[0]); i++)
2451 uschar *name = NULL;
2452 pw = getpwuid(uidlist[i]);
2453 if (pw != NULL) name = US pw->pw_name;
2454 if (sep != '\0') printf("%c", sep);
2455 if (name != NULL) printf("%s", name);
2456 else printf("%ld", (long int)(uidlist[i]));
2464 gidlist = *((gid_t **)value);
2465 if (!no_labels) printf("%s =", name);
2466 if (gidlist != NULL)
2470 if (no_labels) sep = '\0';
2471 for (i = 1; i <= (int)(gidlist[0]); i++)
2473 uschar *name = NULL;
2474 gr = getgrgid(gidlist[i]);
2475 if (gr != NULL) name = US gr->gr_name;
2476 if (sep != '\0') printf("%c", sep);
2477 if (name != NULL) printf("%s", name);
2478 else printf("%ld", (long int)(gidlist[i]));
2486 if (!no_labels) printf("%s = ", name);
2487 printf("%s\n", readconf_printtime(*((int *)value)));
2493 int *list = (int *)value;
2494 if (!no_labels) printf("%s = ", name);
2495 for (i = 0; i < list[1]; i++)
2496 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2502 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2506 case opt_expand_bool:
2507 sprintf(CS name2, "*expand_%.50s", name);
2508 ol2 = find_option(name2, oltop, last);
2509 if (ol2 != NULL && ol2->value != NULL)
2511 void *value2 = ol2->value;
2512 if (options_block != NULL)
2513 value2 = (void *)((uschar *)options_block + (long int)value2);
2514 s = *((uschar **)value2);
2517 if (!no_labels) printf("%s = ", name);
2518 printf("%s\n", string_printing(s));
2521 /* s == NULL => string not set; fall through */
2527 case opt_bool_verify:
2529 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2536 /*************************************************
2537 * Print value from main configuration *
2538 *************************************************/
2540 /* This function, called as a result of encountering the -bP option,
2541 causes the value of any main configuration variable to be output if the
2542 second argument is NULL. There are some special values:
2544 all print all main configuration options
2545 config_file print the name of the configuration file
2546 (configure_file will still work, for backward
2548 routers print the routers' configurations
2549 transports print the transports' configuration
2550 authenticators print the authenticators' configuration
2551 macros print the macros' configuration
2552 router_list print a list of router names
2553 transport_list print a list of transport names
2554 authenticator_list print a list of authentication mechanism names
2555 macro_list print a list of macro names
2556 +name print a named list item
2557 local_scan print the local_scan options
2558 config print the configuration as it is parsed
2559 environment print the used execution environment
2561 If the second argument is not NULL, it must be one of "router", "transport",
2562 "authenticator" or "macro" in which case the first argument identifies the
2563 driver whose options are to be printed.
2566 name option name if type == NULL; else driver name
2567 type NULL or driver type name, as described above
2568 no_labels avoid the "foo = " at the start of an item
2574 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2576 BOOL names_only = FALSE;
2578 optionlist *ol2 = NULL;
2579 driver_instance *d = NULL;
2590 static uschar *types[] = { US"address", US"domain", US"host",
2592 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2593 &hostlist_anchor, &localpartlist_anchor };
2595 for (i = 0; i < 4; i++)
2597 t = tree_search(*(anchors[i]), name+1);
2602 printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2604 printf("%slist %s = %s\n", types[i], name+1,
2605 ((namedlist_block *)(t->data.ptr))->string);
2610 printf("no address, domain, host, or local part list called \"%s\" "
2611 "exists\n", name+1);
2616 if ( Ustrcmp(name, "configure_file") == 0
2617 ||Ustrcmp(name, "config_file") == 0)
2619 printf("%s\n", CS config_main_filename);
2623 if (Ustrcmp(name, "all") == 0)
2625 for (ol = optionlist_config;
2626 ol < optionlist_config + optionlist_config_size; ol++)
2628 if ((ol->type & opt_hidden) == 0)
2629 print_ol(ol, US ol->name, NULL,
2630 optionlist_config, optionlist_config_size,
2636 if (Ustrcmp(name, "local_scan") == 0)
2638 #ifndef LOCAL_SCAN_HAS_OPTIONS
2639 printf("local_scan() options are not supported\n");
2641 for (ol = local_scan_options;
2642 ol < local_scan_options + local_scan_options_count; ol++)
2644 print_ol(ol, US ol->name, NULL, local_scan_options,
2645 local_scan_options_count, no_labels);
2651 if (Ustrcmp(name, "config") == 0)
2653 print_config(admin_user, no_labels);
2657 if (Ustrcmp(name, "routers") == 0)
2662 else if (Ustrcmp(name, "transports") == 0)
2664 type = US"transport";
2668 else if (Ustrcmp(name, "authenticators") == 0)
2670 type = US"authenticator";
2674 else if (Ustrcmp(name, "macros") == 0)
2680 else if (Ustrcmp(name, "router_list") == 0)
2687 else if (Ustrcmp(name, "transport_list") == 0)
2689 type = US"transport";
2694 else if (Ustrcmp(name, "authenticator_list") == 0)
2696 type = US"authenticator";
2701 else if (Ustrcmp(name, "macro_list") == 0)
2708 else if (Ustrcmp(name, "environment") == 0)
2713 for (p = USS environ; *p; p++) ;
2714 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2716 for (p = USS environ; *p; p++)
2719 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2728 print_ol(find_option(name, optionlist_config, optionlist_config_size),
2729 name, NULL, optionlist_config, optionlist_config_size, no_labels);
2734 /* Handle the options for a router or transport. Skip options that are flagged
2735 as hidden. Some of these are options with names starting with '*', used for
2736 internal alternative representations of other options (which the printing
2737 function will sort out). Others are synonyms kept for backward compatibility.
2740 if (Ustrcmp(type, "router") == 0)
2742 d = (driver_instance *)routers;
2743 ol2 = optionlist_routers;
2744 size = optionlist_routers_size;
2746 else if (Ustrcmp(type, "transport") == 0)
2748 d = (driver_instance *)transports;
2749 ol2 = optionlist_transports;
2750 size = optionlist_transports_size;
2752 else if (Ustrcmp(type, "authenticator") == 0)
2754 d = (driver_instance *)auths;
2755 ol2 = optionlist_auths;
2756 size = optionlist_auths_size;
2759 else if (Ustrcmp(type, "macro") == 0)
2761 /* People store passwords in macros and they were previously not available
2762 for printing. So we have an admin_users restriction. */
2765 fprintf(stderr, "exim: permission denied\n");
2768 for (m = macros; m != NULL; m = m->next)
2770 if (name == NULL || Ustrcmp(name, m->name) == 0)
2773 printf("%s\n", CS m->name);
2775 printf("%s=%s\n", CS m->name, CS m->replacement);
2781 printf("%s %s not found\n", type, name);
2787 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2791 /* Either search for a given driver, or print all of them */
2793 for (; d != NULL; d = d->next)
2796 printf("\n%s %s:\n", d->name, type);
2797 else if (Ustrcmp(d->name, name) != 0) continue;
2799 for (ol = ol2; ol < ol2 + size; ol++)
2801 if ((ol->type & opt_hidden) == 0)
2802 print_ol(ol, US ol->name, d, ol2, size, no_labels);
2805 for (ol = d->info->options;
2806 ol < d->info->options + *(d->info->options_count); ol++)
2808 if ((ol->type & opt_hidden) == 0)
2809 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2811 if (name != NULL) return;
2813 if (name != NULL) printf("%s %s not found\n", type, name);
2818 /*************************************************
2819 * Read a named list item *
2820 *************************************************/
2822 /* This function reads a name and a list (i.e. string). The name is used to
2823 save the list in a tree, sorted by its name. Each entry also has a number,
2824 which can be used for caching tests, but if the string contains any expansion
2825 items other than $key, the number is set negative to inhibit caching. This
2826 mechanism is used for domain, host, and address lists that are referenced by
2830 anchorp points to the tree anchor
2831 numberp points to the current number for this tree
2832 max the maximum number permitted
2833 s the text of the option line, starting immediately after the name
2835 tname the name of the list type, for messages
2841 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2844 BOOL forcecache = FALSE;
2847 namedlist_block *nb = store_get(sizeof(namedlist_block));
2849 if (Ustrncmp(s, "_cache", 6) == 0)
2856 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2858 if (*numberp >= max)
2859 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2862 while (isspace(*s)) s++;
2864 while (isalnum(*s) || *s == '_') s++;
2865 t = store_get(sizeof(tree_node) + s-ss);
2866 Ustrncpy(t->name, ss, s-ss);
2868 while (isspace(*s)) s++;
2870 if (!tree_insertnode(anchorp, t))
2871 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2872 "duplicate name \"%s\" for a named %s", t->name, tname);
2875 nb->number = *numberp;
2878 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2879 "missing '=' after \"%s\"", t->name);
2880 while (isspace(*s)) s++;
2881 nb->string = read_string(s, t->name);
2882 nb->cache_data = NULL;
2884 /* Check the string for any expansions; if any are found, mark this list
2885 uncacheable unless the user has explicited forced caching. */
2887 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2893 /*************************************************
2894 * Unpick data for a rate limit *
2895 *************************************************/
2897 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2901 s string, in the form t,b,f,l
2902 where t is the threshold (integer)
2903 b is the initial delay (time)
2904 f is the multiplicative factor (fixed point)
2905 k is the maximum time (time)
2906 threshold where to store threshold
2907 base where to store base in milliseconds
2908 factor where to store factor in milliseconds
2909 limit where to store limit
2911 Returns: nothing (panics on error)
2915 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2918 uschar bstring[16], lstring[16];
2920 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2921 factor, lstring) == 4)
2923 *base = readconf_readtime(bstring, 0, TRUE);
2924 *limit = readconf_readtime(lstring, 0, TRUE);
2925 if (*base >= 0 && *limit >= 0) return;
2927 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2933 /*************************************************
2934 * Drop privs for checking TLS config *
2935 *************************************************/
2937 /* We want to validate TLS options during readconf, but do not want to be
2938 root when we call into the TLS library, in case of library linkage errors
2939 which cause segfaults; before this check, those were always done as the Exim
2940 runtime user and it makes sense to continue with that.
2942 Assumes: tls_require_ciphers has been set, if it will be
2943 exim_user has been set, if it will be
2944 exim_group has been set, if it will be
2946 Returns: bool for "okay"; false will cause caller to immediately exit.
2951 tls_dropprivs_validate_require_cipher(BOOL nowarn)
2953 const uschar *errmsg;
2956 void (*oldsignal)(int);
2958 /* If TLS will never be used, no point checking ciphers */
2960 if ( !tls_advertise_hosts
2961 || !*tls_advertise_hosts
2962 || Ustrcmp(tls_advertise_hosts, ":") == 0
2965 else if (!nowarn && !tls_certificate)
2966 log_write(0, LOG_MAIN|LOG_PANIC,
2967 "Warning: No server certificate defined; TLS connections will fail.\n"
2968 " Suggested action: either install a certificate or change tls_advertise_hosts option");
2970 oldsignal = signal(SIGCHLD, SIG_DFL);
2973 if ((pid = fork()) < 0)
2974 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
2978 /* in some modes, will have dropped privilege already */
2980 exim_setugid(exim_uid, exim_gid, FALSE,
2981 US"calling tls_validate_require_cipher");
2983 errmsg = tls_validate_require_cipher();
2986 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2987 "tls_require_ciphers invalid: %s", errmsg);
2994 rc = waitpid(pid, &status, 0);
2995 } while (rc < 0 && errno == EINTR);
2998 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3001 signal(SIGCHLD, oldsignal);
3005 #endif /* SUPPORT_TLS */
3010 /*************************************************
3011 * Read main configuration options *
3012 *************************************************/
3014 /* This function is the first to be called for configuration reading. It
3015 opens the configuration file and reads general configuration settings until
3016 it reaches the end of the configuration section. The file is then left open so
3017 that the remaining configuration data can subsequently be read if needed for
3020 The configuration file must be owned either by root or exim, and be writeable
3021 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3022 in the config file, so the test is done on the compiled in values. A slight
3023 anomaly, to be carefully documented.
3025 The name of the configuration file is taken from a list that is included in the
3026 binary of Exim. It can be altered from the command line, but if that is done,
3027 root privilege is immediately withdrawn unless the caller is root or exim.
3028 The first file on the list that exists is used.
3030 For use on multiple systems that share file systems, first look for a
3031 configuration file whose name has the current node name on the end. If that is
3032 not found, try the generic name. For really contorted configurations, that run
3033 multiple Exims with different uid settings, first try adding the effective uid
3034 before the node name. These complications are going to waste resources on most
3035 systems. Therefore they are available only when requested by compile-time
3039 readconf_main(BOOL nowarn)
3042 struct stat statbuf;
3043 uschar *s, *filename;
3044 const uschar *list = config_main_filelist;
3046 /* Loop through the possible file names */
3048 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
3052 /* Cut out all the fancy processing unless specifically wanted */
3054 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3055 uschar *suffix = filename + Ustrlen(filename);
3057 /* Try for the node-specific file if a node name exists */
3059 #ifdef CONFIGURE_FILE_USE_NODE
3061 if (uname(&uts) >= 0)
3063 #ifdef CONFIGURE_FILE_USE_EUID
3064 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3065 config_file = Ufopen(filename, "rb");
3066 if (config_file == NULL)
3067 #endif /* CONFIGURE_FILE_USE_EUID */
3069 sprintf(CS suffix, ".%.256s", uts.nodename);
3070 config_file = Ufopen(filename, "rb");
3073 #endif /* CONFIGURE_FILE_USE_NODE */
3075 /* Otherwise, try the generic name, possibly with the euid added */
3077 #ifdef CONFIGURE_FILE_USE_EUID
3078 if (config_file == NULL)
3080 sprintf(CS suffix, ".%ld", (long int)original_euid);
3081 config_file = Ufopen(filename, "rb");
3083 #endif /* CONFIGURE_FILE_USE_EUID */
3085 /* Finally, try the unadorned name */
3087 if (config_file == NULL)
3090 config_file = Ufopen(filename, "rb");
3092 #else /* if neither defined */
3094 /* This is the common case when the fancy processing is not included. */
3096 config_file = Ufopen(filename, "rb");
3099 /* If the file does not exist, continue to try any others. For any other
3100 error, break out (and die). */
3102 if (config_file != NULL || errno != ENOENT) break;
3105 /* Now, once we found and opened our configuration file, we change the directory
3106 to a safe place. Later we change to $spool_directory. */
3108 if (Uchdir("/") < 0)
3110 perror("exim: chdir `/': ");
3114 /* On success, save the name for verification; config_filename is used when
3115 logging configuration errors (it changes for .included files) whereas
3116 config_main_filename is the name shown by -bP. Failure to open a configuration
3117 file is a serious disaster. */
3119 if (config_file != NULL)
3122 config_filename = config_main_filename = string_copy(filename);
3124 p = Ustrrchr(filename, '/');
3125 config_main_directory = p ? string_copyn(filename, p - filename)
3126 : string_copy(US".");
3130 if (filename == NULL)
3131 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3132 "%s", config_main_filelist);
3134 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3135 "configuration file %s", filename));
3138 /* Check the status of the file we have opened, if we have retained root
3139 privileges and the file isn't /dev/null (which *should* be 0666). */
3141 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3143 if (fstat(fileno(config_file), &statbuf) != 0)
3144 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3147 if ((statbuf.st_uid != root_uid /* owner not root */
3148 #ifdef CONFIGURE_OWNER
3149 && statbuf.st_uid != config_uid /* owner not the special one */
3152 (statbuf.st_gid != root_gid /* group not root & */
3153 #ifdef CONFIGURE_GROUP
3154 && statbuf.st_gid != config_gid /* group not the special one */
3156 && (statbuf.st_mode & 020) != 0) || /* group writeable */
3158 ((statbuf.st_mode & 2) != 0)) /* world writeable */
3160 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3161 "wrong owner, group, or mode", big_buffer);
3164 /* Process the main configuration settings. They all begin with a lower case
3165 letter. If we see something starting with an upper case letter, it is taken as
3166 a macro definition. */
3168 while ((s = get_config_line()) != NULL)
3170 if (isupper(s[0])) read_macro_assignment(s);
3172 else if (Ustrncmp(s, "domainlist", 10) == 0)
3173 read_named_list(&domainlist_anchor, &domainlist_count,
3174 MAX_NAMED_LIST, s+10, US"domain list");
3176 else if (Ustrncmp(s, "hostlist", 8) == 0)
3177 read_named_list(&hostlist_anchor, &hostlist_count,
3178 MAX_NAMED_LIST, s+8, US"host list");
3180 else if (Ustrncmp(s, US"addresslist", 11) == 0)
3181 read_named_list(&addresslist_anchor, &addresslist_count,
3182 MAX_NAMED_LIST, s+11, US"address list");
3184 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3185 read_named_list(&localpartlist_anchor, &localpartlist_count,
3186 MAX_NAMED_LIST, s+13, US"local part list");
3189 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3190 NULL, US"main option \"%s\" unknown");
3194 /* If local_sender_retain is set, local_from_check must be unset. */
3196 if (local_sender_retain && local_from_check)
3197 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3198 "local_sender_retain are set; this combination is not allowed");
3200 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3203 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3205 /* The max retry interval must not be greater than 24 hours. */
3207 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3209 /* remote_max_parallel must be > 0 */
3211 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3213 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3214 start of a new SMTP message. */
3216 freeze_tell_config = freeze_tell;
3218 /* The primary host name may be required for expansion of spool_directory
3219 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3220 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3221 canonize it. Some people like upper case letters in their host names, so we
3222 don't force the case. */
3224 if (primary_hostname == NULL)
3226 const uschar *hostname;
3228 if (uname(&uts) < 0)
3229 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3230 hostname = US uts.nodename;
3232 if (Ustrchr(hostname, '.') == NULL)
3235 struct hostent *hostdata;
3238 if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3239 match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3240 MCL_DOMAIN, TRUE, NULL) != OK))
3249 #if HAVE_GETIPNODEBYNAME
3251 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3253 hostdata = gethostbyname2(CS hostname, af);
3256 hostdata = gethostbyname(CS hostname);
3259 if (hostdata != NULL)
3261 hostname = US hostdata->h_name;
3265 if (af == AF_INET) break;
3270 primary_hostname = string_copy(hostname);
3273 /* Set up default value for smtp_active_hostname */
3275 smtp_active_hostname = primary_hostname;
3277 /* If spool_directory wasn't set in the build-time configuration, it must have
3278 got set above. Of course, writing to the log may not work if log_file_path is
3279 not set, but it will at least get to syslog or somewhere, with any luck. */
3281 if (*spool_directory == 0)
3282 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3285 /* Expand the spool directory name; it may, for example, contain the primary
3286 host name. Same comment about failure. */
3288 s = expand_string(spool_directory);
3290 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3291 "\"%s\": %s", spool_directory, expand_string_message);
3292 spool_directory = s;
3294 /* Expand log_file_path, which must contain "%s" in any component that isn't
3295 the null string or "syslog". It is also allowed to contain one instance of %D
3296 or %M. However, it must NOT contain % followed by anything else. */
3298 if (*log_file_path != 0)
3300 const uschar *ss, *sss;
3301 int sep = ':'; /* Fixed for log file path */
3302 s = expand_string(log_file_path);
3304 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3305 "\"%s\": %s", log_file_path, expand_string_message);
3308 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3311 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3312 t = Ustrstr(sss, "%s");
3314 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3315 "contain \"%%s\"", sss);
3317 t = Ustrchr(sss, '%');
3320 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3321 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3322 "unexpected \"%%\" character", s);
3329 /* Interpret syslog_facility into an integer argument for 'ident' param to
3330 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3333 if (syslog_facility_str != NULL)
3336 uschar *s = syslog_facility_str;
3338 if ((Ustrlen(syslog_facility_str) >= 4) &&
3339 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3342 for (i = 0; i < syslog_list_size; i++)
3344 if (strcmpic(s, syslog_list[i].name) == 0)
3346 syslog_facility = syslog_list[i].value;
3351 if (i >= syslog_list_size)
3353 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3354 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3358 /* Expand pid_file_path */
3360 if (*pid_file_path != 0)
3362 s = expand_string(pid_file_path);
3364 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3365 "\"%s\": %s", pid_file_path, expand_string_message);
3369 /* Set default value of process_log_path */
3371 if (process_log_path == NULL || *process_log_path =='\0')
3372 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3374 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3377 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3379 /* Unpick the SMTP rate limiting options, if set */
3381 if (smtp_ratelimit_mail != NULL)
3383 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3384 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3387 if (smtp_ratelimit_rcpt != NULL)
3389 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3390 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3393 /* The qualify domains default to the primary host name */
3395 if (qualify_domain_sender == NULL)
3396 qualify_domain_sender = primary_hostname;
3397 if (qualify_domain_recipient == NULL)
3398 qualify_domain_recipient = qualify_domain_sender;
3400 /* Setting system_filter_user in the configuration sets the gid as well if a
3401 name is given, but a numerical value does not. */
3403 if (system_filter_uid_set && !system_filter_gid_set)
3405 struct passwd *pw = getpwuid(system_filter_uid);
3407 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3408 (long int)system_filter_uid);
3409 system_filter_gid = pw->pw_gid;
3410 system_filter_gid_set = TRUE;
3413 /* If the errors_reply_to field is set, check that it is syntactically valid
3414 and ensure it contains a domain. */
3416 if (errors_reply_to != NULL)
3419 int start, end, domain;
3420 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3421 &start, &end, &domain, FALSE);
3423 if (recipient == NULL)
3424 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3425 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3428 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3429 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3432 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3433 smtp_accept_max must also be set. */
3435 if (smtp_accept_max == 0 &&
3436 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3437 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3438 "smtp_accept_max must be set if smtp_accept_queue or "
3439 "smtp_accept_max_per_host is set");
3441 /* Set up the host number if anything is specified. It is an expanded string
3442 so that it can be computed from the host name, for example. We do this last
3443 so as to ensure that everything else is set up before the expansion. */
3445 if (host_number_string != NULL)
3449 uschar *s = expand_string(host_number_string);
3451 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3452 "failed to expand localhost_number \"%s\": %s",
3453 host_number_string, expand_string_message);
3454 n = Ustrtol(s, &end, 0);
3455 while (isspace(*end)) end++;
3457 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3458 "localhost_number value is not a number: %s", s);
3459 if (n > LOCALHOST_MAX)
3460 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3461 "localhost_number is greater than the maximum allowed value (%d)",
3467 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3469 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3470 tls_verify_certificates == NULL)
3471 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3472 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3473 (tls_verify_hosts != NULL)? "" : "try_");
3475 /* This also checks that the library linkage is working and we can call
3476 routines in it, so call even if tls_require_ciphers is unset */
3477 if (!tls_dropprivs_validate_require_cipher(nowarn))
3480 /* Magic number: at time of writing, 1024 has been the long-standing value
3481 used by so many clients, and what Exim used to use always, that it makes
3482 sense to just min-clamp this max-clamp at that. */
3483 if (tls_dh_max_bits < 1024)
3484 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3485 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3487 /* If openssl_options is set, validate it */
3488 if (openssl_options != NULL)
3491 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3492 "openssl_options is set but we're using GnuTLS");
3495 if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3496 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3497 "openssl_options parse error: %s", openssl_options);
3501 if (!nowarn && (gnutls_require_kx || gnutls_require_mac || gnutls_require_proto))
3502 log_write(0, LOG_MAIN, "WARNING: main options"
3503 " gnutls_require_kx, gnutls_require_mac and gnutls_require_protocols"
3505 #endif /*SUPPORT_TLS*/
3507 if (!nowarn && !keep_environment && environ && *environ)
3508 log_write(0, LOG_MAIN,
3509 "Warning: purging the environment.\n"
3510 " Suggested action: use keep_environment.");
3515 /*************************************************
3516 * Initialize one driver *
3517 *************************************************/
3519 /* This is called once the driver's generic options, if any, have been read.
3520 We can now find the driver, set up defaults for the private options, and
3521 unset any "set" bits in the private options table (which might have been
3522 set by another incarnation of the same driver).
3525 d pointer to driver instance block, with generic
3527 drivers_available vector of available drivers
3528 size_of_info size of each block in drivers_available
3529 class class of driver, for error message
3531 Returns: pointer to the driver info block
3534 static driver_info *
3535 init_driver(driver_instance *d, driver_info *drivers_available,
3536 int size_of_info, uschar *class)
3540 for (dd = drivers_available; dd->driver_name[0] != 0;
3541 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3543 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3546 int len = dd->options_len;
3548 d->options_block = store_get(len);
3549 memcpy(d->options_block, dd->options_block, len);
3550 for (i = 0; i < *(dd->options_count); i++)
3551 dd->options[i].type &= ~opt_set;
3556 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3557 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3559 return NULL; /* never obeyed */
3565 /*************************************************
3566 * Initialize driver list *
3567 *************************************************/
3569 /* This function is called for routers, transports, and authentication
3570 mechanisms. It reads the data from the current point in the configuration file
3571 up to the end of the section, and sets up a chain of instance blocks according
3572 to the file's contents. The file will already have been opened by a call to
3573 readconf_main, and must be left open for subsequent reading of further data.
3575 Any errors cause a panic crash. Note that the blocks with names driver_info and
3576 driver_instance must map the first portions of all the _info and _instance
3577 blocks for this shared code to work.
3580 class "router", "transport", or "authenticator"
3581 anchor &routers, &transports, &auths
3582 drivers_available available drivers
3583 size_of_info size of each info block
3584 instance_default points to default data for an instance
3585 instance_size size of instance block
3586 driver_optionlist generic option list
3587 driver_optionlist_count count of generic option list
3593 readconf_driver_init(
3595 driver_instance **anchor,
3596 driver_info *drivers_available,
3598 void *instance_default,
3600 optionlist *driver_optionlist,
3601 int driver_optionlist_count)
3603 driver_instance **p = anchor;
3604 driver_instance *d = NULL;
3607 while ((buffer = get_config_line()) != NULL)
3612 /* Read the first name on the line and test for the start of a new driver. A
3613 macro definition indicates the end of the previous driver. If this isn't the
3614 start of a new driver, the line will be re-read. */
3616 s = readconf_readname(name, sizeof(name), buffer);
3618 /* Handle macro definition, first finishing off the initialization of the
3619 previous driver, if any. */
3621 if (isupper(*name) && *s == '=')
3625 if (!d->driver_name)
3626 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3627 "no driver defined for %s \"%s\"", class, d->name);
3631 read_macro_assignment(buffer);
3635 /* If the line starts with a name terminated by a colon, we are at the
3636 start of the definition of a new driver. The rest of the line must be
3643 /* Finish off initializing the previous driver. */
3647 if (!d->driver_name)
3648 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3649 "no driver defined for %s \"%s\"", class, d->name);
3653 /* Check that we haven't already got a driver of this name */
3655 for (d = *anchor; d; d = d->next)
3656 if (Ustrcmp(name, d->name) == 0)
3657 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3658 "there are two %ss called \"%s\"", class, name);
3660 /* Set up a new driver instance data block on the chain, with
3661 its default values installed. */
3663 d = store_get(instance_size);
3664 memcpy(d, instance_default, instance_size);
3667 d->name = string_copy(name);
3669 /* Clear out the "set" bits in the generic options */
3671 for (i = 0; i < driver_optionlist_count; i++)
3672 driver_optionlist[i].type &= ~opt_set;
3674 /* Check nothing more on this line, then do the next loop iteration. */
3676 while (isspace(*s)) s++;
3677 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3681 /* Not the start of a new driver. Give an error if we have not set up a
3682 current driver yet. */
3685 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3687 /* First look to see if this is a generic option; if it is "driver",
3688 initialize the driver. If is it not a generic option, we can look for a
3689 private option provided that the driver has been previously set up. */
3691 if (readconf_handle_option(buffer, driver_optionlist,
3692 driver_optionlist_count, d, NULL))
3694 if (!d->info && d->driver_name)
3695 init_driver(d, drivers_available, size_of_info, class);
3698 /* Handle private options - pass the generic block because some may
3699 live therein. A flag with each option indicates if it is in the public
3703 readconf_handle_option(buffer, d->info->options,
3704 *(d->info->options_count), d, US"option \"%s\" unknown");
3706 /* The option is not generic and the driver name has not yet been given. */
3708 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3709 "(\"driver\" must be specified before any private options)", name);
3712 /* Run the initialization function for the final driver. */
3716 if (!d->driver_name)
3717 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3718 "no driver defined for %s \"%s\"", class, d->name);
3725 /*************************************************
3726 * Check driver dependency *
3727 *************************************************/
3729 /* This function is passed a driver instance and a string. It checks whether
3730 any of the string options for the driver contains the given string as an
3734 d points to a driver instance block
3735 s the string to search for
3737 Returns: TRUE if a dependency is found
3741 readconf_depends(driver_instance *d, uschar *s)
3743 int count = *(d->info->options_count);
3747 for (ol = d->info->options; ol < d->info->options + count; ol++)
3749 void *options_block;
3751 int type = ol->type & opt_mask;
3752 if (type != opt_stringptr) continue;
3753 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3754 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3755 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3757 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3758 isalnum(ss[Ustrlen(s)])) continue;
3759 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3760 d->name, ol->name, s);
3765 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3772 /*************************************************
3773 * Decode an error type for retries *
3774 *************************************************/
3776 /* This function is global because it is also called from the main
3777 program when testing retry information. It decodes strings such as "quota_7d"
3778 into numerical error codes.
3781 pp points to start of text
3782 p points past end of text
3783 basic_errno points to an int to receive the main error number
3784 more_errno points to an int to receive the secondary error data
3786 Returns: NULL if decoded correctly; else points to error text
3790 readconf_retry_error(const uschar *pp, const uschar *p,
3791 int *basic_errno, int *more_errno)
3794 const uschar *q = pp;
3795 while (q < p && *q != '_') q++;
3798 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3800 *basic_errno = ERRNO_EXIMQUOTA;
3801 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3802 return US"bad time value";
3805 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3807 *basic_errno = ECONNREFUSED;
3810 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3811 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3812 else return US"A or MX expected after \"refused\"";
3816 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3818 *basic_errno = ETIMEDOUT;
3822 int xlen = p - q - 1;
3823 const uschar *x = q + 1;
3825 static uschar *extras[] =
3826 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
3827 static int values[] =
3828 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3830 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3831 if (strncmpic(x, extras[i], xlen) == 0)
3833 *more_errno = values[i];
3837 if (i >= sizeof(extras)/sizeof(uschar *))
3838 if (strncmpic(x, US"DNS", xlen) == 0)
3839 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3840 "available in retry rules (it has never worked) - treated as "
3843 return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3847 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
3848 strncmpic(pp, US"rcpt_4", 6) == 0 ||
3849 strncmpic(pp, US"data_4", 6) == 0)
3852 int x = 255; /* means "any 4xx code" */
3853 if (p != pp + 8) bad = TRUE; else
3855 int a = pp[6], b = pp[7];
3859 if (isdigit(b)) x += b - '0';
3860 else if (b == 'x') x += 100;
3863 else if (a != 'x' || b != 'x') bad = TRUE;
3867 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3868 "x is literal and d is any digit", pp);
3870 *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
3871 *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
3872 *more_errno = x << 8;
3875 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3876 strncmpic(q+1, US"failed", p-q-1) == 0)
3877 *basic_errno = ERRNO_AUTHFAIL;
3879 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
3880 *basic_errno = ERRNO_SMTPCLOSED;
3882 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
3883 *basic_errno = ERRNO_TLSREQUIRED;
3885 else if (strncmpic(pp, US"lookup", p - pp) == 0)
3886 *basic_errno = ERRNO_UNKNOWNHOST;
3888 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3889 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
3897 /*************************************************
3898 * Read retry information *
3899 *************************************************/
3901 /* Each line of retry information contains:
3903 . A domain name pattern or an address pattern;
3905 . An error name, possibly with additional data, or *;
3907 . An optional sequence of retry items, each consisting of an identifying
3908 letter, a cutoff time, and optional parameters.
3910 All this is decoded and placed into a control block. */
3913 /* Subroutine to read an argument, preceded by a comma and terminated
3914 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3915 1 = fixed point number (returned *1000).
3918 paddr pointer to pointer to current character; updated
3919 type 0 => read a time; 1 => read a fixed point number
3921 Returns: time in seconds or fixed point number * 1000
3925 retry_arg(const uschar **paddr, int type)
3927 const uschar *p = *paddr;
3930 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3932 while (isspace(*p)) p++;
3934 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3936 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3937 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3942 case 0: return readconf_readtime(pp, *p, FALSE);
3943 case 1: return readconf_readfixed(pp, *p);
3945 return 0; /* Keep picky compilers happy */
3948 /* The function proper */
3951 readconf_retries(void)
3953 retry_config **chain = &retries;
3957 while ((p = get_config_line()))
3959 retry_rule **rchain;
3963 next = store_get(sizeof(retry_config));
3966 chain = &(next->next);
3967 next->basic_errno = next->more_errno = 0;
3968 next->senders = NULL;
3970 rchain = &(next->rules);
3972 next->pattern = string_dequote(&p);
3973 while (isspace(*p)) p++;
3975 while (mac_isgraph(*p)) p++;
3976 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3977 "missing error type in retry rule");
3979 /* Test error names for things we understand. */
3981 if ((error = readconf_retry_error(pp, p, &next->basic_errno,
3982 &next->more_errno)))
3983 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3985 /* There may be an optional address list of senders to be used as another
3986 constraint on the rule. This was added later, so the syntax is a bit of a
3987 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3990 while (isspace(*p)) p++;
3991 if (Ustrncmp(p, "senders", 7) == 0)
3994 while (isspace(*p)) p++;
3995 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3996 "\"=\" expected after \"senders\" in retry rule");
3997 while (isspace(*p)) p++;
3998 next->senders = string_dequote(&p);
4001 /* Now the retry rules. Keep the maximum timeout encountered. */
4003 while (isspace(*p)) p++;
4007 retry_rule *rule = store_get(sizeof(retry_rule));
4009 rchain = &(rule->next);
4011 rule->rule = toupper(*p++);
4012 rule->timeout = retry_arg(&p, 0);
4013 if (rule->timeout > retry_maximum_timeout)
4014 retry_maximum_timeout = rule->timeout;
4018 case 'F': /* Fixed interval */
4019 rule->p1 = retry_arg(&p, 0);
4022 case 'G': /* Geometrically increasing intervals */
4023 case 'H': /* Ditto, but with randomness */
4024 rule->p1 = retry_arg(&p, 0);
4025 rule->p2 = retry_arg(&p, 1);
4029 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4033 if (rule->timeout <= 0 || rule->p1 <= 0 ||
4034 (rule->rule != 'F' && rule->p2 < 1000))
4035 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4036 "bad parameters for retry rule");
4038 while (isspace(*p)) p++;
4042 while (isspace(*p)) p++;
4045 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4052 /*************************************************
4053 * Initialize authenticators *
4054 *************************************************/
4056 /* Read the authenticators section of the configuration file.
4065 auth_instance *au, *bu;
4066 readconf_driver_init(US"authenticator",
4067 (driver_instance **)(&auths), /* chain anchor */
4068 (driver_info *)auths_available, /* available drivers */
4069 sizeof(auth_info), /* size of info block */
4070 &auth_defaults, /* default values for generic options */
4071 sizeof(auth_instance), /* size of instance block */
4072 optionlist_auths, /* generic options */
4073 optionlist_auths_size);
4075 for (au = auths; au; au = au->next)
4077 if (!au->public_name)
4078 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4079 "the %s authenticator", au->name);
4081 for (bu = au->next; bu; bu = bu->next)
4082 if (strcmpic(au->public_name, bu->public_name) == 0)
4083 if ((au->client && bu->client) || (au->server && bu->server))
4084 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4085 "(%s and %s) have the same public name (%s)",
4086 au->client ? US"client" : US"server", au->name, bu->name,
4094 /*************************************************
4095 * Read ACL information *
4096 *************************************************/
4098 /* If this run of Exim is not doing something that involves receiving a
4099 message, we can just skip over the ACL information. No need to parse it.
4101 First, we have a function for acl_read() to call back to get the next line. We
4102 need to remember the line we passed, because at the end it will contain the
4103 name of the next ACL. */
4105 static uschar *acl_line;
4110 acl_line = get_config_line();
4115 /* Now the main function:
4126 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4129 acl_line = get_config_line();
4131 while(acl_line != NULL)
4137 p = readconf_readname(name, sizeof(name), acl_line);
4138 if (isupper(*name) && *p == '=')
4140 read_macro_assignment(acl_line);
4141 acl_line = get_config_line();
4145 if (*p != ':' || name[0] == 0)
4146 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4148 node = store_get(sizeof(tree_node) + Ustrlen(name));
4149 Ustrcpy(node->name, name);
4150 if (!tree_insertnode(&acl_anchor, node))
4151 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4152 "there are two ACLs called \"%s\"", name);
4154 node->data.ptr = acl_read(acl_callback, &error);
4156 if (node->data.ptr == NULL && error != NULL)
4157 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4163 /*************************************************
4164 * Read configuration for local_scan() *
4165 *************************************************/
4167 /* This function is called after "begin local_scan" is encountered in the
4168 configuration file. If the local_scan() function allows for configuration
4169 options, we can process them. Otherwise, we expire in a panic.
4176 local_scan_init(void)
4178 #ifndef LOCAL_SCAN_HAS_OPTIONS
4179 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4180 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4184 while ((p = get_config_line()) != NULL)
4186 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4187 NULL, US"local_scan option \"%s\" unknown");
4194 /*************************************************
4195 * Read rest of configuration (after main) *
4196 *************************************************/
4198 /* This function reads the rest of the runtime configuration, after the main
4199 configuration. It is called only when actually needed. Each subsequent section
4200 of the configuration starts with a line of the form
4204 where the name is "routers", "transports", etc. A section is terminated by
4205 hitting the next "begin" line, and the next name is left in next_section.
4206 Because it may confuse people as to whether the names are singular or plural,
4207 we add "s" if it's missing. There is always enough room in next_section for
4208 this. This function is basically just a switch.
4214 static uschar *section_list[] = {
4228 while(next_section[0] != 0)
4232 int last = sizeof(section_list) / sizeof(uschar *);
4234 int n = Ustrlen(next_section);
4236 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4240 int c = strcmpic(next_section, section_list[mid]);
4242 if (c > 0) first = mid + 1; else last = mid;
4244 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4245 "\"%.*s\" is not a known configuration section name", n, next_section);
4246 mid = (last + first)/2;
4250 if (((had ^= bit) & bit) == 0)
4251 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4252 "\"%.*s\" section is repeated in the configuration file", n,
4257 case 0: readconf_acl(); break;
4258 case 1: auths_init(); break;
4259 case 2: local_scan_init(); break;
4260 case 3: readconf_retries(); break;
4261 case 4: readconf_rewrites(); break;
4262 case 5: route_init(); break;
4263 case 6: transport_init(); break;
4267 (void)fclose(config_file);
4270 /* Init the storage for the pre-parsed config lines */
4272 readconf_save_config(const uschar *s)
4274 save_config_line(string_sprintf("# Exim Configuration (%s)",
4275 running_in_test_harness ? US"X" : s));
4279 save_config_position(const uschar *file, int line)
4281 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4284 /* Append a pre-parsed logical line to the config lines store,
4285 this operates on a global (static) list that holds all the pre-parsed
4286 config lines, we do no further processing here, output formatting and
4287 honouring of <hide> or macros will be done during output */
4289 save_config_line(const uschar* line)
4291 static config_line_item *current;
4292 config_line_item *next;
4294 next = (config_line_item*) store_get(sizeof(config_line_item));
4295 next->line = string_copy(line);
4298 if (!config_lines) config_lines = next;
4299 else current->next = next;
4304 /* List the parsed config lines, care about nice formatting and
4305 hide the <hide> values unless we're the admin user */
4307 print_config(BOOL admin, BOOL terse)
4309 config_line_item *i;
4310 const int TS = terse ? 0 : 2;
4313 for (i = config_lines; i; i = i->next)
4318 /* skip over to the first non-space */
4319 for (current = i->line; *current && isspace(*current); ++current)
4322 if (*current == '\0')
4325 /* Collapse runs of spaces. We stop this if we encounter one of the
4326 * following characters: "'$, as this may indicate careful formatting */
4327 for (p = current; *p; ++p)
4330 if (!isspace(*p)) continue;
4331 if (*p != ' ') *p = ' ';
4333 for (next = p; isspace(*next); ++next)
4337 memmove(p+1, next, Ustrlen(next)+1);
4339 if (*next == '"' || *next == '\'' || *next == '$')
4344 if (current[0] == '#')
4347 /* begin lines are left aligned */
4348 else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4350 if (!terse) puts("");
4355 /* router/acl/transport block names */
4356 else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4358 if (!terse) puts("");
4359 printf("%*s%s\n", TS, "", current);
4363 /* hidden lines (all MACROS or lines prefixed with "hide") */
4365 && ( isupper(*current)
4366 || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4370 if ((p = Ustrchr(current, '=')))
4373 printf("%*s%s= %s\n", indent, "", current, hidden);
4375 /* e.g.: hide split_spool_directory */
4377 printf("%*s\n", indent, hidden);
4381 /* rest is public */
4382 printf("%*s%s\n", indent, "", current);
4388 /* End of readconf.c */