Эксперты по Pipes заходите

#ifndef UNICODE
#define UNICODE
#endif
 
#include <windows.h>
#include <string>
#include <stdio.h>
 
void OnCreate(HWND);
void CreateChildProcess();
void ReadFromPipe();
void WriteToPipe();
 
HWND g_edit;
 
HANDLE g_hChildStd_IN_Rd = NULL;
HANDLE g_hChildStd_IN_Wr = NULL;
HANDLE g_hChildStd_OUT_Rd = NULL;
HANDLE g_hChildStd_OUT_Wr = NULL;
 
/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
 
/*  Make the class name into a global variable  */
WCHAR szClassName[] = L"CodeBlocksWindowsApp";
 
INT WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE, LPSTR, int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */
 
    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);
 
    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
 
    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;
 
    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           L"UCI Chess Engine Test",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );
 
    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);
 
    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }
 
    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}
 
 
/*  This function is called by the Windows function DispatchMessage()  */
 
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
        case WM_CREATE:
            OnCreate(hwnd);
            break;
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
 
    return 0;
}
 
void OnCreate(HWND hwnd)
{
    g_edit = CreateWindow(
        L"EDIT",
        NULL,
        WS_CHILD | WS_BORDER | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE,
        10,10,
        500,200,
        hwnd,
        NULL,
        (HINSTANCE) GetWindowLongPtr(hwnd, GWLP_HINSTANCE),
        NULL
    );
 
    SECURITY_ATTRIBUTES saAttr;
    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    // Set the bInheritHandle flag so pipe handles are inherited.
    saAttr.bInheritHandle = TRUE;
    saAttr.lpSecurityDescriptor = NULL;
 
    // Create a pipe for the child process's STDIN.
    if (!CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0))
    {
        printf("STDIN CreatePipe failed (%lu).\n", GetLastError());
        return;
    }
 
    // Ensure the write handle to the pipe for STDIN is not inherited.
    if (!SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0))
    {
        printf("STDIN SetHandleInformation\n");
        return;
    }
 
    // Create a pipe for the child process's STDOUT.
    if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0))
    {
        printf("STDOUT CreatePipe failed (%lu).\n", GetLastError());
        return;
    }
 
    // Ensure the read handle to the pipe for STDOUT is not inherited.
    if (!SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0))
    {
        printf("STDOUT SetHandleInformation\n");
        return;
    }
/*
    ╔══════════════════╗                ╔══════════════════╗
    ║  Parent Process  ║                ║  Child Process   ║
    ╠══════════════════╣                ╠══════════════════╣
    ║                  ║                ║                  ║
    ║ g_hChildStd_IN_Wr╟─────────────>>>║g_hChildStd_IN_Rd ║
    ║                  ║                ║                  ║
    ║g_hChildStd_OUT_Rd║<<<─────────────╢g_hChildStd_OUT_Wr║
    ║                  ║                ║                  ║
    ╚══════════════════╝                ╚══════════════════╝
*/
    // Create the child process.
    CreateChildProcess();
 
    Sleep(1000);
    ReadFromPipe();
    Sleep(1000);
    WriteToPipe();
    Sleep(1000);
    ReadFromPipe();
//    Sleep(1000);
//    WriteToPipe();
//    Sleep(1000);
//    ReadFromPipe();
}
 
void CreateChildProcess()
{
    // Create a child process that uses the previously created pipes for STDIN and STDOUT.
 
    // Set up members of the PROCESS_INFORMATION structure.
    PROCESS_INFORMATION pi;
    ZeroMemory( &pi, sizeof(pi) );
 
    // Set up members of the STARTUPINFO structure.
    // This structure specifies the STDIN and STDOUT handles for redirection.
    STARTUPINFO si;
    ZeroMemory( &si, sizeof(si) );
    si.cb = sizeof(si);
    si.hStdError = g_hChildStd_OUT_Wr;
    si.hStdOutput = g_hChildStd_OUT_Wr;
    si.hStdInput = g_hChildStd_IN_Rd;
    si.dwFlags |= STARTF_USESTDHANDLES;
 
    WCHAR szCmdline[] = L"stockfish.exe";
 
    // Create the child process.
    if( !CreateProcess(
                NULL,
                szCmdline,      // command line
                NULL,           // Process handle not inheritable
                NULL,           // Thread handle not inheritable
                TRUE,           // Handles are inherited
                NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, // Creation flags
                NULL,           // Use parent's environment block
                NULL,           // Use parent's starting directory
                &si,            // Pointer to STARTUPINFO structure
                &pi )           // Pointer to PROCESS_INFORMATION structure
            )
    {
        // If an error occurs, exit the application.
        printf( "CreateProcess failed (%lu).\n", GetLastError() );
        return;
    }
 
    // 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( pi.hProcess );
    CloseHandle( pi.hThread );
 
    // Close handles to the stdin and stdout pipes no longer needed by the child process.
    // If they are not explicitly closed, there is no way to recognize that the child process has ended.
    CloseHandle(g_hChildStd_OUT_Wr);
    CloseHandle(g_hChildStd_IN_Rd);
 
    printf( "Child process created\n");
}
 
void WriteToPipe()
{
    DWORD dwWritten;
 
    CHAR text[] = "uci";
 
    WriteFile(g_hChildStd_IN_Wr, text, 3, &dwWritten, NULL);
 
    printf( "Chars written: %lu\n", dwWritten);
 
    // Close the pipe handle so the child process stops reading.
    if ( !CloseHandle(g_hChildStd_IN_Wr) )
        printf("Error: CloseHandle hStdinWrite (%lu)\n", GetLastError());
}
 
void ReadFromPipe()
{
    DWORD dwRead;
    CHAR chBuf[4096];
 
    ReadFile(g_hChildStd_OUT_Rd, chBuf, 4096, &dwRead, NULL);
 
    printf( "Chars read: %lu\n", dwRead);
 
    std::wstring text(chBuf, chBuf + dwRead);
    SetWindowText(g_edit, text.c_str());
}