Pepper: Implement PPB_NetAddress_Private Describe() for IPv6 addresses on Windows.

ppapi/tests/test_net_address_private.cc

 // Copyright (c) 2011 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 "ppapi/tests/test_net_address_private.h"
 
 #include "ppapi/cpp/private/net_address_private.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/tests/testing_instance.h"
 
@@ skipping 16 matching lines @@
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #endif
 
 using pp::NetAddressPrivate;
 
 namespace {
 
+// |host| should be an IP address represented as text, e.g., "192.168.0.1".
 PP_NetAddress_Private MakeIPv4NetAddress(const char* host, int port) {
   PP_NetAddress_Private addr = PP_NetAddress_Private();
   addr.size = sizeof(sockaddr_in);
   sockaddr_in* a = reinterpret_cast<sockaddr_in*>(addr.data);
   a->sin_family = AF_INET;
   a->sin_port = htons(port);
   a->sin_addr.s_addr = inet_addr(host);
   return addr;
 }
 
-// TODO(viettrungluu): Also add IPv6 tests.
+// |host| should be an array of eight 16-bit numbers.
+PP_NetAddress_Private MakeIPv6NetAddress(const uint16_t host[], uint16_t port,
+                                         uint32_t scope_id) {
+  PP_NetAddress_Private addr = PP_NetAddress_Private();
+  addr.size = sizeof(sockaddr_in6);
+  sockaddr_in6* a = reinterpret_cast<sockaddr_in6*>(addr.data);
+  a->sin6_family = AF_INET6;
+  a->sin6_port = htons(port);
+  a->sin6_flowinfo = 0;

[dmichael (off chromium), 2011/11/17 04:41:46]

Would it maybe be safer to use a sockaddr_in6 on the stack and then memcpy it to
data? That would avoid any possible alignment problems.

[viettrungluu, 2011/11/17 20:22:56]

That's a good point, though in that case I should change various code elsewhere
too. Maybe it's better/easier/less error-prone overall if I add appropriate
alignment assertions about PP_NetAddress_Private? WDYT?

+  for (int i = 0; i < 8; i++)
+    a->sin6_addr.s6_addr16[i] = htons(host[i]);
+  a->sin6_scope_id = scope_id;
+  return addr;
+}
 
 }  // namespace
 
 REGISTER_TEST_CASE(NetAddressPrivate);
 
 TestNetAddressPrivate::TestNetAddressPrivate(TestingInstance* instance)
     : TestCase(instance) {
 }
 
 bool TestNetAddressPrivate::Init() {
   return NetAddressPrivate::IsAvailable();
 }
 
 void TestNetAddressPrivate::RunTest() {
   RUN_TEST(AreEqual);
   RUN_TEST(AreHostsEqual);
   RUN_TEST(Describe);
   RUN_TEST(ReplacePort);
   RUN_TEST(GetAnyAddress);
+
+  RUN_TEST(DescribeIPv6);
 }
 
 std::string TestNetAddressPrivate::TestAreEqual() {
   // No comparisons should ever be done with invalid addresses.
   PP_NetAddress_Private invalid = PP_NetAddress_Private();
   ASSERT_FALSE(NetAddressPrivate::AreEqual(invalid, invalid));
 
   PP_NetAddress_Private localhost_80 = MakeIPv4NetAddress("127.0.0.1", 80);
   ASSERT_TRUE(NetAddressPrivate::AreEqual(localhost_80, localhost_80));
   ASSERT_FALSE(NetAddressPrivate::AreEqual(localhost_80, invalid));
@@ skipping 71 matching lines @@
   PP_NetAddress_Private result = PP_NetAddress_Private();
 
   NetAddressPrivate::GetAnyAddress(false, &result);
   ASSERT_TRUE(NetAddressPrivate::AreEqual(result, result));
 
   NetAddressPrivate::GetAnyAddress(true, &result);
   ASSERT_TRUE(NetAddressPrivate::AreEqual(result, result));
 
   PASS();
 }
+
+// TODO(viettrungluu): More IPv6 tests needed.
+
+std::string TestNetAddressPrivate::TestDescribeIPv6() {
+  static const uint16_t a1[8] = { 0x1234, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef };
+  PP_NetAddress_Private addr1 = MakeIPv6NetAddress(a1, 1234, 789);
+  ASSERT_EQ("1234:abcd:0:1::cdef%789",
+            NetAddressPrivate::Describe(addr1, false));
+  ASSERT_EQ("[1234:abcd:0:1::cdef%789]:1234",
+            NetAddressPrivate::Describe(addr1, true));
+
+  static const uint16_t a2[8] = { 0x12, 0xabcd, 0, 0x0001, 0, 0, 0, 0xcdef };
+  PP_NetAddress_Private addr2 = MakeIPv6NetAddress(a2, 12, 0);
+  ASSERT_EQ("12:abcd:0:1::cdef",
+            NetAddressPrivate::Describe(addr2, false));
+  ASSERT_EQ("[12:abcd:0:1::cdef]:12",
+            NetAddressPrivate::Describe(addr2, true));
+
+  static const uint16_t a3[8] = { 0, 0, 0, 0x0123, 0, 0, 0, 0 };
+  PP_NetAddress_Private addr3 = MakeIPv6NetAddress(a3, 123, 0);
+  ASSERT_EQ("0:0:0:123::",
+            NetAddressPrivate::Describe(addr3, false));
+  ASSERT_EQ("[0:0:0:123::]:123",
+            NetAddressPrivate::Describe(addr3, true));
+
+  static const uint16_t a4[8] = { 0x1234, 0xabcd, 0, 0, 0xff, 0, 0, 0xcdef };
+  PP_NetAddress_Private addr4 = MakeIPv6NetAddress(a4, 123, 0);
+  ASSERT_EQ("1234:abcd::ff:0:0:cdef",
+            NetAddressPrivate::Describe(addr4, false));
+  ASSERT_EQ("[1234:abcd::ff:0:0:cdef]:123",
+            NetAddressPrivate::Describe(addr4, true));
+
+  static const uint16_t a5[8] = { 0, 0xa, 1, 2, 3, 0, 5, 0 };
+  PP_NetAddress_Private addr5 = MakeIPv6NetAddress(a5, 123, 0);
+  ASSERT_EQ("0:a:1:2:3:0:5:0",
+            NetAddressPrivate::Describe(addr5, false));
+  ASSERT_EQ("[0:a:1:2:3:0:5:0]:123",
+            NetAddressPrivate::Describe(addr5, true));
+
+  static const uint16_t a6[8] = { 0, 0xa, 1, 2, 3, 0, 0, 0 };
+  PP_NetAddress_Private addr6 = MakeIPv6NetAddress(a6, 123, 0);
+  ASSERT_EQ("0:a:1:2:3::",
+            NetAddressPrivate::Describe(addr6, false));
+  ASSERT_EQ("[0:a:1:2:3::]:123",
+            NetAddressPrivate::Describe(addr6, true));
+
+  static const uint16_t a7[8] = { 0, 0, 0, 2, 3, 0, 0, 0 };
+  PP_NetAddress_Private addr7 = MakeIPv6NetAddress(a7, 123, 0);
+  ASSERT_EQ("::2:3:0:0:0",
+            NetAddressPrivate::Describe(addr7, false));
+  ASSERT_EQ("[::2:3:0:0:0]:123",
+            NetAddressPrivate::Describe(addr7, true));
+
+  PASS();
+}