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 <errno.h> | 5 #include <errno.h> |
6 #include <fcntl.h> | 6 #include <fcntl.h> |
7 #include <poll.h> | 7 #include <poll.h> |
8 #include <sys/socket.h> | 8 #include <sys/socket.h> |
9 #include <sys/stat.h> | 9 #include <sys/stat.h> |
10 #include <sys/time.h> | 10 #include <sys/time.h> |
(...skipping 12 matching lines...) Expand all Loading... |
23 #include "base/files/file_path.h" | 23 #include "base/files/file_path.h" |
24 #include "base/memory/ref_counted.h" | 24 #include "base/memory/ref_counted.h" |
25 #include "base/memory/scoped_ptr.h" | 25 #include "base/memory/scoped_ptr.h" |
26 #include "base/message_loop/message_loop.h" | 26 #include "base/message_loop/message_loop.h" |
27 #include "base/posix/eintr_wrapper.h" | 27 #include "base/posix/eintr_wrapper.h" |
28 #include "base/synchronization/condition_variable.h" | 28 #include "base/synchronization/condition_variable.h" |
29 #include "base/synchronization/lock.h" | 29 #include "base/synchronization/lock.h" |
30 #include "base/threading/platform_thread.h" | 30 #include "base/threading/platform_thread.h" |
31 #include "base/threading/thread.h" | 31 #include "base/threading/thread.h" |
32 #include "net/socket/socket_descriptor.h" | 32 #include "net/socket/socket_descriptor.h" |
33 #include "net/socket/unix_domain_socket_posix.h" | 33 #include "net/socket/unix_domain_listen_socket_posix.h" |
34 #include "testing/gtest/include/gtest/gtest.h" | 34 #include "testing/gtest/include/gtest/gtest.h" |
35 | 35 |
36 using std::queue; | 36 using std::queue; |
37 using std::string; | 37 using std::string; |
38 | 38 |
39 namespace net { | 39 namespace net { |
40 namespace { | 40 namespace { |
41 | 41 |
42 const char kSocketFilename[] = "unix_domain_socket_for_testing"; | 42 const char kSocketFilename[] = "unix_domain_socket_for_testing"; |
43 const char kInvalidSocketPath[] = "/invalid/path"; | 43 const char kInvalidSocketPath[] = "/invalid/path"; |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 }; | 144 }; |
145 | 145 |
146 bool UserCanConnectCallback( | 146 bool UserCanConnectCallback( |
147 bool allow_user, const scoped_refptr<EventManager>& event_manager, | 147 bool allow_user, const scoped_refptr<EventManager>& event_manager, |
148 uid_t, gid_t) { | 148 uid_t, gid_t) { |
149 event_manager->Notify( | 149 event_manager->Notify( |
150 allow_user ? EVENT_AUTH_GRANTED : EVENT_AUTH_DENIED); | 150 allow_user ? EVENT_AUTH_GRANTED : EVENT_AUTH_DENIED); |
151 return allow_user; | 151 return allow_user; |
152 } | 152 } |
153 | 153 |
154 class UnixDomainSocketTestHelper : public testing::Test { | 154 class UnixDomainListenSocketTestHelper : public testing::Test { |
155 public: | 155 public: |
156 void CreateAndListen() { | 156 void CreateAndListen() { |
157 socket_ = UnixDomainSocket::CreateAndListen( | 157 socket_ = UnixDomainListenSocket::CreateAndListen( |
158 file_path_.value(), socket_delegate_.get(), MakeAuthCallback()); | 158 file_path_.value(), socket_delegate_.get(), MakeAuthCallback()); |
159 socket_delegate_->OnListenCompleted(); | 159 socket_delegate_->OnListenCompleted(); |
160 } | 160 } |
161 | 161 |
162 protected: | 162 protected: |
163 UnixDomainSocketTestHelper(const string& path, bool allow_user) | 163 UnixDomainListenSocketTestHelper(const string& path, bool allow_user) |
164 : file_path_(path), | 164 : file_path_(path), |
165 allow_user_(allow_user) {} | 165 allow_user_(allow_user) {} |
166 | 166 |
167 virtual void SetUp() OVERRIDE { | 167 virtual void SetUp() OVERRIDE { |
168 event_manager_ = new EventManager(); | 168 event_manager_ = new EventManager(); |
169 socket_delegate_.reset(new TestListenSocketDelegate(event_manager_)); | 169 socket_delegate_.reset(new TestListenSocketDelegate(event_manager_)); |
170 DeleteSocketFile(); | 170 DeleteSocketFile(); |
171 } | 171 } |
172 | 172 |
173 virtual void TearDown() OVERRIDE { | 173 virtual void TearDown() OVERRIDE { |
174 DeleteSocketFile(); | 174 DeleteSocketFile(); |
175 socket_.reset(); | 175 socket_.reset(); |
176 socket_delegate_.reset(); | 176 socket_delegate_.reset(); |
177 event_manager_ = NULL; | 177 event_manager_ = NULL; |
178 } | 178 } |
179 | 179 |
180 UnixDomainSocket::AuthCallback MakeAuthCallback() { | 180 UnixDomainListenSocket::AuthCallback MakeAuthCallback() { |
181 return base::Bind(&UserCanConnectCallback, allow_user_, event_manager_); | 181 return base::Bind(&UserCanConnectCallback, allow_user_, event_manager_); |
182 } | 182 } |
183 | 183 |
184 void DeleteSocketFile() { | 184 void DeleteSocketFile() { |
185 ASSERT_FALSE(file_path_.empty()); | 185 ASSERT_FALSE(file_path_.empty()); |
186 base::DeleteFile(file_path_, false /* not recursive */); | 186 base::DeleteFile(file_path_, false /* not recursive */); |
187 } | 187 } |
188 | 188 |
189 SocketDescriptor CreateClientSocket() { | 189 SocketDescriptor CreateClientSocket() { |
190 const SocketDescriptor sock = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0); | 190 const SocketDescriptor sock = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0); |
(...skipping 14 matching lines...) Expand all Loading... |
205 return sock; | 205 return sock; |
206 } | 206 } |
207 | 207 |
208 scoped_ptr<base::Thread> CreateAndRunServerThread() { | 208 scoped_ptr<base::Thread> CreateAndRunServerThread() { |
209 base::Thread::Options options; | 209 base::Thread::Options options; |
210 options.message_loop_type = base::MessageLoop::TYPE_IO; | 210 options.message_loop_type = base::MessageLoop::TYPE_IO; |
211 scoped_ptr<base::Thread> thread(new base::Thread("socketio_test")); | 211 scoped_ptr<base::Thread> thread(new base::Thread("socketio_test")); |
212 thread->StartWithOptions(options); | 212 thread->StartWithOptions(options); |
213 thread->message_loop()->PostTask( | 213 thread->message_loop()->PostTask( |
214 FROM_HERE, | 214 FROM_HERE, |
215 base::Bind(&UnixDomainSocketTestHelper::CreateAndListen, | 215 base::Bind(&UnixDomainListenSocketTestHelper::CreateAndListen, |
216 base::Unretained(this))); | 216 base::Unretained(this))); |
217 return thread.Pass(); | 217 return thread.Pass(); |
218 } | 218 } |
219 | 219 |
220 const base::FilePath file_path_; | 220 const base::FilePath file_path_; |
221 const bool allow_user_; | 221 const bool allow_user_; |
222 scoped_refptr<EventManager> event_manager_; | 222 scoped_refptr<EventManager> event_manager_; |
223 scoped_ptr<TestListenSocketDelegate> socket_delegate_; | 223 scoped_ptr<TestListenSocketDelegate> socket_delegate_; |
224 scoped_ptr<UnixDomainSocket> socket_; | 224 scoped_ptr<UnixDomainListenSocket> socket_; |
225 }; | 225 }; |
226 | 226 |
227 class UnixDomainSocketTest : public UnixDomainSocketTestHelper { | 227 class UnixDomainListenSocketTest : public UnixDomainListenSocketTestHelper { |
228 protected: | 228 protected: |
229 UnixDomainSocketTest() | 229 UnixDomainListenSocketTest() |
230 : UnixDomainSocketTestHelper(MakeSocketPath(), true /* allow user */) {} | 230 : UnixDomainListenSocketTestHelper(MakeSocketPath(), |
| 231 true /* allow user */) {} |
231 }; | 232 }; |
232 | 233 |
233 class UnixDomainSocketTestWithInvalidPath : public UnixDomainSocketTestHelper { | 234 class UnixDomainListenSocketTestWithInvalidPath |
| 235 : public UnixDomainListenSocketTestHelper { |
234 protected: | 236 protected: |
235 UnixDomainSocketTestWithInvalidPath() | 237 UnixDomainListenSocketTestWithInvalidPath() |
236 : UnixDomainSocketTestHelper(kInvalidSocketPath, true) {} | 238 : UnixDomainListenSocketTestHelper(kInvalidSocketPath, true) {} |
237 }; | 239 }; |
238 | 240 |
239 class UnixDomainSocketTestWithForbiddenUser | 241 class UnixDomainListenSocketTestWithForbiddenUser |
240 : public UnixDomainSocketTestHelper { | 242 : public UnixDomainListenSocketTestHelper { |
241 protected: | 243 protected: |
242 UnixDomainSocketTestWithForbiddenUser() | 244 UnixDomainListenSocketTestWithForbiddenUser() |
243 : UnixDomainSocketTestHelper(MakeSocketPath(), false /* forbid user */) {} | 245 : UnixDomainListenSocketTestHelper(MakeSocketPath(), |
| 246 false /* forbid user */) {} |
244 }; | 247 }; |
245 | 248 |
246 TEST_F(UnixDomainSocketTest, CreateAndListen) { | 249 TEST_F(UnixDomainListenSocketTest, CreateAndListen) { |
247 CreateAndListen(); | 250 CreateAndListen(); |
248 EXPECT_FALSE(socket_.get() == NULL); | 251 EXPECT_FALSE(socket_.get() == NULL); |
249 } | 252 } |
250 | 253 |
251 TEST_F(UnixDomainSocketTestWithInvalidPath, CreateAndListenWithInvalidPath) { | 254 TEST_F(UnixDomainListenSocketTestWithInvalidPath, |
| 255 CreateAndListenWithInvalidPath) { |
252 CreateAndListen(); | 256 CreateAndListen(); |
253 EXPECT_TRUE(socket_.get() == NULL); | 257 EXPECT_TRUE(socket_.get() == NULL); |
254 } | 258 } |
255 | 259 |
256 #ifdef SOCKET_ABSTRACT_NAMESPACE_SUPPORTED | 260 #ifdef SOCKET_ABSTRACT_NAMESPACE_SUPPORTED |
257 // Test with an invalid path to make sure that the socket is not backed by a | 261 // Test with an invalid path to make sure that the socket is not backed by a |
258 // file. | 262 // file. |
259 TEST_F(UnixDomainSocketTestWithInvalidPath, | 263 TEST_F(UnixDomainListenSocketTestWithInvalidPath, |
260 CreateAndListenWithAbstractNamespace) { | 264 CreateAndListenWithAbstractNamespace) { |
261 socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace( | 265 socket_ = UnixDomainListenSocket::CreateAndListenWithAbstractNamespace( |
262 file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback()); | 266 file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback()); |
263 EXPECT_FALSE(socket_.get() == NULL); | 267 EXPECT_FALSE(socket_.get() == NULL); |
264 } | 268 } |
265 | 269 |
266 TEST_F(UnixDomainSocketTest, TestFallbackName) { | 270 TEST_F(UnixDomainListenSocketTest, TestFallbackName) { |
267 scoped_ptr<UnixDomainSocket> existing_socket = | 271 scoped_ptr<UnixDomainListenSocket> existing_socket = |
268 UnixDomainSocket::CreateAndListenWithAbstractNamespace( | 272 UnixDomainListenSocket::CreateAndListenWithAbstractNamespace( |
269 file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback()); | 273 file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback()); |
270 EXPECT_FALSE(existing_socket.get() == NULL); | 274 EXPECT_FALSE(existing_socket.get() == NULL); |
271 // First, try to bind socket with the same name with no fallback name. | 275 // First, try to bind socket with the same name with no fallback name. |
272 socket_ = | 276 socket_ = |
273 UnixDomainSocket::CreateAndListenWithAbstractNamespace( | 277 UnixDomainListenSocket::CreateAndListenWithAbstractNamespace( |
274 file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback()); | 278 file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback()); |
275 EXPECT_TRUE(socket_.get() == NULL); | 279 EXPECT_TRUE(socket_.get() == NULL); |
276 // Now with a fallback name. | 280 // Now with a fallback name. |
277 const char kFallbackSocketName[] = "unix_domain_socket_for_testing_2"; | 281 const char kFallbackSocketName[] = "unix_domain_socket_for_testing_2"; |
278 socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace( | 282 socket_ = UnixDomainListenSocket::CreateAndListenWithAbstractNamespace( |
279 file_path_.value(), | 283 file_path_.value(), |
280 MakeSocketPath(kFallbackSocketName), | 284 MakeSocketPath(kFallbackSocketName), |
281 socket_delegate_.get(), | 285 socket_delegate_.get(), |
282 MakeAuthCallback()); | 286 MakeAuthCallback()); |
283 EXPECT_FALSE(socket_.get() == NULL); | 287 EXPECT_FALSE(socket_.get() == NULL); |
284 } | 288 } |
285 #endif | 289 #endif |
286 | 290 |
287 TEST_F(UnixDomainSocketTest, TestWithClient) { | 291 TEST_F(UnixDomainListenSocketTest, TestWithClient) { |
288 const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread(); | 292 const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread(); |
289 EventType event = event_manager_->WaitForEvent(); | 293 EventType event = event_manager_->WaitForEvent(); |
290 ASSERT_EQ(EVENT_LISTEN, event); | 294 ASSERT_EQ(EVENT_LISTEN, event); |
291 | 295 |
292 // Create the client socket. | 296 // Create the client socket. |
293 const SocketDescriptor sock = CreateClientSocket(); | 297 const SocketDescriptor sock = CreateClientSocket(); |
294 ASSERT_NE(kInvalidSocket, sock); | 298 ASSERT_NE(kInvalidSocket, sock); |
295 event = event_manager_->WaitForEvent(); | 299 event = event_manager_->WaitForEvent(); |
296 ASSERT_EQ(EVENT_AUTH_GRANTED, event); | 300 ASSERT_EQ(EVENT_AUTH_GRANTED, event); |
297 event = event_manager_->WaitForEvent(); | 301 event = event_manager_->WaitForEvent(); |
298 ASSERT_EQ(EVENT_ACCEPT, event); | 302 ASSERT_EQ(EVENT_ACCEPT, event); |
299 | 303 |
300 // Send a message from the client to the server. | 304 // Send a message from the client to the server. |
301 ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0)); | 305 ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0)); |
302 ASSERT_NE(-1, ret); | 306 ASSERT_NE(-1, ret); |
303 ASSERT_EQ(sizeof(kMsg), static_cast<size_t>(ret)); | 307 ASSERT_EQ(sizeof(kMsg), static_cast<size_t>(ret)); |
304 event = event_manager_->WaitForEvent(); | 308 event = event_manager_->WaitForEvent(); |
305 ASSERT_EQ(EVENT_READ, event); | 309 ASSERT_EQ(EVENT_READ, event); |
306 ASSERT_EQ(kMsg, socket_delegate_->ReceivedData()); | 310 ASSERT_EQ(kMsg, socket_delegate_->ReceivedData()); |
307 | 311 |
308 // Close the client socket. | 312 // Close the client socket. |
309 ret = IGNORE_EINTR(close(sock)); | 313 ret = IGNORE_EINTR(close(sock)); |
310 event = event_manager_->WaitForEvent(); | 314 event = event_manager_->WaitForEvent(); |
311 ASSERT_EQ(EVENT_CLOSE, event); | 315 ASSERT_EQ(EVENT_CLOSE, event); |
312 } | 316 } |
313 | 317 |
314 TEST_F(UnixDomainSocketTestWithForbiddenUser, TestWithForbiddenUser) { | 318 TEST_F(UnixDomainListenSocketTestWithForbiddenUser, TestWithForbiddenUser) { |
315 const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread(); | 319 const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread(); |
316 EventType event = event_manager_->WaitForEvent(); | 320 EventType event = event_manager_->WaitForEvent(); |
317 ASSERT_EQ(EVENT_LISTEN, event); | 321 ASSERT_EQ(EVENT_LISTEN, event); |
318 const SocketDescriptor sock = CreateClientSocket(); | 322 const SocketDescriptor sock = CreateClientSocket(); |
319 ASSERT_NE(kInvalidSocket, sock); | 323 ASSERT_NE(kInvalidSocket, sock); |
320 | 324 |
321 event = event_manager_->WaitForEvent(); | 325 event = event_manager_->WaitForEvent(); |
322 ASSERT_EQ(EVENT_AUTH_DENIED, event); | 326 ASSERT_EQ(EVENT_AUTH_DENIED, event); |
323 | 327 |
324 // Wait until the file descriptor is closed by the server. | 328 // Wait until the file descriptor is closed by the server. |
325 struct pollfd poll_fd; | 329 struct pollfd poll_fd; |
326 poll_fd.fd = sock; | 330 poll_fd.fd = sock; |
327 poll_fd.events = POLLIN; | 331 poll_fd.events = POLLIN; |
328 poll(&poll_fd, 1, -1 /* rely on GTest for timeout handling */); | 332 poll(&poll_fd, 1, -1 /* rely on GTest for timeout handling */); |
329 | 333 |
330 // Send() must fail. | 334 // Send() must fail. |
331 ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0)); | 335 ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0)); |
332 ASSERT_EQ(-1, ret); | 336 ASSERT_EQ(-1, ret); |
333 ASSERT_EQ(EPIPE, errno); | 337 ASSERT_EQ(EPIPE, errno); |
334 ASSERT_FALSE(event_manager_->HasPendingEvent()); | 338 ASSERT_FALSE(event_manager_->HasPendingEvent()); |
335 } | 339 } |
336 | 340 |
337 } // namespace | 341 } // namespace |
338 } // namespace net | 342 } // namespace net |
OLD | NEW |