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