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