tidying
[exim.git] / src / src / transports / autoreply.c
CommitLineData
0756eb3c
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
80fea873 5/* Copyright (c) University of Cambridge 1995 - 2016 */
0756eb3c
PH
6/* See the file NOTICE for conditions of use and distribution. */
7
8
9#include "../exim.h"
10#include "autoreply.h"
11
12
13
14/* Options specific to the autoreply transport. They must be in alphabetic
15order (note that "_" comes before the lower case letters). Those starting
16with "*" are not settable by the user but are used by the option-reading
17software for alternative value types. Some options are publicly visible and so
18are stored in the driver instance block. These are flagged with opt_public. */
19
20optionlist autoreply_transport_options[] = {
21 { "bcc", opt_stringptr,
22 (void *)offsetof(autoreply_transport_options_block, bcc) },
23 { "cc", opt_stringptr,
24 (void *)offsetof(autoreply_transport_options_block, cc) },
25 { "file", opt_stringptr,
26 (void *)offsetof(autoreply_transport_options_block, file) },
27 { "file_expand", opt_bool,
28 (void *)offsetof(autoreply_transport_options_block, file_expand) },
29 { "file_optional", opt_bool,
30 (void *)offsetof(autoreply_transport_options_block, file_optional) },
31 { "from", opt_stringptr,
32 (void *)offsetof(autoreply_transport_options_block, from) },
33 { "headers", opt_stringptr,
34 (void *)offsetof(autoreply_transport_options_block, headers) },
35 { "log", opt_stringptr,
36 (void *)offsetof(autoreply_transport_options_block, logfile) },
37 { "mode", opt_octint,
38 (void *)offsetof(autoreply_transport_options_block, mode) },
39 { "never_mail", opt_stringptr,
40 (void *)offsetof(autoreply_transport_options_block, never_mail) },
41 { "once", opt_stringptr,
42 (void *)offsetof(autoreply_transport_options_block, oncelog) },
43 { "once_file_size", opt_int,
44 (void *)offsetof(autoreply_transport_options_block, once_file_size) },
45 { "once_repeat", opt_stringptr,
46 (void *)offsetof(autoreply_transport_options_block, once_repeat) },
47 { "reply_to", opt_stringptr,
48 (void *)offsetof(autoreply_transport_options_block, reply_to) },
49 { "return_message", opt_bool,
50 (void *)offsetof(autoreply_transport_options_block, return_message) },
51 { "subject", opt_stringptr,
52 (void *)offsetof(autoreply_transport_options_block, subject) },
53 { "text", opt_stringptr,
54 (void *)offsetof(autoreply_transport_options_block, text) },
55 { "to", opt_stringptr,
56 (void *)offsetof(autoreply_transport_options_block, to) },
57};
58
59/* Size of the options list. An extern variable has to be used so that its
60address can appear in the tables drtables.c. */
61
62int autoreply_transport_options_count =
63 sizeof(autoreply_transport_options)/sizeof(optionlist);
64
d185889f
JH
65
66#ifdef MACRO_PREDEF
67
68/* Dummy values */
69autoreply_transport_options_block autoreply_transport_option_defaults = {0};
70void autoreply_transport_init(transport_instance *tblock) {}
71BOOL autoreply_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
72
73#else /*!MACRO_PREDEF*/
74
75
0756eb3c
PH
76/* Default private options block for the autoreply transport. */
77
78autoreply_transport_options_block autoreply_transport_option_defaults = {
79 NULL, /* from */
80 NULL, /* reply_to */
81 NULL, /* to */
82 NULL, /* cc */
83 NULL, /* bcc */
84 NULL, /* subject */
85 NULL, /* headers */
86 NULL, /* text */
87 NULL, /* file */
88 NULL, /* logfile */
89 NULL, /* oncelog */
90 NULL, /* once_repeat */
91 NULL, /* never_mail */
92 0600, /* mode */
93 0, /* once_file_size */
94 FALSE, /* file_expand */
95 FALSE, /* file_optional */
96 FALSE /* return message */
97};
98
99
100
101/* Type of text for the checkexpand() function */
102
103enum { cke_text, cke_hdr, cke_file };
104
105
106
107/*************************************************
108* Initialization entry point *
109*************************************************/
110
111/* Called for each instance, after its options have been read, to
112enable consistency checks to be done, or anything else that needs
113to be set up. */
114
115void
116autoreply_transport_init(transport_instance *tblock)
117{
118/*
119autoreply_transport_options_block *ob =
120 (autoreply_transport_options_block *)(tblock->options_block);
121*/
122
123/* If a fixed uid field is set, then a gid field must also be set. */
124
125if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
126 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
127 "user set without group for the %s transport", tblock->name);
128}
129
130
131
132
133/*************************************************
134* Expand string and check *
135*************************************************/
136
137/* If the expansion fails, the error is set up in the address. Expanded
138strings must be checked to ensure they contain only printing characters
139and white space. If not, the function fails.
140
141Arguments:
142 s string to expand
143 addr address that is being worked on
144 name transport name, for error text
145 type type, for checking content:
146 cke_text => no check
147 cke_hdr => header, allow \n + whitespace
148 cke_file => file name, no non-printers allowed
149
150Returns: expanded string if expansion succeeds;
151 NULL otherwise
152*/
153
154static uschar *
155checkexpand(uschar *s, address_item *addr, uschar *name, int type)
156{
157uschar *t;
158uschar *ss = expand_string(s);
159
160if (ss == NULL)
161 {
162 addr->transport_return = FAIL;
163 addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
164 "%s", s, name, expand_string_message);
165 return NULL;
166 }
167
168if (type != cke_text) for (t = ss; *t != 0; t++)
169 {
170 int c = *t;
55414b25 171 const uschar * sp;
0756eb3c
PH
172 if (mac_isprint(c)) continue;
173 if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
55414b25 174 sp = string_printing(s);
0756eb3c
PH
175 addr->transport_return = FAIL;
176 addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
55414b25 177 "contains non-printing character %d", sp, name, c);
0756eb3c
PH
178 return NULL;
179 }
180
181return ss;
182}
183
184
185
186
187/*************************************************
188* Check a header line for never_mail *
189*************************************************/
190
191/* This is called to check to, cc, and bcc for addresses in the never_mail
192list. Any that are found are removed.
193
194Arguments:
195 listptr points to the list of addresses
196 never_mail an address list, already expanded
197
198Returns: nothing
199*/
200
201static void
55414b25 202check_never_mail(uschar **listptr, const uschar *never_mail)
0756eb3c
PH
203{
204uschar *s = *listptr;
205
206while (*s != 0)
207 {
208 uschar *error, *next;
209 uschar *e = parse_find_address_end(s, FALSE);
210 int terminator = *e;
211 int start, end, domain, rc;
212
213 /* Temporarily terminate the string at the address end while extracting
214 the operative address within. */
215
216 *e = 0;
217 next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
218 *e = terminator;
219
220 /* If there is some kind of syntax error, just give up on this header
221 line. */
222
223 if (next == NULL) break;
224
225 /* See if the address is on the never_mail list */
226
227 rc = match_address_list(next, /* address to check */
228 TRUE, /* start caseless */
229 FALSE, /* don't expand the list */
230 &never_mail, /* the list */
231 NULL, /* no caching */
232 -1, /* no expand setup */
233 0, /* separator from list */
234 NULL); /* no lookup value return */
235
236 if (rc == OK) /* Remove this address */
237 {
238 DEBUG(D_transport)
239 debug_printf("discarding recipient %s (matched never_mail)\n", next);
240 if (terminator == ',') e++;
241 memmove(s, e, Ustrlen(e) + 1);
242 }
243 else /* Skip over this address */
244 {
245 s = e;
246 if (terminator == ',') s++;
247 }
248 }
249
250/* Check to see if we removed the last address, leaving a terminating comma
251that needs to be removed */
252
253s = *listptr + Ustrlen(*listptr);
254while (s > *listptr && (isspace(s[-1]) || s[-1] == ',')) s--;
255*s = 0;
256
257/* Check to see if there any addresses left; if not, set NULL */
258
259s = *listptr;
260while (s != 0 && isspace(*s)) s++;
261if (*s == 0) *listptr = NULL;
262}
263
264
265
266/*************************************************
267* Main entry point *
268*************************************************/
269
270/* See local README for interface details. This transport always returns
271FALSE, indicating that the top address has the status for all - though in fact
272this transport can handle only one address at at time anyway. */
273
274BOOL
275autoreply_transport_entry(
276 transport_instance *tblock, /* data for this instantiation */
277 address_item *addr) /* address we are working on */
278{
279int fd, pid, rc;
280int cache_fd = -1;
0756eb3c
PH
281int cache_size = 0;
282int add_size = 0;
283EXIM_DB *dbm_file = NULL;
284BOOL file_expand, return_message;
285uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
286uschar *logfile, *oncelog;
287uschar *cache_buff = NULL;
288uschar *cache_time = NULL;
30dba1e6 289uschar *message_id = NULL;
0756eb3c
PH
290header_line *h;
291time_t now = time(NULL);
292time_t once_repeat_sec = 0;
293FILE *f;
294FILE *ff = NULL;
295
296autoreply_transport_options_block *ob =
297 (autoreply_transport_options_block *)(tblock->options_block);
298
299DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
300
301/* Set up for the good case */
302
303addr->transport_return = OK;
304addr->basic_errno = 0;
305
306/* If the address is pointing to a reply block, then take all the data
307from that block. It has typically been set up by a mail filter processing
308router. Otherwise, the data must be supplied by this transport, and
309it has to be expanded here. */
310
311if (addr->reply != NULL)
312 {
313 DEBUG(D_transport) debug_printf("taking data from address\n");
314 from = addr->reply->from;
315 reply_to = addr->reply->reply_to;
316 to = addr->reply->to;
317 cc = addr->reply->cc;
318 bcc = addr->reply->bcc;
319 subject = addr->reply->subject;
320 headers = addr->reply->headers;
321 text = addr->reply->text;
322 file = addr->reply->file;
323 logfile = addr->reply->logfile;
324 oncelog = addr->reply->oncelog;
325 once_repeat_sec = addr->reply->once_repeat;
326 file_expand = addr->reply->file_expand;
327 expand_forbid = addr->reply->expand_forbid;
328 return_message = addr->reply->return_message;
329 }
330else
331 {
332 uschar *oncerepeat = ob->once_repeat;
333
334 DEBUG(D_transport) debug_printf("taking data from transport\n");
335 from = ob->from;
336 reply_to = ob->reply_to;
337 to = ob->to;
338 cc = ob->cc;
339 bcc = ob->bcc;
340 subject = ob->subject;
341 headers = ob->headers;
342 text = ob->text;
343 file = ob->file;
344 logfile = ob->logfile;
345 oncelog = ob->oncelog;
346 file_expand = ob->file_expand;
347 return_message = ob->return_message;
348
0a6c178c
JH
349 if ( from && !(from = checkexpand(from, addr, tblock->name, cke_hdr))
350 || reply_to && !(reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr))
351 || to && !(to = checkexpand(to, addr, tblock->name, cke_hdr))
352 || cc && !(cc = checkexpand(cc, addr, tblock->name, cke_hdr))
353 || bcc && !(bcc = checkexpand(bcc, addr, tblock->name, cke_hdr))
354 || subject && !(subject = checkexpand(subject, addr, tblock->name, cke_hdr))
355 || headers && !(headers = checkexpand(headers, addr, tblock->name, cke_text))
356 || text && !(text = checkexpand(text, addr, tblock->name, cke_text))
357 || file && !(file = checkexpand(file, addr, tblock->name, cke_file))
358 || logfile && !(logfile = checkexpand(logfile, addr, tblock->name, cke_file))
359 || oncelog && !(oncelog = checkexpand(oncelog, addr, tblock->name, cke_file))
360 || oncerepeat && !(oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file))
361 )
0756eb3c
PH
362 return FALSE;
363
0a6c178c 364 if (oncerepeat)
0756eb3c
PH
365 {
366 once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE);
367 if (once_repeat_sec < 0)
368 {
369 addr->transport_return = FAIL;
370 addr->message = string_sprintf("Invalid time value \"%s\" for "
371 "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
372 return FALSE;
373 }
374 }
375 }
376
377/* If the never_mail option is set, we have to scan all the recipients and
378remove those that match. */
379
0a6c178c 380if (ob->never_mail)
0756eb3c 381 {
55414b25 382 const uschar *never_mail = expand_string(ob->never_mail);
0756eb3c 383
0a6c178c 384 if (!never_mail)
0756eb3c
PH
385 {
386 addr->transport_return = FAIL;
387 addr->message = string_sprintf("Failed to expand \"%s\" for "
388 "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
389 return FALSE;
390 }
391
0a6c178c
JH
392 if (to) check_never_mail(&to, never_mail);
393 if (cc) check_never_mail(&cc, never_mail);
394 if (bcc) check_never_mail(&bcc, never_mail);
0756eb3c 395
0a6c178c 396 if (!to && !cc && !bcc)
0756eb3c
PH
397 {
398 DEBUG(D_transport)
399 debug_printf("*** all recipients removed by never_mail\n");
400 return OK;
401 }
402 }
403
404/* If the -N option is set, can't do any more. */
405
406if (dont_deliver)
407 {
408 DEBUG(D_transport)
409 debug_printf("*** delivery by %s transport bypassed by -N option\n",
410 tblock->name);
411 return FALSE;
412 }
413
414
415/* If the oncelog field is set, we send want to send only one message to the
416given recipient(s). This works only on the "To" field. If there is no "To"
417field, the message is always sent. If the To: field contains more than one
418recipient, the effect might not be quite as envisaged. If once_file_size is
419set, instead of a dbm file, we use a regular file containing a circular buffer
420recipient cache. */
421
0a6c178c 422if (oncelog && *oncelog != 0 && to)
0756eb3c
PH
423 {
424 time_t then = 0;
425
426 /* Handle fixed-size cache file. */
427
428 if (ob->once_file_size > 0)
429 {
0a6c178c 430 uschar * p, * nextp;
0756eb3c
PH
431 struct stat statbuf;
432 cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
433
434 if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
435 {
436 addr->transport_return = DEFER;
437 addr->message = string_sprintf("Failed to %s \"once\" file %s when "
438 "sending message from %s transport: %s",
439 (cache_fd < 0)? "open" : "stat", oncelog, tblock->name,
440 strerror(errno));
441 goto END_OFF;
442 }
443
444 /* Get store in the temporary pool and read the entire file into it. We get
445 an amount of store that is big enough to add the new entry on the end if we
446 need to do that. */
447
448 cache_size = statbuf.st_size;
449 add_size = sizeof(time_t) + Ustrlen(to) + 1;
450 cache_buff = store_get(cache_size + add_size);
451
452 if (read(cache_fd, cache_buff, cache_size) != cache_size)
453 {
454 addr->transport_return = DEFER;
455 addr->basic_errno = errno;
456 addr->message = US"error while reading \"once\" file";
457 goto END_OFF;
458 }
459
460 DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
461
462 /* Scan the data for this recipient. Each entry in the file starts with
463 a time_t sized time value, followed by the address, followed by a binary
464 zero. If we find a match, put the time into "then", and the place where it
465 was found into "cache_time". Otherwise, "then" is left at zero. */
466
0a6c178c 467 for (p = cache_buff; p < cache_buff + cache_size; p = nextp)
0756eb3c
PH
468 {
469 uschar *s = p + sizeof(time_t);
0a6c178c 470 nextp = s + Ustrlen(s) + 1;
0756eb3c
PH
471 if (Ustrcmp(to, s) == 0)
472 {
473 memcpy(&then, p, sizeof(time_t));
474 cache_time = p;
475 break;
476 }
0756eb3c
PH
477 }
478 }
479
480 /* Use a DBM file for the list of previous recipients. */
481
482 else
483 {
484 EXIM_DATUM key_datum, result_datum;
cfb9cf20
JH
485 uschar * dirname = string_copy(oncelog);
486 uschar * s;
487
488 if ((s = Ustrrchr(dirname, '/'))) *s = '\0';
489 EXIM_DBOPEN(oncelog, dirname, O_RDWR|O_CREAT, ob->mode, &dbm_file);
d315eda1 490 if (!dbm_file)
0756eb3c
PH
491 {
492 addr->transport_return = DEFER;
493 addr->message = string_sprintf("Failed to open %s file %s when sending "
494 "message from %s transport: %s", EXIM_DBTYPE, oncelog, tblock->name,
495 strerror(errno));
496 goto END_OFF;
497 }
498
499 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries need datums */
500 EXIM_DATUM_INIT(result_datum); /* to be cleared */
501 EXIM_DATUM_DATA(key_datum) = CS to;
502 EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
503
504 if (EXIM_DBGET(dbm_file, key_datum, result_datum))
505 {
506 /* If the datum size is that of a binary time, we are in the new world
507 where messages are sent periodically. Otherwise the file is an old one,
508 where the datum was filled with a tod_log time, which is assumed to be
509 different in size. For that, only one message is ever sent. This change
510 introduced at Exim 3.00. In a couple of years' time the test on the size
511 can be abolished. */
512
513 if (EXIM_DATUM_SIZE(result_datum) == sizeof(time_t))
0756eb3c 514 memcpy(&then, EXIM_DATUM_DATA(result_datum), sizeof(time_t));
0a6c178c
JH
515 else
516 then = now;
0756eb3c
PH
517 }
518 }
519
520 /* Either "then" is set zero, if no message has yet been sent, or it
521 is set to the time of the last sending. */
522
523 if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
524 {
13559da6 525 int log_fd;
0756eb3c
PH
526 DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
527 (once_repeat_sec > 0)? " and repeat time not reached" : "");
13559da6 528 log_fd = logfile ? Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode) : -1;
0756eb3c
PH
529 if (log_fd >= 0)
530 {
531 uschar *ptr = log_buffer;
532 sprintf(CS ptr, "%s\n previously sent to %.200s\n", tod_stamp(tod_log), to);
533 while(*ptr) ptr++;
1ac6b2e7
JH
534 if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
535 || close(log_fd))
536 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
537 "transport\n", logfile, tblock->name);
0756eb3c
PH
538 }
539 goto END_OFF;
540 }
541
542 DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
543 "no previous message sent to" : "repeat time reached for", to);
544 }
545
546/* We are going to send a message. Ensure any requested file is available. */
547
0a6c178c 548if (file)
0756eb3c
PH
549 {
550 ff = Ufopen(file, "rb");
0a6c178c 551 if (!ff && !ob->file_optional)
0756eb3c
PH
552 {
553 addr->transport_return = DEFER;
554 addr->message = string_sprintf("Failed to open file %s when sending "
555 "message from %s transport: %s", file, tblock->name, strerror(errno));
556 return FALSE;
557 }
558 }
559
560/* Make a subprocess to send the message */
561
562pid = child_open_exim(&fd);
563
564/* Creation of child failed; defer this delivery. */
565
566if (pid < 0)
567 {
568 addr->transport_return = DEFER;
569 addr->message = string_sprintf("Failed to create child process to send "
570 "message from %s transport: %s", tblock->name, strerror(errno));
571 DEBUG(D_transport) debug_printf("%s\n", addr->message);
0a6c178c 572 if (dbm_file) EXIM_DBCLOSE(dbm_file);
0756eb3c
PH
573 return FALSE;
574 }
575
576/* Create the message to be sent - recipients are taken from the headers,
577as the -t option is used. The "headers" stuff *must* be last in case there
578are newlines in it which might, if placed earlier, screw up other headers. */
579
580f = fdopen(fd, "wb");
581
0a6c178c
JH
582if (from) fprintf(f, "From: %s\n", from);
583if (reply_to) fprintf(f, "Reply-To: %s\n", reply_to);
584if (to) fprintf(f, "To: %s\n", to);
585if (cc) fprintf(f, "Cc: %s\n", cc);
586if (bcc) fprintf(f, "Bcc: %s\n", bcc);
587if (subject) fprintf(f, "Subject: %s\n", subject);
0756eb3c
PH
588
589/* Generate In-Reply-To from the message_id header; there should
590always be one, but code defensively. */
591
0a6c178c 592for (h = header_list; h; h = h->next)
0756eb3c
PH
593 if (h->type == htype_id) break;
594
0a6c178c 595if (h)
0756eb3c 596 {
30dba1e6
PH
597 message_id = Ustrchr(h->text, ':') + 1;
598 while (isspace(*message_id)) message_id++;
599 fprintf(f, "In-Reply-To: %s", message_id);
600 }
601
602/* Generate a References header if there is at least one of Message-ID:,
603References:, or In-Reply-To: (see RFC 2822). */
604
0a6c178c 605for (h = header_list; h; h = h->next)
30dba1e6
PH
606 if (h->type != htype_old && strncmpic(US"References:", h->text, 11) == 0)
607 break;
608
0a6c178c
JH
609if (!h)
610 for (h = header_list; h; h = h->next)
30dba1e6
PH
611 if (h->type != htype_old && strncmpic(US"In-Reply-To:", h->text, 12) == 0)
612 break;
613
614/* We limit the total length of references. Although there is no fixed
615limit, some systems do not like headers growing beyond recognition.
616Keep the first message ID for the thread root and the last few for
617the position inside the thread, up to a maximum of 12 altogether. */
618
0a6c178c 619if (h || message_id)
30dba1e6
PH
620 {
621 fprintf(f, "References:");
0a6c178c 622 if (h)
30dba1e6
PH
623 {
624 uschar *s, *id, *error;
625 uschar *referenced_ids[12];
626 int reference_count = 0;
627 int i;
628
629 s = Ustrchr(h->text, ':') + 1;
630 parse_allow_group = FALSE;
631 while (*s != 0 && (s = parse_message_id(s, &id, &error)) != NULL)
632 {
633 if (reference_count == sizeof(referenced_ids)/sizeof(uschar *))
634 {
635 memmove(referenced_ids + 1, referenced_ids + 2,
636 sizeof(referenced_ids) - 2*sizeof(uschar *));
637 referenced_ids[reference_count - 1] = id;
638 }
639 else referenced_ids[reference_count++] = id;
640 }
641 for (i = 0; i < reference_count; ++i) fprintf(f, " %s", referenced_ids[i]);
642 }
643
644 /* The message id will have a newline on the end of it. */
645
0a6c178c
JH
646 if (message_id) fprintf(f, " %s", message_id);
647 else fprintf(f, "\n");
0756eb3c
PH
648 }
649
650/* Add an Auto-Submitted: header */
651
652fprintf(f, "Auto-Submitted: auto-replied\n");
653
654/* Add any specially requested headers */
655
0a6c178c 656if (headers) fprintf(f, "%s\n", headers);
0756eb3c
PH
657fprintf(f, "\n");
658
0a6c178c 659if (text)
0756eb3c
PH
660 {
661 fprintf(f, "%s", CS text);
662 if (text[Ustrlen(text)-1] != '\n') fprintf(f, "\n");
663 }
664
0a6c178c 665if (ff)
0756eb3c
PH
666 {
667 while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
668 {
669 if (file_expand)
670 {
671 uschar *s = expand_string(big_buffer);
672 DEBUG(D_transport)
673 {
0a6c178c 674 if (!s)
0756eb3c
PH
675 debug_printf("error while expanding line from file:\n %s\n %s\n",
676 big_buffer, expand_string_message);
677 }
0a6c178c 678 fprintf(f, "%s", s ? CS s : CS big_buffer);
0756eb3c
PH
679 }
680 else fprintf(f, "%s", CS big_buffer);
681 }
e0eb00cd 682 (void) fclose(ff);
0756eb3c
PH
683 }
684
685/* Copy the original message if required, observing the return size
9f526266 686limit if we are returning the body. */
0756eb3c
PH
687
688if (return_message)
689 {
9f526266
PH
690 uschar *rubric = (tblock->headers_only)?
691 US"------ This is a copy of the message's header lines.\n"
692 : (tblock->body_only)?
693 US"------ This is a copy of the body of the message, without the headers.\n"
694 :
695 US"------ This is a copy of the message, including all the headers.\n";
65de12cc 696 transport_ctx tctx = {
cab0c277 697 {fileno(f)},
65de12cc
JH
698 tblock,
699 addr,
6d5c916c 700 NULL, NULL,
65de12cc
JH
701 (tblock->body_only ? topt_no_headers : 0) |
702 (tblock->headers_only ? topt_no_body : 0) |
703 (tblock->return_path_add ? topt_add_return_path : 0) |
704 (tblock->delivery_date_add ? topt_add_delivery_date : 0) |
705 (tblock->envelope_to_add ? topt_add_envelope_to : 0)
706 };
9f526266
PH
707
708 if (bounce_return_size_limit > 0 && !tblock->headers_only)
0756eb3c
PH
709 {
710 struct stat statbuf;
711 int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
712 DELIVER_IN_BUFFER_SIZE;
713 if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
714 {
9f526266 715 fprintf(f, "\n%s"
b1c749bb 716"------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
9f526266 717"------ %d or so are included here.\n\n", rubric, statbuf.st_size,
0d7eb84a 718 (max/1000)*1000);
0756eb3c 719 }
9f526266 720 else fprintf(f, "\n%s\n", rubric);
0756eb3c 721 }
9f526266 722 else fprintf(f, "\n%s\n", rubric);
0756eb3c
PH
723
724 fflush(f);
725 transport_count = 0;
42055a33 726 transport_write_message(&tctx, bounce_return_size_limit);
0756eb3c
PH
727 }
728
729/* End the message and wait for the child process to end; no timeout. */
730
f1e894f3 731(void)fclose(f);
0756eb3c
PH
732rc = child_close(pid, 0);
733
734/* Update the "sent to" log whatever the yield. This errs on the side of
735missing out a message rather than risking sending more than one. We either have
736cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
737DBM file (or neither, if "once" is not set). */
738
739/* Update fixed-size cache file. If cache_time is set, we found a previous
740entry; that is the spot into which to put the current time. Otherwise we have
741to add a new record; remove the first one in the file if the file is too big.
742We always rewrite the entire file in a single write operation. This is
743(hopefully) going to be the safest thing because there is no interlocking
744between multiple simultaneous deliveries. */
745
746if (cache_fd >= 0)
747 {
748 uschar *from = cache_buff;
749 int size = cache_size;
0756eb3c 750
d315eda1 751 if (lseek(cache_fd, 0, SEEK_SET) == 0)
0756eb3c 752 {
d315eda1 753 if (!cache_time)
0756eb3c 754 {
d315eda1
JH
755 cache_time = from + size;
756 memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
757 size += add_size;
758
759 if (cache_size > 0 && size > ob->once_file_size)
760 {
761 from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
762 size -= (from - cache_buff);
763 }
0756eb3c 764 }
0756eb3c 765
d315eda1
JH
766 memcpy(cache_time, &now, sizeof(time_t));
767 if(write(cache_fd, from, size) != size)
768 DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
769 "transport\n", oncelog, tblock->name);
770 }
0756eb3c
PH
771 }
772
773/* Update DBM file */
774
d315eda1 775else if (dbm_file)
0756eb3c
PH
776 {
777 EXIM_DATUM key_datum, value_datum;
778 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries need to have */
779 EXIM_DATUM_INIT(value_datum); /* cleared datums. */
780 EXIM_DATUM_DATA(key_datum) = CS to;
781 EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
782
783 /* Many OS define the datum value, sensibly, as a void *. However, there
784 are some which still have char *. By casting this address to a char * we
785 can avoid warning messages from the char * systems. */
786
787 EXIM_DATUM_DATA(value_datum) = CS (&now);
788 EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
789 EXIM_DBPUT(dbm_file, key_datum, value_datum);
790 }
791
792/* If sending failed, defer to try again - but if once is set the next
793try will skip, of course. However, if there were no recipients in the
794message, we do not fail. */
795
796if (rc != 0)
0756eb3c
PH
797 if (rc == EXIT_NORECIPIENTS)
798 {
799 DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
800 tblock->name);
801 }
802 else
803 {
804 addr->transport_return = DEFER;
805 addr->message = string_sprintf("Failed to send message from %s "
806 "transport (%d)", tblock->name, rc);
807 goto END_OFF;
808 }
0756eb3c
PH
809
810/* Log the sending of the message if successful and required. If the file
811fails to open, it's hard to know what to do. We cannot write to the Exim
812log from here, since we may be running under an unprivileged uid. We don't
813want to fail the delivery, since the message has been successfully sent. For
814the moment, ignore open failures. Write the log entry as a single write() to a
815file opened for appending, in order to avoid interleaving of output from
816different processes. The log_buffer can be used exactly as for main log
817writing. */
818
0a6c178c 819if (logfile)
0756eb3c
PH
820 {
821 int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
822 if (log_fd >= 0)
823 {
824 uschar *ptr = log_buffer;
825 DEBUG(D_transport) debug_printf("logging message details\n");
826 sprintf(CS ptr, "%s\n", tod_stamp(tod_log));
827 while(*ptr) ptr++;
0a6c178c 828 if (from)
0756eb3c
PH
829 {
830 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
831 " From: %s\n", from);
832 while(*ptr) ptr++;
833 }
0a6c178c 834 if (to)
0756eb3c
PH
835 {
836 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
837 " To: %s\n", to);
838 while(*ptr) ptr++;
839 }
0a6c178c 840 if (cc)
0756eb3c
PH
841 {
842 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
843 " Cc: %s\n", cc);
844 while(*ptr) ptr++;
845 }
0a6c178c 846 if (bcc)
0756eb3c
PH
847 {
848 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
849 " Bcc: %s\n", bcc);
850 while(*ptr) ptr++;
851 }
0a6c178c 852 if (subject)
0756eb3c
PH
853 {
854 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
855 " Subject: %s\n", subject);
856 while(*ptr) ptr++;
857 }
0a6c178c 858 if (headers)
0756eb3c
PH
859 {
860 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
861 " %s\n", headers);
862 while(*ptr) ptr++;
863 }
1ac6b2e7
JH
864 if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
865 || close(log_fd))
866 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
867 "transport\n", logfile, tblock->name);
0756eb3c
PH
868 }
869 else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
870 "transport: %s\n", logfile, tblock->name, strerror(errno));
871 }
872
873END_OFF:
d315eda1 874if (dbm_file) EXIM_DBCLOSE(dbm_file);
f1e894f3 875if (cache_fd > 0) (void)close(cache_fd);
0756eb3c
PH
876
877DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
878
879return FALSE;
880}
881
d185889f 882#endif /*!MACRO_PREDEF*/
0756eb3c 883/* End of transport/autoreply.c */