src/src/transports/autoreply.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2016 */
   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
  66 #ifdef MACRO_PREDEF
  67
  68 /* Dummy values */
  69 autoreply_transport_options_block autoreply_transport_option_defaults = {0};
  70 void autoreply_transport_init(transport_instance *tblock) {}
  71 BOOL autoreply_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
  72
  73 #else   /*!MACRO_PREDEF*/
  74
  75
  76 /* Default private options block for the autoreply transport. */
  77
  78 autoreply_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
 103 enum { 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
 112 enable consistency checks to be done, or anything else that needs
 113 to be set up. */
 114
 115 void
 116 autoreply_transport_init(transport_instance *tblock)
 117 {
 118 /*
 119 autoreply_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
 125 if (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
 138 strings must be checked to ensure they contain only printing characters
 139 and white space. If not, the function fails.
 140
 141 Arguments:
 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
 150 Returns:     expanded string if expansion succeeds;
 151              NULL otherwise
 152 */
 153
 154 static uschar *
 155 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
 156 {
 157 uschar *t;
 158 uschar *ss = expand_string(s);
 159
 160 if (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
 168 if (type != cke_text) for (t = ss; *t != 0; t++)
 169   {
 170   int c = *t;
 171   const uschar * sp;
 172   if (mac_isprint(c)) continue;
 173   if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
 174   sp = string_printing(s);
 175   addr->transport_return = FAIL;
 176   addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
 177     "contains non-printing character %d", sp, name, c);
 178   return NULL;
 179   }
 180
 181 return 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
 192 list. Any that are found are removed.
 193
 194 Arguments:
 195   listptr     points to the list of addresses
 196   never_mail  an address list, already expanded
 197
 198 Returns:      nothing
 199 */
 200
 201 static void
 202 check_never_mail(uschar **listptr, const uschar *never_mail)
 203 {
 204 uschar *s = *listptr;
 205
 206 while (*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
 251 that needs to be removed */
 252
 253 s = *listptr + Ustrlen(*listptr);
 254 while (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
 259 s = *listptr;
 260 while (s != 0 && isspace(*s)) s++;
 261 if (*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
 271 FALSE, indicating that the top address has the status for all - though in fact
 272 this transport can handle only one address at at time anyway. */
 273
 274 BOOL
 275 autoreply_transport_entry(
 276   transport_instance *tblock,      /* data for this instantiation */
 277   address_item *addr)              /* address we are working on */
 278 {
 279 int fd, pid, rc;
 280 int cache_fd = -1;
 281 int cache_size = 0;
 282 int add_size = 0;
 283 EXIM_DB *dbm_file = NULL;
 284 BOOL file_expand, return_message;
 285 uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
 286 uschar *logfile, *oncelog;
 287 uschar *cache_buff = NULL;
 288 uschar *cache_time = NULL;
 289 uschar *message_id = NULL;
 290 header_line *h;
 291 time_t now = time(NULL);
 292 time_t once_repeat_sec = 0;
 293 FILE *f;
 294 FILE *ff = NULL;
 295
 296 autoreply_transport_options_block *ob =
 297   (autoreply_transport_options_block *)(tblock->options_block);
 298
 299 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
 300
 301 /* Set up for the good case */
 302
 303 addr->transport_return = OK;
 304 addr->basic_errno = 0;
 305
 306 /* If the address is pointing to a reply block, then take all the data
 307 from that block. It has typically been set up by a mail filter processing
 308 router. Otherwise, the data must be supplied by this transport, and
 309 it has to be expanded here. */
 310
 311 if (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   }
 330 else
 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
 349   if ((from  != NULL &&
 350         (from = checkexpand(from, addr, tblock->name, cke_hdr)) == NULL) ||
 351       (reply_to    != NULL &&
 352         (reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr)) == NULL) ||
 353       (to    != NULL &&
 354         (to = checkexpand(to, addr, tblock->name, cke_hdr)) == NULL) ||
 355       (cc    != NULL &&
 356         (cc = checkexpand(cc, addr, tblock->name, cke_hdr)) == NULL) ||
 357       (bcc   != NULL &&
 358         (bcc = checkexpand(bcc, addr, tblock->name, cke_hdr)) == NULL) ||
 359       (subject   != NULL &&
 360         (subject = checkexpand(subject, addr, tblock->name, cke_hdr)) == NULL) ||
 361       (headers != NULL &&
 362         (headers = checkexpand(headers, addr, tblock->name, cke_text)) == NULL) ||
 363       (text  != NULL &&
 364         (text = checkexpand(text, addr, tblock->name, cke_text)) == NULL) ||
 365       (file  != NULL &&
 366         (file = checkexpand(file, addr, tblock->name, cke_file)) == NULL) ||
 367       (logfile != NULL &&
 368         (logfile = checkexpand(logfile, addr, tblock->name, cke_file)) == NULL) ||
 369       (oncelog != NULL &&
 370         (oncelog = checkexpand(oncelog, addr, tblock->name, cke_file)) == NULL) ||
 371       (oncerepeat != NULL &&
 372         (oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file)) == NULL))
 373     return FALSE;
 374
 375   if (oncerepeat != NULL)
 376     {
 377     once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE);
 378     if (once_repeat_sec < 0)
 379       {
 380       addr->transport_return = FAIL;
 381       addr->message = string_sprintf("Invalid time value \"%s\" for "
 382         "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
 383       return FALSE;
 384       }
 385     }
 386   }
 387
 388 /* If the never_mail option is set, we have to scan all the recipients and
 389 remove those that match. */
 390
 391 if (ob->never_mail != NULL)
 392   {
 393   const uschar *never_mail = expand_string(ob->never_mail);
 394
 395   if (never_mail == NULL)
 396     {
 397     addr->transport_return = FAIL;
 398     addr->message = string_sprintf("Failed to expand \"%s\" for "
 399       "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
 400     return FALSE;
 401     }
 402
 403   if (to != NULL) check_never_mail(&to, never_mail);
 404   if (cc != NULL) check_never_mail(&cc, never_mail);
 405   if (bcc != NULL) check_never_mail(&bcc, never_mail);
 406
 407   if (to == NULL && cc == NULL && bcc == NULL)
 408     {
 409     DEBUG(D_transport)
 410       debug_printf("*** all recipients removed by never_mail\n");
 411     return OK;
 412     }
 413   }
 414
 415 /* If the -N option is set, can't do any more. */
 416
 417 if (dont_deliver)
 418   {
 419   DEBUG(D_transport)
 420     debug_printf("*** delivery by %s transport bypassed by -N option\n",
 421       tblock->name);
 422   return FALSE;
 423   }
 424
 425
 426 /* If the oncelog field is set, we send want to send only one message to the
 427 given recipient(s). This works only on the "To" field. If there is no "To"
 428 field, the message is always sent. If the To: field contains more than one
 429 recipient, the effect might not be quite as envisaged. If once_file_size is
 430 set, instead of a dbm file, we use a regular file containing a circular buffer
 431 recipient cache. */
 432
 433 if (oncelog != NULL && *oncelog != 0 && to != NULL)
 434   {
 435   time_t then = 0;
 436
 437   /* Handle fixed-size cache file. */
 438
 439   if (ob->once_file_size > 0)
 440     {
 441     uschar *p;
 442     struct stat statbuf;
 443     cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
 444
 445     if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
 446       {
 447       addr->transport_return = DEFER;
 448       addr->message = string_sprintf("Failed to %s \"once\" file %s when "
 449         "sending message from %s transport: %s",
 450         (cache_fd < 0)? "open" : "stat", oncelog, tblock->name,
 451           strerror(errno));
 452       goto END_OFF;
 453       }
 454
 455     /* Get store in the temporary pool and read the entire file into it. We get
 456     an amount of store that is big enough to add the new entry on the end if we
 457     need to do that. */
 458
 459     cache_size = statbuf.st_size;
 460     add_size = sizeof(time_t) + Ustrlen(to) + 1;
 461     cache_buff = store_get(cache_size + add_size);
 462
 463     if (read(cache_fd, cache_buff, cache_size) != cache_size)
 464       {
 465       addr->transport_return = DEFER;
 466       addr->basic_errno = errno;
 467       addr->message = US"error while reading \"once\" file";
 468       goto END_OFF;
 469       }
 470
 471     DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
 472
 473     /* Scan the data for this recipient. Each entry in the file starts with
 474     a time_t sized time value, followed by the address, followed by a binary
 475     zero. If we find a match, put the time into "then", and the place where it
 476     was found into "cache_time". Otherwise, "then" is left at zero. */
 477
 478     p = cache_buff;
 479     while (p < cache_buff + cache_size)
 480       {
 481       uschar *s = p + sizeof(time_t);
 482       uschar *nextp = s + Ustrlen(s) + 1;
 483       if (Ustrcmp(to, s) == 0)
 484         {
 485         memcpy(&then, p, sizeof(time_t));
 486         cache_time = p;
 487         break;
 488         }
 489       p = nextp;
 490       }
 491     }
 492
 493   /* Use a DBM file for the list of previous recipients. */
 494
 495   else
 496     {
 497     EXIM_DATUM key_datum, result_datum;
 498     EXIM_DBOPEN(oncelog, O_RDWR|O_CREAT, ob->mode, &dbm_file);
 499     if (!dbm_file)
 500       {
 501       addr->transport_return = DEFER;
 502       addr->message = string_sprintf("Failed to open %s file %s when sending "
 503         "message from %s transport: %s", EXIM_DBTYPE, oncelog, tblock->name,
 504         strerror(errno));
 505       goto END_OFF;
 506       }
 507
 508     EXIM_DATUM_INIT(key_datum);        /* Some DBM libraries need datums */
 509     EXIM_DATUM_INIT(result_datum);     /* to be cleared */
 510     EXIM_DATUM_DATA(key_datum) = CS to;
 511     EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
 512
 513     if (EXIM_DBGET(dbm_file, key_datum, result_datum))
 514       {
 515       /* If the datum size is that of a binary time, we are in the new world
 516       where messages are sent periodically. Otherwise the file is an old one,
 517       where the datum was filled with a tod_log time, which is assumed to be
 518       different in size. For that, only one message is ever sent. This change
 519       introduced at Exim 3.00. In a couple of years' time the test on the size
 520       can be abolished. */
 521
 522       if (EXIM_DATUM_SIZE(result_datum) == sizeof(time_t))
 523         {
 524         memcpy(&then, EXIM_DATUM_DATA(result_datum), sizeof(time_t));
 525         }
 526       else then = now;
 527       }
 528     }
 529
 530   /* Either "then" is set zero, if no message has yet been sent, or it
 531   is set to the time of the last sending. */
 532
 533   if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
 534     {
 535     int log_fd;
 536     DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
 537       (once_repeat_sec > 0)? " and repeat time not reached" : "");
 538     log_fd = logfile ? Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode) : -1;
 539     if (log_fd >= 0)
 540       {
 541       uschar *ptr = log_buffer;
 542       sprintf(CS ptr, "%s\n  previously sent to %.200s\n", tod_stamp(tod_log), to);
 543       while(*ptr) ptr++;
 544       if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
 545         || close(log_fd))
 546         DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
 547           "transport\n", logfile, tblock->name);
 548       }
 549     goto END_OFF;
 550     }
 551
 552   DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
 553     "no previous message sent to" : "repeat time reached for", to);
 554   }
 555
 556 /* We are going to send a message. Ensure any requested file is available. */
 557
 558 if (file != NULL)
 559   {
 560   ff = Ufopen(file, "rb");
 561   if (ff == NULL && !ob->file_optional)
 562     {
 563     addr->transport_return = DEFER;
 564     addr->message = string_sprintf("Failed to open file %s when sending "
 565       "message from %s transport: %s", file, tblock->name, strerror(errno));
 566     return FALSE;
 567     }
 568   }
 569
 570 /* Make a subprocess to send the message */
 571
 572 pid = child_open_exim(&fd);
 573
 574 /* Creation of child failed; defer this delivery. */
 575
 576 if (pid < 0)
 577   {
 578   addr->transport_return = DEFER;
 579   addr->message = string_sprintf("Failed to create child process to send "
 580     "message from %s transport: %s", tblock->name, strerror(errno));
 581   DEBUG(D_transport) debug_printf("%s\n", addr->message);
 582   return FALSE;
 583   }
 584
 585 /* Create the message to be sent - recipients are taken from the headers,
 586 as the -t option is used. The "headers" stuff *must* be last in case there
 587 are newlines in it which might, if placed earlier, screw up other headers. */
 588
 589 f = fdopen(fd, "wb");
 590
 591 if (from != NULL) fprintf(f, "From: %s\n", from);
 592 if (reply_to != NULL) fprintf(f, "Reply-To: %s\n", reply_to);
 593 if (to != NULL) fprintf(f, "To: %s\n", to);
 594 if (cc != NULL) fprintf(f, "Cc: %s\n", cc);
 595 if (bcc != NULL) fprintf(f, "Bcc: %s\n", bcc);
 596 if (subject != NULL) fprintf(f, "Subject: %s\n", subject);
 597
 598 /* Generate In-Reply-To from the message_id header; there should
 599 always be one, but code defensively. */
 600
 601 for (h = header_list; h != NULL; h = h->next)
 602   if (h->type == htype_id) break;
 603
 604 if (h != NULL)
 605   {
 606   message_id = Ustrchr(h->text, ':') + 1;
 607   while (isspace(*message_id)) message_id++;
 608   fprintf(f, "In-Reply-To: %s", message_id);
 609   }
 610
 611 /* Generate a References header if there is at least one of Message-ID:,
 612 References:, or In-Reply-To: (see RFC 2822). */
 613
 614 for (h = header_list; h != NULL; h = h->next)
 615   if (h->type != htype_old && strncmpic(US"References:", h->text, 11) == 0)
 616     break;
 617
 618 if (h == NULL)
 619   for (h = header_list; h != NULL; h = h->next)
 620     if (h->type != htype_old && strncmpic(US"In-Reply-To:", h->text, 12) == 0)
 621       break;
 622
 623 /* We limit the total length of references.  Although there is no fixed
 624 limit, some systems do not like headers growing beyond recognition.
 625 Keep the first message ID for the thread root and the last few for
 626 the position inside the thread, up to a maximum of 12 altogether. */
 627
 628 if (h != NULL || message_id != NULL)
 629   {
 630   fprintf(f, "References:");
 631   if (h != NULL)
 632     {
 633     uschar *s, *id, *error;
 634     uschar *referenced_ids[12];
 635     int reference_count = 0;
 636     int i;
 637
 638     s = Ustrchr(h->text, ':') + 1;
 639     parse_allow_group = FALSE;
 640     while (*s != 0 && (s = parse_message_id(s, &id, &error)) != NULL)
 641       {
 642       if (reference_count == sizeof(referenced_ids)/sizeof(uschar *))
 643         {
 644         memmove(referenced_ids + 1, referenced_ids + 2,
 645            sizeof(referenced_ids) - 2*sizeof(uschar *));
 646         referenced_ids[reference_count - 1] = id;
 647         }
 648       else referenced_ids[reference_count++] = id;
 649       }
 650     for (i = 0; i < reference_count; ++i) fprintf(f, " %s", referenced_ids[i]);
 651     }
 652
 653   /* The message id will have a newline on the end of it. */
 654
 655   if (message_id != NULL) fprintf(f, " %s", message_id);
 656     else fprintf(f, "\n");
 657   }
 658
 659 /* Add an Auto-Submitted: header */
 660
 661 fprintf(f, "Auto-Submitted: auto-replied\n");
 662
 663 /* Add any specially requested headers */
 664
 665 if (headers != NULL) fprintf(f, "%s\n", headers);
 666 fprintf(f, "\n");
 667
 668 if (text != NULL)
 669   {
 670   fprintf(f, "%s", CS text);
 671   if (text[Ustrlen(text)-1] != '\n') fprintf(f, "\n");
 672   }
 673
 674 if (ff != NULL)
 675   {
 676   while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
 677     {
 678     if (file_expand)
 679       {
 680       uschar *s = expand_string(big_buffer);
 681       DEBUG(D_transport)
 682         {
 683         if (s == NULL)
 684           debug_printf("error while expanding line from file:\n  %s\n  %s\n",
 685             big_buffer, expand_string_message);
 686         }
 687       fprintf(f, "%s", (s == NULL)? CS big_buffer : CS s);
 688       }
 689     else fprintf(f, "%s", CS big_buffer);
 690     }
 691   (void) fclose(ff);
 692   }
 693
 694 /* Copy the original message if required, observing the return size
 695 limit if we are returning the body. */
 696
 697 if (return_message)
 698   {
 699   uschar *rubric = (tblock->headers_only)?
 700     US"------ This is a copy of the message's header lines.\n"
 701     : (tblock->body_only)?
 702     US"------ This is a copy of the body of the message, without the headers.\n"
 703     :
 704     US"------ This is a copy of the message, including all the headers.\n";
 705   transport_ctx tctx = {
 706     fileno(f),
 707     tblock,
 708     addr,
 709     NULL, NULL,
 710     (tblock->body_only ? topt_no_headers : 0) |
 711     (tblock->headers_only ? topt_no_body : 0) |
 712     (tblock->return_path_add ? topt_add_return_path : 0) |
 713     (tblock->delivery_date_add ? topt_add_delivery_date : 0) |
 714     (tblock->envelope_to_add ? topt_add_envelope_to : 0)
 715   };
 716
 717   if (bounce_return_size_limit > 0 && !tblock->headers_only)
 718     {
 719     struct stat statbuf;
 720     int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
 721       DELIVER_IN_BUFFER_SIZE;
 722     if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
 723       {
 724       fprintf(f, "\n%s"
 725 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
 726 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
 727         (max/1000)*1000);
 728       }
 729     else fprintf(f, "\n%s\n", rubric);
 730     }
 731   else fprintf(f, "\n%s\n", rubric);
 732
 733   fflush(f);
 734   transport_count = 0;
 735   transport_write_message(&tctx, bounce_return_size_limit);
 736   }
 737
 738 /* End the message and wait for the child process to end; no timeout. */
 739
 740 (void)fclose(f);
 741 rc = child_close(pid, 0);
 742
 743 /* Update the "sent to" log whatever the yield. This errs on the side of
 744 missing out a message rather than risking sending more than one. We either have
 745 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
 746 DBM file (or neither, if "once" is not set). */
 747
 748 /* Update fixed-size cache file. If cache_time is set, we found a previous
 749 entry; that is the spot into which to put the current time. Otherwise we have
 750 to add a new record; remove the first one in the file if the file is too big.
 751 We always rewrite the entire file in a single write operation. This is
 752 (hopefully) going to be the safest thing because there is no interlocking
 753 between multiple simultaneous deliveries. */
 754
 755 if (cache_fd >= 0)
 756   {
 757   uschar *from = cache_buff;
 758   int size = cache_size;
 759
 760   if (lseek(cache_fd, 0, SEEK_SET) == 0)
 761     {
 762     if (!cache_time)
 763       {
 764       cache_time = from + size;
 765       memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
 766       size += add_size;
 767
 768       if (cache_size > 0 && size > ob->once_file_size)
 769         {
 770         from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
 771         size -= (from - cache_buff);
 772         }
 773       }
 774
 775     memcpy(cache_time, &now, sizeof(time_t));
 776     if(write(cache_fd, from, size) != size)
 777       DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
 778         "transport\n", oncelog, tblock->name);
 779     }
 780   }
 781
 782 /* Update DBM file */
 783
 784 else if (dbm_file)
 785   {
 786   EXIM_DATUM key_datum, value_datum;
 787   EXIM_DATUM_INIT(key_datum);          /* Some DBM libraries need to have */
 788   EXIM_DATUM_INIT(value_datum);        /* cleared datums. */
 789   EXIM_DATUM_DATA(key_datum) = CS to;
 790   EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
 791
 792   /* Many OS define the datum value, sensibly, as a void *. However, there
 793   are some which still have char *. By casting this address to a char * we
 794   can avoid warning messages from the char * systems. */
 795
 796   EXIM_DATUM_DATA(value_datum) = CS (&now);
 797   EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
 798   EXIM_DBPUT(dbm_file, key_datum, value_datum);
 799   }
 800
 801 /* If sending failed, defer to try again - but if once is set the next
 802 try will skip, of course. However, if there were no recipients in the
 803 message, we do not fail. */
 804
 805 if (rc != 0)
 806   {
 807   if (rc == EXIT_NORECIPIENTS)
 808     {
 809     DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
 810       tblock->name);
 811     }
 812   else
 813     {
 814     addr->transport_return = DEFER;
 815     addr->message = string_sprintf("Failed to send message from %s "
 816       "transport (%d)", tblock->name, rc);
 817     goto END_OFF;
 818     }
 819   }
 820
 821 /* Log the sending of the message if successful and required. If the file
 822 fails to open, it's hard to know what to do. We cannot write to the Exim
 823 log from here, since we may be running under an unprivileged uid. We don't
 824 want to fail the delivery, since the message has been successfully sent. For
 825 the moment, ignore open failures. Write the log entry as a single write() to a
 826 file opened for appending, in order to avoid interleaving of output from
 827 different processes. The log_buffer can be used exactly as for main log
 828 writing. */
 829
 830 if (logfile != NULL)
 831   {
 832   int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
 833   if (log_fd >= 0)
 834     {
 835     uschar *ptr = log_buffer;
 836     DEBUG(D_transport) debug_printf("logging message details\n");
 837     sprintf(CS ptr, "%s\n", tod_stamp(tod_log));
 838     while(*ptr) ptr++;
 839     if (from != NULL)
 840       {
 841       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 842         "  From: %s\n", from);
 843       while(*ptr) ptr++;
 844       }
 845     if (to != NULL)
 846       {
 847       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 848         "  To: %s\n", to);
 849       while(*ptr) ptr++;
 850       }
 851     if (cc != NULL)
 852       {
 853       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 854         "  Cc: %s\n", cc);
 855       while(*ptr) ptr++;
 856       }
 857     if (bcc != NULL)
 858       {
 859       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 860         "  Bcc: %s\n", bcc);
 861       while(*ptr) ptr++;
 862       }
 863     if (subject != NULL)
 864       {
 865       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 866         "  Subject: %s\n", subject);
 867       while(*ptr) ptr++;
 868       }
 869     if (headers != NULL)
 870       {
 871       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 872         "  %s\n", headers);
 873       while(*ptr) ptr++;
 874       }
 875     if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
 876       || close(log_fd))
 877       DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
 878         "transport\n", logfile, tblock->name);
 879     }
 880   else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
 881     "transport: %s\n", logfile, tblock->name, strerror(errno));
 882   }
 883
 884 END_OFF:
 885 if (dbm_file) EXIM_DBCLOSE(dbm_file);
 886 if (cache_fd > 0) (void)close(cache_fd);
 887
 888 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
 889
 890 return FALSE;
 891 }
 892
 893 #endif  /*!MACRO_PREDEF*/
 894 /* End of transport/autoreply.c */