projects / exim.git / blob
? search:


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