projects / exim.git / blob
? search:


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