src/src/routers/redirect.c

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