Handle new EAP fields and provide backwards compatibility for old

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 <cstring>
 #include <list>
 #include <set>
 #include <vector>
 
 #include "marshal.glibmarshal.h"  // NOLINT
 #include "base/scoped_ptr.h"
+#include "base/scoped_vector.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus.h"  // NOLINT
 #include "chromeos/glib/object.h"  // NOLINT
 #include "chromeos/string.h"
 
 // TODO(rtc): Unittest this code as soon as the tree is refactored.
 namespace chromeos {  // NOLINT
 
 namespace { // NOLINT
@@ skipping 21 matching lines @@
 static const char* kAddIPConfigFunction = "AddIPConfig";
 static const char* kRemoveConfigFunction = "Remove";
 static const char* kGetEntryFunction = "GetEntry";
 static const char* kDeleteEntryFunction = "DeleteEntry";
 static const char* kActivateCellularModemFunction = "ActivateCellularModem";
 
 // Connman property names.
 static const char* kSecurityProperty = "Security";
 static const char* kPassphraseProperty = "Passphrase";
 static const char* kIdentityProperty = "Identity";
-static const char* kCertPathProperty = "CertPath";
+static const char* kCertPathProperty = "CertPath"; // DEPRECATED
 static const char* kPassphraseRequiredProperty = "PassphraseRequired";
 static const char* kServicesProperty = "Services";
 static const char* kAvailableTechnologiesProperty = "AvailableTechnologies";
 static const char* kEnabledTechnologiesProperty = "EnabledTechnologies";
 static const char* kConnectedTechnologiesProperty = "ConnectedTechnologies";
 static const char* kDefaultTechnologyProperty = "DefaultTechnology";
 static const char* kOfflineModeProperty = "OfflineMode";
 static const char* kSignalStrengthProperty = "Strength";
 static const char* kNameProperty = "Name";
 static const char* kStateProperty = "State";
@@ skipping 32 matching lines @@
 static const char* kImsiProperty = "Cellular.IMSI";
 static const char* kEsnProperty = "Cellular.ESN";
 static const char* kMdnProperty = "Cellular.MDN";
 static const char* kMinProperty = "Cellular.MIN";
 static const char* kModelIDProperty = "Cellular.ModelID";
 static const char* kManufacturerProperty = "Cellular.Manufacturer";
 static const char* kFirmwareRevisionProperty = "Cellular.FirmwareRevision";
 static const char* kHardwareRevisionProperty = "Cellular.HardwareRevision";
 static const char* kLastDeviceUpdateProperty = "Cellular.LastDeviceUpdate";
 static const char* kPRLVersionProperty = "Cellular.PRLVersion"; // (INT16)
+static const char* kCertpathSettingsPrefix = "SETTINGS:";
+
+// Connman EAP service properties
+static const char* kEAPIdentityProperty = "EAP.Identity";
+static const char* kEAPEAPProperty = "EAP.EAP";
+static const char* kEAPInnerEAPProperty = "EAP.InnerEAP";
+static const char* kEAPAnonymousIdentityProperty = "EAP.AnonymousIdentity";
+static const char* kEAPClientCertProperty = "EAP.ClientCert";
+static const char* kEAPCertIDProperty = "EAP.CertID";
+static const char* kEAPPrivateKeyProperty = "EAP.PrivateKey";
+static const char* kEAPPrivateKeyPasswordProperty = "EAP.PrivateKeyPassword";
+static const char* kEAPKeyIDProperty = "EAP.KeyID";
+static const char* kEAPCACertProperty = "EAP.CACert";
+static const char* kEAPCACertIDProperty = "EAP.CACertID";
+static const char* kEAPPINProperty = "EAP.PIN";
+static const char* kEAPPasswordProperty = "EAP.Password";
 
 // Connman monitored properties
 static const char* kMonitorPropertyChanged = "PropertyChanged";
 
 // Connman network state
 static const char* kOnline = "online";
 
 // Connman type options.
 static const char* kTypeEthernet = "ethernet";
 static const char* kTypeWifi = "wifi";
@@ skipping 497 matching lines @@
   properties.Retrieve(kPassphraseRequiredProperty, &default_bool);
   info->passphrase_required = default_bool;
 
   // Passphrase
   default_string = "";
   properties.Retrieve(kPassphraseProperty, &default_string);
   info->passphrase = NewStringCopy(default_string);
 
   // Identity
   default_string = "";
-  properties.Retrieve(kIdentityProperty, &default_string);
+  properties.Retrieve(kEAPIdentityProperty, &default_string);
   info->identity = NewStringCopy(default_string);
 
-  // Certificate path
-  default_string = "";
-  properties.Retrieve(kCertPathProperty, &default_string);
-  info->cert_path = NewStringCopy(default_string);
-
   // Strength
   uint8 default_uint8 = 0;
   properties.Retrieve(kSignalStrengthProperty, &default_uint8);
   info->strength = default_uint8;
 
   // Favorite
   default_bool = false;
   properties.Retrieve(kFavoriteProperty, &default_bool);
   info->favorite = default_bool;
 
@@ skipping 57 matching lines @@
     properties.Retrieve(kOperatorCodeProperty, &default_string);
     info->carrier_info->operator_code = NewStringCopy(default_string);
     // Payment URL
     default_string = kUnknownString;
     properties.Retrieve(kPaymentURLProperty, &default_string);
     info->carrier_info->payment_url = NewStringCopy(default_string);
   } else {
     info->carrier_info = NULL;
   }
 
+  // EAP type
+  default_string = "";
+  properties.Retrieve(kEAPEAPProperty, &default_string);
+  info->eap = NewStringCopy(default_string);
+  // Inner EAP type
+  default_string = "";
+  properties.Retrieve(kEAPInnerEAPProperty, &default_string);
+  info->inner_eap = NewStringCopy(default_string);
+  // Anonymous identity
+  default_string = "";
+  properties.Retrieve(kEAPAnonymousIdentityProperty, &default_string);
+  info->anonymous_identity = NewStringCopy(default_string);
+  // Client certificate
+  default_string = "";
+  properties.Retrieve(kEAPClientCertProperty, &default_string);
+  info->client_cert = NewStringCopy(default_string);
+  // Certificate ID
+  default_string = "";
+  properties.Retrieve(kEAPCertIDProperty, &default_string);
+  info->cert_id = NewStringCopy(default_string);
+  // Private key
+  default_string = "";
+  properties.Retrieve(kEAPPrivateKeyProperty, &default_string);
+  info->private_key = NewStringCopy(default_string);
+  // Private key password
+  default_string = "";
+  properties.Retrieve(kEAPPrivateKeyPasswordProperty, &default_string);
+  info->private_key_passwd = NewStringCopy(default_string);
+  // Private key ID
+  default_string = "";
+  properties.Retrieve(kEAPKeyIDProperty, &default_string);
+  info->key_id = NewStringCopy(default_string);
+  // CA certificate
+  default_string = "";
+  properties.Retrieve(kEAPCACertProperty, &default_string);
+  info->ca_cert = NewStringCopy(default_string);
+  // CA certificate ID
+  default_string = "";
+  properties.Retrieve(kEAPCACertIDProperty, &default_string);
+  info->ca_cert_id = NewStringCopy(default_string);
+  // PKCS#11 PIN
+  default_string = "";
+  properties.Retrieve(kEAPPINProperty, &default_string);
+  info->pin = NewStringCopy(default_string);
+  // EAP Password
+  default_string = "";
+  properties.Retrieve(kEAPPasswordProperty, &default_string);
+  info->password = NewStringCopy(default_string);
+
+  // DEPRECATED: Certificate path (backwards compat only)
+  default_string = "";
+  if (strcmp(info->eap, "TLS") == 0) {
+    // "SETTINGS:cert_id=x,key_id=x,pin=x"
+    std::string certpath("SETTINGS:");
+    const char *comma = "";
+    if (strlen(info->cert_id) != 0) {
+      certpath += StringPrintf("%scert_id=%s", comma, info->cert_id);
+      comma = ",";
+    }
+    if (strlen(info->key_id) != 0) {
+      certpath += StringPrintf("%skey_id=%s", comma, info->key_id);
+      comma = ",";
+    }
+    if (strlen(info->pin) != 0) {
+      certpath += StringPrintf("%spin=%s", comma, info->pin);
+      comma = ",";
+    }
+    info->cert_path = NewStringCopy(certpath.c_str());
+  } else
+    info->cert_path = NewStringCopy(default_string);
+
   // Device Info (initialize to NULL)
   info->device_info = NULL;
 }
 
 // Returns a ServiceInfo object populated with data from a
 // given DBus object path.
 //
 // returns true on success.
 bool GetServiceInfo(const char* path, ServiceInfo *info) {
   dbus::Proxy service_proxy(dbus::GetSystemBusConnection(),
@@ skipping 763 matching lines @@
           "ChromeOSActivateCellularModem: already started activation";
       return true;
     }
     LOG(WARNING) << "ChromeOSActivateCellularModem failed: "
         << (error->message ? error->message : "Unknown Error.");
     return false;
   }
   return true;
 }
 
