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