src/src/routers/queryprogram.c

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