PPB_NetAddress_Private: add getter methods for sockaddr.

ppapi/shared_impl/private/net_address_private_impl.cc

 // Copyright (c) 2012 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/shared_impl/private/net_address_private_impl.h"
 
 #include <string.h>
 
 #include <string>
 
@@ skipping 10 matching lines @@
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/thunk.h"
 
 #if defined(OS_MACOSX)
 // This is a bit evil, but it's standard operating procedure for |s6_addr|....
 #define s6_addr16 __u6_addr.__u6_addr16
 #endif
 
 #if defined(OS_WIN)
-// The type of |sockaddr::sa_family|.
-typedef ADDRESS_FAMILY sa_family_t;
-
 #define s6_addr16 u.Word
 #endif
 
 // The net address interface doesn't have a normal C -> C++ thunk since it
 // doesn't actually have any proxy wrapping or associated objects; it's just a
 // call into base. So we implement the entire interface here, using the thunk
 // namespace so it magically gets hooked up in the proper places.
 
 namespace ppapi {
 
 namespace {
 
 // This assert fails on OpenBSD for an unknown reason at the moment.
 #if !defined(OS_OPENBSD)
 // Make sure the storage in |PP_NetAddress_Private| is big enough. (Do it here
 // since the data is opaque elsewhere.)
 COMPILE_ASSERT(sizeof(reinterpret_cast<PP_NetAddress_Private*>(0)->data) >=
                sizeof(sockaddr_storage), PP_NetAddress_Private_data_too_small);
 #endif
 
-inline sa_family_t GetFamily(const PP_NetAddress_Private& addr) {
-  return reinterpret_cast<const sockaddr*>(addr.data)->sa_family;
+uint16_t GetFamily(const PP_NetAddress_Private* addr) {
+  return reinterpret_cast<const sockaddr*>(addr->data)->sa_family;
+}
+
+uint16_t GetPort(const PP_NetAddress_Private* addr) {
+  if (GetFamily(addr) == AF_INET)  {
+    const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
+    return ntohs(a->sin_port);
+  } else if (GetFamily(addr) == AF_INET6)  {
+    const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
+    return ntohs(a->sin6_port);
+  }
+
+  return 0;
+}
+
+PP_Bool GetAddress(const PP_NetAddress_Private* addr,
+                   void* address,
+                   uint16_t address_size) {
+  if (GetFamily(addr) == AF_INET)  {
+    const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
+    if (address_size >= sizeof(a->sin_addr.s_addr))  {
+      memcpy(address, &(a->sin_addr.s_addr), sizeof(a->sin_addr.s_addr));
+      return PP_TRUE;
+    }
+  } else if (GetFamily(addr) == AF_INET6)  {
+    const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
+    if (address_size >= sizeof(a->sin6_addr.s6_addr)) {
+      memcpy(address, &(a->sin6_addr.s6_addr), sizeof(a->sin6_addr.s6_addr));
+      return PP_TRUE;
+    }
+  }
+
+  return PP_FALSE;
 }
 
 PP_Bool AreHostsEqual(const PP_NetAddress_Private* addr1,
                       const PP_NetAddress_Private* addr2) {
   if (!NetAddressPrivateImpl::ValidateNetAddress(*addr1) ||
       !NetAddressPrivateImpl::ValidateNetAddress(*addr2))
     return PP_FALSE;
 
-  if (GetFamily(*addr1) != GetFamily(*addr2))
+  if (GetFamily(addr1) != GetFamily(addr2))
     return PP_FALSE;
 
-  if (GetFamily(*addr1) == AF_INET) {
+  if (GetFamily(addr1) == AF_INET) {
     const sockaddr_in* a1 = reinterpret_cast<const sockaddr_in*>(addr1->data);
     const sockaddr_in* a2 = reinterpret_cast<const sockaddr_in*>(addr2->data);
     return PP_FromBool(a1->sin_addr.s_addr == a2->sin_addr.s_addr);
   }
 
-  if (GetFamily(*addr1) == AF_INET6) {
+  if (GetFamily(addr1) == AF_INET6) {
     const sockaddr_in6* a1 = reinterpret_cast<const sockaddr_in6*>(addr1->data);
     const sockaddr_in6* a2 = reinterpret_cast<const sockaddr_in6*>(addr2->data);
     return PP_FromBool(a1->sin6_flowinfo == a2->sin6_flowinfo &&
                        memcmp(&a1->sin6_addr, &a2->sin6_addr,
                               sizeof(a1->sin6_addr)) == 0 &&
                        a1->sin6_scope_id == a2->sin6_scope_id);
   }
 
   return PP_FALSE;
 }
 
 PP_Bool AreEqual(const PP_NetAddress_Private* addr1,
                  const PP_NetAddress_Private* addr2) {
   // |AreHostsEqual()| will also validate the addresses and return false if
   // either is invalid.
   if (!AreHostsEqual(addr1, addr2))
     return PP_FALSE;
 
   // Note: Here, we know that |addr1| and |addr2| have the same family.
-  if (GetFamily(*addr1) == AF_INET) {
+  if (GetFamily(addr1) == AF_INET) {
     const sockaddr_in* a1 = reinterpret_cast<const sockaddr_in*>(addr1->data);
     const sockaddr_in* a2 = reinterpret_cast<const sockaddr_in*>(addr2->data);
     return PP_FromBool(a1->sin_port == a2->sin_port);
   }
 
-  if (GetFamily(*addr1) == AF_INET6) {
+  if (GetFamily(addr1) == AF_INET6) {
     const sockaddr_in6* a1 = reinterpret_cast<const sockaddr_in6*>(addr1->data);
     const sockaddr_in6* a2 = reinterpret_cast<const sockaddr_in6*>(addr2->data);
     return PP_FromBool(a1->sin6_port == a2->sin6_port);
   }
 
   return PP_FALSE;
 }
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 std::string ConvertIPv4AddressToString(const sockaddr_in* a,
@@ skipping 90 matching lines @@
                 PP_Bool include_port) {
   if (!NetAddressPrivateImpl::ValidateNetAddress(*addr))
     return PP_MakeUndefined();
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
   // On Windows, |NetAddressToString()| doesn't work in the sandbox. On Mac,
   // the output isn't consistent with RFC 5952, at least on Mac OS 10.6:
   // |getnameinfo()| collapses length-one runs of zeros (and also doesn't
   // display the scope).
   // TODO(viettrungluu): Consider switching to this on Linux.
-  switch (GetFamily(*addr)) {
+  switch (GetFamily(addr)) {
     case AF_INET: {
       const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
       return StringVar::StringToPPVar(
           ConvertIPv4AddressToString(a, !!include_port));
     }
     case AF_INET6: {
       const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
       return StringVar::StringToPPVar(
           ConvertIPv6AddressToString(a, !!include_port));
     }
@@ skipping 11 matching lines @@
   return StringVar::StringToPPVar(description);
 #endif
 }
 
 PP_Bool ReplacePort(const struct PP_NetAddress_Private* src_addr,
                     uint16_t port,
                     struct PP_NetAddress_Private* dest_addr) {
   if (!NetAddressPrivateImpl::ValidateNetAddress(*src_addr))
     return PP_FALSE;
 
-  if (GetFamily(*src_addr) == AF_INET) {
+  if (GetFamily(src_addr) == AF_INET) {
     memmove(dest_addr, src_addr, sizeof(*src_addr));
     reinterpret_cast<sockaddr_in*>(dest_addr->data)->sin_port = htons(port);
     return PP_TRUE;
   }
 
-  if (GetFamily(*src_addr) == AF_INET6) {
+  if (GetFamily(src_addr) == AF_INET6) {
     memmove(dest_addr, src_addr, sizeof(*src_addr));
     reinterpret_cast<sockaddr_in6*>(dest_addr->data)->sin6_port = htons(port);
     return PP_TRUE;
   }
 
   return PP_FALSE;
 }
 
 void GetAnyAddress(PP_Bool is_ipv6, PP_NetAddress_Private* addr) {
   memset(addr->data, 0, arraysize(addr->data) * sizeof(addr->data[0]));
   if (is_ipv6) {
     sockaddr_in6* a = reinterpret_cast<sockaddr_in6*>(addr->data);
     addr->size = sizeof(*a);
     a->sin6_family = AF_INET6;
     a->sin6_addr = in6addr_any;
   } else {
     sockaddr_in* a = reinterpret_cast<sockaddr_in*>(addr->data);
     addr->size = sizeof(*a);
     a->sin_family = AF_INET;
     a->sin_addr.s_addr = INADDR_ANY;
   }
 }
 
-const PPB_NetAddress_Private net_address_private_interface = {
+const PPB_NetAddress_Private_0_1 net_address_private_interface_0_1 = {
   &AreEqual,
   &AreHostsEqual,
   &Describe,
   &ReplacePort,
   &GetAnyAddress
 };
 
+const PPB_NetAddress_Private_1_0 net_address_private_interface_1_0 = {
+  &AreEqual,
+  &AreHostsEqual,
+  &Describe,
+  &ReplacePort,
+  &GetAnyAddress,
+  &GetFamily,
+  &GetPort,
+  &GetAddress
+};
+
 }  // namespace
 
 namespace thunk {
 
 PPAPI_THUNK_EXPORT const PPB_NetAddress_Private_0_1*
 GetPPB_NetAddress_Private_0_1_Thunk() {
-  return &net_address_private_interface;
+  return &net_address_private_interface_0_1;
+}
+
+PPAPI_THUNK_EXPORT const PPB_NetAddress_Private_1_0*
+GetPPB_NetAddress_Private_1_0_Thunk() {
+  return &net_address_private_interface_1_0;
 }
 
 }  // namespace thunk
 
 // static
 const PP_NetAddress_Private NetAddressPrivateImpl::kInvalidNetAddress = { 0 };
 
 // static
 bool NetAddressPrivateImpl::ValidateNetAddress(
     const PP_NetAddress_Private& addr) {
   if (addr.size < sizeof(reinterpret_cast<sockaddr*>(0)->sa_family))
     return false;
 
   // TODO(viettrungluu): more careful validation?
   // Just do a size check for AF_INET.
-  if (GetFamily(addr) == AF_INET && addr.size >= sizeof(sockaddr_in))
+  if (GetFamily(&addr) == AF_INET && addr.size >= sizeof(sockaddr_in))
     return true;
 
   // Ditto for AF_INET6.
-  if (GetFamily(addr) == AF_INET6 && addr.size >= sizeof(sockaddr_in6))
+  if (GetFamily(&addr) == AF_INET6 && addr.size >= sizeof(sockaddr_in6))
     return true;
 
   // Reject everything else.
   return false;
 }
 
 // static
 bool NetAddressPrivateImpl::SockaddrToNetAddress(
     const sockaddr* sa,
     uint32_t sa_length,
@@ skipping 52 matching lines @@
   net::IPEndPoint ip_end_point;
   if (!NetAddressToIPEndPoint(net_addr, &ip_end_point))
     return false;
 
   *address_list = net::AddressList::CreateFromIPAddress(ip_end_point.address(),
                                                         ip_end_point.port());
   return true;
 }
 
 }  // namespace ppapi