+class ScopedPtrGStrFreeV {
+ public:
+  inline void operator()(char** x) const {
+    g_strfreev(x);
+  }
+};
+
+static const char *map_oldprop_to_newprop(const char *oldprop)
+{
+  if (strcmp(oldprop, "key_id") == 0)
+    return kEAPKeyIDProperty;
+  if (strcmp(oldprop, "cert_id") == 0)
+    return kEAPCertIDProperty;
+  if (strcmp(oldprop, "pin") == 0)
+    return kEAPPINProperty;
+
+  return NULL;
+}
+
+
+
 extern "C"
 bool ChromeOSConfigureWifiService(const char* ssid,
                                   ConnectionSecurity security,
                                   const char* passphrase,
                                   const char* identity,
                                   const char* certpath) {
 
   dbus::Proxy manager_proxy(dbus::GetSystemBusConnection(),
                             kConnmanServiceName,
                             "/",
@@ skipping 17 matching lines @@
   glib::Value value_cert_path(certpath);
 
   ::GHashTable* properties = scoped_properties.get();
   ::g_hash_table_insert(properties, ::g_strdup(kModeProperty), &value_mode);
   ::g_hash_table_insert(properties, ::g_strdup(kTypeProperty), &value_type);
   ::g_hash_table_insert(properties, ::g_strdup(kSSIDProperty), &value_ssid);
   ::g_hash_table_insert(properties, ::g_strdup(kSecurityProperty),
                         &value_security);
   ::g_hash_table_insert(properties, ::g_strdup(kPassphraseProperty),
                         &value_passphrase);
-  ::g_hash_table_insert(properties, ::g_strdup(kIdentityProperty),
+  ::g_hash_table_insert(properties, ::g_strdup(kEAPIdentityProperty),
                         &value_identity);
-  ::g_hash_table_insert(properties, ::g_strdup(kCertPathProperty),
-                        &value_cert_path);
+
+  // DEPRECATED
+  // Backwards-compatibility for "CertPath=SETTINGS:key_id=1,cert_id=2,..."
+  ScopedVector<glib::Value> values;
+  scoped_ptr_malloc<char *, ScopedPtrGStrFreeV> settings;
+  if (::g_str_has_prefix(certpath, kCertpathSettingsPrefix)) {
+      char **settingsp;
+      settings.reset(::g_strsplit_set(
+          certpath + strlen(kCertpathSettingsPrefix), ",=", 0));
+      for (settingsp = settings.get(); *settingsp != NULL; settingsp += 2) {
+        const char *key = map_oldprop_to_newprop(*settingsp);
+        if (key == NULL) {
+          LOG(WARNING) << "ConfigureWifiService, unknown key '" << key
+                       << "' from certpath ";
+          continue;
+        }
+        glib::Value *value = new glib::Value(*(settingsp + 1));
+        values.push_back(value);
+        ::g_hash_table_insert(properties, ::g_strdup(key), value);
+      }
+      // Presume EAP-TLS if we're here
+      glib::Value *value = new glib::Value("TLS");
+      values.push_back(value);
+      ::g_hash_table_insert(properties, ::g_strdup(kEAPEAPProperty), value);
+  } else {
+    ::g_hash_table_insert(properties, ::g_strdup(kEAPClientCertProperty),
+                          &value_cert_path);
+  }
 
 
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(manager_proxy.gproxy(),
                            kConfigureWifiServiceFunction,
                            &Resetter(&error).lvalue(),
                            ::dbus_g_type_get_map("GHashTable",
                                                  G_TYPE_STRING,
                                                  G_TYPE_VALUE),
                            properties,
@@ skipping 50 matching lines @@
                              G_TYPE_INVALID,
                              G_TYPE_INVALID)) {
       LOG(WARNING) << "ConnectToNetwork failed on set identity: "
           << (error->message ? error->message : "Unknown Error.");
       return false;
     }
   }
 
   // Set certificate path if non-null.
   if (certpath) {
-    glib::Value value_certpath(certpath);
-    glib::ScopedError error;
-    if (!::dbus_g_proxy_call(service_proxy.gproxy(),
-                             kSetPropertyFunction,
-                             &Resetter(&error).lvalue(),
-                             G_TYPE_STRING,
-                             kCertPathProperty,
-                             G_TYPE_VALUE,
-                             &value_certpath,
-                             G_TYPE_INVALID,
-                             G_TYPE_INVALID)) {
-      LOG(WARNING) << "ConnectToNetwork failed on set certpath: "
-          << (error->message ? error->message : "Unknown Error.");
-      return false;
+    // DEPRECATED
+    // Backwards-compatibility for "CertPath=SETTINGS:key_id=1,cert_id=2,..."
+    if (::g_str_has_prefix(certpath, kCertpathSettingsPrefix)) {
+      glib::ScopedError error;
+      char **settingsp;
+      scoped_ptr_malloc<char *, ScopedPtrGStrFreeV> settings(
+          ::g_strsplit_set(certpath +
+                           strlen(kCertpathSettingsPrefix), ",=", 0));
+      for (settingsp = settings.get(); *settingsp != NULL; settingsp += 2) {
+        const char *key = map_oldprop_to_newprop(*settingsp);
+        if (key == NULL) {
+          LOG(WARNING) << "ConnectToNetwork, unknown key '" << key
+                       << "' from certpath ";
+          continue;
+        }
+        glib::Value value(*(settingsp + 1));
+        if (!::dbus_g_proxy_call(service_proxy.gproxy(),
+                                 kSetPropertyFunction,
+                                 &Resetter(&error).lvalue(),
+                                 G_TYPE_STRING,
+                                 key,
+                                 G_TYPE_VALUE,
+                                 &value,
+                                 G_TYPE_INVALID,
+                                 G_TYPE_INVALID)) {
+          LOG(WARNING) << "ConnectToNetwork failed on set '" << key
+                       << "' (from certpath): "
+                       << (error->message ? error->message : "Unknown Error.");
+          return false;
+        }
+      }
+      // Presume EAP-TLS if we're here
+      glib::Value value("TLS");
+      if (!::dbus_g_proxy_call(service_proxy.gproxy(),
+                               kSetPropertyFunction,
+                               &Resetter(&error).lvalue(),
+                               G_TYPE_STRING,
+                               kEAPEAPProperty,
+                               G_TYPE_VALUE,
+                               &value,
+                               G_TYPE_INVALID,
+                               G_TYPE_INVALID)) {
+        LOG(WARNING) << "ConnectToNetwork failed on set EAP type'"
+                     << "' (from certpath): "
+                     << (error->message ? error->message : "Unknown Error.");
+        return false;
+      }
+    } else {
+      glib::Value value_certpath(certpath);
+      glib::ScopedError error;
+      if (!::dbus_g_proxy_call(service_proxy.gproxy(),
+                               kSetPropertyFunction,
+                               &Resetter(&error).lvalue(),
+                               G_TYPE_STRING,
+                               kEAPClientCertProperty,
+                               G_TYPE_VALUE,
+                               &value_certpath,
+                               G_TYPE_INVALID,
+                               G_TYPE_INVALID)) {
+        LOG(WARNING) << "ConnectToNetwork failed on set certpath: "
+                     << (error->message ? error->message : "Unknown Error.");
+        return false;
+      }
     }
   }
 
   // Now try connecting.
   glib::ScopedError error;
   if (!::dbus_g_proxy_call(service_proxy.gproxy(),
                            kConnectFunction,
                            &Resetter(&error).lvalue(),
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
@@ skipping 719 matching lines @@
   }
   DCHECK(properties_array);
 
   CellularDataPlanList *data_plan_list =
       ParseCellularDataPlanList(properties_array);
   g_ptr_array_unref(properties_array);
   return data_plan_list;
 }
 
 }  // namespace chromeos