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