CreatePipe()等函数创建管道来操纵控制台

#include <stdio.h> 

#include <windows.h> 

  

#define BUFSIZE 4096 

  

HANDLE  hChildStdinRd, hChildStdinWr, hChildStdinWrDup, 

    hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup, 

    hInputFile, hStdout; 

  

BOOL  CreateChildProcess( VOID ); 

VOID  WriteToPipe( VOID ); 

VOID  ReadFromPipe( VOID ); 

VOID  ErrorExit( LPTSTR ); 

VOID  ErrMsg( LPTSTR ,  BOOL ); 

  

DWORD  main( int  argc,  char  *argv[]) 

{ 

    SECURITY_ATTRIBUTES saAttr; 

    BOOL  fSuccess; 

  

// Set the bInheritHandle flag so pipe handles are inherited. 

  

    saAttr.nLength =  sizeof (SECURITY_ATTRIBUTES); 

    saAttr.bInheritHandle = TRUE; 

    saAttr.lpSecurityDescriptor = NULL; 

  

// Get the handle to the current STDOUT. 

  

    hStdout = GetStdHandle(STD_OUTPUT_HANDLE); 

  

// Create a pipe for the child process's STDOUT. 

  

    if  (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) 

       ErrorExit( "Stdout pipe creation failed\n" ); 

  

// Create noninheritable read handle and close the inheritable read 

// handle. 

 

     fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,

         GetCurrentProcess(), &hChildStdoutRdDup , 0,

         FALSE,

         DUPLICATE_SAME_ACCESS);

     if ( !fSuccess )

         ErrorExit( "DuplicateHandle failed" );

     CloseHandle(hChildStdoutRd);

 

// Create a pipe for the child process's STDIN. 

  

    if  (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) 

       ErrorExit( "Stdin pipe creation failed\n" ); 

  

// Duplicate the write handle to the pipe so it is not inherited. 

  

    fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr, 

       GetCurrentProcess(), &hChildStdinWrDup, 0, 

       FALSE,                   // not inherited 

       DUPLICATE_SAME_ACCESS); 

    if  (! fSuccess) 

       ErrorExit( "DuplicateHandle failed" ); 

  

    CloseHandle(hChildStdinWr); 

  

// Now create the child process. 

    

    fSuccess = CreateChildProcess();

    if  (! fSuccess) 

       ErrorExit( "Create process failed" ); 

 

// Get a handle to the parent's input file. 

  

    if  (argc == 1) 

       ErrorExit( "Please specify an input file" );

 

    hInputFile = CreateFile(argv[1], GENERIC_READ, 0, NULL, 

       OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); 

  

    if  (hInputFile == INVALID_HANDLE_VALUE) 

       ErrorExit( "CreateFile failed\n" ); 

  

// Write to pipe that is the standard input for a child process. 

  

    WriteToPipe(); 

  

// Read from pipe that is the standard output for child process. 

  

    ReadFromPipe(); 

  

    return  0; 

} 

  

BOOL  CreateChildProcess() 

{ 

    PROCESS_INFORMATION piProcInfo; 

    STARTUPINFO siStartInfo;

    BOOL  bFuncRetn = FALSE; 

  

// Set up members of the PROCESS_INFORMATION structure. 

  

    ZeroMemory( &piProcInfo,  sizeof (PROCESS_INFORMATION) );

  

// Set up members of the STARTUPINFO structure. 

  

    ZeroMemory( &siStartInfo,  sizeof (STARTUPINFO) );

    siStartInfo.cb =  sizeof (STARTUPINFO); 

    siStartInfo.hStdError = hChildStdoutWr;

    siStartInfo.hStdOutput = hChildStdoutWr;

    siStartInfo.hStdInput = hChildStdinRd;

    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

  

// Create the child process. 

     

    bFuncRetn = CreateProcess(NULL, 

       "child" ,        // command line 

       NULL,           // process security attributes 

       NULL,           // primary thread security attributes 

       TRUE,           // handles are inherited 

       0,              // creation flags 

       NULL,           // use parent's environment 

       NULL,           // use parent's current directory 

       &siStartInfo,   // STARTUPINFO pointer 

       &piProcInfo);   // receives PROCESS_INFORMATION 

    

    if  (bFuncRetn == 0) 

       ErrorExit( "CreateProcess failed" );

    else 

    {

       CloseHandle(piProcInfo.hProcess);

       CloseHandle(piProcInfo.hThread);

       return  bFuncRetn;

    }

}

  

VOID  WriteToPipe( VOID ) 

{ 

    DWORD  dwRead, dwWritten; 

    CHAR  chBuf[BUFSIZE]; 

  

// Read from a file and write its contents to a pipe. 

  

    for  (;;) 

    { 

       if  (! ReadFile(hInputFile, chBuf, BUFSIZE, &dwRead, NULL) || 

          dwRead == 0)  break ; 

       if  (! WriteFile(hChildStdinWrDup, chBuf, dwRead, 

          &dwWritten, NULL))  break ; 

    } 

  

// Close the pipe handle so the child process stops reading. 

  

    if  (! CloseHandle(hChildStdinWrDup)) 

       ErrorExit( "Close pipe failed" ); 

} 

  

VOID  ReadFromPipe( VOID ) 

{ 

    DWORD  dwRead, dwWritten; 

    CHAR  chBuf[BUFSIZE]; 

 

// Close the write end of the pipe before reading from the 

// read end of the pipe. 

  

    if  (!CloseHandle(hChildStdoutWr)) 

       ErrorExit( "CloseHandle failed" ); 

  

// Read output from the child process, and write to parent's STDOUT. 

  

    for  (;;) 

    { 

       if ( !ReadFile( hChildStdoutRdDup, chBuf, BUFSIZE, &dwRead, 

          NULL) || dwRead == 0)  break ; 

       if  (! WriteFile(hStdout, chBuf, dwRead, &dwWritten, NULL)) 

          break ; 

    } 

} 

  

VOID  ErrorExit ( LPTSTR  lpszMessage) 

{ 

    fprintf (stderr,  "%s\n" , lpszMessage); 

    ExitProcess(0); 

}