![[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] / 43BSDTahoe / usr.lib / sendmail / src|
Return to queue.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.lib / sendmail / src |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 Eric P. Allman ! 3: * Copyright (c) 1988 Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * Redistribution and use in source and binary forms are permitted ! 7: * provided that the above copyright notice and this paragraph are ! 8: * duplicated in all such forms and that any documentation, ! 9: * advertising materials, and other materials related to such ! 10: * distribution and use acknowledge that the software was developed ! 11: * by the University of California, Berkeley. The name of the ! 12: * University may not be used to endorse or promote products derived ! 13: * from this software without specific prior written permission. ! 14: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 15: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 16: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 17: */ ! 18: ! 19: # include "sendmail.h" ! 20: ! 21: #ifndef lint ! 22: #ifdef QUEUE ! 23: static char sccsid[] = "@(#)queue.c 5.24 (Berkeley) 6/30/88 (with queueing)"; ! 24: #else ! 25: static char sccsid[] = "@(#)queue.c 5.24 (Berkeley) 6/30/88 (without queueing)"; ! 26: #endif ! 27: #endif /* not lint */ ! 28: ! 29: # include <sys/stat.h> ! 30: # include <sys/dir.h> ! 31: # include <signal.h> ! 32: # include <errno.h> ! 33: ! 34: # ifdef QUEUE ! 35: ! 36: /* ! 37: ** Work queue. ! 38: */ ! 39: ! 40: struct work ! 41: { ! 42: char *w_name; /* name of control file */ ! 43: long w_pri; /* priority of message, see below */ ! 44: time_t w_ctime; /* creation time of message */ ! 45: struct work *w_next; /* next in queue */ ! 46: }; ! 47: ! 48: typedef struct work WORK; ! 49: ! 50: WORK *WorkQ; /* queue of things to be done */ ! 51: /* ! 52: ** QUEUEUP -- queue a message up for future transmission. ! 53: ** ! 54: ** Parameters: ! 55: ** e -- the envelope to queue up. ! 56: ** queueall -- if TRUE, queue all addresses, rather than ! 57: ** just those with the QQUEUEUP flag set. ! 58: ** announce -- if TRUE, tell when you are queueing up. ! 59: ** ! 60: ** Returns: ! 61: ** none. ! 62: ** ! 63: ** Side Effects: ! 64: ** The current request are saved in a control file. ! 65: */ ! 66: ! 67: queueup(e, queueall, announce) ! 68: register ENVELOPE *e; ! 69: bool queueall; ! 70: bool announce; ! 71: { ! 72: char *tf; ! 73: char *qf; ! 74: char buf[MAXLINE]; ! 75: register FILE *tfp; ! 76: register HDR *h; ! 77: register ADDRESS *q; ! 78: MAILER nullmailer; ! 79: ! 80: /* ! 81: ** Create control file. ! 82: */ ! 83: ! 84: tf = newstr(queuename(e, 't')); ! 85: tfp = fopen(tf, "w"); ! 86: if (tfp == NULL) ! 87: { ! 88: syserr("queueup: cannot create temp file %s", tf); ! 89: return; ! 90: } ! 91: (void) chmod(tf, FileMode); ! 92: ! 93: # ifdef DEBUG ! 94: if (tTd(40, 1)) ! 95: printf("queueing %s\n", e->e_id); ! 96: # endif DEBUG ! 97: ! 98: /* ! 99: ** If there is no data file yet, create one. ! 100: */ ! 101: ! 102: if (e->e_df == NULL) ! 103: { ! 104: register FILE *dfp; ! 105: extern putbody(); ! 106: ! 107: e->e_df = newstr(queuename(e, 'd')); ! 108: dfp = fopen(e->e_df, "w"); ! 109: if (dfp == NULL) ! 110: { ! 111: syserr("queueup: cannot create %s", e->e_df); ! 112: (void) fclose(tfp); ! 113: return; ! 114: } ! 115: (void) chmod(e->e_df, FileMode); ! 116: (*e->e_putbody)(dfp, ProgMailer, e); ! 117: (void) fclose(dfp); ! 118: e->e_putbody = putbody; ! 119: } ! 120: ! 121: /* ! 122: ** Output future work requests. ! 123: ** Priority and creation time should be first, since ! 124: ** they are required by orderq. ! 125: */ ! 126: ! 127: /* output message priority */ ! 128: fprintf(tfp, "P%ld\n", e->e_msgpriority); ! 129: ! 130: /* output creation time */ ! 131: fprintf(tfp, "T%ld\n", e->e_ctime); ! 132: ! 133: /* output name of data file */ ! 134: fprintf(tfp, "D%s\n", e->e_df); ! 135: ! 136: /* message from envelope, if it exists */ ! 137: if (e->e_message != NULL) ! 138: fprintf(tfp, "M%s\n", e->e_message); ! 139: ! 140: /* output name of sender */ ! 141: fprintf(tfp, "S%s\n", e->e_from.q_paddr); ! 142: ! 143: /* output list of recipient addresses */ ! 144: for (q = e->e_sendqueue; q != NULL; q = q->q_next) ! 145: { ! 146: if (queueall ? !bitset(QDONTSEND, q->q_flags) : ! 147: bitset(QQUEUEUP, q->q_flags)) ! 148: { ! 149: fprintf(tfp, "R%s\n", q->q_paddr); ! 150: if (announce) ! 151: { ! 152: e->e_to = q->q_paddr; ! 153: message(Arpa_Info, "queued"); ! 154: if (LogLevel > 4) ! 155: logdelivery("queued"); ! 156: e->e_to = NULL; ! 157: } ! 158: #ifdef DEBUG ! 159: if (tTd(40, 1)) ! 160: { ! 161: printf("queueing "); ! 162: printaddr(q, FALSE); ! 163: } ! 164: #endif DEBUG ! 165: } ! 166: } ! 167: ! 168: /* output list of error recipients */ ! 169: for (q = e->e_errorqueue; q != NULL; q = q->q_next) ! 170: { ! 171: if (!bitset(QDONTSEND, q->q_flags)) ! 172: fprintf(tfp, "E%s\n", q->q_paddr); ! 173: } ! 174: ! 175: /* ! 176: ** Output headers for this message. ! 177: ** Expand macros completely here. Queue run will deal with ! 178: ** everything as absolute headers. ! 179: ** All headers that must be relative to the recipient ! 180: ** can be cracked later. ! 181: ** We set up a "null mailer" -- i.e., a mailer that will have ! 182: ** no effect on the addresses as they are output. ! 183: */ ! 184: ! 185: bzero((char *) &nullmailer, sizeof nullmailer); ! 186: nullmailer.m_r_rwset = nullmailer.m_s_rwset = -1; ! 187: nullmailer.m_eol = "\n"; ! 188: ! 189: define('g', "\001f", e); ! 190: for (h = e->e_header; h != NULL; h = h->h_link) ! 191: { ! 192: extern bool bitzerop(); ! 193: ! 194: /* don't output null headers */ ! 195: if (h->h_value == NULL || h->h_value[0] == '\0') ! 196: continue; ! 197: ! 198: /* don't output resent headers on non-resent messages */ ! 199: if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags)) ! 200: continue; ! 201: ! 202: /* output this header */ ! 203: fprintf(tfp, "H"); ! 204: ! 205: /* if conditional, output the set of conditions */ ! 206: if (!bitzerop(h->h_mflags) && bitset(H_CHECK|H_ACHECK, h->h_flags)) ! 207: { ! 208: int j; ! 209: ! 210: (void) putc('?', tfp); ! 211: for (j = '\0'; j <= '\177'; j++) ! 212: if (bitnset(j, h->h_mflags)) ! 213: (void) putc(j, tfp); ! 214: (void) putc('?', tfp); ! 215: } ! 216: ! 217: /* output the header: expand macros, convert addresses */ ! 218: if (bitset(H_DEFAULT, h->h_flags)) ! 219: { ! 220: (void) expand(h->h_value, buf, &buf[sizeof buf], e); ! 221: fprintf(tfp, "%s: %s\n", h->h_field, buf); ! 222: } ! 223: else if (bitset(H_FROM|H_RCPT, h->h_flags)) ! 224: { ! 225: commaize(h, h->h_value, tfp, bitset(EF_OLDSTYLE, e->e_flags), ! 226: &nullmailer); ! 227: } ! 228: else ! 229: fprintf(tfp, "%s: %s\n", h->h_field, h->h_value); ! 230: } ! 231: ! 232: /* ! 233: ** Clean up. ! 234: */ ! 235: ! 236: (void) fclose(tfp); ! 237: qf = queuename(e, 'q'); ! 238: if (tf != NULL) ! 239: { ! 240: (void) unlink(qf); ! 241: if (rename(tf, qf) < 0) ! 242: syserr("cannot unlink(%s, %s), df=%s", tf, qf, e->e_df); ! 243: errno = 0; ! 244: } ! 245: ! 246: # ifdef LOG ! 247: /* save log info */ ! 248: if (LogLevel > 15) ! 249: syslog(LOG_DEBUG, "%s: queueup, qf=%s, df=%s\n", e->e_id, qf, e->e_df); ! 250: # endif LOG ! 251: } ! 252: /* ! 253: ** RUNQUEUE -- run the jobs in the queue. ! 254: ** ! 255: ** Gets the stuff out of the queue in some presumably logical ! 256: ** order and processes them. ! 257: ** ! 258: ** Parameters: ! 259: ** forkflag -- TRUE if the queue scanning should be done in ! 260: ** a child process. We double-fork so it is not our ! 261: ** child and we don't have to clean up after it. ! 262: ** ! 263: ** Returns: ! 264: ** none. ! 265: ** ! 266: ** Side Effects: ! 267: ** runs things in the mail queue. ! 268: */ ! 269: ! 270: runqueue(forkflag) ! 271: bool forkflag; ! 272: { ! 273: extern bool shouldqueue(); ! 274: ! 275: /* ! 276: ** If no work will ever be selected, don't even bother reading ! 277: ** the queue. ! 278: */ ! 279: ! 280: if (shouldqueue(-100000000L)) ! 281: { ! 282: if (Verbose) ! 283: printf("Skipping queue run -- load average too high\n"); ! 284: ! 285: if (forkflag) ! 286: return; ! 287: finis(); ! 288: } ! 289: ! 290: /* ! 291: ** See if we want to go off and do other useful work. ! 292: */ ! 293: ! 294: if (forkflag) ! 295: { ! 296: int pid; ! 297: ! 298: pid = dofork(); ! 299: if (pid != 0) ! 300: { ! 301: extern reapchild(); ! 302: ! 303: /* parent -- pick up intermediate zombie */ ! 304: #ifndef SIGCHLD ! 305: (void) waitfor(pid); ! 306: #else SIGCHLD ! 307: (void) signal(SIGCHLD, reapchild); ! 308: #endif SIGCHLD ! 309: if (QueueIntvl != 0) ! 310: (void) setevent(QueueIntvl, runqueue, TRUE); ! 311: return; ! 312: } ! 313: /* child -- double fork */ ! 314: #ifndef SIGCHLD ! 315: if (fork() != 0) ! 316: exit(EX_OK); ! 317: #else SIGCHLD ! 318: (void) signal(SIGCHLD, SIG_DFL); ! 319: #endif SIGCHLD ! 320: } ! 321: ! 322: setproctitle("running queue"); ! 323: ! 324: # ifdef LOG ! 325: if (LogLevel > 11) ! 326: syslog(LOG_DEBUG, "runqueue %s, pid=%d", QueueDir, getpid()); ! 327: # endif LOG ! 328: ! 329: /* ! 330: ** Release any resources used by the daemon code. ! 331: */ ! 332: ! 333: # ifdef DAEMON ! 334: clrdaemon(); ! 335: # endif DAEMON ! 336: ! 337: /* ! 338: ** Make sure the alias database is open. ! 339: */ ! 340: ! 341: initaliases(AliasFile, FALSE); ! 342: ! 343: /* ! 344: ** Start making passes through the queue. ! 345: ** First, read and sort the entire queue. ! 346: ** Then, process the work in that order. ! 347: ** But if you take too long, start over. ! 348: */ ! 349: ! 350: /* order the existing work requests */ ! 351: (void) orderq(FALSE); ! 352: ! 353: /* process them once at a time */ ! 354: while (WorkQ != NULL) ! 355: { ! 356: WORK *w = WorkQ; ! 357: ! 358: WorkQ = WorkQ->w_next; ! 359: dowork(w); ! 360: free(w->w_name); ! 361: free((char *) w); ! 362: } ! 363: ! 364: /* exit without the usual cleanup */ ! 365: exit(ExitStat); ! 366: } ! 367: /* ! 368: ** ORDERQ -- order the work queue. ! 369: ** ! 370: ** Parameters: ! 371: ** doall -- if set, include everything in the queue (even ! 372: ** the jobs that cannot be run because the load ! 373: ** average is too high). Otherwise, exclude those ! 374: ** jobs. ! 375: ** ! 376: ** Returns: ! 377: ** The number of request in the queue (not necessarily ! 378: ** the number of requests in WorkQ however). ! 379: ** ! 380: ** Side Effects: ! 381: ** Sets WorkQ to the queue of available work, in order. ! 382: */ ! 383: ! 384: # define NEED_P 001 ! 385: # define NEED_T 002 ! 386: ! 387: orderq(doall) ! 388: bool doall; ! 389: { ! 390: register struct direct *d; ! 391: register WORK *w; ! 392: DIR *f; ! 393: register int i; ! 394: WORK wlist[QUEUESIZE+1]; ! 395: int wn = -1; ! 396: extern workcmpf(); ! 397: ! 398: /* clear out old WorkQ */ ! 399: for (w = WorkQ; w != NULL; ) ! 400: { ! 401: register WORK *nw = w->w_next; ! 402: ! 403: WorkQ = nw; ! 404: free(w->w_name); ! 405: free((char *) w); ! 406: w = nw; ! 407: } ! 408: ! 409: /* open the queue directory */ ! 410: f = opendir("."); ! 411: if (f == NULL) ! 412: { ! 413: syserr("orderq: cannot open \"%s\" as \".\"", QueueDir); ! 414: return (0); ! 415: } ! 416: ! 417: /* ! 418: ** Read the work directory. ! 419: */ ! 420: ! 421: while ((d = readdir(f)) != NULL) ! 422: { ! 423: FILE *cf; ! 424: char lbuf[MAXNAME]; ! 425: ! 426: /* is this an interesting entry? */ ! 427: if (d->d_name[0] != 'q' || d->d_name[1] != 'f') ! 428: continue; ! 429: ! 430: /* yes -- open control file (if not too many files) */ ! 431: if (++wn >= QUEUESIZE) ! 432: continue; ! 433: cf = fopen(d->d_name, "r"); ! 434: if (cf == NULL) ! 435: { ! 436: /* this may be some random person sending hir msgs */ ! 437: /* syserr("orderq: cannot open %s", cbuf); */ ! 438: #ifdef DEBUG ! 439: if (tTd(41, 2)) ! 440: printf("orderq: cannot open %s (%d)\n", ! 441: d->d_name, errno); ! 442: #endif DEBUG ! 443: errno = 0; ! 444: wn--; ! 445: continue; ! 446: } ! 447: w = &wlist[wn]; ! 448: w->w_name = newstr(d->d_name); ! 449: ! 450: /* make sure jobs in creation don't clog queue */ ! 451: w->w_pri = 0x7fffffff; ! 452: w->w_ctime = 0; ! 453: ! 454: /* extract useful information */ ! 455: i = NEED_P | NEED_T; ! 456: while (i != 0 && fgets(lbuf, sizeof lbuf, cf) != NULL) ! 457: { ! 458: extern long atol(); ! 459: ! 460: switch (lbuf[0]) ! 461: { ! 462: case 'P': ! 463: w->w_pri = atol(&lbuf[1]); ! 464: i &= ~NEED_P; ! 465: break; ! 466: ! 467: case 'T': ! 468: w->w_ctime = atol(&lbuf[1]); ! 469: i &= ~NEED_T; ! 470: break; ! 471: } ! 472: } ! 473: (void) fclose(cf); ! 474: ! 475: if (!doall && shouldqueue(w->w_pri)) ! 476: { ! 477: /* don't even bother sorting this job in */ ! 478: wn--; ! 479: } ! 480: } ! 481: (void) closedir(f); ! 482: wn++; ! 483: ! 484: /* ! 485: ** Sort the work directory. ! 486: */ ! 487: ! 488: qsort((char *) wlist, min(wn, QUEUESIZE), sizeof *wlist, workcmpf); ! 489: ! 490: /* ! 491: ** Convert the work list into canonical form. ! 492: ** Should be turning it into a list of envelopes here perhaps. ! 493: */ ! 494: ! 495: WorkQ = NULL; ! 496: for (i = min(wn, QUEUESIZE); --i >= 0; ) ! 497: { ! 498: w = (WORK *) xalloc(sizeof *w); ! 499: w->w_name = wlist[i].w_name; ! 500: w->w_pri = wlist[i].w_pri; ! 501: w->w_ctime = wlist[i].w_ctime; ! 502: w->w_next = WorkQ; ! 503: WorkQ = w; ! 504: } ! 505: ! 506: # ifdef DEBUG ! 507: if (tTd(40, 1)) ! 508: { ! 509: for (w = WorkQ; w != NULL; w = w->w_next) ! 510: printf("%32s: pri=%ld\n", w->w_name, w->w_pri); ! 511: } ! 512: # endif DEBUG ! 513: ! 514: return (wn); ! 515: } ! 516: /* ! 517: ** WORKCMPF -- compare function for ordering work. ! 518: ** ! 519: ** Parameters: ! 520: ** a -- the first argument. ! 521: ** b -- the second argument. ! 522: ** ! 523: ** Returns: ! 524: ** -1 if a < b ! 525: ** 0 if a == b ! 526: ** +1 if a > b ! 527: ** ! 528: ** Side Effects: ! 529: ** none. ! 530: */ ! 531: ! 532: workcmpf(a, b) ! 533: register WORK *a; ! 534: register WORK *b; ! 535: { ! 536: long pa = a->w_pri + a->w_ctime; ! 537: long pb = b->w_pri + b->w_ctime; ! 538: ! 539: if (pa == pb) ! 540: return (0); ! 541: else if (pa > pb) ! 542: return (1); ! 543: else ! 544: return (-1); ! 545: } ! 546: /* ! 547: ** DOWORK -- do a work request. ! 548: ** ! 549: ** Parameters: ! 550: ** w -- the work request to be satisfied. ! 551: ** ! 552: ** Returns: ! 553: ** none. ! 554: ** ! 555: ** Side Effects: ! 556: ** The work request is satisfied if possible. ! 557: */ ! 558: ! 559: dowork(w) ! 560: register WORK *w; ! 561: { ! 562: register int i; ! 563: extern bool shouldqueue(); ! 564: ! 565: # ifdef DEBUG ! 566: if (tTd(40, 1)) ! 567: printf("dowork: %s pri %ld\n", w->w_name, w->w_pri); ! 568: # endif DEBUG ! 569: ! 570: /* ! 571: ** Ignore jobs that are too expensive for the moment. ! 572: */ ! 573: ! 574: if (shouldqueue(w->w_pri)) ! 575: { ! 576: if (Verbose) ! 577: printf("\nSkipping %s\n", w->w_name + 2); ! 578: return; ! 579: } ! 580: ! 581: /* ! 582: ** Fork for work. ! 583: */ ! 584: ! 585: if (ForkQueueRuns) ! 586: { ! 587: i = fork(); ! 588: if (i < 0) ! 589: { ! 590: syserr("dowork: cannot fork"); ! 591: return; ! 592: } ! 593: } ! 594: else ! 595: { ! 596: i = 0; ! 597: } ! 598: ! 599: if (i == 0) ! 600: { ! 601: /* ! 602: ** CHILD ! 603: ** Lock the control file to avoid duplicate deliveries. ! 604: ** Then run the file as though we had just read it. ! 605: ** We save an idea of the temporary name so we ! 606: ** can recover on interrupt. ! 607: */ ! 608: ! 609: /* set basic modes, etc. */ ! 610: (void) alarm(0); ! 611: clearenvelope(CurEnv, FALSE); ! 612: QueueRun = TRUE; ! 613: ErrorMode = EM_MAIL; ! 614: CurEnv->e_id = &w->w_name[2]; ! 615: # ifdef LOG ! 616: if (LogLevel > 11) ! 617: syslog(LOG_DEBUG, "%s: dowork, pid=%d", CurEnv->e_id, ! 618: getpid()); ! 619: # endif LOG ! 620: ! 621: /* don't use the headers from sendmail.cf... */ ! 622: CurEnv->e_header = NULL; ! 623: ! 624: /* lock the control file during processing */ ! 625: if (link(w->w_name, queuename(CurEnv, 'l')) < 0) ! 626: { ! 627: /* being processed by another queuer */ ! 628: # ifdef LOG ! 629: if (LogLevel > 4) ! 630: syslog(LOG_DEBUG, "%s: locked", CurEnv->e_id); ! 631: # endif LOG ! 632: if (ForkQueueRuns) ! 633: exit(EX_OK); ! 634: else ! 635: return; ! 636: } ! 637: ! 638: /* do basic system initialization */ ! 639: initsys(); ! 640: ! 641: /* read the queue control file */ ! 642: readqf(CurEnv, TRUE); ! 643: CurEnv->e_flags |= EF_INQUEUE; ! 644: eatheader(CurEnv); ! 645: ! 646: /* do the delivery */ ! 647: if (!bitset(EF_FATALERRS, CurEnv->e_flags)) ! 648: sendall(CurEnv, SM_DELIVER); ! 649: ! 650: /* finish up and exit */ ! 651: if (ForkQueueRuns) ! 652: finis(); ! 653: else ! 654: dropenvelope(CurEnv); ! 655: } ! 656: else ! 657: { ! 658: /* ! 659: ** Parent -- pick up results. ! 660: */ ! 661: ! 662: errno = 0; ! 663: (void) waitfor(i); ! 664: } ! 665: } ! 666: /* ! 667: ** READQF -- read queue file and set up environment. ! 668: ** ! 669: ** Parameters: ! 670: ** e -- the envelope of the job to run. ! 671: ** full -- if set, read in all information. Otherwise just ! 672: ** read in info needed for a queue print. ! 673: ** ! 674: ** Returns: ! 675: ** none. ! 676: ** ! 677: ** Side Effects: ! 678: ** cf is read and created as the current job, as though ! 679: ** we had been invoked by argument. ! 680: */ ! 681: ! 682: readqf(e, full) ! 683: register ENVELOPE *e; ! 684: bool full; ! 685: { ! 686: char *qf; ! 687: register FILE *qfp; ! 688: char buf[MAXFIELD]; ! 689: extern char *fgetfolded(); ! 690: extern long atol(); ! 691: ! 692: /* ! 693: ** Read and process the file. ! 694: */ ! 695: ! 696: qf = queuename(e, 'q'); ! 697: qfp = fopen(qf, "r"); ! 698: if (qfp == NULL) ! 699: { ! 700: syserr("readqf: no control file %s", qf); ! 701: return; ! 702: } ! 703: FileName = qf; ! 704: LineNumber = 0; ! 705: if (Verbose && full) ! 706: printf("\nRunning %s\n", e->e_id); ! 707: while (fgetfolded(buf, sizeof buf, qfp) != NULL) ! 708: { ! 709: # ifdef DEBUG ! 710: if (tTd(40, 4)) ! 711: printf("+++++ %s\n", buf); ! 712: # endif DEBUG ! 713: switch (buf[0]) ! 714: { ! 715: case 'R': /* specify recipient */ ! 716: sendtolist(&buf[1], (ADDRESS *) NULL, &e->e_sendqueue); ! 717: break; ! 718: ! 719: case 'E': /* specify error recipient */ ! 720: sendtolist(&buf[1], (ADDRESS *) NULL, &e->e_errorqueue); ! 721: break; ! 722: ! 723: case 'H': /* header */ ! 724: if (full) ! 725: (void) chompheader(&buf[1], FALSE); ! 726: break; ! 727: ! 728: case 'M': /* message */ ! 729: e->e_message = newstr(&buf[1]); ! 730: break; ! 731: ! 732: case 'S': /* sender */ ! 733: setsender(newstr(&buf[1])); ! 734: break; ! 735: ! 736: case 'D': /* data file name */ ! 737: if (!full) ! 738: break; ! 739: e->e_df = newstr(&buf[1]); ! 740: e->e_dfp = fopen(e->e_df, "r"); ! 741: if (e->e_dfp == NULL) ! 742: syserr("readqf: cannot open %s", e->e_df); ! 743: break; ! 744: ! 745: case 'T': /* init time */ ! 746: e->e_ctime = atol(&buf[1]); ! 747: break; ! 748: ! 749: case 'P': /* message priority */ ! 750: e->e_msgpriority = atol(&buf[1]) + WkTimeFact; ! 751: break; ! 752: ! 753: case '\0': /* blank line; ignore */ ! 754: break; ! 755: ! 756: default: ! 757: syserr("readqf(%s:%d): bad line \"%s\"", e->e_id, ! 758: LineNumber, buf); ! 759: break; ! 760: } ! 761: } ! 762: ! 763: (void) fclose(qfp); ! 764: FileName = NULL; ! 765: ! 766: /* ! 767: ** If we haven't read any lines, this queue file is empty. ! 768: ** Arrange to remove it without referencing any null pointers. ! 769: */ ! 770: ! 771: if (LineNumber == 0) ! 772: { ! 773: errno = 0; ! 774: e->e_flags |= EF_CLRQUEUE | EF_FATALERRS | EF_RESPONSE; ! 775: } ! 776: } ! 777: /* ! 778: ** PRINTQUEUE -- print out a representation of the mail queue ! 779: ** ! 780: ** Parameters: ! 781: ** none. ! 782: ** ! 783: ** Returns: ! 784: ** none. ! 785: ** ! 786: ** Side Effects: ! 787: ** Prints a listing of the mail queue on the standard output. ! 788: */ ! 789: ! 790: printqueue() ! 791: { ! 792: register WORK *w; ! 793: FILE *f; ! 794: int nrequests; ! 795: char buf[MAXLINE]; ! 796: ! 797: /* ! 798: ** Read and order the queue. ! 799: */ ! 800: ! 801: nrequests = orderq(TRUE); ! 802: ! 803: /* ! 804: ** Print the work list that we have read. ! 805: */ ! 806: ! 807: /* first see if there is anything */ ! 808: if (nrequests <= 0) ! 809: { ! 810: printf("Mail queue is empty\n"); ! 811: return; ! 812: } ! 813: ! 814: printf("\t\tMail Queue (%d request%s", nrequests, nrequests == 1 ? "" : "s"); ! 815: if (nrequests > QUEUESIZE) ! 816: printf(", only %d printed", QUEUESIZE); ! 817: if (Verbose) ! 818: printf(")\n--QID-- --Size-- -Priority- ---Q-Time--- -----------Sender/Recipient-----------\n"); ! 819: else ! 820: printf(")\n--QID-- --Size-- -----Q-Time----- ------------Sender/Recipient------------\n"); ! 821: for (w = WorkQ; w != NULL; w = w->w_next) ! 822: { ! 823: struct stat st; ! 824: auto time_t submittime = 0; ! 825: long dfsize = -1; ! 826: char lf[20]; ! 827: char message[MAXLINE]; ! 828: extern bool shouldqueue(); ! 829: ! 830: f = fopen(w->w_name, "r"); ! 831: if (f == NULL) ! 832: { ! 833: errno = 0; ! 834: continue; ! 835: } ! 836: printf("%7s", w->w_name + 2); ! 837: (void) strcpy(lf, w->w_name); ! 838: lf[0] = 'l'; ! 839: if (stat(lf, &st) >= 0) ! 840: printf("*"); ! 841: else if (shouldqueue(w->w_pri)) ! 842: printf("X"); ! 843: else ! 844: printf(" "); ! 845: errno = 0; ! 846: ! 847: message[0] = '\0'; ! 848: while (fgets(buf, sizeof buf, f) != NULL) ! 849: { ! 850: fixcrlf(buf, TRUE); ! 851: switch (buf[0]) ! 852: { ! 853: case 'M': /* error message */ ! 854: (void) strcpy(message, &buf[1]); ! 855: break; ! 856: ! 857: case 'S': /* sender name */ ! 858: if (Verbose) ! 859: printf("%8ld %10ld %.12s %.38s", dfsize, ! 860: w->w_pri, ctime(&submittime) + 4, ! 861: &buf[1]); ! 862: else ! 863: printf("%8ld %.16s %.45s", dfsize, ! 864: ctime(&submittime), &buf[1]); ! 865: if (message[0] != '\0') ! 866: printf("\n\t\t (%.60s)", message); ! 867: break; ! 868: ! 869: case 'R': /* recipient name */ ! 870: if (Verbose) ! 871: printf("\n\t\t\t\t\t %.38s", &buf[1]); ! 872: else ! 873: printf("\n\t\t\t\t %.45s", &buf[1]); ! 874: break; ! 875: ! 876: case 'T': /* creation time */ ! 877: submittime = atol(&buf[1]); ! 878: break; ! 879: ! 880: case 'D': /* data file name */ ! 881: if (stat(&buf[1], &st) >= 0) ! 882: dfsize = st.st_size; ! 883: break; ! 884: } ! 885: } ! 886: if (submittime == (time_t) 0) ! 887: printf(" (no control file)"); ! 888: printf("\n"); ! 889: (void) fclose(f); ! 890: } ! 891: } ! 892: ! 893: # endif QUEUE ! 894: /* ! 895: ** QUEUENAME -- build a file name in the queue directory for this envelope. ! 896: ** ! 897: ** Assigns an id code if one does not already exist. ! 898: ** This code is very careful to avoid trashing existing files ! 899: ** under any circumstances. ! 900: ** We first create an nf file that is only used when ! 901: ** assigning an id. This file is always empty, so that ! 902: ** we can never accidently truncate an lf file. ! 903: ** ! 904: ** Parameters: ! 905: ** e -- envelope to build it in/from. ! 906: ** type -- the file type, used as the first character ! 907: ** of the file name. ! 908: ** ! 909: ** Returns: ! 910: ** a pointer to the new file name (in a static buffer). ! 911: ** ! 912: ** Side Effects: ! 913: ** Will create the lf and qf files if no id code is ! 914: ** already assigned. This will cause the envelope ! 915: ** to be modified. ! 916: */ ! 917: ! 918: char * ! 919: queuename(e, type) ! 920: register ENVELOPE *e; ! 921: char type; ! 922: { ! 923: static char buf[MAXNAME]; ! 924: static int pid = -1; ! 925: char c1 = 'A'; ! 926: char c2 = 'A'; ! 927: ! 928: if (e->e_id == NULL) ! 929: { ! 930: char qf[20]; ! 931: char nf[20]; ! 932: char lf[20]; ! 933: ! 934: /* find a unique id */ ! 935: if (pid != getpid()) ! 936: { ! 937: /* new process -- start back at "AA" */ ! 938: pid = getpid(); ! 939: c1 = 'A'; ! 940: c2 = 'A' - 1; ! 941: } ! 942: (void) sprintf(qf, "qfAA%05d", pid); ! 943: (void) strcpy(lf, qf); ! 944: lf[0] = 'l'; ! 945: (void) strcpy(nf, qf); ! 946: nf[0] = 'n'; ! 947: ! 948: while (c1 < '~' || c2 < 'Z') ! 949: { ! 950: int i; ! 951: ! 952: if (c2 >= 'Z') ! 953: { ! 954: c1++; ! 955: c2 = 'A' - 1; ! 956: } ! 957: lf[2] = nf[2] = qf[2] = c1; ! 958: lf[3] = nf[3] = qf[3] = ++c2; ! 959: # ifdef DEBUG ! 960: if (tTd(7, 20)) ! 961: printf("queuename: trying \"%s\"\n", nf); ! 962: # endif DEBUG ! 963: ! 964: # ifdef QUEUE ! 965: if (access(lf, 0) >= 0 || access(qf, 0) >= 0) ! 966: continue; ! 967: errno = 0; ! 968: i = creat(nf, FileMode); ! 969: if (i < 0) ! 970: { ! 971: (void) unlink(nf); /* kernel bug */ ! 972: continue; ! 973: } ! 974: (void) close(i); ! 975: i = link(nf, lf); ! 976: (void) unlink(nf); ! 977: if (i < 0) ! 978: continue; ! 979: if (link(lf, qf) >= 0) ! 980: break; ! 981: (void) unlink(lf); ! 982: # else QUEUE ! 983: if (close(creat(qf, FileMode)) >= 0) ! 984: break; ! 985: # endif QUEUE ! 986: } ! 987: if (c1 >= '~' && c2 >= 'Z') ! 988: { ! 989: syserr("queuename: Cannot create \"%s\" in \"%s\"", ! 990: qf, QueueDir); ! 991: exit(EX_OSERR); ! 992: } ! 993: e->e_id = newstr(&qf[2]); ! 994: define('i', e->e_id, e); ! 995: # ifdef DEBUG ! 996: if (tTd(7, 1)) ! 997: printf("queuename: assigned id %s, env=%x\n", e->e_id, e); ! 998: # ifdef LOG ! 999: if (LogLevel > 16) ! 1000: syslog(LOG_DEBUG, "%s: assigned id", e->e_id); ! 1001: # endif LOG ! 1002: # endif DEBUG ! 1003: } ! 1004: ! 1005: if (type == '\0') ! 1006: return (NULL); ! 1007: (void) sprintf(buf, "%cf%s", type, e->e_id); ! 1008: # ifdef DEBUG ! 1009: if (tTd(7, 2)) ! 1010: printf("queuename: %s\n", buf); ! 1011: # endif DEBUG ! 1012: return (buf); ! 1013: } ! 1014: /* ! 1015: ** UNLOCKQUEUE -- unlock the queue entry for a specified envelope ! 1016: ** ! 1017: ** Parameters: ! 1018: ** e -- the envelope to unlock. ! 1019: ** ! 1020: ** Returns: ! 1021: ** none ! 1022: ** ! 1023: ** Side Effects: ! 1024: ** unlocks the queue for `e'. ! 1025: */ ! 1026: ! 1027: unlockqueue(e) ! 1028: ENVELOPE *e; ! 1029: { ! 1030: /* remove the transcript */ ! 1031: #ifdef DEBUG ! 1032: # ifdef LOG ! 1033: if (LogLevel > 19) ! 1034: syslog(LOG_DEBUG, "%s: unlock", e->e_id); ! 1035: # endif LOG ! 1036: if (!tTd(51, 4)) ! 1037: #endif DEBUG ! 1038: xunlink(queuename(e, 'x')); ! 1039: ! 1040: # ifdef QUEUE ! 1041: /* last but not least, remove the lock */ ! 1042: xunlink(queuename(e, 'l')); ! 1043: # endif QUEUE ! 1044: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.