src/src/routers/redirect.c

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