Code tidying
[users/jgh/exim.git] / src / src / transport.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
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 #ifdef EXPERIMENTAL_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   { "message_size_limit", opt_stringptr|opt_public,
88                  (void *)offsetof(transport_instance, message_size_limit) },
89   { "rcpt_include_affixes", opt_bool|opt_public,
90                  (void *)offsetof(transport_instance, rcpt_include_affixes) },
91   { "retry_use_local_part", opt_bool|opt_public,
92                  (void *)offsetof(transport_instance, retry_use_local_part) },
93   { "return_path",      opt_stringptr|opt_public,
94                  (void *)(offsetof(transport_instance, return_path)) },
95   { "return_path_add",   opt_bool|opt_public,
96                  (void *)(offsetof(transport_instance, return_path_add)) },
97   { "shadow_condition", opt_stringptr|opt_public,
98                  (void *)offsetof(transport_instance, shadow_condition) },
99   { "shadow_transport", opt_stringptr|opt_public,
100                  (void *)offsetof(transport_instance, shadow) },
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       while ((s = string_nextinlist(&list, &sep, NULL, 0)))
647         {
648         int len;
649
650         if (i == 0)
651           if (!(s = expand_string(s)) && !expand_string_forcedfail)
652             {
653             errno = ERRNO_CHHEADER_FAIL;
654             return FALSE;
655             }
656         len = Ustrlen(s);
657         if (strncmpic(h->text, s, len) != 0) continue;
658         ss = h->text + len;
659         while (*ss == ' ' || *ss == '\t') ss++;
660         if (*ss == ':') break;
661         }
662       if (s != NULL) { include_header = FALSE; break; }
663       }
664     if (addr != NULL) list = addr->p.remove_headers;
665     }
666
667   /* If this header is to be output, try to rewrite it if there are rewriting
668   rules. */
669
670   if (include_header)
671     {
672     if (rewrite_rules)
673       {
674       void *reset_point = store_get(0);
675       header_line *hh;
676
677       if ((hh = rewrite_header(h, NULL, NULL, rewrite_rules, rewrite_existflags, FALSE)))
678         {
679         if (!sendfn(fd, hh->text, hh->slen, use_crlf)) return FALSE;
680         store_reset(reset_point);
681         continue;     /* With the next header line */
682         }
683       }
684
685     /* Either no rewriting rules, or it didn't get rewritten */
686
687     if (!sendfn(fd, h->text, h->slen, use_crlf)) return FALSE;
688     }
689
690   /* Header removed */
691
692   else
693     {
694     DEBUG(D_transport) debug_printf("removed header line:\n%s---\n", h->text);
695     }
696   }
697
698 /* Add on any address-specific headers. If there are multiple addresses,
699 they will all have the same headers in order to be batched. The headers
700 are chained in reverse order of adding (so several addresses from the
701 same alias might share some of them) but we want to output them in the
702 opposite order. This is a bit tedious, but there shouldn't be very many
703 of them. We just walk the list twice, reversing the pointers each time,
704 but on the second time, write out the items.
705
706 Headers added to an address by a router are guaranteed to end with a newline.
707 */
708
709 if (addr)
710   {
711   int i;
712   header_line *hprev = addr->p.extra_headers;
713   header_line *hnext;
714   for (i = 0; i < 2; i++)
715     {
716     for (h = hprev, hprev = NULL; h != NULL; h = hnext)
717       {
718       hnext = h->next;
719       h->next = hprev;
720       hprev = h;
721       if (i == 1)
722         {
723         if (!sendfn(fd, h->text, h->slen, use_crlf)) return FALSE;
724         DEBUG(D_transport)
725           debug_printf("added header line(s):\n%s---\n", h->text);
726         }
727       }
728     }
729   }
730
731 /* If a string containing additional headers exists it is a newline-sep
732 list.  Expand each item and write out the result.  This is done last so that
733 if it (deliberately or accidentally) isn't in header format, it won't mess
734 up any other headers. An empty string or a forced expansion failure are
735 noops. An added header string from a transport may not end with a newline;
736 add one if it does not. */
737
738 if (add_headers)
739   {
740   int sep = '\n';
741   uschar * s;
742
743   while ((s = string_nextinlist(&add_headers, &sep, NULL, 0)))
744     if (!(s = expand_string(s)))
745       {
746       if (!expand_string_forcedfail)
747         { errno = ERRNO_CHHEADER_FAIL; return FALSE; }
748       }
749     else
750       {
751       int len = Ustrlen(s);
752       if (len > 0)
753         {
754         if (!sendfn(fd, s, len, use_crlf)) return FALSE;
755         if (s[len-1] != '\n' && !sendfn(fd, US"\n", 1, use_crlf))
756           return FALSE;
757         DEBUG(D_transport)
758           {
759           debug_printf("added header line:\n%s", s);
760           if (s[len-1] != '\n') debug_printf("\n");
761           debug_printf("---\n");
762           }
763         }
764       }
765   }
766
767 /* Separate headers from body with a blank line */
768
769 return sendfn(fd, US"\n", 1, use_crlf);
770 }
771
772
773 /*************************************************
774 *                Write the message               *
775 *************************************************/
776
777 /* This function writes the message to the given file descriptor. The headers
778 are in the in-store data structure, and the rest of the message is in the open
779 file descriptor deliver_datafile. Make sure we start it at the beginning.
780
781 . If add_return_path is TRUE, a "return-path:" header is added to the message,
782   containing the envelope sender's address.
783
784 . If add_envelope_to is TRUE, a "envelope-to:" header is added to the message,
785   giving the top-level envelope address that caused this delivery to happen.
786
787 . If add_delivery_date is TRUE, a "delivery-date:" header is added to the
788   message. It gives the time and date that delivery took place.
789
790 . If check_string is not null, the start of each line is checked for that
791   string. If it is found, it is replaced by escape_string. This used to be
792   the "from hack" for files, and "smtp_dots" for escaping SMTP dots.
793
794 . If use_crlf is true, newlines are turned into CRLF (SMTP output).
795
796 The yield is TRUE if all went well, and FALSE if not. Exit *immediately* after
797 any writing or reading error, leaving the code in errno intact. Error exits
798 can include timeouts for certain transports, which are requested by setting
799 transport_write_timeout non-zero.
800
801 Arguments:
802   addr                  (chain of) addresses (for extra headers), or NULL;
803                           only the first address is used
804   fd                    file descriptor to write the message to
805   options               bit-wise options:
806     add_return_path       if TRUE, add a "return-path" header
807     add_envelope_to       if TRUE, add a "envelope-to" header
808     add_delivery_date     if TRUE, add a "delivery-date" header
809     use_crlf              if TRUE, turn NL into CR LF
810     end_dot               if TRUE, send a terminating "." line at the end
811     no_headers            if TRUE, omit the headers
812     no_body               if TRUE, omit the body
813   size_limit            if > 0, this is a limit to the size of message written;
814                           it is used when returning messages to their senders,
815                           and is approximate rather than exact, owing to chunk
816                           buffering
817   add_headers           a string containing one or more headers to add; it is
818                           expanded, and must be in correct RFC 822 format as
819                           it is transmitted verbatim; NULL => no additions,
820                           and so does empty string or forced expansion fail
821   remove_headers        a colon-separated list of headers to remove, or NULL
822   check_string          a string to check for at the start of lines, or NULL
823   escape_string         a string to insert in front of any check string
824   rewrite_rules         chain of header rewriting rules
825   rewrite_existflags    flags for the rewriting rules
826
827 Returns:                TRUE on success; FALSE (with errno) on failure.
828                         In addition, the global variable transport_count
829                         is incremented by the number of bytes written.
830 */
831
832 static BOOL
833 internal_transport_write_message(address_item *addr, int fd, int options,
834   int size_limit, uschar *add_headers, uschar *remove_headers, uschar *check_string,
835   uschar *escape_string, rewrite_rule *rewrite_rules, int rewrite_existflags)
836 {
837 int written = 0;
838 int len;
839 BOOL use_crlf  = (options & topt_use_crlf)  != 0;
840
841 /* Initialize pointer in output buffer. */
842
843 chunk_ptr = deliver_out_buffer;
844
845 /* Set up the data for start-of-line data checking and escaping */
846
847 nl_partial_match = -1;
848 if (check_string != NULL && escape_string != NULL)
849   {
850   nl_check = check_string;
851   nl_check_length = Ustrlen(nl_check);
852   nl_escape = escape_string;
853   nl_escape_length = Ustrlen(nl_escape);
854   }
855 else nl_check_length = nl_escape_length = 0;
856
857 /* Whether the escaping mechanism is applied to headers or not is controlled by
858 an option (set for SMTP, not otherwise). Negate the length if not wanted till
859 after the headers. */
860
861 if ((options & topt_escape_headers) == 0) nl_check_length = -nl_check_length;
862
863 /* Write the headers if required, including any that have to be added. If there
864 are header rewriting rules, apply them. */
865
866 if ((options & topt_no_headers) == 0)
867   {
868   /* Add return-path: if requested. */
869
870   if ((options & topt_add_return_path) != 0)
871     {
872     uschar buffer[ADDRESS_MAXLENGTH + 20];
873     sprintf(CS buffer, "Return-path: <%.*s>\n", ADDRESS_MAXLENGTH,
874       return_path);
875     if (!write_chunk(fd, buffer, Ustrlen(buffer), use_crlf)) return FALSE;
876     }
877
878   /* Add envelope-to: if requested */
879
880   if ((options & topt_add_envelope_to) != 0)
881     {
882     BOOL first = TRUE;
883     address_item *p;
884     struct aci *plist = NULL;
885     struct aci *dlist = NULL;
886     void *reset_point = store_get(0);
887
888     if (!write_chunk(fd, US"Envelope-to: ", 13, use_crlf)) return FALSE;
889
890     /* Pick up from all the addresses. The plist and dlist variables are
891     anchors for lists of addresses already handled; they have to be defined at
892     this level becuase write_env_to() calls itself recursively. */
893
894     for (p = addr; p != NULL; p = p->next)
895       {
896       if (!write_env_to(p, &plist, &dlist, &first, fd, use_crlf)) return FALSE;
897       }
898
899     /* Add a final newline and reset the store used for tracking duplicates */
900
901     if (!write_chunk(fd, US"\n", 1, use_crlf)) return FALSE;
902     store_reset(reset_point);
903     }
904
905   /* Add delivery-date: if requested. */
906
907   if ((options & topt_add_delivery_date) != 0)
908     {
909     uschar buffer[100];
910     sprintf(CS buffer, "Delivery-date: %s\n", tod_stamp(tod_full));
911     if (!write_chunk(fd, buffer, Ustrlen(buffer), use_crlf)) return FALSE;
912     }
913
914   /* Then the message's headers. Don't write any that are flagged as "old";
915   that means they were rewritten, or are a record of envelope rewriting, or
916   were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
917   match any entries therein. Then check addr->p.remove_headers too, provided that
918   addr is not NULL. */
919   if (!transport_headers_send(addr, fd, add_headers, remove_headers, &write_chunk,
920         use_crlf, rewrite_rules, rewrite_existflags))
921     return FALSE;
922   }
923
924 /* If the body is required, ensure that the data for check strings (formerly
925 the "from hack") is enabled by negating the length if necessary. (It will be
926 negative in cases where it isn't to apply to the headers). Then ensure the body
927 is positioned at the start of its file (following the message id), then write
928 it, applying the size limit if required. */
929
930 if ((options & topt_no_body) == 0)
931   {
932   nl_check_length = abs(nl_check_length);
933   nl_partial_match = 0;
934   lseek(deliver_datafile, SPOOL_DATA_START_OFFSET, SEEK_SET);
935   while ((len = read(deliver_datafile, deliver_in_buffer,
936            DELIVER_IN_BUFFER_SIZE)) > 0)
937     {
938     if (!write_chunk(fd, deliver_in_buffer, len, use_crlf)) return FALSE;
939     if (size_limit > 0)
940       {
941       written += len;
942       if (written > size_limit)
943         {
944         len = 0;    /* Pretend EOF */
945         break;
946         }
947       }
948     }
949
950   /* A read error on the body will have left len == -1 and errno set. */
951
952   if (len != 0) return FALSE;
953   }
954
955 /* Finished with the check string */
956
957 nl_check_length = nl_escape_length = 0;
958
959 /* If requested, add a terminating "." line (SMTP output). */
960
961 if ((options & topt_end_dot) != 0 && !write_chunk(fd, US".\n", 2, use_crlf))
962   return FALSE;
963
964 /* Write out any remaining data in the buffer before returning. */
965
966 return (len = chunk_ptr - deliver_out_buffer) <= 0 ||
967   transport_write_block(fd, deliver_out_buffer, len);
968 }
969
970
971 #ifndef DISABLE_DKIM
972
973 /***************************************************************************************************
974 *    External interface to write the message, while signing it with DKIM and/or Domainkeys         *
975 ***************************************************************************************************/
976
977 /* This function is a wrapper around transport_write_message().
978    It is only called from the smtp transport if DKIM or Domainkeys support
979    is compiled in.  The function sets up a replacement fd into a -K file,
980    then calls the normal function. This way, the exact bits that exim would
981    have put "on the wire" will end up in the file (except for TLS
982    encapsulation, which is the very very last thing). When we are done
983    signing the file, send the signed message down the original fd (or TLS fd).
984
985 Arguments:
986   as for internal_transport_write_message() above, with additional arguments:
987    uschar *dkim_private_key  DKIM: The private key to use (filename or
988                                     plain data)
989    uschar *dkim_domain       DKIM: The domain to use
990    uschar *dkim_selector     DKIM: The selector to use.
991    uschar *dkim_canon        DKIM: The canonalization scheme to use,
992                                     "simple" or "relaxed"
993    uschar *dkim_strict       DKIM: What to do if signing fails:
994                                   1/true  => throw error
995                                   0/false => send anyway
996    uschar *dkim_sign_headers DKIM: List of headers that should be included
997                                     in signature generation
998
999 Returns:       TRUE on success; FALSE (with errno) for any failure
1000 */
1001
1002 BOOL
1003 dkim_transport_write_message(address_item *addr, int fd, int options,
1004   int size_limit, uschar *add_headers, uschar *remove_headers,
1005   uschar *check_string, uschar *escape_string, rewrite_rule *rewrite_rules,
1006   int rewrite_existflags, uschar *dkim_private_key, uschar *dkim_domain,
1007   uschar *dkim_selector, uschar *dkim_canon, uschar *dkim_strict, uschar *dkim_sign_headers
1008   )
1009 {
1010 int dkim_fd;
1011 int save_errno = 0;
1012 BOOL rc;
1013 uschar dkim_spool_name[256];
1014 char sbuf[2048];
1015 int sread = 0;
1016 int wwritten = 0;
1017 uschar *dkim_signature = NULL;
1018
1019 /* If we can't sign, just call the original function. */
1020
1021 if (!(dkim_private_key && dkim_domain && dkim_selector))
1022   return transport_write_message(addr, fd, options,
1023             size_limit, add_headers, remove_headers,
1024             check_string, escape_string, rewrite_rules,
1025             rewrite_existflags);
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
1030 if ((dkim_fd = Uopen(dkim_spool_name, O_RDWR|O_CREAT|O_TRUNC, SPOOL_MODE)) < 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 to write the -K file */
1039
1040 rc = transport_write_message(addr, dkim_fd, options,
1041   size_limit, add_headers, remove_headers,
1042   check_string, escape_string, rewrite_rules,
1043   rewrite_existflags);
1044
1045 /* Save error state. We must clean up before returning. */
1046 if (!rc)
1047   {
1048   save_errno = errno;
1049   goto CLEANUP;
1050   }
1051
1052 if (dkim_private_key && dkim_domain && dkim_selector)
1053   {
1054   /* Rewind file and feed it to the goats^W DKIM lib */
1055   lseek(dkim_fd, 0, SEEK_SET);
1056   dkim_signature = dkim_exim_sign(dkim_fd,
1057                                   dkim_private_key,
1058                                   dkim_domain,
1059                                   dkim_selector,
1060                                   dkim_canon,
1061                                   dkim_sign_headers);
1062   if (!dkim_signature)
1063     {
1064     if (dkim_strict)
1065       {
1066       uschar *dkim_strict_result = expand_string(dkim_strict);
1067       if (dkim_strict_result)
1068         if ( (strcmpic(dkim_strict,US"1") == 0) ||
1069              (strcmpic(dkim_strict,US"true") == 0) ) 
1070           {
1071           /* Set errno to something halfway meaningful */
1072           save_errno = EACCES;
1073           log_write(0, LOG_MAIN, "DKIM: message could not be signed,"
1074             " and dkim_strict is set. Deferring message delivery.");
1075           rc = FALSE;
1076           goto CLEANUP;
1077           }
1078       }
1079     }
1080   else
1081     {
1082     int siglen = Ustrlen(dkim_signature);
1083     while(siglen > 0)
1084       {
1085 #ifdef SUPPORT_TLS
1086       wwritten = tls_out.active == fd
1087         ? tls_write(FALSE, dkim_signature, siglen)
1088         : write(fd, dkim_signature, siglen);
1089 #else
1090       wwritten = write(fd, dkim_signature, siglen);
1091 #endif
1092       if (wwritten == -1)
1093         {
1094         /* error, bail out */
1095         save_errno = errno;
1096         rc = FALSE;
1097         goto CLEANUP;
1098         }
1099       siglen -= wwritten;
1100       dkim_signature += wwritten;
1101       }
1102     }
1103   }
1104
1105 #ifdef HAVE_LINUX_SENDFILE
1106 /* We can use sendfile() to shove the file contents
1107    to the socket. However only if we don't use TLS,
1108    as then there's another layer of indirection
1109    before the data finally hits the socket. */
1110 if (tls_out.active != fd)
1111   {
1112   off_t size = lseek(dkim_fd, 0, SEEK_END); /* Fetch file size */
1113   ssize_t copied = 0;
1114   off_t offset = 0;
1115
1116   /* Rewind file */
1117   lseek(dkim_fd, 0, SEEK_SET);
1118
1119   while(copied >= 0 && offset < size)
1120     copied = sendfile(fd, dkim_fd, &offset, size - offset);
1121   if (copied < 0)
1122     {
1123     save_errno = errno;
1124     rc = FALSE;
1125     }
1126   }
1127 else
1128
1129 #endif
1130
1131   {
1132   /* Rewind file */
1133   lseek(dkim_fd, 0, SEEK_SET);
1134
1135   /* Send file down the original fd */
1136   while((sread = read(dkim_fd, sbuf, 2048)) > 0)
1137     {
1138     char *p = sbuf;
1139     /* write the chunk */
1140
1141     while (sread)
1142       {
1143 #ifdef SUPPORT_TLS
1144       wwritten = tls_out.active == fd
1145         ? tls_write(FALSE, US p, sread)
1146         : write(fd, p, sread);
1147 #else
1148       wwritten = write(fd, p, sread);
1149 #endif
1150       if (wwritten == -1)
1151         {
1152         /* error, bail out */
1153         save_errno = errno;
1154         rc = FALSE;
1155         goto CLEANUP;
1156         }
1157       p += wwritten;
1158       sread -= wwritten;
1159       }
1160     }
1161
1162   if (sread == -1)
1163     {
1164     save_errno = errno;
1165     rc = FALSE;
1166     }
1167   }
1168
1169 CLEANUP:
1170 /* unlink -K file */
1171 (void)close(dkim_fd);
1172 Uunlink(dkim_spool_name);
1173 errno = save_errno;
1174 return rc;
1175 }
1176
1177 #endif
1178
1179
1180
1181 /*************************************************
1182 *    External interface to write the message     *
1183 *************************************************/
1184
1185 /* If there is no filtering required, call the internal function above to do
1186 the real work, passing over all the arguments from this function. Otherwise,
1187 set up a filtering process, fork another process to call the internal function
1188 to write to the filter, and in this process just suck from the filter and write
1189 down the given fd. At the end, tidy up the pipes and the processes.
1190
1191 Arguments:     as for internal_transport_write_message() above
1192
1193 Returns:       TRUE on success; FALSE (with errno) for any failure
1194                transport_count is incremented by the number of bytes written
1195 */
1196
1197 BOOL
1198 transport_write_message(address_item *addr, int fd, int options,
1199   int size_limit, uschar *add_headers, uschar *remove_headers,
1200   uschar *check_string, uschar *escape_string, rewrite_rule *rewrite_rules,
1201   int rewrite_existflags)
1202 {
1203 BOOL use_crlf;
1204 BOOL last_filter_was_NL = TRUE;
1205 int rc, len, yield, fd_read, fd_write, save_errno;
1206 int pfd[2];
1207 pid_t filter_pid, write_pid;
1208
1209 transport_filter_timed_out = FALSE;
1210
1211 /* If there is no filter command set up, call the internal function that does
1212 the actual work, passing it the incoming fd, and return its result. */
1213
1214 if (transport_filter_argv == NULL)
1215   return internal_transport_write_message(addr, fd, options, size_limit,
1216     add_headers, remove_headers, check_string, escape_string,
1217     rewrite_rules, rewrite_existflags);
1218
1219 /* Otherwise the message must be written to a filter process and read back
1220 before being written to the incoming fd. First set up the special processing to
1221 be done during the copying. */
1222
1223 use_crlf  = (options & topt_use_crlf) != 0;
1224 nl_partial_match = -1;
1225
1226 if (check_string != NULL && escape_string != NULL)
1227   {
1228   nl_check = check_string;
1229   nl_check_length = Ustrlen(nl_check);
1230   nl_escape = escape_string;
1231   nl_escape_length = Ustrlen(nl_escape);
1232   }
1233 else nl_check_length = nl_escape_length = 0;
1234
1235 /* Start up a subprocess to run the command. Ensure that our main fd will
1236 be closed when the subprocess execs, but remove the flag afterwards.
1237 (Otherwise, if this is a TCP/IP socket, it can't get passed on to another
1238 process to deliver another message.) We get back stdin/stdout file descriptors.
1239 If the process creation failed, give an error return. */
1240
1241 fd_read = -1;
1242 fd_write = -1;
1243 save_errno = 0;
1244 yield = FALSE;
1245 write_pid = (pid_t)(-1);
1246
1247 (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
1248 filter_pid = child_open(transport_filter_argv, NULL, 077, &fd_write, &fd_read,
1249   FALSE);
1250 (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) & ~FD_CLOEXEC);
1251 if (filter_pid < 0) goto TIDY_UP;      /* errno set */
1252
1253 DEBUG(D_transport)
1254   debug_printf("process %d running as transport filter: write=%d read=%d\n",
1255     (int)filter_pid, fd_write, fd_read);
1256
1257 /* Fork subprocess to write the message to the filter, and return the result
1258 via a(nother) pipe. While writing to the filter, we do not do the CRLF,
1259 smtp dots, or check string processing. */
1260
1261 if (pipe(pfd) != 0) goto TIDY_UP;      /* errno set */
1262 if ((write_pid = fork()) == 0)
1263   {
1264   BOOL rc;
1265   (void)close(fd_read);
1266   (void)close(pfd[pipe_read]);
1267   nl_check_length = nl_escape_length = 0;
1268   rc = internal_transport_write_message(addr, fd_write,
1269     (options & ~(topt_use_crlf | topt_end_dot)),
1270     size_limit, add_headers, remove_headers, NULL, NULL,
1271     rewrite_rules, rewrite_existflags);
1272   save_errno = errno;
1273   if (  write(pfd[pipe_write], (void *)&rc, sizeof(BOOL))
1274         != sizeof(BOOL)
1275      || write(pfd[pipe_write], (void *)&save_errno, sizeof(int))
1276         != sizeof(int)
1277      || write(pfd[pipe_write], (void *)&(addr->more_errno), sizeof(int))
1278         != sizeof(int)
1279      )
1280     rc = FALSE; /* compiler quietening */
1281   _exit(0);
1282   }
1283 save_errno = errno;
1284
1285 /* Parent process: close our copy of the writing subprocess' pipes. */
1286
1287 (void)close(pfd[pipe_write]);
1288 (void)close(fd_write);
1289 fd_write = -1;
1290
1291 /* Writing process creation failed */
1292
1293 if (write_pid < 0)
1294   {
1295   errno = save_errno;    /* restore */
1296   goto TIDY_UP;
1297   }
1298
1299 /* When testing, let the subprocess get going */
1300
1301 if (running_in_test_harness) millisleep(250);
1302
1303 DEBUG(D_transport)
1304   debug_printf("process %d writing to transport filter\n", (int)write_pid);
1305
1306 /* Copy the message from the filter to the output fd. A read error leaves len
1307 == -1 and errno set. We need to apply a timeout to the read, to cope with
1308 the case when the filter gets stuck, but it can be quite a long one. The
1309 default is 5m, but this is now configurable. */
1310
1311 DEBUG(D_transport) debug_printf("copying from the filter\n");
1312
1313 /* Copy the output of the filter, remembering if the last character was NL. If
1314 no data is returned, that counts as "ended with NL" (default setting of the
1315 variable is TRUE). */
1316
1317 chunk_ptr = deliver_out_buffer;
1318
1319 for (;;)
1320   {
1321   sigalrm_seen = FALSE;
1322   alarm(transport_filter_timeout);
1323   len = read(fd_read, deliver_in_buffer, DELIVER_IN_BUFFER_SIZE);
1324   alarm(0);
1325   if (sigalrm_seen)
1326     {
1327     errno = ETIMEDOUT;
1328     transport_filter_timed_out = TRUE;
1329     goto TIDY_UP;
1330     }
1331
1332   /* If the read was successful, write the block down the original fd,
1333   remembering whether it ends in \n or not. */
1334
1335   if (len > 0)
1336     {
1337     if (!write_chunk(fd, deliver_in_buffer, len, use_crlf)) goto TIDY_UP;
1338     last_filter_was_NL = (deliver_in_buffer[len-1] == '\n');
1339     }
1340
1341   /* Otherwise, break the loop. If we have hit EOF, set yield = TRUE. */
1342
1343   else
1344     {
1345     if (len == 0) yield = TRUE;
1346     break;
1347     }
1348   }
1349
1350 /* Tidying up code. If yield = FALSE there has been an error and errno is set
1351 to something. Ensure the pipes are all closed and the processes are removed. If
1352 there has been an error, kill the processes before waiting for them, just to be
1353 sure. Also apply a paranoia timeout. */
1354
1355 TIDY_UP:
1356 save_errno = errno;
1357
1358 (void)close(fd_read);
1359 if (fd_write > 0) (void)close(fd_write);
1360
1361 if (!yield)
1362   {
1363   if (filter_pid > 0) kill(filter_pid, SIGKILL);
1364   if (write_pid > 0)  kill(write_pid, SIGKILL);
1365   }
1366
1367 /* Wait for the filter process to complete. */
1368
1369 DEBUG(D_transport) debug_printf("waiting for filter process\n");
1370 if (filter_pid > 0 && (rc = child_close(filter_pid, 30)) != 0 && yield)
1371   {
1372   yield = FALSE;
1373   save_errno = ERRNO_FILTER_FAIL;
1374   addr->more_errno = rc;
1375   DEBUG(D_transport) debug_printf("filter process returned %d\n", rc);
1376   }
1377
1378 /* Wait for the writing process to complete. If it ends successfully,
1379 read the results from its pipe, provided we haven't already had a filter
1380 process failure. */
1381
1382 DEBUG(D_transport) debug_printf("waiting for writing process\n");
1383 if (write_pid > 0)
1384   {
1385   rc = child_close(write_pid, 30);
1386   if (yield)
1387     {
1388     if (rc == 0)
1389       {
1390       BOOL ok;
1391       int dummy = read(pfd[pipe_read], (void *)&ok, sizeof(BOOL));
1392       if (!ok)
1393         {
1394         dummy = read(pfd[pipe_read], (void *)&save_errno, sizeof(int));
1395         dummy = read(pfd[pipe_read], (void *)&(addr->more_errno), sizeof(int));
1396         yield = FALSE;
1397         }
1398       }
1399     else
1400       {
1401       yield = FALSE;
1402       save_errno = ERRNO_FILTER_FAIL;
1403       addr->more_errno = rc;
1404       DEBUG(D_transport) debug_printf("writing process returned %d\n", rc);
1405       }
1406     }
1407   }
1408 (void)close(pfd[pipe_read]);
1409
1410 /* If there have been no problems we can now add the terminating "." if this is
1411 SMTP output, turning off escaping beforehand. If the last character from the
1412 filter was not NL, insert a NL to make the SMTP protocol work. */
1413
1414 if (yield)
1415   {
1416   nl_check_length = nl_escape_length = 0;
1417   if ((options & topt_end_dot) != 0 && (last_filter_was_NL?
1418         !write_chunk(fd, US".\n", 2, use_crlf) :
1419         !write_chunk(fd, US"\n.\n", 3, use_crlf)))
1420     {
1421     yield = FALSE;
1422     }
1423
1424   /* Write out any remaining data in the buffer. */
1425
1426   else
1427     {
1428     yield = (len = chunk_ptr - deliver_out_buffer) <= 0 ||
1429       transport_write_block(fd, deliver_out_buffer, len);
1430     }
1431   }
1432 else errno = save_errno;      /* From some earlier error */
1433
1434 DEBUG(D_transport)
1435   {
1436   debug_printf("end of filtering transport writing: yield=%d\n", yield);
1437   if (!yield)
1438     debug_printf("errno=%d more_errno=%d\n", errno, addr->more_errno);
1439   }
1440
1441 return yield;
1442 }
1443
1444
1445
1446
1447
1448 /*************************************************
1449 *            Update waiting database             *
1450 *************************************************/
1451
1452 /* This is called when an address is deferred by remote transports that are
1453 capable of sending more than one message over one connection. A database is
1454 maintained for each transport, keeping track of which messages are waiting for
1455 which hosts. The transport can then consult this when eventually a successful
1456 delivery happens, and if it finds that another message is waiting for the same
1457 host, it can fire up a new process to deal with it using the same connection.
1458
1459 The database records are keyed by host name. They can get full if there are
1460 lots of messages waiting, and so there is a continuation mechanism for them.
1461
1462 Each record contains a list of message ids, packed end to end without any
1463 zeros. Each one is MESSAGE_ID_LENGTH bytes long. The count field says how many
1464 in this record, and the sequence field says if there are any other records for
1465 this host. If the sequence field is 0, there are none. If it is 1, then another
1466 record with the name <hostname>:0 exists; if it is 2, then two other records
1467 with sequence numbers 0 and 1 exist, and so on.
1468
1469 Currently, an exhaustive search of all continuation records has to be done to
1470 determine whether to add a message id to a given record. This shouldn't be
1471 too bad except in extreme cases. I can't figure out a *simple* way of doing
1472 better.
1473
1474 Old records should eventually get swept up by the exim_tidydb utility.
1475
1476 Arguments:
1477   hostlist  list of hosts that this message could be sent to
1478   tpname    name of the transport
1479
1480 Returns:    nothing
1481 */
1482
1483 void
1484 transport_update_waiting(host_item *hostlist, uschar *tpname)
1485 {
1486 uschar buffer[256];
1487 uschar *prevname = US"";
1488 host_item *host;
1489 open_db dbblock;
1490 open_db *dbm_file;
1491
1492 DEBUG(D_transport) debug_printf("updating wait-%s database\n", tpname);
1493
1494 /* Open the database for this transport */
1495
1496 sprintf(CS buffer, "wait-%.200s", tpname);
1497 dbm_file = dbfn_open(buffer, O_RDWR, &dbblock, TRUE);
1498 if (dbm_file == NULL) return;
1499
1500 /* Scan the list of hosts for which this message is waiting, and ensure
1501 that the message id is in each host record. */
1502
1503 for (host = hostlist; host!= NULL; host = host->next)
1504   {
1505   BOOL already = FALSE;
1506   dbdata_wait *host_record;
1507   uschar *s;
1508   int i, host_length;
1509
1510   /* Skip if this is the same host as we just processed; otherwise remember
1511   the name for next time. */
1512
1513   if (Ustrcmp(prevname, host->name) == 0) continue;
1514   prevname = host->name;
1515
1516   /* Look up the host record; if there isn't one, make an empty one. */
1517
1518   host_record = dbfn_read(dbm_file, host->name);
1519   if (host_record == NULL)
1520     {
1521     host_record = store_get(sizeof(dbdata_wait) + MESSAGE_ID_LENGTH);
1522     host_record->count = host_record->sequence = 0;
1523     }
1524
1525   /* Compute the current length */
1526
1527   host_length = host_record->count * MESSAGE_ID_LENGTH;
1528
1529   /* Search the record to see if the current message is already in it. */
1530
1531   for (s = host_record->text; s < host_record->text + host_length;
1532        s += MESSAGE_ID_LENGTH)
1533     {
1534     if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1535       { already = TRUE; break; }
1536     }
1537
1538   /* If we haven't found this message in the main record, search any
1539   continuation records that exist. */
1540
1541   for (i = host_record->sequence - 1; i >= 0 && !already; i--)
1542     {
1543     dbdata_wait *cont;
1544     sprintf(CS buffer, "%.200s:%d", host->name, i);
1545     cont = dbfn_read(dbm_file, buffer);
1546     if (cont != NULL)
1547       {
1548       int clen = cont->count * MESSAGE_ID_LENGTH;
1549       for (s = cont->text; s < cont->text + clen; s += MESSAGE_ID_LENGTH)
1550         {
1551         if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1552           { already = TRUE; break; }
1553         }
1554       }
1555     }
1556
1557   /* If this message is already in a record, no need to update. */
1558
1559   if (already)
1560     {
1561     DEBUG(D_transport) debug_printf("already listed for %s\n", host->name);
1562     continue;
1563     }
1564
1565
1566   /* If this record is full, write it out with a new name constructed
1567   from the sequence number, increase the sequence number, and empty
1568   the record. */
1569
1570   if (host_record->count >= WAIT_NAME_MAX)
1571     {
1572     sprintf(CS buffer, "%.200s:%d", host->name, host_record->sequence);
1573     dbfn_write(dbm_file, buffer, host_record, sizeof(dbdata_wait) + host_length);
1574     host_record->sequence++;
1575     host_record->count = 0;
1576     host_length = 0;
1577     }
1578
1579   /* If this record is not full, increase the size of the record to
1580   allow for one new message id. */
1581
1582   else
1583     {
1584     dbdata_wait *newr =
1585       store_get(sizeof(dbdata_wait) + host_length + MESSAGE_ID_LENGTH);
1586     memcpy(newr, host_record, sizeof(dbdata_wait) + host_length);
1587     host_record = newr;
1588     }
1589
1590   /* Now add the new name on the end */
1591
1592   memcpy(host_record->text + host_length, message_id, MESSAGE_ID_LENGTH);
1593   host_record->count++;
1594   host_length += MESSAGE_ID_LENGTH;
1595
1596   /* Update the database */
1597
1598   dbfn_write(dbm_file, host->name, host_record, sizeof(dbdata_wait) + host_length);
1599   DEBUG(D_transport) debug_printf("added to list for %s\n", host->name);
1600   }
1601
1602 /* All now done */
1603
1604 dbfn_close(dbm_file);
1605 }
1606
1607
1608
1609
1610 /*************************************************
1611 *         Test for waiting messages              *
1612 *************************************************/
1613
1614 /* This function is called by a remote transport which uses the previous
1615 function to remember which messages are waiting for which remote hosts. It's
1616 called after a successful delivery and its job is to check whether there is
1617 another message waiting for the same host. However, it doesn't do this if the
1618 current continue sequence is greater than the maximum supplied as an argument,
1619 or greater than the global connection_max_messages, which, if set, overrides.
1620
1621 Arguments:
1622   transport_name     name of the transport
1623   hostname           name of the host
1624   local_message_max  maximum number of messages down one connection
1625                        as set by the caller transport
1626   new_message_id     set to the message id of a waiting message
1627   more               set TRUE if there are yet more messages waiting
1628
1629 Returns:             TRUE if new_message_id set; FALSE otherwise
1630 */
1631
1632 BOOL
1633 transport_check_waiting(uschar *transport_name, uschar *hostname,
1634   int local_message_max, uschar *new_message_id, BOOL *more)
1635 {
1636 dbdata_wait *host_record;
1637 int host_length, path_len;
1638 open_db dbblock;
1639 open_db *dbm_file;
1640 uschar buffer[256];
1641
1642 *more = FALSE;
1643
1644 DEBUG(D_transport)
1645   {
1646   debug_printf("transport_check_waiting entered\n");
1647   debug_printf("  sequence=%d local_max=%d global_max=%d\n",
1648     continue_sequence, local_message_max, connection_max_messages);
1649   }
1650
1651 /* Do nothing if we have hit the maximum number that can be send down one
1652 connection. */
1653
1654 if (connection_max_messages >= 0) local_message_max = connection_max_messages;
1655 if (local_message_max > 0 && continue_sequence >= local_message_max)
1656   {
1657   DEBUG(D_transport)
1658     debug_printf("max messages for one connection reached: returning\n");
1659   return FALSE;
1660   }
1661
1662 /* Open the waiting information database. */
1663
1664 sprintf(CS buffer, "wait-%.200s", transport_name);
1665 dbm_file = dbfn_open(buffer, O_RDWR, &dbblock, TRUE);
1666 if (dbm_file == NULL) return FALSE;
1667
1668 /* See if there is a record for this host; if not, there's nothing to do. */
1669
1670 host_record = dbfn_read(dbm_file, hostname);
1671 if (host_record == NULL)
1672   {
1673   dbfn_close(dbm_file);
1674   DEBUG(D_transport) debug_printf("no messages waiting for %s\n", hostname);
1675   return FALSE;
1676   }
1677
1678 /* If the data in the record looks corrupt, just log something and
1679 don't try to use it. */
1680
1681 if (host_record->count > WAIT_NAME_MAX)
1682   {
1683   dbfn_close(dbm_file);
1684   log_write(0, LOG_MAIN|LOG_PANIC, "smtp-wait database entry for %s has bad "
1685     "count=%d (max=%d)", hostname, host_record->count, WAIT_NAME_MAX);
1686   return FALSE;
1687   }
1688
1689 /* Scan the message ids in the record from the end towards the beginning,
1690 until one is found for which a spool file actually exists. If the record gets
1691 emptied, delete it and continue with any continuation records that may exist.
1692 */
1693
1694 host_length = host_record->count * MESSAGE_ID_LENGTH;
1695
1696 /* Loop to handle continuation host records in the database */
1697
1698 for (;;)
1699   {
1700   BOOL found = FALSE;
1701
1702   sprintf(CS buffer, "%s/input/", spool_directory);
1703   path_len = Ustrlen(buffer);
1704
1705   for (host_length -= MESSAGE_ID_LENGTH; host_length >= 0;
1706        host_length -= MESSAGE_ID_LENGTH)
1707     {
1708     struct stat statbuf;
1709     Ustrncpy(new_message_id, host_record->text + host_length,
1710       MESSAGE_ID_LENGTH);
1711     new_message_id[MESSAGE_ID_LENGTH] = 0;
1712
1713     if (split_spool_directory)
1714       sprintf(CS(buffer + path_len), "%c/%s-D", new_message_id[5], new_message_id);
1715     else
1716       sprintf(CS(buffer + path_len), "%s-D", new_message_id);
1717
1718     /* The listed message may be the one we are currently processing. If
1719     so, we want to remove it from the list without doing anything else.
1720     If not, do a stat to see if it is an existing message. If it is, break
1721     the loop to handle it. No need to bother about locks; as this is all
1722     "hint" processing, it won't matter if it doesn't exist by the time exim
1723     actually tries to deliver it. */
1724
1725     if (Ustrcmp(new_message_id, message_id) != 0 &&
1726         Ustat(buffer, &statbuf) == 0)
1727       {
1728       found = TRUE;
1729       break;
1730       }
1731     }
1732
1733   /* If we have removed all the message ids from the record delete the record.
1734   If there is a continuation record, fetch it and remove it from the file,
1735   as it will be rewritten as the main record. Repeat in the case of an
1736   empty continuation. */
1737
1738   while (host_length <= 0)
1739     {
1740     int i;
1741     dbdata_wait *newr = NULL;
1742
1743     /* Search for a continuation */
1744
1745     for (i = host_record->sequence - 1; i >= 0 && newr == NULL; i--)
1746       {
1747       sprintf(CS buffer, "%.200s:%d", hostname, i);
1748       newr = dbfn_read(dbm_file, buffer);
1749       }
1750
1751     /* If no continuation, delete the current and break the loop */
1752
1753     if (newr == NULL)
1754       {
1755       dbfn_delete(dbm_file, hostname);
1756       break;
1757       }
1758
1759     /* Else replace the current with the continuation */
1760
1761     dbfn_delete(dbm_file, buffer);
1762     host_record = newr;
1763     host_length = host_record->count * MESSAGE_ID_LENGTH;
1764     }
1765
1766   /* If we found an existing message, break the continuation loop. */
1767
1768   if (found) break;
1769
1770   /* If host_length <= 0 we have emptied a record and not found a good message,
1771   and there are no continuation records. Otherwise there is a continuation
1772   record to process. */
1773
1774   if (host_length <= 0)
1775     {
1776     dbfn_close(dbm_file);
1777     DEBUG(D_transport) debug_printf("waiting messages already delivered\n");
1778     return FALSE;
1779     }
1780   }
1781
1782 /* Control gets here when an existing message has been encountered; its
1783 id is in new_message_id, and host_length is the revised length of the
1784 host record. If it is zero, the record has been removed. Update the
1785 record if required, close the database, and return TRUE. */
1786
1787 if (host_length > 0)
1788   {
1789   host_record->count = host_length/MESSAGE_ID_LENGTH;
1790   dbfn_write(dbm_file, hostname, host_record, (int)sizeof(dbdata_wait) + host_length);
1791   *more = TRUE;
1792   }
1793
1794 dbfn_close(dbm_file);
1795 return TRUE;
1796 }
1797
1798
1799
1800 /*************************************************
1801 *    Deliver waiting message down same socket    *
1802 *************************************************/
1803
1804 /* Fork a new exim process to deliver the message, and do a re-exec, both to
1805 get a clean delivery process, and to regain root privilege in cases where it
1806 has been given away.
1807
1808 Arguments:
1809   transport_name  to pass to the new process
1810   hostname        ditto
1811   hostaddress     ditto
1812   id              the new message to process
1813   socket_fd       the connected socket
1814
1815 Returns:          FALSE if fork fails; TRUE otherwise
1816 */
1817
1818 BOOL
1819 transport_pass_socket(uschar *transport_name, uschar *hostname,
1820   uschar *hostaddress, uschar *id, int socket_fd)
1821 {
1822 pid_t pid;
1823 int status;
1824
1825 DEBUG(D_transport) debug_printf("transport_pass_socket entered\n");
1826
1827 if ((pid = fork()) == 0)
1828   {
1829   int i = 16;
1830   uschar **argv;
1831
1832   /* Disconnect entirely from the parent process. If we are running in the
1833   test harness, wait for a bit to allow the previous process time to finish,
1834   write the log, etc., so that the output is always in the same order for
1835   automatic comparison. */
1836
1837   if ((pid = fork()) != 0) _exit(EXIT_SUCCESS);
1838   if (running_in_test_harness) sleep(1);
1839
1840   /* Set up the calling arguments; use the standard function for the basics,
1841   but we have a number of extras that may be added. */
1842
1843   argv = child_exec_exim(CEE_RETURN_ARGV, TRUE, &i, FALSE, 0);
1844
1845   #ifdef EXPERIMENTAL_DSN
1846   /* Call with the dsn flag */
1847   if (smtp_use_dsn) argv[i++] = US"-MCD";
1848   #endif
1849
1850   if (smtp_authenticated) argv[i++] = US"-MCA";
1851
1852   #ifdef SUPPORT_TLS
1853   if (tls_offered) argv[i++] = US"-MCT";
1854   #endif
1855
1856   if (smtp_use_size) argv[i++] = US"-MCS";
1857   if (smtp_use_pipelining) argv[i++] = US"-MCP";
1858
1859   if (queue_run_pid != (pid_t)0)
1860     {
1861     argv[i++] = US"-MCQ";
1862     argv[i++] = string_sprintf("%d", queue_run_pid);
1863     argv[i++] = string_sprintf("%d", queue_run_pipe);
1864     }
1865
1866   argv[i++] = US"-MC";
1867   argv[i++] = transport_name;
1868   argv[i++] = hostname;
1869   argv[i++] = hostaddress;
1870   argv[i++] = string_sprintf("%d", continue_sequence + 1);
1871   argv[i++] = id;
1872   argv[i++] = NULL;
1873
1874   /* Arrange for the channel to be on stdin. */
1875
1876   if (socket_fd != 0)
1877     {
1878     (void)dup2(socket_fd, 0);
1879     (void)close(socket_fd);
1880     }
1881
1882   DEBUG(D_exec) debug_print_argv(argv);
1883   exim_nullstd();                          /* Ensure std{out,err} exist */
1884   execv(CS argv[0], (char *const *)argv);
1885
1886   DEBUG(D_any) debug_printf("execv failed: %s\n", strerror(errno));
1887   _exit(errno);         /* Note: must be _exit(), NOT exit() */
1888   }
1889
1890 /* If the process creation succeeded, wait for the first-level child, which
1891 immediately exits, leaving the second level process entirely disconnected from
1892 this one. */
1893
1894 if (pid > 0)
1895   {
1896   int rc;
1897   while ((rc = wait(&status)) != pid && (rc >= 0 || errno != ECHILD));
1898   DEBUG(D_transport) debug_printf("transport_pass_socket succeeded\n");
1899   return TRUE;
1900   }
1901 else
1902   {
1903   DEBUG(D_transport) debug_printf("transport_pass_socket failed to fork: %s\n",
1904     strerror(errno));
1905   return FALSE;
1906   }
1907 }
1908
1909
1910
1911 /*************************************************
1912 *          Set up direct (non-shell) command     *
1913 *************************************************/
1914
1915 /* This function is called when a command line is to be parsed and executed
1916 directly, without the use of /bin/sh. It is called by the pipe transport,
1917 the queryprogram router, and also from the main delivery code when setting up a
1918 transport filter process. The code for ETRN also makes use of this; in that
1919 case, no addresses are passed.
1920
1921 Arguments:
1922   argvptr            pointer to anchor for argv vector
1923   cmd                points to the command string
1924   expand_arguments   true if expansion is to occur
1925   expand_failed      error value to set if expansion fails; not relevant if
1926                      addr == NULL
1927   addr               chain of addresses, or NULL
1928   etext              text for use in error messages
1929   errptr             where to put error message if addr is NULL;
1930                      otherwise it is put in the first address
1931
1932 Returns:             TRUE if all went well; otherwise an error will be
1933                      set in the first address and FALSE returned
1934 */
1935
1936 BOOL
1937 transport_set_up_command(uschar ***argvptr, uschar *cmd, BOOL expand_arguments,
1938   int expand_failed, address_item *addr, uschar *etext, uschar **errptr)
1939 {
1940 address_item *ad;
1941 uschar **argv;
1942 uschar *s, *ss;
1943 int address_count = 0;
1944 int argcount = 0;
1945 int i, max_args;
1946
1947 /* Get store in which to build an argument list. Count the number of addresses
1948 supplied, and allow for that many arguments, plus an additional 60, which
1949 should be enough for anybody. Multiple addresses happen only when the local
1950 delivery batch option is set. */
1951
1952 for (ad = addr; ad != NULL; ad = ad->next) address_count++;
1953 max_args = address_count + 60;
1954 *argvptr = argv = store_get((max_args+1)*sizeof(uschar *));
1955
1956 /* Split the command up into arguments terminated by white space. Lose
1957 trailing space at the start and end. Double-quoted arguments can contain \\ and
1958 \" escapes and so can be handled by the standard function; single-quoted
1959 arguments are verbatim. Copy each argument into a new string. */
1960
1961 s = cmd;
1962 while (isspace(*s)) s++;
1963
1964 while (*s != 0 && argcount < max_args)
1965   {
1966   if (*s == '\'')
1967     {
1968     ss = s + 1;
1969     while (*ss != 0 && *ss != '\'') ss++;
1970     argv[argcount++] = ss = store_get(ss - s++);
1971     while (*s != 0 && *s != '\'') *ss++ = *s++;
1972     if (*s != 0) s++;
1973     *ss++ = 0;
1974     }
1975   else argv[argcount++] = string_dequote(&s);
1976   while (isspace(*s)) s++;
1977   }
1978
1979 argv[argcount] = (uschar *)0;
1980
1981 /* If *s != 0 we have run out of argument slots. */
1982
1983 if (*s != 0)
1984   {
1985   uschar *msg = string_sprintf("Too many arguments in command \"%s\" in "
1986     "%s", cmd, etext);
1987   if (addr != NULL)
1988     {
1989     addr->transport_return = FAIL;
1990     addr->message = msg;
1991     }
1992   else *errptr = msg;
1993   return FALSE;
1994   }
1995
1996 /* Expand each individual argument if required. Expansion happens for pipes set
1997 up in filter files and with directly-supplied commands. It does not happen if
1998 the pipe comes from a traditional .forward file. A failing expansion is a big
1999 disaster if the command came from Exim's configuration; if it came from a user
2000 it is just a normal failure. The expand_failed value is used as the error value
2001 to cater for these two cases.
2002
2003 An argument consisting just of the text "$pipe_addresses" is treated specially.
2004 It is not passed to the general expansion function. Instead, it is replaced by
2005 a number of arguments, one for each address. This avoids problems with shell
2006 metacharacters and spaces in addresses.
2007
2008 If the parent of the top address has an original part of "system-filter", this
2009 pipe was set up by the system filter, and we can permit the expansion of
2010 $recipients. */
2011
2012 DEBUG(D_transport)
2013   {
2014   debug_printf("direct command:\n");
2015   for (i = 0; argv[i] != (uschar *)0; i++)
2016     debug_printf("  argv[%d] = %s\n", i, string_printing(argv[i]));
2017   }
2018
2019 if (expand_arguments)
2020   {
2021   BOOL allow_dollar_recipients = addr != NULL &&
2022     addr->parent != NULL &&
2023     Ustrcmp(addr->parent->address, "system-filter") == 0;
2024
2025   for (i = 0; argv[i] != (uschar *)0; i++)
2026     {
2027
2028     /* Handle special fudge for passing an address list */
2029
2030     if (addr != NULL &&
2031         (Ustrcmp(argv[i], "$pipe_addresses") == 0 ||
2032          Ustrcmp(argv[i], "${pipe_addresses}") == 0))
2033       {
2034       int additional;
2035
2036       if (argcount + address_count - 1 > max_args)
2037         {
2038         addr->transport_return = FAIL;
2039         addr->message = string_sprintf("Too many arguments to command \"%s\" "
2040           "in %s", cmd, etext);
2041         return FALSE;
2042         }
2043
2044       additional = address_count - 1;
2045       if (additional > 0)
2046         memmove(argv + i + 1 + additional, argv + i + 1,
2047           (argcount - i)*sizeof(uschar *));
2048
2049       for (ad = addr; ad != NULL; ad = ad->next) {
2050           argv[i++] = ad->address;
2051           argcount++;
2052       }
2053
2054       /* Subtract one since we replace $pipe_addresses */
2055       argcount--;
2056       i--;
2057       }
2058
2059       /* Handle special case of $address_pipe when af_force_command is set */
2060
2061     else if (addr != NULL && testflag(addr,af_force_command) &&
2062         (Ustrcmp(argv[i], "$address_pipe") == 0 ||
2063          Ustrcmp(argv[i], "${address_pipe}") == 0))
2064       {
2065       int address_pipe_i;
2066       int address_pipe_argcount = 0;
2067       int address_pipe_max_args;
2068       uschar **address_pipe_argv;
2069
2070       /* We can never have more then the argv we will be loading into */
2071       address_pipe_max_args = max_args - argcount + 1;
2072
2073       DEBUG(D_transport)
2074         debug_printf("address_pipe_max_args=%d\n", address_pipe_max_args);
2075
2076       /* We allocate an additional for (uschar *)0 */
2077       address_pipe_argv = store_get((address_pipe_max_args+1)*sizeof(uschar *));
2078
2079       /* +1 because addr->local_part[0] == '|' since af_force_command is set */
2080       s = expand_string(addr->local_part + 1);
2081
2082       if (s == NULL || *s == '\0')
2083         {
2084         addr->transport_return = FAIL;
2085         addr->message = string_sprintf("Expansion of \"%s\" "
2086            "from command \"%s\" in %s failed: %s",
2087            (addr->local_part + 1), cmd, etext, expand_string_message);
2088         return FALSE;
2089         }
2090
2091       while (isspace(*s)) s++; /* strip leading space */
2092
2093       while (*s != 0 && address_pipe_argcount < address_pipe_max_args)
2094         {
2095         if (*s == '\'')
2096           {
2097           ss = s + 1;
2098           while (*ss != 0 && *ss != '\'') ss++;
2099           address_pipe_argv[address_pipe_argcount++] = ss = store_get(ss - s++);
2100           while (*s != 0 && *s != '\'') *ss++ = *s++;
2101           if (*s != 0) s++;
2102           *ss++ = 0;
2103           }
2104         else address_pipe_argv[address_pipe_argcount++] = string_dequote(&s);
2105         while (isspace(*s)) s++; /* strip space after arg */
2106         }
2107
2108       address_pipe_argv[address_pipe_argcount] = (uschar *)0;
2109
2110       /* If *s != 0 we have run out of argument slots. */
2111       if (*s != 0)
2112         {
2113         uschar *msg = string_sprintf("Too many arguments in $address_pipe "
2114           "\"%s\" in %s", addr->local_part + 1, etext);
2115         if (addr != NULL)
2116           {
2117           addr->transport_return = FAIL;
2118           addr->message = msg;
2119           }
2120         else *errptr = msg;
2121         return FALSE;
2122         }
2123
2124       /* address_pipe_argcount - 1
2125        * because we are replacing $address_pipe in the argument list
2126        * with the first thing it expands to */
2127       if (argcount + address_pipe_argcount - 1 > max_args)
2128         {
2129         addr->transport_return = FAIL;
2130         addr->message = string_sprintf("Too many arguments to command "
2131           "\"%s\" after expanding $address_pipe in %s", cmd, etext);
2132         return FALSE;
2133         }
2134
2135       /* If we are not just able to replace the slot that contained
2136        * $address_pipe (address_pipe_argcount == 1)
2137        * We have to move the existing argv by address_pipe_argcount - 1
2138        * Visually if address_pipe_argcount == 2:
2139        * [argv 0][argv 1][argv 2($address_pipe)][argv 3][0]
2140        * [argv 0][argv 1][ap_arg0][ap_arg1][old argv 3][0]
2141        */
2142       if (address_pipe_argcount > 1)
2143         memmove(
2144           /* current position + additonal args */
2145           argv + i + address_pipe_argcount,
2146           /* current position + 1 (for the (uschar *)0 at the end) */
2147           argv + i + 1,
2148           /* -1 for the (uschar *)0 at the end)*/
2149           (argcount - i)*sizeof(uschar *)
2150         );
2151
2152       /* Now we fill in the slots we just moved argv out of
2153        * [argv 0][argv 1][argv 2=pipeargv[0]][argv 3=pipeargv[1]][old argv 3][0]
2154        */
2155       for (address_pipe_i = 0;
2156            address_pipe_argv[address_pipe_i] != (uschar *)0;
2157            address_pipe_i++)
2158         {
2159         argv[i++] = address_pipe_argv[address_pipe_i];
2160         argcount++;
2161         }
2162
2163       /* Subtract one since we replace $address_pipe */
2164       argcount--;
2165       i--;
2166       }
2167
2168     /* Handle normal expansion string */
2169
2170     else
2171       {
2172       uschar *expanded_arg;
2173       enable_dollar_recipients = allow_dollar_recipients;
2174       expanded_arg = expand_string(argv[i]);
2175       enable_dollar_recipients = FALSE;
2176
2177       if (expanded_arg == NULL)
2178         {
2179         uschar *msg = string_sprintf("Expansion of \"%s\" "
2180           "from command \"%s\" in %s failed: %s",
2181           argv[i], cmd, etext, expand_string_message);
2182         if (addr != NULL)
2183           {
2184           addr->transport_return = expand_failed;
2185           addr->message = msg;
2186           }
2187         else *errptr = msg;
2188         return FALSE;
2189         }
2190       argv[i] = expanded_arg;
2191       }
2192     }
2193
2194   DEBUG(D_transport)
2195     {
2196     debug_printf("direct command after expansion:\n");
2197     for (i = 0; argv[i] != (uschar *)0; i++)
2198       debug_printf("  argv[%d] = %s\n", i, string_printing(argv[i]));
2199     }
2200   }
2201
2202 return TRUE;
2203 }
2204
2205 /* vi: aw ai sw=2
2206 */
2207 /* End of transport.c */