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 248 matching lines @@
   EXPECT_LT(ki_socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
   EXPECT_EQ(errno, EAFNOSUPPORT);
   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__) 
+#if !defined(__GLIBC__)
+
+TEST(SocketUtilityFunctions, Htonl) {
+  uint32_t host_long = 0x44332211;

[Sam Clegg, 2013/08/08 01:47:25]

Doesn't this test depend on the byte order of the host?

Presumably you need some kind of conditional based
on the endianness of the host?

[binji, 2013/08/08 16:07:21]

Do we have a big-endian NaCl?

[torinmr, 2013/08/08 17:01:22]

I believe this works on any host byte order: 0x44332211 is the number with 0x44
in the most significant byte, 0x33 in the next most significant byte, etc. This
is true whatever the endianness of the host system. After converting the number
to network byte order, the result should have 0x44 in the first byte, 0x33 in
the second, etc., which is what I'm testing.

On 2013/08/08 01:47:25, Sam Clegg wrote:

[Sam Clegg, 2013/08/08 17:21:39]

Ha!  I stand corrected.  Very good.

+  uint32_t network_long = htonl(host_long);
+  uint8_t network_bytes[4];
+  memcpy(network_bytes, &network_long, 4);

[Sam Clegg, 2013/08/08 01:47:25]

Just use a cast maybe?

[binji, 2013/08/08 16:07:21]

I disagree, that breaks strict aliasing. See above.

[torinmr, 2013/08/08 17:01:22]

I tried that first, but then the compiler complained about dereferencing punned
pointers, so I did this instead.

On 2013/08/08 01:47:25, Sam Clegg wrote:

[Sam Clegg, 2013/08/08 17:21:39]

Fair enough.  Ben and the compiler and right I think.

+  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;
@@ skipping 85 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 = reinterpret_cast<uint16_t*>(network_bytes);
+  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 = reinterpret_cast<uint32_t*>(network_bytes);
+  uint32_t host_long = ntohl(*network_long);
+  EXPECT_EQ(host_long, 0x44332211);
+}
+
 #endif  // !defined(__GLIBC__)
 #endif  // PROVIDES_SOCKETPAIR_API