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
16SM_RCSID("@(#)$Id: collect.c,v 8.287 2013-11-22 20:51:55 ca Exp $")
17
18static void	eatfrom __P((char *volatile, ENVELOPE *));
19static void	collect_doheader __P((ENVELOPE *));
20static SM_FILE_T *collect_dfopen __P((ENVELOPE *));
21static 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
46static SM_FILE_T *
47collect_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
91static void
92collect_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
193static SM_FILE_T *
194collect_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
278void
279collect(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
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
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
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					goto readerr;
440				else if (c == '\r')
441				{
442					istate = IS_DOTCR;
443					continue;
444				}
445				else if (ignrdot ||
446					 (c != '.' &&
447					  OpMode != MD_SMTP &&
448					  OpMode != MD_DAEMON &&
449					  OpMode != MD_ARPAFTP))
450
451				{
452					SM_ASSERT(pbp < peekbuf +
453							sizeof(peekbuf));
454					*pbp++ = c;
455					c = '.';
456				}
457				break;
458
459			  case IS_DOTCR:
460				if (c == '\n' && !ignrdot)
461					goto readerr;
462				else
463				{
464					/* push back the ".\rx" */
465					SM_ASSERT(pbp < peekbuf +
466							sizeof(peekbuf));
467					*pbp++ = c;
468					if (OpMode != MD_SMTP &&
469					    OpMode != MD_DAEMON &&
470					    OpMode != MD_ARPAFTP)
471					{
472						SM_ASSERT(pbp < peekbuf +
473							 sizeof(peekbuf));
474						*pbp++ = '\r';
475						c = '.';
476					}
477					else
478						c = '\r';
479				}
480				break;
481
482			  case IS_CR:
483				if (c == '\n')
484					istate = IS_BOL;
485				else
486				{
487					(void) sm_io_ungetc(fp, SM_TIME_DEFAULT,
488							    c);
489					c = '\r';
490					istate = IS_NORM;
491				}
492				goto bufferchar;
493			}
494
495			if (c == '\r')
496			{
497				istate = IS_CR;
498				continue;
499			}
500			else if (c == '\n')
501				istate = IS_BOL;
502			else
503				istate = IS_NORM;
504
505bufferchar:
506			if (!headeronly)
507			{
508				/* no overflow? */
509				if (e->e_msgsize >= 0)
510				{
511					e->e_msgsize++;
512					if (MaxMessageSize > 0 &&
513					    !bitset(EF_TOOBIG, e->e_flags) &&
514					    e->e_msgsize > MaxMessageSize)
515						 e->e_flags |= EF_TOOBIG;
516				}
517			}
518			switch (mstate)
519			{
520			  case MS_BODY:
521				/* just put the character out */
522				if (!bitset(EF_TOOBIG, e->e_flags))
523					(void) sm_io_putc(df, SM_TIME_DEFAULT,
524							  c);
525
526				/* FALLTHROUGH */
527
528			  case MS_DISCARD:
529				continue;
530			}
531
532			SM_ASSERT(mstate == MS_UFROM || mstate == MS_HEADER);
533
534			/* header -- buffer up */
535			if (bp >= &buf[buflen - 2])
536			{
537				char *obuf;
538
539				/* out of space for header */
540				obuf = buf;
541				if (buflen < MEMCHUNKSIZE)
542					buflen *= 2;
543				else
544					buflen += MEMCHUNKSIZE;
545				if (buflen <= 0)
546				{
547					sm_syslog(LOG_NOTICE, e->e_id,
548						  "header overflow from %s during message collect",
549						  CURHOSTNAME);
550					errno = 0;
551					e->e_flags |= EF_CLRQUEUE;
552					e->e_status = "5.6.0";
553					usrerrenh(e->e_status,
554						  "552 Headers too large");
555					goto discard;
556				}
557				buf = xalloc(buflen);
558				memmove(buf, obuf, bp - obuf);
559				bp = &buf[bp - obuf];
560				if (obuf != bufbuf)
561					sm_free(obuf);  /* XXX */
562			}
563
564			if (c != '\0')
565			{
566				*bp++ = c;
567				++hdrslen;
568				if (!headeronly &&
569				    MaxHeadersLength > 0 &&
570				    hdrslen > MaxHeadersLength)
571				{
572					sm_syslog(LOG_NOTICE, e->e_id,
573						  "headers too large (%d max) from %s during message collect",
574						  MaxHeadersLength,
575						  CURHOSTNAME);
576					errno = 0;
577					e->e_flags |= EF_CLRQUEUE;
578					e->e_status = "5.6.0";
579					usrerrenh(e->e_status,
580						  "552 Headers too large (%d max)",
581						  MaxHeadersLength);
582  discard:
583					mstate = MS_DISCARD;
584				}
585			}
586			if (istate == IS_BOL)
587				break;
588		}
589		*bp = '\0';
590
591nextstate:
592		if (tTd(30, 35))
593			sm_dprintf("nextstate, istate=%d, mstate=%d, line=\"%s\"\n",
594				istate, mstate, buf);
595		switch (mstate)
596		{
597		  case MS_UFROM:
598			mstate = MS_HEADER;
599#ifndef NOTUNIX
600			if (strncmp(buf, "From ", 5) == 0)
601			{
602				bp = buf;
603				eatfrom(buf, e);
604				continue;
605			}
606#endif /* ! NOTUNIX */
607			/* FALLTHROUGH */
608
609		  case MS_HEADER:
610			if (!isheader(buf))
611			{
612				mstate = MS_BODY;
613				goto nextstate;
614			}
615
616			/* check for possible continuation line */
617			do
618			{
619				sm_io_clearerr(fp);
620				errno = 0;
621				c = sm_io_getc(fp, SM_TIME_DEFAULT);
622
623				/* timeout? */
624				if (c == SM_IO_EOF && errno == EAGAIN
625				    && smtpmode)
626				{
627					/*
628					**  Override e_message in
629					**  usrerr() as this is the
630					**  reason for failure that
631					**  should be logged for
632					**  undelivered recipients.
633					*/
634
635					e->e_message = NULL;
636					errno = 0;
637					inputerr = true;
638					goto readabort;
639				}
640			} while (c == SM_IO_EOF && errno == EINTR);
641			if (c != SM_IO_EOF)
642				(void) sm_io_ungetc(fp, SM_TIME_DEFAULT, c);
643			if (c == ' ' || c == '\t')
644			{
645				/* yep -- defer this */
646				continue;
647			}
648
649			SM_ASSERT(bp > buf);
650
651			/* guaranteed by isheader(buf) */
652			SM_ASSERT(*(bp - 1) != '\n' || bp > buf + 1);
653
654			/* trim off trailing CRLF or NL */
655			if (*--bp != '\n' || *--bp != '\r')
656				bp++;
657			*bp = '\0';
658
659			if (bitset(H_EOH, chompheader(buf,
660						      CHHDR_CHECK | CHHDR_USER,
661						      hdrp, e)))
662			{
663				mstate = MS_BODY;
664				goto nextstate;
665			}
666			numhdrs++;
667			break;
668
669		  case MS_BODY:
670			if (tTd(30, 1))
671				sm_dprintf("EOH\n");
672
673			if (headeronly)
674				goto readerr;
675
676			df = collect_eoh(e, numhdrs, hdrslen);
677			if (df == NULL)
678				e->e_flags |= EF_TOOBIG;
679
680			bp = buf;
681
682			/* toss blank line */
683			if ((bp[0] == '\r' && bp[1] == '\n') ||
684			    (bp[0] == '\n'))
685			{
686				break;
687			}
688
689			/* if not a blank separator, write it out */
690			if (!bitset(EF_TOOBIG, e->e_flags))
691			{
692				while (*bp != '\0')
693					(void) sm_io_putc(df, SM_TIME_DEFAULT,
694							  *bp++);
695			}
696			break;
697		}
698		bp = buf;
699	}
700
701readerr:
702	if ((sm_io_eof(fp) && smtpmode) || sm_io_error(fp))
703	{
704		const char *errmsg;
705
706		if (sm_io_eof(fp))
707			errmsg = "unexpected close";
708		else
709			errmsg = sm_errstring(errno);
710		if (tTd(30, 1))
711			sm_dprintf("collect: premature EOM: %s\n", errmsg);
712		if (LogLevel > 1)
713			sm_syslog(LOG_WARNING, e->e_id,
714				"collect: premature EOM: %s", errmsg);
715		inputerr = true;
716	}
717
718	if (headeronly)
719		goto end;
720
721	if (mstate != MS_BODY)
722	{
723		/* no body or discard, so we never opened the data file */
724		SM_ASSERT(df == NULL);
725		df = collect_eoh(e, numhdrs, hdrslen);
726	}
727
728	if (df == NULL)
729	{
730		/* skip next few clauses */
731		/* EMPTY */
732	}
733	else if (sm_io_flush(df, SM_TIME_DEFAULT) != 0 || sm_io_error(df))
734	{
735		dferror(df, "sm_io_flush||sm_io_error", e);
736		flush_errors(true);
737		finis(true, true, ExitStat);
738		/* NOTREACHED */
739	}
740	else if (SuperSafe == SAFE_NO ||
741		 SuperSafe == SAFE_INTERACTIVE ||
742		 (SuperSafe == SAFE_REALLY_POSTMILTER && smtpmode))
743	{
744		/* skip next few clauses */
745		/* EMPTY */
746		/* Note: updfs() is not called in this case! */
747	}
748	else if (sm_io_setinfo(df, SM_BF_COMMIT, NULL) < 0 && errno != EINVAL)
749	{
750		int save_errno = errno;
751
752		if (save_errno == EEXIST)
753		{
754			char *dfile;
755			struct stat st;
756			int dfd;
757
758			dfile = queuename(e, DATAFL_LETTER);
759			if (stat(dfile, &st) < 0)
760				st.st_size = -1;
761			errno = EEXIST;
762			syserr("@collect: bfcommit(%s): already on disk, size=%ld",
763			       dfile, (long) st.st_size);
764			dfd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL);
765			if (dfd >= 0)
766				dumpfd(dfd, true, true);
767		}
768		errno = save_errno;
769		dferror(df, "bfcommit", e);
770		flush_errors(true);
771		finis(save_errno != EEXIST, true, ExitStat);
772	}
773	else if ((afd = sm_io_getinfo(df, SM_IO_WHAT_FD, NULL)) < 0)
774	{
775		dferror(df, "sm_io_getinfo", e);
776		flush_errors(true);
777		finis(true, true, ExitStat);
778		/* NOTREACHED */
779	}
780	else if (fsync(afd) < 0)
781	{
782		dferror(df, "fsync", e);
783		flush_errors(true);
784		finis(true, true, ExitStat);
785		/* NOTREACHED */
786	}
787	else if (sm_io_close(df, SM_TIME_DEFAULT) < 0)
788	{
789		dferror(df, "sm_io_close", e);
790		flush_errors(true);
791		finis(true, true, ExitStat);
792		/* NOTREACHED */
793	}
794	else
795	{
796		/* everything is happily flushed to disk */
797		df = NULL;
798
799		/* remove from available space in filesystem */
800		updfs(e, 0, 1, "collect");
801	}
802
803	/* An EOF when running SMTP is an error */
804  readabort:
805	if (inputerr && (OpMode == MD_SMTP || OpMode == MD_DAEMON))
806	{
807		char *host;
808		char *problem;
809		ADDRESS *q;
810
811		host = RealHostName;
812		if (host == NULL)
813			host = "localhost";
814
815		if (sm_io_eof(fp))
816			problem = "unexpected close";
817		else if (sm_io_error(fp))
818			problem = "I/O error";
819		else
820			problem = "read timeout";
821		if (LogLevel > 0 && sm_io_eof(fp))
822			sm_syslog(LOG_NOTICE, e->e_id,
823				"collect: %s on connection from %.100s, sender=%s",
824				problem, host,
825				shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
826		if (sm_io_eof(fp))
827			usrerr("421 4.4.1 collect: %s on connection from %s, from=%s",
828				problem, host,
829				shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
830		else
831			syserr("421 4.4.1 collect: %s on connection from %s, from=%s",
832				problem, host,
833				shortenstring(e->e_from.q_paddr, MAXSHORTSTR));
834		flush_errors(true);
835
836		/* don't return an error indication */
837		e->e_to = NULL;
838		e->e_flags &= ~EF_FATALERRS;
839		e->e_flags |= EF_CLRQUEUE;
840
841		/* Don't send any message notification to sender */
842		for (q = e->e_sendqueue; q != NULL; q = q->q_next)
843		{
844			if (QS_IS_DEAD(q->q_state))
845				continue;
846			q->q_state = QS_FATALERR;
847		}
848
849		(void) sm_io_close(df, SM_TIME_DEFAULT);
850		df = NULL;
851		finis(true, true, ExitStat);
852		/* NOTREACHED */
853	}
854
855	/* Log collection information. */
856	if (tTd(92, 2))
857		sm_dprintf("collect: e_id=%s, EF_LOGSENDER=%d, LogLevel=%d\n",
858			e->e_id, bitset(EF_LOGSENDER, e->e_flags), LogLevel);
859	if (bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4)
860	{
861		logsender(e, e->e_msgid);
862		e->e_flags &= ~EF_LOGSENDER;
863	}
864
865	/* check for message too large */
866	if (bitset(EF_TOOBIG, e->e_flags))
867	{
868		e->e_flags |= EF_NO_BODY_RETN|EF_CLRQUEUE;
869		if (!bitset(EF_FATALERRS, e->e_flags))
870		{
871			e->e_status = "5.2.3";
872			usrerrenh(e->e_status,
873				"552 Message exceeds maximum fixed size (%ld)",
874				MaxMessageSize);
875			if (LogLevel > 6)
876				sm_syslog(LOG_NOTICE, e->e_id,
877					"message size (%ld) exceeds maximum (%ld)",
878					PRT_NONNEGL(e->e_msgsize),
879					MaxMessageSize);
880		}
881	}
882
883	/* check for illegal 8-bit data */
884	if (HasEightBits)
885	{
886		e->e_flags |= EF_HAS8BIT;
887		if (!bitset(MM_PASS8BIT|MM_MIME8BIT, MimeMode) &&
888		    !bitset(EF_IS_MIME, e->e_flags))
889		{
890			e->e_status = "5.6.1";
891			usrerrenh(e->e_status, "554 Eight bit data not allowed");
892		}
893	}
894	else
895	{
896		/* if it claimed to be 8 bits, well, it lied.... */
897		if (e->e_bodytype != NULL &&
898		    sm_strcasecmp(e->e_bodytype, "8BITMIME") == 0)
899			e->e_bodytype = "7BIT";
900	}
901
902#if _FFR_REJECT_NUL_BYTE
903	if (hasNUL && RejectNUL)
904	{
905		e->e_status = "5.6.1";
906		usrerrenh(e->e_status, "554 NUL byte not allowed");
907	}
908#endif /* _FFR_REJECT_NUL_BYTE */
909
910	if (SuperSafe == SAFE_REALLY && !bitset(EF_FATALERRS, e->e_flags))
911	{
912		char *dfname = queuename(e, DATAFL_LETTER);
913		if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
914					   SM_IO_RDONLY_B, NULL)) == NULL)
915		{
916			/* we haven't acked receipt yet, so just chuck this */
917			syserr("@Cannot reopen %s", dfname);
918			finis(true, true, ExitStat);
919			/* NOTREACHED */
920		}
921	}
922	else
923		e->e_dfp = df;
924
925	/* collect statistics */
926	if (OpMode != MD_VERIFY)
927	{
928		/*
929		**  Recalculate e_msgpriority, it is done at in eatheader()
930		**  which is called (in 8.12) after the header is collected,
931		**  hence e_msgsize is (most likely) incorrect.
932		*/
933
934		e->e_msgpriority = e->e_msgsize
935				 - e->e_class * WkClassFact
936				 + e->e_nrcpts * WkRecipFact;
937		markstats(e, (ADDRESS *) NULL, STATS_NORMAL);
938	}
939
940  end:
941	(void) set_tls_rd_tmo(old_rd_tmo);
942}
943
944/*
945**  DFERROR -- signal error on writing the data file.
946**
947**	Called by collect().  Collect() always terminates the process
948**	immediately after calling dferror(), which means that the SMTP
949**	session will be terminated, which means that any error message
950**	issued by dferror must be a 421 error, as per RFC 821.
951**
952**	Parameters:
953**		df -- the file pointer for the data file.
954**		msg -- detailed message.
955**		e -- the current envelope.
956**
957**	Returns:
958**		none.
959**
960**	Side Effects:
961**		Gives an error message.
962**		Arranges for following output to go elsewhere.
963*/
964
965void
966dferror(df, msg, e)
967	SM_FILE_T *volatile df;
968	char *msg;
969	register ENVELOPE *e;
970{
971	char *dfname;
972
973	dfname = queuename(e, DATAFL_LETTER);
974	setstat(EX_IOERR);
975	if (errno == ENOSPC)
976	{
977#if STAT64 > 0
978		struct stat64 st;
979#else
980		struct stat st;
981#endif
982		long avail;
983		long bsize;
984
985		e->e_flags |= EF_NO_BODY_RETN;
986
987		if (
988#if STAT64 > 0
989		    fstat64(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st)
990#else
991		    fstat(sm_io_getinfo(df, SM_IO_WHAT_FD, NULL), &st)
992#endif
993		    < 0)
994		  st.st_size = 0;
995		(void) sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, dfname,
996				    SM_IO_WRONLY_B, NULL, df);
997		if (st.st_size <= 0)
998			(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
999				"\n*** Mail could not be accepted");
1000		else
1001			(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1002				"\n*** Mail of at least %llu bytes could not be accepted\n",
1003				(ULONGLONG_T) st.st_size);
1004		(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1005			"*** at %s due to lack of disk space for temp file.\n",
1006			MyHostName);
1007		avail = freediskspace(qid_printqueue(e->e_qgrp, e->e_qdir),
1008				      &bsize);
1009		if (avail > 0)
1010		{
1011			if (bsize > 1024)
1012				avail *= bsize / 1024;
1013			else if (bsize < 1024)
1014				avail /= 1024 / bsize;
1015			(void) sm_io_fprintf(df, SM_TIME_DEFAULT,
1016				"*** Currently, %ld kilobytes are available for mail temp files.\n",
1017				avail);
1018		}
1019#if 0
1020		/* Wrong response code; should be 421. */
1021		e->e_status = "4.3.1";
1022		usrerrenh(e->e_status, "452 Out of disk space for temp file");
1023#else /* 0 */
1024		syserr("421 4.3.1 Out of disk space for temp file");
1025#endif /* 0 */
1026	}
1027	else
1028		syserr("421 4.3.0 collect: Cannot write %s (%s, uid=%ld, gid=%ld)",
1029			dfname, msg, (long) geteuid(), (long) getegid());
1030	if (sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, SM_PATH_DEVNULL,
1031			 SM_IO_WRONLY, NULL, df) == NULL)
1032		sm_syslog(LOG_ERR, e->e_id,
1033			  "dferror: sm_io_reopen(\"/dev/null\") failed: %s",
1034			  sm_errstring(errno));
1035}
1036/*
1037**  EATFROM -- chew up a UNIX style from line and process
1038**
1039**	This does indeed make some assumptions about the format
1040**	of UNIX messages.
1041**
1042**	Parameters:
1043**		fm -- the from line.
1044**		e -- envelope
1045**
1046**	Returns:
1047**		none.
1048**
1049**	Side Effects:
1050**		extracts what information it can from the header,
1051**		such as the date.
1052*/
1053
1054#ifndef NOTUNIX
1055
1056static char	*DowList[] =
1057{
1058	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
1059};
1060
1061static char	*MonthList[] =
1062{
1063	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
1064	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
1065	NULL
1066};
1067
1068static void
1069eatfrom(fm, e)
1070	char *volatile fm;
1071	register ENVELOPE *e;
1072{
1073	register char *p;
1074	register char **dt;
1075
1076	if (tTd(30, 2))
1077		sm_dprintf("eatfrom(%s)\n", fm);
1078
1079	/* find the date part */
1080	p = fm;
1081	while (*p != '\0')
1082	{
1083		/* skip a word */
1084		while (*p != '\0' && *p != ' ')
1085			p++;
1086		while (*p == ' ')
1087			p++;
1088		if (strlen(p) < 17)
1089		{
1090			/* no room for the date */
1091			return;
1092		}
1093		if (!(isascii(*p) && isupper(*p)) ||
1094		    p[3] != ' ' || p[13] != ':' || p[16] != ':')
1095			continue;
1096
1097		/* we have a possible date */
1098		for (dt = DowList; *dt != NULL; dt++)
1099			if (strncmp(*dt, p, 3) == 0)
1100				break;
1101		if (*dt == NULL)
1102			continue;
1103
1104		for (dt = MonthList; *dt != NULL; dt++)
1105		{
1106			if (strncmp(*dt, &p[4], 3) == 0)
1107				break;
1108		}
1109		if (*dt != NULL)
1110			break;
1111	}
1112
1113	if (*p != '\0')
1114	{
1115		char *q, buf[25];
1116
1117		/* we have found a date */
1118		(void) sm_strlcpy(buf, p, sizeof(buf));
1119		q = arpadate(buf);
1120		macdefine(&e->e_macro, A_TEMP, 'a', q);
1121	}
1122}
1123#endif /* ! NOTUNIX */
1124