Add ONC VPN support for OpenVPN and L2TP/IPsec VPNs

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include <dbus/dbus-glib.h>
 #include <dbus/dbus-gtype-specialized.h>
 #include <glib-object.h>
 
@@ skipping 305 matching lines @@
   return new GValue();
 }
 
 GHashTable* ConvertDictionaryValueToGValueMap(const DictionaryValue* dict) {
   GHashTable* ghash =
       g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
   for (DictionaryValue::key_iterator it = dict->begin_keys();
        it != dict->end_keys(); ++it) {
     std::string key = *it;
     Value* val = NULL;
-    if (dict->Get(key, &val)) {
+    if (dict->GetWithoutPathExpansion(key, &val)) {
       g_hash_table_insert(ghash,
                           g_strdup(const_cast<char*>(key.c_str())),
                           ConvertValueToGValue(val));
+    } else {
+      VLOG(2) << "Could not insert key " << key << " into hash";
     }
   }
   return ghash;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FoundCellularNetwork
 
@@ skipping 74 matching lines @@
   delete entry;
   entry = value.DeepCopy();
   if (VLOG_IS_ON(2)) {
     std::string value_json;
     base::JSONWriter::Write(&value, true, &value_json);
     VLOG(2) << "Updated property map on network: "
             << unique_id() << "[" << index << "] = " << value_json;
   }
 }
 
+bool Network::GetProperty(PropertyIndex index,
+                          const base::Value** value) const {
+  PropertyMap::const_iterator i = property_map_.find(index);
+  if (i == property_map_.end())
+    return false;
+  if (value != NULL)
+    *value = i->second;
+  return true;
+}
+
 void Network::SetState(ConnectionState new_state) {
   if (new_state == state_)
     return;
   ConnectionState old_state = state_;
   state_ = new_state;
   if (!IsConnectingState(new_state))
     set_connection_started(false);
   if (new_state == STATE_FAILURE) {
     if (old_state != STATE_UNKNOWN &&
         old_state != STATE_IDLE) {
@@ skipping 365 matching lines @@
                     user_passphrase, &user_passphrase_);
   SetStringProperty(flimflam::kL2tpIpsecGroupNameProperty,
                     group_name, &group_name_);
 }
 
 void VirtualNetwork::SetOpenVPNCredentials(
     const std::string& client_cert_id,
     const std::string& username,
     const std::string& user_passphrase,
     const std::string& otp) {
+  // TODO(kmixter): Are we missing setting the CaCert property?
   SetStringProperty(flimflam::kOpenVPNClientCertIdProperty,
                     client_cert_id, &client_cert_id_);
   SetStringProperty(flimflam::kOpenVPNUserProperty, username, &username_);
   SetStringProperty(flimflam::kOpenVPNPasswordProperty,
                     user_passphrase, &user_passphrase_);
   SetStringProperty(flimflam::kOpenVPNOTPProperty, otp, NULL);
 }
 
 void VirtualNetwork::SetCertificateSlotAndPin(
     const std::string& slot, const std::string& pin) {
@@ skipping 2006 matching lines @@
     if (!parser.ParseCertificate(i)) {
       DLOG(WARNING) << "Cannot parse certificate in ONC file";
       return false;
     }
   }
 
   for (int i = 0; i < parser.GetNetworkConfigsSize(); i++) {
     // Parse Open Network Configuration blob into a temporary Network object.
     scoped_ptr<Network> network(parser.ParseNetwork(i));
     if (!network.get()) {
-      DLOG(WARNING) << "Cannot parse networks in ONC file";
+      DLOG(WARNING) << "Cannot parse network in ONC file";
       return false;
     }
 
     DictionaryValue dict;
     for (Network::PropertyMap::const_iterator props =
              network->property_map_.begin();
          props != network->property_map_.end(); ++props) {
       std::string key =
           NativeNetworkParser::property_mapper()->GetKey(props->first);
       if (!key.empty())
         dict.SetWithoutPathExpansion(key, props->second->DeepCopy());
+      else
+        VLOG(2) << "Property " << props->first << " will not be sent";
     }
 
     CallConfigureService(network->unique_id(), &dict);
   }
   return parser.GetNetworkConfigsSize() != 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // Testing functions.
 
@@ skipping 824 matching lines @@
   if (error != NETWORK_METHOD_ERROR_NONE) {
     LOG(WARNING) << "Error from ConfigureService callback for: "
                  << service_path
                  << " Error: " << error << " Message: " << error_message;
   }
 }
 
 void NetworkLibraryImplCros::CallConfigureService(const std::string& identifier,
                                                   const DictionaryValue* info) {
   GHashTable* ghash = ConvertDictionaryValueToGValueMap(info);
+  if (VLOG_IS_ON(2)) {
+    scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
+    std::string dict_json;
+    base::JSONWriter::Write(static_cast<Value*>(dict.get()), true, &dict_json);
+    VLOG(2) << "ConfigureService will be called on:" << dict_json;
+  }
   chromeos::ConfigureService(identifier.c_str(), ghash,
                              ConfigureServiceCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkConnectCallback(
     void* object,
     const char* service_path,
     NetworkMethodErrorType error,
     const char* error_message) {
@@ skipping 1552 matching lines @@
   return impl;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until its last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);