1 /* $Cambridge: exim/src/src/readconf.c,v 1.7 2005/04/05 13:58:35 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
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. */
16 #define CSTATE_STACK_SIZE 10
19 /* Structure for chain (stack) of .included files */
21 typedef struct config_file_item {
22 struct config_file_item *next;
28 /* Structure of table of conditional words and their state transitions */
30 typedef struct cond_item {
38 /* Structure of table of syslog facility names and values */
40 typedef struct syslog_fac_item {
46 /* Static variables */
48 static config_file_item *config_file_stack = NULL; /* For includes */
50 static uschar *syslog_facility_str = NULL;
51 static uschar next_section[24];
52 static uschar time_buffer[24];
54 /* State variables for conditional loading (.ifdef / .else / .endif) */
56 static int cstate = 0;
57 static int cstate_stack_ptr = -1;
58 static int cstate_stack[CSTATE_STACK_SIZE];
60 /* Table of state transitions for handling conditional inclusions. There are
61 four possible state transitions:
65 .elifdef true (or .else)
68 .endif just causes the previous cstate to be popped off the stack */
70 static int next_cstate[3][4] =
72 /* State 0: reading from file, or reading until next .else or .endif */
74 /* State 1: condition failed, skipping until next .else or .endif */
76 /* State 2: skipping until .endif */
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:
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
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 }
99 static int cond_list_size = sizeof(cond_list)/sizeof(cond_item);
101 /* Table of syslog facility names and their values */
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 }
119 static int syslog_list_size = sizeof(syslog_list)/sizeof(syslog_fac_item);
124 /*************************************************
125 * Main configuration options *
126 *************************************************/
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. */
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 },
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 },
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 },
156 { "acl_smtp_starttls", opt_stringptr, &acl_smtp_starttls },
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 },
168 { "bi_command", opt_stringptr, &bi_command },
169 #ifdef EXPERIMENTAL_BRIGHTMAIL
170 { "bmi_config_file", opt_stringptr, &bmi_config_file },
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 { "delay_warning", opt_timelist, &delay_warning },
190 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
191 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
192 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
193 { "delivery_date_remove", opt_bool, &delivery_date_remove },
194 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
195 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
196 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
197 { "dns_retrans", opt_time, &dns_retrans },
198 { "dns_retry", opt_int, &dns_retry },
199 /* This option is now a no-op, retained for compability */
200 { "drop_cr", opt_bool, &drop_cr },
201 /*********************************************************/
202 { "envelope_to_remove", opt_bool, &envelope_to_remove },
203 { "errors_copy", opt_stringptr, &errors_copy },
204 { "errors_reply_to", opt_stringptr, &errors_reply_to },
205 { "exim_group", opt_gid, &exim_gid },
206 { "exim_path", opt_stringptr, &exim_path },
207 { "exim_user", opt_uid, &exim_uid },
208 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
209 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
210 { "finduser_retries", opt_int, &finduser_retries },
211 { "freeze_tell", opt_stringptr, &freeze_tell },
212 { "gecos_name", opt_stringptr, &gecos_name },
213 { "gecos_pattern", opt_stringptr, &gecos_pattern },
214 { "header_line_maxsize", opt_int, &header_line_maxsize },
215 { "header_maxsize", opt_int, &header_maxsize },
216 { "headers_charset", opt_stringptr, &headers_charset },
217 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
218 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
219 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
220 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
221 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
222 { "hold_domains", opt_stringptr, &hold_domains },
223 { "host_lookup", opt_stringptr, &host_lookup },
224 { "host_lookup_order", opt_stringptr, &host_lookup_order },
225 { "host_reject_connection", opt_stringptr, &host_reject_connection },
226 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
227 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
229 { "ibase_servers", opt_stringptr, &ibase_servers },
231 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
232 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
233 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
234 { "keep_malformed", opt_time, &keep_malformed },
236 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
237 { "ldap_version", opt_int, &eldap_version },
239 { "local_from_check", opt_bool, &local_from_check },
240 { "local_from_prefix", opt_stringptr, &local_from_prefix },
241 { "local_from_suffix", opt_stringptr, &local_from_suffix },
242 { "local_interfaces", opt_stringptr, &local_interfaces },
243 { "local_scan_timeout", opt_time, &local_scan_timeout },
244 { "local_sender_retain", opt_bool, &local_sender_retain },
245 { "localhost_number", opt_stringptr, &host_number_string },
246 { "log_file_path", opt_stringptr, &log_file_path },
247 { "log_selector", opt_stringptr, &log_selector_string },
248 { "log_timezone", opt_bool, &log_timezone },
249 { "lookup_open_max", opt_int, &lookup_open_max },
250 { "max_username_length", opt_int, &max_username_length },
251 { "message_body_visible", opt_mkint, &message_body_visible },
252 { "message_id_header_domain", opt_stringptr, &message_id_domain },
253 { "message_id_header_text", opt_stringptr, &message_id_text },
254 { "message_logs", opt_bool, &message_logs },
255 { "message_size_limit", opt_stringptr, &message_size_limit },
256 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
257 { "move_frozen_messages", opt_bool, &move_frozen_messages },
259 { "mua_wrapper", opt_bool, &mua_wrapper },
261 { "mysql_servers", opt_stringptr, &mysql_servers },
263 { "never_users", opt_uidlist, &never_users },
265 { "oracle_servers", opt_stringptr, &oracle_servers },
267 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
269 { "perl_at_start", opt_bool, &opt_perl_at_start },
270 { "perl_startup", opt_stringptr, &opt_perl_startup },
273 { "pgsql_servers", opt_stringptr, &pgsql_servers },
275 { "pid_file_path", opt_stringptr, &pid_file_path },
276 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
277 { "preserve_message_logs", opt_bool, &preserve_message_logs },
278 { "primary_hostname", opt_stringptr, &primary_hostname },
279 { "print_topbitchars", opt_bool, &print_topbitchars },
280 { "process_log_path", opt_stringptr, &process_log_path },
281 { "prod_requires_admin", opt_bool, &prod_requires_admin },
282 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
283 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
284 { "queue_domains", opt_stringptr, &queue_domains },
285 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
286 { "queue_only", opt_bool, &queue_only },
287 { "queue_only_file", opt_stringptr, &queue_only_file },
288 { "queue_only_load", opt_fixed, &queue_only_load },
289 { "queue_only_override", opt_bool, &queue_only_override },
290 { "queue_run_in_order", opt_bool, &queue_run_in_order },
291 { "queue_run_max", opt_int, &queue_run_max },
292 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
293 { "receive_timeout", opt_time, &receive_timeout },
294 { "received_header_text", opt_stringptr, &received_header_text },
295 { "received_headers_max", opt_int, &received_headers_max },
296 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
297 { "recipients_max", opt_int, &recipients_max },
298 { "recipients_max_reject", opt_bool, &recipients_max_reject },
299 { "remote_max_parallel", opt_int, &remote_max_parallel },
300 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
301 { "retry_data_expire", opt_time, &retry_data_expire },
302 { "retry_interval_max", opt_time, &retry_interval_max },
303 { "return_path_remove", opt_bool, &return_path_remove },
304 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
305 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
306 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
307 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
308 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
309 { "smtp_accept_max", opt_int, &smtp_accept_max },
310 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
311 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
312 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
313 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
314 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
315 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
316 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
317 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
318 { "smtp_banner", opt_stringptr, &smtp_banner },
319 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
320 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
321 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
322 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
323 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
324 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
325 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
326 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
327 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
328 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
329 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
330 { "smtp_receive_timeout", opt_time, &smtp_receive_timeout },
331 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
332 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
333 #ifdef WITH_CONTENT_SCAN
334 { "spamd_address", opt_stringptr, &spamd_address },
336 { "split_spool_directory", opt_bool, &split_spool_directory },
337 { "spool_directory", opt_stringptr, &spool_directory },
338 #ifdef EXPERIMENTAL_SRS
339 { "srs_config", opt_stringptr, &srs_config },
341 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
342 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
343 { "syslog_duplication", opt_bool, &syslog_duplication },
344 { "syslog_facility", opt_stringptr, &syslog_facility_str },
345 { "syslog_processname", opt_stringptr, &syslog_processname },
346 { "syslog_timestamp", opt_bool, &syslog_timestamp },
347 { "system_filter", opt_stringptr, &system_filter },
348 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
349 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
350 { "system_filter_group", opt_gid, &system_filter_gid },
351 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
352 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
353 { "system_filter_user", opt_uid, &system_filter_uid },
354 { "tcp_nodelay", opt_bool, &tcp_nodelay },
355 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
356 { "timezone", opt_stringptr, &timezone_string },
358 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
359 { "tls_certificate", opt_stringptr, &tls_certificate },
360 { "tls_crl", opt_stringptr, &tls_crl },
361 { "tls_dhparam", opt_stringptr, &tls_dhparam },
362 { "tls_on_connect_ports", opt_stringptr, &tls_on_connect_ports },
363 { "tls_privatekey", opt_stringptr, &tls_privatekey },
364 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
365 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
366 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
367 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
368 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
370 { "trusted_groups", opt_gidlist, &trusted_groups },
371 { "trusted_users", opt_uidlist, &trusted_users },
372 { "unknown_login", opt_stringptr, &unknown_login },
373 { "unknown_username", opt_stringptr, &unknown_username },
374 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
375 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
376 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
377 { "warn_message_file", opt_stringptr, &warn_message_file },
378 { "write_rejectlog", opt_bool, &write_rejectlog }
381 static int optionlist_config_size =
382 sizeof(optionlist_config)/sizeof(optionlist);
386 /*************************************************
387 * Find the name of an option *
388 *************************************************/
390 /* This function is to aid debugging. Various functions take arguments that are
391 pointer variables in the options table or in option tables for various drivers.
392 For debugging output, it is useful to be able to find the name of the option
393 which is currently being processed. This function finds it, if it exists, by
394 searching the table(s).
396 Arguments: a value that is presumed to be in the table above
397 Returns: the option name, or an empty string
401 readconf_find_option(void *p)
405 transport_instance *t;
407 for (i = 0; i < optionlist_config_size; i++)
408 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
410 for (r = routers; r != NULL; r = r->next)
412 router_info *ri = r->info;
413 for (i = 0; i < ri->options_count[0]; i++)
415 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
416 if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
417 return US ri->options[i].name;
421 for (t = transports; t != NULL; t = t->next)
423 transport_info *ti = t->info;
424 for (i = 0; i < ti->options_count[0]; i++)
426 if ((ti->options[i].type & opt_mask) != opt_stringptr) continue;
427 if (p == (char *)(t->options_block) + (long int)(ti->options[i].value))
428 return US ti->options[i].name;
438 /*************************************************
439 * Deal with an assignment to a macro *
440 *************************************************/
442 /* This function is called when a line that starts with an upper case letter is
443 encountered. The argument "line" should contain a complete logical line, and
444 start with the first letter of the macro name. The macro name and the
445 replacement text are extracted and stored. Redefinition of existing,
446 non-command line, macros is permitted using '==' instead of '='.
449 s points to the start of the logical line
455 read_macro_assignment(uschar *s)
461 macro_item *mlast = NULL;
463 while (isalnum(*s) || *s == '_')
465 if (namelen >= sizeof(name) - 1)
466 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
467 "macro name too long (maximum is %d characters)", sizeof(name) - 1);
468 name[namelen++] = *s++;
472 while (isspace(*s)) s++;
474 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
481 while (isspace(*s)) s++;
483 /* If an existing macro of the same name was defined on the command line, we
484 just skip this definition. It's an error to attempt to redefine a macro without
485 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
486 It is also an error to define a macro whose name begins with the name of a
487 previously defined macro. Note: it is documented that the other way round
490 for (m = macros; m != NULL; m = m->next)
492 int len = Ustrlen(m->name);
494 if (Ustrcmp(m->name, name) == 0)
496 if (!m->command_line && !redef)
497 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
498 "defined (use \"==\" if you want to redefine it", name);
502 if (len < namelen && Ustrstr(name, m->name) != NULL)
503 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
504 "a macro because previously defined macro \"%s\" is a substring",
507 /* We cannot have this test, because it is documented that a substring
508 macro is permitted (there is even an example).
510 * if (len > namelen && Ustrstr(m->name, name) != NULL)
511 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
512 * "a macro because it is a substring of previously defined macro \"%s\"",
519 /* Check for an overriding command-line definition. */
521 if (m != NULL && m->command_line) return;
523 /* Redefinition must refer to an existing macro. */
528 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
532 /* We have a new definition. The macro_item structure includes a final vector
533 called "name" which is one byte long. Thus, adding "namelen" gives us enough
534 room to store the "name" string. */
538 m = store_get(sizeof(macro_item) + namelen);
539 if (macros == NULL) macros = m; else mlast->next = m;
540 Ustrncpy(m->name, name, namelen);
541 m->name[namelen] = 0;
543 m->command_line = FALSE;
546 /* Set the value of the new or redefined macro */
548 m->replacement = string_copy(s);
555 /*************************************************
556 * Read configuration line *
557 *************************************************/
559 /* A logical line of text is read from the configuration file into the big
560 buffer, taking account of macros, .includes, and continuations. The size of
561 big_buffer is increased if necessary. The count of configuration lines is
562 maintained. Physical input lines starting with # (ignoring leading white space,
563 and after macro replacement) and empty logical lines are always ignored.
564 Leading and trailing spaces are removed.
566 If we hit a line of the form "begin xxxx", the xxxx is placed in the
567 next_section vector, and the function returns NULL, indicating the end of a
568 configuration section. On end-of-file, NULL is returned with next_section
573 Returns: a pointer to the first non-blank in the line,
574 or NULL if eof or end of section is reached
578 get_config_line(void)
580 int startoffset = 0; /* To first non-blank char in logical line */
581 int len = 0; /* Of logical line so far */
587 /* Loop for handling continuation lines, skipping comments, and dealing with
592 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
594 if (config_file_stack != NULL) /* EOF inside .include */
597 config_file = config_file_stack->file;
598 config_filename = config_file_stack->filename;
599 config_lineno = config_file_stack->lineno;
600 config_file_stack = config_file_stack->next;
604 /* EOF at top level */
606 if (cstate_stack_ptr >= 0)
607 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
608 "Unexpected end of configuration file: .endif missing");
610 if (len != 0) break; /* EOF after continuation */
611 next_section[0] = 0; /* EOF at start of logical line */
616 newlen = len + Ustrlen(big_buffer + len);
618 /* Handle pathologically long physical lines - yes, it did happen - by
619 extending big_buffer at this point. The code also copes with very long
622 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
625 big_buffer_size += BIG_BUFFER_SIZE;
626 newbuffer = store_malloc(big_buffer_size);
628 /* This use of strcpy is OK because we know that the string in the old
629 buffer is shorter than the new buffer. */
631 Ustrcpy(newbuffer, big_buffer);
632 store_free(big_buffer);
633 big_buffer = newbuffer;
634 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
636 newlen += Ustrlen(big_buffer + newlen);
639 /* Find the true start of the physical line - leading spaces are always
642 ss = big_buffer + len;
643 while (isspace(*ss)) ss++;
645 /* Process the physical line for macros. If this is the start of the logical
646 line, skip over initial text at the start of the line if it starts with an
647 upper case character followed by a sequence of name characters and an equals
648 sign, because that is the definition of a new macro, and we don't do
649 replacement therein. */
652 if (len == 0 && isupper(*s))
654 while (isalnum(*s) || *s == '_') s++;
655 while (isspace(*s)) s++;
656 if (*s != '=') s = ss; /* Not a macro definition */
659 /* For each defined macro, scan the line (from after XXX= if present),
660 replacing all occurrences of the macro. */
663 for (m = macros; m != NULL; m = m->next)
668 while ((p = Ustrstr(t, m->name)) != NULL)
671 int namelen = Ustrlen(m->name);
672 int replen = Ustrlen(m->replacement);
674 /* Expand the buffer if necessary */
676 while (newlen - namelen + replen + 1 > big_buffer_size)
678 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
679 uschar *newbuffer = store_malloc(newsize);
680 memcpy(newbuffer, big_buffer, newlen + 1);
681 p = newbuffer + (p - big_buffer);
682 s = newbuffer + (s - big_buffer);
683 ss = newbuffer + (ss - big_buffer);
684 t = newbuffer + (t - big_buffer);
685 big_buffer_size = newsize;
686 store_free(big_buffer);
687 big_buffer = newbuffer;
690 /* Shuffle the remaining characters up or down in the buffer before
691 copying in the replacement text. Don't rescan the replacement for this
695 moveby = replen - namelen;
698 memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
701 Ustrncpy(p, m->replacement, replen);
707 /* An empty macro replacement at the start of a line could mean that ss no
708 longer points to the first non-blank character. */
710 while (isspace(*ss)) ss++;
712 /* Check for comment lines - these are physical lines. */
714 if (*ss == '#') continue;
716 /* Handle conditionals, which are also applied to physical lines. Conditions
717 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
718 expansion occured on the rest of the line. A preliminary test for the leading
719 '.' saves effort on most lines. */
725 /* Search the list of conditional directives */
727 for (i = 0; i < cond_list_size; i++)
730 cond_item *c = cond_list+i;
731 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
733 /* The following character must be white space or end of string */
735 n = ss[1 + c->namelen];
736 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
738 /* .ifdef and .ifndef push the current state onto the stack, then set
739 a new one from the table. Stack overflow is an error */
743 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
744 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
745 ".%s nested too deeply", c->name);
746 cstate_stack[++cstate_stack_ptr] = cstate;
747 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
750 /* For any of the others, stack underflow is an error. The next state
751 comes either from the stack (.endif) or from the table. */
755 if (cstate_stack_ptr < 0)
756 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
757 ".%s without matching .ifdef", c->name);
758 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
759 next_cstate[cstate][macro_found? c->action1 : c->action2];
762 /* Having dealt with a directive, break the loop */
767 /* If we have handled a conditional directive, continue with the next
768 physical line. Otherwise, fall through. */
770 if (i < cond_list_size) continue;
773 /* If the conditional state is not 0 (actively using these lines), ignore
776 if (cstate != 0) continue; /* Conditional skip */
778 /* Handle .include lines - these are also physical lines. */
780 if (Ustrncmp(ss, ".include", 8) == 0 &&
782 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
785 int include_if_exists = isspace(ss[8])? 0 : 10;
786 config_file_item *save;
789 ss += 9 + include_if_exists;
790 while (isspace(*ss)) ss++;
791 t = ss + Ustrlen(ss);
792 while (t > ss && isspace(t[-1])) t--;
793 if (*ss == '\"' && t[-1] == '\"')
800 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
802 save = store_get(sizeof(config_file_item));
803 save->next = config_file_stack;
804 config_file_stack = save;
805 save->file = config_file;
806 save->filename = config_filename;
807 save->lineno = config_lineno;
809 config_file = Ufopen(ss, "rb");
810 if (config_file == NULL)
811 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
812 "configuration file %s", ss);
813 config_filename = string_copy(ss);
818 /* If this is the start of the logical line, remember where the non-blank
819 data starts. Otherwise shuffle down continuation lines to remove leading
823 startoffset = ss - big_buffer;
826 s = big_buffer + len;
829 memmove(s, ss, (newlen - len) - (ss - s) + 1);
834 /* Accept the new addition to the line. Remove trailing white space. */
837 while (len > 0 && isspace(big_buffer[len-1])) len--;
840 /* We are done if the line does not end in backslash and contains some data.
841 Empty logical lines are ignored. For continuations, remove the backslash and
842 go round the loop to read the continuation line. */
846 if (big_buffer[len-1] != '\\') break; /* End of logical line */
847 big_buffer[--len] = 0; /* Remove backslash */
849 } /* Loop for reading multiple physical lines */
851 /* We now have a logical line. Test for the end of a configuration section (or,
852 more accurately, for the start of the next section). Place the name of the next
853 section in next_section, and return NULL. If the name given is longer than
854 next_section, truncate it. It will be unrecognized later, because all the known
855 section names do fit. Leave space for pluralizing. */
857 s = big_buffer + startoffset; /* First non-space character */
858 if (strncmpic(s, US"begin ", 6) == 0)
861 while (isspace(*s)) s++;
862 if (big_buffer + len - s > sizeof(next_section) - 2)
863 s[sizeof(next_section) - 2] = 0;
864 Ustrcpy(next_section, s);
868 /* Return the first non-blank character. */
875 /*************************************************
877 *************************************************/
879 /* The yield is the pointer to the next uschar. Names longer than the
880 output space are silently truncated. This function is also used from acl.c when
884 name where to put the name
888 Returns: new input pointer
892 readconf_readname(uschar *name, int len, uschar *s)
895 while (isspace(*s)) s++;
898 while (isalnum(*s) || *s == '_')
900 if (p < len-1) name[p++] = *s;
905 while (isspace(*s)) s++;
912 /*************************************************
913 * Read a time value *
914 *************************************************/
916 /* This function is also called from outside, to read argument
917 time values. The format of a time value is:
919 [<n>w][<n>d][<n>h][<n>m][<n>s]
921 as long as at least one is present. If a format error is encountered,
922 return a negative value. The value must be terminated by the given
927 terminator required terminating character
928 return_msec if TRUE, allow fractional seconds and return milliseconds
930 Returns: the time value, or -1 on syntax error
931 value is seconds if return_msec is FALSE
932 value is milliseconds if return_msec is TRUE
936 readconf_readtime(uschar *s, int terminator, BOOL return_msec)
944 if (!isdigit(*s)) return -1;
945 (void)sscanf(CS s, "%d%n", &value, &count);
950 case 'w': value *= 7;
951 case 'd': value *= 24;
952 case 'h': value *= 60;
953 case 'm': value *= 60;
958 if (!return_msec) return -1;
959 (void)sscanf(CS s, "%lf%n", &fraction, &count);
961 if (*s++ != 's') return -1;
962 yield += (int)(fraction * 1000.0);
968 if (return_msec) value *= 1000;
970 if (*s == terminator) return yield;
972 /* Control never reaches here. */
977 /*************************************************
978 * Read a fixed point value *
979 *************************************************/
981 /* The value is returned *1000
985 terminator required terminator
987 Returns: the value, or -1 on error
991 readconf_readfixed(uschar *s, int terminator)
995 if (!isdigit(*s)) return -1;
996 (void)sscanf(CS s, "%d%n", &value, &count);
998 yield = value * 1000;
1002 while (isdigit((*(++s))))
1004 yield += (*s - '0') * m;
1009 return (*s == terminator)? yield : (-1);
1014 /*************************************************
1015 * Find option in list *
1016 *************************************************/
1018 /* The lists are always in order, so binary chop can be used.
1021 name the option name to search for
1022 ol the first entry in the option list
1023 last one more than the offset of the last entry in the option list
1025 Returns: pointer to an option entry, or NULL if not found
1029 find_option(uschar *name, optionlist *ol, int last)
1032 while (last > first)
1034 int middle = (first + last)/2;
1035 int c = Ustrcmp(name, ol[middle].name);
1036 if (c == 0) return ol + middle;
1037 else if (c > 0) first = middle + 1;
1045 /*************************************************
1046 * Find a set flag in option list *
1047 *************************************************/
1049 /* Because some versions of Unix make no restrictions on the values of uids and
1050 gids (even negative ones), we cannot represent "unset" by a special value.
1051 There is therefore a separate boolean variable for each one indicating whether
1052 a value is set or not. This function returns a pointer to the boolean, given
1053 the original option name. It is a major disaster if the flag cannot be found.
1056 name the name of the uid or gid option
1057 oltop points to the start of the relevant option list
1058 last one more than the offset of the last item in the option list
1059 data_block NULL when reading main options => data values in the option
1060 list are absolute addresses; otherwise they are byte offsets
1061 in data_block (used for driver options)
1063 Returns: a pointer to the boolean flag.
1067 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1071 sprintf(CS name2, "*set_%.50s", name);
1072 ol = find_option(name2, oltop, last);
1073 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1074 "Exim internal error: missing set flag for %s", name);
1075 return (data_block == NULL)? (BOOL *)(ol->value) :
1076 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1082 /*************************************************
1083 * Output extra characters message and die *
1084 *************************************************/
1086 /* Called when an option line has junk on the end. Sometimes this is because
1087 the sysadmin thinks comments are permitted.
1090 s points to the extra characters
1091 t1..t3 strings to insert in the log message
1093 Returns: doesn't return; dies
1097 extra_chars_error(uschar *s, uschar *t1, uschar *t2, uschar *t3)
1099 uschar *comment = US"";
1100 if (*s == '#') comment = US" (# is comment only at line start)";
1101 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1102 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1107 /*************************************************
1108 * Read rewrite information *
1109 *************************************************/
1111 /* Each line of rewrite information contains:
1113 . A complete address in the form user@domain, possibly with
1114 leading * for each part; or alternatively, a regex.
1116 . A replacement string (which will be expanded).
1118 . An optional sequence of one-letter flags, indicating which
1119 headers etc. to apply this rule to.
1121 All this is decoded and placed into a control block. The OR of the flags is
1122 maintained in a common word.
1125 p points to the string that makes up the rule
1126 existflags points to the overall flag word
1127 isglobal TRUE if reading global rewrite rules
1129 Returns: the control block for the parsed rule.
1132 static rewrite_rule *
1133 readconf_one_rewrite(uschar *p, int *existflags, BOOL isglobal)
1135 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1138 next->key = string_dequote(&p);
1140 while (isspace(*p)) p++;
1142 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1143 "missing rewrite replacement string");
1146 next->replacement = string_dequote(&p);
1148 while (*p != 0) switch (*p++)
1150 case ' ': case '\t': break;
1152 case 'q': next->flags |= rewrite_quit; break;
1153 case 'w': next->flags |= rewrite_whole; break;
1155 case 'h': next->flags |= rewrite_all_headers; break;
1156 case 's': next->flags |= rewrite_sender; break;
1157 case 'f': next->flags |= rewrite_from; break;
1158 case 't': next->flags |= rewrite_to; break;
1159 case 'c': next->flags |= rewrite_cc; break;
1160 case 'b': next->flags |= rewrite_bcc; break;
1161 case 'r': next->flags |= rewrite_replyto; break;
1163 case 'E': next->flags |= rewrite_all_envelope; break;
1164 case 'F': next->flags |= rewrite_envfrom; break;
1165 case 'T': next->flags |= rewrite_envto; break;
1167 case 'Q': next->flags |= rewrite_qualify; break;
1168 case 'R': next->flags |= rewrite_repeat; break;
1171 next->flags |= rewrite_smtp;
1172 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1173 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1174 "rewrite rule has the S flag but is not a regular expression");
1178 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1179 "unknown rewrite flag character '%c' "
1180 "(could be missing quotes round replacement item)", p[-1]);
1184 /* If no action flags are set, set all the "normal" rewrites. */
1186 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1187 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1189 /* Remember which exist, for optimization, and return the rule */
1191 *existflags |= next->flags;
1198 /*************************************************
1199 * Read global rewrite information *
1200 *************************************************/
1202 /* Each line is a single rewrite rule; it is parsed into a control block
1203 by readconf_one_rewrite(), and its flags are ORed into the global flag
1204 word rewrite_existflags. */
1207 readconf_rewrites(void)
1209 rewrite_rule **chain = &global_rewrite_rules;
1212 while ((p = get_config_line()) != NULL)
1214 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1216 chain = &(next->next);
1222 /*************************************************
1224 *************************************************/
1226 /* Strings are read into the normal store pool. As long we aren't too
1227 near the end of the current block, the string will just use what is necessary
1228 on the top of the stacking pool, because string_cat() uses the extension
1232 s the rest of the input line
1233 name the option name (for errors)
1235 Returns: pointer to the string
1239 read_string(uschar *s, uschar *name)
1244 if (*s != '\"') return string_copy(s);
1247 yield = string_dequote(&s);
1249 if (s == ss+1 || s[-1] != '\"')
1250 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1251 "missing quote at end of string value for %s", name);
1253 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1259 /*************************************************
1260 * Handle option line *
1261 *************************************************/
1263 /* This function is called from several places to process a line containing the
1264 setting of an option. The first argument is the line to be decoded; it has been
1265 checked not to be empty and not to start with '#'. Trailing newlines and white
1266 space have been removed. The second argument is a pointer to the list of
1267 variable names that are to be recognized, together with their types and
1268 locations, and the third argument gives the number of entries in the list.
1270 The fourth argument is a pointer to a data block. If it is NULL, then the data
1271 values in the options list are absolute addresses. Otherwise, they are byte
1272 offsets in the data block.
1274 String option data may continue onto several lines; this function reads further
1275 data from config_file if necessary.
1277 The yield of this function is normally zero. If a string continues onto
1278 multiple lines, then the data value is permitted to be followed by a comma
1279 or a semicolon (for use in drivers) and the yield is that character.
1282 buffer contains the configuration line to be handled
1283 oltop points to the start of the relevant option list
1284 last one more than the offset of the last item in the option list
1285 data_block NULL when reading main options => data values in the option
1286 list are absolute addresses; otherwise they are byte offsets
1287 in data_block when they have opt_public set; otherwise
1288 they are byte offsets in data_block->options_block.
1289 unknown_txt format string to use in panic message for unknown option;
1290 must contain %s for option name
1291 if given as NULL, don't panic on unknown option
1293 Returns: TRUE if an option was read successfully,
1294 FALSE false for an unknown option if unknown_txt == NULL,
1295 otherwise panic and die on an unknown option
1299 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1300 void *data_block, uschar *unknown_txt)
1304 int n, count, type, value;
1308 BOOL boolvalue = TRUE;
1309 BOOL freesptr = TRUE;
1310 optionlist *ol, *ol2;
1314 uschar *inttype = US"";
1320 /* There may be leading spaces; thereafter, we expect an option name starting
1323 while (isspace(*s)) s++;
1325 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1327 /* Read the name of the option, and skip any subsequent white space. If
1328 it turns out that what we read was "hide", set the flag indicating that
1329 this is a secure option, and loop to read the next word. */
1331 for (n = 0; n < 2; n++)
1333 while (isalnum(*s) || *s == '_')
1335 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1339 while (isspace(*s)) s++;
1340 if (Ustrcmp(name, "hide") != 0) break;
1341 issecure = opt_secure;
1345 /* Deal with "no_" or "not_" here for booleans */
1347 if (Ustrncmp(name, "no_", 3) == 0)
1353 if (Ustrncmp(name, "not_", 4) == 0)
1359 /* Search the list for the given name. A non-existent name, or an option that
1360 is set twice, is a disaster. */
1362 ol = find_option(name + offset, oltop, last);
1366 if (unknown_txt == NULL) return FALSE;
1367 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1370 if ((ol->type & opt_set) != 0)
1372 uschar *mname = name;
1373 if (Ustrncmp(mname, "no_", 3) == 0) mname += 3;
1374 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1375 "\"%s\" option set for the second time", mname);
1378 ol->type |= opt_set | issecure;
1379 type = ol->type & opt_mask;
1381 /* Types with data values must be followed by '='; the "no[t]_" prefix
1382 applies only to boolean values. */
1384 if (type < opt_bool || type > opt_bool_last)
1387 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1388 "negation prefix applied to a non-boolean option");
1390 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1391 "unexpected end of line (data missing) after %s", name);
1393 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1396 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1397 true/false/yes/no, or, in the case of opt_expanded_bool, a general string that
1398 ultimately expands to one of those values. */
1400 else if (*s != 0 && (offset != 0 || *s != '='))
1401 extra_chars_error(s, US"boolean option ", name, US"");
1403 /* Skip white space after = */
1405 if (*s == '=') while (isspace((*(++s))));
1407 /* If there is a data block and the opt_public flag is not set, change
1408 the data block pointer to the private options block. */
1410 if (data_block != NULL && (ol->type & opt_public) == 0)
1411 data_block = (void *)(((driver_instance *)data_block)->options_block);
1413 /* Now get the data according to the type. */
1417 /* If a string value is not enclosed in quotes, it consists of
1418 the rest of the current line, verbatim. Otherwise, string escapes
1421 A transport is specified as a string, which is then looked up in the
1422 list of transports. A search type is specified as one of a number of
1425 A set or rewrite rules for a driver is specified as a string, which is
1426 then parsed into a suitable chain of control blocks.
1428 Uids and gids are specified as strings which are then looked up in the
1429 passwd file. Lists of uids and gids are similarly specified as colon-
1430 separated strings. */
1435 case opt_expand_uid:
1436 case opt_expand_gid:
1441 reset_point = sptr = read_string(s, name);
1443 /* Having read a string, we now have several different ways of using it,
1444 depending on the data type, so do another switch. If keeping the actual
1445 string is not required (because it is interpreted), freesptr is set TRUE,
1446 and at the end we reset the pool. */
1450 /* If this was a string, set the variable to point to the new string,
1451 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1452 rules, we still keep the string (for printing), and parse the rules into a
1453 control block and flags word. */
1457 if (data_block == NULL)
1458 *((uschar **)(ol->value)) = sptr;
1460 *((uschar **)((uschar *)data_block + (long int)(ol->value))) = sptr;
1462 if (type == opt_rewrite)
1467 rewrite_rule **chain;
1470 sprintf(CS name2, "*%.50s_rules", name);
1471 ol2 = find_option(name2, oltop, last);
1472 sprintf(CS name2, "*%.50s_flags", name);
1473 ol3 = find_option(name2, oltop, last);
1475 if (ol2 == NULL || ol3 == NULL)
1476 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1477 "rewrite rules not available for driver");
1479 if (data_block == NULL)
1481 chain = (rewrite_rule **)(ol2->value);
1482 flagptr = (int *)(ol3->value);
1486 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1487 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1490 while ((p = string_nextinlist(&sptr, &sep, big_buffer, BIG_BUFFER_SIZE))
1493 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1495 chain = &(next->next);
1498 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1499 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1500 "non-header rewrite - not allowed at transport time -");
1504 /* If it was an expanded uid, see if there is any expansion to be
1505 done by checking for the presence of a $ character. If there is, save it
1506 in the corresponding *expand_user option field. Otherwise, fall through
1507 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1510 case opt_expand_uid:
1511 sprintf(CS name2, "*expand_%.50s", name);
1512 ol2 = find_option(name2, oltop, last);
1515 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1517 if (data_block == NULL)
1518 *((uschar **)(ol2->value)) = ss;
1520 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1524 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1530 /* Look up a fixed uid, and also make use of the corresponding gid
1531 if a passwd entry is returned and the gid has not been set. */
1534 if (!route_finduser(sptr, &pw, &uid))
1535 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1536 if (data_block == NULL)
1537 *((uid_t *)(ol->value)) = uid;
1539 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1541 /* Set the flag indicating a fixed value is set */
1543 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1545 /* Handle matching gid if we have a passwd entry: done by finding the
1546 same name with terminating "user" changed to "group"; if not found,
1547 ignore. Also ignore if the value is already set. */
1549 if (pw == NULL) break;
1550 Ustrcpy(name+Ustrlen(name)-4, "group");
1551 ol2 = find_option(name, oltop, last);
1552 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1553 (ol2->type & opt_mask) == opt_expand_gid))
1555 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1558 if (data_block == NULL)
1559 *((gid_t *)(ol2->value)) = pw->pw_gid;
1561 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1567 /* If it was an expanded gid, see if there is any expansion to be
1568 done by checking for the presence of a $ character. If there is, save it
1569 in the corresponding *expand_user option field. Otherwise, fall through
1570 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1573 case opt_expand_gid:
1574 sprintf(CS name2, "*expand_%.50s", name);
1575 ol2 = find_option(name2, oltop, last);
1578 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1580 if (data_block == NULL)
1581 *((uschar **)(ol2->value)) = ss;
1583 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1587 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1593 /* Handle freestanding gid */
1596 if (!route_findgroup(sptr, &gid))
1597 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1598 if (data_block == NULL)
1599 *((gid_t *)(ol->value)) = gid;
1601 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1602 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1605 /* If it was a uid list, look up each individual entry, and build
1606 a vector of uids, with a count in the first element. Put the vector
1607 in malloc store so we can free the string. (We are reading into
1608 permanent store already.) */
1617 if (*p != 0) count++;
1618 while (*p != 0) if (*p++ == ':') count++;
1619 list = store_malloc(count*sizeof(uid_t));
1620 list[ptr++] = (uid_t)(count - 1);
1622 if (data_block == NULL)
1623 *((uid_t **)(ol->value)) = list;
1625 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1631 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1632 if (!route_finduser(big_buffer, NULL, &uid))
1633 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1640 /* If it was a gid list, look up each individual entry, and build
1641 a vector of gids, with a count in the first element. Put the vector
1642 in malloc store so we can free the string. (We are reading into permanent
1652 if (*p != 0) count++;
1653 while (*p != 0) if (*p++ == ':') count++;
1654 list = store_malloc(count*sizeof(gid_t));
1655 list[ptr++] = (gid_t)(count - 1);
1657 if (data_block == NULL)
1658 *((gid_t **)(ol->value)) = list;
1660 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1666 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1667 if (!route_findgroup(big_buffer, &gid))
1668 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1676 /* Release store if the value of the string doesn't need to be kept. */
1678 if (freesptr) store_reset(reset_point);
1681 /* Expanded boolean: if no characters follow, or if there are no dollar
1682 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1683 save the string for later expansion in the alternate place. */
1685 case opt_expand_bool:
1686 if (*s != 0 && Ustrchr(s, '$') != 0)
1688 sprintf(CS name2, "*expand_%.50s", name);
1689 ol2 = find_option(name2, oltop, last);
1692 reset_point = sptr = read_string(s, name);
1693 if (data_block == NULL)
1694 *((uschar **)(ol2->value)) = sptr;
1696 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1703 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1704 look for yes/not/true/false. Some booleans are stored in a single bit in
1705 a single int. There's a special fudge for verify settings; without a suffix
1706 they set both xx_sender and xx_recipient. The table points to the sender
1707 value; search subsequently for the recipient. There's another special case:
1708 opt_bool_set also notes when a boolean has been set. */
1712 case opt_bool_verify:
1716 s = readconf_readname(name2, 64, s);
1717 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1719 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1721 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1722 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1723 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1724 US"for boolean option ", name);
1727 /* Handle single-bit type. */
1729 if (type == opt_bit)
1731 int bit = 1 << ((ol->type >> 16) & 31);
1732 int *ptr = (data_block == NULL)?
1733 (int *)(ol->value) :
1734 (int *)((uschar *)data_block + (long int)ol->value);
1735 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1739 /* Handle full BOOL types */
1741 if (data_block == NULL)
1742 *((BOOL *)(ol->value)) = boolvalue;
1744 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1748 if (type == opt_bool_verify)
1750 sprintf(CS name2, "%.50s_recipient", name + offset);
1751 ol2 = find_option(name2, oltop, last);
1754 if (data_block == NULL)
1755 *((BOOL *)(ol2->value)) = boolvalue;
1757 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1761 /* Note that opt_bool_set type is set, if there is somewhere to do so */
1763 else if (type == opt_bool_set)
1765 sprintf(CS name2, "*set_%.50s", name + offset);
1766 ol2 = find_option(name2, oltop, last);
1769 if (data_block == NULL)
1770 *((BOOL *)(ol2->value)) = TRUE;
1772 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1781 inttype = US"octal ";
1783 /* Integer: a simple(ish) case; allow octal and hex formats, and
1784 suffixes K and M. The different types affect output, not input. */
1791 value = strtol(CS s, CSS &endptr, intbase);
1794 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1797 if (errno != ERANGE)
1799 if (tolower(*endptr) == 'k')
1801 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1805 else if (tolower(*endptr) == 'm')
1807 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
1809 else value *= 1024*1024;
1814 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1815 "absolute value of integer \"%s\" is too large (overflow)", s);
1817 while (isspace(*endptr)) endptr++;
1819 extra_chars_error(endptr, inttype, US"integer value for ", name);
1822 if (data_block == NULL)
1823 *((int *)(ol->value)) = value;
1825 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1828 /* Integer held in K: again, allow octal and hex formats, and suffixes K and
1835 value = strtol(CS s, CSS &endptr, intbase);
1838 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1841 if (errno != ERANGE)
1843 if (tolower(*endptr) == 'm')
1845 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1849 else if (tolower(*endptr) == 'k')
1855 value = (value + 512)/1024;
1859 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1860 "absolute value of integer \"%s\" is too large (overflow)", s);
1862 while (isspace(*endptr)) endptr++;
1864 extra_chars_error(endptr, inttype, US"integer value for ", name);
1867 if (data_block == NULL)
1868 *((int *)(ol->value)) = value;
1870 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1873 /* Fixed-point number: held to 3 decimal places. */
1876 if (sscanf(CS s, "%d%n", &value, &count) != 1)
1877 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1878 "fixed-point number expected for %s", name);
1880 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1881 "integer \"%s\" is too large (overflow)", s);
1885 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1886 "integer \"%s\" is too large (overflow)", s);
1888 if (s[count] == '.')
1891 while (isdigit(s[++count]))
1893 value += (s[count] - '0') * d;
1898 while (isspace(s[count])) count++;
1901 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
1903 if (data_block == NULL)
1904 *((int *)(ol->value)) = value;
1906 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1909 /* There's a special routine to read time values. */
1912 value = readconf_readtime(s, 0, FALSE);
1914 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1916 if (data_block == NULL)
1917 *((int *)(ol->value)) = value;
1919 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1922 /* A time list is a list of colon-separated times, with the first
1923 element holding the size of the list and the second the number of
1929 int *list = (data_block == NULL)?
1930 (int *)(ol->value) :
1931 (int *)((uschar *)data_block + (long int)(ol->value));
1933 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
1936 uschar *snext = Ustrchr(s, ':');
1940 while (ss > s && isspace(ss[-1])) ss--;
1943 value = readconf_readtime(s, terminator, FALSE);
1945 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1947 if (count > 1 && value <= list[count])
1948 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1949 "time value out of order for %s", name);
1950 list[count+1] = value;
1951 if (snext == NULL) break;
1953 while (isspace(*s)) s++;
1956 if (count > list[0] - 2)
1957 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
1959 if (count > 0 && list[2] == 0) count = 0;
1971 /*************************************************
1972 * Print a time value *
1973 *************************************************/
1976 Argument: a time value in seconds
1977 Returns: pointer to a fixed buffer containing the time as a string,
1978 in readconf_readtime() format
1982 readconf_printtime(int t)
1985 uschar *p = time_buffer;
1996 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
1997 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
1998 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
1999 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2000 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2007 /*************************************************
2008 * Print an individual option value *
2009 *************************************************/
2011 /* This is used by the -bP option, so prints to the standard output.
2012 The entire options list is passed in as an argument, because some options come
2013 in pairs - typically uid/gid settings, which can either be explicit numerical
2014 values, or strings to be expanded later. If the numerical value is unset,
2015 search for "*expand_<name>" to see if there is a string equivalent.
2018 ol option entry, or NULL for an unknown option
2020 options_block NULL for main configuration options; otherwise points to
2021 a driver block; if the option doesn't have opt_public
2022 set, then options_block->options_block is where the item
2024 oltop points to the option list in which ol exists
2025 last one more than the offset of the last entry in optop
2031 print_ol(optionlist *ol, uschar *name, void *options_block,
2032 optionlist *oltop, int last)
2045 printf("%s is not a known option\n", name);
2049 /* Non-admin callers cannot see options that have been flagged secure by the
2052 if (!admin_user && (ol->type & opt_secure) != 0)
2054 printf("%s = <value not displayable>\n", name);
2058 /* Else show the value of the option */
2061 if (options_block != NULL)
2063 if ((ol->type & opt_public) == 0)
2064 options_block = (void *)(((driver_instance *)options_block)->options_block);
2065 value = (void *)((uschar *)options_block + (long int)value);
2068 switch(ol->type & opt_mask)
2071 case opt_rewrite: /* Show the text value */
2072 s = *((uschar **)value);
2073 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing2(s, FALSE));
2077 printf("%s = %d\n", name, *((int *)value));
2082 int x = *((int *)value);
2083 if (x != 0 && (x & 1023) == 0)
2087 if ((x & 1023) == 0)
2092 printf("%s = %d%c\n", name, x, c);
2094 else printf("%s = %d\n", name, x);
2100 int x = *((int *)value);
2101 if (x == 0) printf("%s = 0\n", name);
2102 else if ((x & 1023) == 0) printf("%s = %dM\n", name, x >> 10);
2103 else printf("%s = %dK\n", name, x);
2108 printf("%s = %#o\n", name, *((int *)value));
2111 /* Can be negative only when "unset", in which case integer */
2115 int x = *((int *)value);
2118 if (x < 0) printf("%s =\n", name); else
2120 printf("%s = %d.", name, x/1000);
2133 /* If the numerical value is unset, try for the string value */
2135 case opt_expand_uid:
2136 if (! *get_set_flag(name, oltop, last, options_block))
2138 sprintf(CS name2, "*expand_%.50s", name);
2139 ol2 = find_option(name2, oltop, last);
2142 void *value2 = ol2->value;
2143 if (options_block != NULL)
2144 value2 = (void *)((uschar *)options_block + (long int)value2);
2145 s = *((uschar **)value2);
2146 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing(s));
2151 /* Else fall through */
2154 if (! *get_set_flag(name, oltop, last, options_block))
2155 printf("%s =\n", name);
2158 pw = getpwuid(*((uid_t *)value));
2160 printf("%s = %ld\n", name, (long int)(*((uid_t *)value)));
2161 else printf("%s = %s\n", name, pw->pw_name);
2165 /* If the numerical value is unset, try for the string value */
2167 case opt_expand_gid:
2168 if (! *get_set_flag(name, oltop, last, options_block))
2170 sprintf(CS name2, "*expand_%.50s", name);
2171 ol2 = find_option(name2, oltop, last);
2172 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2174 void *value2 = ol2->value;
2175 if (options_block != NULL)
2176 value2 = (void *)((uschar *)options_block + (long int)value2);
2177 s = *((uschar **)value2);
2178 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing(s));
2183 /* Else fall through */
2186 if (! *get_set_flag(name, oltop, last, options_block))
2187 printf("%s =\n", name);
2190 gr = getgrgid(*((int *)value));
2192 printf("%s = %ld\n", name, (long int)(*((int *)value)));
2193 else printf("%s = %s\n", name, gr->gr_name);
2198 uidlist = *((uid_t **)value);
2199 printf("%s =", name);
2200 if (uidlist != NULL)
2204 for (i = 1; i <= (int)(uidlist[0]); i++)
2206 uschar *name = NULL;
2207 pw = getpwuid(uidlist[i]);
2208 if (pw != NULL) name = US pw->pw_name;
2209 if (name != NULL) printf("%c%s", sep, name);
2210 else printf("%c%ld", sep, (long int)(uidlist[i]));
2218 gidlist = *((gid_t **)value);
2219 printf("%s =", name);
2220 if (gidlist != NULL)
2224 for (i = 1; i <= (int)(gidlist[0]); i++)
2226 uschar *name = NULL;
2227 gr = getgrgid(gidlist[i]);
2228 if (gr != NULL) name = US gr->gr_name;
2229 if (name != NULL) printf("%c%s", sep, name);
2230 else printf("%c%ld", sep, (long int)(gidlist[i]));
2238 printf("%s = %s\n", name, readconf_printtime(*((int *)value)));
2244 int *list = (int *)value;
2245 printf("%s = ", name);
2246 for (i = 0; i < list[1]; i++)
2247 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2253 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2257 case opt_expand_bool:
2258 sprintf(CS name2, "*expand_%.50s", name);
2259 ol2 = find_option(name2, oltop, last);
2260 if (ol2 != NULL && ol2->value != NULL)
2262 void *value2 = ol2->value;
2263 if (options_block != NULL)
2264 value2 = (void *)((uschar *)options_block + (long int)value2);
2265 s = *((uschar **)value2);
2268 printf("%s = %s\n", name, string_printing(s));
2271 /* s == NULL => string not set; fall through */
2277 case opt_bool_verify:
2279 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2286 /*************************************************
2287 * Print value from main configuration *
2288 *************************************************/
2290 /* This function, called as a result of encountering the -bP option,
2291 causes the value of any main configuration variable to be output if the
2292 second argument is NULL. There are some special values:
2294 all print all main configuration options
2295 configure_file print the name of the configuration file
2296 routers print the routers' configurations
2297 transports print the transports' configuration
2298 authenticators print the authenticators' configuration
2299 router_list print a list of router names
2300 transport_list print a list of transport names
2301 authenticator_list print a list of authentication mechanism names
2302 +name print a named list item
2303 local_scan print the local_scan options
2305 If the second argument is not NULL, it must be one of "router", "transport", or
2306 "authenticator" in which case the first argument identifies the driver whose
2307 options are to be printed.
2310 name option name if type == NULL; else driver name
2311 type NULL or driver type name, as described above
2317 readconf_print(uschar *name, uschar *type)
2319 BOOL names_only = FALSE;
2321 optionlist *ol2 = NULL;
2322 driver_instance *d = NULL;
2332 static uschar *types[] = { US"address", US"domain", US"host",
2334 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2335 &hostlist_anchor, &localpartlist_anchor };
2337 for (i = 0; i < 4; i++)
2339 t = tree_search(*(anchors[i]), name+1);
2343 printf("%slist %s = %s\n", types[i], name+1,
2344 ((namedlist_block *)(t->data.ptr))->string);
2349 printf("no address, domain, host, or local part list called \"%s\" "
2350 "exists\n", name+1);
2355 if (Ustrcmp(name, "configure_file") == 0)
2357 printf("%s\n", CS config_main_filename);
2361 if (Ustrcmp(name, "all") == 0)
2363 for (ol = optionlist_config;
2364 ol < optionlist_config + optionlist_config_size; ol++)
2366 if ((ol->type & opt_hidden) == 0)
2367 print_ol(ol, US ol->name, NULL, optionlist_config, optionlist_config_size);
2372 if (Ustrcmp(name, "local_scan") == 0)
2374 #ifndef LOCAL_SCAN_HAS_OPTIONS
2375 printf("local_scan() options are not supported\n");
2377 for (ol = local_scan_options;
2378 ol < local_scan_options + local_scan_options_count; ol++)
2380 print_ol(ol, US ol->name, NULL, local_scan_options,
2381 local_scan_options_count);
2387 if (Ustrcmp(name, "routers") == 0)
2392 else if (Ustrcmp(name, "transports") == 0)
2394 type = US"transport";
2398 else if (Ustrcmp(name, "authenticators") == 0)
2400 type = US"authenticator";
2404 else if (Ustrcmp(name, "authenticator_list") == 0)
2406 type = US"authenticator";
2411 else if (Ustrcmp(name, "router_list") == 0)
2417 else if (Ustrcmp(name, "transport_list") == 0)
2419 type = US"transport";
2425 print_ol(find_option(name, optionlist_config, optionlist_config_size),
2426 name, NULL, optionlist_config, optionlist_config_size);
2431 /* Handle the options for a router or transport. Skip options that are flagged
2432 as hidden. Some of these are options with names starting with '*', used for
2433 internal alternative representations of other options (which the printing
2434 function will sort out). Others are synonyms kept for backward compatibility.
2437 if (Ustrcmp(type, "router") == 0)
2439 d = (driver_instance *)routers;
2440 ol2 = optionlist_routers;
2441 size = optionlist_routers_size;
2443 else if (Ustrcmp(type, "transport") == 0)
2445 d = (driver_instance *)transports;
2446 ol2 = optionlist_transports;
2447 size = optionlist_transports_size;
2449 else if (Ustrcmp(type, "authenticator") == 0)
2451 d = (driver_instance *)auths;
2452 ol2 = optionlist_auths;
2453 size = optionlist_auths_size;
2458 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2462 /* Either search for a given driver, or print all of them */
2464 for (; d != NULL; d = d->next)
2467 printf("\n%s %s:\n", d->name, type);
2468 else if (Ustrcmp(d->name, name) != 0) continue;
2470 for (ol = ol2; ol < ol2 + size; ol++)
2472 if ((ol->type & opt_hidden) == 0)
2473 print_ol(ol, US ol->name, d, ol2, size);
2476 for (ol = d->info->options;
2477 ol < d->info->options + *(d->info->options_count); ol++)
2479 if ((ol->type & opt_hidden) == 0)
2480 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count));
2482 if (name != NULL) return;
2484 if (name != NULL) printf("%s %s not found\n", type, name);
2489 /*************************************************
2490 * Read a named list item *
2491 *************************************************/
2493 /* This function reads a name and a list (i.e. string). The name is used to
2494 save the list in a tree, sorted by its name. Each entry also has a number,
2495 which can be used for caching tests, but if the string contains any expansion
2496 items other than $key, the number is set negative to inhibit caching. This
2497 mechanism is used for domain, host, and address lists that are referenced by
2501 anchorp points to the tree anchor
2502 numberp points to the current number for this tree
2503 max the maximum number permitted
2504 s the text of the option line, starting immediately after the name
2506 tname the name of the list type, for messages
2512 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2515 BOOL forcecache = FALSE;
2518 namedlist_block *nb = store_get(sizeof(namedlist_block));
2520 if (Ustrncmp(s, "_cache", 6) == 0)
2527 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2529 if (*numberp >= max)
2530 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2533 while (isspace(*s)) s++;
2535 while (isalnum(*s) || *s == '_') s++;
2536 t = store_get(sizeof(tree_node) + s-ss);
2537 Ustrncpy(t->name, ss, s-ss);
2539 while (isspace(*s)) s++;
2541 if (!tree_insertnode(anchorp, t))
2542 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2543 "duplicate name \"%s\" for a named %s", t->name, tname);
2546 nb->number = *numberp;
2549 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2550 "missing '=' after \"%s\"", t->name);
2551 while (isspace(*s)) s++;
2552 nb->string = read_string(s, t->name);
2553 nb->cache_data = NULL;
2555 /* Check the string for any expansions; if any are found, mark this list
2556 uncacheable unless the user has explicited forced caching. */
2558 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2564 /*************************************************
2565 * Unpick data for a rate limit *
2566 *************************************************/
2568 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2572 s string, in the form t,b,f,l
2573 where t is the threshold (integer)
2574 b is the initial delay (time)
2575 f is the multiplicative factor (fixed point)
2576 k is the maximum time (time)
2577 threshold where to store threshold
2578 base where to store base in milliseconds
2579 factor where to store factor in milliseconds
2580 limit where to store limit
2582 Returns: nothing (panics on error)
2586 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2589 uschar bstring[16], lstring[16];
2591 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2592 factor, lstring) == 4)
2594 *base = readconf_readtime(bstring, 0, TRUE);
2595 *limit = readconf_readtime(lstring, 0, TRUE);
2596 if (*base >= 0 && *limit >= 0) return;
2598 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2604 /*************************************************
2605 * Read main configuration options *
2606 *************************************************/
2608 /* This function is the first to be called for configuration reading. It
2609 opens the configuration file and reads general configuration settings until
2610 it reaches the end of the configuration section. The file is then left open so
2611 that the remaining configuration data can subsequently be read if needed for
2614 The configuration file must be owned either by root or exim, and be writeable
2615 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
2616 in the config file, so the test is done on the compiled in values. A slight
2617 anomaly, to be carefully documented.
2619 The name of the configuration file is taken from a list that is included in the
2620 binary of Exim. It can be altered from the command line, but if that is done,
2621 root privilege is immediately withdrawn unless the caller is root or exim.
2622 The first file on the list that exists is used.
2624 For use on multiple systems that share file systems, first look for a
2625 configuration file whose name has the current node name on the end. If that is
2626 not found, try the generic name. For really contorted configurations, that run
2627 multiple Exims with different uid settings, first try adding the effective uid
2628 before the node name. These complications are going to waste resources on most
2629 systems. Therefore they are available only when requested by compile-time
2636 struct stat statbuf;
2637 uschar *s, *filename;
2638 uschar *list = config_main_filelist;
2640 /* Loop through the possible file names */
2642 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
2645 /* Cut out all the fancy processing unless specifically wanted */
2647 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
2648 uschar *suffix = filename + Ustrlen(filename);
2650 /* Try for the node-specific file if a node name exists */
2652 #ifdef CONFIGURE_FILE_USE_NODE
2654 if (uname(&uts) >= 0)
2656 #ifdef CONFIGURE_FILE_USE_EUID
2657 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
2658 config_file = Ufopen(filename, "rb");
2659 if (config_file == NULL)
2660 #endif /* CONFIGURE_FILE_USE_EUID */
2662 sprintf(CS suffix, ".%.256s", uts.nodename);
2663 config_file = Ufopen(filename, "rb");
2666 #endif /* CONFIGURE_FILE_USE_NODE */
2668 /* Otherwise, try the generic name, possibly with the euid added */
2670 #ifdef CONFIGURE_FILE_USE_EUID
2671 if (config_file == NULL)
2673 sprintf(CS suffix, ".%ld", (long int)original_euid);
2674 config_file = Ufopen(filename, "rb");
2676 #endif /* CONFIGURE_FILE_USE_EUID */
2678 /* Finally, try the unadorned name */
2680 if (config_file == NULL)
2683 config_file = Ufopen(filename, "rb");
2685 #else /* if neither defined */
2687 /* This is the common case when the fancy processing is not included. */
2689 config_file = Ufopen(filename, "rb");
2692 /* If the file does not exist, continue to try any others. For any other
2693 error, break out (and die). */
2695 if (config_file != NULL || errno != ENOENT) break;
2698 /* On success, save the name for verification; config_filename is used when
2699 logging configuration errors (it changes for .included files) whereas
2700 config_main_filename is the name shown by -bP. Failure to open a configuration
2701 file is a serious disaster. */
2703 if (config_file != NULL)
2705 config_filename = config_main_filename = string_copy(filename);
2709 if (filename == NULL)
2710 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
2711 "%s", config_main_filelist);
2713 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
2714 "configuration file %s", filename));
2717 /* Check the status of the file we have opened, unless it was specified on
2718 the command line, in which case privilege was given away at the start. */
2720 if (!config_changed)
2722 if (fstat(fileno(config_file), &statbuf) != 0)
2723 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
2726 if ((statbuf.st_uid != root_uid && /* owner not root */
2727 statbuf.st_uid != exim_uid /* owner not exim */
2728 #ifdef CONFIGURE_OWNER
2729 && statbuf.st_uid != config_uid /* owner not the special one */
2732 (statbuf.st_gid != exim_gid /* group not exim & */
2733 #ifdef CONFIGURE_GROUP
2734 && statbuf.st_gid != config_gid /* group not the special one */
2736 && (statbuf.st_mode & 020) != 0) || /* group writeable */
2738 ((statbuf.st_mode & 2) != 0)) /* world writeable */
2740 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
2741 "wrong owner, group, or mode", big_buffer);
2744 /* Process the main configuration settings. They all begin with a lower case
2745 letter. If we see something starting with an upper case letter, it is taken as
2746 a macro definition. */
2748 while ((s = get_config_line()) != NULL)
2750 if (isupper(s[0])) read_macro_assignment(s);
2752 else if (Ustrncmp(s, "domainlist", 10) == 0)
2753 read_named_list(&domainlist_anchor, &domainlist_count,
2754 MAX_NAMED_LIST, s+10, US"domain list");
2756 else if (Ustrncmp(s, "hostlist", 8) == 0)
2757 read_named_list(&hostlist_anchor, &hostlist_count,
2758 MAX_NAMED_LIST, s+8, US"host list");
2760 else if (Ustrncmp(s, US"addresslist", 11) == 0)
2761 read_named_list(&addresslist_anchor, &addresslist_count,
2762 MAX_NAMED_LIST, s+11, US"address list");
2764 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
2765 read_named_list(&localpartlist_anchor, &localpartlist_count,
2766 MAX_NAMED_LIST, s+13, US"local part list");
2769 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
2770 NULL, US"main option \"%s\" unknown");
2774 /* If local_sender_retain is set, local_from_check must be unset. */
2776 if (local_sender_retain && local_from_check)
2777 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
2778 "local_sender_retain are set; this combination is not allowed");
2780 /* If the timezone string is empty, set it to NULL, implying no TZ variable
2783 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
2785 /* remote_max_parallel must be > 0 */
2787 if (remote_max_parallel <= 0) remote_max_parallel = 1;
2789 /* The primary host name may be required for expansion of spool_directory
2790 and log_file_path, so make sure it is set asap. It is obtained from uname(),
2791 but if that yields an unqualified value, make a FQDN by using gethostbyname to
2792 canonize it. Some people like upper case letters in their host names, so we
2793 don't force the case. */
2795 if (primary_hostname == NULL)
2799 if (uname(&uts) < 0)
2800 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
2801 hostname = US uts.nodename;
2803 if (Ustrchr(hostname, '.') == NULL)
2806 struct hostent *hostdata;
2809 if (dns_ipv4_lookup == NULL ||
2810 match_isinlist(hostname, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2820 #if HAVE_GETIPNODEBYNAME
2822 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
2824 hostdata = gethostbyname2(CS hostname, af);
2827 hostdata = gethostbyname(CS hostname);
2830 if (hostdata != NULL)
2832 hostname = US hostdata->h_name;
2836 if (af == AF_INET) break;
2841 primary_hostname = string_copy(hostname);
2844 /* Set up default value for smtp_active_hostname */
2846 smtp_active_hostname = primary_hostname;
2848 /* If spool_directory wasn't set in the build-time configuration, it must have
2849 got set above. Of course, writing to the log may not work if log_file_path is
2850 not set, but it will at least get to syslog or somewhere, with any luck. */
2852 if (*spool_directory == 0)
2853 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
2856 /* Expand the spool directory name; it may, for example, contain the primary
2857 host name. Same comment about failure. */
2859 s = expand_string(spool_directory);
2861 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
2862 "\"%s\": %s", spool_directory, expand_string_message);
2863 spool_directory = s;
2865 /* Expand log_file_path, which must contain "%s" in any component that isn't
2866 the null string or "syslog". It is also allowed to contain one instance of %D.
2867 However, it must NOT contain % followed by anything else. */
2869 if (*log_file_path != 0)
2872 int sep = ':'; /* Fixed for log file path */
2873 s = expand_string(log_file_path);
2875 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
2876 "\"%s\": %s", log_file_path, expand_string_message);
2879 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
2882 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
2883 t = Ustrstr(sss, "%s");
2885 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
2886 "contain \"%%s\"", sss);
2888 t = Ustrchr(sss, '%');
2891 if (t[1] != 'D' || Ustrchr(t+2, '%') != NULL)
2892 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
2893 "unexpected \"%%\" character", s);
2900 /* Interpret syslog_facility into an integer argument for 'ident' param to
2901 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
2904 if (syslog_facility_str != NULL)
2907 uschar *s = syslog_facility_str;
2909 if ((Ustrlen(syslog_facility_str) >= 4) &&
2910 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
2913 for (i = 0; i < syslog_list_size; i++)
2915 if (strcmpic(s, syslog_list[i].name) == 0)
2917 syslog_facility = syslog_list[i].value;
2922 if (i >= syslog_list_size)
2924 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2925 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
2929 /* Expand pid_file_path */
2931 if (*pid_file_path != 0)
2933 s = expand_string(pid_file_path);
2935 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
2936 "\"%s\": %s", pid_file_path, expand_string_message);
2940 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
2943 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
2945 /* Unpick the SMTP rate limiting options, if set */
2947 if (smtp_ratelimit_mail != NULL)
2949 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
2950 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
2953 if (smtp_ratelimit_rcpt != NULL)
2955 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
2956 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
2959 /* The qualify domains default to the primary host name */
2961 if (qualify_domain_sender == NULL)
2962 qualify_domain_sender = primary_hostname;
2963 if (qualify_domain_recipient == NULL)
2964 qualify_domain_recipient = qualify_domain_sender;
2966 /* Setting system_filter_user in the configuration sets the gid as well if a
2967 name is given, but a numerical value does not. */
2969 if (system_filter_uid_set && !system_filter_gid_set)
2971 struct passwd *pw = getpwuid(system_filter_uid);
2973 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
2974 (long int)system_filter_uid);
2975 system_filter_gid = pw->pw_gid;
2976 system_filter_gid_set = TRUE;
2979 /* If the errors_reply_to field is set, check that it is syntactically valid
2980 and ensure it contains a domain. */
2982 if (errors_reply_to != NULL)
2985 int start, end, domain;
2986 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
2987 &start, &end, &domain, FALSE);
2989 if (recipient == NULL)
2990 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2991 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
2994 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2995 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
2998 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
2999 smtp_accept_max must also be set. */
3001 if (smtp_accept_max == 0 &&
3002 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3003 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3004 "smtp_accept_max must be set if smtp_accept_queue or "
3005 "smtp_accept_max_per_host is set");
3007 /* Set up the host number if anything is specified. It is an expanded string
3008 so that it can be computed from the host name, for example. We do this last
3009 so as to ensure that everything else is set up before the expansion. */
3011 if (host_number_string != NULL)
3014 uschar *s = expand_string(host_number_string);
3015 long int n = Ustrtol(s, &end, 0);
3016 while (isspace(*end)) end++;
3018 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3019 "localhost_number value is not a number: %s", s);
3020 if (n > LOCALHOST_MAX)
3021 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3022 "localhost_number is greater than the maximum allowed value (%d)",
3028 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3030 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3031 tls_verify_certificates == NULL)
3032 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3033 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3034 (tls_verify_hosts != NULL)? "" : "try_");
3040 /*************************************************
3041 * Initialize one driver *
3042 *************************************************/
3044 /* This is called once the driver's generic options, if any, have been read.
3045 We can now find the driver, set up defaults for the private options, and
3046 unset any "set" bits in the private options table (which might have been
3047 set by another incarnation of the same driver).
3050 d pointer to driver instance block, with generic
3052 drivers_available vector of available drivers
3053 size_of_info size of each block in drivers_available
3054 class class of driver, for error message
3056 Returns: pointer to the driver info block
3059 static driver_info *
3060 init_driver(driver_instance *d, driver_info *drivers_available,
3061 int size_of_info, uschar *class)
3065 for (dd = drivers_available; dd->driver_name[0] != 0;
3066 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3068 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3071 int len = dd->options_len;
3073 d->options_block = store_get(len);
3074 memcpy(d->options_block, dd->options_block, len);
3075 for (i = 0; i < *(dd->options_count); i++)
3076 dd->options[i].type &= ~opt_set;
3081 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3082 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3084 return NULL; /* never obeyed */
3090 /*************************************************
3091 * Initialize driver list *
3092 *************************************************/
3094 /* This function is called for routers, transports, and authentication
3095 mechanisms. It reads the data from the current point in the configuration file
3096 up to the end of the section, and sets up a chain of instance blocks according
3097 to the file's contents. The file will already have been opened by a call to
3098 readconf_main, and must be left open for subsequent reading of further data.
3100 Any errors cause a panic crash. Note that the blocks with names driver_info and
3101 driver_instance must map the first portions of all the _info and _instance
3102 blocks for this shared code to work.
3105 class "router", "transport", or "authenticator"
3106 anchor &routers, &transports, &auths
3107 drivers_available available drivers
3108 size_of_info size of each info block
3109 instance_default points to default data for an instance
3110 instance_size size of instance block
3111 driver_optionlist generic option list
3112 driver_optionlist_count count of generic option list
3118 readconf_driver_init(
3120 driver_instance **anchor,
3121 driver_info *drivers_available,
3123 void *instance_default,
3125 optionlist *driver_optionlist,
3126 int driver_optionlist_count)
3128 driver_instance **p = anchor;
3129 driver_instance *d = NULL;
3132 while ((buffer = get_config_line()) != NULL)
3137 /* Read the first name on the line and test for the start of a new driver. A
3138 macro definition indicates the end of the previous driver. If this isn't the
3139 start of a new driver, the line will be re-read. */
3141 s = readconf_readname(name, sizeof(name), buffer);
3143 /* Handle macro definition, first finishing off the initialization of the
3144 previous driver, if any. */
3146 if (isupper(*name) && *s == '=')
3150 if (d->driver_name == NULL)
3151 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3152 "no driver defined for %s \"%s\"", class, d->name);
3156 read_macro_assignment(buffer);
3160 /* If the line starts with a name terminated by a colon, we are at the
3161 start of the definition of a new driver. The rest of the line must be
3168 /* Finish off initializing the previous driver. */
3172 if (d->driver_name == NULL)
3173 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3174 "no driver defined for %s \"%s\"", class, d->name);
3178 /* Check that we haven't already got a driver of this name */
3180 for (d = *anchor; d != NULL; d = d->next)
3181 if (Ustrcmp(name, d->name) == 0)
3182 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3183 "there are two %ss called \"%s\"", class, name);
3185 /* Set up a new driver instance data block on the chain, with
3186 its default values installed. */
3188 d = store_get(instance_size);
3189 memcpy(d, instance_default, instance_size);
3192 d->name = string_copy(name);
3194 /* Clear out the "set" bits in the generic options */
3196 for (i = 0; i < driver_optionlist_count; i++)
3197 driver_optionlist[i].type &= ~opt_set;
3199 /* Check nothing more on this line, then do the next loop iteration. */
3201 while (isspace(*s)) s++;
3202 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3206 /* Not the start of a new driver. Give an error if we have not set up a
3207 current driver yet. */
3209 if (d == NULL) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3210 "%s name missing", class);
3212 /* First look to see if this is a generic option; if it is "driver",
3213 initialize the driver. If is it not a generic option, we can look for a
3214 private option provided that the driver has been previously set up. */
3216 if (readconf_handle_option(buffer, driver_optionlist,
3217 driver_optionlist_count, d, NULL))
3219 if (d->info == NULL && d->driver_name != NULL)
3220 init_driver(d, drivers_available, size_of_info, class);
3223 /* Handle private options - pass the generic block because some may
3224 live therein. A flag with each option indicates if it is in the public
3227 else if (d->info != NULL)
3229 readconf_handle_option(buffer, d->info->options,
3230 *(d->info->options_count), d, US"option \"%s\" unknown");
3233 /* The option is not generic and the driver name has not yet been given. */
3235 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3236 "(\"driver\" must be specified before any private options)", name);
3239 /* Run the initialization function for the final driver. */
3243 if (d->driver_name == NULL)
3244 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3245 "no driver defined for %s \"%s\"", class, d->name);
3252 /*************************************************
3253 * Check driver dependency *
3254 *************************************************/
3256 /* This function is passed a driver instance and a string. It checks whether
3257 any of the string options for the driver contains the given string as an
3261 d points to a driver instance block
3262 s the string to search for
3264 Returns: TRUE if a dependency is found
3268 readconf_depends(driver_instance *d, uschar *s)
3270 int count = *(d->info->options_count);
3274 for (ol = d->info->options; ol < d->info->options + count; ol++)
3276 void *options_block;
3278 int type = ol->type & opt_mask;
3279 if (type != opt_stringptr) continue;
3280 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3281 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3282 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3284 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3285 isalnum(ss[Ustrlen(s)])) continue;
3286 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3287 d->name, ol->name, s);
3292 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3299 /*************************************************
3300 * Decode an error type for retries *
3301 *************************************************/
3303 /* This function is global because it is also called from the main
3304 program when testing retry information. It decodes strings such as "quota_7d"
3305 into numerical error codes.
3308 pp points to start of text
3309 p points past end of text
3310 basic_errno points to an int to receive the main error number
3311 more_errno points to an int to receive the secondary error data
3313 Returns: NULL if decoded correctly; else points to error text
3317 readconf_retry_error(uschar *pp, uschar *p, int *basic_errno, int *more_errno)
3321 while (q < p && *q != '_') q++;
3324 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3326 *basic_errno = ERRNO_EXIMQUOTA;
3327 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3328 return US"bad time value";
3331 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3333 *basic_errno = ECONNREFUSED;
3336 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3337 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3338 else return US"A or MX expected after \"refused\"";
3342 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3344 *basic_errno = ETIMEDOUT;
3348 int xlen = p - q - 1;
3351 static uschar *extras[] =
3352 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
3353 static int values[] =
3354 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3356 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3358 if (strncmpic(x, extras[i], xlen) == 0)
3360 *more_errno = values[i];
3365 if (i >= sizeof(extras)/sizeof(uschar *))
3367 if (strncmpic(x, US"DNS", xlen) == 0)
3369 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3370 "available in retry rules (it has never worked) - treated as "
3373 else return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3378 else if (strncmpic(pp, US"rcpt_4", 6) == 0)
3381 int x = 255; /* means "any 4xx code" */
3382 if (p != pp + 8) bad = TRUE; else
3384 int a = pp[6], b = pp[7];
3388 if (isdigit(b)) x += b - '0';
3389 else if (b == 'x') x += 100;
3392 else if (a != 'x' || b != 'x') bad = TRUE;
3395 if (bad) return US"rcpt_4 must be followed by xx, dx, or dd, where "
3396 "x is literal and d is any digit";
3398 *basic_errno = ERRNO_RCPT4XX;
3399 *more_errno = x << 8;
3402 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3403 strncmpic(q+1, US"failed", p-q-1) == 0)
3405 *basic_errno = ERRNO_AUTHFAIL;
3408 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3409 return string_sprintf("unknown or malformed retry error \"%.*s\"", p-pp, pp);
3417 /*************************************************
3418 * Read retry information *
3419 *************************************************/
3421 /* Each line of retry information contains:
3423 . A domain name pattern or an address pattern;
3425 . An error name, possibly with additional data, or *;
3427 . An optional sequence of retry items, each consisting of an identifying
3428 letter, a cutoff time, and optional parameters.
3430 All this is decoded and placed into a control block. */
3433 /* Subroutine to read an argument, preceded by a comma and terminated
3434 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3435 1 = fixed point number (returned *1000).
3438 paddr pointer to pointer to current character; updated
3439 type 0 => read a time; 1 => read a fixed point number
3441 Returns: time in seconds or fixed point number * 1000
3445 retry_arg(uschar **paddr, int type)
3450 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3452 while (isspace(*p)) p++;
3454 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3456 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3457 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3463 return readconf_readtime(pp, *p, FALSE);
3465 return readconf_readfixed(pp, *p);
3467 return 0; /* Keep picky compilers happy */
3470 /* The function proper */
3473 readconf_retries(void)
3475 retry_config **chain = &retries;
3479 while ((p = get_config_line()) != NULL)
3481 retry_rule **rchain;
3484 next = store_get(sizeof(retry_config));
3487 chain = &(next->next);
3488 next->basic_errno = next->more_errno = 0;
3489 next->senders = NULL;
3491 rchain = &(next->rules);
3493 next->pattern = string_dequote(&p);
3494 while (isspace(*p)) p++;
3496 while (mac_isgraph(*p)) p++;
3497 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3498 "missing error type");
3500 /* Test error names for things we understand. */
3502 if ((error = readconf_retry_error(pp, p, &(next->basic_errno),
3503 &(next->more_errno))) != NULL)
3504 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3506 /* There may be an optional address list of senders to be used as another
3507 constraint on the rule. This was added later, so the syntax is a bit of a
3508 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3511 while (isspace(*p)) p++;
3512 if (Ustrncmp(p, "senders", 7) == 0)
3515 while (isspace(*p)) p++;
3516 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3517 "\"=\" expected after \"senders\" in retry rule");
3518 while (isspace(*p)) p++;
3519 next->senders = string_dequote(&p);
3522 /* Now the retry rules. Keep the maximum timeout encountered. */
3524 while (isspace(*p)) p++;
3528 retry_rule *rule = store_get(sizeof(retry_rule));
3530 rchain = &(rule->next);
3532 rule->rule = toupper(*p++);
3533 rule->timeout = retry_arg(&p, 0);
3534 if (rule->timeout > retry_maximum_timeout)
3535 retry_maximum_timeout = rule->timeout;
3539 case 'F': /* Fixed interval */
3540 rule->p1 = retry_arg(&p, 0);
3543 case 'G': /* Geometrically increasing intervals */
3544 rule->p1 = retry_arg(&p, 0);
3545 rule->p2 = retry_arg(&p, 1);
3549 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
3553 if (rule->timeout <= 0 || rule->p1 <= 0 ||
3554 (rule->rule == 'G' && rule->p2 < 1000))
3555 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3556 "bad parameters for retry rule");
3558 while (isspace(*p)) p++;
3562 while (isspace(*p)) p++;
3565 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
3572 /*************************************************
3573 * Initialize authenticators *
3574 *************************************************/
3576 /* Read the authenticators section of the configuration file.
3585 auth_instance *au, *bu;
3586 readconf_driver_init(US"authenticator",
3587 (driver_instance **)(&auths), /* chain anchor */
3588 (driver_info *)auths_available, /* available drivers */
3589 sizeof(auth_info), /* size of info block */
3590 &auth_defaults, /* default values for generic options */
3591 sizeof(auth_instance), /* size of instance block */
3592 optionlist_auths, /* generic options */
3593 optionlist_auths_size);
3595 for (au = auths; au != NULL; au = au->next)
3597 if (au->public_name == NULL)
3598 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
3599 "the %s authenticator", au->name);
3600 for (bu = au->next; bu != NULL; bu = bu->next)
3602 if (strcmpic(au->public_name, bu->public_name) == 0)
3604 if ((au->client && bu->client) || (au->server && bu->server))
3605 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
3606 "(%s and %s) have the same public name (%s)",
3607 (au->client)? US"client" : US"server", au->name, bu->name,
3617 /*************************************************
3618 * Read ACL information *
3619 *************************************************/
3621 /* If this run of Exim is not doing something that involves receiving a
3622 message, we can just skip over the ACL information. No need to parse it.
3624 First, we have a function for acl_read() to call back to get the next line. We
3625 need to remember the line we passed, because at the end it will contain the
3626 name of the next ACL. */
3628 static uschar *acl_line;
3633 acl_line = get_config_line();
3638 /* Now the main function:
3641 skip TRUE when this Exim process is doing something that will
3642 not need the ACL data
3648 readconf_acl(BOOL skip)
3652 /* Not receiving messages, don't need to parse the ACL data */
3656 DEBUG(D_acl) debug_printf("skipping ACL configuration - not needed\n");
3657 while ((p = get_config_line()) != NULL);
3661 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
3664 acl_line = get_config_line();
3666 while(acl_line != NULL)
3672 p = readconf_readname(name, sizeof(name), acl_line);
3673 if (isupper(*name) && *p == '=')
3675 read_macro_assignment(acl_line);
3676 acl_line = get_config_line();
3680 if (*p != ':' || name[0] == 0)
3681 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
3683 node = store_get(sizeof(tree_node) + Ustrlen(name));
3684 Ustrcpy(node->name, name);
3685 if (!tree_insertnode(&acl_anchor, node))
3686 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3687 "there are two ACLs called \"%s\"", name);
3689 node->data.ptr = acl_read(acl_callback, &error);
3691 if (node->data.ptr == NULL && error != NULL)
3692 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
3698 /*************************************************
3699 * Read configuration for local_scan() *
3700 *************************************************/
3702 /* This function is called after "begin local_scan" is encountered in the
3703 configuration file. If the local_scan() function allows for configuration
3704 options, we can process them. Otherwise, we expire in a panic.
3711 local_scan_init(void)
3713 #ifndef LOCAL_SCAN_HAS_OPTIONS
3714 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
3715 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
3719 while ((p = get_config_line()) != NULL)
3721 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
3722 NULL, US"local_scan option \"%s\" unknown");
3729 /*************************************************
3730 * Read rest of configuration (after main) *
3731 *************************************************/
3733 /* This function reads the rest of the runtime configuration, after the main
3734 configuration. It is called only when actually needed. Each subsequent section
3735 of the configuration starts with a line of the form
3739 where the name is "routers", "transports", etc. A section is terminated by
3740 hitting the next "begin" line, and the next name is left in next_section.
3741 Because it may confuse people as to whether the names are singular or plural,
3742 we add "s" if it's missing. There is always enough room in next_section for
3743 this. This function is basically just a switch.
3746 skip_acl TRUE if ACL information is not needed
3751 static uschar *section_list[] = {
3761 readconf_rest(BOOL skip_acl)
3765 while(next_section[0] != 0)
3769 int last = sizeof(section_list) / sizeof(uschar *);
3771 int n = Ustrlen(next_section);
3773 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
3777 int c = strcmpic(next_section, section_list[mid]);
3779 if (c > 0) first = mid + 1; else last = mid;
3781 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3782 "\"%.*s\" is not a known configuration section name", n, next_section);
3783 mid = (last + first)/2;
3787 if (((had ^= bit) & bit) == 0)
3788 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3789 "\"%.*s\" section is repeated in the configuration file", n,
3794 case 0: readconf_acl(skip_acl); break;
3795 case 1: auths_init(); break;
3796 case 2: local_scan_init(); break;
3797 case 3: readconf_retries(); break;
3798 case 4: readconf_rewrites(); break;
3799 case 5: route_init(); break;
3800 case 6: transport_init(); break;
3804 fclose(config_file);
3807 /* End of readconf.c */