Adds htonl, htons, ntohl, and ntohs to newlib

native_client_sdk/src/libraries/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 <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <sys/stat.h>
 
 #include <map>
 #include <string>
@@ skipping 250 matching lines @@
   EXPECT_LT(ki_socketpair(AF_INET, SOCK_STREAM, 0, sv), 0);
   EXPECT_EQ(errno, EPROTONOSUPPORT);
   EXPECT_LT(ki_socketpair(AF_INET6, SOCK_STREAM, 0, sv), 0);
   EXPECT_EQ(errno, EPROTONOSUPPORT);
 }
 
 // These utility functions are only used for newlib (glibc provides its own
 // implementations of these functions).
 #if !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) {
   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);
-  struct in_addr* real_addr = reinterpret_cast<struct in_addr*>(addr);
-  return *real_addr;
+  struct in_addr real_addr;
+  memcpy(&real_addr, addr, 4);
+  return real_addr;
 }
 
 static struct in6_addr generate_ipv6_addr(int* tuples) {
   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;
   }
-  struct in6_addr* real_addr = reinterpret_cast<struct in6_addr*>(addr);
-  return *real_addr;
+  struct in6_addr real_addr;
+  memcpy(&real_addr, addr, 16);
+  return real_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);
 
   stringified_addr = inet_ntoa(generate_ipv4_addr(127,0,0,1));
   ASSERT_TRUE(NULL != stringified_addr);
   EXPECT_STREQ("127.0.0.1", stringified_addr);
@@ skipping 65 matching lines @@
 
   EXPECT_TRUE(NULL == inet_ntop(AF_INET, &ipv4_addr,
                                 addr_name, INET_ADDRSTRLEN - 1));
   EXPECT_EQ(errno, ENOSPC);
 
   EXPECT_TRUE(NULL == inet_ntop(AF_INET6, &ipv6_addr,
                                 addr_name, INET6_ADDRSTRLEN - 1));
   EXPECT_EQ(errno, ENOSPC);
 }
 
+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