Source/cmDebuggerWindowsPipeConnection.cxx

   1 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2    file Copyright.txt or https://cmake.org/licensing for details.  */
   3 #include "cmDebuggerWindowsPipeConnection.h"
   4
   5 #include <algorithm>
   6 #include <cassert>
   7 #include <cstring>
   8 #include <stdexcept>
   9 #include <utility>
  10
  11 namespace cmDebugger {
  12
  13 #ifdef _WIN32
  14
  15 DuplexPipe_WIN32::DuplexPipe_WIN32(HANDLE pipe)
  16   : hPipe(pipe)
  17 {
  18   readOp.Offset = readOp.OffsetHigh = 0;
  19   readOp.hEvent = CreateEvent(NULL, true, false, NULL);
  20   writeOp.Offset = readOp.OffsetHigh = 0;
  21   writeOp.hEvent = CreateEvent(NULL, true, false, NULL);
  22 }
  23
  24 DuplexPipe_WIN32::~DuplexPipe_WIN32()
  25 {
  26   close();
  27 }
  28
  29 size_t DuplexPipe_WIN32::read(void* buffer, size_t n)
  30 {
  31   if (hPipe != INVALID_HANDLE_VALUE) {
  32     readOp.Offset = readOp.OffsetHigh = 0;
  33     ResetEvent(readOp.hEvent);
  34     auto r = ReadFile(hPipe, buffer, n, NULL, &readOp);
  35     auto err = GetLastError();
  36     if (r || err == ERROR_IO_PENDING) {
  37       DWORD nRead = 0;
  38       if (GetOverlappedResult(hPipe, &readOp, &nRead, true)) {
  39         return nRead;
  40       }
  41     }
  42   }
  43
  44   return 0;
  45 }
  46
  47 bool DuplexPipe_WIN32::write(void const* buffer, size_t n)
  48 {
  49   if (hPipe != INVALID_HANDLE_VALUE) {
  50     writeOp.Offset = writeOp.OffsetHigh = 0;
  51     ResetEvent(writeOp.hEvent);
  52     auto w = WriteFile(hPipe, buffer, n, NULL, &writeOp);
  53     auto err = GetLastError();
  54     if (w || err == ERROR_IO_PENDING) {
  55       DWORD nWrite = 0;
  56       if (GetOverlappedResult(hPipe, &writeOp, &nWrite, true)) {
  57         return n == nWrite;
  58       }
  59     }
  60   }
  61
  62   return false;
  63 }
  64
  65 void DuplexPipe_WIN32::close()
  66 {
  67   CloseHandle(hPipe);
  68   hPipe = INVALID_HANDLE_VALUE;
  69   CloseHandle(readOp.hEvent);
  70   CloseHandle(writeOp.hEvent);
  71   readOp.hEvent = writeOp.hEvent = INVALID_HANDLE_VALUE;
  72 }
  73
  74 bool DuplexPipe_WIN32::WaitForConnection()
  75 {
  76   auto connect = ConnectNamedPipe(hPipe, &readOp);
  77   auto err = GetLastError();
  78   if (!connect && err == ERROR_IO_PENDING) {
  79     DWORD ignored;
  80     if (GetOverlappedResult(hPipe, &readOp, &ignored, true)) {
  81       return true;
  82     }
  83   }
  84
  85   return connect || err == ERROR_PIPE_CONNECTED;
  86 }
  87
  88 cmDebuggerPipeConnection_WIN32::cmDebuggerPipeConnection_WIN32(
  89   std::string name)
  90   : PipeName(std::move(name))
  91   , pipes(nullptr)
  92 {
  93 }
  94
  95 cmDebuggerPipeConnection_WIN32::~cmDebuggerPipeConnection_WIN32()
  96 {
  97   if (isOpen()) {
  98     pipes = nullptr;
  99   }
 100 }
 101
 102 bool cmDebuggerPipeConnection_WIN32::StartListening(std::string& errorMessage)
 103 {
 104   bool result = true;
 105
 106   auto hPipe = CreateNamedPipeA(
 107     PipeName.c_str(),
 108     PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED,
 109     PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_REJECT_REMOTE_CLIENTS, 1,
 110     1024 * 16, 1024 * 16, NMPWAIT_USE_DEFAULT_WAIT, NULL);
 111
 112   if (hPipe == INVALID_HANDLE_VALUE) {
 113     auto err = GetLastError();
 114     errorMessage = GetErrorMessage(err);
 115     result = false;
 116   }
 117
 118   if (result) {
 119     pipes = std::make_unique<DuplexPipe_WIN32>(hPipe);
 120   }
 121
 122   StartedListening.set_value();
 123   return result;
 124 }
 125
 126 std::string cmDebuggerPipeConnection_WIN32::GetErrorMessage(DWORD errorCode)
 127 {
 128   LPSTR message = nullptr;
 129   DWORD size = FormatMessageA(
 130     FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
 131       FORMAT_MESSAGE_IGNORE_INSERTS,
 132     nullptr, errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 133     (LPSTR)&message, 0, nullptr);
 134   std::string errorMessage = "Internal Error with " + this->PipeName + ": " +
 135     std::string(message, size);
 136   LocalFree(message);
 137   return errorMessage;
 138 }
 139
 140 std::shared_ptr<dap::Reader> cmDebuggerPipeConnection_WIN32::GetReader()
 141 {
 142   return std::static_pointer_cast<dap::Reader>(shared_from_this());
 143 }
 144
 145 std::shared_ptr<dap::Writer> cmDebuggerPipeConnection_WIN32::GetWriter()
 146 {
 147   return std::static_pointer_cast<dap::Writer>(shared_from_this());
 148 }
 149
 150 bool cmDebuggerPipeConnection_WIN32::isOpen()
 151 {
 152   return pipes != nullptr;
 153 }
 154
 155 void cmDebuggerPipeConnection_WIN32::close()
 156 {
 157   CloseConnection();
 158 }
 159
 160 void cmDebuggerPipeConnection_WIN32::CloseConnection()
 161 {
 162   if (isOpen()) {
 163     pipes->close();
 164     pipes = nullptr;
 165   }
 166 }
 167
 168 void cmDebuggerPipeConnection_WIN32::WaitForConnection()
 169 {
 170   if (!isOpen()) {
 171     return;
 172   }
 173
 174   if (pipes->WaitForConnection()) {
 175     return;
 176   }
 177
 178   CloseConnection();
 179 }
 180
 181 size_t cmDebuggerPipeConnection_WIN32::read(void* buffer, size_t n)
 182 {
 183   size_t result = 0;
 184   if (isOpen()) {
 185     result = pipes->read(buffer, n);
 186     if (result == 0) {
 187       CloseConnection();
 188     }
 189   }
 190
 191   return result;
 192 }
 193
 194 bool cmDebuggerPipeConnection_WIN32::write(void const* buffer, size_t n)
 195 {
 196   bool result = false;
 197   if (isOpen()) {
 198     result = pipes->write(buffer, n);
 199     if (!result) {
 200       CloseConnection();
 201     }
 202   }
 203
 204   return result;
 205 }
 206
 207 cmDebuggerPipeClient_WIN32::cmDebuggerPipeClient_WIN32(std::string name)
 208   : PipeName(std::move(name))
 209 {
 210 }
 211
 212 cmDebuggerPipeClient_WIN32::~cmDebuggerPipeClient_WIN32()
 213 {
 214   close();
 215 }
 216
 217 void cmDebuggerPipeClient_WIN32::WaitForConnection()
 218 {
 219   if (!isOpen()) {
 220     auto hPipe = CreateFileA(PipeName.c_str(), GENERIC_READ | GENERIC_WRITE, 0,
 221                              NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 222     if (hPipe == INVALID_HANDLE_VALUE) {
 223       auto err = GetLastError();
 224       throw std::runtime_error(std::string("CreateFile failed for pipe ") +
 225                                GetErrorMessage(err));
 226     }
 227
 228     pipes = std::make_unique<DuplexPipe_WIN32>(hPipe);
 229   }
 230 }
 231
 232 std::string cmDebuggerPipeClient_WIN32::GetErrorMessage(DWORD errorCode)
 233 {
 234   LPSTR message = nullptr;
 235   DWORD size = FormatMessageA(
 236     FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
 237       FORMAT_MESSAGE_IGNORE_INSERTS,
 238     nullptr, errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 239     (LPSTR)&message, 0, nullptr);
 240   std::string errorMessage =
 241     this->PipeName + ": " + std::string(message, size);
 242   LocalFree(message);
 243   return errorMessage;
 244 }
 245
 246 bool cmDebuggerPipeClient_WIN32::isOpen()
 247 {
 248   return pipes != nullptr;
 249 }
 250
 251 void cmDebuggerPipeClient_WIN32::close()
 252 {
 253   if (isOpen()) {
 254     pipes->close();
 255     pipes = nullptr;
 256   }
 257 }
 258
 259 size_t cmDebuggerPipeClient_WIN32::read(void* buffer, size_t n)
 260 {
 261   size_t result = 0;
 262   if (isOpen()) {
 263     result = pipes->read(buffer, n);
 264     if (result == 0) {
 265       close();
 266     }
 267   }
 268
 269   return result;
 270 }
 271
 272 bool cmDebuggerPipeClient_WIN32::write(void const* buffer, size_t n)
 273 {
 274   bool result = false;
 275   if (isOpen()) {
 276     result = pipes->write(buffer, n);
 277     if (!result) {
 278       close();
 279     }
 280   }
 281
 282   return result;
 283 }
 284
 285 #endif // _WIN32
 286
 287 } // namespace cmDebugger