1 /* $Cambridge: exim/src/src/readconf.c,v 1.12 2005/08/08 10:48:27 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 { "daemon_startup_retries", opt_int, &daemon_startup_retries },
190 { "daemon_startup_sleep", opt_time, &daemon_startup_sleep },
191 { "delay_warning", opt_timelist, &delay_warning },
192 { "delay_warning_condition", opt_stringptr, &delay_warning_condition },
193 { "deliver_drop_privilege", opt_bool, &deliver_drop_privilege },
194 { "deliver_queue_load_max", opt_fixed, &deliver_queue_load_max },
195 { "delivery_date_remove", opt_bool, &delivery_date_remove },
196 { "dns_again_means_nonexist", opt_stringptr, &dns_again_means_nonexist },
197 { "dns_check_names_pattern", opt_stringptr, &check_dns_names_pattern },
198 { "dns_csa_search_limit", opt_int, &dns_csa_search_limit },
199 { "dns_csa_use_reverse", opt_bool, &dns_csa_use_reverse },
200 { "dns_ipv4_lookup", opt_stringptr, &dns_ipv4_lookup },
201 { "dns_retrans", opt_time, &dns_retrans },
202 { "dns_retry", opt_int, &dns_retry },
203 /* This option is now a no-op, retained for compability */
204 { "drop_cr", opt_bool, &drop_cr },
205 /*********************************************************/
206 { "envelope_to_remove", opt_bool, &envelope_to_remove },
207 { "errors_copy", opt_stringptr, &errors_copy },
208 { "errors_reply_to", opt_stringptr, &errors_reply_to },
209 { "exim_group", opt_gid, &exim_gid },
210 { "exim_path", opt_stringptr, &exim_path },
211 { "exim_user", opt_uid, &exim_uid },
212 { "extra_local_interfaces", opt_stringptr, &extra_local_interfaces },
213 { "extract_addresses_remove_arguments", opt_bool, &extract_addresses_remove_arguments },
214 { "finduser_retries", opt_int, &finduser_retries },
215 { "freeze_tell", opt_stringptr, &freeze_tell },
216 { "gecos_name", opt_stringptr, &gecos_name },
217 { "gecos_pattern", opt_stringptr, &gecos_pattern },
218 { "header_line_maxsize", opt_int, &header_line_maxsize },
219 { "header_maxsize", opt_int, &header_maxsize },
220 { "headers_charset", opt_stringptr, &headers_charset },
221 { "helo_accept_junk_hosts", opt_stringptr, &helo_accept_junk_hosts },
222 { "helo_allow_chars", opt_stringptr, &helo_allow_chars },
223 { "helo_lookup_domains", opt_stringptr, &helo_lookup_domains },
224 { "helo_try_verify_hosts", opt_stringptr, &helo_try_verify_hosts },
225 { "helo_verify_hosts", opt_stringptr, &helo_verify_hosts },
226 { "hold_domains", opt_stringptr, &hold_domains },
227 { "host_lookup", opt_stringptr, &host_lookup },
228 { "host_lookup_order", opt_stringptr, &host_lookup_order },
229 { "host_reject_connection", opt_stringptr, &host_reject_connection },
230 { "hosts_connection_nolog", opt_stringptr, &hosts_connection_nolog },
231 { "hosts_treat_as_local", opt_stringptr, &hosts_treat_as_local },
233 { "ibase_servers", opt_stringptr, &ibase_servers },
235 { "ignore_bounce_errors_after", opt_time, &ignore_bounce_errors_after },
236 { "ignore_fromline_hosts", opt_stringptr, &ignore_fromline_hosts },
237 { "ignore_fromline_local", opt_bool, &ignore_fromline_local },
238 { "keep_malformed", opt_time, &keep_malformed },
240 { "ldap_default_servers", opt_stringptr, &eldap_default_servers },
241 { "ldap_version", opt_int, &eldap_version },
243 { "local_from_check", opt_bool, &local_from_check },
244 { "local_from_prefix", opt_stringptr, &local_from_prefix },
245 { "local_from_suffix", opt_stringptr, &local_from_suffix },
246 { "local_interfaces", opt_stringptr, &local_interfaces },
247 { "local_scan_timeout", opt_time, &local_scan_timeout },
248 { "local_sender_retain", opt_bool, &local_sender_retain },
249 { "localhost_number", opt_stringptr, &host_number_string },
250 { "log_file_path", opt_stringptr, &log_file_path },
251 { "log_selector", opt_stringptr, &log_selector_string },
252 { "log_timezone", opt_bool, &log_timezone },
253 { "lookup_open_max", opt_int, &lookup_open_max },
254 { "max_username_length", opt_int, &max_username_length },
255 { "message_body_visible", opt_mkint, &message_body_visible },
256 { "message_id_header_domain", opt_stringptr, &message_id_domain },
257 { "message_id_header_text", opt_stringptr, &message_id_text },
258 { "message_logs", opt_bool, &message_logs },
259 { "message_size_limit", opt_stringptr, &message_size_limit },
260 #ifdef SUPPORT_MOVE_FROZEN_MESSAGES
261 { "move_frozen_messages", opt_bool, &move_frozen_messages },
263 { "mua_wrapper", opt_bool, &mua_wrapper },
265 { "mysql_servers", opt_stringptr, &mysql_servers },
267 { "never_users", opt_uidlist, &never_users },
269 { "oracle_servers", opt_stringptr, &oracle_servers },
271 { "percent_hack_domains", opt_stringptr, &percent_hack_domains },
273 { "perl_at_start", opt_bool, &opt_perl_at_start },
274 { "perl_startup", opt_stringptr, &opt_perl_startup },
277 { "pgsql_servers", opt_stringptr, &pgsql_servers },
279 { "pid_file_path", opt_stringptr, &pid_file_path },
280 { "pipelining_advertise_hosts", opt_stringptr, &pipelining_advertise_hosts },
281 { "preserve_message_logs", opt_bool, &preserve_message_logs },
282 { "primary_hostname", opt_stringptr, &primary_hostname },
283 { "print_topbitchars", opt_bool, &print_topbitchars },
284 { "process_log_path", opt_stringptr, &process_log_path },
285 { "prod_requires_admin", opt_bool, &prod_requires_admin },
286 { "qualify_domain", opt_stringptr, &qualify_domain_sender },
287 { "qualify_recipient", opt_stringptr, &qualify_domain_recipient },
288 { "queue_domains", opt_stringptr, &queue_domains },
289 { "queue_list_requires_admin",opt_bool, &queue_list_requires_admin },
290 { "queue_only", opt_bool, &queue_only },
291 { "queue_only_file", opt_stringptr, &queue_only_file },
292 { "queue_only_load", opt_fixed, &queue_only_load },
293 { "queue_only_override", opt_bool, &queue_only_override },
294 { "queue_run_in_order", opt_bool, &queue_run_in_order },
295 { "queue_run_max", opt_int, &queue_run_max },
296 { "queue_smtp_domains", opt_stringptr, &queue_smtp_domains },
297 { "receive_timeout", opt_time, &receive_timeout },
298 { "received_header_text", opt_stringptr, &received_header_text },
299 { "received_headers_max", opt_int, &received_headers_max },
300 { "recipient_unqualified_hosts", opt_stringptr, &recipient_unqualified_hosts },
301 { "recipients_max", opt_int, &recipients_max },
302 { "recipients_max_reject", opt_bool, &recipients_max_reject },
303 { "remote_max_parallel", opt_int, &remote_max_parallel },
304 { "remote_sort_domains", opt_stringptr, &remote_sort_domains },
305 { "retry_data_expire", opt_time, &retry_data_expire },
306 { "retry_interval_max", opt_time, &retry_interval_max },
307 { "return_path_remove", opt_bool, &return_path_remove },
308 { "return_size_limit", opt_mkint|opt_hidden, &bounce_return_size_limit },
309 { "rfc1413_hosts", opt_stringptr, &rfc1413_hosts },
310 { "rfc1413_query_timeout", opt_time, &rfc1413_query_timeout },
311 { "sender_unqualified_hosts", opt_stringptr, &sender_unqualified_hosts },
312 { "smtp_accept_keepalive", opt_bool, &smtp_accept_keepalive },
313 { "smtp_accept_max", opt_int, &smtp_accept_max },
314 { "smtp_accept_max_nonmail", opt_int, &smtp_accept_max_nonmail },
315 { "smtp_accept_max_nonmail_hosts", opt_stringptr, &smtp_accept_max_nonmail_hosts },
316 { "smtp_accept_max_per_connection", opt_int, &smtp_accept_max_per_connection },
317 { "smtp_accept_max_per_host", opt_stringptr, &smtp_accept_max_per_host },
318 { "smtp_accept_queue", opt_int, &smtp_accept_queue },
319 { "smtp_accept_queue_per_connection", opt_int, &smtp_accept_queue_per_connection },
320 { "smtp_accept_reserve", opt_int, &smtp_accept_reserve },
321 { "smtp_active_hostname", opt_stringptr, &raw_active_hostname },
322 { "smtp_banner", opt_stringptr, &smtp_banner },
323 { "smtp_check_spool_space", opt_bool, &smtp_check_spool_space },
324 { "smtp_connect_backlog", opt_int, &smtp_connect_backlog },
325 { "smtp_enforce_sync", opt_bool, &smtp_enforce_sync },
326 { "smtp_etrn_command", opt_stringptr, &smtp_etrn_command },
327 { "smtp_etrn_serialize", opt_bool, &smtp_etrn_serialize },
328 { "smtp_load_reserve", opt_fixed, &smtp_load_reserve },
329 { "smtp_max_synprot_errors", opt_int, &smtp_max_synprot_errors },
330 { "smtp_max_unknown_commands",opt_int, &smtp_max_unknown_commands },
331 { "smtp_ratelimit_hosts", opt_stringptr, &smtp_ratelimit_hosts },
332 { "smtp_ratelimit_mail", opt_stringptr, &smtp_ratelimit_mail },
333 { "smtp_ratelimit_rcpt", opt_stringptr, &smtp_ratelimit_rcpt },
334 { "smtp_receive_timeout", opt_time, &smtp_receive_timeout },
335 { "smtp_reserve_hosts", opt_stringptr, &smtp_reserve_hosts },
336 { "smtp_return_error_details",opt_bool, &smtp_return_error_details },
337 #ifdef WITH_CONTENT_SCAN
338 { "spamd_address", opt_stringptr, &spamd_address },
340 { "split_spool_directory", opt_bool, &split_spool_directory },
341 { "spool_directory", opt_stringptr, &spool_directory },
343 { "sqlite_lock_timeout", opt_int, &sqlite_lock_timeout },
345 #ifdef EXPERIMENTAL_SRS
346 { "srs_config", opt_stringptr, &srs_config },
347 { "srs_hashlength", opt_int, &srs_hashlength },
348 { "srs_hashmin", opt_int, &srs_hashmin },
349 { "srs_maxage", opt_int, &srs_maxage },
350 { "srs_secrets", opt_stringptr, &srs_secrets },
351 { "srs_usehash", opt_bool, &srs_usehash },
352 { "srs_usetimestamp", opt_bool, &srs_usetimestamp },
354 { "strip_excess_angle_brackets", opt_bool, &strip_excess_angle_brackets },
355 { "strip_trailing_dot", opt_bool, &strip_trailing_dot },
356 { "syslog_duplication", opt_bool, &syslog_duplication },
357 { "syslog_facility", opt_stringptr, &syslog_facility_str },
358 { "syslog_processname", opt_stringptr, &syslog_processname },
359 { "syslog_timestamp", opt_bool, &syslog_timestamp },
360 { "system_filter", opt_stringptr, &system_filter },
361 { "system_filter_directory_transport", opt_stringptr,&system_filter_directory_transport },
362 { "system_filter_file_transport",opt_stringptr,&system_filter_file_transport },
363 { "system_filter_group", opt_gid, &system_filter_gid },
364 { "system_filter_pipe_transport",opt_stringptr,&system_filter_pipe_transport },
365 { "system_filter_reply_transport",opt_stringptr,&system_filter_reply_transport },
366 { "system_filter_user", opt_uid, &system_filter_uid },
367 { "tcp_nodelay", opt_bool, &tcp_nodelay },
368 { "timeout_frozen_after", opt_time, &timeout_frozen_after },
369 { "timezone", opt_stringptr, &timezone_string },
371 { "tls_advertise_hosts", opt_stringptr, &tls_advertise_hosts },
372 { "tls_certificate", opt_stringptr, &tls_certificate },
373 { "tls_crl", opt_stringptr, &tls_crl },
374 { "tls_dhparam", opt_stringptr, &tls_dhparam },
375 { "tls_on_connect_ports", opt_stringptr, &tls_on_connect_ports },
376 { "tls_privatekey", opt_stringptr, &tls_privatekey },
377 { "tls_remember_esmtp", opt_bool, &tls_remember_esmtp },
378 { "tls_require_ciphers", opt_stringptr, &tls_require_ciphers },
379 { "tls_try_verify_hosts", opt_stringptr, &tls_try_verify_hosts },
380 { "tls_verify_certificates", opt_stringptr, &tls_verify_certificates },
381 { "tls_verify_hosts", opt_stringptr, &tls_verify_hosts },
383 { "trusted_groups", opt_gidlist, &trusted_groups },
384 { "trusted_users", opt_uidlist, &trusted_users },
385 { "unknown_login", opt_stringptr, &unknown_login },
386 { "unknown_username", opt_stringptr, &unknown_username },
387 { "untrusted_set_sender", opt_stringptr, &untrusted_set_sender },
388 { "uucp_from_pattern", opt_stringptr, &uucp_from_pattern },
389 { "uucp_from_sender", opt_stringptr, &uucp_from_sender },
390 { "warn_message_file", opt_stringptr, &warn_message_file },
391 { "write_rejectlog", opt_bool, &write_rejectlog }
394 static int optionlist_config_size =
395 sizeof(optionlist_config)/sizeof(optionlist);
399 /*************************************************
400 * Find the name of an option *
401 *************************************************/
403 /* This function is to aid debugging. Various functions take arguments that are
404 pointer variables in the options table or in option tables for various drivers.
405 For debugging output, it is useful to be able to find the name of the option
406 which is currently being processed. This function finds it, if it exists, by
407 searching the table(s).
409 Arguments: a value that is presumed to be in the table above
410 Returns: the option name, or an empty string
414 readconf_find_option(void *p)
418 transport_instance *t;
420 for (i = 0; i < optionlist_config_size; i++)
421 if (p == optionlist_config[i].value) return US optionlist_config[i].name;
423 for (r = routers; r != NULL; r = r->next)
425 router_info *ri = r->info;
426 for (i = 0; i < ri->options_count[0]; i++)
428 if ((ri->options[i].type & opt_mask) != opt_stringptr) continue;
429 if (p == (char *)(r->options_block) + (long int)(ri->options[i].value))
430 return US ri->options[i].name;
434 for (t = transports; t != NULL; t = t->next)
436 transport_info *ti = t->info;
437 for (i = 0; i < ti->options_count[0]; i++)
439 if ((ti->options[i].type & opt_mask) != opt_stringptr) continue;
440 if (p == (char *)(t->options_block) + (long int)(ti->options[i].value))
441 return US ti->options[i].name;
451 /*************************************************
452 * Deal with an assignment to a macro *
453 *************************************************/
455 /* This function is called when a line that starts with an upper case letter is
456 encountered. The argument "line" should contain a complete logical line, and
457 start with the first letter of the macro name. The macro name and the
458 replacement text are extracted and stored. Redefinition of existing,
459 non-command line, macros is permitted using '==' instead of '='.
462 s points to the start of the logical line
468 read_macro_assignment(uschar *s)
474 macro_item *mlast = NULL;
476 while (isalnum(*s) || *s == '_')
478 if (namelen >= sizeof(name) - 1)
479 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
480 "macro name too long (maximum is %d characters)", sizeof(name) - 1);
481 name[namelen++] = *s++;
485 while (isspace(*s)) s++;
487 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "malformed macro definition");
494 while (isspace(*s)) s++;
496 /* If an existing macro of the same name was defined on the command line, we
497 just skip this definition. It's an error to attempt to redefine a macro without
498 redef set to TRUE, or to redefine a macro when it hasn't been defined earlier.
499 It is also an error to define a macro whose name begins with the name of a
500 previously defined macro. Note: it is documented that the other way round
503 for (m = macros; m != NULL; m = m->next)
505 int len = Ustrlen(m->name);
507 if (Ustrcmp(m->name, name) == 0)
509 if (!m->command_line && !redef)
510 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "macro \"%s\" is already "
511 "defined (use \"==\" if you want to redefine it", name);
515 if (len < namelen && Ustrstr(name, m->name) != NULL)
516 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
517 "a macro because previously defined macro \"%s\" is a substring",
520 /* We cannot have this test, because it is documented that a substring
521 macro is permitted (there is even an example).
523 * if (len > namelen && Ustrstr(m->name, name) != NULL)
524 * log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "\"%s\" cannot be defined as "
525 * "a macro because it is a substring of previously defined macro \"%s\"",
532 /* Check for an overriding command-line definition. */
534 if (m != NULL && m->command_line) return;
536 /* Redefinition must refer to an existing macro. */
541 log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "can't redefine an undefined macro "
545 /* We have a new definition. The macro_item structure includes a final vector
546 called "name" which is one byte long. Thus, adding "namelen" gives us enough
547 room to store the "name" string. */
551 m = store_get(sizeof(macro_item) + namelen);
552 if (macros == NULL) macros = m; else mlast->next = m;
553 Ustrncpy(m->name, name, namelen);
554 m->name[namelen] = 0;
556 m->command_line = FALSE;
559 /* Set the value of the new or redefined macro */
561 m->replacement = string_copy(s);
568 /*************************************************
569 * Read configuration line *
570 *************************************************/
572 /* A logical line of text is read from the configuration file into the big
573 buffer, taking account of macros, .includes, and continuations. The size of
574 big_buffer is increased if necessary. The count of configuration lines is
575 maintained. Physical input lines starting with # (ignoring leading white space,
576 and after macro replacement) and empty logical lines are always ignored.
577 Leading and trailing spaces are removed.
579 If we hit a line of the form "begin xxxx", the xxxx is placed in the
580 next_section vector, and the function returns NULL, indicating the end of a
581 configuration section. On end-of-file, NULL is returned with next_section
586 Returns: a pointer to the first non-blank in the line,
587 or NULL if eof or end of section is reached
591 get_config_line(void)
593 int startoffset = 0; /* To first non-blank char in logical line */
594 int len = 0; /* Of logical line so far */
600 /* Loop for handling continuation lines, skipping comments, and dealing with
605 if (Ufgets(big_buffer+len, big_buffer_size-len, config_file) == NULL)
607 if (config_file_stack != NULL) /* EOF inside .include */
609 (void)fclose(config_file);
610 config_file = config_file_stack->file;
611 config_filename = config_file_stack->filename;
612 config_lineno = config_file_stack->lineno;
613 config_file_stack = config_file_stack->next;
617 /* EOF at top level */
619 if (cstate_stack_ptr >= 0)
620 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
621 "Unexpected end of configuration file: .endif missing");
623 if (len != 0) break; /* EOF after continuation */
624 next_section[0] = 0; /* EOF at start of logical line */
629 newlen = len + Ustrlen(big_buffer + len);
631 /* Handle pathologically long physical lines - yes, it did happen - by
632 extending big_buffer at this point. The code also copes with very long
635 while (newlen == big_buffer_size - 1 && big_buffer[newlen - 1] != '\n')
638 big_buffer_size += BIG_BUFFER_SIZE;
639 newbuffer = store_malloc(big_buffer_size);
641 /* This use of strcpy is OK because we know that the string in the old
642 buffer is shorter than the new buffer. */
644 Ustrcpy(newbuffer, big_buffer);
645 store_free(big_buffer);
646 big_buffer = newbuffer;
647 if (Ufgets(big_buffer+newlen, big_buffer_size-newlen, config_file) == NULL)
649 newlen += Ustrlen(big_buffer + newlen);
652 /* Find the true start of the physical line - leading spaces are always
655 ss = big_buffer + len;
656 while (isspace(*ss)) ss++;
658 /* Process the physical line for macros. If this is the start of the logical
659 line, skip over initial text at the start of the line if it starts with an
660 upper case character followed by a sequence of name characters and an equals
661 sign, because that is the definition of a new macro, and we don't do
662 replacement therein. */
665 if (len == 0 && isupper(*s))
667 while (isalnum(*s) || *s == '_') s++;
668 while (isspace(*s)) s++;
669 if (*s != '=') s = ss; /* Not a macro definition */
672 /* For each defined macro, scan the line (from after XXX= if present),
673 replacing all occurrences of the macro. */
676 for (m = macros; m != NULL; m = m->next)
681 while ((p = Ustrstr(t, m->name)) != NULL)
684 int namelen = Ustrlen(m->name);
685 int replen = Ustrlen(m->replacement);
687 /* Expand the buffer if necessary */
689 while (newlen - namelen + replen + 1 > big_buffer_size)
691 int newsize = big_buffer_size + BIG_BUFFER_SIZE;
692 uschar *newbuffer = store_malloc(newsize);
693 memcpy(newbuffer, big_buffer, newlen + 1);
694 p = newbuffer + (p - big_buffer);
695 s = newbuffer + (s - big_buffer);
696 ss = newbuffer + (ss - big_buffer);
697 t = newbuffer + (t - big_buffer);
698 big_buffer_size = newsize;
699 store_free(big_buffer);
700 big_buffer = newbuffer;
703 /* Shuffle the remaining characters up or down in the buffer before
704 copying in the replacement text. Don't rescan the replacement for this
708 moveby = replen - namelen;
711 memmove(p + replen, pp, (big_buffer + newlen) - pp + 1);
714 Ustrncpy(p, m->replacement, replen);
720 /* An empty macro replacement at the start of a line could mean that ss no
721 longer points to the first non-blank character. */
723 while (isspace(*ss)) ss++;
725 /* Check for comment lines - these are physical lines. */
727 if (*ss == '#') continue;
729 /* Handle conditionals, which are also applied to physical lines. Conditions
730 are of the form ".ifdef ANYTEXT" and are treated as true if any macro
731 expansion occured on the rest of the line. A preliminary test for the leading
732 '.' saves effort on most lines. */
738 /* Search the list of conditional directives */
740 for (i = 0; i < cond_list_size; i++)
743 cond_item *c = cond_list+i;
744 if (Ustrncmp(ss+1, c->name, c->namelen) != 0) continue;
746 /* The following character must be white space or end of string */
748 n = ss[1 + c->namelen];
749 if (n != ' ' && n != 't' && n != '\n' && n != 0) break;
751 /* .ifdef and .ifndef push the current state onto the stack, then set
752 a new one from the table. Stack overflow is an error */
756 if (cstate_stack_ptr >= CSTATE_STACK_SIZE - 1)
757 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
758 ".%s nested too deeply", c->name);
759 cstate_stack[++cstate_stack_ptr] = cstate;
760 cstate = next_cstate[cstate][macro_found? c->action1 : c->action2];
763 /* For any of the others, stack underflow is an error. The next state
764 comes either from the stack (.endif) or from the table. */
768 if (cstate_stack_ptr < 0)
769 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
770 ".%s without matching .ifdef", c->name);
771 cstate = (c->pushpop < 0)? cstate_stack[cstate_stack_ptr--] :
772 next_cstate[cstate][macro_found? c->action1 : c->action2];
775 /* Having dealt with a directive, break the loop */
780 /* If we have handled a conditional directive, continue with the next
781 physical line. Otherwise, fall through. */
783 if (i < cond_list_size) continue;
786 /* If the conditional state is not 0 (actively using these lines), ignore
789 if (cstate != 0) continue; /* Conditional skip */
791 /* Handle .include lines - these are also physical lines. */
793 if (Ustrncmp(ss, ".include", 8) == 0 &&
795 (Ustrncmp(ss+8, "_if_exists", 10) == 0 && isspace(ss[18]))))
798 int include_if_exists = isspace(ss[8])? 0 : 10;
799 config_file_item *save;
802 ss += 9 + include_if_exists;
803 while (isspace(*ss)) ss++;
804 t = ss + Ustrlen(ss);
805 while (t > ss && isspace(t[-1])) t--;
806 if (*ss == '\"' && t[-1] == '\"')
813 if (include_if_exists != 0 && (Ustat(ss, &statbuf) != 0)) continue;
815 save = store_get(sizeof(config_file_item));
816 save->next = config_file_stack;
817 config_file_stack = save;
818 save->file = config_file;
819 save->filename = config_filename;
820 save->lineno = config_lineno;
822 config_file = Ufopen(ss, "rb");
823 if (config_file == NULL)
824 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "failed to open included "
825 "configuration file %s", ss);
826 config_filename = string_copy(ss);
831 /* If this is the start of the logical line, remember where the non-blank
832 data starts. Otherwise shuffle down continuation lines to remove leading
836 startoffset = ss - big_buffer;
839 s = big_buffer + len;
842 memmove(s, ss, (newlen - len) - (ss - s) + 1);
847 /* Accept the new addition to the line. Remove trailing white space. */
850 while (len > 0 && isspace(big_buffer[len-1])) len--;
853 /* We are done if the line does not end in backslash and contains some data.
854 Empty logical lines are ignored. For continuations, remove the backslash and
855 go round the loop to read the continuation line. */
859 if (big_buffer[len-1] != '\\') break; /* End of logical line */
860 big_buffer[--len] = 0; /* Remove backslash */
862 } /* Loop for reading multiple physical lines */
864 /* We now have a logical line. Test for the end of a configuration section (or,
865 more accurately, for the start of the next section). Place the name of the next
866 section in next_section, and return NULL. If the name given is longer than
867 next_section, truncate it. It will be unrecognized later, because all the known
868 section names do fit. Leave space for pluralizing. */
870 s = big_buffer + startoffset; /* First non-space character */
871 if (strncmpic(s, US"begin ", 6) == 0)
874 while (isspace(*s)) s++;
875 if (big_buffer + len - s > sizeof(next_section) - 2)
876 s[sizeof(next_section) - 2] = 0;
877 Ustrcpy(next_section, s);
881 /* Return the first non-blank character. */
888 /*************************************************
890 *************************************************/
892 /* The yield is the pointer to the next uschar. Names longer than the
893 output space are silently truncated. This function is also used from acl.c when
897 name where to put the name
901 Returns: new input pointer
905 readconf_readname(uschar *name, int len, uschar *s)
908 while (isspace(*s)) s++;
911 while (isalnum(*s) || *s == '_')
913 if (p < len-1) name[p++] = *s;
918 while (isspace(*s)) s++;
925 /*************************************************
926 * Read a time value *
927 *************************************************/
929 /* This function is also called from outside, to read argument
930 time values. The format of a time value is:
932 [<n>w][<n>d][<n>h][<n>m][<n>s]
934 as long as at least one is present. If a format error is encountered,
935 return a negative value. The value must be terminated by the given
940 terminator required terminating character
941 return_msec if TRUE, allow fractional seconds and return milliseconds
943 Returns: the time value, or -1 on syntax error
944 value is seconds if return_msec is FALSE
945 value is milliseconds if return_msec is TRUE
949 readconf_readtime(uschar *s, int terminator, BOOL return_msec)
957 if (!isdigit(*s)) return -1;
958 (void)sscanf(CS s, "%d%n", &value, &count);
963 case 'w': value *= 7;
964 case 'd': value *= 24;
965 case 'h': value *= 60;
966 case 'm': value *= 60;
971 if (!return_msec) return -1;
972 (void)sscanf(CS s, "%lf%n", &fraction, &count);
974 if (*s++ != 's') return -1;
975 yield += (int)(fraction * 1000.0);
981 if (return_msec) value *= 1000;
983 if (*s == terminator) return yield;
985 /* Control never reaches here. */
990 /*************************************************
991 * Read a fixed point value *
992 *************************************************/
994 /* The value is returned *1000
998 terminator required terminator
1000 Returns: the value, or -1 on error
1004 readconf_readfixed(uschar *s, int terminator)
1008 if (!isdigit(*s)) return -1;
1009 (void)sscanf(CS s, "%d%n", &value, &count);
1011 yield = value * 1000;
1015 while (isdigit((*(++s))))
1017 yield += (*s - '0') * m;
1022 return (*s == terminator)? yield : (-1);
1027 /*************************************************
1028 * Find option in list *
1029 *************************************************/
1031 /* The lists are always in order, so binary chop can be used.
1034 name the option name to search for
1035 ol the first entry in the option list
1036 last one more than the offset of the last entry in the option list
1038 Returns: pointer to an option entry, or NULL if not found
1042 find_option(uschar *name, optionlist *ol, int last)
1045 while (last > first)
1047 int middle = (first + last)/2;
1048 int c = Ustrcmp(name, ol[middle].name);
1049 if (c == 0) return ol + middle;
1050 else if (c > 0) first = middle + 1;
1058 /*************************************************
1059 * Find a set flag in option list *
1060 *************************************************/
1062 /* Because some versions of Unix make no restrictions on the values of uids and
1063 gids (even negative ones), we cannot represent "unset" by a special value.
1064 There is therefore a separate boolean variable for each one indicating whether
1065 a value is set or not. This function returns a pointer to the boolean, given
1066 the original option name. It is a major disaster if the flag cannot be found.
1069 name the name of the uid or gid option
1070 oltop points to the start of the relevant option list
1071 last one more than the offset of the last item in the option list
1072 data_block NULL when reading main options => data values in the option
1073 list are absolute addresses; otherwise they are byte offsets
1074 in data_block (used for driver options)
1076 Returns: a pointer to the boolean flag.
1080 get_set_flag(uschar *name, optionlist *oltop, int last, void *data_block)
1084 sprintf(CS name2, "*set_%.50s", name);
1085 ol = find_option(name2, oltop, last);
1086 if (ol == NULL) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1087 "Exim internal error: missing set flag for %s", name);
1088 return (data_block == NULL)? (BOOL *)(ol->value) :
1089 (BOOL *)((uschar *)data_block + (long int)(ol->value));
1095 /*************************************************
1096 * Output extra characters message and die *
1097 *************************************************/
1099 /* Called when an option line has junk on the end. Sometimes this is because
1100 the sysadmin thinks comments are permitted.
1103 s points to the extra characters
1104 t1..t3 strings to insert in the log message
1106 Returns: doesn't return; dies
1110 extra_chars_error(uschar *s, uschar *t1, uschar *t2, uschar *t3)
1112 uschar *comment = US"";
1113 if (*s == '#') comment = US" (# is comment only at line start)";
1114 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1115 "extra characters follow %s%s%s%s", t1, t2, t3, comment);
1120 /*************************************************
1121 * Read rewrite information *
1122 *************************************************/
1124 /* Each line of rewrite information contains:
1126 . A complete address in the form user@domain, possibly with
1127 leading * for each part; or alternatively, a regex.
1129 . A replacement string (which will be expanded).
1131 . An optional sequence of one-letter flags, indicating which
1132 headers etc. to apply this rule to.
1134 All this is decoded and placed into a control block. The OR of the flags is
1135 maintained in a common word.
1138 p points to the string that makes up the rule
1139 existflags points to the overall flag word
1140 isglobal TRUE if reading global rewrite rules
1142 Returns: the control block for the parsed rule.
1145 static rewrite_rule *
1146 readconf_one_rewrite(uschar *p, int *existflags, BOOL isglobal)
1148 rewrite_rule *next = store_get(sizeof(rewrite_rule));
1151 next->key = string_dequote(&p);
1153 while (isspace(*p)) p++;
1155 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1156 "missing rewrite replacement string");
1159 next->replacement = string_dequote(&p);
1161 while (*p != 0) switch (*p++)
1163 case ' ': case '\t': break;
1165 case 'q': next->flags |= rewrite_quit; break;
1166 case 'w': next->flags |= rewrite_whole; break;
1168 case 'h': next->flags |= rewrite_all_headers; break;
1169 case 's': next->flags |= rewrite_sender; break;
1170 case 'f': next->flags |= rewrite_from; break;
1171 case 't': next->flags |= rewrite_to; break;
1172 case 'c': next->flags |= rewrite_cc; break;
1173 case 'b': next->flags |= rewrite_bcc; break;
1174 case 'r': next->flags |= rewrite_replyto; break;
1176 case 'E': next->flags |= rewrite_all_envelope; break;
1177 case 'F': next->flags |= rewrite_envfrom; break;
1178 case 'T': next->flags |= rewrite_envto; break;
1180 case 'Q': next->flags |= rewrite_qualify; break;
1181 case 'R': next->flags |= rewrite_repeat; break;
1184 next->flags |= rewrite_smtp;
1185 if (next->key[0] != '^' && Ustrncmp(next->key, "\\N^", 3) != 0)
1186 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1187 "rewrite rule has the S flag but is not a regular expression");
1191 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1192 "unknown rewrite flag character '%c' "
1193 "(could be missing quotes round replacement item)", p[-1]);
1197 /* If no action flags are set, set all the "normal" rewrites. */
1199 if ((next->flags & (rewrite_all | rewrite_smtp)) == 0)
1200 next->flags |= isglobal? rewrite_all : rewrite_all_headers;
1202 /* Remember which exist, for optimization, and return the rule */
1204 *existflags |= next->flags;
1211 /*************************************************
1212 * Read global rewrite information *
1213 *************************************************/
1215 /* Each line is a single rewrite rule; it is parsed into a control block
1216 by readconf_one_rewrite(), and its flags are ORed into the global flag
1217 word rewrite_existflags. */
1220 readconf_rewrites(void)
1222 rewrite_rule **chain = &global_rewrite_rules;
1225 while ((p = get_config_line()) != NULL)
1227 rewrite_rule *next = readconf_one_rewrite(p, &rewrite_existflags, TRUE);
1229 chain = &(next->next);
1235 /*************************************************
1237 *************************************************/
1239 /* Strings are read into the normal store pool. As long we aren't too
1240 near the end of the current block, the string will just use what is necessary
1241 on the top of the stacking pool, because string_cat() uses the extension
1245 s the rest of the input line
1246 name the option name (for errors)
1248 Returns: pointer to the string
1252 read_string(uschar *s, uschar *name)
1257 if (*s != '\"') return string_copy(s);
1260 yield = string_dequote(&s);
1262 if (s == ss+1 || s[-1] != '\"')
1263 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1264 "missing quote at end of string value for %s", name);
1266 if (*s != 0) extra_chars_error(s, US"string value for ", name, US"");
1272 /*************************************************
1273 * Handle option line *
1274 *************************************************/
1276 /* This function is called from several places to process a line containing the
1277 setting of an option. The first argument is the line to be decoded; it has been
1278 checked not to be empty and not to start with '#'. Trailing newlines and white
1279 space have been removed. The second argument is a pointer to the list of
1280 variable names that are to be recognized, together with their types and
1281 locations, and the third argument gives the number of entries in the list.
1283 The fourth argument is a pointer to a data block. If it is NULL, then the data
1284 values in the options list are absolute addresses. Otherwise, they are byte
1285 offsets in the data block.
1287 String option data may continue onto several lines; this function reads further
1288 data from config_file if necessary.
1290 The yield of this function is normally zero. If a string continues onto
1291 multiple lines, then the data value is permitted to be followed by a comma
1292 or a semicolon (for use in drivers) and the yield is that character.
1295 buffer contains the configuration line to be handled
1296 oltop points to the start of the relevant option list
1297 last one more than the offset of the last item in the option list
1298 data_block NULL when reading main options => data values in the option
1299 list are absolute addresses; otherwise they are byte offsets
1300 in data_block when they have opt_public set; otherwise
1301 they are byte offsets in data_block->options_block.
1302 unknown_txt format string to use in panic message for unknown option;
1303 must contain %s for option name
1304 if given as NULL, don't panic on unknown option
1306 Returns: TRUE if an option was read successfully,
1307 FALSE false for an unknown option if unknown_txt == NULL,
1308 otherwise panic and die on an unknown option
1312 readconf_handle_option(uschar *buffer, optionlist *oltop, int last,
1313 void *data_block, uschar *unknown_txt)
1317 int n, count, type, value;
1321 BOOL boolvalue = TRUE;
1322 BOOL freesptr = TRUE;
1323 optionlist *ol, *ol2;
1327 uschar *inttype = US"";
1333 /* There may be leading spaces; thereafter, we expect an option name starting
1336 while (isspace(*s)) s++;
1338 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option setting expected: %s", s);
1340 /* Read the name of the option, and skip any subsequent white space. If
1341 it turns out that what we read was "hide", set the flag indicating that
1342 this is a secure option, and loop to read the next word. */
1344 for (n = 0; n < 2; n++)
1346 while (isalnum(*s) || *s == '_')
1348 if (ptr < sizeof(name)-1) name[ptr++] = *s;
1352 while (isspace(*s)) s++;
1353 if (Ustrcmp(name, "hide") != 0) break;
1354 issecure = opt_secure;
1358 /* Deal with "no_" or "not_" here for booleans */
1360 if (Ustrncmp(name, "no_", 3) == 0)
1366 if (Ustrncmp(name, "not_", 4) == 0)
1372 /* Search the list for the given name. A non-existent name, or an option that
1373 is set twice, is a disaster. */
1375 ol = find_option(name + offset, oltop, last);
1379 if (unknown_txt == NULL) return FALSE;
1380 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, CS unknown_txt, name);
1383 if ((ol->type & opt_set) != 0)
1385 uschar *mname = name;
1386 if (Ustrncmp(mname, "no_", 3) == 0) mname += 3;
1387 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1388 "\"%s\" option set for the second time", mname);
1391 ol->type |= opt_set | issecure;
1392 type = ol->type & opt_mask;
1394 /* Types with data values must be followed by '='; the "no[t]_" prefix
1395 applies only to boolean values. */
1397 if (type < opt_bool || type > opt_bool_last)
1400 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1401 "negation prefix applied to a non-boolean option");
1403 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1404 "unexpected end of line (data missing) after %s", name);
1406 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing \"=\" after %s", name);
1409 /* If a boolean wasn't preceded by "no[t]_" it can be followed by = and
1410 true/false/yes/no, or, in the case of opt_expanded_bool, a general string that
1411 ultimately expands to one of those values. */
1413 else if (*s != 0 && (offset != 0 || *s != '='))
1414 extra_chars_error(s, US"boolean option ", name, US"");
1416 /* Skip white space after = */
1418 if (*s == '=') while (isspace((*(++s))));
1420 /* If there is a data block and the opt_public flag is not set, change
1421 the data block pointer to the private options block. */
1423 if (data_block != NULL && (ol->type & opt_public) == 0)
1424 data_block = (void *)(((driver_instance *)data_block)->options_block);
1426 /* Now get the data according to the type. */
1430 /* If a string value is not enclosed in quotes, it consists of
1431 the rest of the current line, verbatim. Otherwise, string escapes
1434 A transport is specified as a string, which is then looked up in the
1435 list of transports. A search type is specified as one of a number of
1438 A set or rewrite rules for a driver is specified as a string, which is
1439 then parsed into a suitable chain of control blocks.
1441 Uids and gids are specified as strings which are then looked up in the
1442 passwd file. Lists of uids and gids are similarly specified as colon-
1443 separated strings. */
1448 case opt_expand_uid:
1449 case opt_expand_gid:
1454 reset_point = sptr = read_string(s, name);
1456 /* Having read a string, we now have several different ways of using it,
1457 depending on the data type, so do another switch. If keeping the actual
1458 string is not required (because it is interpreted), freesptr is set TRUE,
1459 and at the end we reset the pool. */
1463 /* If this was a string, set the variable to point to the new string,
1464 and set the flag so its store isn't reclaimed. If it was a list of rewrite
1465 rules, we still keep the string (for printing), and parse the rules into a
1466 control block and flags word. */
1470 if (data_block == NULL)
1471 *((uschar **)(ol->value)) = sptr;
1473 *((uschar **)((uschar *)data_block + (long int)(ol->value))) = sptr;
1475 if (type == opt_rewrite)
1480 rewrite_rule **chain;
1483 sprintf(CS name2, "*%.50s_rules", name);
1484 ol2 = find_option(name2, oltop, last);
1485 sprintf(CS name2, "*%.50s_flags", name);
1486 ol3 = find_option(name2, oltop, last);
1488 if (ol2 == NULL || ol3 == NULL)
1489 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1490 "rewrite rules not available for driver");
1492 if (data_block == NULL)
1494 chain = (rewrite_rule **)(ol2->value);
1495 flagptr = (int *)(ol3->value);
1499 chain = (rewrite_rule **)((uschar *)data_block + (long int)(ol2->value));
1500 flagptr = (int *)((uschar *)data_block + (long int)(ol3->value));
1503 while ((p = string_nextinlist(&sptr, &sep, big_buffer, BIG_BUFFER_SIZE))
1506 rewrite_rule *next = readconf_one_rewrite(p, flagptr, FALSE);
1508 chain = &(next->next);
1511 if ((*flagptr & (rewrite_all_envelope | rewrite_smtp)) != 0)
1512 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "rewrite rule specifies a "
1513 "non-header rewrite - not allowed at transport time -");
1517 /* If it was an expanded uid, see if there is any expansion to be
1518 done by checking for the presence of a $ character. If there is, save it
1519 in the corresponding *expand_user option field. Otherwise, fall through
1520 to treat it as a fixed uid. Ensure mutual exclusivity of the two kinds
1523 case opt_expand_uid:
1524 sprintf(CS name2, "*expand_%.50s", name);
1525 ol2 = find_option(name2, oltop, last);
1528 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1530 if (data_block == NULL)
1531 *((uschar **)(ol2->value)) = ss;
1533 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1537 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1543 /* Look up a fixed uid, and also make use of the corresponding gid
1544 if a passwd entry is returned and the gid has not been set. */
1547 if (!route_finduser(sptr, &pw, &uid))
1548 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found", sptr);
1549 if (data_block == NULL)
1550 *((uid_t *)(ol->value)) = uid;
1552 *((uid_t *)((uschar *)data_block + (long int)(ol->value))) = uid;
1554 /* Set the flag indicating a fixed value is set */
1556 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1558 /* Handle matching gid if we have a passwd entry: done by finding the
1559 same name with terminating "user" changed to "group"; if not found,
1560 ignore. Also ignore if the value is already set. */
1562 if (pw == NULL) break;
1563 Ustrcpy(name+Ustrlen(name)-4, "group");
1564 ol2 = find_option(name, oltop, last);
1565 if (ol2 != NULL && ((ol2->type & opt_mask) == opt_gid ||
1566 (ol2->type & opt_mask) == opt_expand_gid))
1568 BOOL *set_flag = get_set_flag(name, oltop, last, data_block);
1571 if (data_block == NULL)
1572 *((gid_t *)(ol2->value)) = pw->pw_gid;
1574 *((gid_t *)((uschar *)data_block + (long int)(ol2->value))) = pw->pw_gid;
1580 /* If it was an expanded gid, see if there is any expansion to be
1581 done by checking for the presence of a $ character. If there is, save it
1582 in the corresponding *expand_user option field. Otherwise, fall through
1583 to treat it as a fixed gid. Ensure mutual exclusivity of the two kinds
1586 case opt_expand_gid:
1587 sprintf(CS name2, "*expand_%.50s", name);
1588 ol2 = find_option(name2, oltop, last);
1591 uschar *ss = (Ustrchr(sptr, '$') != NULL)? sptr : NULL;
1593 if (data_block == NULL)
1594 *((uschar **)(ol2->value)) = ss;
1596 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = ss;
1600 *(get_set_flag(name, oltop, last, data_block)) = FALSE;
1606 /* Handle freestanding gid */
1609 if (!route_findgroup(sptr, &gid))
1610 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found", sptr);
1611 if (data_block == NULL)
1612 *((gid_t *)(ol->value)) = gid;
1614 *((gid_t *)((uschar *)data_block + (long int)(ol->value))) = gid;
1615 *(get_set_flag(name, oltop, last, data_block)) = TRUE;
1618 /* If it was a uid list, look up each individual entry, and build
1619 a vector of uids, with a count in the first element. Put the vector
1620 in malloc store so we can free the string. (We are reading into
1621 permanent store already.) */
1630 if (*p != 0) count++;
1631 while (*p != 0) if (*p++ == ':') count++;
1632 list = store_malloc(count*sizeof(uid_t));
1633 list[ptr++] = (uid_t)(count - 1);
1635 if (data_block == NULL)
1636 *((uid_t **)(ol->value)) = list;
1638 *((uid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1644 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1645 if (!route_finduser(big_buffer, NULL, &uid))
1646 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "user %s was not found",
1653 /* If it was a gid list, look up each individual entry, and build
1654 a vector of gids, with a count in the first element. Put the vector
1655 in malloc store so we can free the string. (We are reading into permanent
1665 if (*p != 0) count++;
1666 while (*p != 0) if (*p++ == ':') count++;
1667 list = store_malloc(count*sizeof(gid_t));
1668 list[ptr++] = (gid_t)(count - 1);
1670 if (data_block == NULL)
1671 *((gid_t **)(ol->value)) = list;
1673 *((gid_t **)((uschar *)data_block + (long int)(ol->value))) = list;
1679 (void)string_nextinlist(&p, &sep, big_buffer, BIG_BUFFER_SIZE);
1680 if (!route_findgroup(big_buffer, &gid))
1681 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "group %s was not found",
1689 /* Release store if the value of the string doesn't need to be kept. */
1691 if (freesptr) store_reset(reset_point);
1694 /* Expanded boolean: if no characters follow, or if there are no dollar
1695 characters, this is a fixed-valued boolean, and we fall through. Otherwise,
1696 save the string for later expansion in the alternate place. */
1698 case opt_expand_bool:
1699 if (*s != 0 && Ustrchr(s, '$') != 0)
1701 sprintf(CS name2, "*expand_%.50s", name);
1702 ol2 = find_option(name2, oltop, last);
1705 reset_point = sptr = read_string(s, name);
1706 if (data_block == NULL)
1707 *((uschar **)(ol2->value)) = sptr;
1709 *((uschar **)((uschar *)data_block + (long int)(ol2->value))) = sptr;
1716 /* Boolean: if no characters follow, the value is boolvalue. Otherwise
1717 look for yes/not/true/false. Some booleans are stored in a single bit in
1718 a single int. There's a special fudge for verify settings; without a suffix
1719 they set both xx_sender and xx_recipient. The table points to the sender
1720 value; search subsequently for the recipient. There's another special case:
1721 opt_bool_set also notes when a boolean has been set. */
1725 case opt_bool_verify:
1729 s = readconf_readname(name2, 64, s);
1730 if (strcmpic(name2, US"true") == 0 || strcmpic(name2, US"yes") == 0)
1732 else if (strcmpic(name2, US"false") == 0 || strcmpic(name2, US"no") == 0)
1734 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1735 "\"%s\" is not a valid value for the \"%s\" option", name2, name);
1736 if (*s != 0) extra_chars_error(s, string_sprintf("\"%s\" ", name2),
1737 US"for boolean option ", name);
1740 /* Handle single-bit type. */
1742 if (type == opt_bit)
1744 int bit = 1 << ((ol->type >> 16) & 31);
1745 int *ptr = (data_block == NULL)?
1746 (int *)(ol->value) :
1747 (int *)((uschar *)data_block + (long int)ol->value);
1748 if (boolvalue) *ptr |= bit; else *ptr &= ~bit;
1752 /* Handle full BOOL types */
1754 if (data_block == NULL)
1755 *((BOOL *)(ol->value)) = boolvalue;
1757 *((BOOL *)((uschar *)data_block + (long int)(ol->value))) = boolvalue;
1761 if (type == opt_bool_verify)
1763 sprintf(CS name2, "%.50s_recipient", name + offset);
1764 ol2 = find_option(name2, oltop, last);
1767 if (data_block == NULL)
1768 *((BOOL *)(ol2->value)) = boolvalue;
1770 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = boolvalue;
1774 /* Note that opt_bool_set type is set, if there is somewhere to do so */
1776 else if (type == opt_bool_set)
1778 sprintf(CS name2, "*set_%.50s", name + offset);
1779 ol2 = find_option(name2, oltop, last);
1782 if (data_block == NULL)
1783 *((BOOL *)(ol2->value)) = TRUE;
1785 *((BOOL *)((uschar *)data_block + (long int)(ol2->value))) = TRUE;
1794 inttype = US"octal ";
1796 /* Integer: a simple(ish) case; allow octal and hex formats, and
1797 suffixes K and M. The different types affect output, not input. */
1804 value = strtol(CS s, CSS &endptr, intbase);
1807 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1810 if (errno != ERANGE)
1812 if (tolower(*endptr) == 'k')
1814 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1818 else if (tolower(*endptr) == 'm')
1820 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
1822 else value *= 1024*1024;
1827 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1828 "absolute value of integer \"%s\" is too large (overflow)", s);
1830 while (isspace(*endptr)) endptr++;
1832 extra_chars_error(endptr, inttype, US"integer value for ", name);
1835 if (data_block == NULL)
1836 *((int *)(ol->value)) = value;
1838 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1841 /* Integer held in K: again, allow octal and hex formats, and suffixes K and
1848 value = strtol(CS s, CSS &endptr, intbase);
1851 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%sinteger expected for %s",
1854 if (errno != ERANGE)
1856 if (tolower(*endptr) == 'm')
1858 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
1862 else if (tolower(*endptr) == 'k')
1868 value = (value + 512)/1024;
1872 if (errno == ERANGE) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1873 "absolute value of integer \"%s\" is too large (overflow)", s);
1875 while (isspace(*endptr)) endptr++;
1877 extra_chars_error(endptr, inttype, US"integer value for ", name);
1880 if (data_block == NULL)
1881 *((int *)(ol->value)) = value;
1883 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1886 /* Fixed-point number: held to 3 decimal places. */
1889 if (sscanf(CS s, "%d%n", &value, &count) != 1)
1890 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1891 "fixed-point number expected for %s", name);
1893 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1894 "integer \"%s\" is too large (overflow)", s);
1898 if (value < 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1899 "integer \"%s\" is too large (overflow)", s);
1901 if (s[count] == '.')
1904 while (isdigit(s[++count]))
1906 value += (s[count] - '0') * d;
1911 while (isspace(s[count])) count++;
1914 extra_chars_error(s+count, US"fixed-point value for ", name, US"");
1916 if (data_block == NULL)
1917 *((int *)(ol->value)) = value;
1919 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1922 /* There's a special routine to read time values. */
1925 value = readconf_readtime(s, 0, FALSE);
1927 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1929 if (data_block == NULL)
1930 *((int *)(ol->value)) = value;
1932 *((int *)((uschar *)data_block + (long int)(ol->value))) = value;
1935 /* A time list is a list of colon-separated times, with the first
1936 element holding the size of the list and the second the number of
1942 int *list = (data_block == NULL)?
1943 (int *)(ol->value) :
1944 (int *)((uschar *)data_block + (long int)(ol->value));
1946 if (*s != 0) for (count = 1; count <= list[0] - 2; count++)
1949 uschar *snext = Ustrchr(s, ':');
1953 while (ss > s && isspace(ss[-1])) ss--;
1956 value = readconf_readtime(s, terminator, FALSE);
1958 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "invalid time value for %s",
1960 if (count > 1 && value <= list[count])
1961 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
1962 "time value out of order for %s", name);
1963 list[count+1] = value;
1964 if (snext == NULL) break;
1966 while (isspace(*s)) s++;
1969 if (count > list[0] - 2)
1970 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many time values for %s",
1972 if (count > 0 && list[2] == 0) count = 0;
1984 /*************************************************
1985 * Print a time value *
1986 *************************************************/
1989 Argument: a time value in seconds
1990 Returns: pointer to a fixed buffer containing the time as a string,
1991 in readconf_readtime() format
1995 readconf_printtime(int t)
1998 uschar *p = time_buffer;
2009 if (w > 0) { sprintf(CS p, "%dw", w); while (*p) p++; }
2010 if (d > 0) { sprintf(CS p, "%dd", d); while (*p) p++; }
2011 if (h > 0) { sprintf(CS p, "%dh", h); while (*p) p++; }
2012 if (m > 0) { sprintf(CS p, "%dm", m); while (*p) p++; }
2013 if (s > 0 || p == time_buffer) sprintf(CS p, "%ds", s);
2020 /*************************************************
2021 * Print an individual option value *
2022 *************************************************/
2024 /* This is used by the -bP option, so prints to the standard output.
2025 The entire options list is passed in as an argument, because some options come
2026 in pairs - typically uid/gid settings, which can either be explicit numerical
2027 values, or strings to be expanded later. If the numerical value is unset,
2028 search for "*expand_<name>" to see if there is a string equivalent.
2031 ol option entry, or NULL for an unknown option
2033 options_block NULL for main configuration options; otherwise points to
2034 a driver block; if the option doesn't have opt_public
2035 set, then options_block->options_block is where the item
2037 oltop points to the option list in which ol exists
2038 last one more than the offset of the last entry in optop
2044 print_ol(optionlist *ol, uschar *name, void *options_block,
2045 optionlist *oltop, int last)
2058 printf("%s is not a known option\n", name);
2062 /* Non-admin callers cannot see options that have been flagged secure by the
2065 if (!admin_user && (ol->type & opt_secure) != 0)
2067 printf("%s = <value not displayable>\n", name);
2071 /* Else show the value of the option */
2074 if (options_block != NULL)
2076 if ((ol->type & opt_public) == 0)
2077 options_block = (void *)(((driver_instance *)options_block)->options_block);
2078 value = (void *)((uschar *)options_block + (long int)value);
2081 switch(ol->type & opt_mask)
2084 case opt_rewrite: /* Show the text value */
2085 s = *((uschar **)value);
2086 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing2(s, FALSE));
2090 printf("%s = %d\n", name, *((int *)value));
2095 int x = *((int *)value);
2096 if (x != 0 && (x & 1023) == 0)
2100 if ((x & 1023) == 0)
2105 printf("%s = %d%c\n", name, x, c);
2107 else printf("%s = %d\n", name, x);
2113 int x = *((int *)value);
2114 if (x == 0) printf("%s = 0\n", name);
2115 else if ((x & 1023) == 0) printf("%s = %dM\n", name, x >> 10);
2116 else printf("%s = %dK\n", name, x);
2121 printf("%s = %#o\n", name, *((int *)value));
2124 /* Can be negative only when "unset", in which case integer */
2128 int x = *((int *)value);
2131 if (x < 0) printf("%s =\n", name); else
2133 printf("%s = %d.", name, x/1000);
2146 /* If the numerical value is unset, try for the string value */
2148 case opt_expand_uid:
2149 if (! *get_set_flag(name, oltop, last, options_block))
2151 sprintf(CS name2, "*expand_%.50s", name);
2152 ol2 = find_option(name2, oltop, last);
2155 void *value2 = ol2->value;
2156 if (options_block != NULL)
2157 value2 = (void *)((uschar *)options_block + (long int)value2);
2158 s = *((uschar **)value2);
2159 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing(s));
2164 /* Else fall through */
2167 if (! *get_set_flag(name, oltop, last, options_block))
2168 printf("%s =\n", name);
2171 pw = getpwuid(*((uid_t *)value));
2173 printf("%s = %ld\n", name, (long int)(*((uid_t *)value)));
2174 else printf("%s = %s\n", name, pw->pw_name);
2178 /* If the numerical value is unset, try for the string value */
2180 case opt_expand_gid:
2181 if (! *get_set_flag(name, oltop, last, options_block))
2183 sprintf(CS name2, "*expand_%.50s", name);
2184 ol2 = find_option(name2, oltop, last);
2185 if (ol2 != NULL && (ol2->type & opt_mask) == opt_stringptr)
2187 void *value2 = ol2->value;
2188 if (options_block != NULL)
2189 value2 = (void *)((uschar *)options_block + (long int)value2);
2190 s = *((uschar **)value2);
2191 printf("%s = %s\n", name, (s == NULL)? US"" : string_printing(s));
2196 /* Else fall through */
2199 if (! *get_set_flag(name, oltop, last, options_block))
2200 printf("%s =\n", name);
2203 gr = getgrgid(*((int *)value));
2205 printf("%s = %ld\n", name, (long int)(*((int *)value)));
2206 else printf("%s = %s\n", name, gr->gr_name);
2211 uidlist = *((uid_t **)value);
2212 printf("%s =", name);
2213 if (uidlist != NULL)
2217 for (i = 1; i <= (int)(uidlist[0]); i++)
2219 uschar *name = NULL;
2220 pw = getpwuid(uidlist[i]);
2221 if (pw != NULL) name = US pw->pw_name;
2222 if (name != NULL) printf("%c%s", sep, name);
2223 else printf("%c%ld", sep, (long int)(uidlist[i]));
2231 gidlist = *((gid_t **)value);
2232 printf("%s =", name);
2233 if (gidlist != NULL)
2237 for (i = 1; i <= (int)(gidlist[0]); i++)
2239 uschar *name = NULL;
2240 gr = getgrgid(gidlist[i]);
2241 if (gr != NULL) name = US gr->gr_name;
2242 if (name != NULL) printf("%c%s", sep, name);
2243 else printf("%c%ld", sep, (long int)(gidlist[i]));
2251 printf("%s = %s\n", name, readconf_printtime(*((int *)value)));
2257 int *list = (int *)value;
2258 printf("%s = ", name);
2259 for (i = 0; i < list[1]; i++)
2260 printf("%s%s", (i == 0)? "" : ":", readconf_printtime(list[i+2]));
2266 printf("%s%s\n", ((*((int *)value)) & (1 << ((ol->type >> 16) & 31)))?
2270 case opt_expand_bool:
2271 sprintf(CS name2, "*expand_%.50s", name);
2272 ol2 = find_option(name2, oltop, last);
2273 if (ol2 != NULL && ol2->value != NULL)
2275 void *value2 = ol2->value;
2276 if (options_block != NULL)
2277 value2 = (void *)((uschar *)options_block + (long int)value2);
2278 s = *((uschar **)value2);
2281 printf("%s = %s\n", name, string_printing(s));
2284 /* s == NULL => string not set; fall through */
2290 case opt_bool_verify:
2292 printf("%s%s\n", (*((BOOL *)value))? "" : "no_", name);
2299 /*************************************************
2300 * Print value from main configuration *
2301 *************************************************/
2303 /* This function, called as a result of encountering the -bP option,
2304 causes the value of any main configuration variable to be output if the
2305 second argument is NULL. There are some special values:
2307 all print all main configuration options
2308 configure_file print the name of the configuration file
2309 routers print the routers' configurations
2310 transports print the transports' configuration
2311 authenticators print the authenticators' configuration
2312 router_list print a list of router names
2313 transport_list print a list of transport names
2314 authenticator_list print a list of authentication mechanism names
2315 +name print a named list item
2316 local_scan print the local_scan options
2318 If the second argument is not NULL, it must be one of "router", "transport", or
2319 "authenticator" in which case the first argument identifies the driver whose
2320 options are to be printed.
2323 name option name if type == NULL; else driver name
2324 type NULL or driver type name, as described above
2330 readconf_print(uschar *name, uschar *type)
2332 BOOL names_only = FALSE;
2334 optionlist *ol2 = NULL;
2335 driver_instance *d = NULL;
2345 static uschar *types[] = { US"address", US"domain", US"host",
2347 static tree_node **anchors[] = { &addresslist_anchor, &domainlist_anchor,
2348 &hostlist_anchor, &localpartlist_anchor };
2350 for (i = 0; i < 4; i++)
2352 t = tree_search(*(anchors[i]), name+1);
2356 printf("%slist %s = %s\n", types[i], name+1,
2357 ((namedlist_block *)(t->data.ptr))->string);
2362 printf("no address, domain, host, or local part list called \"%s\" "
2363 "exists\n", name+1);
2368 if (Ustrcmp(name, "configure_file") == 0)
2370 printf("%s\n", CS config_main_filename);
2374 if (Ustrcmp(name, "all") == 0)
2376 for (ol = optionlist_config;
2377 ol < optionlist_config + optionlist_config_size; ol++)
2379 if ((ol->type & opt_hidden) == 0)
2380 print_ol(ol, US ol->name, NULL, optionlist_config, optionlist_config_size);
2385 if (Ustrcmp(name, "local_scan") == 0)
2387 #ifndef LOCAL_SCAN_HAS_OPTIONS
2388 printf("local_scan() options are not supported\n");
2390 for (ol = local_scan_options;
2391 ol < local_scan_options + local_scan_options_count; ol++)
2393 print_ol(ol, US ol->name, NULL, local_scan_options,
2394 local_scan_options_count);
2400 if (Ustrcmp(name, "routers") == 0)
2405 else if (Ustrcmp(name, "transports") == 0)
2407 type = US"transport";
2411 else if (Ustrcmp(name, "authenticators") == 0)
2413 type = US"authenticator";
2417 else if (Ustrcmp(name, "authenticator_list") == 0)
2419 type = US"authenticator";
2424 else if (Ustrcmp(name, "router_list") == 0)
2430 else if (Ustrcmp(name, "transport_list") == 0)
2432 type = US"transport";
2438 print_ol(find_option(name, optionlist_config, optionlist_config_size),
2439 name, NULL, optionlist_config, optionlist_config_size);
2444 /* Handle the options for a router or transport. Skip options that are flagged
2445 as hidden. Some of these are options with names starting with '*', used for
2446 internal alternative representations of other options (which the printing
2447 function will sort out). Others are synonyms kept for backward compatibility.
2450 if (Ustrcmp(type, "router") == 0)
2452 d = (driver_instance *)routers;
2453 ol2 = optionlist_routers;
2454 size = optionlist_routers_size;
2456 else if (Ustrcmp(type, "transport") == 0)
2458 d = (driver_instance *)transports;
2459 ol2 = optionlist_transports;
2460 size = optionlist_transports_size;
2462 else if (Ustrcmp(type, "authenticator") == 0)
2464 d = (driver_instance *)auths;
2465 ol2 = optionlist_auths;
2466 size = optionlist_auths_size;
2471 for (; d != NULL; d = d->next) printf("%s\n", CS d->name);
2475 /* Either search for a given driver, or print all of them */
2477 for (; d != NULL; d = d->next)
2480 printf("\n%s %s:\n", d->name, type);
2481 else if (Ustrcmp(d->name, name) != 0) continue;
2483 for (ol = ol2; ol < ol2 + size; ol++)
2485 if ((ol->type & opt_hidden) == 0)
2486 print_ol(ol, US ol->name, d, ol2, size);
2489 for (ol = d->info->options;
2490 ol < d->info->options + *(d->info->options_count); ol++)
2492 if ((ol->type & opt_hidden) == 0)
2493 print_ol(ol, US ol->name, d, d->info->options, *(d->info->options_count));
2495 if (name != NULL) return;
2497 if (name != NULL) printf("%s %s not found\n", type, name);
2502 /*************************************************
2503 * Read a named list item *
2504 *************************************************/
2506 /* This function reads a name and a list (i.e. string). The name is used to
2507 save the list in a tree, sorted by its name. Each entry also has a number,
2508 which can be used for caching tests, but if the string contains any expansion
2509 items other than $key, the number is set negative to inhibit caching. This
2510 mechanism is used for domain, host, and address lists that are referenced by
2514 anchorp points to the tree anchor
2515 numberp points to the current number for this tree
2516 max the maximum number permitted
2517 s the text of the option line, starting immediately after the name
2519 tname the name of the list type, for messages
2525 read_named_list(tree_node **anchorp, int *numberp, int max, uschar *s,
2528 BOOL forcecache = FALSE;
2531 namedlist_block *nb = store_get(sizeof(namedlist_block));
2533 if (Ustrncmp(s, "_cache", 6) == 0)
2540 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unrecognized configuration line");
2542 if (*numberp >= max)
2543 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "too many named %ss (max is %d)\n",
2546 while (isspace(*s)) s++;
2548 while (isalnum(*s) || *s == '_') s++;
2549 t = store_get(sizeof(tree_node) + s-ss);
2550 Ustrncpy(t->name, ss, s-ss);
2552 while (isspace(*s)) s++;
2554 if (!tree_insertnode(anchorp, t))
2555 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2556 "duplicate name \"%s\" for a named %s", t->name, tname);
2559 nb->number = *numberp;
2562 if (*s++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
2563 "missing '=' after \"%s\"", t->name);
2564 while (isspace(*s)) s++;
2565 nb->string = read_string(s, t->name);
2566 nb->cache_data = NULL;
2568 /* Check the string for any expansions; if any are found, mark this list
2569 uncacheable unless the user has explicited forced caching. */
2571 if (!forcecache && Ustrchr(nb->string, '$') != NULL) nb->number = -1;
2577 /*************************************************
2578 * Unpick data for a rate limit *
2579 *************************************************/
2581 /* This function is called to unpick smtp_ratelimit_{mail,rcpt} into four
2585 s string, in the form t,b,f,l
2586 where t is the threshold (integer)
2587 b is the initial delay (time)
2588 f is the multiplicative factor (fixed point)
2589 k is the maximum time (time)
2590 threshold where to store threshold
2591 base where to store base in milliseconds
2592 factor where to store factor in milliseconds
2593 limit where to store limit
2595 Returns: nothing (panics on error)
2599 unpick_ratelimit(uschar *s, int *threshold, int *base, double *factor,
2602 uschar bstring[16], lstring[16];
2604 if (sscanf(CS s, "%d, %15[0123456789smhdw.], %lf, %15s", threshold, bstring,
2605 factor, lstring) == 4)
2607 *base = readconf_readtime(bstring, 0, TRUE);
2608 *limit = readconf_readtime(lstring, 0, TRUE);
2609 if (*base >= 0 && *limit >= 0) return;
2611 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "malformed ratelimit data: %s", s);
2617 /*************************************************
2618 * Read main configuration options *
2619 *************************************************/
2621 /* This function is the first to be called for configuration reading. It
2622 opens the configuration file and reads general configuration settings until
2623 it reaches the end of the configuration section. The file is then left open so
2624 that the remaining configuration data can subsequently be read if needed for
2627 The configuration file must be owned either by root or exim, and be writeable
2628 only by root or uid/gid exim. The values for Exim's uid and gid can be changed
2629 in the config file, so the test is done on the compiled in values. A slight
2630 anomaly, to be carefully documented.
2632 The name of the configuration file is taken from a list that is included in the
2633 binary of Exim. It can be altered from the command line, but if that is done,
2634 root privilege is immediately withdrawn unless the caller is root or exim.
2635 The first file on the list that exists is used.
2637 For use on multiple systems that share file systems, first look for a
2638 configuration file whose name has the current node name on the end. If that is
2639 not found, try the generic name. For really contorted configurations, that run
2640 multiple Exims with different uid settings, first try adding the effective uid
2641 before the node name. These complications are going to waste resources on most
2642 systems. Therefore they are available only when requested by compile-time
2649 struct stat statbuf;
2650 uschar *s, *filename;
2651 uschar *list = config_main_filelist;
2653 /* Loop through the possible file names */
2655 while((filename = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
2658 /* Cut out all the fancy processing unless specifically wanted */
2660 #if defined(CONFIGURE_FILE_USE_NODE) || defined(CONFIGURE_FILE_USE_EUID)
2661 uschar *suffix = filename + Ustrlen(filename);
2663 /* Try for the node-specific file if a node name exists */
2665 #ifdef CONFIGURE_FILE_USE_NODE
2667 if (uname(&uts) >= 0)
2669 #ifdef CONFIGURE_FILE_USE_EUID
2670 sprintf(CS suffix, ".%ld.%.256s", (long int)original_euid, uts.nodename);
2671 config_file = Ufopen(filename, "rb");
2672 if (config_file == NULL)
2673 #endif /* CONFIGURE_FILE_USE_EUID */
2675 sprintf(CS suffix, ".%.256s", uts.nodename);
2676 config_file = Ufopen(filename, "rb");
2679 #endif /* CONFIGURE_FILE_USE_NODE */
2681 /* Otherwise, try the generic name, possibly with the euid added */
2683 #ifdef CONFIGURE_FILE_USE_EUID
2684 if (config_file == NULL)
2686 sprintf(CS suffix, ".%ld", (long int)original_euid);
2687 config_file = Ufopen(filename, "rb");
2689 #endif /* CONFIGURE_FILE_USE_EUID */
2691 /* Finally, try the unadorned name */
2693 if (config_file == NULL)
2696 config_file = Ufopen(filename, "rb");
2698 #else /* if neither defined */
2700 /* This is the common case when the fancy processing is not included. */
2702 config_file = Ufopen(filename, "rb");
2705 /* If the file does not exist, continue to try any others. For any other
2706 error, break out (and die). */
2708 if (config_file != NULL || errno != ENOENT) break;
2711 /* On success, save the name for verification; config_filename is used when
2712 logging configuration errors (it changes for .included files) whereas
2713 config_main_filename is the name shown by -bP. Failure to open a configuration
2714 file is a serious disaster. */
2716 if (config_file != NULL)
2718 config_filename = config_main_filename = string_copy(filename);
2722 if (filename == NULL)
2723 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "non-existent configuration file(s): "
2724 "%s", config_main_filelist);
2726 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", string_open_failed(errno,
2727 "configuration file %s", filename));
2730 /* Check the status of the file we have opened, unless it was specified on
2731 the command line, in which case privilege was given away at the start. */
2733 if (!config_changed)
2735 if (fstat(fileno(config_file), &statbuf) != 0)
2736 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to stat configuration file %s",
2739 if ((statbuf.st_uid != root_uid && /* owner not root */
2740 statbuf.st_uid != exim_uid /* owner not exim */
2741 #ifdef CONFIGURE_OWNER
2742 && statbuf.st_uid != config_uid /* owner not the special one */
2745 (statbuf.st_gid != exim_gid /* group not exim & */
2746 #ifdef CONFIGURE_GROUP
2747 && statbuf.st_gid != config_gid /* group not the special one */
2749 && (statbuf.st_mode & 020) != 0) || /* group writeable */
2751 ((statbuf.st_mode & 2) != 0)) /* world writeable */
2753 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Exim configuration file %s has the "
2754 "wrong owner, group, or mode", big_buffer);
2757 /* Process the main configuration settings. They all begin with a lower case
2758 letter. If we see something starting with an upper case letter, it is taken as
2759 a macro definition. */
2761 while ((s = get_config_line()) != NULL)
2763 if (isupper(s[0])) read_macro_assignment(s);
2765 else if (Ustrncmp(s, "domainlist", 10) == 0)
2766 read_named_list(&domainlist_anchor, &domainlist_count,
2767 MAX_NAMED_LIST, s+10, US"domain list");
2769 else if (Ustrncmp(s, "hostlist", 8) == 0)
2770 read_named_list(&hostlist_anchor, &hostlist_count,
2771 MAX_NAMED_LIST, s+8, US"host list");
2773 else if (Ustrncmp(s, US"addresslist", 11) == 0)
2774 read_named_list(&addresslist_anchor, &addresslist_count,
2775 MAX_NAMED_LIST, s+11, US"address list");
2777 else if (Ustrncmp(s, US"localpartlist", 13) == 0)
2778 read_named_list(&localpartlist_anchor, &localpartlist_count,
2779 MAX_NAMED_LIST, s+13, US"local part list");
2782 (void) readconf_handle_option(s, optionlist_config, optionlist_config_size,
2783 NULL, US"main option \"%s\" unknown");
2787 /* If local_sender_retain is set, local_from_check must be unset. */
2789 if (local_sender_retain && local_from_check)
2790 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "both local_from_check and "
2791 "local_sender_retain are set; this combination is not allowed");
2793 /* If the timezone string is empty, set it to NULL, implying no TZ variable
2796 if (timezone_string != NULL && *timezone_string == 0) timezone_string = NULL;
2798 /* remote_max_parallel must be > 0 */
2800 if (remote_max_parallel <= 0) remote_max_parallel = 1;
2802 /* The primary host name may be required for expansion of spool_directory
2803 and log_file_path, so make sure it is set asap. It is obtained from uname(),
2804 but if that yields an unqualified value, make a FQDN by using gethostbyname to
2805 canonize it. Some people like upper case letters in their host names, so we
2806 don't force the case. */
2808 if (primary_hostname == NULL)
2812 if (uname(&uts) < 0)
2813 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "uname() failed to yield host name");
2814 hostname = US uts.nodename;
2816 if (Ustrchr(hostname, '.') == NULL)
2819 struct hostent *hostdata;
2822 if (dns_ipv4_lookup == NULL ||
2823 match_isinlist(hostname, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2833 #if HAVE_GETIPNODEBYNAME
2835 hostdata = getipnodebyname(CS hostname, af, 0, &error_num);
2837 hostdata = gethostbyname2(CS hostname, af);
2840 hostdata = gethostbyname(CS hostname);
2843 if (hostdata != NULL)
2845 hostname = US hostdata->h_name;
2849 if (af == AF_INET) break;
2854 primary_hostname = string_copy(hostname);
2857 /* Set up default value for smtp_active_hostname */
2859 smtp_active_hostname = primary_hostname;
2861 /* If spool_directory wasn't set in the build-time configuration, it must have
2862 got set above. Of course, writing to the log may not work if log_file_path is
2863 not set, but it will at least get to syslog or somewhere, with any luck. */
2865 if (*spool_directory == 0)
2866 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "spool_directory undefined: cannot "
2869 /* Expand the spool directory name; it may, for example, contain the primary
2870 host name. Same comment about failure. */
2872 s = expand_string(spool_directory);
2874 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand spool_directory "
2875 "\"%s\": %s", spool_directory, expand_string_message);
2876 spool_directory = s;
2878 /* Expand log_file_path, which must contain "%s" in any component that isn't
2879 the null string or "syslog". It is also allowed to contain one instance of %D.
2880 However, it must NOT contain % followed by anything else. */
2882 if (*log_file_path != 0)
2885 int sep = ':'; /* Fixed for log file path */
2886 s = expand_string(log_file_path);
2888 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand log_file_path "
2889 "\"%s\": %s", log_file_path, expand_string_message);
2892 while ((sss = string_nextinlist(&ss,&sep,big_buffer,big_buffer_size)) != NULL)
2895 if (sss[0] == 0 || Ustrcmp(sss, "syslog") == 0) continue;
2896 t = Ustrstr(sss, "%s");
2898 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" does not "
2899 "contain \"%%s\"", sss);
2901 t = Ustrchr(sss, '%');
2904 if (t[1] != 'D' || Ustrchr(t+2, '%') != NULL)
2905 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_file_path \"%s\" contains "
2906 "unexpected \"%%\" character", s);
2913 /* Interpret syslog_facility into an integer argument for 'ident' param to
2914 openlog(). Default is LOG_MAIL set in globals.c. Allow the user to omit the
2917 if (syslog_facility_str != NULL)
2920 uschar *s = syslog_facility_str;
2922 if ((Ustrlen(syslog_facility_str) >= 4) &&
2923 (strncmpic(syslog_facility_str, US"log_", 4) == 0))
2926 for (i = 0; i < syslog_list_size; i++)
2928 if (strcmpic(s, syslog_list[i].name) == 0)
2930 syslog_facility = syslog_list[i].value;
2935 if (i >= syslog_list_size)
2937 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
2938 "failed to interpret syslog_facility \"%s\"", syslog_facility_str);
2942 /* Expand pid_file_path */
2944 if (*pid_file_path != 0)
2946 s = expand_string(pid_file_path);
2948 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand pid_file_path "
2949 "\"%s\": %s", pid_file_path, expand_string_message);
2953 /* Compile the regex for matching a UUCP-style "From_" line in an incoming
2956 regex_From = regex_must_compile(uucp_from_pattern, FALSE, TRUE);
2958 /* Unpick the SMTP rate limiting options, if set */
2960 if (smtp_ratelimit_mail != NULL)
2962 unpick_ratelimit(smtp_ratelimit_mail, &smtp_rlm_threshold,
2963 &smtp_rlm_base, &smtp_rlm_factor, &smtp_rlm_limit);
2966 if (smtp_ratelimit_rcpt != NULL)
2968 unpick_ratelimit(smtp_ratelimit_rcpt, &smtp_rlr_threshold,
2969 &smtp_rlr_base, &smtp_rlr_factor, &smtp_rlr_limit);
2972 /* The qualify domains default to the primary host name */
2974 if (qualify_domain_sender == NULL)
2975 qualify_domain_sender = primary_hostname;
2976 if (qualify_domain_recipient == NULL)
2977 qualify_domain_recipient = qualify_domain_sender;
2979 /* Setting system_filter_user in the configuration sets the gid as well if a
2980 name is given, but a numerical value does not. */
2982 if (system_filter_uid_set && !system_filter_gid_set)
2984 struct passwd *pw = getpwuid(system_filter_uid);
2986 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to look up uid %ld",
2987 (long int)system_filter_uid);
2988 system_filter_gid = pw->pw_gid;
2989 system_filter_gid_set = TRUE;
2992 /* If the errors_reply_to field is set, check that it is syntactically valid
2993 and ensure it contains a domain. */
2995 if (errors_reply_to != NULL)
2998 int start, end, domain;
2999 uschar *recipient = parse_extract_address(errors_reply_to, &errmess,
3000 &start, &end, &domain, FALSE);
3002 if (recipient == NULL)
3003 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3004 "error in errors_reply_to (%s): %s", errors_reply_to, errmess);
3007 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3008 "errors_reply_to (%s) does not contain a domain", errors_reply_to);
3011 /* If smtp_accept_queue or smtp_accept_max_per_host is set, then
3012 smtp_accept_max must also be set. */
3014 if (smtp_accept_max == 0 &&
3015 (smtp_accept_queue > 0 || smtp_accept_max_per_host != NULL))
3016 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3017 "smtp_accept_max must be set if smtp_accept_queue or "
3018 "smtp_accept_max_per_host is set");
3020 /* Set up the host number if anything is specified. It is an expanded string
3021 so that it can be computed from the host name, for example. We do this last
3022 so as to ensure that everything else is set up before the expansion. */
3024 if (host_number_string != NULL)
3027 uschar *s = expand_string(host_number_string);
3028 long int n = Ustrtol(s, &end, 0);
3029 while (isspace(*end)) end++;
3031 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3032 "localhost_number value is not a number: %s", s);
3033 if (n > LOCALHOST_MAX)
3034 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3035 "localhost_number is greater than the maximum allowed value (%d)",
3041 /* If tls_verify_hosts is set, tls_verify_certificates must also be set */
3043 if ((tls_verify_hosts != NULL || tls_try_verify_hosts != NULL) &&
3044 tls_verify_certificates == NULL)
3045 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3046 "tls_%sverify_hosts is set, but tls_verify_certificates is not set",
3047 (tls_verify_hosts != NULL)? "" : "try_");
3053 /*************************************************
3054 * Initialize one driver *
3055 *************************************************/
3057 /* This is called once the driver's generic options, if any, have been read.
3058 We can now find the driver, set up defaults for the private options, and
3059 unset any "set" bits in the private options table (which might have been
3060 set by another incarnation of the same driver).
3063 d pointer to driver instance block, with generic
3065 drivers_available vector of available drivers
3066 size_of_info size of each block in drivers_available
3067 class class of driver, for error message
3069 Returns: pointer to the driver info block
3072 static driver_info *
3073 init_driver(driver_instance *d, driver_info *drivers_available,
3074 int size_of_info, uschar *class)
3078 for (dd = drivers_available; dd->driver_name[0] != 0;
3079 dd = (driver_info *)(((uschar *)dd) + size_of_info))
3081 if (Ustrcmp(d->driver_name, dd->driver_name) == 0)
3084 int len = dd->options_len;
3086 d->options_block = store_get(len);
3087 memcpy(d->options_block, dd->options_block, len);
3088 for (i = 0; i < *(dd->options_count); i++)
3089 dd->options[i].type &= ~opt_set;
3094 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3095 "%s %s: cannot find %s driver \"%s\"", class, d->name, class, d->driver_name);
3097 return NULL; /* never obeyed */
3103 /*************************************************
3104 * Initialize driver list *
3105 *************************************************/
3107 /* This function is called for routers, transports, and authentication
3108 mechanisms. It reads the data from the current point in the configuration file
3109 up to the end of the section, and sets up a chain of instance blocks according
3110 to the file's contents. The file will already have been opened by a call to
3111 readconf_main, and must be left open for subsequent reading of further data.
3113 Any errors cause a panic crash. Note that the blocks with names driver_info and
3114 driver_instance must map the first portions of all the _info and _instance
3115 blocks for this shared code to work.
3118 class "router", "transport", or "authenticator"
3119 anchor &routers, &transports, &auths
3120 drivers_available available drivers
3121 size_of_info size of each info block
3122 instance_default points to default data for an instance
3123 instance_size size of instance block
3124 driver_optionlist generic option list
3125 driver_optionlist_count count of generic option list
3131 readconf_driver_init(
3133 driver_instance **anchor,
3134 driver_info *drivers_available,
3136 void *instance_default,
3138 optionlist *driver_optionlist,
3139 int driver_optionlist_count)
3141 driver_instance **p = anchor;
3142 driver_instance *d = NULL;
3145 while ((buffer = get_config_line()) != NULL)
3150 /* Read the first name on the line and test for the start of a new driver. A
3151 macro definition indicates the end of the previous driver. If this isn't the
3152 start of a new driver, the line will be re-read. */
3154 s = readconf_readname(name, sizeof(name), buffer);
3156 /* Handle macro definition, first finishing off the initialization of the
3157 previous driver, if any. */
3159 if (isupper(*name) && *s == '=')
3163 if (d->driver_name == NULL)
3164 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3165 "no driver defined for %s \"%s\"", class, d->name);
3169 read_macro_assignment(buffer);
3173 /* If the line starts with a name terminated by a colon, we are at the
3174 start of the definition of a new driver. The rest of the line must be
3181 /* Finish off initializing the previous driver. */
3185 if (d->driver_name == NULL)
3186 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3187 "no driver defined for %s \"%s\"", class, d->name);
3191 /* Check that we haven't already got a driver of this name */
3193 for (d = *anchor; d != NULL; d = d->next)
3194 if (Ustrcmp(name, d->name) == 0)
3195 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3196 "there are two %ss called \"%s\"", class, name);
3198 /* Set up a new driver instance data block on the chain, with
3199 its default values installed. */
3201 d = store_get(instance_size);
3202 memcpy(d, instance_default, instance_size);
3205 d->name = string_copy(name);
3207 /* Clear out the "set" bits in the generic options */
3209 for (i = 0; i < driver_optionlist_count; i++)
3210 driver_optionlist[i].type &= ~opt_set;
3212 /* Check nothing more on this line, then do the next loop iteration. */
3214 while (isspace(*s)) s++;
3215 if (*s != 0) extra_chars_error(s, US"driver name ", name, US"");
3219 /* Not the start of a new driver. Give an error if we have not set up a
3220 current driver yet. */
3222 if (d == NULL) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3223 "%s name missing", class);
3225 /* First look to see if this is a generic option; if it is "driver",
3226 initialize the driver. If is it not a generic option, we can look for a
3227 private option provided that the driver has been previously set up. */
3229 if (readconf_handle_option(buffer, driver_optionlist,
3230 driver_optionlist_count, d, NULL))
3232 if (d->info == NULL && d->driver_name != NULL)
3233 init_driver(d, drivers_available, size_of_info, class);
3236 /* Handle private options - pass the generic block because some may
3237 live therein. A flag with each option indicates if it is in the public
3240 else if (d->info != NULL)
3242 readconf_handle_option(buffer, d->info->options,
3243 *(d->info->options_count), d, US"option \"%s\" unknown");
3246 /* The option is not generic and the driver name has not yet been given. */
3248 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "option \"%s\" unknown "
3249 "(\"driver\" must be specified before any private options)", name);
3252 /* Run the initialization function for the final driver. */
3256 if (d->driver_name == NULL)
3257 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
3258 "no driver defined for %s \"%s\"", class, d->name);
3265 /*************************************************
3266 * Check driver dependency *
3267 *************************************************/
3269 /* This function is passed a driver instance and a string. It checks whether
3270 any of the string options for the driver contains the given string as an
3274 d points to a driver instance block
3275 s the string to search for
3277 Returns: TRUE if a dependency is found
3281 readconf_depends(driver_instance *d, uschar *s)
3283 int count = *(d->info->options_count);
3287 for (ol = d->info->options; ol < d->info->options + count; ol++)
3289 void *options_block;
3291 int type = ol->type & opt_mask;
3292 if (type != opt_stringptr) continue;
3293 options_block = ((ol->type & opt_public) == 0)? d->options_block : (void *)d;
3294 value = *(uschar **)((uschar *)options_block + (long int)(ol->value));
3295 if (value != NULL && (ss = Ustrstr(value, s)) != NULL)
3297 if (ss <= value || (ss[-1] != '$' && ss[-1] != '{') ||
3298 isalnum(ss[Ustrlen(s)])) continue;
3299 DEBUG(D_transport) debug_printf("driver %s: \"%s\" option depends on %s\n",
3300 d->name, ol->name, s);
3305 DEBUG(D_transport) debug_printf("driver %s does not depend on %s\n", d->name, s);
3312 /*************************************************
3313 * Decode an error type for retries *
3314 *************************************************/
3316 /* This function is global because it is also called from the main
3317 program when testing retry information. It decodes strings such as "quota_7d"
3318 into numerical error codes.
3321 pp points to start of text
3322 p points past end of text
3323 basic_errno points to an int to receive the main error number
3324 more_errno points to an int to receive the secondary error data
3326 Returns: NULL if decoded correctly; else points to error text
3330 readconf_retry_error(uschar *pp, uschar *p, int *basic_errno, int *more_errno)
3334 while (q < p && *q != '_') q++;
3337 if (len == 5 && strncmpic(pp, US"quota", len) == 0)
3339 *basic_errno = ERRNO_EXIMQUOTA;
3340 if (q != p && (*more_errno = readconf_readtime(q+1, *p, FALSE)) < 0)
3341 return US"bad time value";
3344 else if (len == 7 && strncmpic(pp, US"refused", len) == 0)
3346 *basic_errno = ECONNREFUSED;
3349 if (strncmpic(q+1, US"MX", p-q-1) == 0) *more_errno = 'M';
3350 else if (strncmpic(q+1, US"A", p-q-1) == 0) *more_errno = 'A';
3351 else return US"A or MX expected after \"refused\"";
3355 else if (len == 7 && strncmpic(pp, US"timeout", len) == 0)
3357 *basic_errno = ETIMEDOUT;
3361 int xlen = p - q - 1;
3364 static uschar *extras[] =
3365 { US"A", US"MX", US"connect", US"connect_A", US"connect_MX" };
3366 static int values[] =
3367 { 'A', 'M', RTEF_CTOUT, RTEF_CTOUT|'A', RTEF_CTOUT|'M' };
3369 for (i = 0; i < sizeof(extras)/sizeof(uschar *); i++)
3371 if (strncmpic(x, extras[i], xlen) == 0)
3373 *more_errno = values[i];
3378 if (i >= sizeof(extras)/sizeof(uschar *))
3380 if (strncmpic(x, US"DNS", xlen) == 0)
3382 log_write(0, LOG_MAIN|LOG_PANIC, "\"timeout_dns\" is no longer "
3383 "available in retry rules (it has never worked) - treated as "
3386 else return US"\"A\", \"MX\", or \"connect\" expected after \"timeout\"";
3391 else if (strncmpic(pp, US"rcpt_4", 6) == 0)
3394 int x = 255; /* means "any 4xx code" */
3395 if (p != pp + 8) bad = TRUE; else
3397 int a = pp[6], b = pp[7];
3401 if (isdigit(b)) x += b - '0';
3402 else if (b == 'x') x += 100;
3405 else if (a != 'x' || b != 'x') bad = TRUE;
3408 if (bad) return US"rcpt_4 must be followed by xx, dx, or dd, where "
3409 "x is literal and d is any digit";
3411 *basic_errno = ERRNO_RCPT4XX;
3412 *more_errno = x << 8;
3415 else if (len == 4 && strncmpic(pp, US"auth", len) == 0 &&
3416 strncmpic(q+1, US"failed", p-q-1) == 0)
3418 *basic_errno = ERRNO_AUTHFAIL;
3421 else if (len != 1 || Ustrncmp(pp, "*", 1) != 0)
3422 return string_sprintf("unknown or malformed retry error \"%.*s\"", p-pp, pp);
3430 /*************************************************
3431 * Read retry information *
3432 *************************************************/
3434 /* Each line of retry information contains:
3436 . A domain name pattern or an address pattern;
3438 . An error name, possibly with additional data, or *;
3440 . An optional sequence of retry items, each consisting of an identifying
3441 letter, a cutoff time, and optional parameters.
3443 All this is decoded and placed into a control block. */
3446 /* Subroutine to read an argument, preceded by a comma and terminated
3447 by comma, semicolon, whitespace, or newline. The types are: 0 = time value,
3448 1 = fixed point number (returned *1000).
3451 paddr pointer to pointer to current character; updated
3452 type 0 => read a time; 1 => read a fixed point number
3454 Returns: time in seconds or fixed point number * 1000
3458 retry_arg(uschar **paddr, int type)
3463 if (*p++ != ',') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma expected");
3465 while (isspace(*p)) p++;
3467 while (isalnum(*p) || (type == 1 && *p == '.')) p++;
3469 if (*p != 0 && !isspace(*p) && *p != ',' && *p != ';')
3470 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "comma or semicolon expected");
3476 return readconf_readtime(pp, *p, FALSE);
3478 return readconf_readfixed(pp, *p);
3480 return 0; /* Keep picky compilers happy */
3483 /* The function proper */
3486 readconf_retries(void)
3488 retry_config **chain = &retries;
3492 while ((p = get_config_line()) != NULL)
3494 retry_rule **rchain;
3497 next = store_get(sizeof(retry_config));
3500 chain = &(next->next);
3501 next->basic_errno = next->more_errno = 0;
3502 next->senders = NULL;
3504 rchain = &(next->rules);
3506 next->pattern = string_dequote(&p);
3507 while (isspace(*p)) p++;
3509 while (mac_isgraph(*p)) p++;
3510 if (p - pp <= 0) log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3511 "missing error type");
3513 /* Test error names for things we understand. */
3515 if ((error = readconf_retry_error(pp, p, &(next->basic_errno),
3516 &(next->more_errno))) != NULL)
3517 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "%s", error);
3519 /* There may be an optional address list of senders to be used as another
3520 constraint on the rule. This was added later, so the syntax is a bit of a
3521 fudge. Anything that is not a retry rule starting "F," or "G," is treated as
3524 while (isspace(*p)) p++;
3525 if (Ustrncmp(p, "senders", 7) == 0)
3528 while (isspace(*p)) p++;
3529 if (*p++ != '=') log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3530 "\"=\" expected after \"senders\" in retry rule");
3531 while (isspace(*p)) p++;
3532 next->senders = string_dequote(&p);
3535 /* Now the retry rules. Keep the maximum timeout encountered. */
3537 while (isspace(*p)) p++;
3541 retry_rule *rule = store_get(sizeof(retry_rule));
3543 rchain = &(rule->next);
3545 rule->rule = toupper(*p++);
3546 rule->timeout = retry_arg(&p, 0);
3547 if (rule->timeout > retry_maximum_timeout)
3548 retry_maximum_timeout = rule->timeout;
3552 case 'F': /* Fixed interval */
3553 rule->p1 = retry_arg(&p, 0);
3556 case 'G': /* Geometrically increasing intervals */
3557 rule->p1 = retry_arg(&p, 0);
3558 rule->p2 = retry_arg(&p, 1);
3562 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "unknown retry rule letter");
3566 if (rule->timeout <= 0 || rule->p1 <= 0 ||
3567 (rule->rule == 'G' && rule->p2 < 1000))
3568 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3569 "bad parameters for retry rule");
3571 while (isspace(*p)) p++;
3575 while (isspace(*p)) p++;
3578 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "semicolon expected");
3585 /*************************************************
3586 * Initialize authenticators *
3587 *************************************************/
3589 /* Read the authenticators section of the configuration file.
3598 auth_instance *au, *bu;
3599 readconf_driver_init(US"authenticator",
3600 (driver_instance **)(&auths), /* chain anchor */
3601 (driver_info *)auths_available, /* available drivers */
3602 sizeof(auth_info), /* size of info block */
3603 &auth_defaults, /* default values for generic options */
3604 sizeof(auth_instance), /* size of instance block */
3605 optionlist_auths, /* generic options */
3606 optionlist_auths_size);
3608 for (au = auths; au != NULL; au = au->next)
3610 if (au->public_name == NULL)
3611 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "no public name specified for "
3612 "the %s authenticator", au->name);
3613 for (bu = au->next; bu != NULL; bu = bu->next)
3615 if (strcmpic(au->public_name, bu->public_name) == 0)
3617 if ((au->client && bu->client) || (au->server && bu->server))
3618 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "two %s authenticators "
3619 "(%s and %s) have the same public name (%s)",
3620 (au->client)? US"client" : US"server", au->name, bu->name,
3630 /*************************************************
3631 * Read ACL information *
3632 *************************************************/
3634 /* If this run of Exim is not doing something that involves receiving a
3635 message, we can just skip over the ACL information. No need to parse it.
3637 First, we have a function for acl_read() to call back to get the next line. We
3638 need to remember the line we passed, because at the end it will contain the
3639 name of the next ACL. */
3641 static uschar *acl_line;
3646 acl_line = get_config_line();
3651 /* Now the main function:
3654 skip TRUE when this Exim process is doing something that will
3655 not need the ACL data
3661 readconf_acl(BOOL skip)
3665 /* Not receiving messages, don't need to parse the ACL data */
3669 DEBUG(D_acl) debug_printf("skipping ACL configuration - not needed\n");
3670 while ((p = get_config_line()) != NULL);
3674 /* Read each ACL and add it into the tree. Macro (re)definitions are allowed
3677 acl_line = get_config_line();
3679 while(acl_line != NULL)
3685 p = readconf_readname(name, sizeof(name), acl_line);
3686 if (isupper(*name) && *p == '=')
3688 read_macro_assignment(acl_line);
3689 acl_line = get_config_line();
3693 if (*p != ':' || name[0] == 0)
3694 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "missing or malformed ACL name");
3696 node = store_get(sizeof(tree_node) + Ustrlen(name));
3697 Ustrcpy(node->name, name);
3698 if (!tree_insertnode(&acl_anchor, node))
3699 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3700 "there are two ACLs called \"%s\"", name);
3702 node->data.ptr = acl_read(acl_callback, &error);
3704 if (node->data.ptr == NULL && error != NULL)
3705 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "error in ACL: %s", error);
3711 /*************************************************
3712 * Read configuration for local_scan() *
3713 *************************************************/
3715 /* This function is called after "begin local_scan" is encountered in the
3716 configuration file. If the local_scan() function allows for configuration
3717 options, we can process them. Otherwise, we expire in a panic.
3724 local_scan_init(void)
3726 #ifndef LOCAL_SCAN_HAS_OPTIONS
3727 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN, "local_scan() options not supported: "
3728 "(LOCAL_SCAN_HAS_OPTIONS not defined in Local/Makefile)");
3732 while ((p = get_config_line()) != NULL)
3734 (void) readconf_handle_option(p, local_scan_options, local_scan_options_count,
3735 NULL, US"local_scan option \"%s\" unknown");
3742 /*************************************************
3743 * Read rest of configuration (after main) *
3744 *************************************************/
3746 /* This function reads the rest of the runtime configuration, after the main
3747 configuration. It is called only when actually needed. Each subsequent section
3748 of the configuration starts with a line of the form
3752 where the name is "routers", "transports", etc. A section is terminated by
3753 hitting the next "begin" line, and the next name is left in next_section.
3754 Because it may confuse people as to whether the names are singular or plural,
3755 we add "s" if it's missing. There is always enough room in next_section for
3756 this. This function is basically just a switch.
3759 skip_acl TRUE if ACL information is not needed
3764 static uschar *section_list[] = {
3774 readconf_rest(BOOL skip_acl)
3778 while(next_section[0] != 0)
3782 int last = sizeof(section_list) / sizeof(uschar *);
3784 int n = Ustrlen(next_section);
3786 if (tolower(next_section[n-1]) != 's') Ustrcpy(next_section+n, "s");
3790 int c = strcmpic(next_section, section_list[mid]);
3792 if (c > 0) first = mid + 1; else last = mid;
3794 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3795 "\"%.*s\" is not a known configuration section name", n, next_section);
3796 mid = (last + first)/2;
3800 if (((had ^= bit) & bit) == 0)
3801 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_IN,
3802 "\"%.*s\" section is repeated in the configuration file", n,
3807 case 0: readconf_acl(skip_acl); break;
3808 case 1: auths_init(); break;
3809 case 2: local_scan_init(); break;
3810 case 3: readconf_retries(); break;
3811 case 4: readconf_rewrites(); break;
3812 case 5: route_init(); break;
3813 case 6: transport_init(); break;
3817 (void)fclose(config_file);
3820 /* End of readconf.c */