1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
10 #include "rf_functions.h"
15 /* Options specific to the redirect router. */
17 optionlist redirect_router_options[] = {
18 { "allow_defer", opt_bit | (RDON_DEFER << 16),
19 (void *)offsetof(redirect_router_options_block, bit_options) },
20 { "allow_fail", opt_bit | (RDON_FAIL << 16),
21 (void *)offsetof(redirect_router_options_block, bit_options) },
22 { "allow_filter", opt_bit | (RDON_FILTER << 16),
23 (void *)offsetof(redirect_router_options_block, bit_options) },
24 { "allow_freeze", opt_bit | (RDON_FREEZE << 16),
25 (void *)offsetof(redirect_router_options_block, bit_options) },
26 { "check_ancestor", opt_bool,
27 (void *)offsetof(redirect_router_options_block, check_ancestor) },
28 { "check_group", opt_bool,
29 (void *)offsetof(redirect_router_options_block, check_group) },
30 { "check_owner", opt_bool,
31 (void *)offsetof(redirect_router_options_block, check_owner) },
32 { "data", opt_stringptr,
33 (void *)offsetof(redirect_router_options_block, data) },
34 { "directory_transport",opt_stringptr,
35 (void *)offsetof(redirect_router_options_block, directory_transport_name) },
36 { "file", opt_stringptr,
37 (void *)offsetof(redirect_router_options_block, file) },
38 { "file_transport", opt_stringptr,
39 (void *)offsetof(redirect_router_options_block, file_transport_name) },
40 { "filter_prepend_home",opt_bit | (RDON_PREPEND_HOME << 16),
41 (void *)offsetof(redirect_router_options_block, bit_options) },
42 { "forbid_blackhole", opt_bit | (RDON_BLACKHOLE << 16),
43 (void *)offsetof(redirect_router_options_block, bit_options) },
44 { "forbid_exim_filter", opt_bit | (RDON_EXIM_FILTER << 16),
45 (void *)offsetof(redirect_router_options_block, bit_options) },
46 { "forbid_file", opt_bool,
47 (void *)offsetof(redirect_router_options_block, forbid_file) },
48 { "forbid_filter_dlfunc", opt_bit | (RDON_DLFUNC << 16),
49 (void *)offsetof(redirect_router_options_block, bit_options) },
50 { "forbid_filter_existstest", opt_bit | (RDON_EXISTS << 16),
51 (void *)offsetof(redirect_router_options_block, bit_options) },
52 { "forbid_filter_logwrite",opt_bit | (RDON_LOG << 16),
53 (void *)offsetof(redirect_router_options_block, bit_options) },
54 { "forbid_filter_lookup", opt_bit | (RDON_LOOKUP << 16),
55 (void *)offsetof(redirect_router_options_block, bit_options) },
56 { "forbid_filter_perl", opt_bit | (RDON_PERL << 16),
57 (void *)offsetof(redirect_router_options_block, bit_options) },
58 { "forbid_filter_readfile", opt_bit | (RDON_READFILE << 16),
59 (void *)offsetof(redirect_router_options_block, bit_options) },
60 { "forbid_filter_readsocket", opt_bit | (RDON_READSOCK << 16),
61 (void *)offsetof(redirect_router_options_block, bit_options) },
62 { "forbid_filter_reply",opt_bool,
63 (void *)offsetof(redirect_router_options_block, forbid_filter_reply) },
64 { "forbid_filter_run", opt_bit | (RDON_RUN << 16),
65 (void *)offsetof(redirect_router_options_block, bit_options) },
66 { "forbid_include", opt_bit | (RDON_INCLUDE << 16),
67 (void *)offsetof(redirect_router_options_block, bit_options) },
68 { "forbid_pipe", opt_bool,
69 (void *)offsetof(redirect_router_options_block, forbid_pipe) },
70 { "forbid_sieve_filter",opt_bit | (RDON_SIEVE_FILTER << 16),
71 (void *)offsetof(redirect_router_options_block, bit_options) },
72 { "forbid_smtp_code", opt_bool,
73 (void *)offsetof(redirect_router_options_block, forbid_smtp_code) },
74 { "hide_child_in_errmsg", opt_bool,
75 (void *)offsetof(redirect_router_options_block, hide_child_in_errmsg) },
76 { "ignore_eacces", opt_bit | (RDON_EACCES << 16),
77 (void *)offsetof(redirect_router_options_block, bit_options) },
78 { "ignore_enotdir", opt_bit | (RDON_ENOTDIR << 16),
79 (void *)offsetof(redirect_router_options_block, bit_options) },
80 { "include_directory", opt_stringptr,
81 (void *)offsetof(redirect_router_options_block, include_directory) },
82 { "modemask", opt_octint,
83 (void *)offsetof(redirect_router_options_block, modemask) },
84 { "one_time", opt_bool,
85 (void *)offsetof(redirect_router_options_block, one_time) },
86 { "owners", opt_uidlist,
87 (void *)offsetof(redirect_router_options_block, owners) },
88 { "owngroups", opt_gidlist,
89 (void *)offsetof(redirect_router_options_block, owngroups) },
90 { "pipe_transport", opt_stringptr,
91 (void *)offsetof(redirect_router_options_block, pipe_transport_name) },
92 { "qualify_domain", opt_stringptr,
93 (void *)offsetof(redirect_router_options_block, qualify_domain) },
94 { "qualify_preserve_domain", opt_bool,
95 (void *)offsetof(redirect_router_options_block, qualify_preserve_domain) },
96 { "repeat_use", opt_bool | opt_public,
97 (void *)offsetof(router_instance, repeat_use) },
98 { "reply_transport", opt_stringptr,
99 (void *)offsetof(redirect_router_options_block, reply_transport_name) },
100 { "rewrite", opt_bit | (RDON_REWRITE << 16),
101 (void *)offsetof(redirect_router_options_block, bit_options) },
102 { "sieve_enotify_mailto_owner", opt_stringptr,
103 (void *)offsetof(redirect_router_options_block, sieve_enotify_mailto_owner) },
104 { "sieve_subaddress", opt_stringptr,
105 (void *)offsetof(redirect_router_options_block, sieve_subaddress) },
106 { "sieve_useraddress", opt_stringptr,
107 (void *)offsetof(redirect_router_options_block, sieve_useraddress) },
108 { "sieve_vacation_directory", opt_stringptr,
109 (void *)offsetof(redirect_router_options_block, sieve_vacation_directory) },
110 { "skip_syntax_errors", opt_bool,
111 (void *)offsetof(redirect_router_options_block, skip_syntax_errors) },
112 #ifdef EXPERIMENTAL_SRS
113 { "srs", opt_stringptr,
114 (void *)offsetof(redirect_router_options_block, srs) },
115 { "srs_alias", opt_stringptr,
116 (void *)offsetof(redirect_router_options_block, srs_alias) },
117 { "srs_condition", opt_stringptr,
118 (void *)offsetof(redirect_router_options_block, srs_condition) },
119 { "srs_dbinsert", opt_stringptr,
120 (void *)offsetof(redirect_router_options_block, srs_dbinsert) },
121 { "srs_dbselect", opt_stringptr,
122 (void *)offsetof(redirect_router_options_block, srs_dbselect) },
124 { "syntax_errors_text", opt_stringptr,
125 (void *)offsetof(redirect_router_options_block, syntax_errors_text) },
126 { "syntax_errors_to", opt_stringptr,
127 (void *)offsetof(redirect_router_options_block, syntax_errors_to) }
130 /* Size of the options list. An extern variable has to be used so that its
131 address can appear in the tables drtables.c. */
133 int redirect_router_options_count =
134 sizeof(redirect_router_options)/sizeof(optionlist);
140 redirect_router_options_block redirect_router_option_defaults = {0};
141 void redirect_router_init(router_instance *rblock) {}
142 int redirect_router_entry(router_instance *rblock, address_item *addr,
143 struct passwd *pw, int verify, address_item **addr_local,
144 address_item **addr_remote, address_item **addr_new,
145 address_item **addr_succeed) {return 0;}
147 #else /*!MACRO_PREDEF*/
151 /* Default private options block for the redirect router. */
153 redirect_router_options_block redirect_router_option_defaults = {
154 NULL, /* directory_transport */
155 NULL, /* file_transport */
156 NULL, /* pipe_transport */
157 NULL, /* reply_transport */
159 NULL, /* directory_transport_name */
162 NULL, /* file_transport_name */
163 NULL, /* include_directory */
164 NULL, /* pipe_transport_name */
165 NULL, /* reply_transport_name */
166 NULL, /* sieve_subaddress */
167 NULL, /* sieve_useraddress */
168 NULL, /* sieve_vacation_directory */
169 NULL, /* sieve_enotify_mailto_owner */
170 NULL, /* syntax_errors_text */
171 NULL, /* syntax_errors_to */
172 NULL, /* qualify_domain */
174 NULL, /* owngroups */
175 #ifdef EXPERIMENTAL_SRS
177 NULL, /* srs_alias */
178 NULL, /* srs_condition */
179 NULL, /* srs_dbinsert */
180 NULL, /* srs_dbselect */
183 RDO_REWRITE | RDO_PREPEND_HOME, /* bit_options */
184 FALSE, /* check_ancestor */
185 TRUE_UNSET, /* check_owner */
186 TRUE_UNSET, /* check_group */
187 FALSE, /* forbid_file */
188 FALSE, /* forbid_filter_reply */
189 FALSE, /* forbid_pipe */
190 FALSE, /* forbid_smtp_code */
191 FALSE, /* hide_child_in_errmsg */
192 FALSE, /* one_time */
193 FALSE, /* qualify_preserve_domain */
194 FALSE /* skip_syntax_errors */
199 /*************************************************
200 * Initialization entry point *
201 *************************************************/
203 /* Called for each instance, after its options have been read, to enable
204 consistency checks to be done, or anything else that needs to be set up. */
206 void redirect_router_init(router_instance *rblock)
208 redirect_router_options_block *ob =
209 (redirect_router_options_block *)(rblock->options_block);
211 /* Either file or data must be set, but not both */
213 if ((ob->file == NULL) == (ob->data == NULL))
214 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
215 "%sone of \"file\" or \"data\" must be specified",
216 rblock->name, (ob->file == NULL)? "" : "only ");
218 /* Onetime aliases can only be real addresses. Headers can't be manipulated.
219 The combination of one_time and unseen is not allowed. We can't check the
220 expansion of "unseen" here, but we assume that if it is set to anything other
221 than false, there is likely to be a problem. */
225 ob->forbid_pipe = ob->forbid_file = ob->forbid_filter_reply = TRUE;
226 if (rblock->extra_headers || rblock->remove_headers)
227 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
228 "\"headers_add\" and \"headers_remove\" are not permitted with "
229 "\"one_time\"", rblock->name);
230 if (rblock->unseen || rblock->expand_unseen)
231 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
232 "\"unseen\" may not be used with \"one_time\"", rblock->name);
235 /* The defaults for check_owner and check_group depend on other settings. The
236 defaults are: Check the owner if check_local_user or owners is set; check the
237 group if check_local_user is set without a restriction on the group write bit,
238 or if owngroups is set. */
240 if (ob->check_owner == TRUE_UNSET)
241 ob->check_owner = rblock->check_local_user ||
242 (ob->owners && ob->owners[0] != 0);
244 if (ob->check_group == TRUE_UNSET)
245 ob->check_group = (rblock->check_local_user && (ob->modemask & 020) == 0) ||
246 (ob->owngroups != NULL && ob->owngroups[0] != 0);
248 /* If explicit qualify domain set, the preserve option is locked out */
250 if (ob->qualify_domain && ob->qualify_preserve_domain)
251 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
252 "only one of \"qualify_domain\" or \"qualify_preserve_domain\" must be set",
255 /* If allow_filter is set, either user or check_local_user must be set. */
257 if (!rblock->check_local_user &&
259 rblock->expand_uid == NULL &&
260 (ob->bit_options & RDO_FILTER) != 0)
261 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
262 "\"user\" or \"check_local_user\" must be set with \"allow_filter\"",
268 /*************************************************
269 * Get errors address and header mods *
270 *************************************************/
272 /* This function is called when new addresses are generated, in order to
273 sort out errors address and header modifications. We put the errors address
274 into the parent address (even though it is never used from there because that
275 address is never transported) so that it can be retrieved if any of the
276 children gets routed by an "unseen" router. The clone of the child that is
277 passed on must have the original errors_address value.
280 rblock the router control block
281 addr the address being routed
282 verify v_none/v_recipient/v_sender/v_expn
283 addr_prop point to the propagated block, which is where the
284 new values are to be placed
286 Returns: the result of rf_get_errors_address() or rf_get_munge_headers(),
287 which is either OK or DEFER
291 sort_errors_and_headers(router_instance *rblock, address_item *addr,
292 int verify, address_item_propagated *addr_prop)
294 int frc = rf_get_errors_address(addr, rblock, verify,
295 &addr_prop->errors_address);
296 if (frc != OK) return frc;
297 addr->prop.errors_address = addr_prop->errors_address;
298 return rf_get_munge_headers(addr, rblock, &addr_prop->extra_headers,
299 &addr_prop->remove_headers);
304 /*************************************************
305 * Process a set of generated new addresses *
306 *************************************************/
308 /* This function sets up a set of newly generated child addresses and puts them
309 on the new address chain. Copy in the uid, gid and permission flags for use by
310 pipes and files, set the parent, and "or" its af_ignore_error flag. Also record
311 the setting for any starting router.
313 If the generated address is the same as one of its ancestors, and the
314 check_ancestor flag is set, do not use this generated address, but replace it
315 with a copy of the input address. This is to cope with cases where A is aliased
316 to B and B has a .forward file pointing to A, though it is usually set on the
317 forwardfile rather than the aliasfile. We can't just pass on the old
318 address by returning FAIL, because it must act as a general parent for
319 generated addresses, and only get marked "done" when all its children are
324 addr_new new address chain
325 addr original address
326 generated list of generated addresses
327 addr_prop the propagated block, containing the errors_address,
328 header modification stuff, and address_data
329 ugidptr points to uid/gid data for files, pipes, autoreplies
330 pw password entry, set if ob->check_local_user is TRUE
336 add_generated(router_instance *rblock, address_item **addr_new,
337 address_item *addr, address_item *generated,
338 address_item_propagated *addr_prop, ugid_block *ugidptr, struct passwd *pw)
340 redirect_router_options_block *ob =
341 (redirect_router_options_block *)(rblock->options_block);
345 address_item *parent;
346 address_item *next = generated;
347 uschar *errors_address = next->prop.errors_address;
349 generated = next->next;
351 next->start_router = rblock->redirect_router;
352 if (addr->child_count == USHRT_MAX)
353 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
354 "child addresses for <%s>", rblock->name, USHRT_MAX, addr->address);
357 next->next = *addr_new;
360 /* Don't do the "one_time" thing for the first pass of a 2-stage queue run. */
362 if (ob->one_time && !f.queue_2stage)
364 for (parent = addr; parent->parent; parent = parent->parent) ;
365 next->onetime_parent = parent->address;
368 if (ob->hide_child_in_errmsg) setflag(next, af_hide_child);
370 /* If check_ancestor is set, we want to know if any ancestor of this address
371 is the address we are about to generate. The check must be done caselessly
372 unless the ancestor was routed by a case-sensitive router. */
374 if (ob->check_ancestor)
375 for (parent = addr; parent; parent = parent->parent)
376 if ((parent->router && parent->router->caseful_local_part
377 ? Ustrcmp(next->address, parent->address)
378 : strcmpic(next->address, parent->address)
381 DEBUG(D_route) debug_printf("generated parent replaced by child\n");
382 next->address = string_copy(addr->address);
386 /* A user filter may, under some circumstances, set up an errors address.
387 If so, we must take care to re-instate it when we copy in the propagated
388 data so that it overrides any errors_to setting on the router. */
391 BOOL ignore_error = next->prop.ignore_error;
392 next->prop = *addr_prop;
393 next->prop.ignore_error = ignore_error || addr->prop.ignore_error;
395 if (errors_address) next->prop.errors_address = errors_address;
397 /* For pipes, files, and autoreplies, record this router as handling them,
398 because they don't go through the routing process again. Then set up uid,
399 gid, home and current directories for transporting. */
401 if (testflag(next, af_pfr))
403 next->router = rblock;
404 rf_set_ugid(next, ugidptr); /* Will contain pw values if not overridden */
406 /* When getting the home directory out of the password information, wrap it
407 in \N...\N to avoid expansion later. In Cygwin, home directories can
408 contain $ characters. */
410 if (rblock->home_directory != NULL)
411 next->home_dir = rblock->home_directory;
412 else if (rblock->check_local_user)
413 next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
414 else if (rblock->router_home_directory != NULL &&
415 testflag(addr, af_home_expanded))
417 next->home_dir = deliver_home;
418 setflag(next, af_home_expanded);
421 next->current_dir = rblock->current_directory;
423 /* Permission options */
425 if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
426 if (!ob->forbid_file) setflag(next, af_allow_file);
427 if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
429 /* If the transport setting fails, the error gets picked up at the outer
430 level from the setting of basic_errno in the address. */
432 if (next->address[0] == '|')
434 address_pipe = next->address;
435 if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
436 next, rblock->name, US"pipe_transport"))
437 next->transport = ob->pipe_transport;
440 else if (next->address[0] == '>')
442 if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
443 next, rblock->name, US"reply_transport"))
444 next->transport = ob->reply_transport;
446 else /* must be file or directory */
448 int len = Ustrlen(next->address);
449 address_file = next->address;
450 if (next->address[len-1] == '/')
452 if (rf_get_transport(ob->directory_transport_name,
453 &(ob->directory_transport), next, rblock->name,
454 US"directory_transport"))
455 next->transport = ob->directory_transport;
459 if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
460 next, rblock->name, US"file_transport"))
461 next->transport = ob->file_transport;
468 if (!next->prop.utf8_msg)
469 next->prop.utf8_msg = string_is_utf8(next->address)
470 || (sender_address && string_is_utf8(sender_address));
475 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
478 testflag(next, af_pfr)? "pipe, file, or autoreply\n " : "",
479 next->prop.errors_address,
480 (next->transport == NULL)? US"NULL" : next->transport->name);
482 if (testflag(next, af_uid_set))
483 debug_printf(" uid=%ld ", (long int)(next->uid));
485 debug_printf(" uid=unset ");
487 if (testflag(next, af_gid_set))
488 debug_printf("gid=%ld ", (long int)(next->gid));
490 debug_printf("gid=unset ");
493 if (next->prop.utf8_msg) debug_printf("utf8 ");
496 debug_printf("home=%s\n", next->home_dir);
502 /*************************************************
504 *************************************************/
506 /* See local README for interface description. This router returns:
509 . empty address list, or filter did nothing significant
512 . verifying the errors address caused a deferment or a big disaster such
513 as an expansion failure (rf_get_errors_address)
514 . expanding a headers_{add,remove} string caused a deferment or another
515 expansion error (rf_get_munge_headers)
516 . :defer: or "freeze" in a filter
517 . error in address list or filter
518 . skipped syntax errors, but failed to send the message
521 . address was :blackhole:d or "seen finish"ed
527 . new addresses added to addr_new
530 int redirect_router_entry(
531 router_instance *rblock, /* data for this instantiation */
532 address_item *addr, /* address we are working on */
533 struct passwd *pw, /* passwd entry after check_local_user */
534 int verify, /* v_none/v_recipient/v_sender/v_expn */
535 address_item **addr_local, /* add it to this if it's local */
536 address_item **addr_remote, /* add it to this if it's remote */
537 address_item **addr_new, /* put new addresses on here */
538 address_item **addr_succeed) /* put old address here on success */
540 redirect_router_options_block *ob =
541 (redirect_router_options_block *)(rblock->options_block);
542 address_item *generated = NULL;
543 const uschar *save_qualify_domain_recipient = qualify_domain_recipient;
544 uschar *discarded = US"discarded";
545 address_item_propagated addr_prop;
546 error_block *eblock = NULL;
548 redirect_block redirect;
549 int filtertype = FILTER_UNSET;
551 int options = ob->bit_options;
555 addr_local = addr_local; /* Keep picky compilers happy */
556 addr_remote = addr_remote;
558 /* Initialize the data to be propagated to the children */
560 addr_prop.address_data = deliver_address_data;
561 addr_prop.domain_data = deliver_domain_data;
562 addr_prop.localpart_data = deliver_localpart_data;
563 addr_prop.errors_address = NULL;
564 addr_prop.extra_headers = NULL;
565 addr_prop.remove_headers = NULL;
567 #ifdef EXPERIMENTAL_SRS
568 addr_prop.srs_sender = NULL;
571 addr_prop.utf8_msg = addr->prop.utf8_msg;
572 addr_prop.utf8_downcvt = addr->prop.utf8_downcvt;
573 addr_prop.utf8_downcvt_maybe = addr->prop.utf8_downcvt_maybe;
577 /* When verifying and testing addresses, the "logwrite" command in filters
580 if (verify == v_none && !f.address_test_mode) options |= RDO_REALLOG;
582 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
583 file (and interpreting a filter) and (b) for running the transports for
584 generated file and pipe addresses. It is not (necessarily) the same as the uids
585 that may own the file. Exim panics if an expanded string is not a number and
586 can't be found in the password file. Other errors set the freezing bit. */
588 if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
590 if (!ugid.uid_set && pw != NULL)
592 ugid.uid = pw->pw_uid;
596 if (!ugid.gid_set && pw != NULL)
598 ugid.gid = pw->pw_gid;
602 #ifdef EXPERIMENTAL_SRS
603 /* Perform SRS on recipient/return-path as required */
609 if(ob->srs_condition != NULL)
610 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
614 int srs_action = 0, n_srs;
618 /* What are we doing? */
619 if(Ustrcmp(ob->srs, "forward") == 0)
621 else if(Ustrcmp(ob->srs, "reverseandforward") == 0)
625 if((ob->srs_dbinsert == NULL) ^ (ob->srs_dbselect == NULL))
628 else if(Ustrcmp(ob->srs, "reverse") == 0)
634 srs_orig_recipient = addr->address;
638 eximsrs_db_set(TRUE, ob->srs_dbselect);
639 /* Comment this out for now...
641 // eximsrs_db_set(TRUE, NULL);
644 if((n_srs = eximsrs_reverse(&res, addr->address)) == OK)
648 debug_printf("SRS (reverse): Recipient '%s' rewritten to '%s'\n", srs_orig_recipient, srs_recipient);
658 /* No point in actually performing SRS if we are just verifying a recipient */
659 if((srs_action & 1) && verify == v_none &&
660 (sender_address ? sender_address[0] != 0 : FALSE))
663 srs_orig_sender = sender_address;
666 eximsrs_db_set(FALSE, ob->srs_dbinsert);
667 /* Comment this out for now...
669 // eximsrs_db_set(FALSE, NULL);
672 if (!(usedomain = ob->srs_alias ? expand_string(ob->srs_alias) : NULL))
673 usedomain = string_copy(deliver_domain);
675 if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) == OK)
677 addr_prop.srs_sender = res;
679 debug_printf("SRS (forward): Sender '%s' rewritten to '%s'\n", srs_orig_sender, res);
691 /* Call the function that interprets redirection data, either inline or from a
692 file. This is a separate function so that the system filter can use it. It will
693 run the function in a subprocess if necessary. If qualify_preserve_domain is
694 set, temporarily reset qualify_domain_recipient to the current domain so that
695 any unqualified addresses get qualified with the same domain as the incoming
696 address. Otherwise, if a local qualify_domain is provided, set that up. */
698 if (ob->qualify_preserve_domain)
699 qualify_domain_recipient = addr->domain;
700 else if (ob->qualify_domain != NULL)
702 uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
703 if (new_qdr == NULL) return xrc;
704 qualify_domain_recipient = new_qdr;
707 redirect.owners = ob->owners;
708 redirect.owngroups = ob->owngroups;
709 redirect.modemask = ob->modemask;
710 redirect.check_owner = ob->check_owner;
711 redirect.check_group = ob->check_group;
714 if (ob->file != NULL)
716 redirect.string = ob->file;
717 redirect.isfile = TRUE;
721 redirect.string = ob->data;
722 redirect.isfile = FALSE;
725 frc = rda_interpret(&redirect, options, ob->include_directory,
726 ob->sieve_vacation_directory, ob->sieve_enotify_mailto_owner,
727 ob->sieve_useraddress, ob->sieve_subaddress, &ugid, &generated,
728 &(addr->message), ob->skip_syntax_errors? &eblock : NULL, &filtertype,
729 string_sprintf("%s router (recipient is %s)", rblock->name, addr->address));
731 qualify_domain_recipient = save_qualify_domain_recipient;
733 /* Handle exceptional returns from filtering or processing an address list.
734 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
739 addr->message = addr->user_message = NULL;
743 DEBUG(D_route) debug_printf("address :blackhole:d\n");
745 discarded = US":blackhole:";
749 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
750 (:defer: or :fail: in an alias file or "fail" in a filter). If a configured
751 message was supplied, allow it to be included in an SMTP response after
752 verifying. Remove any SMTP code if it is not allowed. */
759 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
761 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
765 if (addr->message == NULL)
766 addr->message = (yield == FAIL)? US"forced rejection" : US"forced defer";
770 if (ob->forbid_smtp_code &&
771 pcre_exec(regex_smtp_code, NULL, CS addr->message,
772 Ustrlen(addr->message), 0, PCRE_EOPT,
773 ovector, sizeof(ovector)/sizeof(int)) >= 0)
775 DEBUG(D_route) debug_printf("SMTP code at start of error message "
776 "is ignored because forbid_smtp_code is set\n");
777 addr->message += ovector[1];
779 addr->user_message = addr->message;
780 setflag(addr, af_pass_message);
784 /* As in the case of a system filter, a freeze does not happen after a manual
785 thaw. In case deliveries were set up by the filter, we set the child count
786 high so that their completion does not mark the original address done. */
789 if (!f.deliver_manual_thaw)
791 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
793 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
794 if (addr->message == NULL) addr->message = US"frozen by filter";
795 addr->special_action = SPECIAL_FREEZE;
796 addr->child_count = 9999;
799 frc = FF_NOTDELIVERED;
802 /* Handle syntax errors and :include: failures and lookup defers */
807 /* If filtertype is still FILTER_UNSET, it means that the redirection data
808 was never inspected, so the error was an expansion failure or failure to open
809 the file, or whatever. In these cases, the existing error message is probably
812 if (filtertype == FILTER_UNSET) return DEFER;
814 /* If it was a filter and skip_syntax_errors is set, we want to set up
815 the error message so that it can be logged and mailed to somebody. */
817 if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
819 eblock = store_get(sizeof(error_block));
821 eblock->text1 = addr->message;
822 eblock->text2 = NULL;
823 addr->message = addr->user_message = NULL;
826 /* Otherwise set up the error for the address and defer. */
830 addr->basic_errno = ERRNO_BADREDIRECT;
831 addr->message = string_sprintf("error in %s %s: %s",
832 (filtertype != FILTER_FORWARD)? "filter" : "redirect",
833 (ob->data == NULL)? "file" : "data",
840 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
841 significant action). Before dealing with these, however, we must handle the
842 effect of skip_syntax_errors.
844 If skip_syntax_errors was set and there were syntax errors in an address list,
845 error messages will be present in eblock. Log them and send a message if so
846 configured. We cannot do this earlier, because the error message must not be
847 sent as the local user. If there were no valid addresses, generated will be
848 NULL. In this case, the router declines.
850 For a filter file, the error message has been fudged into an eblock. After
851 dealing with it, the router declines. */
855 if (!moan_skipped_syntax_errors(
856 rblock->name, /* For message content */
858 (verify != v_none || f.address_test_mode)?
859 NULL : ob->syntax_errors_to, /* Who to mail */
860 generated != NULL, /* True if not all failed */
861 ob->syntax_errors_text)) /* Custom message */
864 if (filtertype != FILTER_FORWARD || generated == NULL)
866 addr->message = US"syntax error in redirection data";
871 /* Sort out the errors address and any header modifications, and handle the
872 generated addresses, if any. If there are no generated addresses, we must avoid
873 calling sort_errors_and_headers() in case this router declines - that function
874 may modify the errors_address field in the current address, and we don't want
875 to do that for a decline. */
877 if (generated != NULL)
879 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
881 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
884 /* FF_DELIVERED with no generated addresses is what we get when an address list
885 contains :blackhole: or a filter contains "seen finish" without having
886 generated anything. Log what happened to this address, and return DISCARD. */
888 if (frc == FF_DELIVERED)
890 if (generated == NULL && verify == v_none && !f.address_test_mode)
892 log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
898 /* For an address list, FF_NOTDELIVERED always means that no addresses were
899 generated. For a filter, addresses may or may not have been generated. If none
900 were, it's the same as an empty address list, and the router declines. However,
901 if addresses were generated, we can't just decline because successful delivery
902 of the base address gets it marked "done", so deferred generated addresses
903 never get tried again. We have to generate a new version of the base address,
904 as if there were a "deliver" command in the filter file, with the original
905 address as parent. */
911 if (generated == NULL) return DECLINE;
913 next = deliver_make_addr(addr->address, FALSE);
916 next->next = *addr_new;
919 /* Set the data that propagates. */
921 next->prop = addr_prop;
923 DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
926 (addr_prop.errors_address != NULL)? " errors to " : "",
927 (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
928 (addr_prop.errors_address != NULL)? "\n" : "");
931 /* Control gets here only when the address has been completely handled. Put the
932 original address onto the succeed queue so that any retry items that get
933 attached to it get processed. */
935 addr->next = *addr_succeed;
936 *addr_succeed = addr;
941 #endif /*!MACRO_PREDEF*/
942 /* End of routers/redirect.c */