怎样在windows环境中启动某控制台程序并改变它的stdin、stdout和stderr？ http://book.77169.org/ask18/how106297.htm

?

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