home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 September / Simtel20_Sept92.cdr / msdos / turbo_c / popen.arc / POPEN.C < prev    next >
C/C++ Source or Header  |  1988-03-08  |  10KB  |  329 lines
  1. /* popen/pclose:
  2.  *
  3.  * simple MS-DOS piping scheme to imitate UNIX pipes
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #include <alloc.h>
  9. #include <string.h>
  10. #include <errno.h>
  11. #include <setjmp.h>
  12. #include <process.h>
  13.  
  14. #include "popen.h"
  15.  
  16. extern char *getenv( char * );
  17.  
  18. #ifndef    _NFILE
  19. # define    _NFILE    OPEN_MAX    /* Number of open files */
  20. #endif    _NFILE
  21.  
  22. #define READIT    1            /* Read pipe */
  23. #define WRITEIT    2            /* Write pipe */
  24.  
  25. static char *prgname[ _NFILE ];        /* program name if write pipe */
  26. static int pipetype[ _NFILE ];        /* 1=read 2=write */
  27. static char *pipename[ _NFILE ];    /* pipe file name */
  28.  
  29. /*
  30.  *------------------------------------------------------------------------
  31.  * stoupper: Convert string to uppercase (in place)
  32.  *------------------------------------------------------------------------
  33.  */
  34.  
  35. static void
  36. stoupper( s )
  37. char *s;
  38. {
  39.    int c;
  40.    for( ; (c = *s) != '\0'; ++s ) {
  41.       if( islower( c ) ) *s = _toupper( c );
  42.    }
  43. }
  44.  
  45. /*
  46.  *------------------------------------------------------------------------
  47.  * strsave: Copy string into malloc'ed memory and return address
  48.  *------------------------------------------------------------------------
  49.  */
  50.  
  51. static char *
  52. strsave( s )
  53. char *s;
  54. {
  55.    char *sp = malloc( strlen( s ) + 1 );
  56.    if( sp != (char *) NULL ) (void) strcpy( sp, s );
  57.    return( sp );
  58. }
  59.  
  60. /*
  61.  *------------------------------------------------------------------------
  62.  * strfree: Returm strsave'd string memory
  63.  *------------------------------------------------------------------------
  64.  */
  65.  
  66. static void
  67. strfree( s )
  68. char *s;
  69. {
  70.    if( s != (char *) NULL ) free( s );
  71. }
  72.  
  73. /*
  74.  *------------------------------------------------------------------------
  75.  * run: Execute command via SHELL or COMSPEC
  76.  *------------------------------------------------------------------------
  77.  */
  78.  
  79. static int
  80. run( command )
  81. char *command;
  82. {
  83.    jmp_buf panic;            /* How to recover from errors */
  84.    int lineno;                /* Line number where panic happened */
  85.    char *shell;                /* Command processor */
  86.    char *s = (char *) NULL;        /* Holds the command */
  87.    int s_is_malloced = 0;        /* True if need to free 's' */
  88.    static char *command_com = "COMMAND.COM";
  89.    int status;                /* Return codes */
  90.    char *shellpath;            /* Full command processor path */
  91.    char *bp;                /* Generic string pointer */
  92.    static char dash_c[ 3 ] = { '?', 'c', '\0' };
  93.    if( (lineno = setjmp( panic )) != 0 ) {
  94.       int E = errno;
  95. #ifdef    DEMO
  96.       fprintf( stderr, "RUN panic on line %d: %d\n", lineno, E );
  97. #endif    DEMO
  98.       if( s_is_malloced && (s != (char *) NULL) ) strfree( s );
  99.       errno = E;
  100.       return( -1 );
  101.    }
  102.    if( (s = strsave( command )) == (char *) NULL ) longjmp( panic, __LINE__ );
  103.    /* Determine the command processor */
  104.    if( ((shell = getenv( "SHELL" )) == (char *) NULL) &&
  105.        ((shell = getenv( "COMSPEC" )) == (char *) NULL) ) shell = command_com;
  106.    stoupper( shell );
  107.    shellpath = shell;
  108.    /* Strip off any leading backslash directories */
  109.    shell = strrchr( shellpath, '\\' );
  110.    if( shell != (char *) NULL ) ++shell;
  111.    else                         shell = shellpath;
  112.    /* Strip off any leading slash directories */
  113.    bp = strrchr( shell, '/'  );
  114.    if( bp != (char *) NULL ) shell = ++bp;
  115.    if( strcmp( shell, command_com ) != 0 ) {
  116.       /* MKS Shell needs quoted argument */
  117.       char *bp;
  118.       if( (bp = s = malloc( strlen( command ) + 3 )) == (char *) NULL ) 
  119.      longjmp( panic, __LINE__ );
  120.       *bp++ = '\'';
  121.       while( (*bp++ = *command++) != '\0' );
  122.       *(bp - 1) = '\'';
  123.       *bp = '\0';
  124.       s_is_malloced = 1;
  125.    } else s = command;
  126.    dash_c[ 0 ] = getswitch();
  127.    /* Run the program */
  128. #ifdef    DEMO
  129.    fprintf( stderr, "Running: (%s) %s %s %s\n", shellpath, shell, dash_c, s );
  130. #endif    DEMO
  131.    status = spawnl( P_WAIT, shellpath, shell, dash_c, s, (char *) NULL );
  132.    if( s_is_malloced ) free( s );
  133.    return( status );
  134. }
  135.  
  136. /* 
  137.  *------------------------------------------------------------------------
  138.  * uniquepipe: returns a unique file name 
  139.  *------------------------------------------------------------------------
  140.  */
  141.  
  142. static char *
  143. uniquepipe()
  144. { 
  145.    static char name[ 14 ];
  146.    static short int num = 0;
  147.    (void) sprintf( name, "pipe%05d.tmp", num++ );
  148.    return( name );
  149. }
  150.  
  151. /*
  152.  *------------------------------------------------------------------------
  153.  * resetpipe: Private routine to cancel a pipe
  154.  *------------------------------------------------------------------------
  155.  */
  156.  
  157. static void
  158. resetpipe( fd )
  159. int fd;
  160. {
  161.    char *bp;
  162.    if( (fd >= 0) && (fd < _NFILE) ) {
  163.       pipetype[ fd ] = 0;
  164.       if( (bp = pipename[ fd ]) != (char *) NULL ) {
  165.      (void) unlink( bp );
  166.      strfree( bp );
  167.      pipename[ fd ] = (char *) NULL;
  168.       }
  169.       if( (bp = prgname[ fd ]) != (char *) NULL ) {
  170.      strfree( bp );
  171.      prgname[ fd ] = (char *) NULL;
  172.       }
  173.    }
  174. }
  175.  
  176. /* 
  177.  *------------------------------------------------------------------------
  178.  * popen: open a pipe 
  179.  *------------------------------------------------------------------------
  180.  */
  181.  
  182. FILE *popen( prg, type )
  183. char *prg;            /* The command to be run */
  184. char *type;            /* "w" or "r" */
  185. { 
  186.    FILE *p = (FILE *) NULL;    /* Where we open the pipe */
  187.    int ostdin;            /* Where our stdin is now */
  188.    int pipefd = -1;        /* fileno( p ) -- for convenience */
  189.    char tmpfile[ BUFSIZ ];    /* Holds name of pipe file */
  190.    char *tmpdir;        /* Points to directory prefix of pipe */
  191.    jmp_buf panic;        /* Where to go if there's an error */
  192.    int lineno;            /* Line number where panic happened */
  193.    /* Find out where we should put temporary files */
  194.    if( (tmpdir = getenv( "TMPDIR" )) == (char *) NULL ) 
  195.       tmpdir = getenv( "TMP" );
  196.    if( tmpdir != (char *) NULL ) {
  197.       /* Use temporary directory if available */
  198.       (void) strcpy( tmpfile, tmpdir );
  199.       (void) strcat( tmpfile, "/" );
  200.    } else *tmpfile = '\0';
  201.    /* Get a unique pipe file name */
  202.    (void) strcat( tmpfile, uniquepipe() );
  203.    if( (lineno = setjmp( panic )) != 0 ) {
  204.       /* An error has occurred, so clean up */
  205.       int E = errno;
  206. #ifdef    DEMO
  207.       fprintf( stderr, "POPEN panic on line %d: %d\n", lineno, E );
  208. #endif    DEMO
  209.       if( p != (FILE *) NULL ) (void) fclose( p );
  210.       resetpipe( pipefd );
  211.       errno = E;
  212.       return( (FILE *) NULL );
  213.    }
  214.    if( strcmp( type, "w" ) == 0 ) {
  215.       /* for write style pipe, pclose handles program execution */
  216.       if( (p = fopen( tmpfile, "w" )) != (FILE *) NULL ) {
  217.      pipefd = fileno( p );
  218.      pipetype[ pipefd ] = WRITEIT;
  219.      pipename[ pipefd ] = strsave( tmpfile );
  220.      prgname[ pipefd ]  = strsave( prg );
  221.      if( !pipename[ pipefd ] || !prgname[ pipefd ] ) longjmp( panic, __LINE__ );
  222.       }
  223.    } else if( strcmp( type, "r" ) == 0 ) {
  224.       /* read pipe must create tmp file, set up stdout to point to the temp
  225.       * file, and run the program.  note that if the pipe file cannot be
  226.       * opened, it'll return a condition indicating pipe failure, which is
  227.       * fine.
  228.       */
  229.       if( (p = fopen( tmpfile, "w" )) != (FILE *) NULL ) {
  230.      int ostdout;
  231.      pipefd = fileno( p );
  232.      pipetype[ pipefd ]= READIT;
  233.      if( (pipename[ pipefd ] = strsave( tmpfile )) == (char *) NULL ) 
  234.         longjmp( panic, __LINE__ );
  235.      /* Redirect stdin for the new command */
  236.      ostdout = dup( fileno( stdout ) );
  237.      if( dup2( fileno( stdout ), pipefd ) < 0 ) {
  238.         int E = errno;
  239.         (void) dup2( fileno( stdout ), ostdout );
  240.         errno = E;
  241.         longjmp( panic, __LINE__ );
  242.      }
  243.      if( run( prg ) != 0 ) longjmp( panic, __LINE__ );
  244.      if( dup2( fileno( stdout ), ostdout ) < 0 ) longjmp( panic, __LINE__ );
  245.      if( fclose( p ) < 0 ) longjmp( panic, __LINE__ );
  246.      if( (p = fopen( tmpfile, "r" )) == (FILE *) NULL ) longjmp( panic, __LINE__ );
  247.       }
  248.    } else {
  249.       /* screwy call or unsupported type */
  250.       errno = EINVFNC;
  251.       longjmp( panic, __LINE__ );
  252.    }
  253.    return( p );
  254. }
  255.  
  256. /* close a pipe */
  257.  
  258. int
  259. pclose( p )
  260. FILE *p;
  261. {
  262.    int pipefd = -1;        /* Fildes where pipe is opened */
  263.    int ostdout;            /* Where our stdout points now */
  264.    int ostdin;            /* Where our stdin points now */
  265.    jmp_buf panic;        /* Context to return to if error */
  266.    int lineno;            /* Line number where panic happened */
  267.    if( (lineno = setjmp( panic )) != 0 ) {
  268.       /* An error has occurred, so clean up and return */
  269.       int E = errno;
  270. #ifdef    DEMO
  271.       fprintf( stderr, "POPEN panic on line %d: %d\n", lineno, E );
  272. #endif    DEMO
  273.       if( p != (FILE *) NULL ) (void) fclose( p );
  274.       resetpipe( pipefd );
  275.       errno = E;
  276.       return( -1 );
  277.    }
  278.    pipefd = fileno( p );
  279.    if( fclose( p ) < 0 ) longjmp( panic, __LINE__ );
  280.    switch( pipetype[ pipefd ] ) {
  281.       case WRITEIT:
  282.      /* open the temp file again as read, redirect stdin from that
  283.       * file, run the program, then clean up.
  284.       */
  285.       if( (p = fopen( pipename[ pipefd ],"r" )) == (FILE *) NULL ) 
  286.      longjmp( panic, __LINE__ );
  287.       ostdin = dup( fileno( stdin ));
  288.       if( dup2( fileno( stdin ), fileno( p ) ) < 0 ) longjmp( panic, __LINE__ );
  289.       if( run( prgname[ pipefd ] ) != 0 ) longjmp( panic, __LINE__ );
  290.       if( dup2( fileno( stdin ), ostdin ) < 0 ) longjmp( panic, __LINE__ );
  291.       if( fclose( p ) < 0 ) longjmp( panic, __LINE__ );
  292.       resetpipe( pipefd );
  293.       break;
  294.    case READIT:
  295.       /* close the temp file and remove it */
  296.       resetpipe( pipefd );
  297.       break;
  298.    default:
  299.       errno = EINVFNC;
  300.       longjmp( panic, __LINE__ );
  301.       /*NOTREACHED*/
  302.    }
  303.    return( 0 );
  304. }
  305.  
  306. #ifdef    DEMO
  307. int
  308. main( argc, argv )
  309. int argc;
  310. char **argv;
  311. {
  312.    FILE *pipe;
  313.    char buf[ BUFSIZ ];
  314.    int n;
  315.    *buf = '\0';
  316.    for( n = 1; n < argc; ++n ) {
  317.       (void) strcat( buf, argv[ n ] );
  318.       (void) strcat( buf, " " );
  319.    }
  320.    if( (pipe = popen( buf, "r" )) != (FILE *) NULL ) {
  321.       while( fgets( buf, sizeof( buf ), pipe ) != (char *) NULL ) 
  322.      (void) fputs( buf, stdout );
  323.       if( pclose( pipe ) != 0 ) fprintf( stderr, "error closing pipe!\n" );
  324.    } else fprintf( stderr, "it didn't work!\n" );
  325.    exit( 0 );
  326.    /*NOTREACHED*/
  327. }
  328. #endif    DEMO
  329.