socket_test.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
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 3// found in the LICENSE file. 4 5#include <arpa/inet.h> 6#include <errno.h> 7#include <fcntl.h> 8#include <netinet/in.h> 9#include <pthread.h> 10#include <sys/types.h> 11#include <sys/socket.h> 12#include <sys/stat.h> 13 14#include <map> 15 16#include "gmock/gmock.h" 17#include "gtest/gtest.h" 18 19#include "nacl_io/kernel_intercept.h" 20#include "nacl_io/kernel_proxy.h" 21#include "nacl_io/ossocket.h" 22#include "nacl_io/ostypes.h" 23 24#ifdef PROVIDES_SOCKET_API 25 26using namespace nacl_io; 27using namespace sdk_util; 28 29namespace { 30class SocketTest : public ::testing::Test { 31 public: 32 SocketTest() {} 33 34 void SetUp() { 35 ki_init(&kp_); 36 } 37 38 void TearDown() { 39 ki_uninit(); 40 } 41 42 protected: 43 KernelProxy kp_; 44}; 45 46} // namespace 47 48TEST_F(SocketTest, Accept) { 49 struct sockaddr addr = {}; 50 socklen_t len = 0; 51 52 EXPECT_LT(ki_accept(123, NULL, &len), 0); 53 EXPECT_EQ(errno, EFAULT); 54 EXPECT_LT(ki_accept(123, &addr, NULL), 0); 55 EXPECT_EQ(errno, EFAULT); 56 EXPECT_LT(ki_accept(123, NULL, NULL), 0); 57 EXPECT_EQ(errno, EFAULT); 58 EXPECT_LT(ki_accept(-1, &addr, &len), 0); 59 EXPECT_EQ(errno, EBADF); 60 EXPECT_LT(ki_accept(0, &addr, &len), 0); 61 EXPECT_EQ(errno, ENOTSOCK); 62} 63 64TEST_F(SocketTest, Bind) { 65 const struct sockaddr const_addr = {}; 66 socklen_t len = 0; 67 68 EXPECT_LT(ki_bind(123, NULL, len), 0); 69 EXPECT_EQ(errno, EFAULT); 70 EXPECT_LT(ki_bind(-1, &const_addr, len), 0); 71 EXPECT_EQ(errno, EBADF); 72 EXPECT_LT(ki_bind(0, &const_addr, len), 0); 73 EXPECT_EQ(errno, ENOTSOCK); 74} 75 76TEST_F(SocketTest, Connect) { 77 const struct sockaddr const_addr = {}; 78 socklen_t len = 0; 79 80 EXPECT_LT(ki_connect(123, NULL, len), 0); 81 EXPECT_EQ(errno, EFAULT); 82 EXPECT_LT(ki_connect(-1, &const_addr, len), 0); 83 EXPECT_EQ(errno, EBADF); 84 EXPECT_LT(ki_connect(0, &const_addr, len), 0); 85 EXPECT_EQ(errno, ENOTSOCK); 86} 87 88TEST_F(SocketTest, Getpeername) { 89 struct sockaddr addr = {}; 90 socklen_t len = 0; 91 92 EXPECT_LT(ki_getpeername(123, NULL, &len), 0); 93 EXPECT_EQ(errno, EFAULT); 94 EXPECT_LT(ki_getpeername(123, &addr, NULL), 0); 95 EXPECT_EQ(errno, EFAULT); 96 EXPECT_LT(ki_getpeername(123, NULL, NULL), 0); 97 EXPECT_EQ(errno, EFAULT); 98 EXPECT_LT(ki_getpeername(-1, &addr, &len), 0); 99 EXPECT_EQ(errno, EBADF); 100 EXPECT_LT(ki_getpeername(0, &addr, &len), 0); 101 EXPECT_EQ(errno, ENOTSOCK); 102} 103 104TEST_F(SocketTest, Getsockname) { 105 struct sockaddr addr = {}; 106 socklen_t len = 0; 107 108 EXPECT_LT(ki_getsockname(123, NULL, &len), 0); 109 EXPECT_EQ(errno, EFAULT); 110 EXPECT_LT(ki_getsockname(123, &addr, NULL), 0); 111 EXPECT_EQ(errno, EFAULT); 112 EXPECT_LT(ki_getsockname(123, NULL, NULL), 0); 113 EXPECT_EQ(errno, EFAULT); 114 EXPECT_LT(ki_getsockname(-1, &addr, &len), 0); 115 EXPECT_EQ(errno, EBADF); 116 EXPECT_LT(ki_getsockname(0, &addr, &len), 0); 117 EXPECT_EQ(errno, ENOTSOCK); 118} 119 120TEST_F(SocketTest, Getsockopt) { 121 socklen_t len = 10; 122 char optval[len]; 123 124 EXPECT_LT(ki_getsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, optval, NULL), 0); 125 EXPECT_EQ(errno, EFAULT); 126 EXPECT_LT(ki_getsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, &len), 0); 127 EXPECT_EQ(errno, EFAULT); 128 EXPECT_LT(ki_getsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, NULL), 0); 129 EXPECT_EQ(errno, EFAULT); 130 EXPECT_LT(ki_getsockopt(-1, SOL_SOCKET, SO_ACCEPTCONN, optval, &len), 0); 131 EXPECT_EQ(errno, EBADF); 132 EXPECT_LT(ki_getsockopt(0, SOL_SOCKET, SO_ACCEPTCONN, optval, &len), 0); 133 EXPECT_EQ(errno, ENOTSOCK); 134} 135 136TEST_F(SocketTest, Listen) { 137 EXPECT_LT(ki_listen(-1, 123), 0); 138 EXPECT_EQ(errno, EBADF); 139 EXPECT_LT(ki_listen(0, 123), 0); 140 EXPECT_EQ(errno, ENOTSOCK); 141} 142 143TEST_F(SocketTest, Recv) { 144 size_t len = 10; 145 char buf[len]; 146 147 EXPECT_LT(ki_recv(123, NULL, len, 0), 0); 148 EXPECT_EQ(errno, EFAULT); 149 EXPECT_LT(ki_recv(-1, buf, len, 0), 0); 150 EXPECT_EQ(errno, EBADF); 151 EXPECT_LT(ki_recv(0, buf, len, 0), 0); 152 EXPECT_EQ(errno, ENOTSOCK); 153} 154 155TEST_F(SocketTest, Recvfrom) { 156 size_t len = 10; 157 char buf[len]; 158 struct sockaddr addr = {}; 159 socklen_t addrlen = 4; 160 161 EXPECT_LT(ki_recvfrom(123, NULL, len, 0, &addr, &addrlen), 0); 162 EXPECT_EQ(errno, EFAULT); 163 EXPECT_LT(ki_recvfrom(123, buf, len, 0, &addr, NULL), 0); 164 EXPECT_EQ(errno, EFAULT); 165 EXPECT_LT(ki_recvfrom(-1, buf, len, 0, &addr, &addrlen), 0); 166 EXPECT_EQ(errno, EBADF); 167 EXPECT_LT(ki_recvfrom(0, buf, len, 0, &addr, &addrlen), 0); 168 EXPECT_EQ(errno, ENOTSOCK); 169} 170 171TEST_F(SocketTest, Recvmsg) { 172 struct msghdr msg = {}; 173 174 EXPECT_LT(ki_recvmsg(123, NULL, 0), 0); 175 EXPECT_EQ(errno, EFAULT); 176 EXPECT_LT(ki_recvmsg(-1, &msg, 0), 0); 177 EXPECT_EQ(errno, EBADF); 178 EXPECT_LT(ki_recvmsg(0, &msg, 0), 0); 179 EXPECT_EQ(errno, ENOTSOCK); 180} 181 182TEST_F(SocketTest, Send) { 183 size_t len = 10; 184 char buf[len]; 185 186 EXPECT_LT(ki_send(123, NULL, len, 0), 0); 187 EXPECT_EQ(errno, EFAULT); 188 EXPECT_LT(ki_send(-1, buf, len, 0), 0); 189 EXPECT_EQ(errno, EBADF); 190 EXPECT_LT(ki_send(0, buf, len, 0), 0); 191 EXPECT_EQ(errno, ENOTSOCK); 192} 193 194TEST_F(SocketTest, Sendto) { 195 size_t len = 10; 196 char buf[len]; 197 struct sockaddr addr = {}; 198 socklen_t addrlen = 4; 199 200 EXPECT_LT(ki_sendto(123, NULL, len, 0, &addr, addrlen), 0); 201 EXPECT_EQ(errno, EFAULT); 202 EXPECT_LT(ki_sendto(-1, buf, len, 0, &addr, addrlen), 0); 203 EXPECT_EQ(errno, EBADF); 204 EXPECT_LT(ki_sendto(0, buf, len, 0, &addr, addrlen), 0); 205 EXPECT_EQ(errno, ENOTSOCK); 206} 207 208TEST_F(SocketTest, Sendmsg) { 209 struct msghdr msg = {}; 210 211 EXPECT_LT(ki_sendmsg(123, NULL, 0), 0); 212 EXPECT_EQ(errno, EFAULT); 213 EXPECT_LT(ki_sendmsg(-1, &msg, 0), 0); 214 EXPECT_EQ(errno, EBADF); 215 EXPECT_LT(ki_sendmsg(0, &msg, 0), 0); 216 EXPECT_EQ(errno, ENOTSOCK); 217} 218 219TEST_F(SocketTest, Setsockopt) { 220 socklen_t len = 10; 221 char optval[len]; 222 223 // Passing a bad address as optval should generate EFAULT 224 EXPECT_EQ(-1, ki_setsockopt(123, SOL_SOCKET, SO_ACCEPTCONN, NULL, len)); 225 EXPECT_EQ(errno, EFAULT); 226 227 // Passing a bad socket descriptor should generate EBADF 228 EXPECT_EQ(-1, ki_setsockopt(-1, SOL_SOCKET, SO_ACCEPTCONN, optval, len)); 229 EXPECT_EQ(errno, EBADF); 230 231 // Passing an FD that is valid but not a socket should generate ENOTSOCK 232 EXPECT_EQ(-1, ki_setsockopt(0, SOL_SOCKET, SO_ACCEPTCONN, optval, len)); 233 EXPECT_EQ(errno, ENOTSOCK); 234} 235 236TEST_F(SocketTest, Shutdown) { 237 EXPECT_LT(ki_shutdown(-1, SHUT_RDWR), 0); 238 EXPECT_EQ(errno, EBADF); 239 EXPECT_LT(ki_shutdown(0, SHUT_RDWR), 0); 240 EXPECT_EQ(errno, ENOTSOCK); 241} 242 243TEST_F(SocketTest, Socket) { 244 EXPECT_LT(ki_socket(AF_UNIX, SOCK_STREAM, 0), 0); 245 EXPECT_EQ(errno, EAFNOSUPPORT); 246 EXPECT_LT(ki_socket(AF_INET, SOCK_RAW, 0), 0); 247 EXPECT_EQ(errno, EPROTONOSUPPORT); 248} 249 250TEST_F(SocketTest, Socketpair) { 251 int sv[2]; 252 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, NULL), 0); 253 EXPECT_EQ(errno, EFAULT); 254 EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0); 255 EXPECT_EQ(errno, EAFNOSUPPORT); 256 EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0); 257 EXPECT_EQ(errno, EPROTONOSUPPORT); 258 EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0); 259 EXPECT_EQ(errno, EPROTONOSUPPORT); 260} 261 262TEST(SocketUtilityFunctions, Htonl) { 263 uint32_t host_long = 0x44332211; 264 uint32_t network_long = htonl(host_long); 265 uint8_t network_bytes[4]; 266 memcpy(network_bytes, &network_long, 4); 267 EXPECT_EQ(network_bytes[0], 0x44); 268 EXPECT_EQ(network_bytes[1], 0x33); 269 EXPECT_EQ(network_bytes[2], 0x22); 270 EXPECT_EQ(network_bytes[3], 0x11); 271} 272 273TEST(SocketUtilityFunctions, Htons) { 274 uint16_t host_short = 0x2211; 275 uint16_t network_short = htons(host_short); 276 uint8_t network_bytes[2]; 277 memcpy(network_bytes, &network_short, 2); 278 EXPECT_EQ(network_bytes[0], 0x22); 279 EXPECT_EQ(network_bytes[1], 0x11); 280} 281 282static struct in_addr generate_ipv4_addr(uint8_t* tuple) { 283 unsigned char addr[4]; 284 addr[0] = static_cast<unsigned char>(tuple[0]); 285 addr[1] = static_cast<unsigned char>(tuple[1]); 286 addr[2] = static_cast<unsigned char>(tuple[2]); 287 addr[3] = static_cast<unsigned char>(tuple[3]); 288 struct in_addr real_addr; 289 memcpy(&real_addr, addr, 4); 290 return real_addr; 291} 292 293static struct in6_addr generate_ipv6_addr(uint16_t* tuple) { 294 unsigned char addr[16]; 295 for (int i = 0; i < 8; i++) { 296 addr[2*i] = (tuple[i] >> 8) & 0xFF; 297 addr[2*i+1] = tuple[i] & 0xFF; 298 } 299 struct in6_addr real_addr; 300 memcpy(&real_addr, addr, 16); 301 return real_addr; 302} 303 304TEST(SocketUtilityFunctions, Inet_addr) { 305 // Fails for if string contains non-integers. 306 ASSERT_EQ(INADDR_NONE, inet_addr("foobar")); 307 308 // Fails if there are too many quads 309 ASSERT_EQ(INADDR_NONE, inet_addr("0.0.0.0.0")); 310 311 // Fails if a single element is > 255 312 ASSERT_EQ(INADDR_NONE, inet_addr("999.0.0.0")); 313 314 // Fails if a single element is negative. 315 ASSERT_EQ(INADDR_NONE, inet_addr("-55.0.0.0")); 316 317 // In tripple, notation third integer cannot be larger 318 // and 16bit unsigned int. 319 ASSERT_EQ(INADDR_NONE, inet_addr("1.2.66000")); 320 321 // Success cases. 322 // Normal dotted-quad address. 323 uint32_t expected_addr = ntohl(0x07060504); 324 ASSERT_EQ(expected_addr, inet_addr("7.6.5.4")); 325 expected_addr = ntohl(0xffffffff); 326 ASSERT_EQ(expected_addr, inet_addr("255.255.255.255")); 327 328 // Tripple case 329 expected_addr = ntohl(1 << 24 | 2 << 16 | 3); 330 ASSERT_EQ(expected_addr, inet_addr("1.2.3")); 331 expected_addr = ntohl(1 << 24 | 2 << 16 | 300); 332 ASSERT_EQ(expected_addr, inet_addr("1.2.300")); 333 334 // Double case 335 expected_addr = ntohl(1 << 24 | 20000); 336 ASSERT_EQ(expected_addr, inet_addr("1.20000")); 337 expected_addr = ntohl(1 << 24 | 2); 338 ASSERT_EQ(expected_addr, inet_addr("1.2")); 339 340 // Single case 341 expected_addr = ntohl(255); 342 ASSERT_EQ(expected_addr, inet_addr("255")); 343 expected_addr = ntohl(4000000000U); 344 ASSERT_EQ(expected_addr, inet_addr("4000000000")); 345} 346 347TEST(SocketUtilityFunctions, Inet_aton) { 348 struct in_addr addr; 349 350 // Failure cases 351 ASSERT_EQ(0, inet_aton("foobar", &addr)); 352 ASSERT_EQ(0, inet_aton("0.0.0.0.0", &addr)); 353 ASSERT_EQ(0, inet_aton("999.0.0.0", &addr)); 354 355 // Success cases 356 uint32_t expected_addr = htonl(0xff020304); 357 ASSERT_NE(0, inet_aton("255.2.3.4", &addr)); 358 ASSERT_EQ(expected_addr, addr.s_addr); 359 360 expected_addr = htonl(0x01000002); 361 ASSERT_NE(0, inet_aton("1.2", &addr)); 362 ASSERT_EQ(expected_addr, addr.s_addr); 363 364 expected_addr = htonl(0x01020003); 365 ASSERT_NE(0, inet_aton("1.2.3", &addr)); 366 ASSERT_EQ(expected_addr, addr.s_addr); 367 368 expected_addr = htonl(0x0000100); 369 ASSERT_NE(0, inet_aton("256", &addr)); 370 ASSERT_EQ(expected_addr, addr.s_addr); 371} 372 373TEST(SocketUtilityFunctions, Inet_ntoa) { 374 struct { 375 unsigned char addr_tuple[4]; 376 const char* output; 377 } tests[] = { 378 { { 0, 0, 0, 0 }, "0.0.0.0" }, 379 { { 127, 0, 0, 1 }, "127.0.0.1" }, 380 { { 255, 255, 255, 255 }, "255.255.255.255" }, 381 }; 382 383 for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) { 384 char* stringified_addr = inet_ntoa(generate_ipv4_addr(tests[i].addr_tuple)); 385 ASSERT_TRUE(NULL != stringified_addr); 386 EXPECT_STREQ(tests[i].output, stringified_addr); 387 } 388} 389 390TEST(SocketUtilityFunctions, Inet_ntop_ipv4) { 391 struct { 392 unsigned char addr_tuple[4]; 393 const char* output; 394 } tests[] = { 395 { { 0, 0, 0, 0 }, "0.0.0.0" }, 396 { { 127, 0, 0, 1 }, "127.0.0.1" }, 397 { { 255, 255, 255, 255 }, "255.255.255.255" }, 398 }; 399 400 for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) { 401 char stringified_addr[INET_ADDRSTRLEN]; 402 struct in_addr real_addr = generate_ipv4_addr(tests[i].addr_tuple); 403 EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr, 404 stringified_addr, INET_ADDRSTRLEN)); 405 EXPECT_STREQ(tests[i].output, stringified_addr); 406 } 407} 408 409TEST(SocketUtilityFunctions, Inet_ntop_ipv6) { 410 struct { 411 unsigned short addr_tuple[8]; 412 const char* output; 413 } tests[] = { 414 { { 0, 0, 0, 0, 0, 0, 0, 0 }, "::" }, 415 { { 1, 2, 3, 0, 0, 0, 0, 0 }, "1:2:3::" }, 416 { { 0, 0, 0, 0, 0, 1, 2, 3 }, "::1:2:3" }, 417 { { 0x1234, 0xa, 0x12, 0x0000, 0x5678, 0x9abc, 0xdef, 0xffff }, 418 "1234:a:12:0:5678:9abc:def:ffff" }, 419 { { 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff }, 420 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" }, 421 { { 0, 0, 0, 0, 0, 0xffff, 0x101, 0x101 }, "::ffff:1.1.1.1" }, 422 { { 0, 0, 0, 0, 0, 0, 0x101, 0x101 }, "::1.1.1.1" }, 423 }; 424 425 for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) { 426 char stringified_addr[INET6_ADDRSTRLEN]; 427 struct in6_addr real_addr = generate_ipv6_addr(tests[i].addr_tuple); 428 EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr, 429 stringified_addr, INET6_ADDRSTRLEN)); 430 EXPECT_STREQ(tests[i].output, stringified_addr); 431 } 432} 433 434TEST(SocketUtilityFunctions, Inet_ntop_failure) { 435 char addr_name[INET6_ADDRSTRLEN]; 436 uint16_t addr6_tuple[8] = { 0xffff, 0xffff, 0xffff, 0xffff, 437 0xffff, 0xffff, 0xffff, 0xffff }; 438 uint8_t addr_tuple[4] = { 255, 255, 255, 255 }; 439 struct in6_addr ipv6_addr = generate_ipv6_addr(addr6_tuple); 440 struct in_addr ipv4_addr = generate_ipv4_addr(addr_tuple); 441 442 EXPECT_EQ(NULL, inet_ntop(AF_UNIX, &ipv6_addr, 443 addr_name, INET6_ADDRSTRLEN)); 444 EXPECT_EQ(EAFNOSUPPORT, errno); 445 446 EXPECT_EQ(NULL, inet_ntop(AF_INET, &ipv4_addr, 447 addr_name, INET_ADDRSTRLEN - 1)); 448 EXPECT_EQ(ENOSPC, errno); 449 450 EXPECT_EQ(NULL, inet_ntop(AF_INET6, &ipv6_addr, 451 addr_name, INET6_ADDRSTRLEN / 2)); 452 EXPECT_EQ(ENOSPC, errno); 453} 454 455TEST(SocketUtilityFunctions, Inet_pton) { 456 struct { 457 int family; 458 const char* input; 459 const char* output; // NULL means output should match input 460 } tests[] = { 461 { AF_INET, "127.127.12.0", NULL }, 462 { AF_INET, "0.0.0.0", NULL }, 463 464 { AF_INET6, "0:0:0:0:0:0:0:0", "::" }, 465 { AF_INET6, "1234:5678:9abc:def0:1234:5678:9abc:def0", NULL }, 466 { AF_INET6, "1:2:3:4:5:6:7:8", NULL }, 467 { AF_INET6, "a:b:c:d:e:f:1:2", NULL }, 468 { AF_INET6, "A:B:C:D:E:F:1:2", "a:b:c:d:e:f:1:2" }, 469 { AF_INET6, "::", "::" }, 470 { AF_INET6, "::12", "::12" }, 471 { AF_INET6, "::1:2:3", "::1:2:3" }, 472 { AF_INET6, "12::", "12::" }, 473 { AF_INET6, "1:2::", "1:2::" }, 474 { AF_INET6, "12:0:0:0:0:0:0:0", "12::" }, 475 { AF_INET6, "1:2:3::4:5", "1:2:3::4:5" }, 476 { AF_INET6, "::ffff:1.1.1.1", "::ffff:1.1.1.1" }, 477 { AF_INET6, "ffff::1.1.1.1", "ffff::101:101" }, 478 { AF_INET6, "::1.1.1.1", "::1.1.1.1" }, 479 }; 480 481 for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) { 482 uint8_t addr[16]; 483 ASSERT_TRUE(inet_pton(tests[i].family, tests[i].input, addr)) 484 << "inet_pton failed for " << tests[i].input; 485 const char* expected = tests[i].output ? tests[i].output : tests[i].input; 486 char out_buffer[256]; 487 ASSERT_EQ(out_buffer, 488 inet_ntop(tests[i].family, addr, out_buffer, sizeof(out_buffer))); 489 ASSERT_STREQ(expected, out_buffer); 490 } 491} 492 493TEST(SocketUtilityFunctions, Inet_pton_failure) { 494 // All these are examples of strings that do not map 495 // to IP address. inet_pton returns 0 on failure. 496 uint8_t addr[16]; 497 EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.24312", &addr)); 498 EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.24 ", &addr)); 499 EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.0.1", &addr)); 500 EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12. 0", &addr)); 501 EXPECT_EQ(0, inet_pton(AF_INET, " 127.127.12.0", &addr)); 502 EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.0.", &addr)); 503 EXPECT_EQ(0, inet_pton(AF_INET, ".127.127.12.0", &addr)); 504 EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.0x0", &addr)); 505 506 EXPECT_EQ(0, inet_pton(AF_INET6, ":::", &addr)); 507 EXPECT_EQ(0, inet_pton(AF_INET6, "0:::0", &addr)); 508 EXPECT_EQ(0, inet_pton(AF_INET6, "0::0:0::1", &addr)); 509 EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1: 2", &addr)); 510 EXPECT_EQ(0, inet_pton(AF_INET6, " 0:0:0:0:0:0:1:2", &addr)); 511 EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1:2 ", &addr)); 512 EXPECT_EQ(0, inet_pton(AF_INET6, ":0:0:0:0:0:0:1:2", &addr)); 513 EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1:2:4", &addr)); 514 EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1:0.0.0.0", &addr)); 515 EXPECT_EQ(0, inet_pton(AF_INET6, "::0.0.0.0:1", &addr)); 516 EXPECT_EQ(0, inet_pton(AF_INET6, "::0.0.0.0.0", &addr)); 517 EXPECT_EQ(0, inet_pton(AF_INET6, "::1.2.3.4.5.6.7.8", &addr)); 518} 519 520TEST(SocketUtilityFunctions, Ntohs) { 521 uint8_t network_bytes[2] = { 0x22, 0x11 }; 522 uint16_t network_short; 523 memcpy(&network_short, network_bytes, 2); 524 uint16_t host_short = ntohs(network_short); 525 EXPECT_EQ(host_short, 0x2211); 526} 527 528TEST(SocketUtilityFunctions, Ntohl) { 529 uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 }; 530 uint32_t network_long; 531 memcpy(&network_long, network_bytes, 4); 532 uint32_t host_long = ntohl(network_long); 533 EXPECT_EQ(host_long, 0x44332211); 534} 535 536#endif // PROVIDES_SOCKETPAIR_API 537