OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/sync_socket.h" | 5 #include "base/sync_socket.h" |
6 #include <limits.h> | 6 |
7 #include <stdio.h> | |
8 #include <windows.h> | |
9 #include <sys/types.h> | |
10 #include "base/logging.h" | 7 #include "base/logging.h" |
| 8 #include "base/win/scoped_handle.h" |
11 | 9 |
12 namespace base { | 10 namespace base { |
13 | 11 |
| 12 using win::ScopedHandle; |
| 13 |
14 namespace { | 14 namespace { |
15 // IMPORTANT: do not change how this name is generated because it will break | 15 // IMPORTANT: do not change how this name is generated because it will break |
16 // in sandboxed scenarios as we might have by-name policies that allow pipe | 16 // in sandboxed scenarios as we might have by-name policies that allow pipe |
17 // creation. Also keep the secure random number generation. | 17 // creation. Also keep the secure random number generation. |
18 const wchar_t kPipeNameFormat[] = L"\\\\.\\pipe\\chrome.sync.%u.%u.%lu"; | 18 const wchar_t kPipeNameFormat[] = L"\\\\.\\pipe\\chrome.sync.%u.%u.%lu"; |
19 const size_t kPipePathMax = arraysize(kPipeNameFormat) + (3 * 10) + 1; | 19 const size_t kPipePathMax = arraysize(kPipeNameFormat) + (3 * 10) + 1; |
20 | 20 |
21 // To avoid users sending negative message lengths to Send/Receive | 21 // To avoid users sending negative message lengths to Send/Receive |
22 // we clamp message lengths, which are size_t, to no more than INT_MAX. | 22 // we clamp message lengths, which are size_t, to no more than INT_MAX. |
23 const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX); | 23 const size_t kMaxMessageLength = static_cast<size_t>(INT_MAX); |
24 | 24 |
25 const int kOutBufferSize = 4096; | 25 const int kOutBufferSize = 4096; |
26 const int kInBufferSize = 4096; | 26 const int kInBufferSize = 4096; |
27 const int kDefaultTimeoutMilliSeconds = 1000; | 27 const int kDefaultTimeoutMilliSeconds = 1000; |
28 | 28 |
| 29 bool CreatePairImpl(HANDLE* socket_a, HANDLE* socket_b, bool overlapped) { |
| 30 DCHECK(socket_a != socket_b); |
| 31 DCHECK(*socket_a == SyncSocket::kInvalidHandle); |
| 32 DCHECK(*socket_b == SyncSocket::kInvalidHandle); |
| 33 |
| 34 wchar_t name[kPipePathMax]; |
| 35 ScopedHandle handle_a; |
| 36 DWORD flags = PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE; |
| 37 if (overlapped) |
| 38 flags |= FILE_FLAG_OVERLAPPED; |
| 39 |
| 40 do { |
| 41 unsigned int rnd_name; |
| 42 if (rand_s(&rnd_name) != 0) |
| 43 return false; |
| 44 |
| 45 swprintf(name, kPipePathMax, |
| 46 kPipeNameFormat, |
| 47 GetCurrentProcessId(), |
| 48 GetCurrentThreadId(), |
| 49 rnd_name); |
| 50 |
| 51 handle_a.Set(CreateNamedPipeW( |
| 52 name, |
| 53 flags, |
| 54 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, |
| 55 1, |
| 56 kOutBufferSize, |
| 57 kInBufferSize, |
| 58 kDefaultTimeoutMilliSeconds, |
| 59 NULL)); |
| 60 } while (!handle_a.IsValid() && |
| 61 (GetLastError() == ERROR_PIPE_BUSY)); |
| 62 |
| 63 if (!handle_a.IsValid()) { |
| 64 NOTREACHED(); |
| 65 return false; |
| 66 } |
| 67 |
| 68 // The SECURITY_ANONYMOUS flag means that the server side (handle_a) cannot |
| 69 // impersonate the client (handle_b). This allows us not to care which side |
| 70 // ends up in which side of a privilege boundary. |
| 71 flags = SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS; |
| 72 if (overlapped) |
| 73 flags |= FILE_FLAG_OVERLAPPED; |
| 74 |
| 75 ScopedHandle handle_b(CreateFileW(name, |
| 76 GENERIC_READ | GENERIC_WRITE, |
| 77 0, // no sharing. |
| 78 NULL, // default security attributes. |
| 79 OPEN_EXISTING, // opens existing pipe. |
| 80 flags, |
| 81 NULL)); // no template file. |
| 82 if (!handle_b.IsValid()) { |
| 83 DPLOG(ERROR) << "CreateFileW failed"; |
| 84 return false; |
| 85 } |
| 86 |
| 87 if (!ConnectNamedPipe(handle_a, NULL)) { |
| 88 DWORD error = GetLastError(); |
| 89 if (error != ERROR_PIPE_CONNECTED) { |
| 90 DPLOG(ERROR) << "ConnectNamedPipe failed"; |
| 91 return false; |
| 92 } |
| 93 } |
| 94 |
| 95 *socket_a = handle_a.Take(); |
| 96 *socket_b = handle_b.Take(); |
| 97 |
| 98 return true; |
| 99 } |
| 100 |
| 101 // Inline helper to avoid having the cast everywhere. |
| 102 DWORD GetNextChunkSize(size_t current_pos, size_t max_size) { |
| 103 // The following statement is for 64 bit portability. |
| 104 return static_cast<DWORD>(((max_size - current_pos) <= UINT_MAX) ? |
| 105 (max_size - current_pos) : UINT_MAX); |
| 106 } |
| 107 |
| 108 // Template function that supports calling ReadFile or WriteFile in an |
| 109 // overlapped fashion and waits for IO completion. The function also waits |
| 110 // on an event that can be used to cancel the operation. If the operation |
| 111 // is cancelled, the function returns and closes the relevant socket object. |
| 112 template <typename BufferType, typename Function> |
| 113 size_t CancelableFileOperation(Function operation, HANDLE file, |
| 114 BufferType* buffer, size_t length, |
| 115 base::WaitableEvent* io_event, |
| 116 base::WaitableEvent* cancel_event, |
| 117 CancelableSyncSocket* socket) { |
| 118 // The buffer must be byte size or the length check won't make much sense. |
| 119 COMPILE_ASSERT(sizeof(buffer[0]) == sizeof(char), incorrect_buffer_type); |
| 120 DCHECK_LE(length, kMaxMessageLength); |
| 121 |
| 122 OVERLAPPED ol = {0}; |
| 123 ol.hEvent = io_event->handle(); |
| 124 size_t count = 0; |
| 125 while (count < length) { |
| 126 DWORD chunk = GetNextChunkSize(count, length); |
| 127 // This is either the ReadFile or WriteFile call depending on whether |
| 128 // we're receiving or sending data. |
| 129 DWORD len; |
| 130 BOOL ok = operation(file, static_cast<BufferType*>(buffer) + count, chunk, |
| 131 &len, &ol); |
| 132 if (!ok) { |
| 133 if (::GetLastError() == ERROR_IO_PENDING) { |
| 134 base::WaitableEvent* events[] = { io_event, cancel_event }; |
| 135 size_t signaled = WaitableEvent::WaitMany(events, arraysize(events)); |
| 136 if (signaled == 1) { |
| 137 VLOG(1) << "Shutdown was signaled. Closing socket."; |
| 138 socket->Close(); |
| 139 break; |
| 140 } else { |
| 141 GetOverlappedResult(file, &ol, &len, TRUE); |
| 142 } |
| 143 } else { |
| 144 return (0 < count) ? count : 0; |
| 145 } |
| 146 } |
| 147 count += len; |
| 148 } |
| 149 return count; |
| 150 } |
| 151 |
29 } // namespace | 152 } // namespace |
30 | 153 |
31 const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE; | 154 const SyncSocket::Handle SyncSocket::kInvalidHandle = INVALID_HANDLE_VALUE; |
32 | 155 |
33 bool SyncSocket::CreatePair(SyncSocket* pair[2]) { | 156 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {} |
34 Handle handles[2]; | |
35 SyncSocket* tmp_sockets[2]; | |
36 | 157 |
37 // Create the two SyncSocket objects first to avoid ugly cleanup issues. | 158 SyncSocket::~SyncSocket() { |
38 tmp_sockets[0] = new SyncSocket(kInvalidHandle); | 159 Close(); |
39 if (tmp_sockets[0] == NULL) { | 160 } |
40 return false; | |
41 } | |
42 tmp_sockets[1] = new SyncSocket(kInvalidHandle); | |
43 if (tmp_sockets[1] == NULL) { | |
44 delete tmp_sockets[0]; | |
45 return false; | |
46 } | |
47 | 161 |
48 wchar_t name[kPipePathMax]; | 162 // static |
49 do { | 163 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) { |
50 unsigned int rnd_name; | 164 return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, false); |
51 if (rand_s(&rnd_name) != 0) | |
52 return false; | |
53 swprintf(name, kPipePathMax, | |
54 kPipeNameFormat, | |
55 GetCurrentProcessId(), | |
56 GetCurrentThreadId(), | |
57 rnd_name); | |
58 handles[0] = CreateNamedPipeW( | |
59 name, | |
60 PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE, | |
61 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, | |
62 1, | |
63 kOutBufferSize, | |
64 kInBufferSize, | |
65 kDefaultTimeoutMilliSeconds, | |
66 NULL); | |
67 } while ((handles[0] == INVALID_HANDLE_VALUE) && | |
68 (GetLastError() == ERROR_PIPE_BUSY)); | |
69 | |
70 if (handles[0] == INVALID_HANDLE_VALUE) { | |
71 NOTREACHED(); | |
72 return false; | |
73 } | |
74 // The SECURITY_ANONYMOUS flag means that the server side (pair[0]) cannot | |
75 // impersonate the client (pair[1]). This allows us not to care which side | |
76 // ends up in which side of a privilege boundary. | |
77 handles[1] = CreateFileW(name, | |
78 GENERIC_READ | GENERIC_WRITE, | |
79 0, // no sharing. | |
80 NULL, // default security attributes. | |
81 OPEN_EXISTING, // opens existing pipe. | |
82 SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS, | |
83 NULL); // no template file. | |
84 if (handles[1] == INVALID_HANDLE_VALUE) { | |
85 CloseHandle(handles[0]); | |
86 return false; | |
87 } | |
88 if (ConnectNamedPipe(handles[0], NULL) == FALSE) { | |
89 DWORD error = GetLastError(); | |
90 if (error != ERROR_PIPE_CONNECTED) { | |
91 CloseHandle(handles[0]); | |
92 CloseHandle(handles[1]); | |
93 return false; | |
94 } | |
95 } | |
96 // Copy the handles out for successful return. | |
97 tmp_sockets[0]->handle_ = handles[0]; | |
98 pair[0] = tmp_sockets[0]; | |
99 tmp_sockets[1]->handle_ = handles[1]; | |
100 pair[1] = tmp_sockets[1]; | |
101 return true; | |
102 } | 165 } |
103 | 166 |
104 bool SyncSocket::Close() { | 167 bool SyncSocket::Close() { |
105 if (handle_ == kInvalidHandle) { | 168 if (handle_ == kInvalidHandle) |
106 return false; | 169 return false; |
107 } | 170 |
108 BOOL retval = CloseHandle(handle_); | 171 BOOL retval = CloseHandle(handle_); |
109 handle_ = kInvalidHandle; | 172 handle_ = kInvalidHandle; |
110 return retval ? true : false; | 173 return retval ? true : false; |
111 } | 174 } |
112 | 175 |
113 size_t SyncSocket::Send(const void* buffer, size_t length) { | 176 size_t SyncSocket::Send(const void* buffer, size_t length) { |
114 DCHECK_LE(length, kMaxMessageLength); | 177 DCHECK_LE(length, kMaxMessageLength); |
115 size_t count = 0; | 178 size_t count = 0; |
116 while (count < length) { | 179 while (count < length) { |
117 DWORD len; | 180 DWORD len; |
118 // The following statement is for 64 bit portability. | 181 DWORD chunk = GetNextChunkSize(count, length); |
119 DWORD chunk = static_cast<DWORD>( | |
120 ((length - count) <= UINT_MAX) ? (length - count) : UINT_MAX); | |
121 if (WriteFile(handle_, static_cast<const char*>(buffer) + count, | 182 if (WriteFile(handle_, static_cast<const char*>(buffer) + count, |
122 chunk, &len, NULL) == FALSE) { | 183 chunk, &len, NULL) == FALSE) { |
123 return (0 < count) ? count : 0; | 184 return (0 < count) ? count : 0; |
124 } | 185 } |
125 count += len; | 186 count += len; |
126 } | 187 } |
127 return count; | 188 return count; |
128 } | 189 } |
129 | 190 |
130 size_t SyncSocket::Receive(void* buffer, size_t length) { | 191 size_t SyncSocket::Receive(void* buffer, size_t length) { |
131 DCHECK_LE(length, kMaxMessageLength); | 192 DCHECK_LE(length, kMaxMessageLength); |
132 size_t count = 0; | 193 size_t count = 0; |
133 while (count < length) { | 194 while (count < length) { |
134 DWORD len; | 195 DWORD len; |
135 DWORD chunk = static_cast<DWORD>( | 196 DWORD chunk = GetNextChunkSize(count, length); |
136 ((length - count) <= UINT_MAX) ? (length - count) : UINT_MAX); | |
137 if (ReadFile(handle_, static_cast<char*>(buffer) + count, | 197 if (ReadFile(handle_, static_cast<char*>(buffer) + count, |
138 chunk, &len, NULL) == FALSE) { | 198 chunk, &len, NULL) == FALSE) { |
139 return (0 < count) ? count : 0; | 199 return (0 < count) ? count : 0; |
140 } | 200 } |
141 count += len; | 201 count += len; |
142 } | 202 } |
143 return count; | 203 return count; |
144 } | 204 } |
145 | 205 |
146 size_t SyncSocket::Peek() { | 206 size_t SyncSocket::Peek() { |
147 DWORD available = 0; | 207 DWORD available = 0; |
148 PeekNamedPipe(handle_, NULL, 0, NULL, &available, NULL); | 208 PeekNamedPipe(handle_, NULL, 0, NULL, &available, NULL); |
149 return available; | 209 return available; |
150 } | 210 } |
151 | 211 |
| 212 CancelableSyncSocket::CancelableSyncSocket() |
| 213 : shutdown_event_(true, false), file_operation_(true, false) { |
| 214 } |
| 215 |
| 216 CancelableSyncSocket::CancelableSyncSocket(Handle handle) |
| 217 : SyncSocket(handle), shutdown_event_(true, false), |
| 218 file_operation_(true, false) { |
| 219 } |
| 220 |
| 221 bool CancelableSyncSocket::Shutdown() { |
| 222 // This doesn't shut down the pipe immediately, but subsequent Receive or Send |
| 223 // methods will fail straight away. |
| 224 shutdown_event_.Signal(); |
| 225 return true; |
| 226 } |
| 227 |
| 228 bool CancelableSyncSocket::Close() { |
| 229 bool ret = SyncSocket::Close(); |
| 230 shutdown_event_.Reset(); |
| 231 return ret; |
| 232 } |
| 233 |
| 234 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) { |
| 235 return CancelableFileOperation(&WriteFile, handle_, |
| 236 reinterpret_cast<const char*>(buffer), length, &file_operation_, |
| 237 &shutdown_event_, this); |
| 238 } |
| 239 |
| 240 size_t CancelableSyncSocket::Receive(void* buffer, size_t length) { |
| 241 return CancelableFileOperation(&ReadFile, handle_, |
| 242 reinterpret_cast<char*>(buffer), length, &file_operation_, |
| 243 &shutdown_event_, this); |
| 244 } |
| 245 |
| 246 // static |
| 247 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a, |
| 248 CancelableSyncSocket* socket_b) { |
| 249 return CreatePairImpl(&socket_a->handle_, &socket_b->handle_, true); |
| 250 } |
| 251 |
| 252 |
152 } // namespace base | 253 } // namespace base |
OLD | NEW |