Translate Saved/StaticIPConfig properties from ONC to Shill

chromeos/network/onc/onc_translator_shill_to_onc.cc

 // Copyright (c) 2012 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 "chromeos/network/onc/onc_translator.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translation_tables.h"
 #include "chromeos/network/shill_property_util.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
@@ skipping 47 matching lines @@
  private:
   void TranslateEthernet();
   void TranslateOpenVPN();
   void TranslateIPsec();
   void TranslateVPN();
   void TranslateWiFiWithState();
   void TranslateCellularWithState();
   void TranslateCellularDevice();
   void TranslateNetworkWithState();
   void TranslateIPConfig();
+  void TranslateSavedOrStaticIPConfig(const std::string& nameserver_property);
+  void TranslateSavedIPConfig();
+  void TranslateStaticIPConfig();
 
   // Creates an ONC object from |dictionary| according to the signature
   // associated to |onc_field_name| and adds it to |onc_object_| at
   // |onc_field_name|.
   void TranslateAndAddNestedObject(const std::string& onc_field_name,
                                    const base::DictionaryValue& dictionary);
 
   // Creates an ONC object from |shill_dictionary_| according to the signature
   // associated to |onc_field_name| and adds it to |onc_object_| at
   // |onc_field_name|.
@@ skipping 60 matching lines @@
     TranslateIPsec();
   } else if (onc_signature_ == &kWiFiWithStateSignature) {
     TranslateWiFiWithState();
   } else if (onc_signature_ == &kCellularWithStateSignature) {
     if (field_translation_table_ == kCellularDeviceTable)
       TranslateCellularDevice();
     else
       TranslateCellularWithState();
   } else if (onc_signature_ == &kIPConfigSignature) {
     TranslateIPConfig();
+  } else if (onc_signature_ == &kSavedIPConfigSignature) {
+    TranslateSavedIPConfig();
+  } else if (onc_signature_ == &kStaticIPConfigSignature) {
+    TranslateStaticIPConfig();
   } else {
     CopyPropertiesAccordingToSignature();
   }
   return onc_object_.Pass();
 }
 
 void ShillToONCTranslator::TranslateEthernet() {
   std::string shill_network_type;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty,
                                                    &shill_network_type);
@@ skipping 194 matching lines @@
   // Translate nested Cellular, WiFi, etc. properties.
   if (!onc_network_type.empty()) {
     onc_object_->SetStringWithoutPathExpansion(::onc::network_config::kType,
                                                onc_network_type);
     TranslateAndAddNestedObject(onc_network_type);
   }
 
   // Since Name is a read only field in Shill unless it's a VPN, it is copied
   // here, but not when going the other direction (if it's not a VPN).
   std::string name;
-  shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty,
-                                                   &name);
+  shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty, &name);
   onc_object_->SetStringWithoutPathExpansion(::onc::network_config::kName,
                                              name);
 
   // Limit ONC state to "NotConnected", "Connected", or "Connecting".
   std::string state;
   if (shill_dictionary_->GetStringWithoutPathExpansion(shill::kStateProperty,
                                                        &state)) {
     std::string onc_state = ::onc::connection_state::kNotConnected;
     if (NetworkState::StateIsConnected(state)) {
       onc_state = ::onc::connection_state::kConnected;
@@ skipping 17 matching lines @@
 
   // Shill's Service has an IPConfig property (note the singular), not an
   // IPConfigs property. However, we require the caller of the translation to
   // patch the Shill dictionary before passing it to the translator.
   const base::ListValue* shill_ipconfigs = NULL;
   if (shill_dictionary_->GetListWithoutPathExpansion(shill::kIPConfigsProperty,
                                                      &shill_ipconfigs)) {
     TranslateAndAddListOfObjects(::onc::network_config::kIPConfigs,
                                  *shill_ipconfigs);
   }
+
+  TranslateAndAddNestedObject(::onc::network_config::kSavedIPConfig);
+  TranslateAndAddNestedObject(::onc::network_config::kStaticIPConfig);
 }
 
 void ShillToONCTranslator::TranslateIPConfig() {
   CopyPropertiesAccordingToSignature();
   std::string shill_ip_method;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kMethodProperty,
                                                    &shill_ip_method);
   std::string type;
   if (shill_ip_method == shill::kTypeIPv4 ||
       shill_ip_method == shill::kTypeDHCP) {
     type = ::onc::ipconfig::kIPv4;
   } else if (shill_ip_method == shill::kTypeIPv6 ||
              shill_ip_method == shill::kTypeDHCP6) {
     type = ::onc::ipconfig::kIPv6;
   } else {
     return;  // Ignore unhandled IPConfig types, e.g. bootp, zeroconf, ppp
   }
 
   onc_object_->SetStringWithoutPathExpansion(::onc::ipconfig::kType, type);
 }
 
