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