| // 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 "chrome/browser/chromeos/cros/native_network_parser.h" |
| |
| #include <string> |
| |
| #include "base/logging.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/values.h" |
| #include "chrome/browser/chromeos/cros/native_network_constants.h" |
| #include "chrome/browser/chromeos/cros/network_library.h" |
| #include "chrome/browser/chromeos/login/user_manager.h" |
| #include "chromeos/network/onc/onc_utils.h" |
| #include "third_party/cros_system_api/dbus/service_constants.h" |
| |
| namespace chromeos { |
| |
| // Local constants. |
| namespace { |
| |
| const char kPostMethod[] = "post"; |
| |
| EnumMapper<PropertyIndex>::Pair property_index_table[] = { |
| { shill::kActivateOverNonCellularNetworkProperty, |
| PROPERTY_INDEX_ACTIVATE_OVER_NON_CELLULAR_NETWORK }, |
| { flimflam::kActivationStateProperty, PROPERTY_INDEX_ACTIVATION_STATE }, |
| { flimflam::kActiveProfileProperty, PROPERTY_INDEX_ACTIVE_PROFILE }, |
| { flimflam::kArpGatewayProperty, PROPERTY_INDEX_ARP_GATEWAY }, |
| { flimflam::kAutoConnectProperty, PROPERTY_INDEX_AUTO_CONNECT }, |
| { flimflam::kAvailableTechnologiesProperty, |
| PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES }, |
| { flimflam::kCarrierProperty, PROPERTY_INDEX_CARRIER }, |
| { flimflam::kCellularAllowRoamingProperty, |
| PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING }, |
| { flimflam::kCellularApnListProperty, PROPERTY_INDEX_CELLULAR_APN_LIST }, |
| { flimflam::kCellularApnProperty, PROPERTY_INDEX_CELLULAR_APN }, |
| { flimflam::kCellularLastGoodApnProperty, |
| PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN }, |
| { flimflam::kCheckPortalProperty, PROPERTY_INDEX_CHECK_PORTAL }, |
| { flimflam::kCheckPortalListProperty, PROPERTY_INDEX_CHECK_PORTAL_LIST }, |
| { flimflam::kConnectableProperty, PROPERTY_INDEX_CONNECTABLE }, |
| { flimflam::kConnectedTechnologiesProperty, |
| PROPERTY_INDEX_CONNECTED_TECHNOLOGIES }, |
| { flimflam::kDefaultTechnologyProperty, PROPERTY_INDEX_DEFAULT_TECHNOLOGY }, |
| { flimflam::kDeviceProperty, PROPERTY_INDEX_DEVICE }, |
| { flimflam::kDevicesProperty, PROPERTY_INDEX_DEVICES }, |
| { flimflam::kEapAnonymousIdentityProperty, |
| PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY }, |
| { flimflam::kEapCaCertIdProperty, PROPERTY_INDEX_EAP_CA_CERT_ID }, |
| { shill::kEapCaCertPemProperty, PROPERTY_INDEX_EAP_CA_CERT_PEM }, |
| { flimflam::kEapCertIdProperty, PROPERTY_INDEX_EAP_CERT_ID }, |
| { flimflam::kEapClientCertNssProperty, PROPERTY_INDEX_EAP_CLIENT_CERT_NSS }, |
| { flimflam::kEapClientCertProperty, PROPERTY_INDEX_EAP_CLIENT_CERT }, |
| { flimflam::kEapIdentityProperty, PROPERTY_INDEX_EAP_IDENTITY }, |
| { flimflam::kEapKeyIdProperty, PROPERTY_INDEX_EAP_KEY_ID }, |
| { flimflam::kEapKeyMgmtProperty, PROPERTY_INDEX_EAP_KEY_MGMT }, |
| { flimflam::kEapMethodProperty, PROPERTY_INDEX_EAP_METHOD }, |
| { flimflam::kEapPasswordProperty, PROPERTY_INDEX_EAP_PASSWORD }, |
| { flimflam::kEapPhase2AuthProperty, PROPERTY_INDEX_EAP_PHASE_2_AUTH }, |
| { flimflam::kEapPinProperty, PROPERTY_INDEX_EAP_PIN }, |
| { flimflam::kEapPrivateKeyPasswordProperty, |
| PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD }, |
| { flimflam::kEapPrivateKeyProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY }, |
| { flimflam::kEapUseSystemCasProperty, PROPERTY_INDEX_EAP_USE_SYSTEM_CAS }, |
| { flimflam::kEnabledTechnologiesProperty, |
| PROPERTY_INDEX_ENABLED_TECHNOLOGIES }, |
| { flimflam::kErrorProperty, PROPERTY_INDEX_ERROR }, |
| { flimflam::kEsnProperty, PROPERTY_INDEX_ESN }, |
| { flimflam::kFavoriteProperty, PROPERTY_INDEX_FAVORITE }, |
| { flimflam::kFirmwareRevisionProperty, PROPERTY_INDEX_FIRMWARE_REVISION }, |
| { flimflam::kFoundNetworksProperty, PROPERTY_INDEX_FOUND_NETWORKS }, |
| { flimflam::kGuidProperty, PROPERTY_INDEX_GUID }, |
| { flimflam::kHardwareRevisionProperty, PROPERTY_INDEX_HARDWARE_REVISION }, |
| { flimflam::kHomeProviderProperty, PROPERTY_INDEX_HOME_PROVIDER }, |
| { flimflam::kHostProperty, PROPERTY_INDEX_HOST }, |
| { flimflam::kIccidProperty, PROPERTY_INDEX_ICCID }, |
| { flimflam::kIdentityProperty, PROPERTY_INDEX_IDENTITY }, |
| { flimflam::kImeiProperty, PROPERTY_INDEX_IMEI }, |
| { flimflam::kImsiProperty, PROPERTY_INDEX_IMSI }, |
| { flimflam::kIsActiveProperty, PROPERTY_INDEX_IS_ACTIVE }, |
| { flimflam::kL2tpIpsecAuthenticationType, |
| PROPERTY_INDEX_IPSEC_AUTHENTICATIONTYPE }, |
| { shill::kL2tpIpsecCaCertPemProperty, |
| PROPERTY_INDEX_L2TPIPSEC_CA_CERT_PEM }, |
| { flimflam::kL2tpIpsecClientCertIdProperty, |
| PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID }, |
| { flimflam::kL2tpIpsecClientCertSlotProp, |
| PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT }, |
| { flimflam::kL2tpIpsecIkeVersion, PROPERTY_INDEX_IPSEC_IKEVERSION }, |
| { flimflam::kL2tpIpsecPinProperty, PROPERTY_INDEX_L2TPIPSEC_PIN }, |
| { flimflam::kL2tpIpsecPskProperty, PROPERTY_INDEX_L2TPIPSEC_PSK }, |
| { flimflam::kL2tpIpsecPskRequiredProperty, |
| PROPERTY_INDEX_L2TPIPSEC_PSK_REQUIRED }, |
| { flimflam::kL2tpIpsecPasswordProperty, PROPERTY_INDEX_L2TPIPSEC_PASSWORD }, |
| { flimflam::kL2tpIpsecUserProperty, PROPERTY_INDEX_L2TPIPSEC_USER }, |
| { shill::kL2tpIpsecTunnelGroupProperty, |
| PROPERTY_INDEX_L2TPIPSEC_GROUP_NAME }, |
| { flimflam::kManufacturerProperty, PROPERTY_INDEX_MANUFACTURER }, |
| { flimflam::kMdnProperty, PROPERTY_INDEX_MDN }, |
| { flimflam::kMeidProperty, PROPERTY_INDEX_MEID }, |
| { flimflam::kMinProperty, PROPERTY_INDEX_MIN }, |
| { flimflam::kModelIDProperty, PROPERTY_INDEX_MODEL_ID }, |
| { flimflam::kNameProperty, PROPERTY_INDEX_NAME }, |
| { flimflam::kNetworkTechnologyProperty, PROPERTY_INDEX_NETWORK_TECHNOLOGY }, |
| { flimflam::kNetworksProperty, PROPERTY_INDEX_NETWORKS }, |
| { flimflam::kOfflineModeProperty, PROPERTY_INDEX_OFFLINE_MODE }, |
| { flimflam::kOperatorCodeProperty, PROPERTY_INDEX_OPERATOR_CODE }, |
| { flimflam::kOperatorNameProperty, PROPERTY_INDEX_OPERATOR_NAME }, |
| { shill::kOutOfCreditsProperty, PROPERTY_INDEX_OUT_OF_CREDITS }, |
| { flimflam::kPRLVersionProperty, PROPERTY_INDEX_PRL_VERSION }, |
| { flimflam::kPassphraseProperty, PROPERTY_INDEX_PASSPHRASE }, |
| { flimflam::kPassphraseRequiredProperty, PROPERTY_INDEX_PASSPHRASE_REQUIRED }, |
| { flimflam::kPortalURLProperty, PROPERTY_INDEX_PORTAL_URL }, |
| { flimflam::kPoweredProperty, PROPERTY_INDEX_POWERED }, |
| { flimflam::kPriorityProperty, PROPERTY_INDEX_PRIORITY }, |
| { flimflam::kProfileProperty, PROPERTY_INDEX_PROFILE }, |
| { flimflam::kProfilesProperty, PROPERTY_INDEX_PROFILES }, |
| { flimflam::kProviderHostProperty, PROPERTY_INDEX_PROVIDER_HOST }, |
| { flimflam::kProviderProperty, PROPERTY_INDEX_PROVIDER }, |
| { shill::kProviderRequiresRoamingProperty, |
| PROPERTY_INDEX_PROVIDER_REQUIRES_ROAMING }, |
| { flimflam::kProviderTypeProperty, PROPERTY_INDEX_PROVIDER_TYPE }, |
| { flimflam::kRoamingStateProperty, PROPERTY_INDEX_ROAMING_STATE }, |
| { flimflam::kSIMLockStatusProperty, PROPERTY_INDEX_SIM_LOCK }, |
| { shill::kSIMPresentProperty, PROPERTY_INDEX_SIM_PRESENT }, |
| { flimflam::kSSIDProperty, PROPERTY_INDEX_SSID }, |
| { flimflam::kSaveCredentialsProperty, PROPERTY_INDEX_SAVE_CREDENTIALS }, |
| { flimflam::kScanningProperty, PROPERTY_INDEX_SCANNING }, |
| { flimflam::kSecurityProperty, PROPERTY_INDEX_SECURITY }, |
| { flimflam::kSelectedNetworkProperty, PROPERTY_INDEX_SELECTED_NETWORK }, |
| { flimflam::kServiceWatchListProperty, PROPERTY_INDEX_SERVICE_WATCH_LIST }, |
| { flimflam::kServicesProperty, PROPERTY_INDEX_SERVICES }, |
| { flimflam::kServingOperatorProperty, PROPERTY_INDEX_SERVING_OPERATOR }, |
| { flimflam::kSignalStrengthProperty, PROPERTY_INDEX_SIGNAL_STRENGTH }, |
| { flimflam::kStateProperty, PROPERTY_INDEX_STATE }, |
| { flimflam::kSupportNetworkScanProperty, |
| PROPERTY_INDEX_SUPPORT_NETWORK_SCAN }, |
| { shill::kSupportedCarriersProperty, PROPERTY_INDEX_SUPPORTED_CARRIERS}, |
| { flimflam::kTechnologyFamilyProperty, PROPERTY_INDEX_TECHNOLOGY_FAMILY }, |
| { flimflam::kTypeProperty, PROPERTY_INDEX_TYPE }, |
| { flimflam::kUIDataProperty, PROPERTY_INDEX_UI_DATA }, |
| { shill::kUninitializedTechnologiesProperty, |
| PROPERTY_INDEX_UNINITIALIZED_TECHNOLOGIES }, |
| { flimflam::kUsageURLProperty, PROPERTY_INDEX_USAGE_URL }, |
| { flimflam::kOpenVPNClientCertIdProperty, |
| PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_ID }, |
| { flimflam::kOpenVPNAuthProperty, PROPERTY_INDEX_OPEN_VPN_AUTH }, |
| { flimflam::kOpenVPNAuthRetryProperty, PROPERTY_INDEX_OPEN_VPN_AUTHRETRY }, |
| { flimflam::kOpenVPNAuthNoCacheProperty, |
| PROPERTY_INDEX_OPEN_VPN_AUTHNOCACHE }, |
| { flimflam::kOpenVPNAuthUserPassProperty, |
| PROPERTY_INDEX_OPEN_VPN_AUTHUSERPASS }, |
| { shill::kOpenVPNCaCertPemProperty, PROPERTY_INDEX_OPEN_VPN_CA_CERT_PEM }, |
| { flimflam::kOpenVPNClientCertSlotProperty, |
| PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_SLOT }, |
| { flimflam::kOpenVPNCipherProperty, PROPERTY_INDEX_OPEN_VPN_CIPHER }, |
| { flimflam::kOpenVPNCompLZOProperty, PROPERTY_INDEX_OPEN_VPN_COMPLZO }, |
| { flimflam::kOpenVPNCompNoAdaptProperty, |
| PROPERTY_INDEX_OPEN_VPN_COMPNOADAPT }, |
| { flimflam::kOpenVPNKeyDirectionProperty, |
| PROPERTY_INDEX_OPEN_VPN_KEYDIRECTION }, |
| { flimflam::kOpenVPNMgmtEnableProperty, |
| PROPERTY_INDEX_OPEN_VPN_MGMT_ENABLE }, |
| { flimflam::kOpenVPNNsCertTypeProperty, PROPERTY_INDEX_OPEN_VPN_NSCERTTYPE }, |
| { flimflam::kOpenVPNOTPProperty, PROPERTY_INDEX_OPEN_VPN_OTP }, |
| { flimflam::kOpenVPNPasswordProperty, PROPERTY_INDEX_OPEN_VPN_PASSWORD }, |
| { flimflam::kOpenVPNPinProperty, PROPERTY_INDEX_OPEN_VPN_PIN }, |
| { flimflam::kOpenVPNPortProperty, PROPERTY_INDEX_OPEN_VPN_PORT }, |
| { flimflam::kOpenVPNProtoProperty, PROPERTY_INDEX_OPEN_VPN_PROTO }, |
| { flimflam::kOpenVPNProviderProperty, |
| PROPERTY_INDEX_OPEN_VPN_PKCS11_PROVIDER }, |
| { flimflam::kOpenVPNPushPeerInfoProperty, |
| PROPERTY_INDEX_OPEN_VPN_PUSHPEERINFO }, |
| { flimflam::kOpenVPNRemoteCertEKUProperty, |
| PROPERTY_INDEX_OPEN_VPN_REMOTECERTEKU }, |
| { flimflam::kOpenVPNRemoteCertKUProperty, |
| PROPERTY_INDEX_OPEN_VPN_REMOTECERTKU }, |
| { flimflam::kOpenVPNRemoteCertTLSProperty, |
| PROPERTY_INDEX_OPEN_VPN_REMOTECERTTLS }, |
| { flimflam::kOpenVPNRenegSecProperty, PROPERTY_INDEX_OPEN_VPN_RENEGSEC }, |
| { flimflam::kOpenVPNServerPollTimeoutProperty, |
| PROPERTY_INDEX_OPEN_VPN_SERVERPOLLTIMEOUT }, |
| { flimflam::kOpenVPNShaperProperty, PROPERTY_INDEX_OPEN_VPN_SHAPER }, |
| { flimflam::kOpenVPNStaticChallengeProperty, |
| PROPERTY_INDEX_OPEN_VPN_STATICCHALLENGE }, |
| { flimflam::kOpenVPNTLSAuthContentsProperty, |
| PROPERTY_INDEX_OPEN_VPN_TLSAUTHCONTENTS }, |
| { flimflam::kOpenVPNTLSRemoteProperty, PROPERTY_INDEX_OPEN_VPN_TLSREMOTE }, |
| { flimflam::kOpenVPNUserProperty, PROPERTY_INDEX_OPEN_VPN_USER }, |
| { flimflam::kPaymentPortalProperty, PROPERTY_INDEX_OLP }, |
| { flimflam::kPaymentURLProperty, PROPERTY_INDEX_OLP_URL }, |
| { flimflam::kVPNDomainProperty, PROPERTY_INDEX_VPN_DOMAIN }, |
| { flimflam::kWifiAuthMode, PROPERTY_INDEX_WIFI_AUTH_MODE }, |
| { flimflam::kWifiBSsid, PROPERTY_INDEX_WIFI_BSSID }, |
| { flimflam::kWifiFrequency, PROPERTY_INDEX_WIFI_FREQUENCY }, |
| { flimflam::kWifiHexSsid, PROPERTY_INDEX_WIFI_HEX_SSID }, |
| { flimflam::kWifiHiddenSsid, PROPERTY_INDEX_WIFI_HIDDEN_SSID }, |
| { flimflam::kWifiPhyMode, PROPERTY_INDEX_WIFI_PHY_MODE }, |
| }; |
| |
| EnumMapper<ConnectionType>::Pair network_type_table[] = { |
| { flimflam::kTypeEthernet, TYPE_ETHERNET }, |
| { flimflam::kTypeWifi, TYPE_WIFI }, |
| { flimflam::kTypeWimax, TYPE_WIMAX }, |
| { flimflam::kTypeBluetooth, TYPE_BLUETOOTH }, |
| { flimflam::kTypeCellular, TYPE_CELLULAR }, |
| { flimflam::kTypeVPN, TYPE_VPN }, |
| }; |
| |
| EnumMapper<ConnectionSecurity>::Pair network_security_table[] = { |
| { flimflam::kSecurityNone, SECURITY_NONE }, |
| { flimflam::kSecurityWep, SECURITY_WEP }, |
| { flimflam::kSecurityWpa, SECURITY_WPA }, |
| { flimflam::kSecurityRsn, SECURITY_RSN }, |
| { flimflam::kSecurityPsk, SECURITY_PSK }, |
| { flimflam::kSecurity8021x, SECURITY_8021X }, |
| }; |
| |
| EnumMapper<EAPMethod>::Pair network_eap_method_table[] = { |
| { flimflam::kEapMethodPEAP, EAP_METHOD_PEAP }, |
| { flimflam::kEapMethodTLS, EAP_METHOD_TLS }, |
| { flimflam::kEapMethodTTLS, EAP_METHOD_TTLS }, |
| { flimflam::kEapMethodLEAP, EAP_METHOD_LEAP }, |
| }; |
| |
| EnumMapper<EAPPhase2Auth>::Pair network_eap_auth_table[] = { |
| { flimflam::kEapPhase2AuthPEAPMD5, EAP_PHASE_2_AUTH_MD5 }, |
| { flimflam::kEapPhase2AuthPEAPMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 }, |
| { flimflam::kEapPhase2AuthTTLSMD5, EAP_PHASE_2_AUTH_MD5 }, |
| { flimflam::kEapPhase2AuthTTLSMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 }, |
| { flimflam::kEapPhase2AuthTTLSMSCHAP, EAP_PHASE_2_AUTH_MSCHAP }, |
| { flimflam::kEapPhase2AuthTTLSPAP, EAP_PHASE_2_AUTH_PAP }, |
| { flimflam::kEapPhase2AuthTTLSCHAP, EAP_PHASE_2_AUTH_CHAP }, |
| }; |
| |
| EnumMapper<ProviderType>::Pair provider_type_table[] = { |
| { flimflam::kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK }, |
| { flimflam::kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN }, |
| }; |
| |
| // Serve the singleton mapper instance. |
| const EnumMapper<PropertyIndex>* get_native_mapper() { |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<PropertyIndex>, mapper, |
| (property_index_table, |
| arraysize(property_index_table), |
| PROPERTY_INDEX_UNKNOWN)); |
| return &mapper; |
| } |
| |
| } // namespace |
| |
| // -------------------- NativeNetworkDeviceParser -------------------- |
| |
| NativeNetworkDeviceParser::NativeNetworkDeviceParser() |
| : NetworkDeviceParser(get_native_mapper()) { |
| } |
| |
| NativeNetworkDeviceParser::~NativeNetworkDeviceParser() { |
| } |
| |
| NetworkDevice* NativeNetworkDeviceParser::CreateNewNetworkDevice( |
| const std::string& device_path) { |
| NetworkDevice* device = |
| NetworkDeviceParser::CreateNewNetworkDevice(device_path); |
| device->SetNetworkDeviceParser(new NativeNetworkDeviceParser()); |
| return device; |
| } |
| |
| bool NativeNetworkDeviceParser::ParseValue( |
| PropertyIndex index, const base::Value& value, NetworkDevice* device) { |
| switch (index) { |
| case PROPERTY_INDEX_TYPE: { |
| std::string type_string; |
| if (value.GetAsString(&type_string)) { |
| device->set_type(ParseType(type_string)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_NAME: { |
| std::string name; |
| if (!value.GetAsString(&name)) |
| return false; |
| device->set_name(name); |
| return true; |
| } |
| case PROPERTY_INDEX_GUID: { |
| std::string unique_id; |
| if (!value.GetAsString(&unique_id)) |
| return false; |
| device->set_unique_id(unique_id); |
| return true; |
| } |
| case PROPERTY_INDEX_CARRIER: { |
| std::string carrier; |
| if (!value.GetAsString(&carrier)) |
| return false; |
| device->set_carrier(carrier); |
| return true; |
| } |
| case PROPERTY_INDEX_SCANNING: { |
| bool scanning; |
| if (!value.GetAsBoolean(&scanning)) |
| return false; |
| device->set_scanning(scanning); |
| return true; |
| } |
| case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: { |
| bool data_roaming_allowed; |
| if (!value.GetAsBoolean(&data_roaming_allowed)) |
| return false; |
| device->set_data_roaming_allowed(data_roaming_allowed); |
| return true; |
| } |
| case PROPERTY_INDEX_CELLULAR_APN_LIST: |
| if (value.IsType(base::Value::TYPE_LIST)) { |
| CellularApnList provider_apn_list; |
| if (!ParseApnList(static_cast<const ListValue&>(value), |
| &provider_apn_list)) |
| return false; |
| device->set_provider_apn_list(provider_apn_list); |
| return true; |
| } |
| break; |
| case PROPERTY_INDEX_NETWORKS: |
| if (value.IsType(base::Value::TYPE_LIST)) { |
| // Ignored. |
| return true; |
| } |
| break; |
| case PROPERTY_INDEX_FOUND_NETWORKS: |
| if (value.IsType(base::Value::TYPE_LIST)) { |
| CellularNetworkList found_cellular_networks; |
| if (!ParseFoundNetworksFromList( |
| static_cast<const ListValue&>(value), |
| &found_cellular_networks)) |
| return false; |
| device->set_found_cellular_networks(found_cellular_networks); |
| return true; |
| } |
| break; |
| case PROPERTY_INDEX_HOME_PROVIDER: { |
| if (value.IsType(base::Value::TYPE_DICTIONARY)) { |
| const DictionaryValue& dict = |
| static_cast<const DictionaryValue&>(value); |
| std::string home_provider_code; |
| std::string home_provider_country; |
| std::string home_provider_name; |
| dict.GetStringWithoutPathExpansion(flimflam::kOperatorCodeKey, |
| &home_provider_code); |
| dict.GetStringWithoutPathExpansion(flimflam::kOperatorCountryKey, |
| &home_provider_country); |
| dict.GetStringWithoutPathExpansion(flimflam::kOperatorNameKey, |
| &home_provider_name); |
| device->set_home_provider_code(home_provider_code); |
| device->set_home_provider_country(home_provider_country); |
| device->set_home_provider_name(home_provider_name); |
| if (!device->home_provider_name().empty() && |
| !device->home_provider_country().empty()) { |
| device->set_home_provider_id(base::StringPrintf( |
| kCarrierIdFormat, |
| device->home_provider_name().c_str(), |
| device->home_provider_country().c_str())); |
| } else { |
| device->set_home_provider_id(home_provider_code); |
| LOG(WARNING) << "Carrier ID not defined, using code instead: " |
| << device->home_provider_id(); |
| } |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_PROVIDER_REQUIRES_ROAMING: { |
| bool provider_requires_roaming; |
| if (!value.GetAsBoolean(&provider_requires_roaming)) |
| return false; |
| device->set_provider_requires_roaming(provider_requires_roaming); |
| return true; |
| } |
| case PROPERTY_INDEX_MEID: |
| case PROPERTY_INDEX_ICCID: |
| case PROPERTY_INDEX_IMEI: |
| case PROPERTY_INDEX_IMSI: |
| case PROPERTY_INDEX_ESN: |
| case PROPERTY_INDEX_MDN: |
| case PROPERTY_INDEX_MIN: |
| case PROPERTY_INDEX_MODEL_ID: |
| case PROPERTY_INDEX_MANUFACTURER: |
| case PROPERTY_INDEX_FIRMWARE_REVISION: |
| case PROPERTY_INDEX_HARDWARE_REVISION: |
| case PROPERTY_INDEX_SELECTED_NETWORK: { |
| std::string item; |
| if (!value.GetAsString(&item)) |
| return false; |
| switch (index) { |
| case PROPERTY_INDEX_MEID: |
| device->set_meid(item); |
| break; |
| case PROPERTY_INDEX_ICCID: |
| device->set_iccid(item); |
| break; |
| case PROPERTY_INDEX_IMEI: |
| device->set_imei(item); |
| break; |
| case PROPERTY_INDEX_IMSI: |
| device->set_imsi(item); |
| break; |
| case PROPERTY_INDEX_ESN: |
| device->set_esn(item); |
| break; |
| case PROPERTY_INDEX_MDN: |
| device->set_mdn(item); |
| break; |
| case PROPERTY_INDEX_MIN: |
| device->set_min(item); |
| break; |
| case PROPERTY_INDEX_MODEL_ID: |
| device->set_model_id(item); |
| break; |
| case PROPERTY_INDEX_MANUFACTURER: |
| device->set_manufacturer(item); |
| break; |
| case PROPERTY_INDEX_FIRMWARE_REVISION: |
| device->set_firmware_revision(item); |
| break; |
| case PROPERTY_INDEX_HARDWARE_REVISION: |
| device->set_hardware_revision(item); |
| break; |
| case PROPERTY_INDEX_SELECTED_NETWORK: |
| device->set_selected_cellular_network(item); |
| break; |
| default: |
| break; |
| } |
| return true; |
| } |
| case PROPERTY_INDEX_SIM_LOCK: |
| if (value.IsType(base::Value::TYPE_DICTIONARY)) { |
| SimLockState sim_lock_state; |
| int sim_retries_left; |
| bool sim_lock_enabled; |
| if (!ParseSimLockStateFromDictionary( |
| static_cast<const DictionaryValue&>(value), |
| &sim_lock_state, |
| &sim_retries_left, |
| &sim_lock_enabled)) |
| return false; |
| device->set_sim_lock_state(sim_lock_state); |
| device->set_sim_retries_left(sim_retries_left); |
| if (sim_lock_enabled) |
| device->set_sim_pin_required(SIM_PIN_REQUIRED); |
| else |
| device->set_sim_pin_required(SIM_PIN_NOT_REQUIRED); |
| return true; |
| } |
| break; |
| case PROPERTY_INDEX_SIM_PRESENT: { |
| bool sim_present; |
| if (!value.GetAsBoolean(&sim_present)) |
| return false; |
| device->set_sim_present(sim_present); |
| return true; |
| } |
| case PROPERTY_INDEX_POWERED: { |
| bool powered; |
| if (!value.GetAsBoolean(&powered)) |
| return false; |
| device->set_powered(powered); |
| return true; |
| } |
| case PROPERTY_INDEX_PRL_VERSION: { |
| int prl_version; |
| if (!value.GetAsInteger(&prl_version)) |
| return false; |
| device->set_prl_version(prl_version); |
| return true; |
| } |
| case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN: { |
| bool support_network_scan; |
| if (!value.GetAsBoolean(&support_network_scan)) |
| return false; |
| device->set_support_network_scan(support_network_scan); |
| return true; |
| } |
| case PROPERTY_INDEX_SUPPORTED_CARRIERS: { |
| if (value.IsType(base::Value::TYPE_LIST)) { |
| device->set_supported_carriers(static_cast<const ListValue&>(value)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_TECHNOLOGY_FAMILY: { |
| std::string technology_family_string; |
| if (value.GetAsString(&technology_family_string)) { |
| device->set_technology_family( |
| ParseTechnologyFamily(technology_family_string)); |
| return true; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| ConnectionType NativeNetworkDeviceParser::ParseType(const std::string& type) { |
| return NativeNetworkParser::network_type_mapper()->Get(type); |
| } |
| |
| bool NativeNetworkDeviceParser::ParseApnList(const ListValue& list, |
| CellularApnList* apn_list) { |
| apn_list->clear(); |
| apn_list->reserve(list.GetSize()); |
| for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) { |
| if ((*it)->IsType(base::Value::TYPE_DICTIONARY)) { |
| apn_list->resize(apn_list->size() + 1); |
| const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnProperty, &apn_list->back().apn); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnNetworkIdProperty, &apn_list->back().network_id); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnUsernameProperty, &apn_list->back().username); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnPasswordProperty, &apn_list->back().password); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnNameProperty, &apn_list->back().name); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnLocalizedNameProperty, |
| &apn_list->back().localized_name); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kApnLanguageProperty, &apn_list->back().language); |
| } else { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool NativeNetworkDeviceParser::ParseFoundNetworksFromList( |
| const ListValue& list, |
| CellularNetworkList* found_networks) { |
| found_networks->clear(); |
| found_networks->reserve(list.GetSize()); |
| for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) { |
| if ((*it)->IsType(base::Value::TYPE_DICTIONARY)) { |
| found_networks->resize(found_networks->size() + 1); |
| const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kStatusProperty, &found_networks->back().status); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kNetworkIdProperty, &found_networks->back().network_id); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kShortNameProperty, &found_networks->back().short_name); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kLongNameProperty, &found_networks->back().long_name); |
| dict->GetStringWithoutPathExpansion( |
| flimflam::kTechnologyProperty, &found_networks->back().technology); |
| } else { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| SimLockState NativeNetworkDeviceParser::ParseSimLockState( |
| const std::string& state) { |
| static EnumMapper<SimLockState>::Pair table[] = { |
| { "", SIM_UNLOCKED }, |
| { flimflam::kSIMLockPin, SIM_LOCKED_PIN }, |
| { flimflam::kSIMLockPuk, SIM_LOCKED_PUK }, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<SimLockState>, parser, |
| (table, arraysize(table), SIM_UNKNOWN)); |
| SimLockState parsed_state = parser.Get(state); |
| DCHECK(parsed_state != SIM_UNKNOWN) << "Unknown SIMLock state encountered"; |
| return parsed_state; |
| } |
| |
| bool NativeNetworkDeviceParser::ParseSimLockStateFromDictionary( |
| const DictionaryValue& info, |
| SimLockState* out_state, |
| int* out_retries, |
| bool* out_enabled) { |
| std::string state_string; |
| // Since RetriesLeft is sent as a uint32, which may overflow int32 range, from |
| // Shill, it may be stored as an integer or a double in DictionaryValue. |
| const base::Value* retries_value = NULL; |
| if (!info.GetString(flimflam::kSIMLockTypeProperty, &state_string) || |
| !info.GetBoolean(flimflam::kSIMLockEnabledProperty, out_enabled) || |
| !info.Get(flimflam::kSIMLockRetriesLeftProperty, &retries_value) || |
| (retries_value->GetType() != base::Value::TYPE_INTEGER && |
| retries_value->GetType() != base::Value::TYPE_DOUBLE)) { |
| LOG(ERROR) << "Error parsing SIMLock state"; |
| return false; |
| } |
| *out_state = ParseSimLockState(state_string); |
| if (retries_value->GetType() == base::Value::TYPE_INTEGER) { |
| retries_value->GetAsInteger(out_retries); |
| } else if (retries_value->GetType() == base::Value::TYPE_DOUBLE) { |
| double retries_double = 0; |
| retries_value->GetAsDouble(&retries_double); |
| *out_retries = retries_double; |
| } |
| return true; |
| } |
| |
| TechnologyFamily NativeNetworkDeviceParser::ParseTechnologyFamily( |
| const std::string& technology_family) { |
| static EnumMapper<TechnologyFamily>::Pair table[] = { |
| { flimflam::kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA }, |
| { flimflam::kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM }, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<TechnologyFamily>, parser, |
| (table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN)); |
| return parser.Get(technology_family); |
| } |
| |
| // -------------------- NativeNetworkParser -------------------- |
| |
| NativeNetworkParser::NativeNetworkParser() |
| : NetworkParser(get_native_mapper()) { |
| } |
| |
| NativeNetworkParser::~NativeNetworkParser() { |
| } |
| |
| // static |
| const EnumMapper<PropertyIndex>* NativeNetworkParser::property_mapper() { |
| return get_native_mapper(); |
| } |
| |
| // static |
| const EnumMapper<ConnectionType>* NativeNetworkParser::network_type_mapper() { |
| CR_DEFINE_STATIC_LOCAL( |
| EnumMapper<ConnectionType>, |
| network_type_mapper, |
| (network_type_table, arraysize(network_type_table), TYPE_UNKNOWN)); |
| return &network_type_mapper; |
| } |
| |
| // static |
| const EnumMapper<ConnectionSecurity>* |
| NativeNetworkParser::network_security_mapper() { |
| CR_DEFINE_STATIC_LOCAL( |
| EnumMapper<ConnectionSecurity>, |
| network_security_mapper, |
| (network_security_table, arraysize(network_security_table), |
| SECURITY_UNKNOWN)); |
| return &network_security_mapper; |
| } |
| |
| // static |
| const EnumMapper<EAPMethod>* NativeNetworkParser::network_eap_method_mapper() { |
| CR_DEFINE_STATIC_LOCAL( |
| EnumMapper<EAPMethod>, |
| network_eap_method_mapper, |
| (network_eap_method_table, arraysize(network_eap_method_table), |
| EAP_METHOD_UNKNOWN)); |
| return &network_eap_method_mapper; |
| } |
| |
| // static |
| const EnumMapper<EAPPhase2Auth>* |
| NativeNetworkParser::network_eap_auth_mapper() { |
| CR_DEFINE_STATIC_LOCAL( |
| EnumMapper<EAPPhase2Auth>, |
| network_eap_auth_mapper, |
| (network_eap_auth_table, arraysize(network_eap_auth_table), |
| EAP_PHASE_2_AUTH_AUTO)); |
| return &network_eap_auth_mapper; |
| } |
| |
| const ConnectionType NativeNetworkParser::ParseConnectionType( |
| const std::string& connection_type) { |
| return network_type_mapper()->Get(connection_type); |
| } |
| |
| Network* NativeNetworkParser::CreateNewNetwork( |
| ConnectionType type, const std::string& service_path) { |
| Network* network = NetworkParser::CreateNewNetwork(type, service_path); |
| if (network) { |
| if (type == TYPE_ETHERNET) |
| network->SetNetworkParser(new NativeEthernetNetworkParser()); |
| else if (type == TYPE_WIFI) |
| network->SetNetworkParser(new NativeWifiNetworkParser()); |
| else if (type == TYPE_WIMAX) |
| network->SetNetworkParser(new NativeWimaxNetworkParser()); |
| else if (type == TYPE_CELLULAR) |
| network->SetNetworkParser(new NativeCellularNetworkParser()); |
| else if (type == TYPE_VPN) |
| network->SetNetworkParser(new NativeVirtualNetworkParser()); |
| } |
| return network; |
| } |
| |
| bool NativeNetworkParser::ParseValue(PropertyIndex index, |
| const base::Value& value, |
| Network* network) { |
| switch (index) { |
| case PROPERTY_INDEX_TYPE: { |
| std::string type_string; |
| if (value.GetAsString(&type_string)) { |
| ConnectionType type = ParseType(type_string); |
| LOG_IF(ERROR, type != network->type()) |
| << "Network with mismatched type: " << network->service_path() |
| << " " << type << " != " << network->type(); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_DEVICE: { |
| std::string device_path; |
| if (!value.GetAsString(&device_path)) |
| return false; |
| network->set_device_path(device_path); |
| return true; |
| } |
| case PROPERTY_INDEX_PROFILE: { |
| // Note: currently this is only provided for non remembered networks. |
| std::string profile_path; |
| if (!value.GetAsString(&profile_path)) |
| return false; |
| network->set_profile_path(profile_path); |
| return true; |
| } |
| case PROPERTY_INDEX_STATE: { |
| std::string state_string; |
| if (value.GetAsString(&state_string)) { |
| network->SetState(ParseState(state_string)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_ERROR: { |
| std::string error_string; |
| if (value.GetAsString(&error_string)) { |
| network->SetError(ParseError(error_string)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_CONNECTABLE: { |
| bool connectable; |
| if (!value.GetAsBoolean(&connectable)) |
| return false; |
| network->set_connectable(connectable); |
| return true; |
| } |
| case PROPERTY_INDEX_IS_ACTIVE: { |
| bool is_active; |
| if (!value.GetAsBoolean(&is_active)) |
| return false; |
| network->set_is_active(is_active); |
| return true; |
| } |
| case PROPERTY_INDEX_FAVORITE: |
| // This property is ignored. |
| return true; |
| case PROPERTY_INDEX_SAVE_CREDENTIALS: { |
| bool save_credentials; |
| if (!value.GetAsBoolean(&save_credentials)) |
| return false; |
| network->set_save_credentials(save_credentials); |
| return true; |
| } |
| case PROPERTY_INDEX_CHECK_PORTAL: |
| // This property is ignored. |
| return true; |
| default: |
| return NetworkParser::ParseValue(index, value, network); |
| break; |
| } |
| return false; |
| } |
| |
| ConnectionType NativeNetworkParser::ParseType(const std::string& type) { |
| return network_type_mapper()->Get(type); |
| } |
| |
| ConnectionType NativeNetworkParser::ParseTypeFromDictionary( |
| const DictionaryValue& info) { |
| std::string type_string; |
| info.GetString(flimflam::kTypeProperty, &type_string); |
| return ParseType(type_string); |
| } |
| |
| ConnectionState NativeNetworkParser::ParseState(const std::string& state) { |
| static EnumMapper<ConnectionState>::Pair table[] = { |
| { flimflam::kStateIdle, STATE_IDLE }, |
| { flimflam::kStateCarrier, STATE_CARRIER }, |
| { flimflam::kStateAssociation, STATE_ASSOCIATION }, |
| { flimflam::kStateConfiguration, STATE_CONFIGURATION }, |
| { flimflam::kStateReady, STATE_READY }, |
| { flimflam::kStateDisconnect, STATE_DISCONNECT }, |
| { flimflam::kStateFailure, STATE_FAILURE }, |
| { flimflam::kStateActivationFailure, STATE_ACTIVATION_FAILURE }, |
| { flimflam::kStatePortal, STATE_PORTAL }, |
| { flimflam::kStateOnline, STATE_ONLINE }, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionState>, parser, |
| (table, arraysize(table), STATE_UNKNOWN)); |
| return parser.Get(state); |
| } |
| |
| ConnectionError NativeNetworkParser::ParseError(const std::string& error) { |
| static EnumMapper<ConnectionError>::Pair table[] = { |
| { flimflam::kErrorOutOfRange, ERROR_OUT_OF_RANGE }, |
| { flimflam::kErrorPinMissing, ERROR_PIN_MISSING }, |
| { flimflam::kErrorDhcpFailed, ERROR_DHCP_FAILED }, |
| { flimflam::kErrorConnectFailed, ERROR_CONNECT_FAILED }, |
| { flimflam::kErrorBadPassphrase, ERROR_BAD_PASSPHRASE }, |
| { flimflam::kErrorBadWEPKey, ERROR_BAD_WEPKEY }, |
| { flimflam::kErrorActivationFailed, ERROR_ACTIVATION_FAILED }, |
| { flimflam::kErrorNeedEvdo, ERROR_NEED_EVDO }, |
| { flimflam::kErrorNeedHomeNetwork, ERROR_NEED_HOME_NETWORK }, |
| { flimflam::kErrorOtaspFailed, ERROR_OTASP_FAILED }, |
| { flimflam::kErrorAaaFailed, ERROR_AAA_FAILED }, |
| { flimflam::kErrorInternal, ERROR_INTERNAL }, |
| { flimflam::kErrorDNSLookupFailed, ERROR_DNS_LOOKUP_FAILED }, |
| { flimflam::kErrorHTTPGetFailed, ERROR_HTTP_GET_FAILED }, |
| { flimflam::kErrorIpsecPskAuthFailed, ERROR_IPSEC_PSK_AUTH_FAILED }, |
| { flimflam::kErrorIpsecCertAuthFailed, ERROR_IPSEC_CERT_AUTH_FAILED }, |
| { flimflam::kErrorPppAuthFailed, ERROR_PPP_AUTH_FAILED }, |
| { shill::kErrorEapAuthenticationFailed, ERROR_EAP_AUTHENTICATION_FAILED }, |
| { shill::kErrorEapLocalTlsFailed, ERROR_EAP_LOCAL_TLS_FAILED }, |
| { shill::kErrorEapRemoteTlsFailed, ERROR_EAP_REMOTE_TLS_FAILED }, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionError>, parser, |
| (table, arraysize(table), ERROR_NO_ERROR)); |
| return parser.Get(error); |
| } |
| |
| // -------------------- NativeEthernetNetworkParser -------------------- |
| |
| NativeEthernetNetworkParser::NativeEthernetNetworkParser() {} |
| NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {} |
| |
| // -------------------- NativeWirelessNetworkParser -------------------- |
| |
| NativeWirelessNetworkParser::NativeWirelessNetworkParser() {} |
| NativeWirelessNetworkParser::~NativeWirelessNetworkParser() {} |
| |
| bool NativeWirelessNetworkParser::ParseValue(PropertyIndex index, |
| const base::Value& value, |
| Network* network) { |
| CHECK(network->type() == TYPE_WIFI || |
| network->type() == TYPE_WIMAX || |
| network->type() == TYPE_BLUETOOTH || |
| network->type() == TYPE_CELLULAR); |
| WirelessNetwork* wireless_network = static_cast<WirelessNetwork*>(network); |
| switch (index) { |
| case PROPERTY_INDEX_SIGNAL_STRENGTH: { |
| int strength; |
| if (!value.GetAsInteger(&strength)) |
| return false; |
| wireless_network->set_strength(strength); |
| return true; |
| } |
| default: |
| return NativeNetworkParser::ParseValue(index, value, network); |
| break; |
| } |
| return false; |
| } |
| |
| // -------------------- NativeCellularNetworkParser -------------------- |
| |
| NativeCellularNetworkParser::NativeCellularNetworkParser() {} |
| NativeCellularNetworkParser::~NativeCellularNetworkParser() {} |
| |
| bool NativeCellularNetworkParser::ParseValue(PropertyIndex index, |
| const base::Value& value, |
| Network* network) { |
| CHECK_EQ(TYPE_CELLULAR, network->type()); |
| CellularNetwork* cellular_network = static_cast<CellularNetwork*>(network); |
| switch (index) { |
| case PROPERTY_INDEX_ACTIVATE_OVER_NON_CELLULAR_NETWORK: { |
| bool activate_over_non_cellular_network; |
| if (value.GetAsBoolean(&activate_over_non_cellular_network)) { |
| cellular_network->set_activate_over_non_cellular_network( |
| activate_over_non_cellular_network); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_ACTIVATION_STATE: { |
| std::string activation_state_string; |
| if (value.GetAsString(&activation_state_string)) { |
| cellular_network->set_activation_state( |
| ParseActivationState(activation_state_string)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_CELLULAR_APN: { |
| if (value.IsType(base::Value::TYPE_DICTIONARY)) { |
| cellular_network->set_apn(static_cast<const DictionaryValue&>(value)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: { |
| if (value.IsType(base::Value::TYPE_DICTIONARY)) { |
| cellular_network->set_last_good_apn( |
| static_cast<const DictionaryValue&>(value)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_NETWORK_TECHNOLOGY: { |
| std::string network_technology_string; |
| if (value.GetAsString(&network_technology_string)) { |
| cellular_network->set_network_technology( |
| ParseNetworkTechnology(network_technology_string)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_ROAMING_STATE: { |
| std::string roaming_state_string; |
| if (value.GetAsString(&roaming_state_string)) { |
| cellular_network->set_roaming_state( |
| ParseRoamingState(roaming_state_string)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_OPERATOR_NAME: { |
| std::string value_str; |
| if (!value.GetAsString(&value_str)) |
| break; |
| cellular_network->set_operator_name(value_str); |
| return true; |
| } |
| case PROPERTY_INDEX_OPERATOR_CODE: { |
| std::string value_str; |
| if (!value.GetAsString(&value_str)) |
| break; |
| cellular_network->set_operator_code(value_str); |
| return true; |
| } |
| case PROPERTY_INDEX_OUT_OF_CREDITS: { |
| bool out_of_credits; |
| if (value.GetAsBoolean(&out_of_credits)) { |
| cellular_network->set_out_of_credits(out_of_credits); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_SERVING_OPERATOR: { |
| if (value.IsType(base::Value::TYPE_DICTIONARY)) { |
| const DictionaryValue& dict = |
| static_cast<const DictionaryValue&>(value); |
| std::string value_str; |
| dict.GetStringWithoutPathExpansion( |
| flimflam::kOperatorNameKey, &value_str); |
| cellular_network->set_operator_name(value_str); |
| value_str.clear(); |
| dict.GetStringWithoutPathExpansion( |
| flimflam::kOperatorCodeKey, &value_str); |
| cellular_network->set_operator_code(value_str); |
| value_str.clear(); |
| dict.GetStringWithoutPathExpansion( |
| flimflam::kOperatorCountryKey, &value_str); |
| cellular_network->set_operator_country(value_str); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_USAGE_URL: { |
| std::string value_str; |
| if (!value.GetAsString(&value_str)) |
| break; |
| cellular_network->set_usage_url(value_str); |
| return true; |
| } |
| case PROPERTY_INDEX_OLP: { |
| if (value.IsType(base::Value::TYPE_DICTIONARY)) { |
| const DictionaryValue& dict = |
| static_cast<const DictionaryValue&>(value); |
| std::string portal_url; |
| std::string method; |
| std::string postdata; |
| dict.GetStringWithoutPathExpansion(flimflam::kPaymentPortalURL, |
| &portal_url); |
| dict.GetStringWithoutPathExpansion(flimflam::kPaymentPortalMethod, |
| &method); |
| dict.GetStringWithoutPathExpansion(flimflam::kPaymentPortalPostData, |
| &postdata); |
| cellular_network->set_payment_url(portal_url); |
| cellular_network->set_post_data(postdata); |
| cellular_network->set_using_post( |
| LowerCaseEqualsASCII(method, kPostMethod)); |
| return true; |
| } |
| break; |
| } |
| case PROPERTY_INDEX_OLP_URL: |
| // This property is ignored. |
| return true; |
| case PROPERTY_INDEX_STATE: { |
| if (NativeWirelessNetworkParser::ParseValue(index, value, network)) |
| return true; |
| break; |
| } |
| default: |
| return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| } |
| return false; |
| } |
| |
| ActivationState NativeCellularNetworkParser::ParseActivationState( |
| const std::string& state) { |
| static EnumMapper<ActivationState>::Pair table[] = { |
| { flimflam::kActivationStateActivated, ACTIVATION_STATE_ACTIVATED }, |
| { flimflam::kActivationStateActivating, ACTIVATION_STATE_ACTIVATING }, |
| { flimflam::kActivationStateNotActivated, ACTIVATION_STATE_NOT_ACTIVATED }, |
| { flimflam::kActivationStatePartiallyActivated, |
| ACTIVATION_STATE_PARTIALLY_ACTIVATED}, |
| { flimflam::kActivationStateUnknown, ACTIVATION_STATE_UNKNOWN}, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<ActivationState>, parser, |
| (table, arraysize(table), ACTIVATION_STATE_UNKNOWN)); |
| return parser.Get(state); |
| } |
| |
| NetworkTechnology NativeCellularNetworkParser::ParseNetworkTechnology( |
| const std::string& technology) { |
| static EnumMapper<NetworkTechnology>::Pair table[] = { |
| { flimflam::kNetworkTechnology1Xrtt, NETWORK_TECHNOLOGY_1XRTT }, |
| { flimflam::kNetworkTechnologyEvdo, NETWORK_TECHNOLOGY_EVDO }, |
| { flimflam::kNetworkTechnologyGprs, NETWORK_TECHNOLOGY_GPRS }, |
| { flimflam::kNetworkTechnologyEdge, NETWORK_TECHNOLOGY_EDGE }, |
| { flimflam::kNetworkTechnologyUmts, NETWORK_TECHNOLOGY_UMTS }, |
| { flimflam::kNetworkTechnologyHspa, NETWORK_TECHNOLOGY_HSPA }, |
| { flimflam::kNetworkTechnologyHspaPlus, NETWORK_TECHNOLOGY_HSPA_PLUS }, |
| { flimflam::kNetworkTechnologyLte, NETWORK_TECHNOLOGY_LTE }, |
| { flimflam::kNetworkTechnologyLteAdvanced, |
| NETWORK_TECHNOLOGY_LTE_ADVANCED }, |
| { flimflam::kNetworkTechnologyGsm, NETWORK_TECHNOLOGY_GSM }, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<NetworkTechnology>, parser, |
| (table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN)); |
| return parser.Get(technology); |
| } |
| |
| NetworkRoamingState NativeCellularNetworkParser::ParseRoamingState( |
| const std::string& roaming_state) { |
| static EnumMapper<NetworkRoamingState>::Pair table[] = { |
| { flimflam::kRoamingStateHome, ROAMING_STATE_HOME }, |
| { flimflam::kRoamingStateRoaming, ROAMING_STATE_ROAMING }, |
| { flimflam::kRoamingStateUnknown, ROAMING_STATE_UNKNOWN }, |
| }; |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<NetworkRoamingState>, parser, |
| (table, arraysize(table), ROAMING_STATE_UNKNOWN)); |
| return parser.Get(roaming_state); |
| } |
| |
| // -------------------- NativeWimaxNetworkParser -------------------- |
| |
| NativeWimaxNetworkParser::NativeWimaxNetworkParser() {} |
| NativeWimaxNetworkParser::~NativeWimaxNetworkParser() {} |
| |
| |
| bool NativeWimaxNetworkParser::ParseValue(PropertyIndex index, |
| const base::Value& value, |
| Network* network) { |
| CHECK_EQ(TYPE_WIMAX, network->type()); |
| WimaxNetwork* wimax_network = static_cast<WimaxNetwork*>(network); |
| switch (index) { |
| case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { |
| bool passphrase_required; |
| if (!value.GetAsBoolean(&passphrase_required)) |
| break; |
| wimax_network->set_passphrase_required(passphrase_required); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_IDENTITY: { |
| std::string eap_identity; |
| if (!value.GetAsString(&eap_identity)) |
| break; |
| |
| wimax_network->set_eap_identity(eap_identity); |
| } |
| case PROPERTY_INDEX_EAP_PASSWORD: { |
| std::string passphrase; |
| if (!value.GetAsString(&passphrase)) |
| break; |
| |
| wimax_network->set_eap_passphrase(passphrase); |
| return true; |
| } |
| default: |
| return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| } |
| return false; |
| } |
| |
| // -------------------- NativeWifiNetworkParser -------------------- |
| |
| NativeWifiNetworkParser::NativeWifiNetworkParser() {} |
| NativeWifiNetworkParser::~NativeWifiNetworkParser() {} |
| |
| bool NativeWifiNetworkParser::ParseValue(PropertyIndex index, |
| const base::Value& value, |
| Network* network) { |
| CHECK_EQ(TYPE_WIFI, network->type()); |
| WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network); |
| switch (index) { |
| case PROPERTY_INDEX_WIFI_HEX_SSID: { |
| std::string ssid_hex; |
| if (!value.GetAsString(&ssid_hex)) |
| return false; |
| wifi_network->SetHexSsid(ssid_hex); |
| return true; |
| } |
| case PROPERTY_INDEX_WIFI_BSSID: { |
| std::string bssid; |
| if (!value.GetAsString(&bssid)) |
| return false; |
| wifi_network->set_bssid(bssid); |
| return true; |
| } |
| case PROPERTY_INDEX_WIFI_HIDDEN_SSID: { |
| bool hidden_ssid; |
| if (!value.GetAsBoolean(&hidden_ssid)) |
| return false; |
| wifi_network->set_hidden_ssid(hidden_ssid); |
| return true; |
| } |
| case PROPERTY_INDEX_WIFI_FREQUENCY: { |
| int frequency; |
| if (!value.GetAsInteger(&frequency)) |
| return false; |
| wifi_network->set_frequency(frequency); |
| return true; |
| } |
| case PROPERTY_INDEX_NAME: { |
| // Does not change network name when it was already set by WiFi.HexSSID. |
| if (!wifi_network->name().empty()) |
| return true; |
| else |
| return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| } |
| case PROPERTY_INDEX_GUID: { |
| std::string unique_id; |
| if (!value.GetAsString(&unique_id)) |
| break; |
| wifi_network->set_unique_id(unique_id); |
| return true; |
| } |
| case PROPERTY_INDEX_SECURITY: { |
| std::string security_string; |
| if (!value.GetAsString(&security_string)) |
| break; |
| wifi_network->set_encryption(ParseSecurity(security_string)); |
| return true; |
| } |
| case PROPERTY_INDEX_PASSPHRASE: { |
| std::string passphrase; |
| if (!value.GetAsString(&passphrase)) |
| break; |
| |
| if (chromeos::UserManager::Get()->IsCurrentUserOwner()) |
| wifi_network->set_passphrase(passphrase); |
| return true; |
| } |
| case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { |
| bool passphrase_required; |
| if (!value.GetAsBoolean(&passphrase_required)) |
| break; |
| wifi_network->set_passphrase_required(passphrase_required); |
| return true; |
| } |
| case PROPERTY_INDEX_IDENTITY: { |
| std::string identity; |
| if (!value.GetAsString(&identity)) |
| break; |
| wifi_network->set_identity(identity); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_IDENTITY: { |
| std::string eap_identity; |
| if (!value.GetAsString(&eap_identity)) |
| break; |
| wifi_network->set_eap_identity(eap_identity); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_METHOD: { |
| std::string eap_method; |
| if (!value.GetAsString(&eap_method)) |
| break; |
| wifi_network->set_eap_method(ParseEAPMethod(eap_method)); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_PHASE_2_AUTH: { |
| std::string eap_phase_2_auth; |
| if (!value.GetAsString(&eap_phase_2_auth)) |
| break; |
| wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth)); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: { |
| std::string eap_anonymous_identity; |
| if (!value.GetAsString(&eap_anonymous_identity)) |
| break; |
| wifi_network->set_eap_anonymous_identity(eap_anonymous_identity); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_CERT_ID: { |
| std::string eap_client_cert_pkcs11_id; |
| if (!value.GetAsString(&eap_client_cert_pkcs11_id)) |
| break; |
| wifi_network->set_eap_client_cert_pkcs11_id(eap_client_cert_pkcs11_id); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_CA_CERT_PEM: { |
| const base::ListValue* pems = NULL; |
| value.GetAsList(&pems); |
| if (!pems) |
| break; |
| std::string ca_cert_pem; |
| if (!pems->empty()) |
| pems->GetString(0, &ca_cert_pem); |
| wifi_network->set_eap_server_ca_cert_pem(ca_cert_pem); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS: { |
| bool eap_use_system_cas; |
| if (!value.GetAsBoolean(&eap_use_system_cas)) |
| break; |
| wifi_network->set_eap_use_system_cas(eap_use_system_cas); |
| return true; |
| } |
| case PROPERTY_INDEX_EAP_PASSWORD: { |
| std::string eap_passphrase; |
| if (!value.GetAsString(&eap_passphrase)) |
| break; |
| wifi_network->set_eap_passphrase(eap_passphrase); |
| return true; |
| } |
| case PROPERTY_INDEX_WIFI_AUTH_MODE: |
| case PROPERTY_INDEX_WIFI_PHY_MODE: |
| case PROPERTY_INDEX_EAP_CLIENT_CERT: |
| case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS: |
| case PROPERTY_INDEX_EAP_PRIVATE_KEY: |
| case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD: |
| case PROPERTY_INDEX_EAP_KEY_ID: |
| case PROPERTY_INDEX_EAP_CA_CERT_ID: |
| case PROPERTY_INDEX_EAP_PIN: |
| case PROPERTY_INDEX_EAP_KEY_MGMT: |
| // These properties are currently not used in the UI. |
| return true; |
| default: |
| return NativeWirelessNetworkParser::ParseValue(index, value, network); |
| } |
| return false; |
| } |
| |
| ConnectionSecurity NativeWifiNetworkParser::ParseSecurity( |
| const std::string& security) { |
| return network_security_mapper()->Get(security); |
| } |
| |
| EAPMethod NativeWifiNetworkParser::ParseEAPMethod(const std::string& method) { |
| return network_eap_method_mapper()->Get(method); |
| } |
| |
| EAPPhase2Auth NativeWifiNetworkParser::ParseEAPPhase2Auth( |
| const std::string& auth) { |
| return network_eap_auth_mapper()->Get(auth); |
| } |
| |
| // -------------------- NativeVirtualNetworkParser -------------------- |
| |
| |
| NativeVirtualNetworkParser::NativeVirtualNetworkParser() {} |
| NativeVirtualNetworkParser::~NativeVirtualNetworkParser() {} |
| |
| bool NativeVirtualNetworkParser::UpdateNetworkFromInfo( |
| const DictionaryValue& info, |
| Network* network) { |
| CHECK_EQ(TYPE_VPN, network->type()); |
| VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); |
| if (!NativeNetworkParser::UpdateNetworkFromInfo(info, network)) |
| return false; |
| VLOG(1) << "Updating VPN '" << virtual_network->name() |
| << "': Server: " << virtual_network->server_hostname() |
| << " Type: " |
| << ProviderTypeToString(virtual_network->provider_type()); |
| if (virtual_network->provider_type() == PROVIDER_TYPE_L2TP_IPSEC_PSK) { |
| if (!virtual_network->client_cert_id().empty()) |
| virtual_network->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT); |
| } |
| return true; |
| } |
| |
| bool NativeVirtualNetworkParser::ParseValue(PropertyIndex index, |
| const base::Value& value, |
| Network* network) { |
| CHECK_EQ(TYPE_VPN, network->type()); |
| VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); |
| switch (index) { |
| case PROPERTY_INDEX_PROVIDER: { |
| // TODO(rkc): Figure out why is this ever not true and fix the root |
| // cause. 'value' comes to us all the way from the cros dbus call, the |
| // issue is likely on the cros side of things. |
| if (value.GetType() != Value::TYPE_DICTIONARY) |
| return false; |
| |
| const DictionaryValue& dict = static_cast<const DictionaryValue&>(value); |
| for (DictionaryValue::Iterator iter(dict); |
| !iter.IsAtEnd(); |
| iter.Advance()) { |
| PropertyIndex index = mapper().Get(iter.key()); |
| if (!ParseProviderValue(index, iter.value(), virtual_network)) { |
| VLOG(1) << network->name() << ": Provider unhandled key: " |
| << iter.key() << " Type: " << iter.value().GetType(); |
| } |
| } |
| return true; |
| } |
| default: |
| return NativeNetworkParser::ParseValue(index, value, network); |
| break; |
| } |
| return false; |
| } |
| |
| bool NativeVirtualNetworkParser::ParseProviderValue(PropertyIndex index, |
| const base::Value& value, |
| VirtualNetwork* network) { |
| switch (index) { |
| case PROPERTY_INDEX_HOST: { |
| std::string server_hostname; |
| if (!value.GetAsString(&server_hostname)) |
| break; |
| network->set_server_hostname(server_hostname); |
| return true; |
| } |
| case PROPERTY_INDEX_NAME: { |
| std::string name; |
| if (!value.GetAsString(&name)) |
| break; |
| network->set_name(name); |
| return true; |
| } |
| case PROPERTY_INDEX_TYPE: { |
| std::string provider_type_string; |
| if (!value.GetAsString(&provider_type_string)) |
| break; |
| network->set_provider_type(ParseProviderType(provider_type_string)); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_CA_CERT_PEM: |
| case PROPERTY_INDEX_OPEN_VPN_CA_CERT_PEM: { |
| const base::ListValue* pems = NULL; |
| value.GetAsList(&pems); |
| if (!pems) |
| break; |
| std::string ca_cert_pem; |
| if (!pems->empty()) |
| pems->GetString(0, &ca_cert_pem); |
| network->set_ca_cert_pem(ca_cert_pem); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_PSK: { |
| std::string psk_passphrase; |
| if (!value.GetAsString(&psk_passphrase)) |
| break; |
| network->set_psk_passphrase(psk_passphrase); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_PSK_REQUIRED: { |
| bool psk_passphrase_required; |
| if (!value.GetAsBoolean(&psk_passphrase_required)) |
| break; |
| network->set_psk_passphrase_required(psk_passphrase_required); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID: |
| case PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_ID: { |
| std::string client_cert_id; |
| if (!value.GetAsString(&client_cert_id)) |
| break; |
| network->set_client_cert_id(client_cert_id); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_USER: |
| case PROPERTY_INDEX_OPEN_VPN_USER: { |
| std::string username; |
| if (!value.GetAsString(&username)) |
| break; |
| network->set_username(username); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_PASSWORD: |
| case PROPERTY_INDEX_OPEN_VPN_PASSWORD: { |
| std::string user_passphrase; |
| if (!value.GetAsString(&user_passphrase)) |
| break; |
| network->set_user_passphrase(user_passphrase); |
| return true; |
| } |
| case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { |
| bool user_passphrase_required; |
| if (!value.GetAsBoolean(&user_passphrase_required)) |
| break; |
| network->set_user_passphrase_required(user_passphrase_required); |
| return true; |
| } |
| case PROPERTY_INDEX_L2TPIPSEC_GROUP_NAME: { |
| std::string group_name; |
| if (!value.GetAsString(&group_name)) |
| break; |
| network->set_group_name(group_name); |
| return true; |
| } |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| // static |
| const EnumMapper<ProviderType>* |
| NativeVirtualNetworkParser::provider_type_mapper() { |
| CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser, |
| (provider_type_table, arraysize(provider_type_table), |
| PROVIDER_TYPE_MAX)); |
| return &parser; |
| } |
| |
| ProviderType NativeVirtualNetworkParser::ParseProviderType( |
| const std::string& type) { |
| return provider_type_mapper()->Get(type); |
| } |
| |
| } // namespace chromeos |
