[NaCl SDK] Add fake for ppb_host_resolver and ppb_net_address

native_client_sdk/src/libraries/nacl_io/host_resolver.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 "nacl_io/host_resolver.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "nacl_io/kernel_proxy.h"
@@ skipping 16 matching lines @@
 }
 
 struct hostent* HostResolver::gethostbyname(const char* name) {
   h_errno = NETDB_INTERNAL;
 
   if (NULL == ppapi_)
     return NULL;
 
   HostResolverInterface* resolver_interface =
     ppapi_->GetHostResolverInterface();
+
+  if (NULL == resolver_interface)
+    return NULL;
+
   ScopedResource resolver(ppapi_,
                           resolver_interface->Create(ppapi_->GetInstance()));
 
   struct PP_CompletionCallback callback;
   callback.func = NULL;
   struct PP_HostResolver_Hint hint;
   hint.family = PP_NETADDRESS_FAMILY_IPV4;
   hint.flags = PP_HOSTRESOLVER_FLAG_CANONNAME;
 
   int err = resolver_interface->Resolve(resolver.pp_resource(),
@@ skipping 34 matching lines @@
     // get an empty string we copy over the input string instead.
     len = strlen(name);
     name_ptr = name;
   }
   hostent_.h_name = static_cast<char*>(malloc(len + 1));
   if (NULL == hostent_.h_name)
     return NULL;
   memcpy(hostent_.h_name, name_ptr, len);
   hostent_.h_name[len] = '\0';
 
+  ppapi_->GetVarInterface()->Release(name_var);
+
   // Aliases aren't supported at the moment, so we just make an empty list.
   hostent_.h_aliases = static_cast<char**>(malloc(sizeof(char*)));
   if (NULL == hostent_.h_aliases)
     return NULL;
   hostent_.h_aliases[0] = NULL;
 
   NetAddressInterface* netaddr_interface = ppapi_->GetNetAddressInterface();
   PP_Resource addr =
       resolver_interface->GetNetAddress(resolver.pp_resource(), 0);
-  if (!PP_ToBool(netaddr_interface->IsNetAddress(addr)))
+  if (!PP_ToBool(netaddr_interface->IsNetAddress(addr))) {
+    ppapi_->ReleaseResource(addr);
     return NULL;
+  }
 
   switch (netaddr_interface->GetFamily(addr)) {
     case PP_NETADDRESS_FAMILY_IPV4:
       hostent_.h_addrtype = AF_INET;
       hostent_.h_length = 4;
       break;
     case PP_NETADDRESS_FAMILY_IPV6:
       hostent_.h_addrtype = AF_INET6;
       hostent_.h_length = 16;
       break;
     default:
+      ppapi_->ReleaseResource(addr);
       return NULL;
   }
 
+  ppapi_->ReleaseResource(addr);
+
   const uint32_t num_addresses =
     resolver_interface->GetNetAddressCount(resolver.pp_resource());
   if (0 == num_addresses)
     return NULL;
   hostent_.h_addr_list =
     static_cast<char**>(calloc(num_addresses + 1, sizeof(char*)));
   if (NULL == hostent_.h_addr_list)
     return NULL;
 
   for (uint32_t i = 0; i < num_addresses; i++) {
     PP_Resource addr =
       resolver_interface->GetNetAddress(resolver.pp_resource(), i);
-    if (!PP_ToBool(netaddr_interface->IsNetAddress(addr)))
+    if (!PP_ToBool(netaddr_interface->IsNetAddress(addr))) {
+      ppapi_->ReleaseResource(addr);

[binji, 2014/01/28 18:13:22]

You can use a ScopedResource (see pepper_interface.h) to prevent having to clean
this up everywhere.

[Sam Clegg, 2014/01/28 19:55:22]

Done.

       return NULL;
+    }
     if (AF_INET == hostent_.h_addrtype) {
       struct PP_NetAddress_IPv4 addr_struct;
       if (!netaddr_interface->DescribeAsIPv4Address(addr, &addr_struct)) {
+        ppapi_->ReleaseResource(addr);
         return NULL;
       }
       hostent_.h_addr_list[i] = static_cast<char*>(malloc(hostent_.h_length));
-      if (NULL == hostent_.h_addr_list[i])
+      if (NULL == hostent_.h_addr_list[i]) {
+        ppapi_->ReleaseResource(addr);
         return NULL;
+      }
       memcpy(hostent_.h_addr_list[i], addr_struct.addr, hostent_.h_length);
     } else { // IPv6
       struct PP_NetAddress_IPv6 addr_struct;
-      if (!netaddr_interface->DescribeAsIPv6Address(addr, &addr_struct))
+      if (!netaddr_interface->DescribeAsIPv6Address(addr, &addr_struct)) {
+        ppapi_->ReleaseResource(addr);
         return NULL;
+      }
       hostent_.h_addr_list[i] = static_cast<char*>(malloc(hostent_.h_length));
-      if (NULL == hostent_.h_addr_list[i])
+      if (NULL == hostent_.h_addr_list[i]) {
+        ppapi_->ReleaseResource(addr);
         return NULL;
+      }
       memcpy(hostent_.h_addr_list[i], addr_struct.addr, hostent_.h_length);
     }
+    ppapi_->ReleaseResource(addr);
   }
   return &hostent_;
 }
 
 // Frees all of the deep pointers in a hostent struct. Called between uses of
 // gethostbyname, and when the kernel_proxy object is destroyed.
 void HostResolver::hostent_cleanup() {
   if (NULL != hostent_.h_name) {
     free(hostent_.h_name);
   }
@@ skipping 10 matching lines @@
     free(hostent_.h_addr_list);
   }
   hostent_.h_name = NULL;
   hostent_.h_aliases = NULL;
   hostent_.h_addr_list = NULL;
 }
 
 }  // namespace nacl_io
 
 #endif  // PROVIDES_SOCKET_API