[NaCl SDK] Add some more logging to nacl_io.

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.
 
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS
 #endif
 
 #include "nacl_io/host_resolver.h"
 
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "nacl_io/kernel_proxy.h"
+#include "nacl_io/log.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/pepper_interface.h"
 
 #ifdef PROVIDES_SOCKET_API
 
 namespace {
 
 void HintsToPPHints(const addrinfo* hints, PP_HostResolver_Hint* pp_hints) {
   memset(pp_hints, 0, sizeof(*pp_hints));
 
@@ skipping 193 matching lines @@
   }
 }
 
 int HostResolver::getaddrinfo(const char* node,
                               const char* service,
                               const struct addrinfo* hints_in,
                               struct addrinfo** result) {
   *result = NULL;
   struct addrinfo* end = NULL;
 
-  if (node == NULL && service == NULL)
+  if (node == NULL && service == NULL) {
+    LOG_TRACE("node and service are NULL.");
     return EAI_NONAME;
+  }
 
   // Check the service name (port).  Currently we only handle numeric
   // services.
   long port = 0;
   if (service != NULL) {
     char* cp;
     port = strtol(service, &cp, 10);
     if (port >= 0 && port <= UINT16_MAX && *cp == '\0') {
       port = htons(port);
     } else {
+      LOG_TRACE("Service \"%s\" not supported.", service);
       return EAI_SERVICE;
     }
   }
 
   struct addrinfo default_hints;
   memset(&default_hints, 0, sizeof(default_hints));
   const struct addrinfo* hints = hints_in ? hints_in : &default_hints;
 
   // Verify values passed in hints structure
   switch (hints->ai_family) {
     case AF_INET6:
     case AF_INET:
     case AF_UNSPEC:
       break;
     default:
+      LOG_TRACE("Unknown family: %d.", hints->ai_family);
       return EAI_FAMILY;
   }
 
   struct sockaddr_in addr_in;
   memset(&addr_in, 0, sizeof(addr_in));
   addr_in.sin_family = AF_INET;
   addr_in.sin_port = port;
 
   struct sockaddr_in6 addr_in6;
   memset(&addr_in6, 0, sizeof(addr_in6));
@@ skipping 29 matching lines @@
       CreateAddrInfo(hints, (sockaddr*)&addr_in6, NULL, result, &end);
     }
 
     if (hints->ai_family == AF_INET || hints->ai_family == AF_UNSPEC) {
       addr_in.sin_addr.s_addr = INADDR_ANY;
       CreateAddrInfo(hints, (sockaddr*)&addr_in, NULL, result, &end);
     }
     return 0;
   }
 
-  if (NULL == ppapi_)
+  if (NULL == ppapi_) {
+    LOG_ERROR("ppapi_ is NULL.");
     return EAI_SYSTEM;
+  }
 
   // Use PPAPI interface to resolve nodename
   HostResolverInterface* resolver_iface = ppapi_->GetHostResolverInterface();
-  VarInterface* var_interface = ppapi_->GetVarInterface();
+  VarInterface* var_iface = ppapi_->GetVarInterface();
   NetAddressInterface* netaddr_iface = ppapi_->GetNetAddressInterface();
 
-  if (NULL == resolver_iface || NULL == var_interface || NULL == netaddr_iface)
+  if (!(resolver_iface && var_iface && netaddr_iface)) {
+    LOG_ERROR("Got NULL interface(s): %s%s%s",
+              resolver_iface ? "" : "HostResolver ",
+              var_iface ? "" : "Var ",
+              netaddr_iface ? "" : "NetAddress");
     return EAI_SYSTEM;
+  }
 
   ScopedResource scoped_resolver(ppapi_,
                                  resolver_iface->Create(ppapi_->GetInstance()));
   PP_Resource resolver = scoped_resolver.pp_resource();
 
   struct PP_HostResolver_Hint pp_hints;
   HintsToPPHints(hints, &pp_hints);
 
   int err = resolver_iface->Resolve(resolver,
                                     node,
                                     0,
                                     &pp_hints,
                                     PP_BlockUntilComplete());
   if (err) {
     switch (err) {
       case PP_ERROR_NOACCESS:
         return EAI_SYSTEM;
       case PP_ERROR_NAME_NOT_RESOLVED:
         return EAI_NONAME;
       default:
         return EAI_SYSTEM;
     }
   }
 
   char* canon_name = NULL;
   if (hints->ai_flags & AI_CANONNAME) {
     PP_Var name_var = resolver_iface->GetCanonicalName(resolver);
     if (PP_VARTYPE_STRING == name_var.type) {
       uint32_t len = 0;
-      const char* tmp = var_interface->VarToUtf8(name_var, &len);
+      const char* tmp = var_iface->VarToUtf8(name_var, &len);
       // For some reason GetCanonicalName alway returns an empty
       // string so this condition is never true.
       // TODO(sbc): investigate this issue with PPAPI team.
       if (len > 0) {
         // Copy and NULL-terminate the UTF8 string var.
         canon_name = static_cast<char*>(malloc(len + 1));
         strncpy(canon_name, tmp, len);
         canon_name[len] = '\0';
       }
     }
     if (!canon_name)
       canon_name = strdup(node);
-    var_interface->Release(name_var);
+    var_iface->Release(name_var);
   }
 
   int num_addresses = resolver_iface->GetNetAddressCount(resolver);
   if (0 == num_addresses)
     return EAI_NODATA;
 
   // Convert address to sockaddr struct.
   for (int i = 0; i < num_addresses; i++) {
     ScopedResource addr(ppapi_, resolver_iface->GetNetAddress(resolver, i));
     PP_Resource resource = addr.pp_resource();
@@ skipping 60 matching lines @@
   hostent_.h_addr_list = NULL;
 #if !defined(h_addr)
   // Initialize h_addr separately in the case where it is not a macro.
   hostent_.h_addr = NULL;
 #endif
 }
 
 }  // namespace nacl_io
 
 #endif  // PROVIDES_SOCKET_API