src/src/routers/queryprogram.c

   1 /* $Cambridge: exim/src/src/routers/queryprogram.c,v 1.8 2006/02/07 14:05:17 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 #include "../exim.h"
  11 #include "rf_functions.h"
  12 #include "queryprogram.h"
  13
  14
  15
  16 /* Options specific to the queryprogram router. */
  17
  18 optionlist queryprogram_router_options[] = {
  19   { "*expand_command_group", opt_bool | opt_hidden,
  20       (void *)(offsetof(queryprogram_router_options_block, expand_cmd_gid)) },
  21   { "*expand_command_user", opt_bool | opt_hidden,
  22       (void *)(offsetof(queryprogram_router_options_block, expand_cmd_uid)) },
  23   { "*set_command_group",   opt_bool | opt_hidden,
  24       (void *)(offsetof(queryprogram_router_options_block, cmd_gid_set)) },
  25   { "*set_command_user",    opt_bool | opt_hidden,
  26       (void *)(offsetof(queryprogram_router_options_block, cmd_uid_set)) },
  27   { "command",      opt_stringptr,
  28       (void *)(offsetof(queryprogram_router_options_block, command)) },
  29   { "command_group",opt_expand_gid,
  30       (void *)(offsetof(queryprogram_router_options_block, cmd_gid)) },
  31   { "command_user", opt_expand_uid,
  32       (void *)(offsetof(queryprogram_router_options_block, cmd_uid)) },
  33   { "current_directory", opt_stringptr,
  34       (void *)(offsetof(queryprogram_router_options_block, current_directory)) },
  35   { "timeout",      opt_time,
  36       (void *)(offsetof(queryprogram_router_options_block, timeout)) }
  37 };
  38
  39 /* Size of the options list. An extern variable has to be used so that its
  40 address can appear in the tables drtables.c. */
  41
  42 int queryprogram_router_options_count =
  43   sizeof(queryprogram_router_options)/sizeof(optionlist);
  44
  45 /* Default private options block for the queryprogram router. */
  46
  47 queryprogram_router_options_block queryprogram_router_option_defaults = {
  48   NULL,         /* command */
  49   60*60,        /* timeout */
  50   (uid_t)(-1),  /* cmd_uid */
  51   (gid_t)(-1),  /* cmd_gid */
  52   FALSE,        /* cmd_uid_set */
  53   FALSE,        /* cmd_gid_set */
  54   US"/",        /* current_directory */
  55   NULL,         /* expand_cmd_gid */
  56   NULL          /* expand_cmd_uid */
  57 };
  58
  59
  60
  61 /*************************************************
  62 *          Initialization entry point            *
  63 *************************************************/
  64
  65 /* Called for each instance, after its options have been read, to enable
  66 consistency checks to be done, or anything else that needs to be set up. */
  67
  68 void
  69 queryprogram_router_init(router_instance *rblock)
  70 {
  71 queryprogram_router_options_block *ob =
  72   (queryprogram_router_options_block *)(rblock->options_block);
  73
  74 /* A command must be given */
  75
  76 if (ob->command == NULL)
  77   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
  78     "a command specification is required", rblock->name);
  79
  80 /* A uid/gid must be supplied */
  81
  82 if (!ob->cmd_uid_set && ob->expand_cmd_uid == NULL)
  83   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
  84     "command_user must be specified", rblock->name);
  85 }
  86
  87
  88
  89 /*************************************************
  90 *    Process a set of generated new addresses    *
  91 *************************************************/
  92
  93 /* This function sets up a set of newly generated child addresses and puts them
  94 on the new address chain.
  95
  96 Arguments:
  97   rblock                  router block
  98   addr_new                new address chain
  99   addr                    original address
 100   generated               list of generated addresses
 101   addr_prop               the propagated data block, containing errors_to,
 102                             header change stuff, and address_data
 103
 104 Returns:         nothing
 105 */
 106
 107 static void
 108 add_generated(router_instance *rblock, address_item **addr_new,
 109   address_item *addr, address_item *generated,
 110   address_item_propagated *addr_prop)
 111 {
 112 while (generated != NULL)
 113   {
 114   address_item *next = generated;
 115   generated = next->next;
 116
 117   next->parent = addr;
 118   orflag(next, addr, af_propagate);
 119   next->p = *addr_prop;
 120   next->start_router = rblock->redirect_router;
 121
 122   next->next = *addr_new;
 123   *addr_new = next;
 124
 125   addr->child_count++;
 126
 127   DEBUG(D_route)
 128     debug_printf("%s router generated %s\n", rblock->name, next->address);
 129   }
 130 }
 131
 132
 133
 134
 135 /*************************************************
 136 *              Main entry point                  *
 137 *************************************************/
 138
 139 /* See local README for interface details. This router returns:
 140
 141 DECLINE
 142   . DECLINE returned
 143   . self = DECLINE
 144
 145 PASS
 146   . PASS returned
 147   . timeout of host lookup and pass_on_timeout set
 148   . self = PASS
 149
 150 DEFER
 151   . verifying the errors address caused a deferment or a big disaster such
 152       as an expansion failure (rf_get_errors_address)
 153   . expanding a headers_{add,remove} string caused a deferment or another
 154       expansion error (rf_get_munge_headers)
 155   . a problem in rf_get_transport: no transport when one is needed;
 156       failed to expand dynamic transport; failed to find dynamic transport
 157   . bad lookup type
 158   . problem looking up host (rf_lookup_hostlist)
 159   . self = DEFER or FREEZE
 160   . failure to set up uid/gid for running the command
 161   . failure of transport_set_up_command: too many arguments, expansion fail
 162   . failure to create child process
 163   . child process crashed or timed out or didn't return data
 164   . :defer: in data
 165   . DEFER or FREEZE returned
 166   . problem in redirection data
 167   . unknown transport name or trouble expanding router transport
 168
 169 FAIL
 170   . :fail: in data
 171   . FAIL returned
 172   . self = FAIL
 173
 174 OK
 175   . address added to addr_local or addr_remote for delivery
 176   . new addresses added to addr_new
 177 */
 178
 179 int
 180 queryprogram_router_entry(
 181   router_instance *rblock,        /* data for this instantiation */
 182   address_item *addr,             /* address we are working on */
 183   struct passwd *pw,              /* passwd entry after check_local_user */
 184   int verify,                     /* v_none/v_recipient/v_sender/v_expn */
 185   address_item **addr_local,      /* add it to this if it's local */
 186   address_item **addr_remote,     /* add it to this if it's remote */
 187   address_item **addr_new,        /* put new addresses on here */
 188   address_item **addr_succeed)    /* put old address here on success */
 189 {
 190 int fd_in, fd_out, len, rc;
 191 pid_t pid;
 192 struct passwd *upw = NULL;
 193 uschar buffer[1024];
 194 uschar **argvptr;
 195 uschar *rword, *rdata, *s;
 196 address_item_propagated addr_prop;
 197 queryprogram_router_options_block *ob =
 198   (queryprogram_router_options_block *)(rblock->options_block);
 199 uschar *current_directory = ob->current_directory;
 200 ugid_block ugid;
 201 uid_t curr_uid = getuid();
 202 gid_t curr_gid = getgid();
 203 uid_t uid = ob->cmd_uid;
 204 gid_t gid = ob->cmd_gid;
 205 uid_t *puid = &uid;
 206 gid_t *pgid = &gid;
 207
 208 DEBUG(D_route) debug_printf("%s router called for %s: domain = %s\n",
 209   rblock->name, addr->address, addr->domain);
 210
 211 ugid.uid_set = ugid.gid_set = FALSE;
 212
 213 /* Set up the propagated data block with the current address_data and the
 214 errors address and extra header stuff. */
 215
 216 addr_prop.address_data = deliver_address_data;
 217
 218 rc = rf_get_errors_address(addr, rblock, verify, &(addr_prop.errors_address));
 219 if (rc != OK) return rc;
 220
 221 rc = rf_get_munge_headers(addr, rblock, &(addr_prop.extra_headers),
 222   &(addr_prop.remove_headers));
 223 if (rc != OK) return rc;
 224
 225 /* Get the fixed or expanded uid under which the command is to run
 226 (initialization ensures that one or the other is set). */
 227
 228 if (!ob->cmd_uid_set)
 229   {
 230   if (!route_find_expanded_user(ob->expand_cmd_uid, rblock->name, US"router",
 231       &upw, &uid, &(addr->message)))
 232     return DEFER;
 233   }
 234
 235 /* Get the fixed or expanded gid, or take the gid from the passwd entry. */
 236
 237 if (!ob->cmd_gid_set)
 238   {
 239   if (ob->expand_cmd_gid != NULL)
 240     {
 241     if (route_find_expanded_group(ob->expand_cmd_gid, rblock->name,
 242         US"router", &gid, &(addr->message)))
 243       return DEFER;
 244     }
 245   else if (upw != NULL)
 246     {
 247     gid = upw->pw_gid;
 248     }
 249   else
 250     {
 251     addr->message = string_sprintf("command_user set without command_group "
 252       "for %s router", rblock->name);
 253     return DEFER;
 254     }
 255   }
 256
 257 DEBUG(D_route) debug_printf("requires uid=%ld gid=%ld current_directory=%s\n",
 258   (long int)uid, (long int)gid, current_directory);
 259
 260 /* If we are not running as root, we will not be able to change uid/gid. */
 261
 262 if (curr_uid != root_uid && (uid != curr_uid || gid != curr_gid))
 263   {
 264   DEBUG(D_route)
 265     {
 266     debug_printf("not running as root: cannot change uid/gid\n");
 267     debug_printf("subprocess will run with uid=%ld gid=%ld\n",
 268       (long int)curr_uid, (long int)curr_gid);
 269     }
 270   puid = pgid = NULL;
 271   }
 272
 273 /* Set up the command to run */
 274
 275 if (!transport_set_up_command(&argvptr, /* anchor for arg list */
 276     ob->command,                        /* raw command */
 277     TRUE,                               /* expand the arguments */
 278     0,                                  /* not relevant when... */
 279     NULL,                               /* no transporting address */
 280     US"queryprogram router",            /* for error messages */
 281     &(addr->message)))                  /* where to put error message */
 282   {
 283   return DEFER;
 284   }
 285
 286 /* Create the child process, making it a group leader. */
 287
 288 pid = child_open_uid(argvptr, NULL, 0077, puid, pgid, &fd_in, &fd_out,
 289   current_directory, TRUE);
 290
 291 if (pid < 0)
 292   {
 293   addr->message = string_sprintf("%s router couldn't create child process: %s",
 294     rblock->name, strerror(errno));
 295   return DEFER;
 296   }
 297
 298 /* Nothing is written to the standard input. */
 299
 300 (void)close(fd_in);
 301
 302 /* Wait for the process to finish, applying the timeout, and inspect its return
 303 code. */
 304
 305 if ((rc = child_close(pid, ob->timeout)) != 0)
 306   {
 307   if (rc > 0)
 308     addr->message = string_sprintf("%s router: command returned non-zero "
 309       "code %d", rblock->name, rc);
 310
 311   else if (rc == -256)
 312     {
 313     addr->message = string_sprintf("%s router: command timed out",
 314       rblock->name);
 315     killpg(pid, SIGKILL);       /* Kill the whole process group */
 316     }
 317
 318   else if (rc == -257)
 319     addr->message = string_sprintf("%s router: wait() failed: %s",
 320       rblock->name, strerror(errno));
 321
 322   else
 323     addr->message = string_sprintf("%s router: command killed by signal %d",
 324       rblock->name, -rc);
 325
 326   return DEFER;
 327   }
 328
 329 /* Read the pipe to get the command's output, and then close it. */
 330
 331 len = read(fd_out, buffer, sizeof(buffer) - 1);
 332 (void)close(fd_out);
 333
 334 /* Failure to return any data is an error. */
 335
 336 if (len <= 0)
 337   {
 338   addr->message = string_sprintf("%s router: command failed to return data",
 339     rblock->name);
 340   return DEFER;
 341   }
 342
 343 /* Get rid of leading and trailing white space, and pick off the first word of
 344 the result. */
 345
 346 while (len > 0 && isspace(buffer[len-1])) len--;
 347 buffer[len] = 0;
 348
 349 DEBUG(D_route) debug_printf("command wrote: %s\n", buffer);
 350
 351 rword = buffer;
 352 while (isspace(*rword)) rword++;
 353 rdata = rword;
 354 while (*rdata != 0 && !isspace(*rdata)) rdata++;
 355 if (*rdata != 0) *rdata++ = 0;
 356
 357 /* The word must be a known yield name. If it is "REDIRECT", the rest of the
 358 line is redirection data, as for a .forward file. It may not contain filter
 359 data, and it may not contain anything other than addresses (no files, no pipes,
 360 no specials). */
 361
 362 if (strcmpic(rword, US"REDIRECT") == 0)
 363   {
 364   int filtertype;
 365   redirect_block redirect;
 366   address_item *generated = NULL;
 367
 368   redirect.string = rdata;
 369   redirect.isfile = FALSE;
 370
 371   rc = rda_interpret(&redirect,  /* redirection data */
 372     RDO_BLACKHOLE |              /* forbid :blackhole: */
 373       RDO_FAIL    |              /* forbid :fail: */
 374       RDO_INCLUDE |              /* forbid :include: */
 375       RDO_REWRITE,               /* rewrite generated addresses */
 376     NULL,                        /* :include: directory not relevant */
 377     NULL,                        /* sieve vacation directory not relevant */
 378     NULL,                        /* sieve useraddress not relevant */
 379     NULL,                        /* sieve subaddress not relevant */
 380     &ugid,                       /* uid/gid (but not set) */
 381     &generated,                  /* where to hang the results */
 382     &(addr->message),            /* where to put messages */
 383     NULL,                        /* don't skip syntax errors */
 384     &filtertype,                 /* not used; will always be FILTER_FORWARD */
 385     string_sprintf("%s router", rblock->name));
 386
 387   switch (rc)
 388     {
 389     /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands.
 390     If a configured message was supplied, allow it to be  included in an SMTP
 391     response after verifying. */
 392
 393     case FF_DEFER:
 394     if (addr->message == NULL) addr->message = US"forced defer";
 395       else addr->user_message = addr->message;
 396     return DEFER;
 397
 398     case FF_FAIL:
 399     add_generated(rblock, addr_new, addr, generated, &addr_prop);
 400     if (addr->message == NULL) addr->message = US"forced rejection";
 401       else addr->user_message = addr->message;
 402     return FAIL;
 403
 404     case FF_DELIVERED:
 405     break;
 406
 407     case FF_NOTDELIVERED:    /* an empty redirection list is bad */
 408     addr->message = US"no addresses supplied";
 409     /* Fall through */
 410
 411     case FF_ERROR:
 412     default:
 413     addr->basic_errno = ERRNO_BADREDIRECT;
 414     addr->message = string_sprintf("error in redirect data: %s", addr->message);
 415     return DEFER;
 416     }
 417
 418   /* Handle the generated addresses, if any. */
 419
 420   add_generated(rblock, addr_new, addr, generated, &addr_prop);
 421
 422   /* Put the original address onto the succeed queue so that any retry items
 423   that get attached to it get processed. */
 424
 425   addr->next = *addr_succeed;
 426   *addr_succeed = addr;
 427
 428   return OK;
 429   }
 430
 431 /* Handle other returns that are not ACCEPT */
 432
 433 if (strcmpic(rword, US"accept") != 0)
 434   {
 435   if (strcmpic(rword, US"decline") == 0) return DECLINE;
 436   if (strcmpic(rword, US"pass") == 0) return PASS;
 437   addr->message = string_copy(rdata);                /* data is a message */
 438   if (strcmpic(rword, US"fail") == 0)
 439     {
 440     setflag(addr, af_pass_message);
 441     return FAIL;
 442     }
 443   if (strcmpic(rword, US"freeze") == 0) addr->special_action = SPECIAL_FREEZE;
 444   else if (strcmpic(rword, US"defer") != 0)
 445     {
 446     addr->message = string_sprintf("bad command yield: %s %s", rword, rdata);
 447     log_write(0, LOG_PANIC, "%s router: %s", rblock->name, addr->message);
 448     }
 449   return DEFER;
 450   }
 451
 452 /* The command yielded "ACCEPT". The rest of the string is a number of keyed
 453 fields from which we can fish out values using the "extract" expansion
 454 function. To use this feature, we must put the string into the $value variable,
 455 i.e. set lookup_value. */
 456
 457 lookup_value = rdata;
 458 s = expand_string(US"${extract{data}{$value}}");
 459 if (*s != 0) addr_prop.address_data = string_copy(s);
 460
 461 s = expand_string(US"${extract{transport}{$value}}");
 462 lookup_value = NULL;
 463
 464 /* If we found a transport name, find the actual transport */
 465
 466 if (*s != 0)
 467   {
 468   transport_instance *transport;
 469   for (transport = transports; transport != NULL; transport = transport->next)
 470     if (Ustrcmp(transport->name, s) == 0) break;
 471   if (transport == NULL)
 472     {
 473     addr->message = string_sprintf("unknown transport name %s yielded by "
 474       "command", s);
 475     log_write(0, LOG_PANIC, "%s router: %s", rblock->name, addr->message);
 476     return DEFER;
 477     }
 478   addr->transport = transport;
 479   }
 480
 481 /* No transport given; get the transport from the router configuration. It may
 482 be fixed or expanded, but there will be an error if it is unset, requested by
 483 the last argument not being NULL. */
 484
 485 else
 486   {
 487   if (!rf_get_transport(rblock->transport_name, &(rblock->transport), addr,
 488        rblock->name, US"transport"))
 489     return DEFER;
 490   addr->transport = rblock->transport;
 491   }
 492
 493 /* See if a host list is given, and if so, look up the addresses. */
 494
 495 lookup_value = rdata;
 496 s = expand_string(US"${extract{hosts}{$value}}");
 497
 498 if (*s != 0)
 499   {
 500   int lookup_type = lk_default;
 501   uschar *ss = expand_string(US"${extract{lookup}{$value}}");
 502   lookup_value = NULL;
 503
 504   if (*ss != 0)
 505     {
 506     if (Ustrcmp(ss, "byname") == 0) lookup_type = lk_byname;
 507     else if (Ustrcmp(ss, "bydns") == 0) lookup_type = lk_bydns;
 508     else
 509       {
 510       addr->message = string_sprintf("bad lookup type \"%s\" yielded by "
 511         "command", ss);
 512       log_write(0, LOG_PANIC, "%s router: %s", rblock->name, addr->message);
 513       return DEFER;
 514       }
 515     }
 516
 517   host_build_hostlist(&(addr->host_list), s, FALSE);  /* pro tem no randomize */
 518
 519   rc = rf_lookup_hostlist(rblock, addr, rblock->ignore_target_hosts,
 520     lookup_type, hff_defer, addr_new);
 521   if (rc != OK) return rc;
 522   }
 523 lookup_value = NULL;
 524
 525 /* Put the errors address, extra headers, and address_data into this address */
 526
 527 addr->p = addr_prop;
 528
 529 /* Queue the address for local or remote delivery. */
 530
 531 return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
 532   OK : DEFER;
 533 }
 534
 535 /* End of routers/queryprogram.c */