Question

我编写了一个程序，该程序实现了一个微小的外壳来处理来自用户的命令。如果输入的命令被识别为内部命令，则我的程序将执行该命令。

这些命令被实现为内部函数，并且它们的输出由另一个内部函数处理，该另一个内部函数能够将文本发送到控制台和/或文件，以进行日志记录。

如果无法识别输入的命令，我会尝试将输入的命令作为Windows命令外壳程序的一部分执行，例如：cmd dir将执行dir命令，输出将打印在控制台上。这是通过CreateProcess完成的。到目前为止，我尚未指定hStdError参数的成员hStdOutput，hStdInput和STARTUPINFO。

我尝试实现和改编Creating a Child Process with Redirected Input and Output的示例。

我没有使用他们对子进程的实现，但是试图将dir命令的输出输入到我的应用程序中：

#include "pch.h"
#include <windows.h>

#define BUFSIZE 512

HANDLE g_hChildStd_IN_Rd = NULL;
HANDLE g_hChildStd_IN_Wr = NULL;
HANDLE g_hChildStd_OUT_Rd = NULL;
HANDLE g_hChildStd_OUT_Wr = NULL;



PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
void CreateChildProcess()
// Create a child process that uses the previously created pipes for STDIN and STDOUT.
{
    TCHAR szCmdline[] = TEXT("cmd /c dir q:\\Sicherung\\Bilder /s");
    BOOL bSuccess = FALSE;

    // Set up members of the PROCESS_INFORMATION structure. 

    ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

    // Set up members of the STARTUPINFO structure. 
    // This structure specifies the STDIN and STDOUT handles for redirection.

    ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
    siStartInfo.cb = sizeof(STARTUPINFO);
    siStartInfo.hStdError = g_hChildStd_OUT_Wr;
    siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;
    siStartInfo.hStdInput = g_hChildStd_IN_Rd;
    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

    // Create the child process. 

    bSuccess = CreateProcess(NULL,
        szCmdline,     // 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 an error occurs, exit the application. 
    if (!bSuccess)
        return; // ErrorExit(("CreateProcess"));
    else
    {
        // Close handles to the child process and its primary thread.
        // Some applications might keep these handles to monitor the status
        // of the child process, for example. 

        //CloseHandle(piProcInfo.hProcess);
        //CloseHandle(piProcInfo.hThread);
    }
}
void ReadFromPipe(void)
// Read output from the child process's pipe for STDOUT
// and write to the parent process's pipe for STDOUT. 
// Stop when there is no more data. 
{
    DWORD dwRead, dwWritten;
    CHAR chBuf[BUFSIZE];
    BOOL bSuccess = FALSE;
    HANDLE hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

    for (;;)
    {
        DWORD objectstat = WAIT_TIMEOUT;
        //do
        //{
        //  objectstat = WaitForSingleObject(piProcInfo.hProcess, 0);
        //} while (objectstat != WAIT_OBJECT_0);
        memset(&chBuf[0], 0x00, BUFSIZE);
        bSuccess = ReadFile(g_hChildStd_OUT_Rd, chBuf, BUFSIZE, &dwRead, NULL);
        if (!bSuccess)
            break;

        bSuccess = WriteFile(hParentStdOut, chBuf,
            dwRead, &dwWritten, NULL);
        if (!bSuccess) 
            break;
        if (dwRead == 0)
            break;
    }
}
int main()
{
    SECURITY_ATTRIBUTES saAttr;

    printf("\n->Start of parent execution.\n");

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

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

    // Create a pipe for the child process's STDOUT. 
    if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0))
        return -1;// ErrorExit("StdoutRd CreatePipe");

    // Ensure the read handle to the pipe for STDOUT is not inherited.

    if (!SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0))
        return -2;// ErrorExit(("Stdout SetHandleInformation"));

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

    if (!CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0))
        return -3 ;// ErrorExit(("Stdin CreatePipe"));

    // Ensure the write handle to the pipe for STDIN is not inherited. 

    if (!SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0))
        return -4;// ErrorExit(("Stdin SetHandleInformation"));

    // Create the child process. 
    CreateChildProcess();
    ReadFromPipe();
    CloseHandle(piProcInfo.hProcess);
    CloseHandle(piProcInfo.hThread);
    return 0;
}

我知道，问题必须出在ReadFile上。我无法确定何时已处理dir命令的所有输出。在dwRead中检查0或BUFSIZE无效。 dwRead永远不会为0，并且它可能小于BUFSIZE，因为dir命令的速度不够快。

那么，我应该如何结束管道数据的处理？

Answer 1

好吧，在Google中搜索了一些不同的术语后，我想到了指向stackoverflow;）的链接： How to read output from cmd.exe using CreateProcess() and CreatePipe()

伊恩·博伊德（Ian Boyd）在那儿写道：

启动子进程后：请确保关闭不再需要的管道末端。

result = CreateProcess(...);



//CreateProcess demands that we close these two populated handles when we're done with them. We're done with them.

CloseHandle(pi.hProcess);

CloseHandle(pi.hThread);



/*

   We've given the console app the writable end of the pipe during CreateProcess; we don't need it anymore.

   We do keep the handle for the *readable* end of the pipe; as we still need to read from it.

   The other reason to close the writable-end handle now is so that there's only one out-standing reference to the writeable end: held by the console app.

   When the app closes, it will close the pipe, and ReadFile will return code 109 (The pipe has been ended).

   That's how we'll know the console app is done. (no need to wait on process handles with buggy infinite waits)

*/

CloseHandle(g_hChildStd_OUT_Wr);

g_hChildStd_OUT_Wr = 0;

CloseHandle(g_hChildStd_IN_Rd);

g_hChildStd_OUT_Wr = 0;

大多数解决方案的常见问题是人们试图等待流程句柄。这有很多问题。主要是如果您等待孩子终止，孩子将永远无法终止。

关闭不需要的句柄后，ReadFile会按预期工作。

如何处理“ dir”的输出？

1 个答案: