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