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