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