Context Navigation

source: trunk/third/sendmail/src/queue.c @ 12554

Visit:

Revision 12554, 49.0 KB checked in by danw, 26 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r12553, which included commits to RCS files with non-trunk default branches.

Line
1	/*
2	* Copyright (c) 1998 Sendmail, Inc. All rights reserved.
3	* Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
4	* Copyright (c) 1988, 1993
5	* The Regents of the University of California. All rights reserved.
6	*
7	* By using this file, you agree to the terms and conditions set
8	* forth in the LICENSE file which can be found at the top level of
9	* the sendmail distribution.
10	*
11	*/
12
13	# include "sendmail.h"
14
15	#ifndef lint
16	#if QUEUE
17	static char sccsid[] = "@(#)queue.c 8.211 (Berkeley) 1/25/1999 (with queueing)";
18	#else
19	static char sccsid[] = "@(#)queue.c 8.211 (Berkeley) 1/25/1999 (without queueing)";
20	#endif
21	#endif /* not lint */
22
23	# include <errno.h>
24	# include <dirent.h>
25
26	# if QUEUE
27
28	/*
29	** Work queue.
30	*/
31
32	struct work
33	{
34	char w_name; / name of control file */
35	char w_host; / name of recipient host */
36	bool w_lock; /* is message locked? */
37	bool w_tooyoung; /* is it too young to run? */
38	long w_pri; /* priority of message, see below */
39	time_t w_ctime; /* creation time of message */
40	struct work w_next; / next in queue */
41	};
42
43	typedef struct work WORK;
44
45	WORK WorkQ; / queue of things to be done */
46
47	#define QF_VERSION 2 /* version number of this queue format */
48
49	extern int orderq __P((bool));
50	/*
51	** QUEUEUP -- queue a message up for future transmission.
52	**
53	** Parameters:
54	** e -- the envelope to queue up.
55	** announce -- if TRUE, tell when you are queueing up.
56	**
57	** Returns:
58	** none.
59	**
60	** Side Effects:
61	** The current request are saved in a control file.
62	** The queue file is left locked.
63	*/
64
65	void
66	queueup(e, announce)
67	register ENVELOPE *e;
68	bool announce;
69	{
70	char *qf;
71	register FILE *tfp;
72	register HDR *h;
73	register ADDRESS *q;
74	int fd;
75	int i;
76	bool newid;
77	register char *p;
78	MAILER nullmailer;
79	MCI mcibuf;
80	char tf[MAXQFNAME];
81	char buf[MAXLINE];
82	extern void printctladdr __P((ADDRESS , FILE ));
83
84	/*
85	** Create control file.
86	*/
87
88	newid = (e->e_id == NULL) \|\| !bitset(EF_INQUEUE, e->e_flags);
89
90	/* if newid, queuename will create a locked qf file in e->lockfp */
91	strcpy(tf, queuename(e, 't'));
92	tfp = e->e_lockfp;
93	if (tfp == NULL)
94	newid = FALSE;
95
96	/* if newid, just write the qf file directly (instead of tf file) */
97	if (!newid)
98	{
99	/* get a locked tf file */
100	for (i = 0; i < 128; i++)
101	{
102	fd = open(tf, O_CREAT\|O_WRONLY\|O_EXCL, FileMode);
103	if (fd < 0)
104	{
105	if (errno != EEXIST)
106	break;
107	if (LogLevel > 0 && (i % 32) == 0)
108	sm_syslog(LOG_ALERT, e->e_id,
109	"queueup: cannot create %s, uid=%d: %s",
110	tf, geteuid(), errstring(errno));
111	}
112	else
113	{
114	if (lockfile(fd, tf, NULL, LOCK_EX\|LOCK_NB))
115	break;
116	else if (LogLevel > 0 && (i % 32) == 0)
117	sm_syslog(LOG_ALERT, e->e_id,
118	"queueup: cannot lock %s: %s",
119	tf, errstring(errno));
120	close(fd);
121	}
122
123	if ((i % 32) == 31)
124	{
125	/* save the old temp file away */
126	(void) rename(tf, queuename(e, 'T'));
127	}
128	else
129	sleep(i % 32);
130	}
131	if (fd < 0 \|\| (tfp = fdopen(fd, "w")) == NULL)
132	{
133	printopenfds(TRUE);
134	syserr("!queueup: cannot create queue temp file %s, uid=%d",
135	tf, geteuid());
136	}
137	}
138
139	if (tTd(40, 1))
140	printf("\n>>>>> queueing %s%s >>>>>\n", e->e_id,
141	newid ? " (new id)" : "");
142	if (tTd(40, 3))
143	{
144	extern void printenvflags __P((ENVELOPE *));
145
146	printf(" e_flags=");
147	printenvflags(e);
148	}
149	if (tTd(40, 32))
150	{
151	printf(" sendq=");
152	printaddr(e->e_sendqueue, TRUE);
153	}
154	if (tTd(40, 9))
155	{
156	printf(" tfp=");
157	dumpfd(fileno(tfp), TRUE, FALSE);
158	printf(" lockfp=");
159	if (e->e_lockfp == NULL)
160	printf("NULL\n");
161	else
162	dumpfd(fileno(e->e_lockfp), TRUE, FALSE);
163	}
164
165	/*
166	** If there is no data file yet, create one.
167	*/
168
169	if (!bitset(EF_HAS_DF, e->e_flags))
170	{
171	register FILE *dfp = NULL;
172	char dfname[MAXQFNAME];
173	struct stat stbuf;
174
175	strcpy(dfname, queuename(e, 'd'));
176	fd = open(dfname, O_WRONLY\|O_CREAT\|O_TRUNC, FileMode);
177	if (fd < 0 \|\| (dfp = fdopen(fd, "w")) == NULL)
178	syserr("!queueup: cannot create data temp file %s, uid=%d",
179	dfname, geteuid());
180	if (fstat(fd, &stbuf) < 0)
181	e->e_dfino = -1;
182	else
183	{
184	e->e_dfdev = stbuf.st_dev;
185	e->e_dfino = stbuf.st_ino;
186	}
187	e->e_flags \|= EF_HAS_DF;
188	bzero(&mcibuf, sizeof mcibuf);
189	mcibuf.mci_out = dfp;
190	mcibuf.mci_mailer = FileMailer;
191	(*e->e_putbody)(&mcibuf, e, NULL);
192	(void) xfclose(dfp, "queueup dfp", e->e_id);
193	e->e_putbody = putbody;
194	}
195
196	/*
197	** Output future work requests.
198	** Priority and creation time should be first, since
199	** they are required by orderq.
200	*/
201
202	/* output queue version number (must be first!) */
203	fprintf(tfp, "V%d\n", QF_VERSION);
204
205	/* output creation time */
206	fprintf(tfp, "T%ld\n", (long) e->e_ctime);
207
208	/* output last delivery time */
209	fprintf(tfp, "K%ld\n", (long) e->e_dtime);
210
211	/* output number of delivery attempts */
212	fprintf(tfp, "N%d\n", e->e_ntries);
213
214	/* output message priority */
215	fprintf(tfp, "P%ld\n", e->e_msgpriority);
216
217	/* output inode number of data file */
218	/* XXX should probably include device major/minor too */
219	if (e->e_dfino != -1)
220	{
221	if (sizeof e->e_dfino > sizeof(long))
222	fprintf(tfp, "I%d/%d/%s\n",
223	major(e->e_dfdev), minor(e->e_dfdev),
224	quad_to_string(e->e_dfino));
225	else
226	fprintf(tfp, "I%d/%d/%lu\n",
227	major(e->e_dfdev), minor(e->e_dfdev),
228	(unsigned long) e->e_dfino);
229	}
230
231	/* output body type */
232	if (e->e_bodytype != NULL)
233	fprintf(tfp, "B%s\n", denlstring(e->e_bodytype, TRUE, FALSE));
234
235	#if _FFR_SAVE_CHARSET
236	if (e->e_charset != NULL)
237	fprintf(tfp, "X%s\n", denlstring(e->e_charset, TRUE, FALSE));
238	#endif
239
240	/* message from envelope, if it exists */
241	if (e->e_message != NULL)
242	fprintf(tfp, "M%s\n", denlstring(e->e_message, TRUE, FALSE));
243
244	/* send various flag bits through */
245	p = buf;
246	if (bitset(EF_WARNING, e->e_flags))
247	*p++ = 'w';
248	if (bitset(EF_RESPONSE, e->e_flags))
249	*p++ = 'r';
250	if (bitset(EF_HAS8BIT, e->e_flags))
251	*p++ = '8';
252	if (bitset(EF_DELETE_BCC, e->e_flags))
253	*p++ = 'b';
254	if (bitset(EF_RET_PARAM, e->e_flags))
255	*p++ = 'd';
256	if (bitset(EF_NO_BODY_RETN, e->e_flags))
257	*p++ = 'n';
258	*p++ = '\0';
259	if (buf[0] != '\0')
260	fprintf(tfp, "F%s\n", buf);
261
262	/* $r and $s and $_ macro values */
263	if ((p = macvalue('r', e)) != NULL)
264	fprintf(tfp, "$r%s\n", denlstring(p, TRUE, FALSE));
265	if ((p = macvalue('s', e)) != NULL)
266	fprintf(tfp, "$s%s\n", denlstring(p, TRUE, FALSE));
267	if ((p = macvalue('_', e)) != NULL)
268	fprintf(tfp, "$_%s\n", denlstring(p, TRUE, FALSE));
269
270	/* output name of sender */
271	if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags))
272	p = e->e_sender;
273	else
274	p = e->e_from.q_paddr;
275	fprintf(tfp, "S%s\n", denlstring(p, TRUE, FALSE));
276
277	/* output ESMTP-supplied "original" information */
278	if (e->e_envid != NULL)
279	fprintf(tfp, "Z%s\n", denlstring(e->e_envid, TRUE, FALSE));
280
281	/* output list of recipient addresses */
282	printctladdr(NULL, NULL);
283	for (q = e->e_sendqueue; q != NULL; q = q->q_next)
284	{
285	if (bitset(QDONTSEND\|QBADADDR\|QSENT, q->q_flags))
286	{
287	#if XDEBUG
288	if (bitset(QQUEUEUP, q->q_flags))
289	sm_syslog(LOG_DEBUG, e->e_id,
290	"dropenvelope: q_flags = %x, paddr = %s",
291	q->q_flags, q->q_paddr);
292	#endif
293	continue;
294	}
295	printctladdr(q, tfp);
296	if (q->q_orcpt != NULL)
297	fprintf(tfp, "Q%s\n",
298	denlstring(q->q_orcpt, TRUE, FALSE));
299	putc('R', tfp);
300	if (bitset(QPRIMARY, q->q_flags))
301	putc('P', tfp);
302	if (bitset(QHASNOTIFY, q->q_flags))
303	putc('N', tfp);
304	if (bitset(QPINGONSUCCESS, q->q_flags))
305	putc('S', tfp);
306	if (bitset(QPINGONFAILURE, q->q_flags))
307	putc('F', tfp);
308	if (bitset(QPINGONDELAY, q->q_flags))
309	putc('D', tfp);
310	putc(':', tfp);
311	fprintf(tfp, "%s\n", denlstring(q->q_paddr, TRUE, FALSE));
312	if (announce)
313	{
314	e->e_to = q->q_paddr;
315	message("queued");
316	if (LogLevel > 8)
317	logdelivery(q->q_mailer, NULL, "queued",
318	NULL, (time_t) 0, e);
319	e->e_to = NULL;
320	}
321	if (tTd(40, 1))
322	{
323	printf("queueing ");
324	printaddr(q, FALSE);
325	}
326	}
327
328	/*
329	** Output headers for this message.
330	** Expand macros completely here. Queue run will deal with
331	** everything as absolute headers.
332	** All headers that must be relative to the recipient
333	** can be cracked later.
334	** We set up a "null mailer" -- i.e., a mailer that will have
335	** no effect on the addresses as they are output.
336	*/
337
338	bzero((char *) &nullmailer, sizeof nullmailer);
339	nullmailer.m_re_rwset = nullmailer.m_rh_rwset =
340	nullmailer.m_se_rwset = nullmailer.m_sh_rwset = -1;
341	nullmailer.m_eol = "\n";
342	bzero(&mcibuf, sizeof mcibuf);
343	mcibuf.mci_mailer = &nullmailer;
344	mcibuf.mci_out = tfp;
345
346	define('g', "\201f", e);
347	for (h = e->e_header; h != NULL; h = h->h_link)
348	{
349	extern bool bitzerop __P((BITMAP));
350
351	if (h->h_value == NULL)
352	continue;
353
354	/* don't output resent headers on non-resent messages */
355	if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
356	continue;
357
358	/* expand macros; if null, don't output header at all */
359	if (bitset(H_DEFAULT, h->h_flags))
360	{
361	(void) expand(h->h_value, buf, sizeof buf, e);
362	if (buf[0] == '\0')
363	continue;
364	}
365
366	/* output this header */
367	fprintf(tfp, "H");
368
369	/* if conditional, output the set of conditions */
370	if (!bitzerop(h->h_mflags) && bitset(H_CHECK\|H_ACHECK, h->h_flags))
371	{
372	int j;
373
374	(void) putc('?', tfp);
375	for (j = '\0'; j <= '\177'; j++)
376	if (bitnset(j, h->h_mflags))
377	(void) putc(j, tfp);
378	(void) putc('?', tfp);
379	}
380
381	/* output the header: expand macros, convert addresses */
382	if (bitset(H_DEFAULT, h->h_flags))
383	{
384	fprintf(tfp, "%s: %s\n",
385	h->h_field,
386	denlstring(buf, FALSE, TRUE));
387	}
388	else if (bitset(H_FROM\|H_RCPT, h->h_flags))
389	{
390	bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
391	FILE *savetrace = TrafficLogFile;
392
393	TrafficLogFile = NULL;
394
395	if (bitset(H_FROM, h->h_flags))
396	oldstyle = FALSE;
397
398	commaize(h, h->h_value, oldstyle, &mcibuf, e);
399
400	TrafficLogFile = savetrace;
401	}
402	else
403	{
404	fprintf(tfp, "%s: %s\n",
405	h->h_field,
406	denlstring(h->h_value, FALSE, TRUE));
407	}
408	}
409
410	/*
411	** Clean up.
412	**
413	** Write a terminator record -- this is to prevent
414	** scurrilous crackers from appending any data.
415	*/
416
417	fprintf(tfp, ".\n");
418
419	if (fflush(tfp) < 0 \|\|
420	(SuperSafe && fsync(fileno(tfp)) < 0) \|\|
421	ferror(tfp))
422	{
423	if (newid)
424	syserr("!552 Error writing control file %s", tf);
425	else
426	syserr("!452 Error writing control file %s", tf);
427	}
428
429	if (!newid)
430	{
431	/* rename (locked) tf to be (locked) qf */
432	qf = queuename(e, 'q');
433	if (rename(tf, qf) < 0)
434	syserr("cannot rename(%s, %s), uid=%d",
435	tf, qf, geteuid());
436
437	/* close and unlock old (locked) qf */
438	if (e->e_lockfp != NULL)
439	(void) xfclose(e->e_lockfp, "queueup lockfp", e->e_id);
440	e->e_lockfp = tfp;
441	}
442	else
443	qf = tf;
444	errno = 0;
445	e->e_flags \|= EF_INQUEUE;
446
447	/* save log info */
448	if (LogLevel > 79)
449	sm_syslog(LOG_DEBUG, e->e_id, "queueup, qf=%s", qf);
450
451	if (tTd(40, 1))
452	printf("<<<<< done queueing %s <<<<<\n\n", e->e_id);
453	return;
454	}
455
456	void
457	printctladdr(a, tfp)
458	register ADDRESS *a;
459	FILE *tfp;
460	{
461	char *uname;
462	register ADDRESS *q;
463	uid_t uid;
464	gid_t gid;
465	static ADDRESS *lastctladdr = NULL;
466	static uid_t lastuid;
467
468	/* initialization */
469	if (a == NULL \|\| a->q_alias == NULL \|\| tfp == NULL)
470	{
471	if (lastctladdr != NULL && tfp != NULL)
472	fprintf(tfp, "C\n");
473	lastctladdr = NULL;
474	lastuid = 0;
475	return;
476	}
477
478	/* find the active uid */
479	q = getctladdr(a);
480	if (q == NULL)
481	{
482	uname = NULL;
483	uid = 0;
484	gid = 0;
485	}
486	else
487	{
488	uname = q->q_ruser != NULL ? q->q_ruser : q->q_user;
489	uid = q->q_uid;
490	gid = q->q_gid;
491	}
492	a = a->q_alias;
493
494	/* check to see if this is the same as last time */
495	if (lastctladdr != NULL && uid == lastuid &&
496	strcmp(lastctladdr->q_paddr, a->q_paddr) == 0)
497	return;
498	lastuid = uid;
499	lastctladdr = a;
500
501	if (uid == 0 \|\| uname == NULL \|\| uname[0] == '\0')
502	fprintf(tfp, "C");
503	else
504	fprintf(tfp, "C%s:%ld:%ld",
505	denlstring(uname, TRUE, FALSE), (long) uid, (long) gid);
506	fprintf(tfp, ":%s\n", denlstring(a->q_paddr, TRUE, FALSE));
507	}
508	/*
509	** RUNQUEUE -- run the jobs in the queue.
510	**
511	** Gets the stuff out of the queue in some presumably logical
512	** order and processes them.
513	**
514	** Parameters:
515	** forkflag -- TRUE if the queue scanning should be done in
516	** a child process. We double-fork so it is not our
517	** child and we don't have to clean up after it.
518	** verbose -- if TRUE, print out status information.
519	**
520	** Returns:
521	** TRUE if the queue run successfully began.
522	**
523	** Side Effects:
524	** runs things in the mail queue.
525	*/
526
527	ENVELOPE QueueEnvelope; /* the queue run envelope */
528	extern int get_num_procs_online __P((void));
529
530	bool
531	runqueue(forkflag, verbose)
532	bool forkflag;
533	bool verbose;
534	{
535	register ENVELOPE *e;
536	int njobs;
537	int sequenceno = 0;
538	time_t current_la_time;
539	extern ENVELOPE BlankEnvelope;
540	extern void clrdaemon __P((void));
541	extern void runqueueevent __P((void));
542
543	DoQueueRun = FALSE;
544
545	/*
546	** If no work will ever be selected, don't even bother reading
547	** the queue.
548	*/
549
550	CurrentLA = getla(); /* get load average */
551	current_la_time = curtime();
552
553	if (shouldqueue(WkRecipFact, current_la_time))
554	{
555	char *msg = "Skipping queue run -- load average too high";
556
557	if (verbose)
558	message("458 %s\n", msg);
559	if (LogLevel > 8)
560	sm_syslog(LOG_INFO, NOQID,
561	"runqueue: %s",
562	msg);
563	if (forkflag && QueueIntvl != 0)
564	(void) setevent(QueueIntvl, runqueueevent, 0);
565	return FALSE;
566	}
567
568	/*
569	** See if we already have too many children.
570	*/
571
572	if (forkflag && QueueIntvl != 0 &&
573	MaxChildren > 0 && CurChildren >= MaxChildren)
574	{
575	(void) setevent(QueueIntvl, runqueueevent, 0);
576	return FALSE;
577	}
578
579	/*
580	** See if we want to go off and do other useful work.
581	*/
582
583	if (forkflag)
584	{
585	pid_t pid;
586	extern SIGFUNC_DECL intsig __P((int));
587	extern SIGFUNC_DECL reapchild __P((int));
588
589	blocksignal(SIGCHLD);
590	(void) setsignal(SIGCHLD, reapchild);
591
592	pid = dofork();
593	if (pid == -1)
594	{
595	const char *msg = "Skipping queue run -- fork() failed";
596	const char *err = errstring(errno);
597
598	if (verbose)
599	message("458 %s: %s\n", msg, err);
600	if (LogLevel > 8)
601	sm_syslog(LOG_INFO, NOQID,
602	"runqueue: %s: %s",
603	msg, err);
604	if (QueueIntvl != 0)
605	(void) setevent(QueueIntvl, runqueueevent, 0);
606	(void) releasesignal(SIGCHLD);
607	return FALSE;
608	}
609	if (pid != 0)
610	{
611	/* parent -- pick up intermediate zombie */
612	(void) blocksignal(SIGALRM);
613	proc_list_add(pid, "Queue runner");
614	(void) releasesignal(SIGALRM);
615	releasesignal(SIGCHLD);
616	if (QueueIntvl != 0)
617	(void) setevent(QueueIntvl, runqueueevent, 0);
618	return TRUE;
619	}
620	/* child -- double fork and clean up signals */
621	clrcontrol();
622	proc_list_clear();
623
624	/* Add parent process as first child item */
625	proc_list_add(getpid(), "Queue runner child process");
626	releasesignal(SIGCHLD);
627	(void) setsignal(SIGCHLD, SIG_DFL);
628	(void) setsignal(SIGHUP, intsig);
629	}
630
631	sm_setproctitle(TRUE, "running queue: %s", QueueDir);
632
633	if (LogLevel > 69)
634	sm_syslog(LOG_DEBUG, NOQID,
635	"runqueue %s, pid=%d, forkflag=%d",
636	QueueDir, getpid(), forkflag);
637
638	/*
639	** Release any resources used by the daemon code.
640	*/
641
642	# if DAEMON
643	clrdaemon();
644	# endif /* DAEMON */
645
646	/* force it to run expensive jobs */
647	NoConnect = FALSE;
648
649	/* drop privileges */
650	if (geteuid() == (uid_t) 0)
651	(void) drop_privileges(FALSE);
652
653	/*
654	** Create ourselves an envelope
655	*/
656
657	CurEnv = &QueueEnvelope;
658	e = newenvelope(&QueueEnvelope, CurEnv);
659	e->e_flags = BlankEnvelope.e_flags;
660
661	/* make sure we have disconnected from parent */
662	if (forkflag)
663	{
664	disconnect(1, e);
665	QuickAbort = FALSE;
666	}
667
668	/*
669	** Make sure the alias database is open.
670	*/
671
672	initmaps(FALSE, e);
673
674	/*
675	** If we are running part of the queue, always ignore stored
676	** host status.
677	*/
678
679	if (QueueLimitId != NULL \|\| QueueLimitSender != NULL \|\|
680	QueueLimitRecipient != NULL)
681	{
682	IgnoreHostStatus = TRUE;
683	MinQueueAge = 0;
684	}
685
686	/*
687	** Start making passes through the queue.
688	** First, read and sort the entire queue.
689	** Then, process the work in that order.
690	** But if you take too long, start over.
691	*/
692
693	/* order the existing work requests */
694	njobs = orderq(FALSE);
695
696	/* process them once at a time */
697	while (WorkQ != NULL)
698	{
699	WORK *w = WorkQ;
700
701	WorkQ = WorkQ->w_next;
702	e->e_to = NULL;
703
704	/*
705	** Ignore jobs that are too expensive for the moment.
706	**
707	** Get new load average every 30 seconds.
708	*/
709
710	if (current_la_time < curtime() - 30)
711	{
712	CurrentLA = getla();
713	current_la_time = curtime();
714	}
715	if (shouldqueue(WkRecipFact, current_la_time))
716	{
717	char *msg = "Aborting queue run: load average too high";
718
719	if (Verbose)
720	message("%s", msg);
721	if (LogLevel > 8)
722	sm_syslog(LOG_INFO, NOQID,
723	"runqueue: %s",
724	msg);
725	break;
726	}
727	sequenceno++;
728	if (shouldqueue(w->w_pri, w->w_ctime))
729	{
730	if (Verbose)
731	message("");
732	if (QueueSortOrder == QS_BYPRIORITY)
733	{
734	if (Verbose)
735	message("Skipping %s (sequence %d of %d) and flushing rest of queue",
736	w->w_name + 2,
737	sequenceno,
738	njobs);
739	if (LogLevel > 8)
740	sm_syslog(LOG_INFO, NOQID,
741	"runqueue: Flushing queue from %s (pri %ld, LA %d, %d of %d)",
742	w->w_name + 2,
743	w->w_pri,
744	CurrentLA,
745	sequenceno,
746	njobs);
747	break;
748	}
749	else if (Verbose)
750	message("Skipping %s (sequence %d of %d)",
751	w->w_name + 2, sequenceno, njobs);
752	}
753	else
754	{
755	pid_t pid;
756
757	if (Verbose)
758	{
759	message("");
760	message("Running %s (sequence %d of %d)",
761	w->w_name + 2, sequenceno, njobs);
762	}
763	pid = dowork(w->w_name + 2, ForkQueueRuns, FALSE, e);
764	errno = 0;
765	if (pid != 0)
766	(void) waitfor(pid);
767	}
768	free(w->w_name);
769	if (w->w_host)
770	free(w->w_host);
771	free((char *) w);
772	}
773
774	/* exit without the usual cleanup */
775	e->e_id = NULL;
776	finis(TRUE, ExitStat);
777	/NOTREACHED/
778	return TRUE;
779	}
780
781
782	/*
783	** RUNQUEUEEVENT -- stub for use in setevent
784	*/
785
786	void
787	runqueueevent()
788	{
789	DoQueueRun = TRUE;
790	}
791	/*
792	** ORDERQ -- order the work queue.
793	**
794	** Parameters:
795	** doall -- if set, include everything in the queue (even
796	** the jobs that cannot be run because the load
797	** average is too high). Otherwise, exclude those
798	** jobs.
799	**
800	** Returns:
801	** The number of request in the queue (not necessarily
802	** the number of requests in WorkQ however).
803	**
804	** Side Effects:
805	** Sets WorkQ to the queue of available work, in order.
806	*/
807
808	# define NEED_P 001
809	# define NEED_T 002
810	# define NEED_R 004
811	# define NEED_S 010
812
813	static WORK *WorkList = NULL;
814	static int WorkListSize = 0;
815
816	int
817	orderq(doall)
818	bool doall;
819	{
820	register struct dirent *d;
821	register WORK *w;
822	register char *p;
823	DIR *f;
824	register int i;
825	int wn = -1;
826	int wc;
827	QUEUE_CHAR *check;
828
829	if (tTd(41, 1))
830	{
831	printf("orderq:\n");
832
833	check = QueueLimitId;
834	while (check != NULL)
835	{
836	printf("\tQueueLimitId = %s\n",
837	check->queue_match);
838	check = check->queue_next;
839	}
840
841	check = QueueLimitSender;
842	while (check != NULL)
843	{
844	printf("\tQueueLimitSender = %s\n",
845	check->queue_match);
846	check = check->queue_next;
847	}
848
849	check = QueueLimitRecipient;
850	while (check != NULL)
851	{
852	printf("\tQueueLimitRecipient = %s\n",
853	check->queue_match);
854	check = check->queue_next;
855	}
856	}
857
858	/* clear out old WorkQ */
859	for (w = WorkQ; w != NULL; )
860	{
861	register WORK *nw = w->w_next;
862
863	WorkQ = nw;
864	free(w->w_name);
865	if (w->w_host)
866	free(w->w_host);
867	free((char *) w);
868	w = nw;
869	}
870
871	/* open the queue directory */
872	f = opendir(".");
873	if (f == NULL)
874	{
875	syserr("orderq: cannot open \"%s\" as \".\"", QueueDir);
876	return (0);
877	}
878
879	/*
880	** Read the work directory.
881	*/
882
883	while ((d = readdir(f)) != NULL)
884	{
885	FILE *cf;
886	int qfver = 0;
887	char lbuf[MAXNAME + 1];
888	extern bool strcontainedin __P((char , char ));
889
890	if (tTd(41, 50))
891	printf("orderq: checking %s\n", d->d_name);
892
893	/* is this an interesting entry? */
894	if (d->d_name[0] != 'q' \|\| d->d_name[1] != 'f')
895	continue;
896
897	if (strlen(d->d_name) > MAXQFNAME)
898	{
899	if (Verbose)
900	printf("orderq: %s too long, %d max characters\n",
901	d->d_name, MAXQFNAME);
902	if (LogLevel > 0)
903	sm_syslog(LOG_ALERT, NOQID,
904	"orderq: %s too long, %d max characters",
905	d->d_name, MAXQFNAME);
906	continue;
907	}
908
909	check = QueueLimitId;
910	while (check != NULL)
911	{
912	if (strcontainedin(check->queue_match, d->d_name))
913	break;
914	else
915	check = check->queue_next;
916	}
917	if (QueueLimitId != NULL && check == NULL)
918	continue;
919
920	#ifdef PICKY_QF_NAME_CHECK
921	/*
922	** Check queue name for plausibility. This handles
923	** both old and new type ids.
924	*/
925
926	p = d->d_name + 2;
927	if (isupper(p[0]) && isupper(p[2]))
928	p += 3;
929	else if (isupper(p[1]))
930	p += 2;
931	else
932	p = d->d_name;
933	for (i = 0; isdigit(*p); p++)
934	i++;
935	if (i < 5 \|\| *p != '\0')
936	{
937	if (Verbose)
938	printf("orderq: bogus qf name %s\n", d->d_name);
939	if (LogLevel > 0)
940	sm_syslog(LOG_ALERT, NOQID,
941	"orderq: bogus qf name %s",
942	d->d_name);
943	if (strlen(d->d_name) > (SIZE_T) MAXNAME)
944	d->d_name[MAXNAME] = '\0';
945	strcpy(lbuf, d->d_name);
946	lbuf[0] = 'Q';
947	(void) rename(d->d_name, lbuf);
948	continue;
949	}
950	#endif
951
952	/* open control file (if not too many files) */
953	if (++wn >= MaxQueueRun && MaxQueueRun > 0)
954	{
955	if (wn == MaxQueueRun && LogLevel > 0)
956	sm_syslog(LOG_ALERT, NOQID,
957	"WorkList for %s maxed out at %d",
958	QueueDir, MaxQueueRun);
959	continue;
960	}
961	if (wn >= WorkListSize)
962	{
963	extern void grow_wlist __P((void));
964
965	grow_wlist();
966	if (wn >= WorkListSize)
967	continue;
968	}
969
970	cf = fopen(d->d_name, "r");
971	if (cf == NULL)
972	{
973	/* this may be some random person sending hir msgs */
974	/* syserr("orderq: cannot open %s", cbuf); */
975	if (tTd(41, 2))
976	printf("orderq: cannot open %s: %s\n",
977	d->d_name, errstring(errno));
978	errno = 0;
979	wn--;
980	continue;
981	}
982	w = &WorkList[wn];
983	w->w_name = newstr(d->d_name);
984	w->w_host = NULL;
985	w->w_lock = !lockfile(fileno(cf), w->w_name, NULL, LOCK_SH\|LOCK_NB);
986	w->w_tooyoung = FALSE;
987
988	/* make sure jobs in creation don't clog queue */
989	w->w_pri = 0x7fffffff;
990	w->w_ctime = 0;
991
992	/* extract useful information */
993	i = NEED_P \| NEED_T;
994	if (QueueLimitSender != NULL)
995	i \|= NEED_S;
996	if (QueueSortOrder == QS_BYHOST \|\| QueueLimitRecipient != NULL)
997	i \|= NEED_R;
998	while (i != 0 && fgets(lbuf, sizeof lbuf, cf) != NULL)
999	{
1000	int c;
1001	time_t age;
1002	extern bool strcontainedin __P((char , char ));
1003
1004	p = strchr(lbuf, '\n');
1005	if (p != NULL)
1006	*p = '\0';
1007	else
1008	{
1009	/* flush rest of overly long line */
1010	while ((c = getc(cf)) != EOF && c != '\n')
1011	continue;
1012	}
1013
1014	switch (lbuf[0])
1015	{
1016	case 'V':
1017	qfver = atoi(&lbuf[1]);
1018	break;
1019
1020	case 'P':
1021	w->w_pri = atol(&lbuf[1]);
1022	i &= ~NEED_P;
1023	break;
1024
1025	case 'T':
1026	w->w_ctime = atol(&lbuf[1]);
1027	i &= ~NEED_T;
1028	break;
1029
1030	case 'R':
1031	if (w->w_host == NULL &&
1032	(p = strrchr(&lbuf[1], '@')) != NULL)
1033	w->w_host = newstr(&p[1]);
1034	if (QueueLimitRecipient == NULL)
1035	{
1036	i &= ~NEED_R;
1037	break;
1038	}
1039	if (qfver > 0)
1040	{
1041	p = strchr(&lbuf[1], ':');
1042	if (p == NULL)
1043	p = &lbuf[1];
1044	}
1045	else
1046	p = &lbuf[1];
1047	check = QueueLimitRecipient;
1048	while (check != NULL)
1049	{
1050	if (strcontainedin(check->queue_match,
1051	p))
1052	break;
1053	else
1054	check = check->queue_next;
1055	}
1056	if (check != NULL)
1057	i &= ~NEED_R;
1058	break;
1059
1060	case 'S':
1061	check = QueueLimitSender;
1062	while (check != NULL)
1063	{
1064	if (strcontainedin(check->queue_match,
1065	&lbuf[1]))
1066	break;
1067	else
1068	check = check->queue_next;
1069	}
1070	if (check != NULL)
1071	i &= ~NEED_S;
1072	break;
1073
1074	case 'K':
1075	age = curtime() - (time_t) atol(&lbuf[1]);
1076	if (age >= 0 && MinQueueAge > 0 &&
1077	age < MinQueueAge)
1078	w->w_tooyoung = TRUE;
1079	break;
1080
1081	case 'N':
1082	if (atol(&lbuf[1]) == 0)
1083	w->w_tooyoung = FALSE;
1084	break;
1085	}
1086	}
1087	(void) fclose(cf);
1088
1089	if ((!doall && shouldqueue(w->w_pri, w->w_ctime)) \|\|
1090	bitset(NEED_R\|NEED_S, i))
1091	{
1092	/* don't even bother sorting this job in */
1093	if (tTd(41, 49))
1094	printf("skipping %s (%x)\n", w->w_name, i);
1095	free(w->w_name);
1096	if (w->w_host)
1097	free(w->w_host);
1098	wn--;
1099	}
1100	}
1101	(void) closedir(f);
1102	wn++;
1103
1104	wc = min(wn, WorkListSize);
1105	if (wc > MaxQueueRun && MaxQueueRun > 0)
1106	wc = MaxQueueRun;
1107
1108	if (QueueSortOrder == QS_BYHOST)
1109	{
1110	extern int workcmpf1();
1111	extern int workcmpf2();
1112
1113	/*
1114	** Sort the work directory for the first time,
1115	** based on host name, lock status, and priority.
1116	*/
1117
1118	qsort((char ) WorkList, wc, sizeof WorkList, workcmpf1);
1119
1120	/*
1121	** If one message to host is locked, "lock" all messages
1122	** to that host.
1123	*/
1124
1125	i = 0;
1126	while (i < wc)
1127	{
1128	if (!WorkList[i].w_lock)
1129	{
1130	i++;
1131	continue;
1132	}
1133	w = &WorkList[i];
1134	while (++i < wc)
1135	{
1136	extern int sm_strcasecmp __P((char , char ));
1137
1138	if (WorkList[i].w_host == NULL &&
1139	w->w_host == NULL)
1140	WorkList[i].w_lock = TRUE;
1141	else if (WorkList[i].w_host != NULL &&
1142	w->w_host != NULL &&
1143	sm_strcasecmp(WorkList[i].w_host, w->w_host) == 0)
1144	WorkList[i].w_lock = TRUE;
1145	else
1146	break;
1147	}
1148	}
1149
1150	/*
1151	** Sort the work directory for the second time,
1152	** based on lock status, host name, and priority.
1153	*/
1154
1155	qsort((char ) WorkList, wc, sizeof WorkList, workcmpf2);
1156	}
1157	else if (QueueSortOrder == QS_BYTIME)
1158	{
1159	extern int workcmpf3();
1160
1161	/*
1162	** Simple sort based on submission time only.
1163	*/
1164
1165	qsort((char ) WorkList, wc, sizeof WorkList, workcmpf3);
1166	}
1167	else
1168	{
1169	extern int workcmpf0();
1170
1171	/*
1172	** Simple sort based on queue priority only.
1173	*/
1174
1175	qsort((char ) WorkList, wc, sizeof WorkList, workcmpf0);
1176	}
1177
1178	/*
1179	** Convert the work list into canonical form.
1180	** Should be turning it into a list of envelopes here perhaps.
1181	*/
1182
1183	WorkQ = NULL;
1184	for (i = wc; --i >= 0; )
1185	{
1186	w = (WORK ) xalloc(sizeof w);
1187	w->w_name = WorkList[i].w_name;
1188	w->w_host = WorkList[i].w_host;
1189	w->w_lock = WorkList[i].w_lock;
1190	w->w_tooyoung = WorkList[i].w_tooyoung;
1191	w->w_pri = WorkList[i].w_pri;
1192	w->w_ctime = WorkList[i].w_ctime;
1193	w->w_next = WorkQ;
1194	WorkQ = w;
1195	}
1196	if (WorkList != NULL)
1197	free(WorkList);
1198	WorkList = NULL;
1199	WorkListSize = 0;
1200
1201	if (tTd(40, 1))
1202	{
1203	for (w = WorkQ; w != NULL; w = w->w_next)
1204	printf("%32s: pri=%ld\n", w->w_name, w->w_pri);
1205	}
1206
1207	return (wn);
1208	}
1209	/*
1210	** GROW_WLIST -- make the work list larger
1211	**
1212	** Parameters:
1213	** none.
1214	**
1215	** Returns:
1216	** none.
1217	**
1218	** Side Effects:
1219	** Adds another QUEUESEGSIZE entries to WorkList if possible.
1220	** It can fail if there isn't enough memory, so WorkListSize
1221	** should be checked again upon return.
1222	*/
1223
1224	void
1225	grow_wlist()
1226	{
1227	if (tTd(41, 1))
1228	printf("grow_wlist: WorkListSize=%d\n", WorkListSize);
1229	if (WorkList == NULL)
1230	{
1231	WorkList = (WORK ) xalloc(sizeof(WORK) (QUEUESEGSIZE + 1));
1232	WorkListSize = QUEUESEGSIZE;
1233	}
1234	else
1235	{
1236	int newsize = WorkListSize + QUEUESEGSIZE;
1237	WORK newlist = (WORK ) realloc((char *)WorkList,
1238	(unsigned)sizeof(WORK) * (newsize + 1));
1239
1240	if (newlist != NULL)
1241	{
1242	WorkListSize = newsize;
1243	WorkList = newlist;
1244	if (LogLevel > 1)
1245	{
1246	sm_syslog(LOG_NOTICE, NOQID,
1247	"grew WorkList for %s to %d",
1248	QueueDir, WorkListSize);
1249	}
1250	}
1251	else if (LogLevel > 0)
1252	{
1253	sm_syslog(LOG_ALERT, NOQID,
1254	"FAILED to grow WorkList for %s to %d",
1255	QueueDir, newsize);
1256	}
1257	}
1258	if (tTd(41, 1))
1259	printf("grow_wlist: WorkListSize now %d\n", WorkListSize);
1260	}
1261	/*
1262	** WORKCMPF0 -- simple priority-only compare function.
1263	**
1264	** Parameters:
1265	** a -- the first argument.
1266	** b -- the second argument.
1267	**
1268	** Returns:
1269	** -1 if a < b
1270	** 0 if a == b
1271	** +1 if a > b
1272	**
1273	** Side Effects:
1274	** none.
1275	*/
1276
1277	int
1278	workcmpf0(a, b)
1279	register WORK *a;
1280	register WORK *b;
1281	{
1282	long pa = a->w_pri;
1283	long pb = b->w_pri;
1284
1285	if (pa == pb)
1286	return 0;
1287	else if (pa > pb)
1288	return 1;
1289	else
1290	return -1;
1291	}
1292	/*
1293	** WORKCMPF1 -- first compare function for ordering work based on host name.
1294	**
1295	** Sorts on host name, lock status, and priority in that order.
1296	**
1297	** Parameters:
1298	** a -- the first argument.
1299	** b -- the second argument.
1300	**
1301	** Returns:
1302	** <0 if a < b
1303	** 0 if a == b
1304	** >0 if a > b
1305	**
1306	** Side Effects:
1307	** none.
1308	*/
1309
1310	int
1311	workcmpf1(a, b)
1312	register WORK *a;
1313	register WORK *b;
1314	{
1315	int i;
1316	extern int sm_strcasecmp __P((char , char ));
1317
1318	/* host name */
1319	if (a->w_host != NULL && b->w_host == NULL)
1320	return 1;
1321	else if (a->w_host == NULL && b->w_host != NULL)
1322	return -1;
1323	if (a->w_host != NULL && b->w_host != NULL &&
1324	(i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
1325	return i;
1326
1327	/* lock status */
1328	if (a->w_lock != b->w_lock)
1329	return b->w_lock - a->w_lock;
1330
1331	/* job priority */
1332	return a->w_pri - b->w_pri;
1333	}
1334	/*
1335	** WORKCMPF2 -- second compare function for ordering work based on host name.
1336	**
1337	** Sorts on lock status, host name, and priority in that order.
1338	**
1339	** Parameters:
1340	** a -- the first argument.
1341	** b -- the second argument.
1342	**
1343	** Returns:
1344	** <0 if a < b
1345	** 0 if a == b
1346	** >0 if a > b
1347	**
1348	** Side Effects:
1349	** none.
1350	*/
1351
1352	int
1353	workcmpf2(a, b)
1354	register WORK *a;
1355	register WORK *b;
1356	{
1357	int i;
1358	extern int sm_strcasecmp __P((char , char ));
1359
1360	/* lock status */
1361	if (a->w_lock != b->w_lock)
1362	return a->w_lock - b->w_lock;
1363
1364	/* host name */
1365	if (a->w_host != NULL && b->w_host == NULL)
1366	return 1;
1367	else if (a->w_host == NULL && b->w_host != NULL)
1368	return -1;
1369	if (a->w_host != NULL && b->w_host != NULL &&
1370	(i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
1371	return i;
1372
1373	/* job priority */
1374	return a->w_pri - b->w_pri;
1375	}
1376	/*
1377	** WORKCMPF3 -- simple submission-time-only compare function.
1378	**
1379	** Parameters:
1380	** a -- the first argument.
1381	** b -- the second argument.
1382	**
1383	** Returns:
1384	** -1 if a < b
1385	** 0 if a == b
1386	** +1 if a > b
1387	**
1388	** Side Effects:
1389	** none.
1390	*/
1391
1392	int
1393	workcmpf3(a, b)
1394	register WORK *a;
1395	register WORK *b;
1396	{
1397	if (a->w_ctime > b->w_ctime)
1398	return 1;
1399	else if (a->w_ctime < b->w_ctime)
1400	return -1;
1401	else
1402	return 0;
1403	}
1404	/*
1405	** DOWORK -- do a work request.
1406	**
1407	** Parameters:
1408	** id -- the ID of the job to run.
1409	** forkflag -- if set, run this in background.
1410	** requeueflag -- if set, reinstantiate the queue quickly.
1411	** This is used when expanding aliases in the queue.
1412	** If forkflag is also set, it doesn't wait for the
1413	** child.
1414	** e - the envelope in which to run it.
1415	**
1416	** Returns:
1417	** process id of process that is running the queue job.
1418	**
1419	** Side Effects:
1420	** The work request is satisfied if possible.
1421	*/
1422
1423	pid_t
1424	dowork(id, forkflag, requeueflag, e)
1425	char *id;
1426	bool forkflag;
1427	bool requeueflag;
1428	register ENVELOPE *e;
1429	{
1430	register pid_t pid;
1431	extern bool readqf __P((ENVELOPE *));
1432
1433	if (tTd(40, 1))
1434	printf("dowork(%s)\n", id);
1435
1436	/*
1437	** Fork for work.
1438	*/
1439
1440	if (forkflag)
1441	{
1442	pid = fork();
1443	if (pid < 0)
1444	{
1445	syserr("dowork: cannot fork");
1446	return 0;
1447	}
1448	else if (pid > 0)
1449	{
1450	/* parent -- clean out connection cache */
1451	mci_flush(FALSE, NULL);
1452	}
1453	else
1454	{
1455	/* child -- error messages to the transcript */
1456	QuickAbort = OnlyOneError = FALSE;
1457
1458	/*
1459	** Since the delivery may happen in a child and the
1460	** parent does not wait, the parent may close the
1461	** maps thereby removing any shared memory used by
1462	** the map. Therefore, open a copy of the maps for
1463	** the delivery process.
1464	*/
1465
1466	initmaps(FALSE, e);
1467	}
1468	}
1469	else
1470	{
1471	pid = 0;
1472	}
1473
1474	if (pid == 0)
1475	{
1476	/*
1477	** CHILD
1478	** Lock the control file to avoid duplicate deliveries.
1479	** Then run the file as though we had just read it.
1480	** We save an idea of the temporary name so we
1481	** can recover on interrupt.
1482	*/
1483
1484	/* set basic modes, etc. */
1485	(void) alarm(0);
1486	clearenvelope(e, FALSE);
1487	e->e_flags \|= EF_QUEUERUN\|EF_GLOBALERRS;
1488	e->e_sendmode = SM_DELIVER;
1489	e->e_errormode = EM_MAIL;
1490	e->e_id = id;
1491	GrabTo = UseErrorsTo = FALSE;
1492	ExitStat = EX_OK;
1493	if (forkflag)
1494	{
1495	disconnect(1, e);
1496	OpMode = MD_DELIVER;
1497	}
1498	sm_setproctitle(TRUE, "%s: from queue", id);
1499	if (LogLevel > 76)
1500	sm_syslog(LOG_DEBUG, e->e_id,
1501	"dowork, pid=%d",
1502	getpid());
1503
1504	/* don't use the headers from sendmail.cf... */
1505	e->e_header = NULL;
1506
1507	/* read the queue control file -- return if locked */
1508	if (!readqf(e))
1509	{
1510	if (tTd(40, 4) && e->e_id != NULL)
1511	printf("readqf(%s) failed\n", e->e_id);
1512	e->e_id = NULL;
1513	if (forkflag)
1514	finis(FALSE, EX_OK);
1515	else
1516	return 0;
1517	}
1518
1519	e->e_flags \|= EF_INQUEUE;
1520	eatheader(e, requeueflag);
1521
1522	if (requeueflag)
1523	queueup(e, FALSE);
1524
1525	/* do the delivery */
1526	sendall(e, SM_DELIVER);
1527
1528	/* finish up and exit */
1529	if (forkflag)
1530	finis(TRUE, ExitStat);
1531	else
1532	dropenvelope(e, TRUE);
1533	}
1534	e->e_id = NULL;
1535	return pid;
1536	}
1537	/*
1538	** READQF -- read queue file and set up environment.
1539	**
1540	** Parameters:
1541	** e -- the envelope of the job to run.
1542	**
1543	** Returns:
1544	** TRUE if it successfully read the queue file.
1545	** FALSE otherwise.
1546	**
1547	** Side Effects:
1548	** The queue file is returned locked.
1549	*/
1550
1551	bool
1552	readqf(e)
1553	register ENVELOPE *e;
1554	{
1555	register FILE *qfp;
1556	ADDRESS *ctladdr;
1557	struct stat st;
1558	char *bp;
1559	int qfver = 0;
1560	long hdrsize = 0;
1561	register char *p;
1562	char *orcpt = NULL;
1563	bool nomore = FALSE;
1564	char qf[MAXQFNAME];
1565	char buf[MAXLINE];
1566	extern ADDRESS setctluser __P((char , int));
1567
1568	/*
1569	** Read and process the file.
1570	*/
1571
1572	strcpy(qf, queuename(e, 'q'));
1573	qfp = fopen(qf, "r+");
1574	if (qfp == NULL)
1575	{
1576	if (tTd(40, 8))
1577	printf("readqf(%s): fopen failure (%s)\n",
1578	qf, errstring(errno));
1579	if (errno != ENOENT)
1580	syserr("readqf: no control file %s", qf);
1581	return FALSE;
1582	}
1583
1584	if (!lockfile(fileno(qfp), qf, NULL, LOCK_EX\|LOCK_NB))
1585	{
1586	/* being processed by another queuer */
1587	if (Verbose \|\| tTd(40, 8))
1588	printf("%s: locked\n", e->e_id);
1589	if (LogLevel > 19)
1590	sm_syslog(LOG_DEBUG, e->e_id, "locked");
1591	(void) fclose(qfp);
1592	return FALSE;
1593	}
1594
1595	/*
1596	** Check the queue file for plausibility to avoid attacks.
1597	*/
1598
1599	if (fstat(fileno(qfp), &st) < 0)
1600	{
1601	/* must have been being processed by someone else */
1602	if (tTd(40, 8))
1603	printf("readqf(%s): fstat failure (%s)\n",
1604	qf, errstring(errno));
1605	fclose(qfp);
1606	return FALSE;
1607	}
1608
1609	if ((st.st_uid != geteuid() && geteuid() != RealUid) \|\|
1610	bitset(S_IWOTH\|S_IWGRP, st.st_mode))
1611	{
1612	if (LogLevel > 0)
1613	{
1614	sm_syslog(LOG_ALERT, e->e_id,
1615	"bogus queue file, uid=%d, mode=%o",
1616	st.st_uid, st.st_mode);
1617	}
1618	if (tTd(40, 8))
1619	printf("readqf(%s): bogus file\n", qf);
1620	loseqfile(e, "bogus file uid in mqueue");
1621	fclose(qfp);
1622	return FALSE;
1623	}
1624
1625	if (st.st_size == 0)
1626	{
1627	/* must be a bogus file -- if also old, just remove it */
1628	if (st.st_ctime + 10 * 60 < curtime())
1629	{
1630	qf[0] = 'd';
1631	(void) unlink(qf);
1632	qf[0] = 'q';
1633	(void) unlink(qf);
1634	}
1635	fclose(qfp);
1636	return FALSE;
1637	}
1638
1639	if (st.st_nlink == 0)
1640	{
1641	/*
1642	** Race condition -- we got a file just as it was being
1643	** unlinked. Just assume it is zero length.
1644	*/
1645
1646	fclose(qfp);
1647	return FALSE;
1648	}
1649
1650	/* good file -- save this lock */
1651	e->e_lockfp = qfp;
1652
1653	/* do basic system initialization */
1654	initsys(e);
1655	define('i', e->e_id, e);
1656
1657	LineNumber = 0;
1658	e->e_flags \|= EF_GLOBALERRS;
1659	OpMode = MD_DELIVER;
1660	ctladdr = NULL;
1661	e->e_dfino = -1;
1662	e->e_msgsize = -1;
1663	while ((bp = fgetfolded(buf, sizeof buf, qfp)) != NULL)
1664	{
1665	register char *p;
1666	u_long qflags;
1667	ADDRESS *q;
1668	int mid;
1669	auto char *ep;
1670
1671	if (tTd(40, 4))
1672	printf("+++++ %s\n", bp);
1673	if (nomore)
1674	{
1675	/* hack attack */
1676	syserr("SECURITY ALERT: extra data in qf: %s", bp);
1677	fclose(qfp);
1678	loseqfile(e, "bogus queue line");
1679	return FALSE;
1680	}
1681	switch (bp[0])
1682	{
1683	case 'V': /* queue file version number */
1684	qfver = atoi(&bp[1]);
1685	if (qfver <= QF_VERSION)
1686	break;
1687	syserr("Version number in qf (%d) greater than max (%d)",
1688	qfver, QF_VERSION);
1689	fclose(qfp);
1690	loseqfile(e, "unsupported qf file version");
1691	return FALSE;
1692
1693	case 'C': /* specify controlling user */
1694	ctladdr = setctluser(&bp[1], qfver);
1695	break;
1696
1697	case 'Q': /* original recipient */
1698	orcpt = newstr(&bp[1]);
1699	break;
1700
1701	case 'R': /* specify recipient */
1702	p = bp;
1703	qflags = 0;
1704	if (qfver >= 1)
1705	{
1706	/* get flag bits */
1707	while (++p != '\0' && p != ':')
1708	{
1709	switch (*p)
1710	{
1711	case 'N':
1712	qflags \|= QHASNOTIFY;
1713	break;
1714
1715	case 'S':
1716	qflags \|= QPINGONSUCCESS;
1717	break;
1718
1719	case 'F':
1720	qflags \|= QPINGONFAILURE;
1721	break;
1722
1723	case 'D':
1724	qflags \|= QPINGONDELAY;
1725	break;
1726
1727	case 'P':
1728	qflags \|= QPRIMARY;
1729	break;
1730	}
1731	}
1732	}
1733	else
1734	qflags \|= QPRIMARY;
1735	q = parseaddr(++p, NULLADDR, RF_COPYALL, '\0', NULL, e);
1736	if (q != NULL)
1737	{
1738	q->q_alias = ctladdr;
1739	if (qfver >= 1)
1740	q->q_flags &= ~Q_PINGFLAGS;
1741	q->q_flags \|= qflags;
1742	q->q_orcpt = orcpt;
1743	(void) recipient(q, &e->e_sendqueue, 0, e);
1744	}
1745	orcpt = NULL;
1746	break;
1747
1748	case 'E': /* specify error recipient */
1749	/* no longer used */
1750	break;
1751
1752	case 'H': /* header */
1753	(void) chompheader(&bp[1], FALSE, NULL, e);
1754	hdrsize += strlen(&bp[1]);
1755	break;
1756
1757	case 'L': /* Solaris Content-Length: */
1758	case 'M': /* message */
1759	/* ignore this; we want a new message next time */
1760	break;
1761
1762	case 'S': /* sender */
1763	setsender(newstr(&bp[1]), e, NULL, '\0', TRUE);
1764	break;
1765
1766	case 'B': /* body type */
1767	e->e_bodytype = newstr(&bp[1]);
1768	break;
1769
1770	#if _FFR_SAVE_CHARSET
1771	case 'X': /* character set */
1772	e->e_charset = newstr(&bp[1]);
1773	break;
1774	#endif
1775
1776	case 'D': /* data file name */
1777	/* obsolete -- ignore */
1778	break;
1779
1780	case 'T': /* init time */
1781	e->e_ctime = atol(&bp[1]);
1782	break;
1783
1784	case 'I': /* data file's inode number */
1785	/* regenerated below */
1786	break;
1787
1788	case 'K': /* time of last deliver attempt */
1789	e->e_dtime = atol(&buf[1]);
1790	break;
1791
1792	case 'N': /* number of delivery attempts */
1793	e->e_ntries = atoi(&buf[1]);
1794
1795	/* if this has been tried recently, let it be */
1796	if (e->e_ntries > 0 &&
1797	MinQueueAge > 0 && e->e_dtime <= curtime() &&
1798	curtime() < e->e_dtime + MinQueueAge)
1799	{
1800	char *howlong = pintvl(curtime() - e->e_dtime, TRUE);
1801
1802	if (Verbose \|\| tTd(40, 8))
1803	printf("%s: too young (%s)\n",
1804	e->e_id, howlong);
1805	if (LogLevel > 19)
1806	sm_syslog(LOG_DEBUG, e->e_id,
1807	"too young (%s)",
1808	howlong);
1809	e->e_id = NULL;
1810	unlockqueue(e);
1811	return FALSE;
1812	}
1813	break;
1814
1815	case 'P': /* message priority */
1816	e->e_msgpriority = atol(&bp[1]) + WkTimeFact;
1817	break;
1818
1819	case 'F': /* flag bits */
1820	if (strncmp(bp, "From ", 5) == 0)
1821	{
1822	/* we are being spoofed! */
1823	syserr("SECURITY ALERT: bogus qf line %s", bp);
1824	fclose(qfp);
1825	loseqfile(e, "bogus queue line");
1826	return FALSE;
1827	}
1828	for (p = &bp[1]; *p != '\0'; p++)
1829	{
1830	switch (*p)
1831	{
1832	case 'w': /* warning sent */
1833	e->e_flags \|= EF_WARNING;
1834	break;
1835
1836	case 'r': /* response */
1837	e->e_flags \|= EF_RESPONSE;
1838	break;
1839
1840	case '8': /* has 8 bit data */
1841	e->e_flags \|= EF_HAS8BIT;
1842	break;
1843
1844	case 'b': /* delete Bcc: header */
1845	e->e_flags \|= EF_DELETE_BCC;
1846	break;
1847
1848	case 'd': /* envelope has DSN RET= */
1849	e->e_flags \|= EF_RET_PARAM;
1850	break;
1851
1852	case 'n': /* don't return body */
1853	e->e_flags \|= EF_NO_BODY_RETN;
1854	break;
1855	}
1856	}
1857	break;
1858
1859	case 'Z': /* original envelope id from ESMTP */
1860	e->e_envid = newstr(&bp[1]);
1861	break;
1862
1863	case '$': /* define macro */
1864	mid = macid(&bp[1], &ep);
1865	define(mid, newstr(ep), e);
1866	break;
1867
1868	case '.': /* terminate file */
1869	nomore = TRUE;
1870	break;
1871
1872	default:
1873	syserr("readqf: %s: line %d: bad line \"%s\"",
1874	qf, LineNumber, shortenstring(bp, MAXSHORTSTR));
1875	fclose(qfp);
1876	loseqfile(e, "unrecognized line");
1877	return FALSE;
1878	}
1879
1880	if (bp != buf)
1881	free(bp);
1882	}
1883
1884	/*
1885	** If we haven't read any lines, this queue file is empty.
1886	** Arrange to remove it without referencing any null pointers.
1887	*/
1888
1889	if (LineNumber == 0)
1890	{
1891	errno = 0;
1892	e->e_flags \|= EF_CLRQUEUE \| EF_FATALERRS \| EF_RESPONSE;
1893	return TRUE;
1894	}
1895
1896	/*
1897	** Arrange to read the data file.
1898	*/
1899
1900	p = queuename(e, 'd');
1901	e->e_dfp = fopen(p, "r");
1902	if (e->e_dfp == NULL)
1903	{
1904	syserr("readqf: cannot open %s", p);
1905	}
1906	else
1907	{
1908	e->e_flags \|= EF_HAS_DF;
1909	if (fstat(fileno(e->e_dfp), &st) >= 0)
1910	{
1911	e->e_msgsize = st.st_size + hdrsize;
1912	e->e_dfdev = st.st_dev;
1913	e->e_dfino = st.st_ino;
1914	}
1915	}
1916
1917	return TRUE;
1918	}
1919	/*
1920	** PRINTQUEUE -- print out a representation of the mail queue
1921	**
1922	** Parameters:
1923	** none.
1924	**
1925	** Returns:
1926	** none.
1927	**
1928	** Side Effects:
1929	** Prints a listing of the mail queue on the standard output.
1930	*/
1931
1932	void
1933	printqueue()
1934	{
1935	register WORK *w;
1936	FILE *f;
1937	int nrequests;
1938	char buf[MAXLINE];
1939
1940	/*
1941	** Check for permission to print the queue
1942	*/
1943
1944	if (bitset(PRIV_RESTRICTMAILQ, PrivacyFlags) && RealUid != 0)
1945	{
1946	struct stat st;
1947	# ifdef NGROUPS_MAX
1948	int n;
1949	extern GIDSET_T InitialGidSet[NGROUPS_MAX];
1950	# endif
1951
1952	if (stat(QueueDir, &st) < 0)
1953	{
1954	syserr("Cannot stat %s", QueueDir);
1955	return;
1956	}
1957	# ifdef NGROUPS_MAX
1958	n = NGROUPS_MAX;
1959	while (--n >= 0)
1960	{
1961	if (InitialGidSet[n] == st.st_gid)
1962	break;
1963	}
1964	if (n < 0 && RealGid != st.st_gid)
1965	# else
1966	if (RealGid != st.st_gid)
1967	# endif
1968	{
1969	usrerr("510 You are not permitted to see the queue");
1970	setstat(EX_NOPERM);
1971	return;
1972	}
1973	}
1974
1975	/*
1976	** Read and order the queue.
1977	*/
1978
1979	nrequests = orderq(TRUE);
1980
1981	/*
1982	** Print the work list that we have read.
1983	*/
1984
1985	/* first see if there is anything */
1986	if (nrequests <= 0)
1987	{
1988	printf("Mail queue is empty\n");
1989	return;
1990	}
1991
1992	CurrentLA = getla(); /* get load average */
1993
1994	printf("\t\tMail Queue (%d request%s", nrequests, nrequests == 1 ? "" : "s");
1995	if (MaxQueueRun > 0 && nrequests > MaxQueueRun)
1996	printf(", only %d printed", MaxQueueRun);
1997	if (Verbose)
1998	printf(")\n--Q-ID-- --Size-- -Priority- ---Q-Time--- -----------Sender/Recipient-----------\n");
1999	else
2000	printf(")\n--Q-ID-- --Size-- -----Q-Time----- ------------Sender/Recipient------------\n");
2001	for (w = WorkQ; w != NULL; w = w->w_next)
2002	{
2003	struct stat st;
2004	auto time_t submittime = 0;
2005	long dfsize;
2006	int flags = 0;
2007	int qfver;
2008	char statmsg[MAXLINE];
2009	char bodytype[MAXNAME + 1];
2010
2011	printf("%8s", w->w_name + 2);
2012	f = fopen(w->w_name, "r");
2013	if (f == NULL)
2014	{
2015	printf(" (job completed)\n");
2016	errno = 0;
2017	continue;
2018	}
2019	w->w_name[0] = 'd';
2020	if (stat(w->w_name, &st) >= 0)
2021	dfsize = st.st_size;
2022	else
2023	dfsize = -1;
2024	if (w->w_lock)
2025	printf("*");
2026	else if (w->w_tooyoung)
2027	printf("-");
2028	else if (shouldqueue(w->w_pri, w->w_ctime))
2029	printf("X");
2030	else
2031	printf(" ");
2032	errno = 0;
2033
2034	statmsg[0] = bodytype[0] = '\0';
2035	qfver = 0;
2036	while (fgets(buf, sizeof buf, f) != NULL)
2037	{
2038	register int i;
2039	register char *p;
2040
2041	fixcrlf(buf, TRUE);
2042	switch (buf[0])
2043	{
2044	case 'V': /* queue file version */
2045	qfver = atoi(&buf[1]);
2046	break;
2047
2048	case 'M': /* error message */
2049	if ((i = strlen(&buf[1])) >= sizeof statmsg)
2050	i = sizeof statmsg - 1;
2051	bcopy(&buf[1], statmsg, i);
2052	statmsg[i] = '\0';
2053	break;
2054
2055	case 'B': /* body type */
2056	if ((i = strlen(&buf[1])) >= sizeof bodytype)
2057	i = sizeof bodytype - 1;
2058	bcopy(&buf[1], bodytype, i);
2059	bodytype[i] = '\0';
2060	break;
2061
2062	case 'S': /* sender name */
2063	if (Verbose)
2064	printf("%8ld %10ld%c%.12s %.78s",
2065	dfsize,
2066	w->w_pri,
2067	bitset(EF_WARNING, flags) ? '+' : ' ',
2068	ctime(&submittime) + 4,
2069	&buf[1]);
2070	else
2071	printf("%8ld %.16s %.45s", dfsize,
2072	ctime(&submittime), &buf[1]);
2073	if (statmsg[0] != '\0' \|\| bodytype[0] != '\0')
2074	{
2075	printf("\n %10.10s", bodytype);
2076	if (statmsg[0] != '\0')
2077	printf(" (%.*s)",
2078	Verbose ? 100 : 60,
2079	statmsg);
2080	}
2081	break;
2082
2083	case 'C': /* controlling user */
2084	if (Verbose)
2085	printf("\n\t\t\t\t (---%.74s---)",
2086	&buf[1]);
2087	break;
2088
2089	case 'R': /* recipient name */
2090	p = &buf[1];
2091	if (qfver >= 1)
2092	{
2093	p = strchr(p, ':');
2094	if (p == NULL)
2095	break;
2096	p++;
2097	}
2098	if (Verbose)
2099	printf("\n\t\t\t\t\t %.78s", p);
2100	else
2101	printf("\n\t\t\t\t %.45s", p);
2102	break;
2103
2104	case 'T': /* creation time */
2105	submittime = atol(&buf[1]);
2106	break;
2107
2108	case 'F': /* flag bits */
2109	for (p = &buf[1]; *p != '\0'; p++)
2110	{
2111	switch (*p)
2112	{
2113	case 'w':
2114	flags \|= EF_WARNING;
2115	break;
2116	}
2117	}
2118	}
2119	}
2120	if (submittime == (time_t) 0)
2121	printf(" (no control file)");
2122	printf("\n");
2123	(void) fclose(f);
2124	}
2125	}
2126
2127	# endif /* QUEUE */
2128	/*
2129	** QUEUENAME -- build a file name in the queue directory for this envelope.
2130	**
2131	** Assigns an id code if one does not already exist.
2132	** This code is very careful to avoid trashing existing files
2133	** under any circumstances.
2134	**
2135	** Parameters:
2136	** e -- envelope to build it in/from.
2137	** type -- the file type, used as the first character
2138	** of the file name.
2139	**
2140	** Returns:
2141	** a pointer to the new file name (in a static buffer).
2142	**
2143	** Side Effects:
2144	** If no id code is already assigned, queuename will
2145	** assign an id code, create a qf file, and leave a
2146	** locked, open-for-write file pointer in the envelope.
2147	*/
2148
2149	#ifndef ENOLCK
2150	# define ENOLCK -1
2151	#endif
2152	#ifndef ENOSPC
2153	# define ENOSPC -1
2154	#endif
2155
2156	char *
2157	queuename(e, type)
2158	register ENVELOPE *e;
2159	int type;
2160	{
2161	static pid_t pid = -1;
2162	static char c0;
2163	static char c1;
2164	static char c2;
2165	time_t now;
2166	struct tm *tm;
2167	static char buf[MAXNAME + 1];
2168
2169	if (e->e_id == NULL)
2170	{
2171	char qf[MAXQFNAME];
2172
2173	/* find a unique id */
2174	if (pid != getpid())
2175	{
2176	/* new process -- start back at "AA" */
2177	pid = getpid();
2178	now = curtime();
2179	tm = localtime(&now);
2180	c0 = 'A' + tm->tm_hour;
2181	c1 = 'A';
2182	c2 = 'A' - 1;
2183	}
2184	(void) snprintf(qf, sizeof qf, "qf%cAA%05d", c0, pid);
2185
2186	while (c1 < '~' \|\| c2 < 'Z')
2187	{
2188	int i;
2189	int attempts = 0;
2190
2191	if (c2 >= 'Z')
2192	{
2193	c1++;
2194	c2 = 'A' - 1;
2195	}
2196	qf[3] = c1;
2197	qf[4] = ++c2;
2198	if (tTd(7, 20))
2199	printf("queuename: trying \"%s\"\n", qf);
2200
2201	i = open(qf, O_WRONLY\|O_CREAT\|O_EXCL, FileMode);
2202	if (i < 0)
2203	{
2204	if (errno == EEXIST)
2205	continue;
2206	syserr("queuename: Cannot create \"%s\" in \"%s\" (euid=%d)",
2207	qf, QueueDir, geteuid());
2208	finis(FALSE, EX_UNAVAILABLE);
2209	}
2210	do
2211	{
2212	if (attempts > 0)
2213	sleep(attempts);
2214	e->e_lockfp = 0;
2215	if (lockfile(i, qf, NULL, LOCK_EX\|LOCK_NB))
2216	{
2217	e->e_lockfp = fdopen(i, "w");
2218	break;
2219	}
2220	} while ((errno == ENOLCK \|\| errno == ENOSPC) &&
2221	attempts++ < 4);
2222
2223	/* Successful lock */
2224	if (e->e_lockfp != 0)
2225	break;
2226
2227	#if !HASFLOCK
2228	if (errno != EAGAIN && errno != EACCES)
2229	#else
2230	if (errno != EWOULDBLOCK)
2231	#endif
2232	{
2233	syserr("queuename: Cannot lock \"%s\" in \"%s\" (euid=%d)",
2234	qf, QueueDir, geteuid());
2235	finis(FALSE, EX_OSERR);
2236	}
2237
2238	/* a reader got the file; abandon it and try again */
2239	(void) close(i);
2240	}
2241	if (c1 >= '~' && c2 >= 'Z')
2242	{
2243	syserr("queuename: Cannot create \"%s\" in \"%s\" (euid=%d)",
2244	qf, QueueDir, geteuid());
2245	finis(FALSE, EX_OSERR);
2246	}
2247	e->e_id = newstr(&qf[2]);
2248	define('i', e->e_id, e);
2249	if (tTd(7, 1))
2250	printf("queuename: assigned id %s, env=%lx\n",
2251	e->e_id, (u_long) e);
2252	if (tTd(7, 9))
2253	{
2254	printf(" lockfd=");
2255	dumpfd(fileno(e->e_lockfp), TRUE, FALSE);
2256	}
2257	if (LogLevel > 93)
2258	sm_syslog(LOG_DEBUG, e->e_id, "assigned id");
2259	}
2260
2261	if (type == '\0')
2262	return (NULL);
2263	(void) snprintf(buf, sizeof buf, "%cf%s", type, e->e_id);
2264	if (tTd(7, 2))
2265	printf("queuename: %s\n", buf);
2266	return (buf);
2267	}
2268	/*
2269	** UNLOCKQUEUE -- unlock the queue entry for a specified envelope
2270	**
2271	** Parameters:
2272	** e -- the envelope to unlock.
2273	**
2274	** Returns:
2275	** none
2276	**
2277	** Side Effects:
2278	** unlocks the queue for `e'.
2279	*/
2280
2281	void
2282	unlockqueue(e)
2283	ENVELOPE *e;
2284	{
2285	if (tTd(51, 4))
2286	printf("unlockqueue(%s)\n",
2287	e->e_id == NULL ? "NOQUEUE" : e->e_id);
2288
2289	/* if there is a lock file in the envelope, close it */
2290	if (e->e_lockfp != NULL)
2291	xfclose(e->e_lockfp, "unlockqueue", e->e_id);
2292	e->e_lockfp = NULL;
2293
2294	/* don't create a queue id if we don't already have one */
2295	if (e->e_id == NULL)
2296	return;
2297
2298	/* remove the transcript */
2299	if (LogLevel > 87)
2300	sm_syslog(LOG_DEBUG, e->e_id, "unlock");
2301	if (!tTd(51, 104))
2302	xunlink(queuename(e, 'x'));
2303
2304	}
2305	/*
2306	** SETCTLUSER -- create a controlling address
2307	**
2308	** Create a fake "address" given only a local login name; this is
2309	** used as a "controlling user" for future recipient addresses.
2310	**
2311	** Parameters:
2312	** user -- the user name of the controlling user.
2313	** qfver -- the version stamp of this qf file.
2314	**
2315	** Returns:
2316	** An address descriptor for the controlling user.
2317	**
2318	** Side Effects:
2319	** none.
2320	*/
2321
2322	ADDRESS *
2323	setctluser(user, qfver)
2324	char *user;
2325	int qfver;
2326	{
2327	register ADDRESS *a;
2328	struct passwd *pw;
2329	char *p;
2330
2331	/*
2332	** See if this clears our concept of controlling user.
2333	*/
2334
2335	if (user == NULL \|\| *user == '\0')
2336	return NULL;
2337
2338	/*
2339	** Set up addr fields for controlling user.
2340	*/
2341
2342	a = (ADDRESS ) xalloc(sizeof a);
2343	bzero((char ) a, sizeof a);
2344
2345	if (*user == '\0')
2346	{
2347	p = NULL;
2348	a->q_user = newstr(DefUser);
2349	}
2350	else if (*user == ':')
2351	{
2352	p = &user[1];
2353	a->q_user = newstr(p);
2354	}
2355	else
2356	{
2357	p = strtok(user, ":");
2358	a->q_user = newstr(user);
2359	if (qfver >= 2)
2360	{
2361	if ((p = strtok(NULL, ":")) != NULL)
2362	a->q_uid = atoi(p);
2363	if ((p = strtok(NULL, ":")) != NULL)
2364	a->q_gid = atoi(p);
2365	if ((p = strtok(NULL, ":")) != NULL)
2366	a->q_flags \|= QGOODUID;
2367	}
2368	else if ((pw = sm_getpwnam(user)) != NULL)
2369	{
2370	if (strcmp(pw->pw_dir, "/") == 0)
2371	a->q_home = "";
2372	else
2373	a->q_home = newstr(pw->pw_dir);
2374	a->q_uid = pw->pw_uid;
2375	a->q_gid = pw->pw_gid;
2376	a->q_flags \|= QGOODUID;
2377	}
2378	}
2379
2380	a->q_flags \|= QPRIMARY; /* flag as a "ctladdr" */
2381	a->q_mailer = LocalMailer;
2382	if (p == NULL)
2383	a->q_paddr = a->q_user;
2384	else
2385	a->q_paddr = newstr(p);
2386	return a;
2387	}
2388	/*
2389	** LOSEQFILE -- save the qf as Qf and try to let someone know
2390	**
2391	** Parameters:
2392	** e -- the envelope (e->e_id will be used).
2393	** why -- reported to whomever can hear.
2394	**
2395	** Returns:
2396	** none.
2397	*/
2398
2399	void
2400	loseqfile(e, why)
2401	register ENVELOPE *e;
2402	char *why;
2403	{
2404	char *p;
2405	char buf[MAXQFNAME + 1];
2406
2407	if (e == NULL \|\| e->e_id == NULL)
2408	return;
2409	p = queuename(e, 'q');
2410	if (strlen(p) > MAXQFNAME)
2411	{
2412	syserr("loseqfile: queuename (%s) too long", p);
2413	return;
2414	}
2415	strcpy(buf, p);
2416	p = queuename(e, 'Q');
2417	if (rename(buf, p) < 0)
2418	syserr("cannot rename(%s, %s), uid=%d", buf, p, geteuid());
2419	else if (LogLevel > 0)
2420	sm_syslog(LOG_ALERT, e->e_id,
2421	"Losing %s: %s", buf, why);
2422	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: