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