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