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); 

}