| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/chromeos/cros/native_network_parser.h" | |
| 6 | |
| 7 #include <string> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "base/strings/string_util.h" | |
| 11 #include "base/strings/stringprintf.h" | |
| 12 #include "base/values.h" | |
| 13 #include "chrome/browser/chromeos/cros/native_network_constants.h" | |
| 14 #include "chrome/browser/chromeos/cros/network_library.h" | |
| 15 #include "chrome/browser/chromeos/login/user_manager.h" | |
| 16 #include "chromeos/network/onc/onc_utils.h" | |
| 17 #include "third_party/cros_system_api/dbus/service_constants.h" | |
| 18 | |
| 19 namespace chromeos { | |
| 20 | |
| 21 // Local constants. | |
| 22 namespace { | |
| 23 | |
| 24 const char kPostMethod[] = "post"; | |
| 25 | |
| 26 EnumMapper<PropertyIndex>::Pair property_index_table[] = { | |
| 27 { shill::kActivateOverNonCellularNetworkProperty, | |
| 28 PROPERTY_INDEX_ACTIVATE_OVER_NON_CELLULAR_NETWORK }, | |
| 29 { flimflam::kActivationStateProperty, PROPERTY_INDEX_ACTIVATION_STATE }, | |
| 30 { flimflam::kActiveProfileProperty, PROPERTY_INDEX_ACTIVE_PROFILE }, | |
| 31 { flimflam::kArpGatewayProperty, PROPERTY_INDEX_ARP_GATEWAY }, | |
| 32 { flimflam::kAutoConnectProperty, PROPERTY_INDEX_AUTO_CONNECT }, | |
| 33 { flimflam::kAvailableTechnologiesProperty, | |
| 34 PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES }, | |
| 35 { flimflam::kCarrierProperty, PROPERTY_INDEX_CARRIER }, | |
| 36 { flimflam::kCellularAllowRoamingProperty, | |
| 37 PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING }, | |
| 38 { flimflam::kCellularApnListProperty, PROPERTY_INDEX_CELLULAR_APN_LIST }, | |
| 39 { flimflam::kCellularApnProperty, PROPERTY_INDEX_CELLULAR_APN }, | |
| 40 { flimflam::kCellularLastGoodApnProperty, | |
| 41 PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN }, | |
| 42 { flimflam::kCheckPortalProperty, PROPERTY_INDEX_CHECK_PORTAL }, | |
| 43 { flimflam::kCheckPortalListProperty, PROPERTY_INDEX_CHECK_PORTAL_LIST }, | |
| 44 { flimflam::kConnectableProperty, PROPERTY_INDEX_CONNECTABLE }, | |
| 45 { flimflam::kConnectedTechnologiesProperty, | |
| 46 PROPERTY_INDEX_CONNECTED_TECHNOLOGIES }, | |
| 47 { flimflam::kDefaultTechnologyProperty, PROPERTY_INDEX_DEFAULT_TECHNOLOGY }, | |
| 48 { flimflam::kDeviceProperty, PROPERTY_INDEX_DEVICE }, | |
| 49 { flimflam::kDevicesProperty, PROPERTY_INDEX_DEVICES }, | |
| 50 { flimflam::kEapAnonymousIdentityProperty, | |
| 51 PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY }, | |
| 52 { flimflam::kEapCaCertIdProperty, PROPERTY_INDEX_EAP_CA_CERT_ID }, | |
| 53 { shill::kEapCaCertPemProperty, PROPERTY_INDEX_EAP_CA_CERT_PEM }, | |
| 54 { flimflam::kEapCertIdProperty, PROPERTY_INDEX_EAP_CERT_ID }, | |
| 55 { flimflam::kEapClientCertNssProperty, PROPERTY_INDEX_EAP_CLIENT_CERT_NSS }, | |
| 56 { flimflam::kEapClientCertProperty, PROPERTY_INDEX_EAP_CLIENT_CERT }, | |
| 57 { flimflam::kEapIdentityProperty, PROPERTY_INDEX_EAP_IDENTITY }, | |
| 58 { flimflam::kEapKeyIdProperty, PROPERTY_INDEX_EAP_KEY_ID }, | |
| 59 { flimflam::kEapKeyMgmtProperty, PROPERTY_INDEX_EAP_KEY_MGMT }, | |
| 60 { flimflam::kEapMethodProperty, PROPERTY_INDEX_EAP_METHOD }, | |
| 61 { flimflam::kEapPasswordProperty, PROPERTY_INDEX_EAP_PASSWORD }, | |
| 62 { flimflam::kEapPhase2AuthProperty, PROPERTY_INDEX_EAP_PHASE_2_AUTH }, | |
| 63 { flimflam::kEapPinProperty, PROPERTY_INDEX_EAP_PIN }, | |
| 64 { flimflam::kEapPrivateKeyPasswordProperty, | |
| 65 PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD }, | |
| 66 { flimflam::kEapPrivateKeyProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY }, | |
| 67 { flimflam::kEapUseSystemCasProperty, PROPERTY_INDEX_EAP_USE_SYSTEM_CAS }, | |
| 68 { flimflam::kEnabledTechnologiesProperty, | |
| 69 PROPERTY_INDEX_ENABLED_TECHNOLOGIES }, | |
| 70 { flimflam::kErrorProperty, PROPERTY_INDEX_ERROR }, | |
| 71 { flimflam::kEsnProperty, PROPERTY_INDEX_ESN }, | |
| 72 { flimflam::kFavoriteProperty, PROPERTY_INDEX_FAVORITE }, | |
| 73 { flimflam::kFirmwareRevisionProperty, PROPERTY_INDEX_FIRMWARE_REVISION }, | |
| 74 { flimflam::kFoundNetworksProperty, PROPERTY_INDEX_FOUND_NETWORKS }, | |
| 75 { flimflam::kGuidProperty, PROPERTY_INDEX_GUID }, | |
| 76 { flimflam::kHardwareRevisionProperty, PROPERTY_INDEX_HARDWARE_REVISION }, | |
| 77 { flimflam::kHomeProviderProperty, PROPERTY_INDEX_HOME_PROVIDER }, | |
| 78 { flimflam::kHostProperty, PROPERTY_INDEX_HOST }, | |
| 79 { flimflam::kIccidProperty, PROPERTY_INDEX_ICCID }, | |
| 80 { flimflam::kIdentityProperty, PROPERTY_INDEX_IDENTITY }, | |
| 81 { flimflam::kImeiProperty, PROPERTY_INDEX_IMEI }, | |
| 82 { flimflam::kImsiProperty, PROPERTY_INDEX_IMSI }, | |
| 83 { flimflam::kIsActiveProperty, PROPERTY_INDEX_IS_ACTIVE }, | |
| 84 { flimflam::kL2tpIpsecAuthenticationType, | |
| 85 PROPERTY_INDEX_IPSEC_AUTHENTICATIONTYPE }, | |
| 86 { shill::kL2tpIpsecCaCertPemProperty, | |
| 87 PROPERTY_INDEX_L2TPIPSEC_CA_CERT_PEM }, | |
| 88 { flimflam::kL2tpIpsecClientCertIdProperty, | |
| 89 PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID }, | |
| 90 { flimflam::kL2tpIpsecClientCertSlotProp, | |
| 91 PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT }, | |
| 92 { flimflam::kL2tpIpsecIkeVersion, PROPERTY_INDEX_IPSEC_IKEVERSION }, | |
| 93 { flimflam::kL2tpIpsecPinProperty, PROPERTY_INDEX_L2TPIPSEC_PIN }, | |
| 94 { flimflam::kL2tpIpsecPskProperty, PROPERTY_INDEX_L2TPIPSEC_PSK }, | |
| 95 { flimflam::kL2tpIpsecPskRequiredProperty, | |
| 96 PROPERTY_INDEX_L2TPIPSEC_PSK_REQUIRED }, | |
| 97 { flimflam::kL2tpIpsecPasswordProperty, PROPERTY_INDEX_L2TPIPSEC_PASSWORD }, | |
| 98 { flimflam::kL2tpIpsecUserProperty, PROPERTY_INDEX_L2TPIPSEC_USER }, | |
| 99 { shill::kL2tpIpsecTunnelGroupProperty, | |
| 100 PROPERTY_INDEX_L2TPIPSEC_GROUP_NAME }, | |
| 101 { flimflam::kManufacturerProperty, PROPERTY_INDEX_MANUFACTURER }, | |
| 102 { flimflam::kMdnProperty, PROPERTY_INDEX_MDN }, | |
| 103 { flimflam::kMeidProperty, PROPERTY_INDEX_MEID }, | |
| 104 { flimflam::kMinProperty, PROPERTY_INDEX_MIN }, | |
| 105 { flimflam::kModelIDProperty, PROPERTY_INDEX_MODEL_ID }, | |
| 106 { flimflam::kNameProperty, PROPERTY_INDEX_NAME }, | |
| 107 { flimflam::kNetworkTechnologyProperty, PROPERTY_INDEX_NETWORK_TECHNOLOGY }, | |
| 108 { flimflam::kNetworksProperty, PROPERTY_INDEX_NETWORKS }, | |
| 109 { flimflam::kOfflineModeProperty, PROPERTY_INDEX_OFFLINE_MODE }, | |
| 110 { flimflam::kOperatorCodeProperty, PROPERTY_INDEX_OPERATOR_CODE }, | |
| 111 { flimflam::kOperatorNameProperty, PROPERTY_INDEX_OPERATOR_NAME }, | |
| 112 { shill::kOutOfCreditsProperty, PROPERTY_INDEX_OUT_OF_CREDITS }, | |
| 113 { flimflam::kPRLVersionProperty, PROPERTY_INDEX_PRL_VERSION }, | |
| 114 { flimflam::kPassphraseProperty, PROPERTY_INDEX_PASSPHRASE }, | |
| 115 { flimflam::kPassphraseRequiredProperty, PROPERTY_INDEX_PASSPHRASE_REQUIRED }, | |
| 116 { flimflam::kPortalURLProperty, PROPERTY_INDEX_PORTAL_URL }, | |
| 117 { flimflam::kPoweredProperty, PROPERTY_INDEX_POWERED }, | |
| 118 { flimflam::kPriorityProperty, PROPERTY_INDEX_PRIORITY }, | |
| 119 { flimflam::kProfileProperty, PROPERTY_INDEX_PROFILE }, | |
| 120 { flimflam::kProfilesProperty, PROPERTY_INDEX_PROFILES }, | |
| 121 { flimflam::kProviderHostProperty, PROPERTY_INDEX_PROVIDER_HOST }, | |
| 122 { flimflam::kProviderProperty, PROPERTY_INDEX_PROVIDER }, | |
| 123 { shill::kProviderRequiresRoamingProperty, | |
| 124 PROPERTY_INDEX_PROVIDER_REQUIRES_ROAMING }, | |
| 125 { flimflam::kProviderTypeProperty, PROPERTY_INDEX_PROVIDER_TYPE }, | |
| 126 { flimflam::kRoamingStateProperty, PROPERTY_INDEX_ROAMING_STATE }, | |
| 127 { flimflam::kSIMLockStatusProperty, PROPERTY_INDEX_SIM_LOCK }, | |
| 128 { shill::kSIMPresentProperty, PROPERTY_INDEX_SIM_PRESENT }, | |
| 129 { flimflam::kSSIDProperty, PROPERTY_INDEX_SSID }, | |
| 130 { flimflam::kSaveCredentialsProperty, PROPERTY_INDEX_SAVE_CREDENTIALS }, | |
| 131 { flimflam::kScanningProperty, PROPERTY_INDEX_SCANNING }, | |
| 132 { flimflam::kSecurityProperty, PROPERTY_INDEX_SECURITY }, | |
| 133 { flimflam::kSelectedNetworkProperty, PROPERTY_INDEX_SELECTED_NETWORK }, | |
| 134 { flimflam::kServiceWatchListProperty, PROPERTY_INDEX_SERVICE_WATCH_LIST }, | |
| 135 { flimflam::kServicesProperty, PROPERTY_INDEX_SERVICES }, | |
| 136 { flimflam::kServingOperatorProperty, PROPERTY_INDEX_SERVING_OPERATOR }, | |
| 137 { flimflam::kSignalStrengthProperty, PROPERTY_INDEX_SIGNAL_STRENGTH }, | |
| 138 { flimflam::kStateProperty, PROPERTY_INDEX_STATE }, | |
| 139 { flimflam::kSupportNetworkScanProperty, | |
| 140 PROPERTY_INDEX_SUPPORT_NETWORK_SCAN }, | |
| 141 { shill::kSupportedCarriersProperty, PROPERTY_INDEX_SUPPORTED_CARRIERS}, | |
| 142 { flimflam::kTechnologyFamilyProperty, PROPERTY_INDEX_TECHNOLOGY_FAMILY }, | |
| 143 { flimflam::kTypeProperty, PROPERTY_INDEX_TYPE }, | |
| 144 { flimflam::kUIDataProperty, PROPERTY_INDEX_UI_DATA }, | |
| 145 { shill::kUninitializedTechnologiesProperty, | |
| 146 PROPERTY_INDEX_UNINITIALIZED_TECHNOLOGIES }, | |
| 147 { flimflam::kUsageURLProperty, PROPERTY_INDEX_USAGE_URL }, | |
| 148 { flimflam::kOpenVPNClientCertIdProperty, | |
| 149 PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_ID }, | |
| 150 { flimflam::kOpenVPNAuthProperty, PROPERTY_INDEX_OPEN_VPN_AUTH }, | |
| 151 { flimflam::kOpenVPNAuthRetryProperty, PROPERTY_INDEX_OPEN_VPN_AUTHRETRY }, | |
| 152 { flimflam::kOpenVPNAuthNoCacheProperty, | |
| 153 PROPERTY_INDEX_OPEN_VPN_AUTHNOCACHE }, | |
| 154 { flimflam::kOpenVPNAuthUserPassProperty, | |
| 155 PROPERTY_INDEX_OPEN_VPN_AUTHUSERPASS }, | |
| 156 { shill::kOpenVPNCaCertPemProperty, PROPERTY_INDEX_OPEN_VPN_CA_CERT_PEM }, | |
| 157 { flimflam::kOpenVPNClientCertSlotProperty, | |
| 158 PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_SLOT }, | |
| 159 { flimflam::kOpenVPNCipherProperty, PROPERTY_INDEX_OPEN_VPN_CIPHER }, | |
| 160 { flimflam::kOpenVPNCompLZOProperty, PROPERTY_INDEX_OPEN_VPN_COMPLZO }, | |
| 161 { flimflam::kOpenVPNCompNoAdaptProperty, | |
| 162 PROPERTY_INDEX_OPEN_VPN_COMPNOADAPT }, | |
| 163 { flimflam::kOpenVPNKeyDirectionProperty, | |
| 164 PROPERTY_INDEX_OPEN_VPN_KEYDIRECTION }, | |
| 165 { flimflam::kOpenVPNMgmtEnableProperty, | |
| 166 PROPERTY_INDEX_OPEN_VPN_MGMT_ENABLE }, | |
| 167 { flimflam::kOpenVPNNsCertTypeProperty, PROPERTY_INDEX_OPEN_VPN_NSCERTTYPE }, | |
| 168 { flimflam::kOpenVPNOTPProperty, PROPERTY_INDEX_OPEN_VPN_OTP }, | |
| 169 { flimflam::kOpenVPNPasswordProperty, PROPERTY_INDEX_OPEN_VPN_PASSWORD }, | |
| 170 { flimflam::kOpenVPNPinProperty, PROPERTY_INDEX_OPEN_VPN_PIN }, | |
| 171 { flimflam::kOpenVPNPortProperty, PROPERTY_INDEX_OPEN_VPN_PORT }, | |
| 172 { flimflam::kOpenVPNProtoProperty, PROPERTY_INDEX_OPEN_VPN_PROTO }, | |
| 173 { flimflam::kOpenVPNProviderProperty, | |
| 174 PROPERTY_INDEX_OPEN_VPN_PKCS11_PROVIDER }, | |
| 175 { flimflam::kOpenVPNPushPeerInfoProperty, | |
| 176 PROPERTY_INDEX_OPEN_VPN_PUSHPEERINFO }, | |
| 177 { flimflam::kOpenVPNRemoteCertEKUProperty, | |
| 178 PROPERTY_INDEX_OPEN_VPN_REMOTECERTEKU }, | |
| 179 { flimflam::kOpenVPNRemoteCertKUProperty, | |
| 180 PROPERTY_INDEX_OPEN_VPN_REMOTECERTKU }, | |
| 181 { flimflam::kOpenVPNRemoteCertTLSProperty, | |
| 182 PROPERTY_INDEX_OPEN_VPN_REMOTECERTTLS }, | |
| 183 { flimflam::kOpenVPNRenegSecProperty, PROPERTY_INDEX_OPEN_VPN_RENEGSEC }, | |
| 184 { flimflam::kOpenVPNServerPollTimeoutProperty, | |
| 185 PROPERTY_INDEX_OPEN_VPN_SERVERPOLLTIMEOUT }, | |
| 186 { flimflam::kOpenVPNShaperProperty, PROPERTY_INDEX_OPEN_VPN_SHAPER }, | |
| 187 { flimflam::kOpenVPNStaticChallengeProperty, | |
| 188 PROPERTY_INDEX_OPEN_VPN_STATICCHALLENGE }, | |
| 189 { flimflam::kOpenVPNTLSAuthContentsProperty, | |
| 190 PROPERTY_INDEX_OPEN_VPN_TLSAUTHCONTENTS }, | |
| 191 { flimflam::kOpenVPNTLSRemoteProperty, PROPERTY_INDEX_OPEN_VPN_TLSREMOTE }, | |
| 192 { flimflam::kOpenVPNUserProperty, PROPERTY_INDEX_OPEN_VPN_USER }, | |
| 193 { flimflam::kPaymentPortalProperty, PROPERTY_INDEX_OLP }, | |
| 194 { flimflam::kPaymentURLProperty, PROPERTY_INDEX_OLP_URL }, | |
| 195 { flimflam::kVPNDomainProperty, PROPERTY_INDEX_VPN_DOMAIN }, | |
| 196 { flimflam::kWifiAuthMode, PROPERTY_INDEX_WIFI_AUTH_MODE }, | |
| 197 { flimflam::kWifiBSsid, PROPERTY_INDEX_WIFI_BSSID }, | |
| 198 { flimflam::kWifiFrequency, PROPERTY_INDEX_WIFI_FREQUENCY }, | |
| 199 { flimflam::kWifiHexSsid, PROPERTY_INDEX_WIFI_HEX_SSID }, | |
| 200 { flimflam::kWifiHiddenSsid, PROPERTY_INDEX_WIFI_HIDDEN_SSID }, | |
| 201 { flimflam::kWifiPhyMode, PROPERTY_INDEX_WIFI_PHY_MODE }, | |
| 202 }; | |
| 203 | |
| 204 EnumMapper<ConnectionType>::Pair network_type_table[] = { | |
| 205 { flimflam::kTypeEthernet, TYPE_ETHERNET }, | |
| 206 { flimflam::kTypeWifi, TYPE_WIFI }, | |
| 207 { flimflam::kTypeWimax, TYPE_WIMAX }, | |
| 208 { flimflam::kTypeBluetooth, TYPE_BLUETOOTH }, | |
| 209 { flimflam::kTypeCellular, TYPE_CELLULAR }, | |
| 210 { flimflam::kTypeVPN, TYPE_VPN }, | |
| 211 }; | |
| 212 | |
| 213 EnumMapper<ConnectionSecurity>::Pair network_security_table[] = { | |
| 214 { flimflam::kSecurityNone, SECURITY_NONE }, | |
| 215 { flimflam::kSecurityWep, SECURITY_WEP }, | |
| 216 { flimflam::kSecurityWpa, SECURITY_WPA }, | |
| 217 { flimflam::kSecurityRsn, SECURITY_RSN }, | |
| 218 { flimflam::kSecurityPsk, SECURITY_PSK }, | |
| 219 { flimflam::kSecurity8021x, SECURITY_8021X }, | |
| 220 }; | |
| 221 | |
| 222 EnumMapper<EAPMethod>::Pair network_eap_method_table[] = { | |
| 223 { flimflam::kEapMethodPEAP, EAP_METHOD_PEAP }, | |
| 224 { flimflam::kEapMethodTLS, EAP_METHOD_TLS }, | |
| 225 { flimflam::kEapMethodTTLS, EAP_METHOD_TTLS }, | |
| 226 { flimflam::kEapMethodLEAP, EAP_METHOD_LEAP }, | |
| 227 }; | |
| 228 | |
| 229 EnumMapper<EAPPhase2Auth>::Pair network_eap_auth_table[] = { | |
| 230 { flimflam::kEapPhase2AuthPEAPMD5, EAP_PHASE_2_AUTH_MD5 }, | |
| 231 { flimflam::kEapPhase2AuthPEAPMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 }, | |
| 232 { flimflam::kEapPhase2AuthTTLSMD5, EAP_PHASE_2_AUTH_MD5 }, | |
| 233 { flimflam::kEapPhase2AuthTTLSMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 }, | |
| 234 { flimflam::kEapPhase2AuthTTLSMSCHAP, EAP_PHASE_2_AUTH_MSCHAP }, | |
| 235 { flimflam::kEapPhase2AuthTTLSPAP, EAP_PHASE_2_AUTH_PAP }, | |
| 236 { flimflam::kEapPhase2AuthTTLSCHAP, EAP_PHASE_2_AUTH_CHAP }, | |
| 237 }; | |
| 238 | |
| 239 EnumMapper<ProviderType>::Pair provider_type_table[] = { | |
| 240 { flimflam::kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK }, | |
| 241 { flimflam::kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN }, | |
| 242 }; | |
| 243 | |
| 244 // Serve the singleton mapper instance. | |
| 245 const EnumMapper<PropertyIndex>* get_native_mapper() { | |
| 246 CR_DEFINE_STATIC_LOCAL(EnumMapper<PropertyIndex>, mapper, | |
| 247 (property_index_table, | |
| 248 arraysize(property_index_table), | |
| 249 PROPERTY_INDEX_UNKNOWN)); | |
| 250 return &mapper; | |
| 251 } | |
| 252 | |
| 253 } // namespace | |
| 254 | |
| 255 // -------------------- NativeNetworkDeviceParser -------------------- | |
| 256 | |
| 257 NativeNetworkDeviceParser::NativeNetworkDeviceParser() | |
| 258 : NetworkDeviceParser(get_native_mapper()) { | |
| 259 } | |
| 260 | |
| 261 NativeNetworkDeviceParser::~NativeNetworkDeviceParser() { | |
| 262 } | |
| 263 | |
| 264 NetworkDevice* NativeNetworkDeviceParser::CreateNewNetworkDevice( | |
| 265 const std::string& device_path) { | |
| 266 NetworkDevice* device = | |
| 267 NetworkDeviceParser::CreateNewNetworkDevice(device_path); | |
| 268 device->SetNetworkDeviceParser(new NativeNetworkDeviceParser()); | |
| 269 return device; | |
| 270 } | |
| 271 | |
| 272 bool NativeNetworkDeviceParser::ParseValue( | |
| 273 PropertyIndex index, const base::Value& value, NetworkDevice* device) { | |
| 274 switch (index) { | |
| 275 case PROPERTY_INDEX_TYPE: { | |
| 276 std::string type_string; | |
| 277 if (value.GetAsString(&type_string)) { | |
| 278 device->set_type(ParseType(type_string)); | |
| 279 return true; | |
| 280 } | |
| 281 break; | |
| 282 } | |
| 283 case PROPERTY_INDEX_NAME: { | |
| 284 std::string name; | |
| 285 if (!value.GetAsString(&name)) | |
| 286 return false; | |
| 287 device->set_name(name); | |
| 288 return true; | |
| 289 } | |
| 290 case PROPERTY_INDEX_GUID: { | |
| 291 std::string unique_id; | |
| 292 if (!value.GetAsString(&unique_id)) | |
| 293 return false; | |
| 294 device->set_unique_id(unique_id); | |
| 295 return true; | |
| 296 } | |
| 297 case PROPERTY_INDEX_CARRIER: { | |
| 298 std::string carrier; | |
| 299 if (!value.GetAsString(&carrier)) | |
| 300 return false; | |
| 301 device->set_carrier(carrier); | |
| 302 return true; | |
| 303 } | |
| 304 case PROPERTY_INDEX_SCANNING: { | |
| 305 bool scanning; | |
| 306 if (!value.GetAsBoolean(&scanning)) | |
| 307 return false; | |
| 308 device->set_scanning(scanning); | |
| 309 return true; | |
| 310 } | |
| 311 case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: { | |
| 312 bool data_roaming_allowed; | |
| 313 if (!value.GetAsBoolean(&data_roaming_allowed)) | |
| 314 return false; | |
| 315 device->set_data_roaming_allowed(data_roaming_allowed); | |
| 316 return true; | |
| 317 } | |
| 318 case PROPERTY_INDEX_CELLULAR_APN_LIST: | |
| 319 if (value.IsType(base::Value::TYPE_LIST)) { | |
| 320 CellularApnList provider_apn_list; | |
| 321 if (!ParseApnList(static_cast<const ListValue&>(value), | |
| 322 &provider_apn_list)) | |
| 323 return false; | |
| 324 device->set_provider_apn_list(provider_apn_list); | |
| 325 return true; | |
| 326 } | |
| 327 break; | |
| 328 case PROPERTY_INDEX_NETWORKS: | |
| 329 if (value.IsType(base::Value::TYPE_LIST)) { | |
| 330 // Ignored. | |
| 331 return true; | |
| 332 } | |
| 333 break; | |
| 334 case PROPERTY_INDEX_FOUND_NETWORKS: | |
| 335 if (value.IsType(base::Value::TYPE_LIST)) { | |
| 336 CellularNetworkList found_cellular_networks; | |
| 337 if (!ParseFoundNetworksFromList( | |
| 338 static_cast<const ListValue&>(value), | |
| 339 &found_cellular_networks)) | |
| 340 return false; | |
| 341 device->set_found_cellular_networks(found_cellular_networks); | |
| 342 return true; | |
| 343 } | |
| 344 break; | |
| 345 case PROPERTY_INDEX_HOME_PROVIDER: { | |
| 346 if (value.IsType(base::Value::TYPE_DICTIONARY)) { | |
| 347 const DictionaryValue& dict = | |
| 348 static_cast<const DictionaryValue&>(value); | |
| 349 std::string home_provider_code; | |
| 350 std::string home_provider_country; | |
| 351 std::string home_provider_name; | |
| 352 dict.GetStringWithoutPathExpansion(flimflam::kOperatorCodeKey, | |
| 353 &home_provider_code); | |
| 354 dict.GetStringWithoutPathExpansion(flimflam::kOperatorCountryKey, | |
| 355 &home_provider_country); | |
| 356 dict.GetStringWithoutPathExpansion(flimflam::kOperatorNameKey, | |
| 357 &home_provider_name); | |
| 358 device->set_home_provider_code(home_provider_code); | |
| 359 device->set_home_provider_country(home_provider_country); | |
| 360 device->set_home_provider_name(home_provider_name); | |
| 361 if (!device->home_provider_name().empty() && | |
| 362 !device->home_provider_country().empty()) { | |
| 363 device->set_home_provider_id(base::StringPrintf( | |
| 364 kCarrierIdFormat, | |
| 365 device->home_provider_name().c_str(), | |
| 366 device->home_provider_country().c_str())); | |
| 367 } else { | |
| 368 device->set_home_provider_id(home_provider_code); | |
| 369 LOG(WARNING) << "Carrier ID not defined, using code instead: " | |
| 370 << device->home_provider_id(); | |
| 371 } | |
| 372 return true; | |
| 373 } | |
| 374 break; | |
| 375 } | |
| 376 case PROPERTY_INDEX_PROVIDER_REQUIRES_ROAMING: { | |
| 377 bool provider_requires_roaming; | |
| 378 if (!value.GetAsBoolean(&provider_requires_roaming)) | |
| 379 return false; | |
| 380 device->set_provider_requires_roaming(provider_requires_roaming); | |
| 381 return true; | |
| 382 } | |
| 383 case PROPERTY_INDEX_MEID: | |
| 384 case PROPERTY_INDEX_ICCID: | |
| 385 case PROPERTY_INDEX_IMEI: | |
| 386 case PROPERTY_INDEX_IMSI: | |
| 387 case PROPERTY_INDEX_ESN: | |
| 388 case PROPERTY_INDEX_MDN: | |
| 389 case PROPERTY_INDEX_MIN: | |
| 390 case PROPERTY_INDEX_MODEL_ID: | |
| 391 case PROPERTY_INDEX_MANUFACTURER: | |
| 392 case PROPERTY_INDEX_FIRMWARE_REVISION: | |
| 393 case PROPERTY_INDEX_HARDWARE_REVISION: | |
| 394 case PROPERTY_INDEX_SELECTED_NETWORK: { | |
| 395 std::string item; | |
| 396 if (!value.GetAsString(&item)) | |
| 397 return false; | |
| 398 switch (index) { | |
| 399 case PROPERTY_INDEX_MEID: | |
| 400 device->set_meid(item); | |
| 401 break; | |
| 402 case PROPERTY_INDEX_ICCID: | |
| 403 device->set_iccid(item); | |
| 404 break; | |
| 405 case PROPERTY_INDEX_IMEI: | |
| 406 device->set_imei(item); | |
| 407 break; | |
| 408 case PROPERTY_INDEX_IMSI: | |
| 409 device->set_imsi(item); | |
| 410 break; | |
| 411 case PROPERTY_INDEX_ESN: | |
| 412 device->set_esn(item); | |
| 413 break; | |
| 414 case PROPERTY_INDEX_MDN: | |
| 415 device->set_mdn(item); | |
| 416 break; | |
| 417 case PROPERTY_INDEX_MIN: | |
| 418 device->set_min(item); | |
| 419 break; | |
| 420 case PROPERTY_INDEX_MODEL_ID: | |
| 421 device->set_model_id(item); | |
| 422 break; | |
| 423 case PROPERTY_INDEX_MANUFACTURER: | |
| 424 device->set_manufacturer(item); | |
| 425 break; | |
| 426 case PROPERTY_INDEX_FIRMWARE_REVISION: | |
| 427 device->set_firmware_revision(item); | |
| 428 break; | |
| 429 case PROPERTY_INDEX_HARDWARE_REVISION: | |
| 430 device->set_hardware_revision(item); | |
| 431 break; | |
| 432 case PROPERTY_INDEX_SELECTED_NETWORK: | |
| 433 device->set_selected_cellular_network(item); | |
| 434 break; | |
| 435 default: | |
| 436 break; | |
| 437 } | |
| 438 return true; | |
| 439 } | |
| 440 case PROPERTY_INDEX_SIM_LOCK: | |
| 441 if (value.IsType(base::Value::TYPE_DICTIONARY)) { | |
| 442 SimLockState sim_lock_state; | |
| 443 int sim_retries_left; | |
| 444 bool sim_lock_enabled; | |
| 445 if (!ParseSimLockStateFromDictionary( | |
| 446 static_cast<const DictionaryValue&>(value), | |
| 447 &sim_lock_state, | |
| 448 &sim_retries_left, | |
| 449 &sim_lock_enabled)) | |
| 450 return false; | |
| 451 device->set_sim_lock_state(sim_lock_state); | |
| 452 device->set_sim_retries_left(sim_retries_left); | |
| 453 if (sim_lock_enabled) | |
| 454 device->set_sim_pin_required(SIM_PIN_REQUIRED); | |
| 455 else | |
| 456 device->set_sim_pin_required(SIM_PIN_NOT_REQUIRED); | |
| 457 return true; | |
| 458 } | |
| 459 break; | |
| 460 case PROPERTY_INDEX_SIM_PRESENT: { | |
| 461 bool sim_present; | |
| 462 if (!value.GetAsBoolean(&sim_present)) | |
| 463 return false; | |
| 464 device->set_sim_present(sim_present); | |
| 465 return true; | |
| 466 } | |
| 467 case PROPERTY_INDEX_POWERED: { | |
| 468 bool powered; | |
| 469 if (!value.GetAsBoolean(&powered)) | |
| 470 return false; | |
| 471 device->set_powered(powered); | |
| 472 return true; | |
| 473 } | |
| 474 case PROPERTY_INDEX_PRL_VERSION: { | |
| 475 int prl_version; | |
| 476 if (!value.GetAsInteger(&prl_version)) | |
| 477 return false; | |
| 478 device->set_prl_version(prl_version); | |
| 479 return true; | |
| 480 } | |
| 481 case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN: { | |
| 482 bool support_network_scan; | |
| 483 if (!value.GetAsBoolean(&support_network_scan)) | |
| 484 return false; | |
| 485 device->set_support_network_scan(support_network_scan); | |
| 486 return true; | |
| 487 } | |
| 488 case PROPERTY_INDEX_SUPPORTED_CARRIERS: { | |
| 489 if (value.IsType(base::Value::TYPE_LIST)) { | |
| 490 device->set_supported_carriers(static_cast<const ListValue&>(value)); | |
| 491 return true; | |
| 492 } | |
| 493 break; | |
| 494 } | |
| 495 case PROPERTY_INDEX_TECHNOLOGY_FAMILY: { | |
| 496 std::string technology_family_string; | |
| 497 if (value.GetAsString(&technology_family_string)) { | |
| 498 device->set_technology_family( | |
| 499 ParseTechnologyFamily(technology_family_string)); | |
| 500 return true; | |
| 501 } | |
| 502 break; | |
| 503 } | |
| 504 default: | |
| 505 break; | |
| 506 } | |
| 507 return false; | |
| 508 } | |
| 509 | |
| 510 ConnectionType NativeNetworkDeviceParser::ParseType(const std::string& type) { | |
| 511 return NativeNetworkParser::network_type_mapper()->Get(type); | |
| 512 } | |
| 513 | |
| 514 bool NativeNetworkDeviceParser::ParseApnList(const ListValue& list, | |
| 515 CellularApnList* apn_list) { | |
| 516 apn_list->clear(); | |
| 517 apn_list->reserve(list.GetSize()); | |
| 518 for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) { | |
| 519 if ((*it)->IsType(base::Value::TYPE_DICTIONARY)) { | |
| 520 apn_list->resize(apn_list->size() + 1); | |
| 521 const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); | |
| 522 dict->GetStringWithoutPathExpansion( | |
| 523 flimflam::kApnProperty, &apn_list->back().apn); | |
| 524 dict->GetStringWithoutPathExpansion( | |
| 525 flimflam::kApnNetworkIdProperty, &apn_list->back().network_id); | |
| 526 dict->GetStringWithoutPathExpansion( | |
| 527 flimflam::kApnUsernameProperty, &apn_list->back().username); | |
| 528 dict->GetStringWithoutPathExpansion( | |
| 529 flimflam::kApnPasswordProperty, &apn_list->back().password); | |
| 530 dict->GetStringWithoutPathExpansion( | |
| 531 flimflam::kApnNameProperty, &apn_list->back().name); | |
| 532 dict->GetStringWithoutPathExpansion( | |
| 533 flimflam::kApnLocalizedNameProperty, | |
| 534 &apn_list->back().localized_name); | |
| 535 dict->GetStringWithoutPathExpansion( | |
| 536 flimflam::kApnLanguageProperty, &apn_list->back().language); | |
| 537 } else { | |
| 538 return false; | |
| 539 } | |
| 540 } | |
| 541 return true; | |
| 542 } | |
| 543 | |
| 544 bool NativeNetworkDeviceParser::ParseFoundNetworksFromList( | |
| 545 const ListValue& list, | |
| 546 CellularNetworkList* found_networks) { | |
| 547 found_networks->clear(); | |
| 548 found_networks->reserve(list.GetSize()); | |
| 549 for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) { | |
| 550 if ((*it)->IsType(base::Value::TYPE_DICTIONARY)) { | |
| 551 found_networks->resize(found_networks->size() + 1); | |
| 552 const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it); | |
| 553 dict->GetStringWithoutPathExpansion( | |
| 554 flimflam::kStatusProperty, &found_networks->back().status); | |
| 555 dict->GetStringWithoutPathExpansion( | |
| 556 flimflam::kNetworkIdProperty, &found_networks->back().network_id); | |
| 557 dict->GetStringWithoutPathExpansion( | |
| 558 flimflam::kShortNameProperty, &found_networks->back().short_name); | |
| 559 dict->GetStringWithoutPathExpansion( | |
| 560 flimflam::kLongNameProperty, &found_networks->back().long_name); | |
| 561 dict->GetStringWithoutPathExpansion( | |
| 562 flimflam::kTechnologyProperty, &found_networks->back().technology); | |
| 563 } else { | |
| 564 return false; | |
| 565 } | |
| 566 } | |
| 567 return true; | |
| 568 } | |
| 569 | |
| 570 SimLockState NativeNetworkDeviceParser::ParseSimLockState( | |
| 571 const std::string& state) { | |
| 572 static EnumMapper<SimLockState>::Pair table[] = { | |
| 573 { "", SIM_UNLOCKED }, | |
| 574 { flimflam::kSIMLockPin, SIM_LOCKED_PIN }, | |
| 575 { flimflam::kSIMLockPuk, SIM_LOCKED_PUK }, | |
| 576 }; | |
| 577 CR_DEFINE_STATIC_LOCAL(EnumMapper<SimLockState>, parser, | |
| 578 (table, arraysize(table), SIM_UNKNOWN)); | |
| 579 SimLockState parsed_state = parser.Get(state); | |
| 580 DCHECK(parsed_state != SIM_UNKNOWN) << "Unknown SIMLock state encountered"; | |
| 581 return parsed_state; | |
| 582 } | |
| 583 | |
| 584 bool NativeNetworkDeviceParser::ParseSimLockStateFromDictionary( | |
| 585 const DictionaryValue& info, | |
| 586 SimLockState* out_state, | |
| 587 int* out_retries, | |
| 588 bool* out_enabled) { | |
| 589 std::string state_string; | |
| 590 // Since RetriesLeft is sent as a uint32, which may overflow int32 range, from | |
| 591 // Shill, it may be stored as an integer or a double in DictionaryValue. | |
| 592 const base::Value* retries_value = NULL; | |
| 593 if (!info.GetString(flimflam::kSIMLockTypeProperty, &state_string) || | |
| 594 !info.GetBoolean(flimflam::kSIMLockEnabledProperty, out_enabled) || | |
| 595 !info.Get(flimflam::kSIMLockRetriesLeftProperty, &retries_value) || | |
| 596 (retries_value->GetType() != base::Value::TYPE_INTEGER && | |
| 597 retries_value->GetType() != base::Value::TYPE_DOUBLE)) { | |
| 598 LOG(ERROR) << "Error parsing SIMLock state"; | |
| 599 return false; | |
| 600 } | |
| 601 *out_state = ParseSimLockState(state_string); | |
| 602 if (retries_value->GetType() == base::Value::TYPE_INTEGER) { | |
| 603 retries_value->GetAsInteger(out_retries); | |
| 604 } else if (retries_value->GetType() == base::Value::TYPE_DOUBLE) { | |
| 605 double retries_double = 0; | |
| 606 retries_value->GetAsDouble(&retries_double); | |
| 607 *out_retries = retries_double; | |
| 608 } | |
| 609 return true; | |
| 610 } | |
| 611 | |
| 612 TechnologyFamily NativeNetworkDeviceParser::ParseTechnologyFamily( | |
| 613 const std::string& technology_family) { | |
| 614 static EnumMapper<TechnologyFamily>::Pair table[] = { | |
| 615 { flimflam::kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA }, | |
| 616 { flimflam::kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM }, | |
| 617 }; | |
| 618 CR_DEFINE_STATIC_LOCAL(EnumMapper<TechnologyFamily>, parser, | |
| 619 (table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN)); | |
| 620 return parser.Get(technology_family); | |
| 621 } | |
| 622 | |
| 623 // -------------------- NativeNetworkParser -------------------- | |
| 624 | |
| 625 NativeNetworkParser::NativeNetworkParser() | |
| 626 : NetworkParser(get_native_mapper()) { | |
| 627 } | |
| 628 | |
| 629 NativeNetworkParser::~NativeNetworkParser() { | |
| 630 } | |
| 631 | |
| 632 // static | |
| 633 const EnumMapper<PropertyIndex>* NativeNetworkParser::property_mapper() { | |
| 634 return get_native_mapper(); | |
| 635 } | |
| 636 | |
| 637 // static | |
| 638 const EnumMapper<ConnectionType>* NativeNetworkParser::network_type_mapper() { | |
| 639 CR_DEFINE_STATIC_LOCAL( | |
| 640 EnumMapper<ConnectionType>, | |
| 641 network_type_mapper, | |
| 642 (network_type_table, arraysize(network_type_table), TYPE_UNKNOWN)); | |
| 643 return &network_type_mapper; | |
| 644 } | |
| 645 | |
| 646 // static | |
| 647 const EnumMapper<ConnectionSecurity>* | |
| 648 NativeNetworkParser::network_security_mapper() { | |
| 649 CR_DEFINE_STATIC_LOCAL( | |
| 650 EnumMapper<ConnectionSecurity>, | |
| 651 network_security_mapper, | |
| 652 (network_security_table, arraysize(network_security_table), | |
| 653 SECURITY_UNKNOWN)); | |
| 654 return &network_security_mapper; | |
| 655 } | |
| 656 | |
| 657 // static | |
| 658 const EnumMapper<EAPMethod>* NativeNetworkParser::network_eap_method_mapper() { | |
| 659 CR_DEFINE_STATIC_LOCAL( | |
| 660 EnumMapper<EAPMethod>, | |
| 661 network_eap_method_mapper, | |
| 662 (network_eap_method_table, arraysize(network_eap_method_table), | |
| 663 EAP_METHOD_UNKNOWN)); | |
| 664 return &network_eap_method_mapper; | |
| 665 } | |
| 666 | |
| 667 // static | |
| 668 const EnumMapper<EAPPhase2Auth>* | |
| 669 NativeNetworkParser::network_eap_auth_mapper() { | |
| 670 CR_DEFINE_STATIC_LOCAL( | |
| 671 EnumMapper<EAPPhase2Auth>, | |
| 672 network_eap_auth_mapper, | |
| 673 (network_eap_auth_table, arraysize(network_eap_auth_table), | |
| 674 EAP_PHASE_2_AUTH_AUTO)); | |
| 675 return &network_eap_auth_mapper; | |
| 676 } | |
| 677 | |
| 678 const ConnectionType NativeNetworkParser::ParseConnectionType( | |
| 679 const std::string& connection_type) { | |
| 680 return network_type_mapper()->Get(connection_type); | |
| 681 } | |
| 682 | |
| 683 Network* NativeNetworkParser::CreateNewNetwork( | |
| 684 ConnectionType type, const std::string& service_path) { | |
| 685 Network* network = NetworkParser::CreateNewNetwork(type, service_path); | |
| 686 if (network) { | |
| 687 if (type == TYPE_ETHERNET) | |
| 688 network->SetNetworkParser(new NativeEthernetNetworkParser()); | |
| 689 else if (type == TYPE_WIFI) | |
| 690 network->SetNetworkParser(new NativeWifiNetworkParser()); | |
| 691 else if (type == TYPE_WIMAX) | |
| 692 network->SetNetworkParser(new NativeWimaxNetworkParser()); | |
| 693 else if (type == TYPE_CELLULAR) | |
| 694 network->SetNetworkParser(new NativeCellularNetworkParser()); | |
| 695 else if (type == TYPE_VPN) | |
| 696 network->SetNetworkParser(new NativeVirtualNetworkParser()); | |
| 697 } | |
| 698 return network; | |
| 699 } | |
| 700 | |
| 701 bool NativeNetworkParser::ParseValue(PropertyIndex index, | |
| 702 const base::Value& value, | |
| 703 Network* network) { | |
| 704 switch (index) { | |
| 705 case PROPERTY_INDEX_TYPE: { | |
| 706 std::string type_string; | |
| 707 if (value.GetAsString(&type_string)) { | |
| 708 ConnectionType type = ParseType(type_string); | |
| 709 LOG_IF(ERROR, type != network->type()) | |
| 710 << "Network with mismatched type: " << network->service_path() | |
| 711 << " " << type << " != " << network->type(); | |
| 712 return true; | |
| 713 } | |
| 714 break; | |
| 715 } | |
| 716 case PROPERTY_INDEX_DEVICE: { | |
| 717 std::string device_path; | |
| 718 if (!value.GetAsString(&device_path)) | |
| 719 return false; | |
| 720 network->set_device_path(device_path); | |
| 721 return true; | |
| 722 } | |
| 723 case PROPERTY_INDEX_PROFILE: { | |
| 724 // Note: currently this is only provided for non remembered networks. | |
| 725 std::string profile_path; | |
| 726 if (!value.GetAsString(&profile_path)) | |
| 727 return false; | |
| 728 network->set_profile_path(profile_path); | |
| 729 return true; | |
| 730 } | |
| 731 case PROPERTY_INDEX_STATE: { | |
| 732 std::string state_string; | |
| 733 if (value.GetAsString(&state_string)) { | |
| 734 network->SetState(ParseState(state_string)); | |
| 735 return true; | |
| 736 } | |
| 737 break; | |
| 738 } | |
| 739 case PROPERTY_INDEX_ERROR: { | |
| 740 std::string error_string; | |
| 741 if (value.GetAsString(&error_string)) { | |
| 742 network->SetError(ParseError(error_string)); | |
| 743 return true; | |
| 744 } | |
| 745 break; | |
| 746 } | |
| 747 case PROPERTY_INDEX_CONNECTABLE: { | |
| 748 bool connectable; | |
| 749 if (!value.GetAsBoolean(&connectable)) | |
| 750 return false; | |
| 751 network->set_connectable(connectable); | |
| 752 return true; | |
| 753 } | |
| 754 case PROPERTY_INDEX_IS_ACTIVE: { | |
| 755 bool is_active; | |
| 756 if (!value.GetAsBoolean(&is_active)) | |
| 757 return false; | |
| 758 network->set_is_active(is_active); | |
| 759 return true; | |
| 760 } | |
| 761 case PROPERTY_INDEX_FAVORITE: | |
| 762 // This property is ignored. | |
| 763 return true; | |
| 764 case PROPERTY_INDEX_SAVE_CREDENTIALS: { | |
| 765 bool save_credentials; | |
| 766 if (!value.GetAsBoolean(&save_credentials)) | |
| 767 return false; | |
| 768 network->set_save_credentials(save_credentials); | |
| 769 return true; | |
| 770 } | |
| 771 case PROPERTY_INDEX_CHECK_PORTAL: | |
| 772 // This property is ignored. | |
| 773 return true; | |
| 774 default: | |
| 775 return NetworkParser::ParseValue(index, value, network); | |
| 776 break; | |
| 777 } | |
| 778 return false; | |
| 779 } | |
| 780 | |
| 781 ConnectionType NativeNetworkParser::ParseType(const std::string& type) { | |
| 782 return network_type_mapper()->Get(type); | |
| 783 } | |
| 784 | |
| 785 ConnectionType NativeNetworkParser::ParseTypeFromDictionary( | |
| 786 const DictionaryValue& info) { | |
| 787 std::string type_string; | |
| 788 info.GetString(flimflam::kTypeProperty, &type_string); | |
| 789 return ParseType(type_string); | |
| 790 } | |
| 791 | |
| 792 ConnectionState NativeNetworkParser::ParseState(const std::string& state) { | |
| 793 static EnumMapper<ConnectionState>::Pair table[] = { | |
| 794 { flimflam::kStateIdle, STATE_IDLE }, | |
| 795 { flimflam::kStateCarrier, STATE_CARRIER }, | |
| 796 { flimflam::kStateAssociation, STATE_ASSOCIATION }, | |
| 797 { flimflam::kStateConfiguration, STATE_CONFIGURATION }, | |
| 798 { flimflam::kStateReady, STATE_READY }, | |
| 799 { flimflam::kStateDisconnect, STATE_DISCONNECT }, | |
| 800 { flimflam::kStateFailure, STATE_FAILURE }, | |
| 801 { flimflam::kStateActivationFailure, STATE_ACTIVATION_FAILURE }, | |
| 802 { flimflam::kStatePortal, STATE_PORTAL }, | |
| 803 { flimflam::kStateOnline, STATE_ONLINE }, | |
| 804 }; | |
| 805 CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionState>, parser, | |
| 806 (table, arraysize(table), STATE_UNKNOWN)); | |
| 807 return parser.Get(state); | |
| 808 } | |
| 809 | |
| 810 ConnectionError NativeNetworkParser::ParseError(const std::string& error) { | |
| 811 static EnumMapper<ConnectionError>::Pair table[] = { | |
| 812 { flimflam::kErrorOutOfRange, ERROR_OUT_OF_RANGE }, | |
| 813 { flimflam::kErrorPinMissing, ERROR_PIN_MISSING }, | |
| 814 { flimflam::kErrorDhcpFailed, ERROR_DHCP_FAILED }, | |
| 815 { flimflam::kErrorConnectFailed, ERROR_CONNECT_FAILED }, | |
| 816 { flimflam::kErrorBadPassphrase, ERROR_BAD_PASSPHRASE }, | |
| 817 { flimflam::kErrorBadWEPKey, ERROR_BAD_WEPKEY }, | |
| 818 { flimflam::kErrorActivationFailed, ERROR_ACTIVATION_FAILED }, | |
| 819 { flimflam::kErrorNeedEvdo, ERROR_NEED_EVDO }, | |
| 820 { flimflam::kErrorNeedHomeNetwork, ERROR_NEED_HOME_NETWORK }, | |
| 821 { flimflam::kErrorOtaspFailed, ERROR_OTASP_FAILED }, | |
| 822 { flimflam::kErrorAaaFailed, ERROR_AAA_FAILED }, | |
| 823 { flimflam::kErrorInternal, ERROR_INTERNAL }, | |
| 824 { flimflam::kErrorDNSLookupFailed, ERROR_DNS_LOOKUP_FAILED }, | |
| 825 { flimflam::kErrorHTTPGetFailed, ERROR_HTTP_GET_FAILED }, | |
| 826 { flimflam::kErrorIpsecPskAuthFailed, ERROR_IPSEC_PSK_AUTH_FAILED }, | |
| 827 { flimflam::kErrorIpsecCertAuthFailed, ERROR_IPSEC_CERT_AUTH_FAILED }, | |
| 828 { flimflam::kErrorPppAuthFailed, ERROR_PPP_AUTH_FAILED }, | |
| 829 { shill::kErrorEapAuthenticationFailed, ERROR_EAP_AUTHENTICATION_FAILED }, | |
| 830 { shill::kErrorEapLocalTlsFailed, ERROR_EAP_LOCAL_TLS_FAILED }, | |
| 831 { shill::kErrorEapRemoteTlsFailed, ERROR_EAP_REMOTE_TLS_FAILED }, | |
| 832 }; | |
| 833 CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionError>, parser, | |
| 834 (table, arraysize(table), ERROR_NO_ERROR)); | |
| 835 return parser.Get(error); | |
| 836 } | |
| 837 | |
| 838 // -------------------- NativeEthernetNetworkParser -------------------- | |
| 839 | |
| 840 NativeEthernetNetworkParser::NativeEthernetNetworkParser() {} | |
| 841 NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {} | |
| 842 | |
| 843 // -------------------- NativeWirelessNetworkParser -------------------- | |
| 844 | |
| 845 NativeWirelessNetworkParser::NativeWirelessNetworkParser() {} | |
| 846 NativeWirelessNetworkParser::~NativeWirelessNetworkParser() {} | |
| 847 | |
| 848 bool NativeWirelessNetworkParser::ParseValue(PropertyIndex index, | |
| 849 const base::Value& value, | |
| 850 Network* network) { | |
| 851 CHECK(network->type() == TYPE_WIFI || | |
| 852 network->type() == TYPE_WIMAX || | |
| 853 network->type() == TYPE_BLUETOOTH || | |
| 854 network->type() == TYPE_CELLULAR); | |
| 855 WirelessNetwork* wireless_network = static_cast<WirelessNetwork*>(network); | |
| 856 switch (index) { | |
| 857 case PROPERTY_INDEX_SIGNAL_STRENGTH: { | |
| 858 int strength; | |
| 859 if (!value.GetAsInteger(&strength)) | |
| 860 return false; | |
| 861 wireless_network->set_strength(strength); | |
| 862 return true; | |
| 863 } | |
| 864 default: | |
| 865 return NativeNetworkParser::ParseValue(index, value, network); | |
| 866 break; | |
| 867 } | |
| 868 return false; | |
| 869 } | |
| 870 | |
| 871 // -------------------- NativeCellularNetworkParser -------------------- | |
| 872 | |
| 873 NativeCellularNetworkParser::NativeCellularNetworkParser() {} | |
| 874 NativeCellularNetworkParser::~NativeCellularNetworkParser() {} | |
| 875 | |
| 876 bool NativeCellularNetworkParser::ParseValue(PropertyIndex index, | |
| 877 const base::Value& value, | |
| 878 Network* network) { | |
| 879 CHECK_EQ(TYPE_CELLULAR, network->type()); | |
| 880 CellularNetwork* cellular_network = static_cast<CellularNetwork*>(network); | |
| 881 switch (index) { | |
| 882 case PROPERTY_INDEX_ACTIVATE_OVER_NON_CELLULAR_NETWORK: { | |
| 883 bool activate_over_non_cellular_network; | |
| 884 if (value.GetAsBoolean(&activate_over_non_cellular_network)) { | |
| 885 cellular_network->set_activate_over_non_cellular_network( | |
| 886 activate_over_non_cellular_network); | |
| 887 return true; | |
| 888 } | |
| 889 break; | |
| 890 } | |
| 891 case PROPERTY_INDEX_ACTIVATION_STATE: { | |
| 892 std::string activation_state_string; | |
| 893 if (value.GetAsString(&activation_state_string)) { | |
| 894 cellular_network->set_activation_state( | |
| 895 ParseActivationState(activation_state_string)); | |
| 896 return true; | |
| 897 } | |
| 898 break; | |
| 899 } | |
| 900 case PROPERTY_INDEX_CELLULAR_APN: { | |
| 901 if (value.IsType(base::Value::TYPE_DICTIONARY)) { | |
| 902 cellular_network->set_apn(static_cast<const DictionaryValue&>(value)); | |
| 903 return true; | |
| 904 } | |
| 905 break; | |
| 906 } | |
| 907 case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: { | |
| 908 if (value.IsType(base::Value::TYPE_DICTIONARY)) { | |
| 909 cellular_network->set_last_good_apn( | |
| 910 static_cast<const DictionaryValue&>(value)); | |
| 911 return true; | |
| 912 } | |
| 913 break; | |
| 914 } | |
| 915 case PROPERTY_INDEX_NETWORK_TECHNOLOGY: { | |
| 916 std::string network_technology_string; | |
| 917 if (value.GetAsString(&network_technology_string)) { | |
| 918 cellular_network->set_network_technology( | |
| 919 ParseNetworkTechnology(network_technology_string)); | |
| 920 return true; | |
| 921 } | |
| 922 break; | |
| 923 } | |
| 924 case PROPERTY_INDEX_ROAMING_STATE: { | |
| 925 std::string roaming_state_string; | |
| 926 if (value.GetAsString(&roaming_state_string)) { | |
| 927 cellular_network->set_roaming_state( | |
| 928 ParseRoamingState(roaming_state_string)); | |
| 929 return true; | |
| 930 } | |
| 931 break; | |
| 932 } | |
| 933 case PROPERTY_INDEX_OPERATOR_NAME: { | |
| 934 std::string value_str; | |
| 935 if (!value.GetAsString(&value_str)) | |
| 936 break; | |
| 937 cellular_network->set_operator_name(value_str); | |
| 938 return true; | |
| 939 } | |
| 940 case PROPERTY_INDEX_OPERATOR_CODE: { | |
| 941 std::string value_str; | |
| 942 if (!value.GetAsString(&value_str)) | |
| 943 break; | |
| 944 cellular_network->set_operator_code(value_str); | |
| 945 return true; | |
| 946 } | |
| 947 case PROPERTY_INDEX_OUT_OF_CREDITS: { | |
| 948 bool out_of_credits; | |
| 949 if (value.GetAsBoolean(&out_of_credits)) { | |
| 950 cellular_network->set_out_of_credits(out_of_credits); | |
| 951 return true; | |
| 952 } | |
| 953 break; | |
| 954 } | |
| 955 case PROPERTY_INDEX_SERVING_OPERATOR: { | |
| 956 if (value.IsType(base::Value::TYPE_DICTIONARY)) { | |
| 957 const DictionaryValue& dict = | |
| 958 static_cast<const DictionaryValue&>(value); | |
| 959 std::string value_str; | |
| 960 dict.GetStringWithoutPathExpansion( | |
| 961 flimflam::kOperatorNameKey, &value_str); | |
| 962 cellular_network->set_operator_name(value_str); | |
| 963 value_str.clear(); | |
| 964 dict.GetStringWithoutPathExpansion( | |
| 965 flimflam::kOperatorCodeKey, &value_str); | |
| 966 cellular_network->set_operator_code(value_str); | |
| 967 value_str.clear(); | |
| 968 dict.GetStringWithoutPathExpansion( | |
| 969 flimflam::kOperatorCountryKey, &value_str); | |
| 970 cellular_network->set_operator_country(value_str); | |
| 971 return true; | |
| 972 } | |
| 973 break; | |
| 974 } | |
| 975 case PROPERTY_INDEX_USAGE_URL: { | |
| 976 std::string value_str; | |
| 977 if (!value.GetAsString(&value_str)) | |
| 978 break; | |
| 979 cellular_network->set_usage_url(value_str); | |
| 980 return true; | |
| 981 } | |
| 982 case PROPERTY_INDEX_OLP: { | |
| 983 if (value.IsType(base::Value::TYPE_DICTIONARY)) { | |
| 984 const DictionaryValue& dict = | |
| 985 static_cast<const DictionaryValue&>(value); | |
| 986 std::string portal_url; | |
| 987 std::string method; | |
| 988 std::string postdata; | |
| 989 dict.GetStringWithoutPathExpansion(flimflam::kPaymentPortalURL, | |
| 990 &portal_url); | |
| 991 dict.GetStringWithoutPathExpansion(flimflam::kPaymentPortalMethod, | |
| 992 &method); | |
| 993 dict.GetStringWithoutPathExpansion(flimflam::kPaymentPortalPostData, | |
| 994 &postdata); | |
| 995 cellular_network->set_payment_url(portal_url); | |
| 996 cellular_network->set_post_data(postdata); | |
| 997 cellular_network->set_using_post( | |
| 998 LowerCaseEqualsASCII(method, kPostMethod)); | |
| 999 return true; | |
| 1000 } | |
| 1001 break; | |
| 1002 } | |
| 1003 case PROPERTY_INDEX_OLP_URL: | |
| 1004 // This property is ignored. | |
| 1005 return true; | |
| 1006 case PROPERTY_INDEX_STATE: { | |
| 1007 if (NativeWirelessNetworkParser::ParseValue(index, value, network)) | |
| 1008 return true; | |
| 1009 break; | |
| 1010 } | |
| 1011 default: | |
| 1012 return NativeWirelessNetworkParser::ParseValue(index, value, network); | |
| 1013 } | |
| 1014 return false; | |
| 1015 } | |
| 1016 | |
| 1017 ActivationState NativeCellularNetworkParser::ParseActivationState( | |
| 1018 const std::string& state) { | |
| 1019 static EnumMapper<ActivationState>::Pair table[] = { | |
| 1020 { flimflam::kActivationStateActivated, ACTIVATION_STATE_ACTIVATED }, | |
| 1021 { flimflam::kActivationStateActivating, ACTIVATION_STATE_ACTIVATING }, | |
| 1022 { flimflam::kActivationStateNotActivated, ACTIVATION_STATE_NOT_ACTIVATED }, | |
| 1023 { flimflam::kActivationStatePartiallyActivated, | |
| 1024 ACTIVATION_STATE_PARTIALLY_ACTIVATED}, | |
| 1025 { flimflam::kActivationStateUnknown, ACTIVATION_STATE_UNKNOWN}, | |
| 1026 }; | |
| 1027 CR_DEFINE_STATIC_LOCAL(EnumMapper<ActivationState>, parser, | |
| 1028 (table, arraysize(table), ACTIVATION_STATE_UNKNOWN)); | |
| 1029 return parser.Get(state); | |
| 1030 } | |
| 1031 | |
| 1032 NetworkTechnology NativeCellularNetworkParser::ParseNetworkTechnology( | |
| 1033 const std::string& technology) { | |
| 1034 static EnumMapper<NetworkTechnology>::Pair table[] = { | |
| 1035 { flimflam::kNetworkTechnology1Xrtt, NETWORK_TECHNOLOGY_1XRTT }, | |
| 1036 { flimflam::kNetworkTechnologyEvdo, NETWORK_TECHNOLOGY_EVDO }, | |
| 1037 { flimflam::kNetworkTechnologyGprs, NETWORK_TECHNOLOGY_GPRS }, | |
| 1038 { flimflam::kNetworkTechnologyEdge, NETWORK_TECHNOLOGY_EDGE }, | |
| 1039 { flimflam::kNetworkTechnologyUmts, NETWORK_TECHNOLOGY_UMTS }, | |
| 1040 { flimflam::kNetworkTechnologyHspa, NETWORK_TECHNOLOGY_HSPA }, | |
| 1041 { flimflam::kNetworkTechnologyHspaPlus, NETWORK_TECHNOLOGY_HSPA_PLUS }, | |
| 1042 { flimflam::kNetworkTechnologyLte, NETWORK_TECHNOLOGY_LTE }, | |
| 1043 { flimflam::kNetworkTechnologyLteAdvanced, | |
| 1044 NETWORK_TECHNOLOGY_LTE_ADVANCED }, | |
| 1045 { flimflam::kNetworkTechnologyGsm, NETWORK_TECHNOLOGY_GSM }, | |
| 1046 }; | |
| 1047 CR_DEFINE_STATIC_LOCAL(EnumMapper<NetworkTechnology>, parser, | |
| 1048 (table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN)); | |
| 1049 return parser.Get(technology); | |
| 1050 } | |
| 1051 | |
| 1052 NetworkRoamingState NativeCellularNetworkParser::ParseRoamingState( | |
| 1053 const std::string& roaming_state) { | |
| 1054 static EnumMapper<NetworkRoamingState>::Pair table[] = { | |
| 1055 { flimflam::kRoamingStateHome, ROAMING_STATE_HOME }, | |
| 1056 { flimflam::kRoamingStateRoaming, ROAMING_STATE_ROAMING }, | |
| 1057 { flimflam::kRoamingStateUnknown, ROAMING_STATE_UNKNOWN }, | |
| 1058 }; | |
| 1059 CR_DEFINE_STATIC_LOCAL(EnumMapper<NetworkRoamingState>, parser, | |
| 1060 (table, arraysize(table), ROAMING_STATE_UNKNOWN)); | |
| 1061 return parser.Get(roaming_state); | |
| 1062 } | |
| 1063 | |
| 1064 // -------------------- NativeWimaxNetworkParser -------------------- | |
| 1065 | |
| 1066 NativeWimaxNetworkParser::NativeWimaxNetworkParser() {} | |
| 1067 NativeWimaxNetworkParser::~NativeWimaxNetworkParser() {} | |
| 1068 | |
| 1069 | |
| 1070 bool NativeWimaxNetworkParser::ParseValue(PropertyIndex index, | |
| 1071 const base::Value& value, | |
| 1072 Network* network) { | |
| 1073 CHECK_EQ(TYPE_WIMAX, network->type()); | |
| 1074 WimaxNetwork* wimax_network = static_cast<WimaxNetwork*>(network); | |
| 1075 switch (index) { | |
| 1076 case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { | |
| 1077 bool passphrase_required; | |
| 1078 if (!value.GetAsBoolean(&passphrase_required)) | |
| 1079 break; | |
| 1080 wimax_network->set_passphrase_required(passphrase_required); | |
| 1081 return true; | |
| 1082 } | |
| 1083 case PROPERTY_INDEX_EAP_IDENTITY: { | |
| 1084 std::string eap_identity; | |
| 1085 if (!value.GetAsString(&eap_identity)) | |
| 1086 break; | |
| 1087 | |
| 1088 wimax_network->set_eap_identity(eap_identity); | |
| 1089 } | |
| 1090 case PROPERTY_INDEX_EAP_PASSWORD: { | |
| 1091 std::string passphrase; | |
| 1092 if (!value.GetAsString(&passphrase)) | |
| 1093 break; | |
| 1094 | |
| 1095 wimax_network->set_eap_passphrase(passphrase); | |
| 1096 return true; | |
| 1097 } | |
| 1098 default: | |
| 1099 return NativeWirelessNetworkParser::ParseValue(index, value, network); | |
| 1100 } | |
| 1101 return false; | |
| 1102 } | |
| 1103 | |
| 1104 // -------------------- NativeWifiNetworkParser -------------------- | |
| 1105 | |
| 1106 NativeWifiNetworkParser::NativeWifiNetworkParser() {} | |
| 1107 NativeWifiNetworkParser::~NativeWifiNetworkParser() {} | |
| 1108 | |
| 1109 bool NativeWifiNetworkParser::ParseValue(PropertyIndex index, | |
| 1110 const base::Value& value, | |
| 1111 Network* network) { | |
| 1112 CHECK_EQ(TYPE_WIFI, network->type()); | |
| 1113 WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network); | |
| 1114 switch (index) { | |
| 1115 case PROPERTY_INDEX_WIFI_HEX_SSID: { | |
| 1116 std::string ssid_hex; | |
| 1117 if (!value.GetAsString(&ssid_hex)) | |
| 1118 return false; | |
| 1119 wifi_network->SetHexSsid(ssid_hex); | |
| 1120 return true; | |
| 1121 } | |
| 1122 case PROPERTY_INDEX_WIFI_BSSID: { | |
| 1123 std::string bssid; | |
| 1124 if (!value.GetAsString(&bssid)) | |
| 1125 return false; | |
| 1126 wifi_network->set_bssid(bssid); | |
| 1127 return true; | |
| 1128 } | |
| 1129 case PROPERTY_INDEX_WIFI_HIDDEN_SSID: { | |
| 1130 bool hidden_ssid; | |
| 1131 if (!value.GetAsBoolean(&hidden_ssid)) | |
| 1132 return false; | |
| 1133 wifi_network->set_hidden_ssid(hidden_ssid); | |
| 1134 return true; | |
| 1135 } | |
| 1136 case PROPERTY_INDEX_WIFI_FREQUENCY: { | |
| 1137 int frequency; | |
| 1138 if (!value.GetAsInteger(&frequency)) | |
| 1139 return false; | |
| 1140 wifi_network->set_frequency(frequency); | |
| 1141 return true; | |
| 1142 } | |
| 1143 case PROPERTY_INDEX_NAME: { | |
| 1144 // Does not change network name when it was already set by WiFi.HexSSID. | |
| 1145 if (!wifi_network->name().empty()) | |
| 1146 return true; | |
| 1147 else | |
| 1148 return NativeWirelessNetworkParser::ParseValue(index, value, network); | |
| 1149 } | |
| 1150 case PROPERTY_INDEX_GUID: { | |
| 1151 std::string unique_id; | |
| 1152 if (!value.GetAsString(&unique_id)) | |
| 1153 break; | |
| 1154 wifi_network->set_unique_id(unique_id); | |
| 1155 return true; | |
| 1156 } | |
| 1157 case PROPERTY_INDEX_SECURITY: { | |
| 1158 std::string security_string; | |
| 1159 if (!value.GetAsString(&security_string)) | |
| 1160 break; | |
| 1161 wifi_network->set_encryption(ParseSecurity(security_string)); | |
| 1162 return true; | |
| 1163 } | |
| 1164 case PROPERTY_INDEX_PASSPHRASE: { | |
| 1165 std::string passphrase; | |
| 1166 if (!value.GetAsString(&passphrase)) | |
| 1167 break; | |
| 1168 | |
| 1169 if (chromeos::UserManager::Get()->IsCurrentUserOwner()) | |
| 1170 wifi_network->set_passphrase(passphrase); | |
| 1171 return true; | |
| 1172 } | |
| 1173 case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { | |
| 1174 bool passphrase_required; | |
| 1175 if (!value.GetAsBoolean(&passphrase_required)) | |
| 1176 break; | |
| 1177 wifi_network->set_passphrase_required(passphrase_required); | |
| 1178 return true; | |
| 1179 } | |
| 1180 case PROPERTY_INDEX_IDENTITY: { | |
| 1181 std::string identity; | |
| 1182 if (!value.GetAsString(&identity)) | |
| 1183 break; | |
| 1184 wifi_network->set_identity(identity); | |
| 1185 return true; | |
| 1186 } | |
| 1187 case PROPERTY_INDEX_EAP_IDENTITY: { | |
| 1188 std::string eap_identity; | |
| 1189 if (!value.GetAsString(&eap_identity)) | |
| 1190 break; | |
| 1191 wifi_network->set_eap_identity(eap_identity); | |
| 1192 return true; | |
| 1193 } | |
| 1194 case PROPERTY_INDEX_EAP_METHOD: { | |
| 1195 std::string eap_method; | |
| 1196 if (!value.GetAsString(&eap_method)) | |
| 1197 break; | |
| 1198 wifi_network->set_eap_method(ParseEAPMethod(eap_method)); | |
| 1199 return true; | |
| 1200 } | |
| 1201 case PROPERTY_INDEX_EAP_PHASE_2_AUTH: { | |
| 1202 std::string eap_phase_2_auth; | |
| 1203 if (!value.GetAsString(&eap_phase_2_auth)) | |
| 1204 break; | |
| 1205 wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth)); | |
| 1206 return true; | |
| 1207 } | |
| 1208 case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: { | |
| 1209 std::string eap_anonymous_identity; | |
| 1210 if (!value.GetAsString(&eap_anonymous_identity)) | |
| 1211 break; | |
| 1212 wifi_network->set_eap_anonymous_identity(eap_anonymous_identity); | |
| 1213 return true; | |
| 1214 } | |
| 1215 case PROPERTY_INDEX_EAP_CERT_ID: { | |
| 1216 std::string eap_client_cert_pkcs11_id; | |
| 1217 if (!value.GetAsString(&eap_client_cert_pkcs11_id)) | |
| 1218 break; | |
| 1219 wifi_network->set_eap_client_cert_pkcs11_id(eap_client_cert_pkcs11_id); | |
| 1220 return true; | |
| 1221 } | |
| 1222 case PROPERTY_INDEX_EAP_CA_CERT_PEM: { | |
| 1223 const base::ListValue* pems = NULL; | |
| 1224 value.GetAsList(&pems); | |
| 1225 if (!pems) | |
| 1226 break; | |
| 1227 std::string ca_cert_pem; | |
| 1228 if (!pems->empty()) | |
| 1229 pems->GetString(0, &ca_cert_pem); | |
| 1230 wifi_network->set_eap_server_ca_cert_pem(ca_cert_pem); | |
| 1231 return true; | |
| 1232 } | |
| 1233 case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS: { | |
| 1234 bool eap_use_system_cas; | |
| 1235 if (!value.GetAsBoolean(&eap_use_system_cas)) | |
| 1236 break; | |
| 1237 wifi_network->set_eap_use_system_cas(eap_use_system_cas); | |
| 1238 return true; | |
| 1239 } | |
| 1240 case PROPERTY_INDEX_EAP_PASSWORD: { | |
| 1241 std::string eap_passphrase; | |
| 1242 if (!value.GetAsString(&eap_passphrase)) | |
| 1243 break; | |
| 1244 wifi_network->set_eap_passphrase(eap_passphrase); | |
| 1245 return true; | |
| 1246 } | |
| 1247 case PROPERTY_INDEX_WIFI_AUTH_MODE: | |
| 1248 case PROPERTY_INDEX_WIFI_PHY_MODE: | |
| 1249 case PROPERTY_INDEX_EAP_CLIENT_CERT: | |
| 1250 case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS: | |
| 1251 case PROPERTY_INDEX_EAP_PRIVATE_KEY: | |
| 1252 case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD: | |
| 1253 case PROPERTY_INDEX_EAP_KEY_ID: | |
| 1254 case PROPERTY_INDEX_EAP_CA_CERT_ID: | |
| 1255 case PROPERTY_INDEX_EAP_PIN: | |
| 1256 case PROPERTY_INDEX_EAP_KEY_MGMT: | |
| 1257 // These properties are currently not used in the UI. | |
| 1258 return true; | |
| 1259 default: | |
| 1260 return NativeWirelessNetworkParser::ParseValue(index, value, network); | |
| 1261 } | |
| 1262 return false; | |
| 1263 } | |
| 1264 | |
| 1265 ConnectionSecurity NativeWifiNetworkParser::ParseSecurity( | |
| 1266 const std::string& security) { | |
| 1267 return network_security_mapper()->Get(security); | |
| 1268 } | |
| 1269 | |
| 1270 EAPMethod NativeWifiNetworkParser::ParseEAPMethod(const std::string& method) { | |
| 1271 return network_eap_method_mapper()->Get(method); | |
| 1272 } | |
| 1273 | |
| 1274 EAPPhase2Auth NativeWifiNetworkParser::ParseEAPPhase2Auth( | |
| 1275 const std::string& auth) { | |
| 1276 return network_eap_auth_mapper()->Get(auth); | |
| 1277 } | |
| 1278 | |
| 1279 // -------------------- NativeVirtualNetworkParser -------------------- | |
| 1280 | |
| 1281 | |
| 1282 NativeVirtualNetworkParser::NativeVirtualNetworkParser() {} | |
| 1283 NativeVirtualNetworkParser::~NativeVirtualNetworkParser() {} | |
| 1284 | |
| 1285 bool NativeVirtualNetworkParser::UpdateNetworkFromInfo( | |
| 1286 const DictionaryValue& info, | |
| 1287 Network* network) { | |
| 1288 CHECK_EQ(TYPE_VPN, network->type()); | |
| 1289 VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); | |
| 1290 if (!NativeNetworkParser::UpdateNetworkFromInfo(info, network)) | |
| 1291 return false; | |
| 1292 VLOG(1) << "Updating VPN '" << virtual_network->name() | |
| 1293 << "': Server: " << virtual_network->server_hostname() | |
| 1294 << " Type: " | |
| 1295 << ProviderTypeToString(virtual_network->provider_type()); | |
| 1296 if (virtual_network->provider_type() == PROVIDER_TYPE_L2TP_IPSEC_PSK) { | |
| 1297 if (!virtual_network->client_cert_id().empty()) | |
| 1298 virtual_network->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT); | |
| 1299 } | |
| 1300 return true; | |
| 1301 } | |
| 1302 | |
| 1303 bool NativeVirtualNetworkParser::ParseValue(PropertyIndex index, | |
| 1304 const base::Value& value, | |
| 1305 Network* network) { | |
| 1306 CHECK_EQ(TYPE_VPN, network->type()); | |
| 1307 VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); | |
| 1308 switch (index) { | |
| 1309 case PROPERTY_INDEX_PROVIDER: { | |
| 1310 // TODO(rkc): Figure out why is this ever not true and fix the root | |
| 1311 // cause. 'value' comes to us all the way from the cros dbus call, the | |
| 1312 // issue is likely on the cros side of things. | |
| 1313 if (value.GetType() != Value::TYPE_DICTIONARY) | |
| 1314 return false; | |
| 1315 | |
| 1316 const DictionaryValue& dict = static_cast<const DictionaryValue&>(value); | |
| 1317 for (DictionaryValue::Iterator iter(dict); | |
| 1318 !iter.IsAtEnd(); | |
| 1319 iter.Advance()) { | |
| 1320 PropertyIndex index = mapper().Get(iter.key()); | |
| 1321 if (!ParseProviderValue(index, iter.value(), virtual_network)) { | |
| 1322 VLOG(1) << network->name() << ": Provider unhandled key: " | |
| 1323 << iter.key() << " Type: " << iter.value().GetType(); | |
| 1324 } | |
| 1325 } | |
| 1326 return true; | |
| 1327 } | |
| 1328 default: | |
| 1329 return NativeNetworkParser::ParseValue(index, value, network); | |
| 1330 break; | |
| 1331 } | |
| 1332 return false; | |
| 1333 } | |
| 1334 | |
| 1335 bool NativeVirtualNetworkParser::ParseProviderValue(PropertyIndex index, | |
| 1336 const base::Value& value, | |
| 1337 VirtualNetwork* network) { | |
| 1338 switch (index) { | |
| 1339 case PROPERTY_INDEX_HOST: { | |
| 1340 std::string server_hostname; | |
| 1341 if (!value.GetAsString(&server_hostname)) | |
| 1342 break; | |
| 1343 network->set_server_hostname(server_hostname); | |
| 1344 return true; | |
| 1345 } | |
| 1346 case PROPERTY_INDEX_NAME: { | |
| 1347 std::string name; | |
| 1348 if (!value.GetAsString(&name)) | |
| 1349 break; | |
| 1350 network->set_name(name); | |
| 1351 return true; | |
| 1352 } | |
| 1353 case PROPERTY_INDEX_TYPE: { | |
| 1354 std::string provider_type_string; | |
| 1355 if (!value.GetAsString(&provider_type_string)) | |
| 1356 break; | |
| 1357 network->set_provider_type(ParseProviderType(provider_type_string)); | |
| 1358 return true; | |
| 1359 } | |
| 1360 case PROPERTY_INDEX_L2TPIPSEC_CA_CERT_PEM: | |
| 1361 case PROPERTY_INDEX_OPEN_VPN_CA_CERT_PEM: { | |
| 1362 const base::ListValue* pems = NULL; | |
| 1363 value.GetAsList(&pems); | |
| 1364 if (!pems) | |
| 1365 break; | |
| 1366 std::string ca_cert_pem; | |
| 1367 if (!pems->empty()) | |
| 1368 pems->GetString(0, &ca_cert_pem); | |
| 1369 network->set_ca_cert_pem(ca_cert_pem); | |
| 1370 return true; | |
| 1371 } | |
| 1372 case PROPERTY_INDEX_L2TPIPSEC_PSK: { | |
| 1373 std::string psk_passphrase; | |
| 1374 if (!value.GetAsString(&psk_passphrase)) | |
| 1375 break; | |
| 1376 network->set_psk_passphrase(psk_passphrase); | |
| 1377 return true; | |
| 1378 } | |
| 1379 case PROPERTY_INDEX_L2TPIPSEC_PSK_REQUIRED: { | |
| 1380 bool psk_passphrase_required; | |
| 1381 if (!value.GetAsBoolean(&psk_passphrase_required)) | |
| 1382 break; | |
| 1383 network->set_psk_passphrase_required(psk_passphrase_required); | |
| 1384 return true; | |
| 1385 } | |
| 1386 case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID: | |
| 1387 case PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_ID: { | |
| 1388 std::string client_cert_id; | |
| 1389 if (!value.GetAsString(&client_cert_id)) | |
| 1390 break; | |
| 1391 network->set_client_cert_id(client_cert_id); | |
| 1392 return true; | |
| 1393 } | |
| 1394 case PROPERTY_INDEX_L2TPIPSEC_USER: | |
| 1395 case PROPERTY_INDEX_OPEN_VPN_USER: { | |
| 1396 std::string username; | |
| 1397 if (!value.GetAsString(&username)) | |
| 1398 break; | |
| 1399 network->set_username(username); | |
| 1400 return true; | |
| 1401 } | |
| 1402 case PROPERTY_INDEX_L2TPIPSEC_PASSWORD: | |
| 1403 case PROPERTY_INDEX_OPEN_VPN_PASSWORD: { | |
| 1404 std::string user_passphrase; | |
| 1405 if (!value.GetAsString(&user_passphrase)) | |
| 1406 break; | |
| 1407 network->set_user_passphrase(user_passphrase); | |
| 1408 return true; | |
| 1409 } | |
| 1410 case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { | |
| 1411 bool user_passphrase_required; | |
| 1412 if (!value.GetAsBoolean(&user_passphrase_required)) | |
| 1413 break; | |
| 1414 network->set_user_passphrase_required(user_passphrase_required); | |
| 1415 return true; | |
| 1416 } | |
| 1417 case PROPERTY_INDEX_L2TPIPSEC_GROUP_NAME: { | |
| 1418 std::string group_name; | |
| 1419 if (!value.GetAsString(&group_name)) | |
| 1420 break; | |
| 1421 network->set_group_name(group_name); | |
| 1422 return true; | |
| 1423 } | |
| 1424 default: | |
| 1425 break; | |
| 1426 } | |
| 1427 return false; | |
| 1428 } | |
| 1429 | |
| 1430 // static | |
| 1431 const EnumMapper<ProviderType>* | |
| 1432 NativeVirtualNetworkParser::provider_type_mapper() { | |
| 1433 CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser, | |
| 1434 (provider_type_table, arraysize(provider_type_table), | |
| 1435 PROVIDER_TYPE_MAX)); | |
| 1436 return &parser; | |
| 1437 } | |
| 1438 | |
| 1439 ProviderType NativeVirtualNetworkParser::ParseProviderType( | |
| 1440 const std::string& type) { | |
| 1441 return provider_type_mapper()->Get(type); | |
| 1442 } | |
| 1443 | |
| 1444 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 23618026:
NOT FOR SUBMIT: Remove NetworkLibrary (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src