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