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.
5 #include "base/sync_socket.h"
10 #include "base/logging.h"
11 #include "base/rand_util.h"
12 #include "base/stl_util.h"
13 #include "base/threading/scoped_blocking_call.h"
14 #include "base/win/scoped_handle.h"
18 using win::ScopedHandle;
21 // IMPORTANT: do not change how this name is generated because it will break
22 // in sandboxed scenarios as we might have by-name policies that allow pipe
23 // creation. Also keep the secure random number generation.
24 const wchar_t kPipeNameFormat[] = L"\\\\.\\pipe\\chrome.sync.%u.%u.%lu";
25 const size_t kPipePathMax = base::size(kPipeNameFormat) + (3 * 10) + 1;
27 // To avoid users sending negative message lengths to Send/Receive
28 // we clamp message lengths, which are size_t, to no more than INT_MAX.
29 const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX);
31 const int kOutBufferSize = 4096;
32 const int kInBufferSize = 4096;
33 const int kDefaultTimeoutMilliSeconds = 1000;
35 bool CreatePairImpl(HANDLE* socket_a, HANDLE* socket_b, bool overlapped) {
36 DCHECK_NE(socket_a, socket_b);
37 DCHECK_EQ(*socket_a, SyncSocket::kInvalidHandle);
38 DCHECK_EQ(*socket_b, SyncSocket::kInvalidHandle);
40 wchar_t name[kPipePathMax];
41 ScopedHandle handle_a;
42 DWORD flags = PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE;
44 flags |= FILE_FLAG_OVERLAPPED;
47 unsigned long rnd_name;
48 RandBytes(&rnd_name, sizeof(rnd_name));
50 swprintf(name, kPipePathMax,
52 GetCurrentProcessId(),
56 handle_a.Set(CreateNamedPipeW(
59 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
63 kDefaultTimeoutMilliSeconds,
65 } while (!handle_a.IsValid() &&
66 (GetLastError() == ERROR_PIPE_BUSY));
68 if (!handle_a.IsValid()) {
73 // The SECURITY_ANONYMOUS flag means that the server side (handle_a) cannot
74 // impersonate the client (handle_b). This allows us not to care which side
75 // ends up in which side of a privilege boundary.
76 flags = SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS;
78 flags |= FILE_FLAG_OVERLAPPED;
80 ScopedHandle handle_b(CreateFileW(name,
81 GENERIC_READ | GENERIC_WRITE,
83 NULL, // default security attributes.
84 OPEN_EXISTING, // opens existing pipe.
86 NULL)); // no template file.
87 if (!handle_b.IsValid()) {
88 DPLOG(ERROR) << "CreateFileW failed";
92 if (!ConnectNamedPipe(handle_a.Get(), NULL)) {
93 DWORD error = GetLastError();
94 if (error != ERROR_PIPE_CONNECTED) {
95 DPLOG(ERROR) << "ConnectNamedPipe failed";
100 *socket_a = handle_a.Take();
101 *socket_b = handle_b.Take();
106 // Inline helper to avoid having the cast everywhere.
107 DWORD GetNextChunkSize(size_t current_pos, size_t max_size) {
108 // The following statement is for 64 bit portability.
109 return static_cast<DWORD>(((max_size - current_pos) <= UINT_MAX) ?
110 (max_size - current_pos) : UINT_MAX);
113 // Template function that supports calling ReadFile or WriteFile in an
114 // overlapped fashion and waits for IO completion. The function also waits
115 // on an event that can be used to cancel the operation. If the operation
116 // is cancelled, the function returns and closes the relevant socket object.
117 template <typename BufferType, typename Function>
118 size_t CancelableFileOperation(Function operation,
122 WaitableEvent* io_event,
123 WaitableEvent* cancel_event,
124 CancelableSyncSocket* socket,
125 DWORD timeout_in_ms) {
126 ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
127 // The buffer must be byte size or the length check won't make much sense.
128 static_assert(sizeof(buffer[0]) == sizeof(char), "incorrect buffer type");
129 DCHECK_GT(length, 0u);
130 DCHECK_LE(length, kMaxMessageLength);
131 DCHECK_NE(file, SyncSocket::kInvalidHandle);
133 // Track the finish time so we can calculate the timeout as data is read.
134 TimeTicks current_time, finish_time;
135 if (timeout_in_ms != INFINITE) {
136 current_time = TimeTicks::Now();
138 current_time + base::TimeDelta::FromMilliseconds(timeout_in_ms);
143 // The OVERLAPPED structure will be modified by ReadFile or WriteFile.
144 OVERLAPPED ol = { 0 };
145 ol.hEvent = io_event->handle();
147 const DWORD chunk = GetNextChunkSize(count, length);
148 // This is either the ReadFile or WriteFile call depending on whether
149 // we're receiving or sending data.
151 const BOOL operation_ok = operation(
152 file, static_cast<BufferType*>(buffer) + count, chunk, &len, &ol);
154 if (::GetLastError() == ERROR_IO_PENDING) {
155 HANDLE events[] = { io_event->handle(), cancel_event->handle() };
156 const int wait_result = WaitForMultipleObjects(
157 base::size(events), events, FALSE,
158 timeout_in_ms == INFINITE
160 : static_cast<DWORD>(
161 (finish_time - current_time).InMilliseconds()));
162 if (wait_result != WAIT_OBJECT_0 + 0) {
163 // CancelIo() doesn't synchronously cancel outstanding IO, only marks
164 // outstanding IO for cancellation. We must call GetOverlappedResult()
165 // below to ensure in flight writes complete before returning.
169 // We set the |bWait| parameter to TRUE for GetOverlappedResult() to
170 // ensure writes are complete before returning.
171 if (!GetOverlappedResult(file, &ol, &len, TRUE))
174 if (wait_result == WAIT_OBJECT_0 + 1) {
175 DVLOG(1) << "Shutdown was signaled. Closing socket.";
180 // Timeouts will be handled by the while() condition below since
181 // GetOverlappedResult() may complete successfully after CancelIo().
182 DCHECK(wait_result == WAIT_OBJECT_0 + 0 || wait_result == WAIT_TIMEOUT);
190 // Quit the operation if we can't write/read anymore.
194 // Since TimeTicks::Now() is expensive, only bother updating the time if we
195 // have more work to do.
196 if (timeout_in_ms != INFINITE && count < length)
197 current_time = base::TimeTicks::Now();
198 } while (count < length &&
199 (timeout_in_ms == INFINITE || current_time < finish_time));
206 #if defined(COMPONENT_BUILD)
207 const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE;
210 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {}
212 SyncSocket::~SyncSocket() {
217 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
218 return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, false);
222 SyncSocket::Handle SyncSocket::UnwrapHandle(
223 const TransitDescriptor& descriptor) {
227 bool SyncSocket::PrepareTransitDescriptor(ProcessHandle peer_process_handle,
228 TransitDescriptor* descriptor) {
230 if (!::DuplicateHandle(GetCurrentProcess(), handle(), peer_process_handle,
231 descriptor, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
232 DPLOG(ERROR) << "Cannot duplicate socket handle for peer process.";
238 bool SyncSocket::Close() {
239 if (handle_ == kInvalidHandle)
242 const BOOL result = CloseHandle(handle_);
243 handle_ = kInvalidHandle;
244 return result == TRUE;
247 size_t SyncSocket::Send(const void* buffer, size_t length) {
248 ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
249 DCHECK_GT(length, 0u);
250 DCHECK_LE(length, kMaxMessageLength);
251 DCHECK_NE(handle_, kInvalidHandle);
253 while (count < length) {
255 DWORD chunk = GetNextChunkSize(count, length);
256 if (::WriteFile(handle_, static_cast<const char*>(buffer) + count, chunk,
257 &len, NULL) == FALSE) {
265 size_t SyncSocket::ReceiveWithTimeout(void* buffer,
272 size_t SyncSocket::Receive(void* buffer, size_t length) {
273 ScopedBlockingCall scoped_blocking_call(BlockingType::MAY_BLOCK);
274 DCHECK_GT(length, 0u);
275 DCHECK_LE(length, kMaxMessageLength);
276 DCHECK_NE(handle_, kInvalidHandle);
278 while (count < length) {
280 DWORD chunk = GetNextChunkSize(count, length);
281 if (::ReadFile(handle_, static_cast<char*>(buffer) + count, chunk, &len,
290 size_t SyncSocket::Peek() {
292 PeekNamedPipe(handle_, NULL, 0, NULL, &available, NULL);
296 SyncSocket::Handle SyncSocket::Release() {
298 handle_ = kInvalidHandle;
302 CancelableSyncSocket::CancelableSyncSocket()
303 : shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL,
304 base::WaitableEvent::InitialState::NOT_SIGNALED),
305 file_operation_(base::WaitableEvent::ResetPolicy::MANUAL,
306 base::WaitableEvent::InitialState::NOT_SIGNALED) {}
308 CancelableSyncSocket::CancelableSyncSocket(Handle handle)
309 : SyncSocket(handle),
310 shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL,
311 base::WaitableEvent::InitialState::NOT_SIGNALED),
312 file_operation_(base::WaitableEvent::ResetPolicy::MANUAL,
313 base::WaitableEvent::InitialState::NOT_SIGNALED) {}
315 bool CancelableSyncSocket::Shutdown() {
316 // This doesn't shut down the pipe immediately, but subsequent Receive or Send
317 // methods will fail straight away.
318 shutdown_event_.Signal();
322 bool CancelableSyncSocket::Close() {
323 const bool result = SyncSocket::Close();
324 shutdown_event_.Reset();
328 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) {
329 static const DWORD kWaitTimeOutInMs = 500;
330 return CancelableFileOperation(
331 &::WriteFile, handle_, reinterpret_cast<const char*>(buffer), length,
332 &file_operation_, &shutdown_event_, this, kWaitTimeOutInMs);
335 size_t CancelableSyncSocket::Receive(void* buffer, size_t length) {
336 return CancelableFileOperation(
337 &::ReadFile, handle_, reinterpret_cast<char*>(buffer), length,
338 &file_operation_, &shutdown_event_, this, INFINITE);
341 size_t CancelableSyncSocket::ReceiveWithTimeout(void* buffer,
344 return CancelableFileOperation(&::ReadFile, handle_,
345 reinterpret_cast<char*>(buffer), length,
346 &file_operation_, &shutdown_event_, this,
347 static_cast<DWORD>(timeout.InMilliseconds()));
351 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
352 CancelableSyncSocket* socket_b) {
353 return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, true);