src/src/routers/redirect.c

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