|
?
|
MSDN里面有一些文档可以看看，方法是利用CreateProcess的 LPSTARTUPINFO 参数，
设置dwFlags为STARTF_USESTDHANDLES：
然后自定义：
HANDLE hStdInput;
HANDLE hStdOutput;
HANDLE hStdError;
三个流句柄。
这些句柄可以用CreatePipe创建的匿名管道句柄代替：
BOOL CreatePipe(
PHANDLE hReadPipe, // read handle
PHANDLE hWritePipe, // write handle
LPSECURITY_ATTRIBUTES lpPipeAttributes, // security attributes
DWORD nSize // pipe size
);
其中hStdOutput,hStdError传给hWritePipe,hStdInput传给hReadPipe,然后把管道的另一端的句柄保存起来。就可以用ReadFile/WriteFile从这些句柄读取/写入控制台程序的输出/输入。
要注意的是这些句柄的继承性，调用CreateProcess时注意设置BOOL bInheritHandles = TRUE，使它可以继承主进程的句柄。调用CreatePipe要设置LPSECURITY_ATTRIBUTES lpPipeAttributes参数使Pipe的句柄能够被继承。
此外，这样使CreatePipe创建的两个句柄都可以被继承了，所以要调用DuplicateHandle把不需要传入子进程的句柄设置为不可继承。不然子进程拥有了另一个句柄但是不会调用Closehandle减少引用记数，会导致Pipe不能被在使用完毕后被撤消。
此外注意关闭所有使用过的内核对象句柄。
以下是MSDN的一个例子：
- INHERIT.C
- /******************************************************************************* This is a part of the Microsoft Source Code Samples.
- * Copyright (C) 1992-1996 Microsoft Corporation.
- * All rights reserved.
- * This source code is only intended as a supplement to
- * Microsoft Development Tools and/or WinHelp documentation.
- * See these sources for detailed information regarding the
- * Microsoft samples programs.
- /******************************************************************************/
- /********************************************************************
- * This program is to demonstrate the use of anonymous pipes used as *
- * stdout and stderr replacements. One of two techniques can be *
- * chose to do this: the SetStdHandle technique or the *
- * STARTF_USESTDHANDLES technique. The SetStdHandle technique sets *
- * the standard output handles to the pipe that we will read from, *
- * which the child will inherit. The STARTF_USESTDHANDLES technique *
- * passes the pipe handles to the child as standard handles via the *
- * STARTUPINFO structure. The STARTF_USESTDHANDLES technique *must* *
- * be used for "console-less" processes such as GUI applications or *
- * detached processes. *
- * *
- * This program demonstrates the use of the following Win32 APIs: *
- * CreatePipe, CreateProcess. *
- * *
- * This program also uses the following Win32 APIs: *
- * GetLastError, CreateFile, CloseHandle, CreateProcess, ReadFile, *
- * WriteFile. *
- * *
- * *
- * Execution instructions: *
- * *
- * inherit <trace file> <command to execute> *
- * trace file is the name of the file where the stdout *
- * and stderr of command will be redirected *
- * *
- * command to execute can be either an external executable or an *
- * internal cmd.exe command. *
- * *
- * Examples: *
- * *
- * inherit chkdsk.dat chkdsk d: *
- * inherit nmake.txt nmake /f foo.mak *
- * * ********************************************************************/
- #include <windows.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- /* define USESTDHANDLES to use the new technique of passing the
- standard handles to the child process via the STARTUPINFO structure.
- This technique must be used for "console-less" parents such as GUI
- applications or detached applications. */
- #define USESTDHANDLES
- /* Standard error macro for reporting API errors */
- //#define PERR(bSuccess, api) {if (!(bSuccess)) printf("%s: Error %d from %s
- // on line %d/n", __FILE__, GetLastError(), api, __LINE__);} void PERR(BOOL bSuccess, char * api);
- int main(int argc, char *argv[])
- {
- char chReadBuffer[64]; /* pipe read buffer */
- BOOL bSuccess; /* BOOL return code for APIs */
- int j;
- HANDLE hOutFile; /* handle to log file */
- /* handles to the anonymous pipe */
- HANDLE hReadPipe, hWritePipe, hWritePipe2;
- char szArgs[256]; /* child process argument buffer */
- char *p; /* temporary pointer into szArgs */
- DWORD cchReadBuffer; /* number of bytes read or to be written */
- STARTUPINFO si; /* for CreateProcess call */
- PROCESS_INFORMATION pi; /* for CreateProcess call */
- SECURITY_ATTRIBUTES saPipe; /* security for anonymous pipe */
- OSVERSIONINFO os; /* operating system specs */
- os.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); // required assignment
- // check if running on Windows NT, if not, display notice and terminate
- if ( GetVersionEx(&os) )
- {
- if( os.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS &
- os.dwPlatformId != VER_PLATFORM_WIN32_NT)
- {
- MessageBox( NULL,
- "This sample application can only run on Windows NT and Windows 95./n
- This application will now terminate.",
- "Inherit",
- MB_OK | MB_ICONSTOP | MB_SETFOREGROUND );
- return( 1 );
- }
- }
- else
- {
- MessageBox( NULL,
- "Unable to test for OS version.",
- "Inherit Error",
- MB_OK | MB_ICONSTOP | MB_SETFOREGROUND );
- return( 1 );
- }
- if (argc < 3)
- {
- puts("format: inherit <trace file> <command to execute>");
- puts("trace file is the name of the file where the stdout");
- puts("and stderr of command will be redirected/n");
- puts("command to execute is command line of the function");
- puts("you wish to perform./n");
- puts("Examples:/n");
- puts(" inherit trace.txt chkdsk d:");
- puts(" inherit trace.txt nmake /f foo.mak");
- return(1);
- }
- /* create the log file where we will save all output from child */
- hOutFile = CreateFile(argv[1], /* file to open */
- GENERIC_WRITE, /* access mode */
- FILE_SHARE_READ, /* share mode */
- NULL, /* security attributes */
- CREATE_ALWAYS, /* creation flags - trash existing file */
- FILE_ATTRIBUTE_NORMAL, /* file attributes */
- NULL);
- PERR(hOutFile != INVALID_HANDLE_VALUE, "CreateFile");
- /* set up the security attributes for the anonymous pipe */
- saPipe.nLength = sizeof(SECURITY_ATTRIBUTES);
- saPipe.lpSecurityDescriptor = NULL;
- /* In order for the child to be able to write to the pipe, the handle */
- /* must be marked as inheritable by setting this flag: */
- saPipe.bInheritHandle = TRUE;
- /* create the anonymous pipe */
- bSuccess = CreatePipe(&hReadPipe, /* read handle */
- &hWritePipe, /* write handle, used as stdout by child */
- &saPipe, /* security descriptor */
- 0); /* pipe buffer size */
- PERR(bSuccess, "CreatePipe");
- /* Now we need to change the inheritable property for the readable
- end of the pipe so that the child will not inherit that handle as
- a "garbage" handle. This will keep us from having extra,
- unclosable handles to the pipe. Alternatively, we could have
- opened the pipe with saPipe.bInheritHandle = FALSE and changed the
- inherit property on the *write* handle of the pipe to TRUE. */
- bSuccess = DuplicateHandle(GetCurrentProcess(), /* source process */
- hReadPipe, /* handle to duplicate */
- GetCurrentProcess(), /* destination process */
- NULL, /* new handle - don't want one, change original handle */
- 0, /* new access flags - ignored since DUPLICATE_SAME_ACCESS */
- FALSE, /* make it *not* inheritable */
- DUPLICATE_SAME_ACCESS);
- PERR(bSuccess, "DuplicateHandle");
- /* I most cases you can get away with using the same anonymous
- pipe write handle for both the child's standard output and
- standard error, but this may cause problems if the child app
- explicitly closes one of its standard output or error handles. If
- that happens, the anonymous pipe will close, since the child's
- standard output and error handles are really the same handle. The
- child won't be able to write to the other write handle since the
- pipe is now gone, and parent reads from the pipe will return
- ERROR_BROKEN_PIPE and child output will be lost. To solve this
- problem, simply duplicate the write end of the pipe to create
- another distinct, separate handle to the write end of the pipe.
- One pipe write handle will serve as standard out, the other as
- standard error. Now *both* write handles must be closed before the
- write end of the pipe actually closes. */
- bSuccess = DuplicateHandle(GetCurrentProcess(), /* source process */
- hWritePipe, /* handle to duplicate */
- GetCurrentProcess(), /* destination process */
- &hWritePipe2, /* new handle, used as stderr by child */
- 0, /* new access flags - ignored since DUPLICATE_SAME_ACCESS */
- TRUE, /* it's inheritable */
- DUPLICATE_SAME_ACCESS);
- PERR(bSuccess, "DuplicateHandle");
- /* Set up the STARTUPINFO structure for the CreateProcess() call */
- memset(&si, 0, sizeof(si));
- si.cb = sizeof(si);
- /* Set up the command-line buffer for the child for CreateProcess() */
- memset(szArgs, 0, sizeof(szArgs));
- strcpy(szArgs, argv[2]);
- if (strchr(szArgs, '.') == NULL) /* does it have a '.'? */
- strcat(szArgs, ".exe"); /* if not, assume it's an .exe */
- strcat(szArgs, " ");
- p = strchr(szArgs, 0); /* point to the terminating null */
- for (j = 3; j < argc; j++)
- {
- strcat(p, argv[j]);
- /* the program and parameters are delimited by spaces */
- strcat(p, " ");
- }
- #ifdef USESTDHANDLES
- /* If using the STARTUPINFO STARTF_USESTDHANDLES flag, be sure to
- set the CreateProcess fInheritHandles parameter too TRUE so that
- the file handles specified in the STARTUPINFO structure will be
- inheritied by the child. Note that we don't specify a standard
- input handle; the child will not inherit a valid input handle, so
- if it reads from stdin, it will encounter errors. */
- si.hStdInput = hWritePipe2; /* hStdInput needs a valid handle in case it is checked by the child */
- si.hStdOutput = hWritePipe; /* write end of the pipe */
- si.hStdError = hWritePipe2; /* duplicate of write end of the pipe */
- si.dwFlags = STARTF_USESTDHANDLES;
- #else
- /* If we're not using the STARTF_USESTDHANDLES flag, set the
- standard output and error handles to the end of the pipe we want
- the child to inherit with SetStdHandle(). For this program, we
- don't want standard input inherited so we'll also change the
- handle inheritance property of standard input so that it is not
- inherited */
- bSuccess = SetStdHandle(STD_INPUT_HANDLE, hWritePipe2);
- PERR(bSuccess, "SetStdHandle");
- bSuccess = SetStdHandle(STD_OUTPUT_HANDLE, hWritePipe);
- PERR(bSuccess, "SetStdHandle");
- bSuccess = SetStdHandle(STD_ERROR_HANDLE, hWritePipe2);
- PERR(bSuccess, "SetStdHandle");
- bSuccess = DuplicateHandle(GetCurrentProcess(), /* source process */
- GetStdHandle(STD_INPUT_HANDLE), /* handle to duplicate */
- GetCurrentProcess(), /* destination process */
- NULL, /* new handle - don't want one, change original handle */
- 0, /* new access flags - ignored since DUPLICATE_SAME_ACCESS */
- FALSE, /* it's *not* inheritable */
- DUPLICATE_SAME_ACCESS);
- PERR(bSuccess, "DuplicateHandle");
- #endif
- /* Now create the child process, inheriting handles */
- bSuccess = CreateProcess(NULL, /* filename */
- szArgs, /* full command line for child */
- NULL, /* process security descriptor */
- NULL, /* thread security descriptor */
- TRUE, /* inherit handles? Also use if STARTF_USESTDHANDLES */
- 0, /* creation flags */
- NULL, /* inherited environment address */
- NULL, /* startup dir; NULL = start in current */
- &si, /* pointer to startup info (input) */
- π); /* pointer to process info (output) */
- PERR(bSuccess, "CreateProcess");
- /* We can close the returned child process handle and thread
- handle as we won't be needing them; you could, however, wait on
- the process handle to wait until the child process terminates. */
- CloseHandle(pi.hThread);
- CloseHandle(pi.hProcess);
- /* We need to close our instances of the inheritable pipe write
- handle now that it's been inherited so that all open handles to
- the pipe are closed when the child process ends and closes its
- handles to the pipe. */
- bSuccess = CloseHandle(hWritePipe);
- PERR(bSuccess, "CloseHandle");
- bSuccess = CloseHandle(hWritePipe2);
- PERR(bSuccess, "CloseHandle");
- /* read from the pipe until we get an ERROR_BROKEN_PIPE */
- for (;;)
- {
- bSuccess = ReadFile(hReadPipe, /* read handle */
- chReadBuffer, /* buffer for incoming data */
- sizeof(chReadBuffer), /* number of bytes to read */
- &cchReadBuffer, /* number of bytes actually read */
- NULL); /* no overlapped reading */
- if (!bSuccess && (GetLastError() == ERROR_BROKEN_PIPE))
- break; /* child has died */
- PERR(bSuccess, "ReadFile");
- if (bSuccess && cchReadBuffer)
- {
- /* write the data from the child to the file */
- bSuccess = WriteFile(hOutFile, /* write handle */
- chReadBuffer, /* buffer to write */
- cchReadBuffer, /* number of bytes to write */
- &cchReadBuffer, /* number of bytes actually written */
- NULL); /* no overlapped writing */
- PERR(bSuccess, "WriteFile");
- /* write buffer (of specified length) to console */
- printf("%.*s", cchReadBuffer, chReadBuffer);
- }
- }
- /* close the trace file, pipe handles */
- CloseHandle(hOutFile);
- CloseHandle(hReadPipe);
- return(0);
- }
- void PERR(BOOL bSuccess, char * api)
- {
- DWORD dwError;
- TCHAR szMsgBuf[500];
- if (!(bSuccess))
- {
- dwError = GetLastError();
- printf("/nFile:%s/nError occured in %s on line %d/n", __FILE__, api, __LINE__);
- FormatMessage(
- FORMAT_MESSAGE_FROM_SYSTEM,
- NULL, // ignored
- dwError, // message id
- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // message language
- szMsgBuf, // address of buffer pointer
- 500, // minimum buffer size
- NULL ); // no other arguments
- printf("/nError:(%ld)%s ", dwError, szMsgBuf);
- }
- }
|
