| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/native_network_parser.h" |
| 6 |
| 7 #include "base/stringprintf.h" |
| 8 #include "chrome/browser/chromeos/cros/native_network_constants.h" |
| 9 #include "chrome/browser/chromeos/cros/network_library.h" |
| 10 #include "chrome/browser/chromeos/login/user_manager.h" |
| 11 |
| 12 namespace chromeos { |
| 13 |
| 14 // Local constants. |
| 15 namespace { |
| 16 |
| 17 EnumMapper<PropertyIndex>::Pair property_index_table[] = { |
| 18 { kActivationStateProperty, PROPERTY_INDEX_ACTIVATION_STATE }, |
| 19 { kActiveProfileProperty, PROPERTY_INDEX_ACTIVE_PROFILE }, |
| 20 { kArpGatewayProperty, PROPERTY_INDEX_ARP_GATEWAY }, |
| 21 { kAutoConnectProperty, PROPERTY_INDEX_AUTO_CONNECT }, |
| 22 { kAvailableTechnologiesProperty, PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES }, |
| 23 { kCarrierProperty, PROPERTY_INDEX_CARRIER }, |
| 24 { kCellularAllowRoamingProperty, PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING }, |
| 25 { kCellularApnListProperty, PROPERTY_INDEX_CELLULAR_APN_LIST }, |
| 26 { kCellularApnProperty, PROPERTY_INDEX_CELLULAR_APN }, |
| 27 { kCellularLastGoodApnProperty, PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN }, |
| 28 { kCheckPortalListProperty, PROPERTY_INDEX_CHECK_PORTAL_LIST }, |
| 29 { kConnectableProperty, PROPERTY_INDEX_CONNECTABLE }, |
| 30 { kConnectedTechnologiesProperty, PROPERTY_INDEX_CONNECTED_TECHNOLOGIES }, |
| 31 { kDefaultTechnologyProperty, PROPERTY_INDEX_DEFAULT_TECHNOLOGY }, |
| 32 { kDeviceProperty, PROPERTY_INDEX_DEVICE }, |
| 33 { kDevicesProperty, PROPERTY_INDEX_DEVICES }, |
| 34 { kEapAnonymousIdentityProperty, PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY }, |
| 35 { kEapCaCertIdProperty, PROPERTY_INDEX_EAP_CA_CERT_ID }, |
| 36 { kEapCaCertNssProperty, PROPERTY_INDEX_EAP_CA_CERT_NSS }, |
| 37 { kEapCaCertProperty, PROPERTY_INDEX_EAP_CA_CERT }, |
| 38 { kEapCertIdProperty, PROPERTY_INDEX_EAP_CERT_ID }, |
| 39 { kEapClientCertNssProperty, PROPERTY_INDEX_EAP_CLIENT_CERT_NSS }, |
| 40 { kEapClientCertProperty, PROPERTY_INDEX_EAP_CLIENT_CERT }, |
| 41 { kEapIdentityProperty, PROPERTY_INDEX_EAP_IDENTITY }, |
| 42 { kEapKeyIdProperty, PROPERTY_INDEX_EAP_KEY_ID }, |
| 43 { kEapKeyMgmtProperty, PROPERTY_INDEX_EAP_KEY_MGMT }, |
| 44 { kEapMethodProperty, PROPERTY_INDEX_EAP_METHOD }, |
| 45 { kEapPasswordProperty, PROPERTY_INDEX_EAP_PASSWORD }, |
| 46 { kEapPhase2AuthProperty, PROPERTY_INDEX_EAP_PHASE_2_AUTH }, |
| 47 { kEapPinProperty, PROPERTY_INDEX_EAP_PIN }, |
| 48 { kEapPrivateKeyPasswordProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD }, |
| 49 { kEapPrivateKeyProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY }, |
| 50 { kEapUseSystemCasProperty, PROPERTY_INDEX_EAP_USE_SYSTEM_CAS }, |
| 51 { kEnabledTechnologiesProperty, PROPERTY_INDEX_ENABLED_TECHNOLOGIES }, |
| 52 { kErrorProperty, PROPERTY_INDEX_ERROR }, |
| 53 { kEsnProperty, PROPERTY_INDEX_ESN }, |
| 54 { kFavoriteProperty, PROPERTY_INDEX_FAVORITE }, |
| 55 { kFirmwareRevisionProperty, PROPERTY_INDEX_FIRMWARE_REVISION }, |
| 56 { kFoundNetworksProperty, PROPERTY_INDEX_FOUND_NETWORKS }, |
| 57 { kGuidProperty, PROPERTY_INDEX_GUID }, |
| 58 { kHardwareRevisionProperty, PROPERTY_INDEX_HARDWARE_REVISION }, |
| 59 { kHomeProviderProperty, PROPERTY_INDEX_HOME_PROVIDER }, |
| 60 { kHostProperty, PROPERTY_INDEX_HOST }, |
| 61 { kIdentityProperty, PROPERTY_INDEX_IDENTITY }, |
| 62 { kImeiProperty, PROPERTY_INDEX_IMEI }, |
| 63 { kImsiProperty, PROPERTY_INDEX_IMSI }, |
| 64 { kIsActiveProperty, PROPERTY_INDEX_IS_ACTIVE }, |
| 65 { kL2tpIpsecCaCertNssProperty, PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS }, |
| 66 { kL2tpIpsecClientCertIdProperty, PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID }, |
| 67 { kL2tpIpsecClientCertSlotProp, PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT }, |
| 68 { kL2tpIpsecPinProperty, PROPERTY_INDEX_L2TPIPSEC_PIN }, |
| 69 { kL2tpIpsecPskProperty, PROPERTY_INDEX_L2TPIPSEC_PSK }, |
| 70 { kL2tpIpsecPasswordProperty, PROPERTY_INDEX_L2TPIPSEC_PASSWORD }, |
| 71 { kL2tpIpsecUserProperty, PROPERTY_INDEX_L2TPIPSEC_USER }, |
| 72 { kManufacturerProperty, PROPERTY_INDEX_MANUFACTURER }, |
| 73 { kMdnProperty, PROPERTY_INDEX_MDN }, |
| 74 { kMeidProperty, PROPERTY_INDEX_MEID }, |
| 75 { kMinProperty, PROPERTY_INDEX_MIN }, |
| 76 { kModeProperty, PROPERTY_INDEX_MODE }, |
| 77 { kModelIdProperty, PROPERTY_INDEX_MODEL_ID }, |
| 78 { kNameProperty, PROPERTY_INDEX_NAME }, |
| 79 { kNetworkTechnologyProperty, PROPERTY_INDEX_NETWORK_TECHNOLOGY }, |
| 80 { kNetworksProperty, PROPERTY_INDEX_NETWORKS }, |
| 81 { kOfflineModeProperty, PROPERTY_INDEX_OFFLINE_MODE }, |
| 82 { kOperatorCodeProperty, PROPERTY_INDEX_OPERATOR_CODE }, |
| 83 { kOperatorNameProperty, PROPERTY_INDEX_OPERATOR_NAME }, |
| 84 { kPrlVersionProperty, PROPERTY_INDEX_PRL_VERSION }, |
| 85 { kPassphraseProperty, PROPERTY_INDEX_PASSPHRASE }, |
| 86 { kPassphraseRequiredProperty, PROPERTY_INDEX_PASSPHRASE_REQUIRED }, |
| 87 { kPaymentUrlProperty, PROPERTY_INDEX_PAYMENT_URL }, |
| 88 { kPortalUrlProperty, PROPERTY_INDEX_PORTAL_URL }, |
| 89 { kPoweredProperty, PROPERTY_INDEX_POWERED }, |
| 90 { kPriorityProperty, PROPERTY_INDEX_PRIORITY }, |
| 91 { kProfileProperty, PROPERTY_INDEX_PROFILE }, |
| 92 { kProfilesProperty, PROPERTY_INDEX_PROFILES }, |
| 93 { kProviderProperty, PROPERTY_INDEX_PROVIDER }, |
| 94 { kProxyConfigProperty, PROPERTY_INDEX_PROXY_CONFIG }, |
| 95 { kRoamingStateProperty, PROPERTY_INDEX_ROAMING_STATE }, |
| 96 { kSimLockStatusProperty, PROPERTY_INDEX_SIM_LOCK }, |
| 97 { kSaveCredentialsProperty, PROPERTY_INDEX_SAVE_CREDENTIALS }, |
| 98 { kScanningProperty, PROPERTY_INDEX_SCANNING }, |
| 99 { kSecurityProperty, PROPERTY_INDEX_SECURITY }, |
| 100 { kSelectedNetworkProperty, PROPERTY_INDEX_SELECTED_NETWORK }, |
| 101 { kServiceWatchListProperty, PROPERTY_INDEX_SERVICE_WATCH_LIST }, |
| 102 { kServicesProperty, PROPERTY_INDEX_SERVICES }, |
| 103 { kServingOperatorProperty, PROPERTY_INDEX_SERVING_OPERATOR }, |
| 104 { kSignalStrengthProperty, PROPERTY_INDEX_SIGNAL_STRENGTH }, |
| 105 { kStateProperty, PROPERTY_INDEX_STATE }, |
| 106 { kSupportNetworkScanProperty, PROPERTY_INDEX_SUPPORT_NETWORK_SCAN }, |
| 107 { kTechnologyFamilyProperty, PROPERTY_INDEX_TECHNOLOGY_FAMILY }, |
| 108 { kTypeProperty, PROPERTY_INDEX_TYPE }, |
| 109 { kUsageUrlProperty, PROPERTY_INDEX_USAGE_URL }, |
| 110 { kWifiAuthMode, PROPERTY_INDEX_WIFI_AUTH_MODE }, |
| 111 { kWifiFrequency, PROPERTY_INDEX_WIFI_FREQUENCY }, |
| 112 { kWifiHexSsid, PROPERTY_INDEX_WIFI_HEX_SSID }, |
| 113 { kWifiHiddenSsid, PROPERTY_INDEX_WIFI_HIDDEN_SSID }, |
| 114 { kWifiPhyMode, PROPERTY_INDEX_WIFI_PHY_MODE }, |
| 115 }; |
| 116 |
| 117 // Serve the singleton mapper instance. |
| 118 const EnumMapper<PropertyIndex>* get_native_mapper() { |
| 119 static const EnumMapper<PropertyIndex> mapper(property_index_table, |
| 120 arraysize(property_index_table), |
| 121 PROPERTY_INDEX_UNKNOWN); |
| 122 return &mapper; |
| 123 } |
| 124 |
| 125 ConnectionType ParseNetworkType(const std::string& type) { |
| 126 static EnumMapper<ConnectionType>::Pair table[] = { |
| 127 { kTypeEthernet, TYPE_ETHERNET }, |
| 128 { kTypeWifi, TYPE_WIFI }, |
| 129 { kTypeWimax, TYPE_WIMAX }, |
| 130 { kTypeBluetooth, TYPE_BLUETOOTH }, |
| 131 { kTypeCellular, TYPE_CELLULAR }, |
| 132 { kTypeVpn, TYPE_VPN }, |
| 133 }; |
| 134 static EnumMapper<ConnectionType> parser( |
| 135 table, arraysize(table), TYPE_UNKNOWN); |
| 136 return parser.Get(type); |
| 137 } |
| 138 |
| 139 } // namespace |
| 140 |
| 141 // -------------------- NativeNetworkDeviceParser -------------------- |
| 142 |
| 143 NativeNetworkDeviceParser::NativeNetworkDeviceParser() |
| 144 : NetworkDeviceParser(get_native_mapper()) { |
| 145 } |
| 146 |
| 147 NativeNetworkDeviceParser::~NativeNetworkDeviceParser() { |
| 148 } |
| 149 |
| 150 bool NativeNetworkDeviceParser::ParseValue( |
| 151 PropertyIndex index, const Value& value, NetworkDevice* device) { |
| 152 switch (index) { |
| 153 case PROPERTY_INDEX_TYPE: { |
| 154 std::string type_string; |
| 155 if (value.GetAsString(&type_string)) { |
| 156 device->set_type(ParseType(type_string)); |
| 157 return true; |
| 158 } |
| 159 break; |
| 160 } |
| 161 case PROPERTY_INDEX_NAME: { |
| 162 std::string name; |
| 163 if (!value.GetAsString(&name)) |
| 164 return false; |
| 165 device->set_name(name); |
| 166 return true; |
| 167 } |
| 168 case PROPERTY_INDEX_GUID: { |
| 169 std::string unique_id; |
| 170 if (!value.GetAsString(&unique_id)) |
| 171 return false; |
| 172 device->set_unique_id(unique_id); |
| 173 return true; |
| 174 } |
| 175 case PROPERTY_INDEX_CARRIER: { |
| 176 std::string carrier; |
| 177 if (!value.GetAsString(&carrier)) |
| 178 return false; |
| 179 device->set_carrier(carrier); |
| 180 return true; |
| 181 } |
| 182 case PROPERTY_INDEX_SCANNING: { |
| 183 bool scanning; |
| 184 if (!value.GetAsBoolean(&scanning)) |
| 185 return false; |
| 186 device->set_scanning(scanning); |
| 187 return true; |
| 188 } |
| 189 case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: { |
| 190 bool data_roaming_allowed; |
| 191 if (!value.GetAsBoolean(&data_roaming_allowed)) |
| 192 return false; |
| 193 device->set_data_roaming_allowed(data_roaming_allowed); |
| 194 return true; |
| 195 } |
| 196 case PROPERTY_INDEX_CELLULAR_APN_LIST: |
| 197 if (value.IsType(Value::TYPE_LIST)) { |
| 198 CellularApnList provider_apn_list; |
| 199 if (!ParseApnList(static_cast<const ListValue&>(value), |
| 200 &provider_apn_list)) |
| 201 return false; |
| 202 device->set_provider_apn_list(provider_apn_list); |
| 203 return true; |
| 204 } |
| 205 break; |
| 206 case PROPERTY_INDEX_NETWORKS: |
| 207 if (value.IsType(Value::TYPE_LIST)) { |
| 208 // Ignored. |
| 209 return true; |
| 210 } |
| 211 break; |
| 212 case PROPERTY_INDEX_FOUND_NETWORKS: |
| 213 if (value.IsType(Value::TYPE_LIST)) { |
| 214 CellularNetworkList found_cellular_networks; |
| 215 if (!ParseFoundNetworksFromList( |
| 216 static_cast<const ListValue&>(value), |
| 217 &found_cellular_networks)) |
| 218 return false; |
| 219 device->set_found_cellular_networks(found_cellular_networks); |
| 220 return true; |
| 221 } |
| 222 break; |
| 223 case PROPERTY_INDEX_HOME_PROVIDER: { |
| 224 if (value.IsType(Value::TYPE_DICTIONARY)) { |
| 225 const DictionaryValue& dict = |
| 226 static_cast<const DictionaryValue&>(value); |
| 227 std::string home_provider_code; |
| 228 std::string home_provider_country; |
| 229 std::string home_provider_name; |
| 230 dict.GetStringWithoutPathExpansion(kOperatorCodeKey, |
| 231 &home_provider_code); |
| 232 dict.GetStringWithoutPathExpansion(kOperatorCountryKey, |
| 233 &home_provider_country); |
| 234 dict.GetStringWithoutPathExpansion(kOperatorNameKey, |
| 235 &home_provider_name); |
| 236 device->set_home_provider_code(home_provider_code); |
| 237 device->set_home_provider_country(home_provider_country); |
| 238 device->set_home_provider_name(home_provider_name); |
| 239 if (!device->home_provider_name().empty() && |
| 240 !device->home_provider_country().empty()) { |
| 241 device->set_home_provider_id(base::StringPrintf( |
| 242 kCarrierIdFormat, |
| 243 device->home_provider_name().c_str(), |
| 244 device->home_provider_country().c_str())); |
| 245 } else { |
| 246 device->set_home_provider_id(home_provider_code); |
| 247 LOG(WARNING) << "Carrier ID not defined, using code instead: " |
| 248 << device->home_provider_id(); |
| 249 } |
| 250 return true; |
| 251 } |
| 252 break; |
| 253 } |
| 254 case PROPERTY_INDEX_MEID: |
| 255 case PROPERTY_INDEX_IMEI: |
| 256 case PROPERTY_INDEX_IMSI: |
| 257 case PROPERTY_INDEX_ESN: |
| 258 case PROPERTY_INDEX_MDN: |
| 259 case PROPERTY_INDEX_MIN: |
| 260 case PROPERTY_INDEX_MODEL_ID: |
| 261 case PROPERTY_INDEX_MANUFACTURER: |
| 262 case PROPERTY_INDEX_FIRMWARE_REVISION: |
| 263 case PROPERTY_INDEX_HARDWARE_REVISION: |
| 264 case PROPERTY_INDEX_SELECTED_NETWORK: { |
| 265 std::string item; |
| 266 if (!value.GetAsString(&item)) |
| 267 return false; |
| 268 switch (index) { |
| 269 case PROPERTY_INDEX_MEID: |
| 270 device->set_meid(item); |
| 271 break; |
| 272 case PROPERTY_INDEX_IMEI: |
| 273 device->set_imei(item); |
| 274 break; |
| 275 case PROPERTY_INDEX_IMSI: |
| 276 device->set_imsi(item); |
| 277 break; |
| 278 case PROPERTY_INDEX_ESN: |
| 279 device->set_esn(item); |
| 280 break; |
| 281 case PROPERTY_INDEX_MDN: |
| 282 device->set_mdn(item); |
| 283 break; |
| 284 case PROPERTY_INDEX_MIN: |
| 285 device->set_min(item); |
| 286 break; |
| 287 case PROPERTY_INDEX_MODEL_ID: |
| 288 device->set_model_id(item); |
| 289 break; |
| 290 case PROPERTY_INDEX_MANUFACTURER: |
| 291 device->set_manufacturer(item); |
| 292 break; |
| 293 case PROPERTY_INDEX_FIRMWARE_REVISION: |
| 294 device->set_firmware_revision(item); |
| 295 break; |
| 296 case PROPERTY_INDEX_HARDWARE_REVISION: |
| 297 device->set_hardware_revision(item); |
| 298 break; |
| 299 case PROPERTY_INDEX_SELECTED_NETWORK: |
| 300 device->set_selected_cellular_network(item); |
| 301 break; |
| 302 default: |
| 303 break; |
| 304 } |
| 305 return true; |
| 306 } |
| 307 case PROPERTY_INDEX_SIM_LOCK: |
| 308 if (value.IsType(Value::TYPE_DICTIONARY)) { |
| 309 SimLockState sim_lock_state; |
| 310 int sim_retries_left; |
| 311 if (!ParseSimLockStateFromDictionary( |
| 312 static_cast<const DictionaryValue&>(value), |
| 313 &sim_lock_state, |
| 314 &sim_retries_left)) |
| 315 return false; |
| 316 device->set_sim_lock_state(sim_lock_state); |
| 317 device->set_sim_retries_left(sim_retries_left); |
| 318 // Initialize PinRequired value only once. |
| 319 // See SimPinRequire enum comments. |
| 320 if (device->sim_pin_required() == SIM_PIN_REQUIRE_UNKNOWN) { |
| 321 if (device->sim_lock_state() == SIM_UNLOCKED) { |
| 322 device->set_sim_pin_required(SIM_PIN_NOT_REQUIRED); |
| 323 } else if (device->sim_lock_state() == SIM_LOCKED_PIN || |
| 324 device->sim_lock_state() == SIM_LOCKED_PUK) { |
| 325 device->set_sim_pin_required(SIM_PIN_REQUIRED); |
| 326 } |
| 327 } |
| 328 return true; |
| 329 } |
| 330 break; |
| 331 case PROPERTY_INDEX_POWERED: |
| 332 // we don't care about the value, just the fact that it changed |
| 333 return true; |
| 334 case PROPERTY_INDEX_PRL_VERSION: { |
| 335 int prl_version; |
| 336 if (!value.GetAsInteger(&prl_version)) |
| 337 return false; |
| 338 device->set_prl_version(prl_version); |
| 339 return true; |
| 340 } |
| 341 case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN: { |
| 342 bool support_network_scan; |
| 343 if (!value.GetAsBoolean(&support_network_scan)) |
| 344 return false; |
| 345 device->set_support_network_scan(support_network_scan); |
| 346 return true; |
| 347 } |
| 348 case PROPERTY_INDEX_TECHNOLOGY_FAMILY: { |
| 349 std::string technology_family_string; |
| 350 if (value.GetAsString(&technology_family_string)) { |
| 351 device->set_technology_family( |
| 352 ParseTechnologyFamily(technology_family_string)); |
| 353 return true; |
| 354 } |
| 355 break; |
| 356 } |
| 357 default: |
| 358 break; |
| 359 } |
| 360 return false; |
| 361 } |
| 362 |
| 363 ConnectionType NativeNetworkDeviceParser::ParseType(const std::string& type) { |
| 364 return ParseNetworkType(type); |
| 365 } |
| 366 |
| 367 bool NativeNetworkDeviceParser::ParseApnList(const ListValue& list, |
| 368 CellularApnList* apn_list) { |
| 369 apn_list->clear(); |
| 370 apn_list->reserve(list.GetSize()); |
| 371 for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) { |
| 372 if ((*it)->IsType(Value::TYPE_DICTIONARY)) { |
| 373 apn_list->resize(apn_list->size() + 1); |
| 374 const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); |
| 375 dict->GetStringWithoutPathExpansion( |
| 376 kApnProperty, &apn_list->back().apn); |
| 377 dict->GetStringWithoutPathExpansion( |
| 378 kApnNetworkIdProperty, &apn_list->back().network_id); |
| 379 dict->GetStringWithoutPathExpansion( |
| 380 kApnUsernameProperty, &apn_list->back().username); |
| 381 dict->GetStringWithoutPathExpansion( |
| 382 kApnPasswordProperty, &apn_list->back().password); |
| 383 dict->GetStringWithoutPathExpansion( |
| 384 kApnNameProperty, &apn_list->back().name); |
| 385 dict->GetStringWithoutPathExpansion( |
| 386 kApnLocalizedNameProperty, &apn_list->back().localized_name); |
| 387 dict->GetStringWithoutPathExpansion( |
| 388 kApnLanguageProperty, &apn_list->back().language); |
| 389 } else { |
| 390 return false; |
| 391 } |
| 392 } |
| 393 return true; |
| 394 } |
| 395 |
| 396 bool NativeNetworkDeviceParser::ParseFoundNetworksFromList( |
| 397 const ListValue& list, |
| 398 CellularNetworkList* found_networks) { |
| 399 found_networks->clear(); |
| 400 found_networks->reserve(list.GetSize()); |
| 401 for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) { |
| 402 if ((*it)->IsType(Value::TYPE_DICTIONARY)) { |
| 403 found_networks->resize(found_networks->size() + 1); |
| 404 const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); |
| 405 dict->GetStringWithoutPathExpansion( |
| 406 kStatusProperty, &found_networks->back().status); |
| 407 dict->GetStringWithoutPathExpansion( |
| 408 kNetworkIdProperty, &found_networks->back().network_id); |
| 409 dict->GetStringWithoutPathExpansion( |
| 410 kShortNameProperty, &found_networks->back().short_name); |
| 411 dict->GetStringWithoutPathExpansion( |
| 412 kLongNameProperty, &found_networks->back().long_name); |
| 413 dict->GetStringWithoutPathExpansion( |
| 414 kTechnologyProperty, &found_networks->back().technology); |
| 415 } else { |
| 416 return false; |
| 417 } |
| 418 } |
| 419 return true; |
| 420 } |
| 421 |
| 422 SimLockState NativeNetworkDeviceParser::ParseSimLockState( |
| 423 const std::string& state) { |
| 424 static EnumMapper<SimLockState>::Pair table[] = { |
| 425 { "", SIM_UNLOCKED }, |
| 426 { kSimLockPin, SIM_LOCKED_PIN }, |
| 427 { kSimLockPuk, SIM_LOCKED_PUK }, |
| 428 }; |
| 429 static EnumMapper<SimLockState> parser( |
| 430 table, arraysize(table), SIM_UNKNOWN); |
| 431 SimLockState parsed_state = parser.Get(state); |
| 432 DCHECK(parsed_state != SIM_UNKNOWN) << "Unknown SIMLock state encountered"; |
| 433 return parsed_state; |
| 434 } |
| 435 |
| 436 bool NativeNetworkDeviceParser::ParseSimLockStateFromDictionary( |
| 437 const DictionaryValue& info, SimLockState* out_state, int* out_retries) { |
| 438 std::string state_string; |
| 439 if (!info.GetString(kSimLockTypeProperty, &state_string) || |
| 440 !info.GetInteger(kSimLockRetriesLeftProperty, out_retries)) { |
| 441 LOG(ERROR) << "Error parsing SIMLock state"; |
| 442 return false; |
| 443 } |
| 444 *out_state = ParseSimLockState(state_string); |
| 445 return true; |
| 446 } |
| 447 |
| 448 TechnologyFamily NativeNetworkDeviceParser::ParseTechnologyFamily( |
| 449 const std::string& technology_family) { |
| 450 static EnumMapper<TechnologyFamily>::Pair table[] = { |
| 451 { kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA }, |
| 452 { kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM }, |
| 453 }; |
| 454 static EnumMapper<TechnologyFamily> parser( |
| 455 table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN); |
| 456 return parser.Get(technology_family); |
| 457 } |
| 458 |
| 459 // -------------------- NativeNetworkParser -------------------- |
| 460 |
| 461 NativeNetworkParser::NativeNetworkParser() |
| 462 : NetworkParser(get_native_mapper()) { |
| 463 } |
| 464 |
| 465 NativeNetworkParser::~NativeNetworkParser() { |
| 466 } |
| 467 |
| 468 // static |
| 469 const EnumMapper<PropertyIndex>* NativeNetworkParser::property_mapper() { |
| 470 return get_native_mapper(); |
| 471 |
| 472 } |
| 473 |
| 474 const ConnectionType NativeNetworkParser::ParseConnectionType( |
| 475 const std::string& connection_type) { |
| 476 return ParseNetworkType(connection_type); |
| 477 } |
| 478 |
| 479 bool NativeNetworkParser::ParseValue(PropertyIndex index, |
| 480 const Value& value, |
| 481 Network* network) { |
| 482 switch (index) { |
| 483 case PROPERTY_INDEX_TYPE: { |
| 484 std::string type_string; |
| 485 if (value.GetAsString(&type_string)) { |
| 486 ConnectionType type = ParseType(type_string); |
| 487 LOG_IF(ERROR, type != network->type()) |
| 488 << "Network with mismatched type: " << network->service_path() |
| 489 << " " << type << " != " << network->type(); |
| 490 return true; |
| 491 } |
| 492 break; |
| 493 } |
| 494 case PROPERTY_INDEX_DEVICE: { |
| 495 std::string device_path; |
| 496 if (!value.GetAsString(&device_path)) |
| 497 return false; |
| 498 network->set_device_path(device_path); |
| 499 return true; |
| 500 } |
| 501 case PROPERTY_INDEX_NAME: { |
| 502 std::string name; |
| 503 if (!value.GetAsString(&name)) |
| 504 return false; |
| 505 network->SetName(name); |
| 506 return true; |
| 507 } |
| 508 case PROPERTY_INDEX_GUID: { |
| 509 std::string unique_id; |
| 510 if (!value.GetAsString(&unique_id)) |
| 511 return false; |
| 512 network->set_unique_id(unique_id); |
| 513 return true; |
| 514 } |
| 515 case PROPERTY_INDEX_PROFILE: { |
| 516 // Note: currently this is only provided for non remembered networks. |
| 517 std::string profile_path; |
| 518 if (!value.GetAsString(&profile_path)) |
| 519 return false; |
| 520 network->set_profile_path(profile_path); |
| 521 return true; |
| 522 } |
| 523 case PROPERTY_INDEX_STATE: { |
| 524 std::string state_string; |
| 525 if (value.GetAsString(&state_string)) { |
| 526 network->SetState(ParseState(state_string)); |
| 527 return true; |
| 528 } |
| 529 break; |
| 530 } |
| 531 case PROPERTY_INDEX_MODE: { |
| 532 std::string mode_string; |
| 533 if (value.GetAsString(&mode_string)) { |
| 534 network->set_mode(ParseMode(mode_string)); |
| 535 return true; |
| 536 } |
| 537 break; |
| 538 } |
| 539 case PROPERTY_INDEX_ERROR: { |
| 540 std::string error_string; |
| 541 if (value.GetAsString(&error_string)) { |
| 542 network->set_error(ParseError(error_string)); |
| 543 return true; |
| 544 } |
| 545 break; |
| 546 } |
| 547 case PROPERTY_INDEX_CONNECTABLE: { |
| 548 bool connectable; |
| 549 if (!value.GetAsBoolean(&connectable)) |
| 550 return false; |
| 551 network->set_connectable(connectable); |
| 552 return true; |
| 553 } |
| 554 case PROPERTY_INDEX_IS_ACTIVE: { |
| 555 bool is_active; |
| 556 if (!value.GetAsBoolean(&is_active)) |
| 557 return false; |
| 558 network->set_is_active(is_active); |
| 559 return true; |
| 560 } |
| 561 case PROPERTY_INDEX_FAVORITE: |
| 562 // This property is ignored. |
| 563 return true; |
| 564 case PROPERTY_INDEX_AUTO_CONNECT: { |
| 565 bool auto_connect; |
| 566 if (!value.GetAsBoolean(&auto_connect)) |
| 567 return false; |
| 568 network->set_auto_connect(auto_connect); |
| 569 return true; |
| 570 } |
| 571 case PROPERTY_INDEX_SAVE_CREDENTIALS: { |
| 572 bool save_credentials; |
| 573 if (!value.GetAsBoolean(&save_credentials)) |
| 574 return false; |
| 575 network->set_save_credentials(save_credentials); |
| 576 return true; |
| 577 } |
| 578 default: |
| 579 break; |
| 580 } |
| 581 return false; |
| 582 } |
| 583 |
| 584 ConnectionType NativeNetworkParser::ParseType(const std::string& type) { |
| 585 return ParseNetworkType(type); |
| 586 } |
| 587 |
| 588 ConnectionType NativeNetworkParser::ParseTypeFromDictionary( |
| 589 const DictionaryValue& info) { |
| 590 std::string type_string; |
| 591 info.GetString(kTypeProperty, &type_string); |
| 592 return ParseType(type_string); |
| 593 } |
| 594 |
| 595 ConnectionMode NativeNetworkParser::ParseMode(const std::string& mode) { |
| 596 static EnumMapper<ConnectionMode>::Pair table[] = { |
| 597 { kModeManaged, MODE_MANAGED }, |
| 598 { kModeAdhoc, MODE_ADHOC }, |
| 599 }; |
| 600 static EnumMapper<ConnectionMode> parser( |
| 601 table, arraysize(table), MODE_UNKNOWN); |
| 602 return parser.Get(mode); |
| 603 } |
| 604 |
| 605 ConnectionState NativeNetworkParser::ParseState(const std::string& state) { |
| 606 static EnumMapper<ConnectionState>::Pair table[] = { |
| 607 { kStateIdle, STATE_IDLE }, |
| 608 { kStateCarrier, STATE_CARRIER }, |
| 609 { kStateAssociation, STATE_ASSOCIATION }, |
| 610 { kStateConfiguration, STATE_CONFIGURATION }, |
| 611 { kStateReady, STATE_READY }, |
| 612 { kStateDisconnect, STATE_DISCONNECT }, |
| 613 { kStateFailure, STATE_FAILURE }, |
| 614 { kStateActivationFailure, STATE_ACTIVATION_FAILURE }, |
| 615 { kStatePortal, STATE_PORTAL }, |
| 616 { kStateOnline, STATE_ONLINE }, |
| 617 }; |
| 618 static EnumMapper<ConnectionState> parser( |
| 619 table, arraysize(table), STATE_UNKNOWN); |
| 620 return parser.Get(state); |
| 621 } |
| 622 |
| 623 ConnectionError NativeNetworkParser::ParseError(const std::string& error) { |
| 624 static EnumMapper<ConnectionError>::Pair table[] = { |
| 625 { kErrorOutOfRange, ERROR_OUT_OF_RANGE }, |
| 626 { kErrorPinMissing, ERROR_PIN_MISSING }, |
| 627 { kErrorDhcpFailed, ERROR_DHCP_FAILED }, |
| 628 { kErrorConnectFailed, ERROR_CONNECT_FAILED }, |
| 629 { kErrorBadPassphrase, ERROR_BAD_PASSPHRASE }, |
| 630 { kErrorBadWepKey, ERROR_BAD_WEPKEY }, |
| 631 { kErrorActivationFailed, ERROR_ACTIVATION_FAILED }, |
| 632 { kErrorNeedEvdo, ERROR_NEED_EVDO }, |
| 633 { kErrorNeedHomeNetwork, ERROR_NEED_HOME_NETWORK }, |
| 634 { kErrorOtaspFailed, ERROR_OTASP_FAILED }, |
| 635 { kErrorAaaFailed, ERROR_AAA_FAILED }, |
| 636 { kErrorInternal, ERROR_INTERNAL }, |
| 637 { kErrorDnsLookupFailed, ERROR_DNS_LOOKUP_FAILED }, |
| 638 { kErrorHttpGetFailed, ERROR_HTTP_GET_FAILED }, |
| 639 }; |
| 640 static EnumMapper<ConnectionError> parser( |
| 641 table, arraysize(table), ERROR_NO_ERROR); |
| 642 return parser.Get(error); |
| 643 } |
| 644 |
| 645 // -------------------- NativeEthernetNetworkParser -------------------- |
| 646 |
| 647 NativeEthernetNetworkParser::NativeEthernetNetworkParser() {} |
| 648 NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {} |
| 649 |
| 650 // -------------------- NativeWirelessNetworkParser -------------------- |
| 651 |
| 652 NativeWirelessNetworkParser::NativeWirelessNetworkParser() {} |
| 653 NativeWirelessNetworkParser::~NativeWirelessNetworkParser() {} |
| 654 |
| 655 bool NativeWirelessNetworkParser::ParseValue(PropertyIndex index, |
| 656 const Value& value, |
| 657 Network* network) { |
| 658 DCHECK_NE(TYPE_ETHERNET, network->type()); |
| 659 DCHECK_NE(TYPE_VPN, network->type()); |
| 660 WirelessNetwork* wireless_network = static_cast<WirelessNetwork*>(network); |
| 661 switch (index) { |
| 662 case PROPERTY_INDEX_SIGNAL_STRENGTH: { |
| 663 int strength; |
| 664 if (!value.GetAsInteger(&strength)) |
| 665 return false; |
| 666 wireless_network->set_strength(strength); |
| 667 return true; |
| 668 } |
| 669 default: |
| 670 return NativeNetworkParser::ParseValue(index, value, network); |
| 671 break; |
| 672 } |
| 673 return false; |
| 674 } |
| 675 |
| 676 // -------------------- NativeCellularNetworkParser -------------------- |
| 677 |
| 678 NativeCellularNetworkParser::NativeCellularNetworkParser() {} |
| 679 NativeCellularNetworkParser::~NativeCellularNetworkParser() {} |
| 680 |
| 681 bool NativeCellularNetworkParser::ParseValue(PropertyIndex index, |
| 682 const Value& value, |
| 683 Network* network) { |
| 684 DCHECK_EQ(TYPE_CELLULAR, network->type()); |
| 685 CellularNetwork* cellular_network = static_cast<CellularNetwork*>(network); |
| 686 switch (index) { |
| 687 case PROPERTY_INDEX_ACTIVATION_STATE: { |
| 688 std::string activation_state_string; |
| 689 if (value.GetAsString(&activation_state_string)) { |
| 690 ActivationState prev_state = cellular_network->activation_state(); |
| 691 cellular_network->set_activation_state( |
| 692 ParseActivationState(activation_state_string)); |
| 693 if (cellular_network->activation_state() != prev_state) |
| 694 cellular_network->RefreshDataPlansIfNeeded(); |
| 695 return true; |
| 696 } |
| 697 break; |
| 698 } |
| 699 case PROPERTY_INDEX_CELLULAR_APN: { |
| 700 if (value.IsType(Value::TYPE_DICTIONARY)) { |
| 701 cellular_network->set_apn(static_cast<const DictionaryValue&>(value)); |
| 702 return true; |
| 703 } |
| 704 break; |
| 705 } |
| 706 case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: { |
| 707 if (value.IsType(Value::TYPE_DICTIONARY)) { |
| 708 cellular_network->set_last_good_apn( |
| 709 static_cast<const DictionaryValue&>(value)); |
| 710 return true; |
| 711 } |
| 712 break; |
| 713 } |
| 714 case PROPERTY_INDEX_NETWORK_TECHNOLOGY: { |
| 715 std::string network_technology_string; |
| 716 if (value.GetAsString(&network_technology_string)) { |
| 717 cellular_network->set_network_technology( |
| 718 ParseNetworkTechnology(network_technology_string)); |
| 719 return true; |
| 720 } |
| 721 break; |
| 722 } |
| 723 case PROPERTY_INDEX_ROAMING_STATE: { |
| 724 std::string roaming_state_string; |
| 725 if (value.GetAsString(&roaming_state_string)) { |
| 726 cellular_network->set_roaming_state( |
| 727 ParseRoamingState(roaming_state_string)); |
| 728 return true; |
| 729 } |
| 730 break; |
| 731 } |
| 732 case PROPERTY_INDEX_OPERATOR_NAME: { |
| 733 std::string value_str; |
| 734 if (!value.GetAsString(&value_str)) |
| 735 break; |
| 736 cellular_network->set_operator_name(value_str); |
| 737 return true; |
| 738 } |
| 739 case PROPERTY_INDEX_OPERATOR_CODE: { |
| 740 std::string value_str; |
| 741 if (!value.GetAsString(&value_str)) |
| 742 break; |
| 743 cellular_network->set_operator_code(value_str); |
| 744 return true; |
| 745 } |
| 746 case PROPERTY_INDEX_SERVING_OPERATOR: { |
| 747 if (value.IsType(Value::TYPE_DICTIONARY)) { |
| 748 const DictionaryValue& dict = |
| 749 static_cast<const DictionaryValue&>(value); |
| 750 std::string value_str; |
| 751 dict.GetStringWithoutPathExpansion(kOperatorNameKey, &value_str); |
| 752 cellular_network->set_operator_name(value_str); |
| 753 value_str.clear(); |
| 754 dict.GetStringWithoutPathExpansion(kOperatorCodeKey, &value_str); |
| 755 cellular_network->set_operator_code(value_str); |
| 756 value_str.clear(); |
| 757 dict.GetStringWithoutPathExpansion(kOperatorCountryKey, &value_str); |
| 758 cellular_network->set_operator_country(value_str); |
| 759 return true; |
| 760 } |
| 761 break; |
| 762 } |
| 763 case PROPERTY_INDEX_PAYMENT_URL: { |
| 764 std::string value_str; |
| 765 if (!value.GetAsString(&value_str)) |
| 766 break; |
| 767 cellular_network->set_payment_url(value_str); |
| 768 return true; |
| 769 } |
| 770 case PROPERTY_INDEX_USAGE_URL: { |
| 771 std::string value_str; |
| 772 if (!value.GetAsString(&value_str)) |
| 773 break; |
| 774 cellular_network->set_usage_url(value_str); |
| 775 return true; |
| 776 } |
| 777 case PROPERTY_INDEX_STATE: { |
| 778 // Save previous state before calling WirelessNetwork::ParseValue. |
| 779 ConnectionState prev_state = cellular_network->state(); |
| 780 if (NativeWirelessNetworkParser::ParseValue(index, value, network)) { |
| 781 if (cellular_network->state() != prev_state) |
| 782 cellular_network->RefreshDataPlansIfNeeded(); |
| 783 return true; |
| 784 } |
| 785 break; |
| 786 } |
| 787 default: |
| 788 return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| 789 } |
| 790 return false; |
| 791 } |
| 792 |
| 793 ActivationState NativeCellularNetworkParser::ParseActivationState( |
| 794 const std::string& state) { |
| 795 static EnumMapper<ActivationState>::Pair table[] = { |
| 796 { kActivationStateActivated, ACTIVATION_STATE_ACTIVATED }, |
| 797 { kActivationStateActivating, ACTIVATION_STATE_ACTIVATING }, |
| 798 { kActivationStateNotActivated, ACTIVATION_STATE_NOT_ACTIVATED }, |
| 799 { kActivationStatePartiallyActivated, ACTIVATION_STATE_PARTIALLY_ACTIVATED}, |
| 800 { kActivationStateUnknown, ACTIVATION_STATE_UNKNOWN}, |
| 801 }; |
| 802 static EnumMapper<ActivationState> parser( |
| 803 table, arraysize(table), ACTIVATION_STATE_UNKNOWN); |
| 804 return parser.Get(state); |
| 805 } |
| 806 |
| 807 NetworkTechnology NativeCellularNetworkParser::ParseNetworkTechnology( |
| 808 const std::string& technology) { |
| 809 static EnumMapper<NetworkTechnology>::Pair table[] = { |
| 810 { kNetworkTechnology1Xrtt, NETWORK_TECHNOLOGY_1XRTT }, |
| 811 { kNetworkTechnologyEvdo, NETWORK_TECHNOLOGY_EVDO }, |
| 812 { kNetworkTechnologyGprs, NETWORK_TECHNOLOGY_GPRS }, |
| 813 { kNetworkTechnologyEdge, NETWORK_TECHNOLOGY_EDGE }, |
| 814 { kNetworkTechnologyUmts, NETWORK_TECHNOLOGY_UMTS }, |
| 815 { kNetworkTechnologyHspa, NETWORK_TECHNOLOGY_HSPA }, |
| 816 { kNetworkTechnologyHspaPlus, NETWORK_TECHNOLOGY_HSPA_PLUS }, |
| 817 { kNetworkTechnologyLte, NETWORK_TECHNOLOGY_LTE }, |
| 818 { kNetworkTechnologyLteAdvanced, NETWORK_TECHNOLOGY_LTE_ADVANCED }, |
| 819 { kNetworkTechnologyGsm, NETWORK_TECHNOLOGY_GSM }, |
| 820 }; |
| 821 static EnumMapper<NetworkTechnology> parser( |
| 822 table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN); |
| 823 return parser.Get(technology); |
| 824 } |
| 825 |
| 826 NetworkRoamingState NativeCellularNetworkParser::ParseRoamingState( |
| 827 const std::string& roaming_state) { |
| 828 static EnumMapper<NetworkRoamingState>::Pair table[] = { |
| 829 { kRoamingStateHome, ROAMING_STATE_HOME }, |
| 830 { kRoamingStateRoaming, ROAMING_STATE_ROAMING }, |
| 831 { kRoamingStateUnknown, ROAMING_STATE_UNKNOWN }, |
| 832 }; |
| 833 static EnumMapper<NetworkRoamingState> parser( |
| 834 table, arraysize(table), ROAMING_STATE_UNKNOWN); |
| 835 return parser.Get(roaming_state); |
| 836 } |
| 837 |
| 838 // -------------------- NativeWifiNetworkParser -------------------- |
| 839 |
| 840 NativeWifiNetworkParser::NativeWifiNetworkParser() {} |
| 841 NativeWifiNetworkParser::~NativeWifiNetworkParser() {} |
| 842 |
| 843 bool NativeWifiNetworkParser::ParseValue(PropertyIndex index, |
| 844 const Value& value, |
| 845 Network* network) { |
| 846 DCHECK_EQ(TYPE_WIFI, network->type()); |
| 847 WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network); |
| 848 switch (index) { |
| 849 case PROPERTY_INDEX_WIFI_HEX_SSID: { |
| 850 std::string ssid_hex; |
| 851 if (!value.GetAsString(&ssid_hex)) |
| 852 return false; |
| 853 |
| 854 wifi_network->SetHexSsid(ssid_hex); |
| 855 return true; |
| 856 } |
| 857 case PROPERTY_INDEX_WIFI_AUTH_MODE: |
| 858 case PROPERTY_INDEX_WIFI_PHY_MODE: |
| 859 case PROPERTY_INDEX_WIFI_HIDDEN_SSID: |
| 860 case PROPERTY_INDEX_WIFI_FREQUENCY: |
| 861 // These properties are currently not used in the UI. |
| 862 return true; |
| 863 case PROPERTY_INDEX_NAME: { |
| 864 // Does not change network name when it was already set by WiFi.HexSSID. |
| 865 if (!wifi_network->name().empty()) |
| 866 return true; |
| 867 else |
| 868 return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| 869 } |
| 870 case PROPERTY_INDEX_GUID: { |
| 871 std::string unique_id; |
| 872 if (!value.GetAsString(&unique_id)) |
| 873 break; |
| 874 wifi_network->set_unique_id(unique_id); |
| 875 return true; |
| 876 } |
| 877 case PROPERTY_INDEX_SECURITY: { |
| 878 std::string security_string; |
| 879 if (!value.GetAsString(&security_string)) |
| 880 break; |
| 881 wifi_network->set_encryption(ParseSecurity(security_string)); |
| 882 return true; |
| 883 } |
| 884 case PROPERTY_INDEX_PASSPHRASE: { |
| 885 std::string passphrase; |
| 886 if (!value.GetAsString(&passphrase)) |
| 887 break; |
| 888 // Only store the passphrase if we are the owner. |
| 889 // TODO(stevenjb): Remove this when chromium-os:12948 is resolved. |
| 890 if (chromeos::UserManager::Get()->current_user_is_owner()) |
| 891 wifi_network->set_passphrase(passphrase); |
| 892 return true; |
| 893 } |
| 894 case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { |
| 895 bool passphrase_required; |
| 896 value.GetAsBoolean(&passphrase_required); |
| 897 if (!value.GetAsBoolean(&passphrase_required)) |
| 898 break; |
| 899 wifi_network->set_passphrase_required(passphrase_required); |
| 900 return true; |
| 901 } |
| 902 case PROPERTY_INDEX_IDENTITY: { |
| 903 std::string identity; |
| 904 if (!value.GetAsString(&identity)) |
| 905 break; |
| 906 wifi_network->set_identity(identity); |
| 907 return true; |
| 908 } |
| 909 case PROPERTY_INDEX_EAP_IDENTITY: { |
| 910 std::string eap_identity; |
| 911 if (!value.GetAsString(&eap_identity)) |
| 912 break; |
| 913 wifi_network->set_eap_identity(eap_identity); |
| 914 return true; |
| 915 } |
| 916 case PROPERTY_INDEX_EAP_METHOD: { |
| 917 std::string eap_method; |
| 918 if (!value.GetAsString(&eap_method)) |
| 919 break; |
| 920 wifi_network->set_eap_method(ParseEAPMethod(eap_method)); |
| 921 return true; |
| 922 } |
| 923 case PROPERTY_INDEX_EAP_PHASE_2_AUTH: { |
| 924 std::string eap_phase_2_auth; |
| 925 if (!value.GetAsString(&eap_phase_2_auth)) |
| 926 break; |
| 927 wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth)); |
| 928 return true; |
| 929 } |
| 930 case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: { |
| 931 std::string eap_anonymous_identity; |
| 932 if (!value.GetAsString(&eap_anonymous_identity)) |
| 933 break; |
| 934 wifi_network->set_eap_anonymous_identity(eap_anonymous_identity); |
| 935 return true; |
| 936 } |
| 937 case PROPERTY_INDEX_EAP_CERT_ID: { |
| 938 std::string eap_client_cert_pkcs11_id; |
| 939 if (!value.GetAsString(&eap_client_cert_pkcs11_id)) |
| 940 break; |
| 941 wifi_network->set_eap_client_cert_pkcs11_id(eap_client_cert_pkcs11_id); |
| 942 return true; |
| 943 } |
| 944 case PROPERTY_INDEX_EAP_CA_CERT_NSS: { |
| 945 std::string eap_server_ca_cert_nss_nickname; |
| 946 if (!value.GetAsString(&eap_server_ca_cert_nss_nickname)) |
| 947 break; |
| 948 wifi_network->set_eap_server_ca_cert_nss_nickname( |
| 949 eap_server_ca_cert_nss_nickname); |
| 950 return true; |
| 951 } |
| 952 case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS: { |
| 953 bool eap_use_system_cas; |
| 954 if (!value.GetAsBoolean(&eap_use_system_cas)) |
| 955 break; |
| 956 wifi_network->set_eap_use_system_cas(eap_use_system_cas); |
| 957 return true; |
| 958 } |
| 959 case PROPERTY_INDEX_EAP_PASSWORD: { |
| 960 std::string eap_passphrase; |
| 961 if (!value.GetAsString(&eap_passphrase)) |
| 962 break; |
| 963 wifi_network->set_eap_passphrase(eap_passphrase); |
| 964 return true; |
| 965 } |
| 966 case PROPERTY_INDEX_EAP_CLIENT_CERT: |
| 967 case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS: |
| 968 case PROPERTY_INDEX_EAP_PRIVATE_KEY: |
| 969 case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD: |
| 970 case PROPERTY_INDEX_EAP_KEY_ID: |
| 971 case PROPERTY_INDEX_EAP_CA_CERT: |
| 972 case PROPERTY_INDEX_EAP_CA_CERT_ID: |
| 973 case PROPERTY_INDEX_EAP_PIN: |
| 974 case PROPERTY_INDEX_EAP_KEY_MGMT: |
| 975 // These properties are currently not used in the UI. |
| 976 return true; |
| 977 default: |
| 978 return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| 979 } |
| 980 return false; |
| 981 } |
| 982 |
| 983 ConnectionSecurity NativeWifiNetworkParser::ParseSecurity( |
| 984 const std::string& security) { |
| 985 static EnumMapper<ConnectionSecurity>::Pair table[] = { |
| 986 { kSecurityNone, SECURITY_NONE }, |
| 987 { kSecurityWep, SECURITY_WEP }, |
| 988 { kSecurityWpa, SECURITY_WPA }, |
| 989 { kSecurityRsn, SECURITY_RSN }, |
| 990 { kSecurityPsk, SECURITY_PSK }, |
| 991 { kSecurity8021x, SECURITY_8021X }, |
| 992 }; |
| 993 static EnumMapper<ConnectionSecurity> parser( |
| 994 table, arraysize(table), SECURITY_UNKNOWN); |
| 995 return parser.Get(security); |
| 996 } |
| 997 |
| 998 EAPMethod NativeWifiNetworkParser::ParseEAPMethod(const std::string& method) { |
| 999 static EnumMapper<EAPMethod>::Pair table[] = { |
| 1000 { kEapMethodPeap, EAP_METHOD_PEAP }, |
| 1001 { kEapMethodTls, EAP_METHOD_TLS }, |
| 1002 { kEapMethodTtls, EAP_METHOD_TTLS }, |
| 1003 { kEapMethodLeap, EAP_METHOD_LEAP }, |
| 1004 }; |
| 1005 static EnumMapper<EAPMethod> parser( |
| 1006 table, arraysize(table), EAP_METHOD_UNKNOWN); |
| 1007 return parser.Get(method); |
| 1008 } |
| 1009 |
| 1010 EAPPhase2Auth NativeWifiNetworkParser::ParseEAPPhase2Auth( |
| 1011 const std::string& auth) { |
| 1012 static EnumMapper<EAPPhase2Auth>::Pair table[] = { |
| 1013 { kEapPhase2AuthPeapMd5, EAP_PHASE_2_AUTH_MD5 }, |
| 1014 { kEapPhase2AuthPeapMschap2, EAP_PHASE_2_AUTH_MSCHAPV2 }, |
| 1015 { kEapPhase2AuthTtlsMd5, EAP_PHASE_2_AUTH_MD5 }, |
| 1016 { kEapPhase2AuthTtlsMschapV2, EAP_PHASE_2_AUTH_MSCHAPV2 }, |
| 1017 { kEapPhase2AuthTtlsMschap, EAP_PHASE_2_AUTH_MSCHAP }, |
| 1018 { kEapPhase2AuthTtlsPap, EAP_PHASE_2_AUTH_PAP }, |
| 1019 { kEapPhase2AuthTtlsChap, EAP_PHASE_2_AUTH_CHAP }, |
| 1020 }; |
| 1021 static EnumMapper<EAPPhase2Auth> parser( |
| 1022 table, arraysize(table), EAP_PHASE_2_AUTH_AUTO); |
| 1023 return parser.Get(auth); |
| 1024 } |
| 1025 |
| 1026 // -------------------- NativeVirtualNetworkParser -------------------- |
| 1027 |
| 1028 |
| 1029 NativeVirtualNetworkParser::NativeVirtualNetworkParser() {} |
| 1030 NativeVirtualNetworkParser::~NativeVirtualNetworkParser() {} |
| 1031 |
| 1032 bool NativeVirtualNetworkParser::UpdateNetworkFromInfo( |
| 1033 const DictionaryValue& info, |
| 1034 Network* network) { |
| 1035 DCHECK_EQ(TYPE_VPN, network->type()); |
| 1036 VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); |
| 1037 if (!NativeNetworkParser::UpdateNetworkFromInfo(info, network)) |
| 1038 return false; |
| 1039 VLOG(1) << "Updating VPN '" << virtual_network->name() |
| 1040 << "': Server: " << virtual_network->server_hostname() |
| 1041 << " Type: " |
| 1042 << ProviderTypeToString(virtual_network->provider_type()); |
| 1043 if (virtual_network->provider_type() == PROVIDER_TYPE_L2TP_IPSEC_PSK) { |
| 1044 if (!virtual_network->client_cert_id().empty()) |
| 1045 virtual_network->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT); |
| 1046 } |
| 1047 return true; |
| 1048 } |
| 1049 |
| 1050 bool NativeVirtualNetworkParser::ParseValue(PropertyIndex index, |
| 1051 const Value& value, |
| 1052 Network* network) { |
| 1053 DCHECK_EQ(TYPE_VPN, network->type()); |
| 1054 VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); |
| 1055 switch (index) { |
| 1056 case PROPERTY_INDEX_PROVIDER: { |
| 1057 DCHECK_EQ(value.GetType(), Value::TYPE_DICTIONARY); |
| 1058 const DictionaryValue& dict = static_cast<const DictionaryValue&>(value); |
| 1059 for (DictionaryValue::key_iterator iter = dict.begin_keys(); |
| 1060 iter != dict.end_keys(); ++iter) { |
| 1061 const std::string& key = *iter; |
| 1062 Value* provider_value; |
| 1063 bool res = dict.GetWithoutPathExpansion(key, &provider_value); |
| 1064 DCHECK(res); |
| 1065 if (res) { |
| 1066 PropertyIndex index = mapper().Get(key); |
| 1067 if (!ParseProviderValue(index, *provider_value, virtual_network)) |
| 1068 VLOG(1) << network->name() << ": Provider unhandled key: " << key |
| 1069 << " Type: " << provider_value->GetType(); |
| 1070 } |
| 1071 } |
| 1072 return true; |
| 1073 } |
| 1074 default: |
| 1075 return NativeNetworkParser::ParseValue(index, value, network); |
| 1076 break; |
| 1077 } |
| 1078 return false; |
| 1079 } |
| 1080 |
| 1081 bool NativeVirtualNetworkParser::ParseProviderValue(PropertyIndex index, |
| 1082 const Value& value, |
| 1083 VirtualNetwork* network) { |
| 1084 switch (index) { |
| 1085 case PROPERTY_INDEX_HOST: { |
| 1086 std::string server_hostname; |
| 1087 if (!value.GetAsString(&server_hostname)) |
| 1088 break; |
| 1089 network->set_server_hostname(server_hostname); |
| 1090 return true; |
| 1091 } |
| 1092 case PROPERTY_INDEX_NAME: { |
| 1093 std::string name; |
| 1094 if (!value.GetAsString(&name)) |
| 1095 break; |
| 1096 network->set_name(name); |
| 1097 return true; |
| 1098 } |
| 1099 case PROPERTY_INDEX_TYPE: { |
| 1100 std::string provider_type_string; |
| 1101 if (!value.GetAsString(&provider_type_string)) |
| 1102 break; |
| 1103 network->set_provider_type(ParseProviderType(provider_type_string)); |
| 1104 return true; |
| 1105 } |
| 1106 case PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS: { |
| 1107 std::string ca_cert_nss; |
| 1108 if (!value.GetAsString(&ca_cert_nss)) |
| 1109 break; |
| 1110 network->set_ca_cert_nss(ca_cert_nss); |
| 1111 return true; |
| 1112 } |
| 1113 case PROPERTY_INDEX_L2TPIPSEC_PSK:{ |
| 1114 std::string psk_passphrase; |
| 1115 if (!value.GetAsString(&psk_passphrase)) |
| 1116 break; |
| 1117 network->set_psk_passphrase(psk_passphrase); |
| 1118 return true; |
| 1119 } |
| 1120 case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID:{ |
| 1121 std::string client_cert_id; |
| 1122 if (!value.GetAsString(&client_cert_id)) |
| 1123 break; |
| 1124 network->set_client_cert_id(client_cert_id); |
| 1125 return true; |
| 1126 } |
| 1127 case PROPERTY_INDEX_L2TPIPSEC_USER:{ |
| 1128 std::string username; |
| 1129 if (!value.GetAsString(&username)) |
| 1130 break; |
| 1131 network->set_username(username); |
| 1132 return true; |
| 1133 } |
| 1134 case PROPERTY_INDEX_L2TPIPSEC_PASSWORD:{ |
| 1135 std::string user_passphrase; |
| 1136 if (!value.GetAsString(&user_passphrase)) |
| 1137 break; |
| 1138 network->set_user_passphrase(user_passphrase); |
| 1139 return true; |
| 1140 } |
| 1141 default: |
| 1142 break; |
| 1143 } |
| 1144 return false; |
| 1145 } |
| 1146 |
| 1147 ProviderType NativeVirtualNetworkParser::ParseProviderType( |
| 1148 const std::string& type) { |
| 1149 static EnumMapper<ProviderType>::Pair table[] = { |
| 1150 { kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK }, |
| 1151 { kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN }, |
| 1152 }; |
| 1153 static EnumMapper<ProviderType> parser( |
| 1154 table, arraysize(table), PROVIDER_TYPE_MAX); |
| 1155 return parser.Get(type); |
| 1156 } |
| 1157 |
| 1158 } // namespace chromeos |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 7453051:
This factors out all of the parsing code from the network library (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src