1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
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
;
17 #define CSTATE_STACK_SIZE 10
20 /* Structure for chain (stack) of .included files */
22 typedef struct config_file_item
{
23 struct config_file_item
*next
;
29 /* Structure of table of conditional words and their state transitions */
31 typedef struct cond_item
{
39 /* Structure of table of syslog facility names and values */
41 typedef struct syslog_fac_item
{
47 /* Static variables */
49 static config_file_item
*config_file_stack
= NULL
; /* For includes */
51 static uschar
*syslog_facility_str
= NULL
;
52 static uschar next_section
[24];
53 static uschar time_buffer
[24];
55 /* State variables for conditional loading (.ifdef / .else / .endif) */
57 static int cstate
= 0;
58 static int cstate_stack_ptr
= -1;
59 static int cstate_stack
[CSTATE_STACK_SIZE
];
61 /* Table of state transitions for handling conditional inclusions. There are
62 four possible state transitions:
66 .elifdef true (or .else)
69 .endif just causes the previous cstate to be popped off the stack */
71 static int next_cstate
[3][4] =
73 /* State 0: reading from file, or reading until next .else or .endif */
75 /* State 1: condition failed, skipping until next .else or .endif */
77 /* State 2: skipping until .endif */
81 /* Table of conditionals and the states to set. For each name, there are four
82 values: the length of the name (to save computing it each time), the state to
83 set if a macro was found in the line, the state to set if a macro was not found
84 in the line, and a stack manipulation setting which is:
86 -1 pull state value off the stack
87 0 don't alter the stack
88 +1 push value onto stack, before setting new state
91 static cond_item cond_list
[] = {
92 { US
"ifdef", 5, 0, 1, 1 },
93 { US
"ifndef", 6, 1, 0, 1 },
94 { US
"elifdef", 7, 2, 3, 0 },
95 { US
"elifndef", 8, 3, 2, 0 },
96 { US
"else", 4, 2, 2, 0 },
97 { US
"endif", 5, 0, 0, -1 }
100 static int cond_list_size
= sizeof(cond_list
)/sizeof(cond_item
);
102 /* Table of syslog facility names and their values */
104 static syslog_fac_item syslog_list
[] = {
105 { US
"mail", LOG_MAIL
},
106 { US
"user", LOG_USER
},
107 { US
"news", LOG_NEWS
},
108 { US
"uucp", LOG_UUCP
},
109 { US
"local0", LOG_LOCAL0
},
110 { US
"local1", LOG_LOCAL1
},
111 { US
"local2", LOG_LOCAL2
},
112 { US
"local3", LOG_LOCAL3
},
113 { US
"local4", LOG_LOCAL4
},
114 { US
"local5", LOG_LOCAL5
},
115 { US
"local6", LOG_LOCAL6
},
116 { US
"local7", LOG_LOCAL7
},
117 { US
"daemon", LOG_DAEMON
}
120 static int syslog_list_size
= sizeof(syslog_list
)/sizeof(syslog_fac_item
);
125 /*************************************************
126 * Main configuration options *
127 *************************************************/
129 /* The list of options that can be set in the main configuration file. This
130 must be in alphabetic order because it is searched by binary chop. */
132 static optionlist optionlist_config
[] = {
133 { "*set_exim_group", opt_bool
|opt_hidden
, &exim_gid_set
},
134 { "*set_exim_user", opt_bool
|opt_hidden
, &exim_uid_set
},
135 { "*set_system_filter_group", opt_bool
|opt_hidden
, &system_filter_gid_set
},
136 { "*set_system_filter_user", opt_bool
|opt_hidden
, &system_filter_uid_set
},
137 { "accept_8bitmime", opt_bool
, &accept_8bitmime
},
138 { "acl_not_smtp", opt_stringptr
, &acl_not_smtp
},
139 #ifdef WITH_CONTENT_SCAN
140 { "acl_not_smtp_mime", opt_stringptr
, &acl_not_smtp_mime
},
142 { "acl_not_smtp_start", opt_stringptr
, &acl_not_smtp_start
},
143 { "acl_smtp_auth", opt_stringptr
, &acl_smtp_auth
},
144 { "acl_smtp_connect", opt_stringptr
, &acl_smtp_connect
},
145 { "acl_smtp_data", opt_stringptr
, &acl_smtp_data
},
147 { "acl_smtp_data_prdr", opt_stringptr
, &acl_smtp_data_prdr
},
150 { "acl_smtp_dkim", opt_stringptr
, &acl_smtp_dkim
},
152 { "acl_smtp_etrn", opt_stringptr
, &acl_smtp_etrn
},
153 { "acl_smtp_expn", opt_stringptr
, &acl_smtp_expn
},
154 { "acl_smtp_helo", opt_stringptr
, &acl_smtp_helo
},
155 { "acl_smtp_mail", opt_stringptr
, &acl_smtp_mail
},
156 { "acl_smtp_mailauth", opt_stringptr
, &acl_smtp_mailauth
},
157 #ifdef WITH_CONTENT_SCAN
158 { "acl_smtp_mime", opt_stringptr
, &acl_smtp_mime
},
160 { "acl_smtp_notquit", opt_stringptr
, &acl_smtp_notquit
},
161 { "acl_smtp_predata", opt_stringptr
, &acl_smtp_predata
},
162 { "acl_smtp_quit", opt_stringptr
, &acl_smtp_quit
},
163 { "acl_smtp_rcpt", opt_stringptr
, &acl_smtp_rcpt
},
165 { "acl_smtp_starttls", opt_stringptr
, &acl_smtp_starttls
},
167 { "acl_smtp_vrfy", opt_stringptr
, &acl_smtp_vrfy
},
168 { "add_environment", opt_stringptr
, &add_environment
},
169 { "admin_groups", opt_gidlist
, &admin_groups
},
170 { "allow_domain_literals", opt_bool
, &allow_domain_literals
},
171 { "allow_mx_to_ip", opt_bool
, &allow_mx_to_ip
},
172 { "allow_utf8_domains", opt_bool
, &allow_utf8_domains
},
173 { "auth_advertise_hosts", opt_stringptr
, &auth_advertise_hosts
},
174 { "auto_thaw", opt_time
, &auto_thaw
},
175 #ifdef WITH_CONTENT_SCAN
176 { "av_scanner", opt_stringptr
, &av_scanner
},
178 { "bi_command", opt_stringptr
, &bi_command
},
179 #ifdef EXPERIMENTAL_BRIGHTMAIL
180 { "bmi_config_file", opt_stringptr
, &bmi_config_file
},
182 { "bounce_message_file", opt_stringptr
, &bounce_message_file
},
183 { "bounce_message_text", opt_stringptr
, &bounce_message_text
},
184 { "bounce_return_body", opt_bool
, &bounce_return_body
},
185 { "bounce_return_message", opt_bool
, &bounce_return_message
},
186 { "bounce_return_size_limit", opt_mkint
, &bounce_return_size_limit
},
187 { "bounce_sender_authentication",opt_stringptr
,&bounce_sender_authentication
},
188 { "callout_domain_negative_expire", opt_time
, &callout_cache_domain_negative_expire
},
189 { "callout_domain_positive_expire", opt_time
, &callout_cache_domain_positive_expire
},
190 { "callout_negative_expire", opt_time
, &callout_cache_negative_expire
},
191 { "callout_positive_expire", opt_time
, &callout_cache_positive_expire
},
192 { "callout_random_local_part",opt_stringptr
, &callout_random_local_part
},
193 { "check_log_inodes", opt_int
, &check_log_inodes
},
194 { "check_log_space", opt_Kint
, &check_log_space
},
195 { "check_rfc2047_length", opt_bool
, &check_rfc2047_length
},
196 { "check_spool_inodes", opt_int
, &check_spool_inodes
},
197 { "check_spool_space", opt_Kint
, &check_spool_space
},
198 { "daemon_smtp_port", opt_stringptr
|opt_hidden
, &daemon_smtp_port
},
199 { "daemon_smtp_ports", opt_stringptr
, &daemon_smtp_port
},
200 { "daemon_startup_retries", opt_int
, &daemon_startup_retries
},
201 { "daemon_startup_sleep", opt_time
, &daemon_startup_sleep
},
202 #ifdef EXPERIMENTAL_DCC
203 { "dcc_direct_add_header", opt_bool
, &dcc_direct_add_header
},
204 { "dccifd_address", opt_stringptr
, &dccifd_address
},
205 { "dccifd_options", opt_stringptr
, &dccifd_options
},
207 { "delay_warning", opt_timelist
, &delay_warning
},
208 { "delay_warning_condition", opt_stringptr
, &delay_warning_condition
},
209 { "deliver_drop_privilege", opt_bool
, &deliver_drop_privilege
},
210 { "deliver_queue_load_max", opt_fixed
, &deliver_queue_load_max
},
211 { "delivery_date_remove", opt_bool
, &delivery_date_remove
},
212 #ifdef ENABLE_DISABLE_FSYNC
213 { "disable_fsync", opt_bool
, &disable_fsync
},
215 { "disable_ipv6", opt_bool
, &disable_ipv6
},
217 { "dkim_verify_signers", opt_stringptr
, &dkim_verify_signers
},
219 #ifdef EXPERIMENTAL_DMARC
220 { "dmarc_forensic_sender", opt_stringptr
, &dmarc_forensic_sender
},
221 { "dmarc_history_file", opt_stringptr
, &dmarc_history_file
},
222 { "dmarc_tld_file", opt_stringptr
, &dmarc_tld_file
},
224 { "dns_again_means_nonexist", opt_stringptr
, &dns_again_means_nonexist
},
225 { "dns_check_names_pattern", opt_stringptr
, &check_dns_names_pattern
},
226 { "dns_csa_search_limit", opt_int
, &dns_csa_search_limit
},
227 { "dns_csa_use_reverse", opt_bool
, &dns_csa_use_reverse
},
228 { "dns_dnssec_ok", opt_int
, &dns_dnssec_ok
},
229 { "dns_ipv4_lookup", opt_stringptr
, &dns_ipv4_lookup
},
230 { "dns_retrans", opt_time
, &dns_retrans
},
231 { "dns_retry", opt_int
, &dns_retry
},
232 { "dns_use_edns0", opt_int
, &dns_use_edns0
},
233 /* This option is now a no-op, retained for compability */
234 { "drop_cr", opt_bool
, &drop_cr
},
235 /*********************************************************/
236 #ifdef EXPERIMENTAL_DSN
237 { "dsn_advertise_hosts", opt_stringptr
, &dsn_advertise_hosts
},
239 { "dsn_from", opt_stringptr
, &dsn_from
},
240 { "envelope_to_remove", opt_bool
, &envelope_to_remove
},
241 { "errors_copy", opt_stringptr
, &errors_copy
},
242 { "errors_reply_to", opt_stringptr
, &errors_reply_to
},
243 { "exim_group", opt_gid
, &exim_gid
},
244 { "exim_path", opt_stringptr
, &exim_path
},
245 { "exim_user", opt_uid
, &exim_uid
},
246 { "extra_local_interfaces", opt_stringptr
, &extra_local_interfaces
},
247 { "extract_addresses_remove_arguments", opt_bool
, &extract_addresses_remove_arguments
},
248 { "finduser_retries", opt_int
, &finduser_retries
},
249 { "freeze_tell", opt_stringptr
, &freeze_tell
},
250 { "gecos_name", opt_stringptr
, &gecos_name
},
251 { "gecos_pattern", opt_stringptr
, &gecos_pattern
},
253 { "gnutls_allow_auto_pkcs11", opt_bool
, &gnutls_allow_auto_pkcs11
},
254 { "gnutls_compat_mode", opt_bool
, &gnutls_compat_mode
},
255 /* These three gnutls_require_* options stopped working in Exim 4.80 */
256 /* From 4.83 we log a warning; a future relase will remove them */
257 { "gnutls_require_kx", opt_stringptr
, &gnutls_require_kx
},
258 { "gnutls_require_mac", opt_stringptr
, &gnutls_require_mac
},
259 { "gnutls_require_protocols", opt_stringptr
, &gnutls_require_proto
},
261 { "header_line_maxsize", opt_int
, &header_line_maxsize
},
262 { "header_maxsize", opt_int
, &header_maxsize
},
263 { "headers_charset", opt_stringptr
, &headers_charset
},
264 { "helo_accept_junk_hosts", opt_stringptr
, &helo_accept_junk_hosts
},
265 { "helo_allow_chars", opt_stringptr
, &helo_allow_chars
},
266 { "helo_lookup_domains", opt_stringptr
, &helo_lookup_domains
},
267 { "helo_try_verify_hosts", opt_stringptr
, &helo_try_verify_hosts
},
268 { "helo_verify_hosts", opt_stringptr
, &helo_verify_hosts
},
269 { "hold_domains", opt_stringptr
, &hold_domains
},
270 { "host_lookup", opt_stringptr
, &host_lookup
},
271 { "host_lookup_order", opt_stringptr
, &host_lookup_order
},
272 { "host_reject_connection", opt_stringptr
, &host_reject_connection
},
273 { "hosts_connection_nolog", opt_stringptr
, &hosts_connection_nolog
},
274 { "hosts_treat_as_local", opt_stringptr
, &hosts_treat_as_local
},
276 { "ibase_servers", opt_stringptr
, &ibase_servers
},
278 { "ignore_bounce_errors_after", opt_time
, &ignore_bounce_errors_after
},
279 { "ignore_fromline_hosts", opt_stringptr
, &ignore_fromline_hosts
},
280 { "ignore_fromline_local", opt_bool
, &ignore_fromline_local
},
281 { "keep_environment", opt_stringptr
, &keep_environment
},
282 { "keep_malformed", opt_time
, &keep_malformed
},
284 { "ldap_ca_cert_dir", opt_stringptr
, &eldap_ca_cert_dir
},
285 { "ldap_ca_cert_file", opt_stringptr
, &eldap_ca_cert_file
},
286 { "ldap_cert_file", opt_stringptr
, &eldap_cert_file
},
287 { "ldap_cert_key", opt_stringptr
, &eldap_cert_key
},
288 { "ldap_cipher_suite", opt_stringptr
, &eldap_cipher_suite
},
289 { "ldap_default_servers", opt_stringptr
, &eldap_default_servers
},
290 { "ldap_require_cert", opt_stringptr
, &eldap_require_cert
},
291 { "ldap_start_tls", opt_bool
, &eldap_start_tls
},
292 { "ldap_version", opt_int
, &eldap_version
},
294 { "local_from_check", opt_bool
, &local_from_check
},
295 { "local_from_prefix", opt_stringptr
, &local_from_prefix
},
296 { "local_from_suffix", opt_stringptr
, &local_from_suffix
},
297 { "local_interfaces", opt_stringptr
, &local_interfaces
},
298 { "local_scan_timeout", opt_time
, &local_scan_timeout
},
299 { "local_sender_retain", opt_bool
, &local_sender_retain
},
300 { "localhost_number", opt_stringptr
, &host_number_string
},
301 { "log_file_path", opt_stringptr
, &log_file_path
},
302 { "log_selector", opt_stringptr
, &log_selector_string
},
303 { "log_timezone", opt_bool
, &log_timezone
},
304 { "lookup_open_max", opt_int
, &lookup_open_max
},
305 { "max_username_length", opt_int
, &max_username_length
},
306 { "message_body_newlines", opt_bool
, &message_body_newlines
},
307 { "message_body_visible", opt_mkint
, &message_body_visible
},
308 { "message_id_header_domain", opt_stringptr
, &message_id_domain
},
309 { "message_id_header_text", opt_stringptr
, &message_id_text
},
310 { "message_logs", opt_bool
, &message_logs
},
311 { "message_size_limit", opt_stringptr
, &message_size_limit
},
312 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
313 { "move_frozen_messages", opt_bool
, &move_frozen_messages
},
315 { "mua_wrapper", opt_bool
, &mua_wrapper
},
317 { "mysql_servers", opt_stringptr
, &mysql_servers
},
319 { "never_users", opt_uidlist
, &never_users
},
321 { "openssl_options", opt_stringptr
, &openssl_options
},
324 { "oracle_servers", opt_stringptr
, &oracle_servers
},
326 { "percent_hack_domains", opt_stringptr
, &percent_hack_domains
},
328 { "perl_at_start", opt_bool
, &opt_perl_at_start
},
329 { "perl_startup", opt_stringptr
, &opt_perl_startup
},
332 { "pgsql_servers", opt_stringptr
, &pgsql_servers
},
334 { "pid_file_path", opt_stringptr
, &pid_file_path
},
335 { "pipelining_advertise_hosts", opt_stringptr
, &pipelining_advertise_hosts
},
337 { "prdr_enable", opt_bool
, &prdr_enable
},
339 { "preserve_message_logs", opt_bool
, &preserve_message_logs
},
340 { "primary_hostname", opt_stringptr
, &primary_hostname
},
341 { "print_topbitchars", opt_bool
, &print_topbitchars
},
342 { "process_log_path", opt_stringptr
, &process_log_path
},
343 { "prod_requires_admin", opt_bool
, &prod_requires_admin
},
344 #ifdef EXPERIMENTAL_PROXY
345 { "proxy_required_hosts", opt_stringptr
, &proxy_required_hosts
},
347 { "qualify_domain", opt_stringptr
, &qualify_domain_sender
},
348 { "qualify_recipient", opt_stringptr
, &qualify_domain_recipient
},
349 { "queue_domains", opt_stringptr
, &queue_domains
},
350 { "queue_list_requires_admin",opt_bool
, &queue_list_requires_admin
},
351 { "queue_only", opt_bool
, &queue_only
},
352 { "queue_only_file", opt_stringptr
, &queue_only_file
},
353 { "queue_only_load", opt_fixed
, &queue_only_load
},
354 { "queue_only_load_latch", opt_bool
, &queue_only_load_latch
},
355 { "queue_only_override", opt_bool
, &queue_only_override
},
356 { "queue_run_in_order", opt_bool
, &queue_run_in_order
},
357 { "queue_run_max", opt_int
, &queue_run_max
},
358 { "queue_smtp_domains", opt_stringptr
, &queue_smtp_domains
},
359 { "receive_timeout", opt_time
, &receive_timeout
},
360 { "received_header_text", opt_stringptr
, &received_header_text
},
361 { "received_headers_max", opt_int
, &received_headers_max
},
362 { "recipient_unqualified_hosts", opt_stringptr
, &recipient_unqualified_hosts
},
363 { "recipients_max", opt_int
, &recipients_max
},
364 { "recipients_max_reject", opt_bool
, &recipients_max_reject
},
365 #ifdef EXPERIMENTAL_REDIS
366 { "redis_servers", opt_stringptr
, &redis_servers
},
368 { "remote_max_parallel", opt_int
, &remote_max_parallel
},
369 { "remote_sort_domains", opt_stringptr
, &remote_sort_domains
},
370 { "retry_data_expire", opt_time
, &retry_data_expire
},
371 { "retry_interval_max", opt_time
, &retry_interval_max
},
372 { "return_path_remove", opt_bool
, &return_path_remove
},
373 { "return_size_limit", opt_mkint
|opt_hidden
, &bounce_return_size_limit
},
374 { "rfc1413_hosts", opt_stringptr
, &rfc1413_hosts
},
375 { "rfc1413_query_timeout", opt_time
, &rfc1413_query_timeout
},
376 { "sender_unqualified_hosts", opt_stringptr
, &sender_unqualified_hosts
},
377 { "smtp_accept_keepalive", opt_bool
, &smtp_accept_keepalive
},
378 { "smtp_accept_max", opt_int
, &smtp_accept_max
},
379 { "smtp_accept_max_nonmail", opt_int
, &smtp_accept_max_nonmail
},
380 { "smtp_accept_max_nonmail_hosts", opt_stringptr
, &smtp_accept_max_nonmail_hosts
},
381 { "smtp_accept_max_per_connection", opt_int
, &smtp_accept_max_per_connection
},
382 { "smtp_accept_max_per_host", opt_stringptr
, &smtp_accept_max_per_host
},
383 { "smtp_accept_queue", opt_int
, &smtp_accept_queue
},
384 { "smtp_accept_queue_per_connection", opt_int
, &smtp_accept_queue_per_connection
},
385 { "smtp_accept_reserve", opt_int
, &smtp_accept_reserve
},
386 { "smtp_active_hostname", opt_stringptr
, &raw_active_hostname
},
387 { "smtp_banner", opt_stringptr
, &smtp_banner
},
388 { "smtp_check_spool_space", opt_bool
, &smtp_check_spool_space
},
389 { "smtp_connect_backlog", opt_int
, &smtp_connect_backlog
},
390 { "smtp_enforce_sync", opt_bool
, &smtp_enforce_sync
},
391 { "smtp_etrn_command", opt_stringptr
, &smtp_etrn_command
},
392 { "smtp_etrn_serialize", opt_bool
, &smtp_etrn_serialize
},
393 { "smtp_load_reserve", opt_fixed
, &smtp_load_reserve
},
394 { "smtp_max_synprot_errors", opt_int
, &smtp_max_synprot_errors
},
395 { "smtp_max_unknown_commands",opt_int
, &smtp_max_unknown_commands
},
396 { "smtp_ratelimit_hosts", opt_stringptr
, &smtp_ratelimit_hosts
},
397 { "smtp_ratelimit_mail", opt_stringptr
, &smtp_ratelimit_mail
},
398 { "smtp_ratelimit_rcpt", opt_stringptr
, &smtp_ratelimit_rcpt
},
399 { "smtp_receive_timeout", opt_time
, &smtp_receive_timeout
},
400 { "smtp_reserve_hosts", opt_stringptr
, &smtp_reserve_hosts
},
401 { "smtp_return_error_details",opt_bool
, &smtp_return_error_details
},
402 #ifdef WITH_CONTENT_SCAN
403 { "spamd_address", opt_stringptr
, &spamd_address
},
405 #ifdef EXPERIMENTAL_SPF
406 { "spf_guess", opt_stringptr
, &spf_guess
},
408 { "split_spool_directory", opt_bool
, &split_spool_directory
},
409 { "spool_directory", opt_stringptr
, &spool_directory
},
411 { "sqlite_lock_timeout", opt_int
, &sqlite_lock_timeout
},
413 #ifdef EXPERIMENTAL_SRS
414 { "srs_config", opt_stringptr
, &srs_config
},
415 { "srs_hashlength", opt_int
, &srs_hashlength
},
416 { "srs_hashmin", opt_int
, &srs_hashmin
},
417 { "srs_maxage", opt_int
, &srs_maxage
},
418 { "srs_secrets", opt_stringptr
, &srs_secrets
},
419 { "srs_usehash", opt_bool
, &srs_usehash
},
420 { "srs_usetimestamp", opt_bool
, &srs_usetimestamp
},
422 { "strict_acl_vars", opt_bool
, &strict_acl_vars
},
423 { "strip_excess_angle_brackets", opt_bool
, &strip_excess_angle_brackets
},
424 { "strip_trailing_dot", opt_bool
, &strip_trailing_dot
},
425 { "syslog_duplication", opt_bool
, &syslog_duplication
},
426 { "syslog_facility", opt_stringptr
, &syslog_facility_str
},
427 { "syslog_processname", opt_stringptr
, &syslog_processname
},
428 { "syslog_timestamp", opt_bool
, &syslog_timestamp
},
429 { "system_filter", opt_stringptr
, &system_filter
},
430 { "system_filter_directory_transport", opt_stringptr
,&system_filter_directory_transport
},
431 { "system_filter_file_transport",opt_stringptr
,&system_filter_file_transport
},
432 { "system_filter_group", opt_gid
, &system_filter_gid
},
433 { "system_filter_pipe_transport",opt_stringptr
,&system_filter_pipe_transport
},
434 { "system_filter_reply_transport",opt_stringptr
,&system_filter_reply_transport
},
435 { "system_filter_user", opt_uid
, &system_filter_uid
},
436 { "tcp_nodelay", opt_bool
, &tcp_nodelay
},
437 #ifdef USE_TCP_WRAPPERS
438 { "tcp_wrappers_daemon_name", opt_stringptr
, &tcp_wrappers_daemon_name
},
440 { "timeout_frozen_after", opt_time
, &timeout_frozen_after
},
441 { "timezone", opt_stringptr
, &timezone_string
},
443 { "tls_advertise_hosts", opt_stringptr
, &tls_advertise_hosts
},
444 { "tls_certificate", opt_stringptr
, &tls_certificate
},
445 { "tls_crl", opt_stringptr
, &tls_crl
},
446 { "tls_dh_max_bits", opt_int
, &tls_dh_max_bits
},
447 { "tls_dhparam", opt_stringptr
, &tls_dhparam
},
448 # ifndef DISABLE_OCSP
449 { "tls_ocsp_file", opt_stringptr
, &tls_ocsp_file
},
451 { "tls_on_connect_ports", opt_stringptr
, &tls_in
.on_connect_ports
},
452 { "tls_privatekey", opt_stringptr
, &tls_privatekey
},
453 { "tls_remember_esmtp", opt_bool
, &tls_remember_esmtp
},
454 { "tls_require_ciphers", opt_stringptr
, &tls_require_ciphers
},
455 { "tls_try_verify_hosts", opt_stringptr
, &tls_try_verify_hosts
},
456 { "tls_verify_certificates", opt_stringptr
, &tls_verify_certificates
},
457 { "tls_verify_hosts", opt_stringptr
, &tls_verify_hosts
},
459 { "trusted_groups", opt_gidlist
, &trusted_groups
},
460 { "trusted_users", opt_uidlist
, &trusted_users
},
461 { "unknown_login", opt_stringptr
, &unknown_login
},
462 { "unknown_username", opt_stringptr
, &unknown_username
},
463 { "untrusted_set_sender", opt_stringptr
, &untrusted_set_sender
},
464 { "uucp_from_pattern", opt_stringptr
, &uucp_from_pattern
},
465 { "uucp_from_sender", opt_stringptr
, &uucp_from_sender
},
466 { "warn_message_file", opt_stringptr
, &warn_message_file
},
467 { "write_rejectlog", opt_bool
, &write_rejectlog
}
470 static int optionlist_config_size
=
471 sizeof(optionlist_config
)/sizeof(optionlist
);
475 /*************************************************
476 * Find the name of an option *
477 *************************************************/
479 /* This function is to aid debugging. Various functions take arguments that are
480 pointer variables in the options table or in option tables for various drivers.
481 For debugging output, it is useful to be able to find the name of the option
482 which is currently being processed. This function finds it, if it exists, by
483 searching the table(s).
485 Arguments: a value that is presumed to be in the table above
486 Returns: the option name, or an empty string
490 readconf_find_option(void *p
)
494 transport_instance
*t
;
496 for (i
= 0; i
< optionlist_config_size
; i
++)
497 if (p
== optionlist_config
[i
].value
) return US optionlist_config
[i
].name
;
499 for (r
= routers
; r
!= NULL
; r
= r
->next
)
501 router_info
*ri
= r
->info
;
502 for (i
= 0; i
< ri
->options_count
[0]; i
++)
504 if ((ri
->options
[i
].type
& opt_mask
) != opt_stringptr
) continue;
505 if (p
== (char *)(r
->options_block
) + (long int)(ri
->options
[i
].value
))
506 return US ri
->options
[i
].name
;
510 for (t
= transports
; t
!= NULL
; t
= t
->next
)
512 transport_info
*ti
= t
->info
;
513 for (i
= 0; i
< ti
->options_count
[0]; i
++)
515 if ((ti
->options
[i
].type
& opt_mask
) != opt_stringptr
) continue;
516 if (p
== (char *)(t
->options_block
) + (long int)(ti
->options
[i
].value
))
517 return US ti
->options
[i
].name
;
527 /*************************************************
528 * Deal with an assignment to a macro *
529 *************************************************/
531 /* This function is called when a line that starts with an upper case letter is
532 encountered. The argument "line" should contain a complete logical line, and
533 start with the first letter of the macro name. The macro name and the
534 replacement text are extracted and stored. Redefinition of existing,
535 non-command line, macros is permitted using '==' instead of '='.
538 s points to the start of the logical line
544 read_macro_assignment(uschar
*s
)
550 macro_item
*mlast
= NULL
;
552 while (isalnum(*s
) || *s
== '_')
554 if (namelen
>= sizeof(name
) - 1)
555 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
556 "macro name too long (maximum is " SIZE_T_FMT
" characters)", sizeof(name
) - 1);
557 name
[namelen
++] = *s
++;
561 while (isspace(*s
)) s
++;
563 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "malformed macro definition");
570 while (isspace(*s
)) s
++;
572 /* If an existing macro of the same name was defined on the command line, we
573 just skip this definition. It's an error to attempt to redefine a macro without
574 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
575 It is also an error to define a macro whose name begins with the name of a
576 previously defined macro. Note: it is documented that the other way round
579 for (m
= macros
; m
!= NULL
; m
= m
->next
)
581 int len
= Ustrlen(m
->name
);
583 if (Ustrcmp(m
->name
, name
) == 0)
585 if (!m
->command_line
&& !redef
)
586 log_write(0, LOG_CONFIG
|LOG_PANIC_DIE
, "macro \"%s\" is already "
587 "defined (use \"==\" if you want to redefine it", name
);
591 if (len
< namelen
&& Ustrstr(name
, m
->name
) != NULL
)
592 log_write(0, LOG_CONFIG
|LOG_PANIC_DIE
, "\"%s\" cannot be defined as "
593 "a macro because previously defined macro \"%s\" is a substring",
596 /* We cannot have this test, because it is documented that a substring
597 macro is permitted (there is even an example).
599 * if (len > namelen && Ustrstr(m->name, name) != NULL)
600 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
601 * "a macro because it is a substring of previously defined macro \"%s\"",
608 /* Check for an overriding command-line definition. */
610 if (m
!= NULL
&& m
->command_line
) return;
612 /* Redefinition must refer to an existing macro. */
617 log_write(0, LOG_CONFIG
|LOG_PANIC_DIE
, "can't redefine an undefined macro "
621 /* We have a new definition. The macro_item structure includes a final vector
622 called "name" which is one byte long. Thus, adding "namelen" gives us enough
623 room to store the "name" string. */
627 m
= store_get(sizeof(macro_item
) + namelen
);
628 if (macros
== NULL
) macros
= m
; else mlast
->next
= m
;
629 Ustrncpy(m
->name
, name
, namelen
);
630 m
->name
[namelen
] = 0;
632 m
->command_line
= FALSE
;
635 /* Set the value of the new or redefined macro */
637 m
->replacement
= string_copy(s
);
644 /*************************************************
645 * Read configuration line *
646 *************************************************/
648 /* A logical line of text is read from the configuration file into the big
649 buffer, taking account of macros, .includes, and continuations. The size of
650 big_buffer is increased if necessary. The count of configuration lines is
651 maintained. Physical input lines starting with # (ignoring leading white space,
652 and after macro replacement) and empty logical lines are always ignored.
653 Leading and trailing spaces are removed.
655 If we hit a line of the form "begin xxxx", the xxxx is placed in the
656 next_section vector, and the function returns NULL, indicating the end of a
657 configuration section. On end-of-file, NULL is returned with next_section
662 Returns: a pointer to the first non-blank in the line,
663 or NULL if eof or end of section is reached
667 get_config_line(void)
669 int startoffset
= 0; /* To first non-blank char in logical line */
670 int len
= 0; /* Of logical line so far */
676 /* Loop for handling continuation lines, skipping comments, and dealing with
681 if (Ufgets(big_buffer
+len
, big_buffer_size
-len
, config_file
) == NULL
)
683 if (config_file_stack
!= NULL
) /* EOF inside .include */
685 (void)fclose(config_file
);
686 config_file
= config_file_stack
->file
;
687 config_filename
= config_file_stack
->filename
;
688 config_lineno
= config_file_stack
->lineno
;
689 config_file_stack
= config_file_stack
->next
;
693 /* EOF at top level */
695 if (cstate_stack_ptr
>= 0)
696 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
697 "Unexpected end of configuration file: .endif missing");
699 if (len
!= 0) break; /* EOF after continuation */
700 next_section
[0] = 0; /* EOF at start of logical line */
705 newlen
= len
+ Ustrlen(big_buffer
+ len
);
707 /* Handle pathologically long physical lines - yes, it did happen - by
708 extending big_buffer at this point. The code also copes with very long
711 while (newlen
== big_buffer_size
- 1 && big_buffer
[newlen
- 1] != '\n')
714 big_buffer_size
+= BIG_BUFFER_SIZE
;
715 newbuffer
= store_malloc(big_buffer_size
);
717 /* This use of strcpy is OK because we know that the string in the old
718 buffer is shorter than the new buffer. */
720 Ustrcpy(newbuffer
, big_buffer
);
721 store_free(big_buffer
);
722 big_buffer
= newbuffer
;
723 if (Ufgets(big_buffer
+newlen
, big_buffer_size
-newlen
, config_file
) == NULL
)
725 newlen
+= Ustrlen(big_buffer
+ newlen
);
728 /* Find the true start of the physical line - leading spaces are always
731 ss
= big_buffer
+ len
;
732 while (isspace(*ss
)) ss
++;
734 /* Process the physical line for macros. If this is the start of the logical
735 line, skip over initial text at the start of the line if it starts with an
736 upper case character followed by a sequence of name characters and an equals
737 sign, because that is the definition of a new macro, and we don't do
738 replacement therein. */
741 if (len
== 0 && isupper(*s
))
743 while (isalnum(*s
) || *s
== '_') s
++;
744 while (isspace(*s
)) s
++;
745 if (*s
!= '=') s
= ss
; /* Not a macro definition */
748 /* For each defined macro, scan the line (from after XXX= if present),
749 replacing all occurrences of the macro. */
752 for (m
= macros
; m
!= NULL
; m
= m
->next
)
757 while ((p
= Ustrstr(t
, m
->name
)) != NULL
)
760 int namelen
= Ustrlen(m
->name
);
761 int replen
= Ustrlen(m
->replacement
);
763 /* Expand the buffer if necessary */
765 while (newlen
- namelen
+ replen
+ 1 > big_buffer_size
)
767 int newsize
= big_buffer_size
+ BIG_BUFFER_SIZE
;
768 uschar
*newbuffer
= store_malloc(newsize
);
769 memcpy(newbuffer
, big_buffer
, newlen
+ 1);
770 p
= newbuffer
+ (p
- big_buffer
);
771 s
= newbuffer
+ (s
- big_buffer
);
772 ss
= newbuffer
+ (ss
- big_buffer
);
773 t
= newbuffer
+ (t
- big_buffer
);
774 big_buffer_size
= newsize
;
775 store_free(big_buffer
);
776 big_buffer
= newbuffer
;
779 /* Shuffle the remaining characters up or down in the buffer before
780 copying in the replacement text. Don't rescan the replacement for this
784 moveby
= replen
- namelen
;
787 memmove(p
+ replen
, pp
, (big_buffer
+ newlen
) - pp
+ 1);
790 Ustrncpy(p
, m
->replacement
, replen
);
796 /* An empty macro replacement at the start of a line could mean that ss no
797 longer points to the first non-blank character. */
799 while (isspace(*ss
)) ss
++;
801 /* Check for comment lines - these are physical lines. */
803 if (*ss
== '#') continue;
805 /* Handle conditionals, which are also applied to physical lines. Conditions
806 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
807 expansion occured on the rest of the line. A preliminary test for the leading
808 '.' saves effort on most lines. */
814 /* Search the list of conditional directives */
816 for (i
= 0; i
< cond_list_size
; i
++)
819 cond_item
*c
= cond_list
+i
;
820 if (Ustrncmp(ss
+1, c
->name
, c
->namelen
) != 0) continue;
822 /* The following character must be white space or end of string */
824 n
= ss
[1 + c
->namelen
];
825 if (n
!= ' ' && n
!= 't' && n
!= '\n' && n
!= 0) break;
827 /* .ifdef and .ifndef push the current state onto the stack, then set
828 a new one from the table. Stack overflow is an error */
832 if (cstate_stack_ptr
>= CSTATE_STACK_SIZE
- 1)
833 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
834 ".%s nested too deeply", c
->name
);
835 cstate_stack
[++cstate_stack_ptr
] = cstate
;
836 cstate
= next_cstate
[cstate
][macro_found
? c
->action1
: c
->action2
];
839 /* For any of the others, stack underflow is an error. The next state
840 comes either from the stack (.endif) or from the table. */
844 if (cstate_stack_ptr
< 0)
845 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
846 ".%s without matching .ifdef", c
->name
);
847 cstate
= (c
->pushpop
< 0)? cstate_stack
[cstate_stack_ptr
--] :
848 next_cstate
[cstate
][macro_found
? c
->action1
: c
->action2
];
851 /* Having dealt with a directive, break the loop */
856 /* If we have handled a conditional directive, continue with the next
857 physical line. Otherwise, fall through. */
859 if (i
< cond_list_size
) continue;
862 /* If the conditional state is not 0 (actively using these lines), ignore
865 if (cstate
!= 0) continue; /* Conditional skip */
867 /* Handle .include lines - these are also physical lines. */
869 if (Ustrncmp(ss
, ".include", 8) == 0 &&
871 (Ustrncmp(ss
+8, "_if_exists", 10) == 0 && isspace(ss
[18]))))
874 int include_if_exists
= isspace(ss
[8])? 0 : 10;
875 config_file_item
*save
;
878 ss
+= 9 + include_if_exists
;
879 while (isspace(*ss
)) ss
++;
880 t
= ss
+ Ustrlen(ss
);
881 while (t
> ss
&& isspace(t
[-1])) t
--;
882 if (*ss
== '\"' && t
[-1] == '\"')
890 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, ".include specifies a non-"
891 "absolute path \"%s\"", ss
);
893 if (include_if_exists
!= 0 && (Ustat(ss
, &statbuf
) != 0)) continue;
895 save
= store_get(sizeof(config_file_item
));
896 save
->next
= config_file_stack
;
897 config_file_stack
= save
;
898 save
->file
= config_file
;
899 save
->filename
= config_filename
;
900 save
->lineno
= config_lineno
;
902 config_file
= Ufopen(ss
, "rb");
903 if (config_file
== NULL
)
904 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "failed to open included "
905 "configuration file %s", ss
);
906 config_filename
= string_copy(ss
);
911 /* If this is the start of the logical line, remember where the non-blank
912 data starts. Otherwise shuffle down continuation lines to remove leading
916 startoffset
= ss
- big_buffer
;
919 s
= big_buffer
+ len
;
922 memmove(s
, ss
, (newlen
- len
) - (ss
- s
) + 1);
927 /* Accept the new addition to the line. Remove trailing white space. */
930 while (len
> 0 && isspace(big_buffer
[len
-1])) len
--;
933 /* We are done if the line does not end in backslash and contains some data.
934 Empty logical lines are ignored. For continuations, remove the backslash and
935 go round the loop to read the continuation line. */
939 if (big_buffer
[len
-1] != '\\') break; /* End of logical line */
940 big_buffer
[--len
] = 0; /* Remove backslash */
942 } /* Loop for reading multiple physical lines */
944 /* We now have a logical line. Test for the end of a configuration section (or,
945 more accurately, for the start of the next section). Place the name of the next
946 section in next_section, and return NULL. If the name given is longer than
947 next_section, truncate it. It will be unrecognized later, because all the known
948 section names do fit. Leave space for pluralizing. */
950 s
= big_buffer
+ startoffset
; /* First non-space character */
951 if (strncmpic(s
, US
"begin ", 6) == 0)
954 while (isspace(*s
)) s
++;
955 if (big_buffer
+ len
- s
> sizeof(next_section
) - 2)
956 s
[sizeof(next_section
) - 2] = 0;
957 Ustrcpy(next_section
, s
);
961 /* Return the first non-blank character. */
968 /*************************************************
970 *************************************************/
972 /* The yield is the pointer to the next uschar. Names longer than the
973 output space are silently truncated. This function is also used from acl.c when
977 name where to put the name
981 Returns: new input pointer
985 readconf_readname(uschar
*name
, int len
, uschar
*s
)
988 while (isspace(*s
)) s
++;
991 while (isalnum(*s
) || *s
== '_')
993 if (p
< len
-1) name
[p
++] = *s
;
998 while (isspace(*s
)) s
++;
1005 /*************************************************
1006 * Read a time value *
1007 *************************************************/
1009 /* This function is also called from outside, to read argument
1010 time values. The format of a time value is:
1012 [<n>w][<n>d][<n>h][<n>m][<n>s]
1014 as long as at least one is present. If a format error is encountered,
1015 return a negative value. The value must be terminated by the given
1020 terminator required terminating character
1021 return_msec if TRUE, allow fractional seconds and return milliseconds
1023 Returns: the time value, or -1 on syntax error
1024 value is seconds if return_msec is FALSE
1025 value is milliseconds if return_msec is TRUE
1029 readconf_readtime(uschar
*s
, int terminator
, BOOL return_msec
)
1037 if (!isdigit(*s
)) return -1;
1038 (void)sscanf(CS s
, "%d%n", &value
, &count
);
1043 case 'w': value
*= 7;
1044 case 'd': value
*= 24;
1045 case 'h': value
*= 60;
1046 case 'm': value
*= 60;
1051 if (!return_msec
) return -1;
1052 (void)sscanf(CS s
, "%lf%n", &fraction
, &count
);
1054 if (*s
++ != 's') return -1;
1055 yield
+= (int)(fraction
* 1000.0);
1061 if (return_msec
) value
*= 1000;
1063 if (*s
== terminator
) return yield
;
1065 /* Control never reaches here. */
1070 /*************************************************
1071 * Read a fixed point value *
1072 *************************************************/
1074 /* The value is returned *1000
1078 terminator required terminator
1080 Returns: the value, or -1 on error
1084 readconf_readfixed(uschar
*s
, int terminator
)
1088 if (!isdigit(*s
)) return -1;
1089 (void)sscanf(CS s
, "%d%n", &value
, &count
);
1091 yield
= value
* 1000;
1095 while (isdigit((*(++s
))))
1097 yield
+= (*s
- '0') * m
;
1102 return (*s
== terminator
)? yield
: (-1);
1107 /*************************************************
1108 * Find option in list *
1109 *************************************************/
1111 /* The lists are always in order, so binary chop can be used.
1114 name the option name to search for
1115 ol the first entry in the option list
1116 last one more than the offset of the last entry in the option list
1118 Returns: pointer to an option entry, or NULL if not found
1122 find_option(uschar
*name
, optionlist
*ol
, int last
)
1125 while (last
> first
)
1127 int middle
= (first
+ last
)/2;
1128 int c
= Ustrcmp(name
, ol
[middle
].name
);
1129 if (c
== 0) return ol
+ middle
;
1130 else if (c
> 0) first
= middle
+ 1;
1138 /*************************************************
1139 * Find a set flag in option list *
1140 *************************************************/
1142 /* Because some versions of Unix make no restrictions on the values of uids and
1143 gids (even negative ones), we cannot represent "unset" by a special value.
1144 There is therefore a separate boolean variable for each one indicating whether
1145 a value is set or not. This function returns a pointer to the boolean, given
1146 the original option name. It is a major disaster if the flag cannot be found.
1149 name the name of the uid or gid option
1150 oltop points to the start of the relevant option list
1151 last one more than the offset of the last item in the option list
1152 data_block NULL when reading main options => data values in the option
1153 list are absolute addresses; otherwise they are byte offsets
1154 in data_block (used for driver options)
1156 Returns: a pointer to the boolean flag.
1160 get_set_flag(uschar
*name
, optionlist
*oltop
, int last
, void *data_block
)
1164 sprintf(CS name2
, "*set_%.50s", name
);
1165 ol
= find_option(name2
, oltop
, last
);
1166 if (ol
== NULL
) log_write(0, LOG_MAIN
|LOG_PANIC_DIE
,
1167 "Exim internal error: missing set flag for %s", name
);
1168 return (data_block
== NULL
)? (BOOL
*)(ol
->value
) :
1169 (BOOL
*)((uschar
*)data_block
+ (long int)(ol
->value
));
1175 /*************************************************
1176 * Output extra characters message and die *
1177 *************************************************/
1179 /* Called when an option line has junk on the end. Sometimes this is because
1180 the sysadmin thinks comments are permitted.
1183 s points to the extra characters
1184 t1..t3 strings to insert in the log message
1186 Returns: doesn't return; dies
1190 extra_chars_error(uschar
*s
, uschar
*t1
, uschar
*t2
, uschar
*t3
)
1192 uschar
*comment
= US
"";
1193 if (*s
== '#') comment
= US
" (# is comment only at line start)";
1194 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1195 "extra characters follow %s%s%s%s", t1
, t2
, t3
, comment
);
1200 /*************************************************
1201 * Read rewrite information *
1202 *************************************************/
1204 /* Each line of rewrite information contains:
1206 . A complete address in the form user@domain, possibly with
1207 leading * for each part; or alternatively, a regex.
1209 . A replacement string (which will be expanded).
1211 . An optional sequence of one-letter flags, indicating which
1212 headers etc. to apply this rule to.
1214 All this is decoded and placed into a control block. The OR of the flags is
1215 maintained in a common word.
1218 p points to the string that makes up the rule
1219 existflags points to the overall flag word
1220 isglobal TRUE if reading global rewrite rules
1222 Returns: the control block for the parsed rule.
1225 static rewrite_rule
*
1226 readconf_one_rewrite(uschar
*p
, int *existflags
, BOOL isglobal
)
1228 rewrite_rule
*next
= store_get(sizeof(rewrite_rule
));
1231 next
->key
= string_dequote(&p
);
1233 while (isspace(*p
)) p
++;
1235 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1236 "missing rewrite replacement string");
1239 next
->replacement
= string_dequote(&p
);
1241 while (*p
!= 0) switch (*p
++)
1243 case ' ': case '\t': break;
1245 case 'q': next
->flags
|= rewrite_quit
; break;
1246 case 'w': next
->flags
|= rewrite_whole
; break;
1248 case 'h': next
->flags
|= rewrite_all_headers
; break;
1249 case 's': next
->flags
|= rewrite_sender
; break;
1250 case 'f': next
->flags
|= rewrite_from
; break;
1251 case 't': next
->flags
|= rewrite_to
; break;
1252 case 'c': next
->flags
|= rewrite_cc
; break;
1253 case 'b': next
->flags
|= rewrite_bcc
; break;
1254 case 'r': next
->flags
|= rewrite_replyto
; break;
1256 case 'E': next
->flags
|= rewrite_all_envelope
; break;
1257 case 'F': next
->flags
|= rewrite_envfrom
; break;
1258 case 'T': next
->flags
|= rewrite_envto
; break;
1260 case 'Q': next
->flags
|= rewrite_qualify
; break;
1261 case 'R': next
->flags
|= rewrite_repeat
; break;
1264 next
->flags
|= rewrite_smtp
;
1265 if (next
->key
[0] != '^' && Ustrncmp(next
->key
, "\\N^", 3) != 0)
1266 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1267 "rewrite rule has the S flag but is not a regular expression");
1271 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1272 "unknown rewrite flag character '%c' "
1273 "(could be missing quotes round replacement item)", p
[-1]);
1277 /* If no action flags are set, set all the "normal" rewrites. */
1279 if ((next
->flags
& (rewrite_all
| rewrite_smtp
)) == 0)
1280 next
->flags
|= isglobal
? rewrite_all
: rewrite_all_headers
;
1282 /* Remember which exist, for optimization, and return the rule */
1284 *existflags
|= next
->flags
;
1291 /*************************************************
1292 * Read global rewrite information *
1293 *************************************************/
1295 /* Each line is a single rewrite rule; it is parsed into a control block
1296 by readconf_one_rewrite(), and its flags are ORed into the global flag
1297 word rewrite_existflags. */
1300 readconf_rewrites(void)
1302 rewrite_rule
**chain
= &global_rewrite_rules
;
1305 while ((p
= get_config_line()) != NULL
)
1307 rewrite_rule
*next
= readconf_one_rewrite(p
, &rewrite_existflags
, TRUE
);
1309 chain
= &(next
->next
);
1315 /*************************************************
1317 *************************************************/
1319 /* Strings are read into the normal store pool. As long we aren't too
1320 near the end of the current block, the string will just use what is necessary
1321 on the top of the stacking pool, because string_cat() uses the extension
1325 s the rest of the input line
1326 name the option name (for errors)
1328 Returns: pointer to the string
1332 read_string(uschar
*s
, uschar
*name
)
1337 if (*s
!= '\"') return string_copy(s
);
1340 yield
= string_dequote(&s
);
1342 if (s
== ss
+1 || s
[-1] != '\"')
1343 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1344 "missing quote at end of string value for %s", name
);
1346 if (*s
!= 0) extra_chars_error(s
, US
"string value for ", name
, US
"");
1352 /*************************************************
1353 * Handle option line *
1354 *************************************************/
1356 /* This function is called from several places to process a line containing the
1357 setting of an option. The first argument is the line to be decoded; it has been
1358 checked not to be empty and not to start with '#'. Trailing newlines and white
1359 space have been removed. The second argument is a pointer to the list of
1360 variable names that are to be recognized, together with their types and
1361 locations, and the third argument gives the number of entries in the list.
1363 The fourth argument is a pointer to a data block. If it is NULL, then the data
1364 values in the options list are absolute addresses. Otherwise, they are byte
1365 offsets in the data block.
1367 String option data may continue onto several lines; this function reads further
1368 data from config_file if necessary.
1370 The yield of this function is normally zero. If a string continues onto
1371 multiple lines, then the data value is permitted to be followed by a comma
1372 or a semicolon (for use in drivers) and the yield is that character.
1375 buffer contains the configuration line to be handled
1376 oltop points to the start of the relevant option list
1377 last one more than the offset of the last item in the option list
1378 data_block NULL when reading main options => data values in the option
1379 list are absolute addresses; otherwise they are byte offsets
1380 in data_block when they have opt_public set; otherwise
1381 they are byte offsets in data_block->options_block.
1382 unknown_txt format string to use in panic message for unknown option;
1383 must contain %s for option name
1384 if given as NULL, don't panic on unknown option
1386 Returns: TRUE if an option was read successfully,
1387 FALSE false for an unknown option if unknown_txt == NULL,
1388 otherwise panic and die on an unknown option
1392 readconf_handle_option(uschar
*buffer
, optionlist
*oltop
, int last
,
1393 void *data_block
, uschar
*unknown_txt
)
1397 int n
, count
, type
, value
;
1401 BOOL boolvalue
= TRUE
;
1402 BOOL freesptr
= TRUE
;
1403 optionlist
*ol
, *ol2
;
1407 uschar
*inttype
= US
"";
1410 uschar
*saved_condition
, *strtemp
;
1411 uschar
**str_target
;
1415 /* There may be leading spaces; thereafter, we expect an option name starting
1418 while (isspace(*s
)) s
++;
1420 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "option setting expected: %s", s
);
1422 /* Read the name of the option, and skip any subsequent white space. If
1423 it turns out that what we read was "hide", set the flag indicating that
1424 this is a secure option, and loop to read the next word. */
1426 for (n
= 0; n
< 2; n
++)
1428 while (isalnum(*s
) || *s
== '_')
1430 if (ptr
< sizeof(name
)-1) name
[ptr
++] = *s
;
1434 while (isspace(*s
)) s
++;
1435 if (Ustrcmp(name
, "hide") != 0) break;
1436 issecure
= opt_secure
;
1440 /* Deal with "no_" or "not_" here for booleans */
1442 if (Ustrncmp(name
, "no_", 3) == 0)
1448 if (Ustrncmp(name
, "not_", 4) == 0)
1454 /* Search the list for the given name. A non-existent name, or an option that
1455 is set twice, is a disaster. */
1457 ol
= find_option(name
+ offset
, oltop
, last
);
1461 if (unknown_txt
== NULL
) return FALSE
;
1462 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, CS unknown_txt
, name
);
1465 if ((ol
->type
& opt_set
) && !(ol
->type
& (opt_rep_con
| opt_rep_str
)))
1466 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1467 "\"%s\" option set for the second time", name
);
1469 ol
->type
|= opt_set
| issecure
;
1470 type
= ol
->type
& opt_mask
;
1472 /* Types with data values must be followed by '='; the "no[t]_" prefix
1473 applies only to boolean values. */
1475 if (type
< opt_bool
|| type
> opt_bool_last
)
1478 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1479 "negation prefix applied to a non-boolean option");
1481 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1482 "unexpected end of line (data missing) after %s", name
);
1484 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "missing \"=\" after %s", name
);
1487 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1488 true/false/yes/no, or, in the case of opt_expanded_bool, a general string that
1489 ultimately expands to one of those values. */
1491 else if (*s
!= 0 && (offset
!= 0 || *s
!= '='))
1492 extra_chars_error(s
, US
"boolean option ", name
, US
"");
1494 /* Skip white space after = */
1496 if (*s
== '=') while (isspace((*(++s
))));
1498 /* If there is a data block and the opt_public flag is not set, change
1499 the data block pointer to the private options block. */
1501 if (data_block
!= NULL
&& (ol
->type
& opt_public
) == 0)
1502 data_block
= (void *)(((driver_instance
*)data_block
)->options_block
);
1504 /* Now get the data according to the type. */
1508 /* If a string value is not enclosed in quotes, it consists of
1509 the rest of the current line, verbatim. Otherwise, string escapes
1512 A transport is specified as a string, which is then looked up in the
1513 list of transports. A search type is specified as one of a number of
1516 A set or rewrite rules for a driver is specified as a string, which is
1517 then parsed into a suitable chain of control blocks.
1519 Uids and gids are specified as strings which are then looked up in the
1520 passwd file. Lists of uids and gids are similarly specified as colon-
1521 separated strings. */
1526 case opt_expand_uid
:
1527 case opt_expand_gid
:
1532 reset_point
= sptr
= read_string(s
, name
);
1534 /* Having read a string, we now have several different ways of using it,
1535 depending on the data type, so do another switch. If keeping the actual
1536 string is not required (because it is interpreted), freesptr is set TRUE,
1537 and at the end we reset the pool. */
1541 /* If this was a string, set the variable to point to the new string,
1542 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1543 rules, we still keep the string (for printing), and parse the rules into a
1544 control block and flags word. */
1547 if (data_block
== NULL
)
1548 str_target
= (uschar
**)(ol
->value
);
1550 str_target
= (uschar
**)((uschar
*)data_block
+ (long int)(ol
->value
));
1551 if (ol
->type
& opt_rep_con
)
1553 /* We already have a condition, we're conducting a crude hack to let
1554 multiple condition rules be chained together, despite storing them in
1556 saved_condition
= *str_target
;
1557 strtemp
= string_sprintf("${if and{{bool_lax{%s}}{bool_lax{%s}}}}",
1558 saved_condition
, sptr
);
1559 *str_target
= string_copy_malloc(strtemp
);
1560 /* TODO(pdp): there is a memory leak here and just below
1561 when we set 3 or more conditions; I still don't
1562 understand the store mechanism enough to know
1563 what's the safe way to free content from an earlier store.
1564 AFAICT, stores stack, so freeing an early stored item also stores
1565 all data alloc'd after it. If we knew conditions were adjacent,
1566 we could survive that, but we don't. So I *think* we need to take
1567 another bit from opt_type to indicate "malloced"; this seems like
1568 quite a hack, especially for this one case. It also means that
1569 we can't ever reclaim the store from the *first* condition.
1571 Because we only do this once, near process start-up, I'm prepared to
1572 let this slide for the time being, even though it rankles. */
1574 else if (ol
->type
& opt_rep_str
)
1576 uschar sep
= Ustrncmp(name
, "headers_add", 11)==0 ? '\n' : ':';
1579 /* Strip trailing whitespace and seperators */
1580 for (cp
= sptr
+ Ustrlen(sptr
) - 1;
1581 cp
>= sptr
&& (*cp
== '\n' || *cp
== '\t' || *cp
== ' ' || *cp
== sep
);
1585 *str_target
= string_copy_malloc(
1586 *str_target
? string_sprintf("%s%c%s", *str_target
, sep
, sptr
)
1597 if (data_block
== NULL
)
1598 *((uschar
**)(ol
->value
)) = sptr
;
1600 *((uschar
**)((uschar
*)data_block
+ (long int)(ol
->value
))) = sptr
;
1602 if (type
== opt_rewrite
)
1607 rewrite_rule
**chain
;
1610 sprintf(CS name2
, "*%.50s_rules", name
);
1611 ol2
= find_option(name2
, oltop
, last
);
1612 sprintf(CS name2
, "*%.50s_flags", name
);
1613 ol3
= find_option(name2
, oltop
, last
);
1615 if (ol2
== NULL
|| ol3
== NULL
)
1616 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1617 "rewrite rules not available for driver");
1619 if (data_block
== NULL
)
1621 chain
= (rewrite_rule
**)(ol2
->value
);
1622 flagptr
= (int *)(ol3
->value
);
1626 chain
= (rewrite_rule
**)((uschar
*)data_block
+ (long int)(ol2
->value
));
1627 flagptr
= (int *)((uschar
*)data_block
+ (long int)(ol3
->value
));
1630 while ((p
= string_nextinlist(&sptr
, &sep
, big_buffer
, BIG_BUFFER_SIZE
))
1633 rewrite_rule
*next
= readconf_one_rewrite(p
, flagptr
, FALSE
);
1635 chain
= &(next
->next
);
1638 if ((*flagptr
& (rewrite_all_envelope
| rewrite_smtp
)) != 0)
1639 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "rewrite rule specifies a "
1640 "non-header rewrite - not allowed at transport time -");
1644 /* If it was an expanded uid, see if there is any expansion to be
1645 done by checking for the presence of a $ character. If there is, save it
1646 in the corresponding *expand_user option field. Otherwise, fall through
1647 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1650 case opt_expand_uid
:
1651 sprintf(CS name2
, "*expand_%.50s", name
);
1652 ol2
= find_option(name2
, oltop
, last
);
1655 uschar
*ss
= (Ustrchr(sptr
, '$') != NULL
)? sptr
: NULL
;
1657 if (data_block
== NULL
)
1658 *((uschar
**)(ol2
->value
)) = ss
;
1660 *((uschar
**)((uschar
*)data_block
+ (long int)(ol2
->value
))) = ss
;
1664 *(get_set_flag(name
, oltop
, last
, data_block
)) = FALSE
;
1670 /* Look up a fixed uid, and also make use of the corresponding gid
1671 if a passwd entry is returned and the gid has not been set. */
1674 if (!route_finduser(sptr
, &pw
, &uid
))
1675 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "user %s was not found", sptr
);
1676 if (data_block
== NULL
)
1677 *((uid_t
*)(ol
->value
)) = uid
;
1679 *((uid_t
*)((uschar
*)data_block
+ (long int)(ol
->value
))) = uid
;
1681 /* Set the flag indicating a fixed value is set */
1683 *(get_set_flag(name
, oltop
, last
, data_block
)) = TRUE
;
1685 /* Handle matching gid if we have a passwd entry: done by finding the
1686 same name with terminating "user" changed to "group"; if not found,
1687 ignore. Also ignore if the value is already set. */
1689 if (pw
== NULL
) break;
1690 Ustrcpy(name
+Ustrlen(name
)-4, "group");
1691 ol2
= find_option(name
, oltop
, last
);
1692 if (ol2
!= NULL
&& ((ol2
->type
& opt_mask
) == opt_gid
||
1693 (ol2
->type
& opt_mask
) == opt_expand_gid
))
1695 BOOL
*set_flag
= get_set_flag(name
, oltop
, last
, data_block
);
1698 if (data_block
== NULL
)
1699 *((gid_t
*)(ol2
->value
)) = pw
->pw_gid
;
1701 *((gid_t
*)((uschar
*)data_block
+ (long int)(ol2
->value
))) = pw
->pw_gid
;
1707 /* If it was an expanded gid, see if there is any expansion to be
1708 done by checking for the presence of a $ character. If there is, save it
1709 in the corresponding *expand_user option field. Otherwise, fall through
1710 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1713 case opt_expand_gid
:
1714 sprintf(CS name2
, "*expand_%.50s", name
);
1715 ol2
= find_option(name2
, oltop
, last
);
1718 uschar
*ss
= (Ustrchr(sptr
, '$') != NULL
)? sptr
: NULL
;
1720 if (data_block
== NULL
)
1721 *((uschar
**)(ol2
->value
)) = ss
;
1723 *((uschar
**)((uschar
*)data_block
+ (long int)(ol2
->value
))) = ss
;
1727 *(get_set_flag(name
, oltop
, last
, data_block
)) = FALSE
;
1733 /* Handle freestanding gid */
1736 if (!route_findgroup(sptr
, &gid
))
1737 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "group %s was not found", sptr
);
1738 if (data_block
== NULL
)
1739 *((gid_t
*)(ol
->value
)) = gid
;
1741 *((gid_t
*)((uschar
*)data_block
+ (long int)(ol
->value
))) = gid
;
1742 *(get_set_flag(name
, oltop
, last
, data_block
)) = TRUE
;
1745 /* If it was a uid list, look up each individual entry, and build
1746 a vector of uids, with a count in the first element. Put the vector
1747 in malloc store so we can free the string. (We are reading into
1748 permanent store already.) */
1756 uschar
*op
= expand_string (sptr
);
1759 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "failed to expand %s: %s",
1760 name
, expand_string_message
);
1763 if (*p
!= 0) count
++;
1764 while (*p
!= 0) if (*p
++ == ':' && *p
!= 0) count
++;
1765 list
= store_malloc(count
*sizeof(uid_t
));
1766 list
[ptr
++] = (uid_t
)(count
- 1);
1768 if (data_block
== NULL
)
1769 *((uid_t
**)(ol
->value
)) = list
;
1771 *((uid_t
**)((uschar
*)data_block
+ (long int)(ol
->value
))) = list
;
1777 (void)string_nextinlist(&p
, &sep
, big_buffer
, BIG_BUFFER_SIZE
);
1778 if (!route_finduser(big_buffer
, NULL
, &uid
))
1779 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "user %s was not found",
1786 /* If it was a gid list, look up each individual entry, and build
1787 a vector of gids, with a count in the first element. Put the vector
1788 in malloc store so we can free the string. (We are reading into permanent
1797 uschar
*op
= expand_string (sptr
);
1800 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "failed to expand %s: %s",
1801 name
, expand_string_message
);
1804 if (*p
!= 0) count
++;
1805 while (*p
!= 0) if (*p
++ == ':' && *p
!= 0) count
++;
1806 list
= store_malloc(count
*sizeof(gid_t
));
1807 list
[ptr
++] = (gid_t
)(count
- 1);
1809 if (data_block
== NULL
)
1810 *((gid_t
**)(ol
->value
)) = list
;
1812 *((gid_t
**)((uschar
*)data_block
+ (long int)(ol
->value
))) = list
;
1818 (void)string_nextinlist(&p
, &sep
, big_buffer
, BIG_BUFFER_SIZE
);
1819 if (!route_findgroup(big_buffer
, &gid
))
1820 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "group %s was not found",
1828 /* Release store if the value of the string doesn't need to be kept. */
1830 if (freesptr
) store_reset(reset_point
);
1833 /* Expanded boolean: if no characters follow, or if there are no dollar
1834 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1835 save the string for later expansion in the alternate place. */
1837 case opt_expand_bool
:
1838 if (*s
!= 0 && Ustrchr(s
, '$') != 0)
1840 sprintf(CS name2
, "*expand_%.50s", name
);
1841 ol2
= find_option(name2
, oltop
, last
);
1844 reset_point
= sptr
= read_string(s
, name
);
1845 if (data_block
== NULL
)
1846 *((uschar
**)(ol2
->value
)) = sptr
;
1848 *((uschar
**)((uschar
*)data_block
+ (long int)(ol2
->value
))) = sptr
;
1855 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1856 look for yes/not/true/false. Some booleans are stored in a single bit in
1857 a single int. There's a special fudge for verify settings; without a suffix
1858 they set both xx_sender and xx_recipient. The table points to the sender
1859 value; search subsequently for the recipient. There's another special case:
1860 opt_bool_set also notes when a boolean has been set. */
1864 case opt_bool_verify
:
1868 s
= readconf_readname(name2
, 64, s
);
1869 if (strcmpic(name2
, US
"true") == 0 || strcmpic(name2
, US
"yes") == 0)
1871 else if (strcmpic(name2
, US
"false") == 0 || strcmpic(name2
, US
"no") == 0)
1873 else log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1874 "\"%s\" is not a valid value for the \"%s\" option", name2
, name
);
1875 if (*s
!= 0) extra_chars_error(s
, string_sprintf("\"%s\" ", name2
),
1876 US
"for boolean option ", name
);
1879 /* Handle single-bit type. */
1881 if (type
== opt_bit
)
1883 int bit
= 1 << ((ol
->type
>> 16) & 31);
1884 int *ptr
= (data_block
== NULL
)?
1885 (int *)(ol
->value
) :
1886 (int *)((uschar
*)data_block
+ (long int)ol
->value
);
1887 if (boolvalue
) *ptr
|= bit
; else *ptr
&= ~bit
;
1891 /* Handle full BOOL types */
1893 if (data_block
== NULL
)
1894 *((BOOL
*)(ol
->value
)) = boolvalue
;
1896 *((BOOL
*)((uschar
*)data_block
+ (long int)(ol
->value
))) = boolvalue
;
1900 if (type
== opt_bool_verify
)
1902 sprintf(CS name2
, "%.50s_recipient", name
+ offset
);
1903 ol2
= find_option(name2
, oltop
, last
);
1906 if (data_block
== NULL
)
1907 *((BOOL
*)(ol2
->value
)) = boolvalue
;
1909 *((BOOL
*)((uschar
*)data_block
+ (long int)(ol2
->value
))) = boolvalue
;
1913 /* Note that opt_bool_set type is set, if there is somewhere to do so */
1915 else if (type
== opt_bool_set
)
1917 sprintf(CS name2
, "*set_%.50s", name
+ offset
);
1918 ol2
= find_option(name2
, oltop
, last
);
1921 if (data_block
== NULL
)
1922 *((BOOL
*)(ol2
->value
)) = TRUE
;
1924 *((BOOL
*)((uschar
*)data_block
+ (long int)(ol2
->value
))) = TRUE
;
1933 inttype
= US
"octal ";
1935 /* Integer: a simple(ish) case; allow octal and hex formats, and
1936 suffixes K and M. The different types affect output, not input. */
1945 lvalue
= strtol(CS s
, CSS
&endptr
, intbase
);
1948 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "%sinteger expected for %s",
1951 if (errno
!= ERANGE
)
1953 if (tolower(*endptr
) == 'k')
1955 if (lvalue
> INT_MAX
/1024 || lvalue
< INT_MIN
/1024) errno
= ERANGE
;
1956 else lvalue
*= 1024;
1959 else if (tolower(*endptr
) == 'm')
1961 if (lvalue
> INT_MAX
/(1024*1024) || lvalue
< INT_MIN
/(1024*1024))
1963 else lvalue
*= 1024*1024;
1968 if (errno
== ERANGE
|| lvalue
> INT_MAX
|| lvalue
< INT_MIN
)
1969 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
1970 "absolute value of integer \"%s\" is too large (overflow)", s
);
1972 while (isspace(*endptr
)) endptr
++;
1974 extra_chars_error(endptr
, inttype
, US
"integer value for ", name
);
1976 value
= (int)lvalue
;
1979 if (data_block
== NULL
)
1980 *((int *)(ol
->value
)) = value
;
1982 *((int *)((uschar
*)data_block
+ (long int)(ol
->value
))) = value
;
1985 /* Integer held in K: again, allow octal and hex formats, and suffixes K and
1992 value
= strtol(CS s
, CSS
&endptr
, intbase
);
1995 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "%sinteger expected for %s",
1998 if (errno
!= ERANGE
)
2000 if (tolower(*endptr
) == 'm')
2002 if (value
> INT_MAX
/1024 || value
< INT_MIN
/1024) errno
= ERANGE
;
2006 else if (tolower(*endptr
) == 'k')
2012 value
= (value
+ 512)/1024;
2016 if (errno
== ERANGE
) log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2017 "absolute value of integer \"%s\" is too large (overflow)", s
);
2019 while (isspace(*endptr
)) endptr
++;
2021 extra_chars_error(endptr
, inttype
, US
"integer value for ", name
);
2024 if (data_block
== NULL
)
2025 *((int *)(ol
->value
)) = value
;
2027 *((int *)((uschar
*)data_block
+ (long int)(ol
->value
))) = value
;
2030 /* Fixed-point number: held to 3 decimal places. */
2033 if (sscanf(CS s
, "%d%n", &value
, &count
) != 1)
2034 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2035 "fixed-point number expected for %s", name
);
2037 if (value
< 0) log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2038 "integer \"%s\" is too large (overflow)", s
);
2042 if (value
< 0) log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2043 "integer \"%s\" is too large (overflow)", s
);
2045 if (s
[count
] == '.')
2048 while (isdigit(s
[++count
]))
2050 value
+= (s
[count
] - '0') * d
;
2055 while (isspace(s
[count
])) count
++;
2058 extra_chars_error(s
+count
, US
"fixed-point value for ", name
, US
"");
2060 if (data_block
== NULL
)
2061 *((int *)(ol
->value
)) = value
;
2063 *((int *)((uschar
*)data_block
+ (long int)(ol
->value
))) = value
;
2066 /* There's a special routine to read time values. */
2069 value
= readconf_readtime(s
, 0, FALSE
);
2071 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "invalid time value for %s",
2073 if (data_block
== NULL
)
2074 *((int *)(ol
->value
)) = value
;
2076 *((int *)((uschar
*)data_block
+ (long int)(ol
->value
))) = value
;
2079 /* A time list is a list of colon-separated times, with the first
2080 element holding the size of the list and the second the number of
2086 int *list
= (data_block
== NULL
)?
2087 (int *)(ol
->value
) :
2088 (int *)((uschar
*)data_block
+ (long int)(ol
->value
));
2090 if (*s
!= 0) for (count
= 1; count
<= list
[0] - 2; count
++)
2093 uschar
*snext
= Ustrchr(s
, ':');
2097 while (ss
> s
&& isspace(ss
[-1])) ss
--;
2100 value
= readconf_readtime(s
, terminator
, FALSE
);
2102 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "invalid time value for %s",
2104 if (count
> 1 && value
<= list
[count
])
2105 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2106 "time value out of order for %s", name
);
2107 list
[count
+1] = value
;
2108 if (snext
== NULL
) break;
2110 while (isspace(*s
)) s
++;
2113 if (count
> list
[0] - 2)
2114 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "too many time values for %s",
2116 if (count
> 0 && list
[2] == 0) count
= 0;
2128 /*************************************************
2129 * Print a time value *
2130 *************************************************/
2133 Argument: a time value in seconds
2134 Returns: pointer to a fixed buffer containing the time as a string,
2135 in readconf_readtime() format
2139 readconf_printtime(int t
)
2142 uschar
*p
= time_buffer
;
2159 if (w
> 0) { sprintf(CS p
, "%dw", w
); while (*p
) p
++; }
2160 if (d
> 0) { sprintf(CS p
, "%dd", d
); while (*p
) p
++; }
2161 if (h
> 0) { sprintf(CS p
, "%dh", h
); while (*p
) p
++; }
2162 if (m
> 0) { sprintf(CS p
, "%dm", m
); while (*p
) p
++; }
2163 if (s
> 0 || p
== time_buffer
) sprintf(CS p
, "%ds", s
);
2170 /*************************************************
2171 * Print an individual option value *
2172 *************************************************/
2174 /* This is used by the -bP option, so prints to the standard output.
2175 The entire options list is passed in as an argument, because some options come
2176 in pairs - typically uid/gid settings, which can either be explicit numerical
2177 values, or strings to be expanded later. If the numerical value is unset,
2178 search for "*expand_<name>" to see if there is a string equivalent.
2181 ol option entry, or NULL for an unknown option
2183 options_block NULL for main configuration options; otherwise points to
2184 a driver block; if the option doesn't have opt_public
2185 set, then options_block->options_block is where the item
2187 oltop points to the option list in which ol exists
2188 last one more than the offset of the last entry in optop
2189 no_labels do not show "foo = " at the start.
2195 print_ol(optionlist
*ol
, uschar
*name
, void *options_block
,
2196 optionlist
*oltop
, int last
, BOOL no_labels
)
2209 printf("%s is not a known option\n", name
);
2213 /* Non-admin callers cannot see options that have been flagged secure by the
2216 if (!admin_user
&& (ol
->type
& opt_secure
) != 0)
2218 const char * const hidden
= "<value not displayable>";
2220 printf("%s\n", hidden
);
2222 printf("%s = %s\n", name
, hidden
);
2226 /* Else show the value of the option */
2229 if (options_block
!= NULL
)
2231 if ((ol
->type
& opt_public
) == 0)
2232 options_block
= (void *)(((driver_instance
*)options_block
)->options_block
);
2233 value
= (void *)((uschar
*)options_block
+ (long int)value
);
2236 switch(ol
->type
& opt_mask
)
2239 case opt_rewrite
: /* Show the text value */
2240 s
= *((uschar
**)value
);
2241 if (!no_labels
) printf("%s = ", name
);
2242 printf("%s\n", (s
== NULL
)? US
"" : string_printing2(s
, FALSE
));
2246 if (!no_labels
) printf("%s = ", name
);
2247 printf("%d\n", *((int *)value
));
2252 int x
= *((int *)value
);
2253 if (x
!= 0 && (x
& 1023) == 0)
2257 if ((x
& 1023) == 0)
2262 if (!no_labels
) printf("%s = ", name
);
2263 printf("%d%c\n", x
, c
);
2267 if (!no_labels
) printf("%s = ", name
);
2275 int x
= *((int *)value
);
2276 if (!no_labels
) printf("%s = ", name
);
2277 if (x
== 0) printf("0\n");
2278 else if ((x
& 1023) == 0) printf("%dM\n", x
>> 10);
2279 else printf("%dK\n", x
);
2284 if (!no_labels
) printf("%s = ", name
);
2285 printf("%#o\n", *((int *)value
));
2288 /* Can be negative only when "unset", in which case integer */
2292 int x
= *((int *)value
);
2295 if (x
< 0) printf("%s =\n", name
); else
2297 if (!no_labels
) printf("%s = ", name
);
2298 printf("%d.", x
/1000);
2311 /* If the numerical value is unset, try for the string value */
2313 case opt_expand_uid
:
2314 if (! *get_set_flag(name
, oltop
, last
, options_block
))
2316 sprintf(CS name2
, "*expand_%.50s", name
);
2317 ol2
= find_option(name2
, oltop
, last
);
2320 void *value2
= ol2
->value
;
2321 if (options_block
!= NULL
)
2322 value2
= (void *)((uschar
*)options_block
+ (long int)value2
);
2323 s
= *((uschar
**)value2
);
2324 if (!no_labels
) printf("%s = ", name
);
2325 printf("%s\n", (s
== NULL
)? US
"" : string_printing(s
));
2330 /* Else fall through */
2333 if (!no_labels
) printf("%s = ", name
);
2334 if (! *get_set_flag(name
, oltop
, last
, options_block
))
2338 pw
= getpwuid(*((uid_t
*)value
));
2340 printf("%ld\n", (long int)(*((uid_t
*)value
)));
2341 else printf("%s\n", pw
->pw_name
);
2345 /* If the numerical value is unset, try for the string value */
2347 case opt_expand_gid
:
2348 if (! *get_set_flag(name
, oltop
, last
, options_block
))
2350 sprintf(CS name2
, "*expand_%.50s", name
);
2351 ol2
= find_option(name2
, oltop
, last
);
2352 if (ol2
!= NULL
&& (ol2
->type
& opt_mask
) == opt_stringptr
)
2354 void *value2
= ol2
->value
;
2355 if (options_block
!= NULL
)
2356 value2
= (void *)((uschar
*)options_block
+ (long int)value2
);
2357 s
= *((uschar
**)value2
);
2358 if (!no_labels
) printf("%s = ", name
);
2359 printf("%s\n", (s
== NULL
)? US
"" : string_printing(s
));
2364 /* Else fall through */
2367 if (!no_labels
) printf("%s = ", name
);
2368 if (! *get_set_flag(name
, oltop
, last
, options_block
))
2372 gr
= getgrgid(*((int *)value
));
2374 printf("%ld\n", (long int)(*((int *)value
)));
2375 else printf("%s\n", gr
->gr_name
);
2380 uidlist
= *((uid_t
**)value
);
2381 if (!no_labels
) printf("%s =", name
);
2382 if (uidlist
!= NULL
)
2386 if (no_labels
) sep
= '\0';
2387 for (i
= 1; i
<= (int)(uidlist
[0]); i
++)
2389 uschar
*name
= NULL
;
2390 pw
= getpwuid(uidlist
[i
]);
2391 if (pw
!= NULL
) name
= US pw
->pw_name
;
2392 if (sep
!= '\0') printf("%c", sep
);
2393 if (name
!= NULL
) printf("%s", name
);
2394 else printf("%ld", (long int)(uidlist
[i
]));
2402 gidlist
= *((gid_t
**)value
);
2403 if (!no_labels
) printf("%s =", name
);
2404 if (gidlist
!= NULL
)
2408 if (no_labels
) sep
= '\0';
2409 for (i
= 1; i
<= (int)(gidlist
[0]); i
++)
2411 uschar
*name
= NULL
;
2412 gr
= getgrgid(gidlist
[i
]);
2413 if (gr
!= NULL
) name
= US gr
->gr_name
;
2414 if (sep
!= '\0') printf("%c", sep
);
2415 if (name
!= NULL
) printf("%s", name
);
2416 else printf("%ld", (long int)(gidlist
[i
]));
2424 if (!no_labels
) printf("%s = ", name
);
2425 printf("%s\n", readconf_printtime(*((int *)value
)));
2431 int *list
= (int *)value
;
2432 if (!no_labels
) printf("%s = ", name
);
2433 for (i
= 0; i
< list
[1]; i
++)
2434 printf("%s%s", (i
== 0)? "" : ":", readconf_printtime(list
[i
+2]));
2440 printf("%s%s\n", ((*((int *)value
)) & (1 << ((ol
->type
>> 16) & 31)))?
2444 case opt_expand_bool
:
2445 sprintf(CS name2
, "*expand_%.50s", name
);
2446 ol2
= find_option(name2
, oltop
, last
);
2447 if (ol2
!= NULL
&& ol2
->value
!= NULL
)
2449 void *value2
= ol2
->value
;
2450 if (options_block
!= NULL
)
2451 value2
= (void *)((uschar
*)options_block
+ (long int)value2
);
2452 s
= *((uschar
**)value2
);
2455 if (!no_labels
) printf("%s = ", name
);
2456 printf("%s\n", string_printing(s
));
2459 /* s == NULL => string not set; fall through */
2465 case opt_bool_verify
:
2467 printf("%s%s\n", (*((BOOL
*)value
))? "" : "no_", name
);
2474 /*************************************************
2475 * Print value from main configuration *
2476 *************************************************/
2478 /* This function, called as a result of encountering the -bP option,
2479 causes the value of any main configuration variable to be output if the
2480 second argument is NULL. There are some special values:
2482 all print all main configuration options
2483 configure_file print the name of the configuration file
2484 routers print the routers' configurations
2485 transports print the transports' configuration
2486 authenticators print the authenticators' configuration
2487 macros print the macros' configuration
2488 router_list print a list of router names
2489 transport_list print a list of transport names
2490 authenticator_list print a list of authentication mechanism names
2491 macro_list print a list of macro names
2492 +name print a named list item
2493 local_scan print the local_scan options
2494 environment print the used execution environment
2496 If the second argument is not NULL, it must be one of "router", "transport",
2497 "authenticator" or "macro" in which case the first argument identifies the
2498 driver whose options are to be printed.
2501 name option name if type == NULL; else driver name
2502 type NULL or driver type name, as described above
2503 no_labels avoid the "foo = " at the start of an item
2509 readconf_print(uschar
*name
, uschar
*type
, BOOL no_labels
)
2511 BOOL names_only
= FALSE
;
2513 optionlist
*ol2
= NULL
;
2514 driver_instance
*d
= NULL
;
2525 static uschar
*types
[] = { US
"address", US
"domain", US
"host",
2527 static tree_node
**anchors
[] = { &addresslist_anchor
, &domainlist_anchor
,
2528 &hostlist_anchor
, &localpartlist_anchor
};
2530 for (i
= 0; i
< 4; i
++)
2532 t
= tree_search(*(anchors
[i
]), name
+1);
2537 printf("%s\n", ((namedlist_block
*)(t
->data
.ptr
))->string
);
2539 printf("%slist %s = %s\n", types
[i
], name
+1,
2540 ((namedlist_block
*)(t
->data
.ptr
))->string
);
2545 printf("no address, domain, host, or local part list called \"%s\" "
2546 "exists\n", name
+1);
2551 if (Ustrcmp(name
, "configure_file") == 0)
2553 printf("%s\n", CS config_main_filename
);
2557 if (Ustrcmp(name
, "all") == 0)
2559 for (ol
= optionlist_config
;
2560 ol
< optionlist_config
+ optionlist_config_size
; ol
++)
2562 if ((ol
->type
& opt_hidden
) == 0)
2563 print_ol(ol
, US ol
->name
, NULL
,
2564 optionlist_config
, optionlist_config_size
,
2570 if (Ustrcmp(name
, "local_scan") == 0)
2572 #ifndef LOCAL_SCAN_HAS_OPTIONS
2573 printf("local_scan() options are not supported\n");
2575 for (ol
= local_scan_options
;
2576 ol
< local_scan_options
+ local_scan_options_count
; ol
++)
2578 print_ol(ol
, US ol
->name
, NULL
, local_scan_options
,
2579 local_scan_options_count
, no_labels
);
2585 if (Ustrcmp(name
, "routers") == 0)
2590 else if (Ustrcmp(name
, "transports") == 0)
2592 type
= US
"transport";
2596 else if (Ustrcmp(name
, "authenticators") == 0)
2598 type
= US
"authenticator";
2602 else if (Ustrcmp(name
, "macros") == 0)
2608 else if (Ustrcmp(name
, "router_list") == 0)
2615 else if (Ustrcmp(name
, "transport_list") == 0)
2617 type
= US
"transport";
2622 else if (Ustrcmp(name
, "authenticator_list") == 0)
2624 type
= US
"authenticator";
2629 else if (Ustrcmp(name
, "macro_list") == 0)
2636 else if (Ustrcmp(name
, "environment") == 0)
2642 for (p
= USS environ
; *p
; p
++) ;
2643 n
= p
- USS environ
;
2644 qsort(environ
, p
- USS environ
, sizeof(*p
), string_compare_by_pointer
);
2646 for (p
= USS environ
; *p
; p
++)
2648 if (no_labels
) *(Ustrchr(*p
, '=')) = '\0';
2657 print_ol(find_option(name
, optionlist_config
, optionlist_config_size
),
2658 name
, NULL
, optionlist_config
, optionlist_config_size
, no_labels
);
2663 /* Handle the options for a router or transport. Skip options that are flagged
2664 as hidden. Some of these are options with names starting with '*', used for
2665 internal alternative representations of other options (which the printing
2666 function will sort out). Others are synonyms kept for backward compatibility.
2669 if (Ustrcmp(type
, "router") == 0)
2671 d
= (driver_instance
*)routers
;
2672 ol2
= optionlist_routers
;
2673 size
= optionlist_routers_size
;
2675 else if (Ustrcmp(type
, "transport") == 0)
2677 d
= (driver_instance
*)transports
;
2678 ol2
= optionlist_transports
;
2679 size
= optionlist_transports_size
;
2681 else if (Ustrcmp(type
, "authenticator") == 0)
2683 d
= (driver_instance
*)auths
;
2684 ol2
= optionlist_auths
;
2685 size
= optionlist_auths_size
;
2688 else if (Ustrcmp(type
, "macro") == 0)
2690 /* People store passwords in macros and they were previously not available
2691 for printing. So we have an admin_users restriction. */
2694 fprintf(stderr
, "exim: permission denied\n");
2697 for (m
= macros
; m
!= NULL
; m
= m
->next
)
2699 if (name
== NULL
|| Ustrcmp(name
, m
->name
) == 0)
2702 printf("%s\n", CS m
->name
);
2704 printf("%s=%s\n", CS m
->name
, CS m
->replacement
);
2710 printf("%s %s not found\n", type
, name
);
2716 for (; d
!= NULL
; d
= d
->next
) printf("%s\n", CS d
->name
);
2720 /* Either search for a given driver, or print all of them */
2722 for (; d
!= NULL
; d
= d
->next
)
2725 printf("\n%s %s:\n", d
->name
, type
);
2726 else if (Ustrcmp(d
->name
, name
) != 0) continue;
2728 for (ol
= ol2
; ol
< ol2
+ size
; ol
++)
2730 if ((ol
->type
& opt_hidden
) == 0)
2731 print_ol(ol
, US ol
->name
, d
, ol2
, size
, no_labels
);
2734 for (ol
= d
->info
->options
;
2735 ol
< d
->info
->options
+ *(d
->info
->options_count
); ol
++)
2737 if ((ol
->type
& opt_hidden
) == 0)
2738 print_ol(ol
, US ol
->name
, d
, d
->info
->options
, *(d
->info
->options_count
), no_labels
);
2740 if (name
!= NULL
) return;
2742 if (name
!= NULL
) printf("%s %s not found\n", type
, name
);
2747 /*************************************************
2748 * Read a named list item *
2749 *************************************************/
2751 /* This function reads a name and a list (i.e. string). The name is used to
2752 save the list in a tree, sorted by its name. Each entry also has a number,
2753 which can be used for caching tests, but if the string contains any expansion
2754 items other than $key, the number is set negative to inhibit caching. This
2755 mechanism is used for domain, host, and address lists that are referenced by
2759 anchorp points to the tree anchor
2760 numberp points to the current number for this tree
2761 max the maximum number permitted
2762 s the text of the option line, starting immediately after the name
2764 tname the name of the list type, for messages
2770 read_named_list(tree_node
**anchorp
, int *numberp
, int max
, uschar
*s
,
2773 BOOL forcecache
= FALSE
;
2776 namedlist_block
*nb
= store_get(sizeof(namedlist_block
));
2778 if (Ustrncmp(s
, "_cache", 6) == 0)
2785 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "unrecognized configuration line");
2787 if (*numberp
>= max
)
2788 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "too many named %ss (max is %d)\n",
2791 while (isspace(*s
)) s
++;
2793 while (isalnum(*s
) || *s
== '_') s
++;
2794 t
= store_get(sizeof(tree_node
) + s
-ss
);
2795 Ustrncpy(t
->name
, ss
, s
-ss
);
2797 while (isspace(*s
)) s
++;
2799 if (!tree_insertnode(anchorp
, t
))
2800 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2801 "duplicate name \"%s\" for a named %s", t
->name
, tname
);
2804 nb
->number
= *numberp
;
2807 if (*s
++ != '=') log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
2808 "missing '=' after \"%s\"", t
->name
);
2809 while (isspace(*s
)) s
++;
2810 nb
->string
= read_string(s
, t
->name
);
2811 nb
->cache_data
= NULL
;
2813 /* Check the string for any expansions; if any are found, mark this list
2814 uncacheable unless the user has explicited forced caching. */
2816 if (!forcecache
&& Ustrchr(nb
->string
, '$') != NULL
) nb
->number
= -1;
2822 /*************************************************
2823 * Unpick data for a rate limit *
2824 *************************************************/
2826 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2830 s string, in the form t,b,f,l
2831 where t is the threshold (integer)
2832 b is the initial delay (time)
2833 f is the multiplicative factor (fixed point)
2834 k is the maximum time (time)
2835 threshold where to store threshold
2836 base where to store base in milliseconds
2837 factor where to store factor in milliseconds
2838 limit where to store limit
2840 Returns: nothing (panics on error)
2844 unpick_ratelimit(uschar
*s
, int *threshold
, int *base
, double *factor
,
2847 uschar bstring
[16], lstring
[16];
2849 if (sscanf(CS s
, "%d, %15[0123456789smhdw.], %lf, %15s", threshold
, bstring
,
2850 factor
, lstring
) == 4)
2852 *base
= readconf_readtime(bstring
, 0, TRUE
);
2853 *limit
= readconf_readtime(lstring
, 0, TRUE
);
2854 if (*base
>= 0 && *limit
>= 0) return;
2856 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "malformed ratelimit data: %s", s
);
2862 /*************************************************
2863 * Drop privs for checking TLS config *
2864 *************************************************/
2866 /* We want to validate TLS options during readconf, but do not want to be
2867 root when we call into the TLS library, in case of library linkage errors
2868 which cause segfaults; before this check, those were always done as the Exim
2869 runtime user and it makes sense to continue with that.
2871 Assumes: tls_require_ciphers has been set, if it will be
2872 exim_user has been set, if it will be
2873 exim_group has been set, if it will be
2875 Returns: bool for "okay"; false will cause caller to immediately exit.
2880 tls_dropprivs_validate_require_cipher(void)
2882 const uschar
*errmsg
;
2885 void (*oldsignal
)(int);
2887 oldsignal
= signal(SIGCHLD
, SIG_DFL
);
2890 if ((pid
= fork()) < 0)
2891 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "fork failed for TLS check");
2895 /* in some modes, will have dropped privilege already */
2897 exim_setugid(exim_uid
, exim_gid
, FALSE
,
2898 US
"calling tls_validate_require_cipher");
2900 errmsg
= tls_validate_require_cipher();
2903 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
2904 "tls_require_ciphers invalid: %s", errmsg
);
2911 rc
= waitpid(pid
, &status
, 0);
2912 } while (rc
< 0 && errno
== EINTR
);
2915 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
2918 signal(SIGCHLD
, oldsignal
);
2922 #endif /* SUPPORT_TLS */
2927 /*************************************************
2928 * Read main configuration options *
2929 *************************************************/
2931 /* This function is the first to be called for configuration reading. It
2932 opens the configuration file and reads general configuration settings until
2933 it reaches the end of the configuration section. The file is then left open so
2934 that the remaining configuration data can subsequently be read if needed for
2937 The configuration file must be owned either by root or exim, and be writeable
2938 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
2939 in the config file, so the test is done on the compiled in values. A slight
2940 anomaly, to be carefully documented.
2942 The name of the configuration file is taken from a list that is included in the
2943 binary of Exim. It can be altered from the command line, but if that is done,
2944 root privilege is immediately withdrawn unless the caller is root or exim.
2945 The first file on the list that exists is used.
2947 For use on multiple systems that share file systems, first look for a
2948 configuration file whose name has the current node name on the end. If that is
2949 not found, try the generic name. For really contorted configurations, that run
2950 multiple Exims with different uid settings, first try adding the effective uid
2951 before the node name. These complications are going to waste resources on most
2952 systems. Therefore they are available only when requested by compile-time
2959 struct stat statbuf
;
2960 uschar
*s
, *filename
;
2961 uschar
*list
= config_main_filelist
;
2963 /* Loop through the possible file names */
2965 while((filename
= string_nextinlist(&list
, &sep
, big_buffer
, big_buffer_size
))
2969 /* To avoid confusion: Exim changes to / at the very beginning and
2970 * and to $spool_directory later. */
2971 if (filename
[0] != '/')
2973 fprintf(stderr
, "-C %s: only absolute names are allowed\n", filename
);
2977 /* Cut out all the fancy processing unless specifically wanted */
2979 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
2980 uschar
*suffix
= filename
+ Ustrlen(filename
);
2982 /* Try for the node-specific file if a node name exists */
2984 #ifdef CONFIGURE_FILE_USE_NODE
2986 if (uname(&uts
) >= 0)
2988 #ifdef CONFIGURE_FILE_USE_EUID
2989 sprintf(CS suffix
, ".%ld.%.256s", (long int)original_euid
, uts
.nodename
);
2990 config_file
= Ufopen(filename
, "rb");
2991 if (config_file
== NULL
)
2992 #endif /* CONFIGURE_FILE_USE_EUID */
2994 sprintf(CS suffix
, ".%.256s", uts
.nodename
);
2995 config_file
= Ufopen(filename
, "rb");
2998 #endif /* CONFIGURE_FILE_USE_NODE */
3000 /* Otherwise, try the generic name, possibly with the euid added */
3002 #ifdef CONFIGURE_FILE_USE_EUID
3003 if (config_file
== NULL
)
3005 sprintf(CS suffix
, ".%ld", (long int)original_euid
);
3006 config_file
= Ufopen(filename
, "rb");
3008 #endif /* CONFIGURE_FILE_USE_EUID */
3010 /* Finally, try the unadorned name */
3012 if (config_file
== NULL
)
3015 config_file
= Ufopen(filename
, "rb");
3017 #else /* if neither defined */
3019 /* This is the common case when the fancy processing is not included. */
3021 config_file
= Ufopen(filename
, "rb");
3024 /* If the file does not exist, continue to try any others. For any other
3025 error, break out (and die). */
3027 if (config_file
!= NULL
|| errno
!= ENOENT
) break;
3030 /* On success, save the name for verification; config_filename is used when
3031 logging configuration errors (it changes for .included files) whereas
3032 config_main_filename is the name shown by -bP. Failure to open a configuration
3033 file is a serious disaster. */
3035 if (config_file
!= NULL
)
3037 config_filename
= config_main_filename
= string_copy(filename
);
3041 if (filename
== NULL
)
3042 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "non-existent configuration file(s): "
3043 "%s", config_main_filelist
);
3045 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "%s", string_open_failed(errno
,
3046 "configuration file %s", filename
));
3049 /* Check the status of the file we have opened, if we have retained root
3050 privileges and the file isn't /dev/null (which *should* be 0666). */
3052 if (trusted_config
&& Ustrcmp(filename
, US
"/dev/null"))
3054 if (fstat(fileno(config_file
), &statbuf
) != 0)
3055 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to stat configuration file %s",
3058 if ((statbuf
.st_uid
!= root_uid
/* owner not root */
3059 #ifdef CONFIGURE_OWNER
3060 && statbuf
.st_uid
!= config_uid
/* owner not the special one */
3063 (statbuf
.st_gid
!= root_gid
/* group not root & */
3064 #ifdef CONFIGURE_GROUP
3065 && statbuf
.st_gid
!= config_gid
/* group not the special one */
3067 && (statbuf
.st_mode
& 020) != 0) || /* group writeable */
3069 ((statbuf
.st_mode
& 2) != 0)) /* world writeable */
3071 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "Exim configuration file %s has the "
3072 "wrong owner, group, or mode", big_buffer
);
3075 /* Process the main configuration settings. They all begin with a lower case
3076 letter. If we see something starting with an upper case letter, it is taken as
3077 a macro definition. */
3079 while ((s
= get_config_line()) != NULL
)
3081 if (isupper(s
[0])) read_macro_assignment(s
);
3083 else if (Ustrncmp(s
, "domainlist", 10) == 0)
3084 read_named_list(&domainlist_anchor
, &domainlist_count
,
3085 MAX_NAMED_LIST
, s
+10, US
"domain list");
3087 else if (Ustrncmp(s
, "hostlist", 8) == 0)
3088 read_named_list(&hostlist_anchor
, &hostlist_count
,
3089 MAX_NAMED_LIST
, s
+8, US
"host list");
3091 else if (Ustrncmp(s
, US
"addresslist", 11) == 0)
3092 read_named_list(&addresslist_anchor
, &addresslist_count
,
3093 MAX_NAMED_LIST
, s
+11, US
"address list");
3095 else if (Ustrncmp(s
, US
"localpartlist", 13) == 0)
3096 read_named_list(&localpartlist_anchor
, &localpartlist_count
,
3097 MAX_NAMED_LIST
, s
+13, US
"local part list");
3100 (void) readconf_handle_option(s
, optionlist_config
, optionlist_config_size
,
3101 NULL
, US
"main option \"%s\" unknown");
3105 /* If local_sender_retain is set, local_from_check must be unset. */
3107 if (local_sender_retain
&& local_from_check
)
3108 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "both local_from_check and "
3109 "local_sender_retain are set; this combination is not allowed");
3111 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3114 if (timezone_string
!= NULL
&& *timezone_string
== 0) timezone_string
= NULL
;
3116 /* The max retry interval must not be greater than 24 hours. */
3118 if (retry_interval_max
> 24*60*60) retry_interval_max
= 24*60*60;
3120 /* remote_max_parallel must be > 0 */
3122 if (remote_max_parallel
<= 0) remote_max_parallel
= 1;
3124 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3125 start of a new SMTP message. */
3127 freeze_tell_config
= freeze_tell
;
3129 /* The primary host name may be required for expansion of spool_directory
3130 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3131 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3132 canonize it. Some people like upper case letters in their host names, so we
3133 don't force the case. */
3135 if (primary_hostname
== NULL
)
3139 if (uname(&uts
) < 0)
3140 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "uname() failed to yield host name");
3141 hostname
= US uts
.nodename
;
3143 if (Ustrchr(hostname
, '.') == NULL
)
3146 struct hostent
*hostdata
;
3149 if (!disable_ipv6
&& (dns_ipv4_lookup
== NULL
||
3150 match_isinlist(hostname
, &dns_ipv4_lookup
, 0, NULL
, NULL
, MCL_DOMAIN
,
3160 #if HAVE_GETIPNODEBYNAME
3162 hostdata
= getipnodebyname(CS hostname
, af
, 0, &error_num
);
3164 hostdata
= gethostbyname2(CS hostname
, af
);
3167 hostdata
= gethostbyname(CS hostname
);
3170 if (hostdata
!= NULL
)
3172 hostname
= US hostdata
->h_name
;
3176 if (af
== AF_INET
) break;
3181 primary_hostname
= string_copy(hostname
);
3184 /* Set up default value for smtp_active_hostname */
3186 smtp_active_hostname
= primary_hostname
;
3188 /* If spool_directory wasn't set in the build-time configuration, it must have
3189 got set above. Of course, writing to the log may not work if log_file_path is
3190 not set, but it will at least get to syslog or somewhere, with any luck. */
3192 if (*spool_directory
== 0)
3193 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "spool_directory undefined: cannot "
3196 /* Expand the spool directory name; it may, for example, contain the primary
3197 host name. Same comment about failure. */
3199 s
= expand_string(spool_directory
);
3201 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to expand spool_directory "
3202 "\"%s\": %s", spool_directory
, expand_string_message
);
3203 spool_directory
= s
;
3205 /* Expand log_file_path, which must contain "%s" in any component that isn't
3206 the null string or "syslog". It is also allowed to contain one instance of %D
3207 or %M. However, it must NOT contain % followed by anything else. */
3209 if (*log_file_path
!= 0)
3212 int sep
= ':'; /* Fixed for log file path */
3213 s
= expand_string(log_file_path
);
3215 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to expand log_file_path "
3216 "\"%s\": %s", log_file_path
, expand_string_message
);
3219 while ((sss
= string_nextinlist(&ss
,&sep
,big_buffer
,big_buffer_size
)) != NULL
)
3222 if (sss
[0] == 0 || Ustrcmp(sss
, "syslog") == 0) continue;
3223 t
= Ustrstr(sss
, "%s");
3225 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "log_file_path \"%s\" does not "
3226 "contain \"%%s\"", sss
);
3228 t
= Ustrchr(sss
, '%');
3231 if ((t
[1] != 'D' && t
[1] != 'M') || Ustrchr(t
+2, '%') != NULL
)
3232 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "log_file_path \"%s\" contains "
3233 "unexpected \"%%\" character", s
);
3240 /* Interpret syslog_facility into an integer argument for 'ident' param to
3241 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3244 if (syslog_facility_str
!= NULL
)
3247 uschar
*s
= syslog_facility_str
;
3249 if ((Ustrlen(syslog_facility_str
) >= 4) &&
3250 (strncmpic(syslog_facility_str
, US
"log_", 4) == 0))
3253 for (i
= 0; i
< syslog_list_size
; i
++)
3255 if (strcmpic(s
, syslog_list
[i
].name
) == 0)
3257 syslog_facility
= syslog_list
[i
].value
;
3262 if (i
>= syslog_list_size
)
3264 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3265 "failed to interpret syslog_facility \"%s\"", syslog_facility_str
);
3269 /* Expand pid_file_path */
3271 if (*pid_file_path
!= 0)
3273 s
= expand_string(pid_file_path
);
3275 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to expand pid_file_path "
3276 "\"%s\": %s", pid_file_path
, expand_string_message
);
3280 /* Set default value of process_log_path */
3282 if (process_log_path
== NULL
|| *process_log_path
=='\0')
3283 process_log_path
= string_sprintf("%s/exim-process.info", spool_directory
);
3285 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3288 regex_From
= regex_must_compile(uucp_from_pattern
, FALSE
, TRUE
);
3290 /* Unpick the SMTP rate limiting options, if set */
3292 if (smtp_ratelimit_mail
!= NULL
)
3294 unpick_ratelimit(smtp_ratelimit_mail
, &smtp_rlm_threshold
,
3295 &smtp_rlm_base
, &smtp_rlm_factor
, &smtp_rlm_limit
);
3298 if (smtp_ratelimit_rcpt
!= NULL
)
3300 unpick_ratelimit(smtp_ratelimit_rcpt
, &smtp_rlr_threshold
,
3301 &smtp_rlr_base
, &smtp_rlr_factor
, &smtp_rlr_limit
);
3304 /* The qualify domains default to the primary host name */
3306 if (qualify_domain_sender
== NULL
)
3307 qualify_domain_sender
= primary_hostname
;
3308 if (qualify_domain_recipient
== NULL
)
3309 qualify_domain_recipient
= qualify_domain_sender
;
3311 /* Setting system_filter_user in the configuration sets the gid as well if a
3312 name is given, but a numerical value does not. */
3314 if (system_filter_uid_set
&& !system_filter_gid_set
)
3316 struct passwd
*pw
= getpwuid(system_filter_uid
);
3318 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "Failed to look up uid %ld",
3319 (long int)system_filter_uid
);
3320 system_filter_gid
= pw
->pw_gid
;
3321 system_filter_gid_set
= TRUE
;
3324 /* If the errors_reply_to field is set, check that it is syntactically valid
3325 and ensure it contains a domain. */
3327 if (errors_reply_to
!= NULL
)
3330 int start
, end
, domain
;
3331 uschar
*recipient
= parse_extract_address(errors_reply_to
, &errmess
,
3332 &start
, &end
, &domain
, FALSE
);
3334 if (recipient
== NULL
)
3335 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3336 "error in errors_reply_to (%s): %s", errors_reply_to
, errmess
);
3339 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3340 "errors_reply_to (%s) does not contain a domain", errors_reply_to
);
3343 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3344 smtp_accept_max must also be set. */
3346 if (smtp_accept_max
== 0 &&
3347 (smtp_accept_queue
> 0 || smtp_accept_max_per_host
!= NULL
))
3348 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3349 "smtp_accept_max must be set if smtp_accept_queue or "
3350 "smtp_accept_max_per_host is set");
3352 /* Set up the host number if anything is specified. It is an expanded string
3353 so that it can be computed from the host name, for example. We do this last
3354 so as to ensure that everything else is set up before the expansion. */
3356 if (host_number_string
!= NULL
)
3360 uschar
*s
= expand_string(host_number_string
);
3362 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
,
3363 "failed to expand localhost_number \"%s\": %s",
3364 host_number_string
, expand_string_message
);
3365 n
= Ustrtol(s
, &end
, 0);
3366 while (isspace(*end
)) end
++;
3368 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3369 "localhost_number value is not a number: %s", s
);
3370 if (n
> LOCALHOST_MAX
)
3371 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3372 "localhost_number is greater than the maximum allowed value (%d)",
3378 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3380 if ((tls_verify_hosts
!= NULL
|| tls_try_verify_hosts
!= NULL
) &&
3381 tls_verify_certificates
== NULL
)
3382 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3383 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3384 (tls_verify_hosts
!= NULL
)? "" : "try_");
3386 /* This also checks that the library linkage is working and we can call
3387 routines in it, so call even if tls_require_ciphers is unset */
3388 if (!tls_dropprivs_validate_require_cipher())
3391 /* Magic number: at time of writing, 1024 has been the long-standing value
3392 used by so many clients, and what Exim used to use always, that it makes
3393 sense to just min-clamp this max-clamp at that. */
3394 if (tls_dh_max_bits
< 1024)
3395 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3396 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3398 /* If openssl_options is set, validate it */
3399 if (openssl_options
!= NULL
)
3402 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3403 "openssl_options is set but we're using GnuTLS");
3406 if (!(tls_openssl_options_parse(openssl_options
, &dummy
)))
3407 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3408 "openssl_options parse error: %s", openssl_options
);
3412 if (gnutls_require_kx
|| gnutls_require_mac
|| gnutls_require_proto
)
3413 log_write(0, LOG_MAIN
, "WARNING: main options"
3414 " gnutls_require_kx, gnutls_require_mac and gnutls_require_protocols"
3416 #endif /*SUPPORT_TLS*/
3418 if ((!add_environment
|| *add_environment
== '\0') && !keep_environment
)
3419 log_write(0, LOG_MAIN
,
3420 "WARNING: purging the environment.\n"
3421 " Suggested action: use keep_environment and add_environment.\n");
3426 /*************************************************
3427 * Initialize one driver *
3428 *************************************************/
3430 /* This is called once the driver's generic options, if any, have been read.
3431 We can now find the driver, set up defaults for the private options, and
3432 unset any "set" bits in the private options table (which might have been
3433 set by another incarnation of the same driver).
3436 d pointer to driver instance block, with generic
3438 drivers_available vector of available drivers
3439 size_of_info size of each block in drivers_available
3440 class class of driver, for error message
3442 Returns: pointer to the driver info block
3445 static driver_info
*
3446 init_driver(driver_instance
*d
, driver_info
*drivers_available
,
3447 int size_of_info
, uschar
*class)
3451 for (dd
= drivers_available
; dd
->driver_name
[0] != 0;
3452 dd
= (driver_info
*)(((uschar
*)dd
) + size_of_info
))
3454 if (Ustrcmp(d
->driver_name
, dd
->driver_name
) == 0)
3457 int len
= dd
->options_len
;
3459 d
->options_block
= store_get(len
);
3460 memcpy(d
->options_block
, dd
->options_block
, len
);
3461 for (i
= 0; i
< *(dd
->options_count
); i
++)
3462 dd
->options
[i
].type
&= ~opt_set
;
3467 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
3468 "%s %s: cannot find %s driver \"%s\"", class, d
->name
, class, d
->driver_name
);
3470 return NULL
; /* never obeyed */
3476 /*************************************************
3477 * Initialize driver list *
3478 *************************************************/
3480 /* This function is called for routers, transports, and authentication
3481 mechanisms. It reads the data from the current point in the configuration file
3482 up to the end of the section, and sets up a chain of instance blocks according
3483 to the file's contents. The file will already have been opened by a call to
3484 readconf_main, and must be left open for subsequent reading of further data.
3486 Any errors cause a panic crash. Note that the blocks with names driver_info and
3487 driver_instance must map the first portions of all the _info and _instance
3488 blocks for this shared code to work.
3491 class "router", "transport", or "authenticator"
3492 anchor &routers, &transports, &auths
3493 drivers_available available drivers
3494 size_of_info size of each info block
3495 instance_default points to default data for an instance
3496 instance_size size of instance block
3497 driver_optionlist generic option list
3498 driver_optionlist_count count of generic option list
3504 readconf_driver_init(
3506 driver_instance
**anchor
,
3507 driver_info
*drivers_available
,
3509 void *instance_default
,
3511 optionlist
*driver_optionlist
,
3512 int driver_optionlist_count
)
3514 driver_instance
**p
= anchor
;
3515 driver_instance
*d
= NULL
;
3518 while ((buffer
= get_config_line()) != NULL
)
3523 /* Read the first name on the line and test for the start of a new driver. A
3524 macro definition indicates the end of the previous driver. If this isn't the
3525 start of a new driver, the line will be re-read. */
3527 s
= readconf_readname(name
, sizeof(name
), buffer
);
3529 /* Handle macro definition, first finishing off the initialization of the
3530 previous driver, if any. */
3532 if (isupper(*name
) && *s
== '=')
3536 if (d
->driver_name
== NULL
)
3537 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3538 "no driver defined for %s \"%s\"", class, d
->name
);
3542 read_macro_assignment(buffer
);
3546 /* If the line starts with a name terminated by a colon, we are at the
3547 start of the definition of a new driver. The rest of the line must be
3554 /* Finish off initializing the previous driver. */
3558 if (d
->driver_name
== NULL
)
3559 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3560 "no driver defined for %s \"%s\"", class, d
->name
);
3564 /* Check that we haven't already got a driver of this name */
3566 for (d
= *anchor
; d
!= NULL
; d
= d
->next
)
3567 if (Ustrcmp(name
, d
->name
) == 0)
3568 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3569 "there are two %ss called \"%s\"", class, name
);
3571 /* Set up a new driver instance data block on the chain, with
3572 its default values installed. */
3574 d
= store_get(instance_size
);
3575 memcpy(d
, instance_default
, instance_size
);
3578 d
->name
= string_copy(name
);
3580 /* Clear out the "set" bits in the generic options */
3582 for (i
= 0; i
< driver_optionlist_count
; i
++)
3583 driver_optionlist
[i
].type
&= ~opt_set
;
3585 /* Check nothing more on this line, then do the next loop iteration. */
3587 while (isspace(*s
)) s
++;
3588 if (*s
!= 0) extra_chars_error(s
, US
"driver name ", name
, US
"");
3592 /* Not the start of a new driver. Give an error if we have not set up a
3593 current driver yet. */
3595 if (d
== NULL
) log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
3596 "%s name missing", class);
3598 /* First look to see if this is a generic option; if it is "driver",
3599 initialize the driver. If is it not a generic option, we can look for a
3600 private option provided that the driver has been previously set up. */
3602 if (readconf_handle_option(buffer
, driver_optionlist
,
3603 driver_optionlist_count
, d
, NULL
))
3605 if (d
->info
== NULL
&& d
->driver_name
!= NULL
)
3606 init_driver(d
, drivers_available
, size_of_info
, class);
3609 /* Handle private options - pass the generic block because some may
3610 live therein. A flag with each option indicates if it is in the public
3613 else if (d
->info
!= NULL
)
3615 readconf_handle_option(buffer
, d
->info
->options
,
3616 *(d
->info
->options_count
), d
, US
"option \"%s\" unknown");
3619 /* The option is not generic and the driver name has not yet been given. */
3621 else log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "option \"%s\" unknown "
3622 "(\"driver\" must be specified before any private options)", name
);
3625 /* Run the initialization function for the final driver. */
3629 if (d
->driver_name
== NULL
)
3630 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
,
3631 "no driver defined for %s \"%s\"", class, d
->name
);
3638 /*************************************************
3639 * Check driver dependency *
3640 *************************************************/
3642 /* This function is passed a driver instance and a string. It checks whether
3643 any of the string options for the driver contains the given string as an
3647 d points to a driver instance block
3648 s the string to search for
3650 Returns: TRUE if a dependency is found
3654 readconf_depends(driver_instance
*d
, uschar
*s
)
3656 int count
= *(d
->info
->options_count
);
3660 for (ol
= d
->info
->options
; ol
< d
->info
->options
+ count
; ol
++)
3662 void *options_block
;
3664 int type
= ol
->type
& opt_mask
;
3665 if (type
!= opt_stringptr
) continue;
3666 options_block
= ((ol
->type
& opt_public
) == 0)? d
->options_block
: (void *)d
;
3667 value
= *(uschar
**)((uschar
*)options_block
+ (long int)(ol
->value
));
3668 if (value
!= NULL
&& (ss
= Ustrstr(value
, s
)) != NULL
)
3670 if (ss
<= value
|| (ss
[-1] != '$' && ss
[-1] != '{') ||
3671 isalnum(ss
[Ustrlen(s
)])) continue;
3672 DEBUG(D_transport
) debug_printf("driver %s: \"%s\" option depends on %s\n",
3673 d
->name
, ol
->name
, s
);
3678 DEBUG(D_transport
) debug_printf("driver %s does not depend on %s\n", d
->name
, s
);
3685 /*************************************************
3686 * Decode an error type for retries *
3687 *************************************************/
3689 /* This function is global because it is also called from the main
3690 program when testing retry information. It decodes strings such as "quota_7d"
3691 into numerical error codes.
3694 pp points to start of text
3695 p points past end of text
3696 basic_errno points to an int to receive the main error number
3697 more_errno points to an int to receive the secondary error data
3699 Returns: NULL if decoded correctly; else points to error text
3703 readconf_retry_error(uschar
*pp
, uschar
*p
, int *basic_errno
, int *more_errno
)
3707 while (q
< p
&& *q
!= '_') q
++;
3710 if (len
== 5 && strncmpic(pp
, US
"quota", len
) == 0)
3712 *basic_errno
= ERRNO_EXIMQUOTA
;
3713 if (q
!= p
&& (*more_errno
= readconf_readtime(q
+1, *p
, FALSE
)) < 0)
3714 return US
"bad time value";
3717 else if (len
== 7 && strncmpic(pp
, US
"refused", len
) == 0)
3719 *basic_errno
= ECONNREFUSED
;
3722 if (strncmpic(q
+1, US
"MX", p
-q
-1) == 0) *more_errno
= 'M';
3723 else if (strncmpic(q
+1, US
"A", p
-q
-1) == 0) *more_errno
= 'A';
3724 else return US
"A or MX expected after \"refused\"";
3728 else if (len
== 7 && strncmpic(pp
, US
"timeout", len
) == 0)
3730 *basic_errno
= ETIMEDOUT
;
3734 int xlen
= p
- q
- 1;
3737 static uschar
*extras
[] =
3738 { US
"A", US
"MX", US
"connect", US
"connect_A", US
"connect_MX" };
3739 static int values
[] =
3740 { 'A', 'M', RTEF_CTOUT
, RTEF_CTOUT
|'A', RTEF_CTOUT
|'M' };
3742 for (i
= 0; i
< sizeof(extras
)/sizeof(uschar
*); i
++)
3744 if (strncmpic(x
, extras
[i
], xlen
) == 0)
3746 *more_errno
= values
[i
];
3751 if (i
>= sizeof(extras
)/sizeof(uschar
*))
3753 if (strncmpic(x
, US
"DNS", xlen
) == 0)
3755 log_write(0, LOG_MAIN
|LOG_PANIC
, "\"timeout_dns\" is no longer "
3756 "available in retry rules (it has never worked) - treated as "
3759 else return US
"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3764 else if (strncmpic(pp
, US
"mail_4", 6) == 0 ||
3765 strncmpic(pp
, US
"rcpt_4", 6) == 0 ||
3766 strncmpic(pp
, US
"data_4", 6) == 0)
3769 int x
= 255; /* means "any 4xx code" */
3770 if (p
!= pp
+ 8) bad
= TRUE
; else
3772 int a
= pp
[6], b
= pp
[7];
3776 if (isdigit(b
)) x
+= b
- '0';
3777 else if (b
== 'x') x
+= 100;
3780 else if (a
!= 'x' || b
!= 'x') bad
= TRUE
;
3784 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
3785 "x is literal and d is any digit", pp
);
3787 *basic_errno
= (*pp
== 'm')? ERRNO_MAIL4XX
:
3788 (*pp
== 'r')? ERRNO_RCPT4XX
: ERRNO_DATA4XX
;
3789 *more_errno
= x
<< 8;
3792 else if (len
== 4 && strncmpic(pp
, US
"auth", len
) == 0 &&
3793 strncmpic(q
+1, US
"failed", p
-q
-1) == 0)
3794 *basic_errno
= ERRNO_AUTHFAIL
;
3796 else if (strncmpic(pp
, US
"lost_connection", p
- pp
) == 0)
3797 *basic_errno
= ERRNO_SMTPCLOSED
;
3799 else if (strncmpic(pp
, US
"tls_required", p
- pp
) == 0)
3800 *basic_errno
= ERRNO_TLSREQUIRED
;
3802 else if (len
!= 1 || Ustrncmp(pp
, "*", 1) != 0)
3803 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p
-pp
), pp
);
3811 /*************************************************
3812 * Read retry information *
3813 *************************************************/
3815 /* Each line of retry information contains:
3817 . A domain name pattern or an address pattern;
3819 . An error name, possibly with additional data, or *;
3821 . An optional sequence of retry items, each consisting of an identifying
3822 letter, a cutoff time, and optional parameters.
3824 All this is decoded and placed into a control block. */
3827 /* Subroutine to read an argument, preceded by a comma and terminated
3828 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3829 1 = fixed point number (returned *1000).
3832 paddr pointer to pointer to current character; updated
3833 type 0 => read a time; 1 => read a fixed point number
3835 Returns: time in seconds or fixed point number * 1000
3839 retry_arg(uschar
**paddr
, int type
)
3844 if (*p
++ != ',') log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "comma expected");
3846 while (isspace(*p
)) p
++;
3848 while (isalnum(*p
) || (type
== 1 && *p
== '.')) p
++;
3850 if (*p
!= 0 && !isspace(*p
) && *p
!= ',' && *p
!= ';')
3851 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "comma or semicolon expected");
3857 return readconf_readtime(pp
, *p
, FALSE
);
3859 return readconf_readfixed(pp
, *p
);
3861 return 0; /* Keep picky compilers happy */
3864 /* The function proper */
3867 readconf_retries(void)
3869 retry_config
**chain
= &retries
;
3873 while ((p
= get_config_line()) != NULL
)
3875 retry_rule
**rchain
;
3878 next
= store_get(sizeof(retry_config
));
3881 chain
= &(next
->next
);
3882 next
->basic_errno
= next
->more_errno
= 0;
3883 next
->senders
= NULL
;
3885 rchain
= &(next
->rules
);
3887 next
->pattern
= string_dequote(&p
);
3888 while (isspace(*p
)) p
++;
3890 while (mac_isgraph(*p
)) p
++;
3891 if (p
- pp
<= 0) log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
3892 "missing error type in retry rule");
3894 /* Test error names for things we understand. */
3896 if ((error
= readconf_retry_error(pp
, p
, &(next
->basic_errno
),
3897 &(next
->more_errno
))) != NULL
)
3898 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "%s", error
);
3900 /* There may be an optional address list of senders to be used as another
3901 constraint on the rule. This was added later, so the syntax is a bit of a
3902 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3905 while (isspace(*p
)) p
++;
3906 if (Ustrncmp(p
, "senders", 7) == 0)
3909 while (isspace(*p
)) p
++;
3910 if (*p
++ != '=') log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
3911 "\"=\" expected after \"senders\" in retry rule");
3912 while (isspace(*p
)) p
++;
3913 next
->senders
= string_dequote(&p
);
3916 /* Now the retry rules. Keep the maximum timeout encountered. */
3918 while (isspace(*p
)) p
++;
3922 retry_rule
*rule
= store_get(sizeof(retry_rule
));
3924 rchain
= &(rule
->next
);
3926 rule
->rule
= toupper(*p
++);
3927 rule
->timeout
= retry_arg(&p
, 0);
3928 if (rule
->timeout
> retry_maximum_timeout
)
3929 retry_maximum_timeout
= rule
->timeout
;
3933 case 'F': /* Fixed interval */
3934 rule
->p1
= retry_arg(&p
, 0);
3937 case 'G': /* Geometrically increasing intervals */
3938 case 'H': /* Ditto, but with randomness */
3939 rule
->p1
= retry_arg(&p
, 0);
3940 rule
->p2
= retry_arg(&p
, 1);
3944 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "unknown retry rule letter");
3948 if (rule
->timeout
<= 0 || rule
->p1
<= 0 ||
3949 (rule
->rule
!= 'F' && rule
->p2
< 1000))
3950 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
3951 "bad parameters for retry rule");
3953 while (isspace(*p
)) p
++;
3957 while (isspace(*p
)) p
++;
3960 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "semicolon expected");
3967 /*************************************************
3968 * Initialize authenticators *
3969 *************************************************/
3971 /* Read the authenticators section of the configuration file.
3980 auth_instance
*au
, *bu
;
3981 readconf_driver_init(US
"authenticator",
3982 (driver_instance
**)(&auths
), /* chain anchor */
3983 (driver_info
*)auths_available
, /* available drivers */
3984 sizeof(auth_info
), /* size of info block */
3985 &auth_defaults
, /* default values for generic options */
3986 sizeof(auth_instance
), /* size of instance block */
3987 optionlist_auths
, /* generic options */
3988 optionlist_auths_size
);
3990 for (au
= auths
; au
!= NULL
; au
= au
->next
)
3992 if (au
->public_name
== NULL
)
3993 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
, "no public name specified for "
3994 "the %s authenticator", au
->name
);
3995 for (bu
= au
->next
; bu
!= NULL
; bu
= bu
->next
)
3997 if (strcmpic(au
->public_name
, bu
->public_name
) == 0)
3999 if ((au
->client
&& bu
->client
) || (au
->server
&& bu
->server
))
4000 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG
, "two %s authenticators "
4001 "(%s and %s) have the same public name (%s)",
4002 (au
->client
)? US
"client" : US
"server", au
->name
, bu
->name
,
4012 /*************************************************
4013 * Read ACL information *
4014 *************************************************/
4016 /* If this run of Exim is not doing something that involves receiving a
4017 message, we can just skip over the ACL information. No need to parse it.
4019 First, we have a function for acl_read() to call back to get the next line. We
4020 need to remember the line we passed, because at the end it will contain the
4021 name of the next ACL. */
4023 static uschar
*acl_line
;
4028 acl_line
= get_config_line();
4033 /* Now the main function:
4044 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4047 acl_line
= get_config_line();
4049 while(acl_line
!= NULL
)
4055 p
= readconf_readname(name
, sizeof(name
), acl_line
);
4056 if (isupper(*name
) && *p
== '=')
4058 read_macro_assignment(acl_line
);
4059 acl_line
= get_config_line();
4063 if (*p
!= ':' || name
[0] == 0)
4064 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "missing or malformed ACL name");
4066 node
= store_get(sizeof(tree_node
) + Ustrlen(name
));
4067 Ustrcpy(node
->name
, name
);
4068 if (!tree_insertnode(&acl_anchor
, node
))
4069 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
4070 "there are two ACLs called \"%s\"", name
);
4072 node
->data
.ptr
= acl_read(acl_callback
, &error
);
4074 if (node
->data
.ptr
== NULL
&& error
!= NULL
)
4075 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "error in ACL: %s", error
);
4081 /*************************************************
4082 * Read configuration for local_scan() *
4083 *************************************************/
4085 /* This function is called after "begin local_scan" is encountered in the
4086 configuration file. If the local_scan() function allows for configuration
4087 options, we can process them. Otherwise, we expire in a panic.
4094 local_scan_init(void)
4096 #ifndef LOCAL_SCAN_HAS_OPTIONS
4097 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
, "local_scan() options not supported: "
4098 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4102 while ((p
= get_config_line()) != NULL
)
4104 (void) readconf_handle_option(p
, local_scan_options
, local_scan_options_count
,
4105 NULL
, US
"local_scan option \"%s\" unknown");
4112 /*************************************************
4113 * Read rest of configuration (after main) *
4114 *************************************************/
4116 /* This function reads the rest of the runtime configuration, after the main
4117 configuration. It is called only when actually needed. Each subsequent section
4118 of the configuration starts with a line of the form
4122 where the name is "routers", "transports", etc. A section is terminated by
4123 hitting the next "begin" line, and the next name is left in next_section.
4124 Because it may confuse people as to whether the names are singular or plural,
4125 we add "s" if it's missing. There is always enough room in next_section for
4126 this. This function is basically just a switch.
4132 static uschar
*section_list
[] = {
4146 while(next_section
[0] != 0)
4150 int last
= sizeof(section_list
) / sizeof(uschar
*);
4152 int n
= Ustrlen(next_section
);
4154 if (tolower(next_section
[n
-1]) != 's') Ustrcpy(next_section
+n
, "s");
4158 int c
= strcmpic(next_section
, section_list
[mid
]);
4160 if (c
> 0) first
= mid
+ 1; else last
= mid
;
4162 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
4163 "\"%.*s\" is not a known configuration section name", n
, next_section
);
4164 mid
= (last
+ first
)/2;
4168 if (((had
^= bit
) & bit
) == 0)
4169 log_write(0, LOG_PANIC_DIE
|LOG_CONFIG_IN
,
4170 "\"%.*s\" section is repeated in the configuration file", n
,
4175 case 0: readconf_acl(); break;
4176 case 1: auths_init(); break;
4177 case 2: local_scan_init(); break;
4178 case 3: readconf_retries(); break;
4179 case 4: readconf_rewrites(); break;
4180 case 5: route_init(); break;
4181 case 6: transport_init(); break;
4185 (void)fclose(config_file
);
4190 /* End of readconf.c */