| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/sync_socket.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/threading/thread_restrictions.h" | |
| 9 #include "base/win/scoped_handle.h" | |
| 10 | |
| 11 namespace base { | |
| 12 | |
| 13 using win::ScopedHandle; | |
| 14 | |
| 15 namespace { | |
| 16 // IMPORTANT: do not change how this name is generated because it will break | |
| 17 // in sandboxed scenarios as we might have by-name policies that allow pipe | |
| 18 // creation. Also keep the secure random number generation. | |
| 19 const wchar_t kPipeNameFormat[] = L"\\\\.\\pipe\\chrome.sync.%u.%u.%lu"; | |
| 20 const size_t kPipePathMax = arraysize(kPipeNameFormat) + (3 * 10) + 1; | |
| 21 | |
| 22 // To avoid users sending negative message lengths to Send/Receive | |
| 23 // we clamp message lengths, which are size_t, to no more than INT_MAX. | |
| 24 const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX); | |
| 25 | |
| 26 const int kOutBufferSize = 4096; | |
| 27 const int kInBufferSize = 4096; | |
| 28 const int kDefaultTimeoutMilliSeconds = 1000; | |
| 29 | |
| 30 bool CreatePairImpl(HANDLE* socket_a, HANDLE* socket_b, bool overlapped) { | |
| 31 DCHECK_NE(socket_a, socket_b); | |
| 32 DCHECK_EQ(*socket_a, SyncSocket::kInvalidHandle); | |
| 33 DCHECK_EQ(*socket_b, SyncSocket::kInvalidHandle); | |
| 34 | |
| 35 wchar_t name[kPipePathMax]; | |
| 36 ScopedHandle handle_a; | |
| 37 DWORD flags = PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE; | |
| 38 if (overlapped) | |
| 39 flags |= FILE_FLAG_OVERLAPPED; | |
| 40 | |
| 41 do { | |
| 42 unsigned int rnd_name; | |
| 43 if (rand_s(&rnd_name) != 0) | |
| 44 return false; | |
| 45 | |
| 46 swprintf(name, kPipePathMax, | |
| 47 kPipeNameFormat, | |
| 48 GetCurrentProcessId(), | |
| 49 GetCurrentThreadId(), | |
| 50 rnd_name); | |
| 51 | |
| 52 handle_a.Set(CreateNamedPipeW( | |
| 53 name, | |
| 54 flags, | |
| 55 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, | |
| 56 1, | |
| 57 kOutBufferSize, | |
| 58 kInBufferSize, | |
| 59 kDefaultTimeoutMilliSeconds, | |
| 60 NULL)); | |
| 61 } while (!handle_a.IsValid() && | |
| 62 (GetLastError() == ERROR_PIPE_BUSY)); | |
| 63 | |
| 64 if (!handle_a.IsValid()) { | |
| 65 NOTREACHED(); | |
| 66 return false; | |
| 67 } | |
| 68 | |
| 69 // The SECURITY_ANONYMOUS flag means that the server side (handle_a) cannot | |
| 70 // impersonate the client (handle_b). This allows us not to care which side | |
| 71 // ends up in which side of a privilege boundary. | |
| 72 flags = SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS; | |
| 73 if (overlapped) | |
| 74 flags |= FILE_FLAG_OVERLAPPED; | |
| 75 | |
| 76 ScopedHandle handle_b(CreateFileW(name, | |
| 77 GENERIC_READ | GENERIC_WRITE, | |
| 78 0, // no sharing. | |
| 79 NULL, // default security attributes. | |
| 80 OPEN_EXISTING, // opens existing pipe. | |
| 81 flags, | |
| 82 NULL)); // no template file. | |
| 83 if (!handle_b.IsValid()) { | |
| 84 DPLOG(ERROR) << "CreateFileW failed"; | |
| 85 return false; | |
| 86 } | |
| 87 | |
| 88 if (!ConnectNamedPipe(handle_a.Get(), NULL)) { | |
| 89 DWORD error = GetLastError(); | |
| 90 if (error != ERROR_PIPE_CONNECTED) { | |
| 91 DPLOG(ERROR) << "ConnectNamedPipe failed"; | |
| 92 return false; | |
| 93 } | |
| 94 } | |
| 95 | |
| 96 *socket_a = handle_a.Take(); | |
| 97 *socket_b = handle_b.Take(); | |
| 98 | |
| 99 return true; | |
| 100 } | |
| 101 | |
| 102 // Inline helper to avoid having the cast everywhere. | |
| 103 DWORD GetNextChunkSize(size_t current_pos, size_t max_size) { | |
| 104 // The following statement is for 64 bit portability. | |
| 105 return static_cast<DWORD>(((max_size - current_pos) <= UINT_MAX) ? | |
| 106 (max_size - current_pos) : UINT_MAX); | |
| 107 } | |
| 108 | |
| 109 // Template function that supports calling ReadFile or WriteFile in an | |
| 110 // overlapped fashion and waits for IO completion. The function also waits | |
| 111 // on an event that can be used to cancel the operation. If the operation | |
| 112 // is cancelled, the function returns and closes the relevant socket object. | |
| 113 template <typename BufferType, typename Function> | |
| 114 size_t CancelableFileOperation(Function operation, | |
| 115 HANDLE file, | |
| 116 BufferType* buffer, | |
| 117 size_t length, | |
| 118 WaitableEvent* io_event, | |
| 119 WaitableEvent* cancel_event, | |
| 120 CancelableSyncSocket* socket, | |
| 121 DWORD timeout_in_ms) { | |
| 122 ThreadRestrictions::AssertIOAllowed(); | |
| 123 // The buffer must be byte size or the length check won't make much sense. | |
| 124 COMPILE_ASSERT(sizeof(buffer[0]) == sizeof(char), incorrect_buffer_type); | |
| 125 DCHECK_GT(length, 0u); | |
| 126 DCHECK_LE(length, kMaxMessageLength); | |
| 127 DCHECK_NE(file, SyncSocket::kInvalidHandle); | |
| 128 | |
| 129 // Track the finish time so we can calculate the timeout as data is read. | |
| 130 TimeTicks current_time, finish_time; | |
| 131 if (timeout_in_ms != INFINITE) { | |
| 132 current_time = TimeTicks::Now(); | |
| 133 finish_time = | |
| 134 current_time + base::TimeDelta::FromMilliseconds(timeout_in_ms); | |
| 135 } | |
| 136 | |
| 137 size_t count = 0; | |
| 138 do { | |
| 139 // The OVERLAPPED structure will be modified by ReadFile or WriteFile. | |
| 140 OVERLAPPED ol = { 0 }; | |
| 141 ol.hEvent = io_event->handle(); | |
| 142 | |
| 143 const DWORD chunk = GetNextChunkSize(count, length); | |
| 144 // This is either the ReadFile or WriteFile call depending on whether | |
| 145 // we're receiving or sending data. | |
| 146 DWORD len = 0; | |
| 147 const BOOL operation_ok = operation( | |
| 148 file, static_cast<BufferType*>(buffer) + count, chunk, &len, &ol); | |
| 149 if (!operation_ok) { | |
| 150 if (::GetLastError() == ERROR_IO_PENDING) { | |
| 151 HANDLE events[] = { io_event->handle(), cancel_event->handle() }; | |
| 152 const int wait_result = WaitForMultipleObjects( | |
| 153 arraysize(events), events, FALSE, | |
| 154 timeout_in_ms == INFINITE ? | |
| 155 timeout_in_ms : | |
| 156 static_cast<DWORD>( | |
| 157 (finish_time - current_time).InMilliseconds())); | |
| 158 if (wait_result != WAIT_OBJECT_0 + 0) { | |
| 159 // CancelIo() doesn't synchronously cancel outstanding IO, only marks | |
| 160 // outstanding IO for cancellation. We must call GetOverlappedResult() | |
| 161 // below to ensure in flight writes complete before returning. | |
| 162 CancelIo(file); | |
| 163 } | |
| 164 | |
| 165 // We set the |bWait| parameter to TRUE for GetOverlappedResult() to | |
| 166 // ensure writes are complete before returning. | |
| 167 if (!GetOverlappedResult(file, &ol, &len, TRUE)) | |
| 168 len = 0; | |
| 169 | |
| 170 if (wait_result == WAIT_OBJECT_0 + 1) { | |
| 171 DVLOG(1) << "Shutdown was signaled. Closing socket."; | |
| 172 socket->Close(); | |
| 173 return count; | |
| 174 } | |
| 175 | |
| 176 // Timeouts will be handled by the while() condition below since | |
| 177 // GetOverlappedResult() may complete successfully after CancelIo(). | |
| 178 DCHECK(wait_result == WAIT_OBJECT_0 + 0 || wait_result == WAIT_TIMEOUT); | |
| 179 } else { | |
| 180 break; | |
| 181 } | |
| 182 } | |
| 183 | |
| 184 count += len; | |
| 185 | |
| 186 // Quit the operation if we can't write/read anymore. | |
| 187 if (len != chunk) | |
| 188 break; | |
| 189 | |
| 190 // Since TimeTicks::Now() is expensive, only bother updating the time if we | |
| 191 // have more work to do. | |
| 192 if (timeout_in_ms != INFINITE && count < length) | |
| 193 current_time = base::TimeTicks::Now(); | |
| 194 } while (count < length && | |
| 195 (timeout_in_ms == INFINITE || current_time < finish_time)); | |
| 196 | |
| 197 return count; | |
| 198 } | |
| 199 | |
| 200 } // namespace | |
| 201 | |
| 202 #if defined(COMPONENT_BUILD) | |
| 203 const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE; | |
| 204 #endif | |
| 205 | |
| 206 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {} | |
| 207 | |
| 208 SyncSocket::~SyncSocket() { | |
| 209 Close(); | |
| 210 } | |
| 211 | |
| 212 // static | |
| 213 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) { | |
| 214 return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, false); | |
| 215 } | |
| 216 | |
| 217 // static | |
| 218 SyncSocket::Handle SyncSocket::UnwrapHandle( | |
| 219 const TransitDescriptor& descriptor) { | |
| 220 return descriptor; | |
| 221 } | |
| 222 | |
| 223 bool SyncSocket::PrepareTransitDescriptor(ProcessHandle peer_process_handle, | |
| 224 TransitDescriptor* descriptor) { | |
| 225 DCHECK(descriptor); | |
| 226 if (!::DuplicateHandle(GetCurrentProcess(), handle(), peer_process_handle, | |
| 227 descriptor, 0, FALSE, DUPLICATE_SAME_ACCESS)) { | |
| 228 DPLOG(ERROR) << "Cannot duplicate socket handle for peer process."; | |
| 229 return false; | |
| 230 } | |
| 231 return true; | |
| 232 } | |
| 233 | |
| 234 bool SyncSocket::Close() { | |
| 235 if (handle_ == kInvalidHandle) | |
| 236 return true; | |
| 237 | |
| 238 const BOOL result = CloseHandle(handle_); | |
| 239 handle_ = kInvalidHandle; | |
| 240 return result == TRUE; | |
| 241 } | |
| 242 | |
| 243 size_t SyncSocket::Send(const void* buffer, size_t length) { | |
| 244 ThreadRestrictions::AssertIOAllowed(); | |
| 245 DCHECK_GT(length, 0u); | |
| 246 DCHECK_LE(length, kMaxMessageLength); | |
| 247 DCHECK_NE(handle_, kInvalidHandle); | |
| 248 size_t count = 0; | |
| 249 while (count < length) { | |
| 250 DWORD len; | |
| 251 DWORD chunk = GetNextChunkSize(count, length); | |
| 252 if (WriteFile(handle_, static_cast<const char*>(buffer) + count, | |
| 253 chunk, &len, NULL) == FALSE) { | |
| 254 return count; | |
| 255 } | |
| 256 count += len; | |
| 257 } | |
| 258 return count; | |
| 259 } | |
| 260 | |
| 261 size_t SyncSocket::ReceiveWithTimeout(void* buffer, | |
| 262 size_t length, | |
| 263 TimeDelta timeout) { | |
| 264 NOTIMPLEMENTED(); | |
| 265 return 0; | |
| 266 } | |
| 267 | |
| 268 size_t SyncSocket::Receive(void* buffer, size_t length) { | |
| 269 ThreadRestrictions::AssertIOAllowed(); | |
| 270 DCHECK_GT(length, 0u); | |
| 271 DCHECK_LE(length, kMaxMessageLength); | |
| 272 DCHECK_NE(handle_, kInvalidHandle); | |
| 273 size_t count = 0; | |
| 274 while (count < length) { | |
| 275 DWORD len; | |
| 276 DWORD chunk = GetNextChunkSize(count, length); | |
| 277 if (ReadFile(handle_, static_cast<char*>(buffer) + count, | |
| 278 chunk, &len, NULL) == FALSE) { | |
| 279 return count; | |
| 280 } | |
| 281 count += len; | |
| 282 } | |
| 283 return count; | |
| 284 } | |
| 285 | |
| 286 size_t SyncSocket::Peek() { | |
| 287 DWORD available = 0; | |
| 288 PeekNamedPipe(handle_, NULL, 0, NULL, &available, NULL); | |
| 289 return available; | |
| 290 } | |
| 291 | |
| 292 CancelableSyncSocket::CancelableSyncSocket() | |
| 293 : shutdown_event_(true, false), file_operation_(true, false) { | |
| 294 } | |
| 295 | |
| 296 CancelableSyncSocket::CancelableSyncSocket(Handle handle) | |
| 297 : SyncSocket(handle), shutdown_event_(true, false), | |
| 298 file_operation_(true, false) { | |
| 299 } | |
| 300 | |
| 301 bool CancelableSyncSocket::Shutdown() { | |
| 302 // This doesn't shut down the pipe immediately, but subsequent Receive or Send | |
| 303 // methods will fail straight away. | |
| 304 shutdown_event_.Signal(); | |
| 305 return true; | |
| 306 } | |
| 307 | |
| 308 bool CancelableSyncSocket::Close() { | |
| 309 const bool result = SyncSocket::Close(); | |
| 310 shutdown_event_.Reset(); | |
| 311 return result; | |
| 312 } | |
| 313 | |
| 314 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) { | |
| 315 static const DWORD kWaitTimeOutInMs = 500; | |
| 316 return CancelableFileOperation( | |
| 317 &WriteFile, handle_, reinterpret_cast<const char*>(buffer), | |
| 318 length, &file_operation_, &shutdown_event_, this, kWaitTimeOutInMs); | |
| 319 } | |
| 320 | |
| 321 size_t CancelableSyncSocket::Receive(void* buffer, size_t length) { | |
| 322 return CancelableFileOperation( | |
| 323 &ReadFile, handle_, reinterpret_cast<char*>(buffer), length, | |
| 324 &file_operation_, &shutdown_event_, this, INFINITE); | |
| 325 } | |
| 326 | |
| 327 size_t CancelableSyncSocket::ReceiveWithTimeout(void* buffer, | |
| 328 size_t length, | |
| 329 TimeDelta timeout) { | |
| 330 return CancelableFileOperation( | |
| 331 &ReadFile, handle_, reinterpret_cast<char*>(buffer), length, | |
| 332 &file_operation_, &shutdown_event_, this, | |
| 333 static_cast<DWORD>(timeout.InMilliseconds())); | |
| 334 } | |
| 335 | |
| 336 // static | |
| 337 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a, | |
| 338 CancelableSyncSocket* socket_b) { | |
| 339 return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, true); | |
| 340 } | |
| 341 | |
| 342 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1446363003:
Deleted OS_WIN and all Windows specific files from base. (Closed)
Base URL: https://github.com/domokit/mojo.git@base_tests