src/src/transports/pipe.c

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