Add CreateFromIPv[46]Address() in PPB_NetAddress_Private.

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 69 matching lines @@
       return 0;
   }
 }
 
 PP_Bool GetAddress(const PP_NetAddress_Private* addr,
                    void* address,
                    uint16_t address_size) {
   switch (GetFamilyInternal(addr)) {
     case AF_INET: {
       const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
       if (address_size >= sizeof(a->sin_addr.s_addr))  {

[viettrungluu, 2012/03/22 04:54:34]

While you're here, could you get rid of the extra space before the '{'? (Since I
noticed it just now....)

[Sergey Ulanov, 2012/03/22 17:43:48]

Done.

         memcpy(address, &(a->sin_addr.s_addr), sizeof(a->sin_addr.s_addr));
         return PP_TRUE;
       }
       break;
     }
     case 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;
       }
       break;
     }
     default:
       break;
   }
 
   return PP_FALSE;
 }
 
+uint32_t GetScopeID(const PP_NetAddress_Private* addr) {
+  switch (GetFamilyInternal(addr)) {
+    case AF_INET6: {
+      const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
+      return ntohs(a->sin6_scope_id);
+    }
+    default:
+      return 0;
+  }
+}
+
 PP_Bool AreHostsEqual(const PP_NetAddress_Private* addr1,
                       const PP_NetAddress_Private* addr2) {
   if (!NetAddressPrivateImpl::ValidateNetAddress(*addr1) ||
       !NetAddressPrivateImpl::ValidateNetAddress(*addr2))
     return PP_FALSE;
 
   sa_family_t addr1_family = GetFamilyInternal(addr1);
   if (addr1_family != GetFamilyInternal(addr2))
     return PP_FALSE;
 
@@ skipping 202 matching lines @@
     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;
   }
 }
 
+void CreateFromIPv4Address(const uint8_t ip[4],
+                           uint16_t port,
+                           struct PP_NetAddress_Private* addr_out) {
+  memset(addr_out->data, 0,
+         arraysize(addr_out->data) * sizeof(addr_out->data[0]));
+  sockaddr_in* a = reinterpret_cast<sockaddr_in*>(addr_out->data);

[dmichael (off chromium), 2012/03/21 19:33:17]

nit: a is not a very good name

[Sergey Ulanov, 2012/03/21 19:44:51]

It's consistent with the rest of the code in this file.

[viettrungluu, 2012/03/22 04:54:34]

Right, and since it's probably my fault: I think think it's okay due to the
proximity of usage; I don't really think |addr_as_sockaddr_in| or whatever would
be a great improvement.

(Okay, I admit it: I used |a| simply to avoid lots of ridiculous line breaks.)

+  addr_out->size = sizeof(*a);
+  a->sin_family = AF_INET;
+  memcpy(&(a->sin_addr), ip, sizeof(a->sin_addr));
+  a->sin_port = htons(port);
+}
+
+void CreateFromIPv6Address(const uint8_t ip[16],
+                           uint32_t scope_id,
+                           uint16_t port,
+                           struct PP_NetAddress_Private* addr_out) {
+  memset(addr_out->data, 0,
+         arraysize(addr_out->data) * sizeof(addr_out->data[0]));
+  sockaddr_in6* a = reinterpret_cast<sockaddr_in6*>(addr_out->data);
+  addr_out->size = sizeof(*a);
+  a->sin6_family = AF_INET6;
+  memcpy(&(a->sin6_addr), ip, sizeof(a->sin6_addr));
+  a->sin6_port = htons(port);
+  a->sin6_scope_id = scope_id;
+}
+
 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
 };
 
+const PPB_NetAddress_Private_1_1 net_address_private_interface_1_1 = {
+  &AreEqual,
+  &AreHostsEqual,
+  &Describe,
+  &ReplacePort,
+  &GetAnyAddress,
+  &GetFamily,
+  &GetPort,
+  &GetAddress,
+  &GetScopeID,
+  &CreateFromIPv4Address,
+  &CreateFromIPv6Address
+};
+
 }  // namespace
 
 namespace thunk {
 
 PPAPI_THUNK_EXPORT const PPB_NetAddress_Private_0_1*
 GetPPB_NetAddress_Private_0_1_Thunk() {
   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;
 }
 
+PPAPI_THUNK_EXPORT const PPB_NetAddress_Private_1_1*
+GetPPB_NetAddress_Private_1_1_Thunk() {
+  return &net_address_private_interface_1_1;
+}
+
 }  // 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;
@@ skipping 77 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