d2e556e32a18e54870c59cc34bcb81b96f543232
[exim.git] / src / src / receive.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Code for receiving a message and setting up spool files. */
10
11 #include "exim.h"
12 #include <setjmp.h>
13
14 #ifdef EXPERIMENTAL_DCC
15 extern int dcc_ok;
16 #endif
17
18 #ifdef SUPPORT_DMARC
19 # include "dmarc.h"
20 #endif
21
22 /*************************************************
23 *                Local static variables          *
24 *************************************************/
25
26 static int     data_fd = -1;
27 static uschar *spool_name = US"";
28
29 enum CH_STATE {LF_SEEN, MID_LINE, CR_SEEN};
30
31 #ifdef HAVE_LOCAL_SCAN
32 jmp_buf local_scan_env;         /* error-handling context for local_scan */
33 unsigned had_local_scan_crash;
34 unsigned had_local_scan_timeout;
35 #endif
36
37
38 /*************************************************
39 *      Non-SMTP character reading functions      *
40 *************************************************/
41
42 /* These are the default functions that are set up in the variables such as
43 receive_getc initially. They just call the standard functions, passing stdin as
44 the file. (When SMTP input is occurring, different functions are used by
45 changing the pointer variables.) */
46
47 uschar stdin_buf[4096];
48 uschar * stdin_inptr = stdin_buf;
49 uschar * stdin_inend = stdin_buf;
50
51 static BOOL
52 stdin_refill(void)
53 {
54 size_t rc = fread(stdin_buf, 1, sizeof(stdin_buf), stdin);
55 if (rc <= 0)
56   {
57   if (had_data_timeout)
58     {
59     fprintf(stderr, "exim: timed out while reading - message abandoned\n");
60     log_write(L_lost_incoming_connection,
61               LOG_MAIN, "timed out while reading local message");
62     receive_bomb_out(US"data-timeout", NULL);   /* Does not return */
63     }
64   if (had_data_sigint)
65     {
66     if (filter_test == FTEST_NONE)
67       {
68       fprintf(stderr, "\nexim: %s received - message abandoned\n",
69         had_data_sigint == SIGTERM ? "SIGTERM" : "SIGINT");
70       log_write(0, LOG_MAIN, "%s received while reading local message",
71         had_data_sigint == SIGTERM ? "SIGTERM" : "SIGINT");
72       }
73     receive_bomb_out(US"signal-exit", NULL);    /* Does not return */
74     }
75   return FALSE;
76   }
77 stdin_inend = stdin_buf + rc;
78 stdin_inptr = stdin_buf;
79 return TRUE;
80 }
81
82 int
83 stdin_getc(unsigned lim)
84 {
85 if (stdin_inptr >= stdin_inend)
86   if (!stdin_refill())
87       return EOF;
88 return *stdin_inptr++;
89 }
90
91
92 BOOL
93 stdin_hasc(void)
94 {
95 return stdin_inptr < stdin_inend;
96 }
97
98 int
99 stdin_ungetc(int c)
100 {
101 if (stdin_inptr <= stdin_buf)
102   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "buffer underflow in stdin_ungetc");
103
104 *--stdin_inptr = c;
105 return c;
106 }
107
108 int
109 stdin_feof(void)
110 {
111 return stdin_hasc() ? FALSE : feof(stdin);
112 }
113
114 int
115 stdin_ferror(void)
116 {
117 return ferror(stdin);
118 }
119
120
121
122
123 /*************************************************
124 *     Check that a set sender is allowed         *
125 *************************************************/
126
127 /* This function is called when a local caller sets an explicit sender address.
128 It checks whether this is permitted, which it is for trusted callers.
129 Otherwise, it must match the pattern(s) in untrusted_set_sender.
130
131 Arguments:  the proposed sender address
132 Returns:    TRUE for a trusted caller
133             TRUE if the address has been set, untrusted_set_sender has been
134               set, and the address matches something in the list
135             FALSE otherwise
136 */
137
138 BOOL
139 receive_check_set_sender(uschar *newsender)
140 {
141 uschar *qnewsender;
142 if (f.trusted_caller) return TRUE;
143 if (!newsender || !untrusted_set_sender) return FALSE;
144 qnewsender = Ustrchr(newsender, '@')
145   ? newsender : string_sprintf("%s@%s", newsender, qualify_domain_sender);
146 return match_address_list_basic(qnewsender, CUSS &untrusted_set_sender, 0) == OK;
147 }
148
149
150
151
152 /*************************************************
153 *          Read space info for a partition       *
154 *************************************************/
155
156 /* This function is called by receive_check_fs() below, and also by string
157 expansion for variables such as $spool_space. The field names for the statvfs
158 structure are macros, because not all OS have F_FAVAIL and it seems tidier to
159 have macros for F_BAVAIL and F_FILES as well. Some kinds of file system do not
160 have inodes, and they return -1 for the number available.
161
162 Later: It turns out that some file systems that do not have the concept of
163 inodes return 0 rather than -1. Such systems should also return 0 for the total
164 number of inodes, so we require that to be greater than zero before returning
165 an inode count.
166
167 Arguments:
168   isspool       TRUE for spool partition, FALSE for log partition
169   inodeptr      address of int to receive inode count; -1 if there isn't one
170
171 Returns:        available on-root space, in kilobytes
172                 -1 for log partition if there isn't one
173
174 All values are -1 if the STATFS functions are not available.
175 */
176
177 int_eximarith_t
178 receive_statvfs(BOOL isspool, int *inodeptr)
179 {
180 #ifdef HAVE_STATFS
181 struct STATVFS statbuf;
182 struct stat dummy;
183 uschar *path;
184 uschar *name;
185 uschar buffer[1024];
186
187 /* The spool directory must always exist. */
188
189 if (isspool)
190   {
191   path = spool_directory;
192   name = US"spool";
193   }
194
195 /* Need to cut down the log file path to the directory, and to ignore any
196 appearance of "syslog" in it. */
197
198 else
199   {
200   int sep = ':';              /* Not variable - outside scripts use */
201   const uschar *p = log_file_path;
202   name = US"log";
203
204   /* An empty log_file_path means "use the default". This is the same as an
205   empty item in a list. */
206
207   if (*p == 0) p = US":";
208   /* should never be a tainted list */
209   while ((path = string_nextinlist(&p, &sep, buffer, sizeof(buffer))))
210     if (Ustrcmp(path, "syslog") != 0)
211       break;
212
213   if (path == NULL)  /* No log files */
214     {
215     *inodeptr = -1;
216     return -1;
217     }
218
219   /* An empty string means use the default, which is in the spool directory.
220   But don't just use the spool directory, as it is possible that the log
221   subdirectory has been symbolically linked elsewhere. */
222
223   if (path[0] == 0)
224     {
225     sprintf(CS buffer, CS"%s/log", CS spool_directory);
226     path = buffer;
227     }
228   else
229     {
230     uschar *cp;
231     if ((cp = Ustrrchr(path, '/')) != NULL) *cp = 0;
232     }
233   }
234
235 /* We now have the path; do the business */
236
237 memset(&statbuf, 0, sizeof(statbuf));
238
239 if (STATVFS(CS path, &statbuf) != 0)
240   if (stat(CS path, &dummy) == -1 && errno == ENOENT)
241     {                           /* Can happen on first run after installation */
242     *inodeptr = -1;
243     return -1;
244     }
245   else
246     {
247     log_write(0, LOG_MAIN|LOG_PANIC, "cannot accept message: failed to stat "
248       "%s directory %s: %s", name, path, strerror(errno));
249     smtp_closedown(US"spool or log directory problem");
250     exim_exit(EXIT_FAILURE);
251     }
252
253 *inodeptr = (statbuf.F_FILES > 0)? statbuf.F_FAVAIL : -1;
254
255 /* Disks are getting huge. Take care with computing the size in kilobytes. */
256
257 return (int_eximarith_t)(((double)statbuf.F_BAVAIL * (double)statbuf.F_FRSIZE)/1024.0);
258
259 #else
260 /* Unable to find partition sizes in this environment. */
261
262 *inodeptr = -1;
263 return -1;
264 #endif
265 }
266
267
268
269
270 /*************************************************
271 *     Check space on spool and log partitions    *
272 *************************************************/
273
274 /* This function is called before accepting a message; if any thresholds are
275 set, it checks them. If a message_size is supplied, it checks that there is
276 enough space for that size plus the threshold - i.e. that the message won't
277 reduce the space to the threshold. Not all OS have statvfs(); for those that
278 don't, this function always returns TRUE. For some OS the old function and
279 struct name statfs is used; that is handled by a macro, defined in exim.h.
280
281 Arguments:
282   msg_size     the (estimated) size of an incoming message
283
284 Returns:       FALSE if there isn't enough space, or if the information cannot
285                  be obtained
286                TRUE if no check was done or there is enough space
287 */
288
289 BOOL
290 receive_check_fs(int msg_size)
291 {
292 int_eximarith_t space;
293 int inodes;
294
295 if (check_spool_space > 0 || msg_size > 0 || check_spool_inodes > 0)
296   {
297   space = receive_statvfs(TRUE, &inodes);
298
299   DEBUG(D_receive)
300     debug_printf("spool directory space = " PR_EXIM_ARITH "K inodes = %d "
301       "check_space = " PR_EXIM_ARITH "K inodes = %d msg_size = %d\n",
302       space, inodes, check_spool_space, check_spool_inodes, msg_size);
303
304   if (  space >= 0 && space + msg_size / 1024 < check_spool_space
305      || inodes >= 0 && inodes < check_spool_inodes)
306     {
307     log_write(0, LOG_MAIN, "spool directory space check failed: space="
308       PR_EXIM_ARITH " inodes=%d", space, inodes);
309     return FALSE;
310     }
311   }
312
313 if (check_log_space > 0 || check_log_inodes > 0)
314   {
315   space = receive_statvfs(FALSE, &inodes);
316
317   DEBUG(D_receive)
318     debug_printf("log directory space = " PR_EXIM_ARITH "K inodes = %d "
319       "check_space = " PR_EXIM_ARITH "K inodes = %d\n",
320       space, inodes, check_log_space, check_log_inodes);
321
322   if (  space >= 0 && space < check_log_space
323      || inodes >= 0 && inodes < check_log_inodes)
324     {
325     log_write(0, LOG_MAIN, "log directory space check failed: space=" PR_EXIM_ARITH
326       " inodes=%d", space, inodes);
327     return FALSE;
328     }
329   }
330
331 return TRUE;
332 }
333
334
335
336 /*************************************************
337 *         Bomb out while reading a message       *
338 *************************************************/
339
340 /* The common case of wanting to bomb out is if a SIGTERM or SIGINT is
341 received, or if there is a timeout. A rarer case might be if the log files are
342 screwed up and Exim can't open them to record a message's arrival. Handling
343 that case is done by setting a flag to cause the log functions to call this
344 function if there is an ultimate disaster. That is why it is globally
345 accessible.
346
347 Arguments:
348   reason     text reason to pass to the not-quit ACL
349   msg        default SMTP response to give if in an SMTP session
350 Returns:     it doesn't
351 */
352
353 void
354 receive_bomb_out(uschar *reason, uschar *msg)
355 {
356   static BOOL already_bombing_out;
357 /* The smtp_notquit_exit() below can call ACLs which can trigger recursive
358 timeouts, if someone has something slow in their quit ACL.  Since the only
359 things we should be doing are to close down cleanly ASAP, on the second
360 pass we also close down stuff that might be opened again, before bypassing
361 the ACL call and exiting. */
362
363 /* If spool_name is set, it contains the name of the data file that is being
364 written. Unlink it before closing so that it cannot be picked up by a delivery
365 process. Ensure that any header file is also removed. */
366
367 if (spool_name[0] != '\0')
368   {
369   Uunlink(spool_name);
370   spool_name[Ustrlen(spool_name) - 1] = 'H';
371   Uunlink(spool_name);
372   spool_name[0] = '\0';
373   }
374
375 /* Now close the file if it is open, either as a fd or a stream. */
376
377 if (spool_data_file)
378   {
379   (void)fclose(spool_data_file);
380   spool_data_file = NULL;
381   }
382 else if (data_fd >= 0)
383   {
384   (void)close(data_fd);
385   data_fd = -1;
386   }
387
388 /* Attempt to close down an SMTP connection tidily. For non-batched SMTP, call
389 smtp_notquit_exit(), which runs the NOTQUIT ACL, if present, and handles the
390 SMTP response. */
391
392 if (!already_bombing_out)
393   {
394   already_bombing_out = TRUE;
395   if (smtp_input)
396     {
397     if (smtp_batched_input)
398       moan_smtp_batch(NULL, "421 %s - message abandoned", msg);  /* No return */
399     smtp_notquit_exit(reason, US"421", US"%s %s - closing connection.",
400       smtp_active_hostname, msg);
401     }
402   }
403
404 /* Exit from the program (non-BSMTP cases) */
405
406 exim_exit(EXIT_FAILURE);
407 }
408
409
410 /*************************************************
411 *              Data read timeout                 *
412 *************************************************/
413
414 /* Handler function for timeouts that occur while reading the data that
415 comprises a message.
416
417 Argument:  the signal number
418 Returns:   nothing
419 */
420
421 static void
422 data_timeout_handler(int sig)
423 {
424 had_data_timeout = sig;
425 }
426
427
428
429 #ifdef HAVE_LOCAL_SCAN
430 /*************************************************
431 *              local_scan() timeout              *
432 *************************************************/
433
434 /* Handler function for timeouts that occur while running a local_scan()
435 function.  Posix recommends against calling longjmp() from a signal-handler,
436 but the GCC manual says you can so we will, and trust that it's better than
437 calling probably non-signal-safe funxtions during logging from within the
438 handler, even with other compilers.
439
440 See also https://cwe.mitre.org/data/definitions/745.html which also lists
441 it as unsafe.
442
443 This is all because we have no control over what might be written for a
444 local-scan function, so cannot sprinkle had-signal checks after each
445 call-site.  At least with the default "do-nothing" function we won't
446 ever get here.
447
448 Argument:  the signal number
449 Returns:   nothing
450 */
451
452 static void
453 local_scan_timeout_handler(int sig)
454 {
455 had_local_scan_timeout = sig;
456 siglongjmp(local_scan_env, 1);
457 }
458
459
460
461 /*************************************************
462 *            local_scan() crashed                *
463 *************************************************/
464
465 /* Handler function for signals that occur while running a local_scan()
466 function.
467
468 Argument:  the signal number
469 Returns:   nothing
470 */
471
472 static void
473 local_scan_crash_handler(int sig)
474 {
475 had_local_scan_crash = sig;
476 siglongjmp(local_scan_env, 1);
477 }
478
479 #endif /*HAVE_LOCAL_SCAN*/
480
481
482 /*************************************************
483 *           SIGTERM or SIGINT received           *
484 *************************************************/
485
486 /* Handler for SIGTERM or SIGINT signals that occur while reading the
487 data that comprises a message.
488
489 Argument:  the signal number
490 Returns:   nothing
491 */
492
493 static void
494 data_sigterm_sigint_handler(int sig)
495 {
496 had_data_sigint = sig;
497 }
498
499
500
501 /*************************************************
502 *          Add new recipient to list             *
503 *************************************************/
504
505 /* This function builds a list of recipient addresses in argc/argv
506 format.
507
508 Arguments:
509   recipient   the next address to add to recipients_list
510   pno         parent number for fixed aliases; -1 otherwise
511
512 Returns:      nothing
513 */
514
515 void
516 receive_add_recipient(uschar *recipient, int pno)
517 {
518 if (recipients_count >= recipients_list_max)
519   {
520   recipient_item *oldlist = recipients_list;
521   int oldmax = recipients_list_max;
522
523   const int safe_recipients_limit = INT_MAX / 2 / sizeof(recipient_item);
524   if (recipients_list_max < 0 || recipients_list_max >= safe_recipients_limit)
525     {
526     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Too many recipients: %d", recipients_list_max);
527     }
528
529   recipients_list_max = recipients_list_max ? 2*recipients_list_max : 50;
530   recipients_list = store_get(recipients_list_max * sizeof(recipient_item), FALSE);
531   if (oldlist)
532     memcpy(recipients_list, oldlist, oldmax * sizeof(recipient_item));
533   }
534
535 recipients_list[recipients_count].address = recipient;
536 recipients_list[recipients_count].pno = pno;
537 #ifdef EXPERIMENTAL_BRIGHTMAIL
538 recipients_list[recipients_count].bmi_optin = bmi_current_optin;
539 /* reset optin string pointer for next recipient */
540 bmi_current_optin = NULL;
541 #endif
542 recipients_list[recipients_count].orcpt = NULL;
543 recipients_list[recipients_count].dsn_flags = 0;
544 recipients_list[recipients_count++].errors_to = NULL;
545 }
546
547
548
549
550 /*************************************************
551 *        Send user response message              *
552 *************************************************/
553
554 /* This function is passed a default response code and a user message. It calls
555 smtp_message_code() to check and possibly modify the response code, and then
556 calls smtp_respond() to transmit the response. I put this into a function
557 just to avoid a lot of repetition.
558
559 Arguments:
560   code         the response code
561   user_msg     the user message
562
563 Returns:       nothing
564 */
565
566 #ifndef DISABLE_PRDR
567 static void
568 smtp_user_msg(uschar *code, uschar *user_msg)
569 {
570 int len = 3;
571 smtp_message_code(&code, &len, &user_msg, NULL, TRUE);
572 smtp_respond(code, len, TRUE, user_msg);
573 }
574 #endif
575
576
577
578
579
580 /*************************************************
581 *        Remove a recipient from the list        *
582 *************************************************/
583
584 /* This function is provided for local_scan() to use.
585
586 Argument:
587   recipient   address to remove
588
589 Returns:      TRUE if it did remove something; FALSE otherwise
590 */
591
592 BOOL
593 receive_remove_recipient(uschar *recipient)
594 {
595 DEBUG(D_receive) debug_printf("receive_remove_recipient(\"%s\") called\n",
596   recipient);
597 for (int count = 0; count < recipients_count; count++)
598   if (Ustrcmp(recipients_list[count].address, recipient) == 0)
599     {
600     if ((--recipients_count - count) > 0)
601       memmove(recipients_list + count, recipients_list + count + 1,
602         (recipients_count - count)*sizeof(recipient_item));
603     return TRUE;
604     }
605 return FALSE;
606 }
607
608
609
610
611
612 /* Pause for a while waiting for input.  If none received in that time,
613 close the logfile, if we had one open; then if we wait for a long-running
614 datasource (months, in one use-case) log rotation will not leave us holding
615 the file copy. */
616
617 static void
618 log_close_chk(void)
619 {
620 if (!receive_timeout && !receive_hasc())
621   {
622   struct timeval t;
623   timesince(&t, &received_time);
624   if (t.tv_sec > 30*60)
625     mainlog_close();
626   else
627     {
628     fd_set r;
629     FD_ZERO(&r); FD_SET(0, &r);
630     t.tv_sec = 30*60 - t.tv_sec; t.tv_usec = 0;
631     if (select(1, &r, NULL, NULL, &t) == 0) mainlog_close();
632     }
633   }
634 }
635
636 /*************************************************
637 *     Read data portion of a non-SMTP message    *
638 *************************************************/
639
640 /* This function is called to read the remainder of a message (following the
641 header) when the input is not from SMTP - we are receiving a local message on
642 a standard input stream. The message is always terminated by EOF, and is also
643 terminated by a dot on a line by itself if the flag dot_ends is TRUE. Split the
644 two cases for maximum efficiency.
645
646 Ensure that the body ends with a newline. This will naturally be the case when
647 the termination is "\n.\n" but may not be otherwise. The RFC defines messages
648 as "sequences of lines" - this of course strictly applies only to SMTP, but
649 deliveries into BSD-type mailbox files also require it. Exim used to have a
650 flag for doing this at delivery time, but as it was always set for all
651 transports, I decided to simplify things by putting the check here instead.
652
653 There is at least one MUA (dtmail) that sends CRLF via this interface, and
654 other programs are known to do this as well. Exim used to have a option for
655 dealing with this: in July 2003, after much discussion, the code has been
656 changed to default to treat any of LF, CRLF, and bare CR as line terminators.
657
658 However, for the case when a dot on a line by itself terminates a message, the
659 only recognized terminating sequences before and after the dot are LF and CRLF.
660 Otherwise, having read EOL . CR, you don't know whether to read another
661 character or not.
662
663 Internally, in messages stored in Exim's spool files, LF is used as the line
664 terminator. Under the new regime, bare CRs will no longer appear in these
665 files.
666
667 Arguments:
668   fout      a FILE to which to write the message
669
670 Returns:    One of the END_xxx values indicating why it stopped reading
671 */
672
673 static int
674 read_message_data(FILE *fout)
675 {
676 int ch_state;
677 register int ch;
678 register int linelength = 0;
679
680 /* Handle the case when only EOF terminates the message */
681
682 if (!f.dot_ends)
683   {
684   int last_ch = '\n';
685
686   for ( ;
687        log_close_chk(), (ch = (receive_getc)(GETC_BUFFER_UNLIMITED)) != EOF;
688        last_ch = ch)
689     {
690     if (ch == 0) body_zerocount++;
691     if (last_ch == '\r' && ch != '\n')
692       {
693       if (linelength > max_received_linelength)
694         max_received_linelength = linelength;
695       linelength = 0;
696       if (fputc('\n', fout) == EOF) return END_WERROR;
697       message_size++;
698       body_linecount++;
699       }
700     if (ch == '\r') continue;
701
702     if (fputc(ch, fout) == EOF) return END_WERROR;
703     if (ch == '\n')
704       {
705       if (linelength > max_received_linelength)
706         max_received_linelength = linelength;
707       linelength = 0;
708       body_linecount++;
709       }
710     else linelength++;
711     if (++message_size > thismessage_size_limit) return END_SIZE;
712     }
713
714   if (last_ch != '\n')
715     {
716     if (linelength > max_received_linelength)
717       max_received_linelength = linelength;
718     if (fputc('\n', fout) == EOF) return END_WERROR;
719     message_size++;
720     body_linecount++;
721     }
722
723   return END_EOF;
724   }
725
726 /* Handle the case when a dot on a line on its own, or EOF, terminates. */
727
728 ch_state = 1;
729
730 while (log_close_chk(), (ch = (receive_getc)(GETC_BUFFER_UNLIMITED)) != EOF)
731   {
732   if (ch == 0) body_zerocount++;
733   switch (ch_state)
734     {
735     case 0:                         /* Normal state (previous char written) */
736     if (ch == '\n')
737       {
738       body_linecount++;
739       if (linelength > max_received_linelength)
740         max_received_linelength = linelength;
741       linelength = -1;
742       ch_state = 1;
743       }
744     else if (ch == '\r')
745       { ch_state = 2; continue; }
746     break;
747
748     case 1:                         /* After written "\n" */
749     if (ch == '.') { ch_state = 3; continue; }
750     if (ch == '\r') { ch_state = 2; continue; }
751     if (ch == '\n') { body_linecount++; linelength = -1; }
752     else ch_state = 0;
753     break;
754
755     case 2:
756     body_linecount++;               /* After unwritten "\r" */
757     if (linelength > max_received_linelength)
758       max_received_linelength = linelength;
759     if (ch == '\n')
760       {
761       ch_state = 1;
762       linelength = -1;
763       }
764     else
765       {
766       if (message_size++, fputc('\n', fout) == EOF) return END_WERROR;
767       if (ch == '\r') continue;
768       ch_state = 0;
769       linelength = 0;
770       }
771     break;
772
773     case 3:                         /* After "\n." (\n written, dot not) */
774     if (ch == '\n') return END_DOT;
775     if (ch == '\r') { ch_state = 4; continue; }
776     message_size++;
777     linelength++;
778     if (fputc('.', fout) == EOF) return END_WERROR;
779     ch_state = 0;
780     break;
781
782     case 4:                         /* After "\n.\r" (\n written, rest not) */
783     if (ch == '\n') return END_DOT;
784     message_size += 2;
785     body_linecount++;
786     if (fputs(".\n", fout) == EOF) return END_WERROR;
787     if (ch == '\r') { ch_state = 2; continue; }
788     ch_state = 0;
789     break;
790     }
791
792   linelength++;
793   if (fputc(ch, fout) == EOF) return END_WERROR;
794   if (++message_size > thismessage_size_limit) return END_SIZE;
795   }
796
797 /* Get here if EOF read. Unless we have just written "\n", we need to ensure
798 the message ends with a newline, and we must also write any characters that
799 were saved up while testing for an ending dot. */
800
801 if (ch_state != 1)
802   {
803   static uschar *ends[] = { US"\n", NULL, US"\n", US".\n", US".\n" };
804   if (fputs(CS ends[ch_state], fout) == EOF) return END_WERROR;
805   message_size += Ustrlen(ends[ch_state]);
806   body_linecount++;
807   }
808
809 return END_EOF;
810 }
811
812
813
814
815 /*************************************************
816 *      Read data portion of an SMTP message      *
817 *************************************************/
818
819 /* This function is called to read the remainder of an SMTP message (after the
820 headers), or to skip over it when an error has occurred. In this case, the
821 output file is passed as NULL.
822
823 If any line begins with a dot, that character is skipped. The input should only
824 be successfully terminated by CR LF . CR LF unless it is local (non-network)
825 SMTP, in which case the CRs are optional, but...
826
827 FUDGE: It seems that sites on the net send out messages with just LF
828 terminators, despite the warnings in the RFCs, and other MTAs handle this. So
829 we make the CRs optional in all cases.
830
831 July 2003: Bare CRs cause trouble. We now treat them as line terminators as
832 well, so that there are no CRs in spooled messages. However, the message
833 terminating dot is not recognized between two bare CRs.
834
835 Arguments:
836   fout      a FILE to which to write the message; NULL if skipping
837
838 Returns:    One of the END_xxx values indicating why it stopped reading
839 */
840
841 static int
842 read_message_data_smtp(FILE *fout)
843 {
844 int ch_state = 0;
845 int ch;
846 int linelength = 0;
847
848 while ((ch = (receive_getc)(GETC_BUFFER_UNLIMITED)) != EOF)
849   {
850   if (ch == 0) body_zerocount++;
851   switch (ch_state)
852     {
853     case 0:                             /* After LF or CRLF */
854     if (ch == '.')
855       {
856       ch_state = 3;
857       continue;                         /* Don't ever write . after LF */
858       }
859     ch_state = 1;
860
861     /* Else fall through to handle as normal uschar. */
862
863     case 1:                             /* Normal state */
864     if (ch == '\n')
865       {
866       ch_state = 0;
867       body_linecount++;
868       if (linelength > max_received_linelength)
869         max_received_linelength = linelength;
870       linelength = -1;
871       }
872     else if (ch == '\r')
873       {
874       ch_state = 2;
875       continue;
876       }
877     break;
878
879     case 2:                             /* After (unwritten) CR */
880     body_linecount++;
881     if (linelength > max_received_linelength)
882       max_received_linelength = linelength;
883     linelength = -1;
884     if (ch == '\n')
885       {
886       ch_state = 0;
887       }
888     else
889       {
890       message_size++;
891       if (fout != NULL && fputc('\n', fout) == EOF) return END_WERROR;
892       cutthrough_data_put_nl();
893       if (ch != '\r') ch_state = 1; else continue;
894       }
895     break;
896
897     case 3:                             /* After [CR] LF . */
898     if (ch == '\n')
899       return END_DOT;
900     if (ch == '\r')
901       {
902       ch_state = 4;
903       continue;
904       }
905     /* The dot was removed at state 3. For a doubled dot, here, reinstate
906     it to cutthrough. The current ch, dot or not, is passed both to cutthrough
907     and to file below. */
908     if (ch == '.')
909       {
910       uschar c= ch;
911       cutthrough_data_puts(&c, 1);
912       }
913     ch_state = 1;
914     break;
915
916     case 4:                             /* After [CR] LF . CR */
917     if (ch == '\n') return END_DOT;
918     message_size++;
919     body_linecount++;
920     if (fout != NULL && fputc('\n', fout) == EOF) return END_WERROR;
921     cutthrough_data_put_nl();
922     if (ch == '\r')
923       {
924       ch_state = 2;
925       continue;
926       }
927     ch_state = 1;
928     break;
929     }
930
931   /* Add the character to the spool file, unless skipping; then loop for the
932   next. */
933
934   message_size++;
935   linelength++;
936   if (fout)
937     {
938     if (fputc(ch, fout) == EOF) return END_WERROR;
939     if (message_size > thismessage_size_limit) return END_SIZE;
940     }
941   if(ch == '\n')
942     cutthrough_data_put_nl();
943   else
944     {
945     uschar c = ch;
946     cutthrough_data_puts(&c, 1);
947     }
948   }
949
950 /* Fall through here if EOF encountered. This indicates some kind of error,
951 since a correct message is terminated by [CR] LF . [CR] LF. */
952
953 return END_EOF;
954 }
955
956
957
958
959 /* Variant of the above read_message_data_smtp() specialised for RFC 3030
960 CHUNKING. Accept input lines separated by either CRLF or CR or LF and write
961 LF-delimited spoolfile.  Until we have wireformat spoolfiles, we need the
962 body_linecount accounting for proper re-expansion for the wire, so use
963 a cut-down version of the state-machine above; we don't need to do leading-dot
964 detection and unstuffing.
965
966 Arguments:
967   fout      a FILE to which to write the message; NULL if skipping;
968             must be open for both writing and reading.
969
970 Returns:    One of the END_xxx values indicating why it stopped reading
971 */
972
973 static int
974 read_message_bdat_smtp(FILE *fout)
975 {
976 int linelength = 0, ch;
977 enum CH_STATE ch_state = LF_SEEN;
978 BOOL fix_nl = FALSE;
979
980 for(;;)
981   {
982   switch ((ch = bdat_getc(GETC_BUFFER_UNLIMITED)))
983     {
984     case EOF:   return END_EOF;
985     case ERR:   return END_PROTOCOL;
986     case EOD:
987       /* Nothing to get from the sender anymore. We check the last
988       character written to the spool.
989
990       RFC 3030 states, that BDAT chunks are normal text, terminated by CRLF.
991       If we would be strict, we would refuse such broken messages.
992       But we are liberal, so we fix it.  It would be easy just to append
993       the "\n" to the spool.
994
995       But there are some more things (line counting, message size calculation and such),
996       that would need to be duplicated here.  So we simply do some ungetc
997       trickery.
998       */
999       if (fout)
1000         {
1001         if (fseek(fout, -1, SEEK_CUR) < 0)      return END_PROTOCOL;
1002         if (fgetc(fout) == '\n')                return END_DOT;
1003         }
1004
1005       if (linelength == -1)    /* \r already seen (see below) */
1006         {
1007         DEBUG(D_receive) debug_printf("Add missing LF\n");
1008         bdat_ungetc('\n');
1009         continue;
1010         }
1011       DEBUG(D_receive) debug_printf("Add missing CRLF\n");
1012       bdat_ungetc('\r');      /* not even \r was seen */
1013       fix_nl = TRUE;
1014
1015       continue;
1016     case '\0':  body_zerocount++; break;
1017     }
1018   switch (ch_state)
1019     {
1020     case LF_SEEN:                             /* After LF or CRLF */
1021       ch_state = MID_LINE;
1022       /* fall through to handle as normal uschar. */
1023
1024     case MID_LINE:                            /* Mid-line state */
1025       if (ch == '\n')
1026         {
1027         ch_state = LF_SEEN;
1028         body_linecount++;
1029         if (linelength > max_received_linelength)
1030           max_received_linelength = linelength;
1031         linelength = -1;
1032         }
1033       else if (ch == '\r')
1034         {
1035         ch_state = CR_SEEN;
1036        if (fix_nl) bdat_ungetc('\n');
1037         continue;                       /* don't write CR */
1038         }
1039       break;
1040
1041     case CR_SEEN:                       /* After (unwritten) CR */
1042       body_linecount++;
1043       if (linelength > max_received_linelength)
1044         max_received_linelength = linelength;
1045       linelength = -1;
1046       if (ch == '\n')
1047         ch_state = LF_SEEN;
1048       else
1049         {
1050         message_size++;
1051         if (fout && fputc('\n', fout) == EOF) return END_WERROR;
1052         cutthrough_data_put_nl();
1053         if (ch == '\r') continue;       /* don't write CR */
1054         ch_state = MID_LINE;
1055         }
1056       break;
1057     }
1058
1059   /* Add the character to the spool file, unless skipping */
1060
1061   message_size++;
1062   linelength++;
1063   if (fout)
1064     {
1065     if (fputc(ch, fout) == EOF) return END_WERROR;
1066     if (message_size > thismessage_size_limit) return END_SIZE;
1067     }
1068   if(ch == '\n')
1069     cutthrough_data_put_nl();
1070   else
1071     {
1072     uschar c = ch;
1073     cutthrough_data_puts(&c, 1);
1074     }
1075   }
1076 /*NOTREACHED*/
1077 }
1078
1079 static int
1080 read_message_bdat_smtp_wire(FILE *fout)
1081 {
1082 int ch;
1083
1084 /* Remember that this message uses wireformat. */
1085
1086 DEBUG(D_receive) debug_printf("CHUNKING: %s\n",
1087         fout ? "writing spoolfile in wire format" : "flushing input");
1088 f.spool_file_wireformat = TRUE;
1089
1090 for (;;)
1091   {
1092   if (chunking_data_left > 0)
1093     {
1094     unsigned len = MAX(chunking_data_left, thismessage_size_limit - message_size + 1);
1095     uschar * buf = bdat_getbuf(&len);
1096
1097     if (!buf) return END_EOF;
1098     message_size += len;
1099     if (fout && fwrite(buf, len, 1, fout) != 1) return END_WERROR;
1100     }
1101   else switch (ch = bdat_getc(GETC_BUFFER_UNLIMITED))
1102     {
1103     case EOF: return END_EOF;
1104     case EOD: return END_DOT;
1105     case ERR: return END_PROTOCOL;
1106
1107     default:
1108       message_size++;
1109   /*XXX not done:
1110   linelength
1111   max_received_linelength
1112   body_linecount
1113   body_zerocount
1114   */
1115       if (fout && fputc(ch, fout) == EOF) return END_WERROR;
1116       break;
1117     }
1118   if (message_size > thismessage_size_limit) return END_SIZE;
1119   }
1120 /*NOTREACHED*/
1121 }
1122
1123
1124
1125
1126 /*************************************************
1127 *             Swallow SMTP message               *
1128 *************************************************/
1129
1130 /* This function is called when there has been some kind of error while reading
1131 an SMTP message, and the remaining data may need to be swallowed. It is global
1132 because it is called from smtp_closedown() to shut down an incoming call
1133 tidily.
1134
1135 Argument:    a FILE from which to read the message
1136 Returns:     nothing
1137 */
1138
1139 void
1140 receive_swallow_smtp(void)
1141 {
1142 if (message_ended >= END_NOTENDED)
1143   message_ended = chunking_state <= CHUNKING_OFFERED
1144      ? read_message_data_smtp(NULL)
1145      : read_message_bdat_smtp_wire(NULL);
1146 }
1147
1148
1149
1150 /*************************************************
1151 *           Handle lost SMTP connection          *
1152 *************************************************/
1153
1154 /* This function logs connection loss incidents and generates an appropriate
1155 SMTP response.
1156
1157 Argument:  additional data for the message
1158 Returns:   the SMTP response
1159 */
1160
1161 static uschar *
1162 handle_lost_connection(uschar *s)
1163 {
1164 log_write(L_lost_incoming_connection | L_smtp_connection, LOG_MAIN,
1165   "%s lost while reading message data%s", smtp_get_connection_info(), s);
1166 smtp_notquit_exit(US"connection-lost", NULL, NULL);
1167 return US"421 Lost incoming connection";
1168 }
1169
1170
1171
1172
1173 /*************************************************
1174 *         Handle a non-smtp reception error      *
1175 *************************************************/
1176
1177 /* This function is called for various errors during the reception of non-SMTP
1178 messages. It either sends a message to the sender of the problem message, or it
1179 writes to the standard error stream.
1180
1181 Arguments:
1182   errcode     code for moan_to_sender(), identifying the error
1183   text1       first message text, passed to moan_to_sender()
1184   text2       second message text, used only for stderrr
1185   error_rc    code to pass to exim_exit if no problem
1186   f           FILE containing body of message (may be stdin)
1187   hptr        pointer to instore headers or NULL
1188
1189 Returns:      calls exim_exit(), which does not return
1190 */
1191
1192 static void
1193 give_local_error(int errcode, uschar *text1, uschar *text2, int error_rc,
1194   FILE *f, header_line *hptr)
1195 {
1196 if (error_handling == ERRORS_SENDER)
1197   {
1198   error_block eblock;
1199   eblock.next = NULL;
1200   eblock.text1 = text1;
1201   eblock.text2 = US"";
1202   if (!moan_to_sender(errcode, &eblock, hptr, f, FALSE))
1203     error_rc = EXIT_FAILURE;
1204   }
1205 else
1206   fprintf(stderr, "exim: %s%s\n", text2, text1);  /* Sic */
1207 (void)fclose(f);
1208 exim_exit(error_rc);
1209 }
1210
1211
1212
1213 /*************************************************
1214 *          Add header lines set up by ACL        *
1215 *************************************************/
1216
1217 /* This function is called to add the header lines that were set up by
1218 statements in an ACL to the list of headers in memory. It is done in two stages
1219 like this, because when the ACL for RCPT is running, the other headers have not
1220 yet been received. This function is called twice; once just before running the
1221 DATA ACL, and once after. This is so that header lines added by MAIL or RCPT
1222 are visible to the DATA ACL.
1223
1224 Originally these header lines were added at the end. Now there is support for
1225 three different places: top, bottom, and after the Received: header(s). There
1226 will always be at least one Received: header, even if it is marked deleted, and
1227 even if something else has been put in front of it.
1228
1229 Arguments:
1230   acl_name   text to identify which ACL
1231
1232 Returns:     nothing
1233 */
1234
1235 static void
1236 add_acl_headers(int where, uschar *acl_name)
1237 {
1238 header_line *last_received = NULL;
1239
1240 switch(where)
1241   {
1242   case ACL_WHERE_DKIM:
1243   case ACL_WHERE_MIME:
1244   case ACL_WHERE_DATA:
1245     if (  cutthrough.cctx.sock >= 0 && cutthrough.delivery
1246        && (acl_removed_headers || acl_added_headers))
1247     {
1248     log_write(0, LOG_MAIN|LOG_PANIC, "Header modification in data ACLs"
1249                         " will not take effect on cutthrough deliveries");
1250     return;
1251     }
1252   }
1253
1254 if (acl_removed_headers)
1255   {
1256   DEBUG(D_receive|D_acl) debug_printf_indent(">>Headers removed by %s ACL:\n", acl_name);
1257
1258   for (header_line * h = header_list; h; h = h->next) if (h->type != htype_old)
1259     {
1260     const uschar * list = acl_removed_headers;
1261     int sep = ':';         /* This is specified as a colon-separated list */
1262     uschar *s;
1263
1264     while ((s = string_nextinlist(&list, &sep, NULL, 0)))
1265       if (header_testname(h, s, Ustrlen(s), FALSE))
1266         {
1267         h->type = htype_old;
1268         DEBUG(D_receive|D_acl) debug_printf_indent("  %s", h->text);
1269         }
1270     }
1271   acl_removed_headers = NULL;
1272   DEBUG(D_receive|D_acl) debug_printf_indent(">>\n");
1273   }
1274
1275 if (!acl_added_headers) return;
1276 DEBUG(D_receive|D_acl) debug_printf_indent(">>Headers added by %s ACL:\n", acl_name);
1277
1278 for (header_line * h = acl_added_headers, * next; h; h = next)
1279   {
1280   next = h->next;
1281
1282   switch(h->type)
1283     {
1284     case htype_add_top:
1285       h->next = header_list;
1286       header_list = h;
1287       DEBUG(D_receive|D_acl) debug_printf_indent("  (at top)");
1288       break;
1289
1290     case htype_add_rec:
1291       if (!last_received)
1292         {
1293         last_received = header_list;
1294         while (!header_testname(last_received, US"Received", 8, FALSE))
1295           last_received = last_received->next;
1296         while (last_received->next &&
1297                header_testname(last_received->next, US"Received", 8, FALSE))
1298           last_received = last_received->next;
1299         }
1300       h->next = last_received->next;
1301       last_received->next = h;
1302       DEBUG(D_receive|D_acl) debug_printf_indent("  (after Received:)");
1303       break;
1304
1305     case htype_add_rfc:
1306       /* add header before any header which is NOT Received: or Resent- */
1307       last_received = header_list;
1308       while ( last_received->next &&
1309               ( (header_testname(last_received->next, US"Received", 8, FALSE)) ||
1310                 (header_testname_incomplete(last_received->next, US"Resent-", 7, FALSE)) ) )
1311                 last_received = last_received->next;
1312       /* last_received now points to the last Received: or Resent-* header
1313          in an uninterrupted chain of those header types (seen from the beginning
1314          of all headers. Our current header must follow it. */
1315       h->next = last_received->next;
1316       last_received->next = h;
1317       DEBUG(D_receive|D_acl) debug_printf_indent("  (before any non-Received: or Resent-*: header)");
1318       break;
1319
1320     default:
1321       h->next = NULL;
1322       header_last->next = h;
1323       DEBUG(D_receive|D_acl) debug_printf_indent("  ");
1324       break;
1325     }
1326
1327   if (!h->next) header_last = h;
1328
1329   /* Check for one of the known header types (From:, To:, etc.) though in
1330   practice most added headers are going to be "other". Lower case
1331   identification letters are never stored with the header; they are used
1332   for existence tests when messages are received. So discard any lower case
1333   flag values. */
1334
1335   h->type = header_checkname(h, FALSE);
1336   if (h->type >= 'a') h->type = htype_other;
1337
1338   DEBUG(D_receive|D_acl) debug_printf("%s", h->text);
1339   }
1340
1341 acl_added_headers = NULL;
1342 DEBUG(D_receive|D_acl) debug_printf_indent(">>\n");
1343 }
1344
1345
1346
1347 /*************************************************
1348 *       Add host information for log line        *
1349 *************************************************/
1350
1351 /* Called for acceptance and rejecting log lines. This adds information about
1352 the calling host to a string that is being built dynamically.
1353
1354 Arguments:
1355   s           the dynamic string
1356
1357 Returns:      the extended string
1358 */
1359
1360 static gstring *
1361 add_host_info_for_log(gstring * g)
1362 {
1363 if (sender_fullhost)
1364   {
1365   if (LOGGING(dnssec) && sender_host_dnssec)    /*XXX sender_helo_dnssec? */
1366     g = string_catn(g, US" DS", 3);
1367   g = string_append(g, 2, US" H=", sender_fullhost);
1368   if (LOGGING(incoming_interface) && interface_address)
1369     g = string_fmt_append(g, " I=[%s]:%d", interface_address, interface_port);
1370   }
1371 if (f.tcp_in_fastopen && !f.tcp_in_fastopen_logged)
1372   {
1373   g = string_catn(g, US" TFO*", f.tcp_in_fastopen_data ? 5 : 4);
1374   f.tcp_in_fastopen_logged = TRUE;
1375   }
1376 if (sender_ident)
1377   g = string_append(g, 2, US" U=", sender_ident);
1378 if (received_protocol)
1379   g = string_append(g, 2, US" P=", received_protocol);
1380 if (LOGGING(pipelining) && f.smtp_in_pipelining_advertised)
1381   {
1382   g = string_catn(g, US" L", 2);
1383 #ifndef DISABLE_PIPE_CONNECT
1384   if (f.smtp_in_early_pipe_used)
1385     g = string_catn(g, US"*", 1);
1386   else if (f.smtp_in_early_pipe_advertised)
1387     g = string_catn(g, US".", 1);
1388 #endif
1389   if (!f.smtp_in_pipelining_used)
1390     g = string_catn(g, US"-", 1);
1391   }
1392 return g;
1393 }
1394
1395
1396
1397 #ifdef WITH_CONTENT_SCAN
1398
1399 /*************************************************
1400 *       Run the MIME ACL on a message            *
1401 *************************************************/
1402
1403 /* This code is in a subroutine so that it can be used for both SMTP
1404 and non-SMTP messages. It is called with a non-NULL ACL pointer.
1405
1406 Arguments:
1407   acl                The ACL to run (acl_smtp_mime or acl_not_smtp_mime)
1408   smtp_yield_ptr     Set FALSE to kill messages after dropped connection
1409   smtp_reply_ptr     Where SMTP reply is being built
1410   blackholed_by_ptr  Where "blackholed by" message is being built
1411
1412 Returns:             TRUE to carry on; FALSE to abandon the message
1413 */
1414
1415 static BOOL
1416 run_mime_acl(uschar *acl, BOOL *smtp_yield_ptr, uschar **smtp_reply_ptr,
1417   uschar **blackholed_by_ptr)
1418 {
1419 FILE *mbox_file;
1420 uschar * rfc822_file_path = NULL;
1421 unsigned long mbox_size;
1422 uschar *user_msg, *log_msg;
1423 int mime_part_count_buffer = -1;
1424 uschar * mbox_filename;
1425 int rc = OK;
1426
1427 /* check if it is a MIME message */
1428
1429 for (header_line * my_headerlist = header_list; my_headerlist;
1430      my_headerlist = my_headerlist->next)
1431   if (  my_headerlist->type != '*'                      /* skip deleted headers */
1432      && strncmpic(my_headerlist->text, US"Content-Type:", 13) == 0
1433      )
1434     {
1435     DEBUG(D_receive) debug_printf("Found Content-Type: header - executing acl_smtp_mime.\n");
1436     goto DO_MIME_ACL;
1437     }
1438
1439 DEBUG(D_receive) debug_printf("No Content-Type: header - presumably not a MIME message.\n");
1440 return TRUE;
1441
1442 DO_MIME_ACL:
1443
1444 /* make sure the eml mbox file is spooled up */
1445 if (!(mbox_file = spool_mbox(&mbox_size, NULL, &mbox_filename)))
1446   {                                                             /* error while spooling */
1447   log_write(0, LOG_MAIN|LOG_PANIC,
1448          "acl_smtp_mime: error while creating mbox spool file, message temporarily rejected.");
1449   Uunlink(spool_name);
1450   unspool_mbox();
1451 #ifdef EXPERIMENTAL_DCC
1452   dcc_ok = 0;
1453 #endif
1454   smtp_respond(US"451", 3, TRUE, US"temporary local problem");
1455   message_id[0] = 0;            /* Indicate no message accepted */
1456   *smtp_reply_ptr = US"";       /* Indicate reply already sent */
1457   return FALSE;                 /* Indicate skip to end of receive function */
1458   }
1459
1460 mime_is_rfc822 = 0;
1461
1462 MIME_ACL_CHECK:
1463 mime_part_count = -1;
1464 rc = mime_acl_check(acl, mbox_file, NULL, &user_msg, &log_msg);
1465 (void)fclose(mbox_file);
1466
1467 if (rfc822_file_path)
1468   {
1469   mime_part_count = mime_part_count_buffer;
1470
1471   if (unlink(CS rfc822_file_path) == -1)
1472     {
1473     log_write(0, LOG_PANIC,
1474          "acl_smtp_mime: can't unlink RFC822 spool file, skipping.");
1475     goto END_MIME_ACL;
1476     }
1477   rfc822_file_path = NULL;
1478   }
1479
1480 /* check if we must check any message/rfc822 attachments */
1481 if (rc == OK)
1482   {
1483   uschar * scandir = string_copyn(mbox_filename,
1484               Ustrrchr(mbox_filename, '/') - mbox_filename);
1485   struct dirent * entry;
1486   DIR * tempdir;
1487
1488   for (tempdir = exim_opendir(scandir); entry = readdir(tempdir); )
1489     if (strncmpic(US entry->d_name, US"__rfc822_", 9) == 0)
1490       {
1491       rfc822_file_path = string_sprintf("%s/%s", scandir, entry->d_name);
1492       DEBUG(D_receive)
1493         debug_printf("RFC822 attachment detected: running MIME ACL for '%s'\n",
1494           rfc822_file_path);
1495       break;
1496       }
1497   closedir(tempdir);
1498
1499   if (rfc822_file_path)
1500     {
1501     if ((mbox_file = Ufopen(rfc822_file_path, "rb")))
1502       {
1503       /* set RFC822 expansion variable */
1504       mime_is_rfc822 = 1;
1505       mime_part_count_buffer = mime_part_count;
1506       goto MIME_ACL_CHECK;
1507       }
1508     log_write(0, LOG_PANIC,
1509        "acl_smtp_mime: can't open RFC822 spool file, skipping.");
1510     unlink(CS rfc822_file_path);
1511     }
1512   }
1513
1514 END_MIME_ACL:
1515 add_acl_headers(ACL_WHERE_MIME, US"MIME");
1516 if (rc == DISCARD)
1517   {
1518   recipients_count = 0;
1519   *blackholed_by_ptr = US"MIME ACL";
1520   cancel_cutthrough_connection(TRUE, US"mime acl discard");
1521   }
1522 else if (rc != OK)
1523   {
1524   Uunlink(spool_name);
1525   cancel_cutthrough_connection(TRUE, US"mime acl not ok");
1526   unspool_mbox();
1527 #ifdef EXPERIMENTAL_DCC
1528   dcc_ok = 0;
1529 #endif
1530   if (smtp_input)
1531     {
1532     if (smtp_handle_acl_fail(ACL_WHERE_MIME, rc, user_msg, log_msg) != 0)
1533       *smtp_yield_ptr = FALSE;  /* No more messages after dropped connection */
1534     *smtp_reply_ptr = US"";     /* Indicate reply already sent */
1535     }
1536   message_id[0] = 0;            /* Indicate no message accepted */
1537   return FALSE;                 /* Cause skip to end of receive function */
1538   }
1539
1540 return TRUE;
1541 }
1542
1543 #endif  /* WITH_CONTENT_SCAN */
1544
1545
1546
1547 void
1548 received_header_gen(void)
1549 {
1550 uschar * received;
1551 uschar * timestamp = expand_string(US"${tod_full}");
1552 header_line * received_header= header_list;
1553
1554 if (recipients_count == 1) received_for = recipients_list[0].address;
1555 received = expand_string(received_header_text);
1556 received_for = NULL;
1557
1558 if (!received)
1559   {
1560   if(spool_name[0] != 0)
1561     Uunlink(spool_name);           /* Lose the data file */
1562   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Expansion of \"%s\" "
1563     "(received_header_text) failed: %s", string_printing(received_header_text),
1564       expand_string_message);
1565   }
1566
1567 /* The first element on the header chain is reserved for the Received header,
1568 so all we have to do is fill in the text pointer, and set the type. However, if
1569 the result of the expansion is an empty string, we leave the header marked as
1570 "old" so as to refrain from adding a Received header. */
1571
1572 if (!received[0])
1573   {
1574   received_header->text = string_sprintf("Received: ; %s\n", timestamp);
1575   received_header->type = htype_old;
1576   }
1577 else
1578   {
1579   received_header->text = string_sprintf("%s;\n\t%s\n", received, timestamp);
1580   received_header->type = htype_received;
1581   }
1582
1583 received_header->slen = Ustrlen(received_header->text);
1584
1585 DEBUG(D_receive) debug_printf(">>Generated Received: header line\n%c %s",
1586   received_header->type, received_header->text);
1587 }
1588
1589
1590
1591 /*************************************************
1592 *                 Receive message                *
1593 *************************************************/
1594
1595 /* Receive a message on the given input, and put it into a pair of spool files.
1596 Either a non-null list of recipients, or the extract flag will be true, or
1597 both. The flag sender_local is true for locally generated messages. The flag
1598 submission_mode is true if an ACL has obeyed "control = submission". The flag
1599 suppress_local_fixups is true if an ACL has obeyed "control =
1600 suppress_local_fixups" or -G was passed on the command-line.
1601 The flag smtp_input is true if the message is to be
1602 handled using SMTP conventions about termination and lines starting with dots.
1603 For non-SMTP messages, dot_ends is true for dot-terminated messages.
1604
1605 If a message was successfully read, message_id[0] will be non-zero.
1606
1607 The general actions of this function are:
1608
1609   . Read the headers of the message (if any) into a chain of store
1610     blocks.
1611
1612   . If there is a "sender:" header and the message is locally originated,
1613     throw it away, unless the caller is trusted, or unless
1614     active_local_sender_retain is set - which can only happen if
1615     active_local_from_check is false.
1616
1617   . If recipients are to be extracted from the message, build the
1618     recipients list from the headers, removing any that were on the
1619     original recipients list (unless extract_addresses_remove_arguments is
1620     false), and at the same time, remove any bcc header that may be present.
1621
1622   . Get the spool file for the data, sort out its unique name, open
1623     and lock it (but don't give it the name yet).
1624
1625   . Generate a "Message-Id" header if the message doesn't have one, for
1626     locally-originated messages.
1627
1628   . Generate a "Received" header.
1629
1630   . Ensure the recipients list is fully qualified and rewritten if necessary.
1631
1632   . If there are any rewriting rules, apply them to the sender address
1633     and also to the headers.
1634
1635   . If there is no from: header, generate one, for locally-generated messages
1636     and messages in "submission mode" only.
1637
1638   . If the sender is local, check that from: is correct, and if not, generate
1639     a Sender: header, unless message comes from a trusted caller, or this
1640     feature is disabled by active_local_from_check being false.
1641
1642   . If there is no "date" header, generate one, for locally-originated
1643     or submission mode messages only.
1644
1645   . Copy the rest of the input, or up to a terminating "." if in SMTP or
1646     dot_ends mode, to the data file. Leave it open, to hold the lock.
1647
1648   . Write the envelope and the headers to a new file.
1649
1650   . Set the name for the header file; close it.
1651
1652   . Set the name for the data file; close it.
1653
1654 Because this function can potentially be called many times in a single
1655 SMTP connection, all store should be got by store_get(), so that it will be
1656 automatically retrieved after the message is accepted.
1657
1658 FUDGE: It seems that sites on the net send out messages with just LF
1659 terminators, despite the warnings in the RFCs, and other MTAs handle this. So
1660 we make the CRs optional in all cases.
1661
1662 July 2003: Bare CRs in messages, especially in header lines, cause trouble. A
1663 new regime is now in place in which bare CRs in header lines are turned into LF
1664 followed by a space, so as not to terminate the header line.
1665
1666 February 2004: A bare LF in a header line in a message whose first line was
1667 terminated by CRLF is treated in the same way as a bare CR.
1668
1669 Arguments:
1670   extract_recip  TRUE if recipients are to be extracted from the message's
1671                    headers
1672
1673 Returns:  TRUE   there are more messages to be read (SMTP input)
1674           FALSE  there are no more messages to be read (non-SMTP input
1675                  or SMTP connection collapsed, or other failure)
1676
1677 When reading a message for filter testing, the returned value indicates
1678 whether the headers (which is all that is read) were terminated by '.' or
1679 not. */
1680
1681 BOOL
1682 receive_msg(BOOL extract_recip)
1683 {
1684 int  rc = FAIL;
1685 int  msg_size = 0;
1686 int  process_info_len = Ustrlen(process_info);
1687 int  error_rc = error_handling == ERRORS_SENDER
1688         ? errors_sender_rc : EXIT_FAILURE;
1689 int  header_size = 256;
1690 int  had_zero = 0;
1691 int  prevlines_length = 0;
1692 const int id_resolution = BASE_62 == 62 ? 5000 : 10000;
1693
1694 int ptr = 0;
1695
1696 BOOL contains_resent_headers = FALSE;
1697 BOOL extracted_ignored = FALSE;
1698 BOOL first_line_ended_crlf = TRUE_UNSET;
1699 BOOL smtp_yield = TRUE;
1700 BOOL yield = FALSE;
1701
1702 BOOL resents_exist = FALSE;
1703 uschar *resent_prefix = US"";
1704 uschar *blackholed_by = NULL;
1705 uschar *blackhole_log_msg = US"";
1706 enum {NOT_TRIED, TMP_REJ, PERM_REJ, ACCEPTED} cutthrough_done = NOT_TRIED;
1707
1708 flock_t lock_data;
1709 error_block *bad_addresses = NULL;
1710
1711 uschar *frozen_by = NULL;
1712 uschar *queued_by = NULL;
1713
1714 uschar *errmsg;
1715 rmark rcvd_log_reset_point;
1716 gstring * g;
1717 struct stat statbuf;
1718
1719 /* Final message to give to SMTP caller, and messages from ACLs */
1720
1721 uschar *smtp_reply = NULL;
1722 uschar *user_msg, *log_msg;
1723
1724 /* Working header pointers */
1725
1726 rmark reset_point;
1727 header_line *next;
1728
1729 /* Flags for noting the existence of certain headers (only one left) */
1730
1731 BOOL date_header_exists = FALSE;
1732
1733 /* Pointers to receive the addresses of headers whose contents we need. */
1734
1735 header_line *from_header = NULL;
1736 header_line *subject_header = NULL;
1737 header_line *msgid_header = NULL;
1738 header_line *received_header;
1739 BOOL msgid_header_newly_created = FALSE;
1740
1741 /* Variables for use when building the Received: header. */
1742
1743 uschar *timestamp;
1744 int tslen;
1745
1746 /* Time of creation of message_id */
1747
1748 static struct timeval message_id_tv = { 0, 0 };
1749
1750
1751 /* Release any open files that might have been cached while preparing to
1752 accept the message - e.g. by verifying addresses - because reading a message
1753 might take a fair bit of real time. */
1754
1755 search_tidyup();
1756
1757 /* Extracting the recipient list from an input file is incompatible with
1758 cutthrough delivery with the no-spool option.  It shouldn't be possible
1759 to set up the combination, but just in case kill any ongoing connection. */
1760 if (extract_recip || !smtp_input)
1761   cancel_cutthrough_connection(TRUE, US"not smtp input");
1762
1763 /* Initialize the chain of headers by setting up a place-holder for Received:
1764 header. Temporarily mark it as "old", i.e. not to be used. We keep header_last
1765 pointing to the end of the chain to make adding headers simple. */
1766
1767 received_header = header_list = header_last = store_get(sizeof(header_line), FALSE);
1768 header_list->next = NULL;
1769 header_list->type = htype_old;
1770 header_list->text = NULL;
1771 header_list->slen = 0;
1772
1773 /* Control block for the next header to be read. */
1774
1775 reset_point = store_mark();
1776 next = store_get(sizeof(header_line), FALSE);   /* not tainted */
1777 next->text = store_get(header_size, TRUE);      /* tainted */
1778
1779 /* Initialize message id to be null (indicating no message read), and the
1780 header names list to be the normal list. Indicate there is no data file open
1781 yet, initialize the size and warning count, and deal with no size limit. */
1782
1783 message_id[0] = 0;
1784 spool_data_file = NULL;
1785 data_fd = -1;
1786 spool_name = US"";
1787 message_size = 0;
1788 warning_count = 0;
1789 received_count = 1;            /* For the one we will add */
1790
1791 if (thismessage_size_limit <= 0) thismessage_size_limit = INT_MAX;
1792
1793 /* While reading the message, the following counts are computed. */
1794
1795 message_linecount = body_linecount = body_zerocount =
1796   max_received_linelength = 0;
1797
1798 #ifdef WITH_CONTENT_SCAN
1799 /* reset non-per-part mime variables */
1800 mime_is_coverletter    = 0;
1801 mime_is_rfc822         = 0;
1802 mime_part_count        = -1;
1803 #endif
1804
1805 #ifndef DISABLE_DKIM
1806 /* Call into DKIM to set up the context.  In CHUNKING mode
1807 we clear the dot-stuffing flag */
1808 if (smtp_input && !smtp_batched_input && !f.dkim_disable_verify)
1809   dkim_exim_verify_init(chunking_state <= CHUNKING_OFFERED);
1810 #endif
1811
1812 #ifdef SUPPORT_DMARC
1813 if (sender_host_address) dmarc_init();  /* initialize libopendmarc */
1814 #endif
1815
1816 /* In SMTP sessions we may receive several messages in one connection. Before
1817 each subsequent one, we wait for the clock to tick at the level of message-id
1818 granularity.
1819 This is so that the combination of time+pid is unique, even on systems where the
1820 pid can be re-used within our time interval. We can't shorten the interval
1821 without re-designing the message-id. See comments above where the message id is
1822 created. This is Something For The Future.
1823 Do this wait any time we have previously created a message-id, even if we
1824 rejected the message.  This gives unique IDs for logging done by ACLs.
1825 The initial timestamp must have been obtained via exim_gettime() to avoid
1826 issues on Linux with suspend/resume. */
1827
1828 if (message_id_tv.tv_sec)
1829   {
1830   message_id_tv.tv_usec = (message_id_tv.tv_usec/id_resolution) * id_resolution;
1831   exim_wait_tick(&message_id_tv, id_resolution);
1832   }
1833
1834 /* Remember the time of reception. Exim uses time+pid for uniqueness of message
1835 ids, and fractions of a second are required. See the comments that precede the
1836 message id creation below.
1837 We use a routine that if possible uses a monotonic clock, and can be used again
1838 after reception for the tick-wait even under the Linux non-Posix behaviour. */
1839
1840 else
1841   exim_gettime(&message_id_tv);
1842
1843 /* For other uses of the received time we can operate with granularity of one
1844 second, and for that we use the global variable received_time. This is for
1845 things like ultimate message timeouts.
1846 For this we do not care about the Linux suspend/resume problem, so rather than
1847 use exim_gettime() everywhere we use a plain gettimeofday() here. */
1848
1849 gettimeofday(&received_time, NULL);
1850
1851 /* If SMTP input, set the special handler for timeouts. The alarm() calls
1852 happen in the smtp_getc() function when it refills its buffer. */
1853
1854 had_data_timeout = 0;
1855 if (smtp_input)
1856   os_non_restarting_signal(SIGALRM, data_timeout_handler);
1857
1858 /* If not SMTP input, timeout happens only if configured, and we just set a
1859 single timeout for the whole message. */
1860
1861 else if (receive_timeout > 0)
1862   {
1863   os_non_restarting_signal(SIGALRM, data_timeout_handler);
1864   ALARM(receive_timeout);
1865   }
1866
1867 /* SIGTERM and SIGINT are caught always. */
1868
1869 had_data_sigint = 0;
1870 signal(SIGTERM, data_sigterm_sigint_handler);
1871 signal(SIGINT, data_sigterm_sigint_handler);
1872
1873 /* Header lines in messages are not supposed to be very long, though when
1874 unfolded, to: and cc: headers can take up a lot of store. We must also cope
1875 with the possibility of junk being thrown at us. Start by getting 256 bytes for
1876 storing the header, and extend this as necessary using string_cat().
1877
1878 To cope with total lunacies, impose an upper limit on the length of the header
1879 section of the message, as otherwise the store will fill up. We must also cope
1880 with the possibility of binary zeros in the data. Hence we cannot use fgets().
1881 Folded header lines are joined into one string, leaving the '\n' characters
1882 inside them, so that writing them out reproduces the input.
1883
1884 Loop for each character of each header; the next structure for chaining the
1885 header is set up already, with ptr the offset of the next character in
1886 next->text. */
1887
1888 for (;;)
1889   {
1890   int ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
1891
1892   /* If we hit EOF on a SMTP connection, it's an error, since incoming
1893   SMTP must have a correct "." terminator. */
1894
1895   if (ch == EOF && smtp_input /* && !smtp_batched_input */)
1896     {
1897     smtp_reply = handle_lost_connection(US" (header)");
1898     smtp_yield = FALSE;
1899     goto TIDYUP;                       /* Skip to end of function */
1900     }
1901
1902   /* See if we are at the current header's size limit - there must be at least
1903   four bytes left. This allows for the new character plus a zero, plus two for
1904   extra insertions when we are playing games with dots and carriage returns. If
1905   we are at the limit, extend the text buffer. This could have been done
1906   automatically using string_cat() but because this is a tightish loop storing
1907   only one character at a time, we choose to do it inline. Normally
1908   store_extend() will be able to extend the block; only at the end of a big
1909   store block will a copy be needed. To handle the case of very long headers
1910   (and sometimes lunatic messages can have ones that are 100s of K long) we
1911   call store_release() for strings that have been copied - if the string is at
1912   the start of a block (and therefore the only thing in it, because we aren't
1913   doing any other gets), the block gets freed. We can only do this release if
1914   there were no allocations since the once that we want to free. */
1915
1916   if (ptr >= header_size - 4)
1917     {
1918     int oldsize = header_size;
1919
1920     if (header_size >= INT_MAX/2)
1921       goto OVERSIZE;
1922     header_size *= 2;
1923
1924     /* The data came from the message, so is tainted. */
1925
1926     if (!store_extend(next->text, TRUE, oldsize, header_size))
1927       next->text = store_newblock(next->text, TRUE, header_size, ptr);
1928     }
1929
1930   /* Cope with receiving a binary zero. There is dispute about whether
1931   these should be allowed in RFC 822 messages. The middle view is that they
1932   should not be allowed in headers, at least. Exim takes this attitude at
1933   the moment. We can't just stomp on them here, because we don't know that
1934   this line is a header yet. Set a flag to cause scanning later. */
1935
1936   if (ch == 0) had_zero++;
1937
1938   /* Test for termination. Lines in remote SMTP are terminated by CRLF, while
1939   those from data files use just LF. Treat LF in local SMTP input as a
1940   terminator too. Treat EOF as a line terminator always. */
1941
1942   if (ch == EOF) goto EOL;
1943
1944   /* FUDGE: There are sites out there that don't send CRs before their LFs, and
1945   other MTAs accept this. We are therefore forced into this "liberalisation"
1946   too, so we accept LF as a line terminator whatever the source of the message.
1947   However, if the first line of the message ended with a CRLF, we treat a bare
1948   LF specially by inserting a white space after it to ensure that the header
1949   line is not terminated. */
1950
1951   if (ch == '\n')
1952     {
1953     if (first_line_ended_crlf == TRUE_UNSET) first_line_ended_crlf = FALSE;
1954       else if (first_line_ended_crlf) receive_ungetc(' ');
1955     goto EOL;
1956     }
1957
1958   /* This is not the end of the line. If this is SMTP input and this is
1959   the first character in the line and it is a "." character, ignore it.
1960   This implements the dot-doubling rule, though header lines starting with
1961   dots aren't exactly common. They are legal in RFC 822, though. If the
1962   following is CRLF or LF, this is the line that that terminates the
1963   entire message. We set message_ended to indicate this has happened (to
1964   prevent further reading), and break out of the loop, having freed the
1965   empty header, and set next = NULL to indicate no data line. */
1966
1967   if (ptr == 0 && ch == '.' && f.dot_ends)
1968     {
1969     ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
1970     if (ch == '\r')
1971       {
1972       ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
1973       if (ch != '\n')
1974         {
1975         receive_ungetc(ch);
1976         ch = '\r';              /* Revert to CR */
1977         }
1978       }
1979     if (ch == '\n')
1980       {
1981       message_ended = END_DOT;
1982       reset_point = store_reset(reset_point);
1983       next = NULL;
1984       break;                    /* End character-reading loop */
1985       }
1986
1987     /* For non-SMTP input, the dot at the start of the line was really a data
1988     character. What is now in ch is the following character. We guaranteed
1989     enough space for this above. */
1990
1991     if (!smtp_input)
1992       {
1993       next->text[ptr++] = '.';
1994       message_size++;
1995       }
1996     }
1997
1998   /* If CR is immediately followed by LF, end the line, ignoring the CR, and
1999   remember this case if this is the first line ending. */
2000
2001   if (ch == '\r')
2002     {
2003     ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
2004     if (ch == '\n')
2005       {
2006       if (first_line_ended_crlf == TRUE_UNSET) first_line_ended_crlf = TRUE;
2007       goto EOL;
2008       }
2009
2010     /* Otherwise, put back the character after CR, and turn the bare CR
2011     into LF SP. */
2012
2013     ch = (receive_ungetc)(ch);
2014     next->text[ptr++] = '\n';
2015     message_size++;
2016     ch = ' ';
2017     }
2018
2019   /* We have a data character for the header line. */
2020
2021   next->text[ptr++] = ch;    /* Add to buffer */
2022   message_size++;            /* Total message size so far */
2023
2024   /* Handle failure due to a humungously long header section. The >= allows
2025   for the terminating \n. Add what we have so far onto the headers list so
2026   that it gets reflected in any error message, and back up the just-read
2027   character. */
2028
2029   if (message_size >= header_maxsize)
2030     {
2031 OVERSIZE:
2032     next->text[ptr] = 0;
2033     next->slen = ptr;
2034     next->type = htype_other;
2035     next->next = NULL;
2036     header_last->next = next;
2037     header_last = next;
2038
2039     log_write(0, LOG_MAIN, "ridiculously long message header received from "
2040       "%s (more than %d characters): message abandoned",
2041       f.sender_host_unknown ? sender_ident : sender_fullhost, header_maxsize);
2042
2043     if (smtp_input)
2044       {
2045       smtp_reply = US"552 Message header is ridiculously long";
2046       receive_swallow_smtp();
2047       goto TIDYUP;                             /* Skip to end of function */
2048       }
2049
2050     else
2051       {
2052       give_local_error(ERRMESS_VLONGHEADER,
2053         string_sprintf("message header longer than %d characters received: "
2054          "message not accepted", header_maxsize), US"", error_rc, stdin,
2055            header_list->next);
2056       /* Does not return */
2057       }
2058     }
2059
2060   continue;                  /* With next input character */
2061
2062   /* End of header line reached */
2063
2064   EOL:
2065
2066   /* Keep track of lines for BSMTP errors and overall message_linecount. */
2067
2068   receive_linecount++;
2069   message_linecount++;
2070
2071   /* Keep track of maximum line length */
2072
2073   if (ptr - prevlines_length > max_received_linelength)
2074     max_received_linelength = ptr - prevlines_length;
2075   prevlines_length = ptr + 1;
2076
2077   /* Now put in the terminating newline. There is always space for
2078   at least two more characters. */
2079
2080   next->text[ptr++] = '\n';
2081   message_size++;
2082
2083   /* A blank line signals the end of the headers; release the unwanted
2084   space and set next to NULL to indicate this. */
2085
2086   if (ptr == 1)
2087     {
2088     reset_point = store_reset(reset_point);
2089     next = NULL;
2090     break;
2091     }
2092
2093   /* There is data in the line; see if the next input character is a
2094   whitespace character. If it is, we have a continuation of this header line.
2095   There is always space for at least one character at this point. */
2096
2097   if (ch != EOF)
2098     {
2099     int nextch = (receive_getc)(GETC_BUFFER_UNLIMITED);
2100     if (nextch == ' ' || nextch == '\t')
2101       {
2102       next->text[ptr++] = nextch;
2103       if (++message_size >= header_maxsize)
2104         goto OVERSIZE;
2105       continue;                      /* Iterate the loop */
2106       }
2107     else if (nextch != EOF) (receive_ungetc)(nextch);   /* For next time */
2108     else ch = EOF;                   /* Cause main loop to exit at end */
2109     }
2110
2111   /* We have got to the real line end. Terminate the string and release store
2112   beyond it. If it turns out to be a real header, internal binary zeros will
2113   be squashed later. */
2114
2115   next->text[ptr] = 0;
2116   next->slen = ptr;
2117   store_release_above(next->text + ptr + 1);
2118
2119   /* Check the running total size against the overall message size limit. We
2120   don't expect to fail here, but if the overall limit is set less than MESSAGE_
2121   MAXSIZE and a big header is sent, we want to catch it. Just stop reading
2122   headers - the code to read the body will then also hit the buffer. */
2123
2124   if (message_size > thismessage_size_limit) break;
2125
2126   /* A line that is not syntactically correct for a header also marks
2127   the end of the headers. In this case, we leave next containing the
2128   first data line. This might actually be several lines because of the
2129   continuation logic applied above, but that doesn't matter.
2130
2131   It turns out that smail, and presumably sendmail, accept leading lines
2132   of the form
2133
2134   From ph10 Fri Jan  5 12:35 GMT 1996
2135
2136   in messages. The "mail" command on Solaris 2 sends such lines. I cannot
2137   find any documentation of this, but for compatibility it had better be
2138   accepted. Exim restricts it to the case of non-smtp messages, and
2139   treats it as an alternative to the -f command line option. Thus it is
2140   ignored except for trusted users or filter testing. Otherwise it is taken
2141   as the sender address, unless -f was used (sendmail compatibility).
2142
2143   It further turns out that some UUCPs generate the From_line in a different
2144   format, e.g.
2145
2146   From ph10 Fri, 7 Jan 97 14:00:00 GMT
2147
2148   The regex for matching these things is now capable of recognizing both
2149   formats (including 2- and 4-digit years in the latter). In fact, the regex
2150   is now configurable, as is the expansion string to fish out the sender.
2151
2152   Even further on it has been discovered that some broken clients send
2153   these lines in SMTP messages. There is now an option to ignore them from
2154   specified hosts or networks. Sigh. */
2155
2156   if (  header_last == header_list
2157      && (  !smtp_input
2158         || (  sender_host_address
2159            && verify_check_host(&ignore_fromline_hosts) == OK
2160            )
2161         || (!sender_host_address && ignore_fromline_local)
2162         )
2163      && regex_match_and_setup(regex_From, next->text, 0, -1)
2164      )
2165     {
2166     if (!f.sender_address_forced)
2167       {
2168       uschar *uucp_sender = expand_string(uucp_from_sender);
2169       if (!uucp_sender)
2170         log_write(0, LOG_MAIN|LOG_PANIC,
2171           "expansion of \"%s\" failed after matching "
2172           "\"From \" line: %s", uucp_from_sender, expand_string_message);
2173       else
2174         {
2175         int start, end, domain;
2176         uschar *errmess;
2177         uschar *newsender = parse_extract_address(uucp_sender, &errmess,
2178           &start, &end, &domain, TRUE);
2179         if (newsender)
2180           {
2181           if (domain == 0 && newsender[0] != 0)
2182             /* deconst ok as newsender was not const */
2183             newsender = US rewrite_address_qualify(newsender, FALSE);
2184
2185           if (filter_test != FTEST_NONE || receive_check_set_sender(newsender))
2186             {
2187             sender_address = newsender;
2188
2189             if (f.trusted_caller || filter_test != FTEST_NONE)
2190               {
2191               authenticated_sender = NULL;
2192               originator_name = US"";
2193               f.sender_local = FALSE;
2194               }
2195
2196             if (filter_test != FTEST_NONE)
2197               printf("Sender taken from \"From \" line\n");
2198             }
2199           }
2200         }
2201       }
2202     }
2203
2204   /* Not a leading "From " line. Check to see if it is a valid header line.
2205   Header names may contain any non-control characters except space and colon,
2206   amazingly. */
2207
2208   else
2209     {
2210     uschar *p = next->text;
2211
2212     /* If not a valid header line, break from the header reading loop, leaving
2213     next != NULL, indicating that it holds the first line of the body. */
2214
2215     if (isspace(*p)) break;
2216     while (mac_isgraph(*p) && *p != ':') p++;
2217     while (isspace(*p)) p++;
2218     if (*p != ':')
2219       {
2220       body_zerocount = had_zero;
2221       break;
2222       }
2223
2224     /* We have a valid header line. If there were any binary zeroes in
2225     the line, stomp on them here. */
2226
2227     if (had_zero > 0)
2228       for (uschar * p = next->text; p < next->text + ptr; p++) if (*p == 0)
2229         *p = '?';
2230
2231     /* It is perfectly legal to have an empty continuation line
2232     at the end of a header, but it is confusing to humans
2233     looking at such messages, since it looks like a blank line.
2234     Reduce confusion by removing redundant white space at the
2235     end. We know that there is at least one printing character
2236     (the ':' tested for above) so there is no danger of running
2237     off the end. */
2238
2239     p = next->text + ptr - 2;
2240     for (;;)
2241       {
2242       while (*p == ' ' || *p == '\t') p--;
2243       if (*p != '\n') break;
2244       ptr = (p--) - next->text + 1;
2245       message_size -= next->slen - ptr;
2246       next->text[ptr] = 0;
2247       next->slen = ptr;
2248       }
2249
2250     /* Add the header to the chain */
2251
2252     next->type = htype_other;
2253     next->next = NULL;
2254     header_last->next = next;
2255     header_last = next;
2256
2257     /* Check the limit for individual line lengths. This comes after adding to
2258     the chain so that the failing line is reflected if a bounce is generated
2259     (for a local message). */
2260
2261     if (header_line_maxsize > 0 && next->slen > header_line_maxsize)
2262       {
2263       log_write(0, LOG_MAIN, "overlong message header line received from "
2264         "%s (more than %d characters): message abandoned",
2265         f.sender_host_unknown ? sender_ident : sender_fullhost,
2266         header_line_maxsize);
2267
2268       if (smtp_input)
2269         {
2270         smtp_reply = US"552 A message header line is too long";
2271         receive_swallow_smtp();
2272         goto TIDYUP;                             /* Skip to end of function */
2273         }
2274
2275       else
2276         give_local_error(ERRMESS_VLONGHDRLINE,
2277           string_sprintf("message header line longer than %d characters "
2278            "received: message not accepted", header_line_maxsize), US"",
2279            error_rc, stdin, header_list->next);
2280         /* Does not return */
2281       }
2282
2283     /* Note if any resent- fields exist. */
2284
2285     if (!resents_exist && strncmpic(next->text, US"resent-", 7) == 0)
2286       {
2287       resents_exist = TRUE;
2288       resent_prefix = US"Resent-";
2289       }
2290     }
2291
2292   /* Reject CHUNKING messages that do not CRLF their first header line */
2293
2294   if (!first_line_ended_crlf && chunking_state > CHUNKING_OFFERED)
2295     {
2296     log_write(L_size_reject, LOG_MAIN|LOG_REJECT, "rejected from <%s>%s%s%s%s: "
2297       "Non-CRLF-terminated header, under CHUNKING: message abandoned",
2298       sender_address,
2299       sender_fullhost ? " H=" : "", sender_fullhost ? sender_fullhost : US"",
2300       sender_ident ? " U=" : "",    sender_ident ? sender_ident : US"");
2301     smtp_printf("552 Message header not CRLF terminated\r\n", FALSE);
2302     bdat_flush_data();
2303     smtp_reply = US"";
2304     goto TIDYUP;                             /* Skip to end of function */
2305     }
2306
2307   /* The line has been handled. If we have hit EOF, break out of the loop,
2308   indicating no pending data line. */
2309
2310   if (ch == EOF) { next = NULL; break; }
2311
2312   /* Set up for the next header */
2313
2314   reset_point = store_mark();
2315   header_size = 256;
2316   next = store_get(sizeof(header_line), FALSE);
2317   next->text = store_get(header_size, TRUE);
2318   ptr = 0;
2319   had_zero = 0;
2320   prevlines_length = 0;
2321   }      /* Continue, starting to read the next header */
2322
2323 /* At this point, we have read all the headers into a data structure in main
2324 store. The first header is still the dummy placeholder for the Received: header
2325 we are going to generate a bit later on. If next != NULL, it contains the first
2326 data line - which terminated the headers before reaching a blank line (not the
2327 normal case). */
2328
2329 DEBUG(D_receive)
2330   {
2331   debug_printf(">>Headers received:\n");
2332   for (header_line * h = header_list->next; h; h = h->next)
2333     debug_printf("%s", h->text);
2334   debug_printf("\n");
2335   }
2336
2337 /* End of file on any SMTP connection is an error. If an incoming SMTP call
2338 is dropped immediately after valid headers, the next thing we will see is EOF.
2339 We must test for this specially, as further down the reading of the data is
2340 skipped if already at EOF. */
2341
2342 if (smtp_input && (receive_feof)())
2343   {
2344   smtp_reply = handle_lost_connection(US" (after header)");
2345   smtp_yield = FALSE;
2346   goto TIDYUP;                       /* Skip to end of function */
2347   }
2348
2349 /* If this is a filter test run and no headers were read, output a warning
2350 in case there is a mistake in the test message. */
2351
2352 if (filter_test != FTEST_NONE && header_list->next == NULL)
2353   printf("Warning: no message headers read\n");
2354
2355
2356 /* Scan the headers to identify them. Some are merely marked for later
2357 processing; some are dealt with here. */
2358
2359 for (header_line * h = header_list->next; h; h = h->next)
2360   {
2361   BOOL is_resent = strncmpic(h->text, US"resent-", 7) == 0;
2362   if (is_resent) contains_resent_headers = TRUE;
2363
2364   switch (header_checkname(h, is_resent))
2365     {
2366     case htype_bcc:
2367       h->type = htype_bcc;        /* Both Bcc: and Resent-Bcc: */
2368       break;
2369
2370     case htype_cc:
2371       h->type = htype_cc;         /* Both Cc: and Resent-Cc: */
2372       break;
2373
2374       /* Record whether a Date: or Resent-Date: header exists, as appropriate. */
2375
2376     case htype_date:
2377       if (!resents_exist || is_resent) date_header_exists = TRUE;
2378       break;
2379
2380       /* Same comments as about Return-Path: below. */
2381
2382     case htype_delivery_date:
2383       if (delivery_date_remove) h->type = htype_old;
2384       break;
2385
2386       /* Same comments as about Return-Path: below. */
2387
2388     case htype_envelope_to:
2389       if (envelope_to_remove) h->type = htype_old;
2390       break;
2391
2392       /* Mark all "From:" headers so they get rewritten. Save the one that is to
2393       be used for Sender: checking. For Sendmail compatibility, if the "From:"
2394       header consists of just the login id of the user who called Exim, rewrite
2395       it with the gecos field first. Apply this rule to Resent-From: if there
2396       are resent- fields. */
2397
2398     case htype_from:
2399       h->type = htype_from;
2400       if (!resents_exist || is_resent)
2401         {
2402         from_header = h;
2403         if (!smtp_input)
2404           {
2405           int len;
2406           uschar *s = Ustrchr(h->text, ':') + 1;
2407           while (isspace(*s)) s++;
2408           len = h->slen - (s - h->text) - 1;
2409           if (Ustrlen(originator_login) == len &&
2410               strncmpic(s, originator_login, len) == 0)
2411             {
2412             uschar *name = is_resent? US"Resent-From" : US"From";
2413             header_add(htype_from, "%s: %s <%s@%s>\n", name, originator_name,
2414               originator_login, qualify_domain_sender);
2415             from_header = header_last;
2416             h->type = htype_old;
2417             DEBUG(D_receive|D_rewrite)
2418               debug_printf("rewrote \"%s:\" header using gecos\n", name);
2419            }
2420           }
2421         }
2422       break;
2423
2424       /* Identify the Message-id: header for generating "in-reply-to" in the
2425       autoreply transport. For incoming logging, save any resent- value. In both
2426       cases, take just the first of any multiples. */
2427
2428     case htype_id:
2429       if (!msgid_header && (!resents_exist || is_resent))
2430         {
2431         msgid_header = h;
2432         h->type = htype_id;
2433         }
2434       break;
2435
2436       /* Flag all Received: headers */
2437
2438     case htype_received:
2439       h->type = htype_received;
2440       received_count++;
2441       break;
2442
2443       /* "Reply-to:" is just noted (there is no resent-reply-to field) */
2444
2445     case htype_reply_to:
2446       h->type = htype_reply_to;
2447       break;
2448
2449       /* The Return-path: header is supposed to be added to messages when
2450       they leave the SMTP system. We shouldn't receive messages that already
2451       contain Return-path. However, since Exim generates Return-path: on
2452       local delivery, resent messages may well contain it. We therefore
2453       provide an option (which defaults on) to remove any Return-path: headers
2454       on input. Removal actually means flagging as "old", which prevents the
2455       header being transmitted with the message. */
2456
2457     case htype_return_path:
2458       if (return_path_remove) h->type = htype_old;
2459
2460       /* If we are testing a mail filter file, use the value of the
2461       Return-Path: header to set up the return_path variable, which is not
2462       otherwise set. However, remove any <> that surround the address
2463       because the variable doesn't have these. */
2464
2465       if (filter_test != FTEST_NONE)
2466         {
2467         uschar *start = h->text + 12;
2468         uschar *end = start + Ustrlen(start);
2469         while (isspace(*start)) start++;
2470         while (end > start && isspace(end[-1])) end--;
2471         if (*start == '<' && end[-1] == '>')
2472           {
2473           start++;
2474           end--;
2475           }
2476         return_path = string_copyn(start, end - start);
2477         printf("Return-path taken from \"Return-path:\" header line\n");
2478         }
2479       break;
2480
2481     /* If there is a "Sender:" header and the message is locally originated,
2482     and from an untrusted caller and suppress_local_fixups is not set, or if we
2483     are in submission mode for a remote message, mark it "old" so that it will
2484     not be transmitted with the message, unless active_local_sender_retain is
2485     set. (This can only be true if active_local_from_check is false.) If there
2486     are any resent- headers in the message, apply this rule to Resent-Sender:
2487     instead of Sender:. Messages with multiple resent- header sets cannot be
2488     tidily handled. (For this reason, at least one MUA - Pine - turns old
2489     resent- headers into X-resent- headers when resending, leaving just one
2490     set.) */
2491
2492     case htype_sender:
2493       h->type =    !f.active_local_sender_retain
2494                 && (  f.sender_local && !f.trusted_caller && !f.suppress_local_fixups
2495                    || f.submission_mode
2496                    )
2497                 && (!resents_exist || is_resent)
2498         ? htype_old : htype_sender;
2499       break;
2500
2501       /* Remember the Subject: header for logging. There is no Resent-Subject */
2502
2503     case htype_subject:
2504       subject_header = h;
2505       break;
2506
2507       /* "To:" gets flagged, and the existence of a recipient header is noted,
2508       whether it's resent- or not. */
2509
2510     case htype_to:
2511       h->type = htype_to;
2512       /****
2513       to_or_cc_header_exists = TRUE;
2514       ****/
2515       break;
2516     }
2517   }
2518
2519 /* Extract recipients from the headers if that is required (the -t option).
2520 Note that this is documented as being done *before* any address rewriting takes
2521 place. There are two possibilities:
2522
2523 (1) According to sendmail documentation for Solaris, IRIX, and HP-UX, any
2524 recipients already listed are to be REMOVED from the message. Smail 3 works
2525 like this. We need to build a non-recipients tree for that list, because in
2526 subsequent processing this data is held in a tree and that's what the
2527 spool_write_header() function expects. Make sure that non-recipient addresses
2528 are fully qualified and rewritten if necessary.
2529
2530 (2) According to other sendmail documentation, -t ADDS extracted recipients to
2531 those in the command line arguments (and it is rumoured some other MTAs do
2532 this). Therefore, there is an option to make Exim behave this way.
2533
2534 *** Notes on "Resent-" header lines ***
2535
2536 The presence of resent-headers in the message makes -t horribly ambiguous.
2537 Experiments with sendmail showed that it uses recipients for all resent-
2538 headers, totally ignoring the concept of "sets of resent- headers" as described
2539 in RFC 2822 section 3.6.6. Sendmail also amalgamates them into a single set
2540 with all the addresses in one instance of each header.
2541
2542 This seems to me not to be at all sensible. Before release 4.20, Exim 4 gave an
2543 error for -t if there were resent- headers in the message. However, after a
2544 discussion on the mailing list, I've learned that there are MUAs that use
2545 resent- headers with -t, and also that the stuff about sets of resent- headers
2546 and their ordering in RFC 2822 is generally ignored. An MUA that submits a
2547 message with -t and resent- header lines makes sure that only *its* resent-
2548 headers are present; previous ones are often renamed as X-resent- for example.
2549
2550 Consequently, Exim has been changed so that, if any resent- header lines are
2551 present, the recipients are taken from all of the appropriate resent- lines,
2552 and not from the ordinary To:, Cc:, etc. */
2553
2554 if (extract_recip)
2555   {
2556   int rcount = 0;
2557   error_block **bnext = &bad_addresses;
2558
2559   if (extract_addresses_remove_arguments)
2560     {
2561     while (recipients_count-- > 0)
2562       {
2563       const uschar * s = rewrite_address(recipients_list[recipients_count].address,
2564         TRUE, TRUE, global_rewrite_rules, rewrite_existflags);
2565       tree_add_nonrecipient(s);
2566       }
2567     recipients_list = NULL;
2568     recipients_count = recipients_list_max = 0;
2569     }
2570
2571   /* Now scan the headers */
2572
2573   for (header_line * h = header_list->next; h; h = h->next)
2574     {
2575     if ((h->type == htype_to || h->type == htype_cc || h->type == htype_bcc) &&
2576         (!contains_resent_headers || strncmpic(h->text, US"resent-", 7) == 0))
2577       {
2578       uschar *s = Ustrchr(h->text, ':') + 1;
2579       while (isspace(*s)) s++;
2580
2581       f.parse_allow_group = TRUE;          /* Allow address group syntax */
2582
2583       while (*s != 0)
2584         {
2585         uschar *ss = parse_find_address_end(s, FALSE);
2586         uschar *recipient, *errmess, *pp;
2587         int start, end, domain;
2588
2589         /* Check on maximum */
2590
2591         if (recipients_max > 0 && ++rcount > recipients_max)
2592           give_local_error(ERRMESS_TOOMANYRECIP, US"too many recipients",
2593             US"message rejected: ", error_rc, stdin, NULL);
2594           /* Does not return */
2595
2596         /* Make a copy of the address, and remove any internal newlines. These
2597         may be present as a result of continuations of the header line. The
2598         white space that follows the newline must not be removed - it is part
2599         of the header. */
2600
2601         pp = recipient = store_get(ss - s + 1, is_tainted(s));
2602         for (uschar * p = s; p < ss; p++) if (*p != '\n') *pp++ = *p;
2603         *pp = 0;
2604
2605 #ifdef SUPPORT_I18N
2606         {
2607         BOOL b = allow_utf8_domains;
2608         allow_utf8_domains = TRUE;
2609 #endif
2610         recipient = parse_extract_address(recipient, &errmess, &start, &end,
2611           &domain, FALSE);
2612
2613 #ifdef SUPPORT_I18N
2614         if (recipient)
2615           if (string_is_utf8(recipient)) message_smtputf8 = TRUE;
2616           else allow_utf8_domains = b;
2617         }
2618 #else
2619         ;
2620 #endif
2621
2622         /* Keep a list of all the bad addresses so we can send a single
2623         error message at the end. However, an empty address is not an error;
2624         just ignore it. This can come from an empty group list like
2625
2626           To: Recipients of list:;
2627
2628         If there are no recipients at all, an error will occur later. */
2629
2630         if (!recipient && Ustrcmp(errmess, "empty address") != 0)
2631           {
2632           int len = Ustrlen(s);
2633           error_block *b = store_get(sizeof(error_block), FALSE);
2634           while (len > 0 && isspace(s[len-1])) len--;
2635           b->next = NULL;
2636           b->text1 = string_printing(string_copyn(s, len));
2637           b->text2 = errmess;
2638           *bnext = b;
2639           bnext = &(b->next);
2640           }
2641
2642         /* If the recipient is already in the nonrecipients tree, it must
2643         have appeared on the command line with the option extract_addresses_
2644         remove_arguments set. Do not add it to the recipients, and keep a note
2645         that this has happened, in order to give a better error if there are
2646         no recipients left. */
2647
2648         else if (recipient != NULL)
2649           {
2650           if (tree_search(tree_nonrecipients, recipient) == NULL)
2651             receive_add_recipient(recipient, -1);
2652           else
2653             extracted_ignored = TRUE;
2654           }
2655
2656         /* Move on past this address */
2657
2658         s = ss + (*ss? 1:0);
2659         while (isspace(*s)) s++;
2660         }    /* Next address */
2661
2662       f.parse_allow_group = FALSE;      /* Reset group syntax flags */
2663       f.parse_found_group = FALSE;
2664
2665       /* If this was the bcc: header, mark it "old", which means it
2666       will be kept on the spool, but not transmitted as part of the
2667       message. */
2668
2669       if (h->type == htype_bcc) h->type = htype_old;
2670       }   /* For appropriate header line */
2671     }     /* For each header line */
2672
2673   }
2674
2675 /* Now build the unique message id. This has changed several times over the
2676 lifetime of Exim. This description was rewritten for Exim 4.14 (February 2003).
2677 Retaining all the history in the comment has become too unwieldy - read
2678 previous release sources if you want it.
2679
2680 The message ID has 3 parts: tttttt-pppppp-ss. Each part is a number in base 62.
2681 The first part is the current time, in seconds. The second part is the current
2682 pid. Both are large enough to hold 32-bit numbers in base 62. The third part
2683 can hold a number in the range 0-3843. It used to be a computed sequence
2684 number, but is now the fractional component of the current time in units of
2685 1/2000 of a second (i.e. a value in the range 0-1999). After a message has been
2686 received, Exim ensures that the timer has ticked at the appropriate level
2687 before proceeding, to avoid duplication if the pid happened to be re-used
2688 within the same time period. It seems likely that most messages will take at
2689 least half a millisecond to be received, so no delay will normally be
2690 necessary. At least for some time...
2691
2692 There is a modification when localhost_number is set. Formerly this was allowed
2693 to be as large as 255. Now it is restricted to the range 0-16, and the final
2694 component of the message id becomes (localhost_number * 200) + fractional time
2695 in units of 1/200 of a second (i.e. a value in the range 0-3399).
2696
2697 Some not-really-Unix operating systems use case-insensitive file names (Darwin,
2698 Cygwin). For these, we have to use base 36 instead of base 62. Luckily, this
2699 still allows the tttttt field to hold a large enough number to last for some
2700 more decades, and the final two-digit field can hold numbers up to 1295, which
2701 is enough for milliseconds (instead of 1/2000 of a second).
2702
2703 However, the pppppp field cannot hold a 32-bit pid, but it can hold a 31-bit
2704 pid, so it is probably safe because pids have to be positive. The
2705 localhost_number is restricted to 0-10 for these hosts, and when it is set, the
2706 final field becomes (localhost_number * 100) + fractional time in centiseconds.
2707
2708 Note that string_base62() returns its data in a static storage block, so it
2709 must be copied before calling string_base62() again. It always returns exactly
2710 6 characters.
2711
2712 There doesn't seem to be anything in the RFC which requires a message id to
2713 start with a letter, but Smail was changed to ensure this. The external form of
2714 the message id (as supplied by string expansion) therefore starts with an
2715 additional leading 'E'. The spool file names do not include this leading
2716 letter and it is not used internally.
2717
2718 NOTE: If ever the format of message ids is changed, the regular expression for
2719 checking that a string is in this format must be updated in a corresponding
2720 way. It appears in the initializing code in exim.c. The macro MESSAGE_ID_LENGTH
2721 must also be changed to reflect the correct string length. The queue-sort code
2722 needs to know the layout. Then, of course, other programs that rely on the
2723 message id format will need updating too. */
2724
2725 Ustrncpy(message_id, string_base62((long int)(message_id_tv.tv_sec)), 6);
2726 message_id[6] = '-';
2727 Ustrncpy(message_id + 7, string_base62((long int)getpid()), 6);
2728
2729 /* Deal with the case where the host number is set. The value of the number was
2730 checked when it was read, to ensure it isn't too big. */
2731
2732 if (host_number_string)
2733   sprintf(CS(message_id + MESSAGE_ID_LENGTH - 3), "-%2s",
2734     string_base62((long int)(
2735       host_number * (1000000/id_resolution) +
2736         message_id_tv.tv_usec/id_resolution)) + 4);
2737
2738 /* Host number not set: final field is just the fractional time at an
2739 appropriate resolution. */
2740
2741 else
2742   sprintf(CS(message_id + MESSAGE_ID_LENGTH - 3), "-%2s",
2743     string_base62((long int)(message_id_tv.tv_usec/id_resolution)) + 4);
2744
2745 /* Add the current message id onto the current process info string if
2746 it will fit. */
2747
2748 (void)string_format(process_info + process_info_len,
2749   PROCESS_INFO_SIZE - process_info_len, " id=%s", message_id);
2750
2751 /* If we are using multiple input directories, set up the one for this message
2752 to be the least significant base-62 digit of the time of arrival. Otherwise
2753 ensure that it is an empty string. */
2754
2755 set_subdir_str(message_subdir, message_id, 0);
2756
2757 /* Now that we have the message-id, if there is no message-id: header, generate
2758 one, but only for local (without suppress_local_fixups) or submission mode
2759 messages. This can be user-configured if required, but we had better flatten
2760 any illegal characters therein. */
2761
2762 if (  !msgid_header
2763    && ((!sender_host_address && !f.suppress_local_fixups) || f.submission_mode))
2764   {
2765   uschar *id_text = US"";
2766   uschar *id_domain = primary_hostname;
2767   header_line * h;
2768
2769   /* Permit only letters, digits, dots, and hyphens in the domain */
2770
2771   if (message_id_domain)
2772     {
2773     uschar *new_id_domain = expand_string(message_id_domain);
2774     if (!new_id_domain)
2775       {
2776       if (!f.expand_string_forcedfail)
2777         log_write(0, LOG_MAIN|LOG_PANIC,
2778           "expansion of \"%s\" (message_id_header_domain) "
2779           "failed: %s", message_id_domain, expand_string_message);
2780       }
2781     else if (*new_id_domain)
2782       {
2783       id_domain = new_id_domain;
2784       for (uschar * p = id_domain; *p; p++)
2785         if (!isalnum(*p) && *p != '.') *p = '-';  /* No need to test '-' ! */
2786       }
2787     }
2788
2789   /* Permit all characters except controls and RFC 2822 specials in the
2790   additional text part. */
2791
2792   if (message_id_text)
2793     {
2794     uschar *new_id_text = expand_string(message_id_text);
2795     if (!new_id_text)
2796       {
2797       if (!f.expand_string_forcedfail)
2798         log_write(0, LOG_MAIN|LOG_PANIC,
2799           "expansion of \"%s\" (message_id_header_text) "
2800           "failed: %s", message_id_text, expand_string_message);
2801       }
2802     else if (*new_id_text)
2803       {
2804       id_text = new_id_text;
2805       for (uschar * p = id_text; *p; p++) if (mac_iscntrl_or_special(*p)) *p = '-';
2806       }
2807     }
2808
2809   /* Add the header line.
2810   Resent-* headers are prepended, per RFC 5322 3.6.6.  Non-Resent-* are
2811   appended, to preserve classical expectations of header ordering. */
2812
2813   h = header_add_at_position_internal(!resents_exist, NULL, FALSE, htype_id,
2814     "%sMessage-Id: <%s%s%s@%s>\n", resent_prefix, message_id_external,
2815     *id_text == 0 ? "" : ".", id_text, id_domain);
2816
2817   /* Arrange for newly-created Message-Id to be logged */
2818
2819   if (!resents_exist)
2820     {
2821     msgid_header_newly_created = TRUE;
2822     msgid_header = h;
2823     }
2824   }
2825
2826 /* If we are to log recipients, keep a copy of the raw ones before any possible
2827 rewriting. Must copy the count, because later ACLs and the local_scan()
2828 function may mess with the real recipients. */
2829
2830 if (LOGGING(received_recipients))
2831   {
2832   raw_recipients = store_get(recipients_count * sizeof(uschar *), FALSE);
2833   for (int i = 0; i < recipients_count; i++)
2834     raw_recipients[i] = string_copy(recipients_list[i].address);
2835   raw_recipients_count = recipients_count;
2836   }
2837
2838 /* Ensure the recipients list is fully qualified and rewritten. Unqualified
2839 recipients will get here only if the conditions were right (allow_unqualified_
2840 recipient is TRUE). */
2841
2842 for (int i = 0; i < recipients_count; i++)
2843   recipients_list[i].address =  /* deconst ok as src was not cont */
2844     US rewrite_address(recipients_list[i].address, TRUE, TRUE,
2845       global_rewrite_rules, rewrite_existflags);
2846
2847 /* If there is no From: header, generate one for local (without
2848 suppress_local_fixups) or submission_mode messages. If there is no sender
2849 address, but the sender is local or this is a local delivery error, use the
2850 originator login. This shouldn't happen for genuine bounces, but might happen
2851 for autoreplies. The addition of From: must be done *before* checking for the
2852 possible addition of a Sender: header, because untrusted_set_sender allows an
2853 untrusted user to set anything in the envelope (which might then get info
2854 From:) but we still want to ensure a valid Sender: if it is required. */
2855
2856 if (  !from_header
2857    && ((!sender_host_address && !f.suppress_local_fixups) || f.submission_mode))
2858   {
2859   const uschar * oname = US"";
2860
2861   /* Use the originator_name if this is a locally submitted message and the
2862   caller is not trusted. For trusted callers, use it only if -F was used to
2863   force its value or if we have a non-SMTP message for which -f was not used
2864   to set the sender. */
2865
2866   if (!sender_host_address)
2867     {
2868     if (!f.trusted_caller || f.sender_name_forced ||
2869          (!smtp_input && !f.sender_address_forced))
2870       oname = originator_name;
2871     }
2872
2873   /* For non-locally submitted messages, the only time we use the originator
2874   name is when it was forced by the /name= option on control=submission. */
2875
2876   else if (submission_name) oname = submission_name;
2877
2878   /* Envelope sender is empty */
2879
2880   if (!*sender_address)
2881     {
2882     uschar *fromstart, *fromend;
2883
2884     fromstart = string_sprintf("%sFrom: %s%s",
2885       resent_prefix, oname, *oname ? " <" : "");
2886     fromend = *oname ? US">" : US"";
2887
2888     if (f.sender_local || f.local_error_message)
2889       header_add(htype_from, "%s%s@%s%s\n", fromstart,
2890         local_part_quote(originator_login), qualify_domain_sender,
2891         fromend);
2892
2893     else if (f.submission_mode && authenticated_id)
2894       {
2895       if (!submission_domain)
2896         header_add(htype_from, "%s%s@%s%s\n", fromstart,
2897           local_part_quote(authenticated_id), qualify_domain_sender,
2898           fromend);
2899
2900       else if (!*submission_domain)  /* empty => whole address set */
2901         header_add(htype_from, "%s%s%s\n", fromstart, authenticated_id,
2902           fromend);
2903
2904       else
2905         header_add(htype_from, "%s%s@%s%s\n", fromstart,
2906           local_part_quote(authenticated_id), submission_domain, fromend);
2907
2908       from_header = header_last;    /* To get it checked for Sender: */
2909       }
2910     }
2911
2912   /* There is a non-null envelope sender. Build the header using the original
2913   sender address, before any rewriting that might have been done while
2914   verifying it. */
2915
2916   else
2917     {
2918     header_add(htype_from, "%sFrom: %s%s%s%s\n", resent_prefix,
2919       oname,
2920       *oname ? " <" : "",
2921       sender_address_unrewritten ? sender_address_unrewritten : sender_address,
2922       *oname ? ">" : "");
2923
2924     from_header = header_last;    /* To get it checked for Sender: */
2925     }
2926   }
2927
2928
2929 /* If the sender is local (without suppress_local_fixups), or if we are in
2930 submission mode and there is an authenticated_id, check that an existing From:
2931 is correct, and if not, generate a Sender: header, unless disabled. Any
2932 previously-existing Sender: header was removed above. Note that sender_local,
2933 as well as being TRUE if the caller of exim is not trusted, is also true if a
2934 trusted caller did not supply a -f argument for non-smtp input. To allow
2935 trusted callers to forge From: without supplying -f, we have to test explicitly
2936 here. If the From: header contains more than one address, then the call to
2937 parse_extract_address fails, and a Sender: header is inserted, as required. */
2938
2939 if (  from_header
2940    && (  f.active_local_from_check
2941       && (  f.sender_local && !f.trusted_caller && !f.suppress_local_fixups
2942          || f.submission_mode && authenticated_id
2943    )  )  )
2944   {
2945   BOOL make_sender = TRUE;
2946   int start, end, domain;
2947   uschar *errmess;
2948   uschar *from_address =
2949     parse_extract_address(Ustrchr(from_header->text, ':') + 1, &errmess,
2950       &start, &end, &domain, FALSE);
2951   uschar *generated_sender_address;
2952
2953   generated_sender_address = f.submission_mode
2954     ? !submission_domain
2955     ? string_sprintf("%s@%s",
2956         local_part_quote(authenticated_id), qualify_domain_sender)
2957     : !*submission_domain                       /* empty => full address */
2958     ? string_sprintf("%s", authenticated_id)
2959     : string_sprintf("%s@%s",
2960         local_part_quote(authenticated_id), submission_domain)
2961     : string_sprintf("%s@%s",
2962         local_part_quote(originator_login), qualify_domain_sender);
2963
2964   /* Remove permitted prefixes and suffixes from the local part of the From:
2965   address before doing the comparison with the generated sender. */
2966
2967   if (from_address)
2968     {
2969     int slen;
2970     uschar *at = domain ? from_address + domain - 1 : NULL;
2971
2972     if (at) *at = 0;
2973     from_address += route_check_prefix(from_address, local_from_prefix, NULL);
2974     if ((slen = route_check_suffix(from_address, local_from_suffix, NULL)) > 0)
2975       {
2976       memmove(from_address+slen, from_address, Ustrlen(from_address)-slen);
2977       from_address += slen;
2978       }
2979     if (at) *at = '@';
2980
2981     if (  strcmpic(generated_sender_address, from_address) == 0
2982        || (!domain && strcmpic(from_address, originator_login) == 0))
2983         make_sender = FALSE;
2984     }
2985
2986   /* We have to cause the Sender header to be rewritten if there are
2987   appropriate rewriting rules. */
2988
2989   if (make_sender)
2990     if (f.submission_mode && !submission_name)
2991       header_add(htype_sender, "%sSender: %s\n", resent_prefix,
2992         generated_sender_address);
2993     else
2994       header_add(htype_sender, "%sSender: %s <%s>\n",
2995         resent_prefix,
2996         f.submission_mode ? submission_name : originator_name,
2997         generated_sender_address);
2998
2999   /* Ensure that a non-null envelope sender address corresponds to the
3000   submission mode sender address. */
3001
3002   if (f.submission_mode && *sender_address)
3003     {
3004     if (!sender_address_unrewritten)
3005       sender_address_unrewritten = sender_address;
3006     sender_address = generated_sender_address;
3007     if (Ustrcmp(sender_address_unrewritten, generated_sender_address) != 0)
3008       log_write(L_address_rewrite, LOG_MAIN,
3009         "\"%s\" from env-from rewritten as \"%s\" by submission mode",
3010         sender_address_unrewritten, generated_sender_address);
3011     }
3012   }
3013
3014 /* If there are any rewriting rules, apply them to the sender address, unless
3015 it has already been rewritten as part of verification for SMTP input. */
3016
3017 if (global_rewrite_rules && !sender_address_unrewritten && *sender_address)
3018   {
3019   /* deconst ok as src was not const */
3020   sender_address = US rewrite_address(sender_address, FALSE, TRUE,
3021     global_rewrite_rules, rewrite_existflags);
3022   DEBUG(D_receive|D_rewrite)
3023     debug_printf("rewritten sender = %s\n", sender_address);
3024   }
3025
3026
3027 /* The headers must be run through rewrite_header(), because it ensures that
3028 addresses are fully qualified, as well as applying any rewriting rules that may
3029 exist.
3030
3031 Qualification of header addresses in a message from a remote host happens only
3032 if the host is in sender_unqualified_hosts or recipient_unqualified hosts, as
3033 appropriate. For local messages, qualification always happens, unless -bnq is
3034 used to explicitly suppress it. No rewriting is done for an unqualified address
3035 that is left untouched.
3036
3037 We start at the second header, skipping our own Received:. This rewriting is
3038 documented as happening *after* recipient addresses are taken from the headers
3039 by the -t command line option. An added Sender: gets rewritten here. */
3040
3041 for (header_line * h = header_list->next; h; h = h->next)
3042   {
3043   header_line *newh = rewrite_header(h, NULL, NULL, global_rewrite_rules,
3044     rewrite_existflags, TRUE);
3045   if (newh) h = newh;
3046   }
3047
3048
3049 /* An RFC 822 (sic) message is not legal unless it has at least one of "to",
3050 "cc", or "bcc". Note that although the minimal examples in RFC 822 show just
3051 "to" or "bcc", the full syntax spec allows "cc" as well. If any resent- header
3052 exists, this applies to the set of resent- headers rather than the normal set.
3053
3054 The requirement for a recipient header has been removed in RFC 2822. At this
3055 point in the code, earlier versions of Exim added a To: header for locally
3056 submitted messages, and an empty Bcc: header for others. In the light of the
3057 changes in RFC 2822, this was dropped in November 2003. */
3058
3059
3060 /* If there is no date header, generate one if the message originates locally
3061 (i.e. not over TCP/IP) and suppress_local_fixups is not set, or if the
3062 submission mode flag is set. Messages without Date: are not valid, but it seems
3063 to be more confusing if Exim adds one to all remotely-originated messages.
3064 As per Message-Id, we prepend if resending, else append.
3065 */
3066
3067 if (  !date_header_exists
3068    && ((!sender_host_address && !f.suppress_local_fixups) || f.submission_mode))
3069   header_add_at_position(!resents_exist, NULL, FALSE, htype_other,
3070     "%sDate: %s\n", resent_prefix, tod_stamp(tod_full));
3071
3072 search_tidyup();    /* Free any cached resources */
3073
3074 /* Show the complete set of headers if debugging. Note that the first one (the
3075 new Received:) has not yet been set. */
3076
3077 DEBUG(D_receive)
3078   {
3079   debug_printf(">>Headers after rewriting and local additions:\n");
3080   for (header_line * h = header_list->next; h; h = h->next)
3081     debug_printf("%c %s", h->type, h->text);
3082   debug_printf("\n");
3083   }
3084
3085 /* The headers are now complete in store. If we are running in filter
3086 testing mode, that is all this function does. Return TRUE if the message
3087 ended with a dot. */
3088
3089 if (filter_test != FTEST_NONE)
3090   {
3091   process_info[process_info_len] = 0;
3092   return message_ended == END_DOT;
3093   }
3094
3095 /*XXX CHUNKING: need to cancel cutthrough under BDAT, for now.  In future,
3096 think more if it could be handled.  Cannot do onward CHUNKING unless
3097 inbound is, but inbound chunking ought to be ok with outbound plain.
3098 Could we do onward CHUNKING given inbound CHUNKING?
3099 */
3100 if (chunking_state > CHUNKING_OFFERED)
3101   cancel_cutthrough_connection(FALSE, US"chunking active");
3102
3103 /* Cutthrough delivery:
3104 We have to create the Received header now rather than at the end of reception,
3105 so the timestamp behaviour is a change to the normal case.
3106 Having created it, send the headers to the destination. */
3107
3108 if (cutthrough.cctx.sock >= 0 && cutthrough.delivery)
3109   {
3110   if (received_count > received_headers_max)
3111     {
3112     cancel_cutthrough_connection(TRUE, US"too many headers");
3113     if (smtp_input) receive_swallow_smtp();  /* Swallow incoming SMTP */
3114     log_write(0, LOG_MAIN|LOG_REJECT, "rejected from <%s>%s%s%s%s: "
3115       "Too many \"Received\" headers",
3116       sender_address,
3117       sender_fullhost ? "H=" : "", sender_fullhost ? sender_fullhost : US"",
3118       sender_ident ? "U=" : "", sender_ident ? sender_ident : US"");
3119     message_id[0] = 0;                       /* Indicate no message accepted */
3120     smtp_reply = US"550 Too many \"Received\" headers - suspected mail loop";
3121     goto TIDYUP;                             /* Skip to end of function */
3122     }
3123   received_header_gen();
3124   add_acl_headers(ACL_WHERE_RCPT, US"MAIL or RCPT");
3125   (void) cutthrough_headers_send();
3126   }
3127
3128
3129 /* Open a new spool file for the data portion of the message. We need
3130 to access it both via a file descriptor and a stream. Try to make the
3131 directory if it isn't there. */
3132
3133 spool_name = spool_fname(US"input", message_subdir, message_id, US"-D");
3134 DEBUG(D_receive) debug_printf("Data file name: %s\n", spool_name);
3135
3136 if ((data_fd = Uopen(spool_name, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE)) < 0)
3137   {
3138   if (errno == ENOENT)
3139     {
3140     (void) directory_make(spool_directory,
3141                         spool_sname(US"input", message_subdir),
3142                         INPUT_DIRECTORY_MODE, TRUE);
3143     data_fd = Uopen(spool_name, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE);
3144     }
3145   if (data_fd < 0)
3146     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Failed to create spool file %s: %s",
3147       spool_name, strerror(errno));
3148   }
3149
3150 /* Make sure the file's group is the Exim gid, and double-check the mode
3151 because the group setting doesn't always get set automatically. */
3152
3153 if (0 != exim_fchown(data_fd, exim_uid, exim_gid, spool_name))
3154   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
3155     "Failed setting ownership on spool file %s: %s",
3156     spool_name, strerror(errno));
3157 (void)fchmod(data_fd, SPOOL_MODE);
3158
3159 /* We now have data file open. Build a stream for it and lock it. We lock only
3160 the first line of the file (containing the message ID) because otherwise there
3161 are problems when Exim is run under Cygwin (I'm told). See comments in
3162 spool_in.c, where the same locking is done. */
3163
3164 spool_data_file = fdopen(data_fd, "w+");
3165 lock_data.l_type = F_WRLCK;
3166 lock_data.l_whence = SEEK_SET;
3167 lock_data.l_start = 0;
3168 lock_data.l_len = SPOOL_DATA_START_OFFSET;
3169
3170 if (fcntl(data_fd, F_SETLK, &lock_data) < 0)
3171   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Cannot lock %s (%d): %s", spool_name,
3172     errno, strerror(errno));
3173
3174 /* We have an open, locked data file. Write the message id to it to make it
3175 self-identifying. Then read the remainder of the input of this message and
3176 write it to the data file. If the variable next != NULL, it contains the first
3177 data line (which was read as a header but then turned out not to have the right
3178 format); write it (remembering that it might contain binary zeros). The result
3179 of fwrite() isn't inspected; instead we call ferror() below. */
3180
3181 fprintf(spool_data_file, "%s-D\n", message_id);
3182 if (next)
3183   {
3184   uschar *s = next->text;
3185   int len = next->slen;
3186   if (fwrite(s, 1, len, spool_data_file) == len) /* "if" for compiler quietening */
3187     body_linecount++;                 /* Assumes only 1 line */
3188   }
3189
3190 /* Note that we might already be at end of file, or the logical end of file
3191 (indicated by '.'), or might have encountered an error while writing the
3192 message id or "next" line. */
3193
3194 if (!ferror(spool_data_file) && !(receive_feof)() && message_ended != END_DOT)
3195   {
3196   if (smtp_input)
3197     {
3198     message_ended = chunking_state <= CHUNKING_OFFERED
3199       ? read_message_data_smtp(spool_data_file)
3200       : spool_wireformat
3201       ? read_message_bdat_smtp_wire(spool_data_file)
3202       : read_message_bdat_smtp(spool_data_file);
3203     receive_linecount++;                /* The terminating "." line */
3204     }
3205   else
3206     message_ended = read_message_data(spool_data_file);
3207
3208   receive_linecount += body_linecount;  /* For BSMTP errors mainly */
3209   message_linecount += body_linecount;
3210
3211   switch (message_ended)
3212     {
3213     /* Handle premature termination of SMTP */
3214
3215     case END_EOF:
3216       if (smtp_input)
3217         {
3218         Uunlink(spool_name);                 /* Lose data file when closed */
3219         cancel_cutthrough_connection(TRUE, US"sender closed connection");
3220         message_id[0] = 0;                   /* Indicate no message accepted */
3221         smtp_reply = handle_lost_connection(US"");
3222         smtp_yield = FALSE;
3223         goto TIDYUP;                         /* Skip to end of function */
3224         }
3225       break;
3226
3227     /* Handle message that is too big. Don't use host_or_ident() in the log
3228     message; we want to see the ident value even for non-remote messages. */
3229
3230     case END_SIZE:
3231       Uunlink(spool_name);                /* Lose the data file when closed */
3232       cancel_cutthrough_connection(TRUE, US"mail too big");
3233       if (smtp_input) receive_swallow_smtp();  /* Swallow incoming SMTP */
3234
3235       log_write(L_size_reject, LOG_MAIN|LOG_REJECT, "rejected from <%s>%s%s%s%s: "
3236         "message too big: read=%d max=%d",
3237         sender_address,
3238         sender_fullhost ? " H=" : "",
3239         sender_fullhost ? sender_fullhost : US"",
3240         sender_ident ? " U=" : "",
3241         sender_ident ? sender_ident : US"",
3242         message_size,
3243         thismessage_size_limit);
3244
3245       if (smtp_input)
3246         {
3247         smtp_reply = US"552 Message size exceeds maximum permitted";
3248         message_id[0] = 0;               /* Indicate no message accepted */
3249         goto TIDYUP;                     /* Skip to end of function */
3250         }
3251       else
3252         {
3253         fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3254         give_local_error(ERRMESS_TOOBIG,
3255           string_sprintf("message too big (max=%d)", thismessage_size_limit),
3256           US"message rejected: ", error_rc, spool_data_file, header_list);
3257         /* Does not return */
3258         }
3259       break;
3260
3261     /* Handle bad BDAT protocol sequence */
3262
3263     case END_PROTOCOL:
3264       Uunlink(spool_name);              /* Lose the data file when closed */
3265       cancel_cutthrough_connection(TRUE, US"sender protocol error");
3266       smtp_reply = US"";                /* Response already sent */
3267       message_id[0] = 0;                /* Indicate no message accepted */
3268       goto TIDYUP;                      /* Skip to end of function */
3269     }
3270   }
3271
3272 /* Restore the standard SIGALRM handler for any subsequent processing. (For
3273 example, there may be some expansion in an ACL that uses a timer.) */
3274
3275 os_non_restarting_signal(SIGALRM, sigalrm_handler);
3276
3277 /* The message body has now been read into the data file. Call fflush() to
3278 empty the buffers in C, and then call fsync() to get the data written out onto
3279 the disk, as fflush() doesn't do this (or at least, it isn't documented as
3280 having to do this). If there was an I/O error on either input or output,
3281 attempt to send an error message, and unlink the spool file. For non-SMTP input
3282 we can then give up. Note that for SMTP input we must swallow the remainder of
3283 the input in cases of output errors, since the far end doesn't expect to see
3284 anything until the terminating dot line is sent. */
3285
3286 if (fflush(spool_data_file) == EOF || ferror(spool_data_file) ||
3287     EXIMfsync(fileno(spool_data_file)) < 0 || (receive_ferror)())
3288   {
3289   uschar *msg_errno = US strerror(errno);
3290   BOOL input_error = (receive_ferror)() != 0;
3291   uschar *msg = string_sprintf("%s error (%s) while receiving message from %s",
3292     input_error? "Input read" : "Spool write",
3293     msg_errno,
3294     sender_fullhost ? sender_fullhost : sender_ident);
3295
3296   log_write(0, LOG_MAIN, "Message abandoned: %s", msg);
3297   Uunlink(spool_name);                /* Lose the data file */
3298   cancel_cutthrough_connection(TRUE, US"error writing spoolfile");
3299
3300   if (smtp_input)
3301     {
3302     if (input_error)
3303       smtp_reply = US"451 Error while reading input data";
3304     else
3305       {
3306       smtp_reply = US"451 Error while writing spool file";
3307       receive_swallow_smtp();
3308       }
3309     message_id[0] = 0;               /* Indicate no message accepted */
3310     goto TIDYUP;                     /* Skip to end of function */
3311     }
3312
3313   else
3314     {
3315     fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3316     give_local_error(ERRMESS_IOERR, msg, US"", error_rc, spool_data_file,
3317       header_list);
3318     /* Does not return */
3319     }
3320   }
3321
3322
3323 /* No I/O errors were encountered while writing the data file. */
3324
3325 DEBUG(D_receive) debug_printf("Data file written for message %s\n", message_id);
3326 gettimeofday(&received_time_complete, NULL);
3327
3328
3329 /* If there were any bad addresses extracted by -t, or there were no recipients
3330 left after -t, send a message to the sender of this message, or write it to
3331 stderr if the error handling option is set that way. Note that there may
3332 legitimately be no recipients for an SMTP message if they have all been removed
3333 by "discard".
3334
3335 We need to rewind the data file in order to read it. In the case of no
3336 recipients or stderr error writing, throw the data file away afterwards, and
3337 exit. (This can't be SMTP, which always ensures there's at least one
3338 syntactically good recipient address.) */
3339
3340 if (extract_recip && (bad_addresses || recipients_count == 0))
3341   {
3342   DEBUG(D_receive)
3343     {
3344     if (recipients_count == 0) debug_printf("*** No recipients\n");
3345     if (bad_addresses)
3346       {
3347       debug_printf("*** Bad address(es)\n");
3348       for (error_block * eblock = bad_addresses; eblock; eblock = eblock->next)
3349         debug_printf("  %s: %s\n", eblock->text1, eblock->text2);
3350       }
3351     }
3352
3353   log_write(0, LOG_MAIN|LOG_PANIC, "%s %s found in headers",
3354     message_id, bad_addresses ? "bad addresses" : "no recipients");
3355
3356   fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3357
3358   /* If configured to send errors to the sender, but this fails, force
3359   a failure error code. We use a special one for no recipients so that it
3360   can be detected by the autoreply transport. Otherwise error_rc is set to
3361   errors_sender_rc, which is EXIT_FAILURE unless -oee was given, in which case
3362   it is EXIT_SUCCESS. */
3363
3364   if (error_handling == ERRORS_SENDER)
3365     {
3366     if (!moan_to_sender(
3367           bad_addresses
3368           ? recipients_list ? ERRMESS_BADADDRESS : ERRMESS_BADNOADDRESS
3369           : extracted_ignored ? ERRMESS_IGADDRESS : ERRMESS_NOADDRESS,
3370           bad_addresses, header_list, spool_data_file, FALSE
3371        )               )
3372       error_rc = bad_addresses ? EXIT_FAILURE : EXIT_NORECIPIENTS;
3373     }
3374   else
3375     {
3376     if (!bad_addresses)
3377       if (extracted_ignored)
3378         fprintf(stderr, "exim: all -t recipients overridden by command line\n");
3379       else
3380         fprintf(stderr, "exim: no recipients in message\n");
3381     else
3382       {
3383       fprintf(stderr, "exim: invalid address%s",
3384         bad_addresses->next ? "es:\n" : ":");
3385       for ( ; bad_addresses; bad_addresses = bad_addresses->next)
3386         fprintf(stderr, "  %s: %s\n", bad_addresses->text1,
3387           bad_addresses->text2);
3388       }
3389     }
3390
3391   if (recipients_count == 0 || error_handling == ERRORS_STDERR)
3392     {
3393     Uunlink(spool_name);
3394     (void)fclose(spool_data_file);
3395     exim_exit(error_rc);
3396     }
3397   }
3398
3399 /* Data file successfully written. Generate text for the Received: header by
3400 expanding the configured string, and adding a timestamp. By leaving this
3401 operation till now, we ensure that the timestamp is the time that message
3402 reception was completed. However, this is deliberately done before calling the
3403 data ACL and local_scan().
3404
3405 This Received: header may therefore be inspected by the data ACL and by code in
3406 the local_scan() function. When they have run, we update the timestamp to be
3407 the final time of reception.
3408
3409 If there is just one recipient, set up its value in the $received_for variable
3410 for use when we generate the Received: header.
3411
3412 Note: the checking for too many Received: headers is handled by the delivery
3413 code. */
3414 /*XXX eventually add excess Received: check for cutthrough case back when classifying them */
3415
3416 if (!received_header->text)     /* Non-cutthrough case */
3417   {
3418   received_header_gen();
3419
3420   /* Set the value of message_body_size for the DATA ACL and for local_scan() */
3421
3422   message_body_size = (fstat(data_fd, &statbuf) == 0)?
3423     statbuf.st_size - SPOOL_DATA_START_OFFSET : -1;
3424
3425   /* If an ACL from any RCPT commands set up any warning headers to add, do so
3426   now, before running the DATA ACL. */
3427
3428   add_acl_headers(ACL_WHERE_RCPT, US"MAIL or RCPT");
3429   }
3430 else
3431   message_body_size = (fstat(data_fd, &statbuf) == 0)?
3432     statbuf.st_size - SPOOL_DATA_START_OFFSET : -1;
3433
3434 /* If an ACL is specified for checking things at this stage of reception of a
3435 message, run it, unless all the recipients were removed by "discard" in earlier
3436 ACLs. That is the only case in which recipients_count can be zero at this
3437 stage. Set deliver_datafile to point to the data file so that $message_body and
3438 $message_body_end can be extracted if needed. Allow $recipients in expansions.
3439 */
3440
3441 deliver_datafile = data_fd;
3442 user_msg = NULL;
3443
3444 f.enable_dollar_recipients = TRUE;
3445
3446 if (recipients_count == 0)
3447   blackholed_by = f.recipients_discarded ? US"MAIL ACL" : US"RCPT ACL";
3448
3449 else
3450   {
3451   /* Handle interactive SMTP messages */
3452
3453   if (smtp_input && !smtp_batched_input)
3454     {
3455
3456 #ifndef DISABLE_DKIM
3457     if (!f.dkim_disable_verify)
3458       {
3459       /* Finish verification */
3460       dkim_exim_verify_finish();
3461
3462       /* Check if we must run the DKIM ACL */
3463       if (acl_smtp_dkim && dkim_verify_signers && *dkim_verify_signers)
3464         {
3465         uschar * dkim_verify_signers_expanded =
3466           expand_string(dkim_verify_signers);
3467         gstring * results = NULL;
3468         int signer_sep = 0;
3469         const uschar * ptr;
3470         uschar * item;
3471         gstring * seen_items = NULL;
3472         int old_pool = store_pool;
3473
3474         store_pool = POOL_PERM;   /* Allow created variables to live to data ACL */
3475
3476         if (!(ptr = dkim_verify_signers_expanded))
3477           log_write(0, LOG_MAIN|LOG_PANIC,
3478             "expansion of dkim_verify_signers option failed: %s",
3479             expand_string_message);
3480
3481         /* Default to OK when no items are present */
3482         rc = OK;
3483         while ((item = string_nextinlist(&ptr, &signer_sep, NULL, 0)))
3484           {
3485           /* Prevent running ACL for an empty item */
3486           if (!item || !*item) continue;
3487
3488           /* Only run ACL once for each domain or identity,
3489           no matter how often it appears in the expanded list. */
3490           if (seen_items)
3491             {
3492             uschar * seen_item;
3493             const uschar * seen_items_list = string_from_gstring(seen_items);
3494             int seen_sep = ':';
3495             BOOL seen_this_item = FALSE;
3496
3497             while ((seen_item = string_nextinlist(&seen_items_list, &seen_sep,
3498                                                   NULL, 0)))
3499               if (Ustrcmp(seen_item,item) == 0)
3500                 {
3501                 seen_this_item = TRUE;
3502                 break;
3503                 }
3504
3505             if (seen_this_item)
3506               {
3507               DEBUG(D_receive)
3508                 debug_printf("acl_smtp_dkim: skipping signer %s, "
3509                   "already seen\n", item);
3510               continue;
3511               }
3512
3513             seen_items = string_catn(seen_items, US":", 1);
3514             }
3515           seen_items = string_cat(seen_items, item);
3516
3517           rc = dkim_exim_acl_run(item, &results, &user_msg, &log_msg);
3518           if (rc != OK)
3519             {
3520             DEBUG(D_receive)
3521               debug_printf("acl_smtp_dkim: acl_check returned %d on %s, "
3522                 "skipping remaining items\n", rc, item);
3523             cancel_cutthrough_connection(TRUE, US"dkim acl not ok");
3524             break;
3525             }
3526           }
3527         dkim_verify_status = string_from_gstring(results);
3528         store_pool = old_pool;
3529         add_acl_headers(ACL_WHERE_DKIM, US"DKIM");
3530         if (rc == DISCARD)
3531           {
3532           recipients_count = 0;
3533           blackholed_by = US"DKIM ACL";
3534           if (log_msg)
3535             blackhole_log_msg = string_sprintf(": %s", log_msg);
3536           }
3537         else if (rc != OK)
3538           {
3539           Uunlink(spool_name);
3540           if (smtp_handle_acl_fail(ACL_WHERE_DKIM, rc, user_msg, log_msg) != 0)
3541             smtp_yield = FALSE;    /* No more messages after dropped connection */
3542           smtp_reply = US"";       /* Indicate reply already sent */
3543           message_id[0] = 0;       /* Indicate no message accepted */
3544           goto TIDYUP;             /* Skip to end of function */
3545           }
3546         }
3547       else
3548         dkim_exim_verify_log_all();
3549       }
3550 #endif /* DISABLE_DKIM */
3551
3552 #ifdef WITH_CONTENT_SCAN
3553     if (  recipients_count > 0
3554        && acl_smtp_mime
3555        && !run_mime_acl(acl_smtp_mime, &smtp_yield, &smtp_reply, &blackholed_by)
3556        )
3557       goto TIDYUP;
3558 #endif /* WITH_CONTENT_SCAN */
3559
3560 #ifdef SUPPORT_DMARC
3561     dmarc_store_data(from_header);
3562 #endif
3563
3564 #ifndef DISABLE_PRDR
3565     if (prdr_requested && recipients_count > 1 && acl_smtp_data_prdr)
3566       {
3567       int all_pass = OK;
3568       int all_fail = FAIL;
3569
3570       smtp_printf("353 PRDR content analysis beginning\r\n", TRUE);
3571       /* Loop through recipients, responses must be in same order received */
3572       for (unsigned int c = 0; recipients_count > c; c++)
3573         {
3574         uschar * addr= recipients_list[c].address;
3575         uschar * msg= US"PRDR R=<%s> %s";
3576         uschar * code;
3577         DEBUG(D_receive)
3578           debug_printf("PRDR processing recipient %s (%d of %d)\n",
3579                        addr, c+1, recipients_count);
3580         rc = acl_check(ACL_WHERE_PRDR, addr,
3581                        acl_smtp_data_prdr, &user_msg, &log_msg);
3582
3583         /* If any recipient rejected content, indicate it in final message */
3584         all_pass |= rc;
3585         /* If all recipients rejected, indicate in final message */
3586         all_fail &= rc;
3587
3588         switch (rc)
3589           {
3590           case OK: case DISCARD: code = US"250"; break;
3591           case DEFER:            code = US"450"; break;
3592           default:               code = US"550"; break;
3593           }
3594         if (user_msg != NULL)
3595           smtp_user_msg(code, user_msg);
3596         else
3597           {
3598           switch (rc)
3599             {
3600             case OK: case DISCARD:
3601               msg = string_sprintf(CS msg, addr, "acceptance");        break;
3602             case DEFER:
3603               msg = string_sprintf(CS msg, addr, "temporary refusal"); break;
3604             default:
3605               msg = string_sprintf(CS msg, addr, "refusal");           break;
3606             }
3607           smtp_user_msg(code, msg);
3608           }
3609         if (log_msg)       log_write(0, LOG_MAIN, "PRDR %s %s", addr, log_msg);
3610         else if (user_msg) log_write(0, LOG_MAIN, "PRDR %s %s", addr, user_msg);
3611         else               log_write(0, LOG_MAIN, "%s", CS msg);
3612
3613         if (rc != OK) { receive_remove_recipient(addr); c--; }
3614         }
3615       /* Set up final message, used if data acl gives OK */
3616       smtp_reply = string_sprintf("%s id=%s message %s",
3617                        all_fail == FAIL ? US"550" : US"250",
3618                        message_id,
3619                        all_fail == FAIL
3620                          ? US"rejected for all recipients"
3621                          : all_pass == OK
3622                            ? US"accepted"
3623                            : US"accepted for some recipients");
3624       if (recipients_count == 0)
3625         {
3626         message_id[0] = 0;       /* Indicate no message accepted */
3627         goto TIDYUP;
3628         }
3629       }
3630     else
3631       prdr_requested = FALSE;
3632 #endif /* !DISABLE_PRDR */
3633
3634     /* Check the recipients count again, as the MIME ACL might have changed
3635     them. */
3636
3637     if (acl_smtp_data != NULL && recipients_count > 0)
3638       {
3639       rc = acl_check(ACL_WHERE_DATA, NULL, acl_smtp_data, &user_msg, &log_msg);
3640       add_acl_headers(ACL_WHERE_DATA, US"DATA");
3641       if (rc == DISCARD)
3642         {
3643         recipients_count = 0;
3644         blackholed_by = US"DATA ACL";
3645         if (log_msg)
3646           blackhole_log_msg = string_sprintf(": %s", log_msg);
3647         cancel_cutthrough_connection(TRUE, US"data acl discard");
3648         }
3649       else if (rc != OK)
3650         {
3651         Uunlink(spool_name);
3652         cancel_cutthrough_connection(TRUE, US"data acl not ok");
3653 #ifdef WITH_CONTENT_SCAN
3654         unspool_mbox();
3655 #endif
3656 #ifdef EXPERIMENTAL_DCC
3657         dcc_ok = 0;
3658 #endif
3659         if (smtp_handle_acl_fail(ACL_WHERE_DATA, rc, user_msg, log_msg) != 0)
3660           smtp_yield = FALSE;    /* No more messages after dropped connection */
3661         smtp_reply = US"";       /* Indicate reply already sent */
3662         message_id[0] = 0;       /* Indicate no message accepted */
3663         goto TIDYUP;             /* Skip to end of function */
3664         }
3665       }
3666     }
3667
3668   /* Handle non-SMTP and batch SMTP (i.e. non-interactive) messages. Note that
3669   we cannot take different actions for permanent and temporary rejections. */
3670
3671   else
3672     {
3673
3674 #ifdef WITH_CONTENT_SCAN
3675     if (  acl_not_smtp_mime
3676        && !run_mime_acl(acl_not_smtp_mime, &smtp_yield, &smtp_reply,
3677           &blackholed_by)
3678        )
3679       goto TIDYUP;
3680 #endif /* WITH_CONTENT_SCAN */
3681
3682     if (acl_not_smtp)
3683       {
3684       uschar *user_msg, *log_msg;
3685       f.authentication_local = TRUE;
3686       rc = acl_check(ACL_WHERE_NOTSMTP, NULL, acl_not_smtp, &user_msg, &log_msg);
3687       if (rc == DISCARD)
3688         {
3689         recipients_count = 0;
3690         blackholed_by = US"non-SMTP ACL";
3691         if (log_msg)
3692           blackhole_log_msg = string_sprintf(": %s", log_msg);
3693         }
3694       else if (rc != OK)
3695         {
3696         Uunlink(spool_name);
3697 #ifdef WITH_CONTENT_SCAN
3698         unspool_mbox();
3699 #endif
3700 #ifdef EXPERIMENTAL_DCC
3701         dcc_ok = 0;
3702 #endif
3703         /* The ACL can specify where rejections are to be logged, possibly
3704         nowhere. The default is main and reject logs. */
3705
3706         if (log_reject_target)
3707           log_write(0, log_reject_target, "F=<%s> rejected by non-SMTP ACL: %s",
3708             sender_address, log_msg);
3709
3710         if (!user_msg) user_msg = US"local configuration problem";
3711         if (smtp_batched_input)
3712           moan_smtp_batch(NULL, "%d %s", 550, user_msg);
3713           /* Does not return */
3714         else
3715           {
3716           fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3717           give_local_error(ERRMESS_LOCAL_ACL, user_msg,
3718             US"message rejected by non-SMTP ACL: ", error_rc, spool_data_file,
3719               header_list);
3720           /* Does not return */
3721           }
3722         }
3723       add_acl_headers(ACL_WHERE_NOTSMTP, US"non-SMTP");
3724       }
3725     }
3726
3727   /* The applicable ACLs have been run */
3728
3729   if (f.deliver_freeze) frozen_by = US"ACL";     /* for later logging */
3730   if (f.queue_only_policy) queued_by = US"ACL";
3731   }
3732
3733 #ifdef WITH_CONTENT_SCAN
3734 unspool_mbox();
3735 #endif
3736
3737 #ifdef EXPERIMENTAL_DCC
3738 dcc_ok = 0;
3739 #endif
3740
3741
3742 #ifdef HAVE_LOCAL_SCAN
3743 /* The final check on the message is to run the scan_local() function. The
3744 version supplied with Exim always accepts, but this is a hook for sysadmins to
3745 supply their own checking code. The local_scan() function is run even when all
3746 the recipients have been discarded. */
3747
3748 lseek(data_fd, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3749
3750 /* Arrange to catch crashes in local_scan(), so that the -D file gets
3751 deleted, and the incident gets logged. */
3752
3753 if (sigsetjmp(local_scan_env, 1) == 0)
3754   {
3755   had_local_scan_crash = 0;
3756   os_non_restarting_signal(SIGSEGV, local_scan_crash_handler);
3757   os_non_restarting_signal(SIGFPE, local_scan_crash_handler);
3758   os_non_restarting_signal(SIGILL, local_scan_crash_handler);
3759   os_non_restarting_signal(SIGBUS, local_scan_crash_handler);
3760
3761   DEBUG(D_receive) debug_printf("calling local_scan(); timeout=%d\n",
3762     local_scan_timeout);
3763   local_scan_data = NULL;
3764
3765   had_local_scan_timeout = 0;
3766   os_non_restarting_signal(SIGALRM, local_scan_timeout_handler);
3767   if (local_scan_timeout > 0) ALARM(local_scan_timeout);
3768   rc = local_scan(data_fd, &local_scan_data);
3769   ALARM_CLR(0);
3770   os_non_restarting_signal(SIGALRM, sigalrm_handler);
3771
3772   f.enable_dollar_recipients = FALSE;
3773
3774   store_pool = POOL_MAIN;   /* In case changed */
3775   DEBUG(D_receive) debug_printf("local_scan() returned %d %s\n", rc,
3776     local_scan_data);
3777
3778   os_non_restarting_signal(SIGSEGV, SIG_DFL);
3779   os_non_restarting_signal(SIGFPE, SIG_DFL);
3780   os_non_restarting_signal(SIGILL, SIG_DFL);
3781   os_non_restarting_signal(SIGBUS, SIG_DFL);
3782   }
3783 else
3784   {
3785   if (had_local_scan_crash)
3786     {
3787     log_write(0, LOG_MAIN|LOG_REJECT, "local_scan() function crashed with "
3788       "signal %d - message temporarily rejected (size %d)",
3789       had_local_scan_crash, message_size);
3790     receive_bomb_out(US"local-scan-error", US"local verification problem");
3791     /* Does not return */
3792     }
3793   if (had_local_scan_timeout)
3794     {
3795     log_write(0, LOG_MAIN|LOG_REJECT, "local_scan() function timed out - "
3796       "message temporarily rejected (size %d)", message_size);
3797     receive_bomb_out(US"local-scan-timeout", US"local verification problem");
3798     /* Does not return */
3799     }
3800   }
3801
3802 /* The length check is paranoia against some runaway code, and also because
3803 (for a success return) lines in the spool file are read into big_buffer. */
3804
3805 if (local_scan_data)
3806   {
3807   int len = Ustrlen(local_scan_data);
3808   if (len > LOCAL_SCAN_MAX_RETURN) len = LOCAL_SCAN_MAX_RETURN;
3809   local_scan_data = string_copyn(local_scan_data, len);
3810   }
3811
3812 if (rc == LOCAL_SCAN_ACCEPT_FREEZE)
3813   {
3814   if (!f.deliver_freeze)         /* ACL might have already frozen */
3815     {
3816     f.deliver_freeze = TRUE;
3817     deliver_frozen_at = time(NULL);
3818     frozen_by = US"local_scan()";
3819     }
3820   rc = LOCAL_SCAN_ACCEPT;
3821   }
3822 else if (rc == LOCAL_SCAN_ACCEPT_QUEUE)
3823   {
3824   if (!f.queue_only_policy)      /* ACL might have already queued */
3825     {
3826     f.queue_only_policy = TRUE;
3827     queued_by = US"local_scan()";
3828     }
3829   rc = LOCAL_SCAN_ACCEPT;
3830   }
3831
3832 /* Message accepted: remove newlines in local_scan_data because otherwise
3833 the spool file gets corrupted. Ensure that all recipients are qualified. */
3834
3835 if (rc == LOCAL_SCAN_ACCEPT)
3836   {
3837   if (local_scan_data)
3838     for (uschar * s = local_scan_data; *s != 0; s++) if (*s == '\n') *s = ' ';
3839   for (int i = 0; i < recipients_count; i++)
3840     {
3841     recipient_item *r = recipients_list + i;
3842     r->address = rewrite_address_qualify(r->address, TRUE);
3843     if (r->errors_to)
3844       r->errors_to = rewrite_address_qualify(r->errors_to, TRUE);
3845     }
3846   if (recipients_count == 0 && !blackholed_by)
3847     blackholed_by = US"local_scan";
3848   }
3849
3850 /* Message rejected: newlines permitted in local_scan_data to generate
3851 multiline SMTP responses. */
3852
3853 else
3854   {
3855   uschar *istemp = US"";
3856   uschar *smtp_code;
3857   gstring * g;
3858
3859   errmsg = local_scan_data;
3860
3861   Uunlink(spool_name);          /* Cancel this message */
3862   switch(rc)
3863     {
3864     default:
3865       log_write(0, LOG_MAIN, "invalid return %d from local_scan(). Temporary "
3866         "rejection given", rc);
3867       goto TEMPREJECT;
3868
3869     case LOCAL_SCAN_REJECT_NOLOGHDR:
3870       BIT_CLEAR(log_selector, log_selector_size, Li_rejected_header);
3871       /* Fall through */
3872
3873     case LOCAL_SCAN_REJECT:
3874       smtp_code = US"550";
3875       if (!errmsg) errmsg =  US"Administrative prohibition";
3876       break;
3877
3878     case LOCAL_SCAN_TEMPREJECT_NOLOGHDR:
3879       BIT_CLEAR(log_selector, log_selector_size, Li_rejected_header);
3880       /* Fall through */
3881
3882     case LOCAL_SCAN_TEMPREJECT:
3883     TEMPREJECT:
3884       smtp_code = US"451";
3885       if (!errmsg) errmsg = US"Temporary local problem";
3886       istemp = US"temporarily ";
3887       break;
3888     }
3889
3890   g = string_append(NULL, 2, US"F=",
3891     sender_address[0] == 0 ? US"<>" : sender_address);
3892   g = add_host_info_for_log(g);
3893
3894   log_write(0, LOG_MAIN|LOG_REJECT, "%s %srejected by local_scan(): %.256s",
3895     string_from_gstring(g), istemp, string_printing(errmsg));
3896
3897   if (smtp_input)
3898     if (!smtp_batched_input)
3899       {
3900       smtp_respond(smtp_code, 3, TRUE, errmsg);
3901       message_id[0] = 0;            /* Indicate no message accepted */
3902       smtp_reply = US"";            /* Indicate reply already sent */
3903       goto TIDYUP;                  /* Skip to end of function */
3904       }
3905     else
3906       moan_smtp_batch(NULL, "%s %s", smtp_code, errmsg);
3907       /* Does not return */
3908   else
3909     {
3910     fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3911     give_local_error(ERRMESS_LOCAL_SCAN, errmsg,
3912       US"message rejected by local scan code: ", error_rc, spool_data_file,
3913         header_list);
3914     /* Does not return */
3915     }
3916   }
3917
3918 /* Reset signal handlers to ignore signals that previously would have caused
3919 the message to be abandoned. */
3920
3921 signal(SIGTERM, SIG_IGN);
3922 signal(SIGINT, SIG_IGN);
3923 #endif  /* HAVE_LOCAL_SCAN */
3924
3925
3926 /* Ensure the first time flag is set in the newly-received message. */
3927
3928 f.deliver_firsttime = TRUE;
3929
3930 #ifdef EXPERIMENTAL_BRIGHTMAIL
3931 if (bmi_run == 1)
3932   { /* rewind data file */
3933   lseek(data_fd, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3934   bmi_verdicts = bmi_process_message(header_list, data_fd);
3935   }
3936 #endif
3937
3938 /* Update the timestamp in our Received: header to account for any time taken by
3939 an ACL or by local_scan(). The new time is the time that all reception
3940 processing is complete. */
3941
3942 timestamp = expand_string(US"${tod_full}");
3943 tslen = Ustrlen(timestamp);
3944
3945 memcpy(received_header->text + received_header->slen - tslen - 1,
3946   timestamp, tslen);
3947
3948 /* In MUA wrapper mode, ignore queueing actions set by ACL or local_scan() */
3949
3950 if (mua_wrapper)
3951   {
3952   f.deliver_freeze = FALSE;
3953   f.queue_only_policy = FALSE;
3954   }
3955
3956 /* Keep the data file open until we have written the header file, in order to
3957 hold onto the lock. In a -bh run, or if the message is to be blackholed, we
3958 don't write the header file, and we unlink the data file. If writing the header
3959 file fails, we have failed to accept this message. */
3960
3961 if (host_checking || blackholed_by)
3962   {
3963   Uunlink(spool_name);
3964   msg_size = 0;                                  /* Compute size for log line */
3965   for (header_line * h = header_list; h; h = h->next)
3966     if (h->type != '*') msg_size += h->slen;
3967   }
3968
3969 /* Write the -H file */
3970
3971 else
3972   if ((msg_size = spool_write_header(message_id, SW_RECEIVING, &errmsg)) < 0)
3973     {
3974     log_write(0, LOG_MAIN, "Message abandoned: %s", errmsg);
3975     Uunlink(spool_name);           /* Lose the data file */
3976
3977     if (smtp_input)
3978       {
3979       smtp_reply = US"451 Error in writing spool file";
3980       message_id[0] = 0;          /* Indicate no message accepted */
3981       goto TIDYUP;
3982       }
3983     else
3984       {
3985       fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
3986       give_local_error(ERRMESS_IOERR, errmsg, US"", error_rc, spool_data_file,
3987         header_list);
3988       /* Does not return */
3989       }
3990     }
3991
3992
3993 /* The message has now been successfully received. */
3994
3995 receive_messagecount++;
3996
3997 /* Add data size to written header size. We do not count the initial file name
3998 that is in the file, but we do add one extra for the notional blank line that
3999 precedes the data. This total differs from message_size in that it include the
4000 added Received: header and any other headers that got created locally. */
4001
4002 if (fflush(spool_data_file))
4003   {
4004   errmsg = string_sprintf("Spool write error: %s", strerror(errno));
4005   log_write(0, LOG_MAIN, "%s\n", errmsg);
4006   Uunlink(spool_name);           /* Lose the data file */
4007
4008   if (smtp_input)
4009     {
4010     smtp_reply = US"451 Error in writing spool file";
4011     message_id[0] = 0;          /* Indicate no message accepted */
4012     goto TIDYUP;
4013     }
4014   else
4015     {
4016     fseek(spool_data_file, (long int)SPOOL_DATA_START_OFFSET, SEEK_SET);
4017     give_local_error(ERRMESS_IOERR, errmsg, US"", error_rc, spool_data_file,
4018       header_list);
4019     /* Does not return */
4020     }
4021   }
4022 fstat(data_fd, &statbuf);
4023
4024 msg_size += statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
4025
4026 /* Generate a "message received" log entry. We do this by building up a dynamic
4027 string as required.  We log the arrival of a new message while the
4028 file is still locked, just in case the machine is *really* fast, and delivers
4029 it first! Include any message id that is in the message - since the syntax of a
4030 message id is actually an addr-spec, we can use the parse routine to canonicalize
4031 it. */
4032
4033 rcvd_log_reset_point = store_mark();
4034 g = string_get(256);
4035
4036 g = string_append(g, 2,
4037   fake_response == FAIL ? US"(= " : US"<= ",
4038   sender_address[0] == 0 ? US"<>" : sender_address);
4039 if (message_reference)
4040   g = string_append(g, 2, US" R=", message_reference);
4041
4042 g = add_host_info_for_log(g);
4043
4044 #ifndef DISABLE_TLS
4045 if (LOGGING(tls_cipher) && tls_in.cipher)
4046   {
4047   g = string_append(g, 2, US" X=", tls_in.cipher);
4048 # ifndef DISABLE_TLS_RESUME
4049   if (LOGGING(tls_resumption) && tls_in.resumption & RESUME_USED)
4050     g = string_catn(g, US"*", 1);
4051 # endif
4052   }
4053 if (LOGGING(tls_certificate_verified) && tls_in.cipher)
4054   g = string_append(g, 2, US" CV=", tls_in.certificate_verified ? "yes":"no");
4055 if (LOGGING(tls_peerdn) && tls_in.peerdn)
4056   g = string_append(g, 3, US" DN=\"", string_printing(tls_in.peerdn), US"\"");
4057 if (LOGGING(tls_sni) && tls_in.sni)
4058   g = string_append(g, 2, US" SNI=", string_printing2(tls_in.sni, SP_TAB|SP_SPACE));
4059 #endif
4060
4061 if (sender_host_authenticated)
4062   {
4063   g = string_append(g, 2, US" A=", sender_host_authenticated);
4064   if (authenticated_id)
4065     {
4066     g = string_append(g, 2, US":", authenticated_id);
4067     if (LOGGING(smtp_mailauth) && authenticated_sender)
4068       g = string_append(g, 2, US":", authenticated_sender);
4069     }
4070   }
4071
4072 #ifndef DISABLE_PRDR
4073 if (prdr_requested)
4074   g = string_catn(g, US" PRDR", 5);
4075 #endif
4076
4077 #ifdef SUPPORT_PROXY
4078 if (proxy_session && LOGGING(proxy))
4079   g = string_append(g, 2, US" PRX=", proxy_local_address);
4080 #endif
4081
4082 if (chunking_state > CHUNKING_OFFERED)
4083   g = string_catn(g, US" K", 2);
4084
4085 g = string_fmt_append(g, " S=%d", msg_size);
4086
4087 /* log 8BITMIME mode announced in MAIL_FROM
4088    0 ... no BODY= used
4089    7 ... 7BIT
4090    8 ... 8BITMIME */
4091 if (LOGGING(8bitmime))
4092   g = string_fmt_append(g, " M8S=%d", body_8bitmime);
4093
4094 #ifndef DISABLE_DKIM
4095 if (LOGGING(dkim) && dkim_verify_overall)
4096   g = string_append(g, 2, US" DKIM=", dkim_verify_overall);
4097 # ifdef EXPERIMENTAL_ARC
4098 if (LOGGING(dkim) && arc_state && Ustrcmp(arc_state, "pass") == 0)
4099   g = string_catn(g, US" ARC", 4);
4100 # endif
4101 #endif
4102
4103 if (LOGGING(receive_time))
4104   {
4105   struct timeval diff = received_time_complete;
4106   timediff(&diff, &received_time);
4107   g = string_append(g, 2, US" RT=", string_timediff(&diff));
4108   }
4109
4110 if (*queue_name)
4111   g = string_append(g, 2, US" Q=", queue_name);
4112
4113 /* If an addr-spec in a message-id contains a quoted string, it can contain
4114 any characters except " \ and CR and so in particular it can contain NL!
4115 Therefore, make sure we use a printing-characters only version for the log.
4116 Also, allow for domain literals in the message id. */
4117
4118 if (  LOGGING(msg_id) && msgid_header
4119    && (LOGGING(msg_id_created) || !msgid_header_newly_created)
4120    )
4121   {
4122   uschar * old_id;
4123   BOOL save_allow_domain_literals = allow_domain_literals;
4124   allow_domain_literals = TRUE;
4125   int start, end, domain;
4126
4127   old_id = parse_extract_address(Ustrchr(msgid_header->text, ':') + 1,
4128     &errmsg, &start, &end, &domain, FALSE);
4129   allow_domain_literals = save_allow_domain_literals;
4130   if (old_id)
4131     g = string_append(g, 2,
4132       msgid_header_newly_created ? US" id*=" : US" id=",
4133       string_printing(old_id));
4134   }
4135
4136 /* If subject logging is turned on, create suitable printing-character
4137 text. By expanding $h_subject: we make use of the MIME decoding. */
4138
4139 if (LOGGING(subject) && subject_header)
4140   {
4141   uschar *p = big_buffer;
4142   uschar *ss = expand_string(US"$h_subject:");
4143
4144   /* Backslash-quote any double quotes or backslashes so as to make a
4145   a C-like string, and turn any non-printers into escape sequences. */
4146
4147   *p++ = '\"';
4148   if (*ss != 0) for (int i = 0; i < 100 && ss[i] != 0; i++)
4149     {
4150     if (ss[i] == '\"' || ss[i] == '\\') *p++ = '\\';
4151     *p++ = ss[i];
4152     }
4153   *p++ = '\"';
4154   *p = 0;
4155   g = string_append(g, 2, US" T=", string_printing(big_buffer));
4156   }
4157
4158 /* Terminate the string: string_cat() and string_append() leave room, but do
4159 not put the zero in. */
4160
4161 (void) string_from_gstring(g);
4162
4163 /* Create a message log file if message logs are being used and this message is
4164 not blackholed. Write the reception stuff to it. We used to leave message log
4165 creation until the first delivery, but this has proved confusing for some
4166 people. */
4167
4168 if (message_logs && !blackholed_by)
4169   {
4170   int fd;
4171   uschar * m_name = spool_fname(US"msglog", message_subdir, message_id, US"");
4172
4173   if (  (fd = Uopen(m_name, O_WRONLY|O_APPEND|O_CREAT, SPOOL_MODE)) < 0
4174      && errno == ENOENT
4175      )
4176     {
4177     (void)directory_make(spool_directory,
4178                         spool_sname(US"msglog", message_subdir),
4179                         MSGLOG_DIRECTORY_MODE, TRUE);
4180     fd = Uopen(m_name, O_WRONLY|O_APPEND|O_CREAT, SPOOL_MODE);
4181     }
4182
4183   if (fd < 0)
4184     log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't open message log %s: %s",
4185       m_name, strerror(errno));
4186   else
4187     {
4188     FILE *message_log = fdopen(fd, "a");
4189     if (!message_log)
4190       {
4191       log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't fdopen message log %s: %s",
4192         m_name, strerror(errno));
4193       (void)close(fd);
4194       }
4195     else
4196       {
4197       uschar *now = tod_stamp(tod_log);
4198       fprintf(message_log, "%s Received from %s\n", now, g->s+3);
4199       if (f.deliver_freeze) fprintf(message_log, "%s frozen by %s\n", now,
4200         frozen_by);
4201       if (f.queue_only_policy) fprintf(message_log,
4202         "%s no immediate delivery: queued%s%s by %s\n", now,
4203         *queue_name ? " in " : "", *queue_name ? CS queue_name : "",
4204         queued_by);
4205       (void)fclose(message_log);
4206       }
4207     }
4208   }
4209
4210 /* Everything has now been done for a successful message except logging its
4211 arrival, and outputting an SMTP response. While writing to the log, set a flag
4212 to cause a call to receive_bomb_out() if the log cannot be opened. */
4213
4214 f.receive_call_bombout = TRUE;
4215
4216 /* Before sending an SMTP response in a TCP/IP session, we check to see if the
4217 connection has gone away. This can only be done if there is no unconsumed input
4218 waiting in the local input buffer. We can test for this by calling
4219 receive_smtp_buffered(). RFC 2920 (pipelining) explicitly allows for additional
4220 input to be sent following the final dot, so the presence of following input is
4221 not an error.
4222
4223 If the connection is still present, but there is no unread input for the
4224 socket, the result of a select() call will be zero. If, however, the connection
4225 has gone away, or if there is pending input, the result of select() will be
4226 non-zero. The two cases can be distinguished by trying to read the next input
4227 character. If we succeed, we can unread it so that it remains in the local
4228 buffer for handling later. If not, the connection has been lost.
4229
4230 Of course, since TCP/IP is asynchronous, there is always a chance that the
4231 connection will vanish between the time of this test and the sending of the
4232 response, but the chance of this happening should be small. */
4233
4234 if (smtp_input && sender_host_address && !f.sender_host_notsocket &&
4235     !receive_smtp_buffered())
4236   {
4237   struct timeval tv = {.tv_sec = 0, .tv_usec = 0};
4238   fd_set select_check;
4239   FD_ZERO(&select_check);
4240   FD_SET(fileno(smtp_in), &select_check);
4241
4242   if (select(fileno(smtp_in) + 1, &select_check, NULL, NULL, &tv) != 0)
4243     {
4244     int c = (receive_getc)(GETC_BUFFER_UNLIMITED);
4245     if (c != EOF) (receive_ungetc)(c); else
4246       {
4247       smtp_notquit_exit(US"connection-lost", NULL, NULL);
4248       smtp_reply = US"";    /* No attempt to send a response */
4249       smtp_yield = FALSE;   /* Nothing more on this connection */
4250
4251       /* Re-use the log line workspace */
4252
4253       g->ptr = 0;
4254       g = string_cat(g, US"SMTP connection lost after final dot");
4255       g = add_host_info_for_log(g);
4256       log_write(0, LOG_MAIN, "%s", string_from_gstring(g));
4257
4258       /* Delete the files for this aborted message. */
4259
4260       Uunlink(spool_name);
4261       Uunlink(spool_fname(US"input", message_subdir, message_id, US"-H"));
4262       Uunlink(spool_fname(US"msglog", message_subdir, message_id, US""));
4263
4264       goto TIDYUP;
4265       }
4266     }
4267   }
4268
4269 /* The connection has not gone away; we really are going to take responsibility
4270 for this message. */
4271
4272 /* Cutthrough - had sender last-dot; assume we've sent (or bufferred) all
4273    data onward by now.
4274
4275    Send dot onward.  If accepted, wipe the spooled files, log as delivered and accept
4276    the sender's dot (below).
4277    If rejected: copy response to sender, wipe the spooled files, log appropriately.
4278    If temp-reject: normally accept to sender, keep the spooled file - unless defer=pass
4279    in which case pass temp-reject back to initiator and dump the files.
4280
4281    Having the normal spool files lets us do data-filtering, and store/forward on temp-reject.
4282
4283    XXX We do not handle queue-only, freezing, or blackholes.
4284 */
4285 if(cutthrough.cctx.sock >= 0 && cutthrough.delivery)
4286   {
4287   uschar * msg = cutthrough_finaldot(); /* Ask the target system to accept the message */
4288                                         /* Logging was done in finaldot() */
4289   switch(msg[0])
4290     {
4291     case '2':   /* Accept. Do the same to the source; dump any spoolfiles.   */
4292       cutthrough_done = ACCEPTED;
4293       break;                                    /* message_id needed for SMTP accept below */
4294
4295     case '4':   /* Temp-reject. Keep spoolfiles and accept, unless defer-pass mode.
4296                 ... for which, pass back the exact error */
4297       if (cutthrough.defer_pass) smtp_reply = string_copy_perm(msg, TRUE);
4298       cutthrough_done = TMP_REJ;                /* Avoid the usual immediate delivery attempt */
4299       break;                                    /* message_id needed for SMTP accept below */
4300
4301     default:    /* Unknown response, or error.  Treat as temp-reject.         */
4302       if (cutthrough.defer_pass) smtp_reply = US"450 Onward transmission not accepted";
4303       cutthrough_done = TMP_REJ;                /* Avoid the usual immediate delivery attempt */
4304       break;                                    /* message_id needed for SMTP accept below */
4305
4306     case '5':   /* Perm-reject.  Do the same to the source.  Dump any spoolfiles */
4307       smtp_reply = string_copy_perm(msg, TRUE);         /* Pass on the exact error */
4308       cutthrough_done = PERM_REJ;
4309       break;
4310     }
4311   }
4312
4313 #ifndef DISABLE_PRDR
4314 if(!smtp_reply || prdr_requested)
4315 #else
4316 if(!smtp_reply)
4317 #endif
4318   {
4319   log_write(0, LOG_MAIN |
4320     (LOGGING(received_recipients) ? LOG_RECIPIENTS : 0) |
4321     (LOGGING(received_sender) ? LOG_SENDER : 0),
4322     "%s", g->s);
4323
4324   /* Log any control actions taken by an ACL or local_scan(). */
4325
4326   if (f.deliver_freeze) log_write(0, LOG_MAIN, "frozen by %s", frozen_by);
4327   if (f.queue_only_policy) log_write(L_delay_delivery, LOG_MAIN,
4328     "no immediate delivery: queued%s%s by %s",
4329     *queue_name ? " in " : "", *queue_name ? CS queue_name : "",
4330     queued_by);
4331   }
4332 f.receive_call_bombout = FALSE;
4333
4334 /* The store for the main log message can be reused */
4335 rcvd_log_reset_point = store_reset(rcvd_log_reset_point);
4336
4337 /* If the message is frozen, and freeze_tell is set, do the telling. */
4338
4339 if (f.deliver_freeze && freeze_tell && freeze_tell[0])
4340   moan_tell_someone(freeze_tell, NULL, US"Message frozen on arrival",
4341     "Message %s was frozen on arrival by %s.\nThe sender is <%s>.\n",
4342     message_id, frozen_by, sender_address);
4343
4344
4345 /* Either a message has been successfully received and written to the two spool
4346 files, or an error in writing the spool has occurred for an SMTP message, or
4347 an SMTP message has been rejected for policy reasons, or a message was passed on
4348 by cutthrough delivery. (For a non-SMTP message we will have already given up
4349 because there's no point in carrying on!) For non-cutthrough we must now close
4350 (and thereby unlock) the data file. In the successful case, this leaves the
4351 message on the spool, ready for delivery. In the error case, the spool file will
4352 be deleted. Then tidy up store, interact with an SMTP call if necessary, and
4353 return.
4354
4355 For cutthrough we hold the data file locked until we have deleted it, otherwise
4356 a queue-runner could grab it in the window.
4357
4358 A fflush() was done earlier in the expectation that any write errors on the
4359 data file will be flushed(!) out thereby. Nevertheless, it is theoretically
4360 possible for fclose() to fail - but what to do? What has happened to the lock
4361 if this happens?  We can at least log it; if it is observed on some platform
4362 then we can think about properly declaring the message not-received. */
4363
4364
4365 TIDYUP:
4366 process_info[process_info_len] = 0;                     /* Remove message id */
4367 if (spool_data_file && cutthrough_done == NOT_TRIED)
4368   {
4369   if (fclose(spool_data_file))                          /* Frees the lock */
4370     log_write(0, LOG_MAIN|LOG_PANIC,
4371       "spoolfile error on close: %s", strerror(errno));
4372   spool_data_file = NULL;
4373   }
4374
4375 /* Now reset signal handlers to their defaults */
4376
4377 signal(SIGTERM, SIG_DFL);
4378 signal(SIGINT, SIG_DFL);
4379
4380 /* Tell an SMTP caller the state of play, and arrange to return the SMTP return
4381 value, which defaults TRUE - meaning there may be more incoming messages from
4382 this connection. For non-SMTP callers (where there is only ever one message),
4383 the default is FALSE. */
4384
4385 if (smtp_input)
4386   {
4387   yield = smtp_yield;
4388
4389   /* Handle interactive SMTP callers. After several kinds of error, smtp_reply
4390   is set to the response that should be sent. When it is NULL, we generate
4391   default responses. After an ACL error or local_scan() error, the response has
4392   already been sent, and smtp_reply is an empty string to indicate this. */
4393
4394   if (!smtp_batched_input)
4395     {
4396     if (!smtp_reply)
4397       {
4398       if (fake_response != OK)
4399         smtp_respond(fake_response == DEFER ? US"450" : US"550",
4400           3, TRUE, fake_response_text);
4401
4402       /* An OK response is required; use "message" text if present. */
4403
4404       else if (user_msg)
4405         {
4406         uschar *code = US"250";
4407         int len = 3;
4408         smtp_message_code(&code, &len, &user_msg, NULL, TRUE);
4409         smtp_respond(code, len, TRUE, user_msg);
4410         }
4411
4412       /* Default OK response */
4413
4414       else if (chunking_state > CHUNKING_OFFERED)
4415         {
4416         /* If there is more input waiting, no need to flush (probably the client
4417         pipelined QUIT after data).  We check only the in-process buffer, not
4418         the socket. */
4419
4420         smtp_printf("250- %u byte chunk, total %d\r\n250 OK id=%s\r\n",
4421             receive_smtp_buffered(),
4422             chunking_datasize, message_size+message_linecount, message_id);
4423         chunking_state = CHUNKING_OFFERED;
4424         }
4425       else
4426         smtp_printf("250 OK id=%s\r\n", receive_smtp_buffered(), message_id);
4427
4428       if (host_checking)
4429         fprintf(stdout,
4430           "\n**** SMTP testing: that is not a real message id!\n\n");
4431       }
4432
4433     /* smtp_reply is set non-empty */
4434
4435     else if (smtp_reply[0] != 0)
4436       if (fake_response != OK && smtp_reply[0] == '2')
4437         smtp_respond(fake_response == DEFER ? US"450" : US"550", 3, TRUE,
4438           fake_response_text);
4439       else
4440         smtp_printf("%.1024s\r\n", FALSE, smtp_reply);
4441
4442     switch (cutthrough_done)
4443       {
4444       case ACCEPTED:
4445         log_write(0, LOG_MAIN, "Completed");/* Delivery was done */
4446       case PERM_REJ:
4447                                                          /* Delete spool files */
4448         Uunlink(spool_name);
4449         Uunlink(spool_fname(US"input", message_subdir, message_id, US"-H"));
4450         Uunlink(spool_fname(US"msglog", message_subdir, message_id, US""));
4451         break;
4452
4453       case TMP_REJ:
4454         if (cutthrough.defer_pass)
4455           {
4456           Uunlink(spool_name);
4457           Uunlink(spool_fname(US"input", message_subdir, message_id, US"-H"));
4458           Uunlink(spool_fname(US"msglog", message_subdir, message_id, US""));
4459           }
4460       default:
4461         break;
4462       }
4463     if (cutthrough_done != NOT_TRIED)
4464       {
4465       if (spool_data_file)
4466         {
4467         (void) fclose(spool_data_file);  /* Frees the lock; do not care if error */
4468         spool_data_file = NULL;
4469         }
4470       message_id[0] = 0;          /* Prevent a delivery from starting */
4471       cutthrough.delivery = cutthrough.callout_hold_only = FALSE;
4472       cutthrough.defer_pass = FALSE;
4473       }
4474     }
4475
4476   /* For batched SMTP, generate an error message on failure, and do
4477   nothing on success. The function moan_smtp_batch() does not return -
4478   it exits from the program with a non-zero return code. */
4479
4480   else if (smtp_reply)
4481     moan_smtp_batch(NULL, "%s", smtp_reply);
4482   }
4483
4484
4485 /* If blackholing, we can immediately log this message's sad fate. The data
4486 file has already been unlinked, and the header file was never written to disk.
4487 We must now indicate that nothing was received, to prevent a delivery from
4488 starting. */
4489
4490 if (blackholed_by)
4491   {
4492   const uschar *detail =
4493 #ifdef HAVE_LOCAL_SCAN
4494     local_scan_data ? string_printing(local_scan_data) :
4495 #endif
4496     string_sprintf("(%s discarded recipients)", blackholed_by);
4497   log_write(0, LOG_MAIN, "=> blackhole %s%s", detail, blackhole_log_msg);
4498   log_write(0, LOG_MAIN, "Completed");
4499   message_id[0] = 0;
4500   }
4501
4502 /* Reset headers so that logging of rejects for a subsequent message doesn't
4503 include them. It is also important to set header_last = NULL before exiting
4504 from this function, as this prevents certain rewrites that might happen during
4505 subsequent verifying (of another incoming message) from trying to add headers
4506 when they shouldn't. */
4507
4508 header_list = header_last = NULL;
4509
4510 return yield;  /* TRUE if more messages (SMTP only) */
4511 }
4512
4513 /* End of receive.c */