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