Add a whole pile of casts to get rid of compiler warnings in Tom's DK
[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 */