AU: Don't use network on expensive connection types

flimflam_proxy.cc

Index: flimflam_proxy.cc
diff --git a/flimflam_proxy.cc b/flimflam_proxy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1eb1d6ad97f2160628072c17245445c795f3c9b0
--- /dev/null
+++ b/flimflam_proxy.cc
@@ -0,0 +1,178 @@
+// Copyright (c) 2010 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 "update_engine/flimflam_proxy.h"
+
+#include <string>
+
+#include <base/string_util.h>
+#include <dbus/dbus-glib.h>
+#include <glib.h>
+
+#include "update_engine/utils.h"
+
+using std::string;
+
+namespace chromeos_update_engine {
+
+namespace {
+
+// Gets the DbusGProxy for FlimFlam. Must be free'd with ProxyUnref()
+bool GetFlimFlamProxy(DbusGlibInterface* dbus_iface,
+                      const char* path,
+                      const char* interface,
+                      DBusGProxy** out_proxy) {
+  DBusGConnection* bus;
+  DBusGProxy* proxy;
+  GError* error = NULL;
+
+  bus = dbus_iface->BusGet(DBUS_BUS_SYSTEM, &error);
+  if (!bus) {
+    LOG(ERROR) << "Failed to get system bus";
+    return false;
+  }
+  proxy = dbus_iface->ProxyNewForNameOwner(bus,
+                                           kFlimFlamDbusService,
+                                           path,
+                                           interface,
+                                           &error);
+  if (!proxy) {
+    LOG(ERROR) << "Error getting FlimFlam proxy: "
+               << utils::GetGErrorMessage(error);
+    return false;
+  }
+  *out_proxy = proxy;
+  return true;
+}
+
+// On success, caller owns the GHashTable at out_hash_table.
+// Returns true on success.
+bool GetProperties(DbusGlibInterface* dbus_iface,
+                   const char* path,
+                   const char* interface,
+                   GHashTable** out_hash_table) {
+  DBusGProxy* proxy;
+  GError* error = NULL;
+
+  TEST_AND_RETURN_FALSE(GetFlimFlamProxy(dbus_iface,
+                                         path,
+                                         interface,
+                                         &proxy));
+
+  gboolean rc = dbus_iface->ProxyCall(proxy,
+                                      "GetProperties",
+                                      &error,
+                                      G_TYPE_INVALID,
+                                      dbus_g_type_get_map("GHashTable",
+                                                          G_TYPE_STRING,
+                                                          G_TYPE_VALUE),
+                                      out_hash_table,
+                                      G_TYPE_INVALID);
+  dbus_iface->ProxyUnref(proxy);
+  if (rc == FALSE) {
+    LOG(ERROR) << "dbus_g_proxy_call failed";
+    return false;
+  }
+
+  return true;
+}
+
+// Returns (via out_path) the default network path, or empty string if
+// there's no network up.
+// Returns true on success.
+bool GetDefaultServicePath(DbusGlibInterface* dbus_iface, string* out_path) {
+  GHashTable* hash_table = NULL;
+
+  TEST_AND_RETURN_FALSE(GetProperties(dbus_iface,
+                                      kFlimFlamDbusManagerPath,
+                                      kFlimFlamDbusManagerInterface,
+                                      &hash_table));
+
+  GValue* value = reinterpret_cast<GValue*>(g_hash_table_lookup(hash_table,
+                                                                "Services"));
+  GArray* array = NULL;
+  bool success = false;
+  if (value &&
+      (array = reinterpret_cast<GArray*>(g_value_get_boxed(value))) &&
+      (array->len > 0)) {
+    *out_path = g_array_index(array, const char*, 0);
+    success = true;
+  }
+  g_hash_table_unref(hash_table);
+  return success;
+}
+
+NetworkConnectionType ParseConnectionType(const char* type_str) {
+  if (!strcmp(type_str, kFlimFlamNetTypeEthernet)) {
+    return kNetEthernet;
+  } else if (!strcmp(type_str, kFlimFlamNetTypeWifi)) {
+    return kNetWifi;
+  } else if (!strcmp(type_str, kFlimFlamNetTypeWimax)) {
+    return kNetWimax;
+  } else if (!strcmp(type_str, kFlimFlamNetTypeBluetooth)) {
+    return kNetBluetooth;
+  } else if (!strcmp(type_str, kFlimFlamNetTypeCellular)) {
+    return kNetCellular;
+  }
+  return kNetUnknown;
+}
+
+bool GetServicePathType(DbusGlibInterface* dbus_iface,
+                        const string& path,
+                        NetworkConnectionType* out_type) {
+  GHashTable* hash_table = NULL;
+
+  TEST_AND_RETURN_FALSE(GetProperties(dbus_iface,
+                                      path.c_str(),
+                                      kFlimFlamDbusServiceInterface,
+                                      &hash_table));
+
+  GValue* value = (GValue*)g_hash_table_lookup(hash_table, "Type");
+  const char* type_str = NULL;
+  bool success = false;
+  if (value && (type_str = g_value_get_string(value))) {

[petkov, 2010/10/21 05:15:19]

I'm surprised you don't get a gcc warning here. Maybe add an explicit ((type_str
= ...) != NULL)?

[adlr, 2010/10/21 19:41:14]

Done.

+    *out_type = ParseConnectionType(type_str);
+    success = true;
+  }
+  g_hash_table_unref(hash_table);
+  return success;
+}
+
+}  // namespace {}
+
+const char* FlimFlamProxy::StringForConnectionType(NetworkConnectionType type) {
+  static const char* const kValues[] = {kFlimFlamNetTypeEthernet,
+                                        kFlimFlamNetTypeWifi,
+                                        kFlimFlamNetTypeWimax,
+                                        kFlimFlamNetTypeBluetooth,
+                                        kFlimFlamNetTypeCellular};
+  if (type < 0 || type >= static_cast<int>(arraysize(kValues))) {
+    return "Unknown";
+  }
+  return kValues[type];
+}
+
+bool FlimFlamProxy::GetConnectionType(DbusGlibInterface* dbus_iface,
+                                      NetworkConnectionType* out_type) {
+  string default_service_path;
+  TEST_AND_RETURN_FALSE(GetDefaultServicePath(dbus_iface,
+                                              &default_service_path));
+  TEST_AND_RETURN_FALSE(GetServicePathType(dbus_iface,
+                                           default_service_path,
+                                           out_type));
+  return true;
+}
+
+const char* kFlimFlamDbusService = "org.chromium.flimflam";
+const char* kFlimFlamDbusManagerInterface = "org.chromium.flimflam.Manager";
+const char* kFlimFlamDbusManagerPath = "/";
+const char* kFlimFlamDbusServiceInterface = "org.chromium.flimflam.Service";
+
+const char* kFlimFlamNetTypeEthernet = "ethernet";
+const char* kFlimFlamNetTypeWifi = "wifi";
+const char* kFlimFlamNetTypeWimax = "wimax";
+const char* kFlimFlamNetTypeBluetooth = "bluetooth";
+const char* kFlimFlamNetTypeCellular = "cellular";
+
+}  // namespace chromeos_update_engine