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