src/src/routers/queryprogram.c

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