Return to dospopen.c CVS log

Up to [Research Unix] / researchv10dc / cmd / library

Annotation of researchv10dc/cmd/library/dospopen.c, revision 1.1

1.1     ! root        1: /*     library:dospopen.c      1.2     */
        !             2: #include "sccsid.h"
        !             3: VERSION(@(#)library:dospopen.c 1.2)
        !             4: 
        !             5: /* popen/pclose: simple MS-DOS piping scheme to imitate UNIX pipes */
        !             6: 
        !             7: /* information needed between popen and pclose */
        !             8: #include <stdio.h>
        !             9: 
        !            10: static char *prgname[32];          /* program name if write pipe */
        !            11: static int pipetype[32];           /* 1=read 2=write */
        !            12: 
        !            13: /* open a pipe */
        !            14: FILE *popen(prg,type)
        !            15: char *prg,*type;
        !            16: { FILE *p;
        !            17:   int ostdout, ostdin;
        !            18: 
        !            19:   switch(*type) {
        !            20: 
        !            21:     /* for write style pipe, pclose handles program execution */
        !            22:     case 'w' :
        !            23:       if ((p= fopen("\\pipe.tmp","w")) != NULL) {
        !            24:         pipetype[fileno(p)]= 1;
        !            25:         prgname[fileno(p)]= prg;
        !            26:       }
        !            27:       return(p);
        !            28: 
        !            29: /* read pipe must create tmp file, set up stdout to point to the temp
        !            30:  * file, and run the program.  note that if the pipe file cannot be
        !            31:  * opened, it'll return a condition indicating pipe failure, which is
        !            32:  * fine.
        !            33:  */
        !            34: 
        !            35:     case 'r' :
        !            36:       if ((p= fopen("\\pipe.tmp","w")) != NULL) {
        !            37:         pipetype[fileno(p)]= 2;
        !            38:         ostdout= dup(fileno(stdout));   /* we need this later */
        !            39:         dup2(fileno(stdout),fileno(p)); /* substitute for stdout */
        !            40:         system(prg);                    /* run the program */
        !            41:         dup2(fileno(stdout),ostdout);   /* repair stdout */
        !            42:         fclose(p);                      /* close redirected stdout */
        !            43:         return(fopen("\\pipe.tmp","r"));     /* return pointer to tmp file */
        !            44:       }
        !            45:       return(NULL);                     /* everyone has their problems */
        !            46: 
        !            47:     /* screwy call or unsupported type */
        !            48:     default :
        !            49:       printf("popen: unknown pipe style\n");
        !            50:       exit(1);
        !            51:   }
        !            52: }
        !            53: 
        !            54: /* close a pipe */
        !            55: void pclose(p)
        !            56: FILE *p;
        !            57: { int n;
        !            58:   int ostdout, ostdin;
        !            59:   FILE *p2;
        !            60: 
        !            61:   switch(pipetype[fileno(p)]) {
        !            62: 
        !            63: /* close the temp file, open again as read, redirect stdin from that
        !            64:  * file, run the program, then clean up.
        !            65:  */
        !            66: 
        !            67:     case 1 :
        !            68:       n= fileno(p);
        !            69:       fclose(p);
        !            70:       if ((p2= fopen("\\pipe.tmp","r")) != NULL) {
        !            71:         ostdin= dup(fileno(stdin));     /* save stdin for later */
        !            72:         dup2(fileno(stdin),fileno(p2)); /* redirect to tmp file */
        !            73:         system(prgname[n]);             /* run the program */
        !            74:         dup2(fileno(stdin),ostdin);     /* repair stdin */
        !            75:         fclose(p2);
        !            76:         unlink("\\pipe.tmp");            /* erase tmp file */
        !            77:         return;
        !            78:       }
        !            79:       printf("pclose: could not reopen temporary file\n");
        !            80:       exit(1);
        !            81: 
        !            82:     /* close the temp file and remove it */
        !            83:     case 2 :
        !            84:       n= fileno(p);        /* get file number for unlink */
        !            85:       fclose(p);           /* close the file */
        !            86:       unlink("\\pipe.tmp"); /* erase the file */
        !            87:       return;
        !            88: 
        !            89:     /* if we're neither read nor write, we have problems */
        !            90:     default :
        !            91:       printf("pclose: internal error\n");
        !            92:       exit(1);
        !            93:   }
        !            94: }
        !            95: 

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