[NaCl SDK] nacl_io: Fix inet_ntop to be consistent with glibc.

native_client_sdk/src/tests/nacl_io_test/socket_test.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 
 #include <map>
 #include <string>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include "nacl_io/kernel_intercept.h"
 #include "nacl_io/kernel_proxy.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/ostypes.h"
 
 #ifdef PROVIDES_SOCKET_API
 
+// When devloping tests for host resolution function is can be usefull

[binji, 2014/01/27 19:57:18]

When developing tests for host resolution it can be useful

[Sam Clegg, 2014/01/27 23:10:15]

Hmm, this should not be part of this CL.

Removed.

+// to compare results with the host glibc version.
+#if 0
+#define ki_getaddrinfo getaddrinfo
+#define ki_gethostbyname gethostbyname
+#define ki_freeaddrinfo freeaddrinfo
+#endif
+
 using namespace nacl_io;
 using namespace sdk_util;
 
 namespace {
 class SocketTest : public ::testing::Test {
  public:
   SocketTest() {}
 
   void SetUp() {
     ki_init(&kp_);
@@ skipping 225 matching lines @@
 
 // These utility functions are only used for newlib (glibc provides its own
 // implementations of these functions).
 #if !defined(__GLIBC__)
 
 TEST(SocketUtilityFunctions, Hstrerror) {
   EXPECT_STREQ(hstrerror(2718),
                "Unknown error in gethostbyname: 2718.");
 }
 
+#endif  // !defined(__GLIBC__)
+
 TEST(SocketUtilityFunctions, Htonl) {
   uint32_t host_long = 0x44332211;
   uint32_t network_long = htonl(host_long);
   uint8_t network_bytes[4];
   memcpy(network_bytes, &network_long, 4);
   EXPECT_EQ(network_bytes[0], 0x44);
   EXPECT_EQ(network_bytes[1], 0x33);
   EXPECT_EQ(network_bytes[2], 0x22);
   EXPECT_EQ(network_bytes[3], 0x11);
 }
 
 TEST(SocketUtilityFunctions, Htons) {
   uint16_t host_short = 0x2211;
   uint16_t network_short = htons(host_short);
   uint8_t network_bytes[2];
   memcpy(network_bytes, &network_short, 2);
   EXPECT_EQ(network_bytes[0], 0x22);
   EXPECT_EQ(network_bytes[1], 0x11);
 }
 
-static struct in_addr generate_ipv4_addr(int tuple1, int tuple2,
-                                         int tuple3, int tuple4) {
+static struct in_addr generate_ipv4_addr(uint8_t* tuple) {
   unsigned char addr[4];
-  addr[0] = static_cast<unsigned char>(tuple1);
-  addr[1] = static_cast<unsigned char>(tuple2);
-  addr[2] = static_cast<unsigned char>(tuple3);
-  addr[3] = static_cast<unsigned char>(tuple4);
+  addr[0] = static_cast<unsigned char>(tuple[0]);
+  addr[1] = static_cast<unsigned char>(tuple[1]);
+  addr[2] = static_cast<unsigned char>(tuple[2]);
+  addr[3] = static_cast<unsigned char>(tuple[3]);
   struct in_addr real_addr;
   memcpy(&real_addr, addr, 4);
   return real_addr;
 }
 
-static struct in6_addr generate_ipv6_addr(int* tuples) {
+static struct in6_addr generate_ipv6_addr(uint16_t* tuple) {
   unsigned char addr[16];
   for (int i = 0; i < 8; i++) {
-    addr[2*i] = (tuples[i] >> 8) & 0xFF;
-    addr[2*i+1] = tuples[i] & 0xFF;
+    addr[2*i] = (tuple[i] >> 8) & 0xFF;
+    addr[2*i+1] = tuple[i] & 0xFF;
   }
   struct in6_addr real_addr;
   memcpy(&real_addr, addr, 16);
   return real_addr;
 }
 
+TEST(SocketUtilityFunctions, Inet_addr) {
+   // Fails for anything other than

[binji, 2014/01/27 19:57:18]

other than...

[Sam Clegg, 2014/01/27 23:10:15]

Done.

+   ASSERT_EQ(INADDR_NONE, inet_addr("foobar"));
+
+   // Fails if there are too many quads
+   ASSERT_EQ(INADDR_NONE, inet_addr("0.0.0.0.0"));
+
+   // Fails if a single element is > 256
+   ASSERT_EQ(INADDR_NONE, inet_addr("999.0.0.0"));
+
+   // Fails if a single element is negative.
+   ASSERT_EQ(INADDR_NONE, inet_addr("-55.0.0.0"));
+
+   // Success cases
+   uint32_t expected_addr = ntohl(0x07060504);
+   ASSERT_EQ(expected_addr, inet_addr("7.6.5.4"));
+   expected_addr = ntohl(0xffffffff);
+   ASSERT_EQ(expected_addr, inet_addr("255.255.255.255"));
+}
+
+TEST(SocketUtilityFunctions, Inet_aton) {
+   struct in_addr addr;
+
+   // Failure cases
+   ASSERT_EQ(0, inet_aton("foobar", &addr));
+   ASSERT_EQ(0, inet_aton("0.0.0.0.0", &addr));
+   ASSERT_EQ(0, inet_aton("999.0.0.0", &addr));
+
+   // Success cases
+   uint32_t expected_addr = htonl(0xff020304);
+   ASSERT_NE(0, inet_aton("255.2.3.4", &addr));
+   ASSERT_EQ(expected_addr, addr.s_addr);
+
+   expected_addr = htonl(0x01000002);
+   ASSERT_NE(0, inet_aton("1.2", &addr));
+   ASSERT_EQ(expected_addr, addr.s_addr);
+
+   expected_addr = htonl(0x01020003);
+   ASSERT_NE(0, inet_aton("1.2.3", &addr));
+   ASSERT_EQ(expected_addr, addr.s_addr);
+
+   expected_addr = htonl(0x0000100);
+   ASSERT_NE(0, inet_aton("256", &addr));

[binji, 2014/01/27 19:57:18]

test larger numbers here and above? The spec says that x.x.y allows y as 16-bit,
and x.y allows y as 24-bit, and x as 32-bit value.

[Sam Clegg, 2014/01/27 23:10:15]

Done.

+   ASSERT_EQ(expected_addr, addr.s_addr);
+}
+
 TEST(SocketUtilityFunctions, Inet_ntoa) {
-  char* stringified_addr = inet_ntoa(generate_ipv4_addr(0,0,0,0));
-  ASSERT_TRUE(NULL != stringified_addr);
-  EXPECT_STREQ("0.0.0.0", stringified_addr);
+  struct {
+    unsigned char addr_tuple[4];
+    const char* output;
+  } tests[] = {
+    { { 0,   0,   0,   0   }, "0.0.0.0" },
+    { { 127, 0,   0,   1   }, "127.0.0.1" },
+    { { 255, 255, 255, 255 }, "255.255.255.255" },
+  };
 
-  stringified_addr = inet_ntoa(generate_ipv4_addr(127,0,0,1));
-  ASSERT_TRUE(NULL != stringified_addr);
-  EXPECT_STREQ("127.0.0.1", stringified_addr);
-
-  stringified_addr = inet_ntoa(generate_ipv4_addr(255,255,255,255));
-  ASSERT_TRUE(NULL != stringified_addr);
-  EXPECT_STREQ("255.255.255.255", stringified_addr);
+  for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) {
+    char* stringified_addr = inet_ntoa(generate_ipv4_addr(tests[i].addr_tuple));
+    ASSERT_TRUE(NULL != stringified_addr);
+    EXPECT_STREQ(tests[i].output, stringified_addr);
+  }
 }
 
 TEST(SocketUtilityFunctions, Inet_ntop_ipv4) {
-  char stringified_addr[INET_ADDRSTRLEN];
+  struct {
+    unsigned char addr_tuple[4];
+    const char* output;
+  } tests[] = {
+    { { 0,   0,   0,   0   }, "0.0.0.0" },
+    { { 127, 0,   0,   1   }, "127.0.0.1" },
+    { { 255, 255, 255, 255 }, "255.255.255.255" },
+  };
 
-  struct in_addr real_addr = generate_ipv4_addr(0,0,0,0);
-  EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
-                                stringified_addr, INET_ADDRSTRLEN));
-  EXPECT_STREQ("0.0.0.0", stringified_addr);
-
-  real_addr = generate_ipv4_addr(127,0,0,1);
-  EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
-                                stringified_addr, INET_ADDRSTRLEN));
-  EXPECT_STREQ("127.0.0.1", stringified_addr);
-
-  real_addr = generate_ipv4_addr(255,255,255,255);
-  EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
-                                stringified_addr, INET_ADDRSTRLEN));
-  EXPECT_STREQ("255.255.255.255", stringified_addr);
+  for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) {
+    char stringified_addr[INET_ADDRSTRLEN];
+    struct in_addr real_addr = generate_ipv4_addr(tests[i].addr_tuple);
+    EXPECT_TRUE(NULL != inet_ntop(AF_INET, &real_addr,
+                                  stringified_addr, INET_ADDRSTRLEN));
+    EXPECT_STREQ(tests[i].output, stringified_addr);
+  }
 }
 
 TEST(SocketUtilityFunctions, Inet_ntop_ipv6) {
-  char stringified_addr[INET6_ADDRSTRLEN];
+  struct {
+    unsigned short addr_tuple[8];
+    const char* output;
+  } tests[] = {
+    { { 0, 0, 0, 0, 0, 0, 0, 0 }, "::" },
+    { { 1, 2, 3, 0, 0, 0, 0, 0 }, "1:2:3::" },
+    { { 0, 0, 0, 0, 0, 1, 2, 3 }, "::1:2:3" },
+    { { 0x1234, 0xa, 0x12, 0x0000, 0x5678, 0x9abc, 0xdef, 0xffff },
+      "1234:a:12:0:5678:9abc:def:ffff" },
+    { { 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff },
+      "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" },
+    { { 0, 0, 0, 0, 0, 0xffff, 0x101, 0x101 }, "::ffff:1.1.1.1" },
+    { { 0, 0, 0, 0, 0, 0, 0x101, 0x101 }, "::1.1.1.1" },
+  };
 
-  {
-    int addr_tuples[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-    struct in6_addr real_addr = generate_ipv6_addr(addr_tuples);
+  for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) {
+    char stringified_addr[INET6_ADDRSTRLEN];
+    struct in6_addr real_addr = generate_ipv6_addr(tests[i].addr_tuple);
     EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr,
                                   stringified_addr, INET6_ADDRSTRLEN));
-    EXPECT_STREQ("0:0:0:0:0:0:0:0", stringified_addr);
-  }
-
-  {
-    int addr_tuples[8] = { 0x1234, 0xa, 0x12, 0x0000,
-                                0x5678, 0x9abc, 0xdef, 0xffff };
-    struct in6_addr real_addr = generate_ipv6_addr(addr_tuples);
-    EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr,
-                                  stringified_addr, INET6_ADDRSTRLEN));
-    EXPECT_STREQ("1234:a:12:0:5678:9abc:def:ffff", stringified_addr);
-  }
-
-  {
-    int addr_tuples[8] = { 0xffff, 0xffff, 0xffff, 0xffff,
-                                0xffff, 0xffff, 0xffff, 0xffff };
-    struct in6_addr real_addr = generate_ipv6_addr(addr_tuples);
-    EXPECT_TRUE(NULL != inet_ntop(AF_INET6, &real_addr,
-                                  stringified_addr, INET6_ADDRSTRLEN));
-    EXPECT_STREQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", stringified_addr);
+    EXPECT_STREQ(tests[i].output, stringified_addr);
   }
 }
 
 TEST(SocketUtilityFunctions, Inet_ntop_failure) {
   char addr_name[INET6_ADDRSTRLEN];
-  int addr_tuples[8] = { 0xffff, 0xffff, 0xffff, 0xffff,
+  uint16_t addr6_tuple[8] = { 0xffff, 0xffff, 0xffff, 0xffff,
                               0xffff, 0xffff, 0xffff, 0xffff };
-  struct in6_addr ipv6_addr = generate_ipv6_addr(addr_tuples);
-  struct in_addr ipv4_addr = generate_ipv4_addr(255,255,255,255);
+  uint8_t addr_tuple[4] = { 255, 255, 255, 255 };
+  struct in6_addr ipv6_addr = generate_ipv6_addr(addr6_tuple);
+  struct in_addr ipv4_addr = generate_ipv4_addr(addr_tuple);
 
-  EXPECT_TRUE(NULL == inet_ntop(AF_UNIX, &ipv6_addr,
-                                addr_name, INET6_ADDRSTRLEN));
-  EXPECT_EQ(errno, EAFNOSUPPORT);
+  EXPECT_EQ(NULL, inet_ntop(AF_UNIX, &ipv6_addr,
+                            addr_name, INET6_ADDRSTRLEN));
+  EXPECT_EQ(EAFNOSUPPORT, errno);
 
-  EXPECT_TRUE(NULL == inet_ntop(AF_INET, &ipv4_addr,
-                                addr_name, INET_ADDRSTRLEN - 1));
-  EXPECT_EQ(errno, ENOSPC);
+  EXPECT_EQ(NULL, inet_ntop(AF_INET, &ipv4_addr,
+                            addr_name, INET_ADDRSTRLEN - 1));
+  EXPECT_EQ(ENOSPC, errno);
 
-  EXPECT_TRUE(NULL == inet_ntop(AF_INET6, &ipv6_addr,
-                                addr_name, INET6_ADDRSTRLEN - 1));
-  EXPECT_EQ(errno, ENOSPC);
+  EXPECT_EQ(NULL, inet_ntop(AF_INET6, &ipv6_addr,
+                            addr_name, INET6_ADDRSTRLEN / 2));
+  EXPECT_EQ(ENOSPC, errno);
 }
 
 TEST(SocketUtilityFunctions, Inet_pton) {
   struct {
     int family;
     const char* input;
-    const char* output;
+    const char* output; // NULL means output should match input
   } tests[] = {
     { AF_INET, "127.127.12.0", NULL },
     { AF_INET, "0.0.0.0", NULL },
 
-    { AF_INET6, "0:0:0:0:0:0:0:0", NULL },
+    { AF_INET6, "0:0:0:0:0:0:0:0", "::" },
     { AF_INET6, "1234:5678:9abc:def0:1234:5678:9abc:def0", NULL },
     { AF_INET6, "1:2:3:4:5:6:7:8", NULL },
     { AF_INET6, "a:b:c:d:e:f:1:2", NULL },
     { AF_INET6, "A:B:C:D:E:F:1:2", "a:b:c:d:e:f:1:2" },
-    { AF_INET6, "::", "0:0:0:0:0:0:0:0" },
-    { AF_INET6, "::12", "0:0:0:0:0:0:0:12" },
-    { AF_INET6, "::1:2:3", "0:0:0:0:0:1:2:3" },
-    { AF_INET6, "12::", "12:0:0:0:0:0:0:0" },
-    { AF_INET6, "1:2::", "1:2:0:0:0:0:0:0" },
-    { AF_INET6, "::12:0:0:0:0:0:0:0", "12:0:0:0:0:0:0:0" },
-    { AF_INET6, "1:2:3::4:5", "1:2:3:0:0:0:4:5" },
-    { AF_INET6, "::1.1.1.1", "0:0:0:0:0:0:101:101" },
-    { AF_INET6, "::ffff:1.1.1.1", "0:0:0:0:0:ffff:101:101" },
-    { AF_INET6, "ffff::1.1.1.1", "ffff:0:0:0:0:0:101:101" },
-    { AF_INET6, "::1.1.1.1", "0:0:0:0:0:0:101:101" },
+    { AF_INET6, "::", "::" },
+    { AF_INET6, "::12", "::12" },
+    { AF_INET6, "::1:2:3", "::1:2:3" },
+    { AF_INET6, "12::", "12::" },
+    { AF_INET6, "1:2::", "1:2::" },
+    { AF_INET6, "12:0:0:0:0:0:0:0", "12::" },
+    { AF_INET6, "1:2:3::4:5", "1:2:3::4:5" },
+    { AF_INET6, "::ffff:1.1.1.1", "::ffff:1.1.1.1" },
+    { AF_INET6, "ffff::1.1.1.1", "ffff::101:101" },
+    { AF_INET6, "::1.1.1.1", "::1.1.1.1" },
   };
 
   for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i) {
     uint8_t addr[16];
-    EXPECT_TRUE(inet_pton(tests[i].family, tests[i].input, addr));
+    ASSERT_TRUE(inet_pton(tests[i].family, tests[i].input, addr))
+        << "inet_pton failed for " << tests[i].input;
     const char* expected = tests[i].output ? tests[i].output : tests[i].input;
     char out_buffer[256];
-    EXPECT_TRUE(
-        inet_ntop(tests[i].family, addr, out_buffer, sizeof(out_buffer)));
-    EXPECT_EQ(std::string(expected), std::string(out_buffer));
+    ASSERT_EQ(out_buffer,
+              inet_ntop(tests[i].family, addr, out_buffer, sizeof(out_buffer)));
+    ASSERT_STREQ(expected, out_buffer);
   }
 }
 
 TEST(SocketUtilityFunctions, Inet_pton_failure) {
+  // All these are examples of strings that do not map
+  // to IP address.  inet_pton returns 0 on failure.
   uint8_t addr[16];
   EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.24312", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.24 ", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.0.1", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12. 0", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, " 127.127.12.0", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.0.", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, ".127.127.12.0", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET, "127.127.12.0x0", &addr));
 
   EXPECT_EQ(0, inet_pton(AF_INET6, ":::", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "0:::0", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "0::0:0::1", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1: 2", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, " 0:0:0:0:0:0:1:2", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1:2 ", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, ":0:0:0:0:0:0:1:2", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1:2:4", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "0:0:0:0:0:0:1:0.0.0.0", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "::0.0.0.0:1", &addr));
   EXPECT_EQ(0, inet_pton(AF_INET6, "::0.0.0.0.0", &addr));
+  EXPECT_EQ(0, inet_pton(AF_INET6, "::1.2.3.4.5.6.7.8", &addr));
 }
 
 TEST(SocketUtilityFunctions, Ntohs) {
   uint8_t network_bytes[2] = { 0x22, 0x11 };
   uint16_t network_short;
   memcpy(&network_short, network_bytes, 2);
   uint16_t host_short = ntohs(network_short);
   EXPECT_EQ(host_short, 0x2211);
 }
 
 TEST(SocketUtilityFunctions, Ntohl) {
   uint8_t network_bytes[4] = { 0x44, 0x33, 0x22, 0x11 };
   uint32_t network_long;
   memcpy(&network_long, network_bytes, 4);
   uint32_t host_long = ntohl(network_long);
   EXPECT_EQ(host_long, 0x44332211);
 }
 
-#endif  // !defined(__GLIBC__)
 #endif  // PROVIDES_SOCKETPAIR_API