Return to collect.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / Mail

Annotation of 43BSDTahoe/ucb/Mail/collect.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms are permitted
        !             6:  * provided that this notice is preserved and that due credit is given
        !             7:  * to the University of California at Berkeley. The name of the University
        !             8:  * may not be used to endorse or promote products derived from this
        !             9:  * software without specific prior written permission. This software
        !            10:  * is provided ``as is'' without express or implied warranty.
        !            11:  */
        !            12: 
        !            13: #ifdef notdef
        !            14: static char sccsid[] = "@(#)collect.c  5.6 (Berkeley) 2/18/88";
        !            15: #endif /* notdef */
        !            16: 
        !            17: /*
        !            18:  * Mail -- a mail program
        !            19:  *
        !            20:  * Collect input from standard input, handling
        !            21:  * ~ escapes.
        !            22:  */
        !            23: 
        !            24: #include "rcv.h"
        !            25: #include <sys/stat.h>
        !            26: #include <sys/wait.h>
        !            27: 
        !            28: /*
        !            29:  * Read a message from standard output and return a read file to it
        !            30:  * or NULL on error.
        !            31:  */
        !            32: 
        !            33: /*
        !            34:  * The following hokiness with global variables is so that on
        !            35:  * receipt of an interrupt signal, the partial message can be salted
        !            36:  * away on dead.letter.
        !            37:  */
        !            38: 
        !            39: static int     (*saveint)();           /* Previous SIGINT value */
        !            40: static int     (*savehup)();           /* Previous SIGHUP value */
        !            41: static int     (*savecont)();          /* Previous SIGCONT value */
        !            42: static FILE    *collf;                 /* File for saving away */
        !            43: static int     hadintr;                /* Have seen one SIGINT so far */
        !            44: 
        !            45: static jmp_buf coljmp;                 /* To get back to work */
        !            46: 
        !            47: FILE *
        !            48: collect(hp)
        !            49:        struct header *hp;
        !            50: {
        !            51:        FILE *fp, *fbuf;
        !            52:        int lc, cc, escape, eof;
        !            53:        int collrub(), intack(), collcont();
        !            54:        register int c, t;
        !            55:        char linebuf[LINESIZE], *cp;
        !            56:        extern char tempMail[];
        !            57:        int notify();
        !            58:        char getsub;
        !            59:        int omask;
        !            60: 
        !            61:        noreset++;
        !            62:        fp = NULL;
        !            63:        collf = NULL;
        !            64: 
        !            65:        /*
        !            66:         * Start catching signals from here, but we're still die on interrupts
        !            67:         * until we're in the main loop.
        !            68:         */
        !            69:        omask = sigblock(sigmask(SIGINT) | sigmask(SIGHUP));
        !            70:        if ((saveint = signal(SIGINT, SIG_IGN)) != SIG_IGN)
        !            71:                signal(SIGINT, value("ignore") != NOSTR ? intack : collrub);
        !            72:        if ((savehup = signal(SIGHUP, SIG_IGN)) != SIG_IGN)
        !            73:                signal(SIGHUP, collrub);
        !            74:        savecont = signal(SIGCONT, SIG_DFL);
        !            75:        if (setjmp(coljmp)) {
        !            76:                remove(tempMail);
        !            77:                goto err;
        !            78:        }
        !            79:        sigsetmask(omask & ~(sigmask(SIGINT) | sigmask(SIGHUP)));
        !            80: 
        !            81:        if ((fp = fopen(tempMail, "w+")) == NULL) {
        !            82:                perror(tempMail);
        !            83:                goto err;
        !            84:        }
        !            85:        collf = fp;
        !            86:        remove(tempMail);
        !            87: 
        !            88:        /*
        !            89:         * If we are going to prompt for a subject,
        !            90:         * refrain from printing a newline after
        !            91:         * the headers (since some people mind).
        !            92:         */
        !            93:        t = GTO|GSUBJECT|GCC|GNL;
        !            94:        getsub = 0;
        !            95:        if (intty && sflag == NOSTR && hp->h_subject == NOSTR && value("ask"))
        !            96:                t &= ~GNL, getsub++;
        !            97:        if (hp->h_seq != 0) {
        !            98:                puthead(hp, stdout, t);
        !            99:                fflush(stdout);
        !           100:        }
        !           101:        escape = ESCAPE;
        !           102:        if ((cp = value("escape")) != NOSTR)
        !           103:                escape = *cp;
        !           104:        eof = 0;
        !           105:        hadintr = 0;
        !           106: 
        !           107:        /*
        !           108:         * We can put the setjmp here because register variable
        !           109:         * needs to be saved in the loop.
        !           110:         */
        !           111:        if (!setjmp(coljmp)) {
        !           112:                signal(SIGCONT, collcont);
        !           113:                if (getsub)
        !           114:                        grabh(hp, GSUBJECT);
        !           115:        } else {
        !           116:                /*
        !           117:                 * Come here for printing the after-signal message.
        !           118:                 * Duplicate messages won't be printed because
        !           119:                 * the write is aborted if we get a SIGTTOU.
        !           120:                 */
        !           121: cont:
        !           122:                if (hadintr) {
        !           123:                        fflush(stdout);
        !           124:                        fprintf(stderr,
        !           125:                        "\n(Interrupt -- one more to kill letter)\n");
        !           126:                } else {
        !           127:                        printf("(continue)\n");
        !           128:                        fflush(stdout);
        !           129:                }
        !           130:        }
        !           131:        for (;;) {
        !           132:                if (readline(stdin, linebuf) < 0) {
        !           133:                        if (intty && value("ignoreeof") != NOSTR) {
        !           134:                                if (++eof > 35)
        !           135:                                        break;
        !           136:                                printf("Use \".\" to terminate letter\n");
        !           137:                                continue;
        !           138:                        }
        !           139:                        break;
        !           140:                }
        !           141:                eof = 0;
        !           142:                hadintr = 0;
        !           143:                if (intty && equal(".", linebuf) &&
        !           144:                    (value("dot") != NOSTR || value("ignoreeof") != NOSTR))
        !           145:                        break;
        !           146:                if (linebuf[0] != escape || rflag != NOSTR) {
        !           147:                        if (putline(fp, linebuf) < 0)
        !           148:                                goto err;
        !           149:                        continue;
        !           150:                }
        !           151:                c = linebuf[1];
        !           152:                switch (c) {
        !           153:                default:
        !           154:                        /*
        !           155:                         * On double escape, just send the single one.
        !           156:                         * Otherwise, it's an error.
        !           157:                         */
        !           158: 
        !           159:                        if (c == escape) {
        !           160:                                if (putline(fp, &linebuf[1]) < 0)
        !           161:                                        goto err;
        !           162:                                else
        !           163:                                        break;
        !           164:                        }
        !           165:                        printf("Unknown tilde escape.\n");
        !           166:                        break;
        !           167: 
        !           168:                case 'C':
        !           169:                        /*
        !           170:                         * Dump core.
        !           171:                         */
        !           172: 
        !           173:                        core();
        !           174:                        break;
        !           175: 
        !           176:                case '!':
        !           177:                        /*
        !           178:                         * Shell escape, send the balance of the
        !           179:                         * line to sh -c.
        !           180:                         */
        !           181: 
        !           182:                        shell(&linebuf[2]);
        !           183:                        break;
        !           184: 
        !           185:                case ':':
        !           186:                case '_':
        !           187:                        /*
        !           188:                         * Escape to command mode, but be nice!
        !           189:                         */
        !           190: 
        !           191:                        execute(&linebuf[2], 1);
        !           192:                        goto cont;
        !           193: 
        !           194:                case '.':
        !           195:                        /*
        !           196:                         * Simulate end of file on input.
        !           197:                         */
        !           198:                        goto out;
        !           199: 
        !           200:                case 'q':
        !           201:                case 'Q':
        !           202:                        /*
        !           203:                         * Force a quit of sending mail.
        !           204:                         * Act like an interrupt happened.
        !           205:                         */
        !           206: 
        !           207:                        hadintr++;
        !           208:                        collrub(SIGINT);
        !           209:                        exit(1);
        !           210: 
        !           211:                case 'h':
        !           212:                        /*
        !           213:                         * Grab a bunch of headers.
        !           214:                         */
        !           215:                        if (!intty || !outtty) {
        !           216:                                printf("~h: no can do!?\n");
        !           217:                                break;
        !           218:                        }
        !           219:                        grabh(hp, GTO|GSUBJECT|GCC|GBCC);
        !           220:                        goto cont;
        !           221: 
        !           222:                case 't':
        !           223:                        /*
        !           224:                         * Add to the To list.
        !           225:                         */
        !           226: 
        !           227:                        hp->h_to = addto(hp->h_to, &linebuf[2]);
        !           228:                        hp->h_seq++;
        !           229:                        break;
        !           230: 
        !           231:                case 's':
        !           232:                        /*
        !           233:                         * Set the Subject list.
        !           234:                         */
        !           235: 
        !           236:                        cp = &linebuf[2];
        !           237:                        while (isspace(*cp))
        !           238:                                cp++;
        !           239:                        hp->h_subject = savestr(cp);
        !           240:                        hp->h_seq++;
        !           241:                        break;
        !           242: 
        !           243:                case 'c':
        !           244:                        /*
        !           245:                         * Add to the CC list.
        !           246:                         */
        !           247: 
        !           248:                        hp->h_cc = addto(hp->h_cc, &linebuf[2]);
        !           249:                        hp->h_seq++;
        !           250:                        break;
        !           251: 
        !           252:                case 'b':
        !           253:                        /*
        !           254:                         * Add stuff to blind carbon copies list.
        !           255:                         */
        !           256:                        hp->h_bcc = addto(hp->h_bcc, &linebuf[2]);
        !           257:                        hp->h_seq++;
        !           258:                        break;
        !           259: 
        !           260:                case 'd':
        !           261:                        strcpy(linebuf + 2, deadletter);
        !           262:                        /* fall into . . . */
        !           263: 
        !           264:                case 'r':
        !           265:                        /*
        !           266:                         * Invoke a file:
        !           267:                         * Search for the file name,
        !           268:                         * then open it and copy the contents to fp.
        !           269:                         */
        !           270: 
        !           271:                        cp = &linebuf[2];
        !           272:                        while (isspace(*cp))
        !           273:                                cp++;
        !           274:                        if (*cp == '\0') {
        !           275:                                printf("Interpolate what file?\n");
        !           276:                                break;
        !           277:                        }
        !           278:                        cp = expand(cp);
        !           279:                        if (cp == NOSTR)
        !           280:                                break;
        !           281:                        if (isdir(cp)) {
        !           282:                                printf("%s: Directory\n", cp);
        !           283:                                break;
        !           284:                        }
        !           285:                        if ((fbuf = fopen(cp, "r")) == NULL) {
        !           286:                                perror(cp);
        !           287:                                break;
        !           288:                        }
        !           289:                        printf("\"%s\" ", cp);
        !           290:                        fflush(stdout);
        !           291:                        lc = 0;
        !           292:                        cc = 0;
        !           293:                        while (readline(fbuf, linebuf) >= 0) {
        !           294:                                lc++;
        !           295:                                if ((t = putline(fp, linebuf)) < 0) {
        !           296:                                        fclose(fbuf);
        !           297:                                        goto err;
        !           298:                                }
        !           299:                                cc += t;
        !           300:                        }
        !           301:                        fclose(fbuf);
        !           302:                        printf("%d/%d\n", lc, cc);
        !           303:                        break;
        !           304: 
        !           305:                case 'w':
        !           306:                        /*
        !           307:                         * Write the message on a file.
        !           308:                         */
        !           309: 
        !           310:                        cp = &linebuf[2];
        !           311:                        while (any(*cp, " \t"))
        !           312:                                cp++;
        !           313:                        if (*cp == '\0') {
        !           314:                                fprintf(stderr, "Write what file!?\n");
        !           315:                                break;
        !           316:                        }
        !           317:                        if ((cp = expand(cp)) == NOSTR)
        !           318:                                break;
        !           319:                        rewind(fp);
        !           320:                        exwrite(cp, fp, 1);
        !           321:                        break;
        !           322: 
        !           323:                case 'm':
        !           324:                case 'f':
        !           325:                        /*
        !           326:                         * Interpolate the named messages, if we
        !           327:                         * are in receiving mail mode.  Does the
        !           328:                         * standard list processing garbage.
        !           329:                         * If ~f is given, we don't shift over.
        !           330:                         */
        !           331: 
        !           332:                        if (!rcvmode) {
        !           333:                                printf("No messages to send from!?!\n");
        !           334:                                break;
        !           335:                        }
        !           336:                        cp = &linebuf[2];
        !           337:                        while (any(*cp, " \t"))
        !           338:                                cp++;
        !           339:                        if (forward(cp, fp, c) < 0)
        !           340:                                goto err;
        !           341:                        goto cont;
        !           342: 
        !           343:                case '?':
        !           344:                        if ((fbuf = fopen(THELPFILE, "r")) == NULL) {
        !           345:                                perror(THELPFILE);
        !           346:                                break;
        !           347:                        }
        !           348:                        while ((t = getc(fbuf)) != EOF)
        !           349:                                putchar(t);
        !           350:                        fclose(fbuf);
        !           351:                        break;
        !           352: 
        !           353:                case 'p':
        !           354:                        /*
        !           355:                         * Print out the current state of the
        !           356:                         * message without altering anything.
        !           357:                         */
        !           358: 
        !           359:                        rewind(fp);
        !           360:                        printf("-------\nMessage contains:\n");
        !           361:                        puthead(hp, stdout, GTO|GSUBJECT|GCC|GBCC|GNL);
        !           362:                        while ((t = getc(fp)) != EOF)
        !           363:                                putchar(t);
        !           364:                        goto cont;
        !           365: 
        !           366:                case '^':
        !           367:                case '|':
        !           368:                        /*
        !           369:                         * Pipe message through command.
        !           370:                         * Collect output as new message.
        !           371:                         */
        !           372: 
        !           373:                        rewind(fp);
        !           374:                        fp = mespipe(fp, &linebuf[2]);
        !           375:                        goto cont;
        !           376: 
        !           377:                case 'v':
        !           378:                case 'e':
        !           379:                        /*
        !           380:                         * Edit the current message.
        !           381:                         * 'e' means to use EDITOR
        !           382:                         * 'v' means to use VISUAL
        !           383:                         */
        !           384: 
        !           385:                        rewind(fp);
        !           386:                        if ((fp = mesedit(fp, c)) == NULL)
        !           387:                                goto err;
        !           388:                        goto cont;
        !           389:                }
        !           390:        }
        !           391:        goto out;
        !           392: err:
        !           393:        if (fp != NULL) {
        !           394:                fclose(fp);
        !           395:                fp = NULL;
        !           396:        }
        !           397: out:
        !           398:        if (fp != NULL)
        !           399:                rewind(fp);
        !           400:        signal(SIGINT, saveint);
        !           401:        signal(SIGHUP, savehup);
        !           402:        signal(SIGCONT, savecont);
        !           403:        sigsetmask(omask);
        !           404:        noreset = 0;
        !           405:        return(fp);
        !           406: }
        !           407: 
        !           408: /*
        !           409:  * Write a file, ex-like if f set.
        !           410:  */
        !           411: 
        !           412: exwrite(name, fp, f)
        !           413:        char name[];
        !           414:        FILE *fp;
        !           415: {
        !           416:        register FILE *of;
        !           417:        register int c;
        !           418:        long cc;
        !           419:        int lc;
        !           420:        struct stat junk;
        !           421: 
        !           422:        if (f) {
        !           423:                printf("\"%s\" ", name);
        !           424:                fflush(stdout);
        !           425:        }
        !           426:        if (stat(name, &junk) >= 0 && (junk.st_mode & S_IFMT) == S_IFREG) {
        !           427:                if (!f)
        !           428:                        fprintf(stderr, "%s: ", name);
        !           429:                fprintf(stderr, "File exists\n");
        !           430:                return(-1);
        !           431:        }
        !           432:        if ((of = fopen(name, "w")) == NULL) {
        !           433:                perror(NOSTR);
        !           434:                return(-1);
        !           435:        }
        !           436:        lc = 0;
        !           437:        cc = 0;
        !           438:        while ((c = getc(fp)) != EOF) {
        !           439:                cc++;
        !           440:                if (c == '\n')
        !           441:                        lc++;
        !           442:                putc(c, of);
        !           443:                if (ferror(of)) {
        !           444:                        perror(name);
        !           445:                        fclose(of);
        !           446:                        return(-1);
        !           447:                }
        !           448:        }
        !           449:        fclose(of);
        !           450:        printf("%d/%ld\n", lc, cc);
        !           451:        fflush(stdout);
        !           452:        return(0);
        !           453: }
        !           454: 
        !           455: /*
        !           456:  * Edit the message being collected on fp.
        !           457:  * Write the message out onto some poorly-named temp file
        !           458:  * and point an editor at it.
        !           459:  *
        !           460:  * On return, make the edit file the new temp file.
        !           461:  */
        !           462: 
        !           463: FILE *
        !           464: mesedit(fp, c)
        !           465:        FILE *fp;
        !           466: {
        !           467:        int pid;
        !           468:        union wait s;
        !           469:        FILE *fbuf;
        !           470:        register int t;
        !           471:        int (*sigint)(), (*sigcont)();
        !           472:        struct stat sbuf;
        !           473:        extern char tempEdit[];
        !           474:        register char *edit;
        !           475: 
        !           476:        sigint = signal(SIGINT, SIG_IGN);
        !           477:        sigcont = signal(SIGCONT, SIG_DFL);
        !           478:        if (stat(tempEdit, &sbuf) >= 0) {
        !           479:                printf("%s: file exists\n", tempEdit);
        !           480:                goto out;
        !           481:        }
        !           482:        close(creat(tempEdit, 0600));
        !           483:        if ((fbuf = fopen(tempEdit, "w")) == NULL) {
        !           484:                perror(tempEdit);
        !           485:                goto out;
        !           486:        }
        !           487:        while ((t = getc(fp)) != EOF)
        !           488:                putc(t, fbuf);
        !           489:        fflush(fbuf);
        !           490:        if (ferror(fbuf)) {
        !           491:                perror(tempEdit);
        !           492:                remove(tempEdit);
        !           493:                goto fix;
        !           494:        }
        !           495:        fclose(fbuf);
        !           496:        if ((edit = value(c == 'e' ? "EDITOR" : "VISUAL")) == NOSTR)
        !           497:                edit = c == 'e' ? EDITOR : VISUAL;
        !           498:        pid = vfork();
        !           499:        if (pid == 0) {
        !           500:                if (sigint != SIG_IGN)
        !           501:                        signal(SIGINT, SIG_DFL);
        !           502:                execl(edit, edit, tempEdit, 0);
        !           503:                perror(edit);
        !           504:                _exit(1);
        !           505:        }
        !           506:        if (pid == -1) {
        !           507:                perror("fork");
        !           508:                remove(tempEdit);
        !           509:                goto out;
        !           510:        }
        !           511:        while (wait(&s) != pid)
        !           512:                ;
        !           513:        if (s.w_status != 0) {
        !           514:                printf("Fatal error in \"%s\"\n", edit);
        !           515:                remove(tempEdit);
        !           516:                goto out;
        !           517:        }
        !           518: 
        !           519:        /*
        !           520:         * Now switch to new file.
        !           521:         */
        !           522: 
        !           523:        if ((fbuf = fopen(tempEdit, "a+")) == NULL) {
        !           524:                perror(tempEdit);
        !           525:                remove(tempEdit);
        !           526:                goto out;
        !           527:        }
        !           528:        remove(tempEdit);
        !           529:        collf = fbuf;
        !           530:        fclose(fp);
        !           531:        fp = fbuf;
        !           532:        goto out;
        !           533: fix:
        !           534:        perror(tempEdit);
        !           535: out:
        !           536:        signal(SIGCONT, sigcont);
        !           537:        signal(SIGINT, sigint);
        !           538:        return(fp);
        !           539: }
        !           540: 
        !           541: /*
        !           542:  * Pipe the message through the command.
        !           543:  * Old message is on stdin of command;
        !           544:  * New message collected from stdout.
        !           545:  * Sh -c must return 0 to accept the new message.
        !           546:  */
        !           547: 
        !           548: FILE *
        !           549: mespipe(fp, cmd)
        !           550:        FILE *fp;
        !           551:        char cmd[];
        !           552: {
        !           553:        extern char tempEdit[];
        !           554:        register FILE *nf;
        !           555:        int pid;
        !           556:        union wait s;
        !           557:        int (*saveint)();
        !           558:        char *Shell;
        !           559: 
        !           560:        if ((nf = fopen(tempEdit, "w+")) == NULL) {
        !           561:                perror(tempEdit);
        !           562:                return(fp);
        !           563:        }
        !           564:        remove(tempEdit);
        !           565:        saveint = signal(SIGINT, SIG_IGN);
        !           566:        if ((Shell = value("SHELL")) == NULL)
        !           567:                Shell = "/bin/sh";
        !           568:        if ((pid = vfork()) == -1) {
        !           569:                perror("fork");
        !           570:                goto err;
        !           571:        }
        !           572:        if (pid == 0) {
        !           573:                int fd;
        !           574:                /*
        !           575:                 * stdin = current message.
        !           576:                 * stdout = new message.
        !           577:                 */
        !           578: 
        !           579:                close(0);
        !           580:                dup(fileno(fp));
        !           581:                close(1);
        !           582:                dup(fileno(nf));
        !           583:                for (fd = getdtablesize(); --fd > 2;)
        !           584:                        close(fd);
        !           585:                execl(Shell, Shell, "-c", cmd, 0);
        !           586:                perror(Shell);
        !           587:                _exit(1);
        !           588:        }
        !           589:        while (wait(&s) != pid)
        !           590:                ;
        !           591:        if (s.w_status != 0 || pid == -1) {
        !           592:                fprintf(stderr, "\"%s\" failed!?\n", cmd);
        !           593:                goto err;
        !           594:        }
        !           595:        if (fsize(nf) == 0) {
        !           596:                fprintf(stderr, "No bytes from \"%s\" !?\n", cmd);
        !           597:                goto err;
        !           598:        }
        !           599: 
        !           600:        /*
        !           601:         * Take new files.
        !           602:         */
        !           603: 
        !           604:        fseek(nf, 0L, 2);
        !           605:        collf = nf;
        !           606:        fclose(fp);
        !           607:        signal(SIGINT, saveint);
        !           608:        return(nf);
        !           609: 
        !           610: err:
        !           611:        fclose(nf);
        !           612:        signal(SIGINT, saveint);
        !           613:        return(fp);
        !           614: }
        !           615: 
        !           616: /*
        !           617:  * Interpolate the named messages into the current
        !           618:  * message, preceding each line with a tab.
        !           619:  * Return a count of the number of characters now in
        !           620:  * the message, or -1 if an error is encountered writing
        !           621:  * the message temporary.  The flag argument is 'm' if we
        !           622:  * should shift over and 'f' if not.
        !           623:  */
        !           624: forward(ms, fp, f)
        !           625:        char ms[];
        !           626:        FILE *fp;
        !           627: {
        !           628:        register int *msgvec, *ip;
        !           629:        extern char tempMail[];
        !           630: 
        !           631:        msgvec = (int *) salloc((msgCount+1) * sizeof *msgvec);
        !           632:        if (msgvec == (int *) NOSTR)
        !           633:                return(0);
        !           634:        if (getmsglist(ms, msgvec, 0) < 0)
        !           635:                return(0);
        !           636:        if (*msgvec == NULL) {
        !           637:                *msgvec = first(0, MMNORM);
        !           638:                if (*msgvec == NULL) {
        !           639:                        printf("No appropriate messages\n");
        !           640:                        return(0);
        !           641:                }
        !           642:                msgvec[1] = NULL;
        !           643:        }
        !           644:        printf("Interpolating:");
        !           645:        for (ip = msgvec; *ip != NULL; ip++) {
        !           646:                touch(*ip);
        !           647:                printf(" %d", *ip);
        !           648:                if (f == 'm') {
        !           649:                        if (transmit(&message[*ip-1], fp) < 0L) {
        !           650:                                perror(tempMail);
        !           651:                                return(-1);
        !           652:                        }
        !           653:                } else
        !           654:                        if (send(&message[*ip-1], fp, 0) < 0) {
        !           655:                                perror(tempMail);
        !           656:                                return(-1);
        !           657:                        }
        !           658:        }
        !           659:        printf("\n");
        !           660:        return(0);
        !           661: }
        !           662: 
        !           663: /*
        !           664:  * Send message described by the passed pointer to the
        !           665:  * passed output buffer.  Insert a tab in front of each
        !           666:  * line.  Return a count of the characters sent, or -1
        !           667:  * on error.
        !           668:  */
        !           669: 
        !           670: long
        !           671: transmit(mailp, fp)
        !           672:        struct message *mailp;
        !           673:        FILE *fp;
        !           674: {
        !           675:        register struct message *mp;
        !           676:        register int ch;
        !           677:        long c, n;
        !           678:        int bol;
        !           679:        FILE *ibuf;
        !           680: 
        !           681:        mp = mailp;
        !           682:        ibuf = setinput(mp);
        !           683:        c = mp->m_size;
        !           684:        n = c;
        !           685:        bol = 1;
        !           686:        while (c-- > 0L) {
        !           687:                ch = getc(ibuf);
        !           688:                if (ch == '\n')
        !           689:                        bol = 1;
        !           690:                else if (bol) {
        !           691:                        bol = 0;
        !           692:                        putc('\t', fp);
        !           693:                        n++;
        !           694:                }
        !           695:                putc(ch, fp);
        !           696:                if (ferror(fp)) {
        !           697:                        perror("/tmp");
        !           698:                        return(-1L);
        !           699:                }
        !           700:        }
        !           701:        return(n);
        !           702: }
        !           703: 
        !           704: /*
        !           705:  * Print (continue) when continued after ^Z.
        !           706:  */
        !           707: /*ARGSUSED*/
        !           708: collcont(s)
        !           709: {
        !           710: 
        !           711:        hadintr = 0;
        !           712:        longjmp(coljmp, 1);
        !           713: }
        !           714: 
        !           715: /*
        !           716:  * On interrupt, go here to save the partial
        !           717:  * message on ~/dead.letter.
        !           718:  * Then restore signals and execute the normal
        !           719:  * signal routine.  We only come here if signals
        !           720:  * were previously set anyway.
        !           721:  */
        !           722: 
        !           723: collrub(s)
        !           724: {
        !           725:        register FILE *dbuf;
        !           726:        register int c;
        !           727: 
        !           728:        if (s == SIGINT && hadintr == 0) {
        !           729:                hadintr = 1;
        !           730:                longjmp(coljmp, 1);
        !           731:        }
        !           732:        rewind(collf);
        !           733:        if (s == SIGINT && value("nosave") != NOSTR || fsize(collf) == 0)
        !           734:                goto done;
        !           735:        if ((dbuf = fopen(deadletter, "w")) == NULL)
        !           736:                goto done;
        !           737:        chmod(deadletter, 0600);
        !           738:        while ((c = getc(collf)) != EOF)
        !           739:                putc(c, dbuf);
        !           740:        fclose(dbuf);
        !           741: 
        !           742: done:
        !           743:        fclose(collf);
        !           744:        signal(SIGINT, saveint);
        !           745:        signal(SIGHUP, savehup);
        !           746:        signal(SIGCONT, savecont);
        !           747:        if (rcvmode) {
        !           748:                if (s == SIGHUP)
        !           749:                        hangup(SIGHUP);
        !           750:                else
        !           751:                        stop(s);
        !           752:        } else
        !           753:                exit(1);
        !           754: }
        !           755: 
        !           756: /*
        !           757:  * Acknowledge an interrupt signal from the tty by typing an @
        !           758:  */
        !           759: 
        !           760: /*ARGSUSED*/
        !           761: intack(s)
        !           762: {
        !           763: 
        !           764:        puts("@");
        !           765:        fflush(stdout);
        !           766:        clearerr(stdin);
        !           767: }
        !           768: 
        !           769: /*
        !           770:  * Add a string to the end of a header entry field.
        !           771:  */
        !           772: 
        !           773: char *
        !           774: addto(hf, news)
        !           775:        char hf[], news[];
        !           776: {
        !           777:        register char *cp, *cp2, *linebuf;
        !           778: 
        !           779:        if (hf == NOSTR)
        !           780:                hf = "";
        !           781:        if (*news == '\0')
        !           782:                return(hf);
        !           783:        linebuf = salloc(strlen(hf) + strlen(news) + 2);
        !           784:        for (cp = hf; any(*cp, " \t"); cp++)
        !           785:                ;
        !           786:        for (cp2 = linebuf; *cp;)
        !           787:                *cp2++ = *cp++;
        !           788:        *cp2++ = ' ';
        !           789:        for (cp = news; any(*cp, " \t"); cp++)
        !           790:                ;
        !           791:        while (*cp != '\0')
        !           792:                *cp2++ = *cp++;
        !           793:        *cp2 = '\0';
        !           794:        return(linebuf);
        !           795: }

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