src/src/routers/redirect.c

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