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