Return to msgs.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / msgs

Annotation of 43BSD/ucb/msgs/msgs.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: char copyright[] =
        !             9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
        !            10:  All rights reserved.\n";
        !            11: #endif not lint
        !            12: 
        !            13: #ifndef lint
        !            14: static char sccsid[] = "@(#)msgs.c     5.2 (Berkeley) 4/10/86";
        !            15: #endif not lint
        !            16: 
        !            17: /*
        !            18:  * msgs - a user bulletin board program
        !            19:  *
        !            20:  * usage:
        !            21:  *     msgs [fhlopq] [[-]number]       to read messages
        !            22:  *     msgs -s                         to place messages
        !            23:  *     msgs -c [-days]                 to clean up the bulletin board
        !            24:  *
        !            25:  * prompt commands are:
        !            26:  *     y       print message
        !            27:  *     n       flush message, go to next message
        !            28:  *     q       flush message, quit
        !            29:  *     p       print message, turn on 'pipe thru more' mode
        !            30:  *     P       print message, turn off 'pipe thru more' mode
        !            31:  *     -       reprint last message
        !            32:  *     s[-][<num>] [<filename>]        save message
        !            33:  *     m[-][<num>]     mail with message in temp mbox
        !            34:  *     x       exit without flushing this message
        !            35:  *     <num>   print message number <num>
        !            36:  */
        !            37: 
        !            38: #define V7             /* will look for TERM in the environment */
        !            39: #define OBJECT         /* will object to messages without Subjects */
        !            40: /* #define REJECT      /* will reject messages without Subjects
        !            41:                           (OBJECT must be defined also) */
        !            42: /* #define UNBUFFERED  /* use unbuffered output */
        !            43: 
        !            44: #include <stdio.h>
        !            45: #include <sys/param.h>
        !            46: #include <signal.h>
        !            47: #include <sys/dir.h>
        !            48: #include <sys/stat.h>
        !            49: #include <ctype.h>
        !            50: #include <pwd.h>
        !            51: #include <sgtty.h>
        !            52: #include <setjmp.h>
        !            53: #include "msgs.h"
        !            54: 
        !            55: #define CMODE  0666            /* bounds file creation mode */
        !            56: #define NO     0
        !            57: #define YES    1
        !            58: #define SUPERUSER      0       /* superuser uid */
        !            59: #define DAEMON         1       /* daemon uid */
        !            60: #define NLINES 24              /* default number of lines/crt screen */
        !            61: #define NDAYS  21              /* default keep time for messages */
        !            62: #define DAYS   *24*60*60       /* seconds/day */
        !            63: #define TEMP   "/tmp/msgXXXXXX"
        !            64: #define MSGSRC ".msgsrc"       /* user's rc file */
        !            65: #define BOUNDS "bounds"        /* message bounds file */
        !            66: #define NEXT   "Next message? [yq]"
        !            67: #define MORE   "More? [ynq]"
        !            68: #define NOMORE "(No more) [q] ?"
        !            69: 
        !            70: typedef        char    bool;
        !            71: 
        !            72: FILE   *newmsg;
        !            73: char   *sep = "-";
        !            74: char   inbuf[BUFSIZ];
        !            75: char   fname[128];
        !            76: char   cmdbuf[128];
        !            77: char   subj[128];
        !            78: char   from[128];
        !            79: char   date[128];
        !            80: char   *ptr;
        !            81: char   *in;
        !            82: bool   local;
        !            83: bool   ruptible;
        !            84: bool   totty;
        !            85: bool   seenfrom;
        !            86: bool   seensubj;
        !            87: bool   blankline;
        !            88: bool   printing = NO;
        !            89: bool   mailing = NO;
        !            90: bool   quitit = NO;
        !            91: bool   sending = NO;
        !            92: bool   intrpflg = NO;
        !            93: bool   tstpflag = NO;
        !            94: int    uid;
        !            95: int    msg;
        !            96: int    prevmsg;
        !            97: int    lct;
        !            98: int    nlines;
        !            99: int    Lpp = 0;
        !           100: time_t t;
        !           101: time_t keep;
        !           102: struct sgttyb  otty;
        !           103: 
        !           104: char   *ctime();
        !           105: char   *nxtfld();
        !           106: int    onintr();
        !           107: int    onsusp();
        !           108: off_t  ftell();
        !           109: FILE   *popen();
        !           110: struct passwd  *getpwuid();
        !           111: 
        !           112: extern int     errno;
        !           113: 
        !           114: /* option initialization */
        !           115: bool   hdrs = NO;
        !           116: bool   qopt = NO;
        !           117: bool   hush = NO;
        !           118: bool   send = NO;
        !           119: bool   locomode = NO;
        !           120: bool   pause = NO;
        !           121: bool   clean = NO;
        !           122: bool   lastcmd = NO;
        !           123: jmp_buf        tstpbuf;
        !           124: 
        !           125: main(argc, argv)
        !           126: int argc; char *argv[];
        !           127: {
        !           128:        bool newrc, already;
        !           129:        int rcfirst = 0;                /* first message to print (from .rc) */
        !           130:        int rcback = 0;                 /* amount to back off of rcfirst */
        !           131:        int firstmsg, nextmsg, lastmsg = 0;
        !           132:        int blast = 0;
        !           133:        FILE *bounds, *msgsrc;
        !           134: 
        !           135: #ifdef UNBUFFERED
        !           136:        setbuf(stdout, NULL);
        !           137: #endif
        !           138: 
        !           139:        gtty(fileno(stdout), &otty);
        !           140:        time(&t);
        !           141:        setuid(uid = getuid());
        !           142:        ruptible = (signal(SIGINT, SIG_IGN) == SIG_DFL);
        !           143:        if (ruptible)
        !           144:                signal(SIGINT, SIG_DFL);
        !           145: 
        !           146:        argc--, argv++;
        !           147:        while (argc > 0) {
        !           148:                if (isdigit(argv[0][0])) {      /* starting message # */
        !           149:                        rcfirst = atoi(argv[0]);
        !           150:                }
        !           151:                else if (isdigit(argv[0][1])) { /* backward offset */
        !           152:                        rcback = atoi( &( argv[0][1] ) );
        !           153:                }
        !           154:                else {
        !           155:                        ptr = *argv;
        !           156:                        while (*ptr) switch (*ptr++) {
        !           157: 
        !           158:                        case '-':
        !           159:                                break;
        !           160: 
        !           161:                        case 'c':
        !           162:                                if (uid != SUPERUSER && uid != DAEMON) {
        !           163:                                        fprintf(stderr, "Sorry\n");
        !           164:                                        exit(1);
        !           165:                                }
        !           166:                                clean = YES;
        !           167:                                break;
        !           168: 
        !           169:                        case 'f':               /* silently */
        !           170:                                hush = YES;
        !           171:                                break;
        !           172: 
        !           173:                        case 'h':               /* headers only */
        !           174:                                hdrs = YES;
        !           175:                                break;
        !           176: 
        !           177:                        case 'l':               /* local msgs only */
        !           178:                                locomode = YES;
        !           179:                                break;
        !           180: 
        !           181:                        case 'o':               /* option to save last message */
        !           182:                                lastcmd = YES;
        !           183:                                break;
        !           184: 
        !           185:                        case 'p':               /* pipe thru 'more' during long msgs */
        !           186:                                pause = YES;
        !           187:                                break;
        !           188: 
        !           189:                        case 'q':               /* query only */
        !           190:                                qopt = YES;
        !           191:                                break;
        !           192: 
        !           193:                        case 's':               /* sending TO msgs */
        !           194:                                send = YES;
        !           195:                                break;
        !           196: 
        !           197:                        default:
        !           198:                                fprintf(stderr,
        !           199:                                        "usage: msgs [fhlopq] [[-]number]\n");
        !           200:                                exit(1);
        !           201:                        }
        !           202:                }
        !           203:                argc--, argv++;
        !           204:        }
        !           205: 
        !           206:        /*
        !           207:         * determine current message bounds
        !           208:         */
        !           209:        sprintf(fname, "%s/%s", USRMSGS, BOUNDS);
        !           210:        bounds = fopen(fname, "r");
        !           211: 
        !           212:        if (bounds != NULL) {
        !           213:                fscanf(bounds, "%d %d\n", &firstmsg, &lastmsg);
        !           214:                fclose(bounds);
        !           215:                blast = lastmsg;        /* save upper bound */
        !           216:        }
        !           217: 
        !           218:        if (clean)
        !           219:                keep = t - (rcback? rcback : NDAYS) DAYS;
        !           220: 
        !           221:        if (clean || bounds == NULL) {  /* relocate message bounds */
        !           222:                struct direct *dp;
        !           223:                struct stat stbuf;
        !           224:                bool seenany = NO;
        !           225:                DIR     *dirp;
        !           226: 
        !           227:                dirp = opendir(USRMSGS);
        !           228:                if (dirp == NULL) {
        !           229:                        perror(USRMSGS);
        !           230:                        exit(errno);
        !           231:                }
        !           232: 
        !           233:                firstmsg = 32767;
        !           234:                lastmsg = 0;
        !           235: 
        !           236:                for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)){
        !           237:                        register char *cp = dp->d_name;
        !           238:                        register int i = 0;
        !           239: 
        !           240:                        if (dp->d_ino == 0)
        !           241:                                continue;
        !           242:                        if (dp->d_namlen == 0)
        !           243:                                continue;
        !           244: 
        !           245:                        if (clean)
        !           246:                                sprintf(inbuf, "%s/%s", USRMSGS, cp);
        !           247: 
        !           248:                        while (isdigit(*cp))
        !           249:                                i = i * 10 + *cp++ - '0';
        !           250:                        if (*cp)
        !           251:                                continue;       /* not a message! */
        !           252: 
        !           253:                        if (clean) {
        !           254:                                if (stat(inbuf, &stbuf) != 0)
        !           255:                                        continue;
        !           256:                                if (stbuf.st_mtime < keep
        !           257:                                    && stbuf.st_mode&S_IWRITE) {
        !           258:                                        unlink(inbuf);
        !           259:                                        continue;
        !           260:                                }
        !           261:                        }
        !           262: 
        !           263:                        if (i > lastmsg)
        !           264:                                lastmsg = i;
        !           265:                        if (i < firstmsg)
        !           266:                                firstmsg = i;
        !           267:                        seenany = YES;
        !           268:                }
        !           269:                closedir(dirp);
        !           270: 
        !           271:                if (!seenany) {
        !           272:                        if (blast != 0) /* never lower the upper bound! */
        !           273:                                lastmsg = blast;
        !           274:                        firstmsg = lastmsg + 1;
        !           275:                }
        !           276:                else if (blast > lastmsg)
        !           277:                        lastmsg = blast;
        !           278: 
        !           279:                if (!send) {
        !           280:                        bounds = fopen(fname, "w");
        !           281:                        if (bounds == NULL) {
        !           282:                                perror(fname);
        !           283:                                exit(errno);
        !           284:                        }
        !           285:                        chmod(fname, CMODE);
        !           286:                        fprintf(bounds, "%d %d\n", firstmsg, lastmsg);
        !           287:                        fclose(bounds);
        !           288:                }
        !           289:        }
        !           290: 
        !           291:        if (send) {
        !           292:                /*
        !           293:                 * Send mode - place msgs in USRMSGS
        !           294:                 */
        !           295:                bounds = fopen(fname, "w");
        !           296:                if (bounds == NULL) {
        !           297:                        perror(fname);
        !           298:                        exit(errno);
        !           299:                }
        !           300: 
        !           301:                nextmsg = lastmsg + 1;
        !           302:                sprintf(fname, "%s/%d", USRMSGS, nextmsg);
        !           303:                newmsg = fopen(fname, "w");
        !           304:                if (newmsg == NULL) {
        !           305:                        perror(fname);
        !           306:                        exit(errno);
        !           307:                }
        !           308:                chmod(fname, 0644);
        !           309: 
        !           310:                fprintf(bounds, "%d %d\n", firstmsg, nextmsg);
        !           311:                fclose(bounds);
        !           312: 
        !           313:                sending = YES;
        !           314:                if (ruptible)
        !           315:                        signal(SIGINT, onintr);
        !           316: 
        !           317:                if (isatty(fileno(stdin))) {
        !           318:                        ptr = getpwuid(uid)->pw_name;
        !           319:                        printf("Message %d:\nFrom %s %sSubject: ",
        !           320:                                nextmsg, ptr, ctime(&t));
        !           321:                        fflush(stdout);
        !           322:                        fgets(inbuf, sizeof inbuf, stdin);
        !           323:                        putchar('\n');
        !           324:                        fflush(stdout);
        !           325:                        fprintf(newmsg, "From %s %sSubject: %s\n",
        !           326:                                ptr, ctime(&t), inbuf);
        !           327:                        blankline = seensubj = YES;
        !           328:                }
        !           329:                else
        !           330:                        blankline = seensubj = NO;
        !           331:                for (;;) {
        !           332:                        fgets(inbuf, sizeof inbuf, stdin);
        !           333:                        if (feof(stdin) || ferror(stdin))
        !           334:                                break;
        !           335:                        blankline = (blankline || (inbuf[0] == '\n'));
        !           336:                        seensubj = (seensubj || (!blankline && (strncmp(inbuf, "Subj", 4) == 0)));
        !           337:                        fputs(inbuf, newmsg);
        !           338:                }
        !           339: #ifdef OBJECT
        !           340:                if (!seensubj) {
        !           341:                        printf("NOTICE: Messages should have a Subject field!\n");
        !           342: #ifdef REJECT
        !           343:                        unlink(fname);
        !           344: #endif
        !           345:                        exit(1);
        !           346:                }
        !           347: #endif
        !           348:                exit(ferror(stdin));
        !           349:        }
        !           350:        if (clean)
        !           351:                exit(0);
        !           352: 
        !           353:        /*
        !           354:         * prepare to display messages
        !           355:         */
        !           356:        totty = (isatty(fileno(stdout)) != 0);
        !           357:        pause = pause && totty;
        !           358: 
        !           359:        sprintf(fname, "%s/%s", getenv("HOME"), MSGSRC);
        !           360:        msgsrc = fopen(fname, "r");
        !           361:        if (msgsrc) {
        !           362:                newrc = NO;
        !           363:                fscanf(msgsrc, "%d\n", &nextmsg);
        !           364:                fclose(msgsrc);
        !           365:                if (nextmsg > lastmsg+1) {
        !           366:                        printf("Warning: bounds have been reset (%d, %d)\n",
        !           367:                                firstmsg, lastmsg);
        !           368:                        ftruncate(fileno(msgsrc), 0);
        !           369:                        newrc = YES;
        !           370:                }
        !           371:                else if (!rcfirst)
        !           372:                        rcfirst = nextmsg - rcback;
        !           373:        }
        !           374:        else
        !           375:                newrc = YES;
        !           376:        msgsrc = fopen(fname, "a");
        !           377:        if (msgsrc == NULL) {
        !           378:                perror(fname);
        !           379:                exit(errno);
        !           380:        }
        !           381:        if (rcfirst) {
        !           382:                if (rcfirst > lastmsg+1) {
        !           383:                        printf("Warning: the last message is number %d.\n",
        !           384:                                lastmsg);
        !           385:                        rcfirst = nextmsg;
        !           386:                }
        !           387:                if (rcfirst > firstmsg)
        !           388:                        firstmsg = rcfirst;     /* don't set below first msg */
        !           389:        }
        !           390:        if (newrc) {
        !           391:                nextmsg = firstmsg;
        !           392:                fseek(msgsrc, 0L, 0);
        !           393:                fprintf(msgsrc, "%d\n", nextmsg);
        !           394:                fflush(msgsrc);
        !           395:        }
        !           396: 
        !           397: #ifdef V7
        !           398:        if (totty) {
        !           399:                struct winsize win;
        !           400:                if (ioctl(fileno(stdout), TIOCGWINSZ, &win) != -1)
        !           401:                        Lpp = win.ws_row;
        !           402:                if (Lpp <= 0) {
        !           403:                        if (tgetent(inbuf, getenv("TERM")) <= 0
        !           404:                            || (Lpp = tgetnum("li")) <= 0) {
        !           405:                                Lpp = NLINES;
        !           406:                        }
        !           407:                }
        !           408:        }
        !           409: #endif
        !           410:        Lpp -= 6;       /* for headers, etc. */
        !           411: 
        !           412:        already = NO;
        !           413:        prevmsg = firstmsg;
        !           414:        printing = YES;
        !           415:        if (ruptible)
        !           416:                signal(SIGINT, onintr);
        !           417: 
        !           418:        /*
        !           419:         * Main program loop
        !           420:         */
        !           421:        for (msg = firstmsg; msg <= lastmsg; msg++) {
        !           422: 
        !           423:                sprintf(fname, "%s/%d", USRMSGS, msg);
        !           424:                newmsg = fopen(fname, "r");
        !           425:                if (newmsg == NULL)
        !           426:                        continue;
        !           427: 
        !           428:                gfrsub(newmsg);         /* get From and Subject fields */
        !           429:                if (locomode && !local) {
        !           430:                        fclose(newmsg);
        !           431:                        continue;
        !           432:                }
        !           433: 
        !           434:                if (qopt) {     /* This has to be located here */
        !           435:                        printf("There are new messages.\n");
        !           436:                        exit(0);
        !           437:                }
        !           438: 
        !           439:                if (already && !hdrs)
        !           440:                        putchar('\n');
        !           441:                already = YES;
        !           442: 
        !           443:                /*
        !           444:                 * Print header
        !           445:                 */
        !           446: again:
        !           447:                if (totty)
        !           448:                        signal(SIGTSTP, onsusp);
        !           449:                (void) setjmp(tstpbuf);
        !           450:                nlines = 2;
        !           451:                if (seenfrom) {
        !           452:                        printf("Message %d:\nFrom %s %s", msg, from, date);
        !           453:                        nlines++;
        !           454:                }
        !           455:                if (seensubj) {
        !           456:                        printf("Subject: %s", subj);
        !           457:                        nlines++;
        !           458:                }
        !           459:                else {
        !           460:                        if (seenfrom) {
        !           461:                                putchar('\n');
        !           462:                                nlines++;
        !           463:                        }
        !           464:                        while (nlines < 6
        !           465:                            && fgets(inbuf, sizeof inbuf, newmsg)
        !           466:                            && inbuf[0] != '\n') {
        !           467:                                fputs(inbuf, stdout);
        !           468:                                nlines++;
        !           469:                        }
        !           470:                }
        !           471: 
        !           472:                lct = linecnt(newmsg);
        !           473:                if (lct)
        !           474:                        printf("(%d%slines) ", lct, seensubj? " " : " more ");
        !           475: 
        !           476:                if (hdrs) {
        !           477:                        printf("\n-----\n");
        !           478:                        fclose(newmsg);
        !           479:                        continue;
        !           480:                }
        !           481: 
        !           482:                /*
        !           483:                 * Ask user for command
        !           484:                 */
        !           485:                if (totty)
        !           486:                        ask(lct? MORE : (msg==lastmsg? NOMORE : NEXT));
        !           487:                else
        !           488:                        inbuf[0] = 'y';
        !           489:                if (totty)
        !           490:                        signal(SIGTSTP, SIG_DFL);
        !           491: cmnd:
        !           492:                in = inbuf;
        !           493:                switch (*in) {
        !           494:                        case 'x':
        !           495:                        case 'X':
        !           496:                                exit(0);
        !           497: 
        !           498:                        case 'q':
        !           499:                        case 'Q':
        !           500:                                quitit = YES;
        !           501:                                printf("--Postponed--\n");
        !           502:                                exit(0);
        !           503:                                /* intentional fall-thru */
        !           504:                        case 'n':
        !           505:                        case 'N':
        !           506:                                if (msg >= nextmsg) sep = "Flushed";
        !           507:                                prevmsg = msg;
        !           508:                                break;
        !           509: 
        !           510:                        case 'p':
        !           511:                        case 'P':
        !           512:                                pause = (*in++ == 'p');
        !           513:                                /* intentional fallthru */
        !           514:                        case '\n':
        !           515:                        case 'y':
        !           516:                        default:
        !           517:                                if (*in == '-') {
        !           518:                                        msg = prevmsg-1;
        !           519:                                        sep = "replay";
        !           520:                                        break;
        !           521:                                }
        !           522:                                if (isdigit(*in)) {
        !           523:                                        msg = next(in);
        !           524:                                        sep = in;
        !           525:                                        break;
        !           526:                                }
        !           527: 
        !           528:                                prmesg(nlines + lct + (seensubj? 1 : 0));
        !           529:                                prevmsg = msg;
        !           530: 
        !           531:                }
        !           532: 
        !           533:                printf("--%s--\n", sep);
        !           534:                sep = "-";
        !           535:                if (msg >= nextmsg) {
        !           536:                        nextmsg = msg + 1;
        !           537:                        fseek(msgsrc, 0L, 0);
        !           538:                        fprintf(msgsrc, "%d\n", nextmsg);
        !           539:                        fflush(msgsrc);
        !           540:                }
        !           541:                if (newmsg)
        !           542:                        fclose(newmsg);
        !           543:                if (quitit)
        !           544:                        break;
        !           545:        }
        !           546: 
        !           547:        /*
        !           548:         * Make sure .rc file gets updated
        !           549:         */
        !           550:        if (--msg >= nextmsg) {
        !           551:                nextmsg = msg + 1;
        !           552:                fseek(msgsrc, 0L, 0);
        !           553:                fprintf(msgsrc, "%d\n", nextmsg);
        !           554:                fflush(msgsrc);
        !           555:        }
        !           556:        if (already && !quitit && lastcmd && totty) {
        !           557:                /*
        !           558:                 * save or reply to last message?
        !           559:                 */
        !           560:                msg = prevmsg;
        !           561:                ask(NOMORE);
        !           562:                if (inbuf[0] == '-' || isdigit(inbuf[0]))
        !           563:                        goto cmnd;
        !           564:        }
        !           565:        if (!(already || hush || qopt))
        !           566:                printf("No new messages.\n");
        !           567:        exit(0);
        !           568: }
        !           569: 
        !           570: prmesg(length)
        !           571: int length;
        !           572: {
        !           573:        FILE *outf, *inf;
        !           574:        int c;
        !           575: 
        !           576:        if (pause && length > Lpp) {
        !           577:                signal(SIGPIPE, SIG_IGN);
        !           578:                signal(SIGQUIT, SIG_IGN);
        !           579:                sprintf(cmdbuf, PAGE, Lpp);
        !           580:                outf = popen(cmdbuf, "w");
        !           581:                if (!outf)
        !           582:                        outf = stdout;
        !           583:                else
        !           584:                        setbuf(outf, NULL);
        !           585:        }
        !           586:        else
        !           587:                outf = stdout;
        !           588: 
        !           589:        if (seensubj)
        !           590:                putc('\n', outf);
        !           591: 
        !           592:        while (fgets(inbuf, sizeof inbuf, newmsg)) {
        !           593:                fputs(inbuf, outf);
        !           594:                if (ferror(outf)) {
        !           595:                        clearerr(outf);
        !           596:                        break;
        !           597:                }
        !           598:        }
        !           599: 
        !           600:        if (outf != stdout) {
        !           601:                pclose(outf);
        !           602:                signal(SIGPIPE, SIG_DFL);
        !           603:                signal(SIGQUIT, SIG_DFL);
        !           604:        }
        !           605:        else {
        !           606:                fflush(stdout);
        !           607:        }
        !           608: 
        !           609:        /* trick to force wait on output */
        !           610:        stty(fileno(stdout), &otty);
        !           611: }
        !           612: 
        !           613: onintr()
        !           614: {
        !           615:        signal(SIGINT, onintr);
        !           616:        if (mailing)
        !           617:                unlink(fname);
        !           618:        if (sending) {
        !           619:                unlink(fname);
        !           620:                puts("--Killed--");
        !           621:                exit(1);
        !           622:        }
        !           623:        if (printing) {
        !           624:                putchar('\n');
        !           625:                if (hdrs)
        !           626:                        exit(0);
        !           627:                sep = "Interrupt";
        !           628:                if (newmsg)
        !           629:                        fseek(newmsg, 0L, 2);
        !           630:                intrpflg = YES;
        !           631:        }
        !           632: }
        !           633: 
        !           634: /*
        !           635:  * We have just gotten a susp.  Suspend and prepare to resume.
        !           636:  */
        !           637: onsusp()
        !           638: {
        !           639: 
        !           640:        signal(SIGTSTP, SIG_DFL);
        !           641:        sigsetmask(0);
        !           642:        kill(0, SIGTSTP);
        !           643:        signal(SIGTSTP, onsusp);
        !           644:        if (!mailing)
        !           645:                longjmp(tstpbuf);
        !           646: }
        !           647: 
        !           648: linecnt(f)
        !           649: FILE *f;
        !           650: {
        !           651:        off_t oldpos = ftell(f);
        !           652:        int l = 0;
        !           653:        char lbuf[BUFSIZ];
        !           654: 
        !           655:        while (fgets(lbuf, sizeof lbuf, f))
        !           656:                l++;
        !           657:        clearerr(f);
        !           658:        fseek(f, oldpos, 0);
        !           659:        return (l);
        !           660: }
        !           661: 
        !           662: next(buf)
        !           663: char *buf;
        !           664: {
        !           665:        int i;
        !           666:        sscanf(buf, "%d", &i);
        !           667:        sprintf(buf, "Goto %d", i);
        !           668:        return(--i);
        !           669: }
        !           670: 
        !           671: ask(prompt)
        !           672: char *prompt;
        !           673: {
        !           674:        char    inch;
        !           675:        int     n, cmsg;
        !           676:        off_t   oldpos;
        !           677:        FILE    *cpfrom, *cpto;
        !           678: 
        !           679:        printf("%s ", prompt);
        !           680:        fflush(stdout);
        !           681:        intrpflg = NO;
        !           682:        gets(inbuf);
        !           683:        if (intrpflg)
        !           684:                inbuf[0] = 'x';
        !           685: 
        !           686:        /*
        !           687:         * Handle 'mail' and 'save' here.
        !           688:         */
        !           689:        if ((inch = inbuf[0]) == 's' || inch == 'm') {
        !           690:                if (inbuf[1] == '-')
        !           691:                        cmsg = prevmsg;
        !           692:                else if (isdigit(inbuf[1]))
        !           693:                        cmsg = atoi(&inbuf[1]);
        !           694:                else
        !           695:                        cmsg = msg;
        !           696:                sprintf(fname, "%s/%d", USRMSGS, cmsg);
        !           697: 
        !           698:                oldpos = ftell(newmsg);
        !           699: 
        !           700:                cpfrom = fopen(fname, "r");
        !           701:                if (!cpfrom) {
        !           702:                        printf("Message %d not found\n", cmsg);
        !           703:                        ask (prompt);
        !           704:                        return;
        !           705:                }
        !           706: 
        !           707:                if (inch == 's') {
        !           708:                        in = nxtfld(inbuf);
        !           709:                        if (*in) {
        !           710:                                for (n=0; in[n] > ' '; n++) { /* sizeof fname? */
        !           711:                                        fname[n] = in[n];
        !           712:                                }
        !           713:                                fname[n] = NULL;
        !           714:                        }
        !           715:                        else
        !           716:                                strcpy(fname, "Messages");
        !           717:                }
        !           718:                else {
        !           719:                        strcpy(fname, TEMP);
        !           720:                        mktemp(fname);
        !           721:                        sprintf(cmdbuf, MAIL, fname);
        !           722:                        mailing = YES;
        !           723:                }
        !           724:                cpto = fopen(fname, "a");
        !           725:                if (!cpto) {
        !           726:                        perror(fname);
        !           727:                        mailing = NO;
        !           728:                        fseek(newmsg, oldpos, 0);
        !           729:                        ask(prompt);
        !           730:                        return;
        !           731:                }
        !           732: 
        !           733:                while (n = fread(inbuf, 1, sizeof inbuf, cpfrom))
        !           734:                        fwrite(inbuf, 1, n, cpto);
        !           735: 
        !           736:                fclose(cpfrom);
        !           737:                fclose(cpto);
        !           738:                fseek(newmsg, oldpos, 0);       /* reposition current message */
        !           739:                if (inch == 's')
        !           740:                        printf("Message %d saved in \"%s\"\n", cmsg, fname);
        !           741:                else {
        !           742:                        system(cmdbuf);
        !           743:                        unlink(fname);
        !           744:                        mailing = NO;
        !           745:                }
        !           746:                ask(prompt);
        !           747:        }
        !           748: }
        !           749: 
        !           750: gfrsub(infile)
        !           751: FILE *infile;
        !           752: {
        !           753:        off_t frompos;
        !           754: 
        !           755:        seensubj = seenfrom = NO;
        !           756:        local = YES;
        !           757:        subj[0] = from[0] = date[0] = NULL;
        !           758: 
        !           759:        /*
        !           760:         * Is this a normal message?
        !           761:         */
        !           762:        if (fgets(inbuf, sizeof inbuf, infile)) {
        !           763:                if (strncmp(inbuf, "From", 4)==0) {
        !           764:                        /*
        !           765:                         * expected form starts with From
        !           766:                         */
        !           767:                        seenfrom = YES;
        !           768:                        frompos = ftell(infile);
        !           769:                        ptr = from;
        !           770:                        in = nxtfld(inbuf);
        !           771:                        if (*in) while (*in && *in > ' ') {
        !           772:                                if (*in == ':' || *in == '@' || *in == '!')
        !           773:                                        local = NO;
        !           774:                                *ptr++ = *in++;
        !           775:                                /* what about sizeof from ? */
        !           776:                        }
        !           777:                        *ptr = NULL;
        !           778:                        if (*(in = nxtfld(in)))
        !           779:                                strncpy(date, in, sizeof date);
        !           780:                        else {
        !           781:                                date[0] = '\n';
        !           782:                                date[1] = NULL;
        !           783:                        }
        !           784:                }
        !           785:                else {
        !           786:                        /*
        !           787:                         * not the expected form
        !           788:                         */
        !           789:                        fseek(infile, 0L, 0);
        !           790:                        return;
        !           791:                }
        !           792:        }
        !           793:        else
        !           794:                /*
        !           795:                 * empty file ?
        !           796:                 */
        !           797:                return;
        !           798: 
        !           799:        /*
        !           800:         * look for Subject line until EOF or a blank line
        !           801:         */
        !           802:        while (fgets(inbuf, sizeof inbuf, infile)
        !           803:            && !(blankline = (inbuf[0] == '\n'))) {
        !           804:                /*
        !           805:                 * extract Subject line
        !           806:                 */
        !           807:                if (!seensubj && strncmp(inbuf, "Subj", 4)==0) {
        !           808:                        seensubj = YES;
        !           809:                        frompos = ftell(infile);
        !           810:                        strncpy(subj, nxtfld(inbuf), sizeof subj);
        !           811:                }
        !           812:        }
        !           813:        if (!blankline)
        !           814:                /*
        !           815:                 * ran into EOF
        !           816:                 */
        !           817:                fseek(infile, frompos, 0);
        !           818: 
        !           819:        if (!seensubj)
        !           820:                /*
        !           821:                 * for possible use with Mail
        !           822:                 */
        !           823:                strncpy(subj, "(No Subject)\n", sizeof subj);
        !           824: }
        !           825: 
        !           826: char *
        !           827: nxtfld(s)
        !           828: char *s;
        !           829: {
        !           830:        if (*s) while (*s && *s > ' ') s++;     /* skip over this field */
        !           831:        if (*s) while (*s && *s <= ' ') s++;    /* find start of next field */
        !           832:        return (s);
        !           833: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.