projects / exim.git / blob
? search:


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