Return to recorder.c CVS log

Up to [MW Coherent from dump] / coherent / e / bin / script

Annotation of coherent/e/bin/script/recorder.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * File:       recorder.c
        !             3:  *
        !             4:  * Purpose:    recording proces
        !             5:  *
        !             6:  * $Log:       recorder.c,v $
        !             7:  * Revision 1.3  93/02/04  12:02:49  bin
        !             8:  * hal: changed from sys/fcntl.h to fcntl.h in getps* , changed from execvp
        !             9:  * to execvpe in recorder.c
        !            10:  * 
        !            11:  */
        !            12: 
        !            13: /*
        !            14:  * Includes.
        !            15:  */
        !            16: #include <stdio.h>
        !            17: #include <errno.h>
        !            18: #include <signal.h>
        !            19: 
        !            20: /*
        !            21:  * Definitions.
        !            22:  *     Constants.
        !            23:  *     Macros with argument lists.
        !            24:  *     Typedefs.
        !            25:  *     Enums.
        !            26:  */
        !            27: #define BSIZE  512
        !            28: 
        !            29: typedef unsigned char uchar;
        !            30: typedef unsigned int  uint;
        !            31: typedef unsigned long ulong;
        !            32: 
        !            33: /*
        !            34:  * Functions.
        !            35:  *     Import Functions.
        !            36:  *     Export Functions.
        !            37:  *     Local Functions.
        !            38:  */
        !            39: void exec_shell();
        !            40: void pass_all();
        !            41: static void sig_term();
        !            42: 
        !            43: /*
        !            44:  * Global Data.
        !            45:  *     Import Variables.
        !            46:  *     Export Variables.
        !            47:  *     Local Variables.
        !            48:  */
        !            49: static int sigcaught;
        !            50: 
        !            51: /*
        !            52:  * exec_shell()
        !            53:  */
        !            54: void
        !            55: exec_shell(fd, argv, envp)
        !            56: int fd;
        !            57: char ** argv, ** envp;
        !            58: {
        !            59:        char * shell;
        !            60:        char * genenv(), * rindex();
        !            61: 
        !            62:        close(0);
        !            63:        close(1);
        !            64:        close(2);
        !            65:        if (dup(fd) != 0 || dup(fd) != 1 || dup(fd) != 2) {
        !            66:                /*  dup failed */
        !            67:                exit (1);
        !            68:        }
        !            69: 
        !            70:        if (*argv == NULL) {
        !            71:                char * args[2];
        !            72:                args[1] = NULL;
        !            73:                if ( (shell = getenv("SHELL")) == NULL)
        !            74:                        shell = "/bin/sh";
        !            75:                args[0] = shell;
        !            76:                execvpe(shell, args, envp);
        !            77: #if 0
        !            78:                if ( (shell = getenv("SHELL")) == NULL)
        !            79:                        shell = "/bin/sh";
        !            80:                if ( (argv[0] = rindex(shell, '/')) != NULL)
        !            81:                        argv[0]++;
        !            82:                else
        !            83:                        argv[0] = shell;
        !            84:                execvpe(shell, argv, envp);
        !            85: #endif
        !            86:        } else
        !            87:                execvpe(argv[0], argv, envp);
        !            88: 
        !            89:        /* execvpe failed */
        !            90:        exit (1);
        !            91: }
        !            92: 
        !            93: /*
        !            94:  * pass_all()
        !            95:  */
        !            96: void
        !            97: pass_all(fd, lf)
        !            98: int fd;
        !            99: char * lf;
        !           100: {
        !           101:        int newpid, nread;
        !           102:        char buff[BSIZE];
        !           103:        int ppid = getpid();
        !           104: 
        !           105:        if ( (newpid = fork()) < 0) {
        !           106:                /* pass_all can't fork */
        !           107:                exit (1);
        !           108:        } else if (newpid == 0) {
        !           109:                /*
        !           110:                 * Child process.
        !           111:                 * Copy terminal stdin to fd for pty master.
        !           112:                 */
        !           113:                for (;;){
        !           114:                        nread = read(0, buff, BSIZE);
        !           115:                        if (nread < 0) {
        !           116:                                /* pass_all read err on stdin */
        !           117:                                exit (1);
        !           118:                        }
        !           119:                        if (nread == 0)
        !           120:                                break;  /* EOF */
        !           121:                        if (write(fd, buff, nread) != nread) {
        !           122:                                /* pass_all write err to fd */
        !           123:                                exit(1);
        !           124:                        }
        !           125:                }
        !           126:                kill(ppid, SIGTERM);
        !           127:                exit(0);
        !           128:        }
        !           129: 
        !           130:        /*
        !           131:         * Parent process.
        !           132:         * Copy from pty master fd to terminal stdout.
        !           133:         */
        !           134: {
        !           135:        int lfd;
        !           136: 
        !           137:        if((lfd = creat(lf, 0666)) == -1) {
        !           138:                printf("Can't open log file \"%s\"\n", lf);
        !           139:                goto bye;
        !           140:        }
        !           141:        sigcaught = 0;
        !           142:        signal(SIGTERM, sig_term);
        !           143:        for (;;) {
        !           144:                nread = read(fd, buff, BSIZE);
        !           145:                if (nread <= 0)
        !           146:                        break;  /* error or EOF */
        !           147:                write(lfd, buff, nread);
        !           148:                if (write(1, buff, nread) != nread) {
        !           149:                        /* pass_all write error to stdout */
        !           150:                        close(lfd);
        !           151:                        exit (1);
        !           152:                }
        !           153:        }
        !           154:        close(lfd);
        !           155: bye:
        !           156:        if (sigcaught == 0) {
        !           157:                kill(newpid, SIGTERM);
        !           158:        }
        !           159: }
        !           160: }
        !           161: 
        !           162: void
        !           163: sig_term()
        !           164: {
        !           165:        sigcaught = 1;
        !           166: }

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