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