| 1 |
// Copyright (c) 2011-2012 Ryan Prichard |
| 2 |
// |
| 3 |
// Permission is hereby granted, free of charge, to any person obtaining a copy |
| 4 |
// of this software and associated documentation files (the "Software"), to |
| 5 |
// deal in the Software without restriction, including without limitation the |
| 6 |
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| 7 |
// sell copies of the Software, and to permit persons to whom the Software is |
| 8 |
// furnished to do so, subject to the following conditions: |
| 9 |
// |
| 10 |
// The above copyright notice and this permission notice shall be included in |
| 11 |
// all copies or substantial portions of the Software. |
| 12 |
// |
| 13 |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 14 |
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 15 |
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 16 |
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 17 |
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 18 |
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| 19 |
// IN THE SOFTWARE. |
| 20 |
|
| 21 |
#include <string.h> |
| 22 |
|
| 23 |
#include <algorithm> |
| 24 |
|
| 25 |
#include "EventLoop.h" |
| 26 |
#include "NamedPipe.h" |
| 27 |
#include "../shared/DebugClient.h" |
| 28 |
#include "../shared/StringUtil.h" |
| 29 |
#include "../shared/WindowsSecurity.h" |
| 30 |
#include "../shared/WinptyAssert.h" |
| 31 |
|
| 32 |
// Returns true if anything happens (data received, data sent, pipe error). |
| 33 |
bool NamedPipe::serviceIo(std::vector<HANDLE> *waitHandles) |
| 34 |
{ |
| 35 |
bool justConnected = false; |
| 36 |
const auto kError = ServiceResult::Error; |
| 37 |
const auto kProgress = ServiceResult::Progress; |
| 38 |
const auto kNoProgress = ServiceResult::NoProgress; |
| 39 |
if (m_handle == NULL) { |
| 40 |
return false; |
| 41 |
} |
| 42 |
if (m_connectEvent.get() != nullptr) { |
| 43 |
// We're still connecting this server pipe. Check whether the pipe is |
| 44 |
// now connected. If it isn't, add the pipe to the list of handles to |
| 45 |
// wait on. |
| 46 |
DWORD actual = 0; |
| 47 |
BOOL success = |
| 48 |
GetOverlappedResult(m_handle, &m_connectOver, &actual, FALSE); |
| 49 |
if (!success && GetLastError() == ERROR_PIPE_CONNECTED) { |
| 50 |
// I'm not sure this can happen, but it's easy to handle if it |
| 51 |
// does. |
| 52 |
success = TRUE; |
| 53 |
} |
| 54 |
if (!success) { |
| 55 |
ASSERT(GetLastError() == ERROR_IO_INCOMPLETE && |
| 56 |
"Pended ConnectNamedPipe call failed"); |
| 57 |
waitHandles->push_back(m_connectEvent.get()); |
| 58 |
} else { |
| 59 |
TRACE("Server pipe [%s] connected", |
| 60 |
utf8FromWide(m_name).c_str()); |
| 61 |
m_connectEvent.dispose(); |
| 62 |
startPipeWorkers(); |
| 63 |
justConnected = true; |
| 64 |
} |
| 65 |
} |
| 66 |
const auto readProgress = m_inputWorker ? m_inputWorker->service() : kNoProgress; |
| 67 |
const auto writeProgress = m_outputWorker ? m_outputWorker->service() : kNoProgress; |
| 68 |
if (readProgress == kError || writeProgress == kError) { |
| 69 |
closePipe(); |
| 70 |
return true; |
| 71 |
} |
| 72 |
if (m_inputWorker && m_inputWorker->getWaitEvent() != nullptr) { |
| 73 |
waitHandles->push_back(m_inputWorker->getWaitEvent()); |
| 74 |
} |
| 75 |
if (m_outputWorker && m_outputWorker->getWaitEvent() != nullptr) { |
| 76 |
waitHandles->push_back(m_outputWorker->getWaitEvent()); |
| 77 |
} |
| 78 |
return justConnected |
| 79 |
|| readProgress == kProgress |
| 80 |
|| writeProgress == kProgress; |
| 81 |
} |
| 82 |
|
| 83 |
// manual reset, initially unset |
| 84 |
static OwnedHandle createEvent() { |
| 85 |
HANDLE ret = CreateEventW(nullptr, TRUE, FALSE, nullptr); |
| 86 |
ASSERT(ret != nullptr && "CreateEventW failed"); |
| 87 |
return OwnedHandle(ret); |
| 88 |
} |
| 89 |
|
| 90 |
NamedPipe::IoWorker::IoWorker(NamedPipe &namedPipe) : |
| 91 |
m_namedPipe(namedPipe), |
| 92 |
m_event(createEvent()) |
| 93 |
{ |
| 94 |
} |
| 95 |
|
| 96 |
NamedPipe::ServiceResult NamedPipe::IoWorker::service() |
| 97 |
{ |
| 98 |
ServiceResult progress = ServiceResult::NoProgress; |
| 99 |
if (m_pending) { |
| 100 |
DWORD actual = 0; |
| 101 |
BOOL ret = GetOverlappedResult(m_namedPipe.m_handle, &m_over, &actual, FALSE); |
| 102 |
if (!ret) { |
| 103 |
if (GetLastError() == ERROR_IO_INCOMPLETE) { |
| 104 |
// There is a pending I/O. |
| 105 |
return progress; |
| 106 |
} else { |
| 107 |
// Pipe error. |
| 108 |
return ServiceResult::Error; |
| 109 |
} |
| 110 |
} |
| 111 |
ResetEvent(m_event.get()); |
| 112 |
m_pending = false; |
| 113 |
completeIo(actual); |
| 114 |
m_currentIoSize = 0; |
| 115 |
progress = ServiceResult::Progress; |
| 116 |
} |
| 117 |
DWORD nextSize = 0; |
| 118 |
bool isRead = false; |
| 119 |
while (shouldIssueIo(&nextSize, &isRead)) { |
| 120 |
m_currentIoSize = nextSize; |
| 121 |
DWORD actual = 0; |
| 122 |
memset(&m_over, 0, sizeof(m_over)); |
| 123 |
m_over.hEvent = m_event.get(); |
| 124 |
BOOL ret = isRead |
| 125 |
? ReadFile(m_namedPipe.m_handle, m_buffer, nextSize, &actual, &m_over) |
| 126 |
: WriteFile(m_namedPipe.m_handle, m_buffer, nextSize, &actual, &m_over); |
| 127 |
if (!ret) { |
| 128 |
if (GetLastError() == ERROR_IO_PENDING) { |
| 129 |
// There is a pending I/O. |
| 130 |
m_pending = true; |
| 131 |
return progress; |
| 132 |
} else { |
| 133 |
// Pipe error. |
| 134 |
return ServiceResult::Error; |
| 135 |
} |
| 136 |
} |
| 137 |
ResetEvent(m_event.get()); |
| 138 |
completeIo(actual); |
| 139 |
m_currentIoSize = 0; |
| 140 |
progress = ServiceResult::Progress; |
| 141 |
} |
| 142 |
return progress; |
| 143 |
} |
| 144 |
|
| 145 |
// This function is called after CancelIo has returned. We need to block until |
| 146 |
// the I/O operations have completed, which should happen very quickly. |
| 147 |
// https://blogs.msdn.microsoft.com/oldnewthing/20110202-00/?p=11613 |
| 148 |
void NamedPipe::IoWorker::waitForCanceledIo() |
| 149 |
{ |
| 150 |
if (m_pending) { |
| 151 |
DWORD actual = 0; |
| 152 |
GetOverlappedResult(m_namedPipe.m_handle, &m_over, &actual, TRUE); |
| 153 |
m_pending = false; |
| 154 |
} |
| 155 |
} |
| 156 |
|
| 157 |
HANDLE NamedPipe::IoWorker::getWaitEvent() |
| 158 |
{ |
| 159 |
return m_pending ? m_event.get() : NULL; |
| 160 |
} |
| 161 |
|
| 162 |
void NamedPipe::InputWorker::completeIo(DWORD size) |
| 163 |
{ |
| 164 |
m_namedPipe.m_inQueue.append(m_buffer, size); |
| 165 |
} |
| 166 |
|
| 167 |
bool NamedPipe::InputWorker::shouldIssueIo(DWORD *size, bool *isRead) |
| 168 |
{ |
| 169 |
*isRead = true; |
| 170 |
ASSERT(!m_namedPipe.isConnecting()); |
| 171 |
if (m_namedPipe.isClosed()) { |
| 172 |
return false; |
| 173 |
} else if (m_namedPipe.m_inQueue.size() < m_namedPipe.readBufferSize()) { |
| 174 |
*size = kIoSize; |
| 175 |
return true; |
| 176 |
} else { |
| 177 |
return false; |
| 178 |
} |
| 179 |
} |
| 180 |
|
| 181 |
void NamedPipe::OutputWorker::completeIo(DWORD size) |
| 182 |
{ |
| 183 |
ASSERT(size == m_currentIoSize); |
| 184 |
} |
| 185 |
|
| 186 |
bool NamedPipe::OutputWorker::shouldIssueIo(DWORD *size, bool *isRead) |
| 187 |
{ |
| 188 |
*isRead = false; |
| 189 |
if (!m_namedPipe.m_outQueue.empty()) { |
| 190 |
auto &out = m_namedPipe.m_outQueue; |
| 191 |
const DWORD writeSize = std::min<size_t>(out.size(), kIoSize); |
| 192 |
std::copy(&out[0], &out[writeSize], m_buffer); |
| 193 |
out.erase(0, writeSize); |
| 194 |
*size = writeSize; |
| 195 |
return true; |
| 196 |
} else { |
| 197 |
return false; |
| 198 |
} |
| 199 |
} |
| 200 |
|
| 201 |
DWORD NamedPipe::OutputWorker::getPendingIoSize() |
| 202 |
{ |
| 203 |
return m_pending ? m_currentIoSize : 0; |
| 204 |
} |
| 205 |
|
| 206 |
void NamedPipe::openServerPipe(LPCWSTR pipeName, OpenMode::t openMode, |
| 207 |
int outBufferSize, int inBufferSize) { |
| 208 |
ASSERT(isClosed()); |
| 209 |
ASSERT((openMode & OpenMode::Duplex) != 0); |
| 210 |
const DWORD winOpenMode = |
| 211 |
((openMode & OpenMode::Reading) ? PIPE_ACCESS_INBOUND : 0) |
| 212 |
| ((openMode & OpenMode::Writing) ? PIPE_ACCESS_OUTBOUND : 0) |
| 213 |
| FILE_FLAG_FIRST_PIPE_INSTANCE |
| 214 |
| FILE_FLAG_OVERLAPPED; |
| 215 |
const auto sd = createPipeSecurityDescriptorOwnerFullControl(); |
| 216 |
ASSERT(sd && "error creating data pipe SECURITY_DESCRIPTOR"); |
| 217 |
SECURITY_ATTRIBUTES sa = {}; |
| 218 |
sa.nLength = sizeof(sa); |
| 219 |
sa.lpSecurityDescriptor = sd.get(); |
| 220 |
HANDLE handle = CreateNamedPipeW( |
| 221 |
pipeName, |
| 222 |
/*dwOpenMode=*/winOpenMode, |
| 223 |
/*dwPipeMode=*/rejectRemoteClientsPipeFlag(), |
| 224 |
/*nMaxInstances=*/1, |
| 225 |
/*nOutBufferSize=*/outBufferSize, |
| 226 |
/*nInBufferSize=*/inBufferSize, |
| 227 |
/*nDefaultTimeOut=*/30000, |
| 228 |
&sa); |
| 229 |
TRACE("opened server pipe [%s], handle == %p", |
| 230 |
utf8FromWide(pipeName).c_str(), handle); |
| 231 |
ASSERT(handle != INVALID_HANDLE_VALUE && "Could not open server pipe"); |
| 232 |
m_name = pipeName; |
| 233 |
m_handle = handle; |
| 234 |
m_openMode = openMode; |
| 235 |
|
| 236 |
// Start an asynchronous connection attempt. |
| 237 |
m_connectEvent = createEvent(); |
| 238 |
memset(&m_connectOver, 0, sizeof(m_connectOver)); |
| 239 |
m_connectOver.hEvent = m_connectEvent.get(); |
| 240 |
BOOL success = ConnectNamedPipe(m_handle, &m_connectOver); |
| 241 |
const auto err = GetLastError(); |
| 242 |
if (!success && err == ERROR_PIPE_CONNECTED) { |
| 243 |
success = TRUE; |
| 244 |
} |
| 245 |
if (success) { |
| 246 |
TRACE("Server pipe [%s] connected", utf8FromWide(pipeName).c_str()); |
| 247 |
m_connectEvent.dispose(); |
| 248 |
startPipeWorkers(); |
| 249 |
} else if (err != ERROR_IO_PENDING) { |
| 250 |
ASSERT(false && "ConnectNamedPipe call failed"); |
| 251 |
} |
| 252 |
} |
| 253 |
|
| 254 |
void NamedPipe::connectToServer(LPCWSTR pipeName, OpenMode::t openMode) |
| 255 |
{ |
| 256 |
ASSERT(isClosed()); |
| 257 |
ASSERT((openMode & OpenMode::Duplex) != 0); |
| 258 |
HANDLE handle = CreateFileW( |
| 259 |
pipeName, |
| 260 |
GENERIC_READ | GENERIC_WRITE, |
| 261 |
0, |
| 262 |
NULL, |
| 263 |
OPEN_EXISTING, |
| 264 |
SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION | FILE_FLAG_OVERLAPPED, |
| 265 |
NULL); |
| 266 |
TRACE("connected to [%s], handle == %p", |
| 267 |
utf8FromWide(pipeName).c_str(), handle); |
| 268 |
ASSERT(handle != INVALID_HANDLE_VALUE && "Could not connect to pipe"); |
| 269 |
m_name = pipeName; |
| 270 |
m_handle = handle; |
| 271 |
m_openMode = openMode; |
| 272 |
startPipeWorkers(); |
| 273 |
} |
| 274 |
|
| 275 |
void NamedPipe::startPipeWorkers() |
| 276 |
{ |
| 277 |
if (m_openMode & OpenMode::Reading) { |
| 278 |
m_inputWorker.reset(new InputWorker(*this)); |
| 279 |
} |
| 280 |
if (m_openMode & OpenMode::Writing) { |
| 281 |
m_outputWorker.reset(new OutputWorker(*this)); |
| 282 |
} |
| 283 |
} |
| 284 |
|
| 285 |
size_t NamedPipe::bytesToSend() |
| 286 |
{ |
| 287 |
ASSERT(m_openMode & OpenMode::Writing); |
| 288 |
auto ret = m_outQueue.size(); |
| 289 |
if (m_outputWorker != NULL) { |
| 290 |
ret += m_outputWorker->getPendingIoSize(); |
| 291 |
} |
| 292 |
return ret; |
| 293 |
} |
| 294 |
|
| 295 |
void NamedPipe::write(const void *data, size_t size) |
| 296 |
{ |
| 297 |
ASSERT(m_openMode & OpenMode::Writing); |
| 298 |
m_outQueue.append(reinterpret_cast<const char*>(data), size); |
| 299 |
} |
| 300 |
|
| 301 |
void NamedPipe::write(const char *text) |
| 302 |
{ |
| 303 |
write(text, strlen(text)); |
| 304 |
} |
| 305 |
|
| 306 |
size_t NamedPipe::readBufferSize() |
| 307 |
{ |
| 308 |
ASSERT(m_openMode & OpenMode::Reading); |
| 309 |
return m_readBufferSize; |
| 310 |
} |
| 311 |
|
| 312 |
void NamedPipe::setReadBufferSize(size_t size) |
| 313 |
{ |
| 314 |
ASSERT(m_openMode & OpenMode::Reading); |
| 315 |
m_readBufferSize = size; |
| 316 |
} |
| 317 |
|
| 318 |
size_t NamedPipe::bytesAvailable() |
| 319 |
{ |
| 320 |
ASSERT(m_openMode & OpenMode::Reading); |
| 321 |
return m_inQueue.size(); |
| 322 |
} |
| 323 |
|
| 324 |
size_t NamedPipe::peek(void *data, size_t size) |
| 325 |
{ |
| 326 |
ASSERT(m_openMode & OpenMode::Reading); |
| 327 |
const auto out = reinterpret_cast<char*>(data); |
| 328 |
const size_t ret = std::min(size, m_inQueue.size()); |
| 329 |
std::copy(&m_inQueue[0], &m_inQueue[ret], out); |
| 330 |
return ret; |
| 331 |
} |
| 332 |
|
| 333 |
size_t NamedPipe::read(void *data, size_t size) |
| 334 |
{ |
| 335 |
size_t ret = peek(data, size); |
| 336 |
m_inQueue.erase(0, ret); |
| 337 |
return ret; |
| 338 |
} |
| 339 |
|
| 340 |
std::string NamedPipe::readToString(size_t size) |
| 341 |
{ |
| 342 |
ASSERT(m_openMode & OpenMode::Reading); |
| 343 |
size_t retSize = std::min(size, m_inQueue.size()); |
| 344 |
std::string ret = m_inQueue.substr(0, retSize); |
| 345 |
m_inQueue.erase(0, retSize); |
| 346 |
return ret; |
| 347 |
} |
| 348 |
|
| 349 |
std::string NamedPipe::readAllToString() |
| 350 |
{ |
| 351 |
ASSERT(m_openMode & OpenMode::Reading); |
| 352 |
std::string ret = m_inQueue; |
| 353 |
m_inQueue.clear(); |
| 354 |
return ret; |
| 355 |
} |
| 356 |
|
| 357 |
void NamedPipe::closePipe() |
| 358 |
{ |
| 359 |
if (m_handle == NULL) { |
| 360 |
return; |
| 361 |
} |
| 362 |
CancelIo(m_handle); |
| 363 |
if (m_connectEvent.get() != nullptr) { |
| 364 |
DWORD actual = 0; |
| 365 |
GetOverlappedResult(m_handle, &m_connectOver, &actual, TRUE); |
| 366 |
m_connectEvent.dispose(); |
| 367 |
} |
| 368 |
if (m_inputWorker) { |
| 369 |
m_inputWorker->waitForCanceledIo(); |
| 370 |
m_inputWorker.reset(); |
| 371 |
} |
| 372 |
if (m_outputWorker) { |
| 373 |
m_outputWorker->waitForCanceledIo(); |
| 374 |
m_outputWorker.reset(); |
| 375 |
} |
| 376 |
CloseHandle(m_handle); |
| 377 |
m_handle = NULL; |
| 378 |
} |