Attempt to fix crashing bug. Added more logging.

chromeos_network.cc

 // Copyright (c) 2009 The Chromium OS 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 "chromeos_network.h"  // NOLINT
 
 #include <algorithm>
 #include <vector>
 #include <cstring>
 
@@ skipping 218 matching lines @@
 // in the ScopedHashTable. The hash table will map strings to glib values.
 bool GetProperties(const dbus::Proxy& proxy, glib::ScopedHashTable* result) {
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(proxy.gproxy(),
                            kGetPropertiesFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_INVALID,
                            ::dbus_g_type_get_map("GHashTable", G_TYPE_STRING,
                                                  G_TYPE_VALUE),
                            &Resetter(result).lvalue(), G_TYPE_INVALID)) {
-    LOG(WARNING) << "GetProperties failed: "
+    LOG(WARNING) << "GetProperties on path '" << proxy.path() << "' failed: "
                  << (error->message ? error->message : "Unknown Error.");
     return false;
   }
   return true;
 }
 
 // Populates an instance of a ServiceInfo with the properties
 // from a Connman service.
 void ParseServiceProperties(const glib::ScopedHashTable& properties,
                             ServiceInfo* info) {
@@ skipping 251 matching lines @@
                            kConnmanIPConfigInterface);
   glib::ScopedHashTable properties;
   if (!GetProperties(config_proxy, &properties))
     return false;
   ParseIPConfigProperties(properties, ipconfig);
   return true;
 }
 
 extern "C"
 IPConfigStatus* ChromeOSListIPConfigs(const char* device_path) {
+  if (!device_path)
+    return NULL;
 
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy device_proxy(bus,
-                            kConnmanServiceName,
-                            device_path,
-                            kConnmanDeviceInterface);
+                           kConnmanServiceName,
+                           device_path,
+                           kConnmanDeviceInterface);
 
   glib::ScopedHashTable properties;
   if (!GetProperties(device_proxy, &properties)) {
     return NULL;
   }
 
   GHashTable* table = properties.get();
   gpointer ptr = g_hash_table_lookup(table, kIPConfigsProperty);
   if (ptr == NULL)
     return NULL;
 
   GPtrArray* ips_value =
       static_cast<GPtrArray*>(g_value_get_boxed(static_cast<GValue*>(ptr)));
 
   IPConfigStatus* result = new IPConfigStatus();
-  result->size = ips_value->len;
+  std::vector<IPConfig> buffer;
+  const char* path = NULL;
+  for (size_t i = 0; i < ips_value->len; i++) {
+    path = static_cast<const char*>(g_ptr_array_index(ips_value, i));
+    if (!path) {
+      LOG(WARNING) << "Found NULL ip for device " << device_path;
+      continue;
+    }
+    IPConfig ipconfig = {};
+    if (!ParseIPConfig(path, &ipconfig))
+      continue;
+    buffer.push_back(ipconfig);
+  }
+  result->size = buffer.size();
   if (result->size == 0) {
     result->ips = NULL;
   } else {
     result->ips = new IPConfig[result->size];
-    for (size_t i = 0; i < ips_value->len; i++) {
-      const char* path =
-          static_cast<const char*>(g_ptr_array_index(ips_value, i));
-      ParseIPConfig(path, &result->ips[i]);
-    }
   }
+  std::copy(buffer.begin(), buffer.end(), result->ips);
   return result;
 }
 
 extern "C"
 bool ChromeOSAddIPConfig(const char* device_path, IPConfigType type) {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   dbus::Proxy device_proxy(bus,
                            kConnmanServiceName,
                            device_path,
                            kConnmanDeviceInterface);
@@ skipping 90 matching lines @@
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) <<"Set IPConfig Property failed: "
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
   return true;
 }
 
 void DeleteIPConfigProperties(IPConfig config) {
-  delete config.path;
-  delete config.address;
-  delete config.broadcast;
-  delete config.netmask;
-  delete config.gateway;
-  delete config.domainname;
-  delete config.name_servers;
+  if (config.path)
+    delete config.path;
+  if (config.address)
+    delete config.address;
+  if (config.broadcast)
+    delete config.broadcast;
+  if (config.netmask)
+    delete config.netmask;
+  if (config.gateway)
+    delete config.gateway;
+  if (config.domainname)
+    delete config.domainname;
+  if (config.name_servers)
+    delete config.name_servers;
 }
 
 extern "C"
 void ChromeOSFreeIPConfig(IPConfig* config) {
   DeleteIPConfigProperties(*config);
   delete config;
 }
 
 extern "C"
 void ChromeOSFreeIPConfigStatus(IPConfigStatus* status) {
@@ skipping 293 matching lines @@
                            G_TYPE_INVALID)) {
     LOG(WARNING) << "SetOfflineMode failed: "
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
 
   return true;
 }
 
 }  // namespace chromeos