Track tainted data and refuse to expand it
[exim.git] / src / src / transport.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* General functions concerned with transportation, and generic options for all
9 transports. */
10
11
12 #include "exim.h"
13
14 /* Generic options for transports, all of which live inside transport_instance
15 data blocks and which therefore have the opt_public flag set. Note that there
16 are other options living inside this structure which can be set only from
17 certain transports. */
18
19 optionlist optionlist_transports[] = {
20   /*    name            type                                    value */
21   { "*expand_group",    opt_stringptr|opt_hidden|opt_public,
22                  (void *)offsetof(transport_instance, expand_gid) },
23   { "*expand_user",     opt_stringptr|opt_hidden|opt_public,
24                  (void *)offsetof(transport_instance, expand_uid) },
25   { "*headers_rewrite_flags", opt_int|opt_public|opt_hidden,
26                  (void *)offsetof(transport_instance, rewrite_existflags) },
27   { "*headers_rewrite_rules", opt_void|opt_public|opt_hidden,
28                  (void *)offsetof(transport_instance, rewrite_rules) },
29   { "*set_group",       opt_bool|opt_hidden|opt_public,
30                  (void *)offsetof(transport_instance, gid_set) },
31   { "*set_user",        opt_bool|opt_hidden|opt_public,
32                  (void *)offsetof(transport_instance, uid_set) },
33   { "body_only",        opt_bool|opt_public,
34                  (void *)offsetof(transport_instance, body_only) },
35   { "current_directory", opt_stringptr|opt_public,
36                  (void *)offsetof(transport_instance, current_dir) },
37   { "debug_print",      opt_stringptr | opt_public,
38                  (void *)offsetof(transport_instance, debug_string) },
39   { "delivery_date_add", opt_bool|opt_public,
40                  (void *)(offsetof(transport_instance, delivery_date_add)) },
41   { "disable_logging",  opt_bool|opt_public,
42                  (void *)(offsetof(transport_instance, disable_logging)) },
43   { "driver",           opt_stringptr|opt_public,
44                  (void *)offsetof(transport_instance, driver_name) },
45   { "envelope_to_add",   opt_bool|opt_public,
46                  (void *)(offsetof(transport_instance, envelope_to_add)) },
47 #ifndef DISABLE_EVENT
48   { "event_action",     opt_stringptr | opt_public,
49                  (void *)offsetof(transport_instance, event_action) },
50 #endif
51   { "group",             opt_expand_gid|opt_public,
52                  (void *)offsetof(transport_instance, gid) },
53   { "headers_add",      opt_stringptr|opt_public|opt_rep_str,
54                  (void *)offsetof(transport_instance, add_headers) },
55   { "headers_only",     opt_bool|opt_public,
56                  (void *)offsetof(transport_instance, headers_only) },
57   { "headers_remove",   opt_stringptr|opt_public|opt_rep_str,
58                  (void *)offsetof(transport_instance, remove_headers) },
59   { "headers_rewrite",  opt_rewrite|opt_public,
60                  (void *)offsetof(transport_instance, headers_rewrite) },
61   { "home_directory",   opt_stringptr|opt_public,
62                  (void *)offsetof(transport_instance, home_dir) },
63   { "initgroups",       opt_bool|opt_public,
64                  (void *)offsetof(transport_instance, initgroups) },
65   { "max_parallel",     opt_stringptr|opt_public,
66                  (void *)offsetof(transport_instance, max_parallel) },
67   { "message_size_limit", opt_stringptr|opt_public,
68                  (void *)offsetof(transport_instance, message_size_limit) },
69   { "rcpt_include_affixes", opt_bool|opt_public,
70                  (void *)offsetof(transport_instance, rcpt_include_affixes) },
71   { "retry_use_local_part", opt_bool|opt_public,
72                  (void *)offsetof(transport_instance, retry_use_local_part) },
73   { "return_path",      opt_stringptr|opt_public,
74                  (void *)(offsetof(transport_instance, return_path)) },
75   { "return_path_add",   opt_bool|opt_public,
76                  (void *)(offsetof(transport_instance, return_path_add)) },
77   { "shadow_condition", opt_stringptr|opt_public,
78                  (void *)offsetof(transport_instance, shadow_condition) },
79   { "shadow_transport", opt_stringptr|opt_public,
80                  (void *)offsetof(transport_instance, shadow) },
81   { "transport_filter", opt_stringptr|opt_public,
82                  (void *)offsetof(transport_instance, filter_command) },
83   { "transport_filter_timeout", opt_time|opt_public,
84                  (void *)offsetof(transport_instance, filter_timeout) },
85   { "user",             opt_expand_uid|opt_public,
86                  (void *)offsetof(transport_instance, uid) }
87 };
88
89 int optionlist_transports_size = nelem(optionlist_transports);
90
91 #ifdef MACRO_PREDEF
92
93 # include "macro_predef.h"
94
95 void
96 options_transports(void)
97 {
98 uschar buf[64];
99
100 options_from_list(optionlist_transports, nelem(optionlist_transports), US"TRANSPORTS", NULL);
101
102 for (transport_info * ti = transports_available; ti->driver_name[0]; ti++)
103   {
104   spf(buf, sizeof(buf), US"_DRIVER_TRANSPORT_%T", ti->driver_name);
105   builtin_macro_create(buf);
106   options_from_list(ti->options, (unsigned)*ti->options_count, US"TRANSPORT", ti->driver_name);
107   }
108 }
109
110 #else   /*!MACRO_PREDEF*/
111
112 /* Structure for keeping list of addresses that have been added to
113 Envelope-To:, in order to avoid duplication. */
114
115 struct aci {
116   struct aci *next;
117   address_item *ptr;
118   };
119
120
121 /* Static data for write_chunk() */
122
123 static uschar *chunk_ptr;           /* chunk pointer */
124 static uschar *nl_check;            /* string to look for at line start */
125 static int     nl_check_length;     /* length of same */
126 static uschar *nl_escape;           /* string to insert */
127 static int     nl_escape_length;    /* length of same */
128 static int     nl_partial_match;    /* length matched at chunk end */
129
130
131 /*************************************************
132 *             Initialize transport list           *
133 *************************************************/
134
135 /* Read the transports section of the configuration file, and set up a chain of
136 transport instances according to its contents. Each transport has generic
137 options and may also have its own private options. This function is only ever
138 called when transports == NULL. We use generic code in readconf to do most of
139 the work. */
140
141 void
142 transport_init(void)
143 {
144 readconf_driver_init(US"transport",
145   (driver_instance **)(&transports),     /* chain anchor */
146   (driver_info *)transports_available,   /* available drivers */
147   sizeof(transport_info),                /* size of info block */
148   &transport_defaults,                   /* default values for generic options */
149   sizeof(transport_instance),            /* size of instance block */
150   optionlist_transports,                 /* generic options */
151   optionlist_transports_size);
152
153 /* Now scan the configured transports and check inconsistencies. A shadow
154 transport is permitted only for local transports. */
155
156 for (transport_instance * t = transports; t; t = t->next)
157   {
158   if (!t->info->local && t->shadow)
159     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
160       "shadow transport not allowed on non-local transport %s", t->name);
161
162   if (t->body_only && t->headers_only)
163     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
164       "%s transport: body_only and headers_only are mutually exclusive",
165       t->name);
166   }
167 }
168
169
170
171 /*************************************************
172 *             Write block of data                *
173 *************************************************/
174
175 /* Subroutine called by write_chunk() and at the end of the message actually
176 to write a data block. Also called directly by some transports to write
177 additional data to the file descriptor (e.g. prefix, suffix).
178
179 If a transport wants data transfers to be timed, it sets a non-zero value in
180 transport_write_timeout. A non-zero transport_write_timeout causes a timer to
181 be set for each block of data written from here. If time runs out, then write()
182 fails and provokes an error return. The caller can then inspect sigalrm_seen to
183 check for a timeout.
184
185 On some systems, if a quota is exceeded during the write, the yield is the
186 number of bytes written rather than an immediate error code. This also happens
187 on some systems in other cases, for example a pipe that goes away because the
188 other end's process terminates (Linux). On other systems, (e.g. Solaris 2) you
189 get the error codes the first time.
190
191 The write() function is also interruptible; the Solaris 2.6 man page says:
192
193      If write() is interrupted by a signal before it writes any
194      data, it will return -1 with errno set to EINTR.
195
196      If write() is interrupted by a signal after it successfully
197      writes some data, it will return the number of bytes written.
198
199 To handle these cases, we want to restart the write() to output the remainder
200 of the data after a non-negative return from write(), except after a timeout.
201 In the error cases (EDQUOT, EPIPE) no bytes get written the second time, and a
202 proper error then occurs. In principle, after an interruption, the second
203 write() could suffer the same fate, but we do not want to continue for
204 evermore, so stick a maximum repetition count on the loop to act as a
205 longstop.
206
207 Arguments:
208   tctx      transport context: file descriptor or string to write to
209   block     block of bytes to write
210   len       number of bytes to write
211   more      further data expected soon
212
213 Returns:    TRUE on success, FALSE on failure (with errno preserved);
214               transport_count is incremented by the number of bytes written
215 */
216
217 static BOOL
218 transport_write_block_fd(transport_ctx * tctx, uschar *block, int len, BOOL more)
219 {
220 int rc, save_errno;
221 int local_timeout = transport_write_timeout;
222 int fd = tctx->u.fd;
223
224 /* This loop is for handling incomplete writes and other retries. In most
225 normal cases, it is only ever executed once. */
226
227 for (int i = 0; i < 100; i++)
228   {
229   DEBUG(D_transport)
230     debug_printf("writing data block fd=%d size=%d timeout=%d%s\n",
231       fd, len, local_timeout, more ? " (more expected)" : "");
232
233   /* This code makes use of alarm() in order to implement the timeout. This
234   isn't a very tidy way of doing things. Using non-blocking I/O with select()
235   provides a neater approach. However, I don't know how to do this when TLS is
236   in use. */
237
238   if (transport_write_timeout <= 0)   /* No timeout wanted */
239     {
240     rc =
241 #ifndef DISABLE_TLS
242         tls_out.active.sock == fd ? tls_write(tls_out.active.tls_ctx, block, len, more) :
243 #endif
244 #ifdef MSG_MORE
245         more && !(tctx->options & topt_not_socket)
246           ? send(fd, block, len, MSG_MORE) :
247 #endif
248         write(fd, block, len);
249     save_errno = errno;
250     }
251
252   /* Timeout wanted. */
253
254   else
255     {
256     ALARM(local_timeout);
257
258     rc =
259 #ifndef DISABLE_TLS
260         tls_out.active.sock == fd ? tls_write(tls_out.active.tls_ctx, block, len, more) :
261 #endif
262 #ifdef MSG_MORE
263         more && !(tctx->options & topt_not_socket)
264           ? send(fd, block, len, MSG_MORE) :
265 #endif
266         write(fd, block, len);
267
268     save_errno = errno;
269     local_timeout = ALARM_CLR(0);
270     if (sigalrm_seen)
271       {
272       errno = ETIMEDOUT;
273       return FALSE;
274       }
275     }
276
277   /* Hopefully, the most common case is success, so test that first. */
278
279   if (rc == len) { transport_count += len; return TRUE; }
280
281   /* A non-negative return code is an incomplete write. Try again for the rest
282   of the block. If we have exactly hit the timeout, give up. */
283
284   if (rc >= 0)
285     {
286     len -= rc;
287     block += rc;
288     transport_count += rc;
289     DEBUG(D_transport) debug_printf("write incomplete (%d)\n", rc);
290     goto CHECK_TIMEOUT;   /* A few lines below */
291     }
292
293   /* A negative return code with an EINTR error is another form of
294   incomplete write, zero bytes having been written */
295
296   if (save_errno == EINTR)
297     {
298     DEBUG(D_transport)
299       debug_printf("write interrupted before anything written\n");
300     goto CHECK_TIMEOUT;   /* A few lines below */
301     }
302
303   /* A response of EAGAIN from write() is likely only in the case of writing
304   to a FIFO that is not swallowing the data as fast as Exim is writing it. */
305
306   if (save_errno == EAGAIN)
307     {
308     DEBUG(D_transport)
309       debug_printf("write temporarily locked out, waiting 1 sec\n");
310     sleep(1);
311
312     /* Before continuing to try another write, check that we haven't run out of
313     time. */
314
315     CHECK_TIMEOUT:
316     if (transport_write_timeout > 0 && local_timeout <= 0)
317       {
318       errno = ETIMEDOUT;
319       return FALSE;
320       }
321     continue;
322     }
323
324   /* Otherwise there's been an error */
325
326   DEBUG(D_transport) debug_printf("writing error %d: %s\n", save_errno,
327     strerror(save_errno));
328   errno = save_errno;
329   return FALSE;
330   }
331
332 /* We've tried and tried and tried but still failed */
333
334 errno = ERRNO_WRITEINCOMPLETE;
335 return FALSE;
336 }
337
338
339 BOOL
340 transport_write_block(transport_ctx * tctx, uschar *block, int len, BOOL more)
341 {
342 if (!(tctx->options & topt_output_string))
343   return transport_write_block_fd(tctx, block, len, more);
344
345 /* Write to expanding-string.  NOTE: not NUL-terminated */
346
347 if (!tctx->u.msg)
348   tctx->u.msg = string_get(1024);
349
350 tctx->u.msg = string_catn(tctx->u.msg, block, len);
351 return TRUE;
352 }
353
354
355
356
357 /*************************************************
358 *             Write formatted string             *
359 *************************************************/
360
361 /* This is called by various transports. It is a convenience function.
362
363 Arguments:
364   fd          file descriptor
365   format      string format
366   ...         arguments for format
367
368 Returns:      the yield of transport_write_block()
369 */
370
371 BOOL
372 transport_write_string(int fd, const char *format, ...)
373 {
374 transport_ctx tctx = {{0}};
375 gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
376 va_list ap;
377
378 /* Use taint-unchecked routines for writing into big_buffer, trusting
379 that the result will never be expanded. */
380
381 va_start(ap, format);
382 if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, format, ap))
383   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong formatted string in transport");
384 va_end(ap);
385 tctx.u.fd = fd;
386 return transport_write_block(&tctx, gs.s, gs.ptr, FALSE);
387 }
388
389
390
391
392 void
393 transport_write_reset(int options)
394 {
395 if (!(options & topt_continuation)) chunk_ptr = deliver_out_buffer;
396 nl_partial_match = -1;
397 nl_check_length = nl_escape_length = 0;
398 }
399
400
401
402 /*************************************************
403 *              Write character chunk             *
404 *************************************************/
405
406 /* Subroutine used by transport_write_message() to scan character chunks for
407 newlines and act appropriately. The object is to minimise the number of writes.
408 The output byte stream is buffered up in deliver_out_buffer, which is written
409 only when it gets full, thus minimizing write operations and TCP packets.
410
411 Static data is used to handle the case when the last character of the previous
412 chunk was NL, or matched part of the data that has to be escaped.
413
414 Arguments:
415   tctx       transport context - processing to be done during output,
416                 and file descriptor to write to
417   chunk      pointer to data to write
418   len        length of data to write
419
420 In addition, the static nl_xxx variables must be set as required.
421
422 Returns:     TRUE on success, FALSE on failure (with errno preserved)
423 */
424
425 BOOL
426 write_chunk(transport_ctx * tctx, uschar *chunk, int len)
427 {
428 uschar *start = chunk;
429 uschar *end = chunk + len;
430 int mlen = DELIVER_OUT_BUFFER_SIZE - nl_escape_length - 2;
431
432 /* The assumption is made that the check string will never stretch over move
433 than one chunk since the only time there are partial matches is when copying
434 the body in large buffers. There is always enough room in the buffer for an
435 escape string, since the loop below ensures this for each character it
436 processes, and it won't have stuck in the escape string if it left a partial
437 match. */
438
439 if (nl_partial_match >= 0)
440   {
441   if (nl_check_length > 0 && len >= nl_check_length &&
442       Ustrncmp(start, nl_check + nl_partial_match,
443         nl_check_length - nl_partial_match) == 0)
444     {
445     Ustrncpy(chunk_ptr, nl_escape, nl_escape_length);
446     chunk_ptr += nl_escape_length;
447     start += nl_check_length - nl_partial_match;
448     }
449
450   /* The partial match was a false one. Insert the characters carried over
451   from the previous chunk. */
452
453   else if (nl_partial_match > 0)
454     {
455     Ustrncpy(chunk_ptr, nl_check, nl_partial_match);
456     chunk_ptr += nl_partial_match;
457     }
458
459   nl_partial_match = -1;
460   }
461
462 /* Now process the characters in the chunk. Whenever we hit a newline we check
463 for possible escaping. The code for the non-NL route should be as fast as
464 possible. */
465
466 for (uschar * ptr = start; ptr < end; ptr++)
467   {
468   int ch, len;
469
470   /* Flush the buffer if it has reached the threshold - we want to leave enough
471   room for the next uschar, plus a possible extra CR for an LF, plus the escape
472   string. */
473
474   if ((len = chunk_ptr - deliver_out_buffer) > mlen)
475     {
476     DEBUG(D_transport) debug_printf("flushing headers buffer\n");
477
478     /* If CHUNKING, prefix with BDAT (size) NON-LAST.  Also, reap responses
479     from previous SMTP commands. */
480
481     if (tctx->options & topt_use_bdat  &&  tctx->chunk_cb)
482       {
483       if (  tctx->chunk_cb(tctx, (unsigned)len, 0) != OK
484          || !transport_write_block(tctx, deliver_out_buffer, len, FALSE)
485          || tctx->chunk_cb(tctx, 0, tc_reap_prev) != OK
486          )
487         return FALSE;
488       }
489     else
490       if (!transport_write_block(tctx, deliver_out_buffer, len, FALSE))
491         return FALSE;
492     chunk_ptr = deliver_out_buffer;
493     }
494
495   /* Remove CR before NL if required */
496
497   if (  *ptr == '\r' && ptr[1] == '\n'
498      && !(tctx->options & topt_use_crlf)
499      && f.spool_file_wireformat
500      )
501     ptr++;
502
503   if ((ch = *ptr) == '\n')
504     {
505     int left = end - ptr - 1;  /* count of chars left after NL */
506
507     /* Insert CR before NL if required */
508
509     if (tctx->options & topt_use_crlf && !f.spool_file_wireformat)
510       *chunk_ptr++ = '\r';
511     *chunk_ptr++ = '\n';
512     transport_newlines++;
513
514     /* The check_string test (formerly "from hack") replaces the specific
515     string at the start of a line with an escape string (e.g. "From " becomes
516     ">From " or "." becomes "..". It is a case-sensitive test. The length
517     check above ensures there is always enough room to insert this string. */
518
519     if (nl_check_length > 0)
520       {
521       if (left >= nl_check_length &&
522           Ustrncmp(ptr+1, nl_check, nl_check_length) == 0)
523         {
524         Ustrncpy(chunk_ptr, nl_escape, nl_escape_length);
525         chunk_ptr += nl_escape_length;
526         ptr += nl_check_length;
527         }
528
529       /* Handle the case when there isn't enough left to match the whole
530       check string, but there may be a partial match. We remember how many
531       characters matched, and finish processing this chunk. */
532
533       else if (left <= 0) nl_partial_match = 0;
534
535       else if (Ustrncmp(ptr+1, nl_check, left) == 0)
536         {
537         nl_partial_match = left;
538         ptr = end;
539         }
540       }
541     }
542
543   /* Not a NL character */
544
545   else *chunk_ptr++ = ch;
546   }
547
548 return TRUE;
549 }
550
551
552
553
554 /*************************************************
555 *        Generate address for RCPT TO            *
556 *************************************************/
557
558 /* This function puts together an address for RCPT to, using the caseful
559 version of the local part and the caseful version of the domain. If there is no
560 prefix or suffix, or if affixes are to be retained, we can just use the
561 original address. Otherwise, if there is a prefix but no suffix we can use a
562 pointer into the original address. If there is a suffix, however, we have to
563 build a new string.
564
565 Arguments:
566   addr              the address item
567   include_affixes   TRUE if affixes are to be included
568
569 Returns:            a string
570 */
571
572 uschar *
573 transport_rcpt_address(address_item *addr, BOOL include_affixes)
574 {
575 uschar *at;
576 int plen, slen;
577
578 if (include_affixes)
579   {
580   setflag(addr, af_include_affixes);  /* Affects logged => line */
581   return addr->address;
582   }
583
584 if (addr->suffix == NULL)
585   {
586   if (addr->prefix == NULL) return addr->address;
587   return addr->address + Ustrlen(addr->prefix);
588   }
589
590 at = Ustrrchr(addr->address, '@');
591 plen = (addr->prefix == NULL)? 0 : Ustrlen(addr->prefix);
592 slen = Ustrlen(addr->suffix);
593
594 return string_sprintf("%.*s@%s", (int)(at - addr->address - plen - slen),
595    addr->address + plen, at + 1);
596 }
597
598
599 /*************************************************
600 *  Output Envelope-To: address & scan duplicates *
601 *************************************************/
602
603 /* This function is called from internal_transport_write_message() below, when
604 generating an Envelope-To: header line. It checks for duplicates of the given
605 address and its ancestors. When one is found, this function calls itself
606 recursively, to output the envelope address of the duplicate.
607
608 We want to avoid duplication in the list, which can arise for example when
609 A->B,C and then both B and C alias to D. This can also happen when there are
610 unseen drivers in use. So a list of addresses that have been output is kept in
611 the plist variable.
612
613 It is also possible to have loops in the address ancestry/duplication graph,
614 for example if there are two top level addresses A and B and we have A->B,C and
615 B->A. To break the loop, we use a list of processed addresses in the dlist
616 variable.
617
618 After handling duplication, this function outputs the progenitor of the given
619 address.
620
621 Arguments:
622   p         the address we are interested in
623   pplist    address of anchor of the list of addresses not to output
624   pdlist    address of anchor of the list of processed addresses
625   first     TRUE if this is the first address; set it FALSE afterwards
626   tctx      transport context - processing to be done during output
627               and the file descriptor to write to
628
629 Returns:    FALSE if writing failed
630 */
631
632 static BOOL
633 write_env_to(address_item *p, struct aci **pplist, struct aci **pdlist,
634   BOOL *first, transport_ctx * tctx)
635 {
636 address_item *pp;
637 struct aci *ppp;
638
639 /* Do nothing if we have already handled this address. If not, remember it
640 so that we don't handle it again. */
641
642 for (ppp = *pdlist; ppp; ppp = ppp->next) if (p == ppp->ptr) return TRUE;
643
644 ppp = store_get(sizeof(struct aci), FALSE);
645 ppp->next = *pdlist;
646 *pdlist = ppp;
647 ppp->ptr = p;
648
649 /* Now scan up the ancestry, checking for duplicates at each generation. */
650
651 for (pp = p;; pp = pp->parent)
652   {
653   address_item *dup;
654   for (dup = addr_duplicate; dup; dup = dup->next)
655     if (dup->dupof == pp)   /* a dup of our address */
656       if (!write_env_to(dup, pplist, pdlist, first, tctx))
657         return FALSE;
658   if (!pp->parent) break;
659   }
660
661 /* Check to see if we have already output the progenitor. */
662
663 for (ppp = *pplist; ppp; ppp = ppp->next) if (pp == ppp->ptr) break;
664 if (ppp) return TRUE;
665
666 /* Remember what we have output, and output it. */
667
668 ppp = store_get(sizeof(struct aci), FALSE);
669 ppp->next = *pplist;
670 *pplist = ppp;
671 ppp->ptr = pp;
672
673 if (!*first && !write_chunk(tctx, US",\n ", 3)) return FALSE;
674 *first = FALSE;
675 return write_chunk(tctx, pp->address, Ustrlen(pp->address));
676 }
677
678
679
680
681 /* Add/remove/rewrite headers, and send them plus the empty-line separator.
682
683 Globals:
684   header_list
685
686 Arguments:
687   addr                  (chain of) addresses (for extra headers), or NULL;
688                           only the first address is used
689   tctx                  transport context
690   sendfn                function for output (transport or verify)
691
692 Returns:                TRUE on success; FALSE on failure.
693 */
694 BOOL
695 transport_headers_send(transport_ctx * tctx,
696   BOOL (*sendfn)(transport_ctx * tctx, uschar * s, int len))
697 {
698 const uschar *list;
699 transport_instance * tblock = tctx ? tctx->tblock : NULL;
700 address_item * addr = tctx ? tctx->addr : NULL;
701
702 /* Then the message's headers. Don't write any that are flagged as "old";
703 that means they were rewritten, or are a record of envelope rewriting, or
704 were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
705 match any entries therein.  It is a colon-sep list; expand the items
706 separately and squash any empty ones.
707 Then check addr->prop.remove_headers too, provided that addr is not NULL. */
708
709 for (header_line * h = header_list; h; h = h->next) if (h->type != htype_old)
710   {
711   BOOL include_header = TRUE;
712
713   list = tblock ? tblock->remove_headers : NULL;
714   for (int i = 0; i < 2; i++)    /* For remove_headers && addr->prop.remove_headers */
715     {
716     if (list)
717       {
718       int sep = ':';         /* This is specified as a colon-separated list */
719       uschar *s, *ss;
720       while ((s = string_nextinlist(&list, &sep, NULL, 0)))
721         {
722         int len;
723
724         if (i == 0)
725           if (!(s = expand_string(s)) && !f.expand_string_forcedfail)
726             {
727             errno = ERRNO_CHHEADER_FAIL;
728             return FALSE;
729             }
730         len = s ? Ustrlen(s) : 0;
731         if (strncmpic(h->text, s, len) != 0) continue;
732         ss = h->text + len;
733         while (*ss == ' ' || *ss == '\t') ss++;
734         if (*ss == ':') break;
735         }
736       if (s) { include_header = FALSE; break; }
737       }
738     if (addr) list = addr->prop.remove_headers;
739     }
740
741   /* If this header is to be output, try to rewrite it if there are rewriting
742   rules. */
743
744   if (include_header)
745     {
746     if (tblock && tblock->rewrite_rules)
747       {
748       rmark reset_point = store_mark();
749       header_line *hh;
750
751       if ((hh = rewrite_header(h, NULL, NULL, tblock->rewrite_rules,
752                   tblock->rewrite_existflags, FALSE)))
753         {
754         if (!sendfn(tctx, hh->text, hh->slen)) return FALSE;
755         store_reset(reset_point);
756         continue;     /* With the next header line */
757         }
758       }
759
760     /* Either no rewriting rules, or it didn't get rewritten */
761
762     if (!sendfn(tctx, h->text, h->slen)) return FALSE;
763     }
764
765   /* Header removed */
766
767   else
768     DEBUG(D_transport) debug_printf("removed header line:\n%s---\n", h->text);
769   }
770
771 /* Add on any address-specific headers. If there are multiple addresses,
772 they will all have the same headers in order to be batched. The headers
773 are chained in reverse order of adding (so several addresses from the
774 same alias might share some of them) but we want to output them in the
775 opposite order. This is a bit tedious, but there shouldn't be very many
776 of them. We just walk the list twice, reversing the pointers each time,
777 but on the second time, write out the items.
778
779 Headers added to an address by a router are guaranteed to end with a newline.
780 */
781
782 if (addr)
783   {
784   header_line *hprev = addr->prop.extra_headers;
785   header_line *hnext, * h;
786   for (int i = 0; i < 2; i++)
787     for (h = hprev, hprev = NULL; h; h = hnext)
788       {
789       hnext = h->next;
790       h->next = hprev;
791       hprev = h;
792       if (i == 1)
793         {
794         if (!sendfn(tctx, h->text, h->slen)) return FALSE;
795         DEBUG(D_transport)
796           debug_printf("added header line(s):\n%s---\n", h->text);
797         }
798       }
799   }
800
801 /* If a string containing additional headers exists it is a newline-sep
802 list.  Expand each item and write out the result.  This is done last so that
803 if it (deliberately or accidentally) isn't in header format, it won't mess
804 up any other headers. An empty string or a forced expansion failure are
805 noops. An added header string from a transport may not end with a newline;
806 add one if it does not. */
807
808 if (tblock && (list = CUS tblock->add_headers))
809   {
810   int sep = '\n';
811   uschar * s;
812
813   while ((s = string_nextinlist(&list, &sep, NULL, 0)))
814     if ((s = expand_string(s)))
815       {
816       int len = Ustrlen(s);
817       if (len > 0)
818         {
819         if (!sendfn(tctx, s, len)) return FALSE;
820         if (s[len-1] != '\n' && !sendfn(tctx, US"\n", 1))
821           return FALSE;
822         DEBUG(D_transport)
823           {
824           debug_printf("added header line:\n%s", s);
825           if (s[len-1] != '\n') debug_printf("\n");
826           debug_printf("---\n");
827           }
828         }
829       }
830     else if (!f.expand_string_forcedfail)
831       { errno = ERRNO_CHHEADER_FAIL; return FALSE; }
832   }
833
834 /* Separate headers from body with a blank line */
835
836 return sendfn(tctx, US"\n", 1);
837 }
838
839
840 /*************************************************
841 *                Write the message               *
842 *************************************************/
843
844 /* This function writes the message to the given file descriptor. The headers
845 are in the in-store data structure, and the rest of the message is in the open
846 file descriptor deliver_datafile. Make sure we start it at the beginning.
847
848 . If add_return_path is TRUE, a "return-path:" header is added to the message,
849   containing the envelope sender's address.
850
851 . If add_envelope_to is TRUE, a "envelope-to:" header is added to the message,
852   giving the top-level envelope address that caused this delivery to happen.
853
854 . If add_delivery_date is TRUE, a "delivery-date:" header is added to the
855   message. It gives the time and date that delivery took place.
856
857 . If check_string is not null, the start of each line is checked for that
858   string. If it is found, it is replaced by escape_string. This used to be
859   the "from hack" for files, and "smtp_dots" for escaping SMTP dots.
860
861 . If use_crlf is true, newlines are turned into CRLF (SMTP output).
862
863 The yield is TRUE if all went well, and FALSE if not. Exit *immediately* after
864 any writing or reading error, leaving the code in errno intact. Error exits
865 can include timeouts for certain transports, which are requested by setting
866 transport_write_timeout non-zero.
867
868 Arguments:
869   tctx
870     (fd, msg)           Either and fd, to write the message to,
871                         or a string: if null write message to allocated space
872                         otherwire take content as headers.
873     addr                (chain of) addresses (for extra headers), or NULL;
874                           only the first address is used
875     tblock              optional transport instance block (NULL signifies NULL/0):
876       add_headers           a string containing one or more headers to add; it is
877                             expanded, and must be in correct RFC 822 format as
878                             it is transmitted verbatim; NULL => no additions,
879                             and so does empty string or forced expansion fail
880       remove_headers        a colon-separated list of headers to remove, or NULL
881       rewrite_rules         chain of header rewriting rules
882       rewrite_existflags    flags for the rewriting rules
883     options               bit-wise options:
884       add_return_path       if TRUE, add a "return-path" header
885       add_envelope_to       if TRUE, add a "envelope-to" header
886       add_delivery_date     if TRUE, add a "delivery-date" header
887       use_crlf              if TRUE, turn NL into CR LF
888       end_dot               if TRUE, send a terminating "." line at the end
889       no_headers            if TRUE, omit the headers
890       no_body               if TRUE, omit the body
891     check_string          a string to check for at the start of lines, or NULL
892     escape_string         a string to insert in front of any check string
893   size_limit              if > 0, this is a limit to the size of message written;
894                             it is used when returning messages to their senders,
895                             and is approximate rather than exact, owing to chunk
896                             buffering
897
898 Returns:                TRUE on success; FALSE (with errno) on failure.
899                         In addition, the global variable transport_count
900                         is incremented by the number of bytes written.
901 */
902
903 static BOOL
904 internal_transport_write_message(transport_ctx * tctx, int size_limit)
905 {
906 int len, size = 0;
907
908 /* Initialize pointer in output buffer. */
909
910 transport_write_reset(tctx->options);
911
912 /* Set up the data for start-of-line data checking and escaping */
913
914 if (tctx->check_string && tctx->escape_string)
915   {
916   nl_check = tctx->check_string;
917   nl_check_length = Ustrlen(nl_check);
918   nl_escape = tctx->escape_string;
919   nl_escape_length = Ustrlen(nl_escape);
920   }
921
922 /* Whether the escaping mechanism is applied to headers or not is controlled by
923 an option (set for SMTP, not otherwise). Negate the length if not wanted till
924 after the headers. */
925
926 if (!(tctx->options & topt_escape_headers))
927   nl_check_length = -nl_check_length;
928
929 /* Write the headers if required, including any that have to be added. If there
930 are header rewriting rules, apply them.  The datasource is not the -D spoolfile
931 so temporarily hide the global that adjusts for its format. */
932
933 if (!(tctx->options & topt_no_headers))
934   {
935   BOOL save_wireformat = f.spool_file_wireformat;
936   f.spool_file_wireformat = FALSE;
937
938   /* Add return-path: if requested. */
939
940   if (tctx->options & topt_add_return_path)
941     {
942     uschar buffer[ADDRESS_MAXLENGTH + 20];
943     int n = sprintf(CS buffer, "Return-path: <%.*s>\n", ADDRESS_MAXLENGTH,
944       return_path);
945     if (!write_chunk(tctx, buffer, n)) goto bad;
946     }
947
948   /* Add envelope-to: if requested */
949
950   if (tctx->options & topt_add_envelope_to)
951     {
952     BOOL first = TRUE;
953     struct aci *plist = NULL;
954     struct aci *dlist = NULL;
955     rmark reset_point = store_mark();
956
957     if (!write_chunk(tctx, US"Envelope-to: ", 13)) goto bad;
958
959     /* Pick up from all the addresses. The plist and dlist variables are
960     anchors for lists of addresses already handled; they have to be defined at
961     this level because write_env_to() calls itself recursively. */
962
963     for (address_item * p = tctx->addr; p; p = p->next)
964       if (!write_env_to(p, &plist, &dlist, &first, tctx))
965         goto bad;
966
967     /* Add a final newline and reset the store used for tracking duplicates */
968
969     if (!write_chunk(tctx, US"\n", 1)) goto bad;
970     store_reset(reset_point);
971     }
972
973   /* Add delivery-date: if requested. */
974
975   if (tctx->options & topt_add_delivery_date)
976     {
977     uschar * s = tod_stamp(tod_full);
978
979     if (  !write_chunk(tctx, US"Delivery-date: ", 15)
980        || !write_chunk(tctx, s, Ustrlen(s))
981        || !write_chunk(tctx, US"\n", 1)) goto bad;
982     }
983
984   /* Then the message's headers. Don't write any that are flagged as "old";
985   that means they were rewritten, or are a record of envelope rewriting, or
986   were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
987   match any entries therein. Then check addr->prop.remove_headers too, provided that
988   addr is not NULL. */
989
990   if (!transport_headers_send(tctx, &write_chunk))
991     {
992 bad:
993     f.spool_file_wireformat = save_wireformat;
994     return FALSE;
995     }
996
997   f.spool_file_wireformat = save_wireformat;
998   }
999
1000 /* When doing RFC3030 CHUNKING output, work out how much data would be in a
1001 last-BDAT, consisting of the current write_chunk() output buffer fill
1002 (optimally, all of the headers - but it does not matter if we already had to
1003 flush that buffer with non-last BDAT prependix) plus the amount of body data
1004 (as expanded for CRLF lines).  Then create and write BDAT(s), and ensure
1005 that further use of write_chunk() will not prepend BDATs.
1006 The first BDAT written will also first flush any outstanding MAIL and RCPT
1007 commands which were buffered thans to PIPELINING.
1008 Commands go out (using a send()) from a different buffer to data (using a
1009 write()).  They might not end up in the same TCP segment, which is
1010 suboptimal. */
1011
1012 if (tctx->options & topt_use_bdat)
1013   {
1014   off_t fsize;
1015   int hsize;
1016
1017   if ((hsize = chunk_ptr - deliver_out_buffer) < 0)
1018     hsize = 0;
1019   if (!(tctx->options & topt_no_body))
1020     {
1021     if ((fsize = lseek(deliver_datafile, 0, SEEK_END)) < 0) return FALSE;
1022     fsize -= SPOOL_DATA_START_OFFSET;
1023     if (size_limit > 0  &&  fsize > size_limit)
1024       fsize = size_limit;
1025     size = hsize + fsize;
1026     if (tctx->options & topt_use_crlf  &&  !f.spool_file_wireformat)
1027       size += body_linecount;   /* account for CRLF-expansion */
1028
1029     /* With topt_use_bdat we never do dot-stuffing; no need to
1030     account for any expansion due to that. */
1031     }
1032
1033   /* If the message is large, emit first a non-LAST chunk with just the
1034   headers, and reap the command responses.  This lets us error out early
1035   on RCPT rejects rather than sending megabytes of data.  Include headers
1036   on the assumption they are cheap enough and some clever implementations
1037   might errorcheck them too, on-the-fly, and reject that chunk. */
1038
1039   if (size > DELIVER_OUT_BUFFER_SIZE && hsize > 0)
1040     {
1041     DEBUG(D_transport)
1042       debug_printf("sending small initial BDAT; hsize=%d\n", hsize);
1043     if (  tctx->chunk_cb(tctx, hsize, 0) != OK
1044        || !transport_write_block(tctx, deliver_out_buffer, hsize, FALSE)
1045        || tctx->chunk_cb(tctx, 0, tc_reap_prev) != OK
1046        )
1047       return FALSE;
1048     chunk_ptr = deliver_out_buffer;
1049     size -= hsize;
1050     }
1051
1052   /* Emit a LAST datachunk command, and unmark the context for further
1053   BDAT commands. */
1054
1055   if (tctx->chunk_cb(tctx, size, tc_chunk_last) != OK)
1056     return FALSE;
1057   tctx->options &= ~topt_use_bdat;
1058   }
1059
1060 /* If the body is required, ensure that the data for check strings (formerly
1061 the "from hack") is enabled by negating the length if necessary. (It will be
1062 negative in cases where it isn't to apply to the headers). Then ensure the body
1063 is positioned at the start of its file (following the message id), then write
1064 it, applying the size limit if required. */
1065
1066 /* If we have a wireformat -D file (CRNL lines, non-dotstuffed, no ending dot)
1067 and we want to send a body without dotstuffing or ending-dot, in-clear,
1068 then we can just dump it using sendfile.
1069 This should get used for CHUNKING output and also for writing the -K file for
1070 dkim signing,  when we had CHUNKING input.  */
1071
1072 #ifdef OS_SENDFILE
1073 if (  f.spool_file_wireformat
1074    && !(tctx->options & (topt_no_body | topt_end_dot))
1075    && !nl_check_length
1076    && tls_out.active.sock != tctx->u.fd
1077    )
1078   {
1079   ssize_t copied = 0;
1080   off_t offset = SPOOL_DATA_START_OFFSET;
1081
1082   /* Write out any header data in the buffer */
1083
1084   if ((len = chunk_ptr - deliver_out_buffer) > 0)
1085     {
1086     if (!transport_write_block(tctx, deliver_out_buffer, len, TRUE))
1087       return FALSE;
1088     size -= len;
1089     }
1090
1091   DEBUG(D_transport) debug_printf("using sendfile for body\n");
1092
1093   while(size > 0)
1094     {
1095     if ((copied = os_sendfile(tctx->u.fd, deliver_datafile, &offset, size)) <= 0) break;
1096     size -= copied;
1097     }
1098   return copied >= 0;
1099   }
1100 #else
1101 DEBUG(D_transport) debug_printf("cannot use sendfile for body: no support\n");
1102 #endif
1103
1104 DEBUG(D_transport)
1105   if (!(tctx->options & topt_no_body))
1106     debug_printf("cannot use sendfile for body: %s\n",
1107       !f.spool_file_wireformat ? "spoolfile not wireformat"
1108       : tctx->options & topt_end_dot ? "terminating dot wanted"
1109       : nl_check_length ? "dot- or From-stuffing wanted"
1110       : "TLS output wanted");
1111
1112 if (!(tctx->options & topt_no_body))
1113   {
1114   unsigned long size = size_limit > 0 ? size_limit : ULONG_MAX;
1115
1116   nl_check_length = abs(nl_check_length);
1117   nl_partial_match = 0;
1118   if (lseek(deliver_datafile, SPOOL_DATA_START_OFFSET, SEEK_SET) < 0)
1119     return FALSE;
1120   while (  (len = MIN(DELIVER_IN_BUFFER_SIZE, size)) > 0
1121         && (len = read(deliver_datafile, deliver_in_buffer, len)) > 0)
1122     {
1123     if (!write_chunk(tctx, deliver_in_buffer, len))
1124       return FALSE;
1125     size -= len;
1126     }
1127
1128   /* A read error on the body will have left len == -1 and errno set. */
1129
1130   if (len != 0) return FALSE;
1131   }
1132
1133 /* Finished with the check string, and spool-format consideration */
1134
1135 nl_check_length = nl_escape_length = 0;
1136 f.spool_file_wireformat = FALSE;
1137
1138 /* If requested, add a terminating "." line (SMTP output). */
1139
1140 if (tctx->options & topt_end_dot && !write_chunk(tctx, US".\n", 2))
1141   return FALSE;
1142
1143 /* Write out any remaining data in the buffer before returning. */
1144
1145 return (len = chunk_ptr - deliver_out_buffer) <= 0 ||
1146   transport_write_block(tctx, deliver_out_buffer, len, FALSE);
1147 }
1148
1149
1150
1151
1152 /*************************************************
1153 *    External interface to write the message     *
1154 *************************************************/
1155
1156 /* If there is no filtering required, call the internal function above to do
1157 the real work, passing over all the arguments from this function. Otherwise,
1158 set up a filtering process, fork another process to call the internal function
1159 to write to the filter, and in this process just suck from the filter and write
1160 down the fd in the transport context. At the end, tidy up the pipes and the
1161 processes.
1162
1163 Arguments:     as for internal_transport_write_message() above
1164
1165 Returns:       TRUE on success; FALSE (with errno) for any failure
1166                transport_count is incremented by the number of bytes written
1167 */
1168
1169 BOOL
1170 transport_write_message(transport_ctx * tctx, int size_limit)
1171 {
1172 BOOL last_filter_was_NL = TRUE;
1173 BOOL save_spool_file_wireformat = f.spool_file_wireformat;
1174 int rc, len, yield, fd_read, fd_write, save_errno;
1175 int pfd[2] = {-1, -1};
1176 pid_t filter_pid, write_pid;
1177
1178 f.transport_filter_timed_out = FALSE;
1179
1180 /* If there is no filter command set up, call the internal function that does
1181 the actual work, passing it the incoming fd, and return its result. */
1182
1183 if (  !transport_filter_argv
1184    || !*transport_filter_argv
1185    || !**transport_filter_argv
1186    )
1187   return internal_transport_write_message(tctx, size_limit);
1188
1189 /* Otherwise the message must be written to a filter process and read back
1190 before being written to the incoming fd. First set up the special processing to
1191 be done during the copying. */
1192
1193 nl_partial_match = -1;
1194
1195 if (tctx->check_string && tctx->escape_string)
1196   {
1197   nl_check = tctx->check_string;
1198   nl_check_length = Ustrlen(nl_check);
1199   nl_escape = tctx->escape_string;
1200   nl_escape_length = Ustrlen(nl_escape);
1201   }
1202 else nl_check_length = nl_escape_length = 0;
1203
1204 /* Start up a subprocess to run the command. Ensure that our main fd will
1205 be closed when the subprocess execs, but remove the flag afterwards.
1206 (Otherwise, if this is a TCP/IP socket, it can't get passed on to another
1207 process to deliver another message.) We get back stdin/stdout file descriptors.
1208 If the process creation failed, give an error return. */
1209
1210 fd_read = -1;
1211 fd_write = -1;
1212 save_errno = 0;
1213 yield = FALSE;
1214 write_pid = (pid_t)(-1);
1215
1216   {
1217   int bits = fcntl(tctx->u.fd, F_GETFD);
1218   (void)fcntl(tctx->u.fd, F_SETFD, bits | FD_CLOEXEC);
1219   filter_pid = child_open(USS transport_filter_argv, NULL, 077,
1220    &fd_write, &fd_read, FALSE);
1221   (void)fcntl(tctx->u.fd, F_SETFD, bits & ~FD_CLOEXEC);
1222   }
1223 if (filter_pid < 0) goto TIDY_UP;      /* errno set */
1224
1225 DEBUG(D_transport)
1226   debug_printf("process %d running as transport filter: fd_write=%d fd_read=%d\n",
1227     (int)filter_pid, fd_write, fd_read);
1228
1229 /* Fork subprocess to write the message to the filter, and return the result
1230 via a(nother) pipe. While writing to the filter, we do not do the CRLF,
1231 smtp dots, or check string processing. */
1232
1233 if (pipe(pfd) != 0) goto TIDY_UP;      /* errno set */
1234 if ((write_pid = fork()) == 0)
1235   {
1236   BOOL rc;
1237   (void)close(fd_read);
1238   (void)close(pfd[pipe_read]);
1239   nl_check_length = nl_escape_length = 0;
1240
1241   tctx->u.fd = fd_write;
1242   tctx->check_string = tctx->escape_string = NULL;
1243   tctx->options &= ~(topt_use_crlf | topt_end_dot | topt_use_bdat);
1244
1245   rc = internal_transport_write_message(tctx, size_limit);
1246
1247   save_errno = errno;
1248   if (  write(pfd[pipe_write], (void *)&rc, sizeof(BOOL))
1249         != sizeof(BOOL)
1250      || write(pfd[pipe_write], (void *)&save_errno, sizeof(int))
1251         != sizeof(int)
1252      || write(pfd[pipe_write], (void *)&tctx->addr->more_errno, sizeof(int))
1253         != sizeof(int)
1254      || write(pfd[pipe_write], (void *)&tctx->addr->delivery_usec, sizeof(int))
1255         != sizeof(int)
1256      )
1257     rc = FALSE; /* compiler quietening */
1258   exim_underbar_exit(0);
1259   }
1260 save_errno = errno;
1261
1262 /* Parent process: close our copy of the writing subprocess' pipes. */
1263
1264 (void)close(pfd[pipe_write]);
1265 (void)close(fd_write);
1266 fd_write = -1;
1267
1268 /* Writing process creation failed */
1269
1270 if (write_pid < 0)
1271   {
1272   errno = save_errno;    /* restore */
1273   goto TIDY_UP;
1274   }
1275
1276 /* When testing, let the subprocess get going */
1277
1278 if (f.running_in_test_harness) millisleep(250);
1279
1280 DEBUG(D_transport)
1281   debug_printf("process %d writing to transport filter\n", (int)write_pid);
1282
1283 /* Copy the message from the filter to the output fd. A read error leaves len
1284 == -1 and errno set. We need to apply a timeout to the read, to cope with
1285 the case when the filter gets stuck, but it can be quite a long one. The
1286 default is 5m, but this is now configurable. */
1287
1288 DEBUG(D_transport) debug_printf("copying from the filter\n");
1289
1290 /* Copy the output of the filter, remembering if the last character was NL. If
1291 no data is returned, that counts as "ended with NL" (default setting of the
1292 variable is TRUE).  The output should always be unix-format as we converted
1293 any wireformat source on writing input to the filter. */
1294
1295 f.spool_file_wireformat = FALSE;
1296 chunk_ptr = deliver_out_buffer;
1297
1298 for (;;)
1299   {
1300   sigalrm_seen = FALSE;
1301   ALARM(transport_filter_timeout);
1302   len = read(fd_read, deliver_in_buffer, DELIVER_IN_BUFFER_SIZE);
1303   ALARM_CLR(0);
1304   if (sigalrm_seen)
1305     {
1306     errno = ETIMEDOUT;
1307     f.transport_filter_timed_out = TRUE;
1308     goto TIDY_UP;
1309     }
1310
1311   /* If the read was successful, write the block down the original fd,
1312   remembering whether it ends in \n or not. */
1313
1314   if (len > 0)
1315     {
1316     if (!write_chunk(tctx, deliver_in_buffer, len)) goto TIDY_UP;
1317     last_filter_was_NL = (deliver_in_buffer[len-1] == '\n');
1318     }
1319
1320   /* Otherwise, break the loop. If we have hit EOF, set yield = TRUE. */
1321
1322   else
1323     {
1324     if (len == 0) yield = TRUE;
1325     break;
1326     }
1327   }
1328
1329 /* Tidying up code. If yield = FALSE there has been an error and errno is set
1330 to something. Ensure the pipes are all closed and the processes are removed. If
1331 there has been an error, kill the processes before waiting for them, just to be
1332 sure. Also apply a paranoia timeout. */
1333
1334 TIDY_UP:
1335 f.spool_file_wireformat = save_spool_file_wireformat;
1336 save_errno = errno;
1337
1338 (void)close(fd_read);
1339 if (fd_write > 0) (void)close(fd_write);
1340
1341 if (!yield)
1342   {
1343   if (filter_pid > 0) kill(filter_pid, SIGKILL);
1344   if (write_pid > 0)  kill(write_pid, SIGKILL);
1345   }
1346
1347 /* Wait for the filter process to complete. */
1348
1349 DEBUG(D_transport) debug_printf("waiting for filter process\n");
1350 if (filter_pid > 0 && (rc = child_close(filter_pid, 30)) != 0 && yield)
1351   {
1352   yield = FALSE;
1353   save_errno = ERRNO_FILTER_FAIL;
1354   tctx->addr->more_errno = rc;
1355   DEBUG(D_transport) debug_printf("filter process returned %d\n", rc);
1356   }
1357
1358 /* Wait for the writing process to complete. If it ends successfully,
1359 read the results from its pipe, provided we haven't already had a filter
1360 process failure. */
1361
1362 DEBUG(D_transport) debug_printf("waiting for writing process\n");
1363 if (write_pid > 0)
1364   {
1365   rc = child_close(write_pid, 30);
1366   if (yield)
1367     if (rc == 0)
1368       {
1369       BOOL ok;
1370       if (read(pfd[pipe_read], (void *)&ok, sizeof(BOOL)) != sizeof(BOOL))
1371         {
1372         DEBUG(D_transport)
1373           debug_printf("pipe read from writing process: %s\n", strerror(errno));
1374         save_errno = ERRNO_FILTER_FAIL;
1375         yield = FALSE;
1376         }
1377       else if (!ok)
1378         {
1379         int dummy = read(pfd[pipe_read], (void *)&save_errno, sizeof(int));
1380         dummy = read(pfd[pipe_read], (void *)&tctx->addr->more_errno, sizeof(int));
1381         dummy = read(pfd[pipe_read], (void *)&tctx->addr->delivery_usec, sizeof(int));
1382         dummy = dummy;          /* compiler quietening */
1383         yield = FALSE;
1384         }
1385       }
1386     else
1387       {
1388       yield = FALSE;
1389       save_errno = ERRNO_FILTER_FAIL;
1390       tctx->addr->more_errno = rc;
1391       DEBUG(D_transport) debug_printf("writing process returned %d\n", rc);
1392       }
1393   }
1394 (void)close(pfd[pipe_read]);
1395
1396 /* If there have been no problems we can now add the terminating "." if this is
1397 SMTP output, turning off escaping beforehand. If the last character from the
1398 filter was not NL, insert a NL to make the SMTP protocol work. */
1399
1400 if (yield)
1401   {
1402   nl_check_length = nl_escape_length = 0;
1403   f.spool_file_wireformat = FALSE;
1404   if (  tctx->options & topt_end_dot
1405      && ( last_filter_was_NL
1406         ? !write_chunk(tctx, US".\n", 2)
1407         : !write_chunk(tctx, US"\n.\n", 3)
1408      )  )
1409     yield = FALSE;
1410
1411   /* Write out any remaining data in the buffer. */
1412
1413   else
1414     yield = (len = chunk_ptr - deliver_out_buffer) <= 0
1415           || transport_write_block(tctx, deliver_out_buffer, len, FALSE);
1416   }
1417 else
1418   errno = save_errno;      /* From some earlier error */
1419
1420 DEBUG(D_transport)
1421   {
1422   debug_printf("end of filtering transport writing: yield=%d\n", yield);
1423   if (!yield)
1424     debug_printf("errno=%d more_errno=%d\n", errno, tctx->addr->more_errno);
1425   }
1426
1427 return yield;
1428 }
1429
1430
1431
1432
1433
1434 /*************************************************
1435 *            Update waiting database             *
1436 *************************************************/
1437
1438 /* This is called when an address is deferred by remote transports that are
1439 capable of sending more than one message over one connection. A database is
1440 maintained for each transport, keeping track of which messages are waiting for
1441 which hosts. The transport can then consult this when eventually a successful
1442 delivery happens, and if it finds that another message is waiting for the same
1443 host, it can fire up a new process to deal with it using the same connection.
1444
1445 The database records are keyed by host name. They can get full if there are
1446 lots of messages waiting, and so there is a continuation mechanism for them.
1447
1448 Each record contains a list of message ids, packed end to end without any
1449 zeros. Each one is MESSAGE_ID_LENGTH bytes long. The count field says how many
1450 in this record, and the sequence field says if there are any other records for
1451 this host. If the sequence field is 0, there are none. If it is 1, then another
1452 record with the name <hostname>:0 exists; if it is 2, then two other records
1453 with sequence numbers 0 and 1 exist, and so on.
1454
1455 Currently, an exhaustive search of all continuation records has to be done to
1456 determine whether to add a message id to a given record. This shouldn't be
1457 too bad except in extreme cases. I can't figure out a *simple* way of doing
1458 better.
1459
1460 Old records should eventually get swept up by the exim_tidydb utility.
1461
1462 Arguments:
1463   hostlist  list of hosts that this message could be sent to
1464   tpname    name of the transport
1465
1466 Returns:    nothing
1467 */
1468
1469 void
1470 transport_update_waiting(host_item *hostlist, uschar *tpname)
1471 {
1472 const uschar *prevname = US"";
1473 open_db dbblock;
1474 open_db *dbm_file;
1475
1476 DEBUG(D_transport) debug_printf("updating wait-%s database\n", tpname);
1477
1478 /* Open the database for this transport */
1479
1480 if (!(dbm_file = dbfn_open(string_sprintf("wait-%.200s", tpname),
1481                       O_RDWR, &dbblock, TRUE, TRUE)))
1482   return;
1483
1484 /* Scan the list of hosts for which this message is waiting, and ensure
1485 that the message id is in each host record. */
1486
1487 for (host_item * host = hostlist; host; host = host->next)
1488   {
1489   BOOL already = FALSE;
1490   dbdata_wait *host_record;
1491   int host_length;
1492   uschar buffer[256];
1493
1494   /* Skip if this is the same host as we just processed; otherwise remember
1495   the name for next time. */
1496
1497   if (Ustrcmp(prevname, host->name) == 0) continue;
1498   prevname = host->name;
1499
1500   /* Look up the host record; if there isn't one, make an empty one. */
1501
1502   if (!(host_record = dbfn_read(dbm_file, host->name)))
1503     {
1504     host_record = store_get(sizeof(dbdata_wait) + MESSAGE_ID_LENGTH, FALSE);
1505     host_record->count = host_record->sequence = 0;
1506     }
1507
1508   /* Compute the current length */
1509
1510   host_length = host_record->count * MESSAGE_ID_LENGTH;
1511
1512   /* Search the record to see if the current message is already in it. */
1513
1514   for (uschar * s = host_record->text; s < host_record->text + host_length;
1515        s += MESSAGE_ID_LENGTH)
1516     if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1517       { already = TRUE; break; }
1518
1519   /* If we haven't found this message in the main record, search any
1520   continuation records that exist. */
1521
1522   for (int i = host_record->sequence - 1; i >= 0 && !already; i--)
1523     {
1524     dbdata_wait *cont;
1525     sprintf(CS buffer, "%.200s:%d", host->name, i);
1526     if ((cont = dbfn_read(dbm_file, buffer)))
1527       {
1528       int clen = cont->count * MESSAGE_ID_LENGTH;
1529       for (uschar * s = cont->text; s < cont->text + clen; s += MESSAGE_ID_LENGTH)
1530         if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1531           { already = TRUE; break; }
1532       }
1533     }
1534
1535   /* If this message is already in a record, no need to update. */
1536
1537   if (already)
1538     {
1539     DEBUG(D_transport) debug_printf("already listed for %s\n", host->name);
1540     continue;
1541     }
1542
1543
1544   /* If this record is full, write it out with a new name constructed
1545   from the sequence number, increase the sequence number, and empty
1546   the record. */
1547
1548   if (host_record->count >= WAIT_NAME_MAX)
1549     {
1550     sprintf(CS buffer, "%.200s:%d", host->name, host_record->sequence);
1551     dbfn_write(dbm_file, buffer, host_record, sizeof(dbdata_wait) + host_length);
1552     host_record->sequence++;
1553     host_record->count = 0;
1554     host_length = 0;
1555     }
1556
1557   /* If this record is not full, increase the size of the record to
1558   allow for one new message id. */
1559
1560   else
1561     {
1562     dbdata_wait *newr =
1563       store_get(sizeof(dbdata_wait) + host_length + MESSAGE_ID_LENGTH, FALSE);
1564     memcpy(newr, host_record, sizeof(dbdata_wait) + host_length);
1565     host_record = newr;
1566     }
1567
1568   /* Now add the new name on the end */
1569
1570   memcpy(host_record->text + host_length, message_id, MESSAGE_ID_LENGTH);
1571   host_record->count++;
1572   host_length += MESSAGE_ID_LENGTH;
1573
1574   /* Update the database */
1575
1576   dbfn_write(dbm_file, host->name, host_record, sizeof(dbdata_wait) + host_length);
1577   DEBUG(D_transport) debug_printf("added to list for %s\n", host->name);
1578   }
1579
1580 /* All now done */
1581
1582 dbfn_close(dbm_file);
1583 }
1584
1585
1586
1587
1588 /*************************************************
1589 *         Test for waiting messages              *
1590 *************************************************/
1591
1592 /* This function is called by a remote transport which uses the previous
1593 function to remember which messages are waiting for which remote hosts. It's
1594 called after a successful delivery and its job is to check whether there is
1595 another message waiting for the same host. However, it doesn't do this if the
1596 current continue sequence is greater than the maximum supplied as an argument,
1597 or greater than the global connection_max_messages, which, if set, overrides.
1598
1599 Arguments:
1600   transport_name     name of the transport
1601   hostname           name of the host
1602   local_message_max  maximum number of messages down one connection
1603                        as set by the caller transport
1604   new_message_id     set to the message id of a waiting message
1605   more               set TRUE if there are yet more messages waiting
1606   oicf_func          function to call to validate if it is ok to send
1607                      to this message_id from the current instance.
1608   oicf_data          opaque data for oicf_func
1609
1610 Returns:             TRUE if new_message_id set; FALSE otherwise
1611 */
1612
1613 typedef struct msgq_s
1614 {
1615     uschar  message_id [MESSAGE_ID_LENGTH + 1];
1616     BOOL    bKeep;
1617 } msgq_t;
1618
1619 BOOL
1620 transport_check_waiting(const uschar *transport_name, const uschar *hostname,
1621   int local_message_max, uschar *new_message_id, BOOL *more, oicf oicf_func, void *oicf_data)
1622 {
1623 dbdata_wait *host_record;
1624 int host_length;
1625 open_db dbblock;
1626 open_db *dbm_file;
1627
1628 int         i;
1629 struct stat statbuf;
1630
1631 *more = FALSE;
1632
1633 DEBUG(D_transport)
1634   {
1635   debug_printf("transport_check_waiting entered\n");
1636   debug_printf("  sequence=%d local_max=%d global_max=%d\n",
1637     continue_sequence, local_message_max, connection_max_messages);
1638   }
1639
1640 /* Do nothing if we have hit the maximum number that can be send down one
1641 connection. */
1642
1643 if (connection_max_messages >= 0) local_message_max = connection_max_messages;
1644 if (local_message_max > 0 && continue_sequence >= local_message_max)
1645   {
1646   DEBUG(D_transport)
1647     debug_printf("max messages for one connection reached: returning\n");
1648   return FALSE;
1649   }
1650
1651 /* Open the waiting information database. */
1652
1653 if (!(dbm_file = dbfn_open(string_sprintf("wait-%.200s", transport_name),
1654                           O_RDWR, &dbblock, TRUE, TRUE)))
1655   return FALSE;
1656
1657 /* See if there is a record for this host; if not, there's nothing to do. */
1658
1659 if (!(host_record = dbfn_read(dbm_file, hostname)))
1660   {
1661   dbfn_close(dbm_file);
1662   DEBUG(D_transport) debug_printf("no messages waiting for %s\n", hostname);
1663   return FALSE;
1664   }
1665
1666 /* If the data in the record looks corrupt, just log something and
1667 don't try to use it. */
1668
1669 if (host_record->count > WAIT_NAME_MAX)
1670   {
1671   dbfn_close(dbm_file);
1672   log_write(0, LOG_MAIN|LOG_PANIC, "smtp-wait database entry for %s has bad "
1673     "count=%d (max=%d)", hostname, host_record->count, WAIT_NAME_MAX);
1674   return FALSE;
1675   }
1676
1677 /* Scan the message ids in the record from the end towards the beginning,
1678 until one is found for which a spool file actually exists. If the record gets
1679 emptied, delete it and continue with any continuation records that may exist.
1680 */
1681
1682 /* For Bug 1141, I refactored this major portion of the routine, it is risky
1683 but the 1 off will remain without it.  This code now allows me to SKIP over
1684 a message I do not want to send out on this run.  */
1685
1686 host_length = host_record->count * MESSAGE_ID_LENGTH;
1687
1688 while (1)
1689   {
1690   msgq_t      *msgq;
1691   int         msgq_count = 0;
1692   int         msgq_actual = 0;
1693   BOOL        bFound = FALSE;
1694   BOOL        bContinuation = FALSE;
1695
1696   /* create an array to read entire message queue into memory for processing  */
1697
1698   msgq = store_get(sizeof(msgq_t) * host_record->count, FALSE);
1699   msgq_count = host_record->count;
1700   msgq_actual = msgq_count;
1701
1702   for (i = 0; i < host_record->count; ++i)
1703     {
1704     msgq[i].bKeep = TRUE;
1705
1706     Ustrncpy_nt(msgq[i].message_id, host_record->text + (i * MESSAGE_ID_LENGTH), 
1707       MESSAGE_ID_LENGTH);
1708     msgq[i].message_id[MESSAGE_ID_LENGTH] = 0;
1709     }
1710
1711   /* first thing remove current message id if it exists */
1712
1713   for (i = 0; i < msgq_count; ++i)
1714     if (Ustrcmp(msgq[i].message_id, message_id) == 0)
1715       {
1716       msgq[i].bKeep = FALSE;
1717       break;
1718       }
1719
1720   /* now find the next acceptable message_id */
1721
1722   for (i = msgq_count - 1; i >= 0; --i) if (msgq[i].bKeep)
1723     {
1724     uschar subdir[2];
1725
1726     subdir[0] = split_spool_directory ? msgq[i].message_id[5] : 0;
1727     subdir[1] = 0;
1728
1729     if (Ustat(spool_fname(US"input", subdir, msgq[i].message_id, US"-D"),
1730               &statbuf) != 0)
1731       msgq[i].bKeep = FALSE;
1732     else if (!oicf_func || oicf_func(msgq[i].message_id, oicf_data))
1733       {
1734       Ustrcpy_nt(new_message_id, msgq[i].message_id);
1735       msgq[i].bKeep = FALSE;
1736       bFound = TRUE;
1737       break;
1738       }
1739     }
1740
1741   /* re-count */
1742   for (msgq_actual = 0, i = 0; i < msgq_count; ++i)
1743     if (msgq[i].bKeep)
1744       msgq_actual++;
1745
1746   /* reassemble the host record, based on removed message ids, from in
1747   memory queue  */
1748
1749   if (msgq_actual <= 0)
1750     {
1751     host_length = 0;
1752     host_record->count = 0;
1753     }
1754   else
1755     {
1756     host_length = msgq_actual * MESSAGE_ID_LENGTH;
1757     host_record->count = msgq_actual;
1758
1759     if (msgq_actual < msgq_count)
1760       {
1761       int new_count;
1762       for (new_count = 0, i = 0; i < msgq_count; ++i)
1763         if (msgq[i].bKeep)
1764           Ustrncpy(&host_record->text[new_count++ * MESSAGE_ID_LENGTH],
1765             msgq[i].message_id, MESSAGE_ID_LENGTH);
1766
1767       host_record->text[new_count * MESSAGE_ID_LENGTH] = 0;
1768       }
1769     }
1770
1771   /* Check for a continuation record. */
1772
1773   while (host_length <= 0)
1774     {
1775     dbdata_wait * newr = NULL;
1776     uschar buffer[256];
1777
1778     /* Search for a continuation */
1779
1780     for (int i = host_record->sequence - 1; i >= 0 && !newr; i--)
1781       {
1782       sprintf(CS buffer, "%.200s:%d", hostname, i);
1783       newr = dbfn_read(dbm_file, buffer);
1784       }
1785
1786     /* If no continuation, delete the current and break the loop */
1787
1788     if (!newr)
1789       {
1790       dbfn_delete(dbm_file, hostname);
1791       break;
1792       }
1793
1794     /* Else replace the current with the continuation */
1795
1796     dbfn_delete(dbm_file, buffer);
1797     host_record = newr;
1798     host_length = host_record->count * MESSAGE_ID_LENGTH;
1799
1800     bContinuation = TRUE;
1801     }
1802
1803   if (bFound)           /* Usual exit from main loop */
1804     break;
1805
1806   /* If host_length <= 0 we have emptied a record and not found a good message,
1807   and there are no continuation records. Otherwise there is a continuation
1808   record to process. */
1809
1810   if (host_length <= 0)
1811     {
1812     dbfn_close(dbm_file);
1813     DEBUG(D_transport) debug_printf("waiting messages already delivered\n");
1814     return FALSE;
1815     }
1816
1817   /* we were not able to find an acceptable message, nor was there a
1818    * continuation record.  So bug out, outer logic will clean this up.
1819    */
1820
1821   if (!bContinuation)
1822     {
1823     Ustrcpy(new_message_id, message_id);
1824     dbfn_close(dbm_file);
1825     return FALSE;
1826     }
1827   }             /* we need to process a continuation record */
1828
1829 /* Control gets here when an existing message has been encountered; its
1830 id is in new_message_id, and host_length is the revised length of the
1831 host record. If it is zero, the record has been removed. Update the
1832 record if required, close the database, and return TRUE. */
1833
1834 if (host_length > 0)
1835   {
1836   host_record->count = host_length/MESSAGE_ID_LENGTH;
1837
1838   dbfn_write(dbm_file, hostname, host_record, (int)sizeof(dbdata_wait) + host_length);
1839   *more = TRUE;
1840   }
1841
1842 dbfn_close(dbm_file);
1843 return TRUE;
1844 }
1845
1846 /*************************************************
1847 *    Deliver waiting message down same socket    *
1848 *************************************************/
1849
1850 /* Just the regain-root-privilege exec portion */
1851 void
1852 transport_do_pass_socket(const uschar *transport_name, const uschar *hostname,
1853   const uschar *hostaddress, uschar *id, int socket_fd)
1854 {
1855 int i = 20;
1856 const uschar **argv;
1857
1858 /* Set up the calling arguments; use the standard function for the basics,
1859 but we have a number of extras that may be added. */
1860
1861 argv = CUSS child_exec_exim(CEE_RETURN_ARGV, TRUE, &i, FALSE, 0);
1862
1863 if (f.smtp_authenticated)                       argv[i++] = US"-MCA";
1864 if (smtp_peer_options & OPTION_CHUNKING)        argv[i++] = US"-MCK";
1865 if (smtp_peer_options & OPTION_DSN)             argv[i++] = US"-MCD";
1866 if (smtp_peer_options & OPTION_PIPE)            argv[i++] = US"-MCP";
1867 if (smtp_peer_options & OPTION_SIZE)            argv[i++] = US"-MCS";
1868 #ifndef DISABLE_TLS
1869 if (smtp_peer_options & OPTION_TLS)
1870   if (tls_out.active.sock >= 0 || continue_proxy_cipher)
1871     {
1872     argv[i++] = US"-MCt";
1873     argv[i++] = sending_ip_address;
1874     argv[i++] = string_sprintf("%d", sending_port);
1875     argv[i++] = tls_out.active.sock >= 0 ? tls_out.cipher : continue_proxy_cipher;
1876     }
1877   else
1878     argv[i++] = US"-MCT";
1879 #endif
1880
1881 if (queue_run_pid != (pid_t)0)
1882   {
1883   argv[i++] = US"-MCQ";
1884   argv[i++] = string_sprintf("%d", queue_run_pid);
1885   argv[i++] = string_sprintf("%d", queue_run_pipe);
1886   }
1887
1888 argv[i++] = US"-MC";
1889 argv[i++] = US transport_name;
1890 argv[i++] = US hostname;
1891 argv[i++] = US hostaddress;
1892 argv[i++] = string_sprintf("%d", continue_sequence + 1);
1893 argv[i++] = id;
1894 argv[i++] = NULL;
1895
1896 /* Arrange for the channel to be on stdin. */
1897
1898 if (socket_fd != 0)
1899   {
1900   (void)dup2(socket_fd, 0);
1901   (void)close(socket_fd);
1902   }
1903
1904 DEBUG(D_exec) debug_print_argv(argv);
1905 exim_nullstd();                          /* Ensure std{out,err} exist */
1906 execv(CS argv[0], (char *const *)argv);
1907
1908 DEBUG(D_any) debug_printf("execv failed: %s\n", strerror(errno));
1909 _exit(errno);         /* Note: must be _exit(), NOT exit() */
1910 }
1911
1912
1913
1914 /* Fork a new exim process to deliver the message, and do a re-exec, both to
1915 get a clean delivery process, and to regain root privilege in cases where it
1916 has been given away.
1917
1918 Arguments:
1919   transport_name  to pass to the new process
1920   hostname        ditto
1921   hostaddress     ditto
1922   id              the new message to process
1923   socket_fd       the connected socket
1924
1925 Returns:          FALSE if fork fails; TRUE otherwise
1926 */
1927
1928 BOOL
1929 transport_pass_socket(const uschar *transport_name, const uschar *hostname,
1930   const uschar *hostaddress, uschar *id, int socket_fd)
1931 {
1932 pid_t pid;
1933 int status;
1934
1935 DEBUG(D_transport) debug_printf("transport_pass_socket entered\n");
1936
1937 if ((pid = fork()) == 0)
1938   {
1939   /* Disconnect entirely from the parent process. If we are running in the
1940   test harness, wait for a bit to allow the previous process time to finish,
1941   write the log, etc., so that the output is always in the same order for
1942   automatic comparison. */
1943
1944   if ((pid = fork()) != 0)
1945     {
1946     DEBUG(D_transport) debug_printf("transport_pass_socket succeeded (final-pid %d)\n", pid);
1947     _exit(EXIT_SUCCESS);
1948     }
1949   if (f.running_in_test_harness) sleep(1);
1950
1951   transport_do_pass_socket(transport_name, hostname, hostaddress,
1952     id, socket_fd);
1953   }
1954
1955 /* If the process creation succeeded, wait for the first-level child, which
1956 immediately exits, leaving the second level process entirely disconnected from
1957 this one. */
1958
1959 if (pid > 0)
1960   {
1961   int rc;
1962   while ((rc = wait(&status)) != pid && (rc >= 0 || errno != ECHILD));
1963   DEBUG(D_transport) debug_printf("transport_pass_socket succeeded (inter-pid %d)\n", pid);
1964   return TRUE;
1965   }
1966 else
1967   {
1968   DEBUG(D_transport) debug_printf("transport_pass_socket failed to fork: %s\n",
1969     strerror(errno));
1970   return FALSE;
1971   }
1972 }
1973
1974
1975
1976 /*************************************************
1977 *          Set up direct (non-shell) command     *
1978 *************************************************/
1979
1980 /* This function is called when a command line is to be parsed and executed
1981 directly, without the use of /bin/sh. It is called by the pipe transport,
1982 the queryprogram router, and also from the main delivery code when setting up a
1983 transport filter process. The code for ETRN also makes use of this; in that
1984 case, no addresses are passed.
1985
1986 Arguments:
1987   argvptr            pointer to anchor for argv vector
1988   cmd                points to the command string (modified IN PLACE)
1989   expand_arguments   true if expansion is to occur
1990   expand_failed      error value to set if expansion fails; not relevant if
1991                      addr == NULL
1992   addr               chain of addresses, or NULL
1993   etext              text for use in error messages
1994   errptr             where to put error message if addr is NULL;
1995                      otherwise it is put in the first address
1996
1997 Returns:             TRUE if all went well; otherwise an error will be
1998                      set in the first address and FALSE returned
1999 */
2000
2001 BOOL
2002 transport_set_up_command(const uschar ***argvptr, uschar *cmd,
2003   BOOL expand_arguments, int expand_failed, address_item *addr,
2004   uschar *etext, uschar **errptr)
2005 {
2006 const uschar **argv;
2007 uschar *s, *ss;
2008 int address_count = 0;
2009 int argcount = 0;
2010 int max_args;
2011
2012 /* Get store in which to build an argument list. Count the number of addresses
2013 supplied, and allow for that many arguments, plus an additional 60, which
2014 should be enough for anybody. Multiple addresses happen only when the local
2015 delivery batch option is set. */
2016
2017 for (address_item * ad = addr; ad; ad = ad->next) address_count++;
2018 max_args = address_count + 60;
2019 *argvptr = argv = store_get((max_args+1)*sizeof(uschar *), FALSE);
2020
2021 /* Split the command up into arguments terminated by white space. Lose
2022 trailing space at the start and end. Double-quoted arguments can contain \\ and
2023 \" escapes and so can be handled by the standard function; single-quoted
2024 arguments are verbatim. Copy each argument into a new string. */
2025
2026 s = cmd;
2027 while (isspace(*s)) s++;
2028
2029 for (; *s != 0 && argcount < max_args; argcount++)
2030   {
2031   if (*s == '\'')
2032     {
2033     ss = s + 1;
2034     while (*ss != 0 && *ss != '\'') ss++;
2035     argv[argcount] = ss = store_get(ss - s++, is_tainted(cmd));
2036     while (*s != 0 && *s != '\'') *ss++ = *s++;
2037     if (*s != 0) s++;
2038     *ss++ = 0;
2039     }
2040   else
2041     argv[argcount] = string_dequote(CUSS &s);
2042   while (isspace(*s)) s++;
2043   }
2044
2045 argv[argcount] = US 0;
2046
2047 /* If *s != 0 we have run out of argument slots. */
2048
2049 if (*s != 0)
2050   {
2051   uschar *msg = string_sprintf("Too many arguments in command \"%s\" in "
2052     "%s", cmd, etext);
2053   if (addr != NULL)
2054     {
2055     addr->transport_return = FAIL;
2056     addr->message = msg;
2057     }
2058   else *errptr = msg;
2059   return FALSE;
2060   }
2061
2062 /* Expand each individual argument if required. Expansion happens for pipes set
2063 up in filter files and with directly-supplied commands. It does not happen if
2064 the pipe comes from a traditional .forward file. A failing expansion is a big
2065 disaster if the command came from Exim's configuration; if it came from a user
2066 it is just a normal failure. The expand_failed value is used as the error value
2067 to cater for these two cases.
2068
2069 An argument consisting just of the text "$pipe_addresses" is treated specially.
2070 It is not passed to the general expansion function. Instead, it is replaced by
2071 a number of arguments, one for each address. This avoids problems with shell
2072 metacharacters and spaces in addresses.
2073
2074 If the parent of the top address has an original part of "system-filter", this
2075 pipe was set up by the system filter, and we can permit the expansion of
2076 $recipients. */
2077
2078 DEBUG(D_transport)
2079   {
2080   debug_printf("direct command:\n");
2081   for (int i = 0; argv[i]; i++)
2082     debug_printf("  argv[%d] = '%s'\n", i, string_printing(argv[i]));
2083   }
2084
2085 if (expand_arguments)
2086   {
2087   BOOL allow_dollar_recipients = addr != NULL &&
2088     addr->parent != NULL &&
2089     Ustrcmp(addr->parent->address, "system-filter") == 0;
2090
2091   for (int i = 0; argv[i] != US 0; i++)
2092     {
2093
2094     /* Handle special fudge for passing an address list */
2095
2096     if (addr != NULL &&
2097         (Ustrcmp(argv[i], "$pipe_addresses") == 0 ||
2098          Ustrcmp(argv[i], "${pipe_addresses}") == 0))
2099       {
2100       int additional;
2101
2102       if (argcount + address_count - 1 > max_args)
2103         {
2104         addr->transport_return = FAIL;
2105         addr->message = string_sprintf("Too many arguments to command \"%s\" "
2106           "in %s", cmd, etext);
2107         return FALSE;
2108         }
2109
2110       additional = address_count - 1;
2111       if (additional > 0)
2112         memmove(argv + i + 1 + additional, argv + i + 1,
2113           (argcount - i)*sizeof(uschar *));
2114
2115       for (address_item * ad = addr; ad; ad = ad->next)
2116         {
2117         argv[i++] = ad->address;
2118         argcount++;
2119         }
2120
2121       /* Subtract one since we replace $pipe_addresses */
2122       argcount--;
2123       i--;
2124       }
2125
2126       /* Handle special case of $address_pipe when af_force_command is set */
2127
2128     else if (addr != NULL && testflag(addr,af_force_command) &&
2129         (Ustrcmp(argv[i], "$address_pipe") == 0 ||
2130          Ustrcmp(argv[i], "${address_pipe}") == 0))
2131       {
2132       int address_pipe_argcount = 0;
2133       int address_pipe_max_args;
2134       uschar **address_pipe_argv;
2135       BOOL tainted;
2136
2137       /* We can never have more then the argv we will be loading into */
2138       address_pipe_max_args = max_args - argcount + 1;
2139
2140       DEBUG(D_transport)
2141         debug_printf("address_pipe_max_args=%d\n", address_pipe_max_args);
2142
2143       /* We allocate an additional for (uschar *)0 */
2144       address_pipe_argv = store_get((address_pipe_max_args+1)*sizeof(uschar *), FALSE);
2145
2146       /* +1 because addr->local_part[0] == '|' since af_force_command is set */
2147       s = expand_string(addr->local_part + 1);
2148       tainted = is_tainted(s);
2149
2150       if (s == NULL || *s == '\0')
2151         {
2152         addr->transport_return = FAIL;
2153         addr->message = string_sprintf("Expansion of \"%s\" "
2154            "from command \"%s\" in %s failed: %s",
2155            (addr->local_part + 1), cmd, etext, expand_string_message);
2156         return FALSE;
2157         }
2158
2159       while (isspace(*s)) s++; /* strip leading space */
2160
2161       while (*s != 0 && address_pipe_argcount < address_pipe_max_args)
2162         {
2163         if (*s == '\'')
2164           {
2165           ss = s + 1;
2166           while (*ss != 0 && *ss != '\'') ss++;
2167           address_pipe_argv[address_pipe_argcount++] = ss = store_get(ss - s++, tainted);
2168           while (*s != 0 && *s != '\'') *ss++ = *s++;
2169           if (*s != 0) s++;
2170           *ss++ = 0;
2171           }
2172         else address_pipe_argv[address_pipe_argcount++] =
2173               string_copy(string_dequote(CUSS &s));
2174         while (isspace(*s)) s++; /* strip space after arg */
2175         }
2176
2177       address_pipe_argv[address_pipe_argcount] = US 0;
2178
2179       /* If *s != 0 we have run out of argument slots. */
2180       if (*s != 0)
2181         {
2182         uschar *msg = string_sprintf("Too many arguments in $address_pipe "
2183           "\"%s\" in %s", addr->local_part + 1, etext);
2184         if (addr != NULL)
2185           {
2186           addr->transport_return = FAIL;
2187           addr->message = msg;
2188           }
2189         else *errptr = msg;
2190         return FALSE;
2191         }
2192
2193       /* address_pipe_argcount - 1
2194        * because we are replacing $address_pipe in the argument list
2195        * with the first thing it expands to */
2196       if (argcount + address_pipe_argcount - 1 > max_args)
2197         {
2198         addr->transport_return = FAIL;
2199         addr->message = string_sprintf("Too many arguments to command "
2200           "\"%s\" after expanding $address_pipe in %s", cmd, etext);
2201         return FALSE;
2202         }
2203
2204       /* If we are not just able to replace the slot that contained
2205        * $address_pipe (address_pipe_argcount == 1)
2206        * We have to move the existing argv by address_pipe_argcount - 1
2207        * Visually if address_pipe_argcount == 2:
2208        * [argv 0][argv 1][argv 2($address_pipe)][argv 3][0]
2209        * [argv 0][argv 1][ap_arg0][ap_arg1][old argv 3][0]
2210        */
2211       if (address_pipe_argcount > 1)
2212         memmove(
2213           /* current position + additional args */
2214           argv + i + address_pipe_argcount,
2215           /* current position + 1 (for the (uschar *)0 at the end) */
2216           argv + i + 1,
2217           /* -1 for the (uschar *)0 at the end)*/
2218           (argcount - i)*sizeof(uschar *)
2219         );
2220
2221       /* Now we fill in the slots we just moved argv out of
2222        * [argv 0][argv 1][argv 2=pipeargv[0]][argv 3=pipeargv[1]][old argv 3][0]
2223        */
2224       for (int address_pipe_i = 0;
2225            address_pipe_argv[address_pipe_i] != US 0;
2226            address_pipe_i++)
2227         {
2228         argv[i++] = address_pipe_argv[address_pipe_i];
2229         argcount++;
2230         }
2231
2232       /* Subtract one since we replace $address_pipe */
2233       argcount--;
2234       i--;
2235       }
2236
2237     /* Handle normal expansion string */
2238
2239     else
2240       {
2241       const uschar *expanded_arg;
2242       f.enable_dollar_recipients = allow_dollar_recipients;
2243       expanded_arg = expand_cstring(argv[i]);
2244       f.enable_dollar_recipients = FALSE;
2245
2246       if (!expanded_arg)
2247         {
2248         uschar *msg = string_sprintf("Expansion of \"%s\" "
2249           "from command \"%s\" in %s failed: %s",
2250           argv[i], cmd, etext, expand_string_message);
2251         if (addr)
2252           {
2253           addr->transport_return = expand_failed;
2254           addr->message = msg;
2255           }
2256         else *errptr = msg;
2257         return FALSE;
2258         }
2259       argv[i] = expanded_arg;
2260       }
2261     }
2262
2263   DEBUG(D_transport)
2264     {
2265     debug_printf("direct command after expansion:\n");
2266     for (int i = 0; argv[i] != US 0; i++)
2267       debug_printf("  argv[%d] = %s\n", i, string_printing(argv[i]));
2268     }
2269   }
2270
2271 return TRUE;
2272 }
2273
2274 #endif  /*!MACRO_PREDEF*/
2275 /* vi: aw ai sw=2
2276 */
2277 /* End of transport.c */