xref: /freebsd/contrib/sendmail/src/collect.c (revision 63a938566d524836885917d95bd491aa4400b181)
1 /*
2  * Copyright (c) 1998-2006, 2008 Proofpoint, Inc. and its suppliers.
3  *	All rights reserved.
4  * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
5  * Copyright (c) 1988, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  *
8  * By using this file, you agree to the terms and conditions set
9  * forth in the LICENSE file which can be found at the top level of
10  * the sendmail distribution.
11  *
12  */
13 
14 #include <sendmail.h>
15 
16 SM_RCSID("@(#)$Id: collect.c,v 8.287 2013-11-22 20:51:55 ca Exp $")
17 
18 static void	eatfrom __P((char *volatile, ENVELOPE *));
19 static void	collect_doheader __P((ENVELOPE *));
20 static SM_FILE_T *collect_dfopen __P((ENVELOPE *));
21 static SM_FILE_T *collect_eoh __P((ENVELOPE *, int, int));
22 
23 /*
24 **  COLLECT_EOH -- end-of-header processing in collect()
25 **
26 **	Called by collect() when it encounters the blank line
27 **	separating the header from the message body, or when it
28 **	encounters EOF in a message that contains only a header.
29 **
30 **	Parameters:
31 **		e -- envelope
32 **		numhdrs -- number of headers
33 **		hdrslen -- length of headers
34 **
35 **	Results:
36 **		NULL, or handle to open data file
37 **
38 **	Side Effects:
39 **		end-of-header check ruleset is invoked.
40 **		envelope state is updated.
41 **		headers may be added and deleted.
42 **		selects the queue.
43 **		opens the data file.
44 */
45 
46 static SM_FILE_T *
47 collect_eoh(e, numhdrs, hdrslen)
48 	ENVELOPE *e;
49 	int numhdrs;
50 	int hdrslen;
51 {
52 	char hnum[16];
53 	char hsize[16];
54 
55 	/* call the end-of-header check ruleset */
56 	(void) sm_snprintf(hnum, sizeof(hnum), "%d", numhdrs);
57 	(void) sm_snprintf(hsize, sizeof(hsize), "%d", hdrslen);
58 	if (tTd(30, 10))
59 		sm_dprintf("collect: rscheck(\"check_eoh\", \"%s $| %s\")\n",
60 			   hnum, hsize);
61 	(void) rscheck("check_eoh", hnum, hsize, e, RSF_UNSTRUCTURED|RSF_COUNT,
62 			3, NULL, e->e_id, NULL, NULL);
63 
64 	/*
65 	**  Process the header,
66 	**  select the queue, open the data file.
67 	*/
68 
69 	collect_doheader(e);
70 	return collect_dfopen(e);
71 }
72 
73 /*
74 **  COLLECT_DOHEADER -- process header in collect()
75 **
76 **	Called by collect() after it has finished parsing the header,
77 **	but before it selects the queue and creates the data file.
78 **	The results of processing the header will affect queue selection.
79 **
80 **	Parameters:
81 **		e -- envelope
82 **
83 **	Results:
84 **		none.
85 **
86 **	Side Effects:
87 **		envelope state is updated.
88 **		headers may be added and deleted.
89 */
90 
91 static void
92 collect_doheader(e)
93 	ENVELOPE *e;
94 {
95 	/*
96 	**  Find out some information from the headers.
97 	**	Examples are who is the from person & the date.
98 	*/
99 
100 	eatheader(e, true, false);
101 
102 	if (GrabTo && e->e_sendqueue == NULL)
103 		usrerr("No recipient addresses found in header");
104 
105 	/*
106 	**  If we have a Return-Receipt-To:, turn it into a DSN.
107 	*/
108 
109 	if (RrtImpliesDsn && hvalue("return-receipt-to", e->e_header) != NULL)
110 	{
111 		ADDRESS *q;
112 
113 		for (q = e->e_sendqueue; q != NULL; q = q->q_next)
114 			if (!bitset(QHASNOTIFY, q->q_flags))
115 				q->q_flags |= QHASNOTIFY|QPINGONSUCCESS;
116 	}
117 
118 	/*
119 	**  Add an appropriate recipient line if we have none.
120 	*/
121 
122 	if (hvalue("to", e->e_header) != NULL ||
123 	    hvalue("cc", e->e_header) != NULL ||
124 	    hvalue("apparently-to", e->e_header) != NULL)
125 	{
126 		/* have a valid recipient header -- delete Bcc: headers */
127 		e->e_flags |= EF_DELETE_BCC;
128 	}
129 	else if (hvalue("bcc", e->e_header) == NULL)
130 	{
131 		/* no valid recipient headers */
132 		register ADDRESS *q;
133 		char *hdr = NULL;
134 
135 		/* create a recipient field */
136 		switch (NoRecipientAction)
137 		{
138 		  case NRA_ADD_APPARENTLY_TO:
139 			hdr = "Apparently-To";
140 			break;
141 
142 		  case NRA_ADD_TO:
143 			hdr = "To";
144 			break;
145 
146 		  case NRA_ADD_BCC:
147 			addheader("Bcc", " ", 0, e, true);
148 			break;
149 
150 		  case NRA_ADD_TO_UNDISCLOSED:
151 			addheader("To", "undisclosed-recipients:;", 0, e, true);
152 			break;
153 		}
154 
155 		if (hdr != NULL)
156 		{
157 			for (q = e->e_sendqueue; q != NULL; q = q->q_next)
158 			{
159 				if (q->q_alias != NULL)
160 					continue;
161 				if (tTd(30, 3))
162 					sm_dprintf("Adding %s: %s\n",
163 						hdr, q->q_paddr);
164 				addheader(hdr, q->q_paddr, 0, e, true);
165 			}
166 		}
167 	}
168 }
169 
170 /*
171 **  COLLECT_DFOPEN -- open the message data file
172 **
173 **	Called by collect() after it has finished processing the header.
174 **	Queue selection occurs at this point, possibly based on the
175 **	envelope's recipient list and on header information.
176 **
177 **	Parameters:
178 **		e -- envelope
179 **
180 **	Results:
181 **		NULL, or a pointer to an open data file,
182 **		into which the message body will be written by collect().
183 **
184 **	Side Effects:
185 **		Calls syserr, sets EF_FATALERRS and returns NULL
186 **		if there is insufficient disk space.
187 **		Aborts process if data file could not be opened.
188 **		Otherwise, the queue is selected,
189 **		e->e_{dfino,dfdev,msgsize,flags} are updated,
190 **		and a pointer to an open data file is returned.
191 */
192 
193 static SM_FILE_T *
194 collect_dfopen(e)
195 	ENVELOPE *e;
196 {
197 	MODE_T oldumask = 0;
198 	int dfd;
199 	struct stat stbuf;
200 	SM_FILE_T *df;
201 	char *dfname;
202 
203 	if (!setnewqueue(e))
204 		return NULL;
205 
206 	dfname = queuename(e, DATAFL_LETTER);
207 	if (bitset(S_IWGRP, QueueFileMode))
208 		oldumask = umask(002);
209 	df = bfopen(dfname, QueueFileMode, DataFileBufferSize,
210 		    SFF_OPENASROOT);
211 	if (bitset(S_IWGRP, QueueFileMode))
212 		(void) umask(oldumask);
213 	if (df == NULL)
214 	{
215 		syserr("@Cannot create %s", dfname);
216 		e->e_flags |= EF_NO_BODY_RETN;
217 		flush_errors(true);
218 		finis(false, true, ExitStat);
219 		/* NOTREACHED */
220 	}
221 	dfd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL);
222 	if (dfd < 0 || fstat(dfd, &stbuf) < 0)
223 		e->e_dfino = -1;
224 	else
225 	{
226 		e->e_dfdev = stbuf.st_dev;
227 		e->e_dfino = stbuf.st_ino;
228 	}
229 	e->e_flags |= EF_HAS_DF;
230 	return df;
231 }
232 
233 /*
234 **  COLLECT -- read & parse message header & make temp file.
235 **
236 **	Creates a temporary file name and copies the standard
237 **	input to that file.  Leading UNIX-style "From" lines are
238 **	stripped off (after important information is extracted).
239 **
240 **	Parameters:
241 **		fp -- file to read.
242 **		smtpmode -- if set, we are running SMTP: give an RFC821
243 **			style message to say we are ready to collect
244 **			input, and never ignore a single dot to mean
245 **			end of message.
246 **		hdrp -- the location to stash the header.
247 **		e -- the current envelope.
248 **		rsetsize -- reset e_msgsize?
249 **
250 **	Returns:
251 **		none.
252 **
253 **	Side Effects:
254 **		If successful,
255 **		- Data file is created and filled, and e->e_dfp is set.
256 **		- The from person may be set.
257 **		If the "enough disk space" check fails,
258 **		- syserr is called.
259 **		- e->e_dfp is NULL.
260 **		- e->e_flags & EF_FATALERRS is set.
261 **		- collect() returns.
262 **		If data file cannot be created, the process is terminated.
263 */
264 
265 /* values for input state machine */
266 #define IS_NORM		0	/* middle of line */
267 #define IS_BOL		1	/* beginning of line */
268 #define IS_DOT		2	/* read a dot at beginning of line */
269 #define IS_DOTCR	3	/* read ".\r" at beginning of line */
270 #define IS_CR		4	/* read a carriage return */
271 
272 /* values for message state machine */
273 #define MS_UFROM	0	/* reading Unix from line */
274 #define MS_HEADER	1	/* reading message header */
275 #define MS_BODY		2	/* reading message body */
276 #define MS_DISCARD	3	/* discarding rest of message */
277 
278 void
279 collect(fp, smtpmode, hdrp, e, rsetsize)
280 	SM_FILE_T *fp;
281 	bool smtpmode;
282 	HDR **hdrp;
283 	register ENVELOPE *e;
284 	bool rsetsize;
285 {
286 	register SM_FILE_T *df;
287 	bool ignrdot;
288 	int dbto;
289 	register char *bp;
290 	int c;
291 	bool inputerr;
292 	bool headeronly;
293 	char *buf;
294 	int buflen;
295 	int istate;
296 	int mstate;
297 	int hdrslen;
298 	int numhdrs;
299 	int afd;
300 	int old_rd_tmo;
301 	unsigned char *pbp;
302 	unsigned char peekbuf[8];
303 	char bufbuf[MAXLINE];
304 #if _FFR_REJECT_NUL_BYTE
305 	bool hasNUL;		/* has at least one NUL input byte */
306 #endif /* _FFR_REJECT_NUL_BYTE */
307 
308 	df = NULL;
309 	ignrdot = smtpmode ? false : IgnrDot;
310 
311 	/* timeout for I/O functions is in milliseconds */
312 	dbto = smtpmode ? ((int) TimeOuts.to_datablock * 1000)
313 			: SM_TIME_FOREVER;
314 	sm_io_setinfo(fp, SM_IO_WHAT_TIMEOUT, &dbto);
315 	old_rd_tmo = set_tls_rd_tmo(TimeOuts.to_datablock);
316 	c = SM_IO_EOF;
317 	inputerr = false;
318 	headeronly = hdrp != NULL;
319 	hdrslen = 0;
320 	numhdrs = 0;
321 	HasEightBits = false;
322 #if _FFR_REJECT_NUL_BYTE
323 	hasNUL = false;
324 #endif /* _FFR_REJECT_NUL_BYTE */
325 	buf = bp = bufbuf;
326 	buflen = sizeof(bufbuf);
327 	pbp = peekbuf;
328 	istate = IS_BOL;
329 	mstate = SaveFrom ? MS_HEADER : MS_UFROM;
330 
331 	/*
332 	**  Tell ARPANET to go ahead.
333 	*/
334 
335 	if (smtpmode)
336 		message("354 Enter mail, end with \".\" on a line by itself");
337 
338 	/* simulate an I/O timeout when used as sink */
339 	if (tTd(83, 101))
340 		sleep(319);
341 
342 	if (tTd(30, 2))
343 		sm_dprintf("collect\n");
344 
345 	/*
346 	**  Read the message.
347 	**
348 	**	This is done using two interleaved state machines.
349 	**	The input state machine is looking for things like
350 	**	hidden dots; the message state machine is handling
351 	**	the larger picture (e.g., header versus body).
352 	*/
353 
354 	if (rsetsize)
355 		e->e_msgsize = 0;
356 	for (;;)
357 	{
358 		if (tTd(30, 35))
359 			sm_dprintf("top, istate=%d, mstate=%d\n", istate,
360 				   mstate);
361 		for (;;)
362 		{
363 			if (pbp > peekbuf)
364 				c = *--pbp;
365 			else
366 			{
367 				while (!sm_io_eof(fp) && !sm_io_error(fp))
368 				{
369 					errno = 0;
370 					c = sm_io_getc(fp, SM_TIME_DEFAULT);
371 					if (c == SM_IO_EOF && errno == EINTR)
372 					{
373 						/* Interrupted, retry */
374 						sm_io_clearerr(fp);
375 						continue;
376 					}
377 
378 					/* timeout? */
379 					if (c == SM_IO_EOF && errno == EAGAIN
380 					    && smtpmode)
381 					{
382 						/*
383 						**  Override e_message in
384 						**  usrerr() as this is the
385 						**  reason for failure that
386 						**  should be logged for
387 						**  undelivered recipients.
388 						*/
389 
390 						e->e_message = NULL;
391 						errno = 0;
392 						inputerr = true;
393 						goto readabort;
394 					}
395 					break;
396 				}
397 				if (TrafficLogFile != NULL && !headeronly)
398 				{
399 					if (istate == IS_BOL)
400 						(void) sm_io_fprintf(TrafficLogFile,
401 							SM_TIME_DEFAULT,
402 							"%05d <<< ",
403 							(int) CurrentPid);
404 					if (c == SM_IO_EOF)
405 						(void) sm_io_fprintf(TrafficLogFile,
406 							SM_TIME_DEFAULT,
407 							"[EOF]\n");
408 					else
409 						(void) sm_io_putc(TrafficLogFile,
410 							SM_TIME_DEFAULT,
411 							c);
412 				}
413 #if _FFR_REJECT_NUL_BYTE
414 				if (c == '\0')
415 					hasNUL = true;
416 #endif /* _FFR_REJECT_NUL_BYTE */
417 				if (c == SM_IO_EOF)
418 					goto readerr;
419 				if (SevenBitInput)
420 					c &= 0x7f;
421 				else
422 					HasEightBits |= bitset(0x80, c);
423 			}
424 			if (tTd(30, 94))
425 				sm_dprintf("istate=%d, c=%c (0x%x)\n",
426 					istate, (char) c, c);
427 			switch (istate)
428 			{
429 			  case IS_BOL:
430 				if (c == '.')
431 				{
432 					istate = IS_DOT;
433 					continue;
434 				}
435 				break;
436 
437 			  case IS_DOT:
438 				if (c == '\n' && !ignrdot &&
439 				    !bitset(EF_NL_NOT_EOL, e->e_flags))
440 					goto readerr;
441 				else if (c == '\r' &&
442 					 !bitset(EF_CRLF_NOT_EOL, e->e_flags))
443 				{
444 					istate = IS_DOTCR;
445 					continue;
446 				}
447 				else if (ignrdot ||
448 					 (c != '.' &&
449 					  OpMode != MD_SMTP &&
450 					  OpMode != MD_DAEMON &&
451 					  OpMode != MD_ARPAFTP))
452 
453 				{
454 					SM_ASSERT(pbp < peekbuf +
455 							sizeof(peekbuf));
456 					*pbp++ = c;
457 					c = '.';
458 				}
459 				break;
460 
461 			  case IS_DOTCR:
462 				if (c == '\n' && !ignrdot)
463 					goto readerr;
464 				else
465 				{
466 					/* push back the ".\rx" */
467 					SM_ASSERT(pbp < peekbuf +
468 							sizeof(peekbuf));
469 					*pbp++ = c;
470 					if (OpMode != MD_SMTP &&
471 					    OpMode != MD_DAEMON &&
472 					    OpMode != MD_ARPAFTP)
473 					{
474 						SM_ASSERT(pbp < peekbuf +
475 							 sizeof(peekbuf));
476 						*pbp++ = '\r';
477 						c = '.';
478 					}
479 					else
480 						c = '\r';
481 				}
482 				break;
483 
484 			  case IS_CR:
485 				if (c == '\n')
486 					istate = IS_BOL;
487 				else
488 				{
489 					(void) sm_io_ungetc(fp, SM_TIME_DEFAULT,
490 							    c);
491 					c = '\r';
492 					istate = IS_NORM;
493 				}
494 				goto bufferchar;
495 			}
496 
497 			if (c == '\r' && !bitset(EF_CRLF_NOT_EOL, e->e_flags))
498 			{
499 				istate = IS_CR;
500 				continue;
501 			}
502 			else if (c == '\n' && !bitset(EF_NL_NOT_EOL,
503 						      e->e_flags))
504 				istate = IS_BOL;
505 			else
506 				istate = IS_NORM;
507 
508 bufferchar:
509 			if (!headeronly)
510 			{
511 				/* no overflow? */
512 				if (e->e_msgsize >= 0)
513 				{
514 					e->e_msgsize++;
515 					if (MaxMessageSize > 0 &&
516 					    !bitset(EF_TOOBIG, e->e_flags) &&
517 					    e->e_msgsize > MaxMessageSize)
518 						 e->e_flags |= EF_TOOBIG;
519 				}
520 			}
521 			switch (mstate)
522 			{
523 			  case MS_BODY:
524 				/* just put the character out */
525 				if (!bitset(EF_TOOBIG, e->e_flags))
526 					(void) sm_io_putc(df, SM_TIME_DEFAULT,
527 							  c);
528 
529 				/* FALLTHROUGH */
530 
531 			  case MS_DISCARD:
532 				continue;
533 			}
534 
535 			SM_ASSERT(mstate == MS_UFROM || mstate == MS_HEADER);
536 
537 			/* header -- buffer up */
538 			if (bp >= &buf[buflen - 2])
539 			{
540 				char *obuf;
541 
542 				/* out of space for header */
543 				obuf = buf;
544 				if (buflen < MEMCHUNKSIZE)
545 					buflen *= 2;
546 				else
547 					buflen += MEMCHUNKSIZE;
548 				if (buflen <= 0)
549 				{
550 					sm_syslog(LOG_NOTICE, e->e_id,
551 						  "header overflow from %s during message collect",
552 						  CURHOSTNAME);
553 					errno = 0;
554 					e->e_flags |= EF_CLRQUEUE;
555 					e->e_status = "5.6.0";
556 					usrerrenh(e->e_status,
557 						  "552 Headers too large");
558 					goto discard;
559 				}
560 				buf = xalloc(buflen);
561 				memmove(buf, obuf, bp - obuf);
562 				bp = &buf[bp - obuf];
563 				if (obuf != bufbuf)
564 					sm_free(obuf);  /* XXX */
565 			}
566 
567 			if (c != '\0')
568 			{
569 				*bp++ = c;
570 				++hdrslen;
571 				if (!headeronly &&
572 				    MaxHeadersLength > 0 &&
573 				    hdrslen > MaxHeadersLength)
574 				{
575 					sm_syslog(LOG_NOTICE, e->e_id,
576 						  "headers too large (%d max) from %s during message collect",
577 						  MaxHeadersLength,
578 						  CURHOSTNAME);
579 					errno = 0;
580 					e->e_flags |= EF_CLRQUEUE;
581 					e->e_status = "5.6.0";
582 					usrerrenh(e->e_status,
583 						  "552 Headers too large (%d max)",
584 						  MaxHeadersLength);
585   discard:
586 					mstate = MS_DISCARD;
587 				}
588 			}
589 			if (istate == IS_BOL)
590 				break;
591 		}
592 		*bp = '\0';
593 
594 nextstate:
595 		if (tTd(30, 35))
596 			sm_dprintf("nextstate, istate=%d, mstate=%d, line=\"%s\"\n",
597 				istate, mstate, buf);
598 		switch (mstate)
599 		{
600 		  case MS_UFROM:
601 			mstate = MS_HEADER;
602 #ifndef NOTUNIX
603 			if (strncmp(buf, "From ", 5) == 0)
604 			{
605 				bp = buf;
606 				eatfrom(buf, e);
607 				continue;
608 			}
609 #endif /* ! NOTUNIX */
610 			/* FALLTHROUGH */
611 
612 		  case MS_HEADER:
613 			if (!isheader(buf))
614 			{
615 				mstate = MS_BODY;
616 				goto nextstate;
617 			}
618 
619 			/* check for possible continuation line */
620 			do
621 			{
622 				sm_io_clearerr(fp);
623 				errno = 0;
624 				c = sm_io_getc(fp, SM_TIME_DEFAULT);
625 
626 				/* timeout? */
627 				if (c == SM_IO_EOF && errno == EAGAIN
628 				    && smtpmode)
629 				{
630 					/*
631 					**  Override e_message in
632 					**  usrerr() as this is the
633 					**  reason for failure that
634 					**  should be logged for
635 					**  undelivered recipients.
636 					*/
637 
638 					e->e_message = NULL;
639 					errno = 0;
640 					inputerr = true;
641 					goto readabort;
642 				}
643 			} while (c == SM_IO_EOF && errno == EINTR);
644 			if (c != SM_IO_EOF)
645 				(void) sm_io_ungetc(fp, SM_TIME_DEFAULT, c);
646 			if (c == ' ' || c == '\t')
647 			{
648 				/* yep -- defer this */
649 				continue;
650 			}
651 
652 			SM_ASSERT(bp > buf);
653 
654 			/* guaranteed by isheader(buf) */
655 			SM_ASSERT(*(bp - 1) != '\n' || bp > buf + 1);
656 
657 			/* trim off trailing CRLF or NL */
658 			if (*--bp != '\n' || *--bp != '\r')
659 				bp++;
660 			*bp = '\0';
661 
662 			if (bitset(H_EOH, chompheader(buf,
663 						      CHHDR_CHECK | CHHDR_USER,
664 						      hdrp, e)))
665 			{
666 				mstate = MS_BODY;
667 				goto nextstate;
668 			}
669 			numhdrs++;
670 			break;
671 
672 		  case MS_BODY:
673 			if (tTd(30, 1))
674 				sm_dprintf("EOH\n");
675 
676 			if (headeronly)
677 				goto readerr;
678 
679 			df = collect_eoh(e, numhdrs, hdrslen);
680 			if (df == NULL)
681 				e->e_flags |= EF_TOOBIG;
682 
683 			bp = buf;
684 
685 			/* toss blank line */
686 			if ((!bitset(EF_CRLF_NOT_EOL, e->e_flags) &&
687 				bp[0] == '\r' && bp[1] == '\n') ||
688 			    (!bitset(EF_NL_NOT_EOL, e->e_flags) &&
689 				bp[0] == '\n'))
690 			{
691 				break;
692 			}
693 
694 			/* if not a blank separator, write it out */
695 			if (!bitset(EF_TOOBIG, e->e_flags))
696 			{
697 				while (*bp != '\0')
698 					(void) sm_io_putc(df, SM_TIME_DEFAULT,
699 							  *bp++);
700 			}
701 			break;
702 		}
703 		bp = buf;
704 	}
705 
706 readerr:
707 	if ((sm_io_eof(fp) && smtpmode) || sm_io_error(fp))
708 	{
709 		const char *errmsg;
710 
711 		if (sm_io_eof(fp))
712 			errmsg = "unexpected close";
713 		else
714 			errmsg = sm_errstring(errno);
715 		if (tTd(30, 1))
716 			sm_dprintf("collect: premature EOM: %s\n", errmsg);
717 		if (LogLevel > 1)
718 			sm_syslog(LOG_WARNING, e->e_id,
719 				"collect: premature EOM: %s", errmsg);
720 		inputerr = true;
721 	}
722 
723 	if (headeronly)
724 		goto end;
725 
726 	if (mstate != MS_BODY)
727 	{
728 		/* no body or discard, so we never opened the data file */
729 		SM_ASSERT(df == NULL);
730 		df = collect_eoh(e, numhdrs, hdrslen);
731 	}
732 
733 	if (df == NULL)
734 	{
735 		/* skip next few clauses */
736 		/* EMPTY */
737 	}
738 	else if (sm_io_flush(df, SM_TIME_DEFAULT) != 0 || sm_io_error(df))
739 	{
740 		dferror(df, "sm_io_flush||sm_io_error", e);
741 		flush_errors(true);
742 		finis(true, true, ExitStat);
743 		/* NOTREACHED */
744 	}
745 	else if (SuperSafe == SAFE_NO ||
746 		 SuperSafe == SAFE_INTERACTIVE ||
747 		 (SuperSafe == SAFE_REALLY_POSTMILTER && smtpmode))
748 	{
749 		/* skip next few clauses */
750 		/* EMPTY */
751 		/* Note: updfs() is not called in this case! */
752 	}
753 	else if (sm_io_setinfo(df, SM_BF_COMMIT, NULL) < 0 && errno != EINVAL)
754 	{
755 		int save_errno = errno;
756 
757 		if (save_errno == EEXIST)
758 		{
759 			char *dfile;
760 			struct stat st;
761 			int dfd;
762 
763 			dfile = queuename(e, DATAFL_LETTER);
764 			if (stat(dfile, &st) < 0)
765 				st.st_size = -1;
766 			errno = EEXIST;
767 			syserr("@collect: bfcommit(%s): already on disk, size=%ld",
768 			       dfile, (long) st.st_size);
769 			dfd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL);
770 			if (dfd >= 0)
771 				dumpfd(dfd, true, true);
772 		}
773 		errno = save_errno;
774 		dferror(df, "bfcommit", e);
775 		flush_errors(true);
776 		finis(save_errno != EEXIST, true, ExitStat);
777 	}
778 	else if ((afd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL)) < 0)
779 	{
780 		dferror(df, "sm_io_getinfo", e);
781 		flush_errors(true);
782 		finis(true, true, ExitStat);
783 		/* NOTREACHED */
784 	}
785 	else if (fsync(afd) < 0)
786 	{
787 		dferror(df, "fsync", e);
788 		flush_errors(true);
789 		finis(true, true, ExitStat);
790 		/* NOTREACHED */
791 	}
792 	else if (sm_io_close(df, SM_TIME_DEFAULT) < 0)
793 	{
794 		dferror(df, "sm_io_close", e);
795 		flush_errors(true);
796 		finis(true, true, ExitStat);
797 		/* NOTREACHED */
798 	}
799 	else
800 	{
801 		/* everything is happily flushed to disk */
802 		df = NULL;
803 
804 		/* remove from available space in filesystem */
805 		updfs(e, 0, 1, "collect");
806 	}
807 
808 	/* An EOF when running SMTP is an error */
809   readabort:
810 	if (inputerr && (OpMode == MD_SMTP || OpMode == MD_DAEMON))
811 	{
812 		char *host;
813 		char *problem;
814 		ADDRESS *q;
815 
816 		host = RealHostName;
817 		if (host == NULL)
818 			host = "localhost";
819 
820 		if (sm_io_eof(fp))
821 			problem = "unexpected close";
822 		else if (sm_io_error(fp))
823 			problem = "I/O error";
824 		else
825 			problem = "read timeout";
826 		if (LogLevel > 0 && sm_io_eof(fp))
827 			sm_syslog(LOG_NOTICE, e->e_id,
828 				"collect: %s on connection from %.100s, sender=%s",
829 				problem, host,
830 				shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
831 		if (sm_io_eof(fp))
832 			usrerr("421 4.4.1 collect: %s on connection from %s, from=%s",
833 				problem, host,
834 				shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
835 		else
836 			syserr("421 4.4.1 collect: %s on connection from %s, from=%s",
837 				problem, host,
838 				shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
839 		flush_errors(true);
840 
841 		/* don't return an error indication */
842 		e->e_to = NULL;
843 		e->e_flags &= ~EF_FATALERRS;
844 		e->e_flags |= EF_CLRQUEUE;
845 
846 		/* Don't send any message notification to sender */
847 		for (q = e->e_sendqueue; q != NULL; q = q->q_next)
848 		{
849 			if (QS_IS_DEAD(q->q_state))
850 				continue;
851 			q->q_state = QS_FATALERR;
852 		}
853 
854 		(void) sm_io_close(df, SM_TIME_DEFAULT);
855 		df = NULL;
856 		finis(true, true, ExitStat);
857 		/* NOTREACHED */
858 	}
859 
860 	/* Log collection information. */
861 	if (tTd(92, 2))
862 		sm_dprintf("collect: e_id=%s, EF_LOGSENDER=%d, LogLevel=%d\n",
863 			e->e_id, bitset(EF_LOGSENDER, e->e_flags), LogLevel);
864 	if (bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4)
865 	{
866 		logsender(e, e->e_msgid);
867 		e->e_flags &= ~EF_LOGSENDER;
868 	}
869 
870 	/* check for message too large */
871 	if (bitset(EF_TOOBIG, e->e_flags))
872 	{
873 		e->e_flags |= EF_NO_BODY_RETN|EF_CLRQUEUE;
874 		if (!bitset(EF_FATALERRS, e->e_flags))
875 		{
876 			e->e_status = "5.2.3";
877 			usrerrenh(e->e_status,
878 				"552 Message exceeds maximum fixed size (%ld)",
879 				MaxMessageSize);
880 			if (LogLevel > 6)
881 				sm_syslog(LOG_NOTICE, e->e_id,
882 					"message size (%ld) exceeds maximum (%ld)",
883 					PRT_NONNEGL(e->e_msgsize),
884 					MaxMessageSize);
885 		}
886 	}
887 
888 	/* check for illegal 8-bit data */
889 	if (HasEightBits)
890 	{
891 		e->e_flags |= EF_HAS8BIT;
892 		if (!bitset(MM_PASS8BIT|MM_MIME8BIT, MimeMode) &&
893 		    !bitset(EF_IS_MIME, e->e_flags))
894 		{
895 			e->e_status = "5.6.1";
896 			usrerrenh(e->e_status, "554 Eight bit data not allowed");
897 		}
898 	}
899 	else
900 	{
901 		/* if it claimed to be 8 bits, well, it lied.... */
902 		if (e->e_bodytype != NULL &&
903 		    sm_strcasecmp(e->e_bodytype, "8BITMIME") == 0)
904 			e->e_bodytype = "7BIT";
905 	}
906 
907 #if _FFR_REJECT_NUL_BYTE
908 	if (hasNUL && RejectNUL)
909 	{
910 		e->e_status = "5.6.1";
911 		usrerrenh(e->e_status, "554 NUL byte not allowed");
912 	}
913 #endif /* _FFR_REJECT_NUL_BYTE */
914 
915 	if (SuperSafe == SAFE_REALLY && !bitset(EF_FATALERRS, e->e_flags))
916 	{
917 		char *dfname = queuename(e, DATAFL_LETTER);
918 		if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
919 					   SM_IO_RDONLY_B, NULL)) == NULL)
920 		{
921 			/* we haven't acked receipt yet, so just chuck this */
922 			syserr("@Cannot reopen %s", dfname);
923 			finis(true, true, ExitStat);
924 			/* NOTREACHED */
925 		}
926 	}
927 	else
928 		e->e_dfp = df;
929 
930 	/* collect statistics */
931 	if (OpMode != MD_VERIFY)
932 	{
933 		/*
934 		**  Recalculate e_msgpriority, it is done at in eatheader()
935 		**  which is called (in 8.12) after the header is collected,
936 		**  hence e_msgsize is (most likely) incorrect.
937 		*/
938 
939 		e->e_msgpriority = e->e_msgsize
940 				 - e->e_class * WkClassFact
941 				 + e->e_nrcpts * WkRecipFact;
942 		markstats(e, (ADDRESS *) NULL, STATS_NORMAL);
943 	}
944 
945   end:
946 	(void) set_tls_rd_tmo(old_rd_tmo);
947 }
948 
949 /*
950 **  DFERROR -- signal error on writing the data file.
951 **
952 **	Called by collect().  Collect() always terminates the process
953 **	immediately after calling dferror(), which means that the SMTP
954 **	session will be terminated, which means that any error message
955 **	issued by dferror must be a 421 error, as per RFC 821.
956 **
957 **	Parameters:
958 **		df -- the file pointer for the data file.
959 **		msg -- detailed message.
960 **		e -- the current envelope.
961 **
962 **	Returns:
963 **		none.
964 **
965 **	Side Effects:
966 **		Gives an error message.
967 **		Arranges for following output to go elsewhere.
968 */
969 
970 void
971 dferror(df, msg, e)
972 	SM_FILE_T *volatile df;
973 	char *msg;
974 	register ENVELOPE *e;
975 {
976 	char *dfname;
977 
978 	dfname = queuename(e, DATAFL_LETTER);
979 	setstat(EX_IOERR);
980 	if (errno == ENOSPC)
981 	{
982 #if STAT64 > 0
983 		struct stat64 st;
984 #else /* STAT64 > 0 */
985 		struct stat st;
986 #endif /* STAT64 > 0 */
987 		long avail;
988 		long bsize;
989 
990 		e->e_flags |= EF_NO_BODY_RETN;
991 
992 		if (
993 #if STAT64 > 0
994 		    fstat64(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st)
995 #else /* STAT64 > 0 */
996 		    fstat(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st)
997 #endif /* STAT64 > 0 */
998 		    < 0)
999 		  st.st_size = 0;
1000 		(void) sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, dfname,
1001 				    SM_IO_WRONLY_B, NULL, df);
1002 		if (st.st_size <= 0)
1003 			(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1004 				"\n*** Mail could not be accepted");
1005 		else
1006 			(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1007 				"\n*** Mail of at least %llu bytes could not be accepted\n",
1008 				(ULONGLONG_T) st.st_size);
1009 		(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1010 			"*** at %s due to lack of disk space for temp file.\n",
1011 			MyHostName);
1012 		avail = freediskspace(qid_printqueue(e->e_qgrp, e->e_qdir),
1013 				      &bsize);
1014 		if (avail > 0)
1015 		{
1016 			if (bsize > 1024)
1017 				avail *= bsize / 1024;
1018 			else if (bsize < 1024)
1019 				avail /= 1024 / bsize;
1020 			(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1021 				"*** Currently, %ld kilobytes are available for mail temp files.\n",
1022 				avail);
1023 		}
1024 #if 0
1025 		/* Wrong response code; should be 421. */
1026 		e->e_status = "4.3.1";
1027 		usrerrenh(e->e_status, "452 Out of disk space for temp file");
1028 #else /* 0 */
1029 		syserr("421 4.3.1 Out of disk space for temp file");
1030 #endif /* 0 */
1031 	}
1032 	else
1033 		syserr("421 4.3.0 collect: Cannot write %s (%s, uid=%ld, gid=%ld)",
1034 			dfname, msg, (long) geteuid(), (long) getegid());
1035 	if (sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, SM_PATH_DEVNULL,
1036 			 SM_IO_WRONLY, NULL, df) == NULL)
1037 		sm_syslog(LOG_ERR, e->e_id,
1038 			  "dferror: sm_io_reopen(\"/dev/null\") failed: %s",
1039 			  sm_errstring(errno));
1040 }
1041 /*
1042 **  EATFROM -- chew up a UNIX style from line and process
1043 **
1044 **	This does indeed make some assumptions about the format
1045 **	of UNIX messages.
1046 **
1047 **	Parameters:
1048 **		fm -- the from line.
1049 **		e -- envelope
1050 **
1051 **	Returns:
1052 **		none.
1053 **
1054 **	Side Effects:
1055 **		extracts what information it can from the header,
1056 **		such as the date.
1057 */
1058 
1059 #ifndef NOTUNIX
1060 
1061 static char	*DowList[] =
1062 {
1063 	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
1064 };
1065 
1066 static char	*MonthList[] =
1067 {
1068 	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
1069 	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
1070 	NULL
1071 };
1072 
1073 static void
1074 eatfrom(fm, e)
1075 	char *volatile fm;
1076 	register ENVELOPE *e;
1077 {
1078 	register char *p;
1079 	register char **dt;
1080 
1081 	if (tTd(30, 2))
1082 		sm_dprintf("eatfrom(%s)\n", fm);
1083 
1084 	/* find the date part */
1085 	p = fm;
1086 	while (*p != '\0')
1087 	{
1088 		/* skip a word */
1089 		while (*p != '\0' && *p != ' ')
1090 			p++;
1091 		while (*p == ' ')
1092 			p++;
1093 		if (strlen(p) < 17)
1094 		{
1095 			/* no room for the date */
1096 			return;
1097 		}
1098 		if (!(isascii(*p) && isupper(*p)) ||
1099 		    p[3] != ' ' || p[13] != ':' || p[16] != ':')
1100 			continue;
1101 
1102 		/* we have a possible date */
1103 		for (dt = DowList; *dt != NULL; dt++)
1104 			if (strncmp(*dt, p, 3) == 0)
1105 				break;
1106 		if (*dt == NULL)
1107 			continue;
1108 
1109 		for (dt = MonthList; *dt != NULL; dt++)
1110 		{
1111 			if (strncmp(*dt, &p[4], 3) == 0)
1112 				break;
1113 		}
1114 		if (*dt != NULL)
1115 			break;
1116 	}
1117 
1118 	if (*p != '\0')
1119 	{
1120 		char *q, buf[25];
1121 
1122 		/* we have found a date */
1123 		(void) sm_strlcpy(buf, p, sizeof(buf));
1124 		q = arpadate(buf);
1125 		macdefine(&e->e_macro, A_TEMP, 'a', q);
1126 	}
1127 }
1128 #endif /* ! NOTUNIX */
1129