1 /* $Cambridge: exim/src/src/routers/redirect.c,v 1.20 2007/01/08 10:50:20 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2007 */
8 /* See the file NOTICE for conditions of use and distribution. */
12 #include "rf_functions.h"
17 /* Options specific to the redirect router. */
19 optionlist redirect_router_options[] = {
20 { "allow_defer", opt_bit | (RDON_DEFER << 16),
21 (void *)offsetof(redirect_router_options_block, bit_options) },
22 { "allow_fail", opt_bit | (RDON_FAIL << 16),
23 (void *)offsetof(redirect_router_options_block, bit_options) },
24 { "allow_filter", opt_bit | (RDON_FILTER << 16),
25 (void *)offsetof(redirect_router_options_block, bit_options) },
26 { "allow_freeze", opt_bit | (RDON_FREEZE << 16),
27 (void *)offsetof(redirect_router_options_block, bit_options) },
28 { "check_ancestor", opt_bool,
29 (void *)offsetof(redirect_router_options_block, check_ancestor) },
30 { "check_group", opt_bool,
31 (void *)offsetof(redirect_router_options_block, check_group) },
32 { "check_owner", opt_bool,
33 (void *)offsetof(redirect_router_options_block, check_owner) },
34 { "data", opt_stringptr,
35 (void *)offsetof(redirect_router_options_block, data) },
36 { "directory_transport",opt_stringptr,
37 (void *)offsetof(redirect_router_options_block, directory_transport_name) },
38 { "file", opt_stringptr,
39 (void *)offsetof(redirect_router_options_block, file) },
40 { "file_transport", opt_stringptr,
41 (void *)offsetof(redirect_router_options_block, file_transport_name) },
42 { "filter_prepend_home",opt_bit | (RDON_PREPEND_HOME << 16),
43 (void *)offsetof(redirect_router_options_block, bit_options) },
44 { "forbid_blackhole", opt_bit | (RDON_BLACKHOLE << 16),
45 (void *)offsetof(redirect_router_options_block, bit_options) },
46 { "forbid_exim_filter", opt_bit | (RDON_EXIM_FILTER << 16),
47 (void *)offsetof(redirect_router_options_block, bit_options) },
48 { "forbid_file", opt_bool,
49 (void *)offsetof(redirect_router_options_block, forbid_file) },
50 { "forbid_filter_dlfunc", opt_bit | (RDON_DLFUNC << 16),
51 (void *)offsetof(redirect_router_options_block, bit_options) },
52 { "forbid_filter_existstest", opt_bit | (RDON_EXISTS << 16),
53 (void *)offsetof(redirect_router_options_block, bit_options) },
54 { "forbid_filter_logwrite",opt_bit | (RDON_LOG << 16),
55 (void *)offsetof(redirect_router_options_block, bit_options) },
56 { "forbid_filter_lookup", opt_bit | (RDON_LOOKUP << 16),
57 (void *)offsetof(redirect_router_options_block, bit_options) },
58 { "forbid_filter_perl", opt_bit | (RDON_PERL << 16),
59 (void *)offsetof(redirect_router_options_block, bit_options) },
60 { "forbid_filter_readfile", opt_bit | (RDON_READFILE << 16),
61 (void *)offsetof(redirect_router_options_block, bit_options) },
62 { "forbid_filter_readsocket", opt_bit | (RDON_READSOCK << 16),
63 (void *)offsetof(redirect_router_options_block, bit_options) },
64 { "forbid_filter_reply",opt_bool,
65 (void *)offsetof(redirect_router_options_block, forbid_filter_reply) },
66 { "forbid_filter_run", opt_bit | (RDON_RUN << 16),
67 (void *)offsetof(redirect_router_options_block, bit_options) },
68 { "forbid_include", opt_bit | (RDON_INCLUDE << 16),
69 (void *)offsetof(redirect_router_options_block, bit_options) },
70 { "forbid_pipe", opt_bool,
71 (void *)offsetof(redirect_router_options_block, forbid_pipe) },
72 { "forbid_sieve_filter",opt_bit | (RDON_SIEVE_FILTER << 16),
73 (void *)offsetof(redirect_router_options_block, bit_options) },
74 { "forbid_smtp_code", opt_bool,
75 (void *)offsetof(redirect_router_options_block, forbid_smtp_code) },
76 { "hide_child_in_errmsg", opt_bool,
77 (void *)offsetof(redirect_router_options_block, hide_child_in_errmsg) },
78 { "ignore_eacces", opt_bit | (RDON_EACCES << 16),
79 (void *)offsetof(redirect_router_options_block, bit_options) },
80 { "ignore_enotdir", opt_bit | (RDON_ENOTDIR << 16),
81 (void *)offsetof(redirect_router_options_block, bit_options) },
82 { "include_directory", opt_stringptr,
83 (void *)offsetof(redirect_router_options_block, include_directory) },
84 { "modemask", opt_octint,
85 (void *)offsetof(redirect_router_options_block, modemask) },
86 { "one_time", opt_bool,
87 (void *)offsetof(redirect_router_options_block, one_time) },
88 { "owners", opt_uidlist,
89 (void *)offsetof(redirect_router_options_block, owners) },
90 { "owngroups", opt_gidlist,
91 (void *)offsetof(redirect_router_options_block, owngroups) },
92 { "pipe_transport", opt_stringptr,
93 (void *)offsetof(redirect_router_options_block, pipe_transport_name) },
94 { "qualify_domain", opt_stringptr,
95 (void *)offsetof(redirect_router_options_block, qualify_domain) },
96 { "qualify_preserve_domain", opt_bool,
97 (void *)offsetof(redirect_router_options_block, qualify_preserve_domain) },
98 { "repeat_use", opt_bool | opt_public,
99 (void *)offsetof(router_instance, repeat_use) },
100 { "reply_transport", opt_stringptr,
101 (void *)offsetof(redirect_router_options_block, reply_transport_name) },
102 { "rewrite", opt_bit | (RDON_REWRITE << 16),
103 (void *)offsetof(redirect_router_options_block, bit_options) },
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);
136 /* Default private options block for the redirect router. */
138 redirect_router_options_block redirect_router_option_defaults = {
139 NULL, /* directory_transport */
140 NULL, /* file_transport */
141 NULL, /* pipe_transport */
142 NULL, /* reply_transport */
144 NULL, /* directory_transport_name */
147 NULL, /* file_transport_name */
148 NULL, /* include_directory */
149 NULL, /* pipe_transport_name */
150 NULL, /* reply_transport_name */
151 NULL, /* sieve_subaddress */
152 NULL, /* sieve_useraddress */
153 NULL, /* sieve_vacation_directory */
154 NULL, /* syntax_errors_text */
155 NULL, /* syntax_errors_to */
156 NULL, /* qualify_domain */
158 NULL, /* owngroups */
159 #ifdef EXPERIMENTAL_SRS
161 NULL, /* srs_alias */
162 NULL, /* srs_condition */
163 NULL, /* srs_dbinsert */
164 NULL, /* srs_dbselect */
167 RDO_REWRITE | RDO_PREPEND_HOME, /* bit_options */
168 FALSE, /* check_ancestor */
169 TRUE_UNSET, /* check_owner */
170 TRUE_UNSET, /* check_group */
171 FALSE, /* forbid_file */
172 FALSE, /* forbid_filter_reply */
173 FALSE, /* forbid_pipe */
174 FALSE, /* forbid_smtp_code */
175 FALSE, /* hide_child_in_errmsg */
176 FALSE, /* one_time */
177 FALSE, /* qualify_preserve_domain */
178 FALSE /* skip_syntax_errors */
183 /*************************************************
184 * Initialization entry point *
185 *************************************************/
187 /* Called for each instance, after its options have been read, to enable
188 consistency checks to be done, or anything else that needs to be set up. */
190 void redirect_router_init(router_instance *rblock)
192 redirect_router_options_block *ob =
193 (redirect_router_options_block *)(rblock->options_block);
195 /* Either file or data must be set, but not both */
197 if ((ob->file == NULL) == (ob->data == NULL))
198 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
199 "%sone of \"file\" or \"data\" must be specified",
200 rblock->name, (ob->file == NULL)? "" : "only ");
202 /* Onetime aliases can only be real addresses. Headers can't be manipulated.
203 The combination of one_time and unseen is not allowed. We can't check the
204 expansion of "unseen" here, but we assume that if it is set to anything other
205 than false, there is likely to be a problem. */
209 ob->forbid_pipe = ob->forbid_file = ob->forbid_filter_reply = TRUE;
210 if (rblock->extra_headers != NULL || rblock->remove_headers != NULL)
211 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
212 "\"headers_add\" and \"headers_remove\" are not permitted with "
213 "\"one_time\"", rblock->name);
214 if (rblock->unseen || rblock->expand_unseen != NULL)
215 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
216 "\"unseen\" may not be used with \"one_time\"", rblock->name);
219 /* The defaults for check_owner and check_group depend on other settings. The
220 defaults are: Check the owner if check_local_user or owners is set; check the
221 group if check_local_user is set without a restriction on the group write bit,
222 or if owngroups is set. */
224 if (ob->check_owner == TRUE_UNSET)
225 ob->check_owner = rblock->check_local_user ||
226 (ob->owners != NULL && ob->owners[0] != 0);
228 if (ob->check_group == TRUE_UNSET)
229 ob->check_group = (rblock->check_local_user && (ob->modemask & 020) == 0) ||
230 (ob->owngroups != NULL && ob->owngroups[0] != 0);
232 /* If explicit qualify domain set, the preserve option is locked out */
234 if (ob->qualify_domain != NULL && ob->qualify_preserve_domain)
235 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
236 "only one of \"qualify_domain\" or \"qualify_preserve_domain\" must be set",
239 /* If allow_filter is set, either user or check_local_user must be set. */
241 if (!rblock->check_local_user &&
243 rblock->expand_uid == NULL &&
244 (ob->bit_options & RDO_FILTER) != 0)
245 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
246 "\"user\" or \"check_local_user\" must be set with \"allow_filter\"",
252 /*************************************************
253 * Get errors address and header mods *
254 *************************************************/
256 /* This function is called when new addresses are generated, in order to
257 sort out errors address and header modifications. We put the errors address
258 into the parent address (even though it is never used from there because that
259 address is never transported) so that it can be retrieved if any of the
260 children gets routed by an "unseen" router. The clone of the child that is
261 passed on must have the original errors_address value.
264 rblock the router control block
265 addr the address being routed
266 verify v_none/v_recipient/v_sender/v_expn
267 addr_prop point to the propagated block, which is where the
268 new values are to be placed
270 Returns: the result of rf_get_errors_address() or rf_get_munge_headers(),
271 which is either OK or DEFER
275 sort_errors_and_headers(router_instance *rblock, address_item *addr,
276 int verify, address_item_propagated *addr_prop)
278 int frc = rf_get_errors_address(addr, rblock, verify,
279 &(addr_prop->errors_address));
280 if (frc != OK) return frc;
281 addr->p.errors_address = addr_prop->errors_address;
282 return rf_get_munge_headers(addr, rblock, &(addr_prop->extra_headers),
283 &(addr_prop->remove_headers));
288 /*************************************************
289 * Process a set of generated new addresses *
290 *************************************************/
292 /* This function sets up a set of newly generated child addresses and puts them
293 on the new address chain. Copy in the uid, gid and permission flags for use by
294 pipes and files, set the parent, and "or" its af_ignore_error flag. Also record
295 the setting for any starting router.
297 If the generated address is the same as one of its ancestors, and the
298 check_ancestor flag is set, do not use this generated address, but replace it
299 with a copy of the input address. This is to cope with cases where A is aliased
300 to B and B has a .forward file pointing to A, though it is usually set on the
301 forwardfile rather than the aliasfile. We can't just pass on the old
302 address by returning FAIL, because it must act as a general parent for
303 generated addresses, and only get marked "done" when all its children are
308 addr_new new address chain
309 addr original address
310 generated list of generated addresses
311 addr_prop the propagated block, containing the errors_address,
312 header modification stuff, and address_data
313 ugidptr points to uid/gid data for files, pipes, autoreplies
314 pw password entry, set if ob->check_local_user is TRUE
320 add_generated(router_instance *rblock, address_item **addr_new,
321 address_item *addr, address_item *generated,
322 address_item_propagated *addr_prop, ugid_block *ugidptr, struct passwd *pw)
324 redirect_router_options_block *ob =
325 (redirect_router_options_block *)(rblock->options_block);
327 while (generated != NULL)
329 address_item *parent;
330 address_item *next = generated;
331 uschar *errors_address = next->p.errors_address;
333 generated = next->next;
335 orflag(next, addr, af_ignore_error);
336 next->start_router = rblock->redirect_router;
337 if (addr->child_count == SHRT_MAX)
338 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
339 "child addresses for <%s>", rblock->name, SHRT_MAX, addr->address);
342 next->next = *addr_new;
345 /* Don't do the "one_time" thing for the first pass of a 2-stage queue run. */
347 if (ob->one_time && !queue_2stage)
349 for (parent = addr; parent->parent != NULL; parent = parent->parent);
350 next->onetime_parent = parent->address;
353 if (ob->hide_child_in_errmsg) setflag(next, af_hide_child);
355 /* If check_ancestor is set, we want to know if any ancestor of this address
356 is the address we are about to generate. The check must be done caselessly
357 unless the ancestor was routed by a case-sensitive router. */
359 if (ob->check_ancestor)
361 for (parent = addr; parent != NULL; parent = parent->parent)
363 if (((parent->router != NULL && parent->router->caseful_local_part)?
364 Ustrcmp(next->address, parent->address)
366 strcmpic(next->address, parent->address)
369 DEBUG(D_route) debug_printf("generated parent replaced by child\n");
370 next->address = string_copy(addr->address);
376 /* A user filter may, under some circumstances, set up an errors address.
377 If so, we must take care to re-instate it when we copy in the propagated
378 data so that it overrides any errors_to setting on the router. */
380 next->p = *addr_prop;
381 if (errors_address != NULL) next->p.errors_address = errors_address;
383 /* For pipes, files, and autoreplies, record this router as handling them,
384 because they don't go through the routing process again. Then set up uid,
385 gid, home and current directories for transporting. */
387 if (testflag(next, af_pfr))
389 next->router = rblock;
390 rf_set_ugid(next, ugidptr); /* Will contain pw values if not overridden */
392 /* When getting the home directory out of the password information, wrap it
393 in \N...\N to avoid expansion later. In Cygwin, home directories can
394 contain $ characters. */
396 if (rblock->home_directory != NULL)
397 next->home_dir = rblock->home_directory;
398 else if (rblock->check_local_user)
399 next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
400 else if (rblock->router_home_directory != NULL &&
401 testflag(addr, af_home_expanded))
403 next->home_dir = deliver_home;
404 setflag(next, af_home_expanded);
407 next->current_dir = rblock->current_directory;
409 /* Permission options */
411 if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
412 if (!ob->forbid_file) setflag(next, af_allow_file);
413 if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
415 /* If the transport setting fails, the error gets picked up at the outer
416 level from the setting of basic_errno in the address. */
418 if (next->address[0] == '|')
420 address_pipe = next->address;
421 if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
422 next, rblock->name, US"pipe_transport"))
423 next->transport = ob->pipe_transport;
426 else if (next->address[0] == '>')
428 if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
429 next, rblock->name, US"reply_transport"))
430 next->transport = ob->reply_transport;
432 else /* must be file or directory */
434 int len = Ustrlen(next->address);
435 address_file = next->address;
436 if (next->address[len-1] == '/')
438 if (rf_get_transport(ob->directory_transport_name,
439 &(ob->directory_transport), next, rblock->name,
440 US"directory_transport"))
441 next->transport = ob->directory_transport;
445 if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
446 next, rblock->name, US"file_transport"))
447 next->transport = ob->file_transport;
455 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
458 testflag(next, af_pfr)? "pipe, file, or autoreply\n " : "",
459 next->p.errors_address,
460 (next->transport == NULL)? US"NULL" : next->transport->name);
462 if (testflag(next, af_uid_set))
463 debug_printf(" uid=%ld ", (long int)(next->uid));
465 debug_printf(" uid=unset ");
467 if (testflag(next, af_gid_set))
468 debug_printf("gid=%ld ", (long int)(next->gid));
470 debug_printf("gid=unset ");
472 debug_printf("home=%s\n", next->home_dir);
478 /*************************************************
480 *************************************************/
482 /* See local README for interface description. This router returns:
485 . empty address list, or filter did nothing significant
488 . verifying the errors address caused a deferment or a big disaster such
489 as an expansion failure (rf_get_errors_address)
490 . expanding a headers_{add,remove} string caused a deferment or another
491 expansion error (rf_get_munge_headers)
492 . :defer: or "freeze" in a filter
493 . error in address list or filter
494 . skipped syntax errors, but failed to send the message
497 . address was :blackhole:d or "seen finish"ed
503 . new addresses added to addr_new
506 int redirect_router_entry(
507 router_instance *rblock, /* data for this instantiation */
508 address_item *addr, /* address we are working on */
509 struct passwd *pw, /* passwd entry after check_local_user */
510 int verify, /* v_none/v_recipient/v_sender/v_expn */
511 address_item **addr_local, /* add it to this if it's local */
512 address_item **addr_remote, /* add it to this if it's remote */
513 address_item **addr_new, /* put new addresses on here */
514 address_item **addr_succeed) /* put old address here on success */
516 redirect_router_options_block *ob =
517 (redirect_router_options_block *)(rblock->options_block);
518 address_item *generated = NULL;
519 uschar *save_qualify_domain_recipient = qualify_domain_recipient;
520 uschar *discarded = US"discarded";
521 address_item_propagated addr_prop;
522 error_block *eblock = NULL;
524 redirect_block redirect;
525 int filtertype = FILTER_UNSET;
527 int options = ob->bit_options;
531 addr_local = addr_local; /* Keep picky compilers happy */
532 addr_remote = addr_remote;
534 /* Initialize the data to be propagated to the children */
536 addr_prop.address_data = deliver_address_data;
537 addr_prop.domain_data = deliver_domain_data;
538 addr_prop.localpart_data = deliver_localpart_data;
539 addr_prop.errors_address = NULL;
540 addr_prop.extra_headers = NULL;
541 addr_prop.remove_headers = NULL;
543 #ifdef EXPERIMENTAL_SRS
544 addr_prop.srs_sender = NULL;
547 /* When verifying and testing addresses, the "logwrite" command in filters
550 if (verify == v_none && !address_test_mode) options |= RDO_REALLOG;
552 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
553 file (and interpreting a filter) and (b) for running the transports for
554 generated file and pipe addresses. It is not (necessarily) the same as the uids
555 that may own the file. Exim panics if an expanded string is not a number and
556 can't be found in the password file. Other errors set the freezing bit. */
558 if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
560 if (!ugid.uid_set && pw != NULL)
562 ugid.uid = pw->pw_uid;
566 if (!ugid.gid_set && pw != NULL)
568 ugid.gid = pw->pw_gid;
572 #ifdef EXPERIMENTAL_SRS
573 /* Perform SRS on recipient/return-path as required */
579 if(ob->srs_condition != NULL)
580 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
584 int srs_action = 0, n_srs;
588 /* What are we doing? */
589 if(Ustrcmp(ob->srs, "forward") == 0)
591 else if(Ustrcmp(ob->srs, "reverseandforward") == 0)
595 if((ob->srs_dbinsert == NULL) ^ (ob->srs_dbselect == NULL))
598 else if(Ustrcmp(ob->srs, "reverse") == 0)
604 srs_orig_recipient = addr->address;
608 eximsrs_db_set(TRUE, ob->srs_dbselect);
609 /* Comment this out for now...
611 // eximsrs_db_set(TRUE, NULL);
614 if((n_srs = eximsrs_reverse(&res, addr->address)) == OK)
618 debug_printf("SRS (reverse): Recipient '%s' rewritten to '%s'\n", srs_orig_recipient, srs_recipient);
628 /* No point in actually performing SRS if we are just verifying a recipient */
629 if((srs_action & 1) && verify == v_none &&
630 (sender_address ? sender_address[0] != 0 : FALSE))
633 srs_orig_sender = sender_address;
636 eximsrs_db_set(FALSE, ob->srs_dbinsert);
637 /* Comment this out for now...
639 // eximsrs_db_set(FALSE, NULL);
642 if(ob->srs_alias != NULL ? (usedomain = expand_string(ob->srs_alias)) == NULL : 1)
643 usedomain = deliver_domain;
645 if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) == OK)
647 addr_prop.srs_sender = res;
649 debug_printf("SRS (forward): Sender '%s' rewritten to '%s'\n", srs_orig_sender, res);
661 /* Call the function that interprets redirection data, either inline or from a
662 file. This is a separate function so that the system filter can use it. It will
663 run the function in a subprocess if necessary. If qualify_preserve_domain is
664 set, temporarily reset qualify_domain_recipient to the current domain so that
665 any unqualified addresses get qualified with the same domain as the incoming
666 address. Otherwise, if a local qualify_domain is provided, set that up. */
668 if (ob->qualify_preserve_domain)
669 qualify_domain_recipient = addr->domain;
670 else if (ob->qualify_domain != NULL)
672 uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
673 if (new_qdr == NULL) return xrc;
674 qualify_domain_recipient = new_qdr;
677 redirect.owners = ob->owners;
678 redirect.owngroups = ob->owngroups;
679 redirect.modemask = ob->modemask;
680 redirect.check_owner = ob->check_owner;
681 redirect.check_group = ob->check_group;
684 if (ob->file != NULL)
686 redirect.string = ob->file;
687 redirect.isfile = TRUE;
691 redirect.string = ob->data;
692 redirect.isfile = FALSE;
695 frc = rda_interpret(&redirect, options, ob->include_directory,
696 ob->sieve_vacation_directory, ob->sieve_useraddress, ob->sieve_subaddress,
697 &ugid, &generated, &(addr->message), ob->skip_syntax_errors? &eblock : NULL,
698 &filtertype, string_sprintf("%s router (recipient is %s)", rblock->name,
701 qualify_domain_recipient = save_qualify_domain_recipient;
703 /* Handle exceptional returns from filtering or processing an address list.
704 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
709 addr->message = addr->user_message = NULL;
713 DEBUG(D_route) debug_printf("address :blackhole:d\n");
715 discarded = US":blackhole:";
719 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
720 (:defer: or :fail: in an alias file or "fail" in a filter). If a configured
721 message was supplied, allow it to be included in an SMTP response after
722 verifying. Remove any SMTP code if it is not allowed. */
729 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
731 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
735 if (addr->message == NULL)
736 addr->message = (yield == FAIL)? US"forced rejection" : US"forced defer";
740 if (ob->forbid_smtp_code &&
741 pcre_exec(regex_smtp_code, NULL, CS addr->message,
742 Ustrlen(addr->message), 0, PCRE_EOPT,
743 ovector, sizeof(ovector)/sizeof(int)) >= 0)
745 DEBUG(D_route) debug_printf("SMTP code at start of error message "
746 "is ignored because forbid_smtp_code is set\n");
747 addr->message += ovector[1];
749 addr->user_message = addr->message;
750 setflag(addr, af_pass_message);
754 /* As in the case of a system filter, a freeze does not happen after a manual
755 thaw. In case deliveries were set up by the filter, we set the child count
756 high so that their completion does not mark the original address done. */
759 if (!deliver_manual_thaw)
761 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
763 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
764 if (addr->message == NULL) addr->message = US"frozen by filter";
765 addr->special_action = SPECIAL_FREEZE;
766 addr->child_count = 9999;
769 frc = FF_NOTDELIVERED;
772 /* Handle syntax errors and :include: failures and lookup defers */
777 /* If filtertype is still FILTER_UNSET, it means that the redirection data
778 was never inspected, so the error was an expansion failure or failure to open
779 the file, or whatever. In these cases, the existing error message is probably
782 if (filtertype == FILTER_UNSET) return DEFER;
784 /* If it was a filter and skip_syntax_errors is set, we want to set up
785 the error message so that it can be logged and mailed to somebody. */
787 if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
789 eblock = store_get(sizeof(error_block));
791 eblock->text1 = addr->message;
792 eblock->text2 = NULL;
793 addr->message = addr->user_message = NULL;
796 /* Otherwise set up the error for the address and defer. */
800 addr->basic_errno = ERRNO_BADREDIRECT;
801 addr->message = string_sprintf("error in %s %s: %s",
802 (filtertype != FILTER_FORWARD)? "filter" : "redirect",
803 (ob->data == NULL)? "file" : "data",
810 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
811 significant action). Before dealing with these, however, we must handle the
812 effect of skip_syntax_errors.
814 If skip_syntax_errors was set and there were syntax errors in an address list,
815 error messages will be present in eblock. Log them and send a message if so
816 configured. We cannot do this earlier, because the error message must not be
817 sent as the local user. If there were no valid addresses, generated will be
818 NULL. In this case, the router declines.
820 For a filter file, the error message has been fudged into an eblock. After
821 dealing with it, the router declines. */
825 if (!moan_skipped_syntax_errors(
826 rblock->name, /* For message content */
828 (verify != v_none || address_test_mode)?
829 NULL : ob->syntax_errors_to, /* Who to mail */
830 generated != NULL, /* True if not all failed */
831 ob->syntax_errors_text)) /* Custom message */
834 if (filtertype != FILTER_FORWARD || generated == NULL)
836 addr->message = US"syntax error in redirection data";
841 /* Sort out the errors address and any header modifications, and handle the
842 generated addresses, if any. If there are no generated addresses, we must avoid
843 calling sort_errors_and_headers() in case this router declines - that function
844 may modify the errors_address field in the current address, and we don't want
845 to do that for a decline. */
847 if (generated != NULL)
849 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
851 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
854 /* FF_DELIVERED with no generated addresses is what we get when an address list
855 contains :blackhole: or a filter contains "seen finish" without having
856 generated anything. Log what happened to this address, and return DISCARD. */
858 if (frc == FF_DELIVERED)
860 if (generated == NULL && verify == v_none && !address_test_mode)
862 log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
868 /* For an address list, FF_NOTDELIVERED always means that no addresses were
869 generated. For a filter, addresses may or may not have been generated. If none
870 were, it's the same as an empty address list, and the router declines. However,
871 if addresses were generated, we can't just decline because successful delivery
872 of the base address gets it marked "done", so deferred generated addresses
873 never get tried again. We have to generate a new version of the base address,
874 as if there were a "deliver" command in the filter file, with the original
875 address as parent. */
881 if (generated == NULL) return DECLINE;
883 next = deliver_make_addr(addr->address, FALSE);
886 next->next = *addr_new;
889 /* Copy relevant flags (af_propagate is a name for the set), and set the
890 data that propagates. */
892 copyflag(next, addr, af_propagate);
895 DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
898 (addr_prop.errors_address != NULL)? " errors to " : "",
899 (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
900 (addr_prop.errors_address != NULL)? "\n" : "");
903 /* Control gets here only when the address has been completely handled. Put the
904 original address onto the succeed queue so that any retry items that get
905 attached to it get processed. */
907 addr->next = *addr_succeed;
908 *addr_succeed = addr;
913 /* End of routers/redirect.c */