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], outbuf2[128]; | |
Sam Clegg
2016/02/08 17:30:55
nit: put these one on each line
cernekee
2016/02/08 22:53:29
Done.
| |
363 char inbuf[512]; | |
364 | |
365 memset(outbuf1, 0xA4, sizeof(outbuf1)); | |
366 memset(outbuf2, 0xA5, sizeof(outbuf2)); | |
367 memset(inbuf, 0x3C, sizeof(inbuf)); | |
368 | |
369 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_)); | |
370 | |
371 int len1 = ki_send(sv_[0], outbuf1, sizeof(outbuf1), /* flags */ 0); | |
372 EXPECT_EQ(sizeof(outbuf1), len1); | |
373 | |
374 // The buffers should be different. | |
375 EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); | |
376 | |
377 int len2 = ki_send(sv_[0], outbuf2, sizeof(outbuf2), /* flags */ 0); | |
378 EXPECT_EQ(sizeof(outbuf2), len2); | |
379 | |
380 // Make sure the datagram boundaries are respected. | |
381 len1 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0); | |
382 EXPECT_EQ(sizeof(outbuf1), len1); | |
383 EXPECT_EQ(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); | |
384 | |
385 len2 = ki_recv(sv_[1], inbuf, sizeof(inbuf), /* flags */ 0); | |
386 EXPECT_EQ(sizeof(outbuf2), len2); | |
387 EXPECT_EQ(0, memcmp(outbuf2, inbuf, sizeof(outbuf2))); | |
388 | |
389 // A reader should block after trying to read at this point. | |
390 EXPECT_EQ(-1, ki_recv(sv_[1], inbuf, sizeof(inbuf), MSG_DONTWAIT)); | |
391 EXPECT_EQ(EAGAIN, errno); | |
392 | |
393 // Send a datagram larger than the recv buffer, and check for overflow. | |
394 memset(inbuf, 0x3C, sizeof(inbuf)); | |
395 EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); | |
396 len1 = ki_send(sv_[1], outbuf1, sizeof(outbuf1), /* flags */ 0); | |
397 EXPECT_EQ(sizeof(outbuf1), len1); | |
398 | |
399 len2 = ki_recv(sv_[0], inbuf, 16, /* flags */ 0); | |
400 EXPECT_EQ(16, len2); | |
401 EXPECT_EQ(0, memcmp(outbuf1, inbuf, 16)); | |
402 EXPECT_EQ(0x3C, inbuf[16]); | |
403 | |
404 // Send data back in the opposite direction, and make sure the call | |
405 // blocks when there is no more data to read. | |
Sam Clegg
2016/02/08 17:30:55
Didn't you already send data in the opposite direc
cernekee
2016/02/08 22:53:29
Done.
| |
406 memset(inbuf, 0x3C, sizeof(inbuf)); | |
407 EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); | |
408 len1 = ki_send(sv_[1], outbuf1, sizeof(outbuf1), /* flags */ 0); | |
409 EXPECT_EQ(sizeof(outbuf1), len1); | |
410 | |
411 EXPECT_NE(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); | |
412 | |
413 len2 = ki_recv(sv_[0], inbuf, sizeof(inbuf), /* flags */ 0); | |
414 EXPECT_EQ(sizeof(outbuf1), len2); | |
415 | |
416 EXPECT_EQ(0, memcmp(outbuf1, inbuf, sizeof(outbuf1))); | |
417 EXPECT_EQ(-1, ki_recv(sv_[0], inbuf, sizeof(inbuf), MSG_DONTWAIT)); | |
418 EXPECT_EQ(EAGAIN, errno); | |
419 } | |
420 | |
421 TEST_F(UnixSocketTest, RecvNonBlockingDgram) { | |
422 char buf[128]; | |
423 | |
424 EXPECT_EQ(0, ki_socketpair(AF_UNIX, SOCK_DGRAM, 0, sv_)); | |
425 | |
426 EXPECT_EQ(-1, ki_recv(sv_[0], buf, sizeof(buf), MSG_DONTWAIT)); | |
427 EXPECT_EQ(EAGAIN, errno); | |
428 | |
429 struct pollfd pollfd = {sv_[0], POLLIN | POLLOUT, 0}; | |
430 EXPECT_EQ(1, ki_poll(&pollfd, 1, 0)); | |
431 EXPECT_EQ(POLLOUT, pollfd.revents & POLLOUT); | |
432 EXPECT_NE(POLLIN, pollfd.revents & POLLIN); | |
433 } | |
434 | |
355 TEST(SocketUtilityFunctions, Htonl) { | 435 TEST(SocketUtilityFunctions, Htonl) { |
356 uint32_t host_long = 0x44332211; | 436 uint32_t host_long = 0x44332211; |
357 uint32_t network_long = htonl(host_long); | 437 uint32_t network_long = htonl(host_long); |
358 uint8_t network_bytes[4]; | 438 uint8_t network_bytes[4]; |
359 memcpy(network_bytes, &network_long, 4); | 439 memcpy(network_bytes, &network_long, 4); |
360 EXPECT_EQ(network_bytes[0], 0x44); | 440 EXPECT_EQ(network_bytes[0], 0x44); |
361 EXPECT_EQ(network_bytes[1], 0x33); | 441 EXPECT_EQ(network_bytes[1], 0x33); |
362 EXPECT_EQ(network_bytes[2], 0x22); | 442 EXPECT_EQ(network_bytes[2], 0x22); |
363 EXPECT_EQ(network_bytes[3], 0x11); | 443 EXPECT_EQ(network_bytes[3], 0x11); |
364 } | 444 } |
(...skipping 255 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
620 | 700 |
621 TEST(SocketUtilityFunctions, Ntohl) { | 701 TEST(SocketUtilityFunctions, Ntohl) { |
622 uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 }; | 702 uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 }; |
623 uint32_t network_long; | 703 uint32_t network_long; |
624 memcpy(&network_long, network_bytes, 4); | 704 memcpy(&network_long, network_bytes, 4); |
625 uint32_t host_long = ntohl(network_long); | 705 uint32_t host_long = ntohl(network_long); |
626 EXPECT_EQ(host_long, 0x44332211); | 706 EXPECT_EQ(host_long, 0x44332211); |
627 } | 707 } |
628 | 708 |
629 #endif // PROVIDES_SOCKETPAIR_API | 709 #endif // PROVIDES_SOCKETPAIR_API |
OLD | NEW |