Merge from EXISCAN branch.
[exim.git] / src / src / routers / redirect.c
1 /* $Cambridge: exim/src/src/routers/redirect.c,v 1.3 2004/12/16 15:11:48 tom Exp $ */
2
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2004 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10
11 #include "../exim.h"
12 #include "rf_functions.h"
13 #include "redirect.h"
14
15
16
17 /* Options specific to the redirect router. */
18
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 { "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_existstest", opt_bit | (RDON_EXISTS << 16),
49 (void *)offsetof(redirect_router_options_block, bit_options) },
50 { "forbid_filter_logwrite",opt_bit | (RDON_LOG << 16),
51 (void *)offsetof(redirect_router_options_block, bit_options) },
52 { "forbid_filter_lookup", opt_bit | (RDON_LOOKUP << 16),
53 (void *)offsetof(redirect_router_options_block, bit_options) },
54 #ifdef EXIM_PERL
55 { "forbid_filter_perl", opt_bit | (RDON_PERL << 16),
56 (void *)offsetof(redirect_router_options_block, bit_options) },
57 #endif
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 { "hide_child_in_errmsg", opt_bool,
73 (void *)offsetof(redirect_router_options_block, hide_child_in_errmsg) },
74 { "ignore_eacces", opt_bit | (RDON_EACCES << 16),
75 (void *)offsetof(redirect_router_options_block, bit_options) },
76 { "ignore_enotdir", opt_bit | (RDON_ENOTDIR << 16),
77 (void *)offsetof(redirect_router_options_block, bit_options) },
78 { "include_directory", opt_stringptr,
79 (void *)offsetof(redirect_router_options_block, include_directory) },
80 { "modemask", opt_octint,
81 (void *)offsetof(redirect_router_options_block, modemask) },
82 { "one_time", opt_bool,
83 (void *)offsetof(redirect_router_options_block, one_time) },
84 { "owners", opt_uidlist,
85 (void *)offsetof(redirect_router_options_block, owners) },
86 { "owngroups", opt_gidlist,
87 (void *)offsetof(redirect_router_options_block, owngroups) },
88 { "pipe_transport", opt_stringptr,
89 (void *)offsetof(redirect_router_options_block, pipe_transport_name) },
90 { "qualify_domain", opt_stringptr,
91 (void *)offsetof(redirect_router_options_block, qualify_domain) },
92 { "qualify_preserve_domain", opt_bool,
93 (void *)offsetof(redirect_router_options_block, qualify_preserve_domain) },
94 { "repeat_use", opt_bool | opt_public,
95 (void *)offsetof(router_instance, repeat_use) },
96 { "reply_transport", opt_stringptr,
97 (void *)offsetof(redirect_router_options_block, reply_transport_name) },
98 { "rewrite", opt_bit | (RDON_REWRITE << 16),
99 (void *)offsetof(redirect_router_options_block, bit_options) },
100 { "sieve_vacation_directory", opt_stringptr,
101 (void *)offsetof(redirect_router_options_block, sieve_vacation_directory) },
102 { "skip_syntax_errors", opt_bool,
103 (void *)offsetof(redirect_router_options_block, skip_syntax_errors) },
104 #ifdef EXPERIMENTAL_SRS
105 { "srs", opt_stringptr,
106 (void *)offsetof(redirect_router_options_block, srs) },
107 { "srs_alias", opt_stringptr,
108 (void *)offsetof(redirect_router_options_block, srs_alias) },
109 { "srs_condition", opt_stringptr,
110 (void *)offsetof(redirect_router_options_block, srs_condition) },
111 { "srs_db", opt_stringptr,
112 (void *)offsetof(redirect_router_options_block, srs_db) },
113 #endif
114 { "syntax_errors_text", opt_stringptr,
115 (void *)offsetof(redirect_router_options_block, syntax_errors_text) },
116 { "syntax_errors_to", opt_stringptr,
117 (void *)offsetof(redirect_router_options_block, syntax_errors_to) }
118 };
119
120 /* Size of the options list. An extern variable has to be used so that its
121 address can appear in the tables drtables.c. */
122
123 int redirect_router_options_count =
124 sizeof(redirect_router_options)/sizeof(optionlist);
125
126 /* Default private options block for the redirect router. */
127
128 redirect_router_options_block redirect_router_option_defaults = {
129 NULL, /* directory_transport */
130 NULL, /* file_transport */
131 NULL, /* pipe_transport */
132 NULL, /* reply_transport */
133 NULL, /* data */
134 NULL, /* directory_transport_name */
135 NULL, /* file */
136 NULL, /* file_dir */
137 NULL, /* file_transport_name */
138 NULL, /* include_directory */
139 NULL, /* pipe_transport_name */
140 NULL, /* reply_transport_name */
141 NULL, /* sieve_vacation_directory */
142 NULL, /* syntax_errors_text */
143 NULL, /* syntax_errors_to */
144 NULL, /* qualify_domain */
145 NULL, /* owners */
146 NULL, /* owngroups */
147 #ifdef EXPERIMENTAL_SRS
148 NULL, /* srs */
149 NULL, /* srs_condition */
150 NULL, /* srs_db */
151 NULL, /* srs_alias */
152 #endif
153 022, /* modemask */
154 RDO_REWRITE, /* bit_options */
155 FALSE, /* check_ancestor */
156 TRUE_UNSET, /* check_owner */
157 TRUE_UNSET, /* check_group */
158 FALSE, /* forbid_file */
159 FALSE, /* forbid_filter_reply */
160 FALSE, /* forbid_pipe */
161 FALSE, /* hide_child_in_errmsg */
162 FALSE, /* one_time */
163 FALSE, /* qualify_preserve_domain */
164 FALSE /* skip_syntax_errors */
165 };
166
167
168
169 /*************************************************
170 * Initialization entry point *
171 *************************************************/
172
173 /* Called for each instance, after its options have been read, to enable
174 consistency checks to be done, or anything else that needs to be set up. */
175
176 void redirect_router_init(router_instance *rblock)
177 {
178 redirect_router_options_block *ob =
179 (redirect_router_options_block *)(rblock->options_block);
180
181 /* Either file or data must be set, but not both */
182
183 if ((ob->file == NULL) == (ob->data == NULL))
184 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
185 "%sone of \"file\" or \"data\" must be specified",
186 rblock->name, (ob->file == NULL)? "" : "only ");
187
188 /* Onetime aliases can only be real addresses. Headers can't be manipulated. */
189
190 if (ob->one_time)
191 {
192 ob->forbid_pipe = ob->forbid_file = ob->forbid_filter_reply = TRUE;
193 if (rblock->extra_headers != NULL || rblock->remove_headers != NULL)
194 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
195 "\"headers_add\" and \"headers_remove\" are not permitted with "
196 "\"one_time\"", rblock->name);
197 }
198
199 /* The defaults for check_owner and check_group depend on other settings. The
200 defaults are: Check the owner if check_local_user or owners is set; check the
201 group if check_local_user is set without a restriction on the group write bit,
202 or if owngroups is set. */
203
204 if (ob->check_owner == TRUE_UNSET)
205 ob->check_owner = rblock->check_local_user ||
206 (ob->owners != NULL && ob->owners[0] != 0);
207
208 if (ob->check_group == TRUE_UNSET)
209 ob->check_group = (rblock->check_local_user && (ob->modemask & 020) == 0) ||
210 (ob->owngroups != NULL && ob->owngroups[0] != 0);
211
212 /* If explicit qualify domain set, the preserve option is locked out */
213
214 if (ob->qualify_domain != NULL && ob->qualify_preserve_domain)
215 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
216 "only one of \"qualify_domain\" or \"qualify_preserve_domain\" must be set",
217 rblock->name);
218
219 /* If allow_filter is set, either user or check_local_user must be set. */
220
221 if (!rblock->check_local_user &&
222 !rblock->uid_set &&
223 rblock->expand_uid == NULL &&
224 (ob->bit_options & RDO_FILTER) != 0)
225 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
226 "\"user\" or \"check_local_user\" must be set with \"allow_filter\"",
227 rblock->name);
228 }
229
230
231
232 /*************************************************
233 * Get errors address and header mods *
234 *************************************************/
235
236 /* This function is called when new addresses are generated, in order to
237 sort out errors address and header modifications. We put the errors address
238 into the parent address (even though it is never used from there because that
239 address is never transported) so that it can be retrieved if any of the
240 children gets routed by an "unseen" router. The clone of the child that is
241 passed on must have the original errors_address value.
242
243 Arguments:
244 rblock the router control block
245 addr the address being routed
246 verify true if verifying
247 addr_prop point to the propagated block, which is where the
248 new values are to be placed
249
250 Returns: the result of rf_get_errors_address() or rf_get_munge_headers(),
251 which is either OK or DEFER
252 */
253
254 static int
255 sort_errors_and_headers(router_instance *rblock, address_item *addr,
256 BOOL verify, address_item_propagated *addr_prop)
257 {
258 int frc = rf_get_errors_address(addr, rblock, verify,
259 &(addr_prop->errors_address));
260 if (frc != OK) return frc;
261 addr->p.errors_address = addr_prop->errors_address;
262 return rf_get_munge_headers(addr, rblock, &(addr_prop->extra_headers),
263 &(addr_prop->remove_headers));
264 }
265
266
267
268 /*************************************************
269 * Process a set of generated new addresses *
270 *************************************************/
271
272 /* This function sets up a set of newly generated child addresses and puts them
273 on the new address chain. Copy in the uid, gid and permission flags for use by
274 pipes and files, set the parent, and "or" its af_ignore_error flag. Also record
275 the setting for any starting router.
276
277 If the generated address is the same as one of its ancestors, and the
278 check_ancestor flag is set, do not use this generated address, but replace it
279 with a copy of the input address. This is to cope with cases where A is aliased
280 to B and B has a .forward file pointing to A, though it is usually set on the
281 forwardfile rather than the aliasfile. We can't just pass on the old
282 address by returning FAIL, because it must act as a general parent for
283 generated addresses, and only get marked "done" when all its children are
284 delivered.
285
286 Arguments:
287 rblock router block
288 addr_new new address chain
289 addr original address
290 generated list of generated addresses
291 addr_prop the propagated block, containing the errors_address,
292 header modification stuff, and address_data
293 ugidptr points to uid/gid data for files, pipes, autoreplies
294 pw password entry, set if ob->check_local_user is TRUE
295
296 Returns: nothing
297 */
298
299 static void
300 add_generated(router_instance *rblock, address_item **addr_new,
301 address_item *addr, address_item *generated,
302 address_item_propagated *addr_prop, ugid_block *ugidptr, struct passwd *pw)
303 {
304 redirect_router_options_block *ob =
305 (redirect_router_options_block *)(rblock->options_block);
306
307 while (generated != NULL)
308 {
309 address_item *parent;
310 address_item *next = generated;
311 uschar *errors_address = next->p.errors_address;
312
313 generated = next->next;
314 next->parent = addr;
315 orflag(next, addr, af_ignore_error);
316 next->start_router = rblock->redirect_router;
317 addr->child_count++;
318
319 next->next = *addr_new;
320 *addr_new = next;
321
322 /* Don't do the "one_time" thing for the first pass of a 2-stage queue run. */
323
324 if (ob->one_time && !queue_2stage)
325 {
326 for (parent = addr; parent->parent != NULL; parent = parent->parent);
327 next->onetime_parent = parent->address;
328 }
329
330 if (ob->hide_child_in_errmsg) setflag(next, af_hide_child);
331
332 /* If check_ancestor is set, we want to know if any ancestor of this address
333 is the address we are about to generate. The check must be done caselessly
334 unless the ancestor was routed by a case-sensitive router. */
335
336 if (ob->check_ancestor)
337 {
338 for (parent = addr; parent != NULL; parent = parent->parent)
339 {
340 if (((parent->router != NULL && parent->router->caseful_local_part)?
341 Ustrcmp(next->address, parent->address)
342 :
343 strcmpic(next->address, parent->address)
344 ) == 0)
345 {
346 DEBUG(D_route) debug_printf("generated parent replaced by child\n");
347 next->address = string_copy(addr->address);
348 break;
349 }
350 }
351 }
352
353 /* A user filter may, under some circumstances, set up an errors address.
354 If so, we must take care to re-instate it when we copy in the propagated
355 data so that it overrides any errors_to setting on the router. */
356
357 next->p = *addr_prop;
358 if (errors_address != NULL) next->p.errors_address = errors_address;
359
360 /* For pipes, files, and autoreplies, record this router as handling them,
361 because they don't go through the routing process again. Then set up uid,
362 gid, home and current directories for transporting. */
363
364 if (testflag(next, af_pfr))
365 {
366 next->router = rblock;
367 rf_set_ugid(next, ugidptr); /* Will contain pw values if not overridden */
368
369 /* When getting the home directory out of the password information, wrap it
370 in \N...\N to avoid expansion later. In Cygwin, home directories can
371 contain $ characters. */
372
373 if (rblock->home_directory != NULL)
374 next->home_dir = rblock->home_directory;
375 else if (rblock->check_local_user)
376 next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
377 else if (rblock->router_home_directory != NULL &&
378 testflag(addr, af_home_expanded))
379 {
380 next->home_dir = deliver_home;
381 setflag(next, af_home_expanded);
382 }
383
384 next->current_dir = rblock->current_directory;
385
386 /* Permission options */
387
388 if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
389 if (!ob->forbid_file) setflag(next, af_allow_file);
390 if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
391
392 /* If the transport setting fails, the error gets picked up at the outer
393 level from the setting of basic_errno in the address. */
394
395 if (next->address[0] == '|')
396 {
397 address_pipe = next->address;
398 if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
399 next, rblock->name, US"pipe_transport"))
400 next->transport = ob->pipe_transport;
401 address_pipe = NULL;
402 }
403 else if (next->address[0] == '>')
404 {
405 if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
406 next, rblock->name, US"reply_transport"))
407 next->transport = ob->reply_transport;
408 }
409 else /* must be file or directory */
410 {
411 int len = Ustrlen(next->address);
412 address_file = next->address;
413 if (next->address[len-1] == '/')
414 {
415 if (rf_get_transport(ob->directory_transport_name,
416 &(ob->directory_transport), next, rblock->name,
417 US"directory_transport"))
418 next->transport = ob->directory_transport;
419 }
420 else
421 {
422 if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
423 next, rblock->name, US"file_transport"))
424 next->transport = ob->file_transport;
425 }
426 address_file = NULL;
427 }
428 }
429
430 DEBUG(D_route)
431 {
432 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
433 rblock->name,
434 next->address,
435 testflag(next, af_pfr)? "pipe, file, or autoreply\n " : "",
436 next->p.errors_address,
437 (next->transport == NULL)? US"NULL" : next->transport->name);
438
439 if (testflag(next, af_uid_set))
440 debug_printf(" uid=%ld ", (long int)(next->uid));
441 else
442 debug_printf(" uid=unset ");
443
444 if (testflag(next, af_gid_set))
445 debug_printf("gid=%ld ", (long int)(next->gid));
446 else
447 debug_printf("gid=unset ");
448
449 debug_printf("home=%s\n", next->home_dir);
450 }
451 }
452 }
453
454
455 /*************************************************
456 * Main entry point *
457 *************************************************/
458
459 /* See local README for interface description. This router returns:
460
461 DECLINE
462 . empty address list, or filter did nothing significant
463
464 DEFER
465 . verifying the errors address caused a deferment or a big disaster such
466 as an expansion failure (rf_get_errors_address)
467 . expanding a headers_{add,remove} string caused a deferment or another
468 expansion error (rf_get_munge_headers)
469 . :defer: or "freeze" in a filter
470 . error in address list or filter
471 . skipped syntax errors, but failed to send the message
472
473 DISCARD
474 . address was :blackhole:d or "seen finish"ed
475
476 FAIL
477 . :fail:
478
479 OK
480 . new addresses added to addr_new
481 */
482
483 int redirect_router_entry(
484 router_instance *rblock, /* data for this instantiation */
485 address_item *addr, /* address we are working on */
486 struct passwd *pw, /* passwd entry after check_local_user */
487 BOOL verify, /* TRUE when verifying */
488 address_item **addr_local, /* add it to this if it's local */
489 address_item **addr_remote, /* add it to this if it's remote */
490 address_item **addr_new, /* put new addresses on here */
491 address_item **addr_succeed) /* put old address here on success */
492 {
493 redirect_router_options_block *ob =
494 (redirect_router_options_block *)(rblock->options_block);
495 address_item *generated = NULL;
496 uschar *save_qualify_domain_recipient = qualify_domain_recipient;
497 uschar *discarded = US"discarded";
498 address_item_propagated addr_prop;
499 error_block *eblock = NULL;
500 ugid_block ugid;
501 redirect_block redirect;
502 int filtertype = FILTER_UNSET;
503 int yield = OK;
504 int options = ob->bit_options;
505 int frc = 0;
506 int xrc = 0;
507
508 addr_local = addr_local; /* Keep picky compilers happy */
509 addr_remote = addr_remote;
510
511 /* Initialize the data to be propagated to the children */
512
513 addr_prop.address_data = deliver_address_data;
514 addr_prop.domain_data = deliver_domain_data;
515 addr_prop.localpart_data = deliver_localpart_data;
516 addr_prop.errors_address = NULL;
517 addr_prop.extra_headers = NULL;
518 addr_prop.remove_headers = NULL;
519
520 /* When verifying and testing addresses, the "logwrite" command in filters
521 must be bypassed. */
522
523 if (!verify && !address_test_mode) options |= RDO_REALLOG;
524
525 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
526 file (and interpreting a filter) and (b) for running the transports for
527 generated file and pipe addresses. It is not (necessarily) the same as the uids
528 that may own the file. Exim panics if an expanded string is not a number and
529 can't be found in the password file. Other errors set the freezing bit. */
530
531 if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
532
533 if (!ugid.uid_set && pw != NULL)
534 {
535 ugid.uid = pw->pw_uid;
536 ugid.uid_set = TRUE;
537 }
538
539 if (!ugid.gid_set && pw != NULL)
540 {
541 ugid.gid = pw->pw_gid;
542 ugid.gid_set = TRUE;
543 }
544
545 #ifdef EXPERIMENTAL_SRS
546 /* For reverse SRS, fill the srs_recipient expandsion variable,
547 on failure, return decline/fail as relevant */
548 if(ob->srs != NULL)
549 {
550 BOOL usesrs = TRUE;
551
552 if(ob->srs_condition != NULL)
553 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
554
555 if(usesrs)
556 if(Ustrcmp(ob->srs, "reverse") == 0 || Ustrcmp(ob->srs, "reverseandforward") == 0)
557 {
558 uschar *res;
559 int n_srs;
560
561 srs_orig_recipient = addr->address;
562 eximsrs_init();
563 if(ob->srs_db)
564 eximsrs_db_set(TRUE, ob->srs_db);
565 if((n_srs = eximsrs_reverse(&res, addr->address)) != OK)
566 return n_srs;
567 srs_recipient = res;
568 eximsrs_done();
569 DEBUG(D_any)
570 debug_printf("SRS: Recipient '%s' rewriteen to '%s'\n", srs_orig_recipient, srs_recipient);
571 }
572 }
573 #endif
574
575 /* Call the function that interprets redirection data, either inline or from a
576 file. This is a separate function so that the system filter can use it. It will
577 run the function in a subprocess if necessary. If qualify_preserve_domain is
578 set, temporarily reset qualify_domain_recipient to the current domain so that
579 any unqualified addresses get qualified with the same domain as the incoming
580 address. Otherwise, if a local qualify_domain is provided, set that up. */
581
582 if (ob->qualify_preserve_domain)
583 qualify_domain_recipient = addr->domain;
584 else if (ob->qualify_domain != NULL)
585 {
586 uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
587 if (new_qdr == NULL) return xrc;
588 qualify_domain_recipient = new_qdr;
589 }
590
591 redirect.owners = ob->owners;
592 redirect.owngroups = ob->owngroups;
593 redirect.modemask = ob->modemask;
594 redirect.check_owner = ob->check_owner;
595 redirect.check_group = ob->check_group;
596 redirect.pw = pw;
597
598 if (ob->file != NULL)
599 {
600 redirect.string = ob->file;
601 redirect.isfile = TRUE;
602 }
603 else
604 {
605 redirect.string = ob->data;
606 redirect.isfile = FALSE;
607 }
608
609 frc = rda_interpret(&redirect, options, ob->include_directory,
610 ob->sieve_vacation_directory, &ugid, &generated, &(addr->message),
611 ob->skip_syntax_errors? &eblock : NULL, &filtertype,
612 string_sprintf("%s router (recipient is %s)", rblock->name, addr->address));
613
614 qualify_domain_recipient = save_qualify_domain_recipient;
615
616 /* Handle exceptional returns from filtering or processing an address list.
617 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
618
619 switch (frc)
620 {
621 case FF_NONEXIST:
622 addr->message = addr->user_message = NULL;
623 return DECLINE;
624
625 case FF_BLACKHOLE:
626 DEBUG(D_route) debug_printf("address :blackhole:d\n");
627 generated = NULL;
628 discarded = US":blackhole:";
629 frc = FF_DELIVERED;
630 break;
631
632 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
633 (:fail: in an alias file or "fail" in a filter). If a configured message was
634 supplied, allow it to be included in an SMTP response after verifying. */
635
636 case FF_DEFER:
637 if (addr->message == NULL) addr->message = US"forced defer";
638 else addr->user_message = addr->message;
639 return DEFER;
640
641 case FF_FAIL:
642 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
643 return xrc;
644 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
645 if (addr->message == NULL) addr->message = US"forced rejection";
646 else addr->user_message = addr->message;
647 return FAIL;
648
649 /* As in the case of a system filter, a freeze does not happen after a manual
650 thaw. In case deliveries were set up by the filter, we set the child count
651 high so that their completion does not mark the original address done. */
652
653 case FF_FREEZE:
654 if (!deliver_manual_thaw)
655 {
656 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
657 != OK) return xrc;
658 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
659 if (addr->message == NULL) addr->message = US"frozen by filter";
660 addr->special_action = SPECIAL_FREEZE;
661 addr->child_count = 9999;
662 return DEFER;
663 }
664 frc = FF_NOTDELIVERED;
665 break;
666
667 /* Handle syntax errors and :include: failures and lookup defers */
668
669 case FF_ERROR:
670 case FF_INCLUDEFAIL:
671
672 /* If filtertype is still FILTER_UNSET, it means that the redirection data
673 was never inspected, so the error was an expansion failure or failure to open
674 the file, or whatever. In these cases, the existing error message is probably
675 sufficient. */
676
677 if (filtertype == FILTER_UNSET) return DEFER;
678
679 /* If it was a filter and skip_syntax_errors is set, we want to set up
680 the error message so that it can be logged and mailed to somebody. */
681
682 if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
683 {
684 eblock = store_get(sizeof(error_block));
685 eblock->next = NULL;
686 eblock->text1 = addr->message;
687 eblock->text2 = NULL;
688 addr->message = addr->user_message = NULL;
689 }
690
691 /* Otherwise set up the error for the address and defer. */
692
693 else
694 {
695 addr->basic_errno = ERRNO_BADREDIRECT;
696 addr->message = string_sprintf("error in %s %s: %s",
697 (filtertype != FILTER_FORWARD)? "filter" : "redirect",
698 (ob->data == NULL)? "file" : "data",
699 addr->message);
700 return DEFER;
701 }
702 }
703
704
705 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
706 significant action). Before dealing with these, however, we must handle the
707 effect of skip_syntax_errors.
708
709 If skip_syntax_errors was set and there were syntax errors in an address list,
710 error messages will be present in eblock. Log them and send a message if so
711 configured. We cannot do this earlier, because the error message must not be
712 sent as the local user. If there were no valid addresses, generated will be
713 NULL. In this case, the router declines.
714
715 For a filter file, the error message has been fudged into an eblock. After
716 dealing with it, the router declines. */
717
718 if (eblock != NULL)
719 {
720 if (!moan_skipped_syntax_errors(
721 rblock->name, /* For message content */
722 eblock, /* Ditto */
723 (verify || address_test_mode)?
724 NULL : ob->syntax_errors_to, /* Who to mail */
725 generated != NULL, /* True if not all failed */
726 ob->syntax_errors_text)) /* Custom message */
727 return DEFER;
728
729 if (filtertype != FILTER_FORWARD || generated == NULL)
730 {
731 addr->message = US"syntax error in redirection data";
732 return DECLINE;
733 }
734 }
735
736 /* Sort out the errors address and any header modifications, and handle the
737 generated addresses, if any. If there are no generated addresses, we must avoid
738 calling sort_errors_and_headers() in case this router declines - that function
739 may modify the errors_address field in the current address, and we don't want
740 to do that for a decline. */
741
742 if (generated != NULL)
743 {
744 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
745 return xrc;
746 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
747 }
748
749 /* FF_DELIVERED with no generated addresses is what we get when an address list
750 contains :blackhole: or a filter contains "seen finish" without having
751 generated anything. Log what happened to this address, and return DISCARD. */
752
753 if (frc == FF_DELIVERED)
754 {
755 if (generated == NULL && !verify && !address_test_mode)
756 {
757 log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
758 rblock->name);
759 yield = DISCARD;
760 }
761 }
762
763 /* For an address list, FF_NOTDELIVERED always means that no addresses were
764 generated. For a filter, addresses may or may not have been generated. If none
765 were, it's the same as an empty address list, and the router declines. However,
766 if addresses were generated, we can't just decline because successful delivery
767 of the base address gets it marked "done", so deferred generated addresses
768 never get tried again. We have to generate a new version of the base address,
769 as if there were a "deliver" command in the filter file, with the original
770 address as parent. */
771
772 else
773 {
774 address_item *next;
775
776 if (generated == NULL) return DECLINE;
777
778 next = deliver_make_addr(addr->address, FALSE);
779 next->parent = addr;
780 addr->child_count++;
781 next->next = *addr_new;
782 *addr_new = next;
783
784 /* Copy relevant flags (af_propagate is a name for the set), and set the
785 data that propagates. */
786
787 copyflag(next, addr, af_propagate);
788 next->p = addr_prop;
789
790 DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
791 rblock->name,
792 next->address,
793 (addr_prop.errors_address != NULL)? " errors to " : "",
794 (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
795 (addr_prop.errors_address != NULL)? "\n" : "");
796 }
797
798 #ifdef EXPERIMENTAL_SRS
799 /* On successful redirection, check for SRS forwarding and adjust sender */
800 if(ob->srs != NULL)
801 {
802 BOOL usesrs = TRUE;
803
804 if(ob->srs_condition != NULL)
805 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
806
807 if(usesrs)
808 if((Ustrcmp(ob->srs, "forward") == 0 || Ustrcmp(ob->srs, "reverseandforward") == 0) && !verify)
809 {
810 uschar *res;
811 uschar *usedomain;
812 int n_srs;
813
814 srs_orig_sender = sender_address;
815 eximsrs_init();
816 if(ob->srs_db)
817 eximsrs_db_set(FALSE, ob->srs_db);
818
819 if(ob->srs_alias != NULL ? (usedomain = expand_string(ob->srs_alias)) == NULL : 1)
820 usedomain = deliver_domain;
821
822 if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) != OK)
823 return n_srs;
824 sender_address = res;
825 DEBUG(D_any)
826 debug_printf("SRS: Sender '%s' rewritten to '%s'\n", srs_orig_sender, sender_address);
827 }
828 }
829 #endif
830
831 /* Control gets here only when the address has been completely handled. Put the
832 original address onto the succeed queue so that any retry items that get
833 attached to it get processed. */
834
835 addr->next = *addr_succeed;
836 *addr_succeed = addr;
837
838 return yield;
839 }
840
841 /* End of routers/redirect.c */