Главная страница | назад

Article #16534: _open in Win32 GUI does not work

 Question and Answer Database

FAQ1534C.txt   _open in Win32 GUI does not work
Category   :Windows API
Platform    :All
Product    :BC++  5.x


How do I use _open in a Win32 GUI app?


You don't.  Instead use CreatePipe, CreateProcess.  See example
from MSDN following:

The following example shows the creation of a child process by a
console process and illustrates a technique for using anonymous
pipes to redirect the child process's standard input and output.

If you have a program that can read its input from the standard
input (STDIN) or write its results to the standard output
(STDOUT), redirected I/O enables you to execute the program as
a child process while controlling its input and receiving its

The example shows how to use a SECURITY_ATTRIBUTES structure to
create handles that can be inherited by the child process.
The structure is used in the CreatePipe function to create
inheritable handles to the read and write ends of two pipes.
The read end of one pipe serves as standard input for the child
process, and the write end of the other pipe is the child's
standard output. These pipe handles are specified in the 
SetStdHandle function, which makes them the standard handles
inherited by the child process. After the child process is 
created, SetStdHandle is used again to restore the original 
standard handles for the parent process.

The parent process uses the other ends of the pipes to write to
the child's input and read the child's output. The handles to
these ends of the pipe are also inheritable. However, the handle
must not be inherited. Before creating the child process, the
parent process must use DuplicateHandle to create a 
noninheritable duplicate of the application-defined 
hChildStdinWr global variable. It then uses CloseHandle to close
the inheritable handle. 

This leaves the parent process with a pipe handle it can use, 
but which the child process does not inherit. For more
information about pipes, see Pipes. 

The following is the parent process. 

#include <windows.h> 

#define BUFSIZE 4096 

HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup, 
hChildStdoutRd, hChildStdoutWr, 
hInputFile, hSaveStdin, hSaveStdout; 

BOOL CreateChildProcess(VOID); 
VOID WriteToPipe(VOID); 
VOID ReadFromPipe(VOID); 
VOID ErrorExit(LPTSTR); 

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

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

   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
   saAttr.bInheritHandle = TRUE; 
   saAttr.lpSecurityDescriptor = NULL; 

   // The steps for redirecting child's STDOUT:
   //     1.  Save current STDOUT, to be restored later. 
   //     2.  Create anonymous pipe to be STDOUT for child. 
   //     3.  Set STDOUT of parent to be write handle of pipe, 
   //         so it is inherited by child. 

// Save the handle to the current STDOUT. 

   hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE); 

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

   if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) 
      ErrorExit("Stdout pipe creation failed\n"); 

// Set a write handle to the pipe to be STDOUT. 

   if (! SetStdHandle(STD_OUTPUT_HANDLE, hChildStdoutWr)) 
      ErrorExit("Redirecting STDOUT failed"); 

   // The steps for redirecting child's STDIN: 
   //     1.  Save current STDIN, to be restored later. 
   //     2.  Create anonymous pipe to be STDIN for child. 
   //     3.  Set STDIN of parent to be read handle of pipe, so 
   //         it is inherited by child. 
   //     4.  Create a noninheritable duplicate of write handle, 
   //         and close the inheritable write handle. 

// Save the handle to the current STDIN. 

   hSaveStdin = GetStdHandle(STD_INPUT_HANDLE); 

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

   if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) 
      ErrorExit("Stdin pipe creation failed\n"); 

// Set a read handle to the pipe to be STDIN. 

   if (! SetStdHandle(STD_INPUT_HANDLE, hChildStdinRd)) 
      ErrorExit("Redirecting Stdin failed"); 

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

   fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr, 
      GetCurrentProcess(), &hChildStdinWrDup, 0, 
      FALSE,                  // not inherited 
   if (! fSuccess) 
      ErrorExit("DuplicateHandle failed"); 


// Now create the child process. 

   if (! CreateChildProcess()) 
      ErrorExit("Create process failed"); 

// After process creation, restore the saved STDIN and STDOUT. 

   if (! SetStdHandle(STD_INPUT_HANDLE, hSaveStdin)) 
      ErrorExit("Re-redirecting Stdin failed\n"); 

   if (! SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout)) 
      ErrorExit("Re-redirecting Stdout failed\n"); 

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

   if (argc > 1) 
      hInputFile = CreateFile(argv[1], GENERIC_READ, 0, NULL, 
      hInputFile = hSaveStdin; 

   if (hInputFile == INVALID_HANDLE_VALUE) 
      ErrorExit("no input file\n"); 

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


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


   return 0; 

BOOL CreateChildProcess() 
   STARTUPINFO siStartInfo; 

// Set up members of STARTUPINFO structure. 

   siStartInfo.cb = sizeof(STARTUPINFO); 
   siStartInfo.lpReserved = NULL; 
   siStartInfo.lpReserved2 = NULL; 
   siStartInfo.cbReserved2 = 0; 
   siStartInfo.lpDesktop = NULL;  
   siStartInfo.dwFlags = 0; 

// Create the child process. 

   return 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 

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 stops reading. 

   if (! CloseHandle(hChildStdinWrDup)) 
      ErrorExit("Close pipe failed\n"); 

VOID ReadFromPipe(VOID) 
   DWORD dwRead, dwWritten; 
   CHAR chBuf[BUFSIZE]; 
   HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE); 

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

   if (!CloseHandle(hChildStdoutWr)) 
      ErrorExit("Closing handle failed"); 

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

   for (;;) 
    if (! ReadFile(hChildStdoutRd, chBuf, BUFSIZE, &dwRead, NULL) || 
       dwRead == 0) break; 
    if (! WriteFile(hSaveStdout, chBuf, dwRead, &dwWritten, NULL)) 

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

// The child process 

#define BUFSIZE 4096 

VOID main(VOID) 
   CHAR chBuf[BUFSIZE]; 
   DWORD dwRead, dwWritten; 
   HANDLE hStdin, hStdout; 
   BOOL fSuccess; 

   hStdout = GetStdHandle(STD_OUTPUT_HANDLE); 
   hStdin = GetStdHandle(STD_INPUT_HANDLE); 
   if ((hStdout == INVALID_HANDLE_VALUE) || 
      (hStdin == INVALID_HANDLE_VALUE)) 

   for (;;) 
   // Read from standard input. 
      fSuccess = ReadFile(hStdin, chBuf, BUFSIZE, &dwRead, NULL); 
      if (! fSuccess || dwRead == 0) 

   // Write to standard output. 
      fSuccess = WriteFile(hStdout, chBuf, dwRead, &dwWritten, NULL); 
      if (! fSuccess) 

7/2/98 10:32:32 AM

Last Modified: 01-SEP-99