src/src/routers/redirect.c

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