src/src/transports/pipe.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
   9 #include "../exim.h"
  10 #include "pipe.h"
  11
  12 #ifdef HAVE_SETCLASSRESOURCES
  13 #include <login_cap.h>
  14 #endif
  15
  16
  17
  18 /* Options specific to the pipe transport. They must be in alphabetic
  19 order (note that "_" comes before the lower case letters). Those starting
  20 with "*" are not settable by the user but are used by the option-reading
  21 software for alternative value types. Some options are stored in the transport
  22 instance block so as to be publicly visible; these are flagged with opt_public.
  23 */
  24
  25 optionlist pipe_transport_options[] = {
  26   { "allow_commands",    opt_stringptr,
  27       (void *)offsetof(pipe_transport_options_block, allow_commands) },
  28   { "batch_id",          opt_stringptr | opt_public,
  29       (void *)offsetof(transport_instance, batch_id) },
  30   { "batch_max",         opt_int | opt_public,
  31       (void *)offsetof(transport_instance, batch_max) },
  32   { "check_string",      opt_stringptr,
  33       (void *)offsetof(pipe_transport_options_block, check_string) },
  34   { "command",           opt_stringptr,
  35       (void *)offsetof(pipe_transport_options_block, cmd) },
  36   { "environment",       opt_stringptr,
  37       (void *)offsetof(pipe_transport_options_block, environment) },
  38   { "escape_string",     opt_stringptr,
  39       (void *)offsetof(pipe_transport_options_block, escape_string) },
  40   { "force_command",         opt_bool,
  41       (void *)offsetof(pipe_transport_options_block, force_command) },
  42   { "freeze_exec_fail",  opt_bool,
  43       (void *)offsetof(pipe_transport_options_block, freeze_exec_fail) },
  44   { "freeze_signal",     opt_bool,
  45       (void *)offsetof(pipe_transport_options_block, freeze_signal) },
  46   { "ignore_status",     opt_bool,
  47       (void *)offsetof(pipe_transport_options_block, ignore_status) },
  48   { "log_defer_output",  opt_bool | opt_public,
  49       (void *)offsetof(transport_instance, log_defer_output) },
  50   { "log_fail_output",   opt_bool | opt_public,
  51       (void *)offsetof(transport_instance, log_fail_output) },
  52   { "log_output",        opt_bool | opt_public,
  53       (void *)offsetof(transport_instance, log_output) },
  54   { "max_output",        opt_mkint,
  55       (void *)offsetof(pipe_transport_options_block, max_output) },
  56   { "message_prefix",    opt_stringptr,
  57       (void *)offsetof(pipe_transport_options_block, message_prefix) },
  58   { "message_suffix",    opt_stringptr,
  59       (void *)offsetof(pipe_transport_options_block, message_suffix) },
  60   { "path",              opt_stringptr,
  61       (void *)offsetof(pipe_transport_options_block, path) },
  62   { "permit_coredump",   opt_bool,
  63       (void *)offsetof(pipe_transport_options_block, permit_coredump) },
  64   { "pipe_as_creator",   opt_bool | opt_public,
  65       (void *)offsetof(transport_instance, deliver_as_creator) },
  66   { "restrict_to_path",  opt_bool,
  67       (void *)offsetof(pipe_transport_options_block, restrict_to_path) },
  68   { "return_fail_output",opt_bool | opt_public,
  69       (void *)offsetof(transport_instance, return_fail_output) },
  70   { "return_output",     opt_bool | opt_public,
  71       (void *)offsetof(transport_instance, return_output) },
  72   { "temp_errors",       opt_stringptr,
  73       (void *)offsetof(pipe_transport_options_block, temp_errors) },
  74   { "timeout",           opt_time,
  75       (void *)offsetof(pipe_transport_options_block, timeout) },
  76   { "timeout_defer",     opt_bool,
  77       (void *)offsetof(pipe_transport_options_block, timeout_defer) },
  78   { "umask",             opt_octint,
  79       (void *)offsetof(pipe_transport_options_block, umask) },
  80   { "use_bsmtp",         opt_bool,
  81       (void *)offsetof(pipe_transport_options_block, use_bsmtp) },
  82   #ifdef HAVE_SETCLASSRESOURCES
  83   { "use_classresources", opt_bool,
  84       (void *)offsetof(pipe_transport_options_block, use_classresources) },
  85   #endif
  86   { "use_crlf",          opt_bool,
  87       (void *)offsetof(pipe_transport_options_block, use_crlf) },
  88   { "use_shell",         opt_bool,
  89       (void *)offsetof(pipe_transport_options_block, use_shell) },
  90 };
  91
  92 /* Size of the options list. An extern variable has to be used so that its
  93 address can appear in the tables drtables.c. */
  94
  95 int pipe_transport_options_count =
  96   sizeof(pipe_transport_options)/sizeof(optionlist);
  97
  98 /* Default private options block for the pipe transport. */
  99
 100 pipe_transport_options_block pipe_transport_option_defaults = {
 101   NULL,           /* cmd */
 102   NULL,           /* allow_commands */
 103   NULL,           /* environment */
 104   US"/bin:/usr/bin",  /* path */
 105   NULL,           /* message_prefix (reset in init if not bsmtp) */
 106   NULL,           /* message_suffix (ditto) */
 107   US mac_expanded_string(EX_TEMPFAIL) ":"    /* temp_errors */
 108      mac_expanded_string(EX_CANTCREAT),
 109   NULL,           /* check_string */
 110   NULL,           /* escape_string */
 111   022,            /* umask */
 112   20480,          /* max_output */
 113   60*60,          /* timeout */
 114   0,              /* options */
 115   FALSE,          /* force_command */
 116   FALSE,          /* freeze_exec_fail */
 117   FALSE,          /* freeze_signal */
 118   FALSE,          /* ignore_status */
 119   FALSE,          /* permit_coredump */
 120   FALSE,          /* restrict_to_path */
 121   FALSE,          /* timeout_defer */
 122   FALSE,          /* use_shell */
 123   FALSE,          /* use_bsmtp */
 124   FALSE,          /* use_classresources */
 125   FALSE           /* use_crlf */
 126 };
 127
 128
 129
 130 /*************************************************
 131 *              Setup entry point                 *
 132 *************************************************/
 133
 134 /* Called for each delivery in the privileged state, just before the uid/gid
 135 are changed and the main entry point is called. In a system that supports the
 136 login_cap facilities, this function is used to set the class resource limits
 137 for the user.  It may also re-enable coredumps.
 138
 139 Arguments:
 140   tblock     points to the transport instance
 141   addrlist   addresses about to be delivered (not used)
 142   dummy      not used (doesn't pass back data)
 143   uid        the uid that will be set (not used)
 144   gid        the gid that will be set (not used)
 145   errmsg     where to put an error message
 146
 147 Returns:     OK, FAIL, or DEFER
 148 */
 149
 150 static int
 151 pipe_transport_setup(transport_instance *tblock, address_item *addrlist,
 152   transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
 153 {
 154 pipe_transport_options_block *ob =
 155   (pipe_transport_options_block *)(tblock->options_block);
 156
 157 addrlist = addrlist;  /* Keep compiler happy */
 158 dummy = dummy;
 159 uid = uid;
 160 gid = gid;
 161 errmsg = errmsg;
 162 ob = ob;
 163
 164 #ifdef HAVE_SETCLASSRESOURCES
 165 if (ob->use_classresources)
 166   {
 167   struct passwd *pw = getpwuid(uid);
 168   if (pw != NULL)
 169     {
 170     login_cap_t *lc = login_getpwclass(pw);
 171     if (lc != NULL)
 172       {
 173       setclassresources(lc);
 174       login_close(lc);
 175       }
 176     }
 177   }
 178 #endif
 179
 180 #ifdef RLIMIT_CORE
 181 if (ob->permit_coredump)
 182   {
 183   struct rlimit rl;
 184   rl.rlim_cur = RLIM_INFINITY;
 185   rl.rlim_max = RLIM_INFINITY;
 186   if (setrlimit(RLIMIT_CORE, &rl) < 0)
 187     {
 188 #ifdef SETRLIMIT_NOT_SUPPORTED
 189     if (errno != ENOSYS && errno != ENOTSUP)
 190 #endif
 191       log_write(0, LOG_MAIN,
 192           "delivery setrlimit(RLIMIT_CORE, RLIM_INFINITY) failed: %s",
 193           strerror(errno));
 194     }
 195   }
 196 #endif
 197
 198 return OK;
 199 }
 200
 201
 202
 203 /*************************************************
 204 *          Initialization entry point            *
 205 *************************************************/
 206
 207 /* Called for each instance, after its options have been read, to
 208 enable consistency checks to be done, or anything else that needs
 209 to be set up. */
 210
 211 void
 212 pipe_transport_init(transport_instance *tblock)
 213 {
 214 pipe_transport_options_block *ob =
 215   (pipe_transport_options_block *)(tblock->options_block);
 216
 217 /* Set up the setup entry point, to be called in the privileged state */
 218
 219 tblock->setup = pipe_transport_setup;
 220
 221 /* If pipe_as_creator is set, then uid/gid should not be set. */
 222
 223 if (tblock->deliver_as_creator && (tblock->uid_set || tblock->gid_set ||
 224   tblock->expand_uid != NULL || tblock->expand_gid != NULL))
 225     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 226       "both pipe_as_creator and an explicit uid/gid are set for the %s "
 227         "transport", tblock->name);
 228
 229 /* If a fixed uid field is set, then a gid field must also be set. */
 230
 231 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
 232   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 233     "user set without group for the %s transport", tblock->name);
 234
 235 /* Temp_errors must consist only of digits and colons, but there can be
 236 spaces round the colons, so allow them too. */
 237
 238 if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
 239   {
 240   size_t p = Ustrspn(ob->temp_errors, "0123456789: ");
 241   if (ob->temp_errors[p] != 0)
 242     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 243       "temp_errors must be a list of numbers or an asterisk for the %s "
 244       "transport", tblock->name);
 245   }
 246
 247 /* Only one of return_output/return_fail_output or log_output/log_fail_output
 248 should be set. */
 249
 250 if (tblock->return_output && tblock->return_fail_output)
 251   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 252     "both return_output and return_fail_output set for %s transport",
 253     tblock->name);
 254
 255 if (tblock->log_output && tblock->log_fail_output)
 256   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 257     "both log_output and log_fail_output set for the %s transport",
 258     tblock->name);
 259
 260 /* If batch SMTP is set, force the check and escape strings, and arrange that
 261 headers are also escaped. */
 262
 263 if (ob->use_bsmtp)
 264   {
 265   ob->check_string = US".";
 266   ob->escape_string = US"..";
 267   ob->options |= topt_escape_headers;
 268   }
 269
 270 /* If not batch SMTP, and message_prefix or message_suffix are unset, insert
 271 default values for them. */
 272
 273 else
 274   {
 275   if (ob->message_prefix == NULL) ob->message_prefix =
 276     US"From ${if def:return_path{$return_path}{MAILER-DAEMON}} ${tod_bsdinbox}\n";
 277   if (ob->message_suffix == NULL) ob->message_suffix = US"\n";
 278   }
 279
 280 /* The restrict_to_path  and use_shell options are incompatible */
 281
 282 if (ob->restrict_to_path && ob->use_shell)
 283   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 284     "both restrict_to_path and use_shell set for %s transport",
 285     tblock->name);
 286
 287 /* The allow_commands and use_shell options are incompatible */
 288
 289 if (ob->allow_commands && ob->use_shell)
 290   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
 291     "both allow_commands and use_shell set for %s transport",
 292     tblock->name);
 293
 294 /* Set up the bitwise options for transport_write_message from the various
 295 driver options. Only one of body_only and headers_only can be set. */
 296
 297 ob->options |=
 298   (tblock->body_only? topt_no_headers : 0) |
 299   (tblock->headers_only? topt_no_body : 0) |
 300   (tblock->return_path_add? topt_add_return_path : 0) |
 301   (tblock->delivery_date_add? topt_add_delivery_date : 0) |
 302   (tblock->envelope_to_add? topt_add_envelope_to : 0) |
 303   (ob->use_crlf? topt_use_crlf : 0);
 304 }
 305
 306
 307
 308 /*************************************************
 309 *          Set up direct (non-shell) command     *
 310 *************************************************/
 311
 312 /* This function is called when a command line is to be parsed by the transport
 313 and executed directly, without the use of /bin/sh.
 314
 315 Arguments:
 316   argvptr            pointer to anchor for argv vector
 317   cmd                points to the command string
 318   expand_arguments   true if expansion is to occur
 319   expand_fail        error if expansion fails
 320   addr               chain of addresses
 321   tname              the transport name
 322   ob                 the transport options block
 323
 324 Returns:             TRUE if all went well; otherwise an error will be
 325                      set in the first address and FALSE returned
 326 */
 327
 328 static BOOL
 329 set_up_direct_command(const uschar ***argvptr, uschar *cmd,
 330   BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname,
 331   pipe_transport_options_block *ob)
 332 {
 333 BOOL permitted = FALSE;
 334 const uschar **argv;
 335
 336 /* Set up "transport <name>" to be put in any error messages, and then
 337 call the common function for creating an argument list and expanding
 338 the items if necessary. If it fails, this function fails (error information
 339 is in the addresses). */
 340
 341 if (!transport_set_up_command(argvptr, cmd, expand_arguments, expand_fail,
 342       addr, string_sprintf("%.50s transport", tname), NULL))
 343   return FALSE;
 344
 345 /* Point to the set-up arguments. */
 346
 347 argv = *argvptr;
 348
 349 /* If allow_commands is set, see if the command is in the permitted list. */
 350
 351 if (ob->allow_commands)
 352   {
 353   int sep = 0;
 354   const uschar *s;
 355   uschar *p;
 356
 357   if (!(s = expand_string(ob->allow_commands)))
 358     {
 359     addr->transport_return = DEFER;
 360     addr->message = string_sprintf("failed to expand string \"%s\" "
 361       "for %s transport: %s", ob->allow_commands, tname, expand_string_message);
 362     return FALSE;
 363     }
 364
 365   while ((p = string_nextinlist(&s, &sep, NULL, 0)))
 366     if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
 367   }
 368
 369 /* If permitted is TRUE it means the command was found in the allowed list, and
 370 no further checks are done. If permitted = FALSE, it either means
 371 allow_commands wasn't set, or that the command didn't match anything in the
 372 list. In both cases, if restrict_to_path is set, we fail if the command
 373 contains any slashes, but if restrict_to_path is not set, we must fail the
 374 command only if allow_commands is set. */
 375
 376 if (!permitted)
 377   {
 378   if (ob->restrict_to_path)
 379     {
 380     if (Ustrchr(argv[0], '/') != NULL)
 381       {
 382       addr->transport_return = FAIL;
 383       addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
 384         "transport) - failed for security reasons", cmd, tname);
 385       return FALSE;
 386       }
 387     }
 388
 389   else if (ob->allow_commands)
 390     {
 391     addr->transport_return = FAIL;
 392     addr->message = string_sprintf("\"%s\" command not permitted by %s "
 393       "transport", argv[0], tname);
 394     return FALSE;
 395     }
 396   }
 397
 398 /* If the command is not an absolute path, search the PATH directories
 399 for it. */
 400
 401 if (argv[0][0] != '/')
 402   {
 403   int sep = 0;
 404   uschar *p;
 405   const uschar *listptr = expand_string(ob->path);
 406
 407   while ((p = string_nextinlist(&listptr, &sep, NULL, 0)))
 408     {
 409     struct stat statbuf;
 410     sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
 411     if (Ustat(big_buffer, &statbuf) == 0)
 412       {
 413       argv[0] = string_copy(big_buffer);
 414       break;
 415       }
 416     }
 417   if (!p)
 418     {
 419     addr->transport_return = FAIL;
 420     addr->message = string_sprintf("\"%s\" command not found for %s transport",
 421       argv[0], tname);
 422     return FALSE;
 423     }
 424   }
 425
 426 return TRUE;
 427 }
 428
 429
 430 /*************************************************
 431 *               Set up shell command             *
 432 *************************************************/
 433
 434 /* This function is called when a command line is to be passed to /bin/sh
 435 without parsing inside the transport.
 436
 437 Arguments:
 438   argvptr            pointer to anchor for argv vector
 439   cmd                points to the command string
 440   expand_arguments   true if expansion is to occur
 441   expand_fail        error if expansion fails
 442   addr               chain of addresses
 443   tname              the transport name
 444
 445 Returns:             TRUE if all went well; otherwise an error will be
 446                      set in the first address and FALSE returned
 447 */
 448
 449 static BOOL
 450 set_up_shell_command(const uschar ***argvptr, uschar *cmd,
 451   BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname)
 452 {
 453 const uschar **argv;
 454
 455 *argvptr = argv = store_get((4)*sizeof(uschar *));
 456
 457 argv[0] = US"/bin/sh";
 458 argv[1] = US"-c";
 459
 460 /* We have to take special action to handle the special "variable" called
 461 $pipe_addresses, which is not recognized by the normal expansion function. */
 462
 463 DEBUG(D_transport)
 464   debug_printf("shell pipe command before expansion:\n  %s\n", cmd);
 465
 466 if (expand_arguments)
 467   {
 468   uschar *s = cmd;
 469   uschar *p = Ustrstr(cmd, "pipe_addresses");
 470
 471   if (p != NULL && (
 472          (p > cmd && p[-1] == '$') ||
 473          (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
 474     {
 475     address_item *ad;
 476     uschar *q = p + 14;
 477     int size = Ustrlen(cmd) + 64;
 478     int offset;
 479
 480     if (p[-1] == '{') { q++; p--; }
 481
 482     s = store_get(size);
 483     offset = p - cmd - 1;
 484     Ustrncpy(s, cmd, offset);
 485
 486     for (ad = addr; ad != NULL; ad = ad->next)
 487       {
 488       /*XXX string_append_listele() ? */
 489       if (ad != addr) s = string_catn(s, &size, &offset, US" ", 1);
 490       s = string_cat(s, &size, &offset, ad->address);
 491       }
 492
 493     s = string_cat(s, &size, &offset, q);
 494     s[offset] = 0;
 495     }
 496
 497   /* Allow $recipients in the expansion iff it comes from a system filter */
 498
 499   enable_dollar_recipients = addr != NULL &&
 500     addr->parent != NULL &&
 501     Ustrcmp(addr->parent->address, "system-filter") == 0;
 502   argv[2] = expand_string(s);
 503   enable_dollar_recipients = FALSE;
 504
 505   if (argv[2] == NULL)
 506     {
 507     addr->transport_return = search_find_defer? DEFER : expand_fail;
 508     addr->message = string_sprintf("Expansion of command \"%s\" "
 509       "in %s transport failed: %s",
 510       cmd, tname, expand_string_message);
 511     return FALSE;
 512     }
 513
 514   DEBUG(D_transport)
 515     debug_printf("shell pipe command after expansion:\n  %s\n", argv[2]);
 516   }
 517 else argv[2] = cmd;
 518
 519 argv[3] = (uschar *)0;
 520 return TRUE;
 521 }
 522
 523
 524
 525
 526 /*************************************************
 527 *              Main entry point                  *
 528 *************************************************/
 529
 530 /* See local README for interface details. This transport always returns FALSE,
 531 indicating that the status in the first address is the status for all addresses
 532 in a batch. */
 533
 534 BOOL
 535 pipe_transport_entry(
 536   transport_instance *tblock,      /* data for this instantiation */
 537   address_item *addr)              /* address(es) we are working on */
 538 {
 539 pid_t pid, outpid;
 540 int fd_in, fd_out, rc;
 541 int envcount = 0;
 542 int envsep = 0;
 543 int expand_fail;
 544 pipe_transport_options_block *ob =
 545   (pipe_transport_options_block *)(tblock->options_block);
 546 int timeout = ob->timeout;
 547 BOOL written_ok = FALSE;
 548 BOOL expand_arguments;
 549 const uschar **argv;
 550 uschar *envp[50];
 551 const uschar *envlist = ob->environment;
 552 uschar *cmd, *ss;
 553 uschar *eol = ob->use_crlf ? US"\r\n" : US"\n";
 554 transport_ctx tctx = {
 555   tblock,
 556   addr,
 557   ob->check_string,
 558   ob->escape_string,
 559   ob->options /* set at initialization time */
 560 };
 561
 562 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
 563
 564 /* Set up for the good case */
 565
 566 addr->transport_return = OK;
 567 addr->basic_errno = 0;
 568
 569 /* Pipes are not accepted as general addresses, but they can be generated from
 570 .forward files or alias files. In those cases, the pfr flag is set, and the
 571 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
 572 symbol. In other cases, the command is supplied as one of the pipe transport's
 573 options. */
 574
 575 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
 576   {
 577   if (ob->force_command)
 578     {
 579     /* Enables expansion of $address_pipe into separate arguments */
 580     setflag(addr, af_force_command);
 581     cmd = ob->cmd;
 582     expand_arguments = TRUE;
 583     expand_fail = PANIC;
 584     }
 585   else
 586     {
 587     cmd = addr->local_part + 1;
 588     while (isspace(*cmd)) cmd++;
 589     expand_arguments = testflag(addr, af_expand_pipe);
 590     expand_fail = FAIL;
 591     }
 592   }
 593 else
 594   {
 595   cmd = ob->cmd;
 596   expand_arguments = TRUE;
 597   expand_fail = PANIC;
 598   }
 599
 600 /* If no command has been supplied, we are in trouble.
 601  * We also check for an empty string since it may be
 602  * coming from addr->local_part[0] == '|'
 603  */
 604
 605 if (cmd == NULL || *cmd == '\0')
 606   {
 607   addr->transport_return = DEFER;
 608   addr->message = string_sprintf("no command specified for %s transport",
 609     tblock->name);
 610   return FALSE;
 611   }
 612
 613 /* When a pipe is set up by a filter file, there may be values for $thisaddress
 614 and numerical the variables in existence. These are passed in
 615 addr->pipe_expandn for use here. */
 616
 617 if (expand_arguments && addr->pipe_expandn)
 618   {
 619   uschar **ss = addr->pipe_expandn;
 620   expand_nmax = -1;
 621   if (*ss != NULL) filter_thisaddress = *ss++;
 622   while (*ss != NULL)
 623     {
 624     expand_nstring[++expand_nmax] = *ss;
 625     expand_nlength[expand_nmax] = Ustrlen(*ss++);
 626     }
 627   }
 628
 629 /* The default way of processing the command is to split it up into arguments
 630 here, and run it directly. This offers some security advantages. However, there
 631 are installations that want by default to run commands under /bin/sh always, so
 632 there is an option to do that. */
 633
 634 if (ob->use_shell)
 635   {
 636   if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
 637     tblock->name)) return FALSE;
 638   }
 639 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
 640   tblock->name, ob)) return FALSE;
 641
 642 expand_nmax = -1;           /* Reset */
 643 filter_thisaddress = NULL;
 644
 645 /* Set up the environment for the command. */
 646
 647 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
 648 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
 649 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
 650 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
 651   deliver_localpart_prefix);
 652 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
 653   deliver_localpart_suffix);
 654 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
 655 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
 656 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
 657 envp[envcount++] = string_sprintf("PATH=%s", expand_string(ob->path));
 658 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
 659   deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
 660   deliver_domain);
 661 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
 662 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
 663 envp[envcount++] = US"SHELL=/bin/sh";
 664
 665 if (addr->host_list != NULL)
 666   envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
 667
 668 if (timestamps_utc) envp[envcount++] = US"TZ=UTC";
 669 else if (timezone_string != NULL && timezone_string[0] != 0)
 670   envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
 671
 672 /* Add any requested items */
 673
 674 if (envlist)
 675   {
 676   envlist = expand_cstring(envlist);
 677   if (envlist == NULL)
 678     {
 679     addr->transport_return = DEFER;
 680     addr->message = string_sprintf("failed to expand string \"%s\" "
 681       "for %s transport: %s", ob->environment, tblock->name,
 682       expand_string_message);
 683     return FALSE;
 684     }
 685   }
 686
 687 while ((ss = string_nextinlist(&envlist, &envsep, big_buffer, big_buffer_size))
 688        != NULL)
 689    {
 690    if (envcount > sizeof(envp)/sizeof(uschar *) - 2)
 691      {
 692      addr->transport_return = DEFER;
 693      addr->message = string_sprintf("too many environment settings for "
 694        "%s transport", tblock->name);
 695      return FALSE;
 696      }
 697    envp[envcount++] = string_copy(ss);
 698    }
 699
 700 envp[envcount] = NULL;
 701
 702 /* If the -N option is set, can't do any more. */
 703
 704 if (dont_deliver)
 705   {
 706   DEBUG(D_transport)
 707     debug_printf("*** delivery by %s transport bypassed by -N option",
 708       tblock->name);
 709   return FALSE;
 710   }
 711
 712
 713 /* Handling the output from the pipe is tricky. If a file for catching this
 714 output is provided, we could in theory just hand that fd over to the process,
 715 but this isn't very safe because it might loop and carry on writing for
 716 ever (which is exactly what happened in early versions of Exim). Therefore we
 717 use the standard child_open() function, which creates pipes. We can then read
 718 our end of the output pipe and count the number of bytes that come through,
 719 chopping the sub-process if it exceeds some limit.
 720
 721 However, this means we want to run a sub-process with both its input and output
 722 attached to pipes. We can't handle that easily from a single parent process
 723 using straightforward code such as the transport_write_message() function
 724 because the subprocess might not be reading its input because it is trying to
 725 write to a full output pipe. The complication of redesigning the world to
 726 handle this is too great - simpler just to run another process to do the
 727 reading of the output pipe. */
 728
 729
 730 /* As this is a local transport, we are already running with the required
 731 uid/gid and current directory. Request that the new process be a process group
 732 leader, so we can kill it and all its children on a timeout. */
 733
 734 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE)) < 0)
 735   {
 736   addr->transport_return = DEFER;
 737   addr->message = string_sprintf(
 738     "Failed to create child process for %s transport: %s", tblock->name,
 739       strerror(errno));
 740   return FALSE;
 741   }
 742
 743 /* Now fork a process to handle the output that comes down the pipe. */
 744
 745 if ((outpid = fork()) < 0)
 746   {
 747   addr->basic_errno = errno;
 748   addr->transport_return = DEFER;
 749   addr->message = string_sprintf(
 750     "Failed to create process for handling output in %s transport",
 751       tblock->name);
 752   (void)close(fd_in);
 753   (void)close(fd_out);
 754   return FALSE;
 755   }
 756
 757 /* This is the code for the output-handling subprocess. Read from the pipe
 758 in chunks, and write to the return file if one is provided. Keep track of
 759 the number of bytes handled. If the limit is exceeded, try to kill the
 760 subprocess group, and in any case close the pipe and exit, which should cause
 761 the subprocess to fail. */
 762
 763 if (outpid == 0)
 764   {
 765   int count = 0;
 766   (void)close(fd_in);
 767   set_process_info("reading output from |%s", cmd);
 768   while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
 769     {
 770     if (addr->return_file >= 0)
 771       if(write(addr->return_file, big_buffer, rc) != rc)
 772         DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
 773     count += rc;
 774     if (count > ob->max_output)
 775       {
 776       DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
 777       if (addr->return_file >= 0)
 778         {
 779         uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
 780         rc = Ustrlen(message);
 781         if(write(addr->return_file, message, rc) != rc)
 782           DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
 783         }
 784       killpg(pid, SIGKILL);
 785       break;
 786       }
 787     }
 788   (void)close(fd_out);
 789   _exit(0);
 790   }
 791
 792 (void)close(fd_out);  /* Not used in this process */
 793
 794
 795 /* Carrying on now with the main parent process. Attempt to write the message
 796 to it down the pipe. It is a fallacy to think that you can detect write errors
 797 when the sub-process fails to read the pipe. The parent process may complete
 798 writing and close the pipe before the sub-process completes. We could sleep a
 799 bit here to let the sub-process get going, but it may still not complete. So we
 800 ignore all writing errors. (When in the test harness, we do do a short sleep so
 801 any debugging output is likely to be in the same order.) */
 802
 803 if (running_in_test_harness) millisleep(500);
 804
 805 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
 806
 807 /* Arrange to time out writes if there is a timeout set. */
 808
 809 if (timeout > 0)
 810   {
 811   sigalrm_seen = FALSE;
 812   transport_write_timeout = timeout;
 813   }
 814
 815 /* Reset the counter of bytes written */
 816
 817 transport_count = 0;
 818
 819 /* First write any configured prefix information */
 820
 821 if (ob->message_prefix != NULL)
 822   {
 823   uschar *prefix = expand_string(ob->message_prefix);
 824   if (prefix == NULL)
 825     {
 826     addr->transport_return = search_find_defer? DEFER : PANIC;
 827     addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
 828       "transport) failed: %s", ob->message_prefix, tblock->name,
 829       expand_string_message);
 830     return FALSE;
 831     }
 832   if (!transport_write_block(fd_in, prefix, Ustrlen(prefix)))
 833     goto END_WRITE;
 834   }
 835
 836 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
 837 The various different values for batching are handled outside; if there is more
 838 than one address available here, all must be included. Force SMTP dot-handling.
 839 */
 840
 841 if (ob->use_bsmtp)
 842   {
 843   address_item *a;
 844
 845   if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
 846     goto END_WRITE;
 847
 848   for (a = addr; a; a = a->next)
 849     if (!transport_write_string(fd_in,
 850         "RCPT TO:<%s>%s",
 851         transport_rcpt_address(a, tblock->rcpt_include_affixes),
 852         eol))
 853       goto END_WRITE;
 854
 855   if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
 856   }
 857
 858 /* Now the actual message */
 859
 860 if (!transport_write_message(fd_in, &tctx, 0))
 861     goto END_WRITE;
 862
 863 /* Now any configured suffix */
 864
 865 if (ob->message_suffix)
 866   {
 867   uschar *suffix = expand_string(ob->message_suffix);
 868   if (!suffix)
 869     {
 870     addr->transport_return = search_find_defer? DEFER : PANIC;
 871     addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
 872       "transport) failed: %s", ob->message_suffix, tblock->name,
 873       expand_string_message);
 874     return FALSE;
 875     }
 876   if (!transport_write_block(fd_in, suffix, Ustrlen(suffix)))
 877     goto END_WRITE;
 878   }
 879
 880 /* If local_smtp, write the terminating dot. */
 881
 882 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
 883   goto END_WRITE;
 884
 885 /* Flag all writing completed successfully. */
 886
 887 written_ok = TRUE;
 888
 889 /* Come here if there are errors during writing. */
 890
 891 END_WRITE:
 892
 893 /* OK, the writing is now all done. Close the pipe. */
 894
 895 (void) close(fd_in);
 896
 897 /* Handle errors during writing. For timeouts, set the timeout for waiting for
 898 the child process to 1 second. If the process at the far end of the pipe died
 899 without reading all of it, we expect an EPIPE error, which should be ignored.
 900 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
 901 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
 902 comments therein. */
 903
 904 if (!written_ok)
 905   {
 906   if (errno == ETIMEDOUT)
 907     {
 908     addr->message = string_sprintf("%stimeout while writing to pipe",
 909       transport_filter_timed_out? "transport filter " : "");
 910     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
 911     timeout = 1;
 912     }
 913   else if (errno == EPIPE)
 914     {
 915     debug_printf("transport error EPIPE ignored\n");
 916     }
 917   else
 918     {
 919     addr->transport_return = PANIC;
 920     addr->basic_errno = errno;
 921     if (errno == ERRNO_CHHEADER_FAIL)
 922       addr->message =
 923         string_sprintf("Failed to expand headers_add or headers_remove: %s",
 924           expand_string_message);
 925     else if (errno == ERRNO_FILTER_FAIL)
 926       addr->message = string_sprintf("Transport filter process failed (%d)%s",
 927       addr->more_errno,
 928       (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
 929     else if (errno == ERRNO_WRITEINCOMPLETE)
 930       addr->message = string_sprintf("Failed repeatedly to write data");
 931     else
 932       addr->message = string_sprintf("Error %d", errno);
 933     return FALSE;
 934     }
 935   }
 936
 937 /* Wait for the child process to complete and take action if the returned
 938 status is nonzero. The timeout will be just 1 second if any of the writes
 939 above timed out. */
 940
 941 if ((rc = child_close(pid, timeout)) != 0)
 942   {
 943   uschar *tmsg = (addr->message == NULL)? US"" :
 944     string_sprintf(" (preceded by %s)", addr->message);
 945
 946   /* The process did not complete in time; kill its process group and fail
 947   the delivery. It appears to be necessary to kill the output process too, as
 948   otherwise it hangs on for some time if the actual pipe process is sleeping.
 949   (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
 950   the delivery, that shouldn't cause any problem. */
 951
 952   if (rc == -256)
 953     {
 954     killpg(pid, SIGKILL);
 955     kill(outpid, SIGKILL);
 956     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
 957     addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
 958     }
 959
 960   /* Wait() failed. */
 961
 962   else if (rc == -257)
 963     {
 964     addr->transport_return = PANIC;
 965     addr->message = string_sprintf("Wait() failed for child process of %s "
 966       "transport: %s%s", tblock->name, strerror(errno), tmsg);
 967     }
 968
 969   /* Since the transport_filter timed out we assume it has sent the child process
 970   a malformed or incomplete data stream.  Kill off the child process
 971   and prevent checking its exit status as it will has probably exited in error.
 972   This prevents the transport_filter timeout message from getting overwritten
 973   by the exit error which is not the cause of the problem. */
 974
 975   else if (transport_filter_timed_out)
 976     {
 977     killpg(pid, SIGKILL);
 978     kill(outpid, SIGKILL);
 979     }
 980
 981   /* Either the process completed, but yielded a non-zero (necessarily
 982   positive) status, or the process was terminated by a signal (rc will contain
 983   the negation of the signal number). Treat killing by signal as failure unless
 984   status is being ignored. By default, the message is bounced back, unless
 985   freeze_signal is set, in which case it is frozen instead. */
 986
 987   else if (rc < 0)
 988     {
 989     if (ob->freeze_signal)
 990       {
 991       addr->transport_return = DEFER;
 992       addr->special_action = SPECIAL_FREEZE;
 993       addr->message = string_sprintf("Child process of %s transport (running "
 994         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
 995         -rc, os_strsignal(-rc), tmsg);
 996       }
 997     else if (!ob->ignore_status)
 998       {
 999       addr->transport_return = FAIL;
1000       addr->message = string_sprintf("Child process of %s transport (running "
1001         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
1002         -rc, os_strsignal(-rc), tmsg);
1003       }
1004     }
1005
1006   /* For positive values (process terminated with non-zero status), we need a
1007   status code to request deferral. A number of systems contain the following
1008   line in sysexits.h:
1009
1010       #define EX_TEMPFAIL 75
1011
1012   with the description
1013
1014       EX_TEMPFAIL -- temporary failure, indicating something that
1015          is not really an error.  In sendmail, this means
1016          that a mailer (e.g.) could not create a connection,
1017          and the request should be reattempted later.
1018
1019   Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1020   not ignoring the returned status. However, there is now an option that
1021   contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1022
1023   Another case that needs special treatment is if execve() failed (typically
1024   the command that was given is a non-existent path). By default this is
1025   treated as just another failure, but if freeze_exec_fail is set, the reaction
1026   is to freeze the message rather than bounce the address. Exim used to signal
1027   this failure with EX_UNAVAILABLE, which is defined in many systems as
1028
1029       #define EX_UNAVAILABLE  69
1030
1031   with the description
1032
1033       EX_UNAVAILABLE -- A service is unavailable.  This can occur
1034             if a support program or file does not exist.  This
1035             can also be used as a catchall message when something
1036             you wanted to do doesn't work, but you don't know why.
1037
1038   However, this can be confused with a command that actually returns 69 because
1039   something *it* wanted is unavailable. At release 4.21, Exim was changed to
1040   use return code 127 instead, because this is what the shell returns when it
1041   is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1042   child.c to signal execve() failure and other unexpected failures such as
1043   setuid() not working - though that won't be the case here because we aren't
1044   changing uid. */
1045
1046   else
1047     {
1048     /* Always handle execve() failure specially if requested to */
1049
1050     if (ob->freeze_exec_fail && (rc == EX_EXECFAILED))
1051       {
1052       addr->transport_return = DEFER;
1053       addr->special_action = SPECIAL_FREEZE;
1054       addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1055         cmd, tmsg);
1056       }
1057
1058     /* Otherwise take action only if not ignoring status */
1059
1060     else if (!ob->ignore_status)
1061       {
1062       uschar *ss;
1063       int size, ptr, i;
1064
1065       /* If temp_errors is "*" all codes are temporary. Initialization checks
1066       that it's either "*" or a list of numbers. If not "*", scan the list of
1067       temporary failure codes; if any match, the result is DEFER. */
1068
1069       if (ob->temp_errors[0] == '*')
1070         addr->transport_return = DEFER;
1071
1072       else
1073         {
1074         const uschar *s = ob->temp_errors;
1075         uschar *p;
1076         int sep = 0;
1077
1078         addr->transport_return = FAIL;
1079         while ((p = string_nextinlist(&s,&sep,NULL,0)))
1080           if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1081         }
1082
1083       /* Ensure the message contains the expanded command and arguments. This
1084       doesn't have to be brilliantly efficient - it is an error situation. */
1085
1086       addr->message = string_sprintf("Child process of %s transport returned "
1087         "%d", tblock->name, rc);
1088
1089       ptr = Ustrlen(addr->message);
1090       size = ptr + 1;
1091
1092       /* If the return code is > 128, it often means that a shell command
1093       was terminated by a signal. */
1094
1095       ss = (rc > 128)?
1096         string_sprintf("(could mean shell command ended by signal %d (%s))",
1097           rc-128, os_strsignal(rc-128)) :
1098         US os_strexit(rc);
1099
1100       if (*ss != 0)
1101         {
1102         addr->message = string_catn(addr->message, &size, &ptr, US" ", 1);
1103         addr->message = string_cat (addr->message, &size, &ptr, ss);
1104         }
1105
1106       /* Now add the command and arguments */
1107
1108       addr->message = string_catn(addr->message, &size, &ptr,
1109         US" from command:", 14);
1110
1111       for (i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1112         {
1113         BOOL quote = FALSE;
1114         addr->message = string_catn(addr->message, &size, &ptr, US" ", 1);
1115         if (Ustrpbrk(argv[i], " \t") != NULL)
1116           {
1117           quote = TRUE;
1118           addr->message = string_catn(addr->message, &size, &ptr, US"\"", 1);
1119           }
1120         addr->message = string_cat(addr->message, &size, &ptr, argv[i]);
1121         if (quote)
1122           addr->message = string_catn(addr->message, &size, &ptr, US"\"", 1);
1123         }
1124
1125       /* Add previous filter timeout message, if present. */
1126
1127       if (*tmsg)
1128         addr->message = string_cat(addr->message, &size, &ptr, tmsg);
1129
1130       addr->message[ptr] = 0;  /* Ensure concatenated string terminated */
1131       }
1132     }
1133   }
1134
1135 /* Ensure all subprocesses (in particular, the output handling process)
1136 are complete before we pass this point. */
1137
1138 while (wait(&rc) >= 0);
1139
1140 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1141   addr->transport_return);
1142
1143 /* If there has been a problem, the message in addr->message contains details
1144 of the pipe command. We don't want to expose these to the world, so we set up
1145 something bland to return to the sender. */
1146
1147 if (addr->transport_return != OK)
1148   addr->user_message = US"local delivery failed";
1149
1150 return FALSE;
1151 }
1152
1153 /* End of transport/pipe.c */