Return to cmd4.c CVS log

Up to [Research Unix] / researchv10no / lbin / mailx

Annotation of researchv10no/lbin/mailx/cmd4.c, revision 1.1

1.1     ! root        1: #ident "@(#)cmd4.c     1.3 'attmail mail(1) command'"
        !             2: #ident "@(#)mailx:cmd4.c       1.4.1.1"
        !             3: /*     Copyright (c) 1984 AT&T */
        !             4: /*       All Rights Reserved   */
        !             5: 
        !             6: /*     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T     */
        !             7: /*     The copyright notice above does not evidence any        */
        !             8: /*     actual or intended publication of such source code.     */
        !             9: 
        !            10: #ident "@(#)mailx:cmd4.c       1.4"
        !            11: 
        !            12: #include "rcv.h"
        !            13: 
        !            14: /*
        !            15:  * mailx -- a modified version of a University of California at Berkeley
        !            16:  *     mail program
        !            17:  *
        !            18:  * More commands..
        !            19:  */
        !            20: 
        !            21: 
        !            22: /*
        !            23:  * pipe messages to cmd.
        !            24:  */
        !            25: 
        !            26: dopipe(str)
        !            27:        char str[];
        !            28: {
        !            29:        register int *ip, mesg;
        !            30:        register struct message *mp;
        !            31:        char *cp, *cmd;
        !            32:        int f, *msgvec, nowait=0;
        !            33:        void (*sigint)(), (*sigpipe)();
        !            34:        long lc, cc, t;
        !            35:        register pid_t pid;
        !            36:        int page, s, pivec[2];
        !            37:        char *Shell;
        !            38:        FILE *pio;
        !            39: 
        !            40:        msgvec = (int *) salloc((msgCount + 2) * sizeof *msgvec);
        !            41:        if ((cmd = snarf(str, &f, 0)) == NOSTR) {
        !            42:                if (f == -1) {
        !            43:                        printf("pipe command error\n");
        !            44:                        return(1);
        !            45:                        }
        !            46:                if ( (cmd = value("cmd")) == NOSTR) {
        !            47:                        printf("\"cmd\" not set, ignored.\n");
        !            48:                        return(1);
        !            49:                        }
        !            50:                }
        !            51:        if (!f) {
        !            52:                *msgvec = first(0, MMNORM);
        !            53:                if (*msgvec == NULL) {
        !            54:                        printf("No messages to pipe.\n");
        !            55:                        return(1);
        !            56:                }
        !            57:                msgvec[1] = NULL;
        !            58:        }
        !            59:        if (f && getmsglist(str, msgvec, 0) < 0)
        !            60:                return(1);
        !            61:        if (*(cp=cmd+strlen(cmd)-1)=='&'){
        !            62:                *cp=0;
        !            63:                nowait++;
        !            64:                }
        !            65:        printf("Pipe to: \"%s\"\n", cmd);
        !            66:        flush();
        !            67: 
        !            68:                                        /*  setup pipe */
        !            69:        if (pipe(pivec) < 0) {
        !            70:                perror("pipe");
        !            71:                return(0);
        !            72:        }
        !            73: 
        !            74:        if ((pid = fork()) == 0) {
        !            75:                close(pivec[1]);        /* child */
        !            76:                fclose(stdin);
        !            77:                dup(pivec[0]);
        !            78:                close(pivec[0]);
        !            79:                if ((Shell = value("SHELL")) == NOSTR || *Shell=='\0')
        !            80:                        Shell = SHELL;
        !            81:                execlp(Shell, Shell, "-c", cmd, (char *)0);
        !            82:                perror(Shell);
        !            83:                _exit(1);
        !            84:        }
        !            85:        if (pid == (pid_t)-1) {         /* error */
        !            86:                perror("fork");
        !            87:                close(pivec[0]);
        !            88:                close(pivec[1]);
        !            89:                return(0);
        !            90:        }
        !            91: 
        !            92:        close(pivec[0]);                /* parent */
        !            93:        pio=fdopen(pivec[1],"w");
        !            94:        sigint = sigset(SIGINT, SIG_IGN);
        !            95:        sigpipe = sigset(SIGPIPE, SIG_IGN);
        !            96: 
        !            97:                                        /* send all messages to cmd */
        !            98:        page = (value("page")!=NOSTR);
        !            99:        lc = cc = 0;
        !           100:        for (ip = msgvec; *ip && ip-msgvec < msgCount; ip++) {
        !           101:                mesg = *ip;
        !           102:                touch(mesg);
        !           103:                mp = &message[mesg-1];
        !           104:                if ((t = send(mp, pio, 0)) < 0) {
        !           105:                        perror(cmd);
        !           106:                        sigset(SIGPIPE, sigpipe);
        !           107:                        sigset(SIGINT, sigint);
        !           108:                        return(1);
        !           109:                }
        !           110:                lc += t;
        !           111:                cc += mp->m_size;
        !           112:                if (page) putc('\f', pio);
        !           113:        }
        !           114: 
        !           115:        fflush(pio);
        !           116:        if (ferror(pio))
        !           117:              perror(cmd);
        !           118:        fclose(pio);
        !           119: 
        !           120:                                        /* wait */
        !           121:        if (!nowait) {
        !           122:                while (wait(&s) != pid);
        !           123:                if (s != 0)
        !           124:                        printf("Pipe to \"%s\" failed\n", cmd);
        !           125:        }
        !           126:        if (nowait || s == 0)
        !           127:                printf("\"%s\" %ld/%ld\n", cmd, lc, cc);
        !           128:        sigset(SIGPIPE, sigpipe);
        !           129:        sigset(SIGINT, sigint);
        !           130:        return(0);
        !           131: }

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