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