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);
20 static void readconf_options_auths(void);
23 #define CSTATE_STACK_SIZE 10
26 /* Structure for chain (stack) of .included files */
28 typedef struct config_file_item {
29 struct config_file_item *next;
35 /* Structure for chain of configuration lines (-bP config) */
37 typedef struct config_line_item {
38 struct config_line_item *next;
42 static config_line_item* config_lines;
44 /* Structure of table of conditional words and their state transitions */
46 typedef struct cond_item {
54 /* Structure of table of syslog facility names and values */
56 typedef struct syslog_fac_item {
62 static const char * const hidden = "<value not displayable>";
64 /* Static variables */
66 static config_file_item *config_file_stack = NULL; /* For includes */
68 static uschar *syslog_facility_str = NULL;
69 static uschar next_section[24];
70 static uschar time_buffer[24];
72 /* State variables for conditional loading (.ifdef / .else / .endif) */
74 static int cstate = 0;
75 static int cstate_stack_ptr = -1;
76 static int cstate_stack[CSTATE_STACK_SIZE];
78 /* Table of state transitions for handling conditional inclusions. There are
79 four possible state transitions:
83 .elifdef true (or .else)
86 .endif just causes the previous cstate to be popped off the stack */
88 static int next_cstate[3][4] =
90 /* State 0: reading from file, or reading until next .else or .endif */
92 /* State 1: condition failed, skipping until next .else or .endif */
94 /* State 2: skipping until .endif */
98 /* Table of conditionals and the states to set. For each name, there are four
99 values: the length of the name (to save computing it each time), the state to
100 set if a macro was found in the line, the state to set if a macro was not found
101 in the line, and a stack manipulation setting which is:
103 -1 pull state value off the stack
104 0 don't alter the stack
105 +1 push value onto stack, before setting new state
108 static cond_item cond_list[] = {
109 { US"ifdef", 5, 0, 1, 1 },
110 { US"ifndef", 6, 1, 0, 1 },
111 { US"elifdef", 7, 2, 3, 0 },
112 { US"elifndef", 8, 3, 2, 0 },
113 { US"else", 4, 2, 2, 0 },
114 { US"endif", 5, 0, 0, -1 }
117 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
119 /* Table of syslog facility names and their values */
121 static syslog_fac_item syslog_list[] = {
122 { US"mail", LOG_MAIL },
123 { US"user", LOG_USER },
124 { US"news", LOG_NEWS },
125 { US"uucp", LOG_UUCP },
126 { US"local0", LOG_LOCAL0 },
127 { US"local1", LOG_LOCAL1 },
128 { US"local2", LOG_LOCAL2 },
129 { US"local3", LOG_LOCAL3 },
130 { US"local4", LOG_LOCAL4 },
131 { US"local5", LOG_LOCAL5 },
132 { US"local6", LOG_LOCAL6 },
133 { US"local7", LOG_LOCAL7 },
134 { US"daemon", LOG_DAEMON }
137 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
142 /*************************************************
143 * Main configuration options *
144 *************************************************/
146 /* The list of options that can be set in the main configuration file. This
147 must be in alphabetic order because it is searched by binary chop. */
149 static optionlist optionlist_config[] = {
150 { "*set_exim_group", opt_bool|opt_hidden, &exim_gid_set },
151 { "*set_exim_user", opt_bool|opt_hidden, &exim_uid_set },
152 { "*set_system_filter_group", opt_bool|opt_hidden, &system_filter_gid_set },
153 { "*set_system_filter_user", opt_bool|opt_hidden, &system_filter_uid_set },
154 { "accept_8bitmime", opt_bool, &accept_8bitmime },
155 { "acl_not_smtp", opt_stringptr, &acl_not_smtp },
156 #ifdef WITH_CONTENT_SCAN
157 { "acl_not_smtp_mime", opt_stringptr, &acl_not_smtp_mime },
159 { "acl_not_smtp_start", opt_stringptr, &acl_not_smtp_start },
160 { "acl_smtp_auth", opt_stringptr, &acl_smtp_auth },
161 { "acl_smtp_connect", opt_stringptr, &acl_smtp_connect },
162 { "acl_smtp_data", opt_stringptr, &acl_smtp_data },
164 { "acl_smtp_data_prdr", opt_stringptr, &acl_smtp_data_prdr },
167 { "acl_smtp_dkim", opt_stringptr, &acl_smtp_dkim },
169 { "acl_smtp_etrn", opt_stringptr, &acl_smtp_etrn },
170 { "acl_smtp_expn", opt_stringptr, &acl_smtp_expn },
171 { "acl_smtp_helo", opt_stringptr, &acl_smtp_helo },
172 { "acl_smtp_mail", opt_stringptr, &acl_smtp_mail },
173 { "acl_smtp_mailauth", opt_stringptr, &acl_smtp_mailauth },
174 #ifdef WITH_CONTENT_SCAN
175 { "acl_smtp_mime", opt_stringptr, &acl_smtp_mime },
177 { "acl_smtp_notquit", opt_stringptr, &acl_smtp_notquit },
178 { "acl_smtp_predata", opt_stringptr, &acl_smtp_predata },
179 { "acl_smtp_quit", opt_stringptr, &acl_smtp_quit },
180 { "acl_smtp_rcpt", opt_stringptr, &acl_smtp_rcpt },
182 { "acl_smtp_starttls", opt_stringptr, &acl_smtp_starttls },
184 { "acl_smtp_vrfy", opt_stringptr, &acl_smtp_vrfy },
185 { "add_environment", opt_stringptr, &add_environment },
186 { "admin_groups", opt_gidlist, &admin_groups },
187 { "allow_domain_literals", opt_bool, &allow_domain_literals },
188 { "allow_mx_to_ip", opt_bool, &allow_mx_to_ip },
189 { "allow_utf8_domains", opt_bool, &allow_utf8_domains },
190 { "auth_advertise_hosts", opt_stringptr, &auth_advertise_hosts },
191 { "auto_thaw", opt_time, &auto_thaw },
192 #ifdef WITH_CONTENT_SCAN
193 { "av_scanner", opt_stringptr, &av_scanner },
195 { "bi_command", opt_stringptr, &bi_command },
196 #ifdef EXPERIMENTAL_BRIGHTMAIL
197 { "bmi_config_file", opt_stringptr, &bmi_config_file },
199 { "bounce_message_file", opt_stringptr, &bounce_message_file },
200 { "bounce_message_text", opt_stringptr, &bounce_message_text },
201 { "bounce_return_body", opt_bool, &bounce_return_body },
202 { "bounce_return_linesize_limit", opt_mkint, &bounce_return_linesize_limit },
203 { "bounce_return_message", opt_bool, &bounce_return_message },
204 { "bounce_return_size_limit", opt_mkint, &bounce_return_size_limit },
205 { "bounce_sender_authentication",opt_stringptr,&bounce_sender_authentication },
206 { "callout_domain_negative_expire", opt_time, &callout_cache_domain_negative_expire },
207 { "callout_domain_positive_expire", opt_time, &callout_cache_domain_positive_expire },
208 { "callout_negative_expire", opt_time, &callout_cache_negative_expire },
209 { "callout_positive_expire", opt_time, &callout_cache_positive_expire },
210 { "callout_random_local_part",opt_stringptr, &callout_random_local_part },
211 { "check_log_inodes", opt_int, &check_log_inodes },
212 { "check_log_space", opt_Kint, &check_log_space },
213 { "check_rfc2047_length", opt_bool, &check_rfc2047_length },
214 { "check_spool_inodes", opt_int, &check_spool_inodes },
215 { "check_spool_space", opt_Kint, &check_spool_space },
216 { "chunking_advertise_hosts", opt_stringptr, &chunking_advertise_hosts },
217 { "daemon_smtp_port", opt_stringptr|opt_hidden, &daemon_smtp_port },
218 { "daemon_smtp_ports", opt_stringptr, &daemon_smtp_port },
219 { "daemon_startup_retries", opt_int, &daemon_startup_retries },
220 { "daemon_startup_sleep", opt_time, &daemon_startup_sleep },
221 #ifdef EXPERIMENTAL_DCC
222 { "dcc_direct_add_header", opt_bool, &dcc_direct_add_header },
223 { "dccifd_address", opt_stringptr, &dccifd_address },
224 { "dccifd_options", opt_stringptr, &dccifd_options },
226 { "delay_warning", opt_timelist, &delay_warning },
227 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
228 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
229 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
230 { "delivery_date_remove", opt_bool, &delivery_date_remove },
231 #ifdef ENABLE_DISABLE_FSYNC
232 { "disable_fsync", opt_bool, &disable_fsync },
234 { "disable_ipv6", opt_bool, &disable_ipv6 },
236 { "dkim_verify_signers", opt_stringptr, &dkim_verify_signers },
238 #ifdef EXPERIMENTAL_DMARC
239 { "dmarc_forensic_sender", opt_stringptr, &dmarc_forensic_sender },
240 { "dmarc_history_file", opt_stringptr, &dmarc_history_file },
241 { "dmarc_tld_file", opt_stringptr, &dmarc_tld_file },
243 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
244 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
245 { "dns_csa_search_limit", opt_int, &dns_csa_search_limit },
246 { "dns_csa_use_reverse", opt_bool, &dns_csa_use_reverse },
247 { "dns_dnssec_ok", opt_int, &dns_dnssec_ok },
248 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
249 { "dns_retrans", opt_time, &dns_retrans },
250 { "dns_retry", opt_int, &dns_retry },
251 { "dns_trust_aa", opt_stringptr, &dns_trust_aa },
252 { "dns_use_edns0", opt_int, &dns_use_edns0 },
253 /* This option is now a no-op, retained for compability */
254 { "drop_cr", opt_bool, &drop_cr },
255 /*********************************************************/
256 { "dsn_advertise_hosts", opt_stringptr, &dsn_advertise_hosts },
257 { "dsn_from", opt_stringptr, &dsn_from },
258 { "envelope_to_remove", opt_bool, &envelope_to_remove },
259 { "errors_copy", opt_stringptr, &errors_copy },
260 { "errors_reply_to", opt_stringptr, &errors_reply_to },
261 #ifndef DISABLE_EVENT
262 { "event_action", opt_stringptr, &event_action },
264 { "exim_group", opt_gid, &exim_gid },
265 { "exim_path", opt_stringptr, &exim_path },
266 { "exim_user", opt_uid, &exim_uid },
267 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
268 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
269 { "finduser_retries", opt_int, &finduser_retries },
270 { "freeze_tell", opt_stringptr, &freeze_tell },
271 { "gecos_name", opt_stringptr, &gecos_name },
272 { "gecos_pattern", opt_stringptr, &gecos_pattern },
274 { "gnutls_allow_auto_pkcs11", opt_bool, &gnutls_allow_auto_pkcs11 },
275 { "gnutls_compat_mode", opt_bool, &gnutls_compat_mode },
277 { "header_line_maxsize", opt_int, &header_line_maxsize },
278 { "header_maxsize", opt_int, &header_maxsize },
279 { "headers_charset", opt_stringptr, &headers_charset },
280 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
281 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
282 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
283 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
284 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
285 { "hold_domains", opt_stringptr, &hold_domains },
286 { "host_lookup", opt_stringptr, &host_lookup },
287 { "host_lookup_order", opt_stringptr, &host_lookup_order },
288 { "host_reject_connection", opt_stringptr, &host_reject_connection },
289 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
291 { "hosts_proxy", opt_stringptr, &hosts_proxy },
293 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
295 { "ibase_servers", opt_stringptr, &ibase_servers },
297 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
298 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
299 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
300 { "keep_environment", opt_stringptr, &keep_environment },
301 { "keep_malformed", opt_time, &keep_malformed },
303 { "ldap_ca_cert_dir", opt_stringptr, &eldap_ca_cert_dir },
304 { "ldap_ca_cert_file", opt_stringptr, &eldap_ca_cert_file },
305 { "ldap_cert_file", opt_stringptr, &eldap_cert_file },
306 { "ldap_cert_key", opt_stringptr, &eldap_cert_key },
307 { "ldap_cipher_suite", opt_stringptr, &eldap_cipher_suite },
308 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
309 { "ldap_require_cert", opt_stringptr, &eldap_require_cert },
310 { "ldap_start_tls", opt_bool, &eldap_start_tls },
311 { "ldap_version", opt_int, &eldap_version },
313 { "local_from_check", opt_bool, &local_from_check },
314 { "local_from_prefix", opt_stringptr, &local_from_prefix },
315 { "local_from_suffix", opt_stringptr, &local_from_suffix },
316 { "local_interfaces", opt_stringptr, &local_interfaces },
317 { "local_scan_timeout", opt_time, &local_scan_timeout },
318 { "local_sender_retain", opt_bool, &local_sender_retain },
319 { "localhost_number", opt_stringptr, &host_number_string },
320 { "log_file_path", opt_stringptr, &log_file_path },
321 { "log_selector", opt_stringptr, &log_selector_string },
322 { "log_timezone", opt_bool, &log_timezone },
323 { "lookup_open_max", opt_int, &lookup_open_max },
324 { "max_username_length", opt_int, &max_username_length },
325 { "message_body_newlines", opt_bool, &message_body_newlines },
326 { "message_body_visible", opt_mkint, &message_body_visible },
327 { "message_id_header_domain", opt_stringptr, &message_id_domain },
328 { "message_id_header_text", opt_stringptr, &message_id_text },
329 { "message_logs", opt_bool, &message_logs },
330 { "message_size_limit", opt_stringptr, &message_size_limit },
331 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
332 { "move_frozen_messages", opt_bool, &move_frozen_messages },
334 { "mua_wrapper", opt_bool, &mua_wrapper },
336 { "mysql_servers", opt_stringptr, &mysql_servers },
338 { "never_users", opt_uidlist, &never_users },
340 { "openssl_options", opt_stringptr, &openssl_options },
343 { "oracle_servers", opt_stringptr, &oracle_servers },
345 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
347 { "perl_at_start", opt_bool, &opt_perl_at_start },
348 { "perl_startup", opt_stringptr, &opt_perl_startup },
349 { "perl_taintmode", opt_bool, &opt_perl_taintmode },
352 { "pgsql_servers", opt_stringptr, &pgsql_servers },
354 { "pid_file_path", opt_stringptr, &pid_file_path },
355 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
357 { "prdr_enable", opt_bool, &prdr_enable },
359 { "preserve_message_logs", opt_bool, &preserve_message_logs },
360 { "primary_hostname", opt_stringptr, &primary_hostname },
361 { "print_topbitchars", opt_bool, &print_topbitchars },
362 { "process_log_path", opt_stringptr, &process_log_path },
363 { "prod_requires_admin", opt_bool, &prod_requires_admin },
364 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
365 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
366 { "queue_domains", opt_stringptr, &queue_domains },
367 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
368 { "queue_only", opt_bool, &queue_only },
369 { "queue_only_file", opt_stringptr, &queue_only_file },
370 { "queue_only_load", opt_fixed, &queue_only_load },
371 { "queue_only_load_latch", opt_bool, &queue_only_load_latch },
372 { "queue_only_override", opt_bool, &queue_only_override },
373 { "queue_run_in_order", opt_bool, &queue_run_in_order },
374 { "queue_run_max", opt_stringptr, &queue_run_max },
375 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
376 { "receive_timeout", opt_time, &receive_timeout },
377 { "received_header_text", opt_stringptr, &received_header_text },
378 { "received_headers_max", opt_int, &received_headers_max },
379 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
380 { "recipients_max", opt_int, &recipients_max },
381 { "recipients_max_reject", opt_bool, &recipients_max_reject },
383 { "redis_servers", opt_stringptr, &redis_servers },
385 { "remote_max_parallel", opt_int, &remote_max_parallel },
386 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
387 { "retry_data_expire", opt_time, &retry_data_expire },
388 { "retry_interval_max", opt_time, &retry_interval_max },
389 { "return_path_remove", opt_bool, &return_path_remove },
390 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
391 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
392 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
393 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
394 { "slow_lookup_log", opt_int, &slow_lookup_log },
395 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
396 { "smtp_accept_max", opt_int, &smtp_accept_max },
397 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
398 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
399 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
400 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
401 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
402 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
403 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
404 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
405 { "smtp_banner", opt_stringptr, &smtp_banner },
406 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
407 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
408 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
409 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
410 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
411 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
412 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
413 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
414 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
415 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
416 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
417 { "smtp_receive_timeout", opt_func, &fn_smtp_receive_timeout },
418 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
419 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
421 { "smtputf8_advertise_hosts", opt_stringptr, &smtputf8_advertise_hosts },
423 #ifdef WITH_CONTENT_SCAN
424 { "spamd_address", opt_stringptr, &spamd_address },
426 #ifdef EXPERIMENTAL_SPF
427 { "spf_guess", opt_stringptr, &spf_guess },
429 { "split_spool_directory", opt_bool, &split_spool_directory },
430 { "spool_directory", opt_stringptr, &spool_directory },
432 { "sqlite_lock_timeout", opt_int, &sqlite_lock_timeout },
434 #ifdef EXPERIMENTAL_SRS
435 { "srs_config", opt_stringptr, &srs_config },
436 { "srs_hashlength", opt_int, &srs_hashlength },
437 { "srs_hashmin", opt_int, &srs_hashmin },
438 { "srs_maxage", opt_int, &srs_maxage },
439 { "srs_secrets", opt_stringptr, &srs_secrets },
440 { "srs_usehash", opt_bool, &srs_usehash },
441 { "srs_usetimestamp", opt_bool, &srs_usetimestamp },
443 { "strict_acl_vars", opt_bool, &strict_acl_vars },
444 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
445 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
446 { "syslog_duplication", opt_bool, &syslog_duplication },
447 { "syslog_facility", opt_stringptr, &syslog_facility_str },
448 { "syslog_processname", opt_stringptr, &syslog_processname },
449 { "syslog_timestamp", opt_bool, &syslog_timestamp },
450 { "system_filter", opt_stringptr, &system_filter },
451 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
452 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
453 { "system_filter_group", opt_gid, &system_filter_gid },
454 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
455 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
456 { "system_filter_user", opt_uid, &system_filter_uid },
457 { "tcp_nodelay", opt_bool, &tcp_nodelay },
458 #ifdef USE_TCP_WRAPPERS
459 { "tcp_wrappers_daemon_name", opt_stringptr, &tcp_wrappers_daemon_name },
461 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
462 { "timezone", opt_stringptr, &timezone_string },
463 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
465 { "tls_certificate", opt_stringptr, &tls_certificate },
466 { "tls_crl", opt_stringptr, &tls_crl },
467 { "tls_dh_max_bits", opt_int, &tls_dh_max_bits },
468 { "tls_dhparam", opt_stringptr, &tls_dhparam },
469 { "tls_eccurve", opt_stringptr, &tls_eccurve },
470 # ifndef DISABLE_OCSP
471 { "tls_ocsp_file", opt_stringptr, &tls_ocsp_file },
473 { "tls_on_connect_ports", opt_stringptr, &tls_in.on_connect_ports },
474 { "tls_privatekey", opt_stringptr, &tls_privatekey },
475 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
476 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
477 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
478 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
479 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
481 { "trusted_groups", opt_gidlist, &trusted_groups },
482 { "trusted_users", opt_uidlist, &trusted_users },
483 { "unknown_login", opt_stringptr, &unknown_login },
484 { "unknown_username", opt_stringptr, &unknown_username },
485 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
486 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
487 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
488 { "warn_message_file", opt_stringptr, &warn_message_file },
489 { "write_rejectlog", opt_bool, &write_rejectlog }
492 static int optionlist_config_size = nelem(optionlist_config);
496 /*************************************************
497 * Find the name of an option *
498 *************************************************/
500 /* This function is to aid debugging. Various functions take arguments that are
501 pointer variables in the options table or in option tables for various drivers.
502 For debugging output, it is useful to be able to find the name of the option
503 which is currently being processed. This function finds it, if it exists, by
504 searching the table(s).
506 Arguments: a value that is presumed to be in the table above
507 Returns: the option name, or an empty string
511 readconf_find_option(void *p)
515 transport_instance *t;
517 for (i = 0; i < nelem(optionlist_config); i++)
518 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
520 for (r = routers; r; r = r->next)
522 router_info *ri = r->info;
523 for (i = 0; i < *ri->options_count; i++)
525 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
526 if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
527 return US ri->options[i].name;
531 for (t = transports; t; t = t->next)
533 transport_info *ti = t->info;
534 for (i = 0; i < *ti->options_count; i++)
536 optionlist * op = &ti->options[i];
537 if ((op->type & opt_mask) != opt_stringptr) continue;
538 if (p == ( op->type & opt_public
540 : (char *)t->options_block
542 + (long int)op->value)
553 /*************************************************
554 * Deal with an assignment to a macro *
555 *************************************************/
557 /* We have a new definition. The macro_item structure includes a final vector
558 called "name" which is one byte long. Thus, adding "namelen" gives us enough
559 room to store the "name" string. */
562 macro_create(const uschar * name, const uschar * val, BOOL command_line)
564 unsigned namelen = Ustrlen(name);
565 macro_item * m = store_get(sizeof(macro_item) + namelen);
567 if (!macros) macros = m; else mlast->next = m;
570 m->command_line = command_line;
571 m->namelen = namelen;
572 m->replacement = string_copy(val);
573 Ustrcpy(m->name, name);
578 /* This function is called when a line that starts with an upper case letter is
579 encountered. The argument "line" should contain a complete logical line, and
580 start with the first letter of the macro name. The macro name and the
581 replacement text are extracted and stored. Redefinition of existing,
582 non-command line, macros is permitted using '==' instead of '='.
585 s points to the start of the logical line
591 read_macro_assignment(uschar *s)
598 while (isalnum(*s) || *s == '_')
600 if (namelen >= sizeof(name) - 1)
601 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
602 "macro name too long (maximum is " SIZE_T_FMT " characters)", sizeof(name) - 1);
603 name[namelen++] = *s++;
607 while (isspace(*s)) s++;
609 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
616 while (isspace(*s)) s++;
618 /* If an existing macro of the same name was defined on the command line, we
619 just skip this definition. It's an error to attempt to redefine a macro without
620 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
621 It is also an error to define a macro whose name begins with the name of a
622 previously defined macro. This is the requirement that make using a tree
623 for macros hard; we must check all macros for the substring. Perhaps a
624 sorted list, and a bsearch, would work?
625 Note: it is documented that the other way round works. */
627 for (m = macros; m; m = m->next)
629 if (Ustrcmp(m->name, name) == 0)
631 if (!m->command_line && !redef)
632 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
633 "defined (use \"==\" if you want to redefine it", name);
637 if (m->namelen < namelen && Ustrstr(name, m->name) != NULL)
638 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
639 "a macro because previously defined macro \"%s\" is a substring",
642 /* We cannot have this test, because it is documented that a substring
643 macro is permitted (there is even an example).
645 * if (m->namelen > namelen && Ustrstr(m->name, name) != NULL)
646 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
647 * "a macro because it is a substring of previously defined macro \"%s\"",
652 /* Check for an overriding command-line definition. */
654 if (m && m->command_line) return;
656 /* Redefinition must refer to an existing macro. */
660 m->replacement = string_copy(s);
662 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
665 /* We have a new definition. */
667 (void) macro_create(name, s, FALSE);
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 replen = Ustrlen(m->replacement);
797 /* Expand the buffer if necessary */
799 while (newlen - m->namelen + replen + 1 > big_buffer_size)
801 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
802 uschar *newbuffer = store_malloc(newsize);
803 memcpy(newbuffer, big_buffer, newlen + 1);
804 p = newbuffer + (p - big_buffer);
805 s = newbuffer + (s - big_buffer);
806 ss = newbuffer + (ss - big_buffer);
807 t = newbuffer + (t - big_buffer);
808 big_buffer_size = newsize;
809 store_free(big_buffer);
810 big_buffer = newbuffer;
813 /* Shuffle the remaining characters up or down in the buffer before
814 copying in the replacement text. Don't rescan the replacement for this
818 if ((moveby = replen - m->namelen) != 0)
820 memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
823 Ustrncpy(p, m->replacement, replen);
829 /* An empty macro replacement at the start of a line could mean that ss no
830 longer points to the first non-blank character. */
832 while (isspace(*ss)) ss++;
834 /* Check for comment lines - these are physical lines. */
836 if (*ss == '#') continue;
838 /* Handle conditionals, which are also applied to physical lines. Conditions
839 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
840 expansion occured on the rest of the line. A preliminary test for the leading
841 '.' saves effort on most lines. */
847 /* Search the list of conditional directives */
849 for (i = 0; i < cond_list_size; i++)
852 cond_item *c = cond_list+i;
853 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
855 /* The following character must be white space or end of string */
857 n = ss[1 + c->namelen];
858 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
860 /* .ifdef and .ifndef push the current state onto the stack, then set
861 a new one from the table. Stack overflow is an error */
865 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
866 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
867 ".%s nested too deeply", c->name);
868 cstate_stack[++cstate_stack_ptr] = cstate;
869 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
872 /* For any of the others, stack underflow is an error. The next state
873 comes either from the stack (.endif) or from the table. */
877 if (cstate_stack_ptr < 0)
878 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
879 ".%s without matching .ifdef", c->name);
880 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
881 next_cstate[cstate][macro_found? c->action1 : c->action2];
884 /* Having dealt with a directive, break the loop */
889 /* If we have handled a conditional directive, continue with the next
890 physical line. Otherwise, fall through. */
892 if (i < cond_list_size) continue;
895 /* If the conditional state is not 0 (actively using these lines), ignore
898 if (cstate != 0) continue; /* Conditional skip */
900 /* Handle .include lines - these are also physical lines. */
902 if (Ustrncmp(ss, ".include", 8) == 0 &&
904 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
907 int include_if_exists = isspace(ss[8])? 0 : 10;
908 config_file_item *save;
911 ss += 9 + include_if_exists;
912 while (isspace(*ss)) ss++;
913 t = ss + Ustrlen(ss);
914 while (t > ss && isspace(t[-1])) t--;
915 if (*ss == '\"' && t[-1] == '\"')
923 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, ".include specifies a non-"
924 "absolute path \"%s\"", ss);
926 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
929 save_config_position(config_filename, config_lineno);
930 save = store_get(sizeof(config_file_item));
931 save->next = config_file_stack;
932 config_file_stack = save;
933 save->file = config_file;
934 save->filename = config_filename;
935 save->lineno = config_lineno;
937 if (!(config_file = Ufopen(ss, "rb")))
938 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
939 "configuration file %s", ss);
941 config_filename = string_copy(ss);
946 /* If this is the start of the logical line, remember where the non-blank
947 data starts. Otherwise shuffle down continuation lines to remove leading
951 startoffset = ss - big_buffer;
954 s = big_buffer + len;
957 memmove(s, ss, (newlen - len) - (ss - s) + 1);
962 /* Accept the new addition to the line. Remove trailing white space. */
965 while (len > 0 && isspace(big_buffer[len-1])) len--;
968 /* We are done if the line does not end in backslash and contains some data.
969 Empty logical lines are ignored. For continuations, remove the backslash and
970 go round the loop to read the continuation line. */
974 if (big_buffer[len-1] != '\\') break; /* End of logical line */
975 big_buffer[--len] = 0; /* Remove backslash */
977 } /* Loop for reading multiple physical lines */
979 /* We now have a logical line. Test for the end of a configuration section (or,
980 more accurately, for the start of the next section). Place the name of the next
981 section in next_section, and return NULL. If the name given is longer than
982 next_section, truncate it. It will be unrecognized later, because all the known
983 section names do fit. Leave space for pluralizing. */
985 s = big_buffer + startoffset; /* First non-space character */
990 if (strncmpic(s, US"begin ", 6) == 0)
993 while (isspace(*s)) s++;
994 if (big_buffer + len - s > sizeof(next_section) - 2)
995 s[sizeof(next_section) - 2] = 0;
996 Ustrcpy(next_section, s);
1000 /* Return the first non-blank character. */
1007 /*************************************************
1009 *************************************************/
1011 /* The yield is the pointer to the next uschar. Names longer than the
1012 output space are silently truncated. This function is also used from acl.c when
1016 name where to put the name
1020 Returns: new input pointer
1024 readconf_readname(uschar *name, int len, uschar *s)
1027 while (isspace(*s)) s++;
1030 while (isalnum(*s) || *s == '_')
1032 if (p < len-1) name[p++] = *s;
1037 while (isspace(*s)) s++;
1044 /*************************************************
1045 * Read a time value *
1046 *************************************************/
1048 /* This function is also called from outside, to read argument
1049 time values. The format of a time value is:
1051 [<n>w][<n>d][<n>h][<n>m][<n>s]
1053 as long as at least one is present. If a format error is encountered,
1054 return a negative value. The value must be terminated by the given
1059 terminator required terminating character
1060 return_msec if TRUE, allow fractional seconds and return milliseconds
1062 Returns: the time value, or -1 on syntax error
1063 value is seconds if return_msec is FALSE
1064 value is milliseconds if return_msec is TRUE
1068 readconf_readtime(const uschar *s, int terminator, BOOL return_msec)
1076 if (!isdigit(*s)) return -1;
1077 (void)sscanf(CCS s, "%d%n", &value, &count);
1082 case 'w': value *= 7;
1083 case 'd': value *= 24;
1084 case 'h': value *= 60;
1085 case 'm': value *= 60;
1090 if (!return_msec) return -1;
1091 (void)sscanf(CCS s, "%lf%n", &fraction, &count);
1093 if (*s++ != 's') return -1;
1094 yield += (int)(fraction * 1000.0);
1100 if (return_msec) value *= 1000;
1102 if (*s == terminator) return yield;
1104 /* Control never reaches here. */
1109 /*************************************************
1110 * Read a fixed point value *
1111 *************************************************/
1113 /* The value is returned *1000
1117 terminator required terminator
1119 Returns: the value, or -1 on error
1123 readconf_readfixed(const uschar *s, int terminator)
1127 if (!isdigit(*s)) return -1;
1128 (void)sscanf(CS s, "%d%n", &value, &count);
1130 yield = value * 1000;
1134 while (isdigit((*(++s))))
1136 yield += (*s - '0') * m;
1141 return (*s == terminator)? yield : (-1);
1146 /*************************************************
1147 * Find option in list *
1148 *************************************************/
1150 /* The lists are always in order, so binary chop can be used.
1153 name the option name to search for
1154 ol the first entry in the option list
1155 last one more than the offset of the last entry in the option list
1157 Returns: pointer to an option entry, or NULL if not found
1161 find_option(uschar *name, optionlist *ol, int last)
1164 while (last > first)
1166 int middle = (first + last)/2;
1167 int c = Ustrcmp(name, ol[middle].name);
1169 if (c == 0) return ol + middle;
1170 else if (c > 0) first = middle + 1;
1178 /*************************************************
1179 * Find a set flag in option list *
1180 *************************************************/
1182 /* Because some versions of Unix make no restrictions on the values of uids and
1183 gids (even negative ones), we cannot represent "unset" by a special value.
1184 There is therefore a separate boolean variable for each one indicating whether
1185 a value is set or not. This function returns a pointer to the boolean, given
1186 the original option name. It is a major disaster if the flag cannot be found.
1189 name the name of the uid or gid option
1190 oltop points to the start of the relevant option list
1191 last one more than the offset of the last item in the option list
1192 data_block NULL when reading main options => data values in the option
1193 list are absolute addresses; otherwise they are byte offsets
1194 in data_block (used for driver options)
1196 Returns: a pointer to the boolean flag.
1200 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1204 sprintf(CS name2, "*set_%.50s", name);
1205 ol = find_option(name2, oltop, last);
1206 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1207 "Exim internal error: missing set flag for %s", name);
1208 return (data_block == NULL)? (BOOL *)(ol->value) :
1209 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1215 /*************************************************
1216 * Output extra characters message and die *
1217 *************************************************/
1219 /* Called when an option line has junk on the end. Sometimes this is because
1220 the sysadmin thinks comments are permitted.
1223 s points to the extra characters
1224 t1..t3 strings to insert in the log message
1226 Returns: doesn't return; dies
1230 extra_chars_error(const uschar *s, const uschar *t1, const uschar *t2, const uschar *t3)
1232 uschar *comment = US"";
1233 if (*s == '#') comment = US" (# is comment only at line start)";
1234 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1235 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1240 /*************************************************
1241 * Read rewrite information *
1242 *************************************************/
1244 /* Each line of rewrite information contains:
1246 . A complete address in the form user@domain, possibly with
1247 leading * for each part; or alternatively, a regex.
1249 . A replacement string (which will be expanded).
1251 . An optional sequence of one-letter flags, indicating which
1252 headers etc. to apply this rule to.
1254 All this is decoded and placed into a control block. The OR of the flags is
1255 maintained in a common word.
1258 p points to the string that makes up the rule
1259 existflags points to the overall flag word
1260 isglobal TRUE if reading global rewrite rules
1262 Returns: the control block for the parsed rule.
1265 static rewrite_rule *
1266 readconf_one_rewrite(const uschar *p, int *existflags, BOOL isglobal)
1268 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1271 next->key = string_dequote(&p);
1273 while (isspace(*p)) p++;
1275 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1276 "missing rewrite replacement string");
1279 next->replacement = string_dequote(&p);
1281 while (*p != 0) switch (*p++)
1283 case ' ': case '\t': break;
1285 case 'q': next->flags |= rewrite_quit; break;
1286 case 'w': next->flags |= rewrite_whole; break;
1288 case 'h': next->flags |= rewrite_all_headers; break;
1289 case 's': next->flags |= rewrite_sender; break;
1290 case 'f': next->flags |= rewrite_from; break;
1291 case 't': next->flags |= rewrite_to; break;
1292 case 'c': next->flags |= rewrite_cc; break;
1293 case 'b': next->flags |= rewrite_bcc; break;
1294 case 'r': next->flags |= rewrite_replyto; break;
1296 case 'E': next->flags |= rewrite_all_envelope; break;
1297 case 'F': next->flags |= rewrite_envfrom; break;
1298 case 'T': next->flags |= rewrite_envto; break;
1300 case 'Q': next->flags |= rewrite_qualify; break;
1301 case 'R': next->flags |= rewrite_repeat; break;
1304 next->flags |= rewrite_smtp;
1305 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1306 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1307 "rewrite rule has the S flag but is not a regular expression");
1311 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1312 "unknown rewrite flag character '%c' "
1313 "(could be missing quotes round replacement item)", p[-1]);
1317 /* If no action flags are set, set all the "normal" rewrites. */
1319 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1320 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1322 /* Remember which exist, for optimization, and return the rule */
1324 *existflags |= next->flags;
1331 /*************************************************
1332 * Read global rewrite information *
1333 *************************************************/
1335 /* Each line is a single rewrite rule; it is parsed into a control block
1336 by readconf_one_rewrite(), and its flags are ORed into the global flag
1337 word rewrite_existflags. */
1340 readconf_rewrites(void)
1342 rewrite_rule **chain = &global_rewrite_rules;
1345 while ((p = get_config_line()) != NULL)
1347 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1349 chain = &(next->next);
1355 /*************************************************
1357 *************************************************/
1359 /* Strings are read into the normal store pool. As long we aren't too
1360 near the end of the current block, the string will just use what is necessary
1361 on the top of the stacking pool, because string_cat() uses the extension
1365 s the rest of the input line
1366 name the option name (for errors)
1368 Returns: pointer to the string
1372 read_string(const uschar *s, const uschar *name)
1377 if (*s != '\"') return string_copy(s);
1380 yield = string_dequote(&s);
1382 if (s == ss+1 || s[-1] != '\"')
1383 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1384 "missing quote at end of string value for %s", name);
1386 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1392 /*************************************************
1393 * Custom-handler options *
1394 *************************************************/
1396 fn_smtp_receive_timeout(const uschar * name, const uschar * str)
1399 smtp_receive_timeout_s = string_copy(str);
1402 /* "smtp_receive_timeout", opt_time, &smtp_receive_timeout */
1403 smtp_receive_timeout = readconf_readtime(str, 0, FALSE);
1404 if (smtp_receive_timeout < 0)
1405 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1410 /*************************************************
1411 * Handle option line *
1412 *************************************************/
1414 /* This function is called from several places to process a line containing the
1415 setting of an option. The first argument is the line to be decoded; it has been
1416 checked not to be empty and not to start with '#'. Trailing newlines and white
1417 space have been removed. The second argument is a pointer to the list of
1418 variable names that are to be recognized, together with their types and
1419 locations, and the third argument gives the number of entries in the list.
1421 The fourth argument is a pointer to a data block. If it is NULL, then the data
1422 values in the options list are absolute addresses. Otherwise, they are byte
1423 offsets in the data block.
1425 String option data may continue onto several lines; this function reads further
1426 data from config_file if necessary.
1428 The yield of this function is normally zero. If a string continues onto
1429 multiple lines, then the data value is permitted to be followed by a comma
1430 or a semicolon (for use in drivers) and the yield is that character.
1433 buffer contains the configuration line to be handled
1434 oltop points to the start of the relevant option list
1435 last one more than the offset of the last item in the option list
1436 data_block NULL when reading main options => data values in the option
1437 list are absolute addresses; otherwise they are byte offsets
1438 in data_block when they have opt_public set; otherwise
1439 they are byte offsets in data_block->options_block.
1440 unknown_txt format string to use in panic message for unknown option;
1441 must contain %s for option name
1442 if given as NULL, don't panic on unknown option
1444 Returns: TRUE if an option was read successfully,
1445 FALSE false for an unknown option if unknown_txt == NULL,
1446 otherwise panic and die on an unknown option
1450 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1451 void *data_block, uschar *unknown_txt)
1455 int n, count, type, value;
1459 BOOL boolvalue = TRUE;
1460 BOOL freesptr = TRUE;
1461 optionlist *ol, *ol2;
1465 uschar *inttype = US"";
1468 uschar **str_target;
1472 /* There may be leading spaces; thereafter, we expect an option name starting
1475 while (isspace(*s)) s++;
1477 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1479 /* Read the name of the option, and skip any subsequent white space. If
1480 it turns out that what we read was "hide", set the flag indicating that
1481 this is a secure option, and loop to read the next word. */
1483 for (n = 0; n < 2; n++)
1485 while (isalnum(*s) || *s == '_')
1487 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1491 while (isspace(*s)) s++;
1492 if (Ustrcmp(name, "hide") != 0) break;
1493 issecure = opt_secure;
1497 /* Deal with "no_" or "not_" here for booleans */
1499 if (Ustrncmp(name, "no_", 3) == 0)
1505 if (Ustrncmp(name, "not_", 4) == 0)
1511 /* Search the list for the given name. A non-existent name, or an option that
1512 is set twice, is a disaster. */
1514 if (!(ol = find_option(name + offset, oltop, last)))
1516 if (unknown_txt == NULL) return FALSE;
1517 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1520 if ((ol->type & opt_set) && !(ol->type & (opt_rep_con | opt_rep_str)))
1521 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1522 "\"%s\" option set for the second time", name);
1524 ol->type |= opt_set | issecure;
1525 type = ol->type & opt_mask;
1527 /* Types with data values must be followed by '='; the "no[t]_" prefix
1528 applies only to boolean values. */
1530 if (type < opt_bool || type > opt_bool_last)
1533 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1534 "negation prefix applied to a non-boolean option");
1536 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1537 "unexpected end of line (data missing) after %s", name);
1539 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1542 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1543 true/false/yes/no, or, in the case of opt_expand_bool, a general string that
1544 ultimately expands to one of those values. */
1546 else if (*s != 0 && (offset != 0 || *s != '='))
1547 extra_chars_error(s, US"boolean option ", name, US"");
1549 /* Skip white space after = */
1551 if (*s == '=') while (isspace((*(++s))));
1553 /* If there is a data block and the opt_public flag is not set, change
1554 the data block pointer to the private options block. */
1556 if (data_block != NULL && (ol->type & opt_public) == 0)
1557 data_block = (void *)(((driver_instance *)data_block)->options_block);
1559 /* Now get the data according to the type. */
1563 /* If a string value is not enclosed in quotes, it consists of
1564 the rest of the current line, verbatim. Otherwise, string escapes
1567 A transport is specified as a string, which is then looked up in the
1568 list of transports. A search type is specified as one of a number of
1571 A set or rewrite rules for a driver is specified as a string, which is
1572 then parsed into a suitable chain of control blocks.
1574 Uids and gids are specified as strings which are then looked up in the
1575 passwd file. Lists of uids and gids are similarly specified as colon-
1576 separated strings. */
1581 case opt_expand_uid:
1582 case opt_expand_gid:
1587 reset_point = sptr = read_string(s, name);
1589 /* Having read a string, we now have several different ways of using it,
1590 depending on the data type, so do another switch. If keeping the actual
1591 string is not required (because it is interpreted), freesptr is set TRUE,
1592 and at the end we reset the pool. */
1596 /* If this was a string, set the variable to point to the new string,
1597 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1598 rules, we still keep the string (for printing), and parse the rules into a
1599 control block and flags word. */
1602 str_target = data_block ? USS (US data_block + (long int)(ol->value))
1604 if (ol->type & opt_rep_con)
1606 uschar * saved_condition;
1607 /* We already have a condition, we're conducting a crude hack to let
1608 multiple condition rules be chained together, despite storing them in
1610 *str_target = string_copy_malloc( (saved_condition = *str_target)
1611 ? string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1612 saved_condition, sptr)
1614 /* TODO(pdp): there is a memory leak here and just below
1615 when we set 3 or more conditions; I still don't
1616 understand the store mechanism enough to know
1617 what's the safe way to free content from an earlier store.
1618 AFAICT, stores stack, so freeing an early stored item also stores
1619 all data alloc'd after it. If we knew conditions were adjacent,
1620 we could survive that, but we don't. So I *think* we need to take
1621 another bit from opt_type to indicate "malloced"; this seems like
1622 quite a hack, especially for this one case. It also means that
1623 we can't ever reclaim the store from the *first* condition.
1625 Because we only do this once, near process start-up, I'm prepared to
1626 let this slide for the time being, even though it rankles. */
1628 else if (ol->type & opt_rep_str)
1630 uschar sep_o = Ustrncmp(name, "headers_add", 11)==0 ? '\n' : ':';
1631 int sep_i = -(int)sep_o;
1632 const uschar * list = sptr;
1634 uschar * list_o = *str_target;
1636 while ((s = string_nextinlist(&list, &sep_i, NULL, 0)))
1637 list_o = string_append_listele(list_o, sep_o, s);
1639 *str_target = string_copy_malloc(list_o);
1650 *USS (US data_block + (long int)(ol->value)) = sptr;
1652 *USS (ol->value) = sptr;
1654 if (type == opt_rewrite)
1659 rewrite_rule **chain;
1662 sprintf(CS name2, "*%.50s_rules", name);
1663 ol2 = find_option(name2, oltop, last);
1664 sprintf(CS name2, "*%.50s_flags", name);
1665 ol3 = find_option(name2, oltop, last);
1667 if (ol2 == NULL || ol3 == NULL)
1668 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1669 "rewrite rules not available for driver");
1671 if (data_block == NULL)
1673 chain = (rewrite_rule **)(ol2->value);
1674 flagptr = (int *)(ol3->value);
1678 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1679 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1682 while ((p = string_nextinlist(CUSS &sptr, &sep, big_buffer, BIG_BUFFER_SIZE)))
1684 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1686 chain = &(next->next);
1689 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1690 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1691 "non-header rewrite - not allowed at transport time -");
1695 /* If it was an expanded uid, see if there is any expansion to be
1696 done by checking for the presence of a $ character. If there is, save it
1697 in the corresponding *expand_user option field. Otherwise, fall through
1698 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1701 case opt_expand_uid:
1702 sprintf(CS name2, "*expand_%.50s", name);
1703 ol2 = find_option(name2, oltop, last);
1706 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1708 if (data_block == NULL)
1709 *((uschar **)(ol2->value)) = ss;
1711 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1715 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1721 /* Look up a fixed uid, and also make use of the corresponding gid
1722 if a passwd entry is returned and the gid has not been set. */
1725 if (!route_finduser(sptr, &pw, &uid))
1726 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1727 if (data_block == NULL)
1728 *((uid_t *)(ol->value)) = uid;
1730 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1732 /* Set the flag indicating a fixed value is set */
1734 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1736 /* Handle matching gid if we have a passwd entry: done by finding the
1737 same name with terminating "user" changed to "group"; if not found,
1738 ignore. Also ignore if the value is already set. */
1740 if (pw == NULL) break;
1741 Ustrcpy(name+Ustrlen(name)-4, "group");
1742 ol2 = find_option(name, oltop, last);
1743 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1744 (ol2->type & opt_mask) == opt_expand_gid))
1746 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1749 if (data_block == NULL)
1750 *((gid_t *)(ol2->value)) = pw->pw_gid;
1752 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1758 /* If it was an expanded gid, see if there is any expansion to be
1759 done by checking for the presence of a $ character. If there is, save it
1760 in the corresponding *expand_user option field. Otherwise, fall through
1761 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1764 case opt_expand_gid:
1765 sprintf(CS name2, "*expand_%.50s", name);
1766 ol2 = find_option(name2, oltop, last);
1769 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1771 if (data_block == NULL)
1772 *((uschar **)(ol2->value)) = ss;
1774 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1778 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1784 /* Handle freestanding gid */
1787 if (!route_findgroup(sptr, &gid))
1788 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1789 if (data_block == NULL)
1790 *((gid_t *)(ol->value)) = gid;
1792 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1793 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1796 /* If it was a uid list, look up each individual entry, and build
1797 a vector of uids, with a count in the first element. Put the vector
1798 in malloc store so we can free the string. (We are reading into
1799 permanent store already.) */
1807 const uschar *op = expand_string (sptr);
1810 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1811 name, expand_string_message);
1814 if (*p != 0) count++;
1815 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1816 list = store_malloc(count*sizeof(uid_t));
1817 list[ptr++] = (uid_t)(count - 1);
1819 if (data_block == NULL)
1820 *((uid_t **)(ol->value)) = list;
1822 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1828 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1829 if (!route_finduser(big_buffer, NULL, &uid))
1830 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1837 /* If it was a gid list, look up each individual entry, and build
1838 a vector of gids, with a count in the first element. Put the vector
1839 in malloc store so we can free the string. (We are reading into permanent
1848 const uschar *op = expand_string (sptr);
1851 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to expand %s: %s",
1852 name, expand_string_message);
1855 if (*p != 0) count++;
1856 while (*p != 0) if (*p++ == ':' && *p != 0) count++;
1857 list = store_malloc(count*sizeof(gid_t));
1858 list[ptr++] = (gid_t)(count - 1);
1860 if (data_block == NULL)
1861 *((gid_t **)(ol->value)) = list;
1863 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1869 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1870 if (!route_findgroup(big_buffer, &gid))
1871 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1879 /* Release store if the value of the string doesn't need to be kept. */
1881 if (freesptr) store_reset(reset_point);
1884 /* Expanded boolean: if no characters follow, or if there are no dollar
1885 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1886 save the string for later expansion in the alternate place. */
1888 case opt_expand_bool:
1889 if (*s != 0 && Ustrchr(s, '$') != 0)
1891 sprintf(CS name2, "*expand_%.50s", name);
1892 ol2 = find_option(name2, oltop, last);
1895 reset_point = sptr = read_string(s, name);
1896 if (data_block == NULL)
1897 *((uschar **)(ol2->value)) = sptr;
1899 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1906 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1907 look for yes/not/true/false. Some booleans are stored in a single bit in
1908 a single int. There's a special fudge for verify settings; without a suffix
1909 they set both xx_sender and xx_recipient. The table points to the sender
1910 value; search subsequently for the recipient. There's another special case:
1911 opt_bool_set also notes when a boolean has been set. */
1915 case opt_bool_verify:
1919 s = readconf_readname(name2, 64, s);
1920 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1922 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1924 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1925 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1926 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1927 US"for boolean option ", name);
1930 /* Handle single-bit type. */
1932 if (type == opt_bit)
1934 int bit = 1 << ((ol->type >> 16) & 31);
1935 int *ptr = (data_block == NULL)?
1936 (int *)(ol->value) :
1937 (int *)((uschar *)data_block + (long int)ol->value);
1938 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1942 /* Handle full BOOL types */
1944 if (data_block == NULL)
1945 *((BOOL *)(ol->value)) = boolvalue;
1947 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1951 if (type == opt_bool_verify)
1953 sprintf(CS name2, "%.50s_recipient", name + offset);
1954 ol2 = find_option(name2, oltop, last);
1957 if (data_block == NULL)
1958 *((BOOL *)(ol2->value)) = boolvalue;
1960 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1964 /* Note that opt_bool_set type is set, if there is somewhere to do so */
1966 else if (type == opt_bool_set)
1968 sprintf(CS name2, "*set_%.50s", name + offset);
1969 ol2 = find_option(name2, oltop, last);
1972 if (data_block == NULL)
1973 *((BOOL *)(ol2->value)) = TRUE;
1975 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1984 inttype = US"octal ";
1986 /* Integer: a simple(ish) case; allow octal and hex formats, and
1987 suffixes K, M and G. The different types affect output, not input. */
1996 lvalue = strtol(CS s, CSS &endptr, intbase);
1999 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
2002 if (errno != ERANGE)
2003 if (tolower(*endptr) == 'k')
2005 if (lvalue > INT_MAX/1024 || lvalue < INT_MIN/1024) errno = ERANGE;
2006 else lvalue *= 1024;
2009 else if (tolower(*endptr) == 'm')
2011 if (lvalue > INT_MAX/(1024*1024) || lvalue < INT_MIN/(1024*1024))
2013 else lvalue *= 1024*1024;
2016 else if (tolower(*endptr) == 'g')
2018 if (lvalue > INT_MAX/(1024*1024*1024) || lvalue < INT_MIN/(1024*1024*1024))
2020 else lvalue *= 1024*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, M
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)
2056 if (tolower(*endptr) == 'g')
2058 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
2064 else if (tolower(*endptr) == 'm')
2066 if (value > INT_MAX/1024 || value < INT_MIN/1024)
2072 else if (tolower(*endptr) == 'k')
2075 value = (value + 512)/1024;
2077 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2078 "absolute value of integer \"%s\" is too large (overflow)", s);
2080 while (isspace(*endptr)) endptr++;
2082 extra_chars_error(endptr, inttype, US"integer value for ", name);
2085 if (data_block == NULL)
2086 *((int *)(ol->value)) = value;
2088 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2091 /* Fixed-point number: held to 3 decimal places. */
2094 if (sscanf(CS s, "%d%n", &value, &count) != 1)
2095 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2096 "fixed-point number expected for %s", name);
2098 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2099 "integer \"%s\" is too large (overflow)", s);
2103 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2104 "integer \"%s\" is too large (overflow)", s);
2106 if (s[count] == '.')
2109 while (isdigit(s[++count]))
2111 value += (s[count] - '0') * d;
2116 while (isspace(s[count])) count++;
2119 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
2121 if (data_block == NULL)
2122 *((int *)(ol->value)) = value;
2124 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2127 /* There's a special routine to read time values. */
2130 value = readconf_readtime(s, 0, FALSE);
2132 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2134 if (data_block == NULL)
2135 *((int *)(ol->value)) = value;
2137 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
2140 /* A time list is a list of colon-separated times, with the first
2141 element holding the size of the list and the second the number of
2147 int *list = (data_block == NULL)?
2148 (int *)(ol->value) :
2149 (int *)((uschar *)data_block + (long int)(ol->value));
2151 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
2154 uschar *snext = Ustrchr(s, ':');
2158 while (ss > s && isspace(ss[-1])) ss--;
2161 value = readconf_readtime(s, terminator, FALSE);
2163 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
2165 if (count > 1 && value <= list[count])
2166 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2167 "time value out of order for %s", name);
2168 list[count+1] = value;
2169 if (snext == NULL) break;
2171 while (isspace(*s)) s++;
2174 if (count > list[0] - 2)
2175 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
2177 if (count > 0 && list[2] == 0) count = 0;
2184 void (*fn)() = ol->value;
2195 /*************************************************
2196 * Print a time value *
2197 *************************************************/
2200 Argument: a time value in seconds
2201 Returns: pointer to a fixed buffer containing the time as a string,
2202 in readconf_readtime() format
2206 readconf_printtime(int t)
2209 uschar *p = time_buffer;
2226 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2227 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2228 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2229 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2230 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2237 /*************************************************
2238 * Print an individual option value *
2239 *************************************************/
2241 /* This is used by the -bP option, so prints to the standard output.
2242 The entire options list is passed in as an argument, because some options come
2243 in pairs - typically uid/gid settings, which can either be explicit numerical
2244 values, or strings to be expanded later. If the numerical value is unset,
2245 search for "*expand_<name>" to see if there is a string equivalent.
2248 ol option entry, or NULL for an unknown option
2250 options_block NULL for main configuration options; otherwise points to
2251 a driver block; if the option doesn't have opt_public
2252 set, then options_block->options_block is where the item
2254 oltop points to the option list in which ol exists
2255 last one more than the offset of the last entry in optop
2256 no_labels do not show "foo = " at the start.
2262 print_ol(optionlist *ol, uschar *name, void *options_block,
2263 optionlist *oltop, int last, BOOL no_labels)
2276 printf("%s is not a known option\n", name);
2280 /* Non-admin callers cannot see options that have been flagged secure by the
2283 if (!admin_user && (ol->type & opt_secure) != 0)
2286 printf("%s\n", hidden);
2288 printf("%s = %s\n", name, hidden);
2292 /* Else show the value of the option */
2295 if (options_block != NULL)
2297 if ((ol->type & opt_public) == 0)
2298 options_block = (void *)(((driver_instance *)options_block)->options_block);
2299 value = (void *)((uschar *)options_block + (long int)value);
2302 switch(ol->type & opt_mask)
2305 case opt_rewrite: /* Show the text value */
2306 s = *((uschar **)value);
2307 if (!no_labels) printf("%s = ", name);
2308 printf("%s\n", (s == NULL)? US"" : string_printing2(s, FALSE));
2312 if (!no_labels) printf("%s = ", name);
2313 printf("%d\n", *((int *)value));
2318 int x = *((int *)value);
2319 if (x != 0 && (x & 1023) == 0)
2323 if ((x & 1023) == 0)
2328 if (!no_labels) printf("%s = ", name);
2329 printf("%d%c\n", x, c);
2333 if (!no_labels) printf("%s = ", name);
2341 int x = *((int *)value);
2342 if (!no_labels) printf("%s = ", name);
2343 if (x == 0) printf("0\n");
2344 else if ((x & 1023) == 0) printf("%dM\n", x >> 10);
2345 else printf("%dK\n", x);
2350 if (!no_labels) printf("%s = ", name);
2351 printf("%#o\n", *((int *)value));
2354 /* Can be negative only when "unset", in which case integer */
2358 int x = *((int *)value);
2361 if (x < 0) printf("%s =\n", name); else
2363 if (!no_labels) printf("%s = ", name);
2364 printf("%d.", x/1000);
2377 /* If the numerical value is unset, try for the string value */
2379 case opt_expand_uid:
2380 if (! *get_set_flag(name, oltop, last, options_block))
2382 sprintf(CS name2, "*expand_%.50s", name);
2383 ol2 = find_option(name2, oltop, last);
2386 void *value2 = ol2->value;
2387 if (options_block != NULL)
2388 value2 = (void *)((uschar *)options_block + (long int)value2);
2389 s = *((uschar **)value2);
2390 if (!no_labels) printf("%s = ", name);
2391 printf("%s\n", (s == NULL)? US"" : string_printing(s));
2396 /* Else fall through */
2399 if (!no_labels) printf("%s = ", name);
2400 if (! *get_set_flag(name, oltop, last, options_block))
2404 pw = getpwuid(*((uid_t *)value));
2406 printf("%ld\n", (long int)(*((uid_t *)value)));
2407 else printf("%s\n", pw->pw_name);
2411 /* If the numerical value is unset, try for the string value */
2413 case opt_expand_gid:
2414 if (! *get_set_flag(name, oltop, last, options_block))
2416 sprintf(CS name2, "*expand_%.50s", name);
2417 ol2 = find_option(name2, oltop, last);
2418 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2420 void *value2 = ol2->value;
2421 if (options_block != NULL)
2422 value2 = (void *)((uschar *)options_block + (long int)value2);
2423 s = *((uschar **)value2);
2424 if (!no_labels) printf("%s = ", name);
2425 printf("%s\n", (s == NULL)? US"" : string_printing(s));
2430 /* Else fall through */
2433 if (!no_labels) printf("%s = ", name);
2434 if (! *get_set_flag(name, oltop, last, options_block))
2438 gr = getgrgid(*((int *)value));
2440 printf("%ld\n", (long int)(*((int *)value)));
2441 else printf("%s\n", gr->gr_name);
2446 uidlist = *((uid_t **)value);
2447 if (!no_labels) printf("%s =", name);
2448 if (uidlist != NULL)
2452 if (no_labels) sep = '\0';
2453 for (i = 1; i <= (int)(uidlist[0]); i++)
2455 uschar *name = NULL;
2456 pw = getpwuid(uidlist[i]);
2457 if (pw != NULL) name = US pw->pw_name;
2458 if (sep != '\0') printf("%c", sep);
2459 if (name != NULL) printf("%s", name);
2460 else printf("%ld", (long int)(uidlist[i]));
2468 gidlist = *((gid_t **)value);
2469 if (!no_labels) printf("%s =", name);
2470 if (gidlist != NULL)
2474 if (no_labels) sep = '\0';
2475 for (i = 1; i <= (int)(gidlist[0]); i++)
2477 uschar *name = NULL;
2478 gr = getgrgid(gidlist[i]);
2479 if (gr != NULL) name = US gr->gr_name;
2480 if (sep != '\0') printf("%c", sep);
2481 if (name != NULL) printf("%s", name);
2482 else printf("%ld", (long int)(gidlist[i]));
2490 if (!no_labels) printf("%s = ", name);
2491 printf("%s\n", readconf_printtime(*((int *)value)));
2497 int *list = (int *)value;
2498 if (!no_labels) printf("%s = ", name);
2499 for (i = 0; i < list[1]; i++)
2500 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2506 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2510 case opt_expand_bool:
2511 sprintf(CS name2, "*expand_%.50s", name);
2512 ol2 = find_option(name2, oltop, last);
2513 if (ol2 != NULL && ol2->value != NULL)
2515 void *value2 = ol2->value;
2516 if (options_block != NULL)
2517 value2 = (void *)((uschar *)options_block + (long int)value2);
2518 s = *((uschar **)value2);
2521 if (!no_labels) printf("%s = ", name);
2522 printf("%s\n", string_printing(s));
2525 /* s == NULL => string not set; fall through */
2531 case opt_bool_verify:
2533 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2540 /*************************************************
2541 * Print value from main configuration *
2542 *************************************************/
2544 /* This function, called as a result of encountering the -bP option,
2545 causes the value of any main configuration variable to be output if the
2546 second argument is NULL. There are some special values:
2548 all print all main configuration options
2549 config_file print the name of the configuration file
2550 (configure_file will still work, for backward
2552 routers print the routers' configurations
2553 transports print the transports' configuration
2554 authenticators print the authenticators' configuration
2555 macros print the macros' configuration
2556 router_list print a list of router names
2557 transport_list print a list of transport names
2558 authenticator_list print a list of authentication mechanism names
2559 macro_list print a list of macro names
2560 +name print a named list item
2561 local_scan print the local_scan options
2562 config print the configuration as it is parsed
2563 environment print the used execution environment
2565 If the second argument is not NULL, it must be one of "router", "transport",
2566 "authenticator" or "macro" in which case the first argument identifies the
2567 driver whose options are to be printed.
2570 name option name if type == NULL; else driver name
2571 type NULL or driver type name, as described above
2572 no_labels avoid the "foo = " at the start of an item
2578 readconf_print(uschar *name, uschar *type, BOOL no_labels)
2580 BOOL names_only = FALSE;
2582 optionlist *ol2 = NULL;
2583 driver_instance *d = NULL;
2594 static uschar *types[] = { US"address", US"domain", US"host",
2596 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2597 &hostlist_anchor, &localpartlist_anchor };
2599 for (i = 0; i < 4; i++)
2601 t = tree_search(*(anchors[i]), name+1);
2606 printf("%s\n", ((namedlist_block *)(t->data.ptr))->string);
2608 printf("%slist %s = %s\n", types[i], name+1,
2609 ((namedlist_block *)(t->data.ptr))->string);
2614 printf("no address, domain, host, or local part list called \"%s\" "
2615 "exists\n", name+1);
2620 if ( Ustrcmp(name, "configure_file") == 0
2621 || Ustrcmp(name, "config_file") == 0)
2623 printf("%s\n", CS config_main_filename);
2627 if (Ustrcmp(name, "all") == 0)
2629 for (ol = optionlist_config;
2630 ol < optionlist_config + nelem(optionlist_config); ol++)
2632 if ((ol->type & opt_hidden) == 0)
2633 print_ol(ol, US ol->name, NULL,
2634 optionlist_config, nelem(optionlist_config),
2640 if (Ustrcmp(name, "local_scan") == 0)
2642 #ifndef LOCAL_SCAN_HAS_OPTIONS
2643 printf("local_scan() options are not supported\n");
2645 for (ol = local_scan_options;
2646 ol < local_scan_options + local_scan_options_count; ol++)
2648 print_ol(ol, US ol->name, NULL, local_scan_options,
2649 local_scan_options_count, no_labels);
2655 if (Ustrcmp(name, "config") == 0)
2657 print_config(admin_user, no_labels);
2661 if (Ustrcmp(name, "routers") == 0)
2666 else if (Ustrcmp(name, "transports") == 0)
2668 type = US"transport";
2672 else if (Ustrcmp(name, "authenticators") == 0)
2674 type = US"authenticator";
2678 else if (Ustrcmp(name, "macros") == 0)
2684 else if (Ustrcmp(name, "router_list") == 0)
2691 else if (Ustrcmp(name, "transport_list") == 0)
2693 type = US"transport";
2698 else if (Ustrcmp(name, "authenticator_list") == 0)
2700 type = US"authenticator";
2705 else if (Ustrcmp(name, "macro_list") == 0)
2712 else if (Ustrcmp(name, "environment") == 0)
2717 for (p = USS environ; *p; p++) ;
2718 qsort(environ, p - USS environ, sizeof(*p), string_compare_by_pointer);
2720 for (p = USS environ; *p; p++)
2723 if (no_labels && (q = Ustrchr(*p, '='))) *q = '\0';
2732 print_ol(find_option(name, optionlist_config, nelem(optionlist_config)),
2733 name, NULL, optionlist_config, nelem(optionlist_config), no_labels);
2738 /* Handle the options for a router or transport. Skip options that are flagged
2739 as hidden. Some of these are options with names starting with '*', used for
2740 internal alternative representations of other options (which the printing
2741 function will sort out). Others are synonyms kept for backward compatibility.
2744 if (Ustrcmp(type, "router") == 0)
2746 d = (driver_instance *)routers;
2747 ol2 = optionlist_routers;
2748 size = optionlist_routers_size;
2750 else if (Ustrcmp(type, "transport") == 0)
2752 d = (driver_instance *)transports;
2753 ol2 = optionlist_transports;
2754 size = optionlist_transports_size;
2756 else if (Ustrcmp(type, "authenticator") == 0)
2758 d = (driver_instance *)auths;
2759 ol2 = optionlist_auths;
2760 size = optionlist_auths_size;
2763 else if (Ustrcmp(type, "macro") == 0)
2765 /* People store passwords in macros and they were previously not available
2766 for printing. So we have an admin_users restriction. */
2769 fprintf(stderr, "exim: permission denied\n");
2772 for (m = macros; m; m = m->next)
2773 if (!name || Ustrcmp(name, m->name) == 0)
2776 printf("%s\n", CS m->name);
2778 printf("%s=%s\n", CS m->name, CS m->replacement);
2783 printf("%s %s not found\n", type, name);
2789 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2793 /* Either search for a given driver, or print all of them */
2795 for (; d != NULL; d = d->next)
2798 printf("\n%s %s:\n", d->name, type);
2799 else if (Ustrcmp(d->name, name) != 0) continue;
2801 for (ol = ol2; ol < ol2 + size; ol++)
2803 if ((ol->type & opt_hidden) == 0)
2804 print_ol(ol, US ol->name, d, ol2, size, no_labels);
2807 for (ol = d->info->options;
2808 ol < d->info->options + *(d->info->options_count); ol++)
2810 if ((ol->type & opt_hidden) == 0)
2811 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count), no_labels);
2813 if (name != NULL) return;
2815 if (name != NULL) printf("%s %s not found\n", type, name);
2820 /*************************************************
2821 * Read a named list item *
2822 *************************************************/
2824 /* This function reads a name and a list (i.e. string). The name is used to
2825 save the list in a tree, sorted by its name. Each entry also has a number,
2826 which can be used for caching tests, but if the string contains any expansion
2827 items other than $key, the number is set negative to inhibit caching. This
2828 mechanism is used for domain, host, and address lists that are referenced by
2832 anchorp points to the tree anchor
2833 numberp points to the current number for this tree
2834 max the maximum number permitted
2835 s the text of the option line, starting immediately after the name
2837 tname the name of the list type, for messages
2843 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2846 BOOL forcecache = FALSE;
2849 namedlist_block *nb = store_get(sizeof(namedlist_block));
2851 if (Ustrncmp(s, "_cache", 6) == 0)
2858 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2860 if (*numberp >= max)
2861 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2864 while (isspace(*s)) s++;
2866 while (isalnum(*s) || *s == '_') s++;
2867 t = store_get(sizeof(tree_node) + s-ss);
2868 Ustrncpy(t->name, ss, s-ss);
2870 while (isspace(*s)) s++;
2872 if (!tree_insertnode(anchorp, t))
2873 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2874 "duplicate name \"%s\" for a named %s", t->name, tname);
2877 nb->number = *numberp;
2880 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2881 "missing '=' after \"%s\"", t->name);
2882 while (isspace(*s)) s++;
2883 nb->string = read_string(s, t->name);
2884 nb->cache_data = NULL;
2886 /* Check the string for any expansions; if any are found, mark this list
2887 uncacheable unless the user has explicited forced caching. */
2889 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2895 /*************************************************
2896 * Unpick data for a rate limit *
2897 *************************************************/
2899 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2903 s string, in the form t,b,f,l
2904 where t is the threshold (integer)
2905 b is the initial delay (time)
2906 f is the multiplicative factor (fixed point)
2907 k is the maximum time (time)
2908 threshold where to store threshold
2909 base where to store base in milliseconds
2910 factor where to store factor in milliseconds
2911 limit where to store limit
2913 Returns: nothing (panics on error)
2917 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2920 uschar bstring[16], lstring[16];
2922 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2923 factor, lstring) == 4)
2925 *base = readconf_readtime(bstring, 0, TRUE);
2926 *limit = readconf_readtime(lstring, 0, TRUE);
2927 if (*base >= 0 && *limit >= 0) return;
2929 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2935 /*************************************************
2936 * Drop privs for checking TLS config *
2937 *************************************************/
2939 /* We want to validate TLS options during readconf, but do not want to be
2940 root when we call into the TLS library, in case of library linkage errors
2941 which cause segfaults; before this check, those were always done as the Exim
2942 runtime user and it makes sense to continue with that.
2944 Assumes: tls_require_ciphers has been set, if it will be
2945 exim_user has been set, if it will be
2946 exim_group has been set, if it will be
2948 Returns: bool for "okay"; false will cause caller to immediately exit.
2953 tls_dropprivs_validate_require_cipher(BOOL nowarn)
2955 const uschar *errmsg;
2958 void (*oldsignal)(int);
2960 /* If TLS will never be used, no point checking ciphers */
2962 if ( !tls_advertise_hosts
2963 || !*tls_advertise_hosts
2964 || Ustrcmp(tls_advertise_hosts, ":") == 0
2967 else if (!nowarn && !tls_certificate)
2968 log_write(0, LOG_MAIN,
2969 "Warning: No server certificate defined; will use a selfsigned one.\n"
2970 " Suggested action: either install a certificate or change tls_advertise_hosts option");
2972 oldsignal = signal(SIGCHLD, SIG_DFL);
2975 if ((pid = fork()) < 0)
2976 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork failed for TLS check");
2980 /* in some modes, will have dropped privilege already */
2982 exim_setugid(exim_uid, exim_gid, FALSE,
2983 US"calling tls_validate_require_cipher");
2985 errmsg = tls_validate_require_cipher();
2988 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2989 "tls_require_ciphers invalid: %s", errmsg);
2996 rc = waitpid(pid, &status, 0);
2997 } while (rc < 0 && errno == EINTR);
3000 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3003 signal(SIGCHLD, oldsignal);
3007 #endif /* SUPPORT_TLS */
3012 /*************************************************/
3013 /* Create compile-time feature macros */
3015 readconf_features(void)
3017 /* Probably we could work out a static initialiser for wherever
3018 macros are stored, but this will do for now. Some names are awkward
3019 due to conflicts with other common macros. */
3021 #ifdef SUPPORT_CRYPTEQ
3022 macro_create(US"_HAVE_CRYPTEQ", US"y", FALSE);
3025 macro_create(US"_HAVE_ICONV", US"y", FALSE);
3028 macro_create(US"_HAVE_IPV6", US"y", FALSE);
3030 #ifdef HAVE_SETCLASSRESOURCES
3031 macro_create(US"_HAVE_SETCLASSRESOURCES", US"y", FALSE);
3034 macro_create(US"_HAVE_PAM", US"y", FALSE);
3037 macro_create(US"_HAVE_PERL", US"y", FALSE);
3039 #ifdef EXPAND_DLFUNC
3040 macro_create(US"_HAVE_DLFUNC", US"y", FALSE);
3042 #ifdef USE_TCP_WRAPPERS
3043 macro_create(US"_HAVE_TCPWRAPPERS", US"y", FALSE);
3046 macro_create(US"_HAVE_TLS", US"y", FALSE);
3048 macro_create(US"_HAVE_GNUTLS", US"y", FALSE);
3050 macro_create(US"_HAVE_OPENSSL", US"y", FALSE);
3053 #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
3054 macro_create(US"_HAVE_TRANSLATE_IP_ADDRESS", US"y", FALSE);
3056 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
3057 macro_create(US"_HAVE_MOVE_FROZEN_MESSAGES", US"y", FALSE);
3059 #ifdef WITH_CONTENT_SCAN
3060 macro_create(US"_HAVE_CONTENT_SCANNING", US"y", FALSE);
3062 #ifndef DISABLE_DKIM
3063 macro_create(US"_HAVE_DKIM", US"y", FALSE);
3065 #ifndef DISABLE_DNSSEC
3066 macro_create(US"_HAVE_DNSSEC", US"y", FALSE);
3068 #ifndef DISABLE_EVENT
3069 macro_create(US"_HAVE_EVENT", US"y", FALSE);
3072 macro_create(US"_HAVE_I18N", US"y", FALSE);
3074 #ifndef DISABLE_OCSP
3075 macro_create(US"_HAVE_OCSP", US"y", FALSE);
3077 #ifndef DISABLE_PRDR
3078 macro_create(US"_HAVE_PRDR", US"y", FALSE);
3080 #ifdef SUPPORT_PROXY
3081 macro_create(US"_HAVE_PROXY", US"y", FALSE);
3083 #ifdef SUPPORT_SOCKS
3084 macro_create(US"_HAVE_SOCKS", US"y", FALSE);
3086 #ifdef EXPERIMENTAL_LMDB
3087 macro_create(US"_HAVE_LMDB", US"y", FALSE);
3089 #ifdef EXPERIMENTAL_SPF
3090 macro_create(US"_HAVE_SPF", US"y", FALSE);
3092 #ifdef EXPERIMENTAL_SRS
3093 macro_create(US"_HAVE_SRS", US"y", FALSE);
3095 #ifdef EXPERIMENTAL_BRIGHTMAIL
3096 macro_create(US"_HAVE_BRIGHTMAIL", US"y", FALSE);
3098 #ifdef EXPERIMENTAL_DANE
3099 macro_create(US"_HAVE_DANE", US"y", FALSE);
3101 #ifdef EXPERIMENTAL_DCC
3102 macro_create(US"_HAVE_DCC", US"y", FALSE);
3104 #ifdef EXPERIMENTAL_DMARC
3105 macro_create(US"_HAVE_DMARC", US"y", FALSE);
3107 #ifdef EXPERIMENTAL_DSN_INFO
3108 macro_create(US"_HAVE_DSN_INFO", US"y", FALSE);
3111 #ifdef LOOKUP_LSEARCH
3112 macro_create(US"_HAVE_LKUP_LSEARCH", US"y", FALSE);
3115 macro_create(US"_HAVE_LKUP_CDB", US"y", FALSE);
3118 macro_create(US"_HAVE_LKUP_DBM", US"y", FALSE);
3121 macro_create(US"_HAVE_LKUP_DNSDB", US"y", FALSE);
3123 #ifdef LOOKUP_DSEARCH
3124 macro_create(US"_HAVE_LKUP_DSEARCH", US"y", FALSE);
3127 macro_create(US"_HAVE_LKUP_IBASE", US"y", FALSE);
3130 macro_create(US"_HAVE_LKUP_LDAP", US"y", FALSE);
3132 #ifdef EXPERIMENTAL_LMDB
3133 macro_create(US"_HAVE_LKUP_LMDB", US"y", FALSE);
3136 macro_create(US"_HAVE_LKUP_MYSQL", US"y", FALSE);
3139 macro_create(US"_HAVE_LKUP_NIS", US"y", FALSE);
3141 #ifdef LOOKUP_NISPLUS
3142 macro_create(US"_HAVE_LKUP_NISPLUS", US"y", FALSE);
3144 #ifdef LOOKUP_ORACLE
3145 macro_create(US"_HAVE_LKUP_ORACLE", US"y", FALSE);
3147 #ifdef LOOKUP_PASSWD
3148 macro_create(US"_HAVE_LKUP_PASSWD", US"y", FALSE);
3151 macro_create(US"_HAVE_LKUP_PGSQL", US"y", FALSE);
3154 macro_create(US"_HAVE_LKUP_REDIS", US"y", FALSE);
3156 #ifdef LOOKUP_SQLITE
3157 macro_create(US"_HAVE_LKUP_SQLITE", US"y", FALSE);
3159 #ifdef LOOKUP_TESTDB
3160 macro_create(US"_HAVE_LKUP_TESTDB", US"y", FALSE);
3162 #ifdef LOOKUP_WHOSON
3163 macro_create(US"_HAVE_LKUP_WHOSON", US"y", FALSE);
3166 #ifdef TRANSPORT_APPENDFILE
3167 # ifdef SUPPORT_MAILDIR
3168 macro_create(US"_HAVE_TPT_APPEND_MAILDR", US"y", FALSE);
3170 # ifdef SUPPORT_MAILSTORE
3171 macro_create(US"_HAVE_TPT_APPEND_MAILSTORE", US"y", FALSE);
3174 macro_create(US"_HAVE_TPT_APPEND_MBX", US"y", FALSE);
3181 readconf_options_from_list(optionlist * opts, unsigned nopt, uschar * group)
3186 /* Walk the array backwards to get substring-conflict names */
3187 for (i = nopt-1; i >= 0; i--) if (*(s = opts[i].name) && *s != '*')
3188 macro_create(string_sprintf("_OPT_%T_%T", group, s), US"y", FALSE);
3193 readconf_options(void)
3195 readconf_options_from_list(optionlist_config, nelem(optionlist_config), US"MAIN");
3196 readconf_options_routers();
3197 readconf_options_transports();
3198 readconf_options_auths();
3202 /*************************************************
3203 * Read main configuration options *
3204 *************************************************/
3206 /* This function is the first to be called for configuration reading. It
3207 opens the configuration file and reads general configuration settings until
3208 it reaches the end of the configuration section. The file is then left open so
3209 that the remaining configuration data can subsequently be read if needed for
3212 The configuration file must be owned either by root or exim, and be writeable
3213 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3214 in the config file, so the test is done on the compiled in values. A slight
3215 anomaly, to be carefully documented.
3217 The name of the configuration file is taken from a list that is included in the
3218 binary of Exim. It can be altered from the command line, but if that is done,
3219 root privilege is immediately withdrawn unless the caller is root or exim.
3220 The first file on the list that exists is used.
3222 For use on multiple systems that share file systems, first look for a
3223 configuration file whose name has the current node name on the end. If that is
3224 not found, try the generic name. For really contorted configurations, that run
3225 multiple Exims with different uid settings, first try adding the effective uid
3226 before the node name. These complications are going to waste resources on most
3227 systems. Therefore they are available only when requested by compile-time
3231 readconf_main(BOOL nowarn)
3234 struct stat statbuf;
3235 uschar *s, *filename;
3236 const uschar *list = config_main_filelist;
3238 /* Loop through the possible file names */
3240 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
3244 /* Cut out all the fancy processing unless specifically wanted */
3246 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3247 uschar *suffix = filename + Ustrlen(filename);
3249 /* Try for the node-specific file if a node name exists */
3251 #ifdef CONFIGURE_FILE_USE_NODE
3253 if (uname(&uts) >= 0)
3255 #ifdef CONFIGURE_FILE_USE_EUID
3256 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3257 config_file = Ufopen(filename, "rb");
3258 if (config_file == NULL)
3259 #endif /* CONFIGURE_FILE_USE_EUID */
3261 sprintf(CS suffix, ".%.256s", uts.nodename);
3262 config_file = Ufopen(filename, "rb");
3265 #endif /* CONFIGURE_FILE_USE_NODE */
3267 /* Otherwise, try the generic name, possibly with the euid added */
3269 #ifdef CONFIGURE_FILE_USE_EUID
3270 if (config_file == NULL)
3272 sprintf(CS suffix, ".%ld", (long int)original_euid);
3273 config_file = Ufopen(filename, "rb");
3275 #endif /* CONFIGURE_FILE_USE_EUID */
3277 /* Finally, try the unadorned name */
3279 if (config_file == NULL)
3282 config_file = Ufopen(filename, "rb");
3284 #else /* if neither defined */
3286 /* This is the common case when the fancy processing is not included. */
3288 config_file = Ufopen(filename, "rb");
3291 /* If the file does not exist, continue to try any others. For any other
3292 error, break out (and die). */
3294 if (config_file != NULL || errno != ENOENT) break;
3297 /* Now, once we found and opened our configuration file, we change the directory
3298 to a safe place. Later we change to $spool_directory. */
3300 if (Uchdir("/") < 0)
3302 perror("exim: chdir `/': ");
3306 /* On success, save the name for verification; config_filename is used when
3307 logging configuration errors (it changes for .included files) whereas
3308 config_main_filename is the name shown by -bP. Failure to open a configuration
3309 file is a serious disaster. */
3311 if (config_file != NULL)
3314 config_filename = config_main_filename = string_copy(filename);
3316 p = Ustrrchr(filename, '/');
3317 config_main_directory = p ? string_copyn(filename, p - filename)
3318 : string_copy(US".");
3322 if (filename == NULL)
3323 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3324 "%s", config_main_filelist);
3326 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3327 "configuration file %s", filename));
3330 /* Check the status of the file we have opened, if we have retained root
3331 privileges and the file isn't /dev/null (which *should* be 0666). */
3333 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3335 if (fstat(fileno(config_file), &statbuf) != 0)
3336 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3339 if ((statbuf.st_uid != root_uid /* owner not root */
3340 #ifdef CONFIGURE_OWNER
3341 && statbuf.st_uid != config_uid /* owner not the special one */
3344 (statbuf.st_gid != root_gid /* group not root & */
3345 #ifdef CONFIGURE_GROUP
3346 && statbuf.st_gid != config_gid /* group not the special one */
3348 && (statbuf.st_mode & 020) != 0) || /* group writeable */
3350 ((statbuf.st_mode & 2) != 0)) /* world writeable */
3352 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3353 "wrong owner, group, or mode", big_buffer);
3356 /* Process the main configuration settings. They all begin with a lower case
3357 letter. If we see something starting with an upper case letter, it is taken as
3358 a macro definition. */
3360 while ((s = get_config_line()) != NULL)
3362 if (isupper(s[0])) read_macro_assignment(s);
3364 else if (Ustrncmp(s, "domainlist", 10) == 0)
3365 read_named_list(&domainlist_anchor, &domainlist_count,
3366 MAX_NAMED_LIST, s+10, US"domain list");
3368 else if (Ustrncmp(s, "hostlist", 8) == 0)
3369 read_named_list(&hostlist_anchor, &hostlist_count,
3370 MAX_NAMED_LIST, s+8, US"host list");
3372 else if (Ustrncmp(s, US"addresslist", 11) == 0)
3373 read_named_list(&addresslist_anchor, &addresslist_count,
3374 MAX_NAMED_LIST, s+11, US"address list");
3376 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3377 read_named_list(&localpartlist_anchor, &localpartlist_count,
3378 MAX_NAMED_LIST, s+13, US"local part list");
3381 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3382 NULL, US"main option \"%s\" unknown");
3386 /* If local_sender_retain is set, local_from_check must be unset. */
3388 if (local_sender_retain && local_from_check)
3389 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3390 "local_sender_retain are set; this combination is not allowed");
3392 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3395 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3397 /* The max retry interval must not be greater than 24 hours. */
3399 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3401 /* remote_max_parallel must be > 0 */
3403 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3405 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3406 start of a new SMTP message. */
3408 freeze_tell_config = freeze_tell;
3410 /* The primary host name may be required for expansion of spool_directory
3411 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3412 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3413 canonize it. Some people like upper case letters in their host names, so we
3414 don't force the case. */
3416 if (primary_hostname == NULL)
3418 const uschar *hostname;
3420 if (uname(&uts) < 0)
3421 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3422 hostname = US uts.nodename;
3424 if (Ustrchr(hostname, '.') == NULL)
3427 struct hostent *hostdata;
3430 if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3431 match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3432 MCL_DOMAIN, TRUE, NULL) != OK))
3441 #if HAVE_GETIPNODEBYNAME
3443 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3445 hostdata = gethostbyname2(CS hostname, af);
3448 hostdata = gethostbyname(CS hostname);
3451 if (hostdata != NULL)
3453 hostname = US hostdata->h_name;
3457 if (af == AF_INET) break;
3462 primary_hostname = string_copy(hostname);
3465 /* Set up default value for smtp_active_hostname */
3467 smtp_active_hostname = primary_hostname;
3469 /* If spool_directory wasn't set in the build-time configuration, it must have
3470 got set above. Of course, writing to the log may not work if log_file_path is
3471 not set, but it will at least get to syslog or somewhere, with any luck. */
3473 if (*spool_directory == 0)
3474 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3477 /* Expand the spool directory name; it may, for example, contain the primary
3478 host name. Same comment about failure. */
3480 s = expand_string(spool_directory);
3482 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3483 "\"%s\": %s", spool_directory, expand_string_message);
3484 spool_directory = s;
3486 /* Expand log_file_path, which must contain "%s" in any component that isn't
3487 the null string or "syslog". It is also allowed to contain one instance of %D
3488 or %M. However, it must NOT contain % followed by anything else. */
3490 if (*log_file_path != 0)
3492 const uschar *ss, *sss;
3493 int sep = ':'; /* Fixed for log file path */
3494 s = expand_string(log_file_path);
3496 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3497 "\"%s\": %s", log_file_path, expand_string_message);
3500 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3503 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3504 t = Ustrstr(sss, "%s");
3506 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3507 "contain \"%%s\"", sss);
3509 t = Ustrchr(sss, '%');
3512 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3513 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3514 "unexpected \"%%\" character", s);
3521 /* Interpret syslog_facility into an integer argument for 'ident' param to
3522 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3525 if (syslog_facility_str != NULL)
3528 uschar *s = syslog_facility_str;
3530 if ((Ustrlen(syslog_facility_str) >= 4) &&
3531 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3534 for (i = 0; i < syslog_list_size; i++)
3536 if (strcmpic(s, syslog_list[i].name) == 0)
3538 syslog_facility = syslog_list[i].value;
3543 if (i >= syslog_list_size)
3545 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3546 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3550 /* Expand pid_file_path */
3552 if (*pid_file_path != 0)
3554 s = expand_string(pid_file_path);
3556 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3557 "\"%s\": %s", pid_file_path, expand_string_message);
3561 /* Set default value of process_log_path */
3563 if (process_log_path == NULL || *process_log_path =='\0')
3564 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3566 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3569 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3571 /* Unpick the SMTP rate limiting options, if set */
3573 if (smtp_ratelimit_mail != NULL)
3575 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3576 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3579 if (smtp_ratelimit_rcpt != NULL)
3581 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3582 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3585 /* The qualify domains default to the primary host name */
3587 if (qualify_domain_sender == NULL)
3588 qualify_domain_sender = primary_hostname;
3589 if (qualify_domain_recipient == NULL)
3590 qualify_domain_recipient = qualify_domain_sender;
3592 /* Setting system_filter_user in the configuration sets the gid as well if a
3593 name is given, but a numerical value does not. */
3595 if (system_filter_uid_set && !system_filter_gid_set)
3597 struct passwd *pw = getpwuid(system_filter_uid);
3599 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3600 (long int)system_filter_uid);
3601 system_filter_gid = pw->pw_gid;
3602 system_filter_gid_set = TRUE;
3605 /* If the errors_reply_to field is set, check that it is syntactically valid
3606 and ensure it contains a domain. */
3608 if (errors_reply_to != NULL)
3611 int start, end, domain;
3612 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3613 &start, &end, &domain, FALSE);
3615 if (recipient == NULL)
3616 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3617 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3620 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3621 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3624 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3625 smtp_accept_max must also be set. */
3627 if (smtp_accept_max == 0 &&
3628 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3629 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3630 "smtp_accept_max must be set if smtp_accept_queue or "
3631 "smtp_accept_max_per_host is set");
3633 /* Set up the host number if anything is specified. It is an expanded string
3634 so that it can be computed from the host name, for example. We do this last
3635 so as to ensure that everything else is set up before the expansion. */
3637 if (host_number_string != NULL)
3641 uschar *s = expand_string(host_number_string);
3643 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3644 "failed to expand localhost_number \"%s\": %s",
3645 host_number_string, expand_string_message);
3646 n = Ustrtol(s, &end, 0);
3647 while (isspace(*end)) end++;
3649 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3650 "localhost_number value is not a number: %s", s);
3651 if (n > LOCALHOST_MAX)
3652 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3653 "localhost_number is greater than the maximum allowed value (%d)",
3659 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3661 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3662 tls_verify_certificates == NULL)
3663 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3664 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3665 (tls_verify_hosts != NULL)? "" : "try_");
3667 /* This also checks that the library linkage is working and we can call
3668 routines in it, so call even if tls_require_ciphers is unset */
3669 if (!tls_dropprivs_validate_require_cipher(nowarn))
3672 /* Magic number: at time of writing, 1024 has been the long-standing value
3673 used by so many clients, and what Exim used to use always, that it makes
3674 sense to just min-clamp this max-clamp at that. */
3675 if (tls_dh_max_bits < 1024)
3676 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3677 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3679 /* If openssl_options is set, validate it */
3680 if (openssl_options != NULL)
3683 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3684 "openssl_options is set but we're using GnuTLS");
3687 if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3688 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3689 "openssl_options parse error: %s", openssl_options);
3692 #endif /*SUPPORT_TLS*/
3694 if (!nowarn && !keep_environment && environ && *environ)
3695 log_write(0, LOG_MAIN,
3696 "Warning: purging the environment.\n"
3697 " Suggested action: use keep_environment.");
3702 /*************************************************
3703 * Initialize one driver *
3704 *************************************************/
3706 /* This is called once the driver's generic options, if any, have been read.
3707 We can now find the driver, set up defaults for the private options, and
3708 unset any "set" bits in the private options table (which might have been
3709 set by another incarnation of the same driver).
3712 d pointer to driver instance block, with generic
3714 drivers_available vector of available drivers
3715 size_of_info size of each block in drivers_available
3716 class class of driver, for error message
3718 Returns: pointer to the driver info block
3721 static driver_info *
3722 init_driver(driver_instance *d, driver_info *drivers_available,
3723 int size_of_info, uschar *class)
3727 for (dd = drivers_available; dd->driver_name[0] != 0;
3728 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3730 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3733 int len = dd->options_len;
3735 d->options_block = store_get(len);
3736 memcpy(d->options_block, dd->options_block, len);
3737 for (i = 0; i < *(dd->options_count); i++)
3738 dd->options[i].type &= ~opt_set;
3743 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3744 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3746 return NULL; /* never obeyed */
3752 /*************************************************
3753 * Initialize driver list *
3754 *************************************************/
3756 /* This function is called for routers, transports, and authentication
3757 mechanisms. It reads the data from the current point in the configuration file
3758 up to the end of the section, and sets up a chain of instance blocks according
3759 to the file's contents. The file will already have been opened by a call to
3760 readconf_main, and must be left open for subsequent reading of further data.
3762 Any errors cause a panic crash. Note that the blocks with names driver_info and
3763 driver_instance must map the first portions of all the _info and _instance
3764 blocks for this shared code to work.
3767 class "router", "transport", or "authenticator"
3768 anchor &routers, &transports, &auths
3769 drivers_available available drivers
3770 size_of_info size of each info block
3771 instance_default points to default data for an instance
3772 instance_size size of instance block
3773 driver_optionlist generic option list
3774 driver_optionlist_count count of generic option list
3780 readconf_driver_init(
3782 driver_instance **anchor,
3783 driver_info *drivers_available,
3785 void *instance_default,
3787 optionlist *driver_optionlist,
3788 int driver_optionlist_count)
3790 driver_instance **p = anchor;
3791 driver_instance *d = NULL;
3794 while ((buffer = get_config_line()) != NULL)
3799 /* Read the first name on the line and test for the start of a new driver. A
3800 macro definition indicates the end of the previous driver. If this isn't the
3801 start of a new driver, the line will be re-read. */
3803 s = readconf_readname(name, sizeof(name), buffer);
3805 /* Handle macro definition, first finishing off the initialization of the
3806 previous driver, if any. */
3808 if (isupper(*name) && *s == '=')
3812 if (!d->driver_name)
3813 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3814 "no driver defined for %s \"%s\"", class, d->name);
3818 read_macro_assignment(buffer);
3822 /* If the line starts with a name terminated by a colon, we are at the
3823 start of the definition of a new driver. The rest of the line must be
3830 /* Finish off initializing the previous driver. */
3834 if (!d->driver_name)
3835 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3836 "no driver defined for %s \"%s\"", class, d->name);
3840 /* Check that we haven't already got a driver of this name */
3842 for (d = *anchor; d; d = d->next)
3843 if (Ustrcmp(name, d->name) == 0)
3844 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3845 "there are two %ss called \"%s\"", class, name);
3847 /* Set up a new driver instance data block on the chain, with
3848 its default values installed. */
3850 d = store_get(instance_size);
3851 memcpy(d, instance_default, instance_size);
3854 d->name = string_copy(name);
3856 /* Clear out the "set" bits in the generic options */
3858 for (i = 0; i < driver_optionlist_count; i++)
3859 driver_optionlist[i].type &= ~opt_set;
3861 /* Check nothing more on this line, then do the next loop iteration. */
3863 while (isspace(*s)) s++;
3864 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3868 /* Not the start of a new driver. Give an error if we have not set up a
3869 current driver yet. */
3872 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3874 /* First look to see if this is a generic option; if it is "driver",
3875 initialize the driver. If is it not a generic option, we can look for a
3876 private option provided that the driver has been previously set up. */
3878 if (readconf_handle_option(buffer, driver_optionlist,
3879 driver_optionlist_count, d, NULL))
3881 if (!d->info && d->driver_name)
3882 init_driver(d, drivers_available, size_of_info, class);
3885 /* Handle private options - pass the generic block because some may
3886 live therein. A flag with each option indicates if it is in the public
3890 readconf_handle_option(buffer, d->info->options,
3891 *(d->info->options_count), d, US"option \"%s\" unknown");
3893 /* The option is not generic and the driver name has not yet been given. */
3895 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3896 "(\"driver\" must be specified before any private options)", name);
3899 /* Run the initialization function for the final driver. */
3903 if (!d->driver_name)
3904 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3905 "no driver defined for %s \"%s\"", class, d->name);
3912 /*************************************************
3913 * Check driver dependency *
3914 *************************************************/
3916 /* This function is passed a driver instance and a string. It checks whether
3917 any of the string options for the driver contains the given string as an
3921 d points to a driver instance block
3922 s the string to search for
3924 Returns: TRUE if a dependency is found
3928 readconf_depends(driver_instance *d, uschar *s)
3930 int count = *(d->info->options_count);
3934 for (ol = d->info->options; ol < d->info->options + count; ol++)
3936 void *options_block;
3938 int type = ol->type & opt_mask;
3939 if (type != opt_stringptr) continue;
3940 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3941 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3942 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3944 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3945 isalnum(ss[Ustrlen(s)])) continue;
3946 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3947 d->name, ol->name, s);
3952 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3959 /*************************************************
3960 * Decode an error type for retries *
3961 *************************************************/
3963 /* This function is global because it is also called from the main
3964 program when testing retry information. It decodes strings such as "quota_7d"
3965 into numerical error codes.
3968 pp points to start of text
3969 p points past end of text
3970 basic_errno points to an int to receive the main error number
3971 more_errno points to an int to receive the secondary error data
3973 Returns: NULL if decoded correctly; else points to error text
3977 readconf_retry_error(const uschar *pp, const uschar *p,
3978 int *basic_errno, int *more_errno)
3981 const uschar *q = pp;
3982 while (q < p && *q != '_') q++;
3985 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3987 *basic_errno = ERRNO_EXIMQUOTA;
3988 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3989 return US"bad time value";
3992 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3994 *basic_errno = ECONNREFUSED;
3997 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3998 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3999 else return US"A or MX expected after \"refused\"";
4003 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
4005 *basic_errno = ETIMEDOUT;
4009 int xlen = p - q - 1;
4010 const uschar *x = q + 1;
4012 static uschar *extras[] =
4013 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
4014 static int values[] =
4015 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
4017 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
4018 if (strncmpic(x, extras[i], xlen) == 0)
4020 *more_errno = values[i];
4024 if (i >= sizeof(extras)/sizeof(uschar *))
4025 if (strncmpic(x, US"DNS", xlen) == 0)
4026 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
4027 "available in retry rules (it has never worked) - treated as "
4030 return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
4034 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
4035 strncmpic(pp, US"rcpt_4", 6) == 0 ||
4036 strncmpic(pp, US"data_4", 6) == 0)
4039 int x = 255; /* means "any 4xx code" */
4040 if (p != pp + 8) bad = TRUE; else
4042 int a = pp[6], b = pp[7];
4046 if (isdigit(b)) x += b - '0';
4047 else if (b == 'x') x += 100;
4050 else if (a != 'x' || b != 'x') bad = TRUE;
4054 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
4055 "x is literal and d is any digit", pp);
4057 *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
4058 *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
4059 *more_errno = x << 8;
4062 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
4063 strncmpic(q+1, US"failed", p-q-1) == 0)
4064 *basic_errno = ERRNO_AUTHFAIL;
4066 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
4067 *basic_errno = ERRNO_SMTPCLOSED;
4069 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
4070 *basic_errno = ERRNO_TLSREQUIRED;
4072 else if (strncmpic(pp, US"lookup", p - pp) == 0)
4073 *basic_errno = ERRNO_UNKNOWNHOST;
4075 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4076 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4084 /*************************************************
4085 * Read retry information *
4086 *************************************************/
4088 /* Each line of retry information contains:
4090 . A domain name pattern or an address pattern;
4092 . An error name, possibly with additional data, or *;
4094 . An optional sequence of retry items, each consisting of an identifying
4095 letter, a cutoff time, and optional parameters.
4097 All this is decoded and placed into a control block. */
4100 /* Subroutine to read an argument, preceded by a comma and terminated
4101 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4102 1 = fixed point number (returned *1000).
4105 paddr pointer to pointer to current character; updated
4106 type 0 => read a time; 1 => read a fixed point number
4108 Returns: time in seconds or fixed point number * 1000
4112 retry_arg(const uschar **paddr, int type)
4114 const uschar *p = *paddr;
4117 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4119 while (isspace(*p)) p++;
4121 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4123 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4124 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4129 case 0: return readconf_readtime(pp, *p, FALSE);
4130 case 1: return readconf_readfixed(pp, *p);
4132 return 0; /* Keep picky compilers happy */
4135 /* The function proper */
4138 readconf_retries(void)
4140 retry_config **chain = &retries;
4144 while ((p = get_config_line()))
4146 retry_rule **rchain;
4150 next = store_get(sizeof(retry_config));
4153 chain = &(next->next);
4154 next->basic_errno = next->more_errno = 0;
4155 next->senders = NULL;
4157 rchain = &(next->rules);
4159 next->pattern = string_dequote(&p);
4160 while (isspace(*p)) p++;
4162 while (mac_isgraph(*p)) p++;
4163 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4164 "missing error type in retry rule");
4166 /* Test error names for things we understand. */
4168 if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4169 &next->more_errno)))
4170 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4172 /* There may be an optional address list of senders to be used as another
4173 constraint on the rule. This was added later, so the syntax is a bit of a
4174 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4177 while (isspace(*p)) p++;
4178 if (Ustrncmp(p, "senders", 7) == 0)
4181 while (isspace(*p)) p++;
4182 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4183 "\"=\" expected after \"senders\" in retry rule");
4184 while (isspace(*p)) p++;
4185 next->senders = string_dequote(&p);
4188 /* Now the retry rules. Keep the maximum timeout encountered. */
4190 while (isspace(*p)) p++;
4194 retry_rule *rule = store_get(sizeof(retry_rule));
4196 rchain = &(rule->next);
4198 rule->rule = toupper(*p++);
4199 rule->timeout = retry_arg(&p, 0);
4200 if (rule->timeout > retry_maximum_timeout)
4201 retry_maximum_timeout = rule->timeout;
4205 case 'F': /* Fixed interval */
4206 rule->p1 = retry_arg(&p, 0);
4209 case 'G': /* Geometrically increasing intervals */
4210 case 'H': /* Ditto, but with randomness */
4211 rule->p1 = retry_arg(&p, 0);
4212 rule->p2 = retry_arg(&p, 1);
4216 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4220 if (rule->timeout <= 0 || rule->p1 <= 0 ||
4221 (rule->rule != 'F' && rule->p2 < 1000))
4222 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4223 "bad parameters for retry rule");
4225 while (isspace(*p)) p++;
4229 while (isspace(*p)) p++;
4232 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4239 /*************************************************
4240 * Initialize authenticators *
4241 *************************************************/
4244 readconf_options_auths(void)
4246 struct auth_info * ai;
4248 readconf_options_from_list(optionlist_auths, optionlist_auths_size, US"AU");
4250 for (ai = auths_available; ai->driver_name[0]; ai++)
4252 macro_create(string_sprintf("_DRVR_AUTH_%T", ai->driver_name), US"y", FALSE);
4253 readconf_options_from_list(ai->options, (unsigned)*ai->options_count, ai->driver_name);
4258 /* Read the authenticators section of the configuration file.
4267 auth_instance *au, *bu;
4269 readconf_driver_init(US"authenticator",
4270 (driver_instance **)(&auths), /* chain anchor */
4271 (driver_info *)auths_available, /* available drivers */
4272 sizeof(auth_info), /* size of info block */
4273 &auth_defaults, /* default values for generic options */
4274 sizeof(auth_instance), /* size of instance block */
4275 optionlist_auths, /* generic options */
4276 optionlist_auths_size);
4278 for (au = auths; au; au = au->next)
4280 if (!au->public_name)
4281 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4282 "the %s authenticator", au->name);
4284 for (bu = au->next; bu; bu = bu->next)
4285 if (strcmpic(au->public_name, bu->public_name) == 0)
4286 if ((au->client && bu->client) || (au->server && bu->server))
4287 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4288 "(%s and %s) have the same public name (%s)",
4289 au->client ? US"client" : US"server", au->name, bu->name,
4297 /*************************************************
4298 * Read ACL information *
4299 *************************************************/
4301 /* If this run of Exim is not doing something that involves receiving a
4302 message, we can just skip over the ACL information. No need to parse it.
4304 First, we have a function for acl_read() to call back to get the next line. We
4305 need to remember the line we passed, because at the end it will contain the
4306 name of the next ACL. */
4308 static uschar *acl_line;
4313 acl_line = get_config_line();
4318 /* Now the main function:
4329 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4332 acl_line = get_config_line();
4334 while(acl_line != NULL)
4340 p = readconf_readname(name, sizeof(name), acl_line);
4341 if (isupper(*name) && *p == '=')
4343 read_macro_assignment(acl_line);
4344 acl_line = get_config_line();
4348 if (*p != ':' || name[0] == 0)
4349 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4351 node = store_get(sizeof(tree_node) + Ustrlen(name));
4352 Ustrcpy(node->name, name);
4353 if (!tree_insertnode(&acl_anchor, node))
4354 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4355 "there are two ACLs called \"%s\"", name);
4357 node->data.ptr = acl_read(acl_callback, &error);
4359 if (node->data.ptr == NULL && error != NULL)
4360 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4366 /*************************************************
4367 * Read configuration for local_scan() *
4368 *************************************************/
4370 /* This function is called after "begin local_scan" is encountered in the
4371 configuration file. If the local_scan() function allows for configuration
4372 options, we can process them. Otherwise, we expire in a panic.
4379 local_scan_init(void)
4381 #ifndef LOCAL_SCAN_HAS_OPTIONS
4382 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4383 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4387 while ((p = get_config_line()) != NULL)
4389 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4390 NULL, US"local_scan option \"%s\" unknown");
4397 /*************************************************
4398 * Read rest of configuration (after main) *
4399 *************************************************/
4401 /* This function reads the rest of the runtime configuration, after the main
4402 configuration. It is called only when actually needed. Each subsequent section
4403 of the configuration starts with a line of the form
4407 where the name is "routers", "transports", etc. A section is terminated by
4408 hitting the next "begin" line, and the next name is left in next_section.
4409 Because it may confuse people as to whether the names are singular or plural,
4410 we add "s" if it's missing. There is always enough room in next_section for
4411 this. This function is basically just a switch.
4417 static uschar *section_list[] = {
4431 while(next_section[0] != 0)
4435 int last = sizeof(section_list) / sizeof(uschar *);
4437 int n = Ustrlen(next_section);
4439 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4443 int c = strcmpic(next_section, section_list[mid]);
4445 if (c > 0) first = mid + 1; else last = mid;
4447 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4448 "\"%.*s\" is not a known configuration section name", n, next_section);
4449 mid = (last + first)/2;
4453 if (((had ^= bit) & bit) == 0)
4454 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4455 "\"%.*s\" section is repeated in the configuration file", n,
4460 case 0: readconf_acl(); break;
4461 case 1: auths_init(); break;
4462 case 2: local_scan_init(); break;
4463 case 3: readconf_retries(); break;
4464 case 4: readconf_rewrites(); break;
4465 case 5: route_init(); break;
4466 case 6: transport_init(); break;
4470 (void)fclose(config_file);
4473 /* Init the storage for the pre-parsed config lines */
4475 readconf_save_config(const uschar *s)
4477 save_config_line(string_sprintf("# Exim Configuration (%s)",
4478 running_in_test_harness ? US"X" : s));
4482 save_config_position(const uschar *file, int line)
4484 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4487 /* Append a pre-parsed logical line to the config lines store,
4488 this operates on a global (static) list that holds all the pre-parsed
4489 config lines, we do no further processing here, output formatting and
4490 honouring of <hide> or macros will be done during output */
4492 save_config_line(const uschar* line)
4494 static config_line_item *current;
4495 config_line_item *next;
4497 next = (config_line_item*) store_get(sizeof(config_line_item));
4498 next->line = string_copy(line);
4501 if (!config_lines) config_lines = next;
4502 else current->next = next;
4507 /* List the parsed config lines, care about nice formatting and
4508 hide the <hide> values unless we're the admin user */
4510 print_config(BOOL admin, BOOL terse)
4512 config_line_item *i;
4513 const int TS = terse ? 0 : 2;
4516 for (i = config_lines; i; i = i->next)
4521 /* skip over to the first non-space */
4522 for (current = i->line; *current && isspace(*current); ++current)
4525 if (*current == '\0')
4528 /* Collapse runs of spaces. We stop this if we encounter one of the
4529 * following characters: "'$, as this may indicate careful formatting */
4530 for (p = current; *p; ++p)
4533 if (!isspace(*p)) continue;
4534 if (*p != ' ') *p = ' ';
4536 for (next = p; isspace(*next); ++next)
4540 memmove(p+1, next, Ustrlen(next)+1);
4542 if (*next == '"' || *next == '\'' || *next == '$')
4547 if (current[0] == '#')
4550 /* begin lines are left aligned */
4551 else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4553 if (!terse) puts("");
4558 /* router/acl/transport block names */
4559 else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4561 if (!terse) puts("");
4562 printf("%*s%s\n", TS, "", current);
4566 /* hidden lines (all MACROS or lines prefixed with "hide") */
4568 && ( isupper(*current)
4569 || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4573 if ((p = Ustrchr(current, '=')))
4576 printf("%*s%s= %s\n", indent, "", current, hidden);
4578 /* e.g.: hide split_spool_directory */
4580 printf("%*s\n", indent, hidden);
4584 /* rest is public */
4585 printf("%*s%s\n", indent, "", current);
4591 /* End of readconf.c */