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