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 // Shill uses "Unknown" to indicate an unset error state. 89 if (error_ == kErrorUnknown) 90 error_.clear(); 91 return true; 92 } else if (key == IPConfigProperty(shill::kAddressProperty)) { 93 return GetStringValue(key, value, &ip_address_); 94 } else if (key == IPConfigProperty(shill::kGatewayProperty)) { 95 return GetStringValue(key, value, &gateway_); 96 } else if (key == IPConfigProperty(shill::kNameServersProperty)) { 97 const base::ListValue* dns_servers; 98 if (!value.GetAsList(&dns_servers)) 99 return false; 100 dns_servers_.clear(); 101 ConvertListValueToStringVector(*dns_servers, &dns_servers_); 102 return true; 103 } else if (key == IPConfigProperty(shill::kPrefixlenProperty)) { 104 return GetIntegerValue(key, value, &prefix_length_); 105 } else if (key == IPConfigProperty( 106 shill::kWebProxyAutoDiscoveryUrlProperty)) { 107 std::string url_string; 108 if (!GetStringValue(key, value, &url_string)) 109 return false; 110 if (url_string.empty()) { 111 web_proxy_auto_discovery_url_ = GURL(); 112 } else { 113 GURL gurl(url_string); 114 if (!gurl.is_valid()) { 115 web_proxy_auto_discovery_url_ = gurl; 116 } else { 117 NET_LOG_ERROR("Invalid WebProxyAutoDiscoveryUrl: " + url_string, 118 path()); 119 web_proxy_auto_discovery_url_ = GURL(); 120 } 121 } 122 return true; 123 } else if (key == shill::kActivationStateProperty) { 124 return GetStringValue(key, value, &activation_state_); 125 } else if (key == shill::kRoamingStateProperty) { 126 return GetStringValue(key, value, &roaming_); 127 } else if (key == shill::kSecurityProperty) { 128 return GetStringValue(key, value, &security_); 129 } else if (key == shill::kEapMethodProperty) { 130 return GetStringValue(key, value, &eap_method_); 131 } else if (key == shill::kUIDataProperty) { 132 scoped_ptr<NetworkUIData> new_ui_data = 133 shill_property_util::GetUIDataFromValue(value); 134 if (!new_ui_data) { 135 NET_LOG_ERROR("Failed to parse " + key, path()); 136 return false; 137 } 138 ui_data_ = *new_ui_data; 139 return true; 140 } else if (key == shill::kNetworkTechnologyProperty) { 141 return GetStringValue(key, value, &network_technology_); 142 } else if (key == shill::kDeviceProperty) { 143 return GetStringValue(key, value, &device_path_); 144 } else if (key == shill::kGuidProperty) { 145 return GetStringValue(key, value, &guid_); 146 } else if (key == shill::kProfileProperty) { 147 return GetStringValue(key, value, &profile_path_); 148 } else if (key == shill::kActivateOverNonCellularNetworkProperty) { 149 return GetBooleanValue(key, value, &activate_over_non_cellular_networks_); 150 } else if (key == shill::kOutOfCreditsProperty) { 151 return GetBooleanValue(key, value, &cellular_out_of_credits_); 152 } 153 return false; 154 } 155 156 bool NetworkState::InitialPropertiesReceived( 157 const base::DictionaryValue& properties) { 158 NET_LOG_DEBUG("InitialPropertiesReceived", path()); 159 bool changed = UpdateName(properties); 160 bool had_ca_cert_nss = has_ca_cert_nss_; 161 has_ca_cert_nss_ = IsCaCertNssSet(properties); 162 changed |= had_ca_cert_nss != has_ca_cert_nss_; 163 return changed; 164 } 165 166 void NetworkState::GetProperties(base::DictionaryValue* dictionary) const { 167 // Keep care that these properties are the same as in |PropertyChanged|. 168 dictionary->SetStringWithoutPathExpansion(shill::kNameProperty, name()); 169 dictionary->SetStringWithoutPathExpansion(shill::kTypeProperty, type()); 170 dictionary->SetIntegerWithoutPathExpansion(shill::kSignalStrengthProperty, 171 signal_strength_); 172 dictionary->SetStringWithoutPathExpansion(shill::kStateProperty, 173 connection_state_); 174 dictionary->SetBooleanWithoutPathExpansion(shill::kConnectableProperty, 175 connectable_); 176 177 dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error_); 178 179 // IPConfig properties 180 base::DictionaryValue* ipconfig_properties = new base::DictionaryValue; 181 ipconfig_properties->SetStringWithoutPathExpansion(shill::kAddressProperty, 182 ip_address_); 183 ipconfig_properties->SetStringWithoutPathExpansion(shill::kGatewayProperty, 184 gateway_); 185 base::ListValue* name_servers = new base::ListValue; 186 name_servers->AppendStrings(dns_servers_); 187 ipconfig_properties->SetWithoutPathExpansion(shill::kNameServersProperty, 188 name_servers); 189 ipconfig_properties->SetStringWithoutPathExpansion( 190 shill::kWebProxyAutoDiscoveryUrlProperty, 191 web_proxy_auto_discovery_url_.spec()); 192 dictionary->SetWithoutPathExpansion(shill::kIPConfigProperty, 193 ipconfig_properties); 194 195 dictionary->SetStringWithoutPathExpansion(shill::kActivationStateProperty, 196 activation_state_); 197 dictionary->SetStringWithoutPathExpansion(shill::kRoamingStateProperty, 198 roaming_); 199 dictionary->SetStringWithoutPathExpansion(shill::kSecurityProperty, 200 security_); 201 dictionary->SetStringWithoutPathExpansion(shill::kEapMethodProperty, 202 eap_method_); 203 // Proxy config and ONC source are intentionally omitted: These properties are 204 // placed in NetworkState to transition ProxyConfigServiceImpl from 205 // NetworkLibrary to the new network stack. The networking extension API 206 // shouldn't depend on this member. Once ManagedNetworkConfigurationHandler 207 // is used instead of NetworkLibrary, we can remove them again. 208 dictionary->SetStringWithoutPathExpansion( 209 shill::kNetworkTechnologyProperty, 210 network_technology_); 211 dictionary->SetStringWithoutPathExpansion(shill::kDeviceProperty, 212 device_path_); 213 dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid_); 214 dictionary->SetStringWithoutPathExpansion(shill::kProfileProperty, 215 profile_path_); 216 dictionary->SetBooleanWithoutPathExpansion( 217 shill::kActivateOverNonCellularNetworkProperty, 218 activate_over_non_cellular_networks_); 219 dictionary->SetBooleanWithoutPathExpansion(shill::kOutOfCreditsProperty, 220 cellular_out_of_credits_); 221 } 222 223 bool NetworkState::RequiresActivation() const { 224 return (type() == shill::kTypeCellular && 225 activation_state() != shill::kActivationStateActivated && 226 activation_state() != shill::kActivationStateUnknown); 227 } 228 229 bool NetworkState::IsConnectedState() const { 230 return StateIsConnected(connection_state_); 231 } 232 233 bool NetworkState::IsConnectingState() const { 234 return StateIsConnecting(connection_state_); 235 } 236 237 bool NetworkState::IsPrivate() const { 238 return !profile_path_.empty() && 239 profile_path_ != NetworkProfileHandler::kSharedProfilePath; 240 } 241 242 std::string NetworkState::GetDnsServersAsString() const { 243 std::string result; 244 for (size_t i = 0; i < dns_servers_.size(); ++i) { 245 if (i != 0) 246 result += ","; 247 result += dns_servers_[i]; 248 } 249 return result; 250 } 251 252 std::string NetworkState::GetNetmask() const { 253 return network_util::PrefixLengthToNetmask(prefix_length_); 254 } 255 256 bool NetworkState::UpdateName(const base::DictionaryValue& properties) { 257 std::string updated_name = 258 shill_property_util::GetNameFromProperties(path(), properties); 259 if (updated_name != name()) { 260 set_name(updated_name); 261 return true; 262 } 263 return false; 264 } 265 266 // static 267 bool NetworkState::StateIsConnected(const std::string& connection_state) { 268 return (connection_state == shill::kStateReady || 269 connection_state == shill::kStateOnline || 270 connection_state == shill::kStatePortal); 271 } 272 273 // static 274 bool NetworkState::StateIsConnecting(const std::string& connection_state) { 275 return (connection_state == shill::kStateAssociation || 276 connection_state == shill::kStateConfiguration || 277 connection_state == shill::kStateCarrier); 278 } 279 280 // static 281 std::string NetworkState::IPConfigProperty(const char* key) { 282 return base::StringPrintf("%s.%s", shill::kIPConfigProperty, key); 283 } 284 285 } // namespace chromeos 286
