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