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