CPipe.cpp

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Automatic Testing Utility
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     Class that manages an unidirectional anonymous byte stream pipe
 * COPYRIGHT:   Copyright 2015 Thomas Faber (thomas.faber@reactos.org)
 *              Copyright 2019 Colin Finck (colin@reactos.org)
 */
 
#include "precomp.h"
 
LONG CPipe::m_lPipeCount = 0;
 
 
CPipe::CPipe()
{
    SECURITY_ATTRIBUTES SecurityAttributes;
 
    SecurityAttributes.nLength = sizeof(SecurityAttributes);
    SecurityAttributes.bInheritHandle = TRUE;
    SecurityAttributes.lpSecurityDescriptor = NULL;
 
    // Construct a unique pipe name.
    WCHAR wszPipeName[MAX_PATH];
    InterlockedIncrement(&m_lPipeCount);
    _swprintf(wszPipeName, L"\\\\.\\pipe\\TestmanPipe%ld", m_lPipeCount);
 
    // Create a named pipe with the default settings, but overlapped (asynchronous) operations.
    // Latter feature is why we can't simply use CreatePipe.
    const DWORD dwDefaultBufferSize = 4096;
    const DWORD dwDefaultTimeoutMilliseconds = 120000;
 
    m_hReadPipe = CreateNamedPipeW(wszPipeName,
        PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
        PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
        1,
        dwDefaultBufferSize,
        dwDefaultBufferSize,
        dwDefaultTimeoutMilliseconds,
        &SecurityAttributes);
    if (m_hReadPipe == INVALID_HANDLE_VALUE)
    {
        FATAL("CreateNamedPipe failed\n");
    }
 
    // Use CreateFileW to get the write handle to the pipe.
    // Writing is done synchronously, so no FILE_FLAG_OVERLAPPED here!
    m_hWritePipe = CreateFileW(wszPipeName,
        GENERIC_WRITE,
        0,
        &SecurityAttributes,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL);
    if (m_hWritePipe == INVALID_HANDLE_VALUE)
    {
        FATAL("CreateFileW failed\n");
    }
 
    // Prepare the OVERLAPPED structure for reading.
    ZeroMemory(&m_ReadOverlapped, sizeof(m_ReadOverlapped));
    m_ReadOverlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
    if (!m_ReadOverlapped.hEvent)
    {
        FATAL("CreateEvent failed\n");
    }
}
 
CPipe::~CPipe()
{
    if (m_hReadPipe)
        CloseHandle(m_hReadPipe);
    if (m_hWritePipe)
        CloseHandle(m_hWritePipe);
}
 
void
CPipe::CloseReadPipe()
{
    if (!m_hReadPipe)
        FATAL("Trying to close already closed read pipe\n");
    CloseHandle(m_hReadPipe);
    m_hReadPipe = NULL;
}
 
void
CPipe::CloseWritePipe()
{
    if (!m_hWritePipe)
        FATAL("Trying to close already closed write pipe\n");
    CloseHandle(m_hWritePipe);
    m_hWritePipe = NULL;
}
 
bool
CPipe::Peek(PVOID Buffer, DWORD BufferSize, PDWORD BytesRead, PDWORD TotalBytesAvailable)
{
    if (!m_hReadPipe)
        FATAL("Trying to peek from a closed read pipe\n");
 
    return PeekNamedPipe(m_hReadPipe, Buffer, BufferSize, BytesRead, TotalBytesAvailable, NULL);
}
 
DWORD
CPipe::Read(PVOID Buffer, DWORD NumberOfBytesToRead, PDWORD NumberOfBytesRead, DWORD TimeoutMilliseconds)
{
    if (!m_hReadPipe)
    {
        FATAL("Trying to read from a closed read pipe\n");
    }
 
    RtlZeroMemory(&m_ReadOverlapped, FIELD_OFFSET(OVERLAPPED, hEvent));
    ResetEvent(m_ReadOverlapped.hEvent);
 
    if (ReadFile(m_hReadPipe, Buffer, NumberOfBytesToRead, NumberOfBytesRead, &m_ReadOverlapped))
    {
        // The asynchronous read request could be satisfied immediately.
        return ERROR_SUCCESS;
    }
 
    DWORD dwLastError = GetLastError();
    if (dwLastError == ERROR_IO_PENDING)
    {
        // The asynchronous read request could not be satisfied immediately, so wait for it with the given timeout.
        DWORD dwWaitResult = WaitForSingleObject(m_ReadOverlapped.hEvent, TimeoutMilliseconds);
        if (dwWaitResult == WAIT_OBJECT_0)
        {
            // Fill NumberOfBytesRead.
            if (GetOverlappedResult(m_hReadPipe, &m_ReadOverlapped, NumberOfBytesRead, FALSE))
            {
                // We successfully read NumberOfBytesRead bytes.
                return ERROR_SUCCESS;
            }
 
            dwLastError = GetLastError();
            if (dwLastError == ERROR_BROKEN_PIPE)
            {
                // The other end of the pipe has been closed.
                return ERROR_BROKEN_PIPE;
            }
            else
            {
                // An unexpected error.
                FATAL("GetOverlappedResult failed\n");
            }
        }
        else
        {
            // This may be WAIT_TIMEOUT or an unexpected error.
            CancelIo(m_hReadPipe);
            return dwWaitResult;
        }
    }
    else
    {
        // This may be ERROR_BROKEN_PIPE or an unexpected error.
        return dwLastError;
    }
}
 
bool
CPipe::Write(LPCVOID Buffer, DWORD NumberOfBytesToWrite, PDWORD NumberOfBytesWritten)
{
    if (!m_hWritePipe)
        FATAL("Trying to write to a closed write pipe\n");
 
    return WriteFile(m_hWritePipe, Buffer, NumberOfBytesToWrite, NumberOfBytesWritten, NULL);
}