src/src/routers/queryprogram.c

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