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