projects / exim.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
TLS: rework error logging to pass more string back to caller for logging
[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 compatibility */
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_MAILDIR", 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 accessing 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 if ((errmsg = tls_validate_require_cipher()))
3255 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3256 "tls_require_ciphers invalid: %s", errmsg);
3257 fflush(NULL);
3258 _exit(0);
3259 }
3260
3261 do {
3262 rc = waitpid(pid, &status, 0);
3263 } while (rc < 0 && errno == EINTR);
3264
3265 DEBUG(D_tls)
3266 debug_printf("tls_validate_require_cipher child %d ended: status=0x%x\n",
3267 (int)pid, status);
3268
3269 signal(SIGCHLD, oldsignal);
3270
3271 return status == 0;
3272 }
3273 #endif /* SUPPORT_TLS */
3274
3275
3276
3277
3278 /*************************************************
3279 * Read main configuration options *
3280 *************************************************/
3281
3282 /* This function is the first to be called for configuration reading. It
3283 opens the configuration file and reads general configuration settings until
3284 it reaches the end of the configuration section. The file is then left open so
3285 that the remaining configuration data can subsequently be read if needed for
3286 this run of Exim.
3287
3288 The configuration file must be owned either by root or exim, and be writeable
3289 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
3290 in the config file, so the test is done on the compiled in values. A slight
3291 anomaly, to be carefully documented.
3292
3293 The name of the configuration file is taken from a list that is included in the
3294 binary of Exim. It can be altered from the command line, but if that is done,
3295 root privilege is immediately withdrawn unless the caller is root or exim.
3296 The first file on the list that exists is used.
3297
3298 For use on multiple systems that share file systems, first look for a
3299 configuration file whose name has the current node name on the end. If that is
3300 not found, try the generic name. For really contorted configurations, that run
3301 multiple Exims with different uid settings, first try adding the effective uid
3302 before the node name. These complications are going to waste resources on most
3303 systems. Therefore they are available only when requested by compile-time
3304 options. */
3305
3306 void
3307 readconf_main(BOOL nowarn)
3308 {
3309 int sep = 0;
3310 struct stat statbuf;
3311 uschar *s, *filename;
3312 const uschar *list = config_main_filelist;
3313
3314 /* Loop through the possible file names */
3315
3316 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3317 {
3318
3319 /* Cut out all the fancy processing unless specifically wanted */
3320
3321 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
3322 uschar *suffix = filename + Ustrlen(filename);
3323
3324 /* Try for the node-specific file if a node name exists */
3325
3326 #ifdef CONFIGURE_FILE_USE_NODE
3327 struct utsname uts;
3328 if (uname(&uts) >= 0)
3329 {
3330 #ifdef CONFIGURE_FILE_USE_EUID
3331 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
3332 config_file = Ufopen(filename, "rb");
3333 if (config_file == NULL)
3334 #endif /* CONFIGURE_FILE_USE_EUID */
3335 {
3336 sprintf(CS suffix, ".%.256s", uts.nodename);
3337 config_file = Ufopen(filename, "rb");
3338 }
3339 }
3340 #endif /* CONFIGURE_FILE_USE_NODE */
3341
3342 /* Otherwise, try the generic name, possibly with the euid added */
3343
3344 #ifdef CONFIGURE_FILE_USE_EUID
3345 if (config_file == NULL)
3346 {
3347 sprintf(CS suffix, ".%ld", (long int)original_euid);
3348 config_file = Ufopen(filename, "rb");
3349 }
3350 #endif /* CONFIGURE_FILE_USE_EUID */
3351
3352 /* Finally, try the unadorned name */
3353
3354 if (config_file == NULL)
3355 {
3356 *suffix = 0;
3357 config_file = Ufopen(filename, "rb");
3358 }
3359 #else /* if neither defined */
3360
3361 /* This is the common case when the fancy processing is not included. */
3362
3363 config_file = Ufopen(filename, "rb");
3364 #endif
3365
3366 /* If the file does not exist, continue to try any others. For any other
3367 error, break out (and die). */
3368
3369 if (config_file != NULL || errno != ENOENT) break;
3370 }
3371
3372 /* On success, save the name for verification; config_filename is used when
3373 logging configuration errors (it changes for .included files) whereas
3374 config_main_filename is the name shown by -bP. Failure to open a configuration
3375 file is a serious disaster. */
3376
3377 if (config_file)
3378 {
3379 uschar *last_slash = Ustrrchr(filename, '/');
3380 config_filename = config_main_filename = string_copy(filename);
3381
3382 /* The config_main_directory we need for the $config_dir expansion.
3383 config_main_filename we need for $config_file expansion.
3384 And config_dir is the directory of the current configuration, used for
3385 relative .includes. We do need to know it's name, as we change our working
3386 directory later. */
3387
3388 if (filename[0] == '/')
3389 config_main_directory = last_slash == filename ? US"/" : string_copyn(filename, last_slash - filename);
3390 else
3391 {
3392 /* relative configuration file name: working dir + / + basename(filename) */
3393
3394 char buf[PATH_MAX];
3395 int offset = 0;
3396 int size = 0;
3397
3398 if (getcwd(buf, PATH_MAX) == NULL)
3399 {
3400 perror("exim: getcwd");
3401 exit(EXIT_FAILURE);
3402 }
3403 config_main_directory = string_cat(NULL, &size, &offset, buf);
3404
3405 /* If the dir does not end with a "/", append one */
3406 if (config_main_directory[offset-1] != '/')
3407 config_main_directory = string_catn(config_main_directory, &size, &offset, US"/", 1);
3408
3409 /* If the config file contains a "/", extract the directory part */
3410 if (last_slash)
3411 config_main_directory = string_catn(config_main_directory, &size, &offset, filename, last_slash - filename);
3412
3413 config_main_directory[offset] = '\0';
3414 }
3415 config_directory = config_main_directory;
3416 }
3417 else
3418 {
3419 if (filename == NULL)
3420 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
3421 "%s", config_main_filelist);
3422 else
3423 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
3424 "configuration file %s", filename));
3425 }
3426
3427 /* Now, once we found and opened our configuration file, we change the directory
3428 to a safe place. Later we change to $spool_directory. */
3429
3430 if (Uchdir("/") < 0)
3431 {
3432 perror("exim: chdir `/': ");
3433 exit(EXIT_FAILURE);
3434 }
3435
3436 /* Check the status of the file we have opened, if we have retained root
3437 privileges and the file isn't /dev/null (which *should* be 0666). */
3438
3439 if (trusted_config && Ustrcmp(filename, US"/dev/null"))
3440 {
3441 if (fstat(fileno(config_file), &statbuf) != 0)
3442 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
3443 big_buffer);
3444
3445 if ((statbuf.st_uid != root_uid /* owner not root */
3446 #ifdef CONFIGURE_OWNER
3447 && statbuf.st_uid != config_uid /* owner not the special one */
3448 #endif
3449 ) || /* or */
3450 (statbuf.st_gid != root_gid /* group not root & */
3451 #ifdef CONFIGURE_GROUP
3452 && statbuf.st_gid != config_gid /* group not the special one */
3453 #endif
3454 && (statbuf.st_mode & 020) != 0) || /* group writeable */
3455 /* or */
3456 ((statbuf.st_mode & 2) != 0)) /* world writeable */
3457
3458 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
3459 "wrong owner, group, or mode", big_buffer);
3460 }
3461
3462 /* Process the main configuration settings. They all begin with a lower case
3463 letter. If we see something starting with an upper case letter, it is taken as
3464 a macro definition. */
3465
3466 while ((s = get_config_line()) != NULL)
3467 {
3468 if (isupper(s[0])) read_macro_assignment(s);
3469
3470 else if (Ustrncmp(s, "domainlist", 10) == 0)
3471 read_named_list(&domainlist_anchor, &domainlist_count,
3472 MAX_NAMED_LIST, s+10, US"domain list");
3473
3474 else if (Ustrncmp(s, "hostlist", 8) == 0)
3475 read_named_list(&hostlist_anchor, &hostlist_count,
3476 MAX_NAMED_LIST, s+8, US"host list");
3477
3478 else if (Ustrncmp(s, US"addresslist", 11) == 0)
3479 read_named_list(&addresslist_anchor, &addresslist_count,
3480 MAX_NAMED_LIST, s+11, US"address list");
3481
3482 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
3483 read_named_list(&localpartlist_anchor, &localpartlist_count,
3484 MAX_NAMED_LIST, s+13, US"local part list");
3485
3486 else
3487 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
3488 NULL, US"main option \"%s\" unknown");
3489 }
3490
3491
3492 /* If local_sender_retain is set, local_from_check must be unset. */
3493
3494 if (local_sender_retain && local_from_check)
3495 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
3496 "local_sender_retain are set; this combination is not allowed");
3497
3498 /* If the timezone string is empty, set it to NULL, implying no TZ variable
3499 wanted. */
3500
3501 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
3502
3503 /* The max retry interval must not be greater than 24 hours. */
3504
3505 if (retry_interval_max > 24*60*60) retry_interval_max = 24*60*60;
3506
3507 /* remote_max_parallel must be > 0 */
3508
3509 if (remote_max_parallel <= 0) remote_max_parallel = 1;
3510
3511 /* Save the configured setting of freeze_tell, so we can re-instate it at the
3512 start of a new SMTP message. */
3513
3514 freeze_tell_config = freeze_tell;
3515
3516 /* The primary host name may be required for expansion of spool_directory
3517 and log_file_path, so make sure it is set asap. It is obtained from uname(),
3518 but if that yields an unqualified value, make a FQDN by using gethostbyname to
3519 canonize it. Some people like upper case letters in their host names, so we
3520 don't force the case. */
3521
3522 if (primary_hostname == NULL)
3523 {
3524 const uschar *hostname;
3525 struct utsname uts;
3526 if (uname(&uts) < 0)
3527 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
3528 hostname = US uts.nodename;
3529
3530 if (Ustrchr(hostname, '.') == NULL)
3531 {
3532 int af = AF_INET;
3533 struct hostent *hostdata;
3534
3535 #if HAVE_IPV6
3536 if (!disable_ipv6 && (dns_ipv4_lookup == NULL ||
3537 match_isinlist(hostname, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
3538 MCL_DOMAIN, TRUE, NULL) != OK))
3539 af = AF_INET6;
3540 #else
3541 af = AF_INET;
3542 #endif
3543
3544 for (;;)
3545 {
3546 #if HAVE_IPV6
3547 #if HAVE_GETIPNODEBYNAME
3548 int error_num;
3549 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
3550 #else
3551 hostdata = gethostbyname2(CS hostname, af);
3552 #endif
3553 #else
3554 hostdata = gethostbyname(CS hostname);
3555 #endif
3556
3557 if (hostdata != NULL)
3558 {
3559 hostname = US hostdata->h_name;
3560 break;
3561 }
3562
3563 if (af == AF_INET) break;
3564 af = AF_INET;
3565 }
3566 }
3567
3568 primary_hostname = string_copy(hostname);
3569 }
3570
3571 /* Set up default value for smtp_active_hostname */
3572
3573 smtp_active_hostname = primary_hostname;
3574
3575 /* If spool_directory wasn't set in the build-time configuration, it must have
3576 got set above. Of course, writing to the log may not work if log_file_path is
3577 not set, but it will at least get to syslog or somewhere, with any luck. */
3578
3579 if (*spool_directory == 0)
3580 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
3581 "proceed");
3582
3583 /* Expand the spool directory name; it may, for example, contain the primary
3584 host name. Same comment about failure. */
3585
3586 s = expand_string(spool_directory);
3587 if (s == NULL)
3588 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
3589 "\"%s\": %s", spool_directory, expand_string_message);
3590 spool_directory = s;
3591
3592 /* Expand log_file_path, which must contain "%s" in any component that isn't
3593 the null string or "syslog". It is also allowed to contain one instance of %D
3594 or %M. However, it must NOT contain % followed by anything else. */
3595
3596 if (*log_file_path != 0)
3597 {
3598 const uschar *ss, *sss;
3599 int sep = ':'; /* Fixed for log file path */
3600 s = expand_string(log_file_path);
3601 if (s == NULL)
3602 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
3603 "\"%s\": %s", log_file_path, expand_string_message);
3604
3605 ss = s;
3606 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
3607 {
3608 uschar *t;
3609 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
3610 t = Ustrstr(sss, "%s");
3611 if (t == NULL)
3612 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
3613 "contain \"%%s\"", sss);
3614 *t = 'X';
3615 t = Ustrchr(sss, '%');
3616 if (t != NULL)
3617 {
3618 if ((t[1] != 'D' && t[1] != 'M') || Ustrchr(t+2, '%') != NULL)
3619 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
3620 "unexpected \"%%\" character", s);
3621 }
3622 }
3623
3624 log_file_path = s;
3625 }
3626
3627 /* Interpret syslog_facility into an integer argument for 'ident' param to
3628 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
3629 leading "log_". */
3630
3631 if (syslog_facility_str != NULL)
3632 {
3633 int i;
3634 uschar *s = syslog_facility_str;
3635
3636 if ((Ustrlen(syslog_facility_str) >= 4) &&
3637 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
3638 s += 4;
3639
3640 for (i = 0; i < syslog_list_size; i++)
3641 {
3642 if (strcmpic(s, syslog_list[i].name) == 0)
3643 {
3644 syslog_facility = syslog_list[i].value;
3645 break;
3646 }
3647 }
3648
3649 if (i >= syslog_list_size)
3650 {
3651 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3652 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
3653 }
3654 }
3655
3656 /* Expand pid_file_path */
3657
3658 if (*pid_file_path != 0)
3659 {
3660 s = expand_string(pid_file_path);
3661 if (s == NULL)
3662 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
3663 "\"%s\": %s", pid_file_path, expand_string_message);
3664 pid_file_path = s;
3665 }
3666
3667 /* Set default value of process_log_path */
3668
3669 if (process_log_path == NULL || *process_log_path =='\0')
3670 process_log_path = string_sprintf("%s/exim-process.info", spool_directory);
3671
3672 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
3673 message. */
3674
3675 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
3676
3677 /* Unpick the SMTP rate limiting options, if set */
3678
3679 if (smtp_ratelimit_mail != NULL)
3680 {
3681 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
3682 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
3683 }
3684
3685 if (smtp_ratelimit_rcpt != NULL)
3686 {
3687 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
3688 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
3689 }
3690
3691 /* The qualify domains default to the primary host name */
3692
3693 if (qualify_domain_sender == NULL)
3694 qualify_domain_sender = primary_hostname;
3695 if (qualify_domain_recipient == NULL)
3696 qualify_domain_recipient = qualify_domain_sender;
3697
3698 /* Setting system_filter_user in the configuration sets the gid as well if a
3699 name is given, but a numerical value does not. */
3700
3701 if (system_filter_uid_set && !system_filter_gid_set)
3702 {
3703 struct passwd *pw = getpwuid(system_filter_uid);
3704 if (pw == NULL)
3705 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
3706 (long int)system_filter_uid);
3707 system_filter_gid = pw->pw_gid;
3708 system_filter_gid_set = TRUE;
3709 }
3710
3711 /* If the errors_reply_to field is set, check that it is syntactically valid
3712 and ensure it contains a domain. */
3713
3714 if (errors_reply_to != NULL)
3715 {
3716 uschar *errmess;
3717 int start, end, domain;
3718 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3719 &start, &end, &domain, FALSE);
3720
3721 if (recipient == NULL)
3722 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3723 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3724
3725 if (domain == 0)
3726 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3727 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3728 }
3729
3730 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3731 smtp_accept_max must also be set. */
3732
3733 if (smtp_accept_max == 0 &&
3734 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3735 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3736 "smtp_accept_max must be set if smtp_accept_queue or "
3737 "smtp_accept_max_per_host is set");
3738
3739 /* Set up the host number if anything is specified. It is an expanded string
3740 so that it can be computed from the host name, for example. We do this last
3741 so as to ensure that everything else is set up before the expansion. */
3742
3743 if (host_number_string != NULL)
3744 {
3745 long int n;
3746 uschar *end;
3747 uschar *s = expand_string(host_number_string);
3748 if (s == NULL)
3749 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3750 "failed to expand localhost_number \"%s\": %s",
3751 host_number_string, expand_string_message);
3752 n = Ustrtol(s, &end, 0);
3753 while (isspace(*end)) end++;
3754 if (*end != 0)
3755 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3756 "localhost_number value is not a number: %s", s);
3757 if (n > LOCALHOST_MAX)
3758 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3759 "localhost_number is greater than the maximum allowed value (%d)",
3760 LOCALHOST_MAX);
3761 host_number = n;
3762 }
3763
3764 #ifdef SUPPORT_TLS
3765 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3766
3767 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3768 tls_verify_certificates == NULL)
3769 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3770 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3771 (tls_verify_hosts != NULL)? "" : "try_");
3772
3773 /* This also checks that the library linkage is working and we can call
3774 routines in it, so call even if tls_require_ciphers is unset */
3775 if (!tls_dropprivs_validate_require_cipher(nowarn))
3776 exit(1);
3777
3778 /* Magic number: at time of writing, 1024 has been the long-standing value
3779 used by so many clients, and what Exim used to use always, that it makes
3780 sense to just min-clamp this max-clamp at that. */
3781 if (tls_dh_max_bits < 1024)
3782 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3783 "tls_dh_max_bits is too small, must be at least 1024 for interop");
3784
3785 /* If openssl_options is set, validate it */
3786 if (openssl_options != NULL)
3787 {
3788 # ifdef USE_GNUTLS
3789 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3790 "openssl_options is set but we're using GnuTLS");
3791 # else
3792 long dummy;
3793 if (!(tls_openssl_options_parse(openssl_options, &dummy)))
3794 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3795 "openssl_options parse error: %s", openssl_options);
3796 # endif
3797 }
3798 #endif /*SUPPORT_TLS*/
3799
3800 if (!nowarn && !keep_environment && environ && *environ)
3801 log_write(0, LOG_MAIN,
3802 "Warning: purging the environment.\n"
3803 " Suggested action: use keep_environment.");
3804 }
3805
3806
3807
3808 /*************************************************
3809 * Initialize one driver *
3810 *************************************************/
3811
3812 /* This is called once the driver's generic options, if any, have been read.
3813 We can now find the driver, set up defaults for the private options, and
3814 unset any "set" bits in the private options table (which might have been
3815 set by another incarnation of the same driver).
3816
3817 Arguments:
3818 d pointer to driver instance block, with generic
3819 options filled in
3820 drivers_available vector of available drivers
3821 size_of_info size of each block in drivers_available
3822 class class of driver, for error message
3823
3824 Returns: pointer to the driver info block
3825 */
3826
3827 static driver_info *
3828 init_driver(driver_instance *d, driver_info *drivers_available,
3829 int size_of_info, uschar *class)
3830 {
3831 driver_info *dd;
3832
3833 for (dd = drivers_available; dd->driver_name[0] != 0;
3834 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3835 {
3836 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3837 {
3838 int i;
3839 int len = dd->options_len;
3840 d->info = dd;
3841 d->options_block = store_get(len);
3842 memcpy(d->options_block, dd->options_block, len);
3843 for (i = 0; i < *(dd->options_count); i++)
3844 dd->options[i].type &= ~opt_set;
3845 return dd;
3846 }
3847 }
3848
3849 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3850 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3851
3852 return NULL; /* never obeyed */
3853 }
3854
3855
3856
3857
3858 /*************************************************
3859 * Initialize driver list *
3860 *************************************************/
3861
3862 /* This function is called for routers, transports, and authentication
3863 mechanisms. It reads the data from the current point in the configuration file
3864 up to the end of the section, and sets up a chain of instance blocks according
3865 to the file's contents. The file will already have been opened by a call to
3866 readconf_main, and must be left open for subsequent reading of further data.
3867
3868 Any errors cause a panic crash. Note that the blocks with names driver_info and
3869 driver_instance must map the first portions of all the _info and _instance
3870 blocks for this shared code to work.
3871
3872 Arguments:
3873 class "router", "transport", or "authenticator"
3874 anchor &routers, &transports, &auths
3875 drivers_available available drivers
3876 size_of_info size of each info block
3877 instance_default points to default data for an instance
3878 instance_size size of instance block
3879 driver_optionlist generic option list
3880 driver_optionlist_count count of generic option list
3881
3882 Returns: nothing
3883 */
3884
3885 void
3886 readconf_driver_init(
3887 uschar *class,
3888 driver_instance **anchor,
3889 driver_info *drivers_available,
3890 int size_of_info,
3891 void *instance_default,
3892 int instance_size,
3893 optionlist *driver_optionlist,
3894 int driver_optionlist_count)
3895 {
3896 driver_instance **p = anchor;
3897 driver_instance *d = NULL;
3898 uschar *buffer;
3899
3900 while ((buffer = get_config_line()) != NULL)
3901 {
3902 uschar name[64];
3903 uschar *s;
3904
3905 /* Read the first name on the line and test for the start of a new driver. A
3906 macro definition indicates the end of the previous driver. If this isn't the
3907 start of a new driver, the line will be re-read. */
3908
3909 s = readconf_readname(name, sizeof(name), buffer);
3910
3911 /* Handle macro definition, first finishing off the initialization of the
3912 previous driver, if any. */
3913
3914 if (isupper(*name) && *s == '=')
3915 {
3916 if (d)
3917 {
3918 if (!d->driver_name)
3919 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3920 "no driver defined for %s \"%s\"", class, d->name);
3921 (d->info->init)(d);
3922 d = NULL;
3923 }
3924 read_macro_assignment(buffer);
3925 continue;
3926 }
3927
3928 /* If the line starts with a name terminated by a colon, we are at the
3929 start of the definition of a new driver. The rest of the line must be
3930 blank. */
3931
3932 if (*s++ == ':')
3933 {
3934 int i;
3935
3936 /* Finish off initializing the previous driver. */
3937
3938 if (d)
3939 {
3940 if (!d->driver_name)
3941 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3942 "no driver defined for %s \"%s\"", class, d->name);
3943 (d->info->init)(d);
3944 }
3945
3946 /* Check that we haven't already got a driver of this name */
3947
3948 for (d = *anchor; d; d = d->next)
3949 if (Ustrcmp(name, d->name) == 0)
3950 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3951 "there are two %ss called \"%s\"", class, name);
3952
3953 /* Set up a new driver instance data block on the chain, with
3954 its default values installed. */
3955
3956 d = store_get(instance_size);
3957 memcpy(d, instance_default, instance_size);
3958 *p = d;
3959 p = &d->next;
3960 d->name = string_copy(name);
3961
3962 /* Clear out the "set" bits in the generic options */
3963
3964 for (i = 0; i < driver_optionlist_count; i++)
3965 driver_optionlist[i].type &= ~opt_set;
3966
3967 /* Check nothing more on this line, then do the next loop iteration. */
3968
3969 while (isspace(*s)) s++;
3970 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3971 continue;
3972 }
3973
3974 /* Not the start of a new driver. Give an error if we have not set up a
3975 current driver yet. */
3976
3977 if (!d)
3978 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s name missing", class);
3979
3980 /* First look to see if this is a generic option; if it is "driver",
3981 initialize the driver. If is it not a generic option, we can look for a
3982 private option provided that the driver has been previously set up. */
3983
3984 if (readconf_handle_option(buffer, driver_optionlist,
3985 driver_optionlist_count, d, NULL))
3986 {
3987 if (!d->info && d->driver_name)
3988 init_driver(d, drivers_available, size_of_info, class);
3989 }
3990
3991 /* Handle private options - pass the generic block because some may
3992 live therein. A flag with each option indicates if it is in the public
3993 block. */
3994
3995 else if (d->info)
3996 readconf_handle_option(buffer, d->info->options,
3997 *(d->info->options_count), d, US"option \"%s\" unknown");
3998
3999 /* The option is not generic and the driver name has not yet been given. */
4000
4001 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
4002 "(\"driver\" must be specified before any private options)", name);
4003 }
4004
4005 /* Run the initialization function for the final driver. */
4006
4007 if (d)
4008 {
4009 if (!d->driver_name)
4010 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
4011 "no driver defined for %s \"%s\"", class, d->name);
4012 (d->info->init)(d);
4013 }
4014 }
4015
4016
4017
4018 /*************************************************
4019 * Check driver dependency *
4020 *************************************************/
4021
4022 /* This function is passed a driver instance and a string. It checks whether
4023 any of the string options for the driver contains the given string as an
4024 expansion variable.
4025
4026 Arguments:
4027 d points to a driver instance block
4028 s the string to search for
4029
4030 Returns: TRUE if a dependency is found
4031 */
4032
4033 BOOL
4034 readconf_depends(driver_instance *d, uschar *s)
4035 {
4036 int count = *(d->info->options_count);
4037 optionlist *ol;
4038 uschar *ss;
4039
4040 for (ol = d->info->options; ol < d->info->options + count; ol++)
4041 {
4042 void *options_block;
4043 uschar *value;
4044 int type = ol->type & opt_mask;
4045 if (type != opt_stringptr) continue;
4046 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
4047 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
4048 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
4049 {
4050 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
4051 isalnum(ss[Ustrlen(s)])) continue;
4052 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
4053 d->name, ol->name, s);
4054 return TRUE;
4055 }
4056 }
4057
4058 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
4059 return FALSE;
4060 }
4061
4062
4063
4064
4065 /*************************************************
4066 * Decode an error type for retries *
4067 *************************************************/
4068
4069 /* This function is global because it is also called from the main
4070 program when testing retry information. It decodes strings such as "quota_7d"
4071 into numerical error codes.
4072
4073 Arguments:
4074 pp points to start of text
4075 p points past end of text
4076 basic_errno points to an int to receive the main error number
4077 more_errno points to an int to receive the secondary error data
4078
4079 Returns: NULL if decoded correctly; else points to error text
4080 */
4081
4082 uschar *
4083 readconf_retry_error(const uschar *pp, const uschar *p,
4084 int *basic_errno, int *more_errno)
4085 {
4086 int len;
4087 const uschar *q = pp;
4088 while (q < p && *q != '_') q++;
4089 len = q - pp;
4090
4091 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
4092 {
4093 *basic_errno = ERRNO_EXIMQUOTA;
4094 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
4095 return US"bad time value";
4096 }
4097
4098 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
4099 {
4100 *basic_errno = ECONNREFUSED;
4101 if (q != p)
4102 {
4103 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
4104 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
4105 else return US"A or MX expected after \"refused\"";
4106 }
4107 }
4108
4109 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
4110 {
4111 *basic_errno = ETIMEDOUT;
4112 if (q != p)
4113 {
4114 int i;
4115 int xlen = p - q - 1;
4116 const uschar *x = q + 1;
4117
4118 static uschar *extras[] =
4119 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
4120 static int values[] =
4121 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
4122
4123 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
4124 if (strncmpic(x, extras[i], xlen) == 0)
4125 {
4126 *more_errno = values[i];
4127 break;
4128 }
4129
4130 if (i >= sizeof(extras)/sizeof(uschar *))
4131 if (strncmpic(x, US"DNS", xlen) == 0)
4132 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
4133 "available in retry rules (it has never worked) - treated as "
4134 "\"timeout\"");
4135 else
4136 return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
4137 }
4138 }
4139
4140 else if (strncmpic(pp, US"mail_4", 6) == 0 ||
4141 strncmpic(pp, US"rcpt_4", 6) == 0 ||
4142 strncmpic(pp, US"data_4", 6) == 0)
4143 {
4144 BOOL bad = FALSE;
4145 int x = 255; /* means "any 4xx code" */
4146 if (p != pp + 8) bad = TRUE; else
4147 {
4148 int a = pp[6], b = pp[7];
4149 if (isdigit(a))
4150 {
4151 x = (a - '0') * 10;
4152 if (isdigit(b)) x += b - '0';
4153 else if (b == 'x') x += 100;
4154 else bad = TRUE;
4155 }
4156 else if (a != 'x' || b != 'x') bad = TRUE;
4157 }
4158
4159 if (bad)
4160 return string_sprintf("%.4s_4 must be followed by xx, dx, or dd, where "
4161 "x is literal and d is any digit", pp);
4162
4163 *basic_errno = *pp == 'm' ? ERRNO_MAIL4XX :
4164 *pp == 'r' ? ERRNO_RCPT4XX : ERRNO_DATA4XX;
4165 *more_errno = x << 8;
4166 }
4167
4168 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
4169 strncmpic(q+1, US"failed", p-q-1) == 0)
4170 *basic_errno = ERRNO_AUTHFAIL;
4171
4172 else if (strncmpic(pp, US"lost_connection", p - pp) == 0)
4173 *basic_errno = ERRNO_SMTPCLOSED;
4174
4175 else if (strncmpic(pp, US"tls_required", p - pp) == 0)
4176 *basic_errno = ERRNO_TLSREQUIRED;
4177
4178 else if (strncmpic(pp, US"lookup", p - pp) == 0)
4179 *basic_errno = ERRNO_UNKNOWNHOST;
4180
4181 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
4182 return string_sprintf("unknown or malformed retry error \"%.*s\"", (int) (p-pp), pp);
4183
4184 return NULL;
4185 }
4186
4187
4188
4189
4190 /*************************************************
4191 * Read retry information *
4192 *************************************************/
4193
4194 /* Each line of retry information contains:
4195
4196 . A domain name pattern or an address pattern;
4197
4198 . An error name, possibly with additional data, or *;
4199
4200 . An optional sequence of retry items, each consisting of an identifying
4201 letter, a cutoff time, and optional parameters.
4202
4203 All this is decoded and placed into a control block. */
4204
4205
4206 /* Subroutine to read an argument, preceded by a comma and terminated
4207 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
4208 1 = fixed point number (returned *1000).
4209
4210 Arguments:
4211 paddr pointer to pointer to current character; updated
4212 type 0 => read a time; 1 => read a fixed point number
4213
4214 Returns: time in seconds or fixed point number * 1000
4215 */
4216
4217 static int
4218 retry_arg(const uschar **paddr, int type)
4219 {
4220 const uschar *p = *paddr;
4221 const uschar *pp;
4222
4223 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
4224
4225 while (isspace(*p)) p++;
4226 pp = p;
4227 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
4228
4229 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
4230 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
4231
4232 *paddr = p;
4233 switch (type)
4234 {
4235 case 0: return readconf_readtime(pp, *p, FALSE);
4236 case 1: return readconf_readfixed(pp, *p);
4237 }
4238 return 0; /* Keep picky compilers happy */
4239 }
4240
4241 /* The function proper */
4242
4243 void
4244 readconf_retries(void)
4245 {
4246 retry_config **chain = &retries;
4247 retry_config *next;
4248 const uschar *p;
4249
4250 while ((p = get_config_line()))
4251 {
4252 retry_rule **rchain;
4253 const uschar *pp;
4254 uschar *error;
4255
4256 next = store_get(sizeof(retry_config));
4257 next->next = NULL;
4258 *chain = next;
4259 chain = &(next->next);
4260 next->basic_errno = next->more_errno = 0;
4261 next->senders = NULL;
4262 next->rules = NULL;
4263 rchain = &(next->rules);
4264
4265 next->pattern = string_dequote(&p);
4266 while (isspace(*p)) p++;
4267 pp = p;
4268 while (mac_isgraph(*p)) p++;
4269 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4270 "missing error type in retry rule");
4271
4272 /* Test error names for things we understand. */
4273
4274 if ((error = readconf_retry_error(pp, p, &next->basic_errno,
4275 &next->more_errno)))
4276 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
4277
4278 /* There may be an optional address list of senders to be used as another
4279 constraint on the rule. This was added later, so the syntax is a bit of a
4280 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
4281 an address list. */
4282
4283 while (isspace(*p)) p++;
4284 if (Ustrncmp(p, "senders", 7) == 0)
4285 {
4286 p += 7;
4287 while (isspace(*p)) p++;
4288 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4289 "\"=\" expected after \"senders\" in retry rule");
4290 while (isspace(*p)) p++;
4291 next->senders = string_dequote(&p);
4292 }
4293
4294 /* Now the retry rules. Keep the maximum timeout encountered. */
4295
4296 while (isspace(*p)) p++;
4297
4298 while (*p != 0)
4299 {
4300 retry_rule *rule = store_get(sizeof(retry_rule));
4301 *rchain = rule;
4302 rchain = &(rule->next);
4303 rule->next = NULL;
4304 rule->rule = toupper(*p++);
4305 rule->timeout = retry_arg(&p, 0);
4306 if (rule->timeout > retry_maximum_timeout)
4307 retry_maximum_timeout = rule->timeout;
4308
4309 switch (rule->rule)
4310 {
4311 case 'F': /* Fixed interval */
4312 rule->p1 = retry_arg(&p, 0);
4313 break;
4314
4315 case 'G': /* Geometrically increasing intervals */
4316 case 'H': /* Ditto, but with randomness */
4317 rule->p1 = retry_arg(&p, 0);
4318 rule->p2 = retry_arg(&p, 1);
4319 break;
4320
4321 default:
4322 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
4323 break;
4324 }
4325
4326 if (rule->timeout <= 0 || rule->p1 <= 0 ||
4327 (rule->rule != 'F' && rule->p2 < 1000))
4328 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4329 "bad parameters for retry rule");
4330
4331 while (isspace(*p)) p++;
4332 if (*p == ';')
4333 {
4334 p++;
4335 while (isspace(*p)) p++;
4336 }
4337 else if (*p != 0)
4338 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
4339 }
4340 }
4341 }
4342
4343
4344
4345 /*************************************************
4346 * Initialize authenticators *
4347 *************************************************/
4348
4349 static void
4350 readconf_options_auths(void)
4351 {
4352 struct auth_info * ai;
4353
4354 readconf_options_from_list(optionlist_auths, optionlist_auths_size, US"AUTHENTICATORS", NULL);
4355
4356 for (ai = auths_available; ai->driver_name[0]; ai++)
4357 {
4358 macro_create(string_sprintf("_DRIVER_AUTHENTICATOR_%T", ai->driver_name), US"y", FALSE, TRUE);
4359 readconf_options_from_list(ai->options, (unsigned)*ai->options_count, US"AUTHENTICATOR", ai->driver_name);
4360 }
4361 }
4362
4363
4364 /* Read the authenticators section of the configuration file.
4365
4366 Arguments: none
4367 Returns: nothing
4368 */
4369
4370 static void
4371 auths_init(void)
4372 {
4373 auth_instance *au, *bu;
4374
4375 readconf_driver_init(US"authenticator",
4376 (driver_instance **)(&auths), /* chain anchor */
4377 (driver_info *)auths_available, /* available drivers */
4378 sizeof(auth_info), /* size of info block */
4379 &auth_defaults, /* default values for generic options */
4380 sizeof(auth_instance), /* size of instance block */
4381 optionlist_auths, /* generic options */
4382 optionlist_auths_size);
4383
4384 for (au = auths; au; au = au->next)
4385 {
4386 if (!au->public_name)
4387 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
4388 "the %s authenticator", au->name);
4389
4390 for (bu = au->next; bu; bu = bu->next)
4391 if (strcmpic(au->public_name, bu->public_name) == 0)
4392 if ((au->client && bu->client) || (au->server && bu->server))
4393 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
4394 "(%s and %s) have the same public name (%s)",
4395 au->client ? US"client" : US"server", au->name, bu->name,
4396 au->public_name);
4397 }
4398 }
4399
4400
4401
4402
4403 /*************************************************
4404 * Read ACL information *
4405 *************************************************/
4406
4407 /* If this run of Exim is not doing something that involves receiving a
4408 message, we can just skip over the ACL information. No need to parse it.
4409
4410 First, we have a function for acl_read() to call back to get the next line. We
4411 need to remember the line we passed, because at the end it will contain the
4412 name of the next ACL. */
4413
4414 static uschar *acl_line;
4415
4416 static uschar *
4417 acl_callback(void)
4418 {
4419 acl_line = get_config_line();
4420 return acl_line;
4421 }
4422
4423
4424 /* Now the main function:
4425
4426 Arguments: none
4427 Returns: nothing
4428 */
4429
4430 static void
4431 readconf_acl(void)
4432 {
4433 uschar *p;
4434
4435 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
4436 between ACLs. */
4437
4438 acl_line = get_config_line();
4439
4440 while(acl_line != NULL)
4441 {
4442 uschar name[64];
4443 tree_node *node;
4444 uschar *error;
4445
4446 p = readconf_readname(name, sizeof(name), acl_line);
4447 if (isupper(*name) && *p == '=')
4448 {
4449 read_macro_assignment(acl_line);
4450 acl_line = get_config_line();
4451 continue;
4452 }
4453
4454 if (*p != ':' || name[0] == 0)
4455 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
4456
4457 node = store_get(sizeof(tree_node) + Ustrlen(name));
4458 Ustrcpy(node->name, name);
4459 if (!tree_insertnode(&acl_anchor, node))
4460 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4461 "there are two ACLs called \"%s\"", name);
4462
4463 node->data.ptr = acl_read(acl_callback, &error);
4464
4465 if (node->data.ptr == NULL && error != NULL)
4466 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
4467 }
4468 }
4469
4470
4471
4472 /*************************************************
4473 * Read configuration for local_scan() *
4474 *************************************************/
4475
4476 /* This function is called after "begin local_scan" is encountered in the
4477 configuration file. If the local_scan() function allows for configuration
4478 options, we can process them. Otherwise, we expire in a panic.
4479
4480 Arguments: none
4481 Returns: nothing
4482 */
4483
4484 static void
4485 local_scan_init(void)
4486 {
4487 #ifndef LOCAL_SCAN_HAS_OPTIONS
4488 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
4489 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
4490 #else
4491
4492 uschar *p;
4493 while ((p = get_config_line()) != NULL)
4494 {
4495 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
4496 NULL, US"local_scan option \"%s\" unknown");
4497 }
4498 #endif
4499 }
4500
4501
4502
4503 /*************************************************
4504 * Read rest of configuration (after main) *
4505 *************************************************/
4506
4507 /* This function reads the rest of the runtime configuration, after the main
4508 configuration. It is called only when actually needed. Each subsequent section
4509 of the configuration starts with a line of the form
4510
4511 begin name
4512
4513 where the name is "routers", "transports", etc. A section is terminated by
4514 hitting the next "begin" line, and the next name is left in next_section.
4515 Because it may confuse people as to whether the names are singular or plural,
4516 we add "s" if it's missing. There is always enough room in next_section for
4517 this. This function is basically just a switch.
4518
4519 Arguments: none
4520 Returns: nothing
4521 */
4522
4523 static uschar *section_list[] = {
4524 US"acls",
4525 US"authenticators",
4526 US"local_scans",
4527 US"retrys",
4528 US"rewrites",
4529 US"routers",
4530 US"transports"};
4531
4532 void
4533 readconf_rest(void)
4534 {
4535 int had = 0;
4536
4537 while(next_section[0] != 0)
4538 {
4539 int bit;
4540 int first = 0;
4541 int last = sizeof(section_list) / sizeof(uschar *);
4542 int mid = last/2;
4543 int n = Ustrlen(next_section);
4544
4545 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
4546
4547 for (;;)
4548 {
4549 int c = strcmpic(next_section, section_list[mid]);
4550 if (c == 0) break;
4551 if (c > 0) first = mid + 1; else last = mid;
4552 if (first >= last)
4553 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4554 "\"%.*s\" is not a known configuration section name", n, next_section);
4555 mid = (last + first)/2;
4556 }
4557
4558 bit = 1 << mid;
4559 if (((had ^= bit) & bit) == 0)
4560 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
4561 "\"%.*s\" section is repeated in the configuration file", n,
4562 next_section);
4563
4564 switch(mid)
4565 {
4566 case 0: readconf_acl(); break;
4567 case 1: auths_init(); break;
4568 case 2: local_scan_init(); break;
4569 case 3: readconf_retries(); break;
4570 case 4: readconf_rewrites(); break;
4571 case 5: route_init(); break;
4572 case 6: transport_init(); break;
4573 }
4574 }
4575
4576 (void)fclose(config_file);
4577 }
4578
4579 /* Init the storage for the pre-parsed config lines */
4580 void
4581 readconf_save_config(const uschar *s)
4582 {
4583 save_config_line(string_sprintf("# Exim Configuration (%s)",
4584 running_in_test_harness ? US"X" : s));
4585 }
4586
4587 static void
4588 save_config_position(const uschar *file, int line)
4589 {
4590 save_config_line(string_sprintf("# %d \"%s\"", line, file));
4591 }
4592
4593 /* Append a pre-parsed logical line to the config lines store,
4594 this operates on a global (static) list that holds all the pre-parsed
4595 config lines, we do no further processing here, output formatting and
4596 honouring of <hide> or macros will be done during output */
4597 static void
4598 save_config_line(const uschar* line)
4599 {
4600 static config_line_item *current;
4601 config_line_item *next;
4602
4603 next = (config_line_item*) store_get(sizeof(config_line_item));
4604 next->line = string_copy(line);
4605 next->next = NULL;
4606
4607 if (!config_lines) config_lines = next;
4608 else current->next = next;
4609
4610 current = next;
4611 }
4612
4613 /* List the parsed config lines, care about nice formatting and
4614 hide the <hide> values unless we're the admin user */
4615 void
4616 print_config(BOOL admin, BOOL terse)
4617 {
4618 config_line_item *i;
4619 const int TS = terse ? 0 : 2;
4620 int indent = 0;
4621
4622 for (i = config_lines; i; i = i->next)
4623 {
4624 uschar *current;
4625 uschar *p;
4626
4627 /* skip over to the first non-space */
4628 for (current = i->line; *current && isspace(*current); ++current)
4629 ;
4630
4631 if (*current == '\0')
4632 continue;
4633
4634 /* Collapse runs of spaces. We stop this if we encounter one of the
4635 * following characters: "'$, as this may indicate careful formatting */
4636 for (p = current; *p; ++p)
4637 {
4638 uschar *next;
4639 if (!isspace(*p)) continue;
4640 if (*p != ' ') *p = ' ';
4641
4642 for (next = p; isspace(*next); ++next)
4643 ;
4644
4645 if (next - p > 1)
4646 memmove(p+1, next, Ustrlen(next)+1);
4647
4648 if (*next == '"' || *next == '\'' || *next == '$')
4649 break;
4650 }
4651
4652 /* # lines */
4653 if (current[0] == '#')
4654 puts(CCS current);
4655
4656 /* begin lines are left aligned */
4657 else if (Ustrncmp(current, "begin", 5) == 0 && isspace(current[5]))
4658 {
4659 if (!terse) puts("");
4660 puts(CCS current);
4661 indent = TS;
4662 }
4663
4664 /* router/acl/transport block names */
4665 else if (current[Ustrlen(current)-1] == ':' && !Ustrchr(current, '='))
4666 {
4667 if (!terse) puts("");
4668 printf("%*s%s\n", TS, "", current);
4669 indent = 2 * TS;
4670 }
4671
4672 /* hidden lines (all MACROS or lines prefixed with "hide") */
4673 else if ( !admin
4674 && ( isupper(*current)
4675 || Ustrncmp(current, "hide", 4) == 0 && isspace(current[4])
4676 )
4677 )
4678 {
4679 if ((p = Ustrchr(current, '=')))
4680 {
4681 *p = '\0';
4682 printf("%*s%s= %s\n", indent, "", current, hidden);
4683 }
4684 /* e.g.: hide split_spool_directory */
4685 else
4686 printf("%*s\n", indent, hidden);
4687 }
4688
4689 else
4690 /* rest is public */
4691 printf("%*s%s\n", indent, "", current);
4692 }
4693 }
4694
4695 /* vi: aw ai sw=2
4696 */
4697 /* End of readconf.c */
Unnamed repository; edit this file 'description' to name the repository.