14632Seric # include "sendmail.h"
24632Seric # include <sys/stat.h>
36625Sglickman # include <ndir.h>
44634Seric # include <signal.h>
54632Seric # include <errno.h>
64632Seric 
75182Seric # ifndef QUEUE
8*7391Seric SCCSID(@(#)queue.c	3.24		07/14/82	(no queueing));
95182Seric # else QUEUE
104632Seric 
11*7391Seric SCCSID(@(#)queue.c	3.24		07/14/82);
125182Seric 
134632Seric /*
144632Seric **  QUEUEUP -- queue a message up for future transmission.
154632Seric **
164632Seric **	The queued message should already be in the correct place.
174632Seric **	This routine just outputs the control file as appropriate.
184632Seric **
194632Seric **	Parameters:
206980Seric **		e -- the envelope to queue up.
216999Seric **		queueall -- if TRUE, queue all addresses, rather than
226999Seric **			just those with the QQUEUEUP flag set.
234632Seric **
244632Seric **	Returns:
254632Seric **		none.
264632Seric **
274632Seric **	Side Effects:
284632Seric **		The current request (only unsatisfied addresses)
294632Seric **			are saved in a control file.
304632Seric */
314632Seric 
326999Seric queueup(e, queueall)
336980Seric 	register ENVELOPE *e;
346999Seric 	bool queueall;
354632Seric {
364632Seric 	char cf[MAXNAME];
376980Seric 	char buf[MAXNAME];
386980Seric 	register FILE *cfp;
394632Seric 	register HDR *h;
405007Seric 	register ADDRESS *q;
415199Seric 	extern char *mktemp();
425902Seric 	register int i;
434632Seric 
445037Seric 	/*
455037Seric 	**  Create control file.
465037Seric 	*/
474632Seric 
487009Seric 	(void) strcpy(cf, QueueDir);
497009Seric 	(void) strcat(cf, "/tfXXXXXX");
505037Seric 	(void) mktemp(cf);
516980Seric 	cfp = fopen(cf, "w");
526980Seric 	if (cfp == NULL)
534632Seric 	{
544632Seric 		syserr("queueup: cannot create control file %s", cf);
554632Seric 		return;
564632Seric 	}
577010Seric 	(void) chmod(cf, 0600);
584632Seric 
594632Seric # ifdef DEBUG
604632Seric 	if (Debug)
616980Seric 		printf("queueing in %s\n", cf);
624632Seric # endif DEBUG
634632Seric 
644632Seric 	/*
656980Seric 	**  If there is no data file yet, create one.
666980Seric 	*/
676980Seric 
686980Seric 	if (e->e_df == NULL)
696980Seric 	{
706980Seric 		register FILE *dfp;
716980Seric 
727009Seric 		(void) strcpy(buf, QueueDir);
737009Seric 		(void) strcat(buf, "/dfXXXXXX");
746980Seric 		e->e_df = newstr(mktemp(buf));
756980Seric 		dfp = fopen(e->e_df, "w");
766980Seric 		if (dfp == NULL)
776980Seric 		{
786980Seric 			syserr("queueup: cannot create %s", e->e_df);
797009Seric 			(void) fclose(cfp);
806980Seric 			return;
816980Seric 		}
827010Seric 		(void) chmod(e->e_df, 0600);
836980Seric 		(*e->e_putbody)(dfp, Mailer[1], FALSE);
847009Seric 		(void) fclose(dfp);
856980Seric 	}
866980Seric 
876980Seric 	/*
884632Seric 	**  Output future work requests.
894632Seric 	*/
904632Seric 
914632Seric 	/* output name of data file */
926980Seric 	fprintf(cfp, "D%s\n", e->e_df);
934632Seric 
944632Seric 	/* output name of sender */
956980Seric 	fprintf(cfp, "S%s\n", e->e_from.q_paddr);
964632Seric 
974632Seric 	/* output timeout */
986980Seric 	fprintf(cfp, "T%ld\n", TimeOut);
994632Seric 
1004634Seric 	/* output message priority */
1016980Seric 	fprintf(cfp, "P%ld\n", e->e_msgpriority);
1024634Seric 
1036980Seric 	/* output message class */
1046980Seric 	fprintf(cfp, "C%d\n", e->e_class);
1056980Seric 
1065902Seric 	/* output macro definitions */
1075902Seric 	for (i = 0; i < 128; i++)
1085902Seric 	{
1096980Seric 		register char *p = e->e_macro[i];
1105902Seric 
1115902Seric 		if (p != NULL && i != (int) 'b')
1126980Seric 			fprintf(cfp, "M%c%s\n", i, p);
1135902Seric 	}
1145902Seric 
1154632Seric 	/* output list of recipient addresses */
1166980Seric 	for (q = e->e_sendqueue; q != NULL; q = q->q_next)
1174632Seric 	{
1185037Seric # ifdef DEBUG
1195037Seric 		if (Debug > 0)
1205037Seric 		{
1215037Seric 			printf("queueing ");
1225037Seric 			printaddr(q, FALSE);
1235037Seric 		}
1245037Seric # endif DEBUG
1256999Seric 		if (queueall || bitset(QQUEUEUP, q->q_flags))
1266980Seric 			fprintf(cfp, "R%s\n", q->q_paddr);
1274632Seric 	}
1284632Seric 
1294632Seric 	/* output headers for this message */
1306980Seric 	for (h = e->e_header; h != NULL; h = h->h_link)
1314632Seric 	{
1324632Seric 		if (h->h_value == NULL || h->h_value[0] == '\0')
1334632Seric 			continue;
1346980Seric 		fprintf(cfp, "H");
1354632Seric 		if (h->h_mflags != 0 && bitset(H_CHECK|H_ACHECK, h->h_flags))
1366980Seric 			mfdecode(h->h_mflags, cfp);
1376980Seric 		fprintf(cfp, "%s: %s\n", h->h_field, h->h_value);
1384632Seric 	}
1394632Seric 
1404632Seric 	/*
1414632Seric 	**  Clean up.
1424632Seric 	*/
1434632Seric 
1446980Seric 	(void) fclose(cfp);
1456980Seric 	(void) strcpy(buf, QueueDir);
1466980Seric 	(void) strcat(buf, "/cfXXXXXX");
1476980Seric 	(void) mktemp(buf);
1486980Seric 	if (link(cf, buf) < 0)
1496980Seric 		syserr("cannot link(%s, %s), df=%s", cf, buf, e->e_df);
1506980Seric 	else
1517009Seric 		(void) unlink(cf);
152*7391Seric 
153*7391Seric 	/* disconnect this temp file from the job */
154*7391Seric 	e->e_df = NULL;
1554632Seric }
1564632Seric /*
1574632Seric **  RUNQUEUE -- run the jobs in the queue.
1584632Seric **
1594632Seric **	Gets the stuff out of the queue in some presumably logical
1604632Seric **	order and processes them.
1614632Seric **
1624632Seric **	Parameters:
1634632Seric **		none.
1644632Seric **
1654632Seric **	Returns:
1664632Seric **		none.
1674632Seric **
1684632Seric **	Side Effects:
1694632Seric **		runs things in the mail queue.
1704632Seric */
1714632Seric 
1724639Seric bool	ReorderQueue;		/* if set, reorder the send queue */
1734639Seric int	QueuePid;		/* pid of child running queue */
1744634Seric 
1754639Seric runqueue(forkflag)
1764639Seric 	bool forkflag;
1774632Seric {
1784634Seric 	extern reordersig();
1794632Seric 
1804639Seric 	if (QueueIntvl != 0)
1814639Seric 	{
1824836Seric 		(void) signal(SIGALRM, reordersig);
1837009Seric 		(void) alarm(QueueIntvl);
1844639Seric 	}
1854639Seric 
1864639Seric 	if (forkflag)
1874639Seric 	{
1884639Seric 		QueuePid = dofork();
1894639Seric 		if (QueuePid > 0)
1904639Seric 		{
1914639Seric 			/* parent */
1924639Seric 			return;
1934639Seric 		}
1944639Seric 		else
1957009Seric 			(void) alarm(0);
1964639Seric 	}
1974639Seric 
1984634Seric 	for (;;)
1994634Seric 	{
2004634Seric 		/*
2014634Seric 		**  Order the existing work requests.
2024634Seric 		*/
2034632Seric 
2044634Seric 		orderq();
2054632Seric 
2064634Seric 		if (WorkQ == NULL)
2074634Seric 		{
2084634Seric 			/* no work?  well, maybe later */
2094634Seric 			if (QueueIntvl == 0)
2104634Seric 				break;
2114639Seric 			pause();
2124634Seric 			continue;
2134634Seric 		}
2144632Seric 
2154634Seric 		ReorderQueue = FALSE;
2164634Seric 
2174634Seric 		/*
2184634Seric 		**  Process them once at a time.
2194634Seric 		**	The queue could be reordered while we do this to take
2204634Seric 		**	new requests into account.  If so, the existing job
2214634Seric 		**	will be finished but the next thing taken off WorkQ
2224634Seric 		**	may be something else.
2234634Seric 		*/
2244634Seric 
2254634Seric 		while (WorkQ != NULL)
2264634Seric 		{
2274634Seric 			WORK *w = WorkQ;
2284634Seric 
2294634Seric 			WorkQ = WorkQ->w_next;
2304634Seric 			dowork(w);
2314634Seric 			free(w->w_name);
2324634Seric 			free((char *) w);
2334634Seric 			if (ReorderQueue)
2344634Seric 				break;
2354634Seric 		}
2364634Seric 
2374634Seric 		if (QueueIntvl == 0)
2384634Seric 			break;
2394632Seric 	}
2405978Seric 
2415978Seric 	/* no work to do -- just exit */
2425978Seric 	finis();
2434632Seric }
2444632Seric /*
2454634Seric **  REORDERSIG -- catch the alarm signal and tell sendmail to reorder queue.
2464634Seric **
2474634Seric **	Parameters:
2484634Seric **		none.
2494634Seric **
2504634Seric **	Returns:
2514634Seric **		none.
2524634Seric **
2534634Seric **	Side Effects:
2544634Seric **		sets the "reorder work queue" flag.
2554634Seric */
2564634Seric 
2574634Seric reordersig()
2584634Seric {
2594639Seric 	if (QueuePid == 0)
2604639Seric 	{
2614639Seric 		/* we are in a child doing queueing */
2624639Seric 		ReorderQueue = TRUE;
2634639Seric 	}
2644639Seric 	else
2654639Seric 	{
2664639Seric 		/* we are in a parent -- poke child or start new one */
2674639Seric 		if (kill(QueuePid, SIGALRM) < 0)
2684639Seric 		{
2694639Seric 			/* no child -- get zombie & start new one */
2704639Seric 			static int st;
2714639Seric 
2724836Seric 			(void) wait(&st);
2734639Seric 			QueuePid = dofork();
2744639Seric 			if (QueuePid == 0)
2754639Seric 			{
2764639Seric 				/* new child; run queue */
2774836Seric 				runqueue(FALSE);
2784639Seric 				finis();
2794639Seric 			}
2804639Seric 		}
2814639Seric 	}
2824639Seric 
2834639Seric 	/*
2844639Seric 	**  Arrange to get this signal again.
2854639Seric 	*/
2864639Seric 
2876065Seric 	(void) signal(SIGALRM, reordersig);
2887009Seric 	(void) alarm(QueueIntvl);
2894634Seric }
2904634Seric /*
2914632Seric **  ORDERQ -- order the work queue.
2924632Seric **
2934632Seric **	Parameters:
2944632Seric **		none.
2954632Seric **
2964632Seric **	Returns:
2974632Seric **		none.
2984632Seric **
2994632Seric **	Side Effects:
3004632Seric **		Sets WorkQ to the queue of available work, in order.
3014632Seric */
3024632Seric 
3034632Seric # define WLSIZE		120	/* max size of worklist per sort */
3044632Seric 
3054632Seric orderq()
3064632Seric {
3076625Sglickman 	register struct direct *d;
3084632Seric 	register WORK *w;
3094632Seric 	register WORK **wp;		/* parent of w */
3106625Sglickman 	DIR *f;
3114632Seric 	register int i;
3124632Seric 	WORK wlist[WLSIZE];
3134632Seric 	int wn = 0;
3144632Seric 	extern workcmpf();
3154632Seric 	extern char *QueueDir;
3164632Seric 
3174632Seric 	/* clear out old WorkQ */
3184632Seric 	for (w = WorkQ; w != NULL; )
3194632Seric 	{
3204632Seric 		register WORK *nw = w->w_next;
3214632Seric 
3224632Seric 		WorkQ = nw;
3234632Seric 		free(w->w_name);
3244632Seric 		free((char *) w);
3254632Seric 		w = nw;
3264632Seric 	}
3274632Seric 
3284632Seric 	/* open the queue directory */
3296625Sglickman 	f = opendir(QueueDir);
3304632Seric 	if (f == NULL)
3314632Seric 	{
3324632Seric 		syserr("orderq: cannot open %s", QueueDir);
3334632Seric 		return;
3344632Seric 	}
3354632Seric 
3364632Seric 	/*
3374632Seric 	**  Read the work directory.
3384632Seric 	*/
3394632Seric 
3406625Sglickman 	while (wn < WLSIZE && (d = readdir(f)) != NULL)
3414632Seric 	{
3424632Seric 		char cbuf[MAXNAME];
3434632Seric 		char lbuf[MAXNAME];
3444632Seric 		FILE *cf;
3454632Seric 		register char *p;
3464632Seric 
3474632Seric 		/* is this an interesting entry? */
3486625Sglickman 		if (d->d_name[0] != 'c')
3494632Seric 			continue;
3504632Seric 
3514632Seric 		/* yes -- find the control file location */
3527009Seric 		(void) strcpy(cbuf, QueueDir);
3537009Seric 		(void) strcat(cbuf, "/");
3544632Seric 		p = &cbuf[strlen(cbuf)];
3557009Seric 		(void) strcpy(p, d->d_name);
3564632Seric 
3574632Seric 		/* open control file */
3584632Seric 		cf = fopen(cbuf, "r");
3594632Seric 		if (cf == NULL)
3604632Seric 		{
3617055Seric 			/* this may be some random person sending hir msgs */
3627055Seric 			/* syserr("orderq: cannot open %s", cbuf); */
3637055Seric 			errno = 0;
3644632Seric 			continue;
3654632Seric 		}
3665037Seric 		wlist[wn].w_name = newstr(cbuf);
3674632Seric 
3684632Seric 		/* extract useful information */
3694632Seric 		while (fgets(lbuf, sizeof lbuf, cf) != NULL)
3704632Seric 		{
3714632Seric 			fixcrlf(lbuf, TRUE);
3724632Seric 
3734632Seric 			switch (lbuf[0])
3744632Seric 			{
3754632Seric 			  case 'P':		/* message priority */
3765037Seric 				(void) sscanf(&lbuf[1], "%ld", &wlist[wn].w_pri);
3774632Seric 				break;
3784632Seric 			}
3794632Seric 		}
3804632Seric 		wn++;
3814632Seric 		(void) fclose(cf);
3824632Seric 	}
3836625Sglickman 	(void) closedir(f);
3844632Seric 
3854632Seric 	/*
3864632Seric 	**  Sort the work directory.
3874632Seric 	*/
3884632Seric 
3894632Seric 	qsort(wlist, wn, sizeof *wlist, workcmpf);
3904632Seric 
3914632Seric 	/*
3924632Seric 	**  Convert the work list into canonical form.
3934632Seric 	*/
3944632Seric 
3954632Seric 	wp = &WorkQ;
3964632Seric 	for (i = 0; i < wn; i++)
3974632Seric 	{
3984632Seric 		w = (WORK *) xalloc(sizeof *w);
3994632Seric 		w->w_name = wlist[i].w_name;
4004632Seric 		w->w_pri = wlist[i].w_pri;
4014632Seric 		w->w_next = NULL;
4024632Seric 		*wp = w;
4034632Seric 		wp = &w->w_next;
4044632Seric 	}
4054632Seric 
4064632Seric # ifdef DEBUG
4074632Seric 	if (Debug)
4084632Seric 	{
4094632Seric 		for (w = WorkQ; w != NULL; w = w->w_next)
4105037Seric 			printf("%32s: pri=%ld\n", w->w_name, w->w_pri);
4114632Seric 	}
4124632Seric # endif DEBUG
4134632Seric }
4144632Seric /*
4154632Seric **	WORKCMPF -- compare function for ordering work.
4164632Seric **
4174632Seric **	Parameters:
4184632Seric **		a -- the first argument.
4194632Seric **		b -- the second argument.
4204632Seric **
4214632Seric **	Returns:
4224632Seric **		-1 if a < b
4234632Seric **		0 if a == b
4244632Seric **		1 if a > b
4254632Seric **
4264632Seric **	Side Effects:
4274632Seric **		none.
4284632Seric */
4294632Seric 
4304632Seric # define PRIFACT	1800		/* bytes each priority point is worth */
4314632Seric 
4324632Seric workcmpf(a, b)
4335037Seric 	register WORK *a;
4345037Seric 	register WORK *b;
4354632Seric {
4365037Seric 	if (a->w_pri == b->w_pri)
4374632Seric 		return (0);
4385037Seric 	else if (a->w_pri > b->w_pri)
4394632Seric 		return (1);
4404632Seric 	else
4414632Seric 		return (-1);
4424632Seric }
4434632Seric /*
4444632Seric **  DOWORK -- do a work request.
4454632Seric **
4464632Seric **	Parameters:
4474632Seric **		w -- the work request to be satisfied.
4484632Seric **
4494632Seric **	Returns:
4504632Seric **		none.
4514632Seric **
4524632Seric **	Side Effects:
4534632Seric **		The work request is satisfied if possible.
4544632Seric */
4554632Seric 
4564632Seric dowork(w)
4574632Seric 	register WORK *w;
4584632Seric {
4594632Seric 	register int i;
4604632Seric 	auto int xstat;
4614632Seric 
4624632Seric # ifdef DEBUG
4634632Seric 	if (Debug)
4645037Seric 		printf("dowork: %s pri %ld\n", w->w_name, w->w_pri);
4654632Seric # endif DEBUG
4664632Seric 
4674632Seric 	/*
4684632Seric 	**  Fork for work.
4694632Seric 	*/
4704632Seric 
4714632Seric 	i = fork();
4724632Seric 	if (i < 0)
4734632Seric 	{
4744632Seric 		syserr("dowork: cannot fork");
4754632Seric 		return;
4764632Seric 	}
4774632Seric 
4784632Seric 	if (i == 0)
4794632Seric 	{
4806980Seric 		char buf[MAXNAME];
4816980Seric 
4824632Seric 		/*
4834632Seric 		**  CHILD
4846980Seric 		**	Change the name of the control file to avoid
4857350Seric 		**		duplicate deliveries.   Then run the file
4867350Seric 		**		as though we had just read it.
4877350Seric 		**	We save an idea of the temporary name so we
4887350Seric 		**		can recover on interrupt.
4894632Seric 		*/
4904632Seric 
4917356Seric 		(void) alarm(0);
4927347Seric 		FatalErrors = FALSE;
4934632Seric 		QueueRun = TRUE;
4946991Seric 		MailBack = TRUE;
4956980Seric 		(void) strcpy(buf, QueueDir);
4966980Seric 		(void) strcat(buf, "/tfXXXXXX");
4976980Seric 		(void) mktemp(buf);
4986980Seric 		if (link(w->w_name, buf) < 0)
4996980Seric 		{
5006980Seric 			syserr("dowork: link(%s, %s)", w->w_name, buf);
5016980Seric 
5026980Seric 			/* it's ok to lie -- it will be run later */
5036980Seric 			exit(EX_OK);
5046980Seric 		}
5057350Seric 		ControlFile = newstr(buf);
5066980Seric 		(void) unlink(w->w_name);
5076980Seric 
5086980Seric 		/* create ourselves a transcript file */
5094634Seric 		openxscrpt();
5106980Seric 
5116980Seric 		/* do basic system initialization */
5124632Seric 		initsys();
5136980Seric 
5146980Seric 		/* read the queue control file */
5156980Seric 		readqf(buf);
5166980Seric 
5176980Seric 		/* do the delivery */
5187046Seric 		sendall(CurEnv, FALSE);
5196980Seric 
5206980Seric 		/* if still not sent, perhaps we should time out.... */
5214634Seric # ifdef DEBUG
5224634Seric 		if (Debug > 2)
5234634Seric 			printf("CurTime=%ld, TimeOut=%ld\n", CurTime, TimeOut);
5244634Seric # endif DEBUG
5256908Seric 		if (CurEnv->e_queueup && CurTime > TimeOut)
5264634Seric 			timeout(w);
5276980Seric 
5286980Seric 		/* get rid of the temporary file -- a new cf will be made */
5297350Seric 		ControlFile = NULL;
5306980Seric 		(void) unlink(buf);
5316980Seric 
5326980Seric 		/* finish up and exit */
5334632Seric 		finis();
5344632Seric 	}
5354632Seric 
5364632Seric 	/*
5374632Seric 	**  Parent -- pick up results.
5384632Seric 	*/
5394632Seric 
5404632Seric 	errno = 0;
5414632Seric 	while ((i = wait(&xstat)) > 0 && errno != EINTR)
5424632Seric 	{
5434632Seric 		if (errno == EINTR)
5444632Seric 		{
5454632Seric 			errno = 0;
5464632Seric 		}
5474632Seric 	}
5484632Seric }
5494632Seric /*
5504632Seric **  READQF -- read queue file and set up environment.
5514632Seric **
5524632Seric **	Parameters:
5534632Seric **		cf -- name of queue control file.
5544632Seric **
5554632Seric **	Returns:
5564632Seric **		none.
5574632Seric **
5584632Seric **	Side Effects:
5594632Seric **		cf is read and created as the current job, as though
5604632Seric **		we had been invoked by argument.
5614632Seric */
5624632Seric 
5634632Seric readqf(cf)
5644632Seric 	char *cf;
5654632Seric {
5664632Seric 	register FILE *f;
5674632Seric 	char buf[MAXLINE];
5684632Seric 
5694632Seric 	/*
5704632Seric 	**  Open the file created by queueup.
5714632Seric 	*/
5724632Seric 
5734632Seric 	f = fopen(cf, "r");
5744632Seric 	if (f == NULL)
5754632Seric 	{
5764632Seric 		syserr("readqf: no cf file %s", cf);
5774632Seric 		return;
5784632Seric 	}
5794632Seric 
5804632Seric 	/*
5814632Seric 	**  Read and process the file.
5824632Seric 	*/
5834632Seric 
5847356Seric 	if (Verbose)
5857356Seric 		printf("\nRunning %s\n", cf);
5864632Seric 	while (fgets(buf, sizeof buf, f) != NULL)
5874632Seric 	{
5884632Seric 		fixcrlf(buf, TRUE);
5894632Seric 
5904632Seric 		switch (buf[0])
5914632Seric 		{
5924632Seric 		  case 'R':		/* specify recipient */
5936908Seric 			sendto(&buf[1], 1, (ADDRESS *) NULL, &CurEnv->e_sendqueue);
5944632Seric 			break;
5954632Seric 
5964632Seric 		  case 'H':		/* header */
5974632Seric 			(void) chompheader(&buf[1], FALSE);
5984632Seric 			break;
5994632Seric 
6004632Seric 		  case 'S':		/* sender */
6014634Seric 			setsender(newstr(&buf[1]));
6024632Seric 			break;
6034632Seric 
6044632Seric 		  case 'D':		/* data file name */
6056991Seric 			CurEnv->e_df = newstr(&buf[1]);
6066991Seric 			TempFile = fopen(CurEnv->e_df, "r");
6074632Seric 			if (TempFile == NULL)
6086991Seric 				syserr("readqf: cannot open %s", CurEnv->e_df);
6094632Seric 			break;
6104632Seric 
6114632Seric 		  case 'T':		/* timeout */
6124632Seric 			(void) sscanf(&buf[1], "%ld", &TimeOut);
6134632Seric 			break;
6144632Seric 
6154634Seric 		  case 'P':		/* message priority */
6166908Seric 			(void) sscanf(&buf[1], "%ld", &CurEnv->e_msgpriority);
6175037Seric 
6185037Seric 			/* make sure that big things get sent eventually */
6196908Seric 			CurEnv->e_msgpriority -= WKTIMEFACT;
6204634Seric 			break;
6214634Seric 
6226980Seric 		  case 'C':		/* message class */
6236980Seric 			(void) sscanf(&buf[1], "%hd", &CurEnv->e_class);
6246980Seric 			break;
6256980Seric 
6265902Seric 		  case 'M':		/* define macro */
6275902Seric 			define(buf[1], newstr(&buf[2]));
6285902Seric 			break;
6295902Seric 
6304632Seric 		  default:
6314632Seric 			syserr("readqf(%s): bad line \"%s\"", cf, buf);
6324632Seric 			break;
6334632Seric 		}
6344632Seric 	}
6354632Seric }
6364632Seric /*
6374632Seric **  TIMEOUT -- process timeout on queue file.
6384632Seric **
6394632Seric **	Parameters:
6404632Seric **		w -- pointer to work request that timed out.
6414632Seric **
6424632Seric **	Returns:
6434632Seric **		none.
6444632Seric **
6454632Seric **	Side Effects:
6464632Seric **		Returns a message to the sender saying that this
6474632Seric **		message has timed out.
6484632Seric */
6494632Seric 
6504632Seric timeout(w)
6514632Seric 	register WORK *w;
6524632Seric {
6537369Seric 	char buf[MAXLINE];
6547369Seric 	extern char *TextTimeOut;
6557369Seric 
6564634Seric # ifdef DEBUG
6574634Seric 	if (Debug > 0)
6584634Seric 		printf("timeout(%s)\n", w->w_name);
6594634Seric # endif DEBUG
6606991Seric 	message(Arpa_Info, "Message has timed out");
6614634Seric 
6624634Seric 	/* return message to sender */
6637369Seric 	(void) sprintf(buf, "Cannot send mail for %s", TextTimeOut);
6647369Seric 	(void) returntosender(buf, &CurEnv->e_from, TRUE);
6654634Seric 
6664634Seric 	/* arrange to remove files from queue */
6676908Seric 	CurEnv->e_queueup = FALSE;
6684632Seric }
6695182Seric 
6705182Seric # endif QUEUE
671