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