![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to queue.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src|
Return to queue.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src |
1.1 root 1: # include "sendmail.h"
2: # include <sys/stat.h>
3: # include <sys/dir.h>
4: # include <signal.h>
5: # include <errno.h>
6:
7: # ifndef QUEUE
8: SCCSID(@(#)queue.c 4.1 7/25/83 (no queueing));
9: # else QUEUE
10:
11: SCCSID(@(#)queue.c 4.1 7/25/83);
12:
13: /*
14: ** Work queue.
15: */
16:
17: struct work
18: {
19: char *w_name; /* name of control file */
20: long w_pri; /* priority of message, see below */
21: struct work *w_next; /* next in queue */
22: };
23:
24: typedef struct work WORK;
25:
26: WORK *WorkQ; /* queue of things to be done */
27: /*
28: ** QUEUEUP -- queue a message up for future transmission.
29: **
30: ** Parameters:
31: ** e -- the envelope to queue up.
32: ** queueall -- if TRUE, queue all addresses, rather than
33: ** just those with the QQUEUEUP flag set.
34: ** announce -- if TRUE, tell when you are queueing up.
35: **
36: ** Returns:
37: ** none.
38: **
39: ** Side Effects:
40: ** The current request are saved in a control file.
41: */
42:
43: queueup(e, queueall, announce)
44: register ENVELOPE *e;
45: bool queueall;
46: bool announce;
47: {
48: char *tf;
49: char *qf;
50: char buf[MAXLINE];
51: register FILE *tfp;
52: register HDR *h;
53: register ADDRESS *q;
54: MAILER nullmailer;
55:
56: /*
57: ** Create control file.
58: */
59:
60: tf = newstr(queuename(e, 't'));
61: tfp = fopen(tf, "w");
62: if (tfp == NULL)
63: {
64: syserr("queueup: cannot create temp file %s", tf);
65: return;
66: }
67: (void) chmod(tf, FileMode);
68:
69: # ifdef DEBUG
70: if (tTd(40, 1))
71: printf("queueing in %s\n", tf);
72: # endif DEBUG
73:
74: /*
75: ** If there is no data file yet, create one.
76: */
77:
78: if (e->e_df == NULL)
79: {
80: register FILE *dfp;
81: extern putbody();
82:
83: e->e_df = newstr(queuename(e, 'd'));
84: dfp = fopen(e->e_df, "w");
85: if (dfp == NULL)
86: {
87: syserr("queueup: cannot create %s", e->e_df);
88: (void) fclose(tfp);
89: return;
90: }
91: (void) chmod(e->e_df, FileMode);
92: (*e->e_putbody)(dfp, ProgMailer, e);
93: (void) fclose(dfp);
94: e->e_putbody = putbody;
95: }
96:
97: /*
98: ** Output future work requests.
99: ** Priority should be first, since it is read by orderq.
100: */
101:
102: /* output message priority */
103: fprintf(tfp, "P%ld\n", e->e_msgpriority);
104:
105: /* output creation time */
106: fprintf(tfp, "T%ld\n", e->e_ctime);
107:
108: /* output name of data file */
109: fprintf(tfp, "D%s\n", e->e_df);
110:
111: /* message from envelope, if it exists */
112: if (e->e_message != NULL)
113: fprintf(tfp, "M%s\n", e->e_message);
114:
115: /* output name of sender */
116: fprintf(tfp, "S%s\n", e->e_from.q_paddr);
117:
118: /* output list of recipient addresses */
119: for (q = e->e_sendqueue; q != NULL; q = q->q_next)
120: {
121: if (queueall ? !bitset(QDONTSEND, q->q_flags) :
122: bitset(QQUEUEUP, q->q_flags))
123: {
124: fprintf(tfp, "R%s\n", q->q_paddr);
125: if (announce)
126: {
127: e->e_to = q->q_paddr;
128: message(Arpa_Info, "queued");
129: if (LogLevel > 4)
130: logdelivery("queued");
131: e->e_to = NULL;
132: }
133: #ifdef DEBUG
134: if (tTd(40, 1))
135: {
136: printf("queueing ");
137: printaddr(q, FALSE);
138: }
139: #endif DEBUG
140: }
141: }
142:
143: /*
144: ** Output headers for this message.
145: ** Expand macros completely here. Queue run will deal with
146: ** everything as absolute headers.
147: ** All headers that must be relative to the recipient
148: ** can be cracked later.
149: ** We set up a "null mailer" -- i.e., a mailer that will have
150: ** no effect on the addresses as they are output.
151: */
152:
153: bzero((char *) &nullmailer, sizeof nullmailer);
154: nullmailer.m_r_rwset = nullmailer.m_s_rwset = -1;
155: nullmailer.m_eol = "\n";
156:
157: define('g', "$f", e);
158: for (h = e->e_header; h != NULL; h = h->h_link)
159: {
160: extern bool bitzerop();
161:
162: /* don't output null headers */
163: if (h->h_value == NULL || h->h_value[0] == '\0')
164: continue;
165:
166: /* don't output resent headers on non-resent messages */
167: if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
168: continue;
169:
170: /* output this header */
171: fprintf(tfp, "H");
172:
173: /* if conditional, output the set of conditions */
174: if (!bitzerop(h->h_mflags) && bitset(H_CHECK|H_ACHECK, h->h_flags))
175: {
176: int j;
177:
178: putc('?', tfp);
179: for (j = '\0'; j <= '\177'; j++)
180: if (bitnset(j, h->h_mflags))
181: putc(j, tfp);
182: putc('?', tfp);
183: }
184:
185: /* output the header: expand macros, convert addresses */
186: if (bitset(H_DEFAULT, h->h_flags))
187: {
188: (void) expand(h->h_value, buf, &buf[sizeof buf], e);
189: fprintf(tfp, "%s: %s\n", h->h_field, buf);
190: }
191: else if (bitset(H_FROM|H_RCPT, h->h_flags))
192: {
193: commaize(h, h->h_value, tfp, bitset(EF_OLDSTYLE, e->e_flags),
194: &nullmailer);
195: }
196: else
197: fprintf(tfp, "%s: %s\n", h->h_field, h->h_value);
198: }
199:
200: /*
201: ** Clean up.
202: */
203:
204: (void) fclose(tfp);
205: qf = queuename(e, 'q');
206: holdsigs();
207: (void) unlink(qf);
208: if (link(tf, qf) < 0)
209: syserr("cannot link(%s, %s), df=%s", tf, qf, e->e_df);
210: else
211: (void) unlink(tf);
212: rlsesigs();
213:
214: # ifdef LOG
215: /* save log info */
216: if (LogLevel > 15)
217: syslog(LOG_DEBUG, "%s: queueup, qf=%s, df=%s\n", e->e_id, qf, e->e_df);
218: # endif LOG
219: }
220: /*
221: ** RUNQUEUE -- run the jobs in the queue.
222: **
223: ** Gets the stuff out of the queue in some presumably logical
224: ** order and processes them.
225: **
226: ** Parameters:
227: ** none.
228: **
229: ** Returns:
230: ** none.
231: **
232: ** Side Effects:
233: ** runs things in the mail queue.
234: */
235:
236: runqueue(forkflag)
237: bool forkflag;
238: {
239: /*
240: ** See if we want to go off and do other useful work.
241: */
242:
243: if (forkflag)
244: {
245: int pid;
246:
247: pid = dofork();
248: if (pid != 0)
249: {
250: /* parent -- pick up intermediate zombie */
251: (void) waitfor(pid);
252: if (QueueIntvl != 0)
253: (void) setevent(QueueIntvl, runqueue, TRUE);
254: return;
255: }
256: /* child -- double fork */
257: if (fork() != 0)
258: exit(EX_OK);
259: }
260: # ifdef LOG
261: if (LogLevel > 11)
262: syslog(LOG_DEBUG, "runqueue %s, pid=%d", QueueDir, getpid());
263: # endif LOG
264:
265: /*
266: ** Release any resources used by the daemon code.
267: */
268:
269: # ifdef DAEMON
270: clrdaemon();
271: # endif DAEMON
272:
273: /*
274: ** Start making passes through the queue.
275: ** First, read and sort the entire queue.
276: ** Then, process the work in that order.
277: ** But if you take too long, start over.
278: */
279:
280: /* order the existing work requests */
281: (void) orderq();
282:
283: /* process them once at a time */
284: while (WorkQ != NULL)
285: {
286: WORK *w = WorkQ;
287:
288: WorkQ = WorkQ->w_next;
289: dowork(w);
290: free(w->w_name);
291: free((char *) w);
292: }
293: finis();
294: }
295: /*
296: ** ORDERQ -- order the work queue.
297: **
298: ** Parameters:
299: ** none.
300: **
301: ** Returns:
302: ** The number of request in the queue (not necessarily
303: ** the number of requests in WorkQ however).
304: **
305: ** Side Effects:
306: ** Sets WorkQ to the queue of available work, in order.
307: */
308:
309: # define WLSIZE 120 /* max size of worklist per sort */
310:
311: orderq()
312: {
313: register struct direct *d;
314: register WORK *w;
315: register WORK **wp; /* parent of w */
316: DIR *f;
317: register int i;
318: WORK wlist[WLSIZE+1];
319: int wn = -1;
320: extern workcmpf();
321:
322: /* clear out old WorkQ */
323: for (w = WorkQ; w != NULL; )
324: {
325: register WORK *nw = w->w_next;
326:
327: WorkQ = nw;
328: free(w->w_name);
329: free((char *) w);
330: w = nw;
331: }
332:
333: /* open the queue directory */
334: f = opendir(".");
335: if (f == NULL)
336: {
337: syserr("orderq: cannot open \"%s\" as \".\"", QueueDir);
338: return (0);
339: }
340:
341: /*
342: ** Read the work directory.
343: */
344:
345: while ((d = readdir(f)) != NULL)
346: {
347: FILE *cf;
348: char lbuf[MAXNAME];
349:
350: /* is this an interesting entry? */
351: if (d->d_name[0] != 'q' || d->d_name[1] != 'f')
352: continue;
353:
354: /* yes -- open control file (if not too many files) */
355: if (++wn >= WLSIZE)
356: continue;
357: cf = fopen(d->d_name, "r");
358: if (cf == NULL)
359: {
360: /* this may be some random person sending hir msgs */
361: /* syserr("orderq: cannot open %s", cbuf); */
362: #ifdef DEBUG
363: if (tTd(41, 2))
364: printf("orderq: cannot open %s (%d)\n",
365: d->d_name, errno);
366: #endif DEBUG
367: errno = 0;
368: wn--;
369: continue;
370: }
371: wlist[wn].w_name = newstr(d->d_name);
372:
373: /* extract useful information */
374: while (fgets(lbuf, sizeof lbuf, cf) != NULL)
375: {
376: if (lbuf[0] == 'P')
377: {
378: (void) sscanf(&lbuf[1], "%ld", &wlist[wn].w_pri);
379: break;
380: }
381: }
382: (void) fclose(cf);
383: }
384: (void) closedir(f);
385: wn++;
386:
387: /*
388: ** Sort the work directory.
389: */
390:
391: qsort(wlist, min(wn, WLSIZE), sizeof *wlist, workcmpf);
392:
393: /*
394: ** Convert the work list into canonical form.
395: ** Should be turning it into a list of envelopes here perhaps.
396: */
397:
398: wp = &WorkQ;
399: for (i = min(wn, WLSIZE); --i >= 0; )
400: {
401: w = (WORK *) xalloc(sizeof *w);
402: w->w_name = wlist[i].w_name;
403: w->w_pri = wlist[i].w_pri;
404: w->w_next = NULL;
405: *wp = w;
406: wp = &w->w_next;
407: }
408:
409: # ifdef DEBUG
410: if (tTd(40, 1))
411: {
412: for (w = WorkQ; w != NULL; w = w->w_next)
413: printf("%32s: pri=%ld\n", w->w_name, w->w_pri);
414: }
415: # endif DEBUG
416:
417: return (wn);
418: }
419: /*
420: ** WORKCMPF -- compare function for ordering work.
421: **
422: ** Parameters:
423: ** a -- the first argument.
424: ** b -- the second argument.
425: **
426: ** Returns:
427: ** 1 if a < b
428: ** 0 if a == b
429: ** -1 if a > b
430: **
431: ** Side Effects:
432: ** none.
433: */
434:
435: workcmpf(a, b)
436: register WORK *a;
437: register WORK *b;
438: {
439: if (a->w_pri == b->w_pri)
440: return (0);
441: else if (a->w_pri > b->w_pri)
442: return (-1);
443: else
444: return (1);
445: }
446: /*
447: ** DOWORK -- do a work request.
448: **
449: ** Parameters:
450: ** w -- the work request to be satisfied.
451: **
452: ** Returns:
453: ** none.
454: **
455: ** Side Effects:
456: ** The work request is satisfied if possible.
457: */
458:
459: dowork(w)
460: register WORK *w;
461: {
462: register int i;
463:
464: # ifdef DEBUG
465: if (tTd(40, 1))
466: printf("dowork: %s pri %ld\n", w->w_name, w->w_pri);
467: # endif DEBUG
468:
469: /*
470: ** Fork for work.
471: */
472:
473: i = fork();
474: if (i < 0)
475: {
476: syserr("dowork: cannot fork");
477: return;
478: }
479:
480: if (i == 0)
481: {
482: /*
483: ** CHILD
484: ** Lock the control file to avoid duplicate deliveries.
485: ** Then run the file as though we had just read it.
486: ** We save an idea of the temporary name so we
487: ** can recover on interrupt.
488: */
489:
490: /* set basic modes, etc. */
491: (void) alarm(0);
492: closexscript(CurEnv);
493: CurEnv->e_flags &= ~EF_FATALERRS;
494: QueueRun = TRUE;
495: ErrorMode = EM_MAIL;
496: CurEnv->e_id = &w->w_name[2];
497: # ifdef LOG
498: if (LogLevel > 11)
499: syslog(LOG_DEBUG, "%s: dowork, pid=%d", CurEnv->e_id,
500: getpid());
501: # endif LOG
502:
503: /* don't use the headers from sendmail.cf... */
504: CurEnv->e_header = NULL;
505:
506: /* create the link to the control file during processing */
507: if (link(w->w_name, queuename(CurEnv, 'l')) < 0)
508: {
509: /* being processed by another queuer */
510: # ifdef LOG
511: if (LogLevel > 4)
512: syslog(LOG_DEBUG, "%s: locked", CurEnv->e_id);
513: # endif LOG
514: exit(EX_OK);
515: }
516:
517: /* do basic system initialization */
518: initsys();
519:
520: /* read the queue control file */
521: readqf(CurEnv, TRUE);
522: CurEnv->e_flags |= EF_INQUEUE;
523: eatheader(CurEnv);
524:
525: /* do the delivery */
526: if (!bitset(EF_FATALERRS, CurEnv->e_flags))
527: sendall(CurEnv, SM_DELIVER);
528:
529: /* finish up and exit */
530: finis();
531: }
532:
533: /*
534: ** Parent -- pick up results.
535: */
536:
537: errno = 0;
538: (void) waitfor(i);
539: }
540: /*
541: ** READQF -- read queue file and set up environment.
542: **
543: ** Parameters:
544: ** e -- the envelope of the job to run.
545: ** full -- if set, read in all information. Otherwise just
546: ** read in info needed for a queue print.
547: **
548: ** Returns:
549: ** none.
550: **
551: ** Side Effects:
552: ** cf is read and created as the current job, as though
553: ** we had been invoked by argument.
554: */
555:
556: readqf(e, full)
557: register ENVELOPE *e;
558: bool full;
559: {
560: register FILE *f;
561: char buf[MAXFIELD];
562: extern char *fgetfolded();
563: register char *p;
564:
565: /*
566: ** Open the file created by queueup.
567: */
568:
569: p = queuename(e, 'q');
570: f = fopen(p, "r");
571: if (f == NULL)
572: {
573: syserr("readqf: no control file %s", p);
574: return;
575: }
576: FileName = p;
577: LineNumber = 0;
578:
579: /*
580: ** Read and process the file.
581: */
582:
583: if (Verbose && full)
584: printf("\nRunning %s\n", e->e_id);
585: while (fgetfolded(buf, sizeof buf, f) != NULL)
586: {
587: switch (buf[0])
588: {
589: case 'R': /* specify recipient */
590: sendtolist(&buf[1], (ADDRESS *) NULL, &e->e_sendqueue);
591: break;
592:
593: case 'H': /* header */
594: if (full)
595: (void) chompheader(&buf[1], FALSE);
596: break;
597:
598: case 'M': /* message */
599: e->e_message = newstr(&buf[1]);
600: break;
601:
602: case 'S': /* sender */
603: setsender(newstr(&buf[1]));
604: break;
605:
606: case 'D': /* data file name */
607: if (!full)
608: break;
609: e->e_df = newstr(&buf[1]);
610: e->e_dfp = fopen(e->e_df, "r");
611: if (e->e_dfp == NULL)
612: syserr("readqf: cannot open %s", e->e_df);
613: break;
614:
615: case 'T': /* init time */
616: (void) sscanf(&buf[1], "%ld", &e->e_ctime);
617: break;
618:
619: case 'P': /* message priority */
620: (void) sscanf(&buf[1], "%ld", &e->e_msgpriority);
621:
622: /* make sure that big things get sent eventually */
623: e->e_msgpriority -= WKTIMEFACT;
624: break;
625:
626: default:
627: syserr("readqf(%s): bad line \"%s\"", e->e_id, buf);
628: break;
629: }
630: }
631:
632: FileName = NULL;
633: }
634: /*
635: ** PRINTQUEUE -- print out a representation of the mail queue
636: **
637: ** Parameters:
638: ** none.
639: **
640: ** Returns:
641: ** none.
642: **
643: ** Side Effects:
644: ** Prints a listing of the mail queue on the standard output.
645: */
646:
647: printqueue()
648: {
649: register WORK *w;
650: FILE *f;
651: int nrequests;
652: char buf[MAXLINE];
653:
654: /*
655: ** Read and order the queue.
656: */
657:
658: nrequests = orderq();
659:
660: /*
661: ** Print the work list that we have read.
662: */
663:
664: /* first see if there is anything */
665: if (nrequests <= 0)
666: {
667: printf("Mail queue is empty\n");
668: return;
669: }
670:
671: printf("\t\tMail Queue (%d request%s", nrequests, nrequests == 1 ? "" : "s");
672: if (nrequests > WLSIZE)
673: printf(", only %d printed", WLSIZE);
674: printf(")\n--QID-- --Size-- -----Q-Time----- ------------Sender/Recipient------------\n");
675: for (w = WorkQ; w != NULL; w = w->w_next)
676: {
677: struct stat st;
678: auto time_t submittime = 0;
679: long dfsize = -1;
680: char lf[20];
681: char message[MAXLINE];
682:
683: printf("%7s", w->w_name + 2);
684: strcpy(lf, w->w_name);
685: lf[0] = 'l';
686: if (stat(lf, &st) >= 0)
687: printf("*");
688: else
689: printf(" ");
690: errno = 0;
691: f = fopen(w->w_name, "r");
692: if (f == NULL)
693: {
694: printf(" (finished)\n");
695: errno = 0;
696: continue;
697: }
698: message[0] = '\0';
699: while (fgets(buf, sizeof buf, f) != NULL)
700: {
701: fixcrlf(buf, TRUE);
702: switch (buf[0])
703: {
704: case 'M': /* error message */
705: strcpy(message, &buf[1]);
706: break;
707:
708: case 'S': /* sender name */
709: printf("%8ld %.16s %.45s", dfsize,
710: ctime(&submittime), &buf[1]);
711: if (message[0] != '\0')
712: printf("\n\t\t\t\t (%.43s)", message);
713: break;
714:
715: case 'R': /* recipient name */
716: printf("\n\t\t\t\t %.45s", &buf[1]);
717: break;
718:
719: case 'T': /* creation time */
720: sscanf(&buf[1], "%ld", &submittime);
721: break;
722:
723: case 'D': /* data file name */
724: if (stat(&buf[1], &st) >= 0)
725: dfsize = st.st_size;
726: break;
727: }
728: }
729: if (submittime == (time_t) 0)
730: printf(" (no control file)");
731: printf("\n");
732: fclose(f);
733: }
734: }
735:
736: # endif QUEUE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.