+void ShillToONCTranslator::TranslateSavedOrStaticIPConfig(
+    const std::string& nameserver_property) {
+  CopyPropertiesAccordingToSignature();
+  // Saved IP config nameservers are stored as a comma separated list.

[pneubeck (no reviews), 2014/09/04 12:38:45]

nit: Saved and static ...

[stevenjb, 2014/09/04 15:26:21]

Done.

+  std::string shill_nameservers;
+  shill_dictionary_->GetStringWithoutPathExpansion(
+      nameserver_property, &shill_nameservers);
+  std::vector<std::string> onc_nameserver_vector;
+  if (Tokenize(shill_nameservers, ",", &onc_nameserver_vector) > 0) {
+    scoped_ptr<base::ListValue> onc_nameservers(new base::ListValue);
+    for (std::vector<std::string>::iterator iter =
+             onc_nameserver_vector.begin();
+         iter != onc_nameserver_vector.end(); ++iter) {
+      onc_nameservers->AppendString(*iter);
+    }
+    onc_object_->SetWithoutPathExpansion(::onc::ipconfig::kNameServers,
+                                         onc_nameservers.release());
+  }
+}
+
+void ShillToONCTranslator::TranslateSavedIPConfig() {
+  TranslateSavedOrStaticIPConfig(shill::kSavedIPNameServersProperty);
+}
+
+void ShillToONCTranslator::TranslateStaticIPConfig() {
+  TranslateSavedOrStaticIPConfig(shill::kStaticIPNameServersProperty);
+}
+
 void ShillToONCTranslator::TranslateAndAddNestedObject(
     const std::string& onc_field_name) {
   TranslateAndAddNestedObject(onc_field_name, *shill_dictionary_);
 }
 
 void ShillToONCTranslator::TranslateAndAddNestedObject(
     const std::string& onc_field_name,
     const base::DictionaryValue& dictionary) {
   const OncFieldSignature* field_signature =
       GetFieldSignature(*onc_signature_, onc_field_name);
@@ skipping 58 matching lines @@
 }
 
 void ShillToONCTranslator::CopyPropertiesAccordingToSignature() {
   CopyPropertiesAccordingToSignature(onc_signature_);
 }
 
 void ShillToONCTranslator::CopyPropertiesAccordingToSignature(
     const OncValueSignature* value_signature) {
   if (value_signature->base_signature)
     CopyPropertiesAccordingToSignature(value_signature->base_signature);
+  if (!value_signature->fields)
+    return;
   for (const OncFieldSignature* field_signature = value_signature->fields;
        field_signature->onc_field_name != NULL; ++field_signature) {
     CopyProperty(field_signature);
   }
 }
 
 void ShillToONCTranslator::CopyProperty(
     const OncFieldSignature* field_signature) {
   std::string shill_property_name;
   const base::Value* shill_value = NULL;
@@ skipping 52 matching lines @@
     const base::DictionaryValue& shill_dictionary,
     const OncValueSignature* onc_signature) {
   CHECK(onc_signature != NULL);
 
   ShillToONCTranslator translator(shill_dictionary, *onc_signature);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos