src/src/routers/redirect.c

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