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