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