OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 <arpa/inet.h> | 5 #include <arpa/inet.h> |
6 #include <errno.h> | 6 #include <errno.h> |
7 #include <fcntl.h> | 7 #include <fcntl.h> |
8 #include <netinet/in.h> | 8 #include <netinet/in.h> |
9 #include <pthread.h> | 9 #include <pthread.h> |
10 #include <sys/types.h> | 10 #include <sys/types.h> |
(...skipping 238 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
249 } | 249 } |
250 | 250 |
251 TEST_F(SocketTest, SocketpairUnsupported) { | 251 TEST_F(SocketTest, SocketpairUnsupported) { |
252 int sv[2]; | 252 int sv[2]; |
253 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, NULL), 0); | 253 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, NULL), 0); |
254 EXPECT_EQ(errno, EFAULT); | 254 EXPECT_EQ(errno, EFAULT); |
255 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0); | 255 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0); |
256 EXPECT_EQ(errno, EOPNOTSUPP); | 256 EXPECT_EQ(errno, EOPNOTSUPP); |
257 EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0); | 257 EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0); |
258 EXPECT_EQ(errno, EOPNOTSUPP); | 258 EXPECT_EQ(errno, EOPNOTSUPP); |
259 EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv), 0); | 259 EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_RAW, 0, sv), 0); |
260 EXPECT_EQ(errno, EPROTOTYPE); | 260 EXPECT_EQ(errno, EPROTOTYPE); |
261 EXPECT_LT(ki_socketpair(AF_MAX, SOCK_STREAM, 0, sv), 0); | 261 EXPECT_LT(ki_socketpair(AF_MAX, SOCK_STREAM, 0, sv), 0); |
262 EXPECT_EQ(errno, EAFNOSUPPORT); | 262 EXPECT_EQ(errno, EAFNOSUPPORT); |
263 } | 263 } |
264 | 264 |
265 class UnixSocketTest : public ::testing::Test { | 265 class UnixSocketTest : public ::testing::Test { |
266 public: | 266 public: |
267 UnixSocketTest() { sv_[0] = sv_[1] = -1; } | 267 UnixSocketTest() { sv_[0] = sv_[1] = -1; } |
268 | 268 |
269 void SetUp() { | 269 void SetUp() { |
(...skipping 19 matching lines...) Expand all Loading... |
289 EXPECT_EQ(-1, ki_socket(AF_UNIX, SOCK_STREAM, 0)); | 289 EXPECT_EQ(-1, ki_socket(AF_UNIX, SOCK_STREAM, 0)); |
290 EXPECT_EQ(EAFNOSUPPORT, errno); | 290 EXPECT_EQ(EAFNOSUPPORT, errno); |
291 } | 291 } |
292 | 292 |
293 TEST_F(UnixSocketTest, Socketpair) { | 293 TEST_F(UnixSocketTest, Socketpair) { |
294 errno = 0; | 294 errno = 0; |
295 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_)); | 295 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_)); |
296 EXPECT_EQ(0, errno); | 296 EXPECT_EQ(0, errno); |
297 EXPECT_LE(0, sv_[0]); | 297 EXPECT_LE(0, sv_[0]); |
298 EXPECT_LE(0, sv_[1]); | 298 EXPECT_LE(0, sv_[1]); |
| 299 |
| 300 errno = 0; |
| 301 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_)); |
| 302 EXPECT_EQ(0, errno); |
| 303 EXPECT_LE(0, sv_[0]); |
| 304 EXPECT_LE(0, sv_[1]); |
299 } | 305 } |
300 | 306 |
301 TEST_F(UnixSocketTest, SendRecv) { | 307 TEST_F(UnixSocketTest, SendRecvStream) { |
302 char outbuf[256]; | 308 char outbuf[256]; |
303 char inbuf[512]; | 309 char inbuf[512]; |
304 | 310 |
305 memset(outbuf, 0xA5, sizeof(outbuf)); | 311 memset(outbuf, 0xA5, sizeof(outbuf)); |
306 memset(inbuf, 0x3C, sizeof(inbuf)); | 312 memset(inbuf, 0x3C, sizeof(inbuf)); |
307 | 313 |
308 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_)); | 314 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_)); |
309 | 315 |
310 int len1 = ki_send(sv_[0], outbuf, sizeof(outbuf), /* flags */ 0); | 316 int len1 = ki_send(sv_[0], outbuf, sizeof(outbuf), /* flags */ 0); |
311 EXPECT_EQ(sizeof(outbuf), len1); | 317 EXPECT_EQ(sizeof(outbuf), len1); |
312 | 318 |
313 // The buffers should be different. | 319 // The buffers should be different. |
314 EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf))); | 320 EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf))); |
315 | 321 |
316 int len2 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0); | 322 int len2 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0); |
317 EXPECT_EQ(sizeof(outbuf), len2); | 323 EXPECT_EQ(sizeof(outbuf), len2); |
318 | 324 |
319 EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf))); | 325 EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf))); |
320 | 326 |
321 // A reader should block after to read at this point. | 327 // A reader should block after trying to read at this point. |
322 EXPECT_EQ(-1, ki_recv(sv_[1], inbuf, sizeof(inbuf), MSG_DONTWAIT)); | 328 EXPECT_EQ(-1, ki_recv(sv_[1], inbuf, sizeof(inbuf), MSG_DONTWAIT)); |
323 EXPECT_EQ(EAGAIN, errno); | 329 EXPECT_EQ(EAGAIN, errno); |
324 | 330 |
325 // Send data back in the opposite direction. | 331 // Send data back in the opposite direction. |
326 memset(inbuf, 0x3C, sizeof(inbuf)); | 332 memset(inbuf, 0x3C, sizeof(inbuf)); |
327 EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf))); | 333 EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf))); |
328 len1 = ki_send(sv_[1], outbuf, sizeof(outbuf), /* flags */ 0); | 334 len1 = ki_send(sv_[1], outbuf, sizeof(outbuf), /* flags */ 0); |
329 EXPECT_EQ(sizeof(outbuf), len1); | 335 EXPECT_EQ(sizeof(outbuf), len1); |
330 | 336 |
331 EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf))); | 337 EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf))); |
332 | 338 |
333 len2 = ki_recv(sv_[0], inbuf, sizeof(inbuf), /* flags */ 0); | 339 len2 = ki_recv(sv_[0], inbuf, sizeof(inbuf), /* flags */ 0); |
334 EXPECT_EQ(sizeof(outbuf), len2); | 340 EXPECT_EQ(sizeof(outbuf), len2); |
335 | 341 |
336 EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf))); | 342 EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf))); |
337 EXPECT_EQ(-1, ki_recv(sv_[0], inbuf, sizeof(inbuf), MSG_DONTWAIT)); | 343 EXPECT_EQ(-1, ki_recv(sv_[0], inbuf, sizeof(inbuf), MSG_DONTWAIT)); |
338 EXPECT_EQ(EAGAIN, errno); | 344 EXPECT_EQ(EAGAIN, errno); |
339 } | 345 } |
340 | 346 |
341 TEST_F(UnixSocketTest, RecvNonBlocking) { | 347 TEST_F(UnixSocketTest, RecvNonBlockingStream) { |
342 char buf[128]; | 348 char buf[128]; |
343 | 349 |
344 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_)); | 350 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv_)); |
345 | 351 |
346 EXPECT_EQ(-1, ki_recv(sv_[0], buf, sizeof(buf), MSG_DONTWAIT)); | 352 EXPECT_EQ(-1, ki_recv(sv_[0], buf, sizeof(buf), MSG_DONTWAIT)); |
347 EXPECT_EQ(EAGAIN, errno); | 353 EXPECT_EQ(EAGAIN, errno); |
348 | 354 |
349 struct pollfd pollfd = {sv_[0], POLLIN | POLLOUT, 0}; | 355 struct pollfd pollfd = {sv_[0], POLLIN | POLLOUT, 0}; |
350 EXPECT_EQ(1, ki_poll(&pollfd, 1, 0)); | 356 EXPECT_EQ(1, ki_poll(&pollfd, 1, 0)); |
351 EXPECT_EQ(POLLOUT, pollfd.revents & POLLOUT); | 357 EXPECT_EQ(POLLOUT, pollfd.revents & POLLOUT); |
352 EXPECT_NE(POLLIN, pollfd.revents & POLLIN); | 358 EXPECT_NE(POLLIN, pollfd.revents & POLLIN); |
353 } | 359 } |
354 | 360 |
| 361 TEST_F(UnixSocketTest, SendRecvDgram) { |
| 362 char outbuf1[256]; |
| 363 char outbuf2[128]; |
| 364 char inbuf[512]; |
| 365 |
| 366 memset(outbuf1, 0xA4, sizeof(outbuf1)); |
| 367 memset(outbuf2, 0xA5, sizeof(outbuf2)); |
| 368 memset(inbuf, 0x3C, sizeof(inbuf)); |
| 369 |
| 370 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_)); |
| 371 |
| 372 int len1 = ki_send(sv_[0], outbuf1, sizeof(outbuf1), /* flags */ 0); |
| 373 EXPECT_EQ(sizeof(outbuf1), len1); |
| 374 |
| 375 // The buffers should be different. |
| 376 EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); |
| 377 |
| 378 int len2 = ki_send(sv_[0], outbuf2, sizeof(outbuf2), /* flags */ 0); |
| 379 EXPECT_EQ(sizeof(outbuf2), len2); |
| 380 |
| 381 // Make sure the datagram boundaries are respected. |
| 382 len1 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0); |
| 383 EXPECT_EQ(sizeof(outbuf1), len1); |
| 384 EXPECT_EQ(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); |
| 385 |
| 386 len2 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0); |
| 387 EXPECT_EQ(sizeof(outbuf2), len2); |
| 388 EXPECT_EQ(0, memcmp(outbuf2, inbuf, sizeof(outbuf2))); |
| 389 |
| 390 // A reader should block after trying to read at this point. |
| 391 EXPECT_EQ(-1, ki_recv(sv_[1], inbuf, sizeof(inbuf), MSG_DONTWAIT)); |
| 392 EXPECT_EQ(EAGAIN, errno); |
| 393 |
| 394 // Send a datagram larger than the recv buffer, and check for overflow. |
| 395 memset(inbuf, 0x3C, sizeof(inbuf)); |
| 396 EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); |
| 397 len1 = ki_send(sv_[1], outbuf1, sizeof(outbuf1), /* flags */ 0); |
| 398 EXPECT_EQ(sizeof(outbuf1), len1); |
| 399 |
| 400 len2 = ki_recv(sv_[0], inbuf, 16, /* flags */ 0); |
| 401 EXPECT_EQ(16, len2); |
| 402 EXPECT_EQ(0, memcmp(outbuf1, inbuf, 16)); |
| 403 EXPECT_EQ(0x3C, inbuf[16]); |
| 404 |
| 405 // Verify that the remainder of the packet was discarded, and there |
| 406 // is nothing left to receive. |
| 407 EXPECT_EQ(-1, ki_recv(sv_[0], inbuf, sizeof(inbuf), MSG_DONTWAIT)); |
| 408 EXPECT_EQ(EAGAIN, errno); |
| 409 } |
| 410 |
| 411 TEST_F(UnixSocketTest, RecvNonBlockingDgram) { |
| 412 char buf[128]; |
| 413 |
| 414 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_)); |
| 415 |
| 416 EXPECT_EQ(-1, ki_recv(sv_[0], buf, sizeof(buf), MSG_DONTWAIT)); |
| 417 EXPECT_EQ(EAGAIN, errno); |
| 418 |
| 419 struct pollfd pollfd = {sv_[0], POLLIN | POLLOUT, 0}; |
| 420 EXPECT_EQ(1, ki_poll(&pollfd, 1, 0)); |
| 421 EXPECT_EQ(POLLOUT, pollfd.revents & POLLOUT); |
| 422 EXPECT_NE(POLLIN, pollfd.revents & POLLIN); |
| 423 } |
| 424 |
355 TEST(SocketUtilityFunctions, Htonl) { | 425 TEST(SocketUtilityFunctions, Htonl) { |
356 uint32_t host_long = 0x44332211; | 426 uint32_t host_long = 0x44332211; |
357 uint32_t network_long = htonl(host_long); | 427 uint32_t network_long = htonl(host_long); |
358 uint8_t network_bytes[4]; | 428 uint8_t network_bytes[4]; |
359 memcpy(network_bytes, &network_long, 4); | 429 memcpy(network_bytes, &network_long, 4); |
360 EXPECT_EQ(network_bytes[0], 0x44); | 430 EXPECT_EQ(network_bytes[0], 0x44); |
361 EXPECT_EQ(network_bytes[1], 0x33); | 431 EXPECT_EQ(network_bytes[1], 0x33); |
362 EXPECT_EQ(network_bytes[2], 0x22); | 432 EXPECT_EQ(network_bytes[2], 0x22); |
363 EXPECT_EQ(network_bytes[3], 0x11); | 433 EXPECT_EQ(network_bytes[3], 0x11); |
364 } | 434 } |
(...skipping 255 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
620 | 690 |
621 TEST(SocketUtilityFunctions, Ntohl) { | 691 TEST(SocketUtilityFunctions, Ntohl) { |
622 uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 }; | 692 uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 }; |
623 uint32_t network_long; | 693 uint32_t network_long; |
624 memcpy(&network_long, network_bytes, 4); | 694 memcpy(&network_long, network_bytes, 4); |
625 uint32_t host_long = ntohl(network_long); | 695 uint32_t host_long = ntohl(network_long); |
626 EXPECT_EQ(host_long, 0x44332211); | 696 EXPECT_EQ(host_long, 0x44332211); |
627 } | 697 } |
628 | 698 |
629 #endif // PROVIDES_SOCKETPAIR_API | 699 #endif // PROVIDES_SOCKETPAIR_API |
OLD | NEW |