xref: /illumos-gate/usr/src/cmd/sendmail/src/queue.c (revision 55fea89dcaa64928bed4327112404dcb3e07b79f)
1 /*
2  * Copyright (c) 1998-2009 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 #include <sm/sem.h>
16 
17 SM_RCSID("@(#)$Id: queue.c,v 8.987 2009/12/18 17:08:01 ca Exp $")
18 
19 #include <dirent.h>
20 
21 # define RELEASE_QUEUE	(void) 0
22 # define ST_INODE(st)	(st).st_ino
23 
24 #  define sm_file_exists(errno) ((errno) == EEXIST)
25 
26 # if HASFLOCK && defined(O_EXLOCK)
27 #   define SM_OPEN_EXLOCK 1
28 #   define TF_OPEN_FLAGS (O_CREAT|O_WRONLY|O_EXCL|O_EXLOCK)
29 # else /* HASFLOCK && defined(O_EXLOCK) */
30 #  define TF_OPEN_FLAGS (O_CREAT|O_WRONLY|O_EXCL)
31 # endif /* HASFLOCK && defined(O_EXLOCK) */
32 
33 #ifndef SM_OPEN_EXLOCK
34 # define SM_OPEN_EXLOCK 0
35 #endif /* ! SM_OPEN_EXLOCK */
36 
37 /*
38 **  Historical notes:
39 **	QF_VERSION == 4 was sendmail 8.10/8.11 without _FFR_QUEUEDELAY
40 **	QF_VERSION == 5 was sendmail 8.10/8.11 with    _FFR_QUEUEDELAY
41 **	QF_VERSION == 6 was sendmail 8.12      without _FFR_QUEUEDELAY
42 **	QF_VERSION == 7 was sendmail 8.12      with    _FFR_QUEUEDELAY
43 **	QF_VERSION == 8 is  sendmail 8.13
44 */
45 
46 #define QF_VERSION	8	/* version number of this queue format */
47 
48 static char	queue_letter __P((ENVELOPE *, int));
49 static bool	quarantine_queue_item __P((int, int, ENVELOPE *, char *));
50 
51 /* Naming convention: qgrp: index of queue group, qg: QUEUEGROUP */
52 
53 /*
54 **  Work queue.
55 */
56 
57 struct work
58 {
59 	char		*w_name;	/* name of control file */
60 	char		*w_host;	/* name of recipient host */
61 	bool		w_lock;		/* is message locked? */
62 	bool		w_tooyoung;	/* is it too young to run? */
63 	long		w_pri;		/* priority of message, see below */
64 	time_t		w_ctime;	/* creation time */
65 	time_t		w_mtime;	/* modification time */
66 	int		w_qgrp;		/* queue group located in */
67 	int		w_qdir;		/* queue directory located in */
68 	struct work	*w_next;	/* next in queue */
69 };
70 
71 typedef struct work	WORK;
72 
73 static WORK	*WorkQ;		/* queue of things to be done */
74 static int	NumWorkGroups;	/* number of work groups */
75 static time_t	Current_LA_time = 0;
76 
77 /* Get new load average every 30 seconds. */
78 #define GET_NEW_LA_TIME	30
79 
80 #define SM_GET_LA(now)	\
81 	do							\
82 	{							\
83 		now = curtime();				\
84 		if (Current_LA_time < now - GET_NEW_LA_TIME)	\
85 		{						\
86 			sm_getla();				\
87 			Current_LA_time = now;			\
88 		}						\
89 	} while (0)
90 
91 /*
92 **  DoQueueRun indicates that a queue run is needed.
93 **	Notice: DoQueueRun is modified in a signal handler!
94 */
95 
96 static bool	volatile DoQueueRun; /* non-interrupt time queue run needed */
97 
98 /*
99 **  Work group definition structure.
100 **	Each work group contains one or more queue groups. This is done
101 **	to manage the number of queue group runners active at the same time
102 **	to be within the constraints of MaxQueueChildren (if it is set).
103 **	The number of queue groups that can be run on the next work run
104 **	is kept track of. The queue groups are run in a round robin.
105 */
106 
107 struct workgrp
108 {
109 	int		wg_numqgrp;	/* number of queue groups in work grp */
110 	int		wg_runners;	/* total runners */
111 	int		wg_curqgrp;	/* current queue group */
112 	QUEUEGRP	**wg_qgs;	/* array of queue groups */
113 	int		wg_maxact;	/* max # of active runners */
114 	time_t		wg_lowqintvl;	/* lowest queue interval */
115 	int		wg_restart;	/* needs restarting? */
116 	int		wg_restartcnt;	/* count of times restarted */
117 };
118 
119 typedef struct workgrp WORKGRP;
120 
121 static WORKGRP	volatile WorkGrp[MAXWORKGROUPS + 1];	/* work groups */
122 
123 #if SM_HEAP_CHECK
124 static SM_DEBUG_T DebugLeakQ = SM_DEBUG_INITIALIZER("leak_q",
125 	"@(#)$Debug: leak_q - trace memory leaks during queue processing $");
126 #endif /* SM_HEAP_CHECK */
127 
128 /*
129 **  We use EmptyString instead of "" to avoid
130 **  'zero-length format string' warnings from gcc
131 */
132 
133 static const char EmptyString[] = "";
134 
135 static void	grow_wlist __P((int, int));
136 static int	multiqueue_cache __P((char *, int, QUEUEGRP *, int, unsigned int *));
137 static int	gatherq __P((int, int, bool, bool *, bool *, int *));
138 static int	sortq __P((int));
139 static void	printctladdr __P((ADDRESS *, SM_FILE_T *));
140 static bool	readqf __P((ENVELOPE *, bool));
141 static void	restart_work_group __P((int));
142 static void	runner_work __P((ENVELOPE *, int, bool, int, int));
143 static void	schedule_queue_runs __P((bool, int, bool));
144 static char	*strrev __P((char *));
145 static ADDRESS	*setctluser __P((char *, int, ENVELOPE *));
146 #if _FFR_RHS
147 static int	sm_strshufflecmp __P((char *, char *));
148 static void	init_shuffle_alphabet __P(());
149 #endif /* _FFR_RHS */
150 
151 /*
152 **  Note: workcmpf?() don't use a prototype because it will cause a conflict
153 **  with the qsort() call (which expects something like
154 **  int (*compar)(const void *, const void *), not (WORK *, WORK *))
155 */
156 
157 static int	workcmpf0();
158 static int	workcmpf1();
159 static int	workcmpf2();
160 static int	workcmpf3();
161 static int	workcmpf4();
162 static int	randi = 3;	/* index for workcmpf5() */
163 static int	workcmpf5();
164 static int	workcmpf6();
165 #if _FFR_RHS
166 static int	workcmpf7();
167 #endif /* _FFR_RHS */
168 
169 #if RANDOMSHIFT
170 # define get_rand_mod(m)	((get_random() >> RANDOMSHIFT) % (m))
171 #else /* RANDOMSHIFT */
172 # define get_rand_mod(m)	(get_random() % (m))
173 #endif /* RANDOMSHIFT */
174 
175 /*
176 **  File system definition.
177 **	Used to keep track of how much free space is available
178 **	on a file system in which one or more queue directories reside.
179 */
180 
181 typedef struct filesys_shared	FILESYS;
182 
183 struct filesys_shared
184 {
185 	dev_t	fs_dev;		/* unique device id */
186 	long	fs_avail;	/* number of free blocks available */
187 	long	fs_blksize;	/* block size, in bytes */
188 };
189 
190 /* probably kept in shared memory */
191 static FILESYS	FileSys[MAXFILESYS];	/* queue file systems */
192 static const char *FSPath[MAXFILESYS];	/* pathnames for file systems */
193 
194 #if SM_CONF_SHM
195 
196 /*
197 **  Shared memory data
198 **
199 **  Current layout:
200 **	size -- size of shared memory segment
201 **	pid -- pid of owner, should be a unique id to avoid misinterpretations
202 **		by other processes.
203 **	tag -- should be a unique id to avoid misinterpretations by others.
204 **		idea: hash over configuration data that will be stored here.
205 **	NumFileSys -- number of file systems.
206 **	FileSys -- (arrary of) structure for used file systems.
207 **	RSATmpCnt -- counter for number of uses of ephemeral RSA key.
208 **	QShm -- (array of) structure for information about queue directories.
209 */
210 
211 /*
212 **  Queue data in shared memory
213 */
214 
215 typedef struct queue_shared	QUEUE_SHM_T;
216 
217 struct queue_shared
218 {
219 	int	qs_entries;	/* number of entries */
220 	/* XXX more to follow? */
221 };
222 
223 static void	*Pshm;		/* pointer to shared memory */
224 static FILESYS	*PtrFileSys;	/* pointer to queue file system array */
225 int		ShmId = SM_SHM_NO_ID;	/* shared memory id */
226 static QUEUE_SHM_T	*QShm;		/* pointer to shared queue data */
227 static size_t shms;
228 
229 # define SHM_OFF_PID(p)	(((char *) (p)) + sizeof(int))
230 # define SHM_OFF_TAG(p)	(((char *) (p)) + sizeof(pid_t) + sizeof(int))
231 # define SHM_OFF_HEAD	(sizeof(pid_t) + sizeof(int) * 2)
232 
233 /* how to access FileSys */
234 # define FILE_SYS(i)	(PtrFileSys[i])
235 
236 /* first entry is a tag, for now just the size */
237 # define OFF_FILE_SYS(p)	(((char *) (p)) + SHM_OFF_HEAD)
238 
239 /* offset for PNumFileSys */
240 # define OFF_NUM_FILE_SYS(p)	(((char *) (p)) + SHM_OFF_HEAD + sizeof(FileSys))
241 
242 /* offset for PRSATmpCnt */
243 # define OFF_RSA_TMP_CNT(p) (((char *) (p)) + SHM_OFF_HEAD + sizeof(FileSys) + sizeof(int))
244 int	*PRSATmpCnt;
245 
246 /* offset for queue_shm */
247 # define OFF_QUEUE_SHM(p) (((char *) (p)) + SHM_OFF_HEAD + sizeof(FileSys) + sizeof(int) * 2)
248 
249 # define QSHM_ENTRIES(i)	QShm[i].qs_entries
250 
251 /* basic size of shared memory segment */
252 # define SM_T_SIZE	(SHM_OFF_HEAD + sizeof(FileSys) + sizeof(int) * 2)
253 
254 static unsigned int	hash_q __P((char *, unsigned int));
255 
256 /*
257 **  HASH_Q -- simple hash function
258 **
259 **	Parameters:
260 **		p -- string to hash.
261 **		h -- hash start value (from previous run).
262 **
263 **	Returns:
264 **		hash value.
265 */
266 
267 static unsigned int
hash_q(p,h)268 hash_q(p, h)
269 	char *p;
270 	unsigned int h;
271 {
272 	int c, d;
273 
274 	while (*p != '\0')
275 	{
276 		d = *p++;
277 		c = d;
278 		c ^= c<<6;
279 		h += (c<<11) ^ (c>>1);
280 		h ^= (d<<14) + (d<<7) + (d<<4) + d;
281 	}
282 	return h;
283 }
284 
285 
286 #else /* SM_CONF_SHM */
287 # define FILE_SYS(i)	FileSys[i]
288 #endif /* SM_CONF_SHM */
289 
290 /* access to the various components of file system data */
291 #define FILE_SYS_NAME(i)	FSPath[i]
292 #define FILE_SYS_AVAIL(i)	FILE_SYS(i).fs_avail
293 #define FILE_SYS_BLKSIZE(i)	FILE_SYS(i).fs_blksize
294 #define FILE_SYS_DEV(i)	FILE_SYS(i).fs_dev
295 
296 
297 /*
298 **  Current qf file field assignments:
299 **
300 **	A	AUTH= parameter
301 **	B	body type
302 **	C	controlling user
303 **	D	data file name
304 **	d	data file directory name (added in 8.12)
305 **	E	error recipient
306 **	F	flag bits
307 **	G	free (was: queue delay algorithm if _FFR_QUEUEDELAY)
308 **	H	header
309 **	I	data file's inode number
310 **	K	time of last delivery attempt
311 **	L	Solaris Content-Length: header (obsolete)
312 **	M	message
313 **	N	number of delivery attempts
314 **	P	message priority
315 **	q	quarantine reason
316 **	Q	original recipient (ORCPT=)
317 **	r	final recipient (Final-Recipient: DSN field)
318 **	R	recipient
319 **	S	sender
320 **	T	init time
321 **	V	queue file version
322 **	X	free (was: character set if _FFR_SAVE_CHARSET)
323 **	Y	free (was: current delay if _FFR_QUEUEDELAY)
324 **	Z	original envelope id from ESMTP
325 **	!	deliver by (added in 8.12)
326 **	$	define macro
327 **	.	terminate file
328 */
329 
330 /*
331 **  QUEUEUP -- queue a message up for future transmission.
332 **
333 **	Parameters:
334 **		e -- the envelope to queue up.
335 **		announce -- if true, tell when you are queueing up.
336 **		msync -- if true, then fsync() if SuperSafe interactive mode.
337 **
338 **	Returns:
339 **		none.
340 **
341 **	Side Effects:
342 **		The current request is saved in a control file.
343 **		The queue file is left locked.
344 */
345 
346 void
queueup(e,announce,msync)347 queueup(e, announce, msync)
348 	register ENVELOPE *e;
349 	bool announce;
350 	bool msync;
351 {
352 	register SM_FILE_T *tfp;
353 	register HDR *h;
354 	register ADDRESS *q;
355 	int tfd = -1;
356 	int i;
357 	bool newid;
358 	register char *p;
359 	MAILER nullmailer;
360 	MCI mcibuf;
361 	char qf[MAXPATHLEN];
362 	char tf[MAXPATHLEN];
363 	char df[MAXPATHLEN];
364 	char buf[MAXLINE];
365 
366 	/*
367 	**  Create control file.
368 	*/
369 
370 #define OPEN_TF	do							\
371 		{							\
372 			MODE_T oldumask = 0;				\
373 									\
374 			if (bitset(S_IWGRP, QueueFileMode))		\
375 				oldumask = umask(002);			\
376 			tfd = open(tf, TF_OPEN_FLAGS, QueueFileMode);	\
377 			if (bitset(S_IWGRP, QueueFileMode))		\
378 				(void) umask(oldumask);			\
379 		} while (0)
380 
381 
382 	newid = (e->e_id == NULL) || !bitset(EF_INQUEUE, e->e_flags);
383 	(void) sm_strlcpy(tf, queuename(e, NEWQFL_LETTER), sizeof(tf));
384 	tfp = e->e_lockfp;
385 	if (tfp == NULL && newid)
386 	{
387 		/*
388 		**  open qf file directly: this will give an error if the file
389 		**  already exists and hence prevent problems if a queue-id
390 		**  is reused (e.g., because the clock is set back).
391 		*/
392 
393 		(void) sm_strlcpy(tf, queuename(e, ANYQFL_LETTER), sizeof(tf));
394 		OPEN_TF;
395 		if (tfd < 0 ||
396 #if !SM_OPEN_EXLOCK
397 		    !lockfile(tfd, tf, NULL, LOCK_EX|LOCK_NB) ||
398 #endif /* !SM_OPEN_EXLOCK */
399 		    (tfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
400 					 (void *) &tfd, SM_IO_WRONLY,
401 					 NULL)) == NULL)
402 		{
403 			int save_errno = errno;
404 
405 			printopenfds(true);
406 			errno = save_errno;
407 			syserr("!queueup: cannot create queue file %s, euid=%d, fd=%d, fp=%p",
408 				tf, (int) geteuid(), tfd, tfp);
409 			/* NOTREACHED */
410 		}
411 		e->e_lockfp = tfp;
412 		upd_qs(e, 1, 0, "queueup");
413 	}
414 
415 	/* if newid, write the queue file directly (instead of temp file) */
416 	if (!newid)
417 	{
418 		/* get a locked tf file */
419 		for (i = 0; i < 128; i++)
420 		{
421 			if (tfd < 0)
422 			{
423 				OPEN_TF;
424 				if (tfd < 0)
425 				{
426 					if (errno != EEXIST)
427 						break;
428 					if (LogLevel > 0 && (i % 32) == 0)
429 						sm_syslog(LOG_ALERT, e->e_id,
430 							  "queueup: cannot create %s, euid=%d: %s",
431 							  tf, (int) geteuid(),
432 							  sm_errstring(errno));
433 				}
434 #if SM_OPEN_EXLOCK
435 				else
436 					break;
437 #endif /* SM_OPEN_EXLOCK */
438 			}
439 			if (tfd >= 0)
440 			{
441 #if SM_OPEN_EXLOCK
442 				/* file is locked by open() */
443 				break;
444 #else /* SM_OPEN_EXLOCK */
445 				if (lockfile(tfd, tf, NULL, LOCK_EX|LOCK_NB))
446 					break;
447 				else
448 #endif /* SM_OPEN_EXLOCK */
449 				if (LogLevel > 0 && (i % 32) == 0)
450 					sm_syslog(LOG_ALERT, e->e_id,
451 						  "queueup: cannot lock %s: %s",
452 						  tf, sm_errstring(errno));
453 				if ((i % 32) == 31)
454 				{
455 					(void) close(tfd);
456 					tfd = -1;
457 				}
458 			}
459 
460 			if ((i % 32) == 31)
461 			{
462 				/* save the old temp file away */
463 				(void) rename(tf, queuename(e, TEMPQF_LETTER));
464 			}
465 			else
466 				(void) sleep(i % 32);
467 		}
468 		if (tfd < 0 || (tfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
469 						 (void *) &tfd, SM_IO_WRONLY_B,
470 						 NULL)) == NULL)
471 		{
472 			int save_errno = errno;
473 
474 			printopenfds(true);
475 			errno = save_errno;
476 			syserr("!queueup: cannot create queue temp file %s, uid=%d",
477 				tf, (int) geteuid());
478 		}
479 	}
480 
481 	if (tTd(40, 1))
482 		sm_dprintf("\n>>>>> queueing %s/%s%s >>>>>\n",
483 			   qid_printqueue(e->e_qgrp, e->e_qdir),
484 			   queuename(e, ANYQFL_LETTER),
485 			   newid ? " (new id)" : "");
486 	if (tTd(40, 3))
487 	{
488 		sm_dprintf("  e_flags=");
489 		printenvflags(e);
490 	}
491 	if (tTd(40, 32))
492 	{
493 		sm_dprintf("  sendq=");
494 		printaddr(sm_debug_file(), e->e_sendqueue, true);
495 	}
496 	if (tTd(40, 9))
497 	{
498 		sm_dprintf("  tfp=");
499 		dumpfd(sm_io_getinfo(tfp, SM_IO_WHAT_FD, NULL), true, false);
500 		sm_dprintf("  lockfp=");
501 		if (e->e_lockfp == NULL)
502 			sm_dprintf("NULL\n");
503 		else
504 			dumpfd(sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL),
505 			       true, false);
506 	}
507 
508 	/*
509 	**  If there is no data file yet, create one.
510 	*/
511 
512 	(void) sm_strlcpy(df, queuename(e, DATAFL_LETTER), sizeof(df));
513 	if (bitset(EF_HAS_DF, e->e_flags))
514 	{
515 		if (e->e_dfp != NULL &&
516 		    SuperSafe != SAFE_REALLY &&
517 		    SuperSafe != SAFE_REALLY_POSTMILTER &&
518 		    sm_io_setinfo(e->e_dfp, SM_BF_COMMIT, NULL) < 0 &&
519 		    errno != EINVAL)
520 		{
521 			syserr("!queueup: cannot commit data file %s, uid=%d",
522 			       queuename(e, DATAFL_LETTER), (int) geteuid());
523 		}
524 		if (e->e_dfp != NULL &&
525 		    SuperSafe == SAFE_INTERACTIVE && msync)
526 		{
527 			if (tTd(40,32))
528 				sm_syslog(LOG_INFO, e->e_id,
529 					  "queueup: fsync(e->e_dfp)");
530 
531 			if (fsync(sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD,
532 						NULL)) < 0)
533 			{
534 				if (newid)
535 					syserr("!552 Error writing data file %s",
536 					       df);
537 				else
538 					syserr("!452 Error writing data file %s",
539 					       df);
540 			}
541 		}
542 	}
543 	else
544 	{
545 		int dfd;
546 		MODE_T oldumask = 0;
547 		register SM_FILE_T *dfp = NULL;
548 		struct stat stbuf;
549 
550 		if (e->e_dfp != NULL &&
551 		    sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
552 			syserr("committing over bf file");
553 
554 		if (bitset(S_IWGRP, QueueFileMode))
555 			oldumask = umask(002);
556 		dfd = open(df, O_WRONLY|O_CREAT|O_TRUNC|QF_O_EXTRA,
557 			   QueueFileMode);
558 		if (bitset(S_IWGRP, QueueFileMode))
559 			(void) umask(oldumask);
560 		if (dfd < 0 || (dfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
561 						 (void *) &dfd, SM_IO_WRONLY_B,
562 						 NULL)) == NULL)
563 			syserr("!queueup: cannot create data temp file %s, uid=%d",
564 				df, (int) geteuid());
565 		if (fstat(dfd, &stbuf) < 0)
566 			e->e_dfino = -1;
567 		else
568 		{
569 			e->e_dfdev = stbuf.st_dev;
570 			e->e_dfino = ST_INODE(stbuf);
571 		}
572 		e->e_flags |= EF_HAS_DF;
573 		memset(&mcibuf, '\0', sizeof(mcibuf));
574 		mcibuf.mci_out = dfp;
575 		mcibuf.mci_mailer = FileMailer;
576 		(*e->e_putbody)(&mcibuf, e, NULL);
577 
578 		if (SuperSafe == SAFE_REALLY ||
579 		    SuperSafe == SAFE_REALLY_POSTMILTER ||
580 		    (SuperSafe == SAFE_INTERACTIVE && msync))
581 		{
582 			if (tTd(40,32))
583 				sm_syslog(LOG_INFO, e->e_id,
584 					  "queueup: fsync(dfp)");
585 
586 			if (fsync(sm_io_getinfo(dfp, SM_IO_WHAT_FD, NULL)) < 0)
587 			{
588 				if (newid)
589 					syserr("!552 Error writing data file %s",
590 					       df);
591 				else
592 					syserr("!452 Error writing data file %s",
593 					       df);
594 			}
595 		}
596 
597 		if (sm_io_close(dfp, SM_TIME_DEFAULT) < 0)
598 			syserr("!queueup: cannot save data temp file %s, uid=%d",
599 				df, (int) geteuid());
600 		e->e_putbody = putbody;
601 	}
602 
603 	/*
604 	**  Output future work requests.
605 	**	Priority and creation time should be first, since
606 	**	they are required by gatherq.
607 	*/
608 
609 	/* output queue version number (must be first!) */
610 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "V%d\n", QF_VERSION);
611 
612 	/* output creation time */
613 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "T%ld\n", (long) e->e_ctime);
614 
615 	/* output last delivery time */
616 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "K%ld\n", (long) e->e_dtime);
617 
618 	/* output number of delivery attempts */
619 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "N%d\n", e->e_ntries);
620 
621 	/* output message priority */
622 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "P%ld\n", e->e_msgpriority);
623 
624 	/*
625 	**  If data file is in a different directory than the queue file,
626 	**  output a "d" record naming the directory of the data file.
627 	*/
628 
629 	if (e->e_dfqgrp != e->e_qgrp)
630 	{
631 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "d%s\n",
632 			Queue[e->e_dfqgrp]->qg_qpaths[e->e_dfqdir].qp_name);
633 	}
634 
635 	/* output inode number of data file */
636 	/* XXX should probably include device major/minor too */
637 	if (e->e_dfino != -1)
638 	{
639 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "I%ld/%ld/%llu\n",
640 				     (long) major(e->e_dfdev),
641 				     (long) minor(e->e_dfdev),
642 				     (ULONGLONG_T) e->e_dfino);
643 	}
644 
645 	/* output body type */
646 	if (e->e_bodytype != NULL)
647 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "B%s\n",
648 				     denlstring(e->e_bodytype, true, false));
649 
650 	/* quarantine reason */
651 	if (e->e_quarmsg != NULL)
652 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "q%s\n",
653 				     denlstring(e->e_quarmsg, true, false));
654 
655 	/* message from envelope, if it exists */
656 	if (e->e_message != NULL)
657 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "M%s\n",
658 				     denlstring(e->e_message, true, false));
659 
660 	/* send various flag bits through */
661 	p = buf;
662 	if (bitset(EF_WARNING, e->e_flags))
663 		*p++ = 'w';
664 	if (bitset(EF_RESPONSE, e->e_flags))
665 		*p++ = 'r';
666 	if (bitset(EF_HAS8BIT, e->e_flags))
667 		*p++ = '8';
668 	if (bitset(EF_DELETE_BCC, e->e_flags))
669 		*p++ = 'b';
670 	if (bitset(EF_RET_PARAM, e->e_flags))
671 		*p++ = 'd';
672 	if (bitset(EF_NO_BODY_RETN, e->e_flags))
673 		*p++ = 'n';
674 	if (bitset(EF_SPLIT, e->e_flags))
675 		*p++ = 's';
676 	*p++ = '\0';
677 	if (buf[0] != '\0')
678 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "F%s\n", buf);
679 
680 	/* save $={persistentMacros} macro values */
681 	queueup_macros(macid("{persistentMacros}"), tfp, e);
682 
683 	/* output name of sender */
684 	if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags))
685 		p = e->e_sender;
686 	else
687 		p = e->e_from.q_paddr;
688 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "S%s\n",
689 			     denlstring(p, true, false));
690 
691 	/* output ESMTP-supplied "original" information */
692 	if (e->e_envid != NULL)
693 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "Z%s\n",
694 				     denlstring(e->e_envid, true, false));
695 
696 	/* output AUTH= parameter */
697 	if (e->e_auth_param != NULL)
698 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "A%s\n",
699 				     denlstring(e->e_auth_param, true, false));
700 	if (e->e_dlvr_flag != 0)
701 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "!%c %ld\n",
702 				     (char) e->e_dlvr_flag, e->e_deliver_by);
703 
704 	/* output list of recipient addresses */
705 	printctladdr(NULL, NULL);
706 	for (q = e->e_sendqueue; q != NULL; q = q->q_next)
707 	{
708 		if (!QS_IS_UNDELIVERED(q->q_state))
709 			continue;
710 
711 		/* message for this recipient, if it exists */
712 		if (q->q_message != NULL)
713 			(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "M%s\n",
714 					     denlstring(q->q_message, true,
715 							false));
716 
717 		printctladdr(q, tfp);
718 		if (q->q_orcpt != NULL)
719 			(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "Q%s\n",
720 					     denlstring(q->q_orcpt, true,
721 							false));
722 		if (q->q_finalrcpt != NULL)
723 			(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "r%s\n",
724 					     denlstring(q->q_finalrcpt, true,
725 							false));
726 		(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'R');
727 		if (bitset(QPRIMARY, q->q_flags))
728 			(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'P');
729 		if (bitset(QHASNOTIFY, q->q_flags))
730 			(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'N');
731 		if (bitset(QPINGONSUCCESS, q->q_flags))
732 			(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'S');
733 		if (bitset(QPINGONFAILURE, q->q_flags))
734 			(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'F');
735 		if (bitset(QPINGONDELAY, q->q_flags))
736 			(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'D');
737 		if (q->q_alias != NULL &&
738 		    bitset(QALIAS, q->q_alias->q_flags))
739 			(void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'A');
740 		(void) sm_io_putc(tfp, SM_TIME_DEFAULT, ':');
741 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "%s\n",
742 				     denlstring(q->q_paddr, true, false));
743 		if (announce)
744 		{
745 			char *tag = "queued";
746 
747 			if (e->e_quarmsg != NULL)
748 				tag = "quarantined";
749 
750 			e->e_to = q->q_paddr;
751 			message(tag);
752 			if (LogLevel > 8)
753 				logdelivery(q->q_mailer, NULL, q->q_status,
754 					    tag, NULL, (time_t) 0, e);
755 			e->e_to = NULL;
756 		}
757 		if (tTd(40, 1))
758 		{
759 			sm_dprintf("queueing ");
760 			printaddr(sm_debug_file(), q, false);
761 		}
762 	}
763 
764 	/*
765 	**  Output headers for this message.
766 	**	Expand macros completely here.  Queue run will deal with
767 	**	everything as absolute headers.
768 	**		All headers that must be relative to the recipient
769 	**		can be cracked later.
770 	**	We set up a "null mailer" -- i.e., a mailer that will have
771 	**	no effect on the addresses as they are output.
772 	*/
773 
774 	memset((char *) &nullmailer, '\0', sizeof(nullmailer));
775 	nullmailer.m_re_rwset = nullmailer.m_rh_rwset =
776 			nullmailer.m_se_rwset = nullmailer.m_sh_rwset = -1;
777 	nullmailer.m_eol = "\n";
778 	memset(&mcibuf, '\0', sizeof(mcibuf));
779 	mcibuf.mci_mailer = &nullmailer;
780 	mcibuf.mci_out = tfp;
781 
782 	macdefine(&e->e_macro, A_PERM, 'g', "\201f");
783 	for (h = e->e_header; h != NULL; h = h->h_link)
784 	{
785 		if (h->h_value == NULL)
786 			continue;
787 
788 		/* don't output resent headers on non-resent messages */
789 		if (bitset(H_RESENT, h->h_flags) &&
790 		    !bitset(EF_RESENT, e->e_flags))
791 			continue;
792 
793 		/* expand macros; if null, don't output header at all */
794 		if (bitset(H_DEFAULT, h->h_flags))
795 		{
796 			(void) expand(h->h_value, buf, sizeof(buf), e);
797 			if (buf[0] == '\0')
798 				continue;
799 			if (buf[0] == ' ' && buf[1] == '\0')
800 				continue;
801 		}
802 
803 		/* output this header */
804 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "H?");
805 
806 		/* output conditional macro if present */
807 		if (h->h_macro != '\0')
808 		{
809 			if (bitset(0200, h->h_macro))
810 				(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT,
811 						     "${%s}",
812 						      macname(bitidx(h->h_macro)));
813 			else
814 				(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT,
815 						     "$%c", h->h_macro);
816 		}
817 		else if (!bitzerop(h->h_mflags) &&
818 			 bitset(H_CHECK|H_ACHECK, h->h_flags))
819 		{
820 			int j;
821 
822 			/* if conditional, output the set of conditions */
823 			for (j = '\0'; j <= '\177'; j++)
824 				if (bitnset(j, h->h_mflags))
825 					(void) sm_io_putc(tfp, SM_TIME_DEFAULT,
826 							  j);
827 		}
828 		(void) sm_io_putc(tfp, SM_TIME_DEFAULT, '?');
829 
830 		/* output the header: expand macros, convert addresses */
831 		if (bitset(H_DEFAULT, h->h_flags) &&
832 		    !bitset(H_BINDLATE, h->h_flags))
833 		{
834 			(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "%s:%s\n",
835 					     h->h_field,
836 					     denlstring(buf, false, true));
837 		}
838 		else if (bitset(H_FROM|H_RCPT, h->h_flags) &&
839 			 !bitset(H_BINDLATE, h->h_flags))
840 		{
841 			bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
842 			SM_FILE_T *savetrace = TrafficLogFile;
843 
844 			TrafficLogFile = NULL;
845 
846 			if (bitset(H_FROM, h->h_flags))
847 				oldstyle = false;
848 			commaize(h, h->h_value, oldstyle, &mcibuf, e,
849 				 PXLF_HEADER);
850 
851 			TrafficLogFile = savetrace;
852 		}
853 		else
854 		{
855 			(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "%s:%s\n",
856 					     h->h_field,
857 					     denlstring(h->h_value, false,
858 							true));
859 		}
860 	}
861 
862 	/*
863 	**  Clean up.
864 	**
865 	**	Write a terminator record -- this is to prevent
866 	**	scurrilous crackers from appending any data.
867 	*/
868 
869 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, ".\n");
870 
871 	if (sm_io_flush(tfp, SM_TIME_DEFAULT) != 0 ||
872 	    ((SuperSafe == SAFE_REALLY ||
873 	      SuperSafe == SAFE_REALLY_POSTMILTER ||
874 	      (SuperSafe == SAFE_INTERACTIVE && msync)) &&
875 	     fsync(sm_io_getinfo(tfp, SM_IO_WHAT_FD, NULL)) < 0) ||
876 	    sm_io_error(tfp))
877 	{
878 		if (newid)
879 			syserr("!552 Error writing control file %s", tf);
880 		else
881 			syserr("!452 Error writing control file %s", tf);
882 	}
883 
884 	if (!newid)
885 	{
886 		char new = queue_letter(e, ANYQFL_LETTER);
887 
888 		/* rename (locked) tf to be (locked) [qh]f */
889 		(void) sm_strlcpy(qf, queuename(e, ANYQFL_LETTER),
890 				  sizeof(qf));
891 		if (rename(tf, qf) < 0)
892 			syserr("cannot rename(%s, %s), uid=%d",
893 				tf, qf, (int) geteuid());
894 		else
895 		{
896 			/*
897 			**  Check if type has changed and only
898 			**  remove the old item if the rename above
899 			**  succeeded.
900 			*/
901 
902 			if (e->e_qfletter != '\0' &&
903 			    e->e_qfletter != new)
904 			{
905 				if (tTd(40, 5))
906 				{
907 					sm_dprintf("type changed from %c to %c\n",
908 						   e->e_qfletter, new);
909 				}
910 
911 				if (unlink(queuename(e, e->e_qfletter)) < 0)
912 				{
913 					/* XXX: something more drastic? */
914 					if (LogLevel > 0)
915 						sm_syslog(LOG_ERR, e->e_id,
916 							  "queueup: unlink(%s) failed: %s",
917 							  queuename(e, e->e_qfletter),
918 							  sm_errstring(errno));
919 				}
920 			}
921 		}
922 		e->e_qfletter = new;
923 
924 		/*
925 		**  fsync() after renaming to make sure metadata is
926 		**  written to disk on filesystems in which renames are
927 		**  not guaranteed.
928 		*/
929 
930 		if (SuperSafe != SAFE_NO)
931 		{
932 			/* for softupdates */
933 			if (tfd >= 0 && fsync(tfd) < 0)
934 			{
935 				syserr("!queueup: cannot fsync queue temp file %s",
936 				       tf);
937 			}
938 			SYNC_DIR(qf, true);
939 		}
940 
941 		/* close and unlock old (locked) queue file */
942 		if (e->e_lockfp != NULL)
943 			(void) sm_io_close(e->e_lockfp, SM_TIME_DEFAULT);
944 		e->e_lockfp = tfp;
945 
946 		/* save log info */
947 		if (LogLevel > 79)
948 			sm_syslog(LOG_DEBUG, e->e_id, "queueup %s", qf);
949 	}
950 	else
951 	{
952 		/* save log info */
953 		if (LogLevel > 79)
954 			sm_syslog(LOG_DEBUG, e->e_id, "queueup %s", tf);
955 
956 		e->e_qfletter = queue_letter(e, ANYQFL_LETTER);
957 	}
958 
959 	errno = 0;
960 	e->e_flags |= EF_INQUEUE;
961 
962 	if (tTd(40, 1))
963 		sm_dprintf("<<<<< done queueing %s <<<<<\n\n", e->e_id);
964 	return;
965 }
966 
967 /*
968 **  PRINTCTLADDR -- print control address to file.
969 **
970 **	Parameters:
971 **		a -- address.
972 **		tfp -- file pointer.
973 **
974 **	Returns:
975 **		none.
976 **
977 **	Side Effects:
978 **		The control address (if changed) is printed to the file.
979 **		The last control address and uid are saved.
980 */
981 
982 static void
printctladdr(a,tfp)983 printctladdr(a, tfp)
984 	register ADDRESS *a;
985 	SM_FILE_T *tfp;
986 {
987 	char *user;
988 	register ADDRESS *q;
989 	uid_t uid;
990 	gid_t gid;
991 	static ADDRESS *lastctladdr = NULL;
992 	static uid_t lastuid;
993 
994 	/* initialization */
995 	if (a == NULL || a->q_alias == NULL || tfp == NULL)
996 	{
997 		if (lastctladdr != NULL && tfp != NULL)
998 			(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "C\n");
999 		lastctladdr = NULL;
1000 		lastuid = 0;
1001 		return;
1002 	}
1003 
1004 	/* find the active uid */
1005 	q = getctladdr(a);
1006 	if (q == NULL)
1007 	{
1008 		user = NULL;
1009 		uid = 0;
1010 		gid = 0;
1011 	}
1012 	else
1013 	{
1014 		user = q->q_ruser != NULL ? q->q_ruser : q->q_user;
1015 		uid = q->q_uid;
1016 		gid = q->q_gid;
1017 	}
1018 	a = a->q_alias;
1019 
1020 	/* check to see if this is the same as last time */
1021 	if (lastctladdr != NULL && uid == lastuid &&
1022 	    strcmp(lastctladdr->q_paddr, a->q_paddr) == 0)
1023 		return;
1024 	lastuid = uid;
1025 	lastctladdr = a;
1026 
1027 	if (uid == 0 || user == NULL || user[0] == '\0')
1028 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "C");
1029 	else
1030 		(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "C%s:%ld:%ld",
1031 				     denlstring(user, true, false), (long) uid,
1032 				     (long) gid);
1033 	(void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, ":%s\n",
1034 			     denlstring(a->q_paddr, true, false));
1035 }
1036 
1037 /*
1038 **  RUNNERS_SIGTERM -- propagate a SIGTERM to queue runner process
1039 **
1040 **	This propagates the signal to the child processes that are queue
1041 **	runners. This is for a queue runner "cleanup". After all of the
1042 **	child queue runner processes are signaled (it should be SIGTERM
1043 **	being the sig) then the old signal handler (Oldsh) is called
1044 **	to handle any cleanup set for this process (provided it is not
1045 **	SIG_DFL or SIG_IGN). The signal may not be handled immediately
1046 **	if the BlockOldsh flag is set. If the current process doesn't
1047 **	have a parent then handle the signal immediately, regardless of
1048 **	BlockOldsh.
1049 **
1050 **	Parameters:
1051 **		sig -- the signal number being sent
1052 **
1053 **	Returns:
1054 **		none.
1055 **
1056 **	Side Effects:
1057 **		Sets the NoMoreRunners boolean to true to stop more runners
1058 **		from being started in runqueue().
1059 **
1060 **	NOTE:	THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
1061 **		ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1062 **		DOING.
1063 */
1064 
1065 static bool		volatile NoMoreRunners = false;
1066 static sigfunc_t	Oldsh_term = SIG_DFL;
1067 static sigfunc_t	Oldsh_hup = SIG_DFL;
1068 static sigfunc_t	volatile Oldsh = SIG_DFL;
1069 static bool		BlockOldsh = false;
1070 static int		volatile Oldsig = 0;
1071 static SIGFUNC_DECL	runners_sigterm __P((int));
1072 static SIGFUNC_DECL	runners_sighup __P((int));
1073 
1074 static SIGFUNC_DECL
runners_sigterm(sig)1075 runners_sigterm(sig)
1076 	int sig;
1077 {
1078 	int save_errno = errno;
1079 
1080 	FIX_SYSV_SIGNAL(sig, runners_sigterm);
1081 	errno = save_errno;
1082 	CHECK_CRITICAL(sig);
1083 	NoMoreRunners = true;
1084 	Oldsh = Oldsh_term;
1085 	Oldsig = sig;
1086 	proc_list_signal(PROC_QUEUE, sig);
1087 
1088 	if (!BlockOldsh || getppid() <= 1)
1089 	{
1090 		/* Check that a valid 'old signal handler' is callable */
1091 		if (Oldsh_term != SIG_DFL && Oldsh_term != SIG_IGN &&
1092 		    Oldsh_term != runners_sigterm)
1093 			(*Oldsh_term)(sig);
1094 	}
1095 	errno = save_errno;
1096 	return SIGFUNC_RETURN;
1097 }
1098 /*
1099 **  RUNNERS_SIGHUP -- propagate a SIGHUP to queue runner process
1100 **
1101 **	This propagates the signal to the child processes that are queue
1102 **	runners. This is for a queue runner "cleanup". After all of the
1103 **	child queue runner processes are signaled (it should be SIGHUP
1104 **	being the sig) then the old signal handler (Oldsh) is called to
1105 **	handle any cleanup set for this process (provided it is not SIG_DFL
1106 **	or SIG_IGN). The signal may not be handled immediately if the
1107 **	BlockOldsh flag is set. If the current process doesn't have
1108 **	a parent then handle the signal immediately, regardless of
1109 **	BlockOldsh.
1110 **
1111 **	Parameters:
1112 **		sig -- the signal number being sent
1113 **
1114 **	Returns:
1115 **		none.
1116 **
1117 **	Side Effects:
1118 **		Sets the NoMoreRunners boolean to true to stop more runners
1119 **		from being started in runqueue().
1120 **
1121 **	NOTE:	THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
1122 **		ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1123 **		DOING.
1124 */
1125 
1126 static SIGFUNC_DECL
runners_sighup(sig)1127 runners_sighup(sig)
1128 	int sig;
1129 {
1130 	int save_errno = errno;
1131 
1132 	FIX_SYSV_SIGNAL(sig, runners_sighup);
1133 	errno = save_errno;
1134 	CHECK_CRITICAL(sig);
1135 	NoMoreRunners = true;
1136 	Oldsh = Oldsh_hup;
1137 	Oldsig = sig;
1138 	proc_list_signal(PROC_QUEUE, sig);
1139 
1140 	if (!BlockOldsh || getppid() <= 1)
1141 	{
1142 		/* Check that a valid 'old signal handler' is callable */
1143 		if (Oldsh_hup != SIG_DFL && Oldsh_hup != SIG_IGN &&
1144 		    Oldsh_hup != runners_sighup)
1145 			(*Oldsh_hup)(sig);
1146 	}
1147 	errno = save_errno;
1148 	return SIGFUNC_RETURN;
1149 }
1150 /*
1151 **  MARK_WORK_GROUP_RESTART -- mark a work group as needing a restart
1152 **
1153 **  Sets a workgroup for restarting.
1154 **
1155 **	Parameters:
1156 **		wgrp -- the work group id to restart.
1157 **		reason -- why (signal?), -1 to turn off restart
1158 **
1159 **	Returns:
1160 **		none.
1161 **
1162 **	Side effects:
1163 **		May set global RestartWorkGroup to true.
1164 **
1165 **	NOTE:	THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
1166 **		ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1167 **		DOING.
1168 */
1169 
1170 void
mark_work_group_restart(wgrp,reason)1171 mark_work_group_restart(wgrp, reason)
1172 	int wgrp;
1173 	int reason;
1174 {
1175 	if (wgrp < 0 || wgrp > NumWorkGroups)
1176 		return;
1177 
1178 	WorkGrp[wgrp].wg_restart = reason;
1179 	if (reason >= 0)
1180 		RestartWorkGroup = true;
1181 }
1182 /*
1183 **  RESTART_MARKED_WORK_GROUPS -- restart work groups marked as needing restart
1184 **
1185 **  Restart any workgroup marked as needing a restart provided more
1186 **  runners are allowed.
1187 **
1188 **	Parameters:
1189 **		none.
1190 **
1191 **	Returns:
1192 **		none.
1193 **
1194 **	Side effects:
1195 **		Sets global RestartWorkGroup to false.
1196 */
1197 
1198 void
restart_marked_work_groups()1199 restart_marked_work_groups()
1200 {
1201 	int i;
1202 	int wasblocked;
1203 
1204 	if (NoMoreRunners)
1205 		return;
1206 
1207 	/* Block SIGCHLD so reapchild() doesn't mess with us */
1208 	wasblocked = sm_blocksignal(SIGCHLD);
1209 
1210 	for (i = 0; i < NumWorkGroups; i++)
1211 	{
1212 		if (WorkGrp[i].wg_restart >= 0)
1213 		{
1214 			if (LogLevel > 8)
1215 				sm_syslog(LOG_ERR, NOQID,
1216 					  "restart queue runner=%d due to signal 0x%x",
1217 					  i, WorkGrp[i].wg_restart);
1218 			restart_work_group(i);
1219 		}
1220 	}
1221 	RestartWorkGroup = false;
1222 
1223 	if (wasblocked == 0)
1224 		(void) sm_releasesignal(SIGCHLD);
1225 }
1226 /*
1227 **  RESTART_WORK_GROUP -- restart a specific work group
1228 **
1229 **  Restart a specific workgroup provided more runners are allowed.
1230 **  If the requested work group has been restarted too many times log
1231 **  this and refuse to restart.
1232 **
1233 **	Parameters:
1234 **		wgrp -- the work group id to restart
1235 **
1236 **	Returns:
1237 **		none.
1238 **
1239 **	Side Effects:
1240 **		starts another process doing the work of wgrp
1241 */
1242 
1243 #define MAX_PERSIST_RESTART	10	/* max allowed number of restarts */
1244 
1245 static void
restart_work_group(wgrp)1246 restart_work_group(wgrp)
1247 	int wgrp;
1248 {
1249 	if (NoMoreRunners ||
1250 	    wgrp < 0 || wgrp > NumWorkGroups)
1251 		return;
1252 
1253 	WorkGrp[wgrp].wg_restart = -1;
1254 	if (WorkGrp[wgrp].wg_restartcnt < MAX_PERSIST_RESTART)
1255 	{
1256 		/* avoid overflow; increment here */
1257 		WorkGrp[wgrp].wg_restartcnt++;
1258 		(void) run_work_group(wgrp, RWG_FORK|RWG_PERSISTENT|RWG_RUNALL);
1259 	}
1260 	else
1261 	{
1262 		sm_syslog(LOG_ERR, NOQID,
1263 			  "ERROR: persistent queue runner=%d restarted too many times, queue runner lost",
1264 			  wgrp);
1265 	}
1266 }
1267 /*
1268 **  SCHEDULE_QUEUE_RUNS -- schedule the next queue run for a work group.
1269 **
1270 **	Parameters:
1271 **		runall -- schedule even if individual bit is not set.
1272 **		wgrp -- the work group id to schedule.
1273 **		didit -- the queue run was performed for this work group.
1274 **
1275 **	Returns:
1276 **		nothing
1277 */
1278 
1279 #define INCR_MOD(v, m)	if (++v >= m)	\
1280 				v = 0;	\
1281 			else
1282 
1283 static void
schedule_queue_runs(runall,wgrp,didit)1284 schedule_queue_runs(runall, wgrp, didit)
1285 	bool runall;
1286 	int wgrp;
1287 	bool didit;
1288 {
1289 	int qgrp, cgrp, endgrp;
1290 #if _FFR_QUEUE_SCHED_DBG
1291 	time_t lastsched;
1292 	bool sched;
1293 #endif /* _FFR_QUEUE_SCHED_DBG */
1294 	time_t now;
1295 	time_t minqintvl;
1296 
1297 	/*
1298 	**  This is a bit ugly since we have to duplicate the
1299 	**  code that "walks" through a work queue group.
1300 	*/
1301 
1302 	now = curtime();
1303 	minqintvl = 0;
1304 	cgrp = endgrp = WorkGrp[wgrp].wg_curqgrp;
1305 	do
1306 	{
1307 		time_t qintvl;
1308 
1309 #if _FFR_QUEUE_SCHED_DBG
1310 		lastsched = 0;
1311 		sched = false;
1312 #endif /* _FFR_QUEUE_SCHED_DBG */
1313 		qgrp = WorkGrp[wgrp].wg_qgs[cgrp]->qg_index;
1314 		if (Queue[qgrp]->qg_queueintvl > 0)
1315 			qintvl = Queue[qgrp]->qg_queueintvl;
1316 		else if (QueueIntvl > 0)
1317 			qintvl = QueueIntvl;
1318 		else
1319 			qintvl = (time_t) 0;
1320 #if _FFR_QUEUE_SCHED_DBG
1321 		lastsched = Queue[qgrp]->qg_nextrun;
1322 #endif /* _FFR_QUEUE_SCHED_DBG */
1323 		if ((runall || Queue[qgrp]->qg_nextrun <= now) && qintvl > 0)
1324 		{
1325 #if _FFR_QUEUE_SCHED_DBG
1326 			sched = true;
1327 #endif /* _FFR_QUEUE_SCHED_DBG */
1328 			if (minqintvl == 0 || qintvl < minqintvl)
1329 				minqintvl = qintvl;
1330 
1331 			/*
1332 			**  Only set a new time if a queue run was performed
1333 			**  for this queue group.  If the queue was not run,
1334 			**  we could starve it by setting a new time on each
1335 			**  call.
1336 			*/
1337 
1338 			if (didit)
1339 				Queue[qgrp]->qg_nextrun += qintvl;
1340 		}
1341 #if _FFR_QUEUE_SCHED_DBG
1342 		if (tTd(69, 10))
1343 			sm_syslog(LOG_INFO, NOQID,
1344 				"sqr: wgrp=%d, cgrp=%d, qgrp=%d, intvl=%ld, QI=%ld, runall=%d, lastrun=%ld, nextrun=%ld, sched=%d",
1345 				wgrp, cgrp, qgrp, Queue[qgrp]->qg_queueintvl,
1346 				QueueIntvl, runall, lastsched,
1347 				Queue[qgrp]->qg_nextrun, sched);
1348 #endif /* _FFR_QUEUE_SCHED_DBG */
1349 		INCR_MOD(cgrp, WorkGrp[wgrp].wg_numqgrp);
1350 	} while (endgrp != cgrp);
1351 	if (minqintvl > 0)
1352 		(void) sm_setevent(minqintvl, runqueueevent, 0);
1353 }
1354 
1355 #if _FFR_QUEUE_RUN_PARANOIA
1356 /*
1357 **  CHECKQUEUERUNNER -- check whether a queue group hasn't been run.
1358 **
1359 **	Use this if events may get lost and hence queue runners may not
1360 **	be started and mail will pile up in a queue.
1361 **
1362 **	Parameters:
1363 **		none.
1364 **
1365 **	Returns:
1366 **		true if a queue run is necessary.
1367 **
1368 **	Side Effects:
1369 **		may schedule a queue run.
1370 */
1371 
1372 bool
checkqueuerunner()1373 checkqueuerunner()
1374 {
1375 	int qgrp;
1376 	time_t now, minqintvl;
1377 
1378 	now = curtime();
1379 	minqintvl = 0;
1380 	for (qgrp = 0; qgrp < NumQueue && Queue[qgrp] != NULL; qgrp++)
1381 	{
1382 		time_t qintvl;
1383 
1384 		if (Queue[qgrp]->qg_queueintvl > 0)
1385 			qintvl = Queue[qgrp]->qg_queueintvl;
1386 		else if (QueueIntvl > 0)
1387 			qintvl = QueueIntvl;
1388 		else
1389 			qintvl = (time_t) 0;
1390 		if (Queue[qgrp]->qg_nextrun <= now - qintvl)
1391 		{
1392 			if (minqintvl == 0 || qintvl < minqintvl)
1393 				minqintvl = qintvl;
1394 			if (LogLevel > 1)
1395 				sm_syslog(LOG_WARNING, NOQID,
1396 					"checkqueuerunner: queue %d should have been run at %s, queue interval %ld",
1397 					qgrp,
1398 					arpadate(ctime(&Queue[qgrp]->qg_nextrun)),
1399 					qintvl);
1400 		}
1401 	}
1402 	if (minqintvl > 0)
1403 	{
1404 		(void) sm_setevent(minqintvl, runqueueevent, 0);
1405 		return true;
1406 	}
1407 	return false;
1408 }
1409 #endif /* _FFR_QUEUE_RUN_PARANOIA */
1410 
1411 /*
1412 **  RUNQUEUE -- run the jobs in the queue.
1413 **
1414 **	Gets the stuff out of the queue in some presumably logical
1415 **	order and processes them.
1416 **
1417 **	Parameters:
1418 **		forkflag -- true if the queue scanning should be done in
1419 **			a child process.  We double-fork so it is not our
1420 **			child and we don't have to clean up after it.
1421 **			false can be ignored if we have multiple queues.
1422 **		verbose -- if true, print out status information.
1423 **		persistent -- persistent queue runner?
1424 **		runall -- run all groups or only a subset (DoQueueRun)?
1425 **
1426 **	Returns:
1427 **		true if the queue run successfully began.
1428 **
1429 **	Side Effects:
1430 **		runs things in the mail queue using run_work_group().
1431 **		maybe schedules next queue run.
1432 */
1433 
1434 static ENVELOPE	QueueEnvelope;		/* the queue run envelope */
1435 static time_t	LastQueueTime = 0;	/* last time a queue ID assigned */
1436 static pid_t	LastQueuePid = -1;	/* last PID which had a queue ID */
1437 
1438 /* values for qp_supdirs */
1439 #define QP_NOSUB	0x0000	/* No subdirectories */
1440 #define QP_SUBDF	0x0001	/* "df" subdirectory */
1441 #define QP_SUBQF	0x0002	/* "qf" subdirectory */
1442 #define QP_SUBXF	0x0004	/* "xf" subdirectory */
1443 
1444 bool
runqueue(forkflag,verbose,persistent,runall)1445 runqueue(forkflag, verbose, persistent, runall)
1446 	bool forkflag;
1447 	bool verbose;
1448 	bool persistent;
1449 	bool runall;
1450 {
1451 	int i;
1452 	bool ret = true;
1453 	static int curnum = 0;
1454 	sigfunc_t cursh;
1455 #if SM_HEAP_CHECK
1456 	SM_NONVOLATILE int oldgroup = 0;
1457 
1458 	if (sm_debug_active(&DebugLeakQ, 1))
1459 	{
1460 		oldgroup = sm_heap_group();
1461 		sm_heap_newgroup();
1462 		sm_dprintf("runqueue() heap group #%d\n", sm_heap_group());
1463 	}
1464 #endif /* SM_HEAP_CHECK */
1465 
1466 	/* queue run has been started, don't do any more this time */
1467 	DoQueueRun = false;
1468 
1469 	/* more than one queue or more than one directory per queue */
1470 	if (!forkflag && !verbose &&
1471 	    (WorkGrp[0].wg_qgs[0]->qg_numqueues > 1 || NumWorkGroups > 1 ||
1472 	     WorkGrp[0].wg_numqgrp > 1))
1473 		forkflag = true;
1474 
1475 	/*
1476 	**  For controlling queue runners via signals sent to this process.
1477 	**  Oldsh* will get called too by runners_sig* (if it is not SIG_IGN
1478 	**  or SIG_DFL) to preserve cleanup behavior. Now that this process
1479 	**  will have children (and perhaps grandchildren) this handler will
1480 	**  be left in place. This is because this process, once it has
1481 	**  finished spinning off queue runners, may go back to doing something
1482 	**  else (like being a daemon). And we still want on a SIG{TERM,HUP} to
1483 	**  clean up the child queue runners. Only install 'runners_sig*' once
1484 	**  else we'll get stuck looping forever.
1485 	*/
1486 
1487 	cursh = sm_signal(SIGTERM, runners_sigterm);
1488 	if (cursh != runners_sigterm)
1489 		Oldsh_term = cursh;
1490 	cursh = sm_signal(SIGHUP, runners_sighup);
1491 	if (cursh != runners_sighup)
1492 		Oldsh_hup = cursh;
1493 
1494 	for (i = 0; i < NumWorkGroups && !NoMoreRunners; i++)
1495 	{
1496 		int rwgflags = RWG_NONE;
1497 
1498 		/*
1499 		**  If MaxQueueChildren active then test whether the start
1500 		**  of the next queue group's additional queue runners (maximum)
1501 		**  will result in MaxQueueChildren being exceeded.
1502 		**
1503 		**  Note: do not use continue; even though another workgroup
1504 		**	may have fewer queue runners, this would be "unfair",
1505 		**	i.e., this work group might "starve" then.
1506 		*/
1507 
1508 #if _FFR_QUEUE_SCHED_DBG
1509 		if (tTd(69, 10))
1510 			sm_syslog(LOG_INFO, NOQID,
1511 				"rq: curnum=%d, MaxQueueChildren=%d, CurRunners=%d, WorkGrp[curnum].wg_maxact=%d",
1512 				curnum, MaxQueueChildren, CurRunners,
1513 				WorkGrp[curnum].wg_maxact);
1514 #endif /* _FFR_QUEUE_SCHED_DBG */
1515 		if (MaxQueueChildren > 0 &&
1516 		    CurRunners + WorkGrp[curnum].wg_maxact > MaxQueueChildren)
1517 			break;
1518 
1519 		/*
1520 		**  Pick up where we left off (curnum), in case we
1521 		**  used up all the children last time without finishing.
1522 		**  This give a round-robin fairness to queue runs.
1523 		**
1524 		**  Increment CurRunners before calling run_work_group()
1525 		**  to avoid a "race condition" with proc_list_drop() which
1526 		**  decrements CurRunners if the queue runners terminate.
1527 		**  Notice: CurRunners is an upper limit, in some cases
1528 		**  (too few jobs in the queue) this value is larger than
1529 		**  the actual number of queue runners. The discrepancy can
1530 		**  increase if some queue runners "hang" for a long time.
1531 		*/
1532 
1533 		CurRunners += WorkGrp[curnum].wg_maxact;
1534 		if (forkflag)
1535 			rwgflags |= RWG_FORK;
1536 		if (verbose)
1537 			rwgflags |= RWG_VERBOSE;
1538 		if (persistent)
1539 			rwgflags |= RWG_PERSISTENT;
1540 		if (runall)
1541 			rwgflags |= RWG_RUNALL;
1542 		ret = run_work_group(curnum, rwgflags);
1543 
1544 		/*
1545 		**  Failure means a message was printed for ETRN
1546 		**  and subsequent queues are likely to fail as well.
1547 		**  Decrement CurRunners in that case because
1548 		**  none have been started.
1549 		*/
1550 
1551 		if (!ret)
1552 		{
1553 			CurRunners -= WorkGrp[curnum].wg_maxact;
1554 			break;
1555 		}
1556 
1557 		if (!persistent)
1558 			schedule_queue_runs(runall, curnum, true);
1559 		INCR_MOD(curnum, NumWorkGroups);
1560 	}
1561 
1562 	/* schedule left over queue runs */
1563 	if (i < NumWorkGroups && !NoMoreRunners && !persistent)
1564 	{
1565 		int h;
1566 
1567 		for (h = curnum; i < NumWorkGroups; i++)
1568 		{
1569 			schedule_queue_runs(runall, h, false);
1570 			INCR_MOD(h, NumWorkGroups);
1571 		}
1572 	}
1573 
1574 
1575 #if SM_HEAP_CHECK
1576 	if (sm_debug_active(&DebugLeakQ, 1))
1577 		sm_heap_setgroup(oldgroup);
1578 #endif /* SM_HEAP_CHECK */
1579 	return ret;
1580 }
1581 
1582 #if _FFR_SKIP_DOMAINS
1583 /*
1584 **  SKIP_DOMAINS -- Skip 'skip' number of domains in the WorkQ.
1585 **
1586 **  Added by Stephen Frost <sfrost@snowman.net> to support
1587 **  having each runner process every N'th domain instead of
1588 **  every N'th message.
1589 **
1590 **	Parameters:
1591 **		skip -- number of domains in WorkQ to skip.
1592 **
1593 **	Returns:
1594 **		total number of messages skipped.
1595 **
1596 **	Side Effects:
1597 **		may change WorkQ
1598 */
1599 
1600 static int
skip_domains(skip)1601 skip_domains(skip)
1602 	int skip;
1603 {
1604 	int n, seqjump;
1605 
1606 	for (n = 0, seqjump = 0; n < skip && WorkQ != NULL; seqjump++)
1607 	{
1608 		if (WorkQ->w_next != NULL)
1609 		{
1610 			if (WorkQ->w_host != NULL &&
1611 			    WorkQ->w_next->w_host != NULL)
1612 			{
1613 				if (sm_strcasecmp(WorkQ->w_host,
1614 						WorkQ->w_next->w_host) != 0)
1615 					n++;
1616 			}
1617 			else
1618 			{
1619 				if ((WorkQ->w_host != NULL &&
1620 				     WorkQ->w_next->w_host == NULL) ||
1621 				    (WorkQ->w_host == NULL &&
1622 				     WorkQ->w_next->w_host != NULL))
1623 					     n++;
1624 			}
1625 		}
1626 		WorkQ = WorkQ->w_next;
1627 	}
1628 	return seqjump;
1629 }
1630 #endif /* _FFR_SKIP_DOMAINS */
1631 
1632 /*
1633 **  RUNNER_WORK -- have a queue runner do its work
1634 **
1635 **  Have a queue runner do its work a list of entries.
1636 **  When work isn't directly being done then this process can take a signal
1637 **  and terminate immediately (in a clean fashion of course).
1638 **  When work is directly being done, it's not to be interrupted
1639 **  immediately: the work should be allowed to finish at a clean point
1640 **  before termination (in a clean fashion of course).
1641 **
1642 **	Parameters:
1643 **		e -- envelope.
1644 **		sequenceno -- 'th process to run WorkQ.
1645 **		didfork -- did the calling process fork()?
1646 **		skip -- process only each skip'th item.
1647 **		njobs -- number of jobs in WorkQ.
1648 **
1649 **	Returns:
1650 **		none.
1651 **
1652 **	Side Effects:
1653 **		runs things in the mail queue.
1654 */
1655 
1656 static void
runner_work(e,sequenceno,didfork,skip,njobs)1657 runner_work(e, sequenceno, didfork, skip, njobs)
1658 	register ENVELOPE *e;
1659 	int sequenceno;
1660 	bool didfork;
1661 	int skip;
1662 	int njobs;
1663 {
1664 	int n, seqjump;
1665 	WORK *w;
1666 	time_t now;
1667 
1668 	SM_GET_LA(now);
1669 
1670 	/*
1671 	**  Here we temporarily block the second calling of the handlers.
1672 	**  This allows us to handle the signal without terminating in the
1673 	**  middle of direct work. If a signal does come, the test for
1674 	**  NoMoreRunners will find it.
1675 	*/
1676 
1677 	BlockOldsh = true;
1678 	seqjump = skip;
1679 
1680 	/* process them once at a time */
1681 	while (WorkQ != NULL)
1682 	{
1683 #if SM_HEAP_CHECK
1684 		SM_NONVOLATILE int oldgroup = 0;
1685 
1686 		if (sm_debug_active(&DebugLeakQ, 1))
1687 		{
1688 			oldgroup = sm_heap_group();
1689 			sm_heap_newgroup();
1690 			sm_dprintf("run_queue_group() heap group #%d\n",
1691 				sm_heap_group());
1692 		}
1693 #endif /* SM_HEAP_CHECK */
1694 
1695 		/* do no more work */
1696 		if (NoMoreRunners)
1697 		{
1698 			/* Check that a valid signal handler is callable */
1699 			if (Oldsh != SIG_DFL && Oldsh != SIG_IGN &&
1700 			    Oldsh != runners_sighup &&
1701 			    Oldsh != runners_sigterm)
1702 				(*Oldsh)(Oldsig);
1703 			break;
1704 		}
1705 
1706 		w = WorkQ; /* assign current work item */
1707 
1708 		/*
1709 		**  Set the head of the WorkQ to the next work item.
1710 		**  It is set 'skip' ahead (the number of parallel queue
1711 		**  runners working on WorkQ together) since each runner
1712 		**  works on every 'skip'th (N-th) item.
1713 #if _FFR_SKIP_DOMAINS
1714 		**  In the case of the BYHOST Queue Sort Order, the 'item'
1715 		**  is a domain, so we work on every 'skip'th (N-th) domain.
1716 #endif * _FFR_SKIP_DOMAINS *
1717 		*/
1718 
1719 #if _FFR_SKIP_DOMAINS
1720 		if (QueueSortOrder == QSO_BYHOST)
1721 		{
1722 			seqjump = 1;
1723 			if (WorkQ->w_next != NULL)
1724 			{
1725 				if (WorkQ->w_host != NULL &&
1726 				    WorkQ->w_next->w_host != NULL)
1727 				{
1728 					if (sm_strcasecmp(WorkQ->w_host,
1729 							WorkQ->w_next->w_host)
1730 								!= 0)
1731 						seqjump = skip_domains(skip);
1732 					else
1733 						WorkQ = WorkQ->w_next;
1734 				}
1735 				else
1736 				{
1737 					if ((WorkQ->w_host != NULL &&
1738 					     WorkQ->w_next->w_host == NULL) ||
1739 					    (WorkQ->w_host == NULL &&
1740 					     WorkQ->w_next->w_host != NULL))
1741 						seqjump = skip_domains(skip);
1742 					else
1743 						WorkQ = WorkQ->w_next;
1744 				}
1745 			}
1746 			else
1747 				WorkQ = WorkQ->w_next;
1748 		}
1749 		else
1750 #endif /* _FFR_SKIP_DOMAINS */
1751 		{
1752 			for (n = 0; n < skip && WorkQ != NULL; n++)
1753 				WorkQ = WorkQ->w_next;
1754 		}
1755 
1756 		e->e_to = NULL;
1757 
1758 		/*
1759 		**  Ignore jobs that are too expensive for the moment.
1760 		**
1761 		**	Get new load average every GET_NEW_LA_TIME seconds.
1762 		*/
1763 
1764 		SM_GET_LA(now);
1765 		if (shouldqueue(WkRecipFact, Current_LA_time))
1766 		{
1767 			char *msg = "Aborting queue run: load average too high";
1768 
1769 			if (Verbose)
1770 				message("%s", msg);
1771 			if (LogLevel > 8)
1772 				sm_syslog(LOG_INFO, NOQID, "runqueue: %s", msg);
1773 			break;
1774 		}
1775 		if (shouldqueue(w->w_pri, w->w_ctime))
1776 		{
1777 			if (Verbose)
1778 				message(EmptyString);
1779 			if (QueueSortOrder == QSO_BYPRIORITY)
1780 			{
1781 				if (Verbose)
1782 					message("Skipping %s/%s (sequence %d of %d) and flushing rest of queue",
1783 						qid_printqueue(w->w_qgrp,
1784 							       w->w_qdir),
1785 						w->w_name + 2, sequenceno,
1786 						njobs);
1787 				if (LogLevel > 8)
1788 					sm_syslog(LOG_INFO, NOQID,
1789 						  "runqueue: Flushing queue from %s/%s (pri %ld, LA %d, %d of %d)",
1790 						  qid_printqueue(w->w_qgrp,
1791 								 w->w_qdir),
1792 						  w->w_name + 2, w->w_pri,
1793 						  CurrentLA, sequenceno,
1794 						  njobs);
1795 				break;
1796 			}
1797 			else if (Verbose)
1798 				message("Skipping %s/%s (sequence %d of %d)",
1799 					qid_printqueue(w->w_qgrp, w->w_qdir),
1800 					w->w_name + 2, sequenceno, njobs);
1801 		}
1802 		else
1803 		{
1804 			if (Verbose)
1805 			{
1806 				message(EmptyString);
1807 				message("Running %s/%s (sequence %d of %d)",
1808 					qid_printqueue(w->w_qgrp, w->w_qdir),
1809 					w->w_name + 2, sequenceno, njobs);
1810 			}
1811 			if (didfork && MaxQueueChildren > 0)
1812 			{
1813 				sm_blocksignal(SIGCHLD);
1814 				(void) sm_signal(SIGCHLD, reapchild);
1815 			}
1816 			if (tTd(63, 100))
1817 				sm_syslog(LOG_DEBUG, NOQID,
1818 					  "runqueue %s dowork(%s)",
1819 					  qid_printqueue(w->w_qgrp, w->w_qdir),
1820 					  w->w_name + 2);
1821 
1822 			(void) dowork(w->w_qgrp, w->w_qdir, w->w_name + 2,
1823 				      ForkQueueRuns, false, e);
1824 			errno = 0;
1825 		}
1826 		sm_free(w->w_name); /* XXX */
1827 		if (w->w_host != NULL)
1828 			sm_free(w->w_host); /* XXX */
1829 		sm_free((char *) w); /* XXX */
1830 		sequenceno += seqjump; /* next sequence number */
1831 #if SM_HEAP_CHECK
1832 		if (sm_debug_active(&DebugLeakQ, 1))
1833 			sm_heap_setgroup(oldgroup);
1834 #endif /* SM_HEAP_CHECK */
1835 	}
1836 
1837 	BlockOldsh = false;
1838 
1839 	/* check the signals didn't happen during the revert */
1840 	if (NoMoreRunners)
1841 	{
1842 		/* Check that a valid signal handler is callable */
1843 		if (Oldsh != SIG_DFL && Oldsh != SIG_IGN &&
1844 		    Oldsh != runners_sighup && Oldsh != runners_sigterm)
1845 			(*Oldsh)(Oldsig);
1846 	}
1847 
1848 	Oldsh = SIG_DFL; /* after the NoMoreRunners check */
1849 }
1850 /*
1851 **  RUN_WORK_GROUP -- run the jobs in a queue group from a work group.
1852 **
1853 **	Gets the stuff out of the queue in some presumably logical
1854 **	order and processes them.
1855 **
1856 **	Parameters:
1857 **		wgrp -- work group to process.
1858 **		flags -- RWG_* flags
1859 **
1860 **	Returns:
1861 **		true if the queue run successfully began.
1862 **
1863 **	Side Effects:
1864 **		runs things in the mail queue.
1865 */
1866 
1867 /* Minimum sleep time for persistent queue runners */
1868 #define MIN_SLEEP_TIME	5
1869 
1870 bool
run_work_group(wgrp,flags)1871 run_work_group(wgrp, flags)
1872 	int wgrp;
1873 	int flags;
1874 {
1875 	register ENVELOPE *e;
1876 	int njobs, qdir;
1877 	int sequenceno = 1;
1878 	int qgrp, endgrp, h, i;
1879 	time_t now;
1880 	bool full, more;
1881 	SM_RPOOL_T *rpool;
1882 	extern ENVELOPE BlankEnvelope;
1883 	extern SIGFUNC_DECL reapchild __P((int));
1884 
1885 	if (wgrp < 0)
1886 		return false;
1887 
1888 	/*
1889 	**  If no work will ever be selected, don't even bother reading
1890 	**  the queue.
1891 	*/
1892 
1893 	SM_GET_LA(now);
1894 
1895 	if (!bitset(RWG_PERSISTENT, flags) &&
1896 	    shouldqueue(WkRecipFact, Current_LA_time))
1897 	{
1898 		char *msg = "Skipping queue run -- load average too high";
1899 
1900 		if (bitset(RWG_VERBOSE, flags))
1901 			message("458 %s\n", msg);
1902 		if (LogLevel > 8)
1903 			sm_syslog(LOG_INFO, NOQID, "runqueue: %s", msg);
1904 		return false;
1905 	}
1906 
1907 	/*
1908 	**  See if we already have too many children.
1909 	*/
1910 
1911 	if (bitset(RWG_FORK, flags) &&
1912 	    WorkGrp[wgrp].wg_lowqintvl > 0 &&
1913 	    !bitset(RWG_PERSISTENT, flags) &&
1914 	    MaxChildren > 0 && CurChildren >= MaxChildren)
1915 	{
1916 		char *msg = "Skipping queue run -- too many children";
1917 
1918 		if (bitset(RWG_VERBOSE, flags))
1919 			message("458 %s (%d)\n", msg, CurChildren);
1920 		if (LogLevel > 8)
1921 			sm_syslog(LOG_INFO, NOQID, "runqueue: %s (%d)",
1922 				  msg, CurChildren);
1923 		return false;
1924 	}
1925 
1926 	/*
1927 	**  See if we want to go off and do other useful work.
1928 	*/
1929 
1930 	if (bitset(RWG_FORK, flags))
1931 	{
1932 		pid_t pid;
1933 
1934 		(void) sm_blocksignal(SIGCHLD);
1935 		(void) sm_signal(SIGCHLD, reapchild);
1936 
1937 		pid = dofork();
1938 		if (pid == -1)
1939 		{
1940 			const char *msg = "Skipping queue run -- fork() failed";
1941 			const char *err = sm_errstring(errno);
1942 
1943 			if (bitset(RWG_VERBOSE, flags))
1944 				message("458 %s: %s\n", msg, err);
1945 			if (LogLevel > 8)
1946 				sm_syslog(LOG_INFO, NOQID, "runqueue: %s: %s",
1947 					  msg, err);
1948 			(void) sm_releasesignal(SIGCHLD);
1949 			return false;
1950 		}
1951 		if (pid != 0)
1952 		{
1953 			/* parent -- pick up intermediate zombie */
1954 			(void) sm_blocksignal(SIGALRM);
1955 
1956 			/* wgrp only used when queue runners are persistent */
1957 			proc_list_add(pid, "Queue runner", PROC_QUEUE,
1958 				      WorkGrp[wgrp].wg_maxact,
1959 				      bitset(RWG_PERSISTENT, flags) ? wgrp : -1,
1960 				      NULL);
1961 			(void) sm_releasesignal(SIGALRM);
1962 			(void) sm_releasesignal(SIGCHLD);
1963 			return true;
1964 		}
1965 
1966 		/* child -- clean up signals */
1967 
1968 		/* Reset global flags */
1969 		RestartRequest = NULL;
1970 		RestartWorkGroup = false;
1971 		ShutdownRequest = NULL;
1972 		PendingSignal = 0;
1973 		CurrentPid = getpid();
1974 		close_sendmail_pid();
1975 
1976 		/*
1977 		**  Initialize exception stack and default exception
1978 		**  handler for child process.
1979 		*/
1980 
1981 		sm_exc_newthread(fatal_error);
1982 		clrcontrol();
1983 		proc_list_clear();
1984 
1985 		/* Add parent process as first child item */
1986 		proc_list_add(CurrentPid, "Queue runner child process",
1987 			      PROC_QUEUE_CHILD, 0, -1, NULL);
1988 		(void) sm_releasesignal(SIGCHLD);
1989 		(void) sm_signal(SIGCHLD, SIG_DFL);
1990 		(void) sm_signal(SIGHUP, SIG_DFL);
1991 		(void) sm_signal(SIGTERM, intsig);
1992 	}
1993 
1994 	/*
1995 	**  Release any resources used by the daemon code.
1996 	*/
1997 
1998 	clrdaemon();
1999 
2000 	/* force it to run expensive jobs */
2001 	NoConnect = false;
2002 
2003 	/* drop privileges */
2004 	if (geteuid() == (uid_t) 0)
2005 		(void) drop_privileges(false);
2006 
2007 	/*
2008 	**  Create ourselves an envelope
2009 	*/
2010 
2011 	CurEnv = &QueueEnvelope;
2012 	rpool = sm_rpool_new_x(NULL);
2013 	e = newenvelope(&QueueEnvelope, CurEnv, rpool);
2014 	e->e_flags = BlankEnvelope.e_flags;
2015 	e->e_parent = NULL;
2016 
2017 	/* make sure we have disconnected from parent */
2018 	if (bitset(RWG_FORK, flags))
2019 	{
2020 		disconnect(1, e);
2021 		QuickAbort = false;
2022 	}
2023 
2024 	/*
2025 	**  If we are running part of the queue, always ignore stored
2026 	**  host status.
2027 	*/
2028 
2029 	if (QueueLimitId != NULL || QueueLimitSender != NULL ||
2030 	    QueueLimitQuarantine != NULL ||
2031 	    QueueLimitRecipient != NULL)
2032 	{
2033 		IgnoreHostStatus = true;
2034 		MinQueueAge = 0;
2035 	}
2036 
2037 	/*
2038 	**  Here is where we choose the queue group from the work group.
2039 	**  The caller of the "domorework" label must setup a new envelope.
2040 	*/
2041 
2042 	endgrp = WorkGrp[wgrp].wg_curqgrp; /* to not spin endlessly */
2043 
2044   domorework:
2045 
2046 	/*
2047 	**  Run a queue group if:
2048 	**  RWG_RUNALL bit is set or the bit for this group is set.
2049 	*/
2050 
2051 	now = curtime();
2052 	for (;;)
2053 	{
2054 		/*
2055 		**  Find the next queue group within the work group that
2056 		**  has been marked as needing a run.
2057 		*/
2058 
2059 		qgrp = WorkGrp[wgrp].wg_qgs[WorkGrp[wgrp].wg_curqgrp]->qg_index;
2060 		WorkGrp[wgrp].wg_curqgrp++; /* advance */
2061 		WorkGrp[wgrp].wg_curqgrp %= WorkGrp[wgrp].wg_numqgrp; /* wrap */
2062 		if (bitset(RWG_RUNALL, flags) ||
2063 		    (Queue[qgrp]->qg_nextrun <= now &&
2064 		     Queue[qgrp]->qg_nextrun != (time_t) -1))
2065 			break;
2066 		if (endgrp == WorkGrp[wgrp].wg_curqgrp)
2067 		{
2068 			e->e_id = NULL;
2069 			if (bitset(RWG_FORK, flags))
2070 				finis(true, true, ExitStat);
2071 			return true; /* we're done */
2072 		}
2073 	}
2074 
2075 	qdir = Queue[qgrp]->qg_curnum; /* round-robin init of queue position */
2076 #if _FFR_QUEUE_SCHED_DBG
2077 	if (tTd(69, 12))
2078 		sm_syslog(LOG_INFO, NOQID,
2079 			"rwg: wgrp=%d, qgrp=%d, qdir=%d, name=%s, curqgrp=%d, numgrps=%d",
2080 			wgrp, qgrp, qdir, qid_printqueue(qgrp, qdir),
2081 			WorkGrp[wgrp].wg_curqgrp, WorkGrp[wgrp].wg_numqgrp);
2082 #endif /* _FFR_QUEUE_SCHED_DBG */
2083 
2084 #if HASNICE
2085 	/* tweak niceness of queue runs */
2086 	if (Queue[qgrp]->qg_nice > 0)
2087 		(void) nice(Queue[qgrp]->qg_nice);
2088 #endif /* HASNICE */
2089 
2090 	/* XXX running queue group... */
2091 	sm_setproctitle(true, CurEnv, "running queue: %s",
2092 			qid_printqueue(qgrp, qdir));
2093 
2094 	if (LogLevel > 69 || tTd(63, 99))
2095 		sm_syslog(LOG_DEBUG, NOQID,
2096 			  "runqueue %s, pid=%d, forkflag=%d",
2097 			  qid_printqueue(qgrp, qdir), (int) CurrentPid,
2098 			  bitset(RWG_FORK, flags));
2099 
2100 	/*
2101 	**  Start making passes through the queue.
2102 	**	First, read and sort the entire queue.
2103 	**	Then, process the work in that order.
2104 	**		But if you take too long, start over.
2105 	*/
2106 
2107 	for (i = 0; i < Queue[qgrp]->qg_numqueues; i++)
2108 	{
2109 		(void) gatherq(qgrp, qdir, false, &full, &more, &h);
2110 #if SM_CONF_SHM
2111 		if (ShmId != SM_SHM_NO_ID)
2112 			QSHM_ENTRIES(Queue[qgrp]->qg_qpaths[qdir].qp_idx) = h;
2113 #endif /* SM_CONF_SHM */
2114 		/* If there are no more items in this queue advance */
2115 		if (!more)
2116 		{
2117 			/* A round-robin advance */
2118 			qdir++;
2119 			qdir %= Queue[qgrp]->qg_numqueues;
2120 		}
2121 
2122 		/* Has the WorkList reached the limit? */
2123 		if (full)
2124 			break; /* don't try to gather more */
2125 	}
2126 
2127 	/* order the existing work requests */
2128 	njobs = sortq(Queue[qgrp]->qg_maxlist);
2129 	Queue[qgrp]->qg_curnum = qdir; /* update */
2130 
2131 
2132 	if (!Verbose && bitnset(QD_FORK, Queue[qgrp]->qg_flags))
2133 	{
2134 		int loop, maxrunners;
2135 		pid_t pid;
2136 
2137 		/*
2138 		**  For this WorkQ we want to fork off N children (maxrunners)
2139 		**  at this point. Each child has a copy of WorkQ. Each child
2140 		**  will process every N-th item. The parent will wait for all
2141 		**  of the children to finish before moving on to the next
2142 		**  queue group within the work group. This saves us forking
2143 		**  a new runner-child for each work item.
2144 		**  It's valid for qg_maxqrun == 0 since this may be an
2145 		**  explicit "don't run this queue" setting.
2146 		*/
2147 
2148 		maxrunners = Queue[qgrp]->qg_maxqrun;
2149 
2150 		/*
2151 		**  If no runners are configured for this group but
2152 		**  the queue is "forced" then lets use 1 runner.
2153 		*/
2154 
2155 		if (maxrunners == 0 && bitset(RWG_FORCE, flags))
2156 			maxrunners = 1;
2157 
2158 		/* No need to have more runners then there are jobs */
2159 		if (maxrunners > njobs)
2160 			maxrunners = njobs;
2161 		for (loop = 0; loop < maxrunners; loop++)
2162 		{
2163 			/*
2164 			**  Since the delivery may happen in a child and the
2165 			**  parent does not wait, the parent may close the
2166 			**  maps thereby removing any shared memory used by
2167 			**  the map.  Therefore, close the maps now so the
2168 			**  child will dynamically open them if necessary.
2169 			*/
2170 
2171 			closemaps(false);
2172 
2173 			pid = fork();
2174 			if (pid < 0)
2175 			{
2176 				syserr("run_work_group: cannot fork");
2177 				return false;
2178 			}
2179 			else if (pid > 0)
2180 			{
2181 				/* parent -- clean out connection cache */
2182 				mci_flush(false, NULL);
2183 #if _FFR_SKIP_DOMAINS
2184 				if (QueueSortOrder == QSO_BYHOST)
2185 				{
2186 					sequenceno += skip_domains(1);
2187 				}
2188 				else
2189 #endif /* _FFR_SKIP_DOMAINS */
2190 				{
2191 					/* for the skip */
2192 					WorkQ = WorkQ->w_next;
2193 					sequenceno++;
2194 				}
2195 				proc_list_add(pid, "Queue child runner process",
2196 					      PROC_QUEUE_CHILD, 0, -1, NULL);
2197 
2198 				/* No additional work, no additional runners */
2199 				if (WorkQ == NULL)
2200 					break;
2201 			}
2202 			else
2203 			{
2204 				/* child -- Reset global flags */
2205 				RestartRequest = NULL;
2206 				RestartWorkGroup = false;
2207 				ShutdownRequest = NULL;
2208 				PendingSignal = 0;
2209 				CurrentPid = getpid();
2210 				close_sendmail_pid();
2211 
2212 				/*
2213 				**  Initialize exception stack and default
2214 				**  exception handler for child process.
2215 				**  When fork()'d the child now has a private
2216 				**  copy of WorkQ at its current position.
2217 				*/
2218 
2219 				sm_exc_newthread(fatal_error);
2220 
2221 				/*
2222 				**  SMTP processes (whether -bd or -bs) set
2223 				**  SIGCHLD to reapchild to collect
2224 				**  children status.  However, at delivery
2225 				**  time, that status must be collected
2226 				**  by sm_wait() to be dealt with properly
2227 				**  (check success of delivery based
2228 				**  on status code, etc).  Therefore, if we
2229 				**  are an SMTP process, reset SIGCHLD
2230 				**  back to the default so reapchild
2231 				**  doesn't collect status before
2232 				**  sm_wait().
2233 				*/
2234 
2235 				if (OpMode == MD_SMTP ||
2236 				    OpMode == MD_DAEMON ||
2237 				    MaxQueueChildren > 0)
2238 				{
2239 					proc_list_clear();
2240 					sm_releasesignal(SIGCHLD);
2241 					(void) sm_signal(SIGCHLD, SIG_DFL);
2242 				}
2243 
2244 				/* child -- error messages to the transcript */
2245 				QuickAbort = OnlyOneError = false;
2246 				runner_work(e, sequenceno, true,
2247 					    maxrunners, njobs);
2248 
2249 				/* This child is done */
2250 				finis(true, true, ExitStat);
2251 				/* NOTREACHED */
2252 			}
2253 		}
2254 
2255 		sm_releasesignal(SIGCHLD);
2256 
2257 		/*
2258 		**  Wait until all of the runners have completed before
2259 		**  seeing if there is another queue group in the
2260 		**  work group to process.
2261 		**  XXX Future enhancement: don't wait() for all children
2262 		**  here, just go ahead and make sure that overall the number
2263 		**  of children is not exceeded.
2264 		*/
2265 
2266 		while (CurChildren > 0)
2267 		{
2268 			int status;
2269 			pid_t ret;
2270 
2271 			while ((ret = sm_wait(&status)) <= 0)
2272 				continue;
2273 			proc_list_drop(ret, status, NULL);
2274 		}
2275 	}
2276 	else if (Queue[qgrp]->qg_maxqrun > 0 || bitset(RWG_FORCE, flags))
2277 	{
2278 		/*
2279 		**  When current process will not fork children to do the work,
2280 		**  it will do the work itself. The 'skip' will be 1 since
2281 		**  there are no child runners to divide the work across.
2282 		*/
2283 
2284 		runner_work(e, sequenceno, false, 1, njobs);
2285 	}
2286 
2287 	/* free memory allocated by newenvelope() above */
2288 	sm_rpool_free(rpool);
2289 	QueueEnvelope.e_rpool = NULL;
2290 
2291 	/* Are there still more queues in the work group to process? */
2292 	if (endgrp != WorkGrp[wgrp].wg_curqgrp)
2293 	{
2294 		rpool = sm_rpool_new_x(NULL);
2295 		e = newenvelope(&QueueEnvelope, CurEnv, rpool);
2296 		e->e_flags = BlankEnvelope.e_flags;
2297 		goto domorework;
2298 	}
2299 
2300 	/* No more queues in work group to process. Now check persistent. */
2301 	if (bitset(RWG_PERSISTENT, flags))
2302 	{
2303 		sequenceno = 1;
2304 		sm_setproctitle(true, CurEnv, "running queue: %s",
2305 				qid_printqueue(qgrp, qdir));
2306 
2307 		/*
2308 		**  close bogus maps, i.e., maps which caused a tempfail,
2309 		**	so we get fresh map connections on the next lookup.
2310 		**  closemaps() is also called when children are started.
2311 		*/
2312 
2313 		closemaps(true);
2314 
2315 		/* Close any cached connections. */
2316 		mci_flush(true, NULL);
2317 
2318 		/* Clean out expired related entries. */
2319 		rmexpstab();
2320 
2321 #if NAMED_BIND
2322 		/* Update MX records for FallbackMX. */
2323 		if (FallbackMX != NULL)
2324 			(void) getfallbackmxrr(FallbackMX);
2325 #endif /* NAMED_BIND */
2326 
2327 #if USERDB
2328 		/* close UserDatabase */
2329 		_udbx_close();
2330 #endif /* USERDB */
2331 
2332 #if SM_HEAP_CHECK
2333 		if (sm_debug_active(&SmHeapCheck, 2)
2334 		    && access("memdump", F_OK) == 0
2335 		   )
2336 		{
2337 			SM_FILE_T *out;
2338 
2339 			remove("memdump");
2340 			out = sm_io_open(SmFtStdio, SM_TIME_DEFAULT,
2341 					 "memdump.out", SM_IO_APPEND, NULL);
2342 			if (out != NULL)
2343 			{
2344 				(void) sm_io_fprintf(out, SM_TIME_DEFAULT, "----------------------\n");
2345 				sm_heap_report(out,
2346 					sm_debug_level(&SmHeapCheck) - 1);
2347 				(void) sm_io_close(out, SM_TIME_DEFAULT);
2348 			}
2349 		}
2350 #endif /* SM_HEAP_CHECK */
2351 
2352 		/* let me rest for a second to catch my breath */
2353 		if (njobs == 0 && WorkGrp[wgrp].wg_lowqintvl < MIN_SLEEP_TIME)
2354 			sleep(MIN_SLEEP_TIME);
2355 		else if (WorkGrp[wgrp].wg_lowqintvl <= 0)
2356 			sleep(QueueIntvl > 0 ? QueueIntvl : MIN_SLEEP_TIME);
2357 		else
2358 			sleep(WorkGrp[wgrp].wg_lowqintvl);
2359 
2360 		/*
2361 		**  Get the LA outside the WorkQ loop if necessary.
2362 		**  In a persistent queue runner the code is repeated over
2363 		**  and over but gatherq() may ignore entries due to
2364 		**  shouldqueue() (do we really have to do this twice?).
2365 		**  Hence the queue runners would just idle around when once
2366 		**  CurrentLA caused all entries in a queue to be ignored.
2367 		*/
2368 
2369 		if (njobs == 0)
2370 			SM_GET_LA(now);
2371 		rpool = sm_rpool_new_x(NULL);
2372 		e = newenvelope(&QueueEnvelope, CurEnv, rpool);
2373 		e->e_flags = BlankEnvelope.e_flags;
2374 		goto domorework;
2375 	}
2376 
2377 	/* exit without the usual cleanup */
2378 	e->e_id = NULL;
2379 	if (bitset(RWG_FORK, flags))
2380 		finis(true, true, ExitStat);
2381 	/* NOTREACHED */
2382 	return true;
2383 }
2384 
2385 /*
2386 **  DOQUEUERUN -- do a queue run?
2387 */
2388 
2389 bool
doqueuerun()2390 doqueuerun()
2391 {
2392 	return DoQueueRun;
2393 }
2394 
2395 /*
2396 **  RUNQUEUEEVENT -- Sets a flag to indicate that a queue run should be done.
2397 **
2398 **	Parameters:
2399 **		none.
2400 **
2401 **	Returns:
2402 **		none.
2403 **
2404 **	Side Effects:
2405 **		The invocation of this function via an alarm may interrupt
2406 **		a set of actions. Thus errno may be set in that context.
2407 **		We need to restore errno at the end of this function to ensure
2408 **		that any work done here that sets errno doesn't return a
2409 **		misleading/false errno value. Errno may	be EINTR upon entry to
2410 **		this function because of non-restartable/continuable system
2411 **		API was active. Iff this is true we will override errno as
2412 **		a timeout (as a more accurate error message).
2413 **
2414 **	NOTE:	THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
2415 **		ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2416 **		DOING.
2417 */
2418 
2419 void
runqueueevent(ignore)2420 runqueueevent(ignore)
2421 	int ignore;
2422 {
2423 	int save_errno = errno;
2424 
2425 	/*
2426 	**  Set the general bit that we want a queue run,
2427 	**  tested in doqueuerun()
2428 	*/
2429 
2430 	DoQueueRun = true;
2431 #if _FFR_QUEUE_SCHED_DBG
2432 	if (tTd(69, 10))
2433 		sm_syslog(LOG_INFO, NOQID, "rqe: done");
2434 #endif /* _FFR_QUEUE_SCHED_DBG */
2435 
2436 	errno = save_errno;
2437 	if (errno == EINTR)
2438 		errno = ETIMEDOUT;
2439 }
2440 /*
2441 **  GATHERQ -- gather messages from the message queue(s) the work queue.
2442 **
2443 **	Parameters:
2444 **		qgrp -- the index of the queue group.
2445 **		qdir -- the index of the queue directory.
2446 **		doall -- if set, include everything in the queue (even
2447 **			the jobs that cannot be run because the load
2448 **			average is too high, or MaxQueueRun is reached).
2449 **			Otherwise, exclude those jobs.
2450 **		full -- (optional) to be set 'true' if WorkList is full
2451 **		more -- (optional) to be set 'true' if there are still more
2452 **			messages in this queue not added to WorkList
2453 **		pnentries -- (optional) total nuber of entries in queue
2454 **
2455 **	Returns:
2456 **		The number of request in the queue (not necessarily
2457 **		the number of requests in WorkList however).
2458 **
2459 **	Side Effects:
2460 **		prepares available work into WorkList
2461 */
2462 
2463 #define NEED_P		0001	/* 'P': priority */
2464 #define NEED_T		0002	/* 'T': time */
2465 #define NEED_R		0004	/* 'R': recipient */
2466 #define NEED_S		0010	/* 'S': sender */
2467 #define NEED_H		0020	/* host */
2468 #define HAS_QUARANTINE	0040	/* has an unexpected 'q' line */
2469 #define NEED_QUARANTINE	0100	/* 'q': reason */
2470 
2471 static WORK	*WorkList = NULL;	/* list of unsort work */
2472 static int	WorkListSize = 0;	/* current max size of WorkList */
2473 static int	WorkListCount = 0;	/* # of work items in WorkList */
2474 
2475 static int
gatherq(qgrp,qdir,doall,full,more,pnentries)2476 gatherq(qgrp, qdir, doall, full, more, pnentries)
2477 	int qgrp;
2478 	int qdir;
2479 	bool doall;
2480 	bool *full;
2481 	bool *more;
2482 	int *pnentries;
2483 {
2484 	register struct dirent *d;
2485 	register WORK *w;
2486 	register char *p;
2487 	DIR *f;
2488 	int i, num_ent, wn, nentries;
2489 	QUEUE_CHAR *check;
2490 	char qd[MAXPATHLEN];
2491 	char qf[MAXPATHLEN];
2492 
2493 	wn = WorkListCount - 1;
2494 	num_ent = 0;
2495 	nentries = 0;
2496 	if (qdir == NOQDIR)
2497 		(void) sm_strlcpy(qd, ".", sizeof(qd));
2498 	else
2499 		(void) sm_strlcpyn(qd, sizeof(qd), 2,
2500 			Queue[qgrp]->qg_qpaths[qdir].qp_name,
2501 			(bitset(QP_SUBQF,
2502 				Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
2503 					? "/qf" : ""));
2504 
2505 	if (tTd(41, 1))
2506 	{
2507 		sm_dprintf("gatherq:\n");
2508 
2509 		check = QueueLimitId;
2510 		while (check != NULL)
2511 		{
2512 			sm_dprintf("\tQueueLimitId = %s%s\n",
2513 				check->queue_negate ? "!" : "",
2514 				check->queue_match);
2515 			check = check->queue_next;
2516 		}
2517 
2518 		check = QueueLimitSender;
2519 		while (check != NULL)
2520 		{
2521 			sm_dprintf("\tQueueLimitSender = %s%s\n",
2522 				check->queue_negate ? "!" : "",
2523 				check->queue_match);
2524 			check = check->queue_next;
2525 		}
2526 
2527 		check = QueueLimitRecipient;
2528 		while (check != NULL)
2529 		{
2530 			sm_dprintf("\tQueueLimitRecipient = %s%s\n",
2531 				check->queue_negate ? "!" : "",
2532 				check->queue_match);
2533 			check = check->queue_next;
2534 		}
2535 
2536 		if (QueueMode == QM_QUARANTINE)
2537 		{
2538 			check = QueueLimitQuarantine;
2539 			while (check != NULL)
2540 			{
2541 				sm_dprintf("\tQueueLimitQuarantine = %s%s\n",
2542 					   check->queue_negate ? "!" : "",
2543 					   check->queue_match);
2544 				check = check->queue_next;
2545 			}
2546 		}
2547 	}
2548 
2549 	/* open the queue directory */
2550 	f = opendir(qd);
2551 	if (f == NULL)
2552 	{
2553 		syserr("gatherq: cannot open \"%s\"",
2554 			qid_printqueue(qgrp, qdir));
2555 		if (full != NULL)
2556 			*full = WorkListCount >= MaxQueueRun && MaxQueueRun > 0;
2557 		if (more != NULL)
2558 			*more = false;
2559 		return 0;
2560 	}
2561 
2562 	/*
2563 	**  Read the work directory.
2564 	*/
2565 
2566 	while ((d = readdir(f)) != NULL)
2567 	{
2568 		SM_FILE_T *cf;
2569 		int qfver = 0;
2570 		char lbuf[MAXNAME + 1];
2571 		struct stat sbuf;
2572 
2573 		if (tTd(41, 50))
2574 			sm_dprintf("gatherq: checking %s..", d->d_name);
2575 
2576 		/* is this an interesting entry? */
2577 		if (!(((QueueMode == QM_NORMAL &&
2578 			d->d_name[0] == NORMQF_LETTER) ||
2579 		       (QueueMode == QM_QUARANTINE &&
2580 			d->d_name[0] == QUARQF_LETTER) ||
2581 		       (QueueMode == QM_LOST &&
2582 			d->d_name[0] == LOSEQF_LETTER)) &&
2583 		      d->d_name[1] == 'f'))
2584 		{
2585 			if (tTd(41, 50))
2586 				sm_dprintf("  skipping\n");
2587 			continue;
2588 		}
2589 		if (tTd(41, 50))
2590 			sm_dprintf("\n");
2591 
2592 		if (strlen(d->d_name) >= MAXQFNAME)
2593 		{
2594 			if (Verbose)
2595 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2596 						     "gatherq: %s too long, %d max characters\n",
2597 						     d->d_name, MAXQFNAME);
2598 			if (LogLevel > 0)
2599 				sm_syslog(LOG_ALERT, NOQID,
2600 					  "gatherq: %s too long, %d max characters",
2601 					  d->d_name, MAXQFNAME);
2602 			continue;
2603 		}
2604 
2605 		++nentries;
2606 		check = QueueLimitId;
2607 		while (check != NULL)
2608 		{
2609 			if (strcontainedin(false, check->queue_match,
2610 					   d->d_name) != check->queue_negate)
2611 				break;
2612 			else
2613 				check = check->queue_next;
2614 		}
2615 		if (QueueLimitId != NULL && check == NULL)
2616 			continue;
2617 
2618 		/* grow work list if necessary */
2619 		if (++wn >= MaxQueueRun && MaxQueueRun > 0)
2620 		{
2621 			if (wn == MaxQueueRun && LogLevel > 0)
2622 				sm_syslog(LOG_WARNING, NOQID,
2623 					  "WorkList for %s maxed out at %d",
2624 					  qid_printqueue(qgrp, qdir),
2625 					  MaxQueueRun);
2626 			if (doall)
2627 				continue;	/* just count entries */
2628 			break;
2629 		}
2630 		if (wn >= WorkListSize)
2631 		{
2632 			grow_wlist(qgrp, qdir);
2633 			if (wn >= WorkListSize)
2634 				continue;
2635 		}
2636 		SM_ASSERT(wn >= 0);
2637 		w = &WorkList[wn];
2638 
2639 		(void) sm_strlcpyn(qf, sizeof(qf), 3, qd, "/", d->d_name);
2640 		if (stat(qf, &sbuf) < 0)
2641 		{
2642 			if (errno != ENOENT)
2643 				sm_syslog(LOG_INFO, NOQID,
2644 					  "gatherq: can't stat %s/%s",
2645 					  qid_printqueue(qgrp, qdir),
2646 					  d->d_name);
2647 			wn--;
2648 			continue;
2649 		}
2650 		if (!bitset(S_IFREG, sbuf.st_mode))
2651 		{
2652 			/* Yikes!  Skip it or we will hang on open! */
2653 			if (!((d->d_name[0] == DATAFL_LETTER ||
2654 			       d->d_name[0] == NORMQF_LETTER ||
2655 			       d->d_name[0] == QUARQF_LETTER ||
2656 			       d->d_name[0] == LOSEQF_LETTER ||
2657 			       d->d_name[0] == XSCRPT_LETTER) &&
2658 			      d->d_name[1] == 'f' && d->d_name[2] == '\0'))
2659 				syserr("gatherq: %s/%s is not a regular file",
2660 				       qid_printqueue(qgrp, qdir), d->d_name);
2661 			wn--;
2662 			continue;
2663 		}
2664 
2665 		/* avoid work if possible */
2666 		if ((QueueSortOrder == QSO_BYFILENAME ||
2667 		     QueueSortOrder == QSO_BYMODTIME ||
2668 		     QueueSortOrder == QSO_NONE ||
2669 		     QueueSortOrder == QSO_RANDOM) &&
2670 		    QueueLimitQuarantine == NULL &&
2671 		    QueueLimitSender == NULL &&
2672 		    QueueLimitRecipient == NULL)
2673 		{
2674 			w->w_qgrp = qgrp;
2675 			w->w_qdir = qdir;
2676 			w->w_name = newstr(d->d_name);
2677 			w->w_host = NULL;
2678 			w->w_lock = w->w_tooyoung = false;
2679 			w->w_pri = 0;
2680 			w->w_ctime = 0;
2681 			w->w_mtime = sbuf.st_mtime;
2682 			++num_ent;
2683 			continue;
2684 		}
2685 
2686 		/* open control file */
2687 		cf = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, qf, SM_IO_RDONLY_B,
2688 				NULL);
2689 		if (cf == NULL && OpMode != MD_PRINT)
2690 		{
2691 			/* this may be some random person sending hir msgs */
2692 			if (tTd(41, 2))
2693 				sm_dprintf("gatherq: cannot open %s: %s\n",
2694 					d->d_name, sm_errstring(errno));
2695 			errno = 0;
2696 			wn--;
2697 			continue;
2698 		}
2699 		w->w_qgrp = qgrp;
2700 		w->w_qdir = qdir;
2701 		w->w_name = newstr(d->d_name);
2702 		w->w_host = NULL;
2703 		if (cf != NULL)
2704 		{
2705 			w->w_lock = !lockfile(sm_io_getinfo(cf, SM_IO_WHAT_FD,
2706 							    NULL),
2707 					      w->w_name, NULL,
2708 					      LOCK_SH|LOCK_NB);
2709 		}
2710 		w->w_tooyoung = false;
2711 
2712 		/* make sure jobs in creation don't clog queue */
2713 		w->w_pri = 0x7fffffff;
2714 		w->w_ctime = 0;
2715 		w->w_mtime = sbuf.st_mtime;
2716 
2717 		/* extract useful information */
2718 		i = NEED_P|NEED_T;
2719 		if (QueueSortOrder == QSO_BYHOST
2720 #if _FFR_RHS
2721 		    || QueueSortOrder == QSO_BYSHUFFLE
2722 #endif /* _FFR_RHS */
2723 		   )
2724 		{
2725 			/* need w_host set for host sort order */
2726 			i |= NEED_H;
2727 		}
2728 		if (QueueLimitSender != NULL)
2729 			i |= NEED_S;
2730 		if (QueueLimitRecipient != NULL)
2731 			i |= NEED_R;
2732 		if (QueueLimitQuarantine != NULL)
2733 			i |= NEED_QUARANTINE;
2734 		while (cf != NULL && i != 0 &&
2735 		       sm_io_fgets(cf, SM_TIME_DEFAULT, lbuf,
2736 				   sizeof(lbuf)) != NULL)
2737 		{
2738 			int c;
2739 			time_t age;
2740 
2741 			p = strchr(lbuf, '\n');
2742 			if (p != NULL)
2743 				*p = '\0';
2744 			else
2745 			{
2746 				/* flush rest of overly long line */
2747 				while ((c = sm_io_getc(cf, SM_TIME_DEFAULT))
2748 				       != SM_IO_EOF && c != '\n')
2749 					continue;
2750 			}
2751 
2752 			switch (lbuf[0])
2753 			{
2754 			  case 'V':
2755 				qfver = atoi(&lbuf[1]);
2756 				break;
2757 
2758 			  case 'P':
2759 				w->w_pri = atol(&lbuf[1]);
2760 				i &= ~NEED_P;
2761 				break;
2762 
2763 			  case 'T':
2764 				w->w_ctime = atol(&lbuf[1]);
2765 				i &= ~NEED_T;
2766 				break;
2767 
2768 			  case 'q':
2769 				if (QueueMode != QM_QUARANTINE &&
2770 				    QueueMode != QM_LOST)
2771 				{
2772 					if (tTd(41, 49))
2773 						sm_dprintf("%s not marked as quarantined but has a 'q' line\n",
2774 							   w->w_name);
2775 					i |= HAS_QUARANTINE;
2776 				}
2777 				else if (QueueMode == QM_QUARANTINE)
2778 				{
2779 					if (QueueLimitQuarantine == NULL)
2780 					{
2781 						i &= ~NEED_QUARANTINE;
2782 						break;
2783 					}
2784 					p = &lbuf[1];
2785 					check = QueueLimitQuarantine;
2786 					while (check != NULL)
2787 					{
2788 						if (strcontainedin(false,
2789 								   check->queue_match,
2790 								   p) !=
2791 						    check->queue_negate)
2792 							break;
2793 						else
2794 							check = check->queue_next;
2795 					}
2796 					if (check != NULL)
2797 						i &= ~NEED_QUARANTINE;
2798 				}
2799 				break;
2800 
2801 			  case 'R':
2802 				if (w->w_host == NULL &&
2803 				    (p = strrchr(&lbuf[1], '@')) != NULL)
2804 				{
2805 #if _FFR_RHS
2806 					if (QueueSortOrder == QSO_BYSHUFFLE)
2807 						w->w_host = newstr(&p[1]);
2808 					else
2809 #endif /* _FFR_RHS */
2810 						w->w_host = strrev(&p[1]);
2811 					makelower(w->w_host);
2812 					i &= ~NEED_H;
2813 				}
2814 				if (QueueLimitRecipient == NULL)
2815 				{
2816 					i &= ~NEED_R;
2817 					break;
2818 				}
2819 				if (qfver > 0)
2820 				{
2821 					p = strchr(&lbuf[1], ':');
2822 					if (p == NULL)
2823 						p = &lbuf[1];
2824 					else
2825 						++p; /* skip over ':' */
2826 				}
2827 				else
2828 					p = &lbuf[1];
2829 				check = QueueLimitRecipient;
2830 				while (check != NULL)
2831 				{
2832 					if (strcontainedin(true,
2833 							   check->queue_match,
2834 							   p) !=
2835 					    check->queue_negate)
2836 						break;
2837 					else
2838 						check = check->queue_next;
2839 				}
2840 				if (check != NULL)
2841 					i &= ~NEED_R;
2842 				break;
2843 
2844 			  case 'S':
2845 				check = QueueLimitSender;
2846 				while (check != NULL)
2847 				{
2848 					if (strcontainedin(true,
2849 							   check->queue_match,
2850 							   &lbuf[1]) !=
2851 					    check->queue_negate)
2852 						break;
2853 					else
2854 						check = check->queue_next;
2855 				}
2856 				if (check != NULL)
2857 					i &= ~NEED_S;
2858 				break;
2859 
2860 			  case 'K':
2861 #if _FFR_EXPDELAY
2862 				if (MaxQueueAge > 0)
2863 				{
2864 					time_t lasttry, delay;
2865 
2866 					lasttry = (time_t) atol(&lbuf[1]);
2867 					delay = MIN(lasttry - w->w_ctime,
2868 						    MaxQueueAge);
2869 					age = curtime() - lasttry;
2870 					if (age < delay)
2871 						w->w_tooyoung = true;
2872 					break;
2873 				}
2874 #endif /* _FFR_EXPDELAY */
2875 
2876 				age = curtime() - (time_t) atol(&lbuf[1]);
2877 				if (age >= 0 && MinQueueAge > 0 &&
2878 				    age < MinQueueAge)
2879 					w->w_tooyoung = true;
2880 				break;
2881 
2882 			  case 'N':
2883 				if (atol(&lbuf[1]) == 0)
2884 					w->w_tooyoung = false;
2885 				break;
2886 			}
2887 		}
2888 		if (cf != NULL)
2889 			(void) sm_io_close(cf, SM_TIME_DEFAULT);
2890 
2891 		if ((!doall && (shouldqueue(w->w_pri, w->w_ctime) ||
2892 		    w->w_tooyoung)) ||
2893 		    bitset(HAS_QUARANTINE, i) ||
2894 		    bitset(NEED_QUARANTINE, i) ||
2895 		    bitset(NEED_R|NEED_S, i))
2896 		{
2897 			/* don't even bother sorting this job in */
2898 			if (tTd(41, 49))
2899 				sm_dprintf("skipping %s (%x)\n", w->w_name, i);
2900 			sm_free(w->w_name); /* XXX */
2901 			if (w->w_host != NULL)
2902 				sm_free(w->w_host); /* XXX */
2903 			wn--;
2904 		}
2905 		else
2906 			++num_ent;
2907 	}
2908 	(void) closedir(f);
2909 	wn++;
2910 
2911 	i = wn - WorkListCount;
2912 	WorkListCount += SM_MIN(num_ent, WorkListSize);
2913 
2914 	if (more != NULL)
2915 		*more = WorkListCount < wn;
2916 
2917 	if (full != NULL)
2918 		*full = (wn >= MaxQueueRun && MaxQueueRun > 0) ||
2919 			(WorkList == NULL && wn > 0);
2920 
2921 	if (pnentries != NULL)
2922 		*pnentries = nentries;
2923 	return i;
2924 }
2925 /*
2926 **  SORTQ -- sort the work list
2927 **
2928 **	First the old WorkQ is cleared away. Then the WorkList is sorted
2929 **	for all items so that important (higher sorting value) items are not
2930 **	trunctated off. Then the most important items are moved from
2931 **	WorkList to WorkQ. The lower count of 'max' or MaxListCount items
2932 **	are moved.
2933 **
2934 **	Parameters:
2935 **		max -- maximum number of items to be placed in WorkQ
2936 **
2937 **	Returns:
2938 **		the number of items in WorkQ
2939 **
2940 **	Side Effects:
2941 **		WorkQ gets released and filled with new work. WorkList
2942 **		gets released. Work items get sorted in order.
2943 */
2944 
2945 static int
sortq(max)2946 sortq(max)
2947 	int max;
2948 {
2949 	register int i;			/* local counter */
2950 	register WORK *w;		/* tmp item pointer */
2951 	int wc = WorkListCount;		/* trim size for WorkQ */
2952 
2953 	if (WorkQ != NULL)
2954 	{
2955 		WORK *nw;
2956 
2957 		/* Clear out old WorkQ. */
2958 		for (w = WorkQ; w != NULL; w = nw)
2959 		{
2960 			nw = w->w_next;
2961 			sm_free(w->w_name); /* XXX */
2962 			if (w->w_host != NULL)
2963 				sm_free(w->w_host); /* XXX */
2964 			sm_free((char *) w); /* XXX */
2965 		}
2966 		WorkQ = NULL;
2967 	}
2968 
2969 	if (WorkList == NULL || wc <= 0)
2970 		return 0;
2971 
2972 	/*
2973 	**  The sort now takes place using all of the items in WorkList.
2974 	**  The list gets trimmed to the most important items after the sort.
2975 	**  If the trim were to happen before the sort then one or more
2976 	**  important items might get truncated off -- not what we want.
2977 	*/
2978 
2979 	if (QueueSortOrder == QSO_BYHOST)
2980 	{
2981 		/*
2982 		**  Sort the work directory for the first time,
2983 		**  based on host name, lock status, and priority.
2984 		*/
2985 
2986 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf1);
2987 
2988 		/*
2989 		**  If one message to host is locked, "lock" all messages
2990 		**  to that host.
2991 		*/
2992 
2993 		i = 0;
2994 		while (i < wc)
2995 		{
2996 			if (!WorkList[i].w_lock)
2997 			{
2998 				i++;
2999 				continue;
3000 			}
3001 			w = &WorkList[i];
3002 			while (++i < wc)
3003 			{
3004 				if (WorkList[i].w_host == NULL &&
3005 				    w->w_host == NULL)
3006 					WorkList[i].w_lock = true;
3007 				else if (WorkList[i].w_host != NULL &&
3008 					 w->w_host != NULL &&
3009 					 sm_strcasecmp(WorkList[i].w_host,
3010 						       w->w_host) == 0)
3011 					WorkList[i].w_lock = true;
3012 				else
3013 					break;
3014 			}
3015 		}
3016 
3017 		/*
3018 		**  Sort the work directory for the second time,
3019 		**  based on lock status, host name, and priority.
3020 		*/
3021 
3022 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf2);
3023 	}
3024 	else if (QueueSortOrder == QSO_BYTIME)
3025 	{
3026 		/*
3027 		**  Simple sort based on submission time only.
3028 		*/
3029 
3030 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf3);
3031 	}
3032 	else if (QueueSortOrder == QSO_BYFILENAME)
3033 	{
3034 		/*
3035 		**  Sort based on queue filename.
3036 		*/
3037 
3038 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf4);
3039 	}
3040 	else if (QueueSortOrder == QSO_RANDOM)
3041 	{
3042 		/*
3043 		**  Sort randomly.  To avoid problems with an instable sort,
3044 		**  use a random index into the queue file name to start
3045 		**  comparison.
3046 		*/
3047 
3048 		randi = get_rand_mod(MAXQFNAME);
3049 		if (randi < 2)
3050 			randi = 3;
3051 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf5);
3052 	}
3053 	else if (QueueSortOrder == QSO_BYMODTIME)
3054 	{
3055 		/*
3056 		**  Simple sort based on modification time of queue file.
3057 		**  This puts the oldest items first.
3058 		*/
3059 
3060 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf6);
3061 	}
3062 #if _FFR_RHS
3063 	else if (QueueSortOrder == QSO_BYSHUFFLE)
3064 	{
3065 		/*
3066 		**  Simple sort based on shuffled host name.
3067 		*/
3068 
3069 		init_shuffle_alphabet();
3070 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf7);
3071 	}
3072 #endif /* _FFR_RHS */
3073 	else if (QueueSortOrder == QSO_BYPRIORITY)
3074 	{
3075 		/*
3076 		**  Simple sort based on queue priority only.
3077 		*/
3078 
3079 		qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf0);
3080 	}
3081 	/* else don't sort at all */
3082 
3083 	/* Check if the per queue group item limit will be exceeded */
3084 	if (wc > max && max > 0)
3085 		wc = max;
3086 
3087 	/*
3088 	**  Convert the work list into canonical form.
3089 	**	Should be turning it into a list of envelopes here perhaps.
3090 	**  Only take the most important items up to the per queue group
3091 	**  maximum.
3092 	*/
3093 
3094 	for (i = wc; --i >= 0; )
3095 	{
3096 		w = (WORK *) xalloc(sizeof(*w));
3097 		w->w_qgrp = WorkList[i].w_qgrp;
3098 		w->w_qdir = WorkList[i].w_qdir;
3099 		w->w_name = WorkList[i].w_name;
3100 		w->w_host = WorkList[i].w_host;
3101 		w->w_lock = WorkList[i].w_lock;
3102 		w->w_tooyoung = WorkList[i].w_tooyoung;
3103 		w->w_pri = WorkList[i].w_pri;
3104 		w->w_ctime = WorkList[i].w_ctime;
3105 		w->w_mtime = WorkList[i].w_mtime;
3106 		w->w_next = WorkQ;
3107 		WorkQ = w;
3108 	}
3109 
3110 	/* free the rest of the list */
3111 	for (i = WorkListCount; --i >= wc; )
3112 	{
3113 		sm_free(WorkList[i].w_name);
3114 		if (WorkList[i].w_host != NULL)
3115 			sm_free(WorkList[i].w_host);
3116 	}
3117 
3118 	if (WorkList != NULL)
3119 		sm_free(WorkList); /* XXX */
3120 	WorkList = NULL;
3121 	WorkListSize = 0;
3122 	WorkListCount = 0;
3123 
3124 	if (tTd(40, 1))
3125 	{
3126 		for (w = WorkQ; w != NULL; w = w->w_next)
3127 		{
3128 			if (w->w_host != NULL)
3129 				sm_dprintf("%22s: pri=%ld %s\n",
3130 					w->w_name, w->w_pri, w->w_host);
3131 			else
3132 				sm_dprintf("%32s: pri=%ld\n",
3133 					w->w_name, w->w_pri);
3134 		}
3135 	}
3136 
3137 	return wc; /* return number of WorkQ items */
3138 }
3139 /*
3140 **  GROW_WLIST -- make the work list larger
3141 **
3142 **	Parameters:
3143 **		qgrp -- the index for the queue group.
3144 **		qdir -- the index for the queue directory.
3145 **
3146 **	Returns:
3147 **		none.
3148 **
3149 **	Side Effects:
3150 **		Adds another QUEUESEGSIZE entries to WorkList if possible.
3151 **		It can fail if there isn't enough memory, so WorkListSize
3152 **		should be checked again upon return.
3153 */
3154 
3155 static void
grow_wlist(qgrp,qdir)3156 grow_wlist(qgrp, qdir)
3157 	int qgrp;
3158 	int qdir;
3159 {
3160 	if (tTd(41, 1))
3161 		sm_dprintf("grow_wlist: WorkListSize=%d\n", WorkListSize);
3162 	if (WorkList == NULL)
3163 	{
3164 		WorkList = (WORK *) xalloc((sizeof(*WorkList)) *
3165 					   (QUEUESEGSIZE + 1));
3166 		WorkListSize = QUEUESEGSIZE;
3167 	}
3168 	else
3169 	{
3170 		int newsize = WorkListSize + QUEUESEGSIZE;
3171 		WORK *newlist = (WORK *) sm_realloc((char *) WorkList,
3172 					  (unsigned) sizeof(WORK) * (newsize + 1));
3173 
3174 		if (newlist != NULL)
3175 		{
3176 			WorkListSize = newsize;
3177 			WorkList = newlist;
3178 			if (LogLevel > 1)
3179 			{
3180 				sm_syslog(LOG_INFO, NOQID,
3181 					  "grew WorkList for %s to %d",
3182 					  qid_printqueue(qgrp, qdir),
3183 					  WorkListSize);
3184 			}
3185 		}
3186 		else if (LogLevel > 0)
3187 		{
3188 			sm_syslog(LOG_ALERT, NOQID,
3189 				  "FAILED to grow WorkList for %s to %d",
3190 				  qid_printqueue(qgrp, qdir), newsize);
3191 		}
3192 	}
3193 	if (tTd(41, 1))
3194 		sm_dprintf("grow_wlist: WorkListSize now %d\n", WorkListSize);
3195 }
3196 /*
3197 **  WORKCMPF0 -- simple priority-only compare function.
3198 **
3199 **	Parameters:
3200 **		a -- the first argument.
3201 **		b -- the second argument.
3202 **
3203 **	Returns:
3204 **		-1 if a < b
3205 **		 0 if a == b
3206 **		+1 if a > b
3207 **
3208 */
3209 
3210 static int
workcmpf0(a,b)3211 workcmpf0(a, b)
3212 	register WORK *a;
3213 	register WORK *b;
3214 {
3215 	long pa = a->w_pri;
3216 	long pb = b->w_pri;
3217 
3218 	if (pa == pb)
3219 		return 0;
3220 	else if (pa > pb)
3221 		return 1;
3222 	else
3223 		return -1;
3224 }
3225 /*
3226 **  WORKCMPF1 -- first compare function for ordering work based on host name.
3227 **
3228 **	Sorts on host name, lock status, and priority in that order.
3229 **
3230 **	Parameters:
3231 **		a -- the first argument.
3232 **		b -- the second argument.
3233 **
3234 **	Returns:
3235 **		<0 if a < b
3236 **		 0 if a == b
3237 **		>0 if a > b
3238 **
3239 */
3240 
3241 static int
workcmpf1(a,b)3242 workcmpf1(a, b)
3243 	register WORK *a;
3244 	register WORK *b;
3245 {
3246 	int i;
3247 
3248 	/* host name */
3249 	if (a->w_host != NULL && b->w_host == NULL)
3250 		return 1;
3251 	else if (a->w_host == NULL && b->w_host != NULL)
3252 		return -1;
3253 	if (a->w_host != NULL && b->w_host != NULL &&
3254 	    (i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
3255 		return i;
3256 
3257 	/* lock status */
3258 	if (a->w_lock != b->w_lock)
3259 		return b->w_lock - a->w_lock;
3260 
3261 	/* job priority */
3262 	return workcmpf0(a, b);
3263 }
3264 /*
3265 **  WORKCMPF2 -- second compare function for ordering work based on host name.
3266 **
3267 **	Sorts on lock status, host name, and priority in that order.
3268 **
3269 **	Parameters:
3270 **		a -- the first argument.
3271 **		b -- the second argument.
3272 **
3273 **	Returns:
3274 **		<0 if a < b
3275 **		 0 if a == b
3276 **		>0 if a > b
3277 **
3278 */
3279 
3280 static int
workcmpf2(a,b)3281 workcmpf2(a, b)
3282 	register WORK *a;
3283 	register WORK *b;
3284 {
3285 	int i;
3286 
3287 	/* lock status */
3288 	if (a->w_lock != b->w_lock)
3289 		return a->w_lock - b->w_lock;
3290 
3291 	/* host name */
3292 	if (a->w_host != NULL && b->w_host == NULL)
3293 		return 1;
3294 	else if (a->w_host == NULL && b->w_host != NULL)
3295 		return -1;
3296 	if (a->w_host != NULL && b->w_host != NULL &&
3297 	    (i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
3298 		return i;
3299 
3300 	/* job priority */
3301 	return workcmpf0(a, b);
3302 }
3303 /*
3304 **  WORKCMPF3 -- simple submission-time-only compare function.
3305 **
3306 **	Parameters:
3307 **		a -- the first argument.
3308 **		b -- the second argument.
3309 **
3310 **	Returns:
3311 **		-1 if a < b
3312 **		 0 if a == b
3313 **		+1 if a > b
3314 **
3315 */
3316 
3317 static int
workcmpf3(a,b)3318 workcmpf3(a, b)
3319 	register WORK *a;
3320 	register WORK *b;
3321 {
3322 	if (a->w_ctime > b->w_ctime)
3323 		return 1;
3324 	else if (a->w_ctime < b->w_ctime)
3325 		return -1;
3326 	else
3327 		return 0;
3328 }
3329 /*
3330 **  WORKCMPF4 -- compare based on file name
3331 **
3332 **	Parameters:
3333 **		a -- the first argument.
3334 **		b -- the second argument.
3335 **
3336 **	Returns:
3337 **		-1 if a < b
3338 **		 0 if a == b
3339 **		+1 if a > b
3340 **
3341 */
3342 
3343 static int
workcmpf4(a,b)3344 workcmpf4(a, b)
3345 	register WORK *a;
3346 	register WORK *b;
3347 {
3348 	return strcmp(a->w_name, b->w_name);
3349 }
3350 /*
3351 **  WORKCMPF5 -- compare based on assigned random number
3352 **
3353 **	Parameters:
3354 **		a -- the first argument.
3355 **		b -- the second argument.
3356 **
3357 **	Returns:
3358 **		randomly 1/-1
3359 */
3360 
3361 /* ARGSUSED0 */
3362 static int
workcmpf5(a,b)3363 workcmpf5(a, b)
3364 	register WORK *a;
3365 	register WORK *b;
3366 {
3367 	if (strlen(a->w_name) < randi || strlen(b->w_name) < randi)
3368 		return -1;
3369 	return a->w_name[randi] - b->w_name[randi];
3370 }
3371 /*
3372 **  WORKCMPF6 -- simple modification-time-only compare function.
3373 **
3374 **	Parameters:
3375 **		a -- the first argument.
3376 **		b -- the second argument.
3377 **
3378 **	Returns:
3379 **		-1 if a < b
3380 **		 0 if a == b
3381 **		+1 if a > b
3382 **
3383 */
3384 
3385 static int
workcmpf6(a,b)3386 workcmpf6(a, b)
3387 	register WORK *a;
3388 	register WORK *b;
3389 {
3390 	if (a->w_mtime > b->w_mtime)
3391 		return 1;
3392 	else if (a->w_mtime < b->w_mtime)
3393 		return -1;
3394 	else
3395 		return 0;
3396 }
3397 #if _FFR_RHS
3398 /*
3399 **  WORKCMPF7 -- compare function for ordering work based on shuffled host name.
3400 **
3401 **	Sorts on lock status, host name, and priority in that order.
3402 **
3403 **	Parameters:
3404 **		a -- the first argument.
3405 **		b -- the second argument.
3406 **
3407 **	Returns:
3408 **		<0 if a < b
3409 **		 0 if a == b
3410 **		>0 if a > b
3411 **
3412 */
3413 
3414 static int
workcmpf7(a,b)3415 workcmpf7(a, b)
3416 	register WORK *a;
3417 	register WORK *b;
3418 {
3419 	int i;
3420 
3421 	/* lock status */
3422 	if (a->w_lock != b->w_lock)
3423 		return a->w_lock - b->w_lock;
3424 
3425 	/* host name */
3426 	if (a->w_host != NULL && b->w_host == NULL)
3427 		return 1;
3428 	else if (a->w_host == NULL && b->w_host != NULL)
3429 		return -1;
3430 	if (a->w_host != NULL && b->w_host != NULL &&
3431 	    (i = sm_strshufflecmp(a->w_host, b->w_host)) != 0)
3432 		return i;
3433 
3434 	/* job priority */
3435 	return workcmpf0(a, b);
3436 }
3437 #endif /* _FFR_RHS */
3438 /*
3439 **  STRREV -- reverse string
3440 **
3441 **	Returns a pointer to a new string that is the reverse of
3442 **	the string pointed to by fwd.  The space for the new
3443 **	string is obtained using xalloc().
3444 **
3445 **	Parameters:
3446 **		fwd -- the string to reverse.
3447 **
3448 **	Returns:
3449 **		the reversed string.
3450 */
3451 
3452 static char *
strrev(fwd)3453 strrev(fwd)
3454 	char *fwd;
3455 {
3456 	char *rev = NULL;
3457 	int len, cnt;
3458 
3459 	len = strlen(fwd);
3460 	rev = xalloc(len + 1);
3461 	for (cnt = 0; cnt < len; ++cnt)
3462 		rev[cnt] = fwd[len - cnt - 1];
3463 	rev[len] = '\0';
3464 	return rev;
3465 }
3466 
3467 #if _FFR_RHS
3468 
3469 # define NASCII	128
3470 # define NCHAR	256
3471 
3472 static unsigned char ShuffledAlphabet[NCHAR];
3473 
3474 void
init_shuffle_alphabet()3475 init_shuffle_alphabet()
3476 {
3477 	static bool init = false;
3478 	int i;
3479 
3480 	if (init)
3481 		return;
3482 
3483 	/* fill the ShuffledAlphabet */
3484 	for (i = 0; i < NASCII; i++)
3485 		ShuffledAlphabet[i] = i;
3486 
3487 	/* mix it */
3488 	for (i = 1; i < NASCII; i++)
3489 	{
3490 		register int j = get_random() % NASCII;
3491 		register int tmp;
3492 
3493 		tmp = ShuffledAlphabet[j];
3494 		ShuffledAlphabet[j] = ShuffledAlphabet[i];
3495 		ShuffledAlphabet[i] = tmp;
3496 	}
3497 
3498 	/* make it case insensitive */
3499 	for (i = 'A'; i <= 'Z'; i++)
3500 		ShuffledAlphabet[i] = ShuffledAlphabet[i + 'a' - 'A'];
3501 
3502 	/* fill the upper part */
3503 	for (i = 0; i < NASCII; i++)
3504 		ShuffledAlphabet[i + NASCII] = ShuffledAlphabet[i];
3505 	init = true;
3506 }
3507 
3508 static int
sm_strshufflecmp(a,b)3509 sm_strshufflecmp(a, b)
3510 	char *a;
3511 	char *b;
3512 {
3513 	const unsigned char *us1 = (const unsigned char *) a;
3514 	const unsigned char *us2 = (const unsigned char *) b;
3515 
3516 	while (ShuffledAlphabet[*us1] == ShuffledAlphabet[*us2++])
3517 	{
3518 		if (*us1++ == '\0')
3519 			return 0;
3520 	}
3521 	return (ShuffledAlphabet[*us1] - ShuffledAlphabet[*--us2]);
3522 }
3523 #endif /* _FFR_RHS */
3524 
3525 /*
3526 **  DOWORK -- do a work request.
3527 **
3528 **	Parameters:
3529 **		qgrp -- the index of the queue group for the job.
3530 **		qdir -- the index of the queue directory for the job.
3531 **		id -- the ID of the job to run.
3532 **		forkflag -- if set, run this in background.
3533 **		requeueflag -- if set, reinstantiate the queue quickly.
3534 **			This is used when expanding aliases in the queue.
3535 **			If forkflag is also set, it doesn't wait for the
3536 **			child.
3537 **		e - the envelope in which to run it.
3538 **
3539 **	Returns:
3540 **		process id of process that is running the queue job.
3541 **
3542 **	Side Effects:
3543 **		The work request is satisfied if possible.
3544 */
3545 
3546 pid_t
dowork(qgrp,qdir,id,forkflag,requeueflag,e)3547 dowork(qgrp, qdir, id, forkflag, requeueflag, e)
3548 	int qgrp;
3549 	int qdir;
3550 	char *id;
3551 	bool forkflag;
3552 	bool requeueflag;
3553 	register ENVELOPE *e;
3554 {
3555 	register pid_t pid;
3556 	SM_RPOOL_T *rpool;
3557 
3558 	if (tTd(40, 1))
3559 		sm_dprintf("dowork(%s/%s)\n", qid_printqueue(qgrp, qdir), id);
3560 
3561 	/*
3562 	**  Fork for work.
3563 	*/
3564 
3565 	if (forkflag)
3566 	{
3567 		/*
3568 		**  Since the delivery may happen in a child and the
3569 		**  parent does not wait, the parent may close the
3570 		**  maps thereby removing any shared memory used by
3571 		**  the map.  Therefore, close the maps now so the
3572 		**  child will dynamically open them if necessary.
3573 		*/
3574 
3575 		closemaps(false);
3576 
3577 		pid = fork();
3578 		if (pid < 0)
3579 		{
3580 			syserr("dowork: cannot fork");
3581 			return 0;
3582 		}
3583 		else if (pid > 0)
3584 		{
3585 			/* parent -- clean out connection cache */
3586 			mci_flush(false, NULL);
3587 		}
3588 		else
3589 		{
3590 			/*
3591 			**  Initialize exception stack and default exception
3592 			**  handler for child process.
3593 			*/
3594 
3595 			/* Reset global flags */
3596 			RestartRequest = NULL;
3597 			RestartWorkGroup = false;
3598 			ShutdownRequest = NULL;
3599 			PendingSignal = 0;
3600 			CurrentPid = getpid();
3601 			sm_exc_newthread(fatal_error);
3602 
3603 			/*
3604 			**  See note above about SMTP processes and SIGCHLD.
3605 			*/
3606 
3607 			if (OpMode == MD_SMTP ||
3608 			    OpMode == MD_DAEMON ||
3609 			    MaxQueueChildren > 0)
3610 			{
3611 				proc_list_clear();
3612 				sm_releasesignal(SIGCHLD);
3613 				(void) sm_signal(SIGCHLD, SIG_DFL);
3614 			}
3615 
3616 			/* child -- error messages to the transcript */
3617 			QuickAbort = OnlyOneError = false;
3618 		}
3619 	}
3620 	else
3621 	{
3622 		pid = 0;
3623 	}
3624 
3625 	if (pid == 0)
3626 	{
3627 		/*
3628 		**  CHILD
3629 		**	Lock the control file to avoid duplicate deliveries.
3630 		**		Then run the file as though we had just read it.
3631 		**	We save an idea of the temporary name so we
3632 		**		can recover on interrupt.
3633 		*/
3634 
3635 		if (forkflag)
3636 		{
3637 			/* Reset global flags */
3638 			RestartRequest = NULL;
3639 			RestartWorkGroup = false;
3640 			ShutdownRequest = NULL;
3641 			PendingSignal = 0;
3642 		}
3643 
3644 		/* set basic modes, etc. */
3645 		sm_clear_events();
3646 		clearstats();
3647 		rpool = sm_rpool_new_x(NULL);
3648 		clearenvelope(e, false, rpool);
3649 		e->e_flags |= EF_QUEUERUN|EF_GLOBALERRS;
3650 		set_delivery_mode(SM_DELIVER, e);
3651 		e->e_errormode = EM_MAIL;
3652 		e->e_id = id;
3653 		e->e_qgrp = qgrp;
3654 		e->e_qdir = qdir;
3655 		GrabTo = UseErrorsTo = false;
3656 		ExitStat = EX_OK;
3657 		if (forkflag)
3658 		{
3659 			disconnect(1, e);
3660 			set_op_mode(MD_QUEUERUN);
3661 		}
3662 		sm_setproctitle(true, e, "%s from queue", qid_printname(e));
3663 		if (LogLevel > 76)
3664 			sm_syslog(LOG_DEBUG, e->e_id, "dowork, pid=%d",
3665 				  (int) CurrentPid);
3666 
3667 		/* don't use the headers from sendmail.cf... */
3668 		e->e_header = NULL;
3669 
3670 		/* read the queue control file -- return if locked */
3671 		if (!readqf(e, false))
3672 		{
3673 			if (tTd(40, 4) && e->e_id != NULL)
3674 				sm_dprintf("readqf(%s) failed\n",
3675 					qid_printname(e));
3676 			e->e_id = NULL;
3677 			if (forkflag)
3678 				finis(false, true, EX_OK);
3679 			else
3680 			{
3681 				/* adding this frees 8 bytes */
3682 				clearenvelope(e, false, rpool);
3683 
3684 				/* adding this frees 12 bytes */
3685 				sm_rpool_free(rpool);
3686 				e->e_rpool = NULL;
3687 				return 0;
3688 			}
3689 		}
3690 
3691 		e->e_flags |= EF_INQUEUE;
3692 		eatheader(e, requeueflag, true);
3693 
3694 		if (requeueflag)
3695 			queueup(e, false, false);
3696 
3697 		/* do the delivery */
3698 		sendall(e, SM_DELIVER);
3699 
3700 		/* finish up and exit */
3701 		if (forkflag)
3702 			finis(true, true, ExitStat);
3703 		else
3704 		{
3705 			(void) dropenvelope(e, true, false);
3706 			sm_rpool_free(rpool);
3707 			e->e_rpool = NULL;
3708 		}
3709 	}
3710 	e->e_id = NULL;
3711 	return pid;
3712 }
3713 
3714 /*
3715 **  DOWORKLIST -- process a list of envelopes as work requests
3716 **
3717 **	Similar to dowork(), except that after forking, it processes an
3718 **	envelope and its siblings, treating each envelope as a work request.
3719 **
3720 **	Parameters:
3721 **		el -- envelope to be processed including its siblings.
3722 **		forkflag -- if set, run this in background.
3723 **		requeueflag -- if set, reinstantiate the queue quickly.
3724 **			This is used when expanding aliases in the queue.
3725 **			If forkflag is also set, it doesn't wait for the
3726 **			child.
3727 **
3728 **	Returns:
3729 **		process id of process that is running the queue job.
3730 **
3731 **	Side Effects:
3732 **		The work request is satisfied if possible.
3733 */
3734 
3735 pid_t
doworklist(el,forkflag,requeueflag)3736 doworklist(el, forkflag, requeueflag)
3737 	ENVELOPE *el;
3738 	bool forkflag;
3739 	bool requeueflag;
3740 {
3741 	register pid_t pid;
3742 	ENVELOPE *ei;
3743 
3744 	if (tTd(40, 1))
3745 		sm_dprintf("doworklist()\n");
3746 
3747 	/*
3748 	**  Fork for work.
3749 	*/
3750 
3751 	if (forkflag)
3752 	{
3753 		/*
3754 		**  Since the delivery may happen in a child and the
3755 		**  parent does not wait, the parent may close the
3756 		**  maps thereby removing any shared memory used by
3757 		**  the map.  Therefore, close the maps now so the
3758 		**  child will dynamically open them if necessary.
3759 		*/
3760 
3761 		closemaps(false);
3762 
3763 		pid = fork();
3764 		if (pid < 0)
3765 		{
3766 			syserr("doworklist: cannot fork");
3767 			return 0;
3768 		}
3769 		else if (pid > 0)
3770 		{
3771 			/* parent -- clean out connection cache */
3772 			mci_flush(false, NULL);
3773 		}
3774 		else
3775 		{
3776 			/*
3777 			**  Initialize exception stack and default exception
3778 			**  handler for child process.
3779 			*/
3780 
3781 			/* Reset global flags */
3782 			RestartRequest = NULL;
3783 			RestartWorkGroup = false;
3784 			ShutdownRequest = NULL;
3785 			PendingSignal = 0;
3786 			CurrentPid = getpid();
3787 			sm_exc_newthread(fatal_error);
3788 
3789 			/*
3790 			**  See note above about SMTP processes and SIGCHLD.
3791 			*/
3792 
3793 			if (OpMode == MD_SMTP ||
3794 			    OpMode == MD_DAEMON ||
3795 			    MaxQueueChildren > 0)
3796 			{
3797 				proc_list_clear();
3798 				sm_releasesignal(SIGCHLD);
3799 				(void) sm_signal(SIGCHLD, SIG_DFL);
3800 			}
3801 
3802 			/* child -- error messages to the transcript */
3803 			QuickAbort = OnlyOneError = false;
3804 		}
3805 	}
3806 	else
3807 	{
3808 		pid = 0;
3809 	}
3810 
3811 	if (pid != 0)
3812 		return pid;
3813 
3814 	/*
3815 	**  IN CHILD
3816 	**	Lock the control file to avoid duplicate deliveries.
3817 	**		Then run the file as though we had just read it.
3818 	**	We save an idea of the temporary name so we
3819 	**		can recover on interrupt.
3820 	*/
3821 
3822 	if (forkflag)
3823 	{
3824 		/* Reset global flags */
3825 		RestartRequest = NULL;
3826 		RestartWorkGroup = false;
3827 		ShutdownRequest = NULL;
3828 		PendingSignal = 0;
3829 	}
3830 
3831 	/* set basic modes, etc. */
3832 	sm_clear_events();
3833 	clearstats();
3834 	GrabTo = UseErrorsTo = false;
3835 	ExitStat = EX_OK;
3836 	if (forkflag)
3837 	{
3838 		disconnect(1, el);
3839 		set_op_mode(MD_QUEUERUN);
3840 	}
3841 	if (LogLevel > 76)
3842 		sm_syslog(LOG_DEBUG, el->e_id, "doworklist, pid=%d",
3843 			  (int) CurrentPid);
3844 
3845 	for (ei = el; ei != NULL; ei = ei->e_sibling)
3846 	{
3847 		ENVELOPE e;
3848 		SM_RPOOL_T *rpool;
3849 
3850 		if (WILL_BE_QUEUED(ei->e_sendmode))
3851 			continue;
3852 		else if (QueueMode != QM_QUARANTINE &&
3853 			 ei->e_quarmsg != NULL)
3854 			continue;
3855 
3856 		rpool = sm_rpool_new_x(NULL);
3857 		clearenvelope(&e, true, rpool);
3858 		e.e_flags |= EF_QUEUERUN|EF_GLOBALERRS;
3859 		set_delivery_mode(SM_DELIVER, &e);
3860 		e.e_errormode = EM_MAIL;
3861 		e.e_id = ei->e_id;
3862 		e.e_qgrp = ei->e_qgrp;
3863 		e.e_qdir = ei->e_qdir;
3864 		openxscript(&e);
3865 		sm_setproctitle(true, &e, "%s from queue", qid_printname(&e));
3866 
3867 		/* don't use the headers from sendmail.cf... */
3868 		e.e_header = NULL;
3869 		CurEnv = &e;
3870 
3871 		/* read the queue control file -- return if locked */
3872 		if (readqf(&e, false))
3873 		{
3874 			e.e_flags |= EF_INQUEUE;
3875 			eatheader(&e, requeueflag, true);
3876 
3877 			if (requeueflag)
3878 				queueup(&e, false, false);
3879 
3880 			/* do the delivery */
3881 			sendall(&e, SM_DELIVER);
3882 			(void) dropenvelope(&e, true, false);
3883 		}
3884 		else
3885 		{
3886 			if (tTd(40, 4) && e.e_id != NULL)
3887 				sm_dprintf("readqf(%s) failed\n",
3888 					qid_printname(&e));
3889 		}
3890 		sm_rpool_free(rpool);
3891 		ei->e_id = NULL;
3892 	}
3893 
3894 	/* restore CurEnv */
3895 	CurEnv = el;
3896 
3897 	/* finish up and exit */
3898 	if (forkflag)
3899 		finis(true, true, ExitStat);
3900 	return 0;
3901 }
3902 /*
3903 **  READQF -- read queue file and set up environment.
3904 **
3905 **	Parameters:
3906 **		e -- the envelope of the job to run.
3907 **		openonly -- only open the qf (returned as e_lockfp)
3908 **
3909 **	Returns:
3910 **		true if it successfully read the queue file.
3911 **		false otherwise.
3912 **
3913 **	Side Effects:
3914 **		The queue file is returned locked.
3915 */
3916 
3917 static bool
readqf(e,openonly)3918 readqf(e, openonly)
3919 	register ENVELOPE *e;
3920 	bool openonly;
3921 {
3922 	register SM_FILE_T *qfp;
3923 	ADDRESS *ctladdr;
3924 	struct stat st, stf;
3925 	char *bp;
3926 	int qfver = 0;
3927 	long hdrsize = 0;
3928 	register char *p;
3929 	char *frcpt = NULL;
3930 	char *orcpt = NULL;
3931 	bool nomore = false;
3932 	bool bogus = false;
3933 	MODE_T qsafe;
3934 	char *err;
3935 	char qf[MAXPATHLEN];
3936 	char buf[MAXLINE];
3937 	int bufsize;
3938 
3939 	/*
3940 	**  Read and process the file.
3941 	*/
3942 
3943 	SM_REQUIRE(e != NULL);
3944 	bp = NULL;
3945 	(void) sm_strlcpy(qf, queuename(e, ANYQFL_LETTER), sizeof(qf));
3946 	qfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, qf, SM_IO_RDWR_B, NULL);
3947 	if (qfp == NULL)
3948 	{
3949 		int save_errno = errno;
3950 
3951 		if (tTd(40, 8))
3952 			sm_dprintf("readqf(%s): sm_io_open failure (%s)\n",
3953 				qf, sm_errstring(errno));
3954 		errno = save_errno;
3955 		if (errno != ENOENT
3956 		    )
3957 			syserr("readqf: no control file %s", qf);
3958 		RELEASE_QUEUE;
3959 		return false;
3960 	}
3961 
3962 	if (!lockfile(sm_io_getinfo(qfp, SM_IO_WHAT_FD, NULL), qf, NULL,
3963 		      LOCK_EX|LOCK_NB))
3964 	{
3965 		/* being processed by another queuer */
3966 		if (Verbose)
3967 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3968 					     "%s: locked\n", e->e_id);
3969 		if (tTd(40, 8))
3970 			sm_dprintf("%s: locked\n", e->e_id);
3971 		if (LogLevel > 19)
3972 			sm_syslog(LOG_DEBUG, e->e_id, "locked");
3973 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
3974 		RELEASE_QUEUE;
3975 		return false;
3976 	}
3977 
3978 	RELEASE_QUEUE;
3979 
3980 	/*
3981 	**  Prevent locking race condition.
3982 	**
3983 	**  Process A: readqf(): qfp = fopen(qffile)
3984 	**  Process B: queueup(): rename(tf, qf)
3985 	**  Process B: unlocks(tf)
3986 	**  Process A: lockfile(qf);
3987 	**
3988 	**  Process A (us) has the old qf file (before the rename deleted
3989 	**  the directory entry) and will be delivering based on old data.
3990 	**  This can lead to multiple deliveries of the same recipients.
3991 	**
3992 	**  Catch this by checking if the underlying qf file has changed
3993 	**  *after* acquiring our lock and if so, act as though the file
3994 	**  was still locked (i.e., just return like the lockfile() case
3995 	**  above.
3996 	*/
3997 
3998 	if (stat(qf, &stf) < 0 ||
3999 	    fstat(sm_io_getinfo(qfp, SM_IO_WHAT_FD, NULL), &st) < 0)
4000 	{
4001 		/* must have been being processed by someone else */
4002 		if (tTd(40, 8))
4003 			sm_dprintf("readqf(%s): [f]stat failure (%s)\n",
4004 				qf, sm_errstring(errno));
4005 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4006 		return false;
4007 	}
4008 
4009 	if (st.st_nlink != stf.st_nlink ||
4010 	    st.st_dev != stf.st_dev ||
4011 	    ST_INODE(st) != ST_INODE(stf) ||
4012 #if HAS_ST_GEN && 0		/* AFS returns garbage in st_gen */
4013 	    st.st_gen != stf.st_gen ||
4014 #endif /* HAS_ST_GEN && 0 */
4015 	    st.st_uid != stf.st_uid ||
4016 	    st.st_gid != stf.st_gid ||
4017 	    st.st_size != stf.st_size)
4018 	{
4019 		/* changed after opened */
4020 		if (Verbose)
4021 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4022 					     "%s: changed\n", e->e_id);
4023 		if (tTd(40, 8))
4024 			sm_dprintf("%s: changed\n", e->e_id);
4025 		if (LogLevel > 19)
4026 			sm_syslog(LOG_DEBUG, e->e_id, "changed");
4027 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4028 		return false;
4029 	}
4030 
4031 	/*
4032 	**  Check the queue file for plausibility to avoid attacks.
4033 	*/
4034 
4035 	qsafe = S_IWOTH|S_IWGRP;
4036 	if (bitset(S_IWGRP, QueueFileMode))
4037 		qsafe &= ~S_IWGRP;
4038 
4039 	bogus = st.st_uid != geteuid() &&
4040 		st.st_uid != TrustedUid &&
4041 		geteuid() != RealUid;
4042 
4043 	/*
4044 	**  If this qf file results from a set-group-ID binary, then
4045 	**  we check whether the directory is group-writable,
4046 	**  the queue file mode contains the group-writable bit, and
4047 	**  the groups are the same.
4048 	**  Notice: this requires that the set-group-ID binary is used to
4049 	**  run the queue!
4050 	*/
4051 
4052 	if (bogus && st.st_gid == getegid() && UseMSP)
4053 	{
4054 		char delim;
4055 		struct stat dst;
4056 
4057 		bp = SM_LAST_DIR_DELIM(qf);
4058 		if (bp == NULL)
4059 			delim = '\0';
4060 		else
4061 		{
4062 			delim = *bp;
4063 			*bp = '\0';
4064 		}
4065 		if (stat(delim == '\0' ? "." : qf, &dst) < 0)
4066 			syserr("readqf: cannot stat directory %s",
4067 				delim == '\0' ? "." : qf);
4068 		else
4069 		{
4070 			bogus = !(bitset(S_IWGRP, QueueFileMode) &&
4071 				  bitset(S_IWGRP, dst.st_mode) &&
4072 				  dst.st_gid == st.st_gid);
4073 		}
4074 		if (delim != '\0')
4075 			*bp = delim;
4076 		bp = NULL;
4077 	}
4078 	if (!bogus)
4079 		bogus = bitset(qsafe, st.st_mode);
4080 	if (bogus)
4081 	{
4082 		if (LogLevel > 0)
4083 		{
4084 			sm_syslog(LOG_ALERT, e->e_id,
4085 				  "bogus queue file, uid=%d, gid=%d, mode=%o",
4086 				  st.st_uid, st.st_gid, st.st_mode);
4087 		}
4088 		if (tTd(40, 8))
4089 			sm_dprintf("readqf(%s): bogus file\n", qf);
4090 		e->e_flags |= EF_INQUEUE;
4091 		if (!openonly)
4092 			loseqfile(e, "bogus file uid/gid in mqueue");
4093 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4094 		return false;
4095 	}
4096 
4097 	if (st.st_size == 0)
4098 	{
4099 		/* must be a bogus file -- if also old, just remove it */
4100 		if (!openonly && st.st_ctime + 10 * 60 < curtime())
4101 		{
4102 			(void) xunlink(queuename(e, DATAFL_LETTER));
4103 			(void) xunlink(queuename(e, ANYQFL_LETTER));
4104 		}
4105 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4106 		return false;
4107 	}
4108 
4109 	if (st.st_nlink == 0)
4110 	{
4111 		/*
4112 		**  Race condition -- we got a file just as it was being
4113 		**  unlinked.  Just assume it is zero length.
4114 		*/
4115 
4116 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4117 		return false;
4118 	}
4119 
4120 #if _FFR_TRUSTED_QF
4121 	/*
4122 	**  If we don't own the file mark it as unsafe.
4123 	**  However, allow TrustedUser to own it as well
4124 	**  in case TrustedUser manipulates the queue.
4125 	*/
4126 
4127 	if (st.st_uid != geteuid() && st.st_uid != TrustedUid)
4128 		e->e_flags |= EF_UNSAFE;
4129 #else /* _FFR_TRUSTED_QF */
4130 	/* If we don't own the file mark it as unsafe */
4131 	if (st.st_uid != geteuid())
4132 		e->e_flags |= EF_UNSAFE;
4133 #endif /* _FFR_TRUSTED_QF */
4134 
4135 	/* good file -- save this lock */
4136 	e->e_lockfp = qfp;
4137 
4138 	/* Just wanted the open file */
4139 	if (openonly)
4140 		return true;
4141 
4142 	/* do basic system initialization */
4143 	initsys(e);
4144 	macdefine(&e->e_macro, A_PERM, 'i', e->e_id);
4145 
4146 	LineNumber = 0;
4147 	e->e_flags |= EF_GLOBALERRS;
4148 	set_op_mode(MD_QUEUERUN);
4149 	ctladdr = NULL;
4150 	e->e_qfletter = queue_letter(e, ANYQFL_LETTER);
4151 	e->e_dfqgrp = e->e_qgrp;
4152 	e->e_dfqdir = e->e_qdir;
4153 #if _FFR_QUEUE_MACRO
4154 	macdefine(&e->e_macro, A_TEMP, macid("{queue}"),
4155 		  qid_printqueue(e->e_qgrp, e->e_qdir));
4156 #endif /* _FFR_QUEUE_MACRO */
4157 	e->e_dfino = -1;
4158 	e->e_msgsize = -1;
4159 	while (bufsize = sizeof(buf),
4160 	       (bp = fgetfolded(buf, &bufsize, qfp)) != NULL)
4161 	{
4162 		unsigned long qflags;
4163 		ADDRESS *q;
4164 		int r;
4165 		time_t now;
4166 		auto char *ep;
4167 
4168 		if (tTd(40, 4))
4169 			sm_dprintf("+++++ %s\n", bp);
4170 		if (nomore)
4171 		{
4172 			/* hack attack */
4173   hackattack:
4174 			syserr("SECURITY ALERT: extra or bogus data in queue file: %s",
4175 			       bp);
4176 			err = "bogus queue line";
4177 			goto fail;
4178 		}
4179 		switch (bp[0])
4180 		{
4181 		  case 'A':		/* AUTH= parameter */
4182 			if (!xtextok(&bp[1]))
4183 				goto hackattack;
4184 			e->e_auth_param = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4185 			break;
4186 
4187 		  case 'B':		/* body type */
4188 			r = check_bodytype(&bp[1]);
4189 			if (!BODYTYPE_VALID(r))
4190 				goto hackattack;
4191 			e->e_bodytype = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4192 			break;
4193 
4194 		  case 'C':		/* specify controlling user */
4195 			ctladdr = setctluser(&bp[1], qfver, e);
4196 			break;
4197 
4198 		  case 'D':		/* data file name */
4199 			/* obsolete -- ignore */
4200 			break;
4201 
4202 		  case 'd':		/* data file directory name */
4203 			{
4204 				int qgrp, qdir;
4205 
4206 #if _FFR_MSP_PARANOIA
4207 				/* forbid queue groups in MSP? */
4208 				if (UseMSP)
4209 					goto hackattack;
4210 #endif /* _FFR_MSP_PARANOIA */
4211 				for (qgrp = 0;
4212 				     qgrp < NumQueue && Queue[qgrp] != NULL;
4213 				     ++qgrp)
4214 				{
4215 					for (qdir = 0;
4216 					     qdir < Queue[qgrp]->qg_numqueues;
4217 					     ++qdir)
4218 					{
4219 						if (strcmp(&bp[1],
4220 							   Queue[qgrp]->qg_qpaths[qdir].qp_name)
4221 						    == 0)
4222 						{
4223 							e->e_dfqgrp = qgrp;
4224 							e->e_dfqdir = qdir;
4225 							goto done;
4226 						}
4227 					}
4228 				}
4229 				err = "bogus queue file directory";
4230 				goto fail;
4231 			  done:
4232 				break;
4233 			}
4234 
4235 		  case 'E':		/* specify error recipient */
4236 			/* no longer used */
4237 			break;
4238 
4239 		  case 'F':		/* flag bits */
4240 			if (strncmp(bp, "From ", 5) == 0)
4241 			{
4242 				/* we are being spoofed! */
4243 				syserr("SECURITY ALERT: bogus qf line %s", bp);
4244 				err = "bogus queue line";
4245 				goto fail;
4246 			}
4247 			for (p = &bp[1]; *p != '\0'; p++)
4248 			{
4249 				switch (*p)
4250 				{
4251 				  case '8':	/* has 8 bit data */
4252 					e->e_flags |= EF_HAS8BIT;
4253 					break;
4254 
4255 				  case 'b':	/* delete Bcc: header */
4256 					e->e_flags |= EF_DELETE_BCC;
4257 					break;
4258 
4259 				  case 'd':	/* envelope has DSN RET= */
4260 					e->e_flags |= EF_RET_PARAM;
4261 					break;
4262 
4263 				  case 'n':	/* don't return body */
4264 					e->e_flags |= EF_NO_BODY_RETN;
4265 					break;
4266 
4267 				  case 'r':	/* response */
4268 					e->e_flags |= EF_RESPONSE;
4269 					break;
4270 
4271 				  case 's':	/* split */
4272 					e->e_flags |= EF_SPLIT;
4273 					break;
4274 
4275 				  case 'w':	/* warning sent */
4276 					e->e_flags |= EF_WARNING;
4277 					break;
4278 				}
4279 			}
4280 			break;
4281 
4282 		  case 'q':		/* quarantine reason */
4283 			e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4284 			macdefine(&e->e_macro, A_PERM,
4285 				  macid("{quarantine}"), e->e_quarmsg);
4286 			break;
4287 
4288 		  case 'H':		/* header */
4289 
4290 			/*
4291 			**  count size before chompheader() destroys the line.
4292 			**  this isn't accurate due to macro expansion, but
4293 			**  better than before. "-3" to skip H?? at least.
4294 			*/
4295 
4296 			hdrsize += strlen(bp) - 3;
4297 			(void) chompheader(&bp[1], CHHDR_QUEUE, NULL, e);
4298 			break;
4299 
4300 		  case 'I':		/* data file's inode number */
4301 			/* regenerated below */
4302 			break;
4303 
4304 		  case 'K':		/* time of last delivery attempt */
4305 			e->e_dtime = atol(&buf[1]);
4306 			break;
4307 
4308 		  case 'L':		/* Solaris Content-Length: */
4309 		  case 'M':		/* message */
4310 			/* ignore this; we want a new message next time */
4311 			break;
4312 
4313 		  case 'N':		/* number of delivery attempts */
4314 			e->e_ntries = atoi(&buf[1]);
4315 
4316 			/* if this has been tried recently, let it be */
4317 			now = curtime();
4318 			if (e->e_ntries > 0 && e->e_dtime <= now &&
4319 			    now < e->e_dtime + MinQueueAge)
4320 			{
4321 				char *howlong;
4322 
4323 				howlong = pintvl(now - e->e_dtime, true);
4324 				if (Verbose)
4325 					(void) sm_io_fprintf(smioout,
4326 							     SM_TIME_DEFAULT,
4327 							     "%s: too young (%s)\n",
4328 							     e->e_id, howlong);
4329 				if (tTd(40, 8))
4330 					sm_dprintf("%s: too young (%s)\n",
4331 						e->e_id, howlong);
4332 				if (LogLevel > 19)
4333 					sm_syslog(LOG_DEBUG, e->e_id,
4334 						  "too young (%s)",
4335 						  howlong);
4336 				e->e_id = NULL;
4337 				unlockqueue(e);
4338 				if (bp != buf)
4339 					sm_free(bp);
4340 				return false;
4341 			}
4342 			macdefine(&e->e_macro, A_TEMP,
4343 				macid("{ntries}"), &buf[1]);
4344 
4345 #if NAMED_BIND
4346 			/* adjust BIND parameters immediately */
4347 			if (e->e_ntries == 0)
4348 			{
4349 				_res.retry = TimeOuts.res_retry[RES_TO_FIRST];
4350 				_res.retrans = TimeOuts.res_retrans[RES_TO_FIRST];
4351 			}
4352 			else
4353 			{
4354 				_res.retry = TimeOuts.res_retry[RES_TO_NORMAL];
4355 				_res.retrans = TimeOuts.res_retrans[RES_TO_NORMAL];
4356 			}
4357 #endif /* NAMED_BIND */
4358 			break;
4359 
4360 		  case 'P':		/* message priority */
4361 			e->e_msgpriority = atol(&bp[1]) + WkTimeFact;
4362 			break;
4363 
4364 		  case 'Q':		/* original recipient */
4365 			orcpt = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4366 			break;
4367 
4368 		  case 'r':		/* final recipient */
4369 			frcpt = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4370 			break;
4371 
4372 		  case 'R':		/* specify recipient */
4373 			p = bp;
4374 			qflags = 0;
4375 			if (qfver >= 1)
4376 			{
4377 				/* get flag bits */
4378 				while (*++p != '\0' && *p != ':')
4379 				{
4380 					switch (*p)
4381 					{
4382 					  case 'N':
4383 						qflags |= QHASNOTIFY;
4384 						break;
4385 
4386 					  case 'S':
4387 						qflags |= QPINGONSUCCESS;
4388 						break;
4389 
4390 					  case 'F':
4391 						qflags |= QPINGONFAILURE;
4392 						break;
4393 
4394 					  case 'D':
4395 						qflags |= QPINGONDELAY;
4396 						break;
4397 
4398 					  case 'P':
4399 						qflags |= QPRIMARY;
4400 						break;
4401 
4402 					  case 'A':
4403 						if (ctladdr != NULL)
4404 							ctladdr->q_flags |= QALIAS;
4405 						break;
4406 
4407 					  default: /* ignore or complain? */
4408 						break;
4409 					}
4410 				}
4411 			}
4412 			else
4413 				qflags |= QPRIMARY;
4414 			macdefine(&e->e_macro, A_PERM, macid("{addr_type}"),
4415 				"e r");
4416 			if (*p != '\0')
4417 				q = parseaddr(++p, NULLADDR, RF_COPYALL, '\0',
4418 						NULL, e, true);
4419 			else
4420 				q = NULL;
4421 			if (q != NULL)
4422 			{
4423 				/* make sure we keep the current qgrp */
4424 				if (ISVALIDQGRP(e->e_qgrp))
4425 					q->q_qgrp = e->e_qgrp;
4426 				q->q_alias = ctladdr;
4427 				if (qfver >= 1)
4428 					q->q_flags &= ~Q_PINGFLAGS;
4429 				q->q_flags |= qflags;
4430 				q->q_finalrcpt = frcpt;
4431 				q->q_orcpt = orcpt;
4432 				(void) recipient(q, &e->e_sendqueue, 0, e);
4433 			}
4434 			frcpt = NULL;
4435 			orcpt = NULL;
4436 			macdefine(&e->e_macro, A_PERM, macid("{addr_type}"),
4437 				NULL);
4438 			break;
4439 
4440 		  case 'S':		/* sender */
4441 			setsender(sm_rpool_strdup_x(e->e_rpool, &bp[1]),
4442 				  e, NULL, '\0', true);
4443 			break;
4444 
4445 		  case 'T':		/* init time */
4446 			e->e_ctime = atol(&bp[1]);
4447 			break;
4448 
4449 		  case 'V':		/* queue file version number */
4450 			qfver = atoi(&bp[1]);
4451 			if (qfver <= QF_VERSION)
4452 				break;
4453 			syserr("Version number in queue file (%d) greater than max (%d)",
4454 				qfver, QF_VERSION);
4455 			err = "unsupported queue file version";
4456 			goto fail;
4457 			/* NOTREACHED */
4458 			break;
4459 
4460 		  case 'Z':		/* original envelope id from ESMTP */
4461 			e->e_envid = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4462 			macdefine(&e->e_macro, A_PERM,
4463 				macid("{dsn_envid}"), e->e_envid);
4464 			break;
4465 
4466 		  case '!':		/* deliver by */
4467 
4468 			/* format: flag (1 char) space long-integer */
4469 			e->e_dlvr_flag = buf[1];
4470 			e->e_deliver_by = strtol(&buf[3], NULL, 10);
4471 			/* FALLTHROUGH */
4472 
4473 		  case '$':		/* define macro */
4474 			{
4475 				char *p;
4476 
4477 				/* XXX elimate p? */
4478 				r = macid_parse(&bp[1], &ep);
4479 				if (r == 0)
4480 					break;
4481 				p = sm_rpool_strdup_x(e->e_rpool, ep);
4482 				macdefine(&e->e_macro, A_PERM, r, p);
4483 			}
4484 			break;
4485 
4486 		  case '.':		/* terminate file */
4487 			nomore = true;
4488 			break;
4489 
4490 #if _FFR_QUEUEDELAY
4491 		  case 'G':
4492 		  case 'Y':
4493 
4494 			/*
4495 			**  Maintain backward compatibility for
4496 			**  users who defined _FFR_QUEUEDELAY in
4497 			**  previous releases.  Remove this
4498 			**  code in 8.14 or 8.15.
4499 			*/
4500 
4501 			if (qfver == 5 || qfver == 7)
4502 				break;
4503 
4504 			/* If not qfver 5 or 7, then 'G' or 'Y' is invalid */
4505 			/* FALLTHROUGH */
4506 #endif /* _FFR_QUEUEDELAY */
4507 
4508 		  default:
4509 			syserr("readqf: %s: line %d: bad line \"%s\"",
4510 				qf, LineNumber, shortenstring(bp, MAXSHORTSTR));
4511 			err = "unrecognized line";
4512 			goto fail;
4513 		}
4514 
4515 		if (bp != buf)
4516 			SM_FREE(bp);
4517 	}
4518 
4519 	/*
4520 	**  If we haven't read any lines, this queue file is empty.
4521 	**  Arrange to remove it without referencing any null pointers.
4522 	*/
4523 
4524 	if (LineNumber == 0)
4525 	{
4526 		errno = 0;
4527 		e->e_flags |= EF_CLRQUEUE|EF_FATALERRS|EF_RESPONSE;
4528 		return true;
4529 	}
4530 
4531 	/* Check to make sure we have a complete queue file read */
4532 	if (!nomore)
4533 	{
4534 		syserr("readqf: %s: incomplete queue file read", qf);
4535 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4536 		return false;
4537 	}
4538 
4539 #if _FFR_QF_PARANOIA
4540 	/* Check to make sure key fields were read */
4541 	if (e->e_from.q_mailer == NULL)
4542 	{
4543 		syserr("readqf: %s: sender not specified in queue file", qf);
4544 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4545 		return false;
4546 	}
4547 	/* other checks? */
4548 #endif /* _FFR_QF_PARANOIA */
4549 
4550 	/* possibly set ${dsn_ret} macro */
4551 	if (bitset(EF_RET_PARAM, e->e_flags))
4552 	{
4553 		if (bitset(EF_NO_BODY_RETN, e->e_flags))
4554 			macdefine(&e->e_macro, A_PERM,
4555 				macid("{dsn_ret}"), "hdrs");
4556 		else
4557 			macdefine(&e->e_macro, A_PERM,
4558 				macid("{dsn_ret}"), "full");
4559 	}
4560 
4561 	/*
4562 	**  Arrange to read the data file.
4563 	*/
4564 
4565 	p = queuename(e, DATAFL_LETTER);
4566 	e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, p, SM_IO_RDONLY_B,
4567 			      NULL);
4568 	if (e->e_dfp == NULL)
4569 	{
4570 		syserr("readqf: cannot open %s", p);
4571 	}
4572 	else
4573 	{
4574 		e->e_flags |= EF_HAS_DF;
4575 		if (fstat(sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL), &st)
4576 		    >= 0)
4577 		{
4578 			e->e_msgsize = st.st_size + hdrsize;
4579 			e->e_dfdev = st.st_dev;
4580 			e->e_dfino = ST_INODE(st);
4581 			(void) sm_snprintf(buf, sizeof(buf), "%ld",
4582 					   e->e_msgsize);
4583 			macdefine(&e->e_macro, A_TEMP, macid("{msg_size}"),
4584 				  buf);
4585 		}
4586 	}
4587 
4588 	return true;
4589 
4590   fail:
4591 	/*
4592 	**  There was some error reading the qf file (reason is in err var.)
4593 	**  Cleanup:
4594 	**	close file; clear e_lockfp since it is the same as qfp,
4595 	**	hence it is invalid (as file) after qfp is closed;
4596 	**	the qf file is on disk, so set the flag to avoid calling
4597 	**	queueup() with bogus data.
4598 	*/
4599 
4600 	if (bp != buf)
4601 		SM_FREE(bp);
4602 	if (qfp != NULL)
4603 		(void) sm_io_close(qfp, SM_TIME_DEFAULT);
4604 	e->e_lockfp = NULL;
4605 	e->e_flags |= EF_INQUEUE;
4606 	loseqfile(e, err);
4607 	return false;
4608 }
4609 /*
4610 **  PRTSTR -- print a string, "unprintable" characters are shown as \oct
4611 **
4612 **	Parameters:
4613 **		s -- string to print
4614 **		ml -- maximum length of output
4615 **
4616 **	Returns:
4617 **		number of entries
4618 **
4619 **	Side Effects:
4620 **		Prints a string on stdout.
4621 */
4622 
4623 static void prtstr __P((char *, int));
4624 
4625 static void
prtstr(s,ml)4626 prtstr(s, ml)
4627 	char *s;
4628 	int ml;
4629 {
4630 	int c;
4631 
4632 	if (s == NULL)
4633 		return;
4634 	while (ml-- > 0 && ((c = *s++) != '\0'))
4635 	{
4636 		if (c == '\\')
4637 		{
4638 			if (ml-- > 0)
4639 			{
4640 				(void) sm_io_putc(smioout, SM_TIME_DEFAULT, c);
4641 				(void) sm_io_putc(smioout, SM_TIME_DEFAULT, c);
4642 			}
4643 		}
4644 		else if (isascii(c) && isprint(c))
4645 			(void) sm_io_putc(smioout, SM_TIME_DEFAULT, c);
4646 		else
4647 		{
4648 			if ((ml -= 3) > 0)
4649 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4650 						     "\\%03o", c & 0xFF);
4651 		}
4652 	}
4653 }
4654 /*
4655 **  PRINTNQE -- print out number of entries in the mail queue
4656 **
4657 **	Parameters:
4658 **		out -- output file pointer.
4659 **		prefix -- string to output in front of each line.
4660 **
4661 **	Returns:
4662 **		none.
4663 */
4664 
4665 void
printnqe(out,prefix)4666 printnqe(out, prefix)
4667 	SM_FILE_T *out;
4668 	char *prefix;
4669 {
4670 #if SM_CONF_SHM
4671 	int i, k = 0, nrequests = 0;
4672 	bool unknown = false;
4673 
4674 	if (ShmId == SM_SHM_NO_ID)
4675 	{
4676 		if (prefix == NULL)
4677 			(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4678 					"Data unavailable: shared memory not updated\n");
4679 		else
4680 			(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4681 					"%sNOTCONFIGURED:-1\r\n", prefix);
4682 		return;
4683 	}
4684 	for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
4685 	{
4686 		int j;
4687 
4688 		k++;
4689 		for (j = 0; j < Queue[i]->qg_numqueues; j++)
4690 		{
4691 			int n;
4692 
4693 			if (StopRequest)
4694 				stop_sendmail();
4695 
4696 			n = QSHM_ENTRIES(Queue[i]->qg_qpaths[j].qp_idx);
4697 			if (prefix != NULL)
4698 				(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4699 					"%s%s:%d\r\n",
4700 					prefix, qid_printqueue(i, j), n);
4701 			else if (n < 0)
4702 			{
4703 				(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4704 					"%s: unknown number of entries\n",
4705 					qid_printqueue(i, j));
4706 				unknown = true;
4707 			}
4708 			else if (n == 0)
4709 			{
4710 				(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4711 					"%s is empty\n",
4712 					qid_printqueue(i, j));
4713 			}
4714 			else if (n > 0)
4715 			{
4716 				(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4717 					"%s: entries=%d\n",
4718 					qid_printqueue(i, j), n);
4719 				nrequests += n;
4720 				k++;
4721 			}
4722 		}
4723 	}
4724 	if (prefix == NULL && k > 1)
4725 		(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4726 				     "\t\tTotal requests: %d%s\n",
4727 				     nrequests, unknown ? " (about)" : "");
4728 #else /* SM_CONF_SHM */
4729 	if (prefix == NULL)
4730 		(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4731 			     "Data unavailable without shared memory support\n");
4732 	else
4733 		(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4734 			     "%sNOTAVAILABLE:-1\r\n", prefix);
4735 #endif /* SM_CONF_SHM */
4736 }
4737 /*
4738 **  PRINTQUEUE -- print out a representation of the mail queue
4739 **
4740 **	Parameters:
4741 **		none.
4742 **
4743 **	Returns:
4744 **		none.
4745 **
4746 **	Side Effects:
4747 **		Prints a listing of the mail queue on the standard output.
4748 */
4749 
4750 void
printqueue()4751 printqueue()
4752 {
4753 	int i, k = 0, nrequests = 0;
4754 
4755 	for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
4756 	{
4757 		int j;
4758 
4759 		k++;
4760 		for (j = 0; j < Queue[i]->qg_numqueues; j++)
4761 		{
4762 			if (StopRequest)
4763 				stop_sendmail();
4764 			nrequests += print_single_queue(i, j);
4765 			k++;
4766 		}
4767 	}
4768 	if (k > 1)
4769 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4770 				     "\t\tTotal requests: %d\n",
4771 				     nrequests);
4772 }
4773 /*
4774 **  PRINT_SINGLE_QUEUE -- print out a representation of a single mail queue
4775 **
4776 **	Parameters:
4777 **		qgrp -- the index of the queue group.
4778 **		qdir -- the queue directory.
4779 **
4780 **	Returns:
4781 **		number of requests in mail queue.
4782 **
4783 **	Side Effects:
4784 **		Prints a listing of the mail queue on the standard output.
4785 */
4786 
4787 int
print_single_queue(qgrp,qdir)4788 print_single_queue(qgrp, qdir)
4789 	int qgrp;
4790 	int qdir;
4791 {
4792 	register WORK *w;
4793 	SM_FILE_T *f;
4794 	int nrequests;
4795 	char qd[MAXPATHLEN];
4796 	char qddf[MAXPATHLEN];
4797 	char buf[MAXLINE];
4798 
4799 	if (qdir == NOQDIR)
4800 	{
4801 		(void) sm_strlcpy(qd, ".", sizeof(qd));
4802 		(void) sm_strlcpy(qddf, ".", sizeof(qddf));
4803 	}
4804 	else
4805 	{
4806 		(void) sm_strlcpyn(qd, sizeof(qd), 2,
4807 			Queue[qgrp]->qg_qpaths[qdir].qp_name,
4808 			(bitset(QP_SUBQF,
4809 				Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
4810 					? "/qf" : ""));
4811 		(void) sm_strlcpyn(qddf, sizeof(qddf), 2,
4812 			Queue[qgrp]->qg_qpaths[qdir].qp_name,
4813 			(bitset(QP_SUBDF,
4814 				Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
4815 					? "/df" : ""));
4816 	}
4817 
4818 	/*
4819 	**  Check for permission to print the queue
4820 	*/
4821 
4822 	if (bitset(PRIV_RESTRICTMAILQ, PrivacyFlags) && RealUid != 0)
4823 	{
4824 		struct stat st;
4825 #ifdef NGROUPS_MAX
4826 		int n;
4827 		extern GIDSET_T InitialGidSet[NGROUPS_MAX];
4828 #endif /* NGROUPS_MAX */
4829 
4830 		if (stat(qd, &st) < 0)
4831 		{
4832 			syserr("Cannot stat %s",
4833 				qid_printqueue(qgrp, qdir));
4834 			return 0;
4835 		}
4836 #ifdef NGROUPS_MAX
4837 		n = NGROUPS_MAX;
4838 		while (--n >= 0)
4839 		{
4840 			if (InitialGidSet[n] == st.st_gid)
4841 				break;
4842 		}
4843 		if (n < 0 && RealGid != st.st_gid)
4844 #else /* NGROUPS_MAX */
4845 		if (RealGid != st.st_gid)
4846 #endif /* NGROUPS_MAX */
4847 		{
4848 			usrerr("510 You are not permitted to see the queue");
4849 			setstat(EX_NOPERM);
4850 			return 0;
4851 		}
4852 	}
4853 
4854 	/*
4855 	**  Read and order the queue.
4856 	*/
4857 
4858 	nrequests = gatherq(qgrp, qdir, true, NULL, NULL, NULL);
4859 	(void) sortq(Queue[qgrp]->qg_maxlist);
4860 
4861 	/*
4862 	**  Print the work list that we have read.
4863 	*/
4864 
4865 	/* first see if there is anything */
4866 	if (nrequests <= 0)
4867 	{
4868 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%s is empty\n",
4869 				     qid_printqueue(qgrp, qdir));
4870 		return 0;
4871 	}
4872 
4873 	sm_getla();	/* get load average */
4874 
4875 	(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "\t\t%s (%d request%s",
4876 			     qid_printqueue(qgrp, qdir),
4877 			     nrequests, nrequests == 1 ? "" : "s");
4878 	if (MaxQueueRun > 0 && nrequests > MaxQueueRun)
4879 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4880 				     ", only %d printed", MaxQueueRun);
4881 	if (Verbose)
4882 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4883 			")\n-----Q-ID----- --Size-- -Priority- ---Q-Time--- --------Sender/Recipient--------\n");
4884 	else
4885 		(void) sm_io_fprintf(smioout,  SM_TIME_DEFAULT,
4886 			")\n-----Q-ID----- --Size-- -----Q-Time----- ------------Sender/Recipient-----------\n");
4887 	for (w = WorkQ; w != NULL; w = w->w_next)
4888 	{
4889 		struct stat st;
4890 		auto time_t submittime = 0;
4891 		long dfsize;
4892 		int flags = 0;
4893 		int qfver;
4894 		char quarmsg[MAXLINE];
4895 		char statmsg[MAXLINE];
4896 		char bodytype[MAXNAME + 1];
4897 		char qf[MAXPATHLEN];
4898 
4899 		if (StopRequest)
4900 			stop_sendmail();
4901 
4902 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%13s",
4903 				     w->w_name + 2);
4904 		(void) sm_strlcpyn(qf, sizeof(qf), 3, qd, "/", w->w_name);
4905 		f = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, qf, SM_IO_RDONLY_B,
4906 			       NULL);
4907 		if (f == NULL)
4908 		{
4909 			if (errno == EPERM)
4910 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4911 						     " (permission denied)\n");
4912 			else if (errno == ENOENT)
4913 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4914 						     " (job completed)\n");
4915 			else
4916 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4917 						     " (%s)\n",
4918 						     sm_errstring(errno));
4919 			errno = 0;
4920 			continue;
4921 		}
4922 		w->w_name[0] = DATAFL_LETTER;
4923 		(void) sm_strlcpyn(qf, sizeof(qf), 3, qddf, "/", w->w_name);
4924 		if (stat(qf, &st) >= 0)
4925 			dfsize = st.st_size;
4926 		else
4927 		{
4928 			ENVELOPE e;
4929 
4930 			/*
4931 			**  Maybe the df file can't be statted because
4932 			**  it is in a different directory than the qf file.
4933 			**  In order to find out, we must read the qf file.
4934 			*/
4935 
4936 			newenvelope(&e, &BlankEnvelope, sm_rpool_new_x(NULL));
4937 			e.e_id = w->w_name + 2;
4938 			e.e_qgrp = qgrp;
4939 			e.e_qdir = qdir;
4940 			dfsize = -1;
4941 			if (readqf(&e, false))
4942 			{
4943 				char *df = queuename(&e, DATAFL_LETTER);
4944 				if (stat(df, &st) >= 0)
4945 					dfsize = st.st_size;
4946 			}
4947 			if (e.e_lockfp != NULL)
4948 			{
4949 				(void) sm_io_close(e.e_lockfp, SM_TIME_DEFAULT);
4950 				e.e_lockfp = NULL;
4951 			}
4952 			clearenvelope(&e, false, e.e_rpool);
4953 			sm_rpool_free(e.e_rpool);
4954 		}
4955 		if (w->w_lock)
4956 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "*");
4957 		else if (QueueMode == QM_LOST)
4958 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "?");
4959 		else if (w->w_tooyoung)
4960 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "-");
4961 		else if (shouldqueue(w->w_pri, w->w_ctime))
4962 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "X");
4963 		else
4964 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " ");
4965 
4966 		errno = 0;
4967 
4968 		quarmsg[0] = '\0';
4969 		statmsg[0] = bodytype[0] = '\0';
4970 		qfver = 0;
4971 		while (sm_io_fgets(f, SM_TIME_DEFAULT, buf, sizeof(buf)) != NULL)
4972 		{
4973 			register int i;
4974 			register char *p;
4975 
4976 			if (StopRequest)
4977 				stop_sendmail();
4978 
4979 			fixcrlf(buf, true);
4980 			switch (buf[0])
4981 			{
4982 			  case 'V':	/* queue file version */
4983 				qfver = atoi(&buf[1]);
4984 				break;
4985 
4986 			  case 'M':	/* error message */
4987 				if ((i = strlen(&buf[1])) >= sizeof(statmsg))
4988 					i = sizeof(statmsg) - 1;
4989 				memmove(statmsg, &buf[1], i);
4990 				statmsg[i] = '\0';
4991 				break;
4992 
4993 			  case 'q':	/* quarantine reason */
4994 				if ((i = strlen(&buf[1])) >= sizeof(quarmsg))
4995 					i = sizeof(quarmsg) - 1;
4996 				memmove(quarmsg, &buf[1], i);
4997 				quarmsg[i] = '\0';
4998 				break;
4999 
5000 			  case 'B':	/* body type */
5001 				if ((i = strlen(&buf[1])) >= sizeof(bodytype))
5002 					i = sizeof(bodytype) - 1;
5003 				memmove(bodytype, &buf[1], i);
5004 				bodytype[i] = '\0';
5005 				break;
5006 
5007 			  case 'S':	/* sender name */
5008 				if (Verbose)
5009 				{
5010 					(void) sm_io_fprintf(smioout,
5011 						SM_TIME_DEFAULT,
5012 						"%8ld %10ld%c%.12s ",
5013 						dfsize,
5014 						w->w_pri,
5015 						bitset(EF_WARNING, flags)
5016 							? '+' : ' ',
5017 						ctime(&submittime) + 4);
5018 					prtstr(&buf[1], 78);
5019 				}
5020 				else
5021 				{
5022 					(void) sm_io_fprintf(smioout,
5023 						SM_TIME_DEFAULT,
5024 						"%8ld %.16s ",
5025 						dfsize,
5026 						ctime(&submittime));
5027 					prtstr(&buf[1], 39);
5028 				}
5029 
5030 				if (quarmsg[0] != '\0')
5031 				{
5032 					(void) sm_io_fprintf(smioout,
5033 							     SM_TIME_DEFAULT,
5034 							     "\n     QUARANTINE: %.*s",
5035 							     Verbose ? 100 : 60,
5036 							     quarmsg);
5037 					quarmsg[0] = '\0';
5038 				}
5039 
5040 				if (statmsg[0] != '\0' || bodytype[0] != '\0')
5041 				{
5042 					(void) sm_io_fprintf(smioout,
5043 						SM_TIME_DEFAULT,
5044 						"\n    %10.10s",
5045 						bodytype);
5046 					if (statmsg[0] != '\0')
5047 						(void) sm_io_fprintf(smioout,
5048 							SM_TIME_DEFAULT,
5049 							"   (%.*s)",
5050 							Verbose ? 100 : 60,
5051 							statmsg);
5052 					statmsg[0] = '\0';
5053 				}
5054 				break;
5055 
5056 			  case 'C':	/* controlling user */
5057 				if (Verbose)
5058 					(void) sm_io_fprintf(smioout,
5059 						SM_TIME_DEFAULT,
5060 						"\n\t\t\t\t\t\t(---%.64s---)",
5061 						&buf[1]);
5062 				break;
5063 
5064 			  case 'R':	/* recipient name */
5065 				p = &buf[1];
5066 				if (qfver >= 1)
5067 				{
5068 					p = strchr(p, ':');
5069 					if (p == NULL)
5070 						break;
5071 					p++;
5072 				}
5073 				if (Verbose)
5074 				{
5075 					(void) sm_io_fprintf(smioout,
5076 							SM_TIME_DEFAULT,
5077 							"\n\t\t\t\t\t\t");
5078 					prtstr(p, 71);
5079 				}
5080 				else
5081 				{
5082 					(void) sm_io_fprintf(smioout,
5083 							SM_TIME_DEFAULT,
5084 							"\n\t\t\t\t\t ");
5085 					prtstr(p, 38);
5086 				}
5087 				if (Verbose && statmsg[0] != '\0')
5088 				{
5089 					(void) sm_io_fprintf(smioout,
5090 							SM_TIME_DEFAULT,
5091 							"\n\t\t (%.100s)",
5092 							statmsg);
5093 					statmsg[0] = '\0';
5094 				}
5095 				break;
5096 
5097 			  case 'T':	/* creation time */
5098 				submittime = atol(&buf[1]);
5099 				break;
5100 
5101 			  case 'F':	/* flag bits */
5102 				for (p = &buf[1]; *p != '\0'; p++)
5103 				{
5104 					switch (*p)
5105 					{
5106 					  case 'w':
5107 						flags |= EF_WARNING;
5108 						break;
5109 					}
5110 				}
5111 			}
5112 		}
5113 		if (submittime == (time_t) 0)
5114 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
5115 					     " (no control file)");
5116 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "\n");
5117 		(void) sm_io_close(f, SM_TIME_DEFAULT);
5118 	}
5119 	return nrequests;
5120 }
5121 
5122 /*
5123 **  QUEUE_LETTER -- get the proper queue letter for the current QueueMode.
5124 **
5125 **	Parameters:
5126 **		e -- envelope to build it in/from.
5127 **		type -- the file type, used as the first character
5128 **			of the file name.
5129 **
5130 **	Returns:
5131 **		the letter to use
5132 */
5133 
5134 static char
queue_letter(e,type)5135 queue_letter(e, type)
5136 	ENVELOPE *e;
5137 	int type;
5138 {
5139 	/* Change type according to QueueMode */
5140 	if (type == ANYQFL_LETTER)
5141 	{
5142 		if (e->e_quarmsg != NULL)
5143 			type = QUARQF_LETTER;
5144 		else
5145 		{
5146 			switch (QueueMode)
5147 			{
5148 			  case QM_NORMAL:
5149 				type = NORMQF_LETTER;
5150 				break;
5151 
5152 			  case QM_QUARANTINE:
5153 				type = QUARQF_LETTER;
5154 				break;
5155 
5156 			  case QM_LOST:
5157 				type = LOSEQF_LETTER;
5158 				break;
5159 
5160 			  default:
5161 				/* should never happen */
5162 				abort();
5163 				/* NOTREACHED */
5164 			}
5165 		}
5166 	}
5167 	return type;
5168 }
5169 
5170 /*
5171 **  QUEUENAME -- build a file name in the queue directory for this envelope.
5172 **
5173 **	Parameters:
5174 **		e -- envelope to build it in/from.
5175 **		type -- the file type, used as the first character
5176 **			of the file name.
5177 **
5178 **	Returns:
5179 **		a pointer to the queue name (in a static buffer).
5180 **
5181 **	Side Effects:
5182 **		If no id code is already assigned, queuename() will
5183 **		assign an id code with assign_queueid().  If no queue
5184 **		directory is assigned, one will be set with setnewqueue().
5185 */
5186 
5187 char *
queuename(e,type)5188 queuename(e, type)
5189 	register ENVELOPE *e;
5190 	int type;
5191 {
5192 	int qd, qg;
5193 	char *sub = "/";
5194 	char pref[3];
5195 	static char buf[MAXPATHLEN];
5196 
5197 	/* Assign an ID if needed */
5198 	if (e->e_id == NULL)
5199 		assign_queueid(e);
5200 	type = queue_letter(e, type);
5201 
5202 	/* begin of filename */
5203 	pref[0] = (char) type;
5204 	pref[1] = 'f';
5205 	pref[2] = '\0';
5206 
5207 	/* Assign a queue group/directory if needed */
5208 	if (type == XSCRPT_LETTER)
5209 	{
5210 		/*
5211 		**  We don't want to call setnewqueue() if we are fetching
5212 		**  the pathname of the transcript file, because setnewqueue
5213 		**  chooses a queue, and sometimes we need to write to the
5214 		**  transcript file before we have gathered enough information
5215 		**  to choose a queue.
5216 		*/
5217 
5218 		if (e->e_xfqgrp == NOQGRP || e->e_xfqdir == NOQDIR)
5219 		{
5220 			if (e->e_qgrp != NOQGRP && e->e_qdir != NOQDIR)
5221 			{
5222 				e->e_xfqgrp = e->e_qgrp;
5223 				e->e_xfqdir = e->e_qdir;
5224 			}
5225 			else
5226 			{
5227 				e->e_xfqgrp = 0;
5228 				if (Queue[e->e_xfqgrp]->qg_numqueues <= 1)
5229 					e->e_xfqdir = 0;
5230 				else
5231 				{
5232 					e->e_xfqdir = get_rand_mod(
5233 					      Queue[e->e_xfqgrp]->qg_numqueues);
5234 				}
5235 			}
5236 		}
5237 		qd = e->e_xfqdir;
5238 		qg = e->e_xfqgrp;
5239 	}
5240 	else
5241 	{
5242 		if (e->e_qgrp == NOQGRP || e->e_qdir == NOQDIR)
5243 			(void) setnewqueue(e);
5244 		if (type ==  DATAFL_LETTER)
5245 		{
5246 			qd = e->e_dfqdir;
5247 			qg = e->e_dfqgrp;
5248 		}
5249 		else
5250 		{
5251 			qd = e->e_qdir;
5252 			qg = e->e_qgrp;
5253 		}
5254 	}
5255 
5256 	/* xf files always have a valid qd and qg picked above */
5257 	if ((qd == NOQDIR || qg == NOQGRP) && type != XSCRPT_LETTER)
5258 		(void) sm_strlcpyn(buf, sizeof(buf), 2, pref, e->e_id);
5259 	else
5260 	{
5261 		switch (type)
5262 		{
5263 		  case DATAFL_LETTER:
5264 			if (bitset(QP_SUBDF, Queue[qg]->qg_qpaths[qd].qp_subdirs))
5265 				sub = "/df/";
5266 			break;
5267 
5268 		  case QUARQF_LETTER:
5269 		  case TEMPQF_LETTER:
5270 		  case NEWQFL_LETTER:
5271 		  case LOSEQF_LETTER:
5272 		  case NORMQF_LETTER:
5273 			if (bitset(QP_SUBQF, Queue[qg]->qg_qpaths[qd].qp_subdirs))
5274 				sub = "/qf/";
5275 			break;
5276 
5277 		  case XSCRPT_LETTER:
5278 			if (bitset(QP_SUBXF, Queue[qg]->qg_qpaths[qd].qp_subdirs))
5279 				sub = "/xf/";
5280 			break;
5281 
5282 		  default:
5283 			sm_abort("queuename: bad queue file type %d", type);
5284 		}
5285 
5286 		(void) sm_strlcpyn(buf, sizeof(buf), 4,
5287 				Queue[qg]->qg_qpaths[qd].qp_name,
5288 				sub, pref, e->e_id);
5289 	}
5290 
5291 	if (tTd(7, 2))
5292 		sm_dprintf("queuename: %s\n", buf);
5293 	return buf;
5294 }
5295 
5296 /*
5297 **  INIT_QID_ALG -- Initialize the (static) parameters that are used to
5298 **	generate a queue ID.
5299 **
5300 **	This function is called by the daemon to reset
5301 **	LastQueueTime and LastQueuePid which are used by assign_queueid().
5302 **	Otherwise the algorithm may cause problems because
5303 **	LastQueueTime and LastQueuePid are set indirectly by main()
5304 **	before the daemon process is started, hence LastQueuePid is not
5305 **	the pid of the daemon and therefore a child of the daemon can
5306 **	actually have the same pid as LastQueuePid which means the section
5307 **	in  assign_queueid():
5308 **	* see if we need to get a new base time/pid *
5309 **	is NOT triggered which will cause the same queue id to be generated.
5310 **
5311 **	Parameters:
5312 **		none
5313 **
5314 **	Returns:
5315 **		none.
5316 */
5317 
5318 void
init_qid_alg()5319 init_qid_alg()
5320 {
5321 	LastQueueTime = 0;
5322 	LastQueuePid = -1;
5323 }
5324 
5325 /*
5326 **  ASSIGN_QUEUEID -- assign a queue ID for this envelope.
5327 **
5328 **	Assigns an id code if one does not already exist.
5329 **	This code assumes that nothing will remain in the queue for
5330 **	longer than 60 years.  It is critical that files with the given
5331 **	name do not already exist in the queue.
5332 **	[No longer initializes e_qdir to NOQDIR.]
5333 **
5334 **	Parameters:
5335 **		e -- envelope to set it in.
5336 **
5337 **	Returns:
5338 **		none.
5339 */
5340 
5341 static const char QueueIdChars[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
5342 # define QIC_LEN	60
5343 # define QIC_LEN_R	62
5344 
5345 /*
5346 **  Note: the length is "officially" 60 because minutes and seconds are
5347 **	usually only 0-59.  However (Linux):
5348 **       tm_sec The number of seconds after the minute, normally in
5349 **		the range 0 to 59, but can be up to 61 to allow for
5350 **		leap seconds.
5351 **	Hence the real length of the string is 62 to take this into account.
5352 **	Alternatively % QIC_LEN can (should) be used for access everywhere.
5353 */
5354 
5355 # define queuenextid() CurrentPid
5356 #define QIC_LEN_SQR	(QIC_LEN * QIC_LEN)
5357 
5358 void
assign_queueid(e)5359 assign_queueid(e)
5360 	register ENVELOPE *e;
5361 {
5362 	pid_t pid = queuenextid();
5363 	static unsigned int cX = 0;
5364 	static unsigned int random_offset;
5365 	struct tm *tm;
5366 	char idbuf[MAXQFNAME - 2];
5367 	unsigned int seq;
5368 
5369 	if (e->e_id != NULL)
5370 		return;
5371 
5372 	/* see if we need to get a new base time/pid */
5373 	if (cX >= QIC_LEN_SQR || LastQueueTime == 0 || LastQueuePid != pid)
5374 	{
5375 		time_t then = LastQueueTime;
5376 
5377 		/* if the first time through, pick a random offset */
5378 		if (LastQueueTime == 0)
5379 			random_offset = ((unsigned int)get_random())
5380 					% QIC_LEN_SQR;
5381 
5382 		while ((LastQueueTime = curtime()) == then &&
5383 		       LastQueuePid == pid)
5384 		{
5385 			(void) sleep(1);
5386 		}
5387 		LastQueuePid = queuenextid();
5388 		cX = 0;
5389 	}
5390 
5391 	/*
5392 	**  Generate a new sequence number between 0 and QIC_LEN_SQR-1.
5393 	**  This lets us generate up to QIC_LEN_SQR unique queue ids
5394 	**  per second, per process.  With envelope splitting,
5395 	**  a single message can consume many queue ids.
5396 	*/
5397 
5398 	seq = (cX + random_offset) % QIC_LEN_SQR;
5399 	++cX;
5400 	if (tTd(7, 50))
5401 		sm_dprintf("assign_queueid: random_offset=%u (%u)\n",
5402 			random_offset, seq);
5403 
5404 	tm = gmtime(&LastQueueTime);
5405 	idbuf[0] = QueueIdChars[tm->tm_year % QIC_LEN];
5406 	idbuf[1] = QueueIdChars[tm->tm_mon];
5407 	idbuf[2] = QueueIdChars[tm->tm_mday];
5408 	idbuf[3] = QueueIdChars[tm->tm_hour];
5409 	idbuf[4] = QueueIdChars[tm->tm_min % QIC_LEN_R];
5410 	idbuf[5] = QueueIdChars[tm->tm_sec % QIC_LEN_R];
5411 	idbuf[6] = QueueIdChars[seq / QIC_LEN];
5412 	idbuf[7] = QueueIdChars[seq % QIC_LEN];
5413 	(void) sm_snprintf(&idbuf[8], sizeof(idbuf) - 8, "%06d",
5414 			   (int) LastQueuePid);
5415 	e->e_id = sm_rpool_strdup_x(e->e_rpool, idbuf);
5416 	macdefine(&e->e_macro, A_PERM, 'i', e->e_id);
5417 #if 0
5418 	/* XXX: inherited from MainEnvelope */
5419 	e->e_qgrp = NOQGRP;  /* too early to do anything else */
5420 	e->e_qdir = NOQDIR;
5421 	e->e_xfqgrp = NOQGRP;
5422 #endif /* 0 */
5423 
5424 	/* New ID means it's not on disk yet */
5425 	e->e_qfletter = '\0';
5426 
5427 	if (tTd(7, 1))
5428 		sm_dprintf("assign_queueid: assigned id %s, e=%p\n",
5429 			e->e_id, e);
5430 	if (LogLevel > 93)
5431 		sm_syslog(LOG_DEBUG, e->e_id, "assigned id");
5432 }
5433 /*
5434 **  SYNC_QUEUE_TIME -- Assure exclusive PID in any given second
5435 **
5436 **	Make sure one PID can't be used by two processes in any one second.
5437 **
5438 **		If the system rotates PIDs fast enough, may get the
5439 **		same pid in the same second for two distinct processes.
5440 **		This will interfere with the queue file naming system.
5441 **
5442 **	Parameters:
5443 **		none
5444 **
5445 **	Returns:
5446 **		none
5447 */
5448 
5449 void
sync_queue_time()5450 sync_queue_time()
5451 {
5452 #if FAST_PID_RECYCLE
5453 	if (OpMode != MD_TEST &&
5454 	    OpMode != MD_CHECKCONFIG &&
5455 	    OpMode != MD_VERIFY &&
5456 	    LastQueueTime > 0 &&
5457 	    LastQueuePid == CurrentPid &&
5458 	    curtime() == LastQueueTime)
5459 		(void) sleep(1);
5460 #endif /* FAST_PID_RECYCLE */
5461 }
5462 /*
5463 **  UNLOCKQUEUE -- unlock the queue entry for a specified envelope
5464 **
5465 **	Parameters:
5466 **		e -- the envelope to unlock.
5467 **
5468 **	Returns:
5469 **		none
5470 **
5471 **	Side Effects:
5472 **		unlocks the queue for `e'.
5473 */
5474 
5475 void
unlockqueue(e)5476 unlockqueue(e)
5477 	ENVELOPE *e;
5478 {
5479 	if (tTd(51, 4))
5480 		sm_dprintf("unlockqueue(%s)\n",
5481 			e->e_id == NULL ? "NOQUEUE" : e->e_id);
5482 
5483 
5484 	/* if there is a lock file in the envelope, close it */
5485 	if (e->e_lockfp != NULL)
5486 		(void) sm_io_close(e->e_lockfp, SM_TIME_DEFAULT);
5487 	e->e_lockfp = NULL;
5488 
5489 	/* don't create a queue id if we don't already have one */
5490 	if (e->e_id == NULL)
5491 		return;
5492 
5493 	/* remove the transcript */
5494 	if (LogLevel > 87)
5495 		sm_syslog(LOG_DEBUG, e->e_id, "unlock");
5496 	if (!tTd(51, 104))
5497 		(void) xunlink(queuename(e, XSCRPT_LETTER));
5498 }
5499 /*
5500 **  SETCTLUSER -- create a controlling address
5501 **
5502 **	Create a fake "address" given only a local login name; this is
5503 **	used as a "controlling user" for future recipient addresses.
5504 **
5505 **	Parameters:
5506 **		user -- the user name of the controlling user.
5507 **		qfver -- the version stamp of this queue file.
5508 **		e -- envelope
5509 **
5510 **	Returns:
5511 **		An address descriptor for the controlling user,
5512 **		using storage allocated from e->e_rpool.
5513 **
5514 */
5515 
5516 static ADDRESS *
setctluser(user,qfver,e)5517 setctluser(user, qfver, e)
5518 	char *user;
5519 	int qfver;
5520 	ENVELOPE *e;
5521 {
5522 	register ADDRESS *a;
5523 	struct passwd *pw;
5524 	char *p;
5525 
5526 	/*
5527 	**  See if this clears our concept of controlling user.
5528 	*/
5529 
5530 	if (user == NULL || *user == '\0')
5531 		return NULL;
5532 
5533 	/*
5534 	**  Set up addr fields for controlling user.
5535 	*/
5536 
5537 	a = (ADDRESS *) sm_rpool_malloc_x(e->e_rpool, sizeof(*a));
5538 	memset((char *) a, '\0', sizeof(*a));
5539 
5540 	if (*user == ':')
5541 	{
5542 		p = &user[1];
5543 		a->q_user = sm_rpool_strdup_x(e->e_rpool, p);
5544 	}
5545 	else
5546 	{
5547 		p = strtok(user, ":");
5548 		a->q_user = sm_rpool_strdup_x(e->e_rpool, user);
5549 		if (qfver >= 2)
5550 		{
5551 			if ((p = strtok(NULL, ":")) != NULL)
5552 				a->q_uid = atoi(p);
5553 			if ((p = strtok(NULL, ":")) != NULL)
5554 				a->q_gid = atoi(p);
5555 			if ((p = strtok(NULL, ":")) != NULL)
5556 			{
5557 				char *o;
5558 
5559 				a->q_flags |= QGOODUID;
5560 
5561 				/* if there is another ':': restore it */
5562 				if ((o = strtok(NULL, ":")) != NULL && o > p)
5563 					o[-1] = ':';
5564 			}
5565 		}
5566 		else if ((pw = sm_getpwnam(user)) != NULL)
5567 		{
5568 			if (*pw->pw_dir == '\0')
5569 				a->q_home = NULL;
5570 			else if (strcmp(pw->pw_dir, "/") == 0)
5571 				a->q_home = "";
5572 			else
5573 				a->q_home = sm_rpool_strdup_x(e->e_rpool, pw->pw_dir);
5574 			a->q_uid = pw->pw_uid;
5575 			a->q_gid = pw->pw_gid;
5576 			a->q_flags |= QGOODUID;
5577 		}
5578 	}
5579 
5580 	a->q_flags |= QPRIMARY;		/* flag as a "ctladdr" */
5581 	a->q_mailer = LocalMailer;
5582 	if (p == NULL)
5583 		a->q_paddr = sm_rpool_strdup_x(e->e_rpool, a->q_user);
5584 	else
5585 		a->q_paddr = sm_rpool_strdup_x(e->e_rpool, p);
5586 	return a;
5587 }
5588 /*
5589 **  LOSEQFILE -- rename queue file with LOSEQF_LETTER & try to let someone know
5590 **
5591 **	Parameters:
5592 **		e -- the envelope (e->e_id will be used).
5593 **		why -- reported to whomever can hear.
5594 **
5595 **	Returns:
5596 **		none.
5597 */
5598 
5599 void
loseqfile(e,why)5600 loseqfile(e, why)
5601 	register ENVELOPE *e;
5602 	char *why;
5603 {
5604 	bool loseit = true;
5605 	char *p;
5606 	char buf[MAXPATHLEN];
5607 
5608 	if (e == NULL || e->e_id == NULL)
5609 		return;
5610 	p = queuename(e, ANYQFL_LETTER);
5611 	if (sm_strlcpy(buf, p, sizeof(buf)) >= sizeof(buf))
5612 		return;
5613 	if (!bitset(EF_INQUEUE, e->e_flags))
5614 		queueup(e, false, true);
5615 	else if (QueueMode == QM_LOST)
5616 		loseit = false;
5617 
5618 	/* if already lost, no need to re-lose */
5619 	if (loseit)
5620 	{
5621 		p = queuename(e, LOSEQF_LETTER);
5622 		if (rename(buf, p) < 0)
5623 			syserr("cannot rename(%s, %s), uid=%d",
5624 			       buf, p, (int) geteuid());
5625 		else if (LogLevel > 0)
5626 			sm_syslog(LOG_ALERT, e->e_id,
5627 				  "Losing %s: %s", buf, why);
5628 	}
5629 	if (e->e_dfp != NULL)
5630 	{
5631 		(void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
5632 		e->e_dfp = NULL;
5633 	}
5634 	e->e_flags &= ~EF_HAS_DF;
5635 }
5636 /*
5637 **  NAME2QID -- translate a queue group name to a queue group id
5638 **
5639 **	Parameters:
5640 **		queuename -- name of queue group.
5641 **
5642 **	Returns:
5643 **		queue group id if found.
5644 **		NOQGRP otherwise.
5645 */
5646 
5647 int
name2qid(queuename)5648 name2qid(queuename)
5649 	char *queuename;
5650 {
5651 	register STAB *s;
5652 
5653 	s = stab(queuename, ST_QUEUE, ST_FIND);
5654 	if (s == NULL)
5655 		return NOQGRP;
5656 	return s->s_quegrp->qg_index;
5657 }
5658 /*
5659 **  QID_PRINTNAME -- create externally printable version of queue id
5660 **
5661 **	Parameters:
5662 **		e -- the envelope.
5663 **
5664 **	Returns:
5665 **		a printable version
5666 */
5667 
5668 char *
qid_printname(e)5669 qid_printname(e)
5670 	ENVELOPE *e;
5671 {
5672 	char *id;
5673 	static char idbuf[MAXQFNAME + 34];
5674 
5675 	if (e == NULL)
5676 		return "";
5677 
5678 	if (e->e_id == NULL)
5679 		id = "";
5680 	else
5681 		id = e->e_id;
5682 
5683 	if (e->e_qdir == NOQDIR)
5684 		return id;
5685 
5686 	(void) sm_snprintf(idbuf, sizeof(idbuf), "%.32s/%s",
5687 			   Queue[e->e_qgrp]->qg_qpaths[e->e_qdir].qp_name,
5688 			   id);
5689 	return idbuf;
5690 }
5691 /*
5692 **  QID_PRINTQUEUE -- create full version of queue directory for data files
5693 **
5694 **	Parameters:
5695 **		qgrp -- index in queue group.
5696 **		qdir -- the short version of the queue directory
5697 **
5698 **	Returns:
5699 **		the full pathname to the queue (might point to a static var)
5700 */
5701 
5702 char *
qid_printqueue(qgrp,qdir)5703 qid_printqueue(qgrp, qdir)
5704 	int qgrp;
5705 	int qdir;
5706 {
5707 	char *subdir;
5708 	static char dir[MAXPATHLEN];
5709 
5710 	if (qdir == NOQDIR)
5711 		return Queue[qgrp]->qg_qdir;
5712 
5713 	if (strcmp(Queue[qgrp]->qg_qpaths[qdir].qp_name, ".") == 0)
5714 		subdir = NULL;
5715 	else
5716 		subdir = Queue[qgrp]->qg_qpaths[qdir].qp_name;
5717 
5718 	(void) sm_strlcpyn(dir, sizeof(dir), 4,
5719 			Queue[qgrp]->qg_qdir,
5720 			subdir == NULL ? "" : "/",
5721 			subdir == NULL ? "" : subdir,
5722 			(bitset(QP_SUBDF,
5723 				Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
5724 					? "/df" : ""));
5725 	return dir;
5726 }
5727 
5728 /*
5729 **  PICKQDIR -- Pick a queue directory from a queue group
5730 **
5731 **	Parameters:
5732 **		qg -- queue group
5733 **		fsize -- file size in bytes
5734 **		e -- envelope, or NULL
5735 **
5736 **	Result:
5737 **		NOQDIR if no queue directory in qg has enough free space to
5738 **		hold a file of size 'fsize', otherwise the index of
5739 **		a randomly selected queue directory which resides on a
5740 **		file system with enough disk space.
5741 **		XXX This could be extended to select a queuedir with
5742 **			a few (the fewest?) number of entries. That data
5743 **			is available if shared memory is used.
5744 **
5745 **	Side Effects:
5746 **		If the request fails and e != NULL then sm_syslog is called.
5747 */
5748 
5749 int
pickqdir(qg,fsize,e)5750 pickqdir(qg, fsize, e)
5751 	QUEUEGRP *qg;
5752 	long fsize;
5753 	ENVELOPE *e;
5754 {
5755 	int qdir;
5756 	int i;
5757 	long avail = 0;
5758 
5759 	/* Pick a random directory, as a starting point. */
5760 	if (qg->qg_numqueues <= 1)
5761 		qdir = 0;
5762 	else
5763 		qdir = get_rand_mod(qg->qg_numqueues);
5764 
5765 #if _FFR_TESTS
5766 	if (tTd(4, 101))
5767 		return NOQDIR;
5768 #endif /* _FFR_TESTS */
5769 	if (MinBlocksFree <= 0 && fsize <= 0)
5770 		return qdir;
5771 
5772 	/*
5773 	**  Now iterate over the queue directories,
5774 	**  looking for a directory with enough space for this message.
5775 	*/
5776 
5777 	i = qdir;
5778 	do
5779 	{
5780 		QPATHS *qp = &qg->qg_qpaths[i];
5781 		long needed = 0;
5782 		long fsavail = 0;
5783 
5784 		if (fsize > 0)
5785 			needed += fsize / FILE_SYS_BLKSIZE(qp->qp_fsysidx)
5786 				  + ((fsize % FILE_SYS_BLKSIZE(qp->qp_fsysidx)
5787 				      > 0) ? 1 : 0);
5788 		if (MinBlocksFree > 0)
5789 			needed += MinBlocksFree;
5790 		fsavail = FILE_SYS_AVAIL(qp->qp_fsysidx);
5791 #if SM_CONF_SHM
5792 		if (fsavail <= 0)
5793 		{
5794 			long blksize;
5795 
5796 			/*
5797 			**  might be not correctly updated,
5798 			**  let's try to get the info directly.
5799 			*/
5800 
5801 			fsavail = freediskspace(FILE_SYS_NAME(qp->qp_fsysidx),
5802 						&blksize);
5803 			if (fsavail < 0)
5804 				fsavail = 0;
5805 		}
5806 #endif /* SM_CONF_SHM */
5807 		if (needed <= fsavail)
5808 			return i;
5809 		if (avail < fsavail)
5810 			avail = fsavail;
5811 
5812 		if (qg->qg_numqueues > 0)
5813 			i = (i + 1) % qg->qg_numqueues;
5814 	} while (i != qdir);
5815 
5816 	if (e != NULL && LogLevel > 0)
5817 		sm_syslog(LOG_ALERT, e->e_id,
5818 			"low on space (%s needs %ld bytes + %ld blocks in %s), max avail: %ld",
5819 			CurHostName == NULL ? "SMTP-DAEMON" : CurHostName,
5820 			fsize, MinBlocksFree,
5821 			qg->qg_qdir, avail);
5822 	return NOQDIR;
5823 }
5824 /*
5825 **  SETNEWQUEUE -- Sets a new queue group and directory
5826 **
5827 **	Assign a queue group and directory to an envelope and store the
5828 **	directory in e->e_qdir.
5829 **
5830 **	Parameters:
5831 **		e -- envelope to assign a queue for.
5832 **
5833 **	Returns:
5834 **		true if successful
5835 **		false otherwise
5836 **
5837 **	Side Effects:
5838 **		On success, e->e_qgrp and e->e_qdir are non-negative.
5839 **		On failure (not enough disk space),
5840 **		e->qgrp = NOQGRP, e->e_qdir = NOQDIR
5841 **		and usrerr() is invoked (which could raise an exception).
5842 */
5843 
5844 bool
setnewqueue(e)5845 setnewqueue(e)
5846 	ENVELOPE *e;
5847 {
5848 	if (tTd(41, 20))
5849 		sm_dprintf("setnewqueue: called\n");
5850 
5851 	/* not set somewhere else */
5852 	if (e->e_qgrp == NOQGRP)
5853 	{
5854 		ADDRESS *q;
5855 
5856 		/*
5857 		**  Use the queue group of the "first" recipient, as set by
5858 		**  the "queuegroup" rule set.  If that is not defined, then
5859 		**  use the queue group of the mailer of the first recipient.
5860 		**  If that is not defined either, then use the default
5861 		**  queue group.
5862 		**  Notice: "first" depends on the sorting of sendqueue
5863 		**  in recipient().
5864 		**  To avoid problems with "bad" recipients look
5865 		**  for a valid address first.
5866 		*/
5867 
5868 		q = e->e_sendqueue;
5869 		while (q != NULL &&
5870 		       (QS_IS_BADADDR(q->q_state) || QS_IS_DEAD(q->q_state)))
5871 		{
5872 			q = q->q_next;
5873 		}
5874 		if (q == NULL)
5875 			e->e_qgrp = 0;
5876 		else if (q->q_qgrp >= 0)
5877 			e->e_qgrp = q->q_qgrp;
5878 		else if (q->q_mailer != NULL &&
5879 			 ISVALIDQGRP(q->q_mailer->m_qgrp))
5880 			e->e_qgrp = q->q_mailer->m_qgrp;
5881 		else
5882 			e->e_qgrp = 0;
5883 		e->e_dfqgrp = e->e_qgrp;
5884 	}
5885 
5886 	if (ISVALIDQDIR(e->e_qdir) && ISVALIDQDIR(e->e_dfqdir))
5887 	{
5888 		if (tTd(41, 20))
5889 			sm_dprintf("setnewqueue: e_qdir already assigned (%s)\n",
5890 				qid_printqueue(e->e_qgrp, e->e_qdir));
5891 		return true;
5892 	}
5893 
5894 	filesys_update();
5895 	e->e_qdir = pickqdir(Queue[e->e_qgrp], e->e_msgsize, e);
5896 	if (e->e_qdir == NOQDIR)
5897 	{
5898 		e->e_qgrp = NOQGRP;
5899 		if (!bitset(EF_FATALERRS, e->e_flags))
5900 			usrerr("452 4.4.5 Insufficient disk space; try again later");
5901 		e->e_flags |= EF_FATALERRS;
5902 		return false;
5903 	}
5904 
5905 	if (tTd(41, 3))
5906 		sm_dprintf("setnewqueue: Assigned queue directory %s\n",
5907 			qid_printqueue(e->e_qgrp, e->e_qdir));
5908 
5909 	if (e->e_xfqgrp == NOQGRP || e->e_xfqdir == NOQDIR)
5910 	{
5911 		e->e_xfqgrp = e->e_qgrp;
5912 		e->e_xfqdir = e->e_qdir;
5913 	}
5914 	e->e_dfqdir = e->e_qdir;
5915 	return true;
5916 }
5917 /*
5918 **  CHKQDIR -- check a queue directory
5919 **
5920 **	Parameters:
5921 **		name -- name of queue directory
5922 **		sff -- flags for safefile()
5923 **
5924 **	Returns:
5925 **		is it a queue directory?
5926 */
5927 
5928 static bool chkqdir __P((char *, long));
5929 
5930 static bool
chkqdir(name,sff)5931 chkqdir(name, sff)
5932 	char *name;
5933 	long sff;
5934 {
5935 	struct stat statb;
5936 	int i;
5937 
5938 	/* skip over . and .. directories */
5939 	if (name[0] == '.' &&
5940 	    (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')))
5941 		return false;
5942 #if HASLSTAT
5943 	if (lstat(name, &statb) < 0)
5944 #else /* HASLSTAT */
5945 	if (stat(name, &statb) < 0)
5946 #endif /* HASLSTAT */
5947 	{
5948 		if (tTd(41, 2))
5949 			sm_dprintf("chkqdir: stat(\"%s\"): %s\n",
5950 				   name, sm_errstring(errno));
5951 		return false;
5952 	}
5953 #if HASLSTAT
5954 	if (S_ISLNK(statb.st_mode))
5955 	{
5956 		/*
5957 		**  For a symlink we need to make sure the
5958 		**  target is a directory
5959 		*/
5960 
5961 		if (stat(name, &statb) < 0)
5962 		{
5963 			if (tTd(41, 2))
5964 				sm_dprintf("chkqdir: stat(\"%s\"): %s\n",
5965 					   name, sm_errstring(errno));
5966 			return false;
5967 		}
5968 	}
5969 #endif /* HASLSTAT */
5970 
5971 	if (!S_ISDIR(statb.st_mode))
5972 	{
5973 		if (tTd(41, 2))
5974 			sm_dprintf("chkqdir: \"%s\": Not a directory\n",
5975 				name);
5976 		return false;
5977 	}
5978 
5979 	/* Print a warning if unsafe (but still use it) */
5980 	/* XXX do this only if we want the warning? */
5981 	i = safedirpath(name, RunAsUid, RunAsGid, NULL, sff, 0, 0);
5982 	if (i != 0)
5983 	{
5984 		if (tTd(41, 2))
5985 			sm_dprintf("chkqdir: \"%s\": Not safe: %s\n",
5986 				   name, sm_errstring(i));
5987 #if _FFR_CHK_QUEUE
5988 		if (LogLevel > 8)
5989 			sm_syslog(LOG_WARNING, NOQID,
5990 				  "queue directory \"%s\": Not safe: %s",
5991 				  name, sm_errstring(i));
5992 #endif /* _FFR_CHK_QUEUE */
5993 	}
5994 	return true;
5995 }
5996 /*
5997 **  MULTIQUEUE_CACHE -- cache a list of paths to queues.
5998 **
5999 **	Each potential queue is checked as the cache is built.
6000 **	Thereafter, each is blindly trusted.
6001 **	Note that we can be called again after a timeout to rebuild
6002 **	(although code for that is not ready yet).
6003 **
6004 **	Parameters:
6005 **		basedir -- base of all queue directories.
6006 **		blen -- strlen(basedir).
6007 **		qg -- queue group.
6008 **		qn -- number of queue directories already cached.
6009 **		phash -- pointer to hash value over queue dirs.
6010 #if SM_CONF_SHM
6011 **			only used if shared memory is active.
6012 #endif * SM_CONF_SHM *
6013 **
6014 **	Returns:
6015 **		new number of queue directories.
6016 */
6017 
6018 #define INITIAL_SLOTS	20
6019 #define ADD_SLOTS	10
6020 
6021 static int
multiqueue_cache(basedir,blen,qg,qn,phash)6022 multiqueue_cache(basedir, blen, qg, qn, phash)
6023 	char *basedir;
6024 	int blen;
6025 	QUEUEGRP *qg;
6026 	int qn;
6027 	unsigned int *phash;
6028 {
6029 	char *cp;
6030 	int i, len;
6031 	int slotsleft = 0;
6032 	long sff = SFF_ANYFILE;
6033 	char qpath[MAXPATHLEN];
6034 	char subdir[MAXPATHLEN];
6035 	char prefix[MAXPATHLEN];	/* dir relative to basedir */
6036 
6037 	if (tTd(41, 20))
6038 		sm_dprintf("multiqueue_cache: called\n");
6039 
6040 	/* Initialize to current directory */
6041 	prefix[0] = '.';
6042 	prefix[1] = '\0';
6043 	if (qg->qg_numqueues != 0 && qg->qg_qpaths != NULL)
6044 	{
6045 		for (i = 0; i < qg->qg_numqueues; i++)
6046 		{
6047 			if (qg->qg_qpaths[i].qp_name != NULL)
6048 				(void) sm_free(qg->qg_qpaths[i].qp_name); /* XXX */
6049 		}
6050 		(void) sm_free((char *) qg->qg_qpaths); /* XXX */
6051 		qg->qg_qpaths = NULL;
6052 		qg->qg_numqueues = 0;
6053 	}
6054 
6055 	/* If running as root, allow safedirpath() checks to use privs */
6056 	if (RunAsUid == 0)
6057 		sff |= SFF_ROOTOK;
6058 #if _FFR_CHK_QUEUE
6059 	sff |= SFF_SAFEDIRPATH|SFF_NOWWFILES;
6060 	if (!UseMSP)
6061 		sff |= SFF_NOGWFILES;
6062 #endif /* _FFR_CHK_QUEUE */
6063 
6064 	if (!SM_IS_DIR_START(qg->qg_qdir))
6065 	{
6066 		/*
6067 		**  XXX we could add basedir, but then we have to realloc()
6068 		**  the string... Maybe another time.
6069 		*/
6070 
6071 		syserr("QueuePath %s not absolute", qg->qg_qdir);
6072 		ExitStat = EX_CONFIG;
6073 		return qn;
6074 	}
6075 
6076 	/* qpath: directory of current workgroup */
6077 	len = sm_strlcpy(qpath, qg->qg_qdir, sizeof(qpath));
6078 	if (len >= sizeof(qpath))
6079 	{
6080 		syserr("QueuePath %.256s too long (%d max)",
6081 		       qg->qg_qdir, (int) sizeof(qpath));
6082 		ExitStat = EX_CONFIG;
6083 		return qn;
6084 	}
6085 
6086 	/* begin of qpath must be same as basedir */
6087 	if (strncmp(basedir, qpath, blen) != 0 &&
6088 	    (strncmp(basedir, qpath, blen - 1) != 0 || len != blen - 1))
6089 	{
6090 		syserr("QueuePath %s not subpath of QueueDirectory %s",
6091 			qpath, basedir);
6092 		ExitStat = EX_CONFIG;
6093 		return qn;
6094 	}
6095 
6096 	/* Do we have a nested subdirectory? */
6097 	if (blen < len && SM_FIRST_DIR_DELIM(qg->qg_qdir + blen) != NULL)
6098 	{
6099 
6100 		/* Copy subdirectory into prefix for later use */
6101 		if (sm_strlcpy(prefix, qg->qg_qdir + blen, sizeof(prefix)) >=
6102 		    sizeof(prefix))
6103 		{
6104 			syserr("QueuePath %.256s too long (%d max)",
6105 				qg->qg_qdir, (int) sizeof(qpath));
6106 			ExitStat = EX_CONFIG;
6107 			return qn;
6108 		}
6109 		cp = SM_LAST_DIR_DELIM(prefix);
6110 		SM_ASSERT(cp != NULL);
6111 		*cp = '\0';	/* cut off trailing / */
6112 	}
6113 
6114 	/* This is guaranteed by the basedir check above */
6115 	SM_ASSERT(len >= blen - 1);
6116 	cp = &qpath[len - 1];
6117 	if (*cp == '*')
6118 	{
6119 		register DIR *dp;
6120 		register struct dirent *d;
6121 		int off;
6122 		char *delim;
6123 		char relpath[MAXPATHLEN];
6124 
6125 		*cp = '\0';	/* Overwrite wildcard */
6126 		if ((cp = SM_LAST_DIR_DELIM(qpath)) == NULL)
6127 		{
6128 			syserr("QueueDirectory: can not wildcard relative path");
6129 			if (tTd(41, 2))
6130 				sm_dprintf("multiqueue_cache: \"%s*\": Can not wildcard relative path.\n",
6131 					qpath);
6132 			ExitStat = EX_CONFIG;
6133 			return qn;
6134 		}
6135 		if (cp == qpath)
6136 		{
6137 			/*
6138 			**  Special case of top level wildcard, like /foo*
6139 			**	Change to //foo*
6140 			*/
6141 
6142 			(void) sm_strlcpy(qpath + 1, qpath, sizeof(qpath) - 1);
6143 			++cp;
6144 		}
6145 		delim = cp;
6146 		*(cp++) = '\0';		/* Replace / with \0 */
6147 		len = strlen(cp);	/* Last component of queue directory */
6148 
6149 		/*
6150 		**  Path relative to basedir, with trailing /
6151 		**  It will be modified below to specify the subdirectories
6152 		**  so they can be opened without chdir().
6153 		*/
6154 
6155 		off = sm_strlcpyn(relpath, sizeof(relpath), 2, prefix, "/");
6156 		SM_ASSERT(off < sizeof(relpath));
6157 
6158 		if (tTd(41, 2))
6159 			sm_dprintf("multiqueue_cache: prefix=\"%s%s\"\n",
6160 				   relpath, cp);
6161 
6162 		/* It is always basedir: we don't need to store it per group */
6163 		/* XXX: optimize this! -> one more global? */
6164 		qg->qg_qdir = newstr(basedir);
6165 		qg->qg_qdir[blen - 1] = '\0';	/* cut off trailing / */
6166 
6167 		/*
6168 		**  XXX Should probably wrap this whole loop in a timeout
6169 		**  in case some wag decides to NFS mount the queues.
6170 		*/
6171 
6172 		/* Test path to get warning messages. */
6173 		if (qn == 0)
6174 		{
6175 			/*  XXX qg_runasuid and qg_runasgid for specials? */
6176 			i = safedirpath(basedir, RunAsUid, RunAsGid, NULL,
6177 					sff, 0, 0);
6178 			if (i != 0 && tTd(41, 2))
6179 				sm_dprintf("multiqueue_cache: \"%s\": Not safe: %s\n",
6180 					   basedir, sm_errstring(i));
6181 		}
6182 
6183 		if ((dp = opendir(prefix)) == NULL)
6184 		{
6185 			syserr("can not opendir(%s/%s)", qg->qg_qdir, prefix);
6186 			if (tTd(41, 2))
6187 				sm_dprintf("multiqueue_cache: opendir(\"%s/%s\"): %s\n",
6188 					   qg->qg_qdir, prefix,
6189 					   sm_errstring(errno));
6190 			ExitStat = EX_CONFIG;
6191 			return qn;
6192 		}
6193 		while ((d = readdir(dp)) != NULL)
6194 		{
6195 			/* Skip . and .. directories */
6196 			if (strcmp(d->d_name, ".") == 0 ||
6197 			    strcmp(d->d_name, "..") == 0)
6198 				continue;
6199 
6200 			i = strlen(d->d_name);
6201 			if (i < len || strncmp(d->d_name, cp, len) != 0)
6202 			{
6203 				if (tTd(41, 5))
6204 					sm_dprintf("multiqueue_cache: \"%s\", skipped\n",
6205 						d->d_name);
6206 				continue;
6207 			}
6208 
6209 			/* Create relative pathname: prefix + local directory */
6210 			i = sizeof(relpath) - off;
6211 			if (sm_strlcpy(relpath + off, d->d_name, i) >= i)
6212 				continue;	/* way too long */
6213 
6214 			if (!chkqdir(relpath, sff))
6215 				continue;
6216 
6217 			if (qg->qg_qpaths == NULL)
6218 			{
6219 				slotsleft = INITIAL_SLOTS;
6220 				qg->qg_qpaths = (QPATHS *)xalloc((sizeof(*qg->qg_qpaths)) *
6221 								slotsleft);
6222 				qg->qg_numqueues = 0;
6223 			}
6224 			else if (slotsleft < 1)
6225 			{
6226 				qg->qg_qpaths = (QPATHS *)sm_realloc((char *)qg->qg_qpaths,
6227 							  (sizeof(*qg->qg_qpaths)) *
6228 							  (qg->qg_numqueues +
6229 							   ADD_SLOTS));
6230 				if (qg->qg_qpaths == NULL)
6231 				{
6232 					(void) closedir(dp);
6233 					return qn;
6234 				}
6235 				slotsleft += ADD_SLOTS;
6236 			}
6237 
6238 			/* check subdirs */
6239 			qg->qg_qpaths[qg->qg_numqueues].qp_subdirs = QP_NOSUB;
6240 
6241 #define CHKRSUBDIR(name, flag)	\
6242 	(void) sm_strlcpyn(subdir, sizeof(subdir), 3, relpath, "/", name); \
6243 	if (chkqdir(subdir, sff))	\
6244 		qg->qg_qpaths[qg->qg_numqueues].qp_subdirs |= flag;	\
6245 	else
6246 
6247 
6248 			CHKRSUBDIR("qf", QP_SUBQF);
6249 			CHKRSUBDIR("df", QP_SUBDF);
6250 			CHKRSUBDIR("xf", QP_SUBXF);
6251 
6252 			/* assert(strlen(d->d_name) < MAXPATHLEN - 14) */
6253 			/* maybe even - 17 (subdirs) */
6254 
6255 			if (prefix[0] != '.')
6256 				qg->qg_qpaths[qg->qg_numqueues].qp_name =
6257 					newstr(relpath);
6258 			else
6259 				qg->qg_qpaths[qg->qg_numqueues].qp_name =
6260 					newstr(d->d_name);
6261 
6262 			if (tTd(41, 2))
6263 				sm_dprintf("multiqueue_cache: %d: \"%s\" cached (%x).\n",
6264 					qg->qg_numqueues, relpath,
6265 					qg->qg_qpaths[qg->qg_numqueues].qp_subdirs);
6266 #if SM_CONF_SHM
6267 			qg->qg_qpaths[qg->qg_numqueues].qp_idx = qn;
6268 			*phash = hash_q(relpath, *phash);
6269 #endif /* SM_CONF_SHM */
6270 			qg->qg_numqueues++;
6271 			++qn;
6272 			slotsleft--;
6273 		}
6274 		(void) closedir(dp);
6275 
6276 		/* undo damage */
6277 		*delim = '/';
6278 	}
6279 	if (qg->qg_numqueues == 0)
6280 	{
6281 		qg->qg_qpaths = (QPATHS *) xalloc(sizeof(*qg->qg_qpaths));
6282 
6283 		/* test path to get warning messages */
6284 		i = safedirpath(qpath, RunAsUid, RunAsGid, NULL, sff, 0, 0);
6285 		if (i == ENOENT)
6286 		{
6287 			syserr("can not opendir(%s)", qpath);
6288 			if (tTd(41, 2))
6289 				sm_dprintf("multiqueue_cache: opendir(\"%s\"): %s\n",
6290 					   qpath, sm_errstring(i));
6291 			ExitStat = EX_CONFIG;
6292 			return qn;
6293 		}
6294 
6295 		qg->qg_qpaths[0].qp_subdirs = QP_NOSUB;
6296 		qg->qg_numqueues = 1;
6297 
6298 		/* check subdirs */
6299 #define CHKSUBDIR(name, flag)	\
6300 	(void) sm_strlcpyn(subdir, sizeof(subdir), 3, qg->qg_qdir, "/", name); \
6301 	if (chkqdir(subdir, sff))	\
6302 		qg->qg_qpaths[0].qp_subdirs |= flag;	\
6303 	else
6304 
6305 		CHKSUBDIR("qf", QP_SUBQF);
6306 		CHKSUBDIR("df", QP_SUBDF);
6307 		CHKSUBDIR("xf", QP_SUBXF);
6308 
6309 		if (qg->qg_qdir[blen - 1] != '\0' &&
6310 		    qg->qg_qdir[blen] != '\0')
6311 		{
6312 			/*
6313 			**  Copy the last component into qpaths and
6314 			**  cut off qdir
6315 			*/
6316 
6317 			qg->qg_qpaths[0].qp_name = newstr(qg->qg_qdir + blen);
6318 			qg->qg_qdir[blen - 1] = '\0';
6319 		}
6320 		else
6321 			qg->qg_qpaths[0].qp_name = newstr(".");
6322 
6323 #if SM_CONF_SHM
6324 		qg->qg_qpaths[0].qp_idx = qn;
6325 		*phash = hash_q(qg->qg_qpaths[0].qp_name, *phash);
6326 #endif /* SM_CONF_SHM */
6327 		++qn;
6328 	}
6329 	return qn;
6330 }
6331 
6332 /*
6333 **  FILESYS_FIND -- find entry in FileSys table, or add new one
6334 **
6335 **	Given the pathname of a directory, determine the file system
6336 **	in which that directory resides, and return a pointer to the
6337 **	entry in the FileSys table that describes the file system.
6338 **	A new entry is added if necessary (and requested).
6339 **	If the directory does not exist, -1 is returned.
6340 **
6341 **	Parameters:
6342 **		name -- name of directory (must be persistent!)
6343 **		path -- pathname of directory (name plus maybe "/df")
6344 **		add -- add to structure if not found.
6345 **
6346 **	Returns:
6347 **		>=0: found: index in file system table
6348 **		<0: some error, i.e.,
6349 **		FSF_TOO_MANY: too many filesystems (-> syserr())
6350 **		FSF_STAT_FAIL: can't stat() filesystem (-> syserr())
6351 **		FSF_NOT_FOUND: not in list
6352 */
6353 
6354 static short filesys_find __P((const char *, const char *, bool));
6355 
6356 #define FSF_NOT_FOUND	(-1)
6357 #define FSF_STAT_FAIL	(-2)
6358 #define FSF_TOO_MANY	(-3)
6359 
6360 static short
filesys_find(name,path,add)6361 filesys_find(name, path, add)
6362 	const char *name;
6363 	const char *path;
6364 	bool add;
6365 {
6366 	struct stat st;
6367 	short i;
6368 
6369 	if (stat(path, &st) < 0)
6370 	{
6371 		syserr("cannot stat queue directory %s", path);
6372 		return FSF_STAT_FAIL;
6373 	}
6374 	for (i = 0; i < NumFileSys; ++i)
6375 	{
6376 		if (FILE_SYS_DEV(i) == st.st_dev)
6377 		{
6378 			/*
6379 			**  Make sure the file system (FS) name is set:
6380 			**  even though the source code indicates that
6381 			**  FILE_SYS_DEV() is only set below, it could be
6382 			**  set via shared memory, hence we need to perform
6383 			**  this check/assignment here.
6384 			*/
6385 
6386 			if (NULL == FILE_SYS_NAME(i))
6387 				FILE_SYS_NAME(i) = name;
6388 			return i;
6389 		}
6390 	}
6391 	if (i >= MAXFILESYS)
6392 	{
6393 		syserr("too many queue file systems (%d max)", MAXFILESYS);
6394 		return FSF_TOO_MANY;
6395 	}
6396 	if (!add)
6397 		return FSF_NOT_FOUND;
6398 
6399 	++NumFileSys;
6400 	FILE_SYS_NAME(i) = name;
6401 	FILE_SYS_DEV(i) = st.st_dev;
6402 	FILE_SYS_AVAIL(i) = 0;
6403 	FILE_SYS_BLKSIZE(i) = 1024; /* avoid divide by zero */
6404 	return i;
6405 }
6406 
6407 /*
6408 **  FILESYS_SETUP -- set up mapping from queue directories to file systems
6409 **
6410 **	This data structure is used to efficiently check the amount of
6411 **	free space available in a set of queue directories.
6412 **
6413 **	Parameters:
6414 **		add -- initialize structure if necessary.
6415 **
6416 **	Returns:
6417 **		0: success
6418 **		<0: some error, i.e.,
6419 **		FSF_NOT_FOUND: not in list
6420 **		FSF_STAT_FAIL: can't stat() filesystem (-> syserr())
6421 **		FSF_TOO_MANY: too many filesystems (-> syserr())
6422 */
6423 
6424 static int filesys_setup __P((bool));
6425 
6426 static int
filesys_setup(add)6427 filesys_setup(add)
6428 	bool add;
6429 {
6430 	int i, j;
6431 	short fs;
6432 	int ret;
6433 
6434 	ret = 0;
6435 	for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
6436 	{
6437 		for (j = 0; j < Queue[i]->qg_numqueues; ++j)
6438 		{
6439 			QPATHS *qp = &Queue[i]->qg_qpaths[j];
6440 			char qddf[MAXPATHLEN];
6441 
6442 			(void) sm_strlcpyn(qddf, sizeof(qddf), 2, qp->qp_name,
6443 					(bitset(QP_SUBDF, qp->qp_subdirs)
6444 						? "/df" : ""));
6445 			fs = filesys_find(qp->qp_name, qddf, add);
6446 			if (fs >= 0)
6447 				qp->qp_fsysidx = fs;
6448 			else
6449 				qp->qp_fsysidx = 0;
6450 			if (fs < ret)
6451 				ret = fs;
6452 		}
6453 	}
6454 	return ret;
6455 }
6456 
6457 /*
6458 **  FILESYS_UPDATE -- update amount of free space on all file systems
6459 **
6460 **	The FileSys table is used to cache the amount of free space
6461 **	available on all queue directory file systems.
6462 **	This function updates the cached information if it has expired.
6463 **
6464 **	Parameters:
6465 **		none.
6466 **
6467 **	Returns:
6468 **		none.
6469 **
6470 **	Side Effects:
6471 **		Updates FileSys table.
6472 */
6473 
6474 void
filesys_update()6475 filesys_update()
6476 {
6477 	int i;
6478 	long avail, blksize;
6479 	time_t now;
6480 	static time_t nextupdate = 0;
6481 
6482 #if SM_CONF_SHM
6483 	/*
6484 	**  Only the daemon updates the shared memory, i.e.,
6485 	**  if shared memory is available but the pid is not the
6486 	**  one of the daemon, then don't do anything.
6487 	*/
6488 
6489 	if (ShmId != SM_SHM_NO_ID && DaemonPid != CurrentPid)
6490 		return;
6491 #endif /* SM_CONF_SHM */
6492 	now = curtime();
6493 	if (now < nextupdate)
6494 		return;
6495 	nextupdate = now + FILESYS_UPDATE_INTERVAL;
6496 	for (i = 0; i < NumFileSys; ++i)
6497 	{
6498 		FILESYS *fs = &FILE_SYS(i);
6499 
6500 		avail = freediskspace(FILE_SYS_NAME(i), &blksize);
6501 		if (avail < 0 || blksize <= 0)
6502 		{
6503 			if (LogLevel > 5)
6504 				sm_syslog(LOG_ERR, NOQID,
6505 					"filesys_update failed: %s, fs=%s, avail=%ld, blocksize=%ld",
6506 					sm_errstring(errno),
6507 					FILE_SYS_NAME(i), avail, blksize);
6508 			fs->fs_avail = 0;
6509 			fs->fs_blksize = 1024; /* avoid divide by zero */
6510 			nextupdate = now + 2; /* let's do this soon again */
6511 		}
6512 		else
6513 		{
6514 			fs->fs_avail = avail;
6515 			fs->fs_blksize = blksize;
6516 		}
6517 	}
6518 }
6519 
6520 #if _FFR_ANY_FREE_FS
6521 /*
6522 **  FILESYS_FREE -- check whether there is at least one fs with enough space.
6523 **
6524 **	Parameters:
6525 **		fsize -- file size in bytes
6526 **
6527 **	Returns:
6528 **		true iff there is one fs with more than fsize bytes free.
6529 */
6530 
6531 bool
filesys_free(fsize)6532 filesys_free(fsize)
6533 	long fsize;
6534 {
6535 	int i;
6536 
6537 	if (fsize <= 0)
6538 		return true;
6539 	for (i = 0; i < NumFileSys; ++i)
6540 	{
6541 		long needed = 0;
6542 
6543 		if (FILE_SYS_AVAIL(i) < 0 || FILE_SYS_BLKSIZE(i) <= 0)
6544 			continue;
6545 		needed += fsize / FILE_SYS_BLKSIZE(i)
6546 			  + ((fsize % FILE_SYS_BLKSIZE(i)
6547 			      > 0) ? 1 : 0)
6548 			  + MinBlocksFree;
6549 		if (needed <= FILE_SYS_AVAIL(i))
6550 			return true;
6551 	}
6552 	return false;
6553 }
6554 #endif /* _FFR_ANY_FREE_FS */
6555 
6556 /*
6557 **  DISK_STATUS -- show amount of free space in queue directories
6558 **
6559 **	Parameters:
6560 **		out -- output file pointer.
6561 **		prefix -- string to output in front of each line.
6562 **
6563 **	Returns:
6564 **		none.
6565 */
6566 
6567 void
disk_status(out,prefix)6568 disk_status(out, prefix)
6569 	SM_FILE_T *out;
6570 	char *prefix;
6571 {
6572 	int i;
6573 	long avail, blksize;
6574 	long free;
6575 
6576 	for (i = 0; i < NumFileSys; ++i)
6577 	{
6578 		avail = freediskspace(FILE_SYS_NAME(i), &blksize);
6579 		if (avail >= 0 && blksize > 0)
6580 		{
6581 			free = (long)((double) avail *
6582 				((double) blksize / 1024));
6583 		}
6584 		else
6585 			free = -1;
6586 		(void) sm_io_fprintf(out, SM_TIME_DEFAULT,
6587 				"%s%d/%s/%ld\r\n",
6588 				prefix, i,
6589 				FILE_SYS_NAME(i),
6590 					free);
6591 	}
6592 }
6593 
6594 #if SM_CONF_SHM
6595 
6596 /*
6597 **  INIT_SEM -- initialize semaphore system
6598 **
6599 **	Parameters:
6600 **		owner -- is this the owner of semaphores?
6601 **
6602 **	Returns:
6603 **		none.
6604 */
6605 
6606 #if _FFR_USE_SEM_LOCKING
6607 #if SM_CONF_SEM
6608 static int SemId = -1;		/* Semaphore Id */
6609 int SemKey = SM_SEM_KEY;
6610 #endif /* SM_CONF_SEM */
6611 #endif /* _FFR_USE_SEM_LOCKING */
6612 
6613 static void init_sem __P((bool));
6614 
6615 static void
init_sem(owner)6616 init_sem(owner)
6617 	bool owner;
6618 {
6619 #if _FFR_USE_SEM_LOCKING
6620 #if SM_CONF_SEM
6621 	SemId = sm_sem_start(SemKey, 1, 0, owner);
6622 	if (SemId < 0)
6623 	{
6624 		sm_syslog(LOG_ERR, NOQID,
6625 			"func=init_sem, sem_key=%ld, sm_sem_start=%d, error=%s",
6626 			(long) SemKey, SemId, sm_errstring(-SemId));
6627 		return;
6628 	}
6629 	if (owner && RunAsUid != 0)
6630 	{
6631 		int r;
6632 
6633 		r = sm_semsetowner(SemId, RunAsUid, RunAsGid, 0660);
6634 		if (r != 0)
6635 			sm_syslog(LOG_ERR, NOQID,
6636 				"key=%ld, sm_semsetowner=%d, RunAsUid=%d, RunAsGid=%d",
6637 				(long) SemKey, r, RunAsUid, RunAsGid);
6638 	}
6639 #endif /* SM_CONF_SEM */
6640 #endif /* _FFR_USE_SEM_LOCKING */
6641 	return;
6642 }
6643 
6644 /*
6645 **  STOP_SEM -- stop semaphore system
6646 **
6647 **	Parameters:
6648 **		owner -- is this the owner of semaphores?
6649 **
6650 **	Returns:
6651 **		none.
6652 */
6653 
6654 static void stop_sem __P((bool));
6655 
6656 static void
stop_sem(owner)6657 stop_sem(owner)
6658 	bool owner;
6659 {
6660 #if _FFR_USE_SEM_LOCKING
6661 #if SM_CONF_SEM
6662 	if (owner && SemId >= 0)
6663 		sm_sem_stop(SemId);
6664 #endif /* SM_CONF_SEM */
6665 #endif /* _FFR_USE_SEM_LOCKING */
6666 	return;
6667 }
6668 
6669 /*
6670 **  UPD_QS -- update information about queue when adding/deleting an entry
6671 **
6672 **	Parameters:
6673 **		e -- envelope.
6674 **		count -- add/remove entry (+1/0/-1: add/no change/remove)
6675 **		space -- update the space available as well.
6676 **			(>0/0/<0: add/no change/remove)
6677 **		where -- caller (for logging)
6678 **
6679 **	Returns:
6680 **		none.
6681 **
6682 **	Side Effects:
6683 **		Modifies available space in filesystem.
6684 **		Changes number of entries in queue directory.
6685 */
6686 
6687 void
upd_qs(e,count,space,where)6688 upd_qs(e, count, space, where)
6689 	ENVELOPE *e;
6690 	int count;
6691 	int space;
6692 	char *where;
6693 {
6694 	short fidx;
6695 	int idx;
6696 # if _FFR_USE_SEM_LOCKING
6697 	int r;
6698 # endif /* _FFR_USE_SEM_LOCKING */
6699 	long s;
6700 
6701 	if (ShmId == SM_SHM_NO_ID || e == NULL)
6702 		return;
6703 	if (e->e_qgrp == NOQGRP || e->e_qdir == NOQDIR)
6704 		return;
6705 	idx = Queue[e->e_qgrp]->qg_qpaths[e->e_qdir].qp_idx;
6706 	if (tTd(73,2))
6707 		sm_dprintf("func=upd_qs, count=%d, space=%d, where=%s, idx=%d, entries=%d\n",
6708 			count, space, where, idx, QSHM_ENTRIES(idx));
6709 
6710 	/* XXX in theory this needs to be protected with a mutex */
6711 	if (QSHM_ENTRIES(idx) >= 0 && count != 0)
6712 	{
6713 # if _FFR_USE_SEM_LOCKING
6714 		r = sm_sem_acq(SemId, 0, 1);
6715 # endif /* _FFR_USE_SEM_LOCKING */
6716 		QSHM_ENTRIES(idx) += count;
6717 # if _FFR_USE_SEM_LOCKING
6718 		if (r >= 0)
6719 			r = sm_sem_rel(SemId, 0, 1);
6720 # endif /* _FFR_USE_SEM_LOCKING */
6721 	}
6722 
6723 	fidx = Queue[e->e_qgrp]->qg_qpaths[e->e_qdir].qp_fsysidx;
6724 	if (fidx < 0)
6725 		return;
6726 
6727 	/* update available space also?  (might be loseqfile) */
6728 	if (space == 0)
6729 		return;
6730 
6731 	/* convert size to blocks; this causes rounding errors */
6732 	s = e->e_msgsize / FILE_SYS_BLKSIZE(fidx);
6733 	if (s == 0)
6734 		return;
6735 
6736 	/* XXX in theory this needs to be protected with a mutex */
6737 	if (space > 0)
6738 		FILE_SYS_AVAIL(fidx) += s;
6739 	else
6740 		FILE_SYS_AVAIL(fidx) -= s;
6741 
6742 }
6743 
6744 static bool write_key_file __P((char *, long));
6745 static long read_key_file __P((char *, long));
6746 
6747 /*
6748 **  WRITE_KEY_FILE -- record some key into a file.
6749 **
6750 **	Parameters:
6751 **		keypath -- file name.
6752 **		key -- key to write.
6753 **
6754 **	Returns:
6755 **		true iff file could be written.
6756 **
6757 **	Side Effects:
6758 **		writes file.
6759 */
6760 
6761 static bool
write_key_file(keypath,key)6762 write_key_file(keypath, key)
6763 	char *keypath;
6764 	long key;
6765 {
6766 	bool ok;
6767 	long sff;
6768 	SM_FILE_T *keyf;
6769 
6770 	ok = false;
6771 	if (keypath == NULL || *keypath == '\0')
6772 		return ok;
6773 	sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY|SFF_CREAT;
6774 	if (TrustedUid != 0 && RealUid == TrustedUid)
6775 		sff |= SFF_OPENASROOT;
6776 	keyf = safefopen(keypath, O_WRONLY|O_TRUNC, FileMode, sff);
6777 	if (keyf == NULL)
6778 	{
6779 		sm_syslog(LOG_ERR, NOQID, "unable to write %s: %s",
6780 			  keypath, sm_errstring(errno));
6781 	}
6782 	else
6783 	{
6784 		if (geteuid() == 0 && RunAsUid != 0)
6785 		{
6786 #  if HASFCHOWN
6787 			int fd;
6788 
6789 			fd = keyf->f_file;
6790 			if (fd >= 0 && fchown(fd, RunAsUid, -1) < 0)
6791 			{
6792 				int err = errno;
6793 
6794 				sm_syslog(LOG_ALERT, NOQID,
6795 					  "ownership change on %s to %d failed: %s",
6796 					  keypath, RunAsUid, sm_errstring(err));
6797 			}
6798 #  endif /* HASFCHOWN */
6799 		}
6800 		ok = sm_io_fprintf(keyf, SM_TIME_DEFAULT, "%ld\n", key) !=
6801 		     SM_IO_EOF;
6802 		ok = (sm_io_close(keyf, SM_TIME_DEFAULT) != SM_IO_EOF) && ok;
6803 	}
6804 	return ok;
6805 }
6806 
6807 /*
6808 **  READ_KEY_FILE -- read a key from a file.
6809 **
6810 **	Parameters:
6811 **		keypath -- file name.
6812 **		key -- default key.
6813 **
6814 **	Returns:
6815 **		key.
6816 */
6817 
6818 static long
read_key_file(keypath,key)6819 read_key_file(keypath, key)
6820 	char *keypath;
6821 	long key;
6822 {
6823 	int r;
6824 	long sff, n;
6825 	SM_FILE_T *keyf;
6826 
6827 	if (keypath == NULL || *keypath == '\0')
6828 		return key;
6829 	sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY;
6830 	if (RealUid == 0 || (TrustedUid != 0 && RealUid == TrustedUid))
6831 		sff |= SFF_OPENASROOT;
6832 	keyf = safefopen(keypath, O_RDONLY, FileMode, sff);
6833 	if (keyf == NULL)
6834 	{
6835 		sm_syslog(LOG_ERR, NOQID, "unable to read %s: %s",
6836 			  keypath, sm_errstring(errno));
6837 	}
6838 	else
6839 	{
6840 		r = sm_io_fscanf(keyf, SM_TIME_DEFAULT, "%ld", &n);
6841 		if (r == 1)
6842 			key = n;
6843 		(void) sm_io_close(keyf, SM_TIME_DEFAULT);
6844 	}
6845 	return key;
6846 }
6847 
6848 /*
6849 **  INIT_SHM -- initialize shared memory structure
6850 **
6851 **	Initialize or attach to shared memory segment.
6852 **	Currently it is not a fatal error if this doesn't work.
6853 **	However, it causes us to have a "fallback" storage location
6854 **	for everything that is supposed to be in the shared memory,
6855 **	which makes the code slightly ugly.
6856 **
6857 **	Parameters:
6858 **		qn -- number of queue directories.
6859 **		owner -- owner of shared memory.
6860 **		hash -- identifies data that is stored in shared memory.
6861 **
6862 **	Returns:
6863 **		none.
6864 */
6865 
6866 static void init_shm __P((int, bool, unsigned int));
6867 
6868 static void
init_shm(qn,owner,hash)6869 init_shm(qn, owner, hash)
6870 	int qn;
6871 	bool owner;
6872 	unsigned int hash;
6873 {
6874 	int i;
6875 	int count;
6876 	int save_errno;
6877 	bool keyselect;
6878 
6879 	PtrFileSys = &FileSys[0];
6880 	PNumFileSys = &Numfilesys;
6881 /* if this "key" is specified: select one yourself */
6882 #define SEL_SHM_KEY	((key_t) -1)
6883 #define FIRST_SHM_KEY	25
6884 
6885 	/* This allows us to disable shared memory at runtime. */
6886 	if (ShmKey == 0)
6887 		return;
6888 
6889 	count = 0;
6890 	shms = SM_T_SIZE + qn * sizeof(QUEUE_SHM_T);
6891 	keyselect = ShmKey == SEL_SHM_KEY;
6892 	if (keyselect)
6893 	{
6894 		if (owner)
6895 			ShmKey = FIRST_SHM_KEY;
6896 		else
6897 		{
6898 			errno = 0;
6899 			ShmKey = read_key_file(ShmKeyFile, ShmKey);
6900 			keyselect = false;
6901 			if (ShmKey == SEL_SHM_KEY)
6902 			{
6903 				save_errno = (errno != 0) ? errno : EINVAL;
6904 				goto error;
6905 			}
6906 		}
6907 	}
6908 	for (;;)
6909 	{
6910 		/* allow read/write access for group? */
6911 		Pshm = sm_shmstart(ShmKey, shms,
6912 				SHM_R|SHM_W|(SHM_R>>3)|(SHM_W>>3),
6913 				&ShmId, owner);
6914 		save_errno = errno;
6915 		if (Pshm != NULL || !sm_file_exists(save_errno))
6916 			break;
6917 		if (++count >= 3)
6918 		{
6919 			if (keyselect)
6920 			{
6921 				++ShmKey;
6922 
6923 				/* back where we started? */
6924 				if (ShmKey == SEL_SHM_KEY)
6925 					break;
6926 				continue;
6927 			}
6928 			break;
6929 		}
6930 
6931 		/* only sleep if we are at the first key */
6932 		if (!keyselect || ShmKey == SEL_SHM_KEY)
6933 			sleep(count);
6934 	}
6935 	if (Pshm != NULL)
6936 	{
6937 		int *p;
6938 
6939 		if (keyselect)
6940 			(void) write_key_file(ShmKeyFile, (long) ShmKey);
6941 		if (owner && RunAsUid != 0)
6942 		{
6943 			i = sm_shmsetowner(ShmId, RunAsUid, RunAsGid, 0660);
6944 			if (i != 0)
6945 				sm_syslog(LOG_ERR, NOQID,
6946 					"key=%ld, sm_shmsetowner=%d, RunAsUid=%d, RunAsGid=%d",
6947 					(long) ShmKey, i, RunAsUid, RunAsGid);
6948 		}
6949 		p = (int *) Pshm;
6950 		if (owner)
6951 		{
6952 			*p = (int) shms;
6953 			*((pid_t *) SHM_OFF_PID(Pshm)) = CurrentPid;
6954 			p = (int *) SHM_OFF_TAG(Pshm);
6955 			*p = hash;
6956 		}
6957 		else
6958 		{
6959 			if (*p != (int) shms)
6960 			{
6961 				save_errno = EINVAL;
6962 				cleanup_shm(false);
6963 				goto error;
6964 			}
6965 			p = (int *) SHM_OFF_TAG(Pshm);
6966 			if (*p != (int) hash)
6967 			{
6968 				save_errno = EINVAL;
6969 				cleanup_shm(false);
6970 				goto error;
6971 			}
6972 
6973 			/*
6974 			**  XXX how to check the pid?
6975 			**  Read it from the pid-file? That does
6976 			**  not need to exist.
6977 			**  We could disable shm if we can't confirm
6978 			**  that it is the right one.
6979 			*/
6980 		}
6981 
6982 		PtrFileSys = (FILESYS *) OFF_FILE_SYS(Pshm);
6983 		PNumFileSys = (int *) OFF_NUM_FILE_SYS(Pshm);
6984 		QShm = (QUEUE_SHM_T *) OFF_QUEUE_SHM(Pshm);
6985 		PRSATmpCnt = (int *) OFF_RSA_TMP_CNT(Pshm);
6986 		*PRSATmpCnt = 0;
6987 		if (owner)
6988 		{
6989 			/* initialize values in shared memory */
6990 			NumFileSys = 0;
6991 			for (i = 0; i < qn; i++)
6992 				QShm[i].qs_entries = -1;
6993 		}
6994 		init_sem(owner);
6995 		return;
6996 	}
6997   error:
6998 	if (LogLevel > (owner ? 8 : 11))
6999 	{
7000 		sm_syslog(owner ? LOG_ERR : LOG_NOTICE, NOQID,
7001 			  "can't %s shared memory, key=%ld: %s",
7002 			  owner ? "initialize" : "attach to",
7003 			  (long) ShmKey, sm_errstring(save_errno));
7004 	}
7005 }
7006 #endif /* SM_CONF_SHM */
7007 
7008 
7009 /*
7010 **  SETUP_QUEUES -- set up all queue groups
7011 **
7012 **	Parameters:
7013 **		owner -- owner of shared memory?
7014 **
7015 **	Returns:
7016 **		none.
7017 **
7018 #if SM_CONF_SHM
7019 **	Side Effects:
7020 **		attaches shared memory.
7021 #endif * SM_CONF_SHM *
7022 */
7023 
7024 void
setup_queues(owner)7025 setup_queues(owner)
7026 	bool owner;
7027 {
7028 	int i, qn, len;
7029 	unsigned int hashval;
7030 	time_t now;
7031 	char basedir[MAXPATHLEN];
7032 	struct stat st;
7033 
7034 	/*
7035 	**  Determine basedir for all queue directories.
7036 	**  All queue directories must be (first level) subdirectories
7037 	**  of the basedir.  The basedir is the QueueDir
7038 	**  without wildcards, but with trailing /
7039 	*/
7040 
7041 	hashval = 0;
7042 	errno = 0;
7043 	len = sm_strlcpy(basedir, QueueDir, sizeof(basedir));
7044 
7045 	/* Provide space for trailing '/' */
7046 	if (len >= sizeof(basedir) - 1)
7047 	{
7048 		syserr("QueueDirectory: path too long: %d,  max %d",
7049 			len, (int) sizeof(basedir) - 1);
7050 		ExitStat = EX_CONFIG;
7051 		return;
7052 	}
7053 	SM_ASSERT(len > 0);
7054 	if (basedir[len - 1] == '*')
7055 	{
7056 		char *cp;
7057 
7058 		cp = SM_LAST_DIR_DELIM(basedir);
7059 		if (cp == NULL)
7060 		{
7061 			syserr("QueueDirectory: can not wildcard relative path \"%s\"",
7062 				QueueDir);
7063 			if (tTd(41, 2))
7064 				sm_dprintf("setup_queues: \"%s\": Can not wildcard relative path.\n",
7065 					QueueDir);
7066 			ExitStat = EX_CONFIG;
7067 			return;
7068 		}
7069 
7070 		/* cut off wildcard pattern */
7071 		*++cp = '\0';
7072 		len = cp - basedir;
7073 	}
7074 	else if (!SM_IS_DIR_DELIM(basedir[len - 1]))
7075 	{
7076 		/* append trailing slash since it is a directory */
7077 		basedir[len] = '/';
7078 		basedir[++len] = '\0';
7079 	}
7080 
7081 	/* len counts up to the last directory delimiter */
7082 	SM_ASSERT(basedir[len - 1] == '/');
7083 
7084 	if (chdir(basedir) < 0)
7085 	{
7086 		int save_errno = errno;
7087 
7088 		syserr("can not chdir(%s)", basedir);
7089 		if (save_errno == EACCES)
7090 			(void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
7091 				"Program mode requires special privileges, e.g., root or TrustedUser.\n");
7092 		if (tTd(41, 2))
7093 			sm_dprintf("setup_queues: \"%s\": %s\n",
7094 				   basedir, sm_errstring(errno));
7095 		ExitStat = EX_CONFIG;
7096 		return;
7097 	}
7098 #if SM_CONF_SHM
7099 	hashval = hash_q(basedir, hashval);
7100 #endif /* SM_CONF_SHM */
7101 
7102 	/* initialize for queue runs */
7103 	DoQueueRun = false;
7104 	now = curtime();
7105 	for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
7106 		Queue[i]->qg_nextrun = now;
7107 
7108 
7109 	if (UseMSP && OpMode != MD_TEST)
7110 	{
7111 		long sff = SFF_CREAT;
7112 
7113 		if (stat(".", &st) < 0)
7114 		{
7115 			syserr("can not stat(%s)", basedir);
7116 			if (tTd(41, 2))
7117 				sm_dprintf("setup_queues: \"%s\": %s\n",
7118 					   basedir, sm_errstring(errno));
7119 			ExitStat = EX_CONFIG;
7120 			return;
7121 		}
7122 		if (RunAsUid == 0)
7123 			sff |= SFF_ROOTOK;
7124 
7125 		/*
7126 		**  Check queue directory permissions.
7127 		**	Can we write to a group writable queue directory?
7128 		*/
7129 
7130 		if (bitset(S_IWGRP, QueueFileMode) &&
7131 		    bitset(S_IWGRP, st.st_mode) &&
7132 		    safefile(" ", RunAsUid, RunAsGid, RunAsUserName, sff,
7133 			     QueueFileMode, NULL) != 0)
7134 		{
7135 			syserr("can not write to queue directory %s (RunAsGid=%d, required=%d)",
7136 				basedir, (int) RunAsGid, (int) st.st_gid);
7137 		}
7138 		if (bitset(S_IWOTH|S_IXOTH, st.st_mode))
7139 		{
7140 #if _FFR_MSP_PARANOIA
7141 			syserr("dangerous permissions=%o on queue directory %s",
7142 				(int) st.st_mode, basedir);
7143 #else /* _FFR_MSP_PARANOIA */
7144 			if (LogLevel > 0)
7145 				sm_syslog(LOG_ERR, NOQID,
7146 					  "dangerous permissions=%o on queue directory %s",
7147 					  (int) st.st_mode, basedir);
7148 #endif /* _FFR_MSP_PARANOIA */
7149 		}
7150 #if _FFR_MSP_PARANOIA
7151 		if (NumQueue > 1)
7152 			syserr("can not use multiple queues for MSP");
7153 #endif /* _FFR_MSP_PARANOIA */
7154 	}
7155 
7156 	/* initial number of queue directories */
7157 	qn = 0;
7158 	for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
7159 		qn = multiqueue_cache(basedir, len, Queue[i], qn, &hashval);
7160 
7161 #if SM_CONF_SHM
7162 	init_shm(qn, owner, hashval);
7163 	i = filesys_setup(owner || ShmId == SM_SHM_NO_ID);
7164 	if (i == FSF_NOT_FOUND)
7165 	{
7166 		/*
7167 		**  We didn't get the right filesystem data
7168 		**  This may happen if we don't have the right shared memory.
7169 		**  So let's do this without shared memory.
7170 		*/
7171 
7172 		SM_ASSERT(!owner);
7173 		cleanup_shm(false);	/* release shared memory */
7174 		i = filesys_setup(false);
7175 		if (i < 0)
7176 			syserr("filesys_setup failed twice, result=%d", i);
7177 		else if (LogLevel > 8)
7178 			sm_syslog(LOG_WARNING, NOQID,
7179 				  "shared memory does not contain expected data, ignored");
7180 	}
7181 #else /* SM_CONF_SHM */
7182 	i = filesys_setup(true);
7183 #endif /* SM_CONF_SHM */
7184 	if (i < 0)
7185 		ExitStat = EX_CONFIG;
7186 }
7187 
7188 #if SM_CONF_SHM
7189 /*
7190 **  CLEANUP_SHM -- do some cleanup work for shared memory etc
7191 **
7192 **	Parameters:
7193 **		owner -- owner of shared memory?
7194 **
7195 **	Returns:
7196 **		none.
7197 **
7198 **	Side Effects:
7199 **		detaches shared memory.
7200 */
7201 
7202 void
cleanup_shm(owner)7203 cleanup_shm(owner)
7204 	bool owner;
7205 {
7206 	if (ShmId != SM_SHM_NO_ID)
7207 	{
7208 		if (sm_shmstop(Pshm, ShmId, owner) < 0 && LogLevel > 8)
7209 			sm_syslog(LOG_INFO, NOQID, "sm_shmstop failed=%s",
7210 				  sm_errstring(errno));
7211 		Pshm = NULL;
7212 		ShmId = SM_SHM_NO_ID;
7213 	}
7214 	stop_sem(owner);
7215 }
7216 #endif /* SM_CONF_SHM */
7217 
7218 /*
7219 **  CLEANUP_QUEUES -- do some cleanup work for queues
7220 **
7221 **	Parameters:
7222 **		none.
7223 **
7224 **	Returns:
7225 **		none.
7226 **
7227 */
7228 
7229 void
cleanup_queues()7230 cleanup_queues()
7231 {
7232 	sync_queue_time();
7233 }
7234 /*
7235 **  SET_DEF_QUEUEVAL -- set default values for a queue group.
7236 **
7237 **	Parameters:
7238 **		qg -- queue group
7239 **		all -- set all values (true for default group)?
7240 **
7241 **	Returns:
7242 **		none.
7243 **
7244 **	Side Effects:
7245 **		sets default values for the queue group.
7246 */
7247 
7248 void
set_def_queueval(qg,all)7249 set_def_queueval(qg, all)
7250 	QUEUEGRP *qg;
7251 	bool all;
7252 {
7253 	if (bitnset(QD_DEFINED, qg->qg_flags))
7254 		return;
7255 	if (all)
7256 		qg->qg_qdir = QueueDir;
7257 #if _FFR_QUEUE_GROUP_SORTORDER
7258 	qg->qg_sortorder = QueueSortOrder;
7259 #endif /* _FFR_QUEUE_GROUP_SORTORDER */
7260 	qg->qg_maxqrun = all ? MaxRunnersPerQueue : -1;
7261 	qg->qg_nice = NiceQueueRun;
7262 }
7263 /*
7264 **  MAKEQUEUE -- define a new queue.
7265 **
7266 **	Parameters:
7267 **		line -- description of queue.  This is in labeled fields.
7268 **			The fields are:
7269 **			   F -- the flags associated with the queue
7270 **			   I -- the interval between running the queue
7271 **			   J -- the maximum # of jobs in work list
7272 **			   [M -- the maximum # of jobs in a queue run]
7273 **			   N -- the niceness at which to run
7274 **			   P -- the path to the queue
7275 **			   S -- the queue sorting order
7276 **			   R -- number of parallel queue runners
7277 **			   r -- max recipients per envelope
7278 **			The first word is the canonical name of the queue.
7279 **		qdef -- this is a 'Q' definition from .cf
7280 **
7281 **	Returns:
7282 **		none.
7283 **
7284 **	Side Effects:
7285 **		enters the queue into the queue table.
7286 */
7287 
7288 void
makequeue(line,qdef)7289 makequeue(line, qdef)
7290 	char *line;
7291 	bool qdef;
7292 {
7293 	register char *p;
7294 	register QUEUEGRP *qg;
7295 	register STAB *s;
7296 	int i;
7297 	char fcode;
7298 
7299 	/* allocate a queue and set up defaults */
7300 	qg = (QUEUEGRP *) xalloc(sizeof(*qg));
7301 	memset((char *) qg, '\0', sizeof(*qg));
7302 
7303 	if (line[0] == '\0')
7304 	{
7305 		syserr("name required for queue");
7306 		return;
7307 	}
7308 
7309 	/* collect the queue name */
7310 	for (p = line;
7311 	     *p != '\0' && *p != ',' && !(isascii(*p) && isspace(*p));
7312 	     p++)
7313 		continue;
7314 	if (*p != '\0')
7315 		*p++ = '\0';
7316 	qg->qg_name = newstr(line);
7317 
7318 	/* set default values, can be overridden below */
7319 	set_def_queueval(qg, false);
7320 
7321 	/* now scan through and assign info from the fields */
7322 	while (*p != '\0')
7323 	{
7324 		auto char *delimptr;
7325 
7326 		while (*p != '\0' &&
7327 		       (*p == ',' || (isascii(*p) && isspace(*p))))
7328 			p++;
7329 
7330 		/* p now points to field code */
7331 		fcode = *p;
7332 		while (*p != '\0' && *p != '=' && *p != ',')
7333 			p++;
7334 		if (*p++ != '=')
7335 		{
7336 			syserr("queue %s: `=' expected", qg->qg_name);
7337 			return;
7338 		}
7339 		while (isascii(*p) && isspace(*p))
7340 			p++;
7341 
7342 		/* p now points to the field body */
7343 		p = munchstring(p, &delimptr, ',');
7344 
7345 		/* install the field into the queue struct */
7346 		switch (fcode)
7347 		{
7348 		  case 'P':		/* pathname */
7349 			if (*p == '\0')
7350 				syserr("queue %s: empty path name",
7351 					qg->qg_name);
7352 			else
7353 				qg->qg_qdir = newstr(p);
7354 			break;
7355 
7356 		  case 'F':		/* flags */
7357 			for (; *p != '\0'; p++)
7358 				if (!(isascii(*p) && isspace(*p)))
7359 					setbitn(*p, qg->qg_flags);
7360 			break;
7361 
7362 			/*
7363 			**  Do we need two intervals here:
7364 			**  One for persistent queue runners,
7365 			**  one for "normal" queue runs?
7366 			*/
7367 
7368 		  case 'I':	/* interval between running the queue */
7369 			qg->qg_queueintvl = convtime(p, 'm');
7370 			break;
7371 
7372 		  case 'N':		/* run niceness */
7373 			qg->qg_nice = atoi(p);
7374 			break;
7375 
7376 		  case 'R':		/* maximum # of runners for the group */
7377 			i = atoi(p);
7378 
7379 			/* can't have more runners than allowed total */
7380 			if (MaxQueueChildren > 0 && i > MaxQueueChildren)
7381 			{
7382 				qg->qg_maxqrun = MaxQueueChildren;
7383 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
7384 						     "Q=%s: R=%d exceeds MaxQueueChildren=%d, set to MaxQueueChildren\n",
7385 						     qg->qg_name, i,
7386 						     MaxQueueChildren);
7387 			}
7388 			else
7389 				qg->qg_maxqrun = i;
7390 			break;
7391 
7392 		  case 'J':		/* maximum # of jobs in work list */
7393 			qg->qg_maxlist = atoi(p);
7394 			break;
7395 
7396 		  case 'r':		/* max recipients per envelope */
7397 			qg->qg_maxrcpt = atoi(p);
7398 			break;
7399 
7400 #if _FFR_QUEUE_GROUP_SORTORDER
7401 		  case 'S':		/* queue sorting order */
7402 			switch (*p)
7403 			{
7404 			  case 'h':	/* Host first */
7405 			  case 'H':
7406 				qg->qg_sortorder = QSO_BYHOST;
7407 				break;
7408 
7409 			  case 'p':	/* Priority order */
7410 			  case 'P':
7411 				qg->qg_sortorder = QSO_BYPRIORITY;
7412 				break;
7413 
7414 			  case 't':	/* Submission time */
7415 			  case 'T':
7416 				qg->qg_sortorder = QSO_BYTIME;
7417 				break;
7418 
7419 			  case 'f':	/* File name */
7420 			  case 'F':
7421 				qg->qg_sortorder = QSO_BYFILENAME;
7422 				break;
7423 
7424 			  case 'm':	/* Modification time */
7425 			  case 'M':
7426 				qg->qg_sortorder = QSO_BYMODTIME;
7427 				break;
7428 
7429 			  case 'r':	/* Random */
7430 			  case 'R':
7431 				qg->qg_sortorder = QSO_RANDOM;
7432 				break;
7433 
7434 # if _FFR_RHS
7435 			  case 's':	/* Shuffled host name */
7436 			  case 'S':
7437 				qg->qg_sortorder = QSO_BYSHUFFLE;
7438 				break;
7439 # endif /* _FFR_RHS */
7440 
7441 			  case 'n':	/* none */
7442 			  case 'N':
7443 				qg->qg_sortorder = QSO_NONE;
7444 				break;
7445 
7446 			  default:
7447 				syserr("Invalid queue sort order \"%s\"", p);
7448 			}
7449 			break;
7450 #endif /* _FFR_QUEUE_GROUP_SORTORDER */
7451 
7452 		  default:
7453 			syserr("Q%s: unknown queue equate %c=",
7454 			       qg->qg_name, fcode);
7455 			break;
7456 		}
7457 
7458 		p = delimptr;
7459 	}
7460 
7461 #if !HASNICE
7462 	if (qg->qg_nice != NiceQueueRun)
7463 	{
7464 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
7465 				     "Q%s: Warning: N= set on system that doesn't support nice()\n",
7466 				     qg->qg_name);
7467 	}
7468 #endif /* !HASNICE */
7469 
7470 	/* do some rationality checking */
7471 	if (NumQueue >= MAXQUEUEGROUPS)
7472 	{
7473 		syserr("too many queue groups defined (%d max)",
7474 			MAXQUEUEGROUPS);
7475 		return;
7476 	}
7477 
7478 	if (qg->qg_qdir == NULL)
7479 	{
7480 		if (QueueDir == NULL || *QueueDir == '\0')
7481 		{
7482 			syserr("QueueDir must be defined before queue groups");
7483 			return;
7484 		}
7485 		qg->qg_qdir = newstr(QueueDir);
7486 	}
7487 
7488 	if (qg->qg_maxqrun > 1 && !bitnset(QD_FORK, qg->qg_flags))
7489 	{
7490 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
7491 				     "Warning: Q=%s: R=%d: multiple queue runners specified\n\tbut flag '%c' is not set\n",
7492 				     qg->qg_name, qg->qg_maxqrun, QD_FORK);
7493 	}
7494 
7495 	/* enter the queue into the symbol table */
7496 	if (tTd(37, 8))
7497 		sm_syslog(LOG_INFO, NOQID,
7498 			  "Adding %s to stab, path: %s", qg->qg_name,
7499 			  qg->qg_qdir);
7500 	s = stab(qg->qg_name, ST_QUEUE, ST_ENTER);
7501 	if (s->s_quegrp != NULL)
7502 	{
7503 		i = s->s_quegrp->qg_index;
7504 
7505 		/* XXX what about the pointers inside this struct? */
7506 		sm_free(s->s_quegrp); /* XXX */
7507 	}
7508 	else
7509 		i = NumQueue++;
7510 	Queue[i] = s->s_quegrp = qg;
7511 	qg->qg_index = i;
7512 
7513 	/* set default value for max queue runners */
7514 	if (qg->qg_maxqrun < 0)
7515 	{
7516 		if (MaxRunnersPerQueue > 0)
7517 			qg->qg_maxqrun = MaxRunnersPerQueue;
7518 		else
7519 			qg->qg_maxqrun = 1;
7520 	}
7521 	if (qdef)
7522 		setbitn(QD_DEFINED, qg->qg_flags);
7523 }
7524 #if 0
7525 /*
7526 **  HASHFQN -- calculate a hash value for a fully qualified host name
7527 **
7528 **	Arguments:
7529 **		fqn -- an all lower-case host.domain string
7530 **		buckets -- the number of buckets (queue directories)
7531 **
7532 **	Returns:
7533 **		a bucket number (signed integer)
7534 **		-1 on error
7535 **
7536 **	Contributed by Exactis.com, Inc.
7537 */
7538 
7539 int
7540 hashfqn(fqn, buckets)
7541 	register char *fqn;
7542 	int buckets;
7543 {
7544 	register char *p;
7545 	register int h = 0, hash, cnt;
7546 
7547 	if (fqn == NULL)
7548 		return -1;
7549 
7550 	/*
7551 	**  A variation on the gdb hash
7552 	**  This is the best as of Feb 19, 1996 --bcx
7553 	*/
7554 
7555 	p = fqn;
7556 	h = 0x238F13AF * strlen(p);
7557 	for (cnt = 0; *p != 0; ++p, cnt++)
7558 	{
7559 		h = (h + (*p << (cnt * 5 % 24))) & 0x7FFFFFFF;
7560 	}
7561 	h = (1103515243 * h + 12345) & 0x7FFFFFFF;
7562 	if (buckets < 2)
7563 		hash = 0;
7564 	else
7565 		hash = (h % buckets);
7566 
7567 	return hash;
7568 }
7569 #endif /* 0 */
7570 
7571 /*
7572 **  A structure for sorting Queue according to maxqrun without
7573 **	screwing up Queue itself.
7574 */
7575 
7576 struct sortqgrp
7577 {
7578 	int sg_idx;		/* original index */
7579 	int sg_maxqrun;		/* max queue runners */
7580 };
7581 typedef struct sortqgrp	SORTQGRP_T;
7582 static int cmpidx __P((const void *, const void *));
7583 
7584 static int
cmpidx(a,b)7585 cmpidx(a, b)
7586 	const void *a;
7587 	const void *b;
7588 {
7589 	/* The sort is highest to lowest, so the comparison is reversed */
7590 	if (((SORTQGRP_T *)a)->sg_maxqrun < ((SORTQGRP_T *)b)->sg_maxqrun)
7591 		return 1;
7592 	else if (((SORTQGRP_T *)a)->sg_maxqrun > ((SORTQGRP_T *)b)->sg_maxqrun)
7593 		return -1;
7594 	else
7595 		return 0;
7596 }
7597 
7598 /*
7599 **  MAKEWORKGROUP -- balance queue groups into work groups per MaxQueueChildren
7600 **
7601 **  Take the now defined queue groups and assign them to work groups.
7602 **  This is done to balance out the number of concurrently active
7603 **  queue runners such that MaxQueueChildren is not exceeded. This may
7604 **  result in more than one queue group per work group. In such a case
7605 **  the number of running queue groups in that work group will have no
7606 **  more than the work group maximum number of runners (a "fair" portion
7607 **  of MaxQueueRunners). All queue groups within a work group will get a
7608 **  chance at running.
7609 **
7610 **	Parameters:
7611 **		none.
7612 **
7613 **	Returns:
7614 **		nothing.
7615 **
7616 **	Side Effects:
7617 **		Sets up WorkGrp structure.
7618 */
7619 
7620 void
makeworkgroups()7621 makeworkgroups()
7622 {
7623 	int i, j, total_runners, dir, h;
7624 	SORTQGRP_T si[MAXQUEUEGROUPS + 1];
7625 
7626 	total_runners = 0;
7627 	if (NumQueue == 1 && strcmp(Queue[0]->qg_name, "mqueue") == 0)
7628 	{
7629 		/*
7630 		**  There is only the "mqueue" queue group (a default)
7631 		**  containing all of the queues. We want to provide to
7632 		**  this queue group the maximum allowable queue runners.
7633 		**  To match older behavior (8.10/8.11) we'll try for
7634 		**  1 runner per queue capping it at MaxQueueChildren.
7635 		**  So if there are N queues, then there will be N runners
7636 		**  for the "mqueue" queue group (where N is kept less than
7637 		**  MaxQueueChildren).
7638 		*/
7639 
7640 		NumWorkGroups = 1;
7641 		WorkGrp[0].wg_numqgrp = 1;
7642 		WorkGrp[0].wg_qgs = (QUEUEGRP **) xalloc(sizeof(QUEUEGRP *));
7643 		WorkGrp[0].wg_qgs[0] = Queue[0];
7644 		if (MaxQueueChildren > 0 &&
7645 		    Queue[0]->qg_numqueues > MaxQueueChildren)
7646 			WorkGrp[0].wg_runners = MaxQueueChildren;
7647 		else
7648 			WorkGrp[0].wg_runners = Queue[0]->qg_numqueues;
7649 
7650 		Queue[0]->qg_wgrp = 0;
7651 
7652 		/* can't have more runners than allowed total */
7653 		if (MaxQueueChildren > 0 &&
7654 		    Queue[0]->qg_maxqrun > MaxQueueChildren)
7655 			Queue[0]->qg_maxqrun = MaxQueueChildren;
7656 		WorkGrp[0].wg_maxact = Queue[0]->qg_maxqrun;
7657 		WorkGrp[0].wg_lowqintvl = Queue[0]->qg_queueintvl;
7658 		return;
7659 	}
7660 
7661 	for (i = 0; i < NumQueue; i++)
7662 	{
7663 		si[i].sg_maxqrun = Queue[i]->qg_maxqrun;
7664 		si[i].sg_idx = i;
7665 	}
7666 	qsort(si, NumQueue, sizeof(si[0]), cmpidx);
7667 
7668 	NumWorkGroups = 0;
7669 	for (i = 0; i < NumQueue; i++)
7670 	{
7671 		total_runners += si[i].sg_maxqrun;
7672 		if (MaxQueueChildren <= 0 || total_runners <= MaxQueueChildren)
7673 			NumWorkGroups++;
7674 		else
7675 			break;
7676 	}
7677 
7678 	if (NumWorkGroups < 1)
7679 		NumWorkGroups = 1; /* gotta have one at least */
7680 	else if (NumWorkGroups > MAXWORKGROUPS)
7681 		NumWorkGroups = MAXWORKGROUPS; /* the limit */
7682 
7683 	/*
7684 	**  We now know the number of work groups to pack the queue groups
7685 	**  into. The queue groups in 'Queue' are sorted from highest
7686 	**  to lowest for the number of runners per queue group.
7687 	**  We put the queue groups with the largest number of runners
7688 	**  into work groups first. Then the smaller ones are fitted in
7689 	**  where it looks best.
7690 	*/
7691 
7692 	j = 0;
7693 	dir = 1;
7694 	for (i = 0; i < NumQueue; i++)
7695 	{
7696 		/* a to-and-fro packing scheme, continue from last position */
7697 		if (j >= NumWorkGroups)
7698 		{
7699 			dir = -1;
7700 			j = NumWorkGroups - 1;
7701 		}
7702 		else if (j < 0)
7703 		{
7704 			j = 0;
7705 			dir = 1;
7706 		}
7707 
7708 		if (WorkGrp[j].wg_qgs == NULL)
7709 			WorkGrp[j].wg_qgs = (QUEUEGRP **)sm_malloc(sizeof(QUEUEGRP *) *
7710 							(WorkGrp[j].wg_numqgrp + 1));
7711 		else
7712 			WorkGrp[j].wg_qgs = (QUEUEGRP **)sm_realloc(WorkGrp[j].wg_qgs,
7713 							sizeof(QUEUEGRP *) *
7714 							(WorkGrp[j].wg_numqgrp + 1));
7715 		if (WorkGrp[j].wg_qgs == NULL)
7716 		{
7717 			syserr("!cannot allocate memory for work queues, need %d bytes",
7718 			       (int) (sizeof(QUEUEGRP *) *
7719 				      (WorkGrp[j].wg_numqgrp + 1)));
7720 		}
7721 
7722 		h = si[i].sg_idx;
7723 		WorkGrp[j].wg_qgs[WorkGrp[j].wg_numqgrp] = Queue[h];
7724 		WorkGrp[j].wg_numqgrp++;
7725 		WorkGrp[j].wg_runners += Queue[h]->qg_maxqrun;
7726 		Queue[h]->qg_wgrp = j;
7727 
7728 		if (WorkGrp[j].wg_maxact == 0)
7729 		{
7730 			/* can't have more runners than allowed total */
7731 			if (MaxQueueChildren > 0 &&
7732 			    Queue[h]->qg_maxqrun > MaxQueueChildren)
7733 				Queue[h]->qg_maxqrun = MaxQueueChildren;
7734 			WorkGrp[j].wg_maxact = Queue[h]->qg_maxqrun;
7735 		}
7736 
7737 		/*
7738 		**  XXX: must wg_lowqintvl be the GCD?
7739 		**  qg1: 2m, qg2: 3m, minimum: 2m, when do queue runs for
7740 		**  qg2 occur?
7741 		*/
7742 
7743 		/* keep track of the lowest interval for a persistent runner */
7744 		if (Queue[h]->qg_queueintvl > 0 &&
7745 		    WorkGrp[j].wg_lowqintvl < Queue[h]->qg_queueintvl)
7746 			WorkGrp[j].wg_lowqintvl = Queue[h]->qg_queueintvl;
7747 		j += dir;
7748 	}
7749 	if (tTd(41, 9))
7750 	{
7751 		for (i = 0; i < NumWorkGroups; i++)
7752 		{
7753 			sm_dprintf("Workgroup[%d]=", i);
7754 			for (j = 0; j < WorkGrp[i].wg_numqgrp; j++)
7755 			{
7756 				sm_dprintf("%s, ",
7757 					WorkGrp[i].wg_qgs[j]->qg_name);
7758 			}
7759 			sm_dprintf("\n");
7760 		}
7761 	}
7762 }
7763 
7764 /*
7765 **  DUP_DF -- duplicate envelope data file
7766 **
7767 **	Copy the data file from the 'old' envelope to the 'new' envelope
7768 **	in the most efficient way possible.
7769 **
7770 **	Create a hard link from the 'old' data file to the 'new' data file.
7771 **	If the old and new queue directories are on different file systems,
7772 **	then the new data file link is created in the old queue directory,
7773 **	and the new queue file will contain a 'd' record pointing to the
7774 **	directory containing the new data file.
7775 **
7776 **	Parameters:
7777 **		old -- old envelope.
7778 **		new -- new envelope.
7779 **
7780 **	Results:
7781 **		Returns true on success, false on failure.
7782 **
7783 **	Side Effects:
7784 **		On success, the new data file is created.
7785 **		On fatal failure, EF_FATALERRS is set in old->e_flags.
7786 */
7787 
7788 static bool	dup_df __P((ENVELOPE *, ENVELOPE *));
7789 
7790 static bool
dup_df(old,new)7791 dup_df(old, new)
7792 	ENVELOPE *old;
7793 	ENVELOPE *new;
7794 {
7795 	int ofs, nfs, r;
7796 	char opath[MAXPATHLEN];
7797 	char npath[MAXPATHLEN];
7798 
7799 	if (!bitset(EF_HAS_DF, old->e_flags))
7800 	{
7801 		/*
7802 		**  this can happen if: SuperSafe != True
7803 		**  and a bounce mail is sent that is split.
7804 		*/
7805 
7806 		queueup(old, false, true);
7807 	}
7808 	SM_REQUIRE(ISVALIDQGRP(old->e_qgrp) && ISVALIDQDIR(old->e_qdir));
7809 	SM_REQUIRE(ISVALIDQGRP(new->e_qgrp) && ISVALIDQDIR(new->e_qdir));
7810 
7811 	(void) sm_strlcpy(opath, queuename(old, DATAFL_LETTER), sizeof(opath));
7812 	(void) sm_strlcpy(npath, queuename(new, DATAFL_LETTER), sizeof(npath));
7813 
7814 	if (old->e_dfp != NULL)
7815 	{
7816 		r = sm_io_setinfo(old->e_dfp, SM_BF_COMMIT, NULL);
7817 		if (r < 0 && errno != EINVAL)
7818 		{
7819 			syserr("@can't commit %s", opath);
7820 			old->e_flags |= EF_FATALERRS;
7821 			return false;
7822 		}
7823 	}
7824 
7825 	/*
7826 	**  Attempt to create a hard link, if we think both old and new
7827 	**  are on the same file system, otherwise copy the file.
7828 	**
7829 	**  Don't waste time attempting a hard link unless old and new
7830 	**  are on the same file system.
7831 	*/
7832 
7833 	SM_REQUIRE(ISVALIDQGRP(old->e_dfqgrp) && ISVALIDQDIR(old->e_dfqdir));
7834 	SM_REQUIRE(ISVALIDQGRP(new->e_dfqgrp) && ISVALIDQDIR(new->e_dfqdir));
7835 
7836 	ofs = Queue[old->e_dfqgrp]->qg_qpaths[old->e_dfqdir].qp_fsysidx;
7837 	nfs = Queue[new->e_dfqgrp]->qg_qpaths[new->e_dfqdir].qp_fsysidx;
7838 	if (FILE_SYS_DEV(ofs) == FILE_SYS_DEV(nfs))
7839 	{
7840 		if (link(opath, npath) == 0)
7841 		{
7842 			new->e_flags |= EF_HAS_DF;
7843 			SYNC_DIR(npath, true);
7844 			return true;
7845 		}
7846 		goto error;
7847 	}
7848 
7849 	/*
7850 	**  Can't link across queue directories, so try to create a hard
7851 	**  link in the same queue directory as the old df file.
7852 	**  The qf file will refer to the new df file using a 'd' record.
7853 	*/
7854 
7855 	new->e_dfqgrp = old->e_dfqgrp;
7856 	new->e_dfqdir = old->e_dfqdir;
7857 	(void) sm_strlcpy(npath, queuename(new, DATAFL_LETTER), sizeof(npath));
7858 	if (link(opath, npath) == 0)
7859 	{
7860 		new->e_flags |= EF_HAS_DF;
7861 		SYNC_DIR(npath, true);
7862 		return true;
7863 	}
7864 
7865   error:
7866 	if (LogLevel > 0)
7867 		sm_syslog(LOG_ERR, old->e_id,
7868 			  "dup_df: can't link %s to %s, error=%s, envelope splitting failed",
7869 			  opath, npath, sm_errstring(errno));
7870 	return false;
7871 }
7872 
7873 /*
7874 **  SPLIT_ENV -- Allocate a new envelope based on a given envelope.
7875 **
7876 **	Parameters:
7877 **		e -- envelope.
7878 **		sendqueue -- sendqueue for new envelope.
7879 **		qgrp -- index of queue group.
7880 **		qdir -- queue directory.
7881 **
7882 **	Results:
7883 **		new envelope.
7884 **
7885 */
7886 
7887 static ENVELOPE	*split_env __P((ENVELOPE *, ADDRESS *, int, int));
7888 
7889 static ENVELOPE *
split_env(e,sendqueue,qgrp,qdir)7890 split_env(e, sendqueue, qgrp, qdir)
7891 	ENVELOPE *e;
7892 	ADDRESS *sendqueue;
7893 	int qgrp;
7894 	int qdir;
7895 {
7896 	ENVELOPE *ee;
7897 
7898 	ee = (ENVELOPE *) sm_rpool_malloc_x(e->e_rpool, sizeof(*ee));
7899 	STRUCTCOPY(*e, *ee);
7900 	ee->e_message = NULL;	/* XXX use original message? */
7901 	ee->e_id = NULL;
7902 	assign_queueid(ee);
7903 	ee->e_sendqueue = sendqueue;
7904 	ee->e_flags &= ~(EF_INQUEUE|EF_CLRQUEUE|EF_FATALERRS
7905 			 |EF_SENDRECEIPT|EF_RET_PARAM|EF_HAS_DF);
7906 	ee->e_flags |= EF_NORECEIPT;	/* XXX really? */
7907 	ee->e_from.q_state = QS_SENDER;
7908 	ee->e_dfp = NULL;
7909 	ee->e_lockfp = NULL;
7910 	if (e->e_xfp != NULL)
7911 		ee->e_xfp = sm_io_dup(e->e_xfp);
7912 
7913 	/* failed to dup e->e_xfp, start a new transcript */
7914 	if (ee->e_xfp == NULL)
7915 		openxscript(ee);
7916 
7917 	ee->e_qgrp = ee->e_dfqgrp = qgrp;
7918 	ee->e_qdir = ee->e_dfqdir = qdir;
7919 	ee->e_errormode = EM_MAIL;
7920 	ee->e_statmsg = NULL;
7921 	if (e->e_quarmsg != NULL)
7922 		ee->e_quarmsg = sm_rpool_strdup_x(ee->e_rpool,
7923 						  e->e_quarmsg);
7924 
7925 	/*
7926 	**  XXX Not sure if this copying is necessary.
7927 	**  sendall() does this copying, but I (dm) don't know if that is
7928 	**  because of the storage management discipline we were using
7929 	**  before rpools were introduced, or if it is because these lists
7930 	**  can be modified later.
7931 	*/
7932 
7933 	ee->e_header = copyheader(e->e_header, ee->e_rpool);
7934 	ee->e_errorqueue = copyqueue(e->e_errorqueue, ee->e_rpool);
7935 
7936 	return ee;
7937 }
7938 
7939 /* return values from split functions, check also below! */
7940 #define SM_SPLIT_FAIL	(0)
7941 #define SM_SPLIT_NONE	(1)
7942 #define SM_SPLIT_NEW(n)	(1 + (n))
7943 
7944 /*
7945 **  SPLIT_ACROSS_QUEUE_GROUPS
7946 **
7947 **	This function splits an envelope across multiple queue groups
7948 **	based on the queue group of each recipient.
7949 **
7950 **	Parameters:
7951 **		e -- envelope.
7952 **
7953 **	Results:
7954 **		SM_SPLIT_FAIL on failure
7955 **		SM_SPLIT_NONE if no splitting occurred,
7956 **		or 1 + the number of additional envelopes created.
7957 **
7958 **	Side Effects:
7959 **		On success, e->e_sibling points to a list of zero or more
7960 **		additional envelopes, and the associated data files exist
7961 **		on disk.  But the queue files are not created.
7962 **
7963 **		On failure, e->e_sibling is not changed.
7964 **		The order of recipients in e->e_sendqueue is permuted.
7965 **		Abandoned data files for additional envelopes that failed
7966 **		to be created may exist on disk.
7967 */
7968 
7969 static int	q_qgrp_compare __P((const void *, const void *));
7970 static int	e_filesys_compare __P((const void *, const void *));
7971 
7972 static int
q_qgrp_compare(p1,p2)7973 q_qgrp_compare(p1, p2)
7974 	const void *p1;
7975 	const void *p2;
7976 {
7977 	ADDRESS **pq1 = (ADDRESS **) p1;
7978 	ADDRESS **pq2 = (ADDRESS **) p2;
7979 
7980 	return (*pq1)->q_qgrp - (*pq2)->q_qgrp;
7981 }
7982 
7983 static int
e_filesys_compare(p1,p2)7984 e_filesys_compare(p1, p2)
7985 	const void *p1;
7986 	const void *p2;
7987 {
7988 	ENVELOPE **pe1 = (ENVELOPE **) p1;
7989 	ENVELOPE **pe2 = (ENVELOPE **) p2;
7990 	int fs1, fs2;
7991 
7992 	fs1 = Queue[(*pe1)->e_qgrp]->qg_qpaths[(*pe1)->e_qdir].qp_fsysidx;
7993 	fs2 = Queue[(*pe2)->e_qgrp]->qg_qpaths[(*pe2)->e_qdir].qp_fsysidx;
7994 	if (FILE_SYS_DEV(fs1) < FILE_SYS_DEV(fs2))
7995 		return -1;
7996 	if (FILE_SYS_DEV(fs1) > FILE_SYS_DEV(fs2))
7997 		return 1;
7998 	return 0;
7999 }
8000 
8001 static int split_across_queue_groups __P((ENVELOPE *));
8002 static int
split_across_queue_groups(e)8003 split_across_queue_groups(e)
8004 	ENVELOPE *e;
8005 {
8006 	int naddrs, nsplits, i;
8007 	bool changed;
8008 	char **pvp;
8009 	ADDRESS *q, **addrs;
8010 	ENVELOPE *ee, *es;
8011 	ENVELOPE *splits[MAXQUEUEGROUPS];
8012 	char pvpbuf[PSBUFSIZE];
8013 
8014 	SM_REQUIRE(ISVALIDQGRP(e->e_qgrp));
8015 
8016 	/* Count addresses and assign queue groups. */
8017 	naddrs = 0;
8018 	changed = false;
8019 	for (q = e->e_sendqueue; q != NULL; q = q->q_next)
8020 	{
8021 		if (QS_IS_DEAD(q->q_state))
8022 			continue;
8023 		++naddrs;
8024 
8025 		/* bad addresses and those already sent stay put */
8026 		if (QS_IS_BADADDR(q->q_state) ||
8027 		    QS_IS_SENT(q->q_state))
8028 			q->q_qgrp = e->e_qgrp;
8029 		else if (!ISVALIDQGRP(q->q_qgrp))
8030 		{
8031 			/* call ruleset which should return a queue group */
8032 			i = rscap(RS_QUEUEGROUP, q->q_user, NULL, e, &pvp,
8033 				  pvpbuf, sizeof(pvpbuf));
8034 			if (i == EX_OK &&
8035 			    pvp != NULL && pvp[0] != NULL &&
8036 			    (pvp[0][0] & 0377) == CANONNET &&
8037 			    pvp[1] != NULL && pvp[1][0] != '\0')
8038 			{
8039 				i = name2qid(pvp[1]);
8040 				if (ISVALIDQGRP(i))
8041 				{
8042 					q->q_qgrp = i;
8043 					changed = true;
8044 					if (tTd(20, 4))
8045 						sm_syslog(LOG_INFO, NOQID,
8046 							"queue group name %s -> %d",
8047 							pvp[1], i);
8048 					continue;
8049 				}
8050 				else if (LogLevel > 10)
8051 					sm_syslog(LOG_INFO, NOQID,
8052 						"can't find queue group name %s, selection ignored",
8053 						pvp[1]);
8054 			}
8055 			if (q->q_mailer != NULL &&
8056 			    ISVALIDQGRP(q->q_mailer->m_qgrp))
8057 			{
8058 				changed = true;
8059 				q->q_qgrp = q->q_mailer->m_qgrp;
8060 			}
8061 			else if (ISVALIDQGRP(e->e_qgrp))
8062 				q->q_qgrp = e->e_qgrp;
8063 			else
8064 				q->q_qgrp = 0;
8065 		}
8066 	}
8067 
8068 	/* only one address? nothing to split. */
8069 	if (naddrs <= 1 && !changed)
8070 		return SM_SPLIT_NONE;
8071 
8072 	/* sort the addresses by queue group */
8073 	addrs = sm_rpool_malloc_x(e->e_rpool, naddrs * sizeof(ADDRESS *));
8074 	for (i = 0, q = e->e_sendqueue; q != NULL; q = q->q_next)
8075 	{
8076 		if (QS_IS_DEAD(q->q_state))
8077 			continue;
8078 		addrs[i++] = q;
8079 	}
8080 	qsort(addrs, naddrs, sizeof(ADDRESS *), q_qgrp_compare);
8081 
8082 	/* split into multiple envelopes, by queue group */
8083 	nsplits = 0;
8084 	es = NULL;
8085 	e->e_sendqueue = NULL;
8086 	for (i = 0; i < naddrs; ++i)
8087 	{
8088 		if (i == naddrs - 1 || addrs[i]->q_qgrp != addrs[i + 1]->q_qgrp)
8089 			addrs[i]->q_next = NULL;
8090 		else
8091 			addrs[i]->q_next = addrs[i + 1];
8092 
8093 		/* same queue group as original envelope? */
8094 		if (addrs[i]->q_qgrp == e->e_qgrp)
8095 		{
8096 			if (e->e_sendqueue == NULL)
8097 				e->e_sendqueue = addrs[i];
8098 			continue;
8099 		}
8100 
8101 		/* different queue group than original envelope */
8102 		if (es == NULL || addrs[i]->q_qgrp != es->e_qgrp)
8103 		{
8104 			ee = split_env(e, addrs[i], addrs[i]->q_qgrp, NOQDIR);
8105 			es = ee;
8106 			splits[nsplits++] = ee;
8107 		}
8108 	}
8109 
8110 	/* no splits? return right now. */
8111 	if (nsplits <= 0)
8112 		return SM_SPLIT_NONE;
8113 
8114 	/* assign a queue directory to each additional envelope */
8115 	for (i = 0; i < nsplits; ++i)
8116 	{
8117 		es = splits[i];
8118 #if 0
8119 		es->e_qdir = pickqdir(Queue[es->e_qgrp], es->e_msgsize, es);
8120 #endif /* 0 */
8121 		if (!setnewqueue(es))
8122 			goto failure;
8123 	}
8124 
8125 	/* sort the additional envelopes by queue file system */
8126 	qsort(splits, nsplits, sizeof(ENVELOPE *), e_filesys_compare);
8127 
8128 	/* create data files for each additional envelope */
8129 	if (!dup_df(e, splits[0]))
8130 	{
8131 		i = 0;
8132 		goto failure;
8133 	}
8134 	for (i = 1; i < nsplits; ++i)
8135 	{
8136 		/* copy or link to the previous data file */
8137 		if (!dup_df(splits[i - 1], splits[i]))
8138 			goto failure;
8139 	}
8140 
8141 	/* success: prepend the new envelopes to the e->e_sibling list */
8142 	for (i = 0; i < nsplits; ++i)
8143 	{
8144 		es = splits[i];
8145 		es->e_sibling = e->e_sibling;
8146 		e->e_sibling = es;
8147 	}
8148 	return SM_SPLIT_NEW(nsplits);
8149 
8150 	/* failure: clean up */
8151   failure:
8152 	if (i > 0)
8153 	{
8154 		int j;
8155 
8156 		for (j = 0; j < i; j++)
8157 			(void) unlink(queuename(splits[j], DATAFL_LETTER));
8158 	}
8159 	e->e_sendqueue = addrs[0];
8160 	for (i = 0; i < naddrs - 1; ++i)
8161 		addrs[i]->q_next = addrs[i + 1];
8162 	addrs[naddrs - 1]->q_next = NULL;
8163 	return SM_SPLIT_FAIL;
8164 }
8165 
8166 /*
8167 **  SPLIT_WITHIN_QUEUE
8168 **
8169 **	Split an envelope with multiple recipients into several
8170 **	envelopes within the same queue directory, if the number of
8171 **	recipients exceeds the limit for the queue group.
8172 **
8173 **	Parameters:
8174 **		e -- envelope.
8175 **
8176 **	Results:
8177 **		SM_SPLIT_FAIL on failure
8178 **		SM_SPLIT_NONE if no splitting occurred,
8179 **		or 1 + the number of additional envelopes created.
8180 */
8181 
8182 #define SPLIT_LOG_LEVEL	8
8183 
8184 static int	split_within_queue __P((ENVELOPE *));
8185 
8186 static int
split_within_queue(e)8187 split_within_queue(e)
8188 	ENVELOPE *e;
8189 {
8190 	int maxrcpt, nrcpt, ndead, nsplit, i;
8191 	int j, l;
8192 	char *lsplits;
8193 	ADDRESS *q, **addrs;
8194 	ENVELOPE *ee, *firstsibling;
8195 
8196 	if (!ISVALIDQGRP(e->e_qgrp) || bitset(EF_SPLIT, e->e_flags))
8197 		return SM_SPLIT_NONE;
8198 
8199 	/* don't bother if there is no recipient limit */
8200 	maxrcpt = Queue[e->e_qgrp]->qg_maxrcpt;
8201 	if (maxrcpt <= 0)
8202 		return SM_SPLIT_NONE;
8203 
8204 	/* count recipients */
8205 	nrcpt = 0;
8206 	for (q = e->e_sendqueue; q != NULL; q = q->q_next)
8207 	{
8208 		if (QS_IS_DEAD(q->q_state))
8209 			continue;
8210 		++nrcpt;
8211 	}
8212 	if (nrcpt <= maxrcpt)
8213 		return SM_SPLIT_NONE;
8214 
8215 	/*
8216 	**  Preserve the recipient list
8217 	**  so that we can restore it in case of error.
8218 	**  (But we discard dead addresses.)
8219 	*/
8220 
8221 	addrs = sm_rpool_malloc_x(e->e_rpool, nrcpt * sizeof(ADDRESS *));
8222 	for (i = 0, q = e->e_sendqueue; q != NULL; q = q->q_next)
8223 	{
8224 		if (QS_IS_DEAD(q->q_state))
8225 			continue;
8226 		addrs[i++] = q;
8227 	}
8228 
8229 	/*
8230 	**  Partition the recipient list so that bad and sent addresses
8231 	**  come first. These will go with the original envelope, and
8232 	**  do not count towards the maxrcpt limit.
8233 	**  addrs[] does not contain QS_IS_DEAD() addresses.
8234 	*/
8235 
8236 	ndead = 0;
8237 	for (i = 0; i < nrcpt; ++i)
8238 	{
8239 		if (QS_IS_BADADDR(addrs[i]->q_state) ||
8240 		    QS_IS_SENT(addrs[i]->q_state) ||
8241 		    QS_IS_DEAD(addrs[i]->q_state)) /* for paranoia's sake */
8242 		{
8243 			if (i > ndead)
8244 			{
8245 				ADDRESS *tmp = addrs[i];
8246 
8247 				addrs[i] = addrs[ndead];
8248 				addrs[ndead] = tmp;
8249 			}
8250 			++ndead;
8251 		}
8252 	}
8253 
8254 	/* Check if no splitting required. */
8255 	if (nrcpt - ndead <= maxrcpt)
8256 		return SM_SPLIT_NONE;
8257 
8258 	/* fix links */
8259 	for (i = 0; i < nrcpt - 1; ++i)
8260 		addrs[i]->q_next = addrs[i + 1];
8261 	addrs[nrcpt - 1]->q_next = NULL;
8262 	e->e_sendqueue = addrs[0];
8263 
8264 	/* prepare buffer for logging */
8265 	if (LogLevel > SPLIT_LOG_LEVEL)
8266 	{
8267 		l = MAXLINE;
8268 		lsplits = sm_malloc(l);
8269 		if (lsplits != NULL)
8270 			*lsplits = '\0';
8271 		j = 0;
8272 	}
8273 	else
8274 	{
8275 		/* get rid of stupid compiler warnings */
8276 		lsplits = NULL;
8277 		j = l = 0;
8278 	}
8279 
8280 	/* split the envelope */
8281 	firstsibling = e->e_sibling;
8282 	i = maxrcpt + ndead;
8283 	nsplit = 0;
8284 	for (;;)
8285 	{
8286 		addrs[i - 1]->q_next = NULL;
8287 		ee = split_env(e, addrs[i], e->e_qgrp, e->e_qdir);
8288 		if (!dup_df(e, ee))
8289 		{
8290 
8291 			ee = firstsibling;
8292 			while (ee != NULL)
8293 			{
8294 				(void) unlink(queuename(ee, DATAFL_LETTER));
8295 				ee = ee->e_sibling;
8296 			}
8297 
8298 			/* Error.  Restore e's sibling & recipient lists. */
8299 			e->e_sibling = firstsibling;
8300 			for (i = 0; i < nrcpt - 1; ++i)
8301 				addrs[i]->q_next = addrs[i + 1];
8302 			if (lsplits != NULL)
8303 				sm_free(lsplits);
8304 			return SM_SPLIT_FAIL;
8305 		}
8306 
8307 		/* prepend the new envelope to e->e_sibling */
8308 		ee->e_sibling = e->e_sibling;
8309 		e->e_sibling = ee;
8310 		++nsplit;
8311 		if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL)
8312 		{
8313 			if (j >= l - strlen(ee->e_id) - 3)
8314 			{
8315 				char *p;
8316 
8317 				l += MAXLINE;
8318 				p = sm_realloc(lsplits, l);
8319 				if (p == NULL)
8320 				{
8321 					/* let's try to get this done */
8322 					sm_free(lsplits);
8323 					lsplits = NULL;
8324 				}
8325 				else
8326 					lsplits = p;
8327 			}
8328 			if (lsplits != NULL)
8329 			{
8330 				if (j == 0)
8331 					j += sm_strlcat(lsplits + j,
8332 							ee->e_id,
8333 							l - j);
8334 				else
8335 					j += sm_strlcat2(lsplits + j,
8336 							 "; ",
8337 							 ee->e_id,
8338 							 l - j);
8339 				SM_ASSERT(j < l);
8340 			}
8341 		}
8342 		if (nrcpt - i <= maxrcpt)
8343 			break;
8344 		i += maxrcpt;
8345 	}
8346 	if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL)
8347 	{
8348 		if (nsplit > 0)
8349 		{
8350 			sm_syslog(LOG_NOTICE, e->e_id,
8351 				  "split: maxrcpts=%d, rcpts=%d, count=%d, id%s=%s",
8352 				  maxrcpt, nrcpt - ndead, nsplit,
8353 				  nsplit > 1 ? "s" : "", lsplits);
8354 		}
8355 		sm_free(lsplits);
8356 	}
8357 	return SM_SPLIT_NEW(nsplit);
8358 }
8359 /*
8360 **  SPLIT_BY_RECIPIENT
8361 **
8362 **	Split an envelope with multiple recipients into multiple
8363 **	envelopes as required by the sendmail configuration.
8364 **
8365 **	Parameters:
8366 **		e -- envelope.
8367 **
8368 **	Results:
8369 **		Returns true on success, false on failure.
8370 **
8371 **	Side Effects:
8372 **		see split_across_queue_groups(), split_within_queue(e)
8373 */
8374 
8375 bool
split_by_recipient(e)8376 split_by_recipient(e)
8377 	ENVELOPE *e;
8378 {
8379 	int split, n, i, j, l;
8380 	char *lsplits;
8381 	ENVELOPE *ee, *next, *firstsibling;
8382 
8383 	if (OpMode == SM_VERIFY || !ISVALIDQGRP(e->e_qgrp) ||
8384 	    bitset(EF_SPLIT, e->e_flags))
8385 		return true;
8386 	n = split_across_queue_groups(e);
8387 	if (n == SM_SPLIT_FAIL)
8388 		return false;
8389 	firstsibling = ee = e->e_sibling;
8390 	if (n > 1 && LogLevel > SPLIT_LOG_LEVEL)
8391 	{
8392 		l = MAXLINE;
8393 		lsplits = sm_malloc(l);
8394 		if (lsplits != NULL)
8395 			*lsplits = '\0';
8396 		j = 0;
8397 	}
8398 	else
8399 	{
8400 		/* get rid of stupid compiler warnings */
8401 		lsplits = NULL;
8402 		j = l = 0;
8403 	}
8404 	for (i = 1; i < n; ++i)
8405 	{
8406 		next = ee->e_sibling;
8407 		if (split_within_queue(ee) == SM_SPLIT_FAIL)
8408 		{
8409 			e->e_sibling = firstsibling;
8410 			return false;
8411 		}
8412 		ee->e_flags |= EF_SPLIT;
8413 		if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL)
8414 		{
8415 			if (j >= l - strlen(ee->e_id) - 3)
8416 			{
8417 				char *p;
8418 
8419 				l += MAXLINE;
8420 				p = sm_realloc(lsplits, l);
8421 				if (p == NULL)
8422 				{
8423 					/* let's try to get this done */
8424 					sm_free(lsplits);
8425 					lsplits = NULL;
8426 				}
8427 				else
8428 					lsplits = p;
8429 			}
8430 			if (lsplits != NULL)
8431 			{
8432 				if (j == 0)
8433 					j += sm_strlcat(lsplits + j,
8434 							ee->e_id, l - j);
8435 				else
8436 					j += sm_strlcat2(lsplits + j, "; ",
8437 							 ee->e_id, l - j);
8438 				SM_ASSERT(j < l);
8439 			}
8440 		}
8441 		ee = next;
8442 	}
8443 	if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL && n > 1)
8444 	{
8445 		sm_syslog(LOG_NOTICE, e->e_id, "split: count=%d, id%s=%s",
8446 			  n - 1, n > 2 ? "s" : "", lsplits);
8447 		sm_free(lsplits);
8448 	}
8449 	split = split_within_queue(e) != SM_SPLIT_FAIL;
8450 	if (split)
8451 		e->e_flags |= EF_SPLIT;
8452 	return split;
8453 }
8454 
8455 /*
8456 **  QUARANTINE_QUEUE_ITEM -- {un,}quarantine a single envelope
8457 **
8458 **	Add/remove quarantine reason and requeue appropriately.
8459 **
8460 **	Parameters:
8461 **		qgrp -- queue group for the item
8462 **		qdir -- queue directory in the given queue group
8463 **		e -- envelope information for the item
8464 **		reason -- quarantine reason, NULL means unquarantine.
8465 **
8466 **	Results:
8467 **		true if item changed, false otherwise
8468 **
8469 **	Side Effects:
8470 **		Changes quarantine tag in queue file and renames it.
8471 */
8472 
8473 static bool
quarantine_queue_item(qgrp,qdir,e,reason)8474 quarantine_queue_item(qgrp, qdir, e, reason)
8475 	int qgrp;
8476 	int qdir;
8477 	ENVELOPE *e;
8478 	char *reason;
8479 {
8480 	bool dirty = false;
8481 	bool failing = false;
8482 	bool foundq = false;
8483 	bool finished = false;
8484 	int fd;
8485 	int flags;
8486 	int oldtype;
8487 	int newtype;
8488 	int save_errno;
8489 	MODE_T oldumask = 0;
8490 	SM_FILE_T *oldqfp, *tempqfp;
8491 	char *bp;
8492 	int bufsize;
8493 	char oldqf[MAXPATHLEN];
8494 	char tempqf[MAXPATHLEN];
8495 	char newqf[MAXPATHLEN];
8496 	char buf[MAXLINE];
8497 
8498 	oldtype = queue_letter(e, ANYQFL_LETTER);
8499 	(void) sm_strlcpy(oldqf, queuename(e, ANYQFL_LETTER), sizeof(oldqf));
8500 	(void) sm_strlcpy(tempqf, queuename(e, NEWQFL_LETTER), sizeof(tempqf));
8501 
8502 	/*
8503 	**  Instead of duplicating all the open
8504 	**  and lock code here, tell readqf() to
8505 	**  do that work and return the open
8506 	**  file pointer in e_lockfp.  Note that
8507 	**  we must release the locks properly when
8508 	**  we are done.
8509 	*/
8510 
8511 	if (!readqf(e, true))
8512 	{
8513 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8514 				     "Skipping %s\n", qid_printname(e));
8515 		return false;
8516 	}
8517 	oldqfp = e->e_lockfp;
8518 
8519 	/* open the new queue file */
8520 	flags = O_CREAT|O_WRONLY|O_EXCL;
8521 	if (bitset(S_IWGRP, QueueFileMode))
8522 		oldumask = umask(002);
8523 	fd = open(tempqf, flags, QueueFileMode);
8524 	if (bitset(S_IWGRP, QueueFileMode))
8525 		(void) umask(oldumask);
8526 	RELEASE_QUEUE;
8527 
8528 	if (fd < 0)
8529 	{
8530 		save_errno = errno;
8531 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8532 				     "Skipping %s: Could not open %s: %s\n",
8533 				     qid_printname(e), tempqf,
8534 				     sm_errstring(save_errno));
8535 		(void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8536 		return false;
8537 	}
8538 	if (!lockfile(fd, tempqf, NULL, LOCK_EX|LOCK_NB))
8539 	{
8540 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8541 				     "Skipping %s: Could not lock %s\n",
8542 				     qid_printname(e), tempqf);
8543 		(void) close(fd);
8544 		(void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8545 		return false;
8546 	}
8547 
8548 	tempqfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT, (void *) &fd,
8549 			     SM_IO_WRONLY_B, NULL);
8550 	if (tempqfp == NULL)
8551 	{
8552 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8553 				     "Skipping %s: Could not lock %s\n",
8554 				     qid_printname(e), tempqf);
8555 		(void) close(fd);
8556 		(void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8557 		return false;
8558 	}
8559 
8560 	/* Copy the data over, changing the quarantine reason */
8561 	while (bufsize = sizeof(buf),
8562 	       (bp = fgetfolded(buf, &bufsize, oldqfp)) != NULL)
8563 	{
8564 		if (tTd(40, 4))
8565 			sm_dprintf("+++++ %s\n", bp);
8566 		switch (bp[0])
8567 		{
8568 		  case 'q':		/* quarantine reason */
8569 			foundq = true;
8570 			if (reason == NULL)
8571 			{
8572 				if (Verbose)
8573 				{
8574 					(void) sm_io_fprintf(smioout,
8575 							     SM_TIME_DEFAULT,
8576 							     "%s: Removed quarantine of \"%s\"\n",
8577 							     e->e_id, &bp[1]);
8578 				}
8579 				sm_syslog(LOG_INFO, e->e_id, "unquarantine");
8580 				dirty = true;
8581 			}
8582 			else if (strcmp(reason, &bp[1]) == 0)
8583 			{
8584 				if (Verbose)
8585 				{
8586 					(void) sm_io_fprintf(smioout,
8587 							     SM_TIME_DEFAULT,
8588 							     "%s: Already quarantined with \"%s\"\n",
8589 							     e->e_id, reason);
8590 				}
8591 				(void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8592 						     "q%s\n", reason);
8593 			}
8594 			else
8595 			{
8596 				if (Verbose)
8597 				{
8598 					(void) sm_io_fprintf(smioout,
8599 							     SM_TIME_DEFAULT,
8600 							     "%s: Quarantine changed from \"%s\" to \"%s\"\n",
8601 							     e->e_id, &bp[1],
8602 							     reason);
8603 				}
8604 				(void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8605 						     "q%s\n", reason);
8606 				sm_syslog(LOG_INFO, e->e_id, "quarantine=%s",
8607 					  reason);
8608 				dirty = true;
8609 			}
8610 			break;
8611 
8612 		  case 'S':
8613 			/*
8614 			**  If we are quarantining an unquarantined item,
8615 			**  need to put in a new 'q' line before it's
8616 			**  too late.
8617 			*/
8618 
8619 			if (!foundq && reason != NULL)
8620 			{
8621 				if (Verbose)
8622 				{
8623 					(void) sm_io_fprintf(smioout,
8624 							     SM_TIME_DEFAULT,
8625 							     "%s: Quarantined with \"%s\"\n",
8626 							     e->e_id, reason);
8627 				}
8628 				(void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8629 						     "q%s\n", reason);
8630 				sm_syslog(LOG_INFO, e->e_id, "quarantine=%s",
8631 					  reason);
8632 				foundq = true;
8633 				dirty = true;
8634 			}
8635 
8636 			/* Copy the line to the new file */
8637 			(void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8638 					     "%s\n", bp);
8639 			break;
8640 
8641 		  case '.':
8642 			finished = true;
8643 			/* FALLTHROUGH */
8644 
8645 		  default:
8646 			/* Copy the line to the new file */
8647 			(void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8648 					     "%s\n", bp);
8649 			break;
8650 		}
8651 		if (bp != buf)
8652 			sm_free(bp);
8653 	}
8654 
8655 	/* Make sure we read the whole old file */
8656 	errno = sm_io_error(tempqfp);
8657 	if (errno != 0 && errno != SM_IO_EOF)
8658 	{
8659 		save_errno = errno;
8660 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8661 				     "Skipping %s: Error reading %s: %s\n",
8662 				     qid_printname(e), oldqf,
8663 				     sm_errstring(save_errno));
8664 		failing = true;
8665 	}
8666 
8667 	if (!failing && !finished)
8668 	{
8669 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8670 				     "Skipping %s: Incomplete file: %s\n",
8671 				     qid_printname(e), oldqf);
8672 		failing = true;
8673 	}
8674 
8675 	/* Check if we actually changed anything or we can just bail now */
8676 	if (!dirty)
8677 	{
8678 		/* pretend we failed, even though we technically didn't */
8679 		failing = true;
8680 	}
8681 
8682 	/* Make sure we wrote things out safely */
8683 	if (!failing &&
8684 	    (sm_io_flush(tempqfp, SM_TIME_DEFAULT) != 0 ||
8685 	     ((SuperSafe == SAFE_REALLY ||
8686 	       SuperSafe == SAFE_REALLY_POSTMILTER ||
8687 	       SuperSafe == SAFE_INTERACTIVE) &&
8688 	      fsync(sm_io_getinfo(tempqfp, SM_IO_WHAT_FD, NULL)) < 0) ||
8689 	     ((errno = sm_io_error(tempqfp)) != 0)))
8690 	{
8691 		save_errno = errno;
8692 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8693 				     "Skipping %s: Error writing %s: %s\n",
8694 				     qid_printname(e), tempqf,
8695 				     sm_errstring(save_errno));
8696 		failing = true;
8697 	}
8698 
8699 
8700 	/* Figure out the new filename */
8701 	newtype = (reason == NULL ? NORMQF_LETTER : QUARQF_LETTER);
8702 	if (oldtype == newtype)
8703 	{
8704 		/* going to rename tempqf to oldqf */
8705 		(void) sm_strlcpy(newqf, oldqf, sizeof(newqf));
8706 	}
8707 	else
8708 	{
8709 		/* going to rename tempqf to new name based on newtype */
8710 		(void) sm_strlcpy(newqf, queuename(e, newtype), sizeof(newqf));
8711 	}
8712 
8713 	save_errno = 0;
8714 
8715 	/* rename tempqf to newqf */
8716 	if (!failing &&
8717 	    rename(tempqf, newqf) < 0)
8718 		save_errno = (errno == 0) ? EINVAL : errno;
8719 
8720 	/* Check rename() success */
8721 	if (!failing && save_errno != 0)
8722 	{
8723 		sm_syslog(LOG_DEBUG, e->e_id,
8724 			  "quarantine_queue_item: rename(%s, %s): %s",
8725 			  tempqf, newqf, sm_errstring(save_errno));
8726 
8727 		(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8728 				     "Error renaming %s to %s: %s\n",
8729 				     tempqf, newqf,
8730 				     sm_errstring(save_errno));
8731 		if (oldtype == newtype)
8732 		{
8733 			/*
8734 			**  Bail here since we don't know the state of
8735 			**  the filesystem and may need to keep tempqf
8736 			**  for the user to rescue us.
8737 			*/
8738 
8739 			RELEASE_QUEUE;
8740 			errno = save_errno;
8741 			syserr("!452 Error renaming control file %s", tempqf);
8742 			/* NOTREACHED */
8743 		}
8744 		else
8745 		{
8746 			/* remove new file (if rename() half completed) */
8747 			if (xunlink(newqf) < 0)
8748 			{
8749 				save_errno = errno;
8750 				(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8751 						     "Error removing %s: %s\n",
8752 						     newqf,
8753 						     sm_errstring(save_errno));
8754 			}
8755 
8756 			/* tempqf removed below */
8757 			failing = true;
8758 		}
8759 
8760 	}
8761 
8762 	/* If changing file types, need to remove old type */
8763 	if (!failing && oldtype != newtype)
8764 	{
8765 		if (xunlink(oldqf) < 0)
8766 		{
8767 			save_errno = errno;
8768 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8769 					     "Error removing %s: %s\n",
8770 					     oldqf, sm_errstring(save_errno));
8771 		}
8772 	}
8773 
8774 	/* see if anything above failed */
8775 	if (failing)
8776 	{
8777 		/* Something failed: remove new file, old file still there */
8778 		(void) xunlink(tempqf);
8779 	}
8780 
8781 	/*
8782 	**  fsync() after file operations to make sure metadata is
8783 	**  written to disk on filesystems in which renames are
8784 	**  not guaranteed.  It's ok if they fail, mail won't be lost.
8785 	*/
8786 
8787 	if (SuperSafe != SAFE_NO)
8788 	{
8789 		/* for soft-updates */
8790 		(void) fsync(sm_io_getinfo(tempqfp,
8791 					   SM_IO_WHAT_FD, NULL));
8792 
8793 		if (!failing)
8794 		{
8795 			/* for soft-updates */
8796 			(void) fsync(sm_io_getinfo(oldqfp,
8797 						   SM_IO_WHAT_FD, NULL));
8798 		}
8799 
8800 		/* for other odd filesystems */
8801 		SYNC_DIR(tempqf, false);
8802 	}
8803 
8804 	/* Close up shop */
8805 	RELEASE_QUEUE;
8806 	if (tempqfp != NULL)
8807 		(void) sm_io_close(tempqfp, SM_TIME_DEFAULT);
8808 	if (oldqfp != NULL)
8809 		(void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8810 
8811 	/* All went well */
8812 	return !failing;
8813 }
8814 
8815 /*
8816 **  QUARANTINE_QUEUE -- {un,}quarantine matching items in the queue
8817 **
8818 **	Read all matching queue items, add/remove quarantine
8819 **	reason, and requeue appropriately.
8820 **
8821 **	Parameters:
8822 **		reason -- quarantine reason, "." means unquarantine.
8823 **		qgrplimit -- limit to single queue group unless NOQGRP
8824 **
8825 **	Results:
8826 **		none.
8827 **
8828 **	Side Effects:
8829 **		Lots of changes to the queue.
8830 */
8831 
8832 void
quarantine_queue(reason,qgrplimit)8833 quarantine_queue(reason, qgrplimit)
8834 	char *reason;
8835 	int qgrplimit;
8836 {
8837 	int changed = 0;
8838 	int qgrp;
8839 
8840 	/* Convert internal representation of unquarantine */
8841 	if (reason != NULL && reason[0] == '.' && reason[1] == '\0')
8842 		reason = NULL;
8843 
8844 	if (reason != NULL)
8845 	{
8846 		/* clean it */
8847 		reason = newstr(denlstring(reason, true, true));
8848 	}
8849 
8850 	for (qgrp = 0; qgrp < NumQueue && Queue[qgrp] != NULL; qgrp++)
8851 	{
8852 		int qdir;
8853 
8854 		if (qgrplimit != NOQGRP && qgrplimit != qgrp)
8855 			continue;
8856 
8857 		for (qdir = 0; qdir < Queue[qgrp]->qg_numqueues; qdir++)
8858 		{
8859 			int i;
8860 			int nrequests;
8861 
8862 			if (StopRequest)
8863 				stop_sendmail();
8864 
8865 			nrequests = gatherq(qgrp, qdir, true, NULL, NULL, NULL);
8866 
8867 			/* first see if there is anything */
8868 			if (nrequests <= 0)
8869 			{
8870 				if (Verbose)
8871 				{
8872 					(void) sm_io_fprintf(smioout,
8873 							     SM_TIME_DEFAULT, "%s: no matches\n",
8874 							     qid_printqueue(qgrp, qdir));
8875 				}
8876 				continue;
8877 			}
8878 
8879 			if (Verbose)
8880 			{
8881 				(void) sm_io_fprintf(smioout,
8882 						     SM_TIME_DEFAULT, "Processing %s:\n",
8883 						     qid_printqueue(qgrp, qdir));
8884 			}
8885 
8886 			for (i = 0; i < WorkListCount; i++)
8887 			{
8888 				ENVELOPE e;
8889 
8890 				if (StopRequest)
8891 					stop_sendmail();
8892 
8893 				/* setup envelope */
8894 				clearenvelope(&e, true, sm_rpool_new_x(NULL));
8895 				e.e_id = WorkList[i].w_name + 2;
8896 				e.e_qgrp = qgrp;
8897 				e.e_qdir = qdir;
8898 
8899 				if (tTd(70, 101))
8900 				{
8901 					sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8902 						      "Would do %s\n", e.e_id);
8903 					changed++;
8904 				}
8905 				else if (quarantine_queue_item(qgrp, qdir,
8906 							       &e, reason))
8907 					changed++;
8908 
8909 				/* clean up */
8910 				sm_rpool_free(e.e_rpool);
8911 				e.e_rpool = NULL;
8912 			}
8913 			if (WorkList != NULL)
8914 				sm_free(WorkList); /* XXX */
8915 			WorkList = NULL;
8916 			WorkListSize = 0;
8917 			WorkListCount = 0;
8918 		}
8919 	}
8920 	if (Verbose)
8921 	{
8922 		if (changed == 0)
8923 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8924 					     "No changes\n");
8925 		else
8926 			(void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8927 					     "%d change%s\n",
8928 					     changed,
8929 					     changed == 1 ? "" : "s");
8930 	}
8931 }
8932