modules/rostests/rosautotest/CPipe.cpp

   1 /*
   2  * PROJECT:     ReactOS Automatic Testing Utility
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     Class that manages an unidirectional anonymous byte stream pipe
   5  * COPYRIGHT:   Copyright 2015 Thomas Faber (thomas.faber@reactos.org)
   6  *              Copyright 2019 Colin Finck (colin@reactos.org)
   7  */
   8
   9 #include "precomp.h"
  10
  11 LONG CPipe::m_lPipeCount = 0;
  12
  13
  14 /**
  15  * Constructs a CPipe object and initializes read and write handles.
  16  */
  17 CPipe::CPipe()
  18 {
  19     SECURITY_ATTRIBUTES SecurityAttributes;
  20
  21     SecurityAttributes.nLength = sizeof(SecurityAttributes);
  22     SecurityAttributes.bInheritHandle = TRUE;
  23     SecurityAttributes.lpSecurityDescriptor = NULL;
  24
  25     // Construct a unique pipe name.
  26     WCHAR wszPipeName[MAX_PATH];
  27     InterlockedIncrement(&m_lPipeCount);
  28     swprintf(wszPipeName, L"\\\\.\\pipe\\TestmanPipe%ld", m_lPipeCount);
  29
  30     // Create a named pipe with the default settings, but overlapped (asynchronous) operations.
  31     // Latter feature is why we can't simply use CreatePipe.
  32     const DWORD dwDefaultBufferSize = 4096;
  33     const DWORD dwDefaultTimeoutMilliseconds = 120000;
  34
  35     m_hReadPipe = CreateNamedPipeW(wszPipeName,
  36         PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
  37         PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
  38         1,
  39         dwDefaultBufferSize,
  40         dwDefaultBufferSize,
  41         dwDefaultTimeoutMilliseconds,
  42         &SecurityAttributes);
  43     if (m_hReadPipe == INVALID_HANDLE_VALUE)
  44     {
  45         FATAL("CreateNamedPipe failed\n");
  46     }
  47
  48     // Use CreateFileW to get the write handle to the pipe.
  49     // Writing is done synchronously, so no FILE_FLAG_OVERLAPPED here!
  50     m_hWritePipe = CreateFileW(wszPipeName,
  51         GENERIC_WRITE,
  52         0,
  53         &SecurityAttributes,
  54         OPEN_EXISTING,
  55         FILE_ATTRIBUTE_NORMAL,
  56         NULL);
  57     if (m_hWritePipe == INVALID_HANDLE_VALUE)
  58     {
  59         FATAL("CreateFileW failed\n");
  60     }
  61
  62     // Prepare the OVERLAPPED structure for reading.
  63     ZeroMemory(&m_ReadOverlapped, sizeof(m_ReadOverlapped));
  64     m_ReadOverlapped.hEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
  65     if (!m_ReadOverlapped.hEvent)
  66     {
  67         FATAL("CreateEvent failed\n");
  68     }
  69 }
  70
  71 /**
  72  * Destructs a CPipe object and closes all open handles.
  73  */
  74 CPipe::~CPipe()
  75 {
  76     if (m_hReadPipe)
  77         CloseHandle(m_hReadPipe);
  78     if (m_hWritePipe)
  79         CloseHandle(m_hWritePipe);
  80 }
  81
  82 /**
  83  * Closes a CPipe's read pipe, leaving the write pipe unchanged.
  84  */
  85 void
  86 CPipe::CloseReadPipe()
  87 {
  88     if (!m_hReadPipe)
  89         FATAL("Trying to close already closed read pipe\n");
  90     CloseHandle(m_hReadPipe);
  91     m_hReadPipe = NULL;
  92 }
  93
  94 /**
  95  * Closes a CPipe's write pipe, leaving the read pipe unchanged.
  96  */
  97 void
  98 CPipe::CloseWritePipe()
  99 {
 100     if (!m_hWritePipe)
 101         FATAL("Trying to close already closed write pipe\n");
 102     CloseHandle(m_hWritePipe);
 103     m_hWritePipe = NULL;
 104 }
 105
 106 /**
 107  * Reads data from a pipe without advancing the read offset and/or retrieves information about available data.
 108  *
 109  * This function must not be called after CloseReadPipe.
 110  *
 111  * @param Buffer
 112  * An optional buffer to read pipe data into.
 113  *
 114  * @param BufferSize
 115  * The size of the buffer specified in Buffer, or 0 if no read should be performed.
 116  *
 117  * @param BytesRead
 118  * On return, the number of bytes actually read from the pipe into Buffer.
 119  *
 120  * @param TotalBytesAvailable
 121  * On return, the total number of bytes available to read from the pipe.
 122  *
 123  * @return
 124  * True on success, false on failure; call GetLastError for error information.
 125  *
 126  * @see PeekNamedPipe
 127  */
 128 bool
 129 CPipe::Peek(PVOID Buffer, DWORD BufferSize, PDWORD BytesRead, PDWORD TotalBytesAvailable)
 130 {
 131     if (!m_hReadPipe)
 132         FATAL("Trying to peek from a closed read pipe\n");
 133
 134     return PeekNamedPipe(m_hReadPipe, Buffer, BufferSize, BytesRead, TotalBytesAvailable, NULL);
 135 }
 136
 137 /**
 138  * Reads data from the read pipe, advancing the read offset accordingly.
 139  *
 140  * This function must not be called after CloseReadPipe.
 141  *
 142  * @param Buffer
 143  * Buffer to read pipe data into.
 144  *
 145  * @param NumberOfBytesToRead
 146  * The number of bytes to read into Buffer.
 147  *
 148  * @param NumberOfBytesRead
 149  * On return, the number of bytes actually read from the pipe into Buffer.
 150  *
 151  * @return
 152  * Returns a Win32 error code. Expected error codes include:
 153  *   - ERROR_SUCCESS:     The read has completed successfully.
 154  *   - WAIT_TIMEOUT:      The given timeout has elapsed before any data was read.
 155  *   - ERROR_BROKEN_PIPE: The other end of the pipe has been closed.
 156  *
 157  * @see ReadFile
 158  */
 159 DWORD
 160 CPipe::Read(PVOID Buffer, DWORD NumberOfBytesToRead, PDWORD NumberOfBytesRead, DWORD TimeoutMilliseconds)
 161 {
 162     if (!m_hReadPipe)
 163     {
 164         FATAL("Trying to read from a closed read pipe\n");
 165     }
 166
 167     if (ReadFile(m_hReadPipe, Buffer, NumberOfBytesToRead, NumberOfBytesRead, &m_ReadOverlapped))
 168     {
 169         // The asynchronous read request could be satisfied immediately.
 170         return ERROR_SUCCESS;
 171     }
 172
 173     DWORD dwLastError = GetLastError();
 174     if (dwLastError == ERROR_IO_PENDING)
 175     {
 176         // The asynchronous read request could not be satisfied immediately, so wait for it with the given timeout.
 177         DWORD dwWaitResult = WaitForSingleObject(m_ReadOverlapped.hEvent, TimeoutMilliseconds);
 178         if (dwWaitResult == WAIT_OBJECT_0)
 179         {
 180             // Fill NumberOfBytesRead.
 181             if (GetOverlappedResult(m_hReadPipe, &m_ReadOverlapped, NumberOfBytesRead, FALSE))
 182             {
 183                 // We successfully read NumberOfBytesRead bytes.
 184                 return ERROR_SUCCESS;
 185             }
 186
 187             dwLastError = GetLastError();
 188             if (dwLastError == ERROR_BROKEN_PIPE)
 189             {
 190                 // The other end of the pipe has been closed.
 191                 return ERROR_BROKEN_PIPE;
 192             }
 193             else
 194             {
 195                 // An unexpected error.
 196                 FATAL("GetOverlappedResult failed\n");
 197             }
 198         }
 199         else
 200         {
 201             // This may be WAIT_TIMEOUT or an unexpected error.
 202             return dwWaitResult;
 203         }
 204     }
 205     else
 206     {
 207         // This may be ERROR_BROKEN_PIPE or an unexpected error.
 208         return dwLastError;
 209     }
 210 }
 211
 212 /**
 213  * Writes data to the write pipe.
 214  *
 215  * This function must not be called after CloseWritePipe.
 216  *
 217  * @param Buffer
 218  * Buffer containing the data to write.
 219  *
 220  * @param NumberOfBytesToWrite
 221  * The number of bytes to write to the pipe from Buffer.
 222  *
 223  * @param NumberOfBytesWritten
 224  * On return, the number of bytes actually written to the pipe.
 225  *
 226  * @return
 227  * True on success, false on failure; call GetLastError for error information.
 228  *
 229  * @see WriteFile
 230  */
 231 bool
 232 CPipe::Write(LPCVOID Buffer, DWORD NumberOfBytesToWrite, PDWORD NumberOfBytesWritten)
 233 {
 234     if (!m_hWritePipe)
 235         FATAL("Trying to write to a closed write pipe\n");
 236
 237     return WriteFile(m_hWritePipe, Buffer, NumberOfBytesToWrite, NumberOfBytesWritten, NULL);
 238 }