开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
queue.c
资源名称：sendmail.8.10.0.Beta10.tar.Z　[点击查看]
上传用户：xu_441
上传日期：2007-01-04
资源大小：1640k
文件大小：67k
源码类别：

Email客户端

开发平台：

Unix_Linux

queue.c：源码内容
  1. /*
  2.  * Copyright (c) 1998, 1999 Sendmail, Inc. and its suppliers.
  3.  * All rights reserved.
  4.  * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
  5.  * Copyright (c) 1988, 1993
  6.  * The Regents of the University of California.  All rights reserved.
  7.  *
  8.  * By using this file, you agree to the terms and conditions set
  9.  * forth in the LICENSE file which can be found at the top level of
  10.  * the sendmail distribution.
  11.  *
  12.  */
  14. #include <sendmail.h>
  16. #ifndef lint
  17. # if QUEUE
  18. static char id[] = "@(#)$Id: queue.c,v 8.329 1999/12/06 21:17:01 ca Exp $ (with queueing)";
  19. # else /* QUEUE */
  20. static char id[] = "@(#)$Id: queue.c,v 8.329 1999/12/06 21:17:01 ca Exp $ (without queueing)";
  21. # endif /* QUEUE */
  22. #endif /* ! lint */
  24. #include <dirent.h>
  26. #if QUEUE
  28. # if _FFR_QUEUEDELAY
  29. #  define QF_VERSION 4 /* version number of this queue format */
  30. static time_t queuedelay __P((ENVELOPE *));
  31. # else /* _FFR_QUEUEDELAY */
  32. #  define QF_VERSION 3 /* version number of this queue format */
  33. #  define queuedelay(e) MinQueueAge
  34. # endif /* _FFR_QUEUEDELAY */
  36. /*
  37. **  Work queue.
  38. */
  40. struct work
  41. {
  42. char *w_name; /* name of control file */
  43. char *w_host; /* name of recipient host */
  44. bool w_lock; /* is message locked? */
  45. bool w_tooyoung; /* is it too young to run? */
  46. long w_pri; /* priority of message, see below */
  47. time_t w_ctime; /* creation time of message */
  48. struct work *w_next; /* next in queue */
  49. };
  51. typedef struct work WORK;
  53. static WORK *WorkQ; /* queue of things to be done */
  55. static void grow_wlist __P((int));
  56. static int orderq __P((int, bool));
  57. static void printctladdr __P((ADDRESS *, FILE *));
  58. static int print_single_queue __P((int));
  59. static bool readqf __P((ENVELOPE *));
  60. static void runqueueevent __P((void));
  61. static int run_single_queue __P((int, bool, bool));
  62. static char *strrev __P((char *));
  63. static ADDRESS *setctluser __P((char *, int));
  64. static int workcmpf0();
  65. static int workcmpf1();
  66. static int workcmpf2();
  67. static int workcmpf3();
  68. static int workcmpf4();
  70. /*
  71. **  QUEUEUP -- queue a message up for future transmission.
  72. **
  73. ** Parameters:
  74. ** e -- the envelope to queue up.
  75. ** announce -- if TRUE, tell when you are queueing up.
  76. **
  77. ** Returns:
  78. ** none.
  79. **
  80. ** Side Effects:
  81. ** The current request are saved in a control file.
  82. ** The queue file is left locked.
  83. */
  85. void
  86. queueup(e, announce)
  87. register ENVELOPE *e;
  88. bool announce;
  89. {
  90. char *qf;
  91. register FILE *tfp;
  92. register HDR *h;
  93. register ADDRESS *q;
  94. int tfd = -1;
  95. int i;
  96. bool newid;
  97. register char *p;
  98. MAILER nullmailer;
  99. MCI mcibuf;
  100. char tf[MAXPATHLEN];
  101. char buf[MAXLINE];
  103. /*
  104. **  Create control file.
  105. */
  107. newid = (e->e_id == NULL) || !bitset(EF_INQUEUE, e->e_flags);
  109. /* if newid, queuename will create a locked qf file in e->lockfp */
  110. (void) strlcpy(tf, queuename(e, 't'), sizeof tf);
  111. tfp = e->e_lockfp;
  112. if (tfp == NULL)
  113. newid = FALSE;
  115. /* if newid, just write the qf file directly (instead of tf file) */
  116. if (!newid)
  117. {
  118. /* get a locked tf file */
  119. for (i = 0; i < 128; i++)
  120. {
  121. tfd = open(tf, O_CREAT|O_WRONLY|O_EXCL, FileMode);
  122. if (tfd < 0)
  123. {
  124. if (errno != EEXIST)
  125. break;
  126. if (LogLevel > 0 && (i % 32) == 0)
  127. sm_syslog(LOG_ALERT, e->e_id,
  128.   "queueup: cannot create %s, uid=%d: %s",
  129.   tf, geteuid(), errstring(errno));
  130. }
  131. else
  132. {
  133. if (lockfile(tfd, tf, NULL, LOCK_EX|LOCK_NB))
  134. break;
  135. else if (LogLevel > 0 && (i % 32) == 0)
  136. sm_syslog(LOG_ALERT, e->e_id,
  137.   "queueup: cannot lock %s: %s",
  138.   tf, errstring(errno));
  139. (void) close(tfd);
  140. }
  142. if ((i % 32) == 31)
  143. {
  144. /* save the old temp file away */
  145. (void) rename(tf, queuename(e, 'T'));
  146. }
  147. else
  148. (void) sleep(i % 32);
  149. }
  150. if (tfd < 0 || (tfp = fdopen(tfd, "w")) == NULL)
  151. {
  152. int save_errno = errno;
  154. printopenfds(TRUE);
  155. errno = save_errno;
  156. syserr("!queueup: cannot create queue temp file %s, uid=%d",
  157. tf, geteuid());
  158. }
  159. }
  161. if (tTd(40, 1))
  162. dprintf("n>>>>> queueing %s/qf%s%s >>>>>n",
  163. qid_printqueue(e->e_queuedir), e->e_id,
  164. newid ? " (new id)" : "");
  165. if (tTd(40, 3))
  166. {
  167. dprintf("  e_flags=");
  168. printenvflags(e);
  169. }
  170. if (tTd(40, 32))
  171. {
  172. dprintf("  sendq=");
  173. printaddr(e->e_sendqueue, TRUE);
  174. }
  175. if (tTd(40, 9))
  176. {
  177. dprintf("  tfp=");
  178. dumpfd(fileno(tfp), TRUE, FALSE);
  179. dprintf("  lockfp=");
  180. if (e->e_lockfp == NULL)
  181. dprintf("NULLn");
  182. else
  183. dumpfd(fileno(e->e_lockfp), TRUE, FALSE);
  184. }
  186. /*
  187. **  If there is no data file yet, create one.
  188. */
  190. if (bitset(EF_HAS_DF, e->e_flags))
  191. {
  192. if (e->e_dfp != NULL && bfcommit(e->e_dfp) < 0)
  193. syserr("!queueup: cannot commit data file %s, uid=%d",
  194. queuename(e, 'd'), geteuid());
  195. }
  196. else
  197. {
  198. int dfd;
  199. register FILE *dfp = NULL;
  200. char dfname[MAXPATHLEN];
  201. struct stat stbuf;
  203. if (e->e_dfp != NULL && bftest(e->e_dfp))
  204. syserr("committing over bf file");
  206. (void) strlcpy(dfname, queuename(e, 'd'), sizeof dfname);
  207. dfd = open(dfname, O_WRONLY|O_CREAT|O_TRUNC, FileMode);
  208. if (dfd < 0 || (dfp = fdopen(dfd, "w")) == NULL)
  209. syserr("!queueup: cannot create data temp file %s, uid=%d",
  210. dfname, geteuid());
  211. if (fstat(dfd, &stbuf) < 0)
  212. e->e_dfino = -1;
  213. else
  214. {
  215. e->e_dfdev = stbuf.st_dev;
  216. e->e_dfino = stbuf.st_ino;
  217. }
  218. e->e_flags |= EF_HAS_DF;
  219. memset(&mcibuf, '', sizeof mcibuf);
  220. mcibuf.mci_out = dfp;
  221. mcibuf.mci_mailer = FileMailer;
  222. (*e->e_putbody)(&mcibuf, e, NULL);
  223. if (fclose(dfp) < 0)
  224. syserr("!queueup: cannot save data temp file %s, uid=%d",
  225. dfname, geteuid());
  226. e->e_putbody = putbody;
  227. }
  229. /*
  230. **  Output future work requests.
  231. ** Priority and creation time should be first, since
  232. ** they are required by orderq.
  233. */
  235. /* output queue version number (must be first!) */
  236. fprintf(tfp, "V%dn", QF_VERSION);
  238. /* output creation time */
  239. fprintf(tfp, "T%ldn", (long) e->e_ctime);
  241. /* output last delivery time */
  242. # if _FFR_QUEUEDELAY
  243. fprintf(tfp, "K%ldn", (long) e->e_dtime);
  244. fprintf(tfp, "G%dn", e->e_queuealg);
  245. fprintf(tfp, "Y%ldn", (long) e->e_queuedelay);
  246. if (tTd(40, 64))
  247. sm_syslog(LOG_INFO, e->e_id,
  248. "queue alg: %d delay %ld next: %ld (now: %ld)n",
  249. e->e_queuealg, e->e_queuedelay, e->e_dtime, curtime());
  250. # else /* _FFR_QUEUEDELAY */
  251. fprintf(tfp, "K%ldn", (long) e->e_dtime);
  252. # endif /* _FFR_QUEUEDELAY */
  254. /* output number of delivery attempts */
  255. fprintf(tfp, "N%dn", e->e_ntries);
  257. /* output message priority */
  258. fprintf(tfp, "P%ldn", e->e_msgpriority);
  260. /* output inode number of data file */
  261. /* XXX should probably include device major/minor too */
  262. if (e->e_dfino != -1)
  263. {
  264. /*CONSTCOND*/
  265. if (sizeof e->e_dfino > sizeof(long))
  266. fprintf(tfp, "I%ld/%ld/%sn",
  267. (long) major(e->e_dfdev),
  268. (long) minor(e->e_dfdev),
  269. quad_to_string(e->e_dfino));
  270. else
  271. fprintf(tfp, "I%ld/%ld/%lun",
  272. (long) major(e->e_dfdev),
  273. (long) minor(e->e_dfdev),
  274. (unsigned long) e->e_dfino);
  275. }
  277. /* output body type */
  278. if (e->e_bodytype != NULL)
  279. fprintf(tfp, "B%sn", denlstring(e->e_bodytype, TRUE, FALSE));
  281. # if _FFR_SAVE_CHARSET
  282. if (e->e_charset != NULL)
  283. fprintf(tfp, "X%sn", denlstring(e->e_charset, TRUE, FALSE));
  284. # endif /* _FFR_SAVE_CHARSET */
  286. /* message from envelope, if it exists */
  287. if (e->e_message != NULL)
  288. fprintf(tfp, "M%sn", denlstring(e->e_message, TRUE, FALSE));
  290. /* send various flag bits through */
  291. p = buf;
  292. if (bitset(EF_WARNING, e->e_flags))
  293. *p++ = 'w';
  294. if (bitset(EF_RESPONSE, e->e_flags))
  295. *p++ = 'r';
  296. if (bitset(EF_HAS8BIT, e->e_flags))
  297. *p++ = '8';
  298. if (bitset(EF_DELETE_BCC, e->e_flags))
  299. *p++ = 'b';
  300. if (bitset(EF_RET_PARAM, e->e_flags))
  301. *p++ = 'd';
  302. if (bitset(EF_NO_BODY_RETN, e->e_flags))
  303. *p++ = 'n';
  304. *p++ = '';
  305. if (buf[0] != '')
  306. fprintf(tfp, "F%sn", buf);
  308. /* save $={persistentMacros} macro values */
  309. queueup_macros(macid("{persistentMacros}", NULL), tfp, e);
  311. /* output name of sender */
  312. if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags))
  313. p = e->e_sender;
  314. else
  315. p = e->e_from.q_paddr;
  316. fprintf(tfp, "S%sn", denlstring(p, TRUE, FALSE));
  318. /* output ESMTP-supplied "original" information */
  319. if (e->e_envid != NULL)
  320. fprintf(tfp, "Z%sn", denlstring(e->e_envid, TRUE, FALSE));
  322. /* output AUTH= parameter */
  323. if (e->e_auth_param != NULL)
  324. fprintf(tfp, "A%sn", denlstring(e->e_auth_param,
  325.  TRUE, FALSE));
  327. /* output list of recipient addresses */
  328. printctladdr(NULL, NULL);
  329. for (q = e->e_sendqueue; q != NULL; q = q->q_next)
  330. {
  331. if (!QS_IS_UNDELIVERED(q->q_state))
  332. continue;
  334. printctladdr(q, tfp);
  335. if (q->q_orcpt != NULL)
  336. fprintf(tfp, "Q%sn",
  337. denlstring(q->q_orcpt, TRUE, FALSE));
  338. (void) putc('R', tfp);
  339. if (bitset(QPRIMARY, q->q_flags))
  340. (void) putc('P', tfp);
  341. if (bitset(QHASNOTIFY, q->q_flags))
  342. (void) putc('N', tfp);
  343. if (bitset(QPINGONSUCCESS, q->q_flags))
  344. (void) putc('S', tfp);
  345. if (bitset(QPINGONFAILURE, q->q_flags))
  346. (void) putc('F', tfp);
  347. if (bitset(QPINGONDELAY, q->q_flags))
  348. (void) putc('D', tfp);
  349. (void) putc(':', tfp);
  350. (void) fprintf(tfp, "%sn", denlstring(q->q_paddr, TRUE, FALSE));
  351. if (announce)
  352. {
  353. e->e_to = q->q_paddr;
  354. message("queued");
  355. if (LogLevel > 8)
  356. logdelivery(q->q_mailer, NULL, "queued",
  357.     NULL, (time_t) 0, e);
  358. e->e_to = NULL;
  359. }
  360. if (tTd(40, 1))
  361. {
  362. dprintf("queueing ");
  363. printaddr(q, FALSE);
  364. }
  365. }
  367. /*
  368. **  Output headers for this message.
  369. ** Expand macros completely here.  Queue run will deal with
  370. ** everything as absolute headers.
  371. ** All headers that must be relative to the recipient
  372. ** can be cracked later.
  373. ** We set up a "null mailer" -- i.e., a mailer that will have
  374. ** no effect on the addresses as they are output.
  375. */
  377. memset((char *) &nullmailer, '', sizeof nullmailer);
  378. nullmailer.m_re_rwset = nullmailer.m_rh_rwset =
  379. nullmailer.m_se_rwset = nullmailer.m_sh_rwset = -1;
  380. nullmailer.m_eol = "n";
  381. memset(&mcibuf, '', sizeof mcibuf);
  382. mcibuf.mci_mailer = &nullmailer;
  383. mcibuf.mci_out = tfp;
  385. define('g', "201f", e);
  386. for (h = e->e_header; h != NULL; h = h->h_link)
  387. {
  388. if (h->h_value == NULL)
  389. continue;
  391. /* don't output resent headers on non-resent messages */
  392. if (bitset(H_RESENT, h->h_flags) &&
  393.     !bitset(EF_RESENT, e->e_flags))
  394. continue;
  396. /* expand macros; if null, don't output header at all */
  397. if (bitset(H_DEFAULT, h->h_flags))
  398. {
  399. (void) expand(h->h_value, buf, sizeof buf, e);
  400. if (buf[0] == '')
  401. continue;
  402. }
  404. /* output this header */
  405. fprintf(tfp, "H");
  407. /* if conditional, output the set of conditions */
  408. if (!bitzerop(h->h_mflags) && bitset(H_CHECK|H_ACHECK, h->h_flags))
  409. {
  410. int j;
  412. (void) putc('?', tfp);
  413. for (j = ''; j <= '177'; j++)
  414. if (bitnset(j, h->h_mflags))
  415. (void) putc(j, tfp);
  416. (void) putc('?', tfp);
  417. }
  419. /* output conditional macro if present */
  420. if (h->h_macro != '')
  421. {
  422. if (bitset(0200, h->h_macro))
  423. fprintf(tfp, "${%s}",
  424. macname(h->h_macro & 0377));
  425. else
  426. fprintf(tfp, "$%c", h->h_macro);
  427. }
  429. /* output the header: expand macros, convert addresses */
  430. if (bitset(H_DEFAULT, h->h_flags) &&
  431.     !bitset(H_BINDLATE, h->h_flags))
  432. {
  433. fprintf(tfp, "%s: %sn",
  434. h->h_field,
  435. denlstring(buf, FALSE, TRUE));
  436. }
  437. else if (bitset(H_FROM|H_RCPT, h->h_flags) &&
  438.  !bitset(H_BINDLATE, h->h_flags))
  439. {
  440. bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
  441. FILE *savetrace = TrafficLogFile;
  443. TrafficLogFile = NULL;
  445. if (bitset(H_FROM, h->h_flags))
  446. oldstyle = FALSE;
  448. commaize(h, h->h_value, oldstyle, &mcibuf, e);
  450. TrafficLogFile = savetrace;
  451. }
  452. else
  453. {
  454. fprintf(tfp, "%s: %sn",
  455. h->h_field,
  456. denlstring(h->h_value, FALSE, TRUE));
  457. }
  458. }
  460. /*
  461. **  Clean up.
  462. **
  463. ** Write a terminator record -- this is to prevent
  464. ** scurrilous crackers from appending any data.
  465. */
  467. fprintf(tfp, ".n");
  469. if (fflush(tfp) < 0 ||
  470.     (SuperSafe && fsync(fileno(tfp)) < 0) ||
  471.     ferror(tfp))
  472. {
  473. if (newid)
  474. syserr("!552 Error writing control file %s", tf);
  475. else
  476. syserr("!452 Error writing control file %s", tf);
  477. }
  479. if (!newid)
  480. {
  481. /* rename (locked) tf to be (locked) qf */
  482. qf = queuename(e, 'q');
  483. if (rename(tf, qf) < 0)
  484. syserr("cannot rename(%s, %s), uid=%d",
  485. tf, qf, geteuid());
  487. /*
  488. **  fsync() after renaming to make sure
  489. **  metadata is written to disk on
  490. **  filesystems in which renames are
  491. **  not guaranteed such as softupdates.
  492. */
  494. if (tfd >= 0 && SuperSafe && fsync(tfd) < 0)
  495. syserr("!queueup: cannot fsync queue temp file %s",
  496.        tf);
  498. /* close and unlock old (locked) qf */
  499. if (e->e_lockfp != NULL)
  500. (void) fclose(e->e_lockfp);
  501. e->e_lockfp = tfp;
  502. }
  503. else
  504. qf = tf;
  505. errno = 0;
  506. e->e_flags |= EF_INQUEUE;
  508. /* save log info */
  509. if (LogLevel > 79)
  510. sm_syslog(LOG_DEBUG, e->e_id, "queueup, qf=%s", qf);
  512. if (tTd(40, 1))
  513. dprintf("<<<<< done queueing %s <<<<<nn", e->e_id);
  514. return;
  515. }
  517. static void
  518. printctladdr(a, tfp)
  519. register ADDRESS *a;
  520. FILE *tfp;
  521. {
  522. char *user;
  523. register ADDRESS *q;
  524. uid_t uid;
  525. gid_t gid;
  526. static ADDRESS *lastctladdr = NULL;
  527. static uid_t lastuid;
  529. /* initialization */
  530. if (a == NULL || a->q_alias == NULL || tfp == NULL)
  531. {
  532. if (lastctladdr != NULL && tfp != NULL)
  533. fprintf(tfp, "Cn");
  534. lastctladdr = NULL;
  535. lastuid = 0;
  536. return;
  537. }
  539. /* find the active uid */
  540. q = getctladdr(a);
  541. if (q == NULL)
  542. {
  543. user = NULL;
  544. uid = 0;
  545. gid = 0;
  546. }
  547. else
  548. {
  549. user = q->q_ruser != NULL ? q->q_ruser : q->q_user;
  550. uid = q->q_uid;
  551. gid = q->q_gid;
  552. }
  553. a = a->q_alias;
  555. /* check to see if this is the same as last time */
  556. if (lastctladdr != NULL && uid == lastuid &&
  557.     strcmp(lastctladdr->q_paddr, a->q_paddr) == 0)
  558. return;
  559. lastuid = uid;
  560. lastctladdr = a;
  562. if (uid == 0 || user == NULL || user[0] == '')
  563. fprintf(tfp, "C");
  564. else
  565. fprintf(tfp, "C%s:%ld:%ld",
  566. denlstring(user, TRUE, FALSE), (long) uid, (long) gid);
  567. fprintf(tfp, ":%sn", denlstring(a->q_paddr, TRUE, FALSE));
  568. }
  569. /*
  570. **  RUNQUEUE -- run the jobs in the queue.
  571. **
  572. ** Gets the stuff out of the queue in some presumably logical
  573. ** order and processes them.
  574. **
  575. ** Parameters:
  576. ** forkflag -- TRUE if the queue scanning should be done in
  577. ** a child process.  We double-fork so it is not our
  578. ** child and we don't have to clean up after it.
  579. ** verbose -- if TRUE, print out status information.
  580. **
  581. ** Returns:
  582. ** TRUE if the queue run successfully began.
  583. **
  584. ** Side Effects:
  585. ** runs things in the mail queue.
  586. */
  588. static ENVELOPE QueueEnvelope; /* the queue run envelope */
  589. static int NumQueues = 0;
  590. static time_t LastQueueTime = 0; /* last time a queue ID assigned */
  591. static pid_t LastQueuePid = -1; /* last PID which had a queue ID */
  593. struct qpaths_s
  594. {
  595. char *qp_name; /* name of queue dir */
  596. short qp_subdirs; /* use subdirs? */
  597. };
  599. typedef struct qpaths_s QPATHS;
  601. /* values for qp_supdirs */
  602. #define QP_NOSUB 0x0000 /* No subdirectories */
  603. #define QP_SUBDF 0x0001 /* "df" subdirectory */
  604. #define QP_SUBQF 0x0002 /* "qf" subdirectory */
  605. #define QP_SUBXF 0x0004 /* "xf" subdirectory */
  607. static QPATHS *QPaths = NULL; /* list of queue directories */
  609. bool
  610. runqueue(forkflag, verbose)
  611. bool forkflag;
  612. bool verbose;
  613. {
  614. int i;
  615. bool ret = TRUE;
  616. static int curnum = 0;
  618. for (i = 0; i < NumQueues; i++)
  619. {
  620. /*
  621. **  Pick up where we left off, in case we
  622. **  used up all the children last time
  623. **  without finishing.
  624. */
  626. ret = run_single_queue(curnum, forkflag, verbose);
  628. /*
  629. **  Failure means a message was printed for ETRN
  630. **  and subsequent queues are likely to fail as well.
  631. */
  633. if (!ret)
  634. break;
  636. if (++curnum >= NumQueues)
  637. curnum = 0;
  638. }
  639. if (QueueIntvl != 0)
  640. (void) setevent(QueueIntvl, runqueueevent, 0);
  641. return ret;
  642. }
  643. /*
  644. **  RUN_SINGLE_QUEUE -- run the jobs in a single queue.
  645. **
  646. ** Gets the stuff out of the queue in some presumably logical
  647. ** order and processes them.
  648. **
  649. ** Parameters:
  650. ** queuedir -- queue to process
  651. ** forkflag -- TRUE if the queue scanning should be done in
  652. ** a child process.  We double-fork so it is not our
  653. ** child and we don't have to clean up after it.
  654. ** verbose -- if TRUE, print out status information.
  655. **
  656. ** Returns:
  657. ** TRUE if the queue run successfully began.
  658. **
  659. ** Side Effects:
  660. ** runs things in the mail queue.
  661. */
  663. static bool
  664. run_single_queue(queuedir, forkflag, verbose)
  665. int queuedir;
  666. bool forkflag;
  667. bool verbose;
  668. {
  669. register ENVELOPE *e;
  670. int njobs;
  671. int sequenceno = 0;
  672. time_t current_la_time;
  673. extern ENVELOPE BlankEnvelope;
  675. DoQueueRun = FALSE;
  677. /*
  678. **  If no work will ever be selected, don't even bother reading
  679. **  the queue.
  680. */
  682. CurrentLA = sm_getla(NULL); /* get load average */
  683. current_la_time = curtime();
  685. if (shouldqueue(WkRecipFact, current_la_time))
  686. {
  687. char *msg = "Skipping queue run -- load average too high";
  689. if (verbose)
  690. message("458 %sn", msg);
  691. if (LogLevel > 8)
  692. sm_syslog(LOG_INFO, NOQID,
  693.   "runqueue: %s",
  694.   msg);
  695. return FALSE;
  696. }
  698. /*
  699. **  See if we already have too many children.
  700. */
  702. if (forkflag && QueueIntvl != 0 &&
  703.     MaxChildren > 0 && CurChildren >= MaxChildren)
  704. {
  705. char *msg = "Skipping queue run -- too many children";
  707. if (verbose)
  708. message("458 %s (%d)n", msg, CurChildren);
  709. if (LogLevel > 8)
  710. sm_syslog(LOG_INFO, NOQID,
  711.   "runqueue: %s (%d)",
  712.   msg, CurChildren);
  713. return FALSE;
  714. }
  716. /*
  717. **  See if we want to go off and do other useful work.
  718. */
  720. if (forkflag)
  721. {
  722. pid_t pid;
  724. (void) blocksignal(SIGCHLD);
  725. (void) setsignal(SIGCHLD, reapchild);
  727. pid = dofork();
  728. if (pid == -1)
  729. {
  730. const char *msg = "Skipping queue run -- fork() failed";
  731. const char *err = errstring(errno);
  733. if (verbose)
  734. message("458 %s: %sn", msg, err);
  735. if (LogLevel > 8)
  736. sm_syslog(LOG_INFO, NOQID,
  737.   "runqueue: %s: %s",
  738.   msg, err);
  739. (void) releasesignal(SIGCHLD);
  740. return FALSE;
  741. }
  742. if (pid != 0)
  743. {
  744. /* parent -- pick up intermediate zombie */
  745. (void) blocksignal(SIGALRM);
  746. proc_list_add(pid, "Queue runner", PROC_QUEUE);
  747. (void) releasesignal(SIGALRM);
  748. (void) releasesignal(SIGCHLD);
  749. return TRUE;
  750. }
  751. /* child -- clean up signals */
  752. clrcontrol();
  753. proc_list_clear();
  755. /* Add parent process as first child item */
  756. proc_list_add(getpid(), "Queue runner child process",
  757.       PROC_QUEUE_CHILD);
  758. (void) releasesignal(SIGCHLD);
  759. (void) setsignal(SIGCHLD, SIG_DFL);
  760. (void) setsignal(SIGHUP, intsig);
  761. }
  763. sm_setproctitle(TRUE, CurEnv, "running queue: %s",
  764. qid_printqueue(queuedir));
  766. if (LogLevel > 69 || tTd(63, 99))
  767. sm_syslog(LOG_DEBUG, NOQID,
  768.   "runqueue %s, pid=%d, forkflag=%d",
  769.   qid_printqueue(queuedir), getpid(), forkflag);
  771. /*
  772. **  Release any resources used by the daemon code.
  773. */
  775. # if DAEMON
  776. clrdaemon();
  777. # endif /* DAEMON */
  779. /* force it to run expensive jobs */
  780. NoConnect = FALSE;
  782. /* drop privileges */
  783. if (geteuid() == (uid_t) 0)
  784. (void) drop_privileges(FALSE);
  786. /*
  787. **  Create ourselves an envelope
  788. */
  790. CurEnv = &QueueEnvelope;
  791. e = newenvelope(&QueueEnvelope, CurEnv);
  792. e->e_flags = BlankEnvelope.e_flags;
  794. /* make sure we have disconnected from parent */
  795. if (forkflag)
  796. {
  797. disconnect(1, e);
  798. QuickAbort = FALSE;
  799. }
  801. /*
  802. **  If we are running part of the queue, always ignore stored
  803. **  host status.
  804. */
  806. if (QueueLimitId != NULL || QueueLimitSender != NULL ||
  807.     QueueLimitRecipient != NULL)
  808. {
  809. IgnoreHostStatus = TRUE;
  810. MinQueueAge = 0;
  811. }
  813. /*
  814. **  Start making passes through the queue.
  815. ** First, read and sort the entire queue.
  816. ** Then, process the work in that order.
  817. ** But if you take too long, start over.
  818. */
  820. /* order the existing work requests */
  821. njobs = orderq(queuedir, FALSE);
  823. /* process them once at a time */
  824. while (WorkQ != NULL)
  825. {
  826. WORK *w = WorkQ;
  828. WorkQ = WorkQ->w_next;
  829. e->e_to = NULL;
  831. /*
  832. **  Ignore jobs that are too expensive for the moment.
  833. **
  834. ** Get new load average every 30 seconds.
  835. */
  837. if (current_la_time < curtime() - 30)
  838. {
  839. CurrentLA = sm_getla(e);
  840. current_la_time = curtime();
  841. }
  842. if (shouldqueue(WkRecipFact, current_la_time))
  843. {
  844. char *msg = "Aborting queue run: load average too high";
  846. if (Verbose)
  847. message("%s", msg);
  848. if (LogLevel > 8)
  849. sm_syslog(LOG_INFO, NOQID,
  850.   "runqueue: %s",
  851.   msg);
  852. break;
  853. }
  854. sequenceno++;
  855. if (shouldqueue(w->w_pri, w->w_ctime))
  856. {
  857. if (Verbose)
  858. message("");
  859. if (QueueSortOrder == QSO_BYPRIORITY)
  860. {
  861. if (Verbose)
  862. message("Skipping %s/%s (sequence %d of %d) and flushing rest of queue",
  863. qid_printqueue(queuedir),
  864. w->w_name + 2,
  865. sequenceno,
  866. njobs);
  867. if (LogLevel > 8)
  868. sm_syslog(LOG_INFO, NOQID,
  869.   "runqueue: Flushing queue from %s/%s (pri %ld, LA %d, %d of %d)",
  870.   qid_printqueue(queuedir),
  871.   w->w_name + 2,
  872.   w->w_pri,
  873.   CurrentLA,
  874.   sequenceno,
  875.   njobs);
  876. break;
  877. }
  878. else if (Verbose)
  879. message("Skipping %s/%s (sequence %d of %d)",
  880. qid_printqueue(queuedir),
  881. w->w_name + 2,
  882. sequenceno, njobs);
  883. }
  884. else
  885. {
  886. pid_t pid;
  888. if (Verbose)
  889. {
  890. message("");
  891. message("Running %s/%s (sequence %d of %d)",
  892. qid_printqueue(queuedir),
  893. w->w_name + 2,
  894. sequenceno, njobs);
  895. }
  896. if (tTd(63, 100))
  897. sm_syslog(LOG_DEBUG, NOQID,
  898.   "runqueue %s dowork(%s)",
  899.   qid_printqueue(queuedir),
  900.   w->w_name + 2);
  902. pid = dowork(queuedir, w->w_name + 2,
  903.      ForkQueueRuns, FALSE, e);
  904. errno = 0;
  905. if (pid != 0)
  906. (void) waitfor(pid);
  907. }
  908. free(w->w_name);
  909. if (w->w_host)
  910. free(w->w_host);
  911. free((char *) w);
  912. }
  914. /* exit without the usual cleanup */
  915. e->e_id = NULL;
  916. if (forkflag)
  917. finis(TRUE, ExitStat);
  918. /* NOTREACHED */
  919. return TRUE;
  920. }
  922. /*
  923. **  RUNQUEUEEVENT -- stub for use in setevent
  924. */
  926. static void
  927. runqueueevent()
  928. {
  929. DoQueueRun = TRUE;
  930. }
  931. /*
  932. **  ORDERQ -- order the work queue.
  933. **
  934. ** Parameters:
  935. ** queuedir -- the index of the queue directory.
  936. ** doall -- if set, include everything in the queue (even
  937. ** the jobs that cannot be run because the load
  938. ** average is too high).  Otherwise, exclude those
  939. ** jobs.
  940. **
  941. ** Returns:
  942. ** The number of request in the queue (not necessarily
  943. ** the number of requests in WorkQ however).
  944. **
  945. ** Side Effects:
  946. ** Sets WorkQ to the queue of available work, in order.
  947. */
  949. # define NEED_P 001
  950. # define NEED_T 002
  951. # define NEED_R 004
  952. # define NEED_S 010
  954. static WORK *WorkList = NULL;
  955. static int WorkListSize = 0;
  957. static int
  958. orderq(queuedir, doall)
  959. int queuedir;
  960. bool doall;
  961. {
  962. register struct dirent *d;
  963. register WORK *w;
  964. register char *p;
  965. DIR *f;
  966. register int i;
  967. int wn = -1;
  968. int wc;
  969. QUEUE_CHAR *check;
  970. char qd[MAXPATHLEN];
  971. char qf[MAXPATHLEN];
  973. if (queuedir == NOQDIR)
  974. (void) strlcpy(qd, ".", sizeof qd);
  975. else
  976. (void) snprintf(qd, sizeof qd, "%s%s",
  977. QPaths[queuedir].qp_name,
  978. (bitset(QP_SUBQF, QPaths[queuedir].qp_subdirs) ? "/qf" : ""));
  980. if (tTd(41, 1))
  981. {
  982. dprintf("orderq:n");
  984. check = QueueLimitId;
  985. while (check != NULL)
  986. {
  987. dprintf("tQueueLimitId = %sn",
  988. check->queue_match);
  989. check = check->queue_next;
  990. }
  992. check = QueueLimitSender;
  993. while (check != NULL)
  994. {
  995. dprintf("tQueueLimitSender = %sn",
  996. check->queue_match);
  997. check = check->queue_next;
  998. }
  1000. check = QueueLimitRecipient;
  1001. while (check != NULL)
  1002. {
  1003. dprintf("tQueueLimitRecipient = %sn",
  1004. check->queue_match);
  1005. check = check->queue_next;
  1006. }
  1007. }
  1009. /* clear out old WorkQ */
  1010. for (w = WorkQ; w != NULL; )
  1011. {
  1012. register WORK *nw = w->w_next;
  1014. WorkQ = nw;
  1015. free(w->w_name);
  1016. if (w->w_host)
  1017. free(w->w_host);
  1018. free((char *) w);
  1019. w = nw;
  1020. }
  1022. /* open the queue directory */
  1023. f = opendir(qd);
  1024. if (f == NULL)
  1025. {
  1026. syserr("orderq: cannot open "%s"", qid_printqueue(queuedir));
  1027. return 0;
  1028. }
  1030. /*
  1031. **  Read the work directory.
  1032. */
  1034. while ((d = readdir(f)) != NULL)
  1035. {
  1036. FILE *cf;
  1037. int qfver = 0;
  1038. char lbuf[MAXNAME + 1];
  1039. struct stat sbuf;
  1041. if (tTd(41, 50))
  1042. dprintf("orderq: checking %sn", d->d_name);
  1044. /* is this an interesting entry? */
  1045. if (d->d_name[0] != 'q' || d->d_name[1] != 'f')
  1046. continue;
  1048. if (strlen(d->d_name) >= MAXQFNAME)
  1049. {
  1050. if (Verbose)
  1051. printf("orderq: %s too long, %d max charactersn",
  1052. d->d_name, MAXQFNAME);
  1053. if (LogLevel > 0)
  1054. sm_syslog(LOG_ALERT, NOQID,
  1055.   "orderq: %s too long, %d max characters",
  1056.   d->d_name, MAXQFNAME);
  1057. continue;
  1058. }
  1060. check = QueueLimitId;
  1061. while (check != NULL)
  1062. {
  1063. if (strcontainedin(check->queue_match, d->d_name))
  1064. break;
  1065. else
  1066. check = check->queue_next;
  1067. }
  1068. if (QueueLimitId != NULL && check == NULL)
  1069. continue;
  1071. /* grow work list if necessary */
  1072. if (++wn >= MaxQueueRun && MaxQueueRun > 0)
  1073. {
  1074. if (wn == MaxQueueRun && LogLevel > 0)
  1075. sm_syslog(LOG_WARNING, NOQID,
  1076.   "WorkList for %s maxed out at %d",
  1077.   qid_printqueue(queuedir),
  1078.   MaxQueueRun);
  1079. continue;
  1080. }
  1081. if (wn >= WorkListSize)
  1082. {
  1083. grow_wlist(queuedir);
  1084. if (wn >= WorkListSize)
  1085. continue;
  1086. }
  1087. w = &WorkList[wn];
  1089. (void) snprintf(qf, sizeof qf, "%s/%s", qd, d->d_name);
  1090. if (stat(qf, &sbuf) < 0)
  1091. {
  1092. if (errno != ENOENT)
  1093. sm_syslog(LOG_INFO, NOQID,
  1094.   "orderq: can't stat %s/%s",
  1095.   qid_printqueue(queuedir), d->d_name);
  1096. wn--;
  1097. continue;
  1098. }
  1099. if (!bitset(S_IFREG, sbuf.st_mode))
  1100. {
  1101. /* Yikes!  Skip it or we will hang on open! */
  1102. syserr("orderq: %s/%s is not a regular file",
  1103.        qid_printqueue(queuedir), d->d_name);
  1104. wn--;
  1105. continue;
  1106. }
  1108. /* avoid work if possible */
  1109. if (QueueSortOrder == QSO_BYFILENAME)
  1110. {
  1111. w->w_name = newstr(d->d_name);
  1112. w->w_host = NULL;
  1113. w->w_lock = w->w_tooyoung = FALSE;
  1114. w->w_pri = 0;
  1115. w->w_ctime = 0;
  1116. continue;
  1117. }
  1119. /* open control file */
  1120. cf = fopen(qf, "r");
  1121. if (cf == NULL)
  1122. {
  1123. /* this may be some random person sending hir msgs */
  1124. /* syserr("orderq: cannot open %s", cbuf); */
  1125. if (tTd(41, 2))
  1126. dprintf("orderq: cannot open %s: %sn",
  1127. d->d_name, errstring(errno));
  1128. errno = 0;
  1129. wn--;
  1130. continue;
  1131. }
  1132. w->w_name = newstr(d->d_name);
  1133. w->w_host = NULL;
  1134. w->w_lock = !lockfile(fileno(cf), w->w_name, NULL, LOCK_SH|LOCK_NB);
  1135. w->w_tooyoung = FALSE;
  1137. /* make sure jobs in creation don't clog queue */
  1138. w->w_pri = 0x7fffffff;
  1139. w->w_ctime = 0;
  1141. /* extract useful information */
  1142. i = NEED_P | NEED_T;
  1143. if (QueueLimitSender != NULL)
  1144. i |= NEED_S;
  1145. if (QueueSortOrder == QSO_BYHOST || QueueLimitRecipient != NULL)
  1146. i |= NEED_R;
  1147. while (i != 0 && fgets(lbuf, sizeof lbuf, cf) != NULL)
  1148. {
  1149. int c;
  1150. time_t age;
  1152. p = strchr(lbuf, 'n');
  1153. if (p != NULL)
  1154. *p = '';
  1155. else
  1156. {
  1157. /* flush rest of overly long line */
  1158. while ((c = getc(cf)) != EOF && c != 'n')
  1159. continue;
  1160. }
  1162. switch (lbuf[0])
  1163. {
  1164.   case 'V':
  1165. qfver = atoi(&lbuf[1]);
  1166. break;
  1168.   case 'P':
  1169. w->w_pri = atol(&lbuf[1]);
  1170. i &= ~NEED_P;
  1171. break;
  1173.   case 'T':
  1174. w->w_ctime = atol(&lbuf[1]);
  1175. i &= ~NEED_T;
  1176. break;
  1178.   case 'R':
  1179. if (w->w_host == NULL &&
  1180.     (p = strrchr(&lbuf[1], '@')) != NULL)
  1181. {
  1182. w->w_host = strrev(&p[1]);
  1183. makelower(w->w_host);
  1184. }
  1185. if (QueueLimitRecipient == NULL)
  1186. {
  1187. i &= ~NEED_R;
  1188. break;
  1189. }
  1190. if (qfver > 0)
  1191. {
  1192. p = strchr(&lbuf[1], ':');
  1193. if (p == NULL)
  1194. p = &lbuf[1];
  1195. }
  1196. else
  1197. p = &lbuf[1];
  1198. check = QueueLimitRecipient;
  1199. while (check != NULL)
  1200. {
  1201. if (strcontainedin(check->queue_match,
  1202.    p))
  1203. break;
  1204. else
  1205. check = check->queue_next;
  1206. }
  1207. if (check != NULL)
  1208. i &= ~NEED_R;
  1209. break;
  1211.   case 'S':
  1212.   check = QueueLimitSender;
  1213.   while (check != NULL)
  1214.   {
  1215.   if (strcontainedin(check->queue_match,
  1216.      &lbuf[1]))
  1217.   break;
  1218.   else
  1219.   check = check->queue_next;
  1220.   }
  1221.   if (check != NULL)
  1222.   i &= ~NEED_S;
  1223. break;
  1225.   case 'K':
  1226. age = curtime() - (time_t) atol(&lbuf[1]);
  1227. if (age >= 0 && MinQueueAge > 0 &&
  1228.     age < MinQueueAge)
  1229. w->w_tooyoung = TRUE;
  1230. break;
  1232.   case 'N':
  1233. if (atol(&lbuf[1]) == 0)
  1234. w->w_tooyoung = FALSE;
  1235. break;
  1237. # if _FFR_QUEUEDELAY
  1238. /*
  1239.   case 'G':
  1240. queuealg = atoi(lbuf[1]);
  1241. break;
  1242.   case 'Y':
  1243. queuedelay = (time_t) atol(&lbuf[1]);
  1244. break;
  1245. */
  1246. # endif /* _FFR_QUEUEDELAY */
  1247. }
  1248. }
  1249. (void) fclose(cf);
  1251. if ((!doall && shouldqueue(w->w_pri, w->w_ctime)) ||
  1252.     bitset(NEED_R|NEED_S, i))
  1253. {
  1254. /* don't even bother sorting this job in */
  1255. if (tTd(41, 49))
  1256. dprintf("skipping %s (%x)n", w->w_name, i);
  1257. free(w->w_name);
  1258. if (w->w_host)
  1259. free(w->w_host);
  1260. wn--;
  1261. }
  1262. }
  1263. (void) closedir(f);
  1264. wn++;
  1266. WorkQ = NULL;
  1267. if (WorkList == NULL)
  1268. return 0;
  1269. wc = min(wn, WorkListSize);
  1270. if (wc > MaxQueueRun && MaxQueueRun > 0)
  1271. wc = MaxQueueRun;
  1273. if (QueueSortOrder == QSO_BYHOST)
  1274. {
  1275. /*
  1276. **  Sort the work directory for the first time,
  1277. **  based on host name, lock status, and priority.
  1278. */
  1280. qsort((char *) WorkList, wc, sizeof *WorkList, workcmpf1);
  1282. /*
  1283. **  If one message to host is locked, "lock" all messages
  1284. **  to that host.
  1285. */
  1287. i = 0;
  1288. while (i < wc)
  1289. {
  1290. if (!WorkList[i].w_lock)
  1291. {
  1292. i++;
  1293. continue;
  1294. }
  1295. w = &WorkList[i];
  1296. while (++i < wc)
  1297. {
  1298. if (WorkList[i].w_host == NULL &&
  1299.     w->w_host == NULL)
  1300. WorkList[i].w_lock = TRUE;
  1301. else if (WorkList[i].w_host != NULL &&
  1302.  w->w_host != NULL &&
  1303.  sm_strcasecmp(WorkList[i].w_host, w->w_host) == 0)
  1304. WorkList[i].w_lock = TRUE;
  1305. else
  1306. break;
  1307. }
  1308. }
  1310. /*
  1311. **  Sort the work directory for the second time,
  1312. **  based on lock status, host name, and priority.
  1313. */
  1315. qsort((char *) WorkList, wc, sizeof *WorkList, workcmpf2);
  1316. }
  1317. else if (QueueSortOrder == QSO_BYTIME)
  1318. {
  1319. /*
  1320. **  Simple sort based on submission time only.
  1321. */
  1323. qsort((char *) WorkList, wc, sizeof *WorkList, workcmpf3);
  1324. }
  1325. else if (QueueSortOrder == QSO_BYFILENAME)
  1326. {
  1327. /*
  1328. **  Sort based on qf filename.
  1329. */
  1331. qsort((char *) WorkList, wc, sizeof *WorkList, workcmpf4);
  1332. }
  1333. else
  1334. {
  1335. /*
  1336. **  Simple sort based on queue priority only.
  1337. */
  1339. qsort((char *) WorkList, wc, sizeof *WorkList, workcmpf0);
  1340. }
  1342. /*
  1343. **  Convert the work list into canonical form.
  1344. ** Should be turning it into a list of envelopes here perhaps.
  1345. */
  1347. for (i = wc; --i >= 0; )
  1348. {
  1349. w = (WORK *) xalloc(sizeof *w);
  1350. w->w_name = WorkList[i].w_name;
  1351. w->w_host = WorkList[i].w_host;
  1352. w->w_lock = WorkList[i].w_lock;
  1353. w->w_tooyoung = WorkList[i].w_tooyoung;
  1354. w->w_pri = WorkList[i].w_pri;
  1355. w->w_ctime = WorkList[i].w_ctime;
  1356. w->w_next = WorkQ;
  1357. WorkQ = w;
  1358. }
  1359. if (WorkList != NULL)
  1360. free(WorkList);
  1361. WorkList = NULL;
  1362. WorkListSize = 0;
  1364. if (tTd(40, 1))
  1365. {
  1366. for (w = WorkQ; w != NULL; w = w->w_next)
  1367. {
  1368. if (w->w_host != NULL)
  1369. dprintf("%22s: pri=%ld %sn",
  1370. w->w_name, w->w_pri, w->w_host);
  1371. else
  1372. dprintf("%32s: pri=%ldn",
  1373. w->w_name, w->w_pri);
  1374. }
  1375. }
  1377. return wn;
  1378. }
  1379. /*
  1380. **  GROW_WLIST -- make the work list larger
  1381. **
  1382. ** Parameters:
  1383. ** queuedir -- the index for the queue directory.
  1384. **
  1385. ** Returns:
  1386. ** none.
  1387. **
  1388. ** Side Effects:
  1389. ** Adds another QUEUESEGSIZE entries to WorkList if possible.
  1390. ** It can fail if there isn't enough memory, so WorkListSize
  1391. ** should be checked again upon return.
  1392. */
  1394. static void
  1395. grow_wlist(queuedir)
  1396. int queuedir;
  1397. {
  1398. if (tTd(41, 1))
  1399. dprintf("grow_wlist: WorkListSize=%dn", WorkListSize);
  1400. if (WorkList == NULL)
  1401. {
  1402. WorkList = (WORK *) xalloc((sizeof *WorkList) *
  1403.    (QUEUESEGSIZE + 1));
  1404. WorkListSize = QUEUESEGSIZE;
  1405. }
  1406. else
  1407. {
  1408. int newsize = WorkListSize + QUEUESEGSIZE;
  1409. WORK *newlist = (WORK *) realloc((char *)WorkList,
  1410.   (unsigned)sizeof(WORK) * (newsize + 1));
  1412. if (newlist != NULL)
  1413. {
  1414. WorkListSize = newsize;
  1415. WorkList = newlist;
  1416. if (LogLevel > 1)
  1417. {
  1418. sm_syslog(LOG_INFO, NOQID,
  1419.   "grew WorkList for %s to %d",
  1420.   qid_printqueue(queuedir),
  1421.   WorkListSize);
  1422. }
  1423. }
  1424. else if (LogLevel > 0)
  1425. {
  1426. sm_syslog(LOG_ALERT, NOQID,
  1427.   "FAILED to grow WorkList for %s to %d",
  1428.   qid_printqueue(queuedir), newsize);
  1429. }
  1430. }
  1431. if (tTd(41, 1))
  1432. dprintf("grow_wlist: WorkListSize now %dn", WorkListSize);
  1433. }
  1434. /*
  1435. **  WORKCMPF0 -- simple priority-only compare function.
  1436. **
  1437. ** Parameters:
  1438. ** a -- the first argument.
  1439. ** b -- the second argument.
  1440. **
  1441. ** Returns:
  1442. ** -1 if a < b
  1443. **  0 if a == b
  1444. ** +1 if a > b
  1445. **
  1446. ** Side Effects:
  1447. ** none.
  1448. */
  1450. static int
  1451. workcmpf0(a, b)
  1452. register WORK *a;
  1453. register WORK *b;
  1454. {
  1455. long pa = a->w_pri;
  1456. long pb = b->w_pri;
  1458. if (pa == pb)
  1459. return 0;
  1460. else if (pa > pb)
  1461. return 1;
  1462. else
  1463. return -1;
  1464. }
  1465. /*
  1466. **  WORKCMPF1 -- first compare function for ordering work based on host name.
  1467. **
  1468. ** Sorts on host name, lock status, and priority in that order.
  1469. **
  1470. ** Parameters:
  1471. ** a -- the first argument.
  1472. ** b -- the second argument.
  1473. **
  1474. ** Returns:
  1475. ** <0 if a < b
  1476. **  0 if a == b
  1477. ** >0 if a > b
  1478. **
  1479. ** Side Effects:
  1480. ** none.
  1481. */
  1483. static int
  1484. workcmpf1(a, b)
  1485. register WORK *a;
  1486. register WORK *b;
  1487. {
  1488. int i;
  1490. /* host name */
  1491. if (a->w_host != NULL && b->w_host == NULL)
  1492. return 1;
  1493. else if (a->w_host == NULL && b->w_host != NULL)
  1494. return -1;
  1495. if (a->w_host != NULL && b->w_host != NULL &&
  1496.     (i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
  1497. return i;
  1499. /* lock status */
  1500. if (a->w_lock != b->w_lock)
  1501. return b->w_lock - a->w_lock;
  1503. /* job priority */
  1504. return a->w_pri - b->w_pri;
  1505. }
  1506. /*
  1507. **  WORKCMPF2 -- second compare function for ordering work based on host name.
  1508. **
  1509. ** Sorts on lock status, host name, and priority in that order.
  1510. **
  1511. ** Parameters:
  1512. ** a -- the first argument.
  1513. ** b -- the second argument.
  1514. **
  1515. ** Returns:
  1516. ** <0 if a < b
  1517. **  0 if a == b
  1518. ** >0 if a > b
  1519. **
  1520. ** Side Effects:
  1521. ** none.
  1522. */
  1524. static int
  1525. workcmpf2(a, b)
  1526. register WORK *a;
  1527. register WORK *b;
  1528. {
  1529. int i;
  1531. /* lock status */
  1532. if (a->w_lock != b->w_lock)
  1533. return a->w_lock - b->w_lock;
  1535. /* host name */
  1536. if (a->w_host != NULL && b->w_host == NULL)
  1537. return 1;
  1538. else if (a->w_host == NULL && b->w_host != NULL)
  1539. return -1;
  1540. if (a->w_host != NULL && b->w_host != NULL &&
  1541.     (i = sm_strcasecmp(a->w_host, b->w_host)) != 0)
  1542. return i;
  1544. /* job priority */
  1545. return a->w_pri - b->w_pri;
  1546. }
  1547. /*
  1548. **  WORKCMPF3 -- simple submission-time-only compare function.
  1549. **
  1550. ** Parameters:
  1551. ** a -- the first argument.
  1552. ** b -- the second argument.
  1553. **
  1554. ** Returns:
  1555. ** -1 if a < b
  1556. **  0 if a == b
  1557. ** +1 if a > b
  1558. **
  1559. ** Side Effects:
  1560. ** none.
  1561. */
  1563. static int
  1564. workcmpf3(a, b)
  1565. register WORK *a;
  1566. register WORK *b;
  1567. {
  1568. if (a->w_ctime > b->w_ctime)
  1569. return 1;
  1570. else if (a->w_ctime < b->w_ctime)
  1571. return -1;
  1572. else
  1573. return 0;
  1574. }
  1575. /*
  1576. **  WORKCMPF4 -- compare based on file name
  1577. **
  1578. ** Parameters:
  1579. ** a -- the first argument.
  1580. ** b -- the second argument.
  1581. **
  1582. ** Returns:
  1583. ** -1 if a < b
  1584. **  0 if a == b
  1585. ** +1 if a > b
  1586. **
  1587. ** Side Effects:
  1588. ** none.
  1589. */
  1591. static int
  1592. workcmpf4(a, b)
  1593. register WORK *a;
  1594. register WORK *b;
  1595. {
  1596. return strcmp(a->w_name, b->w_name);
  1597. }
  1598. /*
  1599. **  STRREV -- reverse string
  1600. **
  1601. ** Returns a pointer to a new string that is the reverse of
  1602. ** the string pointed to by fwd.  The space for the new
  1603. ** string is obtained using xalloc().
  1604. **
  1605. ** Parameters:
  1606. ** fwd -- the string to reverse.
  1607. **
  1608. ** Returns:
  1609. ** the reversed string.
  1610. */
  1612. static char *
  1613. strrev(fwd)
  1614. char *fwd;
  1615. {
  1616. char *rev = NULL;
  1617. int len, cnt;
  1619. len = strlen(fwd);
  1620. rev = xalloc(len + 1);
  1621. for (cnt = 0; cnt < len; ++cnt)
  1622. rev[cnt] = fwd[len - cnt - 1];
  1623. rev[len] = '';
  1624. return rev;
  1625. }
  1626. /*
  1627. **  DOWORK -- do a work request.
  1628. **
  1629. ** Parameters:
  1630. ** queuedir -- the index of the queue directory for the job.
  1631. ** id -- the ID of the job to run.
  1632. ** forkflag -- if set, run this in background.
  1633. ** requeueflag -- if set, reinstantiate the queue quickly.
  1634. ** This is used when expanding aliases in the queue.
  1635. ** If forkflag is also set, it doesn't wait for the
  1636. ** child.
  1637. ** e - the envelope in which to run it.
  1638. **
  1639. ** Returns:
  1640. ** process id of process that is running the queue job.
  1641. **
  1642. ** Side Effects:
  1643. ** The work request is satisfied if possible.
  1644. */
  1646. pid_t
  1647. dowork(queuedir, id, forkflag, requeueflag, e)
  1648. int queuedir;
  1649. char *id;
  1650. bool forkflag;
  1651. bool requeueflag;
  1652. register ENVELOPE *e;
  1653. {
  1654. register pid_t pid;
  1656. if (tTd(40, 1))
  1657. dprintf("dowork(%s/%s)n", qid_printqueue(queuedir), id);
  1659. /*
  1660. **  Fork for work.
  1661. */
  1663. if (forkflag)
  1664. {
  1665. /*
  1666. **  Since the delivery may happen in a child and the
  1667. **  parent does not wait, the parent may close the
  1668. **  maps thereby removing any shared memory used by
  1669. **  the map.  Therefore, close the maps now so the
  1670. **  child will dynamically open them if necessary.
  1671. */
  1673. closemaps();
  1675. pid = fork();
  1676. if (pid < 0)
  1677. {
  1678. syserr("dowork: cannot fork");
  1679. return 0;
  1680. }
  1681. else if (pid > 0)
  1682. {
  1683. /* parent -- clean out connection cache */
  1684. mci_flush(FALSE, NULL);
  1685. }
  1686. else
  1687. {
  1688. /* child -- error messages to the transcript */
  1689. QuickAbort = OnlyOneError = FALSE;
  1690. }
  1691. }
  1692. else
  1693. {
  1694. pid = 0;
  1695. }
  1697. if (pid == 0)
  1698. {
  1699. /*
  1700. **  CHILD
  1701. ** Lock the control file to avoid duplicate deliveries.
  1702. ** Then run the file as though we had just read it.
  1703. ** We save an idea of the temporary name so we
  1704. ** can recover on interrupt.
  1705. */
  1707. /* set basic modes, etc. */
  1708. (void) alarm(0);
  1709. clearstats();
  1710. clearenvelope(e, FALSE);
  1711. e->e_flags |= EF_QUEUERUN|EF_GLOBALERRS;
  1712. set_delivery_mode(SM_DELIVER, e);
  1713. e->e_errormode = EM_MAIL;
  1714. e->e_id = id;
  1715. e->e_queuedir = queuedir;
  1716. GrabTo = UseErrorsTo = FALSE;
  1717. ExitStat = EX_OK;
  1718. if (forkflag)
  1719. {
  1720. disconnect(1, e);
  1721. OpMode = MD_QUEUERUN;
  1722. }
  1723. sm_setproctitle(TRUE, e, "%s: from queue", qid_printname(e));
  1724. if (LogLevel > 76)
  1725. sm_syslog(LOG_DEBUG, e->e_id,
  1726.   "dowork, pid=%d",
  1727.   getpid());
  1729. /* don't use the headers from sendmail.cf... */
  1730. e->e_header = NULL;
  1732. /* read the queue control file -- return if locked */
  1733. if (!readqf(e))
  1734. {
  1735. if (tTd(40, 4) && e->e_id != NULL)
  1736. dprintf("readqf(%s) failedn",
  1737. qid_printname(e));
  1738. e->e_id = NULL;
  1739. if (forkflag)
  1740. finis(FALSE, EX_OK);
  1741. else
  1742. return 0;
  1743. }
  1745. e->e_flags |= EF_INQUEUE;
  1746. eatheader(e, requeueflag);
  1748. if (requeueflag)
  1749. queueup(e, FALSE);
  1751. /* do the delivery */
  1752. sendall(e, SM_DELIVER);
  1754. /* finish up and exit */
  1755. if (forkflag)
  1756. finis(TRUE, ExitStat);
  1757. else
  1758. dropenvelope(e, TRUE);
  1759. }
  1760. e->e_id = NULL;
  1761. return pid;
  1762. }
  1763. /*
  1764. **  READQF -- read queue file and set up environment.
  1765. **
  1766. ** Parameters:
  1767. ** e -- the envelope of the job to run.
  1768. **
  1769. ** Returns:
  1770. ** TRUE if it successfully read the queue file.
  1771. ** FALSE otherwise.
  1772. **
  1773. ** Side Effects:
  1774. ** The queue file is returned locked.
  1775. */
  1777. static bool
  1778. readqf(e)
  1779. register ENVELOPE *e;
  1780. {
  1781. register FILE *qfp;
  1782. ADDRESS *ctladdr;
  1783. struct stat st;
  1784. char *bp;
  1785. int qfver = 0;
  1786. int chompflags;
  1787. long hdrsize = 0;
  1788. register char *p;
  1789. char *orcpt = NULL;
  1790. bool nomore = FALSE;
  1791. char qf[MAXPATHLEN];
  1792. char buf[MAXLINE];
  1794. /*
  1795. **  Read and process the file.
  1796. */
  1798. (void) strlcpy(qf, queuename(e, 'q'), sizeof qf);
  1799. qfp = fopen(qf, "r+");
  1800. if (qfp == NULL)
  1801. {
  1802. int save_errno = errno;
  1804. if (tTd(40, 8))
  1805. dprintf("readqf(%s): fopen failure (%s)n",
  1806. qf, errstring(errno));
  1807. errno = save_errno;
  1808. if (errno != ENOENT)
  1809. syserr("readqf: no control file %s", qf);
  1810. return FALSE;
  1811. }
  1813. if (!lockfile(fileno(qfp), qf, NULL, LOCK_EX|LOCK_NB))
  1814. {
  1815. /* being processed by another queuer */
  1816. if (Verbose)
  1817. printf("%s: lockedn", e->e_id);
  1818. if (tTd(40, 8))
  1819. dprintf("%s: lockedn", e->e_id);
  1820. if (LogLevel > 19)
  1821. sm_syslog(LOG_DEBUG, e->e_id, "locked");
  1822. (void) fclose(qfp);
  1823. return FALSE;
  1824. }
  1826. /*
  1827. **  Check the queue file for plausibility to avoid attacks.
  1828. */
  1830. if (fstat(fileno(qfp), &st) < 0)
  1831. {
  1832. /* must have been being processed by someone else */
  1833. if (tTd(40, 8))
  1834. dprintf("readqf(%s): fstat failure (%s)n",
  1835. qf, errstring(errno));
  1836. (void) fclose(qfp);
  1837. return FALSE;
  1838. }
  1840. if ((st.st_uid != geteuid() && geteuid() != RealUid) ||
  1841.     bitset(S_IWOTH|S_IWGRP, st.st_mode))
  1842. {
  1843. if (LogLevel > 0)
  1844. {
  1845. sm_syslog(LOG_ALERT, e->e_id,
  1846.   "bogus queue file, uid=%d, mode=%o",
  1847.   st.st_uid, st.st_mode);
  1848. }
  1849. if (tTd(40, 8))
  1850. dprintf("readqf(%s): bogus filen", qf);
  1851. loseqfile(e, "bogus file uid in mqueue");
  1852. (void) fclose(qfp);
  1853. return FALSE;
  1854. }
  1856. if (st.st_size == 0)
  1857. {
  1858. /* must be a bogus file -- if also old, just remove it */
  1859. if (st.st_ctime + 10 * 60 < curtime())
  1860. {
  1861. (void) unlink(queuename(e, 'd'));
  1862. (void) unlink(queuename(e, 'q'));
  1863. }
  1864. (void) fclose(qfp);
  1865. return FALSE;
  1866. }
  1868. if (st.st_nlink == 0)
  1869. {
  1870. /*
  1871. **  Race condition -- we got a file just as it was being
  1872. **  unlinked.  Just assume it is zero length.
  1873. */
  1875. (void) fclose(qfp);
  1876. return FALSE;
  1877. }
  1879. /* good file -- save this lock */
  1880. e->e_lockfp = qfp;
  1882. /* do basic system initialization */
  1883. initsys(e);
  1884. define('i', e->e_id, e);
  1886. LineNumber = 0;
  1887. e->e_flags |= EF_GLOBALERRS;
  1888. OpMode = MD_QUEUERUN;
  1889. ctladdr = NULL;
  1890. e->e_dfino = -1;
  1891. e->e_msgsize = -1;
  1892. # if _FFR_QUEUEDELAY
  1893. e->e_queuealg = QD_LINEAR;
  1894. e->e_queuedelay = (time_t) 0;
  1895. # endif /* _FFR_QUEUEDELAY */
  1896. while ((bp = fgetfolded(buf, sizeof buf, qfp)) != NULL)
  1897. {
  1898. u_long qflags;
  1899. ADDRESS *q;
  1900. int mid;
  1901. auto char *ep;
  1903. if (tTd(40, 4))
  1904. dprintf("+++++ %sn", bp);
  1905. if (nomore)
  1906. {
  1907. /* hack attack */
  1908. syserr("SECURITY ALERT: extra data in qf: %s", bp);
  1909. (void) fclose(qfp);
  1910. loseqfile(e, "bogus queue line");
  1911. return FALSE;
  1912. }
  1913. switch (bp[0])
  1914. {
  1915.   case 'V': /* queue file version number */
  1916. qfver = atoi(&bp[1]);
  1917. if (qfver <= QF_VERSION)
  1918. break;
  1919. syserr("Version number in qf (%d) greater than max (%d)",
  1920. qfver, QF_VERSION);
  1921. (void) fclose(qfp);
  1922. loseqfile(e, "unsupported qf file version");
  1923. return FALSE;
  1925.   case 'C': /* specify controlling user */
  1926. ctladdr = setctluser(&bp[1], qfver);
  1927. break;
  1929.   case 'Q': /* original recipient */
  1930. orcpt = newstr(&bp[1]);
  1931. break;
  1933.   case 'R': /* specify recipient */
  1934. p = bp;
  1935. qflags = 0;
  1936. if (qfver >= 1)
  1937. {
  1938. /* get flag bits */
  1939. while (*++p != '' && *p != ':')
  1940. {
  1941. switch (*p)
  1942. {
  1943.   case 'N':
  1944. qflags |= QHASNOTIFY;
  1945. break;
  1947.   case 'S':
  1948. qflags |= QPINGONSUCCESS;
  1949. break;
  1951.   case 'F':
  1952. qflags |= QPINGONFAILURE;
  1953. break;
  1955.   case 'D':
  1956. qflags |= QPINGONDELAY;
  1957. break;
  1959.   case 'P':
  1960. qflags |= QPRIMARY;
  1961. break;
  1962. }
  1963. }
  1964. }
  1965. else
  1966. qflags |= QPRIMARY;
  1967. q = parseaddr(++p, NULLADDR, RF_COPYALL, '', NULL, e);
  1968. if (q != NULL)
  1969. {
  1970. q->q_alias = ctladdr;
  1971. if (qfver >= 1)
  1972. q->q_flags &= ~Q_PINGFLAGS;
  1973. q->q_flags |= qflags;
  1974. q->q_orcpt = orcpt;
  1975. (void) recipient(q, &e->e_sendqueue, 0, e);
  1976. }
  1977. orcpt = NULL;
  1978. break;
  1980.   case 'E': /* specify error recipient */
  1981. /* no longer used */
  1982. break;
  1984.   case 'H': /* header */
  1985. chompflags = 0;
  1986. (void) chompheader(&bp[1], &chompflags, NULL, e);
  1987. hdrsize += strlen(&bp[1]);
  1988. break;
  1990.   case 'L': /* Solaris Content-Length: */
  1991.   case 'M': /* message */
  1992. /* ignore this; we want a new message next time */
  1993. break;
  1995.   case 'S': /* sender */
  1996. setsender(newstr(&bp[1]), e, NULL, '', TRUE);
  1997. break;
  1999.   case 'B': /* body type */
  2000. e->e_bodytype = newstr(&bp[1]);
  2001. break;
  2003. # if _FFR_SAVE_CHARSET
  2004.   case 'X': /* character set */
  2005. e->e_charset = newstr(&bp[1]);
  2006. break;
  2007. # endif /* _FFR_SAVE_CHARSET */
  2009.   case 'D': /* data file name */
  2010. /* obsolete -- ignore */
  2011. break;
  2013.   case 'T': /* init time */
  2014. e->e_ctime = atol(&bp[1]);
  2015. break;
  2017.   case 'I': /* data file's inode number */
  2018. /* regenerated below */
  2019. break;
  2021.   case 'K': /* time of last delivery attempt */
  2022. e->e_dtime = atol(&buf[1]);
  2023. break;
  2025. # if _FFR_QUEUEDELAY
  2026.   case 'G': /* queue delay algorithm */
  2027. e->e_queuealg = atoi(&buf[1]);
  2028. break;
  2029.   case 'Y': /* current delay */
  2030. e->e_queuedelay = (time_t) atol(&buf[1]);
  2031. break;
  2032. # endif /* _FFR_QUEUEDELAY */
  2034.   case 'N': /* number of delivery attempts */
  2035. e->e_ntries = atoi(&buf[1]);
  2037. /* if this has been tried recently, let it be */
  2038. if (e->e_ntries > 0 && e->e_dtime <= curtime() &&
  2039.     curtime() < e->e_dtime + queuedelay(e))
  2040. {
  2041. char *howlong;
  2043. howlong = pintvl(curtime() - e->e_dtime, TRUE);
  2044. if (Verbose)
  2045. printf("%s: too young (%s)n",
  2046.        e->e_id, howlong);
  2047. if (tTd(40, 8))
  2048. dprintf("%s: too young (%s)n",
  2049. e->e_id, howlong);
  2050. if (LogLevel > 19)
  2051. sm_syslog(LOG_DEBUG, e->e_id,
  2052.   "too young (%s)",
  2053.   howlong);
  2054. e->e_id = NULL;
  2055. unlockqueue(e);
  2056. return FALSE;
  2057. }
  2058. define(macid("{ntries}", NULL), newstr(&buf[1]), e);
  2060. # if NAMED_BIND
  2061. /* adjust BIND parameters immediately */
  2062. if (e->e_ntries == 0)
  2063. {
  2064. _res.retry = TimeOuts.res_retry[RES_TO_FIRST];
  2065. _res.retrans = TimeOuts.res_retrans[RES_TO_FIRST];
  2066. }
  2067. else
  2068. {
  2069. _res.retry = TimeOuts.res_retry[RES_TO_NORMAL];
  2070. _res.retrans = TimeOuts.res_retrans[RES_TO_NORMAL];
  2071. }
  2072. # endif /* NAMED_BIND */
  2073. break;
  2075.   case 'P': /* message priority */
  2076. e->e_msgpriority = atol(&bp[1]) + WkTimeFact;
  2077. break;
  2079.   case 'F': /* flag bits */
  2080. if (strncmp(bp, "From ", 5) == 0)
  2081. {
  2082. /* we are being spoofed! */
  2083. syserr("SECURITY ALERT: bogus qf line %s", bp);
  2084. (void) fclose(qfp);
  2085. loseqfile(e, "bogus queue line");
  2086. return FALSE;
  2087. }
  2088. for (p = &bp[1]; *p != ''; p++)
  2089. {
  2090. switch (*p)
  2091. {
  2092.   case 'w': /* warning sent */
  2093. e->e_flags |= EF_WARNING;
  2094. break;
  2096.   case 'r': /* response */
  2097. e->e_flags |= EF_RESPONSE;
  2098. break;
  2100.   case '8': /* has 8 bit data */
  2101. e->e_flags |= EF_HAS8BIT;
  2102. break;
  2104.   case 'b': /* delete Bcc: header */
  2105. e->e_flags |= EF_DELETE_BCC;
  2106. break;
  2108.   case 'd': /* envelope has DSN RET= */
  2109. e->e_flags |= EF_RET_PARAM;
  2110. break;
  2112.   case 'n': /* don't return body */
  2113. e->e_flags |= EF_NO_BODY_RETN;
  2114. break;
  2115. }
  2116. }
  2117. break;
  2119.   case 'Z': /* original envelope id from ESMTP */
  2120. e->e_envid = newstr(&bp[1]);
  2121. define(macid("{dsn_envid}", NULL), newstr(&bp[1]), e);
  2122. break;
  2124.   case 'A': /* AUTH= parameter */
  2125. e->e_auth_param = newstr(&bp[1]);
  2126. break;
  2128.   case '$': /* define macro */
  2129. mid = macid(&bp[1], &ep);
  2130. define(mid, newstr(ep), e);
  2131. break;
  2133.   case '.': /* terminate file */
  2134. nomore = TRUE;
  2135. break;
  2137.   default:
  2138. syserr("readqf: %s: line %d: bad line "%s"",
  2139. qf, LineNumber, shortenstring(bp, MAXSHORTSTR));
  2140. (void) fclose(qfp);
  2141. loseqfile(e, "unrecognized line");
  2142. return FALSE;
  2143. }
  2145. if (bp != buf)
  2146. free(bp);
  2147. }
  2149. /*
  2150. **  If we haven't read any lines, this queue file is empty.
  2151. **  Arrange to remove it without referencing any null pointers.
  2152. */
  2154. if (LineNumber == 0)
  2155. {
  2156. errno = 0;
  2157. e->e_flags |= EF_CLRQUEUE | EF_FATALERRS | EF_RESPONSE;
  2158. return TRUE;
  2159. }
  2161. /* possibly set ${dsn_ret} macro */
  2162. if (bitset(EF_RET_PARAM, e->e_flags))
  2163. {
  2164. if (bitset(EF_NO_BODY_RETN, e->e_flags))
  2165. define(macid("{dsn_ret}", NULL), "hdrs", e);
  2166. else
  2167. define(macid("{dsn_ret}", NULL), "full", e);
  2168. }
  2170. /*
  2171. **  Arrange to read the data file.
  2172. */
  2174. p = queuename(e, 'd');
  2175. e->e_dfp = fopen(p, "r");
  2176. if (e->e_dfp == NULL)
  2177. {
  2178. syserr("readqf: cannot open %s", p);
  2179. }
  2180. else
  2181. {
  2182. e->e_flags |= EF_HAS_DF;
  2183. if (fstat(fileno(e->e_dfp), &st) >= 0)
  2184. {
  2185. e->e_msgsize = st.st_size + hdrsize;
  2186. e->e_dfdev = st.st_dev;
  2187. e->e_dfino = st.st_ino;
  2188. }
  2189. }
  2191. return TRUE;
  2192. }
  2193. /*
  2194. **  PRINTQUEUE -- print out a representation of the mail queue
  2195. **
  2196. ** Parameters:
  2197. ** none.
  2198. **
  2199. ** Returns:
  2200. ** none.
  2201. **
  2202. ** Side Effects:
  2203. ** Prints a listing of the mail queue on the standard output.
  2204. */
  2206. void
  2207. printqueue()
  2208. {
  2209. int i, nrequests = 0;
  2211. for (i = 0; i < NumQueues; i++)
  2212. nrequests += print_single_queue(i);
  2213. if (NumQueues > 1)
  2214. printf("ttTotal Requests: %dn", nrequests);
  2215. }
  2216. /*
  2217. **  PRINT_SINGLE_QUEUE -- print out a representation of a single mail queue
  2218. **
  2219. ** Parameters:
  2220. ** queuedir -- queue directory
  2221. **
  2222. ** Returns:
  2223. ** none.
  2224. **
  2225. ** Side Effects:
  2226. ** Prints a listing of the mail queue on the standard output.
  2227. */
  2229. static int
  2230. print_single_queue(queuedir)
  2231. int queuedir;
  2232. {
  2233. register WORK *w;
  2234. FILE *f;
  2235. int nrequests;
  2236. char qd[MAXPATHLEN];
  2237. char qddf[MAXPATHLEN];
  2238. char buf[MAXLINE];
  2240. if (queuedir == NOQDIR)
  2241. {
  2242. (void) strlcpy(qd, ".", sizeof qd);
  2243. (void) strlcpy(qddf, ".", sizeof qddf);
  2244. }
  2245. else
  2246. {
  2247. (void) snprintf(qd, sizeof qd, "%s%s",
  2248. QPaths[queuedir].qp_name,
  2249. (bitset(QP_SUBQF, QPaths[queuedir].qp_subdirs) ? "/qf" : ""));
  2250. (void) snprintf(qddf, sizeof qddf, "%s%s",
  2251. QPaths[queuedir].qp_name,
  2252. (bitset(QP_SUBDF, QPaths[queuedir].qp_subdirs) ? "/df" : ""));
  2253. }
  2255. /*
  2256. **  Check for permission to print the queue
  2257. */
  2259. if (bitset(PRIV_RESTRICTMAILQ, PrivacyFlags) && RealUid != 0)
  2260. {
  2261. struct stat st;
  2262. # ifdef NGROUPS_MAX
  2263. int n;
  2264. extern GIDSET_T InitialGidSet[NGROUPS_MAX];
  2265. # endif /* NGROUPS_MAX */
  2267. if (stat(qd, &st) < 0)
  2268. {
  2269. syserr("Cannot stat %s", qid_printqueue(queuedir));
  2270. return 0;
  2271. }
  2272. # ifdef NGROUPS_MAX
  2273. n = NGROUPS_MAX;
  2274. while (--n >= 0)
  2275. {
  2276. if (InitialGidSet[n] == st.st_gid)
  2277. break;
  2278. }
  2279. if (n < 0 && RealGid != st.st_gid)
  2280. # else /* NGROUPS_MAX */
  2281. if (RealGid != st.st_gid)
  2282. # endif /* NGROUPS_MAX */
  2283. {
  2284. usrerr("510 You are not permitted to see the queue");
  2285. setstat(EX_NOPERM);
  2286. return 0;
  2287. }
  2288. }
  2290. /*
  2291. **  Read and order the queue.
  2292. */
  2294. nrequests = orderq(queuedir, TRUE);
  2296. /*
  2297. **  Print the work list that we have read.
  2298. */
  2300. /* first see if there is anything */
  2301. if (nrequests <= 0)
  2302. {
  2303. printf("%s is emptyn", qid_printqueue(queuedir));
  2304. return 0;
  2305. }
  2307. CurrentLA = sm_getla(NULL); /* get load average */
  2309. printf("tt%s (%d request%s", qid_printqueue(queuedir), nrequests,
  2310.        nrequests == 1 ? "" : "s");
  2311. if (MaxQueueRun > 0 && nrequests > MaxQueueRun)
  2312. printf(", only %d printed", MaxQueueRun);
  2313. if (Verbose)
  2314. printf(")n----Q-ID---- --Size-- -Priority- ---Q-Time--- ---------Sender/Recipient--------n");
  2315. else
  2316. printf(")n----Q-ID---- --Size-- -----Q-Time----- ------------Sender/Recipient------------n");
  2317. for (w = WorkQ; w != NULL; w = w->w_next)
  2318. {
  2319. struct stat st;
  2320. auto time_t submittime = 0;
  2321. long dfsize;
  2322. int flags = 0;
  2323. int qfver;
  2324. char statmsg[MAXLINE];
  2325. char bodytype[MAXNAME + 1];
  2326. char qf[MAXPATHLEN];
  2328. printf("%12s", w->w_name + 2);
  2329. (void) snprintf(qf, sizeof qf, "%s/%s", qd, w->w_name);
  2330. f = fopen(qf, "r");
  2331. if (f == NULL)
  2332. {
  2333. printf(" (job completed)n");
  2334. errno = 0;
  2335. continue;
  2336. }
  2337. w->w_name[0] = 'd';
  2338. (void) snprintf(qf, sizeof qf, "%s/%s", qddf, w->w_name);
  2339. if (stat(qf, &st) >= 0)
  2340. dfsize = st.st_size;
  2341. else
  2342. dfsize = -1;
  2343. if (w->w_lock)
  2344. printf("*");
  2345. else if (w->w_tooyoung)
  2346. printf("-");
  2347. else if (shouldqueue(w->w_pri, w->w_ctime))
  2348. printf("X");
  2349. else
  2350. printf(" ");
  2351. errno = 0;
  2353. statmsg[0] = bodytype[0] = '';
  2354. qfver = 0;
  2355. while (fgets(buf, sizeof buf, f) != NULL)
  2356. {
  2357. register int i;
  2358. register char *p;
  2360. fixcrlf(buf, TRUE);
  2361. switch (buf[0])
  2362. {
  2363.   case 'V': /* queue file version */
  2364. qfver = atoi(&buf[1]);
  2365. break;
  2367.   case 'M': /* error message */
  2368. if ((i = strlen(&buf[1])) >= sizeof statmsg)
  2369. i = sizeof statmsg - 1;
  2370. memmove(statmsg, &buf[1], i);
  2371. statmsg[i] = '';
  2372. break;
  2374.   case 'B': /* body type */
  2375. if ((i = strlen(&buf[1])) >= sizeof bodytype)
  2376. i = sizeof bodytype - 1;
  2377. memmove(bodytype, &buf[1], i);
  2378. bodytype[i] = '';
  2379. break;
  2381.   case 'S': /* sender name */
  2382. if (Verbose)
  2383. printf("%8ld %10ld%c%.12s %.78s",
  2384.        dfsize,
  2385.        w->w_pri,
  2386.        bitset(EF_WARNING, flags) ? '+' : ' ',
  2387.        ctime(&submittime) + 4,
  2388.        &buf[1]);
  2389. else
  2390. printf("%8ld %.16s %.40s", dfsize,
  2391.     ctime(&submittime), &buf[1]);
  2392. if (statmsg[0] != '' || bodytype[0] != '')
  2393. {
  2394. printf("n    %10.10s", bodytype);
  2395. if (statmsg[0] != '')
  2396. printf("   (%.*s)",
  2397.        Verbose ? 100 : 60,
  2398.        statmsg);
  2399. }
  2400. break;
  2402.   case 'C': /* controlling user */
  2403. if (Verbose)
  2404. printf("ntttt      (---%.74s---)",
  2405.        &buf[1]);
  2406. break;
  2408.   case 'R': /* recipient name */
  2409. p = &buf[1];
  2410. if (qfver >= 1)
  2411. {
  2412. p = strchr(p, ':');
  2413. if (p == NULL)
  2414. break;
  2415. p++;
  2416. }
  2417. if (Verbose)
  2418. printf("nttttt      %.73s", p);
  2419. else
  2420. printf("ntttt       %.40s", p);
  2421. break;
  2423.   case 'T': /* creation time */
  2424. submittime = atol(&buf[1]);
  2425. break;
  2427.   case 'F': /* flag bits */
  2428. for (p = &buf[1]; *p != ''; p++)
  2429. {
  2430. switch (*p)
  2431. {
  2432.   case 'w':
  2433. flags |= EF_WARNING;
  2434. break;
  2435. }
  2436. }
  2437. }
  2438. }
  2439. if (submittime == (time_t) 0)
  2440. printf(" (no control file)");
  2441. printf("n");
  2442. (void) fclose(f);
  2443. }
  2444. return nrequests;
  2445. }
  2446. /*
  2447. **  QUEUENAME -- build a file name in the queue directory for this envelope.
  2448. **
  2449. ** Parameters:
  2450. ** e -- envelope to build it in/from.
  2451. ** type -- the file type, used as the first character
  2452. ** of the file name.
  2453. **
  2454. ** Returns:
  2455. ** a pointer to the queue name (in a static buffer).
  2456. **
  2457. ** Side Effects:
  2458. ** If no id code is already assigned, queuename() will
  2459. ** assign an id code with assign_queueid().  If no queue
  2460. ** directory is assigned, one will be set with setnewqueue().
  2461. */
  2463. char *
  2464. queuename(e, type)
  2465. register ENVELOPE *e;
  2466. int type;
  2467. {
  2468. char *sub = "";
  2469. static char buf[MAXPATHLEN];
  2471. /* Assign an ID if needed */
  2472. if (e->e_id == NULL)
  2473. assign_queueid(e);
  2475. /* Assign a queue directory if needed */
  2476. if (e->e_queuedir == NOQDIR)
  2477. setnewqueue(e);
  2479. if (e->e_queuedir == NOQDIR)
  2480. (void) snprintf(buf, sizeof buf, "%cf%s",
  2481. type, e->e_id);
  2482. else
  2483. {
  2484. switch (type)
  2485. {
  2486.   case 'd':
  2487. if (bitset(QP_SUBDF, QPaths[e->e_queuedir].qp_subdirs))
  2488. sub = "/df";
  2489. break;
  2491.   case 'T':
  2492.   case 't':
  2493.   case 'Q':
  2494.   case 'q':
  2495. if (bitset(QP_SUBQF, QPaths[e->e_queuedir].qp_subdirs))
  2496. sub = "/qf";
  2497. break;
  2499.   case 'x':
  2500. if (bitset(QP_SUBXF, QPaths[e->e_queuedir].qp_subdirs))
  2501. sub = "/xf";
  2502. break;
  2503. }
  2505. (void) snprintf(buf, sizeof buf, "%s%s/%cf%s",
  2506. QPaths[e->e_queuedir].qp_name,
  2507. sub, type, e->e_id);
  2508. }
  2510. if (tTd(7, 2))
  2511. dprintf("queuename: %sn", buf);
  2512. return buf;
  2513. }
  2514. /*
  2515. **  ASSIGN_QUEUEID -- assign a queue ID for this envelope.
  2516. **
  2517. ** Assigns an id code if one does not already exist.
  2518. ** This code assumes that nothing will remain in the queue for
  2519. ** longer than 60 years.  It is critical that files with the given
  2520. ** name not already exist in the queue.
  2521. ** Also initializes e_queuedir to NOQDIR.
  2522. **
  2523. ** Parameters:
  2524. ** e -- envelope to set it in.
  2525. **
  2526. ** Returns:
  2527. ** none.
  2528. */
  2530. static char Base60Code[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwx";
  2532. void
  2533. assign_queueid(e)
  2534. register ENVELOPE *e;
  2535. {
  2536. pid_t pid = getpid();
  2537. static char cX = 0;
  2538. static long random_offset;
  2539. struct tm *tm;
  2540. char idbuf[MAXQFNAME - 2];
  2542. if (e->e_id != NULL)
  2543. return;
  2545. /* see if we need to get a new base time/pid */
  2546. if (cX >= 60 || LastQueueTime == 0 || LastQueuePid != pid)
  2547. {
  2548. time_t then = LastQueueTime;
  2550. /* if the first time through, pick a random offset */
  2551. if (LastQueueTime == 0)
  2552. random_offset = get_random();
  2554. while ((LastQueueTime = curtime()) == then &&
  2555.        LastQueuePid == pid)
  2556. {
  2557. (void) sleep(1);
  2558. }
  2559. LastQueuePid = getpid();
  2560. cX = 0;
  2561. }
  2562. if (tTd(7, 50))
  2563. dprintf("assign_queueid: random_offset = %ld (%d)n",
  2564. random_offset, (int)(cX + random_offset) % 60);
  2566. tm = gmtime(&LastQueueTime);
  2567. idbuf[0] = Base60Code[tm->tm_year % 60];
  2568. idbuf[1] = Base60Code[tm->tm_mon];
  2569. idbuf[2] = Base60Code[tm->tm_mday];
  2570. idbuf[3] = Base60Code[tm->tm_hour];
  2571. idbuf[4] = Base60Code[tm->tm_min];
  2572. idbuf[5] = Base60Code[tm->tm_sec];
  2573. idbuf[6] = Base60Code[((int)cX++ + random_offset) % 60];
  2574. (void) snprintf(&idbuf[7], sizeof idbuf - 7, "%05d",
  2575. (int) LastQueuePid);
  2576. e->e_id = newstr(idbuf);
  2577. define('i', e->e_id, e);
  2578. e->e_queuedir = NOQDIR;
  2579. if (tTd(7, 1))
  2580. dprintf("assign_queueid: assigned id %s, e=%lxn",
  2581. e->e_id, (u_long) e);
  2582. if (LogLevel > 93)
  2583. sm_syslog(LOG_DEBUG, e->e_id, "assigned id");
  2584. }
  2585. /*
  2586. **  SYNC_QUEUE_TIME -- Assure exclusive PID in any given second
  2587. **
  2588. ** Make sure one PID can't be used by two processes in any one second.
  2589. **
  2590. ** If the system rotates PIDs fast enough, may get the
  2591. ** same pid in the same second for two distinct processes.
  2592. ** This will interfere with the queue file naming system.
  2593. **
  2594. ** Parameters:
  2595. ** none
  2596. **
  2597. ** Returns:
  2598. ** none
  2599. */
  2600. void
  2601. sync_queue_time()
  2602. {
  2603. # if FAST_PID_RECYCLE
  2604. if (OpMode != MD_TEST &&
  2605.     OpMode != MD_VERIFY &&
  2606.     LastQueueTime > 0 &&
  2607.     LastQueuePid == getpid() &&
  2608.     curtime() == LastQueueTime)
  2609. (void) sleep(1);
  2610. # endif /* FAST_PID_RECYCLE */
  2611. }
  2612. /*
  2613. **  UNLOCKQUEUE -- unlock the queue entry for a specified envelope
  2614. **
  2615. ** Parameters:
  2616. ** e -- the envelope to unlock.
  2617. **
  2618. ** Returns:
  2619. ** none
  2620. **
  2621. ** Side Effects:
  2622. ** unlocks the queue for `e'.
  2623. */
  2625. void
  2626. unlockqueue(e)
  2627. ENVELOPE *e;
  2628. {
  2629. if (tTd(51, 4))
  2630. dprintf("unlockqueue(%s)n",
  2631. e->e_id == NULL ? "NOQUEUE" : e->e_id);
  2633. /* if there is a lock file in the envelope, close it */
  2634. if (e->e_lockfp != NULL)
  2635. (void) fclose(e->e_lockfp);
  2636. e->e_lockfp = NULL;
  2638. /* don't create a queue id if we don't already have one */
  2639. if (e->e_id == NULL)
  2640. return;
  2642. /* remove the transcript */
  2643. if (LogLevel > 87)
  2644. sm_syslog(LOG_DEBUG, e->e_id, "unlock");
  2645. if (!tTd(51, 104))
  2646. xunlink(queuename(e, 'x'));
  2648. }
  2649. /*
  2650. **  SETCTLUSER -- create a controlling address
  2651. **
  2652. ** Create a fake "address" given only a local login name; this is
  2653. ** used as a "controlling user" for future recipient addresses.
  2654. **
  2655. ** Parameters:
  2656. ** user -- the user name of the controlling user.
  2657. ** qfver -- the version stamp of this qf file.
  2658. **
  2659. ** Returns:
  2660. ** An address descriptor for the controlling user.
  2661. **
  2662. ** Side Effects:
  2663. ** none.
  2664. */
  2666. static ADDRESS *
  2667. setctluser(user, qfver)
  2668. char *user;
  2669. int qfver;
  2670. {
  2671. register ADDRESS *a;
  2672. struct passwd *pw;
  2673. char *p;
  2675. /*
  2676. **  See if this clears our concept of controlling user.
  2677. */
  2679. if (user == NULL || *user == '')
  2680. return NULL;
  2682. /*
  2683. **  Set up addr fields for controlling user.
  2684. */
  2686. a = (ADDRESS *) xalloc(sizeof *a);
  2687. memset((char *) a, '', sizeof *a);
  2689. if (*user == '')
  2690. {
  2691. p = NULL;
  2692. a->q_user = newstr(DefUser);
  2693. }
  2694. else if (*user == ':')
  2695. {
  2696. p = &user[1];
  2697. a->q_user = newstr(p);
  2698. }
  2699. else
  2700. {
  2701. p = strtok(user, ":");
  2702. a->q_user = newstr(user);
  2703. if (qfver >= 2)
  2704. {
  2705. if ((p = strtok(NULL, ":")) != NULL)
  2706. a->q_uid = atoi(p);
  2707. if ((p = strtok(NULL, ":")) != NULL)
  2708. a->q_gid = atoi(p);
  2709. if ((p = strtok(NULL, ":")) != NULL)
  2710. a->q_flags |= QGOODUID;
  2711. }
  2712. else if ((pw = sm_getpwnam(user)) != NULL)
  2713. {
  2714. if (strcmp(pw->pw_dir, "/") == 0)
  2715. a->q_home = "";
  2716. else
  2717. a->q_home = newstr(pw->pw_dir);
  2718. a->q_uid = pw->pw_uid;
  2719. a->q_gid = pw->pw_gid;
  2720. a->q_flags |= QGOODUID;
  2721. }
  2722. }
  2724. a->q_flags |= QPRIMARY; /* flag as a "ctladdr" */
  2725. a->q_mailer = LocalMailer;
  2726. if (p == NULL)
  2727. a->q_paddr = newstr(a->q_user);
  2728. else
  2729. a->q_paddr = newstr(p);
  2730. return a;
  2731. }
  2732. /*
  2733. **  LOSEQFILE -- save the qf as Qf and try to let someone know
  2734. **
  2735. ** Parameters:
  2736. ** e -- the envelope (e->e_id will be used).
  2737. ** why -- reported to whomever can hear.
  2738. **
  2739. ** Returns:
  2740. ** none.
  2741. */
  2743. void
  2744. loseqfile(e, why)
  2745. register ENVELOPE *e;
  2746. char *why;
  2747. {
  2748. char *p;
  2749. char buf[MAXPATHLEN];
  2751. if (e == NULL || e->e_id == NULL)
  2752. return;
  2753. p = queuename(e, 'q');
  2754. if (strlen(p) >= (SIZE_T) sizeof buf)
  2755. return;
  2756. (void) strlcpy(buf, p, sizeof buf);
  2757. p = queuename(e, 'Q');
  2758. if (rename(buf, p) < 0)
  2759. syserr("cannot rename(%s, %s), uid=%d", buf, p, geteuid());
  2760. else if (LogLevel > 0)
  2761. sm_syslog(LOG_ALERT, e->e_id,
  2762.   "Losing %s: %s", buf, why);
  2763. }
  2764. /*
  2765. **  QID_PRINTNAME -- create externally printable version of queue id
  2766. **
  2767. ** Parameters:
  2768. ** e -- the envelope.
  2769. **
  2770. ** Returns:
  2771. ** a printable version
  2772. */
  2774. char *
  2775. qid_printname(e)
  2776. ENVELOPE *e;
  2777. {
  2778. char *id;
  2779. static char idbuf[MAXQFNAME + 34];
  2781. if (e == NULL)
  2782. return "";
  2784. if (e->e_id == NULL)
  2785. id = "";
  2786. else
  2787. id = e->e_id;
  2789. if (e->e_queuedir == NOQDIR)
  2790. return id;
  2792. (void) snprintf(idbuf, sizeof idbuf, "%.32s/%s",
  2793. QPaths[e->e_queuedir].qp_name, id);
  2794. return idbuf;
  2795. }
  2796. /*
  2797. **  QID_PRINTQUEUE -- create full version of queue directory for df files
  2798. **
  2799. ** Parameters:
  2800. ** queuedir -- the short version of the queue directory
  2801. **
  2802. ** Returns:
  2803. ** the full pathname to the queue (static)
  2804. */
  2806. char *
  2807. qid_printqueue(queuedir)
  2808. int queuedir;
  2809. {
  2810. char *subdir;
  2811. static char dir[MAXPATHLEN];
  2813. if (queuedir == NOQDIR)
  2814. return QueueDir;
  2816. if (strcmp(QPaths[queuedir].qp_name, ".") == 0)
  2817. subdir = NULL;
  2818. else
  2819. subdir = QPaths[queuedir].qp_name;
  2821. (void) snprintf(dir, sizeof dir, "%s%s%s%s", QueueDir,
  2822. subdir == NULL ? "" : "/",
  2823. subdir == NULL ? "" : subdir,
  2824. (bitset(QP_SUBDF, QPaths[queuedir].qp_subdirs) ? "/df" : ""));
  2825. return dir;
  2826. }
  2827. /*
  2828. **  SETNEWQUEUE -- Sets a new queue directory
  2829. **
  2830. ** Assign a queue directory to an envelope and store the directory
  2831. ** in e->e_queuedir.  The queue is chosen at random.
  2832. **
  2833. ** This routine may be improved in the future to allow for more
  2834. ** elaborate queueing schemes.  Suggestions and code contributions
  2835. ** are welcome.
  2836. **
  2837. ** Parameters:
  2838. ** e -- envelope to assign a queue for.
  2839. **
  2840. ** Returns:
  2841. ** none.
  2842. */
  2844. void
  2845. setnewqueue(e)
  2846. ENVELOPE *e;
  2847. {
  2848. int idx;
  2850. if (tTd(41, 20))
  2851. dprintf("setnewqueue: calledn");
  2853. if (e->e_queuedir != NOQDIR)
  2854. {
  2855. if (tTd(41, 20))
  2856. dprintf("setnewqueue: e_queuedir already assigned (%s)n",
  2857. qid_printqueue(e->e_queuedir));
  2858. return;
  2859. }
  2861. if (NumQueues == 1)
  2862. idx = 0;
  2863. else
  2864. {
  2865. idx = get_random() % NumQueues;
  2866. if (tTd(41, 15))
  2867. dprintf("setnewqueue: get_random() %% %d = %dn",
  2868. NumQueues, idx);
  2869. }
  2871. e->e_queuedir = idx;
  2872. if (tTd(41, 3))
  2873. dprintf("setnewqueue: Assigned queue directory %sn",
  2874. qid_printqueue(e->e_queuedir));
  2875. }
  2877. /*
  2878. **  CHKQDIR -- check a queue directory
  2879. **
  2880. ** Parameters:
  2881. ** name -- name of queue directory
  2882. ** sff -- flags for safefile()
  2883. **
  2884. ** Returns:
  2885. ** is it a queue directory?
  2886. */
  2888. static bool
  2889. chkqdir(name, sff)
  2890. char *name;
  2891. long sff;
  2892. {
  2893. struct stat statb;
  2894. int i;
  2896. # if HASLSTAT
  2897. if (lstat(name, &statb) < 0)
  2898. # else /* HASLSTAT */
  2899. if (stat(name, &statb) < 0)
  2900. # endif /* HASLSTAT */
  2901. {
  2902. if (tTd(41, 2))
  2903. dprintf("multiqueue_cache: stat("%s"): %sn",
  2904. name, errstring(errno));
  2905. return FALSE;
  2906. }
  2907. # if HASLSTAT
  2908. if (S_ISLNK(statb.st_mode))
  2909. {
  2910. /*
  2911. **  For a symlink we need to make sure the
  2912. **  target is a directory
  2913. */
  2914. if (stat(name, &statb) < 0)
  2915. {
  2916. if (tTd(41, 2))
  2917. dprintf("multiqueue_cache: stat("%s"): %sn",
  2918. name, errstring(errno));
  2919. return FALSE;
  2920. }
  2921. }
  2922. # endif /* HASLSTAT */
  2924. if (!S_ISDIR(statb.st_mode))
  2925. {
  2926. if (tTd(41, 2))
  2927. dprintf("multiqueue_cache: "%s": Not a directoryn",
  2928. name);
  2929. return FALSE;
  2930. }
  2932. /* Print a warning if unsafe (but still use it) */
  2933. i = safedirpath(name, RunAsUid, RunAsGid, NULL, sff, 0, 0);
  2934. if (i != 0 && tTd(41, 2))
  2935. dprintf("multiqueue_cache: "%s": Not safe: %sn",
  2936. name, errstring(i));
  2937. return TRUE;
  2938. }
  2940. /*
  2941. **  MULTIQUEUE_CACHE -- cache a list of paths to queues.
  2942. **
  2943. ** Each potential queue is checked as the cache is built.
  2944. ** Thereafter, each is blindly trusted.
  2945. ** Note that we can be called again after a timeout to rebuild
  2946. ** (although code for that is not ready yet).
  2947. **
  2948. ** Parameters:
  2949. ** none
  2950. **
  2951. ** Returns:
  2952. ** none
  2953. */
  2955. void
  2956. multiqueue_cache()
  2957. {
  2958. register DIR *dp;
  2959. register struct dirent *d;
  2960. char *cp;
  2961. int i, len;
  2962. int slotsleft = 0;
  2963. long sff = SFF_ANYFILE;
  2964. char qpath[MAXPATHLEN];
  2965. char subdir[MAXPATHLEN];
  2967. if (tTd(41, 20))
  2968. dprintf("multiqueue_cache: calledn");
  2970. if (NumQueues != 0 && QPaths != NULL)
  2971. {
  2972. for (i = 0; i < NumQueues; i++)
  2973. {
  2974. if (QPaths[i].qp_name != NULL)
  2975. (void) free(QPaths[i].qp_name);
  2976. }
  2977. (void) free((char *)QPaths);
  2978. QPaths = NULL;
  2979. NumQueues = 0;
  2980. }
  2982. /* If running as root, allow safedirpath() checks to use privs */
  2983. if (RunAsUid == 0)
  2984. sff |= SFF_ROOTOK;
  2986. (void) snprintf(qpath, sizeof qpath, "%s", QueueDir);
  2987. len = strlen(qpath) - 1;
  2988. cp = &qpath[len];
  2989. if (*cp == '*')
  2990. {
  2991. *cp = '';
  2992. if ((cp = strrchr(qpath, '/')) == NULL)
  2993. {
  2994. syserr("QueueDirectory: can not wildcard relative path");
  2995. if (tTd(41, 2))
  2996. dprintf("multiqueue_cache: "%s": Can not wildcard relative path.n",
  2997. QueueDir);
  2998. ExitStat = EX_CONFIG;
  2999. return;
  3000. }
  3001. if (cp == qpath)
  3002. {
  3003. /*
  3004. **  Special case of top level wildcard, like /foo*
  3005. */
  3007. (void) snprintf(qpath + 1, sizeof qpath - 1,
  3008. "%s", qpath);
  3009. ++cp;
  3010. }
  3011. *(cp++) = '';
  3012. len = strlen(cp);
  3014. if (tTd(41, 2))
  3015. dprintf("multiqueue_cache: prefix="%s"n", cp);
  3017. QueueDir = newstr(qpath);
  3019. /*
  3020. **  XXX Should probably wrap this whole loop in a timeout
  3021. **  in case some wag decides to NFS mount the queues.
  3022. */
  3024. /* test path to get warning messages */
  3025. i= safedirpath(QueueDir, RunAsUid, RunAsGid, NULL, sff, 0, 0);
  3026. if (i != 0 && tTd(41, 2))
  3027. dprintf("multiqueue_cache: "%s": Not safe: %sn",
  3028. QueueDir, errstring(i));
  3030. if (chdir(QueueDir) < 0)
  3031. {
  3032. syserr("can not chdir(%s)", QueueDir);
  3033. if (tTd(41, 2))
  3034. dprintf("multiqueue_cache: "%s": %sn",
  3035. qpath, errstring(errno));
  3036. ExitStat = EX_CONFIG;
  3037. return;
  3038. }
  3040. if ((dp = opendir(".")) == NULL)
  3041. {
  3042. syserr("can not opendir(%s)", QueueDir);
  3043. if (tTd(41, 2))
  3044. dprintf("multiqueue_cache: opendir("%s"): %sn",
  3045. QueueDir, errstring(errno));
  3046. ExitStat = EX_CONFIG;
  3047. return;
  3048. }
  3049. while ((d = readdir(dp)) != NULL)
  3050. {
  3051. if (strncmp(d->d_name, cp, len) != 0)
  3052. {
  3053. if (tTd(41, 5))
  3054. dprintf("multiqueue_cache: "%s", skippedn",
  3055. d->d_name);
  3056. continue;
  3057. }
  3058. if (!chkqdir(d->d_name, sff))
  3059. continue;
  3061. if (QPaths == NULL)
  3062. {
  3063. slotsleft = 20;
  3064. QPaths = (QPATHS *)xalloc((sizeof *QPaths) *
  3065.   slotsleft);
  3066. NumQueues = 0;
  3067. }
  3068. else if (slotsleft < 1)
  3069. {
  3070. QPaths = (QPATHS *)realloc((char *)QPaths,
  3071.   (sizeof *QPaths) *
  3072.   (NumQueues + 10));
  3073. if (QPaths == NULL)
  3074. {
  3075. (void) closedir(dp);
  3076. return;
  3077. }
  3078. slotsleft += 10;
  3079. }
  3081. /* check subdirs */
  3082. QPaths[NumQueues].qp_subdirs = QP_NOSUB;
  3083. (void) snprintf(subdir, sizeof subdir, "%s/%s/%s",
  3084. qpath, d->d_name, "qf");
  3085. if (chkqdir(subdir, sff))
  3086. QPaths[NumQueues].qp_subdirs |= QP_SUBQF;
  3088. (void) snprintf(subdir, sizeof subdir, "%s/%s/%s",
  3089. qpath, d->d_name, "df");
  3090. if (chkqdir(subdir, sff))
  3091. QPaths[NumQueues].qp_subdirs |= QP_SUBDF;
  3093. (void) snprintf(subdir, sizeof subdir, "%s/%s/%s",
  3094. qpath, d->d_name, "xf");
  3095. if (chkqdir(subdir, sff))
  3096. QPaths[NumQueues].qp_subdirs |= QP_SUBXF;
  3098. /* assert(strlen(d->d_name) < MAXPATHLEN - 14) */
  3099. /* maybe even - 17 (subdirs) */
  3100. QPaths[NumQueues].qp_name = newstr(d->d_name);
  3101. if (tTd(41, 2))
  3102. dprintf("multiqueue_cache: %d: "%s" cached (%x).n",
  3103. NumQueues, d->d_name,
  3104. QPaths[NumQueues].qp_subdirs);
  3105. NumQueues++;
  3106. slotsleft--;
  3107. }
  3108. (void) closedir(dp);
  3109. }
  3110. if (NumQueues == 0)
  3111. {
  3112. if (*cp != '*' && tTd(41, 2))
  3113. dprintf("multiqueue_cache: "%s": No wildcard suffix charactern",
  3114. QueueDir);
  3115. QPaths = (QPATHS *)xalloc(sizeof *QPaths);
  3116. QPaths[0].qp_name = newstr(".");
  3117. QPaths[0].qp_subdirs = QP_NOSUB;
  3118. NumQueues = 1;
  3120. /* test path to get warning messages */
  3121. (void) safedirpath(QueueDir, RunAsUid, RunAsGid,
  3122.    NULL, sff, 0, 0);
  3123. if (chdir(QueueDir) < 0)
  3124. {
  3125. syserr("can not chdir(%s)", QueueDir);
  3126. if (tTd(41, 2))
  3127. dprintf("multiqueue_cache: "%s": %sn",
  3128. QueueDir, errstring(errno));
  3129. ExitStat = EX_CONFIG;
  3130. }
  3132. /* check subdirs */
  3133. (void) snprintf(subdir, sizeof subdir, "%s/qf", QueueDir);
  3134. if (chkqdir(subdir, sff))
  3135. QPaths[0].qp_subdirs |= QP_SUBQF;
  3137. (void) snprintf(subdir, sizeof subdir, "%s/df", QueueDir);
  3138. if (chkqdir(subdir, sff))
  3139. QPaths[0].qp_subdirs |= QP_SUBDF;
  3141. (void) snprintf(subdir, sizeof subdir, "%s/xf", QueueDir);
  3142. if (chkqdir(subdir, sff))
  3143. QPaths[0].qp_subdirs |= QP_SUBXF;
  3144. }
  3145. }
  3147. # if 0
  3148. /*
  3149. **  HASHFQN -- calculate a hash value for a fully qualified host name
  3150. **
  3151. ** Arguments:
  3152. ** fqn -- an all lower-case host.domain string
  3153. ** buckets -- the number of buckets (queue directories)
  3154. **
  3155. ** Returns:
  3156. ** a bucket number (signed integer)
  3157. ** -1 on error
  3158. **
  3159. ** Contributed by Exactis.com, Inc.
  3160. */
  3162. int
  3163. hashfqn(fqn, buckets)
  3164. register char *fqn;
  3165. int buckets;
  3166. {
  3167. register char *p;
  3168. register int h = 0, hash, cnt;
  3169. #  define WATERINC (1000)
  3171. if (fqn == NULL)
  3172. return -1;
  3174. /*
  3175. **  A variation on the gdb hash
  3176. **  This is the best as of Feb 19, 1996 --bcx
  3177. */
  3179. p = fqn;
  3180. h = 0x238F13AF * strlen(p);
  3181. for (cnt = 0; *p != 0; ++p, cnt++)
  3182. {
  3183. h = (h + (*p << (cnt * 5 % 24))) & 0x7FFFFFFF;
  3184. }
  3185. h = (1103515243 * h + 12345) & 0x7FFFFFFF;
  3186. if (buckets < 2)
  3187. hash = 0;
  3188. else
  3189. hash = (h % buckets);
  3191. return hash;
  3192. }
  3193. # endif /* 0 */
  3195. # if _FFR_QUEUEDELAY
  3196. /*
  3197. **  QUEUEDELAY -- compute queue delay time
  3198. **
  3199. ** Parameters:
  3200. ** e -- the envelope to queue up.
  3201. **
  3202. ** Returns:
  3203. ** queue delay time
  3204. **
  3205. ** Side Effects:
  3206. ** may change e_queuedelay
  3207. */
  3209. static time_t
  3210. queuedelay(e)
  3211. ENVELOPE *e;
  3212. {
  3213. time_t qd;
  3215. if (e->e_queuealg == QD_EXP)
  3216. {
  3217. if (e->e_queuedelay == 0)
  3218. e->e_queuedelay = QueueInitDelay;
  3219. else
  3220. {
  3221. e->e_queuedelay *= 2;
  3222. if (e->e_queuedelay > QueueMaxDelay)
  3223. e->e_queuedelay = QueueMaxDelay;
  3224. }
  3225. qd = e->e_queuedelay;
  3226. }
  3227. else
  3228. qd = MinQueueAge;
  3229. return qd;
  3230. }
  3231. # endif /* _FFR_QUEUEDELAY */
  3232. #endif /* QUEUE */