2 * Copyright (c) 1998-2009, 2011, 2012, 2014 Proofpoint, Inc. and its suppliers.
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.
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.
17 SM_RCSID("@(#)$Id: queue.c,v 8.1000 2013-11-22 20:51:56 ca Exp $")
21 # define RELEASE_QUEUE (void) 0
22 # define ST_INODE(st) (st).st_ino
24 # define sm_file_exists(errno) ((errno) == EEXIST)
26 # if HASFLOCK && defined(O_EXLOCK)
27 # define SM_OPEN_EXLOCK 1
28 # define TF_OPEN_FLAGS (O_CREAT|O_WRONLY|O_EXCL|O_EXLOCK)
29 # else /* HASFLOCK && defined(O_EXLOCK) */
30 # define TF_OPEN_FLAGS (O_CREAT|O_WRONLY|O_EXCL)
31 # endif /* HASFLOCK && defined(O_EXLOCK) */
33 #ifndef SM_OPEN_EXLOCK
34 # define SM_OPEN_EXLOCK 0
35 #endif /* ! SM_OPEN_EXLOCK */
39 ** QF_VERSION == 4 was sendmail 8.10/8.11 without _FFR_QUEUEDELAY
40 ** QF_VERSION == 5 was sendmail 8.10/8.11 with _FFR_QUEUEDELAY
41 ** QF_VERSION == 6 was sendmail 8.12 without _FFR_QUEUEDELAY
42 ** QF_VERSION == 7 was sendmail 8.12 with _FFR_QUEUEDELAY
43 ** QF_VERSION == 8 is sendmail 8.13
46 #define QF_VERSION 8 /* version number of this queue format */
48 static char queue_letter __P((ENVELOPE *, int));
49 static bool quarantine_queue_item __P((int, int, ENVELOPE *, char *));
51 /* Naming convention: qgrp: index of queue group, qg: QUEUEGROUP */
59 char *w_name; /* name of control file */
60 char *w_host; /* name of recipient host */
61 bool w_lock; /* is message locked? */
62 bool w_tooyoung; /* is it too young to run? */
63 long w_pri; /* priority of message, see below */
64 time_t w_ctime; /* creation time */
65 time_t w_mtime; /* modification time */
66 int w_qgrp; /* queue group located in */
67 int w_qdir; /* queue directory located in */
68 struct work *w_next; /* next in queue */
71 typedef struct work WORK;
73 static WORK *WorkQ; /* queue of things to be done */
74 static int NumWorkGroups; /* number of work groups */
75 static time_t Current_LA_time = 0;
77 /* Get new load average every 30 seconds. */
78 #define GET_NEW_LA_TIME 30
80 #define SM_GET_LA(now) \
84 if (Current_LA_time < now - GET_NEW_LA_TIME) \
87 Current_LA_time = now; \
92 ** DoQueueRun indicates that a queue run is needed.
93 ** Notice: DoQueueRun is modified in a signal handler!
96 static bool volatile DoQueueRun; /* non-interrupt time queue run needed */
99 ** Work group definition structure.
100 ** Each work group contains one or more queue groups. This is done
101 ** to manage the number of queue group runners active at the same time
102 ** to be within the constraints of MaxQueueChildren (if it is set).
103 ** The number of queue groups that can be run on the next work run
104 ** is kept track of. The queue groups are run in a round robin.
109 int wg_numqgrp; /* number of queue groups in work grp */
110 int wg_runners; /* total runners */
111 int wg_curqgrp; /* current queue group */
112 QUEUEGRP **wg_qgs; /* array of queue groups */
113 int wg_maxact; /* max # of active runners */
114 time_t wg_lowqintvl; /* lowest queue interval */
115 int wg_restart; /* needs restarting? */
116 int wg_restartcnt; /* count of times restarted */
119 typedef struct workgrp WORKGRP;
121 static WORKGRP volatile WorkGrp[MAXWORKGROUPS + 1]; /* work groups */
124 static SM_DEBUG_T DebugLeakQ = SM_DEBUG_INITIALIZER("leak_q",
125 "@(#)$Debug: leak_q - trace memory leaks during queue processing $");
126 #endif /* SM_HEAP_CHECK */
128 static void grow_wlist __P((int, int));
129 static int multiqueue_cache __P((char *, int, QUEUEGRP *, int, unsigned int *));
130 static int gatherq __P((int, int, bool, bool *, bool *, int *));
131 static int sortq __P((int));
132 static void printctladdr __P((ADDRESS *, SM_FILE_T *));
133 static bool readqf __P((ENVELOPE *, bool));
134 static void restart_work_group __P((int));
135 static void runner_work __P((ENVELOPE *, int, bool, int, int));
136 static void schedule_queue_runs __P((bool, int, bool));
137 static char *strrev __P((char *));
138 static ADDRESS *setctluser __P((char *, int, ENVELOPE *));
140 static int sm_strshufflecmp __P((char *, char *));
141 static void init_shuffle_alphabet __P(());
142 #endif /* _FFR_RHS */
145 ** Note: workcmpf?() don't use a prototype because it will cause a conflict
146 ** with the qsort() call (which expects something like
147 ** int (*compar)(const void *, const void *), not (WORK *, WORK *))
150 static int workcmpf0();
151 static int workcmpf1();
152 static int workcmpf2();
153 static int workcmpf3();
154 static int workcmpf4();
155 static int randi = 3; /* index for workcmpf5() */
156 static int workcmpf5();
157 static int workcmpf6();
159 static int workcmpf7();
160 #endif /* _FFR_RHS */
163 # define get_rand_mod(m) ((get_random() >> RANDOMSHIFT) % (m))
164 #else /* RANDOMSHIFT */
165 # define get_rand_mod(m) (get_random() % (m))
166 #endif /* RANDOMSHIFT */
169 ** File system definition.
170 ** Used to keep track of how much free space is available
171 ** on a file system in which one or more queue directories reside.
174 typedef struct filesys_shared FILESYS;
176 struct filesys_shared
178 dev_t fs_dev; /* unique device id */
179 long fs_avail; /* number of free blocks available */
180 long fs_blksize; /* block size, in bytes */
183 /* probably kept in shared memory */
184 static FILESYS FileSys[MAXFILESYS]; /* queue file systems */
185 static const char *FSPath[MAXFILESYS]; /* pathnames for file systems */
190 ** Shared memory data
193 ** size -- size of shared memory segment
194 ** pid -- pid of owner, should be a unique id to avoid misinterpretations
195 ** by other processes.
196 ** tag -- should be a unique id to avoid misinterpretations by others.
197 ** idea: hash over configuration data that will be stored here.
198 ** NumFileSys -- number of file systems.
199 ** FileSys -- (array of) structure for used file systems.
200 ** RSATmpCnt -- counter for number of uses of ephemeral RSA key.
201 ** QShm -- (array of) structure for information about queue directories.
205 ** Queue data in shared memory
208 typedef struct queue_shared QUEUE_SHM_T;
212 int qs_entries; /* number of entries */
213 /* XXX more to follow? */
216 static void *Pshm; /* pointer to shared memory */
217 static FILESYS *PtrFileSys; /* pointer to queue file system array */
218 int ShmId = SM_SHM_NO_ID; /* shared memory id */
219 static QUEUE_SHM_T *QShm; /* pointer to shared queue data */
222 # define SHM_OFF_PID(p) (((char *) (p)) + sizeof(int))
223 # define SHM_OFF_TAG(p) (((char *) (p)) + sizeof(pid_t) + sizeof(int))
224 # define SHM_OFF_HEAD (sizeof(pid_t) + sizeof(int) * 2)
226 /* how to access FileSys */
227 # define FILE_SYS(i) (PtrFileSys[i])
229 /* first entry is a tag, for now just the size */
230 # define OFF_FILE_SYS(p) (((char *) (p)) + SHM_OFF_HEAD)
232 /* offset for PNumFileSys */
233 # define OFF_NUM_FILE_SYS(p) (((char *) (p)) + SHM_OFF_HEAD + sizeof(FileSys))
235 /* offset for PRSATmpCnt */
236 # define OFF_RSA_TMP_CNT(p) (((char *) (p)) + SHM_OFF_HEAD + sizeof(FileSys) + sizeof(int))
239 /* offset for queue_shm */
240 # define OFF_QUEUE_SHM(p) (((char *) (p)) + SHM_OFF_HEAD + sizeof(FileSys) + sizeof(int) * 2)
242 # define QSHM_ENTRIES(i) QShm[i].qs_entries
244 /* basic size of shared memory segment */
245 # define SM_T_SIZE (SHM_OFF_HEAD + sizeof(FileSys) + sizeof(int) * 2)
247 static unsigned int hash_q __P((char *, unsigned int));
250 ** HASH_Q -- simple hash function
253 ** p -- string to hash.
254 ** h -- hash start value (from previous run).
272 h += (c<<11) ^ (c>>1);
273 h ^= (d<<14) + (d<<7) + (d<<4) + d;
279 #else /* SM_CONF_SHM */
280 # define FILE_SYS(i) FileSys[i]
281 #endif /* SM_CONF_SHM */
283 /* access to the various components of file system data */
284 #define FILE_SYS_NAME(i) FSPath[i]
285 #define FILE_SYS_AVAIL(i) FILE_SYS(i).fs_avail
286 #define FILE_SYS_BLKSIZE(i) FILE_SYS(i).fs_blksize
287 #define FILE_SYS_DEV(i) FILE_SYS(i).fs_dev
291 ** Current qf file field assignments:
295 ** C controlling user
297 ** d data file directory name (added in 8.12)
302 ** I data file's inode number
303 ** K time of last delivery attempt
304 ** L Solaris Content-Length: header (obsolete)
306 ** N number of delivery attempts
307 ** P message priority
308 ** q quarantine reason
309 ** Q original recipient (ORCPT=)
310 ** r final recipient (Final-Recipient: DSN field)
314 ** V queue file version
315 ** X free (was: character set if _FFR_SAVE_CHARSET)
317 ** Z original envelope id from ESMTP
318 ** ! deliver by (added in 8.12)
324 ** QUEUEUP -- queue a message up for future transmission.
327 ** e -- the envelope to queue up.
328 ** announce -- if true, tell when you are queueing up.
329 ** msync -- if true, then fsync() if SuperSafe interactive mode.
335 ** The current request is saved in a control file.
336 ** The queue file is left locked.
340 queueup(e, announce, msync)
341 register ENVELOPE *e;
345 register SM_FILE_T *tfp;
360 ** Create control file.
365 MODE_T oldumask = 0; \
367 if (bitset(S_IWGRP, QueueFileMode)) \
368 oldumask = umask(002); \
369 tfd = open(tf, TF_OPEN_FLAGS, QueueFileMode); \
370 if (bitset(S_IWGRP, QueueFileMode)) \
371 (void) umask(oldumask); \
375 newid = (e->e_id == NULL) || !bitset(EF_INQUEUE, e->e_flags);
376 (void) sm_strlcpy(tf, queuename(e, NEWQFL_LETTER), sizeof(tf));
378 if (tfp == NULL && newid)
381 ** open qf file directly: this will give an error if the file
382 ** already exists and hence prevent problems if a queue-id
383 ** is reused (e.g., because the clock is set back).
386 (void) sm_strlcpy(tf, queuename(e, ANYQFL_LETTER), sizeof(tf));
390 !lockfile(tfd, tf, NULL, LOCK_EX|LOCK_NB) ||
391 #endif /* !SM_OPEN_EXLOCK */
392 (tfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
393 (void *) &tfd, SM_IO_WRONLY,
396 int save_errno = errno;
400 syserr("!queueup: cannot create queue file %s, euid=%ld, fd=%d, fp=%p",
401 tf, (long) geteuid(), tfd, tfp);
405 upd_qs(e, 1, 0, "queueup");
408 /* if newid, write the queue file directly (instead of temp file) */
411 /* get a locked tf file */
412 for (i = 0; i < 128; i++)
421 if (LogLevel > 0 && (i % 32) == 0)
422 sm_syslog(LOG_ALERT, e->e_id,
423 "queueup: cannot create %s, euid=%ld: %s",
424 tf, (long) geteuid(),
425 sm_errstring(errno));
430 #endif /* SM_OPEN_EXLOCK */
435 /* file is locked by open() */
437 #else /* SM_OPEN_EXLOCK */
438 if (lockfile(tfd, tf, NULL, LOCK_EX|LOCK_NB))
441 #endif /* SM_OPEN_EXLOCK */
442 if (LogLevel > 0 && (i % 32) == 0)
443 sm_syslog(LOG_ALERT, e->e_id,
444 "queueup: cannot lock %s: %s",
445 tf, sm_errstring(errno));
455 /* save the old temp file away */
456 (void) rename(tf, queuename(e, TEMPQF_LETTER));
459 (void) sleep(i % 32);
461 if (tfd < 0 || (tfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
462 (void *) &tfd, SM_IO_WRONLY_B,
465 int save_errno = errno;
469 syserr("!queueup: cannot create queue temp file %s, uid=%ld",
470 tf, (long) geteuid());
475 sm_dprintf("\n>>>>> queueing %s/%s%s >>>>>\n",
476 qid_printqueue(e->e_qgrp, e->e_qdir),
477 queuename(e, ANYQFL_LETTER),
478 newid ? " (new id)" : "");
481 sm_dprintf(" e_flags=");
486 sm_dprintf(" sendq=");
487 printaddr(sm_debug_file(), e->e_sendqueue, true);
492 dumpfd(sm_io_getinfo(tfp, SM_IO_WHAT_FD, NULL), true, false);
493 sm_dprintf(" lockfp=");
494 if (e->e_lockfp == NULL)
495 sm_dprintf("NULL\n");
497 dumpfd(sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL),
502 ** If there is no data file yet, create one.
505 (void) sm_strlcpy(df, queuename(e, DATAFL_LETTER), sizeof(df));
506 if (bitset(EF_HAS_DF, e->e_flags))
508 if (e->e_dfp != NULL &&
509 SuperSafe != SAFE_REALLY &&
510 SuperSafe != SAFE_REALLY_POSTMILTER &&
511 sm_io_setinfo(e->e_dfp, SM_BF_COMMIT, NULL) < 0 &&
514 syserr("!queueup: cannot commit data file %s, uid=%ld",
515 queuename(e, DATAFL_LETTER), (long) geteuid());
517 if (e->e_dfp != NULL &&
518 SuperSafe == SAFE_INTERACTIVE && msync)
521 sm_syslog(LOG_INFO, e->e_id,
522 "queueup: fsync(e->e_dfp)");
524 if (fsync(sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD,
528 syserr("!552 Error writing data file %s",
531 syserr("!452 Error writing data file %s",
540 register SM_FILE_T *dfp = NULL;
543 if (e->e_dfp != NULL &&
544 sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
545 syserr("committing over bf file");
547 if (bitset(S_IWGRP, QueueFileMode))
548 oldumask = umask(002);
549 dfd = open(df, O_WRONLY|O_CREAT|O_TRUNC|QF_O_EXTRA,
551 if (bitset(S_IWGRP, QueueFileMode))
552 (void) umask(oldumask);
553 if (dfd < 0 || (dfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
554 (void *) &dfd, SM_IO_WRONLY_B,
556 syserr("!queueup: cannot create data temp file %s, uid=%ld",
557 df, (long) geteuid());
558 if (fstat(dfd, &stbuf) < 0)
562 e->e_dfdev = stbuf.st_dev;
563 e->e_dfino = ST_INODE(stbuf);
565 e->e_flags |= EF_HAS_DF;
566 memset(&mcibuf, '\0', sizeof(mcibuf));
567 mcibuf.mci_out = dfp;
568 mcibuf.mci_mailer = FileMailer;
569 (*e->e_putbody)(&mcibuf, e, NULL);
571 if (SuperSafe == SAFE_REALLY ||
572 SuperSafe == SAFE_REALLY_POSTMILTER ||
573 (SuperSafe == SAFE_INTERACTIVE && msync))
576 sm_syslog(LOG_INFO, e->e_id,
577 "queueup: fsync(dfp)");
579 if (fsync(sm_io_getinfo(dfp, SM_IO_WHAT_FD, NULL)) < 0)
582 syserr("!552 Error writing data file %s",
585 syserr("!452 Error writing data file %s",
590 if (sm_io_close(dfp, SM_TIME_DEFAULT) < 0)
591 syserr("!queueup: cannot save data temp file %s, uid=%ld",
592 df, (long) geteuid());
593 e->e_putbody = putbody;
597 ** Output future work requests.
598 ** Priority and creation time should be first, since
599 ** they are required by gatherq.
602 /* output queue version number (must be first!) */
603 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "V%d\n", QF_VERSION);
605 /* output creation time */
606 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "T%ld\n", (long) e->e_ctime);
608 /* output last delivery time */
609 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "K%ld\n", (long) e->e_dtime);
611 /* output number of delivery attempts */
612 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "N%d\n", e->e_ntries);
614 /* output message priority */
615 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "P%ld\n", e->e_msgpriority);
618 ** If data file is in a different directory than the queue file,
619 ** output a "d" record naming the directory of the data file.
622 if (e->e_dfqgrp != e->e_qgrp)
624 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "d%s\n",
625 Queue[e->e_dfqgrp]->qg_qpaths[e->e_dfqdir].qp_name);
628 /* output inode number of data file */
629 if (e->e_dfino != -1)
631 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "I%ld/%ld/%llu\n",
632 (long) major(e->e_dfdev),
633 (long) minor(e->e_dfdev),
634 (ULONGLONG_T) e->e_dfino);
637 /* output body type */
638 if (e->e_bodytype != NULL)
639 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "B%s\n",
640 denlstring(e->e_bodytype, true, false));
642 /* quarantine reason */
643 if (e->e_quarmsg != NULL)
644 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "q%s\n",
645 denlstring(e->e_quarmsg, true, false));
647 /* message from envelope, if it exists */
648 if (e->e_message != NULL)
649 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "M%s\n",
650 denlstring(e->e_message, true, false));
652 /* send various flag bits through */
654 if (bitset(EF_WARNING, e->e_flags))
656 if (bitset(EF_RESPONSE, e->e_flags))
658 if (bitset(EF_HAS8BIT, e->e_flags))
660 if (bitset(EF_DELETE_BCC, e->e_flags))
662 if (bitset(EF_RET_PARAM, e->e_flags))
664 if (bitset(EF_NO_BODY_RETN, e->e_flags))
666 if (bitset(EF_SPLIT, e->e_flags))
670 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "F%s\n", buf);
672 /* save $={persistentMacros} macro values */
673 queueup_macros(macid("{persistentMacros}"), tfp, e);
675 /* output name of sender */
676 if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags))
679 p = e->e_from.q_paddr;
680 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "S%s\n",
681 denlstring(p, true, false));
683 /* output ESMTP-supplied "original" information */
684 if (e->e_envid != NULL)
685 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "Z%s\n",
686 denlstring(e->e_envid, true, false));
688 /* output AUTH= parameter */
689 if (e->e_auth_param != NULL)
690 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "A%s\n",
691 denlstring(e->e_auth_param, true, false));
692 if (e->e_dlvr_flag != 0)
693 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "!%c %ld\n",
694 (char) e->e_dlvr_flag, e->e_deliver_by);
696 /* output list of recipient addresses */
697 printctladdr(NULL, NULL);
698 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
700 if (!QS_IS_UNDELIVERED(q->q_state))
703 /* message for this recipient, if it exists */
704 if (q->q_message != NULL)
705 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "M%s\n",
706 denlstring(q->q_message, true,
709 printctladdr(q, tfp);
710 if (q->q_orcpt != NULL)
711 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "Q%s\n",
712 denlstring(q->q_orcpt, true,
714 if (q->q_finalrcpt != NULL)
715 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "r%s\n",
716 denlstring(q->q_finalrcpt, true,
718 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'R');
719 if (bitset(QPRIMARY, q->q_flags))
720 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'P');
721 if (bitset(QHASNOTIFY, q->q_flags))
722 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'N');
723 if (bitset(QPINGONSUCCESS, q->q_flags))
724 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'S');
725 if (bitset(QPINGONFAILURE, q->q_flags))
726 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'F');
727 if (bitset(QPINGONDELAY, q->q_flags))
728 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'D');
729 if (bitset(QINTBCC, q->q_flags))
730 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'B');
731 if (q->q_alias != NULL &&
732 bitset(QALIAS, q->q_alias->q_flags))
733 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, 'A');
736 if (bitset(QDYNMAILER, q->q_flags))
737 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, QDYNMAILFLG);
738 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, ':');
739 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "%s\n",
740 denlstring(q->q_paddr, true, false));
743 char *tag = "queued";
745 if (e->e_quarmsg != NULL)
748 e->e_to = q->q_paddr;
751 logdelivery(q->q_mailer, NULL, q->q_status,
752 tag, NULL, (time_t) 0, e, q, EX_OK);
757 sm_dprintf("queueing ");
758 printaddr(sm_debug_file(), q, false);
763 ** Output headers for this message.
764 ** Expand macros completely here. Queue run will deal with
765 ** everything as absolute headers.
766 ** All headers that must be relative to the recipient
767 ** can be cracked later.
768 ** We set up a "null mailer" -- i.e., a mailer that will have
769 ** no effect on the addresses as they are output.
772 memset((char *) &nullmailer, '\0', sizeof(nullmailer));
773 nullmailer.m_re_rwset = nullmailer.m_rh_rwset =
774 nullmailer.m_se_rwset = nullmailer.m_sh_rwset = -1;
775 nullmailer.m_eol = "\n";
776 memset(&mcibuf, '\0', sizeof(mcibuf));
777 mcibuf.mci_mailer = &nullmailer;
778 mcibuf.mci_out = tfp;
780 macdefine(&e->e_macro, A_PERM, 'g', "\201f");
781 for (h = e->e_header; h != NULL; h = h->h_link)
783 if (h->h_value == NULL)
786 /* don't output resent headers on non-resent messages */
787 if (bitset(H_RESENT, h->h_flags) &&
788 !bitset(EF_RESENT, e->e_flags))
791 /* expand macros; if null, don't output header at all */
792 if (bitset(H_DEFAULT, h->h_flags))
794 (void) expand(h->h_value, buf, sizeof(buf), e);
797 if (buf[0] == ' ' && buf[1] == '\0')
801 /* output this header */
802 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "H?");
804 /* output conditional macro if present */
805 if (h->h_macro != '\0')
807 if (bitset(0200, h->h_macro))
808 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT,
810 macname(bitidx(h->h_macro)));
812 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT,
815 else if (!bitzerop(h->h_mflags) &&
816 bitset(H_CHECK|H_ACHECK, h->h_flags))
820 /* if conditional, output the set of conditions */
821 for (j = '\0'; j <= '\177'; j++)
822 if (bitnset(j, h->h_mflags))
823 (void) sm_io_putc(tfp, SM_TIME_DEFAULT,
826 (void) sm_io_putc(tfp, SM_TIME_DEFAULT, '?');
828 /* output the header: expand macros, convert addresses */
829 if (bitset(H_DEFAULT, h->h_flags) &&
830 !bitset(H_BINDLATE, h->h_flags))
832 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "%s:%s\n",
834 denlstring(buf, false, true));
836 else if (bitset(H_FROM|H_RCPT, h->h_flags) &&
837 !bitset(H_BINDLATE, h->h_flags))
839 bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
840 SM_FILE_T *savetrace = TrafficLogFile;
842 TrafficLogFile = NULL;
844 if (bitset(H_FROM, h->h_flags))
846 commaize(h, h->h_value, oldstyle, &mcibuf, e,
849 TrafficLogFile = savetrace;
853 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "%s:%s\n",
855 denlstring(h->h_value, false,
863 ** Write a terminator record -- this is to prevent
864 ** scurrilous crackers from appending any data.
867 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, ".\n");
869 if (sm_io_flush(tfp, SM_TIME_DEFAULT) != 0 ||
870 ((SuperSafe == SAFE_REALLY ||
871 SuperSafe == SAFE_REALLY_POSTMILTER ||
872 (SuperSafe == SAFE_INTERACTIVE && msync)) &&
873 fsync(sm_io_getinfo(tfp, SM_IO_WHAT_FD, NULL)) < 0) ||
877 syserr("!552 Error writing control file %s", tf);
879 syserr("!452 Error writing control file %s", tf);
884 char new = queue_letter(e, ANYQFL_LETTER);
886 /* rename (locked) tf to be (locked) [qh]f */
887 (void) sm_strlcpy(qf, queuename(e, ANYQFL_LETTER),
889 if (rename(tf, qf) < 0)
890 syserr("cannot rename(%s, %s), uid=%ld",
891 tf, qf, (long) geteuid());
895 ** Check if type has changed and only
896 ** remove the old item if the rename above
900 if (e->e_qfletter != '\0' &&
901 e->e_qfletter != new)
905 sm_dprintf("type changed from %c to %c\n",
909 if (unlink(queuename(e, e->e_qfletter)) < 0)
911 /* XXX: something more drastic? */
913 sm_syslog(LOG_ERR, e->e_id,
914 "queueup: unlink(%s) failed: %s",
915 queuename(e, e->e_qfletter),
916 sm_errstring(errno));
923 ** fsync() after renaming to make sure metadata is
924 ** written to disk on filesystems in which renames are
928 if (SuperSafe != SAFE_NO)
930 /* for softupdates */
931 if (tfd >= 0 && fsync(tfd) < 0)
933 syserr("!queueup: cannot fsync queue temp file %s",
939 /* close and unlock old (locked) queue file */
940 if (e->e_lockfp != NULL)
941 (void) sm_io_close(e->e_lockfp, SM_TIME_DEFAULT);
946 sm_syslog(LOG_DEBUG, e->e_id, "queueup %s", qf);
952 sm_syslog(LOG_DEBUG, e->e_id, "queueup %s", tf);
954 e->e_qfletter = queue_letter(e, ANYQFL_LETTER);
958 e->e_flags |= EF_INQUEUE;
961 sm_dprintf("<<<<< done queueing %s <<<<<\n\n", e->e_id);
966 ** PRINTCTLADDR -- print control address to file.
970 ** tfp -- file pointer.
976 ** The control address (if changed) is printed to the file.
977 ** The last control address and uid are saved.
989 static ADDRESS *lastctladdr = NULL;
990 static uid_t lastuid;
993 if (a == NULL || a->q_alias == NULL || tfp == NULL)
995 if (lastctladdr != NULL && tfp != NULL)
996 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "C\n");
1002 /* find the active uid */
1012 user = q->q_ruser != NULL ? q->q_ruser : q->q_user;
1018 /* check to see if this is the same as last time */
1019 if (lastctladdr != NULL && uid == lastuid &&
1020 strcmp(lastctladdr->q_paddr, a->q_paddr) == 0)
1025 if (uid == 0 || user == NULL || user[0] == '\0')
1026 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "C");
1028 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, "C%s:%ld:%ld",
1029 denlstring(user, true, false), (long) uid,
1031 (void) sm_io_fprintf(tfp, SM_TIME_DEFAULT, ":%s\n",
1032 denlstring(a->q_paddr, true, false));
1036 ** RUNNERS_SIGTERM -- propagate a SIGTERM to queue runner process
1038 ** This propagates the signal to the child processes that are queue
1039 ** runners. This is for a queue runner "cleanup". After all of the
1040 ** child queue runner processes are signaled (it should be SIGTERM
1041 ** being the sig) then the old signal handler (Oldsh) is called
1042 ** to handle any cleanup set for this process (provided it is not
1043 ** SIG_DFL or SIG_IGN). The signal may not be handled immediately
1044 ** if the BlockOldsh flag is set. If the current process doesn't
1045 ** have a parent then handle the signal immediately, regardless of
1049 ** sig -- the signal number being sent
1055 ** Sets the NoMoreRunners boolean to true to stop more runners
1056 ** from being started in runqueue().
1058 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
1059 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1063 static bool volatile NoMoreRunners = false;
1064 static sigfunc_t Oldsh_term = SIG_DFL;
1065 static sigfunc_t Oldsh_hup = SIG_DFL;
1066 static sigfunc_t volatile Oldsh = SIG_DFL;
1067 static bool BlockOldsh = false;
1068 static int volatile Oldsig = 0;
1069 static SIGFUNC_DECL runners_sigterm __P((int));
1070 static SIGFUNC_DECL runners_sighup __P((int));
1073 runners_sigterm(sig)
1076 int save_errno = errno;
1078 FIX_SYSV_SIGNAL(sig, runners_sigterm);
1080 CHECK_CRITICAL(sig);
1081 NoMoreRunners = true;
1084 proc_list_signal(PROC_QUEUE, sig);
1086 if (!BlockOldsh || getppid() <= 1)
1088 /* Check that a valid 'old signal handler' is callable */
1089 if (Oldsh_term != SIG_DFL && Oldsh_term != SIG_IGN &&
1090 Oldsh_term != runners_sigterm)
1094 return SIGFUNC_RETURN;
1097 ** RUNNERS_SIGHUP -- propagate a SIGHUP to queue runner process
1099 ** This propagates the signal to the child processes that are queue
1100 ** runners. This is for a queue runner "cleanup". After all of the
1101 ** child queue runner processes are signaled (it should be SIGHUP
1102 ** being the sig) then the old signal handler (Oldsh) is called to
1103 ** handle any cleanup set for this process (provided it is not SIG_DFL
1104 ** or SIG_IGN). The signal may not be handled immediately if the
1105 ** BlockOldsh flag is set. If the current process doesn't have
1106 ** a parent then handle the signal immediately, regardless of
1110 ** sig -- the signal number being sent
1116 ** Sets the NoMoreRunners boolean to true to stop more runners
1117 ** from being started in runqueue().
1119 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
1120 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1128 int save_errno = errno;
1130 FIX_SYSV_SIGNAL(sig, runners_sighup);
1132 CHECK_CRITICAL(sig);
1133 NoMoreRunners = true;
1136 proc_list_signal(PROC_QUEUE, sig);
1138 if (!BlockOldsh || getppid() <= 1)
1140 /* Check that a valid 'old signal handler' is callable */
1141 if (Oldsh_hup != SIG_DFL && Oldsh_hup != SIG_IGN &&
1142 Oldsh_hup != runners_sighup)
1146 return SIGFUNC_RETURN;
1149 ** MARK_WORK_GROUP_RESTART -- mark a work group as needing a restart
1151 ** Sets a workgroup for restarting.
1154 ** wgrp -- the work group id to restart.
1155 ** reason -- why (signal?), -1 to turn off restart
1161 ** May set global RestartWorkGroup to true.
1163 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
1164 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1169 mark_work_group_restart(wgrp, reason)
1173 if (wgrp < 0 || wgrp > NumWorkGroups)
1176 WorkGrp[wgrp].wg_restart = reason;
1178 RestartWorkGroup = true;
1181 ** RESTART_MARKED_WORK_GROUPS -- restart work groups marked as needing restart
1183 ** Restart any workgroup marked as needing a restart provided more
1184 ** runners are allowed.
1193 ** Sets global RestartWorkGroup to false.
1197 restart_marked_work_groups()
1205 /* Block SIGCHLD so reapchild() doesn't mess with us */
1206 wasblocked = sm_blocksignal(SIGCHLD);
1208 for (i = 0; i < NumWorkGroups; i++)
1210 if (WorkGrp[i].wg_restart >= 0)
1213 sm_syslog(LOG_ERR, NOQID,
1214 "restart queue runner=%d due to signal 0x%x",
1215 i, WorkGrp[i].wg_restart);
1216 restart_work_group(i);
1219 RestartWorkGroup = false;
1221 if (wasblocked == 0)
1222 (void) sm_releasesignal(SIGCHLD);
1225 ** RESTART_WORK_GROUP -- restart a specific work group
1227 ** Restart a specific workgroup provided more runners are allowed.
1228 ** If the requested work group has been restarted too many times log
1229 ** this and refuse to restart.
1232 ** wgrp -- the work group id to restart
1238 ** starts another process doing the work of wgrp
1241 #define MAX_PERSIST_RESTART 10 /* max allowed number of restarts */
1244 restart_work_group(wgrp)
1247 if (NoMoreRunners ||
1248 wgrp < 0 || wgrp > NumWorkGroups)
1251 WorkGrp[wgrp].wg_restart = -1;
1252 if (WorkGrp[wgrp].wg_restartcnt < MAX_PERSIST_RESTART)
1254 /* avoid overflow; increment here */
1255 WorkGrp[wgrp].wg_restartcnt++;
1256 (void) run_work_group(wgrp, RWG_FORK|RWG_PERSISTENT|RWG_RUNALL);
1260 sm_syslog(LOG_ERR, NOQID,
1261 "ERROR: persistent queue runner=%d restarted too many times, queue runner lost",
1266 ** SCHEDULE_QUEUE_RUNS -- schedule the next queue run for a work group.
1269 ** runall -- schedule even if individual bit is not set.
1270 ** wgrp -- the work group id to schedule.
1271 ** didit -- the queue run was performed for this work group.
1277 #define INCR_MOD(v, m) if (++v >= m) \
1282 schedule_queue_runs(runall, wgrp, didit)
1287 int qgrp, cgrp, endgrp;
1288 #if _FFR_QUEUE_SCHED_DBG
1291 #endif /* _FFR_QUEUE_SCHED_DBG */
1296 ** This is a bit ugly since we have to duplicate the
1297 ** code that "walks" through a work queue group.
1302 cgrp = endgrp = WorkGrp[wgrp].wg_curqgrp;
1307 #if _FFR_QUEUE_SCHED_DBG
1310 #endif /* _FFR_QUEUE_SCHED_DBG */
1311 qgrp = WorkGrp[wgrp].wg_qgs[cgrp]->qg_index;
1312 if (Queue[qgrp]->qg_queueintvl > 0)
1313 qintvl = Queue[qgrp]->qg_queueintvl;
1314 else if (QueueIntvl > 0)
1315 qintvl = QueueIntvl;
1317 qintvl = (time_t) 0;
1318 #if _FFR_QUEUE_SCHED_DBG
1319 lastsched = Queue[qgrp]->qg_nextrun;
1320 #endif /* _FFR_QUEUE_SCHED_DBG */
1321 if ((runall || Queue[qgrp]->qg_nextrun <= now) && qintvl > 0)
1323 #if _FFR_QUEUE_SCHED_DBG
1325 #endif /* _FFR_QUEUE_SCHED_DBG */
1326 if (minqintvl == 0 || qintvl < minqintvl)
1330 ** Only set a new time if a queue run was performed
1331 ** for this queue group. If the queue was not run,
1332 ** we could starve it by setting a new time on each
1337 Queue[qgrp]->qg_nextrun += qintvl;
1339 #if _FFR_QUEUE_SCHED_DBG
1341 sm_syslog(LOG_INFO, NOQID,
1342 "sqr: wgrp=%d, cgrp=%d, qgrp=%d, intvl=%ld, QI=%ld, runall=%d, lastrun=%ld, nextrun=%ld, sched=%d",
1343 wgrp, cgrp, qgrp, Queue[qgrp]->qg_queueintvl,
1344 QueueIntvl, runall, lastsched,
1345 Queue[qgrp]->qg_nextrun, sched);
1346 #endif /* _FFR_QUEUE_SCHED_DBG */
1347 INCR_MOD(cgrp, WorkGrp[wgrp].wg_numqgrp);
1348 } while (endgrp != cgrp);
1350 (void) sm_setevent(minqintvl, runqueueevent, 0);
1353 #if _FFR_QUEUE_RUN_PARANOIA
1355 ** CHECKQUEUERUNNER -- check whether a queue group hasn't been run.
1357 ** Use this if events may get lost and hence queue runners may not
1358 ** be started and mail will pile up in a queue.
1364 ** true if a queue run is necessary.
1367 ** may schedule a queue run.
1374 time_t now, minqintvl;
1378 for (qgrp = 0; qgrp < NumQueue && Queue[qgrp] != NULL; qgrp++)
1382 if (Queue[qgrp]->qg_queueintvl > 0)
1383 qintvl = Queue[qgrp]->qg_queueintvl;
1384 else if (QueueIntvl > 0)
1385 qintvl = QueueIntvl;
1387 qintvl = (time_t) 0;
1388 if (Queue[qgrp]->qg_nextrun <= now - qintvl)
1390 if (minqintvl == 0 || qintvl < minqintvl)
1393 sm_syslog(LOG_WARNING, NOQID,
1394 "checkqueuerunner: queue %d should have been run at %s, queue interval %ld",
1396 arpadate(ctime(&Queue[qgrp]->qg_nextrun)),
1402 (void) sm_setevent(minqintvl, runqueueevent, 0);
1407 #endif /* _FFR_QUEUE_RUN_PARANOIA */
1410 ** RUNQUEUE -- run the jobs in the queue.
1412 ** Gets the stuff out of the queue in some presumably logical
1413 ** order and processes them.
1416 ** forkflag -- true if the queue scanning should be done in
1417 ** a child process. We double-fork so it is not our
1418 ** child and we don't have to clean up after it.
1419 ** false can be ignored if we have multiple queues.
1420 ** verbose -- if true, print out status information.
1421 ** persistent -- persistent queue runner?
1422 ** runall -- run all groups or only a subset (DoQueueRun)?
1425 ** true if the queue run successfully began.
1428 ** runs things in the mail queue using run_work_group().
1429 ** maybe schedules next queue run.
1432 static ENVELOPE QueueEnvelope; /* the queue run envelope */
1433 static time_t LastQueueTime = 0; /* last time a queue ID assigned */
1434 static pid_t LastQueuePid = -1; /* last PID which had a queue ID */
1436 /* values for qp_supdirs */
1437 #define QP_NOSUB 0x0000 /* No subdirectories */
1438 #define QP_SUBDF 0x0001 /* "df" subdirectory */
1439 #define QP_SUBQF 0x0002 /* "qf" subdirectory */
1440 #define QP_SUBXF 0x0004 /* "xf" subdirectory */
1443 runqueue(forkflag, verbose, persistent, runall)
1451 static int curnum = 0;
1454 SM_NONVOLATILE int oldgroup = 0;
1456 if (sm_debug_active(&DebugLeakQ, 1))
1458 oldgroup = sm_heap_group();
1460 sm_dprintf("runqueue() heap group #%d\n", sm_heap_group());
1462 #endif /* SM_HEAP_CHECK */
1464 /* queue run has been started, don't do any more this time */
1467 /* more than one queue or more than one directory per queue */
1468 if (!forkflag && !verbose &&
1469 (WorkGrp[0].wg_qgs[0]->qg_numqueues > 1 || NumWorkGroups > 1 ||
1470 WorkGrp[0].wg_numqgrp > 1))
1474 ** For controlling queue runners via signals sent to this process.
1475 ** Oldsh* will get called too by runners_sig* (if it is not SIG_IGN
1476 ** or SIG_DFL) to preserve cleanup behavior. Now that this process
1477 ** will have children (and perhaps grandchildren) this handler will
1478 ** be left in place. This is because this process, once it has
1479 ** finished spinning off queue runners, may go back to doing something
1480 ** else (like being a daemon). And we still want on a SIG{TERM,HUP} to
1481 ** clean up the child queue runners. Only install 'runners_sig*' once
1482 ** else we'll get stuck looping forever.
1485 cursh = sm_signal(SIGTERM, runners_sigterm);
1486 if (cursh != runners_sigterm)
1488 cursh = sm_signal(SIGHUP, runners_sighup);
1489 if (cursh != runners_sighup)
1492 for (i = 0; i < NumWorkGroups && !NoMoreRunners; i++)
1494 int rwgflags = RWG_NONE;
1498 ** If MaxQueueChildren active then test whether the start
1499 ** of the next queue group's additional queue runners (maximum)
1500 ** will result in MaxQueueChildren being exceeded.
1502 ** Note: do not use continue; even though another workgroup
1503 ** may have fewer queue runners, this would be "unfair",
1504 ** i.e., this work group might "starve" then.
1507 #if _FFR_QUEUE_SCHED_DBG
1509 sm_syslog(LOG_INFO, NOQID,
1510 "rq: curnum=%d, MaxQueueChildren=%d, CurRunners=%d, WorkGrp[curnum].wg_maxact=%d",
1511 curnum, MaxQueueChildren, CurRunners,
1512 WorkGrp[curnum].wg_maxact);
1513 #endif /* _FFR_QUEUE_SCHED_DBG */
1514 if (MaxQueueChildren > 0 &&
1515 CurRunners + WorkGrp[curnum].wg_maxact > MaxQueueChildren)
1519 ** Pick up where we left off (curnum), in case we
1520 ** used up all the children last time without finishing.
1521 ** This give a round-robin fairness to queue runs.
1523 ** Increment CurRunners before calling run_work_group()
1524 ** to avoid a "race condition" with proc_list_drop() which
1525 ** decrements CurRunners if the queue runners terminate.
1526 ** Notice: CurRunners is an upper limit, in some cases
1527 ** (too few jobs in the queue) this value is larger than
1528 ** the actual number of queue runners. The discrepancy can
1529 ** increase if some queue runners "hang" for a long time.
1532 /* don't let proc_list_drop() change CurRunners */
1533 wasblocked = sm_blocksignal(SIGCHLD);
1534 CurRunners += WorkGrp[curnum].wg_maxact;
1535 if (wasblocked == 0)
1536 (void) sm_releasesignal(SIGCHLD);
1538 rwgflags |= RWG_FORK;
1540 rwgflags |= RWG_VERBOSE;
1542 rwgflags |= RWG_PERSISTENT;
1544 rwgflags |= RWG_RUNALL;
1545 ret = run_work_group(curnum, rwgflags);
1548 ** Failure means a message was printed for ETRN
1549 ** and subsequent queues are likely to fail as well.
1550 ** Decrement CurRunners in that case because
1551 ** none have been started.
1556 /* don't let proc_list_drop() change CurRunners */
1557 wasblocked = sm_blocksignal(SIGCHLD);
1558 CurRunners -= WorkGrp[curnum].wg_maxact;
1559 CHK_CUR_RUNNERS("runqueue", curnum,
1560 WorkGrp[curnum].wg_maxact);
1561 if (wasblocked == 0)
1562 (void) sm_releasesignal(SIGCHLD);
1567 schedule_queue_runs(runall, curnum, true);
1568 INCR_MOD(curnum, NumWorkGroups);
1571 /* schedule left over queue runs */
1572 if (i < NumWorkGroups && !NoMoreRunners && !persistent)
1576 for (h = curnum; i < NumWorkGroups; i++)
1578 schedule_queue_runs(runall, h, false);
1579 INCR_MOD(h, NumWorkGroups);
1585 if (sm_debug_active(&DebugLeakQ, 1))
1586 sm_heap_setgroup(oldgroup);
1587 #endif /* SM_HEAP_CHECK */
1591 #if _FFR_SKIP_DOMAINS
1593 ** SKIP_DOMAINS -- Skip 'skip' number of domains in the WorkQ.
1595 ** Added by Stephen Frost <sfrost@snowman.net> to support
1596 ** having each runner process every N'th domain instead of
1597 ** every N'th message.
1600 ** skip -- number of domains in WorkQ to skip.
1603 ** total number of messages skipped.
1615 for (n = 0, seqjump = 0; n < skip && WorkQ != NULL; seqjump++)
1617 if (WorkQ->w_next != NULL)
1619 if (WorkQ->w_host != NULL &&
1620 WorkQ->w_next->w_host != NULL)
1622 if (sm_strcasecmp(WorkQ->w_host,
1623 WorkQ->w_next->w_host) != 0)
1628 if ((WorkQ->w_host != NULL &&
1629 WorkQ->w_next->w_host == NULL) ||
1630 (WorkQ->w_host == NULL &&
1631 WorkQ->w_next->w_host != NULL))
1635 WorkQ = WorkQ->w_next;
1639 #endif /* _FFR_SKIP_DOMAINS */
1642 ** RUNNER_WORK -- have a queue runner do its work
1644 ** Have a queue runner do its work a list of entries.
1645 ** When work isn't directly being done then this process can take a signal
1646 ** and terminate immediately (in a clean fashion of course).
1647 ** When work is directly being done, it's not to be interrupted
1648 ** immediately: the work should be allowed to finish at a clean point
1649 ** before termination (in a clean fashion of course).
1653 ** sequenceno -- 'th process to run WorkQ.
1654 ** didfork -- did the calling process fork()?
1655 ** skip -- process only each skip'th item.
1656 ** njobs -- number of jobs in WorkQ.
1662 ** runs things in the mail queue.
1666 runner_work(e, sequenceno, didfork, skip, njobs)
1667 register ENVELOPE *e;
1680 ** Here we temporarily block the second calling of the handlers.
1681 ** This allows us to handle the signal without terminating in the
1682 ** middle of direct work. If a signal does come, the test for
1683 ** NoMoreRunners will find it.
1689 /* process them once at a time */
1690 while (WorkQ != NULL)
1693 SM_NONVOLATILE int oldgroup = 0;
1695 if (sm_debug_active(&DebugLeakQ, 1))
1697 oldgroup = sm_heap_group();
1699 sm_dprintf("run_queue_group() heap group #%d\n",
1702 #endif /* SM_HEAP_CHECK */
1704 /* do no more work */
1707 /* Check that a valid signal handler is callable */
1708 if (Oldsh != SIG_DFL && Oldsh != SIG_IGN &&
1709 Oldsh != runners_sighup &&
1710 Oldsh != runners_sigterm)
1715 w = WorkQ; /* assign current work item */
1718 ** Set the head of the WorkQ to the next work item.
1719 ** It is set 'skip' ahead (the number of parallel queue
1720 ** runners working on WorkQ together) since each runner
1721 ** works on every 'skip'th (N-th) item.
1722 #if _FFR_SKIP_DOMAINS
1723 ** In the case of the BYHOST Queue Sort Order, the 'item'
1724 ** is a domain, so we work on every 'skip'th (N-th) domain.
1725 #endif * _FFR_SKIP_DOMAINS *
1728 #if _FFR_SKIP_DOMAINS
1729 if (QueueSortOrder == QSO_BYHOST)
1732 if (WorkQ->w_next != NULL)
1734 if (WorkQ->w_host != NULL &&
1735 WorkQ->w_next->w_host != NULL)
1737 if (sm_strcasecmp(WorkQ->w_host,
1738 WorkQ->w_next->w_host)
1740 seqjump = skip_domains(skip);
1742 WorkQ = WorkQ->w_next;
1746 if ((WorkQ->w_host != NULL &&
1747 WorkQ->w_next->w_host == NULL) ||
1748 (WorkQ->w_host == NULL &&
1749 WorkQ->w_next->w_host != NULL))
1750 seqjump = skip_domains(skip);
1752 WorkQ = WorkQ->w_next;
1756 WorkQ = WorkQ->w_next;
1759 #endif /* _FFR_SKIP_DOMAINS */
1761 for (n = 0; n < skip && WorkQ != NULL; n++)
1762 WorkQ = WorkQ->w_next;
1768 ** Ignore jobs that are too expensive for the moment.
1770 ** Get new load average every GET_NEW_LA_TIME seconds.
1774 if (shouldqueue(WkRecipFact, Current_LA_time))
1776 char *msg = "Aborting queue run: load average too high";
1781 sm_syslog(LOG_INFO, NOQID, "runqueue: %s", msg);
1784 if (shouldqueue(w->w_pri, w->w_ctime))
1788 if (QueueSortOrder == QSO_BYPRIORITY)
1791 message("Skipping %s/%s (sequence %d of %d) and flushing rest of queue",
1792 qid_printqueue(w->w_qgrp,
1794 w->w_name + 2, sequenceno,
1797 sm_syslog(LOG_INFO, NOQID,
1798 "runqueue: Flushing queue from %s/%s (pri %ld, LA %d, %d of %d)",
1799 qid_printqueue(w->w_qgrp,
1801 w->w_name + 2, w->w_pri,
1802 CurrentLA, sequenceno,
1807 message("Skipping %s/%s (sequence %d of %d)",
1808 qid_printqueue(w->w_qgrp, w->w_qdir),
1809 w->w_name + 2, sequenceno, njobs);
1816 message("Running %s/%s (sequence %d of %d)",
1817 qid_printqueue(w->w_qgrp, w->w_qdir),
1818 w->w_name + 2, sequenceno, njobs);
1820 if (didfork && MaxQueueChildren > 0)
1822 sm_blocksignal(SIGCHLD);
1823 (void) sm_signal(SIGCHLD, reapchild);
1826 sm_syslog(LOG_DEBUG, NOQID,
1827 "runqueue %s dowork(%s)",
1828 qid_printqueue(w->w_qgrp, w->w_qdir),
1831 (void) dowork(w->w_qgrp, w->w_qdir, w->w_name + 2,
1832 ForkQueueRuns, false, e);
1835 sm_free(w->w_name); /* XXX */
1836 if (w->w_host != NULL)
1837 sm_free(w->w_host); /* XXX */
1838 sm_free((char *) w); /* XXX */
1839 sequenceno += seqjump; /* next sequence number */
1841 if (sm_debug_active(&DebugLeakQ, 1))
1842 sm_heap_setgroup(oldgroup);
1843 #endif /* SM_HEAP_CHECK */
1848 /* check the signals didn't happen during the revert */
1851 /* Check that a valid signal handler is callable */
1852 if (Oldsh != SIG_DFL && Oldsh != SIG_IGN &&
1853 Oldsh != runners_sighup && Oldsh != runners_sigterm)
1857 Oldsh = SIG_DFL; /* after the NoMoreRunners check */
1860 ** RUN_WORK_GROUP -- run the jobs in a queue group from a work group.
1862 ** Gets the stuff out of the queue in some presumably logical
1863 ** order and processes them.
1866 ** wgrp -- work group to process.
1867 ** flags -- RWG_* flags
1870 ** true if the queue run successfully began.
1873 ** runs things in the mail queue.
1876 /* Minimum sleep time for persistent queue runners */
1877 #define MIN_SLEEP_TIME 5
1880 run_work_group(wgrp, flags)
1884 register ENVELOPE *e;
1887 int qgrp, endgrp, h, i;
1891 extern ENVELOPE BlankEnvelope;
1892 extern SIGFUNC_DECL reapchild __P((int));
1898 ** If no work will ever be selected, don't even bother reading
1904 if (!bitset(RWG_PERSISTENT, flags) &&
1905 shouldqueue(WkRecipFact, Current_LA_time))
1907 char *msg = "Skipping queue run -- load average too high";
1909 if (bitset(RWG_VERBOSE, flags))
1910 message("458 %s\n", msg);
1912 sm_syslog(LOG_INFO, NOQID, "runqueue: %s", msg);
1917 ** See if we already have too many children.
1920 if (bitset(RWG_FORK, flags) &&
1921 WorkGrp[wgrp].wg_lowqintvl > 0 &&
1922 !bitset(RWG_PERSISTENT, flags) &&
1923 MaxChildren > 0 && CurChildren >= MaxChildren)
1925 char *msg = "Skipping queue run -- too many children";
1927 if (bitset(RWG_VERBOSE, flags))
1928 message("458 %s (%d)\n", msg, CurChildren);
1930 sm_syslog(LOG_INFO, NOQID, "runqueue: %s (%d)",
1936 ** See if we want to go off and do other useful work.
1939 if (bitset(RWG_FORK, flags))
1943 (void) sm_blocksignal(SIGCHLD);
1944 (void) sm_signal(SIGCHLD, reapchild);
1949 const char *msg = "Skipping queue run -- fork() failed";
1950 const char *err = sm_errstring(errno);
1952 if (bitset(RWG_VERBOSE, flags))
1953 message("458 %s: %s\n", msg, err);
1955 sm_syslog(LOG_INFO, NOQID, "runqueue: %s: %s",
1957 (void) sm_releasesignal(SIGCHLD);
1962 /* parent -- pick up intermediate zombie */
1963 (void) sm_blocksignal(SIGALRM);
1965 /* wgrp only used when queue runners are persistent */
1966 proc_list_add(pid, "Queue runner", PROC_QUEUE,
1967 WorkGrp[wgrp].wg_maxact,
1968 bitset(RWG_PERSISTENT, flags) ? wgrp : -1,
1970 (void) sm_releasesignal(SIGALRM);
1971 (void) sm_releasesignal(SIGCHLD);
1975 /* child -- clean up signals */
1977 /* Reset global flags */
1978 RestartRequest = NULL;
1979 RestartWorkGroup = false;
1980 ShutdownRequest = NULL;
1982 CurrentPid = getpid();
1983 close_sendmail_pid();
1986 ** Initialize exception stack and default exception
1987 ** handler for child process.
1990 sm_exc_newthread(fatal_error);
1994 /* Add parent process as first child item */
1995 proc_list_add(CurrentPid, "Queue runner child process",
1996 PROC_QUEUE_CHILD, 0, -1, NULL);
1997 (void) sm_releasesignal(SIGCHLD);
1998 (void) sm_signal(SIGCHLD, SIG_DFL);
1999 (void) sm_signal(SIGHUP, SIG_DFL);
2000 (void) sm_signal(SIGTERM, intsig);
2004 ** Release any resources used by the daemon code.
2009 /* force it to run expensive jobs */
2012 /* drop privileges */
2013 if (geteuid() == (uid_t) 0)
2014 (void) drop_privileges(false);
2017 ** Create ourselves an envelope
2020 CurEnv = &QueueEnvelope;
2021 rpool = sm_rpool_new_x(NULL);
2022 e = newenvelope(&QueueEnvelope, CurEnv, rpool);
2023 e->e_flags = BlankEnvelope.e_flags;
2026 /* make sure we have disconnected from parent */
2027 if (bitset(RWG_FORK, flags))
2034 ** If we are running part of the queue, always ignore stored
2038 if (QueueLimitId != NULL || QueueLimitSender != NULL ||
2039 QueueLimitQuarantine != NULL ||
2040 QueueLimitRecipient != NULL)
2042 IgnoreHostStatus = true;
2048 ** Here is where we choose the queue group from the work group.
2049 ** The caller of the "domorework" label must setup a new envelope.
2052 endgrp = WorkGrp[wgrp].wg_curqgrp; /* to not spin endlessly */
2057 ** Run a queue group if:
2058 ** RWG_RUNALL bit is set or the bit for this group is set.
2065 ** Find the next queue group within the work group that
2066 ** has been marked as needing a run.
2069 qgrp = WorkGrp[wgrp].wg_qgs[WorkGrp[wgrp].wg_curqgrp]->qg_index;
2070 WorkGrp[wgrp].wg_curqgrp++; /* advance */
2071 WorkGrp[wgrp].wg_curqgrp %= WorkGrp[wgrp].wg_numqgrp; /* wrap */
2072 if (bitset(RWG_RUNALL, flags) ||
2073 (Queue[qgrp]->qg_nextrun <= now &&
2074 Queue[qgrp]->qg_nextrun != (time_t) -1))
2076 if (endgrp == WorkGrp[wgrp].wg_curqgrp)
2079 if (bitset(RWG_FORK, flags))
2080 finis(true, true, ExitStat);
2081 return true; /* we're done */
2085 qdir = Queue[qgrp]->qg_curnum; /* round-robin init of queue position */
2086 #if _FFR_QUEUE_SCHED_DBG
2088 sm_syslog(LOG_INFO, NOQID,
2089 "rwg: wgrp=%d, qgrp=%d, qdir=%d, name=%s, curqgrp=%d, numgrps=%d",
2090 wgrp, qgrp, qdir, qid_printqueue(qgrp, qdir),
2091 WorkGrp[wgrp].wg_curqgrp, WorkGrp[wgrp].wg_numqgrp);
2092 #endif /* _FFR_QUEUE_SCHED_DBG */
2095 /* tweak niceness of queue runs */
2096 if (Queue[qgrp]->qg_nice > 0)
2097 (void) nice(Queue[qgrp]->qg_nice);
2098 #endif /* HASNICE */
2100 /* XXX running queue group... */
2101 sm_setproctitle(true, CurEnv, "running queue: %s",
2102 qid_printqueue(qgrp, qdir));
2104 if (LogLevel > 69 || tTd(63, 99))
2105 sm_syslog(LOG_DEBUG, NOQID,
2106 "runqueue %s, pid=%d, forkflag=%d",
2107 qid_printqueue(qgrp, qdir), (int) CurrentPid,
2108 bitset(RWG_FORK, flags));
2111 ** Start making passes through the queue.
2112 ** First, read and sort the entire queue.
2113 ** Then, process the work in that order.
2114 ** But if you take too long, start over.
2117 for (i = 0; i < Queue[qgrp]->qg_numqueues; i++)
2119 (void) gatherq(qgrp, qdir, false, &full, &more, &h);
2121 if (ShmId != SM_SHM_NO_ID)
2122 QSHM_ENTRIES(Queue[qgrp]->qg_qpaths[qdir].qp_idx) = h;
2123 #endif /* SM_CONF_SHM */
2124 /* If there are no more items in this queue advance */
2127 /* A round-robin advance */
2129 qdir %= Queue[qgrp]->qg_numqueues;
2132 /* Has the WorkList reached the limit? */
2134 break; /* don't try to gather more */
2137 /* order the existing work requests */
2138 njobs = sortq(Queue[qgrp]->qg_maxlist);
2139 Queue[qgrp]->qg_curnum = qdir; /* update */
2142 if (!Verbose && bitnset(QD_FORK, Queue[qgrp]->qg_flags))
2144 int loop, maxrunners;
2148 ** For this WorkQ we want to fork off N children (maxrunners)
2149 ** at this point. Each child has a copy of WorkQ. Each child
2150 ** will process every N-th item. The parent will wait for all
2151 ** of the children to finish before moving on to the next
2152 ** queue group within the work group. This saves us forking
2153 ** a new runner-child for each work item.
2154 ** It's valid for qg_maxqrun == 0 since this may be an
2155 ** explicit "don't run this queue" setting.
2158 maxrunners = Queue[qgrp]->qg_maxqrun;
2161 ** If no runners are configured for this group but
2162 ** the queue is "forced" then lets use 1 runner.
2165 if (maxrunners == 0 && bitset(RWG_FORCE, flags))
2168 /* No need to have more runners then there are jobs */
2169 if (maxrunners > njobs)
2171 for (loop = 0; loop < maxrunners; loop++)
2174 ** Since the delivery may happen in a child and the
2175 ** parent does not wait, the parent may close the
2176 ** maps thereby removing any shared memory used by
2177 ** the map. Therefore, close the maps now so the
2178 ** child will dynamically open them if necessary.
2186 syserr("run_work_group: cannot fork");
2191 /* parent -- clean out connection cache */
2192 mci_flush(false, NULL);
2193 #if _FFR_SKIP_DOMAINS
2194 if (QueueSortOrder == QSO_BYHOST)
2196 sequenceno += skip_domains(1);
2199 #endif /* _FFR_SKIP_DOMAINS */
2202 WorkQ = WorkQ->w_next;
2205 proc_list_add(pid, "Queue child runner process",
2206 PROC_QUEUE_CHILD, 0, -1, NULL);
2208 /* No additional work, no additional runners */
2214 /* child -- Reset global flags */
2215 RestartRequest = NULL;
2216 RestartWorkGroup = false;
2217 ShutdownRequest = NULL;
2219 CurrentPid = getpid();
2220 close_sendmail_pid();
2223 ** Initialize exception stack and default
2224 ** exception handler for child process.
2225 ** When fork()'d the child now has a private
2226 ** copy of WorkQ at its current position.
2229 sm_exc_newthread(fatal_error);
2232 ** SMTP processes (whether -bd or -bs) set
2233 ** SIGCHLD to reapchild to collect
2234 ** children status. However, at delivery
2235 ** time, that status must be collected
2236 ** by sm_wait() to be dealt with properly
2237 ** (check success of delivery based
2238 ** on status code, etc). Therefore, if we
2239 ** are an SMTP process, reset SIGCHLD
2240 ** back to the default so reapchild
2241 ** doesn't collect status before
2245 if (OpMode == MD_SMTP ||
2246 OpMode == MD_DAEMON ||
2247 MaxQueueChildren > 0)
2250 sm_releasesignal(SIGCHLD);
2251 (void) sm_signal(SIGCHLD, SIG_DFL);
2254 /* child -- error messages to the transcript */
2255 QuickAbort = OnlyOneError = false;
2256 runner_work(e, sequenceno, true,
2259 /* This child is done */
2260 finis(true, true, ExitStat);
2265 sm_releasesignal(SIGCHLD);
2268 ** Wait until all of the runners have completed before
2269 ** seeing if there is another queue group in the
2270 ** work group to process.
2271 ** XXX Future enhancement: don't wait() for all children
2272 ** here, just go ahead and make sure that overall the number
2273 ** of children is not exceeded.
2276 while (CurChildren > 0)
2281 while ((ret = sm_wait(&status)) <= 0)
2283 proc_list_drop(ret, status, NULL);
2286 else if (Queue[qgrp]->qg_maxqrun > 0 || bitset(RWG_FORCE, flags))
2289 ** When current process will not fork children to do the work,
2290 ** it will do the work itself. The 'skip' will be 1 since
2291 ** there are no child runners to divide the work across.
2294 runner_work(e, sequenceno, false, 1, njobs);
2297 /* free memory allocated by newenvelope() above */
2298 sm_rpool_free(rpool);
2299 QueueEnvelope.e_rpool = NULL;
2301 /* Are there still more queues in the work group to process? */
2302 if (endgrp != WorkGrp[wgrp].wg_curqgrp)
2304 rpool = sm_rpool_new_x(NULL);
2305 e = newenvelope(&QueueEnvelope, CurEnv, rpool);
2306 e->e_flags = BlankEnvelope.e_flags;
2310 /* No more queues in work group to process. Now check persistent. */
2311 if (bitset(RWG_PERSISTENT, flags))
2314 sm_setproctitle(true, NULL, "running queue: %s",
2315 qid_printqueue(qgrp, qdir));
2318 ** close bogus maps, i.e., maps which caused a tempfail,
2319 ** so we get fresh map connections on the next lookup.
2320 ** closemaps() is also called when children are started.
2325 /* Close any cached connections. */
2326 mci_flush(true, NULL);
2328 /* Clean out expired related entries. */
2332 /* Update MX records for FallbackMX. */
2333 if (FallbackMX != NULL)
2334 (void) getfallbackmxrr(FallbackMX);
2335 #endif /* NAMED_BIND */
2338 /* close UserDatabase */
2343 if (sm_debug_active(&SmHeapCheck, 2)
2344 && access("memdump", F_OK) == 0
2350 out = sm_io_open(SmFtStdio, SM_TIME_DEFAULT,
2351 "memdump.out", SM_IO_APPEND, NULL);
2354 (void) sm_io_fprintf(out, SM_TIME_DEFAULT, "----------------------\n");
2356 sm_debug_level(&SmHeapCheck) - 1);
2357 (void) sm_io_close(out, SM_TIME_DEFAULT);
2360 #endif /* SM_HEAP_CHECK */
2362 /* let me rest for a second to catch my breath */
2363 if (njobs == 0 && WorkGrp[wgrp].wg_lowqintvl < MIN_SLEEP_TIME)
2364 sleep(MIN_SLEEP_TIME);
2365 else if (WorkGrp[wgrp].wg_lowqintvl <= 0)
2366 sleep(QueueIntvl > 0 ? QueueIntvl : MIN_SLEEP_TIME);
2368 sleep(WorkGrp[wgrp].wg_lowqintvl);
2371 ** Get the LA outside the WorkQ loop if necessary.
2372 ** In a persistent queue runner the code is repeated over
2373 ** and over but gatherq() may ignore entries due to
2374 ** shouldqueue() (do we really have to do this twice?).
2375 ** Hence the queue runners would just idle around when once
2376 ** CurrentLA caused all entries in a queue to be ignored.
2381 rpool = sm_rpool_new_x(NULL);
2382 e = newenvelope(&QueueEnvelope, CurEnv, rpool);
2383 e->e_flags = BlankEnvelope.e_flags;
2387 /* exit without the usual cleanup */
2389 if (bitset(RWG_FORK, flags))
2390 finis(true, true, ExitStat);
2396 ** DOQUEUERUN -- do a queue run?
2406 ** RUNQUEUEEVENT -- Sets a flag to indicate that a queue run should be done.
2415 ** The invocation of this function via an alarm may interrupt
2416 ** a set of actions. Thus errno may be set in that context.
2417 ** We need to restore errno at the end of this function to ensure
2418 ** that any work done here that sets errno doesn't return a
2419 ** misleading/false errno value. Errno may be EINTR upon entry to
2420 ** this function because of non-restartable/continuable system
2421 ** API was active. Iff this is true we will override errno as
2422 ** a timeout (as a more accurate error message).
2424 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
2425 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2430 runqueueevent(ignore)
2433 int save_errno = errno;
2436 ** Set the general bit that we want a queue run,
2437 ** tested in doqueuerun()
2441 #if _FFR_QUEUE_SCHED_DBG
2443 sm_syslog(LOG_INFO, NOQID, "rqe: done");
2444 #endif /* _FFR_QUEUE_SCHED_DBG */
2451 ** GATHERQ -- gather messages from the message queue(s) the work queue.
2454 ** qgrp -- the index of the queue group.
2455 ** qdir -- the index of the queue directory.
2456 ** doall -- if set, include everything in the queue (even
2457 ** the jobs that cannot be run because the load
2458 ** average is too high, or MaxQueueRun is reached).
2459 ** Otherwise, exclude those jobs.
2460 ** full -- (optional) to be set 'true' if WorkList is full
2461 ** more -- (optional) to be set 'true' if there are still more
2462 ** messages in this queue not added to WorkList
2463 ** pnentries -- (optional) total nuber of entries in queue
2466 ** The number of request in the queue (not necessarily
2467 ** the number of requests in WorkList however).
2470 ** prepares available work into WorkList
2473 #define NEED_P 0001 /* 'P': priority */
2474 #define NEED_T 0002 /* 'T': time */
2475 #define NEED_R 0004 /* 'R': recipient */
2476 #define NEED_S 0010 /* 'S': sender */
2477 #define NEED_H 0020 /* host */
2478 #define HAS_QUARANTINE 0040 /* has an unexpected 'q' line */
2479 #define NEED_QUARANTINE 0100 /* 'q': reason */
2481 static WORK *WorkList = NULL; /* list of unsort work */
2482 static int WorkListSize = 0; /* current max size of WorkList */
2483 static int WorkListCount = 0; /* # of work items in WorkList */
2486 gatherq(qgrp, qdir, doall, full, more, pnentries)
2494 register struct dirent *d;
2498 int i, num_ent, wn, nentries;
2500 char qd[MAXPATHLEN];
2501 char qf[MAXPATHLEN];
2503 wn = WorkListCount - 1;
2507 (void) sm_strlcpy(qd, ".", sizeof(qd));
2509 (void) sm_strlcpyn(qd, sizeof(qd), 2,
2510 Queue[qgrp]->qg_qpaths[qdir].qp_name,
2512 Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
2517 sm_dprintf("gatherq:\n");
2519 check = QueueLimitId;
2520 while (check != NULL)
2522 sm_dprintf("\tQueueLimitId = %s%s\n",
2523 check->queue_negate ? "!" : "",
2524 check->queue_match);
2525 check = check->queue_next;
2528 check = QueueLimitSender;
2529 while (check != NULL)
2531 sm_dprintf("\tQueueLimitSender = %s%s\n",
2532 check->queue_negate ? "!" : "",
2533 check->queue_match);
2534 check = check->queue_next;
2537 check = QueueLimitRecipient;
2538 while (check != NULL)
2540 sm_dprintf("\tQueueLimitRecipient = %s%s\n",
2541 check->queue_negate ? "!" : "",
2542 check->queue_match);
2543 check = check->queue_next;
2546 if (QueueMode == QM_QUARANTINE)
2548 check = QueueLimitQuarantine;
2549 while (check != NULL)
2551 sm_dprintf("\tQueueLimitQuarantine = %s%s\n",
2552 check->queue_negate ? "!" : "",
2553 check->queue_match);
2554 check = check->queue_next;
2559 /* open the queue directory */
2563 syserr("gatherq: cannot open \"%s\"",
2564 qid_printqueue(qgrp, qdir));
2566 *full = WorkListCount >= MaxQueueRun && MaxQueueRun > 0;
2573 ** Read the work directory.
2576 while ((d = readdir(f)) != NULL)
2580 char lbuf[MAXNAME + 1];
2584 sm_dprintf("gatherq: checking %s..", d->d_name);
2586 /* is this an interesting entry? */
2587 if (!(((QueueMode == QM_NORMAL &&
2588 d->d_name[0] == NORMQF_LETTER) ||
2589 (QueueMode == QM_QUARANTINE &&
2590 d->d_name[0] == QUARQF_LETTER) ||
2591 (QueueMode == QM_LOST &&
2592 d->d_name[0] == LOSEQF_LETTER)) &&
2593 d->d_name[1] == 'f'))
2596 sm_dprintf(" skipping\n");
2602 if (strlen(d->d_name) >= MAXQFNAME)
2605 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
2606 "gatherq: %s too long, %d max characters\n",
2607 d->d_name, MAXQFNAME);
2609 sm_syslog(LOG_ALERT, NOQID,
2610 "gatherq: %s too long, %d max characters",
2611 d->d_name, MAXQFNAME);
2616 check = QueueLimitId;
2617 while (check != NULL)
2619 if (strcontainedin(false, check->queue_match,
2620 d->d_name) != check->queue_negate)
2623 check = check->queue_next;
2625 if (QueueLimitId != NULL && check == NULL)
2628 /* grow work list if necessary */
2629 if (++wn >= MaxQueueRun && MaxQueueRun > 0)
2631 if (wn == MaxQueueRun && LogLevel > 0)
2632 sm_syslog(LOG_WARNING, NOQID,
2633 "WorkList for %s maxed out at %d",
2634 qid_printqueue(qgrp, qdir),
2637 continue; /* just count entries */
2640 if (wn >= WorkListSize)
2642 grow_wlist(qgrp, qdir);
2643 if (wn >= WorkListSize)
2649 (void) sm_strlcpyn(qf, sizeof(qf), 3, qd, "/", d->d_name);
2650 if (stat(qf, &sbuf) < 0)
2652 if (errno != ENOENT)
2653 sm_syslog(LOG_INFO, NOQID,
2654 "gatherq: can't stat %s/%s",
2655 qid_printqueue(qgrp, qdir),
2660 if (!bitset(S_IFREG, sbuf.st_mode))
2662 /* Yikes! Skip it or we will hang on open! */
2663 if (!((d->d_name[0] == DATAFL_LETTER ||
2664 d->d_name[0] == NORMQF_LETTER ||
2665 d->d_name[0] == QUARQF_LETTER ||
2666 d->d_name[0] == LOSEQF_LETTER ||
2667 d->d_name[0] == XSCRPT_LETTER) &&
2668 d->d_name[1] == 'f' && d->d_name[2] == '\0'))
2669 syserr("gatherq: %s/%s is not a regular file",
2670 qid_printqueue(qgrp, qdir), d->d_name);
2675 /* avoid work if possible */
2676 if ((QueueSortOrder == QSO_BYFILENAME ||
2677 QueueSortOrder == QSO_BYMODTIME ||
2678 QueueSortOrder == QSO_NONE ||
2679 QueueSortOrder == QSO_RANDOM) &&
2680 QueueLimitQuarantine == NULL &&
2681 QueueLimitSender == NULL &&
2682 QueueLimitRecipient == NULL)
2686 w->w_name = newstr(d->d_name);
2688 w->w_lock = w->w_tooyoung = false;
2691 w->w_mtime = sbuf.st_mtime;
2696 /* open control file */
2697 cf = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, qf, SM_IO_RDONLY_B,
2699 if (cf == NULL && OpMode != MD_PRINT)
2701 /* this may be some random person sending hir msgs */
2703 sm_dprintf("gatherq: cannot open %s: %s\n",
2704 d->d_name, sm_errstring(errno));
2711 w->w_name = newstr(d->d_name);
2715 w->w_lock = !lockfile(sm_io_getinfo(cf, SM_IO_WHAT_FD,
2720 w->w_tooyoung = false;
2722 /* make sure jobs in creation don't clog queue */
2723 w->w_pri = 0x7fffffff;
2725 w->w_mtime = sbuf.st_mtime;
2727 /* extract useful information */
2729 if (QueueSortOrder == QSO_BYHOST
2731 || QueueSortOrder == QSO_BYSHUFFLE
2732 #endif /* _FFR_RHS */
2735 /* need w_host set for host sort order */
2738 if (QueueLimitSender != NULL)
2740 if (QueueLimitRecipient != NULL)
2742 if (QueueLimitQuarantine != NULL)
2743 i |= NEED_QUARANTINE;
2744 while (cf != NULL && i != 0 &&
2745 sm_io_fgets(cf, SM_TIME_DEFAULT, lbuf,
2751 p = strchr(lbuf, '\n');
2756 /* flush rest of overly long line */
2757 while ((c = sm_io_getc(cf, SM_TIME_DEFAULT))
2758 != SM_IO_EOF && c != '\n')
2765 qfver = atoi(&lbuf[1]);
2769 w->w_pri = atol(&lbuf[1]);
2774 w->w_ctime = atol(&lbuf[1]);
2779 if (QueueMode != QM_QUARANTINE &&
2780 QueueMode != QM_LOST)
2783 sm_dprintf("%s not marked as quarantined but has a 'q' line\n",
2785 i |= HAS_QUARANTINE;
2787 else if (QueueMode == QM_QUARANTINE)
2789 if (QueueLimitQuarantine == NULL)
2791 i &= ~NEED_QUARANTINE;
2795 check = QueueLimitQuarantine;
2796 while (check != NULL)
2798 if (strcontainedin(false,
2801 check->queue_negate)
2804 check = check->queue_next;
2807 i &= ~NEED_QUARANTINE;
2812 if (w->w_host == NULL &&
2813 (p = strrchr(&lbuf[1], '@')) != NULL)
2816 if (QueueSortOrder == QSO_BYSHUFFLE)
2817 w->w_host = newstr(&p[1]);
2819 #endif /* _FFR_RHS */
2820 w->w_host = strrev(&p[1]);
2821 makelower(w->w_host);
2824 if (QueueLimitRecipient == NULL)
2831 p = strchr(&lbuf[1], ':');
2835 ++p; /* skip over ':' */
2839 check = QueueLimitRecipient;
2840 while (check != NULL)
2842 if (strcontainedin(true,
2845 check->queue_negate)
2848 check = check->queue_next;
2855 check = QueueLimitSender;
2856 while (check != NULL)
2858 if (strcontainedin(true,
2861 check->queue_negate)
2864 check = check->queue_next;
2871 if (MaxQueueAge > 0)
2873 time_t lasttry, delay;
2875 lasttry = (time_t) atol(&lbuf[1]);
2876 delay = MIN(lasttry - w->w_ctime,
2878 age = curtime() - lasttry;
2880 w->w_tooyoung = true;
2884 age = curtime() - (time_t) atol(&lbuf[1]);
2885 if (age >= 0 && MinQueueAge > 0 &&
2887 w->w_tooyoung = true;
2891 if (atol(&lbuf[1]) == 0)
2892 w->w_tooyoung = false;
2897 (void) sm_io_close(cf, SM_TIME_DEFAULT);
2899 if ((!doall && (shouldqueue(w->w_pri, w->w_ctime) ||
2901 bitset(HAS_QUARANTINE, i) ||
2902 bitset(NEED_QUARANTINE, i) ||
2903 bitset(NEED_R|NEED_S, i))
2905 /* don't even bother sorting this job in */
2907 sm_dprintf("skipping %s (%x)\n", w->w_name, i);
2908 sm_free(w->w_name); /* XXX */
2909 if (w->w_host != NULL)
2910 sm_free(w->w_host); /* XXX */
2919 i = wn - WorkListCount;
2920 WorkListCount += SM_MIN(num_ent, WorkListSize);
2923 *more = WorkListCount < wn;
2926 *full = (wn >= MaxQueueRun && MaxQueueRun > 0) ||
2927 (WorkList == NULL && wn > 0);
2929 if (pnentries != NULL)
2930 *pnentries = nentries;
2934 ** SORTQ -- sort the work list
2936 ** First the old WorkQ is cleared away. Then the WorkList is sorted
2937 ** for all items so that important (higher sorting value) items are not
2938 ** truncated off. Then the most important items are moved from
2939 ** WorkList to WorkQ. The lower count of 'max' or MaxListCount items
2943 ** max -- maximum number of items to be placed in WorkQ
2946 ** the number of items in WorkQ
2949 ** WorkQ gets released and filled with new work. WorkList
2950 ** gets released. Work items get sorted in order.
2957 register int i; /* local counter */
2958 register WORK *w; /* tmp item pointer */
2959 int wc = WorkListCount; /* trim size for WorkQ */
2965 /* Clear out old WorkQ. */
2966 for (w = WorkQ; w != NULL; w = nw)
2969 sm_free(w->w_name); /* XXX */
2970 if (w->w_host != NULL)
2971 sm_free(w->w_host); /* XXX */
2972 sm_free((char *) w); /* XXX */
2977 if (WorkList == NULL || wc <= 0)
2981 ** The sort now takes place using all of the items in WorkList.
2982 ** The list gets trimmed to the most important items after the sort.
2983 ** If the trim were to happen before the sort then one or more
2984 ** important items might get truncated off -- not what we want.
2987 if (QueueSortOrder == QSO_BYHOST)
2990 ** Sort the work directory for the first time,
2991 ** based on host name, lock status, and priority.
2994 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf1);
2997 ** If one message to host is locked, "lock" all messages
3004 if (!WorkList[i].w_lock)
3012 if (WorkList[i].w_host == NULL &&
3014 WorkList[i].w_lock = true;
3015 else if (WorkList[i].w_host != NULL &&
3016 w->w_host != NULL &&
3017 sm_strcasecmp(WorkList[i].w_host,
3019 WorkList[i].w_lock = true;
3026 ** Sort the work directory for the second time,
3027 ** based on lock status, host name, and priority.
3030 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf2);
3032 else if (QueueSortOrder == QSO_BYTIME)
3035 ** Simple sort based on submission time only.
3038 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf3);
3040 else if (QueueSortOrder == QSO_BYFILENAME)
3043 ** Sort based on queue filename.
3046 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf4);
3048 else if (QueueSortOrder == QSO_RANDOM)
3051 ** Sort randomly. To avoid problems with an instable sort,
3052 ** use a random index into the queue file name to start
3056 randi = get_rand_mod(MAXQFNAME);
3059 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf5);
3061 else if (QueueSortOrder == QSO_BYMODTIME)
3064 ** Simple sort based on modification time of queue file.
3065 ** This puts the oldest items first.
3068 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf6);
3071 else if (QueueSortOrder == QSO_BYSHUFFLE)
3074 ** Simple sort based on shuffled host name.
3077 init_shuffle_alphabet();
3078 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf7);
3080 #endif /* _FFR_RHS */
3081 else if (QueueSortOrder == QSO_BYPRIORITY)
3084 ** Simple sort based on queue priority only.
3087 qsort((char *) WorkList, wc, sizeof(*WorkList), workcmpf0);
3089 /* else don't sort at all */
3091 /* Check if the per queue group item limit will be exceeded */
3092 if (wc > max && max > 0)
3096 ** Convert the work list into canonical form.
3097 ** Should be turning it into a list of envelopes here perhaps.
3098 ** Only take the most important items up to the per queue group
3102 for (i = wc; --i >= 0; )
3104 w = (WORK *) xalloc(sizeof(*w));
3105 w->w_qgrp = WorkList[i].w_qgrp;
3106 w->w_qdir = WorkList[i].w_qdir;
3107 w->w_name = WorkList[i].w_name;
3108 w->w_host = WorkList[i].w_host;
3109 w->w_lock = WorkList[i].w_lock;
3110 w->w_tooyoung = WorkList[i].w_tooyoung;
3111 w->w_pri = WorkList[i].w_pri;
3112 w->w_ctime = WorkList[i].w_ctime;
3113 w->w_mtime = WorkList[i].w_mtime;
3118 /* free the rest of the list */
3119 for (i = WorkListCount; --i >= wc; )
3121 sm_free(WorkList[i].w_name);
3122 if (WorkList[i].w_host != NULL)
3123 sm_free(WorkList[i].w_host);
3126 if (WorkList != NULL)
3127 sm_free(WorkList); /* XXX */
3134 for (w = WorkQ; w != NULL; w = w->w_next)
3136 if (w->w_host != NULL)
3137 sm_dprintf("%22s: pri=%ld %s\n",
3138 w->w_name, w->w_pri, w->w_host);
3140 sm_dprintf("%32s: pri=%ld\n",
3141 w->w_name, w->w_pri);
3145 return wc; /* return number of WorkQ items */
3148 ** GROW_WLIST -- make the work list larger
3151 ** qgrp -- the index for the queue group.
3152 ** qdir -- the index for the queue directory.
3158 ** Adds another QUEUESEGSIZE entries to WorkList if possible.
3159 ** It can fail if there isn't enough memory, so WorkListSize
3160 ** should be checked again upon return.
3164 grow_wlist(qgrp, qdir)
3169 sm_dprintf("grow_wlist: WorkListSize=%d\n", WorkListSize);
3170 if (WorkList == NULL)
3172 WorkList = (WORK *) xalloc((sizeof(*WorkList)) *
3173 (QUEUESEGSIZE + 1));
3174 WorkListSize = QUEUESEGSIZE;
3178 int newsize = WorkListSize + QUEUESEGSIZE;
3179 WORK *newlist = (WORK *) sm_realloc((char *) WorkList,
3180 (unsigned) sizeof(WORK) * (newsize + 1));
3182 if (newlist != NULL)
3184 WorkListSize = newsize;
3188 sm_syslog(LOG_INFO, NOQID,
3189 "grew WorkList for %s to %d",
3190 qid_printqueue(qgrp, qdir),
3194 else if (LogLevel > 0)
3196 sm_syslog(LOG_ALERT, NOQID,
3197 "FAILED to grow WorkList for %s to %d",
3198 qid_printqueue(qgrp, qdir), newsize);
3202 sm_dprintf("grow_wlist: WorkListSize now %d\n", WorkListSize);
3205 ** WORKCMPF0 -- simple priority-only compare function.
3208 ** a -- the first argument.
3209 ** b -- the second argument.
3234 ** WORKCMPF1 -- first compare function for ordering work based on host name.
3236 ** Sorts on host name, lock status, and priority in that order.
3239 ** a -- the first argument.
3240 ** b -- the second argument.
3257 if (a->w_host != NULL && b->w_host == NULL)
3259 else if (a->w_host == NULL && b->w_host != NULL)
3261 if (a->w_host != NULL && b->w_host != NULL &&
3262 (i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
3266 if (a->w_lock != b->w_lock)
3267 return b->w_lock - a->w_lock;
3270 return workcmpf0(a, b);
3273 ** WORKCMPF2 -- second compare function for ordering work based on host name.
3275 ** Sorts on lock status, host name, and priority in that order.
3278 ** a -- the first argument.
3279 ** b -- the second argument.
3296 if (a->w_lock != b->w_lock)
3297 return a->w_lock - b->w_lock;
3300 if (a->w_host != NULL && b->w_host == NULL)
3302 else if (a->w_host == NULL && b->w_host != NULL)
3304 if (a->w_host != NULL && b->w_host != NULL &&
3305 (i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
3309 return workcmpf0(a, b);
3312 ** WORKCMPF3 -- simple submission-time-only compare function.
3315 ** a -- the first argument.
3316 ** b -- the second argument.
3330 if (a->w_ctime > b->w_ctime)
3332 else if (a->w_ctime < b->w_ctime)
3338 ** WORKCMPF4 -- compare based on file name
3341 ** a -- the first argument.
3342 ** b -- the second argument.
3356 return strcmp(a->w_name, b->w_name);
3359 ** WORKCMPF5 -- compare based on assigned random number
3362 ** a -- the first argument.
3363 ** b -- the second argument.
3375 if (strlen(a->w_name) < randi || strlen(b->w_name) < randi)
3377 return a->w_name[randi] - b->w_name[randi];
3380 ** WORKCMPF6 -- simple modification-time-only compare function.
3383 ** a -- the first argument.
3384 ** b -- the second argument.
3398 if (a->w_mtime > b->w_mtime)
3400 else if (a->w_mtime < b->w_mtime)
3407 ** WORKCMPF7 -- compare function for ordering work based on shuffled host name.
3409 ** Sorts on lock status, host name, and priority in that order.
3412 ** a -- the first argument.
3413 ** b -- the second argument.
3430 if (a->w_lock != b->w_lock)
3431 return a->w_lock - b->w_lock;
3434 if (a->w_host != NULL && b->w_host == NULL)
3436 else if (a->w_host == NULL && b->w_host != NULL)
3438 if (a->w_host != NULL && b->w_host != NULL &&
3439 (i = sm_strshufflecmp(a->w_host, b->w_host)) != 0)
3443 return workcmpf0(a, b);
3445 #endif /* _FFR_RHS */
3447 ** STRREV -- reverse string
3449 ** Returns a pointer to a new string that is the reverse of
3450 ** the string pointed to by fwd. The space for the new
3451 ** string is obtained using xalloc().
3454 ** fwd -- the string to reverse.
3457 ** the reversed string.
3468 rev = xalloc(len + 1);
3469 for (cnt = 0; cnt < len; ++cnt)
3470 rev[cnt] = fwd[len - cnt - 1];
3480 static unsigned char ShuffledAlphabet[NCHAR];
3483 init_shuffle_alphabet()
3485 static bool init = false;
3491 /* fill the ShuffledAlphabet */
3492 for (i = 0; i < NASCII; i++)
3493 ShuffledAlphabet[i] = i;
3496 for (i = 1; i < NASCII; i++)
3498 register int j = get_random() % NASCII;
3501 tmp = ShuffledAlphabet[j];
3502 ShuffledAlphabet[j] = ShuffledAlphabet[i];
3503 ShuffledAlphabet[i] = tmp;
3506 /* make it case insensitive */
3507 for (i = 'A'; i <= 'Z'; i++)
3508 ShuffledAlphabet[i] = ShuffledAlphabet[i + 'a' - 'A'];
3510 /* fill the upper part */
3511 for (i = 0; i < NASCII; i++)
3512 ShuffledAlphabet[i + NASCII] = ShuffledAlphabet[i];
3517 sm_strshufflecmp(a, b)
3521 const unsigned char *us1 = (const unsigned char *) a;
3522 const unsigned char *us2 = (const unsigned char *) b;
3524 while (ShuffledAlphabet[*us1] == ShuffledAlphabet[*us2++])
3529 return (ShuffledAlphabet[*us1] - ShuffledAlphabet[*--us2]);
3531 #endif /* _FFR_RHS */
3534 ** DOWORK -- do a work request.
3537 ** qgrp -- the index of the queue group for the job.
3538 ** qdir -- the index of the queue directory for the job.
3539 ** id -- the ID of the job to run.
3540 ** forkflag -- if set, run this in background.
3541 ** requeueflag -- if set, reinstantiate the queue quickly.
3542 ** This is used when expanding aliases in the queue.
3543 ** If forkflag is also set, it doesn't wait for the
3545 ** e - the envelope in which to run it.
3548 ** process id of process that is running the queue job.
3551 ** The work request is satisfied if possible.
3555 dowork(qgrp, qdir, id, forkflag, requeueflag, e)
3561 register ENVELOPE *e;
3567 sm_dprintf("dowork(%s/%s)\n", qid_printqueue(qgrp, qdir), id);
3576 ** Since the delivery may happen in a child and the
3577 ** parent does not wait, the parent may close the
3578 ** maps thereby removing any shared memory used by
3579 ** the map. Therefore, close the maps now so the
3580 ** child will dynamically open them if necessary.
3588 syserr("dowork: cannot fork");
3593 /* parent -- clean out connection cache */
3594 mci_flush(false, NULL);
3599 ** Initialize exception stack and default exception
3600 ** handler for child process.
3603 /* Reset global flags */
3604 RestartRequest = NULL;
3605 RestartWorkGroup = false;
3606 ShutdownRequest = NULL;
3608 CurrentPid = getpid();
3609 sm_exc_newthread(fatal_error);
3612 ** See note above about SMTP processes and SIGCHLD.
3615 if (OpMode == MD_SMTP ||
3616 OpMode == MD_DAEMON ||
3617 MaxQueueChildren > 0)
3620 sm_releasesignal(SIGCHLD);
3621 (void) sm_signal(SIGCHLD, SIG_DFL);
3624 /* child -- error messages to the transcript */
3625 QuickAbort = OnlyOneError = false;
3637 ** Lock the control file to avoid duplicate deliveries.
3638 ** Then run the file as though we had just read it.
3639 ** We save an idea of the temporary name so we
3640 ** can recover on interrupt.
3645 /* Reset global flags */
3646 RestartRequest = NULL;
3647 RestartWorkGroup = false;
3648 ShutdownRequest = NULL;
3652 /* set basic modes, etc. */
3655 rpool = sm_rpool_new_x(NULL);
3656 clearenvelope(e, false, rpool);
3657 e->e_flags |= EF_QUEUERUN|EF_GLOBALERRS;
3658 set_delivery_mode(SM_DELIVER, e);
3659 e->e_errormode = EM_MAIL;
3663 GrabTo = UseErrorsTo = false;
3668 set_op_mode(MD_QUEUERUN);
3670 sm_setproctitle(true, e, "%s from queue", qid_printname(e));
3672 sm_syslog(LOG_DEBUG, e->e_id, "dowork, pid=%d",
3675 /* don't use the headers from sendmail.cf... */
3678 /* read the queue control file -- return if locked */
3679 if (!readqf(e, false))
3681 if (tTd(40, 4) && e->e_id != NULL)
3682 sm_dprintf("readqf(%s) failed\n",
3686 finis(false, true, EX_OK);
3689 /* adding this frees 8 bytes */
3690 clearenvelope(e, false, rpool);
3692 /* adding this frees 12 bytes */
3693 sm_rpool_free(rpool);
3699 e->e_flags |= EF_INQUEUE;
3700 eatheader(e, requeueflag, true);
3703 queueup(e, false, false);
3705 /* do the delivery */
3706 sendall(e, SM_DELIVER);
3708 /* finish up and exit */
3710 finis(true, true, ExitStat);
3713 (void) dropenvelope(e, true, false);
3714 sm_rpool_free(rpool);
3716 e->e_message = NULL;
3724 ** DOWORKLIST -- process a list of envelopes as work requests
3726 ** Similar to dowork(), except that after forking, it processes an
3727 ** envelope and its siblings, treating each envelope as a work request.
3730 ** el -- envelope to be processed including its siblings.
3731 ** forkflag -- if set, run this in background.
3732 ** requeueflag -- if set, reinstantiate the queue quickly.
3733 ** This is used when expanding aliases in the queue.
3734 ** If forkflag is also set, it doesn't wait for the
3738 ** process id of process that is running the queue job.
3741 ** The work request is satisfied if possible.
3745 doworklist(el, forkflag, requeueflag)
3754 sm_dprintf("doworklist()\n");
3763 ** Since the delivery may happen in a child and the
3764 ** parent does not wait, the parent may close the
3765 ** maps thereby removing any shared memory used by
3766 ** the map. Therefore, close the maps now so the
3767 ** child will dynamically open them if necessary.
3775 syserr("doworklist: cannot fork");
3780 /* parent -- clean out connection cache */
3781 mci_flush(false, NULL);
3786 ** Initialize exception stack and default exception
3787 ** handler for child process.
3790 /* Reset global flags */
3791 RestartRequest = NULL;
3792 RestartWorkGroup = false;
3793 ShutdownRequest = NULL;
3795 CurrentPid = getpid();
3796 sm_exc_newthread(fatal_error);
3799 ** See note above about SMTP processes and SIGCHLD.
3802 if (OpMode == MD_SMTP ||
3803 OpMode == MD_DAEMON ||
3804 MaxQueueChildren > 0)
3807 sm_releasesignal(SIGCHLD);
3808 (void) sm_signal(SIGCHLD, SIG_DFL);
3811 /* child -- error messages to the transcript */
3812 QuickAbort = OnlyOneError = false;
3825 ** Lock the control file to avoid duplicate deliveries.
3826 ** Then run the file as though we had just read it.
3827 ** We save an idea of the temporary name so we
3828 ** can recover on interrupt.
3833 /* Reset global flags */
3834 RestartRequest = NULL;
3835 RestartWorkGroup = false;
3836 ShutdownRequest = NULL;
3840 /* set basic modes, etc. */
3843 GrabTo = UseErrorsTo = false;
3848 set_op_mode(MD_QUEUERUN);
3851 sm_syslog(LOG_DEBUG, el->e_id, "doworklist, pid=%d",
3854 for (ei = el; ei != NULL; ei = ei->e_sibling)
3859 if (WILL_BE_QUEUED(ei->e_sendmode))
3861 else if (QueueMode != QM_QUARANTINE &&
3862 ei->e_quarmsg != NULL)
3865 rpool = sm_rpool_new_x(NULL);
3866 clearenvelope(&e, true, rpool);
3867 e.e_flags |= EF_QUEUERUN|EF_GLOBALERRS;
3868 set_delivery_mode(SM_DELIVER, &e);
3869 e.e_errormode = EM_MAIL;
3871 e.e_qgrp = ei->e_qgrp;
3872 e.e_qdir = ei->e_qdir;
3874 sm_setproctitle(true, &e, "%s from queue", qid_printname(&e));
3876 /* don't use the headers from sendmail.cf... */
3880 /* read the queue control file -- return if locked */
3881 if (readqf(&e, false))
3883 e.e_flags |= EF_INQUEUE;
3884 eatheader(&e, requeueflag, true);
3887 queueup(&e, false, false);
3889 /* do the delivery */
3890 sendall(&e, SM_DELIVER);
3891 (void) dropenvelope(&e, true, false);
3895 if (tTd(40, 4) && e.e_id != NULL)
3896 sm_dprintf("readqf(%s) failed\n",
3899 sm_rpool_free(rpool);
3903 /* restore CurEnv */
3906 /* finish up and exit */
3908 finis(true, true, ExitStat);
3912 ** READQF -- read queue file and set up environment.
3915 ** e -- the envelope of the job to run.
3916 ** openonly -- only open the qf (returned as e_lockfp)
3919 ** true if it successfully read the queue file.
3923 ** The queue file is returned locked.
3928 register ENVELOPE *e;
3931 register SM_FILE_T *qfp;
3933 struct stat st, stf;
3940 bool nomore = false;
3944 char qf[MAXPATHLEN];
3949 ** Read and process the file.
3952 SM_REQUIRE(e != NULL);
3954 (void) sm_strlcpy(qf, queuename(e, ANYQFL_LETTER), sizeof(qf));
3955 qfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, qf, SM_IO_RDWR_B, NULL);
3958 int save_errno = errno;
3961 sm_dprintf("readqf(%s): sm_io_open failure (%s)\n",
3962 qf, sm_errstring(errno));
3966 syserr("readqf: no control file %s", qf);
3971 if (!lockfile(sm_io_getinfo(qfp, SM_IO_WHAT_FD, NULL), qf, NULL,
3974 /* being processed by another queuer */
3976 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
3977 "%s: locked\n", e->e_id);
3979 sm_dprintf("%s: locked\n", e->e_id);
3981 sm_syslog(LOG_DEBUG, e->e_id, "locked");
3982 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
3990 ** Prevent locking race condition.
3992 ** Process A: readqf(): qfp = fopen(qffile)
3993 ** Process B: queueup(): rename(tf, qf)
3994 ** Process B: unlocks(tf)
3995 ** Process A: lockfile(qf);
3997 ** Process A (us) has the old qf file (before the rename deleted
3998 ** the directory entry) and will be delivering based on old data.
3999 ** This can lead to multiple deliveries of the same recipients.
4001 ** Catch this by checking if the underlying qf file has changed
4002 ** *after* acquiring our lock and if so, act as though the file
4003 ** was still locked (i.e., just return like the lockfile() case
4007 if (stat(qf, &stf) < 0 ||
4008 fstat(sm_io_getinfo(qfp, SM_IO_WHAT_FD, NULL), &st) < 0)
4010 /* must have been being processed by someone else */
4012 sm_dprintf("readqf(%s): [f]stat failure (%s)\n",
4013 qf, sm_errstring(errno));
4014 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4018 if (st.st_nlink != stf.st_nlink ||
4019 st.st_dev != stf.st_dev ||
4020 ST_INODE(st) != ST_INODE(stf) ||
4021 #if HAS_ST_GEN && 0 /* AFS returns garbage in st_gen */
4022 st.st_gen != stf.st_gen ||
4023 #endif /* HAS_ST_GEN && 0 */
4024 st.st_uid != stf.st_uid ||
4025 st.st_gid != stf.st_gid ||
4026 st.st_size != stf.st_size)
4028 /* changed after opened */
4030 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4031 "%s: changed\n", e->e_id);
4033 sm_dprintf("%s: changed\n", e->e_id);
4035 sm_syslog(LOG_DEBUG, e->e_id, "changed");
4036 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4041 ** Check the queue file for plausibility to avoid attacks.
4044 qsafe = S_IWOTH|S_IWGRP;
4045 if (bitset(S_IWGRP, QueueFileMode))
4048 bogus = st.st_uid != geteuid() &&
4049 st.st_uid != TrustedUid &&
4050 geteuid() != RealUid;
4053 ** If this qf file results from a set-group-ID binary, then
4054 ** we check whether the directory is group-writable,
4055 ** the queue file mode contains the group-writable bit, and
4056 ** the groups are the same.
4057 ** Notice: this requires that the set-group-ID binary is used to
4061 if (bogus && st.st_gid == getegid() && UseMSP)
4066 bp = SM_LAST_DIR_DELIM(qf);
4074 if (stat(delim == '\0' ? "." : qf, &dst) < 0)
4075 syserr("readqf: cannot stat directory %s",
4076 delim == '\0' ? "." : qf);
4079 bogus = !(bitset(S_IWGRP, QueueFileMode) &&
4080 bitset(S_IWGRP, dst.st_mode) &&
4081 dst.st_gid == st.st_gid);
4088 bogus = bitset(qsafe, st.st_mode);
4093 sm_syslog(LOG_ALERT, e->e_id,
4094 "bogus queue file, uid=%ld, gid=%ld, mode=%o",
4095 (long) st.st_uid, (long) st.st_gid,
4096 (unsigned int) st.st_mode);
4099 sm_dprintf("readqf(%s): bogus file\n", qf);
4100 e->e_flags |= EF_INQUEUE;
4102 loseqfile(e, "bogus file uid/gid in mqueue");
4103 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4107 if (st.st_size == 0)
4109 /* must be a bogus file -- if also old, just remove it */
4110 if (!openonly && st.st_ctime + 10 * 60 < curtime())
4112 (void) xunlink(queuename(e, DATAFL_LETTER));
4113 (void) xunlink(queuename(e, ANYQFL_LETTER));
4115 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4119 if (st.st_nlink == 0)
4122 ** Race condition -- we got a file just as it was being
4123 ** unlinked. Just assume it is zero length.
4126 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4132 ** If we don't own the file mark it as unsafe.
4133 ** However, allow TrustedUser to own it as well
4134 ** in case TrustedUser manipulates the queue.
4137 if (st.st_uid != geteuid() && st.st_uid != TrustedUid)
4138 e->e_flags |= EF_UNSAFE;
4139 #else /* _FFR_TRUSTED_QF */
4140 /* If we don't own the file mark it as unsafe */
4141 if (st.st_uid != geteuid())
4142 e->e_flags |= EF_UNSAFE;
4143 #endif /* _FFR_TRUSTED_QF */
4145 /* good file -- save this lock */
4148 /* Just wanted the open file */
4152 /* do basic system initialization */
4154 macdefine(&e->e_macro, A_PERM, 'i', e->e_id);
4157 e->e_flags |= EF_GLOBALERRS;
4158 set_op_mode(MD_QUEUERUN);
4160 e->e_qfletter = queue_letter(e, ANYQFL_LETTER);
4161 e->e_dfqgrp = e->e_qgrp;
4162 e->e_dfqdir = e->e_qdir;
4163 #if _FFR_QUEUE_MACRO
4164 macdefine(&e->e_macro, A_TEMP, macid("{queue}"),
4165 qid_printqueue(e->e_qgrp, e->e_qdir));
4166 #endif /* _FFR_QUEUE_MACRO */
4169 while (bufsize = sizeof(buf),
4170 (bp = fgetfolded(buf, &bufsize, qfp)) != NULL)
4172 unsigned long qflags;
4179 sm_dprintf("+++++ %s\n", bp);
4184 syserr("SECURITY ALERT: extra or bogus data in queue file: %s",
4186 err = "bogus queue line";
4191 case 'A': /* AUTH= parameter */
4192 if (!xtextok(&bp[1]))
4194 e->e_auth_param = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4197 case 'B': /* body type */
4198 r = check_bodytype(&bp[1]);
4199 if (!BODYTYPE_VALID(r))
4201 e->e_bodytype = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4204 case 'C': /* specify controlling user */
4205 ctladdr = setctluser(&bp[1], qfver, e);
4208 case 'D': /* data file name */
4209 /* obsolete -- ignore */
4212 case 'd': /* data file directory name */
4216 #if _FFR_MSP_PARANOIA
4217 /* forbid queue groups in MSP? */
4220 #endif /* _FFR_MSP_PARANOIA */
4222 qgrp < NumQueue && Queue[qgrp] != NULL;
4226 qdir < Queue[qgrp]->qg_numqueues;
4230 Queue[qgrp]->qg_qpaths[qdir].qp_name)
4239 err = "bogus queue file directory";
4245 case 'E': /* specify error recipient */
4246 /* no longer used */
4249 case 'F': /* flag bits */
4250 if (strncmp(bp, "From ", 5) == 0)
4252 /* we are being spoofed! */
4253 syserr("SECURITY ALERT: bogus qf line %s", bp);
4254 err = "bogus queue line";
4257 for (p = &bp[1]; *p != '\0'; p++)
4261 case '8': /* has 8 bit data */
4262 e->e_flags |= EF_HAS8BIT;
4265 case 'b': /* delete Bcc: header */
4266 e->e_flags |= EF_DELETE_BCC;
4269 case 'd': /* envelope has DSN RET= */
4270 e->e_flags |= EF_RET_PARAM;
4273 case 'n': /* don't return body */
4274 e->e_flags |= EF_NO_BODY_RETN;
4277 case 'r': /* response */
4278 e->e_flags |= EF_RESPONSE;
4281 case 's': /* split */
4282 e->e_flags |= EF_SPLIT;
4285 case 'w': /* warning sent */
4286 e->e_flags |= EF_WARNING;
4292 case 'q': /* quarantine reason */
4293 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4294 macdefine(&e->e_macro, A_PERM,
4295 macid("{quarantine}"), e->e_quarmsg);
4298 case 'H': /* header */
4301 ** count size before chompheader() destroys the line.
4302 ** this isn't accurate due to macro expansion, but
4303 ** better than before. "-3" to skip H?? at least.
4306 hdrsize += strlen(bp) - 3;
4307 (void) chompheader(&bp[1], CHHDR_QUEUE, NULL, e);
4310 case 'I': /* data file's inode number */
4311 /* regenerated below */
4314 case 'K': /* time of last delivery attempt */
4315 e->e_dtime = atol(&buf[1]);
4318 case 'L': /* Solaris Content-Length: */
4319 case 'M': /* message */
4320 /* ignore this; we want a new message next time */
4323 case 'N': /* number of delivery attempts */
4324 e->e_ntries = atoi(&buf[1]);
4326 /* if this has been tried recently, let it be */
4328 if (e->e_ntries > 0 && e->e_dtime <= now &&
4329 now < e->e_dtime + MinQueueAge)
4333 howlong = pintvl(now - e->e_dtime, true);
4335 (void) sm_io_fprintf(smioout,
4337 "%s: too young (%s)\n",
4340 sm_dprintf("%s: too young (%s)\n",
4343 sm_syslog(LOG_DEBUG, e->e_id,
4352 macdefine(&e->e_macro, A_TEMP,
4353 macid("{ntries}"), &buf[1]);
4356 /* adjust BIND parameters immediately */
4357 if (e->e_ntries == 0)
4359 _res.retry = TimeOuts.res_retry[RES_TO_FIRST];
4360 _res.retrans = TimeOuts.res_retrans[RES_TO_FIRST];
4364 _res.retry = TimeOuts.res_retry[RES_TO_NORMAL];
4365 _res.retrans = TimeOuts.res_retrans[RES_TO_NORMAL];
4367 #endif /* NAMED_BIND */
4370 case 'P': /* message priority */
4371 e->e_msgpriority = atol(&bp[1]) + WkTimeFact;
4374 case 'Q': /* original recipient */
4375 orcpt = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4378 case 'r': /* final recipient */
4379 frcpt = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4382 case 'R': /* specify recipient */
4388 while (*++p != '\0' && *p != ':')
4393 qflags |= QHASNOTIFY;
4397 qflags |= QPINGONSUCCESS;
4401 qflags |= QPINGONFAILURE;
4405 qflags |= QPINGONDELAY;
4413 if (ctladdr != NULL)
4414 ctladdr->q_flags |= QALIAS;
4422 qflags |= QDYNMAILER;
4425 default: /* ignore or complain? */
4432 macdefine(&e->e_macro, A_PERM, macid("{addr_type}"),
4433 ((qflags & QINTBCC) != 0) ? "e b" : "e r");
4435 q = parseaddr(++p, NULLADDR, RF_COPYALL, '\0',
4441 /* make sure we keep the current qgrp */
4442 if (ISVALIDQGRP(e->e_qgrp))
4443 q->q_qgrp = e->e_qgrp;
4444 q->q_alias = ctladdr;
4446 q->q_flags &= ~Q_PINGFLAGS;
4447 q->q_flags |= qflags;
4448 q->q_finalrcpt = frcpt;
4451 if (bitset(QDYNMAILER, qflags))
4452 newmodmailer(q, QDYNMAILFLG);
4454 (void) recipient(q, &e->e_sendqueue, 0, e);
4458 macdefine(&e->e_macro, A_PERM, macid("{addr_type}"),
4462 case 'S': /* sender */
4463 setsender(sm_rpool_strdup_x(e->e_rpool, &bp[1]),
4464 e, NULL, '\0', true);
4467 case 'T': /* init time */
4468 e->e_ctime = atol(&bp[1]);
4471 case 'V': /* queue file version number */
4472 qfver = atoi(&bp[1]);
4473 if (qfver <= QF_VERSION)
4475 syserr("Version number in queue file (%d) greater than max (%d)",
4477 err = "unsupported queue file version";
4482 case 'Z': /* original envelope id from ESMTP */
4483 e->e_envid = sm_rpool_strdup_x(e->e_rpool, &bp[1]);
4484 macdefine(&e->e_macro, A_PERM,
4485 macid("{dsn_envid}"), e->e_envid);
4488 case '!': /* deliver by */
4490 /* format: flag (1 char) space long-integer */
4491 e->e_dlvr_flag = buf[1];
4492 e->e_deliver_by = strtol(&buf[3], NULL, 10);
4494 case '$': /* define macro */
4498 /* XXX elimate p? */
4499 r = macid_parse(&bp[1], &ep);
4502 p = sm_rpool_strdup_x(e->e_rpool, ep);
4503 macdefine(&e->e_macro, A_PERM, r, p);
4507 case '.': /* terminate file */
4512 syserr("readqf: %s: line %d: bad line \"%s\"",
4513 qf, LineNumber, shortenstring(bp, MAXSHORTSTR));
4514 err = "unrecognized line";
4523 ** If we haven't read any lines, this queue file is empty.
4524 ** Arrange to remove it without referencing any null pointers.
4527 if (LineNumber == 0)
4530 e->e_flags |= EF_CLRQUEUE|EF_FATALERRS|EF_RESPONSE;
4534 /* Check to make sure we have a complete queue file read */
4537 syserr("readqf: %s: incomplete queue file read", qf);
4538 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4542 #if _FFR_QF_PARANOIA
4543 /* Check to make sure key fields were read */
4544 if (e->e_from.q_mailer == NULL)
4546 syserr("readqf: %s: sender not specified in queue file", qf);
4547 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4551 #endif /* _FFR_QF_PARANOIA */
4553 /* possibly set ${dsn_ret} macro */
4554 if (bitset(EF_RET_PARAM, e->e_flags))
4556 if (bitset(EF_NO_BODY_RETN, e->e_flags))
4557 macdefine(&e->e_macro, A_PERM,
4558 macid("{dsn_ret}"), "hdrs");
4560 macdefine(&e->e_macro, A_PERM,
4561 macid("{dsn_ret}"), "full");
4565 ** Arrange to read the data file.
4568 p = queuename(e, DATAFL_LETTER);
4569 e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, p, SM_IO_RDONLY_B,
4571 if (e->e_dfp == NULL)
4573 syserr("readqf: cannot open %s", p);
4577 e->e_flags |= EF_HAS_DF;
4578 if (fstat(sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL), &st)
4581 e->e_msgsize = st.st_size + hdrsize;
4582 e->e_dfdev = st.st_dev;
4583 e->e_dfino = ST_INODE(st);
4584 (void) sm_snprintf(buf, sizeof(buf), "%ld",
4585 PRT_NONNEGL(e->e_msgsize));
4586 macdefine(&e->e_macro, A_TEMP, macid("{msg_size}"),
4595 ** There was some error reading the qf file (reason is in err var.)
4597 ** close file; clear e_lockfp since it is the same as qfp,
4598 ** hence it is invalid (as file) after qfp is closed;
4599 ** the qf file is on disk, so set the flag to avoid calling
4600 ** queueup() with bogus data.
4606 (void) sm_io_close(qfp, SM_TIME_DEFAULT);
4608 e->e_flags |= EF_INQUEUE;
4613 ** PRTSTR -- print a string, "unprintable" characters are shown as \oct
4616 ** s -- string to print
4617 ** ml -- maximum length of output
4620 ** number of entries
4623 ** Prints a string on stdout.
4626 static void prtstr __P((char *, int));
4628 #if _FFR_BOUNCE_QUEUE
4629 # define SKIP_BOUNCE_QUEUE \
4630 if (i == BounceQueue) \
4633 # define SKIP_BOUNCE_QUEUE
4645 while (ml-- > 0 && ((c = *s++) != '\0'))
4651 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, c);
4652 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, c);
4655 else if (isascii(c) && isprint(c))
4656 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, c);
4660 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4661 "\\%03o", c & 0xFF);
4666 ** PRINTNQE -- print out number of entries in the mail queue
4669 ** out -- output file pointer.
4670 ** prefix -- string to output in front of each line.
4677 printnqe(out, prefix)
4682 int i, k = 0, nrequests = 0;
4683 bool unknown = false;
4685 if (ShmId == SM_SHM_NO_ID)
4688 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4689 "Data unavailable: shared memory not updated\n");
4691 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4692 "%sNOTCONFIGURED:-1\r\n", prefix);
4695 for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
4701 for (j = 0; j < Queue[i]->qg_numqueues; j++)
4708 n = QSHM_ENTRIES(Queue[i]->qg_qpaths[j].qp_idx);
4710 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4712 prefix, qid_printqueue(i, j), n);
4715 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4716 "%s: unknown number of entries\n",
4717 qid_printqueue(i, j));
4722 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4724 qid_printqueue(i, j));
4728 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4730 qid_printqueue(i, j), n);
4736 if (prefix == NULL && k > 1)
4737 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4738 "\t\tTotal requests: %d%s\n",
4739 nrequests, unknown ? " (about)" : "");
4740 #else /* SM_CONF_SHM */
4742 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4743 "Data unavailable without shared memory support\n");
4745 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
4746 "%sNOTAVAILABLE:-1\r\n", prefix);
4747 #endif /* SM_CONF_SHM */
4750 ** PRINTQUEUE -- print out a representation of the mail queue
4759 ** Prints a listing of the mail queue on the standard output.
4765 int i, k = 0, nrequests = 0;
4767 for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
4772 for (j = 0; j < Queue[i]->qg_numqueues; j++)
4776 nrequests += print_single_queue(i, j);
4781 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4782 "\t\tTotal requests: %d\n",
4786 ** PRINT_SINGLE_QUEUE -- print out a representation of a single mail queue
4789 ** qgrp -- the index of the queue group.
4790 ** qdir -- the queue directory.
4793 ** number of requests in mail queue.
4796 ** Prints a listing of the mail queue on the standard output.
4800 print_single_queue(qgrp, qdir)
4807 char qd[MAXPATHLEN];
4808 char qddf[MAXPATHLEN];
4813 (void) sm_strlcpy(qd, ".", sizeof(qd));
4814 (void) sm_strlcpy(qddf, ".", sizeof(qddf));
4818 (void) sm_strlcpyn(qd, sizeof(qd), 2,
4819 Queue[qgrp]->qg_qpaths[qdir].qp_name,
4821 Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
4823 (void) sm_strlcpyn(qddf, sizeof(qddf), 2,
4824 Queue[qgrp]->qg_qpaths[qdir].qp_name,
4826 Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
4831 ** Check for permission to print the queue
4834 if (bitset(PRIV_RESTRICTMAILQ, PrivacyFlags) && RealUid != 0)
4839 extern GIDSET_T InitialGidSet[NGROUPS_MAX];
4840 #endif /* NGROUPS_MAX */
4842 if (stat(qd, &st) < 0)
4844 syserr("Cannot stat %s",
4845 qid_printqueue(qgrp, qdir));
4852 if (InitialGidSet[n] == st.st_gid)
4855 if (n < 0 && RealGid != st.st_gid)
4856 #else /* NGROUPS_MAX */
4857 if (RealGid != st.st_gid)
4858 #endif /* NGROUPS_MAX */
4860 usrerr("510 You are not permitted to see the queue");
4867 ** Read and order the queue.
4870 nrequests = gatherq(qgrp, qdir, true, NULL, NULL, NULL);
4871 (void) sortq(Queue[qgrp]->qg_maxlist);
4874 ** Print the work list that we have read.
4877 /* first see if there is anything */
4880 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%s is empty\n",
4881 qid_printqueue(qgrp, qdir));
4885 sm_getla(); /* get load average */
4887 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "\t\t%s (%d request%s",
4888 qid_printqueue(qgrp, qdir),
4889 nrequests, nrequests == 1 ? "" : "s");
4890 if (MaxQueueRun > 0 && nrequests > MaxQueueRun)
4891 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4892 ", only %d printed", MaxQueueRun);
4894 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4895 ")\n-----Q-ID----- --Size-- -Priority- ---Q-Time--- --------Sender/Recipient--------\n");
4897 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4898 ")\n-----Q-ID----- --Size-- -----Q-Time----- ------------Sender/Recipient-----------\n");
4899 for (w = WorkQ; w != NULL; w = w->w_next)
4902 auto time_t submittime = 0;
4906 char quarmsg[MAXLINE];
4907 char statmsg[MAXLINE];
4908 char bodytype[MAXNAME + 1];
4909 char qf[MAXPATHLEN];
4914 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%13s",
4916 (void) sm_strlcpyn(qf, sizeof(qf), 3, qd, "/", w->w_name);
4917 f = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, qf, SM_IO_RDONLY_B,
4922 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4923 " (permission denied)\n");
4924 else if (errno == ENOENT)
4925 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4926 " (job completed)\n");
4928 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
4930 sm_errstring(errno));
4934 w->w_name[0] = DATAFL_LETTER;
4935 (void) sm_strlcpyn(qf, sizeof(qf), 3, qddf, "/", w->w_name);
4936 if (stat(qf, &st) >= 0)
4937 dfsize = st.st_size;
4943 ** Maybe the df file can't be statted because
4944 ** it is in a different directory than the qf file.
4945 ** In order to find out, we must read the qf file.
4948 newenvelope(&e, &BlankEnvelope, sm_rpool_new_x(NULL));
4949 e.e_id = w->w_name + 2;
4953 if (readqf(&e, false))
4955 char *df = queuename(&e, DATAFL_LETTER);
4956 if (stat(df, &st) >= 0)
4957 dfsize = st.st_size;
4959 if (e.e_lockfp != NULL)
4961 (void) sm_io_close(e.e_lockfp, SM_TIME_DEFAULT);
4964 clearenvelope(&e, false, e.e_rpool);
4965 sm_rpool_free(e.e_rpool);
4968 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "*");
4969 else if (QueueMode == QM_LOST)
4970 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "?");
4971 else if (w->w_tooyoung)
4972 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "-");
4973 else if (shouldqueue(w->w_pri, w->w_ctime))
4974 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "X");
4976 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, " ");
4981 statmsg[0] = bodytype[0] = '\0';
4983 while (sm_io_fgets(f, SM_TIME_DEFAULT, buf, sizeof(buf)) >= 0)
4994 case 'V': /* queue file version */
4995 qfver = atoi(&buf[1]);
4998 case 'M': /* error message */
4999 if ((i = strlen(&buf[1])) >= sizeof(statmsg))
5000 i = sizeof(statmsg) - 1;
5001 memmove(statmsg, &buf[1], i);
5005 case 'q': /* quarantine reason */
5006 if ((i = strlen(&buf[1])) >= sizeof(quarmsg))
5007 i = sizeof(quarmsg) - 1;
5008 memmove(quarmsg, &buf[1], i);
5012 case 'B': /* body type */
5013 if ((i = strlen(&buf[1])) >= sizeof(bodytype))
5014 i = sizeof(bodytype) - 1;
5015 memmove(bodytype, &buf[1], i);
5019 case 'S': /* sender name */
5022 (void) sm_io_fprintf(smioout,
5024 "%8ld %10ld%c%.12s ",
5027 bitset(EF_WARNING, flags)
5029 ctime(&submittime) + 4);
5030 prtstr(&buf[1], 78);
5034 (void) sm_io_fprintf(smioout,
5038 ctime(&submittime));
5039 prtstr(&buf[1], 39);
5042 if (quarmsg[0] != '\0')
5044 (void) sm_io_fprintf(smioout,
5046 "\n QUARANTINE: %.*s",
5052 if (statmsg[0] != '\0' || bodytype[0] != '\0')
5054 (void) sm_io_fprintf(smioout,
5058 if (statmsg[0] != '\0')
5059 (void) sm_io_fprintf(smioout,
5068 case 'C': /* controlling user */
5070 (void) sm_io_fprintf(smioout,
5072 "\n\t\t\t\t\t\t(---%.64s---)",
5076 case 'R': /* recipient name */
5087 (void) sm_io_fprintf(smioout,
5094 (void) sm_io_fprintf(smioout,
5099 if (Verbose && statmsg[0] != '\0')
5101 (void) sm_io_fprintf(smioout,
5109 case 'T': /* creation time */
5110 submittime = atol(&buf[1]);
5113 case 'F': /* flag bits */
5114 for (p = &buf[1]; *p != '\0'; p++)
5119 flags |= EF_WARNING;
5125 if (submittime == (time_t) 0)
5126 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
5127 " (no control file)");
5128 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "\n");
5129 (void) sm_io_close(f, SM_TIME_DEFAULT);
5135 ** QUEUE_LETTER -- get the proper queue letter for the current QueueMode.
5138 ** e -- envelope to build it in/from.
5139 ** type -- the file type, used as the first character
5140 ** of the file name.
5143 ** the letter to use
5147 queue_letter(e, type)
5151 /* Change type according to QueueMode */
5152 if (type == ANYQFL_LETTER)
5154 if (e->e_quarmsg != NULL)
5155 type = QUARQF_LETTER;
5161 type = NORMQF_LETTER;
5165 type = QUARQF_LETTER;
5169 type = LOSEQF_LETTER;
5173 /* should never happen */
5183 ** QUEUENAME -- build a file name in the queue directory for this envelope.
5186 ** e -- envelope to build it in/from.
5187 ** type -- the file type, used as the first character
5188 ** of the file name.
5191 ** a pointer to the queue name (in a static buffer).
5194 ** If no id code is already assigned, queuename() will
5195 ** assign an id code with assign_queueid(). If no queue
5196 ** directory is assigned, one will be set with setnewqueue().
5201 register ENVELOPE *e;
5207 static char buf[MAXPATHLEN];
5209 /* Assign an ID if needed */
5210 if (e->e_id == NULL)
5216 type = queue_letter(e, type);
5218 /* begin of filename */
5219 pref[0] = (char) type;
5223 /* Assign a queue group/directory if needed */
5224 if (type == XSCRPT_LETTER)
5227 ** We don't want to call setnewqueue() if we are fetching
5228 ** the pathname of the transcript file, because setnewqueue
5229 ** chooses a queue, and sometimes we need to write to the
5230 ** transcript file before we have gathered enough information
5231 ** to choose a queue.
5234 if (e->e_xfqgrp == NOQGRP || e->e_xfqdir == NOQDIR)
5236 if (e->e_qgrp != NOQGRP && e->e_qdir != NOQDIR)
5238 e->e_xfqgrp = e->e_qgrp;
5239 e->e_xfqdir = e->e_qdir;
5244 if (Queue[e->e_xfqgrp]->qg_numqueues <= 1)
5248 e->e_xfqdir = get_rand_mod(
5249 Queue[e->e_xfqgrp]->qg_numqueues);
5258 if (e->e_qgrp == NOQGRP || e->e_qdir == NOQDIR)
5262 (void) setnewqueue(e);
5264 if (type == DATAFL_LETTER)
5276 /* xf files always have a valid qd and qg picked above */
5277 if ((qd == NOQDIR || qg == NOQGRP) && type != XSCRPT_LETTER)
5278 (void) sm_strlcpyn(buf, sizeof(buf), 2, pref, e->e_id);
5284 if (bitset(QP_SUBDF, Queue[qg]->qg_qpaths[qd].qp_subdirs))
5293 if (bitset(QP_SUBQF, Queue[qg]->qg_qpaths[qd].qp_subdirs))
5298 if (bitset(QP_SUBXF, Queue[qg]->qg_qpaths[qd].qp_subdirs))
5305 sm_abort("queuename: bad queue file type %d", type);
5308 (void) sm_strlcpyn(buf, sizeof(buf), 4,
5309 Queue[qg]->qg_qpaths[qd].qp_name,
5310 sub, pref, e->e_id);
5314 sm_dprintf("queuename: %s\n", buf);
5319 ** INIT_QID_ALG -- Initialize the (static) parameters that are used to
5320 ** generate a queue ID.
5322 ** This function is called by the daemon to reset
5323 ** LastQueueTime and LastQueuePid which are used by assign_queueid().
5324 ** Otherwise the algorithm may cause problems because
5325 ** LastQueueTime and LastQueuePid are set indirectly by main()
5326 ** before the daemon process is started, hence LastQueuePid is not
5327 ** the pid of the daemon and therefore a child of the daemon can
5328 ** actually have the same pid as LastQueuePid which means the section
5329 ** in assign_queueid():
5330 ** * see if we need to get a new base time/pid *
5331 ** is NOT triggered which will cause the same queue id to be generated.
5348 ** ASSIGN_QUEUEID -- assign a queue ID for this envelope.
5350 ** Assigns an id code if one does not already exist.
5351 ** This code assumes that nothing will remain in the queue for
5352 ** longer than 60 years. It is critical that files with the given
5353 ** name do not already exist in the queue.
5354 ** [No longer initializes e_qdir to NOQDIR.]
5357 ** e -- envelope to set it in.
5363 static const char QueueIdChars[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
5365 # define QIC_LEN_R 62
5368 ** Note: the length is "officially" 60 because minutes and seconds are
5369 ** usually only 0-59. However (Linux):
5370 ** tm_sec The number of seconds after the minute, normally in
5371 ** the range 0 to 59, but can be up to 61 to allow for
5373 ** Hence the real length of the string is 62 to take this into account.
5374 ** Alternatively % QIC_LEN can (should) be used for access everywhere.
5377 # define queuenextid() CurrentPid
5378 #define QIC_LEN_SQR (QIC_LEN * QIC_LEN)
5382 register ENVELOPE *e;
5384 pid_t pid = queuenextid();
5385 static unsigned int cX = 0;
5386 static unsigned int random_offset;
5388 char idbuf[MAXQFNAME - 2];
5391 if (e->e_id != NULL)
5394 /* see if we need to get a new base time/pid */
5395 if (cX >= QIC_LEN_SQR || LastQueueTime == 0 || LastQueuePid != pid)
5397 time_t then = LastQueueTime;
5399 /* if the first time through, pick a random offset */
5400 if (LastQueueTime == 0)
5401 random_offset = ((unsigned int)get_random())
5404 while ((LastQueueTime = curtime()) == then &&
5405 LastQueuePid == pid)
5409 LastQueuePid = queuenextid();
5414 ** Generate a new sequence number between 0 and QIC_LEN_SQR-1.
5415 ** This lets us generate up to QIC_LEN_SQR unique queue ids
5416 ** per second, per process. With envelope splitting,
5417 ** a single message can consume many queue ids.
5420 seq = (cX + random_offset) % QIC_LEN_SQR;
5423 sm_dprintf("assign_queueid: random_offset=%u (%u)\n",
5424 random_offset, seq);
5426 tm = gmtime(&LastQueueTime);
5427 idbuf[0] = QueueIdChars[tm->tm_year % QIC_LEN];
5428 idbuf[1] = QueueIdChars[tm->tm_mon];
5429 idbuf[2] = QueueIdChars[tm->tm_mday];
5430 idbuf[3] = QueueIdChars[tm->tm_hour];
5431 idbuf[4] = QueueIdChars[tm->tm_min % QIC_LEN_R];
5432 idbuf[5] = QueueIdChars[tm->tm_sec % QIC_LEN_R];
5433 idbuf[6] = QueueIdChars[seq / QIC_LEN];
5434 idbuf[7] = QueueIdChars[seq % QIC_LEN];
5435 (void) sm_snprintf(&idbuf[8], sizeof(idbuf) - 8, "%06d",
5436 (int) LastQueuePid);
5437 e->e_id = sm_rpool_strdup_x(e->e_rpool, idbuf);
5438 macdefine(&e->e_macro, A_PERM, 'i', e->e_id);
5440 /* XXX: inherited from MainEnvelope */
5441 e->e_qgrp = NOQGRP; /* too early to do anything else */
5443 e->e_xfqgrp = NOQGRP;
5446 /* New ID means it's not on disk yet */
5447 e->e_qfletter = '\0';
5450 sm_dprintf("assign_queueid: assigned id %s, e=%p\n",
5453 sm_syslog(LOG_DEBUG, e->e_id, "assigned id");
5456 ** SYNC_QUEUE_TIME -- Assure exclusive PID in any given second
5458 ** Make sure one PID can't be used by two processes in any one second.
5460 ** If the system rotates PIDs fast enough, may get the
5461 ** same pid in the same second for two distinct processes.
5462 ** This will interfere with the queue file naming system.
5474 #if FAST_PID_RECYCLE
5475 if (OpMode != MD_TEST &&
5476 OpMode != MD_CHECKCONFIG &&
5477 OpMode != MD_VERIFY &&
5478 LastQueueTime > 0 &&
5479 LastQueuePid == CurrentPid &&
5480 curtime() == LastQueueTime)
5482 #endif /* FAST_PID_RECYCLE */
5485 ** UNLOCKQUEUE -- unlock the queue entry for a specified envelope
5488 ** e -- the envelope to unlock.
5494 ** unlocks the queue for `e'.
5502 sm_dprintf("unlockqueue(%s)\n",
5503 e->e_id == NULL ? "NOQUEUE" : e->e_id);
5506 /* if there is a lock file in the envelope, close it */
5507 if (e->e_lockfp != NULL)
5508 (void) sm_io_close(e->e_lockfp, SM_TIME_DEFAULT);
5511 /* don't create a queue id if we don't already have one */
5512 if (e->e_id == NULL)
5515 /* remove the transcript */
5517 sm_syslog(LOG_DEBUG, e->e_id, "unlock");
5519 (void) xunlink(queuename(e, XSCRPT_LETTER));
5522 ** SETCTLUSER -- create a controlling address
5524 ** Create a fake "address" given only a local login name; this is
5525 ** used as a "controlling user" for future recipient addresses.
5528 ** user -- the user name of the controlling user.
5529 ** qfver -- the version stamp of this queue file.
5533 ** An address descriptor for the controlling user,
5534 ** using storage allocated from e->e_rpool.
5539 setctluser(user, qfver, e)
5544 register ADDRESS *a;
5549 ** See if this clears our concept of controlling user.
5552 if (user == NULL || *user == '\0')
5556 ** Set up addr fields for controlling user.
5559 a = (ADDRESS *) sm_rpool_malloc_x(e->e_rpool, sizeof(*a));
5560 memset((char *) a, '\0', sizeof(*a));
5565 a->q_user = sm_rpool_strdup_x(e->e_rpool, p);
5569 p = strtok(user, ":");
5570 a->q_user = sm_rpool_strdup_x(e->e_rpool, user);
5573 if ((p = strtok(NULL, ":")) != NULL)
5575 if ((p = strtok(NULL, ":")) != NULL)
5577 if ((p = strtok(NULL, ":")) != NULL)
5581 a->q_flags |= QGOODUID;
5583 /* if there is another ':': restore it */
5584 if ((o = strtok(NULL, ":")) != NULL && o > p)
5588 else if ((pw = sm_getpwnam(user)) != NULL)
5590 if (*pw->pw_dir == '\0')
5592 else if (strcmp(pw->pw_dir, "/") == 0)
5595 a->q_home = sm_rpool_strdup_x(e->e_rpool, pw->pw_dir);
5596 a->q_uid = pw->pw_uid;
5597 a->q_gid = pw->pw_gid;
5598 a->q_flags |= QGOODUID;
5602 a->q_flags |= QPRIMARY; /* flag as a "ctladdr" */
5603 a->q_mailer = LocalMailer;
5605 a->q_paddr = sm_rpool_strdup_x(e->e_rpool, a->q_user);
5607 a->q_paddr = sm_rpool_strdup_x(e->e_rpool, p);
5611 ** LOSEQFILE -- rename queue file with LOSEQF_LETTER & try to let someone know
5614 ** e -- the envelope (e->e_id will be used).
5615 ** why -- reported to whomever can hear.
5623 register ENVELOPE *e;
5628 char buf[MAXPATHLEN];
5630 if (e == NULL || e->e_id == NULL)
5632 p = queuename(e, ANYQFL_LETTER);
5633 if (sm_strlcpy(buf, p, sizeof(buf)) >= sizeof(buf))
5635 if (!bitset(EF_INQUEUE, e->e_flags))
5636 queueup(e, false, true);
5637 else if (QueueMode == QM_LOST)
5640 /* if already lost, no need to re-lose */
5643 p = queuename(e, LOSEQF_LETTER);
5644 if (rename(buf, p) < 0)
5645 syserr("cannot rename(%s, %s), uid=%ld",
5646 buf, p, (long) geteuid());
5647 else if (LogLevel > 0)
5648 sm_syslog(LOG_ALERT, e->e_id,
5649 "Losing %s: %s", buf, why);
5651 if (e->e_dfp != NULL)
5653 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT);
5656 e->e_flags &= ~EF_HAS_DF;
5659 ** NAME2QID -- translate a queue group name to a queue group id
5662 ** queuename -- name of queue group.
5665 ** queue group id if found.
5666 ** NOQGRP otherwise.
5675 s = stab(queuename, ST_QUEUE, ST_FIND);
5678 return s->s_quegrp->qg_index;
5681 ** QID_PRINTNAME -- create externally printable version of queue id
5684 ** e -- the envelope.
5687 ** a printable version
5695 static char idbuf[MAXQFNAME + 34];
5700 if (e->e_id == NULL)
5705 if (e->e_qdir == NOQDIR)
5708 (void) sm_snprintf(idbuf, sizeof(idbuf), "%.32s/%s",
5709 Queue[e->e_qgrp]->qg_qpaths[e->e_qdir].qp_name,
5714 ** QID_PRINTQUEUE -- create full version of queue directory for data files
5717 ** qgrp -- index in queue group.
5718 ** qdir -- the short version of the queue directory
5721 ** the full pathname to the queue (might point to a static var)
5725 qid_printqueue(qgrp, qdir)
5730 static char dir[MAXPATHLEN];
5733 return Queue[qgrp]->qg_qdir;
5735 if (strcmp(Queue[qgrp]->qg_qpaths[qdir].qp_name, ".") == 0)
5738 subdir = Queue[qgrp]->qg_qpaths[qdir].qp_name;
5740 (void) sm_strlcpyn(dir, sizeof(dir), 4,
5741 Queue[qgrp]->qg_qdir,
5742 subdir == NULL ? "" : "/",
5743 subdir == NULL ? "" : subdir,
5745 Queue[qgrp]->qg_qpaths[qdir].qp_subdirs)
5751 ** PICKQDIR -- Pick a queue directory from a queue group
5754 ** qg -- queue group
5755 ** fsize -- file size in bytes
5756 ** e -- envelope, or NULL
5759 ** NOQDIR if no queue directory in qg has enough free space to
5760 ** hold a file of size 'fsize', otherwise the index of
5761 ** a randomly selected queue directory which resides on a
5762 ** file system with enough disk space.
5763 ** XXX This could be extended to select a queuedir with
5764 ** a few (the fewest?) number of entries. That data
5765 ** is available if shared memory is used.
5768 ** If the request fails and e != NULL then sm_syslog is called.
5772 pickqdir(qg, fsize, e)
5781 /* Pick a random directory, as a starting point. */
5782 if (qg->qg_numqueues <= 1)
5785 qdir = get_rand_mod(qg->qg_numqueues);
5790 #endif /* _FFR_TESTS */
5791 if (MinBlocksFree <= 0 && fsize <= 0)
5795 ** Now iterate over the queue directories,
5796 ** looking for a directory with enough space for this message.
5802 QPATHS *qp = &qg->qg_qpaths[i];
5807 needed += fsize / FILE_SYS_BLKSIZE(qp->qp_fsysidx)
5808 + ((fsize % FILE_SYS_BLKSIZE(qp->qp_fsysidx)
5810 if (MinBlocksFree > 0)
5811 needed += MinBlocksFree;
5812 fsavail = FILE_SYS_AVAIL(qp->qp_fsysidx);
5819 ** might be not correctly updated,
5820 ** let's try to get the info directly.
5823 fsavail = freediskspace(FILE_SYS_NAME(qp->qp_fsysidx),
5828 #endif /* SM_CONF_SHM */
5829 if (needed <= fsavail)
5831 if (avail < fsavail)
5834 if (qg->qg_numqueues > 0)
5835 i = (i + 1) % qg->qg_numqueues;
5836 } while (i != qdir);
5838 if (e != NULL && LogLevel > 0)
5839 sm_syslog(LOG_ALERT, e->e_id,
5840 "low on space (%s needs %ld bytes + %ld blocks in %s), max avail: %ld",
5841 CurHostName == NULL ? "SMTP-DAEMON" : CurHostName,
5842 fsize, MinBlocksFree,
5843 qg->qg_qdir, avail);
5847 ** SETNEWQUEUE -- Sets a new queue group and directory
5849 ** Assign a queue group and directory to an envelope and store the
5850 ** directory in e->e_qdir.
5853 ** e -- envelope to assign a queue for.
5856 ** true if successful
5860 ** On success, e->e_qgrp and e->e_qdir are non-negative.
5861 ** On failure (not enough disk space),
5862 ** e->qgrp = NOQGRP, e->e_qdir = NOQDIR
5863 ** and usrerr() is invoked (which could raise an exception).
5871 sm_dprintf("setnewqueue: called\n");
5873 /* not set somewhere else */
5874 if (e->e_qgrp == NOQGRP)
5879 ** Use the queue group of the "first" recipient, as set by
5880 ** the "queuegroup" rule set. If that is not defined, then
5881 ** use the queue group of the mailer of the first recipient.
5882 ** If that is not defined either, then use the default
5884 ** Notice: "first" depends on the sorting of sendqueue
5886 ** To avoid problems with "bad" recipients look
5887 ** for a valid address first.
5892 (QS_IS_BADADDR(q->q_state) || QS_IS_DEAD(q->q_state)))
5898 else if (q->q_qgrp >= 0)
5899 e->e_qgrp = q->q_qgrp;
5900 else if (q->q_mailer != NULL &&
5901 ISVALIDQGRP(q->q_mailer->m_qgrp))
5902 e->e_qgrp = q->q_mailer->m_qgrp;
5905 e->e_dfqgrp = e->e_qgrp;
5908 if (ISVALIDQDIR(e->e_qdir) && ISVALIDQDIR(e->e_dfqdir))
5911 sm_dprintf("setnewqueue: e_qdir already assigned (%s)\n",
5912 qid_printqueue(e->e_qgrp, e->e_qdir));
5917 e->e_qdir = pickqdir(Queue[e->e_qgrp], e->e_msgsize, e);
5918 if (e->e_qdir == NOQDIR)
5921 if (!bitset(EF_FATALERRS, e->e_flags))
5922 usrerr("452 4.4.5 Insufficient disk space; try again later");
5923 e->e_flags |= EF_FATALERRS;
5928 sm_dprintf("setnewqueue: Assigned queue directory %s\n",
5929 qid_printqueue(e->e_qgrp, e->e_qdir));
5931 if (e->e_xfqgrp == NOQGRP || e->e_xfqdir == NOQDIR)
5933 e->e_xfqgrp = e->e_qgrp;
5934 e->e_xfqdir = e->e_qdir;
5936 e->e_dfqdir = e->e_qdir;
5940 ** CHKQDIR -- check a queue directory
5943 ** name -- name of queue directory
5944 ** sff -- flags for safefile()
5947 ** is it a queue directory?
5950 static bool chkqdir __P((char *, long));
5960 /* skip over . and .. directories */
5961 if (name[0] == '.' &&
5962 (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')))
5965 if (lstat(name, &statb) < 0)
5966 #else /* HASLSTAT */
5967 if (stat(name, &statb) < 0)
5968 #endif /* HASLSTAT */
5971 sm_dprintf("chkqdir: stat(\"%s\"): %s\n",
5972 name, sm_errstring(errno));
5976 if (S_ISLNK(statb.st_mode))
5979 ** For a symlink we need to make sure the
5980 ** target is a directory
5983 if (stat(name, &statb) < 0)
5986 sm_dprintf("chkqdir: stat(\"%s\"): %s\n",
5987 name, sm_errstring(errno));
5991 #endif /* HASLSTAT */
5993 if (!S_ISDIR(statb.st_mode))
5996 sm_dprintf("chkqdir: \"%s\": Not a directory\n",
6001 /* Print a warning if unsafe (but still use it) */
6002 /* XXX do this only if we want the warning? */
6003 i = safedirpath(name, RunAsUid, RunAsGid, NULL, sff, 0, 0);
6007 sm_dprintf("chkqdir: \"%s\": Not safe: %s\n",
6008 name, sm_errstring(i));
6011 sm_syslog(LOG_WARNING, NOQID,
6012 "queue directory \"%s\": Not safe: %s",
6013 name, sm_errstring(i));
6014 #endif /* _FFR_CHK_QUEUE */
6019 ** MULTIQUEUE_CACHE -- cache a list of paths to queues.
6021 ** Each potential queue is checked as the cache is built.
6022 ** Thereafter, each is blindly trusted.
6023 ** Note that we can be called again after a timeout to rebuild
6024 ** (although code for that is not ready yet).
6027 ** basedir -- base of all queue directories.
6028 ** blen -- strlen(basedir).
6029 ** qg -- queue group.
6030 ** qn -- number of queue directories already cached.
6031 ** phash -- pointer to hash value over queue dirs.
6033 ** only used if shared memory is active.
6034 #endif * SM_CONF_SHM *
6037 ** new number of queue directories.
6040 #define INITIAL_SLOTS 20
6041 #define ADD_SLOTS 10
6044 multiqueue_cache(basedir, blen, qg, qn, phash)
6049 unsigned int *phash;
6054 long sff = SFF_ANYFILE;
6055 char qpath[MAXPATHLEN];
6056 char subdir[MAXPATHLEN];
6057 char prefix[MAXPATHLEN]; /* dir relative to basedir */
6060 sm_dprintf("multiqueue_cache: called\n");
6062 /* Initialize to current directory */
6065 if (qg->qg_numqueues != 0 && qg->qg_qpaths != NULL)
6067 for (i = 0; i < qg->qg_numqueues; i++)
6069 if (qg->qg_qpaths[i].qp_name != NULL)
6070 (void) sm_free(qg->qg_qpaths[i].qp_name); /* XXX */
6072 (void) sm_free((char *) qg->qg_qpaths); /* XXX */
6073 qg->qg_qpaths = NULL;
6074 qg->qg_numqueues = 0;
6077 /* If running as root, allow safedirpath() checks to use privs */
6081 sff |= SFF_SAFEDIRPATH|SFF_NOWWFILES;
6083 sff |= SFF_NOGWFILES;
6084 #endif /* _FFR_CHK_QUEUE */
6086 if (!SM_IS_DIR_START(qg->qg_qdir))
6089 ** XXX we could add basedir, but then we have to realloc()
6090 ** the string... Maybe another time.
6093 syserr("QueuePath %s not absolute", qg->qg_qdir);
6094 ExitStat = EX_CONFIG;
6098 /* qpath: directory of current workgroup */
6099 len = sm_strlcpy(qpath, qg->qg_qdir, sizeof(qpath));
6100 if (len >= sizeof(qpath))
6102 syserr("QueuePath %.256s too long (%d max)",
6103 qg->qg_qdir, (int) sizeof(qpath));
6104 ExitStat = EX_CONFIG;
6108 /* begin of qpath must be same as basedir */
6109 if (strncmp(basedir, qpath, blen) != 0 &&
6110 (strncmp(basedir, qpath, blen - 1) != 0 || len != blen - 1))
6112 syserr("QueuePath %s not subpath of QueueDirectory %s",
6114 ExitStat = EX_CONFIG;
6118 /* Do we have a nested subdirectory? */
6119 if (blen < len && SM_FIRST_DIR_DELIM(qg->qg_qdir + blen) != NULL)
6122 /* Copy subdirectory into prefix for later use */
6123 if (sm_strlcpy(prefix, qg->qg_qdir + blen, sizeof(prefix)) >=
6126 syserr("QueuePath %.256s too long (%d max)",
6127 qg->qg_qdir, (int) sizeof(qpath));
6128 ExitStat = EX_CONFIG;
6131 cp = SM_LAST_DIR_DELIM(prefix);
6132 SM_ASSERT(cp != NULL);
6133 *cp = '\0'; /* cut off trailing / */
6136 /* This is guaranteed by the basedir check above */
6137 SM_ASSERT(len >= blen - 1);
6138 cp = &qpath[len - 1];
6142 register struct dirent *d;
6145 char relpath[MAXPATHLEN];
6147 *cp = '\0'; /* Overwrite wildcard */
6148 if ((cp = SM_LAST_DIR_DELIM(qpath)) == NULL)
6150 syserr("QueueDirectory: can not wildcard relative path");
6152 sm_dprintf("multiqueue_cache: \"%s*\": Can not wildcard relative path.\n",
6154 ExitStat = EX_CONFIG;
6160 ** Special case of top level wildcard, like /foo*
6164 (void) sm_strlcpy(qpath + 1, qpath, sizeof(qpath) - 1);
6168 *(cp++) = '\0'; /* Replace / with \0 */
6169 len = strlen(cp); /* Last component of queue directory */
6172 ** Path relative to basedir, with trailing /
6173 ** It will be modified below to specify the subdirectories
6174 ** so they can be opened without chdir().
6177 off = sm_strlcpyn(relpath, sizeof(relpath), 2, prefix, "/");
6178 SM_ASSERT(off < sizeof(relpath));
6181 sm_dprintf("multiqueue_cache: prefix=\"%s%s\"\n",
6184 /* It is always basedir: we don't need to store it per group */
6185 /* XXX: optimize this! -> one more global? */
6186 qg->qg_qdir = newstr(basedir);
6187 qg->qg_qdir[blen - 1] = '\0'; /* cut off trailing / */
6190 ** XXX Should probably wrap this whole loop in a timeout
6191 ** in case some wag decides to NFS mount the queues.
6194 /* Test path to get warning messages. */
6197 /* XXX qg_runasuid and qg_runasgid for specials? */
6198 i = safedirpath(basedir, RunAsUid, RunAsGid, NULL,
6200 if (i != 0 && tTd(41, 2))
6201 sm_dprintf("multiqueue_cache: \"%s\": Not safe: %s\n",
6202 basedir, sm_errstring(i));
6205 if ((dp = opendir(prefix)) == NULL)
6207 syserr("can not opendir(%s/%s)", qg->qg_qdir, prefix);
6209 sm_dprintf("multiqueue_cache: opendir(\"%s/%s\"): %s\n",
6210 qg->qg_qdir, prefix,
6211 sm_errstring(errno));
6212 ExitStat = EX_CONFIG;
6215 while ((d = readdir(dp)) != NULL)
6217 /* Skip . and .. directories */
6218 if (strcmp(d->d_name, ".") == 0 ||
6219 strcmp(d->d_name, "..") == 0)
6222 i = strlen(d->d_name);
6223 if (i < len || strncmp(d->d_name, cp, len) != 0)
6226 sm_dprintf("multiqueue_cache: \"%s\", skipped\n",
6231 /* Create relative pathname: prefix + local directory */
6232 i = sizeof(relpath) - off;
6233 if (sm_strlcpy(relpath + off, d->d_name, i) >= i)
6234 continue; /* way too long */
6236 if (!chkqdir(relpath, sff))
6239 if (qg->qg_qpaths == NULL)
6241 slotsleft = INITIAL_SLOTS;
6242 qg->qg_qpaths = (QPATHS *)xalloc((sizeof(*qg->qg_qpaths)) *
6244 qg->qg_numqueues = 0;
6246 else if (slotsleft < 1)
6248 qg->qg_qpaths = (QPATHS *)sm_realloc((char *)qg->qg_qpaths,
6249 (sizeof(*qg->qg_qpaths)) *
6252 if (qg->qg_qpaths == NULL)
6254 (void) closedir(dp);
6257 slotsleft += ADD_SLOTS;
6261 qg->qg_qpaths[qg->qg_numqueues].qp_subdirs = QP_NOSUB;
6263 #define CHKRSUBDIR(name, flag) \
6264 (void) sm_strlcpyn(subdir, sizeof(subdir), 3, relpath, "/", name); \
6265 if (chkqdir(subdir, sff)) \
6266 qg->qg_qpaths[qg->qg_numqueues].qp_subdirs |= flag; \
6270 CHKRSUBDIR("qf", QP_SUBQF);
6271 CHKRSUBDIR("df", QP_SUBDF);
6272 CHKRSUBDIR("xf", QP_SUBXF);
6274 /* assert(strlen(d->d_name) < MAXPATHLEN - 14) */
6275 /* maybe even - 17 (subdirs) */
6277 if (prefix[0] != '.')
6278 qg->qg_qpaths[qg->qg_numqueues].qp_name =
6281 qg->qg_qpaths[qg->qg_numqueues].qp_name =
6285 sm_dprintf("multiqueue_cache: %d: \"%s\" cached (%x).\n",
6286 qg->qg_numqueues, relpath,
6287 qg->qg_qpaths[qg->qg_numqueues].qp_subdirs);
6289 qg->qg_qpaths[qg->qg_numqueues].qp_idx = qn;
6290 *phash = hash_q(relpath, *phash);
6291 #endif /* SM_CONF_SHM */
6296 (void) closedir(dp);
6301 if (qg->qg_numqueues == 0)
6303 qg->qg_qpaths = (QPATHS *) xalloc(sizeof(*qg->qg_qpaths));
6305 /* test path to get warning messages */
6306 i = safedirpath(qpath, RunAsUid, RunAsGid, NULL, sff, 0, 0);
6309 syserr("can not opendir(%s)", qpath);
6311 sm_dprintf("multiqueue_cache: opendir(\"%s\"): %s\n",
6312 qpath, sm_errstring(i));
6313 ExitStat = EX_CONFIG;
6317 qg->qg_qpaths[0].qp_subdirs = QP_NOSUB;
6318 qg->qg_numqueues = 1;
6321 #define CHKSUBDIR(name, flag) \
6322 (void) sm_strlcpyn(subdir, sizeof(subdir), 3, qg->qg_qdir, "/", name); \
6323 if (chkqdir(subdir, sff)) \
6324 qg->qg_qpaths[0].qp_subdirs |= flag; \
6327 CHKSUBDIR("qf", QP_SUBQF);
6328 CHKSUBDIR("df", QP_SUBDF);
6329 CHKSUBDIR("xf", QP_SUBXF);
6331 if (qg->qg_qdir[blen - 1] != '\0' &&
6332 qg->qg_qdir[blen] != '\0')
6335 ** Copy the last component into qpaths and
6339 qg->qg_qpaths[0].qp_name = newstr(qg->qg_qdir + blen);
6340 qg->qg_qdir[blen - 1] = '\0';
6343 qg->qg_qpaths[0].qp_name = newstr(".");
6346 qg->qg_qpaths[0].qp_idx = qn;
6347 *phash = hash_q(qg->qg_qpaths[0].qp_name, *phash);
6348 #endif /* SM_CONF_SHM */
6355 ** FILESYS_FIND -- find entry in FileSys table, or add new one
6357 ** Given the pathname of a directory, determine the file system
6358 ** in which that directory resides, and return a pointer to the
6359 ** entry in the FileSys table that describes the file system.
6360 ** A new entry is added if necessary (and requested).
6361 ** If the directory does not exist, -1 is returned.
6364 ** name -- name of directory (must be persistent!)
6365 ** path -- pathname of directory (name plus maybe "/df")
6366 ** add -- add to structure if not found.
6369 ** >=0: found: index in file system table
6370 ** <0: some error, i.e.,
6371 ** FSF_TOO_MANY: too many filesystems (-> syserr())
6372 ** FSF_STAT_FAIL: can't stat() filesystem (-> syserr())
6373 ** FSF_NOT_FOUND: not in list
6376 static short filesys_find __P((const char *, const char *, bool));
6378 #define FSF_NOT_FOUND (-1)
6379 #define FSF_STAT_FAIL (-2)
6380 #define FSF_TOO_MANY (-3)
6383 filesys_find(name, path, add)
6391 if (stat(path, &st) < 0)
6393 syserr("cannot stat queue directory %s", path);
6394 return FSF_STAT_FAIL;
6396 for (i = 0; i < NumFileSys; ++i)
6398 if (FILE_SYS_DEV(i) == st.st_dev)
6401 ** Make sure the file system (FS) name is set:
6402 ** even though the source code indicates that
6403 ** FILE_SYS_DEV() is only set below, it could be
6404 ** set via shared memory, hence we need to perform
6405 ** this check/assignment here.
6408 if (NULL == FILE_SYS_NAME(i))
6409 FILE_SYS_NAME(i) = name;
6413 if (i >= MAXFILESYS)
6415 syserr("too many queue file systems (%d max)", MAXFILESYS);
6416 return FSF_TOO_MANY;
6419 return FSF_NOT_FOUND;
6422 FILE_SYS_NAME(i) = name;
6423 FILE_SYS_DEV(i) = st.st_dev;
6424 FILE_SYS_AVAIL(i) = 0;
6425 FILE_SYS_BLKSIZE(i) = 1024; /* avoid divide by zero */
6430 ** FILESYS_SETUP -- set up mapping from queue directories to file systems
6432 ** This data structure is used to efficiently check the amount of
6433 ** free space available in a set of queue directories.
6436 ** add -- initialize structure if necessary.
6440 ** <0: some error, i.e.,
6441 ** FSF_NOT_FOUND: not in list
6442 ** FSF_STAT_FAIL: can't stat() filesystem (-> syserr())
6443 ** FSF_TOO_MANY: too many filesystems (-> syserr())
6446 static int filesys_setup __P((bool));
6457 for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
6459 for (j = 0; j < Queue[i]->qg_numqueues; ++j)
6461 QPATHS *qp = &Queue[i]->qg_qpaths[j];
6462 char qddf[MAXPATHLEN];
6464 (void) sm_strlcpyn(qddf, sizeof(qddf), 2, qp->qp_name,
6465 (bitset(QP_SUBDF, qp->qp_subdirs)
6467 fs = filesys_find(qp->qp_name, qddf, add);
6469 qp->qp_fsysidx = fs;
6480 ** FILESYS_UPDATE -- update amount of free space on all file systems
6482 ** The FileSys table is used to cache the amount of free space
6483 ** available on all queue directory file systems.
6484 ** This function updates the cached information if it has expired.
6493 ** Updates FileSys table.
6500 long avail, blksize;
6502 static time_t nextupdate = 0;
6506 ** Only the daemon updates the shared memory, i.e.,
6507 ** if shared memory is available but the pid is not the
6508 ** one of the daemon, then don't do anything.
6511 if (ShmId != SM_SHM_NO_ID && DaemonPid != CurrentPid)
6513 #endif /* SM_CONF_SHM */
6515 if (now < nextupdate)
6517 nextupdate = now + FILESYS_UPDATE_INTERVAL;
6518 for (i = 0; i < NumFileSys; ++i)
6520 FILESYS *fs = &FILE_SYS(i);
6522 avail = freediskspace(FILE_SYS_NAME(i), &blksize);
6523 if (avail < 0 || blksize <= 0)
6526 sm_syslog(LOG_ERR, NOQID,
6527 "filesys_update failed: %s, fs=%s, avail=%ld, blocksize=%ld",
6528 sm_errstring(errno),
6529 FILE_SYS_NAME(i), avail, blksize);
6531 fs->fs_blksize = 1024; /* avoid divide by zero */
6532 nextupdate = now + 2; /* let's do this soon again */
6536 fs->fs_avail = avail;
6537 fs->fs_blksize = blksize;
6542 #if _FFR_ANY_FREE_FS
6544 ** FILESYS_FREE -- check whether there is at least one fs with enough space.
6547 ** fsize -- file size in bytes
6550 ** true iff there is one fs with more than fsize bytes free.
6561 for (i = 0; i < NumFileSys; ++i)
6565 if (FILE_SYS_AVAIL(i) < 0 || FILE_SYS_BLKSIZE(i) <= 0)
6567 needed += fsize / FILE_SYS_BLKSIZE(i)
6568 + ((fsize % FILE_SYS_BLKSIZE(i)
6571 if (needed <= FILE_SYS_AVAIL(i))
6576 #endif /* _FFR_ANY_FREE_FS */
6579 ** DISK_STATUS -- show amount of free space in queue directories
6582 ** out -- output file pointer.
6583 ** prefix -- string to output in front of each line.
6590 disk_status(out, prefix)
6595 long avail, blksize;
6598 for (i = 0; i < NumFileSys; ++i)
6600 avail = freediskspace(FILE_SYS_NAME(i), &blksize);
6601 if (avail >= 0 && blksize > 0)
6603 free = (long)((double) avail *
6604 ((double) blksize / 1024));
6608 (void) sm_io_fprintf(out, SM_TIME_DEFAULT,
6619 ** INIT_SEM -- initialize semaphore system
6622 ** owner -- is this the owner of semaphores?
6628 #if _FFR_USE_SEM_LOCKING
6630 static int SemId = -1; /* Semaphore Id */
6631 int SemKey = SM_SEM_KEY;
6632 #endif /* SM_CONF_SEM */
6633 #endif /* _FFR_USE_SEM_LOCKING */
6635 static void init_sem __P((bool));
6641 #if _FFR_USE_SEM_LOCKING
6643 SemId = sm_sem_start(SemKey, 1, 0, owner);
6646 sm_syslog(LOG_ERR, NOQID,
6647 "func=init_sem, sem_key=%ld, sm_sem_start=%d, error=%s",
6648 (long) SemKey, SemId, sm_errstring(-SemId));
6651 if (owner && RunAsUid != 0)
6655 r = sm_semsetowner(SemId, RunAsUid, RunAsGid, 0660);
6657 sm_syslog(LOG_ERR, NOQID,
6658 "key=%ld, sm_semsetowner=%d, RunAsUid=%ld, RunAsGid=%ld",
6659 (long) SemKey, r, (long) RunAsUid, (long) RunAsGid);
6661 #endif /* SM_CONF_SEM */
6662 #endif /* _FFR_USE_SEM_LOCKING */
6667 ** STOP_SEM -- stop semaphore system
6670 ** owner -- is this the owner of semaphores?
6676 static void stop_sem __P((bool));
6682 #if _FFR_USE_SEM_LOCKING
6684 if (owner && SemId >= 0)
6686 #endif /* SM_CONF_SEM */
6687 #endif /* _FFR_USE_SEM_LOCKING */
6692 ** UPD_QS -- update information about queue when adding/deleting an entry
6696 ** count -- add/remove entry (+1/0/-1: add/no change/remove)
6697 ** space -- update the space available as well.
6698 ** (>0/0/<0: add/no change/remove)
6699 ** where -- caller (for logging)
6705 ** Modifies available space in filesystem.
6706 ** Changes number of entries in queue directory.
6710 upd_qs(e, count, space, where)
6718 # if _FFR_USE_SEM_LOCKING
6720 # endif /* _FFR_USE_SEM_LOCKING */
6723 if (ShmId == SM_SHM_NO_ID || e == NULL)
6725 if (e->e_qgrp == NOQGRP || e->e_qdir == NOQDIR)
6727 idx = Queue[e->e_qgrp]->qg_qpaths[e->e_qdir].qp_idx;
6729 sm_dprintf("func=upd_qs, count=%d, space=%d, where=%s, idx=%d, entries=%d\n",
6730 count, space, where, idx, QSHM_ENTRIES(idx));
6732 /* XXX in theory this needs to be protected with a mutex */
6733 if (QSHM_ENTRIES(idx) >= 0 && count != 0)
6735 # if _FFR_USE_SEM_LOCKING
6737 r = sm_sem_acq(SemId, 0, 1);
6738 # endif /* _FFR_USE_SEM_LOCKING */
6739 QSHM_ENTRIES(idx) += count;
6740 # if _FFR_USE_SEM_LOCKING
6741 if (SemId >= 0 && r >= 0)
6742 r = sm_sem_rel(SemId, 0, 1);
6743 # endif /* _FFR_USE_SEM_LOCKING */
6746 fidx = Queue[e->e_qgrp]->qg_qpaths[e->e_qdir].qp_fsysidx;
6750 /* update available space also? (might be loseqfile) */
6754 /* convert size to blocks; this causes rounding errors */
6755 s = e->e_msgsize / FILE_SYS_BLKSIZE(fidx);
6759 /* XXX in theory this needs to be protected with a mutex */
6761 FILE_SYS_AVAIL(fidx) += s;
6763 FILE_SYS_AVAIL(fidx) -= s;
6767 static bool write_key_file __P((char *, long));
6768 static long read_key_file __P((char *, long));
6771 ** WRITE_KEY_FILE -- record some key into a file.
6774 ** keypath -- file name.
6775 ** key -- key to write.
6778 ** true iff file could be written.
6785 write_key_file(keypath, key)
6794 if (keypath == NULL || *keypath == '\0')
6796 sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY|SFF_CREAT;
6797 if (TrustedUid != 0 && RealUid == TrustedUid)
6798 sff |= SFF_OPENASROOT;
6799 keyf = safefopen(keypath, O_WRONLY|O_TRUNC, FileMode, sff);
6802 sm_syslog(LOG_ERR, NOQID, "unable to write %s: %s",
6803 keypath, sm_errstring(errno));
6807 if (geteuid() == 0 && RunAsUid != 0)
6813 if (fd >= 0 && fchown(fd, RunAsUid, -1) < 0)
6817 sm_syslog(LOG_ALERT, NOQID,
6818 "ownership change on %s to %ld failed: %s",
6819 keypath, (long) RunAsUid, sm_errstring(err));
6821 # endif /* HASFCHOWN */
6823 ok = sm_io_fprintf(keyf, SM_TIME_DEFAULT, "%ld\n", key) !=
6825 ok = (sm_io_close(keyf, SM_TIME_DEFAULT) != SM_IO_EOF) && ok;
6831 ** READ_KEY_FILE -- read a key from a file.
6834 ** keypath -- file name.
6835 ** key -- default key.
6842 read_key_file(keypath, key)
6850 if (keypath == NULL || *keypath == '\0')
6852 sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY;
6853 if (RealUid == 0 || (TrustedUid != 0 && RealUid == TrustedUid))
6854 sff |= SFF_OPENASROOT;
6855 keyf = safefopen(keypath, O_RDONLY, FileMode, sff);
6858 sm_syslog(LOG_ERR, NOQID, "unable to read %s: %s",
6859 keypath, sm_errstring(errno));
6863 r = sm_io_fscanf(keyf, SM_TIME_DEFAULT, "%ld", &n);
6866 (void) sm_io_close(keyf, SM_TIME_DEFAULT);
6872 ** INIT_SHM -- initialize shared memory structure
6874 ** Initialize or attach to shared memory segment.
6875 ** Currently it is not a fatal error if this doesn't work.
6876 ** However, it causes us to have a "fallback" storage location
6877 ** for everything that is supposed to be in the shared memory,
6878 ** which makes the code slightly ugly.
6881 ** qn -- number of queue directories.
6882 ** owner -- owner of shared memory.
6883 ** hash -- identifies data that is stored in shared memory.
6889 static void init_shm __P((int, bool, unsigned int));
6892 init_shm(qn, owner, hash)
6902 PtrFileSys = &FileSys[0];
6903 PNumFileSys = &Numfilesys;
6904 /* if this "key" is specified: select one yourself */
6905 #define SEL_SHM_KEY ((key_t) -1)
6906 #define FIRST_SHM_KEY 25
6908 /* This allows us to disable shared memory at runtime. */
6913 shms = SM_T_SIZE + qn * sizeof(QUEUE_SHM_T);
6914 keyselect = ShmKey == SEL_SHM_KEY;
6918 ShmKey = FIRST_SHM_KEY;
6922 ShmKey = read_key_file(ShmKeyFile, ShmKey);
6924 if (ShmKey == SEL_SHM_KEY)
6926 save_errno = (errno != 0) ? errno : EINVAL;
6933 /* allow read/write access for group? */
6934 Pshm = sm_shmstart(ShmKey, shms,
6935 SHM_R|SHM_W|(SHM_R>>3)|(SHM_W>>3),
6938 if (Pshm != NULL || !sm_file_exists(save_errno))
6946 /* back where we started? */
6947 if (ShmKey == SEL_SHM_KEY)
6954 /* only sleep if we are at the first key */
6955 if (!keyselect || ShmKey == SEL_SHM_KEY)
6963 (void) write_key_file(ShmKeyFile, (long) ShmKey);
6964 if (owner && RunAsUid != 0)
6966 i = sm_shmsetowner(ShmId, RunAsUid, RunAsGid, 0660);
6968 sm_syslog(LOG_ERR, NOQID,
6969 "key=%ld, sm_shmsetowner=%d, RunAsUid=%ld, RunAsGid=%ld",
6970 (long) ShmKey, i, (long) RunAsUid, (long) RunAsGid);
6976 *((pid_t *) SHM_OFF_PID(Pshm)) = CurrentPid;
6977 p = (int *) SHM_OFF_TAG(Pshm);
6982 if (*p != (int) shms)
6984 save_errno = EINVAL;
6988 p = (int *) SHM_OFF_TAG(Pshm);
6989 if (*p != (int) hash)
6991 save_errno = EINVAL;
6997 ** XXX how to check the pid?
6998 ** Read it from the pid-file? That does
6999 ** not need to exist.
7000 ** We could disable shm if we can't confirm
7001 ** that it is the right one.
7005 PtrFileSys = (FILESYS *) OFF_FILE_SYS(Pshm);
7006 PNumFileSys = (int *) OFF_NUM_FILE_SYS(Pshm);
7007 QShm = (QUEUE_SHM_T *) OFF_QUEUE_SHM(Pshm);
7008 PRSATmpCnt = (int *) OFF_RSA_TMP_CNT(Pshm);
7012 /* initialize values in shared memory */
7014 for (i = 0; i < qn; i++)
7015 QShm[i].qs_entries = -1;
7021 if (LogLevel > (owner ? 8 : 11))
7023 sm_syslog(owner ? LOG_ERR : LOG_NOTICE, NOQID,
7024 "can't %s shared memory, key=%ld: %s",
7025 owner ? "initialize" : "attach to",
7026 (long) ShmKey, sm_errstring(save_errno));
7029 #endif /* SM_CONF_SHM */
7033 ** SETUP_QUEUES -- set up all queue groups
7036 ** owner -- owner of shared memory?
7043 ** attaches shared memory.
7044 #endif * SM_CONF_SHM *
7052 unsigned int hashval;
7054 char basedir[MAXPATHLEN];
7058 ** Determine basedir for all queue directories.
7059 ** All queue directories must be (first level) subdirectories
7060 ** of the basedir. The basedir is the QueueDir
7061 ** without wildcards, but with trailing /
7066 len = sm_strlcpy(basedir, QueueDir, sizeof(basedir));
7068 /* Provide space for trailing '/' */
7069 if (len >= sizeof(basedir) - 1)
7071 syserr("QueueDirectory: path too long: %d, max %d",
7072 len, (int) sizeof(basedir) - 1);
7073 ExitStat = EX_CONFIG;
7077 if (basedir[len - 1] == '*')
7081 cp = SM_LAST_DIR_DELIM(basedir);
7084 syserr("QueueDirectory: can not wildcard relative path \"%s\"",
7087 sm_dprintf("setup_queues: \"%s\": Can not wildcard relative path.\n",
7089 ExitStat = EX_CONFIG;
7093 /* cut off wildcard pattern */
7097 else if (!SM_IS_DIR_DELIM(basedir[len - 1]))
7099 /* append trailing slash since it is a directory */
7101 basedir[++len] = '\0';
7104 /* len counts up to the last directory delimiter */
7105 SM_ASSERT(basedir[len - 1] == '/');
7107 if (chdir(basedir) < 0)
7109 int save_errno = errno;
7111 syserr("can not chdir(%s)", basedir);
7112 if (save_errno == EACCES)
7113 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
7114 "Program mode requires special privileges, e.g., root or TrustedUser.\n");
7116 sm_dprintf("setup_queues: \"%s\": %s\n",
7117 basedir, sm_errstring(errno));
7118 ExitStat = EX_CONFIG;
7122 hashval = hash_q(basedir, hashval);
7123 #endif /* SM_CONF_SHM */
7125 /* initialize for queue runs */
7128 for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
7129 Queue[i]->qg_nextrun = now;
7132 if (UseMSP && OpMode != MD_TEST)
7134 long sff = SFF_CREAT;
7136 if (stat(".", &st) < 0)
7138 syserr("can not stat(%s)", basedir);
7140 sm_dprintf("setup_queues: \"%s\": %s\n",
7141 basedir, sm_errstring(errno));
7142 ExitStat = EX_CONFIG;
7149 ** Check queue directory permissions.
7150 ** Can we write to a group writable queue directory?
7153 if (bitset(S_IWGRP, QueueFileMode) &&
7154 bitset(S_IWGRP, st.st_mode) &&
7155 safefile(" ", RunAsUid, RunAsGid, RunAsUserName, sff,
7156 QueueFileMode, NULL) != 0)
7158 syserr("can not write to queue directory %s (RunAsGid=%ld, required=%ld)",
7159 basedir, (long) RunAsGid, (long) st.st_gid);
7161 if (bitset(S_IWOTH|S_IXOTH, st.st_mode))
7163 #if _FFR_MSP_PARANOIA
7164 syserr("dangerous permissions=%o on queue directory %s",
7165 (unsigned int) st.st_mode, basedir);
7166 #else /* _FFR_MSP_PARANOIA */
7168 sm_syslog(LOG_ERR, NOQID,
7169 "dangerous permissions=%o on queue directory %s",
7170 (unsigned int) st.st_mode, basedir);
7171 #endif /* _FFR_MSP_PARANOIA */
7173 #if _FFR_MSP_PARANOIA
7175 syserr("can not use multiple queues for MSP");
7176 #endif /* _FFR_MSP_PARANOIA */
7179 /* initial number of queue directories */
7181 for (i = 0; i < NumQueue && Queue[i] != NULL; i++)
7182 qn = multiqueue_cache(basedir, len, Queue[i], qn, &hashval);
7185 init_shm(qn, owner, hashval);
7186 i = filesys_setup(owner || ShmId == SM_SHM_NO_ID);
7187 if (i == FSF_NOT_FOUND)
7190 ** We didn't get the right filesystem data
7191 ** This may happen if we don't have the right shared memory.
7192 ** So let's do this without shared memory.
7196 cleanup_shm(false); /* release shared memory */
7197 i = filesys_setup(false);
7199 syserr("filesys_setup failed twice, result=%d", i);
7200 else if (LogLevel > 8)
7201 sm_syslog(LOG_WARNING, NOQID,
7202 "shared memory does not contain expected data, ignored");
7204 #else /* SM_CONF_SHM */
7205 i = filesys_setup(true);
7206 #endif /* SM_CONF_SHM */
7208 ExitStat = EX_CONFIG;
7213 ** CLEANUP_SHM -- do some cleanup work for shared memory etc
7216 ** owner -- owner of shared memory?
7222 ** detaches shared memory.
7229 if (ShmId != SM_SHM_NO_ID)
7231 if (sm_shmstop(Pshm, ShmId, owner) < 0 && LogLevel > 8)
7232 sm_syslog(LOG_INFO, NOQID, "sm_shmstop failed=%s",
7233 sm_errstring(errno));
7235 ShmId = SM_SHM_NO_ID;
7239 #endif /* SM_CONF_SHM */
7242 ** CLEANUP_QUEUES -- do some cleanup work for queues
7258 ** SET_DEF_QUEUEVAL -- set default values for a queue group.
7261 ** qg -- queue group
7262 ** all -- set all values (true for default group)?
7268 ** sets default values for the queue group.
7272 set_def_queueval(qg, all)
7276 if (bitnset(QD_DEFINED, qg->qg_flags))
7279 qg->qg_qdir = QueueDir;
7280 #if _FFR_QUEUE_GROUP_SORTORDER
7281 qg->qg_sortorder = QueueSortOrder;
7282 #endif /* _FFR_QUEUE_GROUP_SORTORDER */
7283 qg->qg_maxqrun = all ? MaxRunnersPerQueue : -1;
7284 qg->qg_nice = NiceQueueRun;
7287 ** MAKEQUEUE -- define a new queue.
7290 ** line -- description of queue. This is in labeled fields.
7292 ** F -- the flags associated with the queue
7293 ** I -- the interval between running the queue
7294 ** J -- the maximum # of jobs in work list
7295 ** [M -- the maximum # of jobs in a queue run]
7296 ** N -- the niceness at which to run
7297 ** P -- the path to the queue
7298 ** S -- the queue sorting order
7299 ** R -- number of parallel queue runners
7300 ** r -- max recipients per envelope
7301 ** The first word is the canonical name of the queue.
7302 ** qdef -- this is a 'Q' definition from .cf
7308 ** enters the queue into the queue table.
7312 makequeue(line, qdef)
7317 register QUEUEGRP *qg;
7322 /* allocate a queue and set up defaults */
7323 qg = (QUEUEGRP *) xalloc(sizeof(*qg));
7324 memset((char *) qg, '\0', sizeof(*qg));
7326 if (line[0] == '\0')
7328 syserr("name required for queue");
7332 /* collect the queue name */
7334 *p != '\0' && *p != ',' && !(isascii(*p) && isspace(*p));
7339 qg->qg_name = newstr(line);
7341 /* set default values, can be overridden below */
7342 set_def_queueval(qg, false);
7344 /* now scan through and assign info from the fields */
7347 auto char *delimptr;
7349 while (*p != '\0' &&
7350 (*p == ',' || (isascii(*p) && isspace(*p))))
7353 /* p now points to field code */
7355 while (*p != '\0' && *p != '=' && *p != ',')
7359 syserr("queue %s: `=' expected", qg->qg_name);
7362 while (isascii(*p) && isspace(*p))
7365 /* p now points to the field body */
7366 p = munchstring(p, &delimptr, ',');
7368 /* install the field into the queue struct */
7371 case 'P': /* pathname */
7373 syserr("queue %s: empty path name",
7376 qg->qg_qdir = newstr(p);
7379 case 'F': /* flags */
7380 for (; *p != '\0'; p++)
7381 if (!(isascii(*p) && isspace(*p)))
7382 setbitn(*p, qg->qg_flags);
7386 ** Do we need two intervals here:
7387 ** One for persistent queue runners,
7388 ** one for "normal" queue runs?
7391 case 'I': /* interval between running the queue */
7392 qg->qg_queueintvl = convtime(p, 'm');
7395 case 'N': /* run niceness */
7396 qg->qg_nice = atoi(p);
7399 case 'R': /* maximum # of runners for the group */
7402 /* can't have more runners than allowed total */
7403 if (MaxQueueChildren > 0 && i > MaxQueueChildren)
7405 qg->qg_maxqrun = MaxQueueChildren;
7406 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
7407 "Q=%s: R=%d exceeds MaxQueueChildren=%d, set to MaxQueueChildren\n",
7415 case 'J': /* maximum # of jobs in work list */
7416 qg->qg_maxlist = atoi(p);
7419 case 'r': /* max recipients per envelope */
7420 qg->qg_maxrcpt = atoi(p);
7423 #if _FFR_QUEUE_GROUP_SORTORDER
7424 case 'S': /* queue sorting order */
7427 case 'h': /* Host first */
7429 qg->qg_sortorder = QSO_BYHOST;
7432 case 'p': /* Priority order */
7434 qg->qg_sortorder = QSO_BYPRIORITY;
7437 case 't': /* Submission time */
7439 qg->qg_sortorder = QSO_BYTIME;
7442 case 'f': /* File name */
7444 qg->qg_sortorder = QSO_BYFILENAME;
7447 case 'm': /* Modification time */
7449 qg->qg_sortorder = QSO_BYMODTIME;
7452 case 'r': /* Random */
7454 qg->qg_sortorder = QSO_RANDOM;
7458 case 's': /* Shuffled host name */
7460 qg->qg_sortorder = QSO_BYSHUFFLE;
7462 # endif /* _FFR_RHS */
7464 case 'n': /* none */
7466 qg->qg_sortorder = QSO_NONE;
7470 syserr("Invalid queue sort order \"%s\"", p);
7473 #endif /* _FFR_QUEUE_GROUP_SORTORDER */
7476 syserr("Q%s: unknown queue equate %c=",
7477 qg->qg_name, fcode);
7485 if (qg->qg_nice != NiceQueueRun)
7487 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
7488 "Q%s: Warning: N= set on system that doesn't support nice()\n",
7491 #endif /* !HASNICE */
7493 /* do some rationality checking */
7494 if (NumQueue >= MAXQUEUEGROUPS)
7496 syserr("too many queue groups defined (%d max)",
7501 if (qg->qg_qdir == NULL)
7503 if (QueueDir == NULL || *QueueDir == '\0')
7505 syserr("QueueDir must be defined before queue groups");
7508 qg->qg_qdir = newstr(QueueDir);
7511 if (qg->qg_maxqrun > 1 && !bitnset(QD_FORK, qg->qg_flags))
7513 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
7514 "Warning: Q=%s: R=%d: multiple queue runners specified\n\tbut flag '%c' is not set\n",
7515 qg->qg_name, qg->qg_maxqrun, QD_FORK);
7518 /* enter the queue into the symbol table */
7520 sm_syslog(LOG_INFO, NOQID,
7521 "Adding %s to stab, path: %s", qg->qg_name,
7523 s = stab(qg->qg_name, ST_QUEUE, ST_ENTER);
7524 if (s->s_quegrp != NULL)
7526 i = s->s_quegrp->qg_index;
7528 /* XXX what about the pointers inside this struct? */
7529 sm_free(s->s_quegrp); /* XXX */
7533 Queue[i] = s->s_quegrp = qg;
7536 /* set default value for max queue runners */
7537 if (qg->qg_maxqrun < 0)
7539 if (MaxRunnersPerQueue > 0)
7540 qg->qg_maxqrun = MaxRunnersPerQueue;
7545 setbitn(QD_DEFINED, qg->qg_flags);
7549 ** HASHFQN -- calculate a hash value for a fully qualified host name
7552 ** fqn -- an all lower-case host.domain string
7553 ** buckets -- the number of buckets (queue directories)
7556 ** a bucket number (signed integer)
7559 ** Contributed by Exactis.com, Inc.
7563 hashfqn(fqn, buckets)
7568 register int h = 0, hash, cnt;
7574 ** A variation on the gdb hash
7575 ** This is the best as of Feb 19, 1996 --bcx
7579 h = 0x238F13AF * strlen(p);
7580 for (cnt = 0; *p != 0; ++p, cnt++)
7582 h = (h + (*p << (cnt * 5 % 24))) & 0x7FFFFFFF;
7584 h = (1103515243 * h + 12345) & 0x7FFFFFFF;
7588 hash = (h % buckets);
7595 ** A structure for sorting Queue according to maxqrun without
7596 ** screwing up Queue itself.
7601 int sg_idx; /* original index */
7602 int sg_maxqrun; /* max queue runners */
7604 typedef struct sortqgrp SORTQGRP_T;
7605 static int cmpidx __P((const void *, const void *));
7612 /* The sort is highest to lowest, so the comparison is reversed */
7613 if (((SORTQGRP_T *)a)->sg_maxqrun < ((SORTQGRP_T *)b)->sg_maxqrun)
7615 else if (((SORTQGRP_T *)a)->sg_maxqrun > ((SORTQGRP_T *)b)->sg_maxqrun)
7622 ** MAKEWORKGROUPS -- balance queue groups into work groups per MaxQueueChildren
7624 ** Take the now defined queue groups and assign them to work groups.
7625 ** This is done to balance out the number of concurrently active
7626 ** queue runners such that MaxQueueChildren is not exceeded. This may
7627 ** result in more than one queue group per work group. In such a case
7628 ** the number of running queue groups in that work group will have no
7629 ** more than the work group maximum number of runners (a "fair" portion
7630 ** of MaxQueueRunners). All queue groups within a work group will get a
7631 ** chance at running.
7640 ** Sets up WorkGrp structure.
7646 int i, j, total_runners, dir, h;
7647 SORTQGRP_T si[MAXQUEUEGROUPS + 1];
7650 if (NumQueue == 1 && strcmp(Queue[0]->qg_name, "mqueue") == 0)
7653 ** There is only the "mqueue" queue group (a default)
7654 ** containing all of the queues. We want to provide to
7655 ** this queue group the maximum allowable queue runners.
7656 ** To match older behavior (8.10/8.11) we'll try for
7657 ** 1 runner per queue capping it at MaxQueueChildren.
7658 ** So if there are N queues, then there will be N runners
7659 ** for the "mqueue" queue group (where N is kept less than
7660 ** MaxQueueChildren).
7664 WorkGrp[0].wg_numqgrp = 1;
7665 WorkGrp[0].wg_qgs = (QUEUEGRP **) xalloc(sizeof(QUEUEGRP *));
7666 WorkGrp[0].wg_qgs[0] = Queue[0];
7667 if (MaxQueueChildren > 0 &&
7668 Queue[0]->qg_numqueues > MaxQueueChildren)
7669 WorkGrp[0].wg_runners = MaxQueueChildren;
7671 WorkGrp[0].wg_runners = Queue[0]->qg_numqueues;
7673 Queue[0]->qg_wgrp = 0;
7675 /* can't have more runners than allowed total */
7676 if (MaxQueueChildren > 0 &&
7677 Queue[0]->qg_maxqrun > MaxQueueChildren)
7678 Queue[0]->qg_maxqrun = MaxQueueChildren;
7679 WorkGrp[0].wg_maxact = Queue[0]->qg_maxqrun;
7680 WorkGrp[0].wg_lowqintvl = Queue[0]->qg_queueintvl;
7684 for (i = 0; i < NumQueue; i++)
7686 si[i].sg_maxqrun = Queue[i]->qg_maxqrun;
7689 qsort(si, NumQueue, sizeof(si[0]), cmpidx);
7692 for (i = 0; i < NumQueue; i++)
7695 total_runners += si[i].sg_maxqrun;
7696 if (MaxQueueChildren <= 0 || total_runners <= MaxQueueChildren)
7702 if (NumWorkGroups < 1)
7703 NumWorkGroups = 1; /* gotta have one at least */
7704 else if (NumWorkGroups > MAXWORKGROUPS)
7705 NumWorkGroups = MAXWORKGROUPS; /* the limit */
7708 ** We now know the number of work groups to pack the queue groups
7709 ** into. The queue groups in 'Queue' are sorted from highest
7710 ** to lowest for the number of runners per queue group.
7711 ** We put the queue groups with the largest number of runners
7712 ** into work groups first. Then the smaller ones are fitted in
7713 ** where it looks best.
7718 for (i = 0; i < NumQueue; i++)
7722 /* a to-and-fro packing scheme, continue from last position */
7723 if (j >= NumWorkGroups)
7726 j = NumWorkGroups - 1;
7734 if (WorkGrp[j].wg_qgs == NULL)
7735 WorkGrp[j].wg_qgs = (QUEUEGRP **)sm_malloc(sizeof(QUEUEGRP *) *
7736 (WorkGrp[j].wg_numqgrp + 1));
7738 WorkGrp[j].wg_qgs = (QUEUEGRP **)sm_realloc(WorkGrp[j].wg_qgs,
7739 sizeof(QUEUEGRP *) *
7740 (WorkGrp[j].wg_numqgrp + 1));
7741 if (WorkGrp[j].wg_qgs == NULL)
7743 syserr("!cannot allocate memory for work queues, need %d bytes",
7744 (int) (sizeof(QUEUEGRP *) *
7745 (WorkGrp[j].wg_numqgrp + 1)));
7749 WorkGrp[j].wg_qgs[WorkGrp[j].wg_numqgrp] = Queue[h];
7750 WorkGrp[j].wg_numqgrp++;
7751 WorkGrp[j].wg_runners += Queue[h]->qg_maxqrun;
7752 Queue[h]->qg_wgrp = j;
7754 if (WorkGrp[j].wg_maxact == 0)
7756 /* can't have more runners than allowed total */
7757 if (MaxQueueChildren > 0 &&
7758 Queue[h]->qg_maxqrun > MaxQueueChildren)
7759 Queue[h]->qg_maxqrun = MaxQueueChildren;
7760 WorkGrp[j].wg_maxact = Queue[h]->qg_maxqrun;
7764 ** XXX: must wg_lowqintvl be the GCD?
7765 ** qg1: 2m, qg2: 3m, minimum: 2m, when do queue runs for
7769 /* keep track of the lowest interval for a persistent runner */
7770 if (Queue[h]->qg_queueintvl > 0 &&
7771 WorkGrp[j].wg_lowqintvl < Queue[h]->qg_queueintvl)
7772 WorkGrp[j].wg_lowqintvl = Queue[h]->qg_queueintvl;
7777 for (i = 0; i < NumWorkGroups; i++)
7779 sm_dprintf("Workgroup[%d]=", i);
7780 for (j = 0; j < WorkGrp[i].wg_numqgrp; j++)
7783 WorkGrp[i].wg_qgs[j]->qg_name);
7791 ** DUP_DF -- duplicate envelope data file
7793 ** Copy the data file from the 'old' envelope to the 'new' envelope
7794 ** in the most efficient way possible.
7796 ** Create a hard link from the 'old' data file to the 'new' data file.
7797 ** If the old and new queue directories are on different file systems,
7798 ** then the new data file link is created in the old queue directory,
7799 ** and the new queue file will contain a 'd' record pointing to the
7800 ** directory containing the new data file.
7803 ** old -- old envelope.
7804 ** new -- new envelope.
7807 ** Returns true on success, false on failure.
7810 ** On success, the new data file is created.
7811 ** On fatal failure, EF_FATALERRS is set in old->e_flags.
7814 static bool dup_df __P((ENVELOPE *, ENVELOPE *));
7822 char opath[MAXPATHLEN];
7823 char npath[MAXPATHLEN];
7825 if (!bitset(EF_HAS_DF, old->e_flags))
7828 ** this can happen if: SuperSafe != True
7829 ** and a bounce mail is sent that is split.
7832 queueup(old, false, true);
7834 SM_REQUIRE(ISVALIDQGRP(old->e_qgrp) && ISVALIDQDIR(old->e_qdir));
7835 SM_REQUIRE(ISVALIDQGRP(new->e_qgrp) && ISVALIDQDIR(new->e_qdir));
7837 (void) sm_strlcpy(opath, queuename(old, DATAFL_LETTER), sizeof(opath));
7838 (void) sm_strlcpy(npath, queuename(new, DATAFL_LETTER), sizeof(npath));
7840 if (old->e_dfp != NULL)
7842 r = sm_io_setinfo(old->e_dfp, SM_BF_COMMIT, NULL);
7843 if (r < 0 && errno != EINVAL)
7845 syserr("@can't commit %s", opath);
7846 old->e_flags |= EF_FATALERRS;
7852 ** Attempt to create a hard link, if we think both old and new
7853 ** are on the same file system, otherwise copy the file.
7855 ** Don't waste time attempting a hard link unless old and new
7856 ** are on the same file system.
7859 SM_REQUIRE(ISVALIDQGRP(old->e_dfqgrp) && ISVALIDQDIR(old->e_dfqdir));
7860 SM_REQUIRE(ISVALIDQGRP(new->e_dfqgrp) && ISVALIDQDIR(new->e_dfqdir));
7862 ofs = Queue[old->e_dfqgrp]->qg_qpaths[old->e_dfqdir].qp_fsysidx;
7863 nfs = Queue[new->e_dfqgrp]->qg_qpaths[new->e_dfqdir].qp_fsysidx;
7864 if (FILE_SYS_DEV(ofs) == FILE_SYS_DEV(nfs))
7866 if (link(opath, npath) == 0)
7868 new->e_flags |= EF_HAS_DF;
7869 SYNC_DIR(npath, true);
7876 ** Can't link across queue directories, so try to create a hard
7877 ** link in the same queue directory as the old df file.
7878 ** The qf file will refer to the new df file using a 'd' record.
7881 new->e_dfqgrp = old->e_dfqgrp;
7882 new->e_dfqdir = old->e_dfqdir;
7883 (void) sm_strlcpy(npath, queuename(new, DATAFL_LETTER), sizeof(npath));
7884 if (link(opath, npath) == 0)
7886 new->e_flags |= EF_HAS_DF;
7887 SYNC_DIR(npath, true);
7893 sm_syslog(LOG_ERR, old->e_id,
7894 "dup_df: can't link %s to %s, error=%s, envelope splitting failed",
7895 opath, npath, sm_errstring(errno));
7900 ** SPLIT_ENV -- Allocate a new envelope based on a given envelope.
7904 ** sendqueue -- sendqueue for new envelope.
7905 ** qgrp -- index of queue group.
7906 ** qdir -- queue directory.
7913 static ENVELOPE *split_env __P((ENVELOPE *, ADDRESS *, int, int));
7916 split_env(e, sendqueue, qgrp, qdir)
7924 ee = (ENVELOPE *) sm_rpool_malloc_x(e->e_rpool, sizeof(*ee));
7925 STRUCTCOPY(*e, *ee);
7926 ee->e_message = NULL; /* XXX use original message? */
7929 ee->e_sendqueue = sendqueue;
7930 ee->e_flags &= ~(EF_INQUEUE|EF_CLRQUEUE|EF_FATALERRS
7931 |EF_SENDRECEIPT|EF_RET_PARAM|EF_HAS_DF);
7932 ee->e_flags |= EF_NORECEIPT; /* XXX really? */
7933 ee->e_from.q_state = QS_SENDER;
7935 ee->e_lockfp = NULL;
7936 if (e->e_xfp != NULL)
7937 ee->e_xfp = sm_io_dup(e->e_xfp);
7939 /* failed to dup e->e_xfp, start a new transcript */
7940 if (ee->e_xfp == NULL)
7943 ee->e_qgrp = ee->e_dfqgrp = qgrp;
7944 ee->e_qdir = ee->e_dfqdir = qdir;
7945 ee->e_errormode = EM_MAIL;
7946 ee->e_statmsg = NULL;
7947 if (e->e_quarmsg != NULL)
7948 ee->e_quarmsg = sm_rpool_strdup_x(ee->e_rpool,
7952 ** XXX Not sure if this copying is necessary.
7953 ** sendall() does this copying, but I (dm) don't know if that is
7954 ** because of the storage management discipline we were using
7955 ** before rpools were introduced, or if it is because these lists
7956 ** can be modified later.
7959 ee->e_header = copyheader(e->e_header, ee->e_rpool);
7960 ee->e_errorqueue = copyqueue(e->e_errorqueue, ee->e_rpool);
7965 /* return values from split functions, check also below! */
7966 #define SM_SPLIT_FAIL (0)
7967 #define SM_SPLIT_NONE (1)
7968 #define SM_SPLIT_NEW(n) (1 + (n))
7971 ** SPLIT_ACROSS_QUEUE_GROUPS
7973 ** This function splits an envelope across multiple queue groups
7974 ** based on the queue group of each recipient.
7980 ** SM_SPLIT_FAIL on failure
7981 ** SM_SPLIT_NONE if no splitting occurred,
7982 ** or 1 + the number of additional envelopes created.
7985 ** On success, e->e_sibling points to a list of zero or more
7986 ** additional envelopes, and the associated data files exist
7987 ** on disk. But the queue files are not created.
7989 ** On failure, e->e_sibling is not changed.
7990 ** The order of recipients in e->e_sendqueue is permuted.
7991 ** Abandoned data files for additional envelopes that failed
7992 ** to be created may exist on disk.
7995 static int q_qgrp_compare __P((const void *, const void *));
7996 static int e_filesys_compare __P((const void *, const void *));
7999 q_qgrp_compare(p1, p2)
8003 ADDRESS **pq1 = (ADDRESS **) p1;
8004 ADDRESS **pq2 = (ADDRESS **) p2;
8006 return (*pq1)->q_qgrp - (*pq2)->q_qgrp;
8010 e_filesys_compare(p1, p2)
8014 ENVELOPE **pe1 = (ENVELOPE **) p1;
8015 ENVELOPE **pe2 = (ENVELOPE **) p2;
8018 fs1 = Queue[(*pe1)->e_qgrp]->qg_qpaths[(*pe1)->e_qdir].qp_fsysidx;
8019 fs2 = Queue[(*pe2)->e_qgrp]->qg_qpaths[(*pe2)->e_qdir].qp_fsysidx;
8020 if (FILE_SYS_DEV(fs1) < FILE_SYS_DEV(fs2))
8022 if (FILE_SYS_DEV(fs1) > FILE_SYS_DEV(fs2))
8027 static int split_across_queue_groups __P((ENVELOPE *));
8029 split_across_queue_groups(e)
8032 int naddrs, nsplits, i;
8035 ADDRESS *q, **addrs;
8037 ENVELOPE *splits[MAXQUEUEGROUPS];
8038 char pvpbuf[PSBUFSIZE];
8040 SM_REQUIRE(ISVALIDQGRP(e->e_qgrp));
8042 /* Count addresses and assign queue groups. */
8045 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
8047 if (QS_IS_DEAD(q->q_state))
8051 /* bad addresses and those already sent stay put */
8052 if (QS_IS_BADADDR(q->q_state) ||
8053 QS_IS_SENT(q->q_state))
8054 q->q_qgrp = e->e_qgrp;
8055 else if (!ISVALIDQGRP(q->q_qgrp))
8057 /* call ruleset which should return a queue group */
8058 i = rscap(RS_QUEUEGROUP, q->q_user, NULL, e, &pvp,
8059 pvpbuf, sizeof(pvpbuf));
8061 pvp != NULL && pvp[0] != NULL &&
8062 (pvp[0][0] & 0377) == CANONNET &&
8063 pvp[1] != NULL && pvp[1][0] != '\0')
8065 i = name2qid(pvp[1]);
8071 sm_syslog(LOG_INFO, NOQID,
8072 "queue group name %s -> %d",
8076 else if (LogLevel > 10)
8077 sm_syslog(LOG_INFO, NOQID,
8078 "can't find queue group name %s, selection ignored",
8081 if (q->q_mailer != NULL &&
8082 ISVALIDQGRP(q->q_mailer->m_qgrp))
8085 q->q_qgrp = q->q_mailer->m_qgrp;
8087 else if (ISVALIDQGRP(e->e_qgrp))
8088 q->q_qgrp = e->e_qgrp;
8094 /* only one address? nothing to split. */
8095 if (naddrs <= 1 && !changed)
8096 return SM_SPLIT_NONE;
8098 /* sort the addresses by queue group */
8099 addrs = sm_rpool_malloc_x(e->e_rpool, naddrs * sizeof(ADDRESS *));
8100 for (i = 0, q = e->e_sendqueue; q != NULL; q = q->q_next)
8102 if (QS_IS_DEAD(q->q_state))
8106 qsort(addrs, naddrs, sizeof(ADDRESS *), q_qgrp_compare);
8108 /* split into multiple envelopes, by queue group */
8111 e->e_sendqueue = NULL;
8112 for (i = 0; i < naddrs; ++i)
8114 if (i == naddrs - 1 || addrs[i]->q_qgrp != addrs[i + 1]->q_qgrp)
8115 addrs[i]->q_next = NULL;
8117 addrs[i]->q_next = addrs[i + 1];
8119 /* same queue group as original envelope? */
8120 if (addrs[i]->q_qgrp == e->e_qgrp)
8122 if (e->e_sendqueue == NULL)
8123 e->e_sendqueue = addrs[i];
8127 /* different queue group than original envelope */
8128 if (es == NULL || addrs[i]->q_qgrp != es->e_qgrp)
8130 ee = split_env(e, addrs[i], addrs[i]->q_qgrp, NOQDIR);
8132 splits[nsplits++] = ee;
8136 /* no splits? return right now. */
8138 return SM_SPLIT_NONE;
8140 /* assign a queue directory to each additional envelope */
8141 for (i = 0; i < nsplits; ++i)
8145 es->e_qdir = pickqdir(Queue[es->e_qgrp], es->e_msgsize, es);
8147 if (!setnewqueue(es))
8151 /* sort the additional envelopes by queue file system */
8152 qsort(splits, nsplits, sizeof(ENVELOPE *), e_filesys_compare);
8154 /* create data files for each additional envelope */
8155 if (!dup_df(e, splits[0]))
8160 for (i = 1; i < nsplits; ++i)
8162 /* copy or link to the previous data file */
8163 if (!dup_df(splits[i - 1], splits[i]))
8167 /* success: prepend the new envelopes to the e->e_sibling list */
8168 for (i = 0; i < nsplits; ++i)
8171 es->e_sibling = e->e_sibling;
8174 return SM_SPLIT_NEW(nsplits);
8176 /* failure: clean up */
8182 for (j = 0; j < i; j++)
8183 (void) unlink(queuename(splits[j], DATAFL_LETTER));
8185 e->e_sendqueue = addrs[0];
8186 for (i = 0; i < naddrs - 1; ++i)
8187 addrs[i]->q_next = addrs[i + 1];
8188 addrs[naddrs - 1]->q_next = NULL;
8189 return SM_SPLIT_FAIL;
8193 ** SPLIT_WITHIN_QUEUE
8195 ** Split an envelope with multiple recipients into several
8196 ** envelopes within the same queue directory, if the number of
8197 ** recipients exceeds the limit for the queue group.
8203 ** SM_SPLIT_FAIL on failure
8204 ** SM_SPLIT_NONE if no splitting occurred,
8205 ** or 1 + the number of additional envelopes created.
8208 #define SPLIT_LOG_LEVEL 8
8210 static int split_within_queue __P((ENVELOPE *));
8213 split_within_queue(e)
8216 int maxrcpt, nrcpt, ndead, nsplit, i;
8219 ADDRESS *q, **addrs;
8220 ENVELOPE *ee, *firstsibling;
8222 if (!ISVALIDQGRP(e->e_qgrp) || bitset(EF_SPLIT, e->e_flags))
8223 return SM_SPLIT_NONE;
8225 /* don't bother if there is no recipient limit */
8226 maxrcpt = Queue[e->e_qgrp]->qg_maxrcpt;
8228 return SM_SPLIT_NONE;
8230 /* count recipients */
8232 for (q = e->e_sendqueue; q != NULL; q = q->q_next)
8234 if (QS_IS_DEAD(q->q_state))
8238 if (nrcpt <= maxrcpt)
8239 return SM_SPLIT_NONE;
8242 ** Preserve the recipient list
8243 ** so that we can restore it in case of error.
8244 ** (But we discard dead addresses.)
8247 addrs = sm_rpool_malloc_x(e->e_rpool, nrcpt * sizeof(ADDRESS *));
8248 for (i = 0, q = e->e_sendqueue; q != NULL; q = q->q_next)
8250 if (QS_IS_DEAD(q->q_state))
8256 ** Partition the recipient list so that bad and sent addresses
8257 ** come first. These will go with the original envelope, and
8258 ** do not count towards the maxrcpt limit.
8259 ** addrs[] does not contain QS_IS_DEAD() addresses.
8263 for (i = 0; i < nrcpt; ++i)
8265 if (QS_IS_BADADDR(addrs[i]->q_state) ||
8266 QS_IS_SENT(addrs[i]->q_state) ||
8267 QS_IS_DEAD(addrs[i]->q_state)) /* for paranoia's sake */
8271 ADDRESS *tmp = addrs[i];
8273 addrs[i] = addrs[ndead];
8280 /* Check if no splitting required. */
8281 if (nrcpt - ndead <= maxrcpt)
8282 return SM_SPLIT_NONE;
8285 for (i = 0; i < nrcpt - 1; ++i)
8286 addrs[i]->q_next = addrs[i + 1];
8287 addrs[nrcpt - 1]->q_next = NULL;
8288 e->e_sendqueue = addrs[0];
8290 /* prepare buffer for logging */
8291 if (LogLevel > SPLIT_LOG_LEVEL)
8294 lsplits = sm_malloc(l);
8295 if (lsplits != NULL)
8301 /* get rid of stupid compiler warnings */
8306 /* split the envelope */
8307 firstsibling = e->e_sibling;
8308 i = maxrcpt + ndead;
8312 addrs[i - 1]->q_next = NULL;
8313 ee = split_env(e, addrs[i], e->e_qgrp, e->e_qdir);
8320 (void) unlink(queuename(ee, DATAFL_LETTER));
8324 /* Error. Restore e's sibling & recipient lists. */
8325 e->e_sibling = firstsibling;
8326 for (i = 0; i < nrcpt - 1; ++i)
8327 addrs[i]->q_next = addrs[i + 1];
8328 if (lsplits != NULL)
8330 return SM_SPLIT_FAIL;
8333 /* prepend the new envelope to e->e_sibling */
8334 ee->e_sibling = e->e_sibling;
8337 if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL)
8339 if (j >= l - strlen(ee->e_id) - 3)
8344 p = sm_realloc(lsplits, l);
8347 /* let's try to get this done */
8354 if (lsplits != NULL)
8357 j += sm_strlcat(lsplits + j,
8361 j += sm_strlcat2(lsplits + j,
8368 if (nrcpt - i <= maxrcpt)
8372 if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL)
8376 sm_syslog(LOG_NOTICE, e->e_id,
8377 "split: maxrcpts=%d, rcpts=%d, count=%d, id%s=%s",
8378 maxrcpt, nrcpt - ndead, nsplit,
8379 nsplit > 1 ? "s" : "", lsplits);
8383 return SM_SPLIT_NEW(nsplit);
8386 ** SPLIT_BY_RECIPIENT
8388 ** Split an envelope with multiple recipients into multiple
8389 ** envelopes as required by the sendmail configuration.
8395 ** Returns true on success, false on failure.
8398 ** see split_across_queue_groups(), split_within_queue(e)
8402 split_by_recipient(e)
8405 int split, n, i, j, l;
8407 ENVELOPE *ee, *next, *firstsibling;
8409 if (OpMode == SM_VERIFY || !ISVALIDQGRP(e->e_qgrp) ||
8410 bitset(EF_SPLIT, e->e_flags))
8412 n = split_across_queue_groups(e);
8413 if (n == SM_SPLIT_FAIL)
8415 firstsibling = ee = e->e_sibling;
8416 if (n > 1 && LogLevel > SPLIT_LOG_LEVEL)
8419 lsplits = sm_malloc(l);
8420 if (lsplits != NULL)
8426 /* get rid of stupid compiler warnings */
8430 for (i = 1; i < n; ++i)
8432 next = ee->e_sibling;
8433 if (split_within_queue(ee) == SM_SPLIT_FAIL)
8435 e->e_sibling = firstsibling;
8438 ee->e_flags |= EF_SPLIT;
8439 if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL)
8441 if (j >= l - strlen(ee->e_id) - 3)
8446 p = sm_realloc(lsplits, l);
8449 /* let's try to get this done */
8456 if (lsplits != NULL)
8459 j += sm_strlcat(lsplits + j,
8462 j += sm_strlcat2(lsplits + j, "; ",
8469 if (LogLevel > SPLIT_LOG_LEVEL && lsplits != NULL && n > 1)
8471 sm_syslog(LOG_NOTICE, e->e_id, "split: count=%d, id%s=%s",
8472 n - 1, n > 2 ? "s" : "", lsplits);
8475 split = split_within_queue(e) != SM_SPLIT_FAIL;
8477 e->e_flags |= EF_SPLIT;
8482 ** QUARANTINE_QUEUE_ITEM -- {un,}quarantine a single envelope
8484 ** Add/remove quarantine reason and requeue appropriately.
8487 ** qgrp -- queue group for the item
8488 ** qdir -- queue directory in the given queue group
8489 ** e -- envelope information for the item
8490 ** reason -- quarantine reason, NULL means unquarantine.
8493 ** true if item changed, false otherwise
8496 ** Changes quarantine tag in queue file and renames it.
8500 quarantine_queue_item(qgrp, qdir, e, reason)
8507 bool failing = false;
8508 bool foundq = false;
8509 bool finished = false;
8515 MODE_T oldumask = 0;
8516 SM_FILE_T *oldqfp, *tempqfp;
8519 char oldqf[MAXPATHLEN];
8520 char tempqf[MAXPATHLEN];
8521 char newqf[MAXPATHLEN];
8524 oldtype = queue_letter(e, ANYQFL_LETTER);
8525 (void) sm_strlcpy(oldqf, queuename(e, ANYQFL_LETTER), sizeof(oldqf));
8526 (void) sm_strlcpy(tempqf, queuename(e, NEWQFL_LETTER), sizeof(tempqf));
8529 ** Instead of duplicating all the open
8530 ** and lock code here, tell readqf() to
8531 ** do that work and return the open
8532 ** file pointer in e_lockfp. Note that
8533 ** we must release the locks properly when
8537 if (!readqf(e, true))
8539 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8540 "Skipping %s\n", qid_printname(e));
8543 oldqfp = e->e_lockfp;
8545 /* open the new queue file */
8546 flags = O_CREAT|O_WRONLY|O_EXCL;
8547 if (bitset(S_IWGRP, QueueFileMode))
8548 oldumask = umask(002);
8549 fd = open(tempqf, flags, QueueFileMode);
8550 if (bitset(S_IWGRP, QueueFileMode))
8551 (void) umask(oldumask);
8557 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8558 "Skipping %s: Could not open %s: %s\n",
8559 qid_printname(e), tempqf,
8560 sm_errstring(save_errno));
8561 (void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8564 if (!lockfile(fd, tempqf, NULL, LOCK_EX|LOCK_NB))
8566 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8567 "Skipping %s: Could not lock %s\n",
8568 qid_printname(e), tempqf);
8570 (void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8574 tempqfp = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT, (void *) &fd,
8575 SM_IO_WRONLY_B, NULL);
8576 if (tempqfp == NULL)
8578 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8579 "Skipping %s: Could not lock %s\n",
8580 qid_printname(e), tempqf);
8582 (void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8586 /* Copy the data over, changing the quarantine reason */
8587 while (bufsize = sizeof(buf),
8588 (bp = fgetfolded(buf, &bufsize, oldqfp)) != NULL)
8591 sm_dprintf("+++++ %s\n", bp);
8594 case 'q': /* quarantine reason */
8600 (void) sm_io_fprintf(smioout,
8602 "%s: Removed quarantine of \"%s\"\n",
8605 sm_syslog(LOG_INFO, e->e_id, "unquarantine");
8608 else if (strcmp(reason, &bp[1]) == 0)
8612 (void) sm_io_fprintf(smioout,
8614 "%s: Already quarantined with \"%s\"\n",
8617 (void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8624 (void) sm_io_fprintf(smioout,
8626 "%s: Quarantine changed from \"%s\" to \"%s\"\n",
8630 (void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8632 sm_syslog(LOG_INFO, e->e_id, "quarantine=%s",
8640 ** If we are quarantining an unquarantined item,
8641 ** need to put in a new 'q' line before it's
8645 if (!foundq && reason != NULL)
8649 (void) sm_io_fprintf(smioout,
8651 "%s: Quarantined with \"%s\"\n",
8654 (void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8656 sm_syslog(LOG_INFO, e->e_id, "quarantine=%s",
8662 /* Copy the line to the new file */
8663 (void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8672 /* Copy the line to the new file */
8673 (void) sm_io_fprintf(tempqfp, SM_TIME_DEFAULT,
8681 /* Make sure we read the whole old file */
8682 errno = sm_io_error(tempqfp);
8683 if (errno != 0 && errno != SM_IO_EOF)
8686 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8687 "Skipping %s: Error reading %s: %s\n",
8688 qid_printname(e), oldqf,
8689 sm_errstring(save_errno));
8693 if (!failing && !finished)
8695 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8696 "Skipping %s: Incomplete file: %s\n",
8697 qid_printname(e), oldqf);
8701 /* Check if we actually changed anything or we can just bail now */
8704 /* pretend we failed, even though we technically didn't */
8708 /* Make sure we wrote things out safely */
8710 (sm_io_flush(tempqfp, SM_TIME_DEFAULT) != 0 ||
8711 ((SuperSafe == SAFE_REALLY ||
8712 SuperSafe == SAFE_REALLY_POSTMILTER ||
8713 SuperSafe == SAFE_INTERACTIVE) &&
8714 fsync(sm_io_getinfo(tempqfp, SM_IO_WHAT_FD, NULL)) < 0) ||
8715 ((errno = sm_io_error(tempqfp)) != 0)))
8718 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8719 "Skipping %s: Error writing %s: %s\n",
8720 qid_printname(e), tempqf,
8721 sm_errstring(save_errno));
8726 /* Figure out the new filename */
8727 newtype = (reason == NULL ? NORMQF_LETTER : QUARQF_LETTER);
8728 if (oldtype == newtype)
8730 /* going to rename tempqf to oldqf */
8731 (void) sm_strlcpy(newqf, oldqf, sizeof(newqf));
8735 /* going to rename tempqf to new name based on newtype */
8736 (void) sm_strlcpy(newqf, queuename(e, newtype), sizeof(newqf));
8741 /* rename tempqf to newqf */
8743 rename(tempqf, newqf) < 0)
8744 save_errno = (errno == 0) ? EINVAL : errno;
8746 /* Check rename() success */
8747 if (!failing && save_errno != 0)
8749 sm_syslog(LOG_DEBUG, e->e_id,
8750 "quarantine_queue_item: rename(%s, %s): %s",
8751 tempqf, newqf, sm_errstring(save_errno));
8753 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8754 "Error renaming %s to %s: %s\n",
8756 sm_errstring(save_errno));
8757 if (oldtype == newtype)
8760 ** Bail here since we don't know the state of
8761 ** the filesystem and may need to keep tempqf
8762 ** for the user to rescue us.
8767 syserr("!452 Error renaming control file %s", tempqf);
8772 /* remove new file (if rename() half completed) */
8773 if (xunlink(newqf) < 0)
8776 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8777 "Error removing %s: %s\n",
8779 sm_errstring(save_errno));
8782 /* tempqf removed below */
8788 /* If changing file types, need to remove old type */
8789 if (!failing && oldtype != newtype)
8791 if (xunlink(oldqf) < 0)
8794 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8795 "Error removing %s: %s\n",
8796 oldqf, sm_errstring(save_errno));
8800 /* see if anything above failed */
8803 /* Something failed: remove new file, old file still there */
8804 (void) xunlink(tempqf);
8808 ** fsync() after file operations to make sure metadata is
8809 ** written to disk on filesystems in which renames are
8810 ** not guaranteed. It's ok if they fail, mail won't be lost.
8813 if (SuperSafe != SAFE_NO)
8815 /* for soft-updates */
8816 (void) fsync(sm_io_getinfo(tempqfp,
8817 SM_IO_WHAT_FD, NULL));
8821 /* for soft-updates */
8822 (void) fsync(sm_io_getinfo(oldqfp,
8823 SM_IO_WHAT_FD, NULL));
8826 /* for other odd filesystems */
8827 SYNC_DIR(tempqf, false);
8832 if (tempqfp != NULL)
8833 (void) sm_io_close(tempqfp, SM_TIME_DEFAULT);
8835 (void) sm_io_close(oldqfp, SM_TIME_DEFAULT);
8842 ** QUARANTINE_QUEUE -- {un,}quarantine matching items in the queue
8844 ** Read all matching queue items, add/remove quarantine
8845 ** reason, and requeue appropriately.
8848 ** reason -- quarantine reason, "." means unquarantine.
8849 ** qgrplimit -- limit to single queue group unless NOQGRP
8855 ** Lots of changes to the queue.
8859 quarantine_queue(reason, qgrplimit)
8866 /* Convert internal representation of unquarantine */
8867 if (reason != NULL && reason[0] == '.' && reason[1] == '\0')
8873 reason = newstr(denlstring(reason, true, true));
8876 for (qgrp = 0; qgrp < NumQueue && Queue[qgrp] != NULL; qgrp++)
8880 if (qgrplimit != NOQGRP && qgrplimit != qgrp)
8883 for (qdir = 0; qdir < Queue[qgrp]->qg_numqueues; qdir++)
8891 nrequests = gatherq(qgrp, qdir, true, NULL, NULL, NULL);
8893 /* first see if there is anything */
8898 (void) sm_io_fprintf(smioout,
8899 SM_TIME_DEFAULT, "%s: no matches\n",
8900 qid_printqueue(qgrp, qdir));
8907 (void) sm_io_fprintf(smioout,
8908 SM_TIME_DEFAULT, "Processing %s:\n",
8909 qid_printqueue(qgrp, qdir));
8912 for (i = 0; i < WorkListCount; i++)
8919 /* setup envelope */
8920 clearenvelope(&e, true, sm_rpool_new_x(NULL));
8921 e.e_id = WorkList[i].w_name + 2;
8927 sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8928 "Would do %s\n", e.e_id);
8931 else if (quarantine_queue_item(qgrp, qdir,
8936 sm_rpool_free(e.e_rpool);
8939 if (WorkList != NULL)
8940 sm_free(WorkList); /* XXX */
8949 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8952 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
8955 changed == 1 ? "" : "s");