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