2434d3cb752f3ae492c57608a6f8c68d4a3b70a0
[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 != NULL)
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 != NULL; 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 {
362 for (parent = addr; parent != NULL; parent = parent->parent)
363 {
364 if (((parent->router != NULL && parent->router->caseful_local_part)?
365 Ustrcmp(next->address, parent->address)
366 :
367 strcmpic(next->address, parent->address)
368 ) == 0)
369 {
370 DEBUG(D_route) debug_printf("generated parent replaced by child\n");
371 next->address = string_copy(addr->address);
372 break;
373 }
374 }
375 }
376
377 /* A user filter may, under some circumstances, set up an errors address.
378 If so, we must take care to re-instate it when we copy in the propagated
379 data so that it overrides any errors_to setting on the router. */
380
381 next->prop = *addr_prop;
382 if (errors_address != NULL) next->prop.errors_address = errors_address;
383
384 /* For pipes, files, and autoreplies, record this router as handling them,
385 because they don't go through the routing process again. Then set up uid,
386 gid, home and current directories for transporting. */
387
388 if (testflag(next, af_pfr))
389 {
390 next->router = rblock;
391 rf_set_ugid(next, ugidptr); /* Will contain pw values if not overridden */
392
393 /* When getting the home directory out of the password information, wrap it
394 in \N...\N to avoid expansion later. In Cygwin, home directories can
395 contain $ characters. */
396
397 if (rblock->home_directory != NULL)
398 next->home_dir = rblock->home_directory;
399 else if (rblock->check_local_user)
400 next->home_dir = string_sprintf("\\N%s\\N", pw->pw_dir);
401 else if (rblock->router_home_directory != NULL &&
402 testflag(addr, af_home_expanded))
403 {
404 next->home_dir = deliver_home;
405 setflag(next, af_home_expanded);
406 }
407
408 next->current_dir = rblock->current_directory;
409
410 /* Permission options */
411
412 if (!ob->forbid_pipe) setflag(next, af_allow_pipe);
413 if (!ob->forbid_file) setflag(next, af_allow_file);
414 if (!ob->forbid_filter_reply) setflag(next, af_allow_reply);
415
416 /* If the transport setting fails, the error gets picked up at the outer
417 level from the setting of basic_errno in the address. */
418
419 if (next->address[0] == '|')
420 {
421 address_pipe = next->address;
422 if (rf_get_transport(ob->pipe_transport_name, &(ob->pipe_transport),
423 next, rblock->name, US"pipe_transport"))
424 next->transport = ob->pipe_transport;
425 address_pipe = NULL;
426 }
427 else if (next->address[0] == '>')
428 {
429 if (rf_get_transport(ob->reply_transport_name, &(ob->reply_transport),
430 next, rblock->name, US"reply_transport"))
431 next->transport = ob->reply_transport;
432 }
433 else /* must be file or directory */
434 {
435 int len = Ustrlen(next->address);
436 address_file = next->address;
437 if (next->address[len-1] == '/')
438 {
439 if (rf_get_transport(ob->directory_transport_name,
440 &(ob->directory_transport), next, rblock->name,
441 US"directory_transport"))
442 next->transport = ob->directory_transport;
443 }
444 else
445 {
446 if (rf_get_transport(ob->file_transport_name, &(ob->file_transport),
447 next, rblock->name, US"file_transport"))
448 next->transport = ob->file_transport;
449 }
450 address_file = NULL;
451 }
452 }
453
454 #ifdef SUPPORT_I18N
455 next->prop.utf8_msg = string_is_utf8(next->address)
456 || (sender_address && string_is_utf8(sender_address));
457 #endif
458
459 DEBUG(D_route)
460 {
461 debug_printf("%s router generated %s\n %serrors_to=%s transport=%s\n",
462 rblock->name,
463 next->address,
464 testflag(next, af_pfr)? "pipe, file, or autoreply\n " : "",
465 next->prop.errors_address,
466 (next->transport == NULL)? US"NULL" : next->transport->name);
467
468 if (testflag(next, af_uid_set))
469 debug_printf(" uid=%ld ", (long int)(next->uid));
470 else
471 debug_printf(" uid=unset ");
472
473 if (testflag(next, af_gid_set))
474 debug_printf("gid=%ld ", (long int)(next->gid));
475 else
476 debug_printf("gid=unset ");
477
478 #ifdef SUPPORT_I18N
479 if (next->prop.utf8_msg) debug_printf("utf8 ");
480 #endif
481
482 debug_printf("home=%s\n", next->home_dir);
483 }
484 }
485 }
486
487
488 /*************************************************
489 * Main entry point *
490 *************************************************/
491
492 /* See local README for interface description. This router returns:
493
494 DECLINE
495 . empty address list, or filter did nothing significant
496
497 DEFER
498 . verifying the errors address caused a deferment or a big disaster such
499 as an expansion failure (rf_get_errors_address)
500 . expanding a headers_{add,remove} string caused a deferment or another
501 expansion error (rf_get_munge_headers)
502 . :defer: or "freeze" in a filter
503 . error in address list or filter
504 . skipped syntax errors, but failed to send the message
505
506 DISCARD
507 . address was :blackhole:d or "seen finish"ed
508
509 FAIL
510 . :fail:
511
512 OK
513 . new addresses added to addr_new
514 */
515
516 int redirect_router_entry(
517 router_instance *rblock, /* data for this instantiation */
518 address_item *addr, /* address we are working on */
519 struct passwd *pw, /* passwd entry after check_local_user */
520 int verify, /* v_none/v_recipient/v_sender/v_expn */
521 address_item **addr_local, /* add it to this if it's local */
522 address_item **addr_remote, /* add it to this if it's remote */
523 address_item **addr_new, /* put new addresses on here */
524 address_item **addr_succeed) /* put old address here on success */
525 {
526 redirect_router_options_block *ob =
527 (redirect_router_options_block *)(rblock->options_block);
528 address_item *generated = NULL;
529 const uschar *save_qualify_domain_recipient = qualify_domain_recipient;
530 uschar *discarded = US"discarded";
531 address_item_propagated addr_prop;
532 error_block *eblock = NULL;
533 ugid_block ugid;
534 redirect_block redirect;
535 int filtertype = FILTER_UNSET;
536 int yield = OK;
537 int options = ob->bit_options;
538 int frc = 0;
539 int xrc = 0;
540
541 addr_local = addr_local; /* Keep picky compilers happy */
542 addr_remote = addr_remote;
543
544 /* Initialize the data to be propagated to the children */
545
546 addr_prop.address_data = deliver_address_data;
547 addr_prop.domain_data = deliver_domain_data;
548 addr_prop.localpart_data = deliver_localpart_data;
549 addr_prop.errors_address = NULL;
550 addr_prop.extra_headers = NULL;
551 addr_prop.remove_headers = NULL;
552
553 #ifdef EXPERIMENTAL_SRS
554 addr_prop.srs_sender = NULL;
555 #endif
556 #ifdef SUPPORT_I18N
557 addr_prop.utf8_msg = FALSE; /*XXX should we not copy this from the parent? */
558 addr_prop.utf8_downcvt = FALSE;
559 addr_prop.utf8_downcvt_maybe = FALSE;
560 #endif
561
562
563 /* When verifying and testing addresses, the "logwrite" command in filters
564 must be bypassed. */
565
566 if (verify == v_none && !address_test_mode) options |= RDO_REALLOG;
567
568 /* Sort out the fixed or dynamic uid/gid. This uid is used (a) for reading the
569 file (and interpreting a filter) and (b) for running the transports for
570 generated file and pipe addresses. It is not (necessarily) the same as the uids
571 that may own the file. Exim panics if an expanded string is not a number and
572 can't be found in the password file. Other errors set the freezing bit. */
573
574 if (!rf_get_ugid(rblock, addr, &ugid)) return DEFER;
575
576 if (!ugid.uid_set && pw != NULL)
577 {
578 ugid.uid = pw->pw_uid;
579 ugid.uid_set = TRUE;
580 }
581
582 if (!ugid.gid_set && pw != NULL)
583 {
584 ugid.gid = pw->pw_gid;
585 ugid.gid_set = TRUE;
586 }
587
588 #ifdef EXPERIMENTAL_SRS
589 /* Perform SRS on recipient/return-path as required */
590
591 if(ob->srs != NULL)
592 {
593 BOOL usesrs = TRUE;
594
595 if(ob->srs_condition != NULL)
596 usesrs = expand_check_condition(ob->srs_condition, "srs_condition expansion failed", NULL);
597
598 if(usesrs)
599 {
600 int srs_action = 0, n_srs;
601 uschar *res;
602 uschar *usedomain;
603
604 /* What are we doing? */
605 if(Ustrcmp(ob->srs, "forward") == 0)
606 srs_action = 1;
607 else if(Ustrcmp(ob->srs, "reverseandforward") == 0)
608 {
609 srs_action = 3;
610
611 if((ob->srs_dbinsert == NULL) ^ (ob->srs_dbselect == NULL))
612 return DEFER;
613 }
614 else if(Ustrcmp(ob->srs, "reverse") == 0)
615 srs_action = 2;
616
617 /* Reverse SRS */
618 if(srs_action & 2)
619 {
620 srs_orig_recipient = addr->address;
621
622 eximsrs_init();
623 if(ob->srs_dbselect)
624 eximsrs_db_set(TRUE, ob->srs_dbselect);
625 /* Comment this out for now...
626 // else
627 // eximsrs_db_set(TRUE, NULL);
628 */
629
630 if((n_srs = eximsrs_reverse(&res, addr->address)) == OK)
631 {
632 srs_recipient = res;
633 DEBUG(D_any)
634 debug_printf("SRS (reverse): Recipient '%s' rewritten to '%s'\n", srs_orig_recipient, srs_recipient);
635 }
636
637 eximsrs_done();
638
639 if(n_srs != OK)
640 return n_srs;
641 }
642
643 /* Forward SRS */
644 /* No point in actually performing SRS if we are just verifying a recipient */
645 if((srs_action & 1) && verify == v_none &&
646 (sender_address ? sender_address[0] != 0 : FALSE))
647 {
648
649 srs_orig_sender = sender_address;
650 eximsrs_init();
651 if(ob->srs_dbinsert)
652 eximsrs_db_set(FALSE, ob->srs_dbinsert);
653 /* Comment this out for now...
654 // else
655 // eximsrs_db_set(FALSE, NULL);
656 */
657
658 if (!(usedomain = ob->srs_alias ? expand_string(ob->srs_alias) : NULL))
659 usedomain = string_copy(deliver_domain);
660
661 if((n_srs = eximsrs_forward(&res, sender_address, usedomain)) == OK)
662 {
663 addr_prop.srs_sender = res;
664 DEBUG(D_any)
665 debug_printf("SRS (forward): Sender '%s' rewritten to '%s'\n", srs_orig_sender, res);
666 }
667
668 eximsrs_done();
669
670 if(n_srs != OK)
671 return n_srs;
672 }
673 }
674 }
675 #endif
676
677 /* Call the function that interprets redirection data, either inline or from a
678 file. This is a separate function so that the system filter can use it. It will
679 run the function in a subprocess if necessary. If qualify_preserve_domain is
680 set, temporarily reset qualify_domain_recipient to the current domain so that
681 any unqualified addresses get qualified with the same domain as the incoming
682 address. Otherwise, if a local qualify_domain is provided, set that up. */
683
684 if (ob->qualify_preserve_domain)
685 qualify_domain_recipient = addr->domain;
686 else if (ob->qualify_domain != NULL)
687 {
688 uschar *new_qdr = rf_expand_data(addr, ob->qualify_domain, &xrc);
689 if (new_qdr == NULL) return xrc;
690 qualify_domain_recipient = new_qdr;
691 }
692
693 redirect.owners = ob->owners;
694 redirect.owngroups = ob->owngroups;
695 redirect.modemask = ob->modemask;
696 redirect.check_owner = ob->check_owner;
697 redirect.check_group = ob->check_group;
698 redirect.pw = pw;
699
700 if (ob->file != NULL)
701 {
702 redirect.string = ob->file;
703 redirect.isfile = TRUE;
704 }
705 else
706 {
707 redirect.string = ob->data;
708 redirect.isfile = FALSE;
709 }
710
711 frc = rda_interpret(&redirect, options, ob->include_directory,
712 ob->sieve_vacation_directory, ob->sieve_enotify_mailto_owner,
713 ob->sieve_useraddress, ob->sieve_subaddress, &ugid, &generated,
714 &(addr->message), ob->skip_syntax_errors? &eblock : NULL, &filtertype,
715 string_sprintf("%s router (recipient is %s)", rblock->name, addr->address));
716
717 qualify_domain_recipient = save_qualify_domain_recipient;
718
719 /* Handle exceptional returns from filtering or processing an address list.
720 For FAIL and FREEZE we honour any previously set up deliveries by a filter. */
721
722 switch (frc)
723 {
724 case FF_NONEXIST:
725 addr->message = addr->user_message = NULL;
726 return DECLINE;
727
728 case FF_BLACKHOLE:
729 DEBUG(D_route) debug_printf("address :blackhole:d\n");
730 generated = NULL;
731 discarded = US":blackhole:";
732 frc = FF_DELIVERED;
733 break;
734
735 /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands
736 (:defer: or :fail: in an alias file or "fail" in a filter). If a configured
737 message was supplied, allow it to be included in an SMTP response after
738 verifying. Remove any SMTP code if it is not allowed. */
739
740 case FF_DEFER:
741 yield = DEFER;
742 goto SORT_MESSAGE;
743
744 case FF_FAIL:
745 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
746 return xrc;
747 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
748 yield = FAIL;
749
750 SORT_MESSAGE:
751 if (addr->message == NULL)
752 addr->message = (yield == FAIL)? US"forced rejection" : US"forced defer";
753 else
754 {
755 int ovector[3];
756 if (ob->forbid_smtp_code &&
757 pcre_exec(regex_smtp_code, NULL, CS addr->message,
758 Ustrlen(addr->message), 0, PCRE_EOPT,
759 ovector, sizeof(ovector)/sizeof(int)) >= 0)
760 {
761 DEBUG(D_route) debug_printf("SMTP code at start of error message "
762 "is ignored because forbid_smtp_code is set\n");
763 addr->message += ovector[1];
764 }
765 addr->user_message = addr->message;
766 setflag(addr, af_pass_message);
767 }
768 return yield;
769
770 /* As in the case of a system filter, a freeze does not happen after a manual
771 thaw. In case deliveries were set up by the filter, we set the child count
772 high so that their completion does not mark the original address done. */
773
774 case FF_FREEZE:
775 if (!deliver_manual_thaw)
776 {
777 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop))
778 != OK) return xrc;
779 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
780 if (addr->message == NULL) addr->message = US"frozen by filter";
781 addr->special_action = SPECIAL_FREEZE;
782 addr->child_count = 9999;
783 return DEFER;
784 }
785 frc = FF_NOTDELIVERED;
786 break;
787
788 /* Handle syntax errors and :include: failures and lookup defers */
789
790 case FF_ERROR:
791 case FF_INCLUDEFAIL:
792
793 /* If filtertype is still FILTER_UNSET, it means that the redirection data
794 was never inspected, so the error was an expansion failure or failure to open
795 the file, or whatever. In these cases, the existing error message is probably
796 sufficient. */
797
798 if (filtertype == FILTER_UNSET) return DEFER;
799
800 /* If it was a filter and skip_syntax_errors is set, we want to set up
801 the error message so that it can be logged and mailed to somebody. */
802
803 if (filtertype != FILTER_FORWARD && ob->skip_syntax_errors)
804 {
805 eblock = store_get(sizeof(error_block));
806 eblock->next = NULL;
807 eblock->text1 = addr->message;
808 eblock->text2 = NULL;
809 addr->message = addr->user_message = NULL;
810 }
811
812 /* Otherwise set up the error for the address and defer. */
813
814 else
815 {
816 addr->basic_errno = ERRNO_BADREDIRECT;
817 addr->message = string_sprintf("error in %s %s: %s",
818 (filtertype != FILTER_FORWARD)? "filter" : "redirect",
819 (ob->data == NULL)? "file" : "data",
820 addr->message);
821 return DEFER;
822 }
823 }
824
825
826 /* Yield is either FF_DELIVERED (significant action) or FF_NOTDELIVERED (no
827 significant action). Before dealing with these, however, we must handle the
828 effect of skip_syntax_errors.
829
830 If skip_syntax_errors was set and there were syntax errors in an address list,
831 error messages will be present in eblock. Log them and send a message if so
832 configured. We cannot do this earlier, because the error message must not be
833 sent as the local user. If there were no valid addresses, generated will be
834 NULL. In this case, the router declines.
835
836 For a filter file, the error message has been fudged into an eblock. After
837 dealing with it, the router declines. */
838
839 if (eblock != NULL)
840 {
841 if (!moan_skipped_syntax_errors(
842 rblock->name, /* For message content */
843 eblock, /* Ditto */
844 (verify != v_none || address_test_mode)?
845 NULL : ob->syntax_errors_to, /* Who to mail */
846 generated != NULL, /* True if not all failed */
847 ob->syntax_errors_text)) /* Custom message */
848 return DEFER;
849
850 if (filtertype != FILTER_FORWARD || generated == NULL)
851 {
852 addr->message = US"syntax error in redirection data";
853 return DECLINE;
854 }
855 }
856
857 /* Sort out the errors address and any header modifications, and handle the
858 generated addresses, if any. If there are no generated addresses, we must avoid
859 calling sort_errors_and_headers() in case this router declines - that function
860 may modify the errors_address field in the current address, and we don't want
861 to do that for a decline. */
862
863 if (generated != NULL)
864 {
865 if ((xrc = sort_errors_and_headers(rblock, addr, verify, &addr_prop)) != OK)
866 return xrc;
867 add_generated(rblock, addr_new, addr, generated, &addr_prop, &ugid, pw);
868 }
869
870 /* FF_DELIVERED with no generated addresses is what we get when an address list
871 contains :blackhole: or a filter contains "seen finish" without having
872 generated anything. Log what happened to this address, and return DISCARD. */
873
874 if (frc == FF_DELIVERED)
875 {
876 if (generated == NULL && verify == v_none && !address_test_mode)
877 {
878 log_write(0, LOG_MAIN, "=> %s <%s> R=%s", discarded, addr->address,
879 rblock->name);
880 yield = DISCARD;
881 }
882 }
883
884 /* For an address list, FF_NOTDELIVERED always means that no addresses were
885 generated. For a filter, addresses may or may not have been generated. If none
886 were, it's the same as an empty address list, and the router declines. However,
887 if addresses were generated, we can't just decline because successful delivery
888 of the base address gets it marked "done", so deferred generated addresses
889 never get tried again. We have to generate a new version of the base address,
890 as if there were a "deliver" command in the filter file, with the original
891 address as parent. */
892
893 else
894 {
895 address_item *next;
896
897 if (generated == NULL) return DECLINE;
898
899 next = deliver_make_addr(addr->address, FALSE);
900 next->parent = addr;
901 addr->child_count++;
902 next->next = *addr_new;
903 *addr_new = next;
904
905 /* Copy relevant flags (af_propagate is a name for the set), and set the
906 data that propagates. */
907
908 copyflag(next, addr, af_propagate);
909 next->prop = addr_prop;
910
911 DEBUG(D_route) debug_printf("%s router autogenerated %s\n%s%s%s",
912 rblock->name,
913 next->address,
914 (addr_prop.errors_address != NULL)? " errors to " : "",
915 (addr_prop.errors_address != NULL)? addr_prop.errors_address : US"",
916 (addr_prop.errors_address != NULL)? "\n" : "");
917 }
918
919 /* Control gets here only when the address has been completely handled. Put the
920 original address onto the succeed queue so that any retry items that get
921 attached to it get processed. */
922
923 addr->next = *addr_succeed;
924 *addr_succeed = addr;
925
926 return yield;
927 }
928
929 /* End of routers/redirect.c */