src/src/transports/autoreply.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2009 */
   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   if (mac_isprint(c)) continue;
 161   if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
 162   s = string_printing(s);
 163   addr->transport_return = FAIL;
 164   addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
 165     "contains non-printing character %d", s, name, c);
 166   return NULL;
 167   }
 168
 169 return ss;
 170 }
 171
 172
 173
 174
 175 /*************************************************
 176 *          Check a header line for never_mail    *
 177 *************************************************/
 178
 179 /* This is called to check to, cc, and bcc for addresses in the never_mail
 180 list. Any that are found are removed.
 181
 182 Arguments:
 183   listptr     points to the list of addresses
 184   never_mail  an address list, already expanded
 185
 186 Returns:      nothing
 187 */
 188
 189 static void
 190 check_never_mail(uschar **listptr, uschar *never_mail)
 191 {
 192 uschar *s = *listptr;
 193
 194 while (*s != 0)
 195   {
 196   uschar *error, *next;
 197   uschar *e = parse_find_address_end(s, FALSE);
 198   int terminator = *e;
 199   int start, end, domain, rc;
 200
 201   /* Temporarily terminate the string at the address end while extracting
 202   the operative address within. */
 203
 204   *e = 0;
 205   next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
 206   *e = terminator;
 207
 208   /* If there is some kind of syntax error, just give up on this header
 209   line. */
 210
 211   if (next == NULL) break;
 212
 213   /* See if the address is on the never_mail list */
 214
 215   rc = match_address_list(next,         /* address to check */
 216                           TRUE,         /* start caseless */
 217                           FALSE,        /* don't expand the list */
 218                           &never_mail,  /* the list */
 219                           NULL,         /* no caching */
 220                           -1,           /* no expand setup */
 221                           0,            /* separator from list */
 222                           NULL);        /* no lookup value return */
 223
 224   if (rc == OK)                         /* Remove this address */
 225     {
 226     DEBUG(D_transport)
 227       debug_printf("discarding recipient %s (matched never_mail)\n", next);
 228     if (terminator == ',') e++;
 229     memmove(s, e, Ustrlen(e) + 1);
 230     }
 231   else                                  /* Skip over this address */
 232     {
 233     s = e;
 234     if (terminator == ',') s++;
 235     }
 236   }
 237
 238 /* Check to see if we removed the last address, leaving a terminating comma
 239 that needs to be removed */
 240
 241 s = *listptr + Ustrlen(*listptr);
 242 while (s > *listptr && (isspace(s[-1]) || s[-1] == ',')) s--;
 243 *s = 0;
 244
 245 /* Check to see if there any addresses left; if not, set NULL */
 246
 247 s = *listptr;
 248 while (s != 0 && isspace(*s)) s++;
 249 if (*s == 0) *listptr = NULL;
 250 }
 251
 252
 253
 254 /*************************************************
 255 *              Main entry point                  *
 256 *************************************************/
 257
 258 /* See local README for interface details. This transport always returns
 259 FALSE, indicating that the top address has the status for all - though in fact
 260 this transport can handle only one address at at time anyway. */
 261
 262 BOOL
 263 autoreply_transport_entry(
 264   transport_instance *tblock,      /* data for this instantiation */
 265   address_item *addr)              /* address we are working on */
 266 {
 267 int fd, pid, rc;
 268 int cache_fd = -1;
 269 int log_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   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     DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
 525       (once_repeat_sec > 0)? " and repeat time not reached" : "");
 526     log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
 527     if (log_fd >= 0)
 528       {
 529       uschar *ptr = log_buffer;
 530       sprintf(CS ptr, "%s\n  previously sent to %.200s\n", tod_stamp(tod_log), to);
 531       while(*ptr) ptr++;
 532       if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
 533         || close(log_fd))
 534         DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
 535           "transport\n", logfile, tblock->name);
 536       }
 537     goto END_OFF;
 538     }
 539
 540   DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
 541     "no previous message sent to" : "repeat time reached for", to);
 542   }
 543
 544 /* We are going to send a message. Ensure any requested file is available. */
 545
 546 if (file != NULL)
 547   {
 548   ff = Ufopen(file, "rb");
 549   if (ff == NULL && !ob->file_optional)
 550     {
 551     addr->transport_return = DEFER;
 552     addr->message = string_sprintf("Failed to open file %s when sending "
 553       "message from %s transport: %s", file, tblock->name, strerror(errno));
 554     return FALSE;
 555     }
 556   }
 557
 558 /* Make a subprocess to send the message */
 559
 560 pid = child_open_exim(&fd);
 561
 562 /* Creation of child failed; defer this delivery. */
 563
 564 if (pid < 0)
 565   {
 566   addr->transport_return = DEFER;
 567   addr->message = string_sprintf("Failed to create child process to send "
 568     "message from %s transport: %s", tblock->name, strerror(errno));
 569   DEBUG(D_transport) debug_printf("%s\n", addr->message);
 570   return FALSE;
 571   }
 572
 573 /* Create the message to be sent - recipients are taken from the headers,
 574 as the -t option is used. The "headers" stuff *must* be last in case there
 575 are newlines in it which might, if placed earlier, screw up other headers. */
 576
 577 f = fdopen(fd, "wb");
 578
 579 if (from != NULL) fprintf(f, "From: %s\n", from);
 580 if (reply_to != NULL) fprintf(f, "Reply-To: %s\n", reply_to);
 581 if (to != NULL) fprintf(f, "To: %s\n", to);
 582 if (cc != NULL) fprintf(f, "Cc: %s\n", cc);
 583 if (bcc != NULL) fprintf(f, "Bcc: %s\n", bcc);
 584 if (subject != NULL) fprintf(f, "Subject: %s\n", subject);
 585
 586 /* Generate In-Reply-To from the message_id header; there should
 587 always be one, but code defensively. */
 588
 589 for (h = header_list; h != NULL; h = h->next)
 590   if (h->type == htype_id) break;
 591
 592 if (h != NULL)
 593   {
 594   message_id = Ustrchr(h->text, ':') + 1;
 595   while (isspace(*message_id)) message_id++;
 596   fprintf(f, "In-Reply-To: %s", message_id);
 597   }
 598
 599 /* Generate a References header if there is at least one of Message-ID:,
 600 References:, or In-Reply-To: (see RFC 2822). */
 601
 602 for (h = header_list; h != NULL; h = h->next)
 603   if (h->type != htype_old && strncmpic(US"References:", h->text, 11) == 0)
 604     break;
 605
 606 if (h == NULL)
 607   for (h = header_list; h != NULL; h = h->next)
 608     if (h->type != htype_old && strncmpic(US"In-Reply-To:", h->text, 12) == 0)
 609       break;
 610
 611 /* We limit the total length of references.  Although there is no fixed
 612 limit, some systems do not like headers growing beyond recognition.
 613 Keep the first message ID for the thread root and the last few for
 614 the position inside the thread, up to a maximum of 12 altogether. */
 615
 616 if (h != NULL || message_id != NULL)
 617   {
 618   fprintf(f, "References:");
 619   if (h != NULL)
 620     {
 621     uschar *s, *id, *error;
 622     uschar *referenced_ids[12];
 623     int reference_count = 0;
 624     int i;
 625
 626     s = Ustrchr(h->text, ':') + 1;
 627     parse_allow_group = FALSE;
 628     while (*s != 0 && (s = parse_message_id(s, &id, &error)) != NULL)
 629       {
 630       if (reference_count == sizeof(referenced_ids)/sizeof(uschar *))
 631         {
 632         memmove(referenced_ids + 1, referenced_ids + 2,
 633            sizeof(referenced_ids) - 2*sizeof(uschar *));
 634         referenced_ids[reference_count - 1] = id;
 635         }
 636       else referenced_ids[reference_count++] = id;
 637       }
 638     for (i = 0; i < reference_count; ++i) fprintf(f, " %s", referenced_ids[i]);
 639     }
 640
 641   /* The message id will have a newline on the end of it. */
 642
 643   if (message_id != NULL) fprintf(f, " %s", message_id);
 644     else fprintf(f, "\n");
 645   }
 646
 647 /* Add an Auto-Submitted: header */
 648
 649 fprintf(f, "Auto-Submitted: auto-replied\n");
 650
 651 /* Add any specially requested headers */
 652
 653 if (headers != NULL) fprintf(f, "%s\n", headers);
 654 fprintf(f, "\n");
 655
 656 if (text != NULL)
 657   {
 658   fprintf(f, "%s", CS text);
 659   if (text[Ustrlen(text)-1] != '\n') fprintf(f, "\n");
 660   }
 661
 662 if (ff != NULL)
 663   {
 664   while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
 665     {
 666     if (file_expand)
 667       {
 668       uschar *s = expand_string(big_buffer);
 669       DEBUG(D_transport)
 670         {
 671         if (s == NULL)
 672           debug_printf("error while expanding line from file:\n  %s\n  %s\n",
 673             big_buffer, expand_string_message);
 674         }
 675       fprintf(f, "%s", (s == NULL)? CS big_buffer : CS s);
 676       }
 677     else fprintf(f, "%s", CS big_buffer);
 678     }
 679   (void) fclose(ff);
 680   }
 681
 682 /* Copy the original message if required, observing the return size
 683 limit if we are returning the body. */
 684
 685 if (return_message)
 686   {
 687   uschar *rubric = (tblock->headers_only)?
 688     US"------ This is a copy of the message's header lines.\n"
 689     : (tblock->body_only)?
 690     US"------ This is a copy of the body of the message, without the headers.\n"
 691     :
 692     US"------ This is a copy of the message, including all the headers.\n";
 693
 694   if (bounce_return_size_limit > 0 && !tblock->headers_only)
 695     {
 696     struct stat statbuf;
 697     int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
 698       DELIVER_IN_BUFFER_SIZE;
 699     if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
 700       {
 701       fprintf(f, "\n%s"
 702 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
 703 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
 704         (max/1000)*1000);
 705       }
 706     else fprintf(f, "\n%s\n", rubric);
 707     }
 708   else fprintf(f, "\n%s\n", rubric);
 709
 710   fflush(f);
 711   transport_count = 0;
 712   transport_write_message(addr, fileno(f),
 713     (tblock->body_only? topt_no_headers : 0) |
 714     (tblock->headers_only? topt_no_body : 0) |
 715     (tblock->return_path_add? topt_add_return_path : 0) |
 716     (tblock->delivery_date_add? topt_add_delivery_date : 0) |
 717     (tblock->envelope_to_add? topt_add_envelope_to : 0),
 718     bounce_return_size_limit, tblock->add_headers, tblock->remove_headers,
 719     NULL, NULL, tblock->rewrite_rules, tblock->rewrite_existflags);
 720   }
 721
 722 /* End the message and wait for the child process to end; no timeout. */
 723
 724 (void)fclose(f);
 725 rc = child_close(pid, 0);
 726
 727 /* Update the "sent to" log whatever the yield. This errs on the side of
 728 missing out a message rather than risking sending more than one. We either have
 729 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
 730 DBM file (or neither, if "once" is not set). */
 731
 732 /* Update fixed-size cache file. If cache_time is set, we found a previous
 733 entry; that is the spot into which to put the current time. Otherwise we have
 734 to add a new record; remove the first one in the file if the file is too big.
 735 We always rewrite the entire file in a single write operation. This is
 736 (hopefully) going to be the safest thing because there is no interlocking
 737 between multiple simultaneous deliveries. */
 738
 739 if (cache_fd >= 0)
 740   {
 741   uschar *from = cache_buff;
 742   int size = cache_size;
 743   (void)lseek(cache_fd, 0, SEEK_SET);
 744
 745   if (cache_time == NULL)
 746     {
 747     cache_time = from + size;
 748     memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
 749     size += add_size;
 750
 751     if (cache_size > 0 && size > ob->once_file_size)
 752       {
 753       from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
 754       size -= (from - cache_buff);
 755       }
 756     }
 757
 758   memcpy(cache_time, &now, sizeof(time_t));
 759   if(write(cache_fd, from, size) != size)
 760     DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
 761       "transport\n", oncelog, tblock->name);
 762   }
 763
 764 /* Update DBM file */
 765
 766 else if (dbm_file != NULL)
 767   {
 768   EXIM_DATUM key_datum, value_datum;
 769   EXIM_DATUM_INIT(key_datum);          /* Some DBM libraries need to have */
 770   EXIM_DATUM_INIT(value_datum);        /* cleared datums. */
 771   EXIM_DATUM_DATA(key_datum) = CS to;
 772   EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
 773
 774   /* Many OS define the datum value, sensibly, as a void *. However, there
 775   are some which still have char *. By casting this address to a char * we
 776   can avoid warning messages from the char * systems. */
 777
 778   EXIM_DATUM_DATA(value_datum) = CS (&now);
 779   EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
 780   EXIM_DBPUT(dbm_file, key_datum, value_datum);
 781   }
 782
 783 /* If sending failed, defer to try again - but if once is set the next
 784 try will skip, of course. However, if there were no recipients in the
 785 message, we do not fail. */
 786
 787 if (rc != 0)
 788   {
 789   if (rc == EXIT_NORECIPIENTS)
 790     {
 791     DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
 792       tblock->name);
 793     }
 794   else
 795     {
 796     addr->transport_return = DEFER;
 797     addr->message = string_sprintf("Failed to send message from %s "
 798       "transport (%d)", tblock->name, rc);
 799     goto END_OFF;
 800     }
 801   }
 802
 803 /* Log the sending of the message if successful and required. If the file
 804 fails to open, it's hard to know what to do. We cannot write to the Exim
 805 log from here, since we may be running under an unprivileged uid. We don't
 806 want to fail the delivery, since the message has been successfully sent. For
 807 the moment, ignore open failures. Write the log entry as a single write() to a
 808 file opened for appending, in order to avoid interleaving of output from
 809 different processes. The log_buffer can be used exactly as for main log
 810 writing. */
 811
 812 if (logfile != NULL)
 813   {
 814   int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
 815   if (log_fd >= 0)
 816     {
 817     uschar *ptr = log_buffer;
 818     DEBUG(D_transport) debug_printf("logging message details\n");
 819     sprintf(CS ptr, "%s\n", tod_stamp(tod_log));
 820     while(*ptr) ptr++;
 821     if (from != NULL)
 822       {
 823       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 824         "  From: %s\n", from);
 825       while(*ptr) ptr++;
 826       }
 827     if (to != NULL)
 828       {
 829       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 830         "  To: %s\n", to);
 831       while(*ptr) ptr++;
 832       }
 833     if (cc != NULL)
 834       {
 835       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 836         "  Cc: %s\n", cc);
 837       while(*ptr) ptr++;
 838       }
 839     if (bcc != NULL)
 840       {
 841       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 842         "  Bcc: %s\n", bcc);
 843       while(*ptr) ptr++;
 844       }
 845     if (subject != NULL)
 846       {
 847       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 848         "  Subject: %s\n", subject);
 849       while(*ptr) ptr++;
 850       }
 851     if (headers != NULL)
 852       {
 853       (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 854         "  %s\n", headers);
 855       while(*ptr) ptr++;
 856       }
 857     if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
 858       || close(log_fd))
 859       DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
 860         "transport\n", logfile, tblock->name);
 861     }
 862   else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
 863     "transport: %s\n", logfile, tblock->name, strerror(errno));
 864   }
 865
 866 END_OFF:
 867 if (dbm_file != NULL) EXIM_DBCLOSE(dbm_file);
 868 if (cache_fd > 0) (void)close(cache_fd);
 869
 870 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
 871
 872 return FALSE;
 873 }
 874
 875 /* End of transport/autoreply.c */