chromeos/network/network_state.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/network/network_state.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "base/values.h"
   9 #include "chromeos/network/network_event_log.h"
  10 #include "chromeos/network/network_profile_handler.h"
  11 #include "chromeos/network/network_util.h"
  12 #include "chromeos/network/shill_property_util.h"
  13 #include "third_party/cros_system_api/dbus/service_constants.h"
  14
  15 namespace {
  16
  17 const char kErrorUnknown[] = "Unknown";
  18
  19 bool ConvertListValueToStringVector(const base::ListValue& string_list,
  20                                     std::vector<std::string>* result) {
  21   for (size_t i = 0; i < string_list.GetSize(); ++i) {
  22     std::string str;
  23     if (!string_list.GetString(i, &str))
  24       return false;
  25     result->push_back(str);
  26   }
  27   return true;
  28 }
  29
  30 bool IsCaCertNssSet(const base::DictionaryValue& properties) {
  31   std::string ca_cert_nss;
  32   if (properties.GetStringWithoutPathExpansion(shill::kEapCaCertNssProperty,
  33                                                &ca_cert_nss) &&
  34       !ca_cert_nss.empty()) {
  35     return true;
  36   }
  37
  38   const base::DictionaryValue* provider = NULL;
  39   properties.GetDictionaryWithoutPathExpansion(shill::kProviderProperty,
  40                                                &provider);
  41   if (!provider)
  42     return false;
  43   if (provider->GetStringWithoutPathExpansion(
  44           shill::kL2tpIpsecCaCertNssProperty, &ca_cert_nss) &&
  45       !ca_cert_nss.empty()) {
  46     return true;
  47   }
  48   if (provider->GetStringWithoutPathExpansion(
  49           shill::kOpenVPNCaCertNSSProperty, &ca_cert_nss) &&
  50       !ca_cert_nss.empty()) {
  51     return true;
  52   }
  53
  54   return false;
  55 }
  56
  57 }  // namespace
  58
  59 namespace chromeos {
  60
  61 NetworkState::NetworkState(const std::string& path)
  62     : ManagedState(MANAGED_TYPE_NETWORK, path),
  63       connectable_(false),
  64       prefix_length_(0),
  65       signal_strength_(0),
  66       activate_over_non_cellular_networks_(false),
  67       cellular_out_of_credits_(false),
  68       has_ca_cert_nss_(false) {
  69 }
  70
  71 NetworkState::~NetworkState() {
  72 }
  73
  74 bool NetworkState::PropertyChanged(const std::string& key,
  75                                    const base::Value& value) {
  76   // Keep care that these properties are the same as in |GetProperties|.
  77   if (ManagedStatePropertyChanged(key, value))
  78     return true;
  79   if (key == shill::kSignalStrengthProperty) {
  80     return GetIntegerValue(key, value, &signal_strength_);
  81   } else if (key == shill::kStateProperty) {
  82     return GetStringValue(key, value, &connection_state_);
  83   } else if (key == shill::kConnectableProperty) {
  84     return GetBooleanValue(key, value, &connectable_);
  85   } else if (key == shill::kErrorProperty) {
  86     if (!GetStringValue(key, value, &error_))
  87       return false;
  88     if (ErrorIsValid(error_))
  89       last_error_ = error_;
  90     else
  91       error_.clear();
  92     return true;
  93   } else if (key == shill::kActivationStateProperty) {
  94     return GetStringValue(key, value, &activation_state_);
  95   } else if (key == shill::kRoamingStateProperty) {
  96     return GetStringValue(key, value, &roaming_);
  97   } else if (key == shill::kSecurityProperty) {
  98     return GetStringValue(key, value, &security_);
  99   } else if (key == shill::kEapMethodProperty) {
 100     return GetStringValue(key, value, &eap_method_);
 101   } else if (key == shill::kUIDataProperty) {
 102     scoped_ptr<NetworkUIData> new_ui_data =
 103         shill_property_util::GetUIDataFromValue(value);
 104     if (!new_ui_data) {
 105       NET_LOG_ERROR("Failed to parse " + key, path());
 106       return false;
 107     }
 108     ui_data_ = *new_ui_data;
 109     return true;
 110   } else if (key == shill::kNetworkTechnologyProperty) {
 111     return GetStringValue(key, value, &network_technology_);
 112   } else if (key == shill::kDeviceProperty) {
 113     return GetStringValue(key, value, &device_path_);
 114   } else if (key == shill::kGuidProperty) {
 115     return GetStringValue(key, value, &guid_);
 116   } else if (key == shill::kProfileProperty) {
 117     return GetStringValue(key, value, &profile_path_);
 118   } else if (key == shill::kActivateOverNonCellularNetworkProperty) {
 119     return GetBooleanValue(key, value, &activate_over_non_cellular_networks_);
 120   } else if (key == shill::kOutOfCreditsProperty) {
 121     return GetBooleanValue(key, value, &cellular_out_of_credits_);
 122   }
 123   return false;
 124 }
 125
 126 bool NetworkState::InitialPropertiesReceived(
 127     const base::DictionaryValue& properties) {
 128   NET_LOG_DEBUG("InitialPropertiesReceived", path());
 129   bool changed = false;
 130   if (!properties.HasKey(shill::kTypeProperty)) {
 131     NET_LOG_ERROR("NetworkState has no type",
 132                   shill_property_util::GetNetworkIdFromProperties(properties));
 133     return false;
 134   }
 135   // Ensure that the network has a valid name.
 136   changed |= UpdateName(properties);
 137
 138   // Set the has_ca_cert_nss_ property.
 139   bool had_ca_cert_nss = has_ca_cert_nss_;
 140   has_ca_cert_nss_ = IsCaCertNssSet(properties);
 141   changed |= had_ca_cert_nss != has_ca_cert_nss_;
 142
 143   // By convention, all visible WiFi networks have a SignalStrength > 0.
 144   if (type() == shill::kTypeWifi) {
 145     if (signal_strength_ <= 0)
 146       signal_strength_ = 1;
 147   }
 148
 149   return changed;
 150 }
 151
 152 void NetworkState::GetStateProperties(base::DictionaryValue* dictionary) const {
 153   ManagedState::GetStateProperties(dictionary);
 154
 155   // Properties shared by all types.
 156   dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid());
 157   dictionary->SetStringWithoutPathExpansion(shill::kStateProperty,
 158                                             connection_state());
 159   dictionary->SetStringWithoutPathExpansion(shill::kSecurityProperty,
 160                                             security());
 161   if (!error().empty())
 162     dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error());
 163
 164   if (!NetworkTypePattern::Wireless().MatchesType(type()))
 165     return;
 166
 167   // Wireless properties
 168   dictionary->SetBooleanWithoutPathExpansion(shill::kConnectableProperty,
 169                                              connectable());
 170   dictionary->SetIntegerWithoutPathExpansion(shill::kSignalStrengthProperty,
 171                                              signal_strength());
 172
 173   // Wifi properties
 174   if (NetworkTypePattern::WiFi().MatchesType(type())) {
 175     dictionary->SetStringWithoutPathExpansion(shill::kEapMethodProperty,
 176                                               eap_method());
 177   }
 178
 179   // Mobile properties
 180   if (NetworkTypePattern::Mobile().MatchesType(type())) {
 181     dictionary->SetStringWithoutPathExpansion(
 182         shill::kNetworkTechnologyProperty,
 183         network_technology());
 184     dictionary->SetStringWithoutPathExpansion(shill::kActivationStateProperty,
 185                                               activation_state());
 186     dictionary->SetStringWithoutPathExpansion(shill::kRoamingStateProperty,
 187                                               roaming());
 188     dictionary->SetBooleanWithoutPathExpansion(shill::kOutOfCreditsProperty,
 189                                                cellular_out_of_credits());
 190   }
 191 }
 192
 193 void NetworkState::IPConfigPropertiesChanged(
 194     const base::DictionaryValue& properties) {
 195   for (base::DictionaryValue::Iterator iter(properties);
 196        !iter.IsAtEnd(); iter.Advance()) {
 197     std::string key = iter.key();
 198     const base::Value& value = iter.value();
 199
 200     if (key == shill::kAddressProperty) {
 201       GetStringValue(key, value, &ip_address_);
 202     } else if (key == shill::kGatewayProperty) {
 203       GetStringValue(key, value, &gateway_);
 204     } else if (key == shill::kNameServersProperty) {
 205       const base::ListValue* dns_servers;
 206       if (value.GetAsList(&dns_servers)) {
 207         dns_servers_.clear();
 208         ConvertListValueToStringVector(*dns_servers, &dns_servers_);
 209       }
 210     } else if (key == shill::kPrefixlenProperty) {
 211       GetIntegerValue(key, value, &prefix_length_);
 212     } else if (key == shill::kWebProxyAutoDiscoveryUrlProperty) {
 213       std::string url_string;
 214       if (GetStringValue(key, value, &url_string)) {
 215         if (url_string.empty()) {
 216           web_proxy_auto_discovery_url_ = GURL();
 217         } else {
 218           GURL gurl(url_string);
 219           if (gurl.is_valid()) {
 220             web_proxy_auto_discovery_url_ = gurl;
 221           } else {
 222             NET_LOG_ERROR("Invalid WebProxyAutoDiscoveryUrl: " + url_string,
 223                           path());
 224             web_proxy_auto_discovery_url_ = GURL();
 225           }
 226         }
 227       }
 228     }
 229   }
 230 }
 231
 232 bool NetworkState::RequiresActivation() const {
 233   return (type() == shill::kTypeCellular &&
 234           activation_state() != shill::kActivationStateActivated &&
 235           activation_state() != shill::kActivationStateUnknown);
 236 }
 237
 238 bool NetworkState::IsConnectedState() const {
 239   return StateIsConnected(connection_state_);
 240 }
 241
 242 bool NetworkState::IsConnectingState() const {
 243   return StateIsConnecting(connection_state_);
 244 }
 245
 246 bool NetworkState::IsPrivate() const {
 247   return !profile_path_.empty() &&
 248       profile_path_ != NetworkProfileHandler::GetSharedProfilePath();
 249 }
 250
 251 std::string NetworkState::GetDnsServersAsString() const {
 252   std::string result;
 253   for (size_t i = 0; i < dns_servers_.size(); ++i) {
 254     if (i != 0)
 255       result += ",";
 256     result += dns_servers_[i];
 257   }
 258   return result;
 259 }
 260
 261 std::string NetworkState::GetNetmask() const {
 262   return network_util::PrefixLengthToNetmask(prefix_length_);
 263 }
 264
 265 void NetworkState::SetGuid(const std::string& guid) {
 266   guid_ = guid;
 267 }
 268
 269 bool NetworkState::UpdateName(const base::DictionaryValue& properties) {
 270   std::string updated_name =
 271       shill_property_util::GetNameFromProperties(path(), properties);
 272   if (updated_name != name()) {
 273     set_name(updated_name);
 274     return true;
 275   }
 276   return false;
 277 }
 278
 279 // static
 280 bool NetworkState::StateIsConnected(const std::string& connection_state) {
 281   return (connection_state == shill::kStateReady ||
 282           connection_state == shill::kStateOnline ||
 283           connection_state == shill::kStatePortal);
 284 }
 285
 286 // static
 287 bool NetworkState::StateIsConnecting(const std::string& connection_state) {
 288   return (connection_state == shill::kStateAssociation ||
 289           connection_state == shill::kStateConfiguration ||
 290           connection_state == shill::kStateCarrier);
 291 }
 292
 293 // static
 294 bool NetworkState::ErrorIsValid(const std::string& error) {
 295   // Shill uses "Unknown" to indicate an unset or cleared error state.
 296   return !error.empty() && error != kErrorUnknown;
 297 }
 298
 299 }  // namespace chromeos