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