src/src/transports/autoreply.c

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