1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.wifi.hotspot2; 18 19 import android.net.wifi.hotspot2.PasspointConfiguration; 20 import android.net.wifi.hotspot2.pps.Credential; 21 import android.net.wifi.hotspot2.pps.HomeSp; 22 import android.net.wifi.hotspot2.pps.Policy; 23 import android.net.wifi.hotspot2.pps.UpdateParameter; 24 import android.os.ParcelUuid; 25 import android.util.Log; 26 27 import com.android.modules.utils.build.SdkLevel; 28 import com.android.server.wifi.util.XmlUtil; 29 30 import org.xmlpull.v1.XmlPullParser; 31 import org.xmlpull.v1.XmlPullParserException; 32 import org.xmlpull.v1.XmlSerializer; 33 34 import java.io.IOException; 35 import java.util.ArrayList; 36 import java.util.HashMap; 37 import java.util.List; 38 import java.util.Map; 39 40 /** 41 * Utility class for serialize and deserialize Passpoint related configurations to/from XML string. 42 */ 43 public class PasspointXmlUtils { 44 private static final String TAG = "PasspointXmlUtils"; 45 // XML section header tags. 46 private static final String XML_TAG_SECTION_HEADER_HOMESP = "HomeSP"; 47 private static final String XML_TAG_SECTION_HEADER_CREDENTIAL = "Credential"; 48 private static final String XML_TAG_SECTION_HEADER_USER_CREDENTIAL = "UserCredential"; 49 private static final String XML_TAG_SECTION_HEADER_CERT_CREDENTIAL = "CertCredential"; 50 private static final String XML_TAG_SECTION_HEADER_SIM_CREDENTIAL = "SimCredential"; 51 private static final String XML_TAG_SECTION_HEADER_POLICY = "Policy"; 52 private static final String XML_TAG_SECTION_HEADER_PREFERRED_ROAMING_PARTNER_LIST = 53 "RoamingPartnerList"; 54 private static final String XML_TAG_SECTION_HEADER_ROAMING_PARTNER = "RoamingPartner"; 55 private static final String XML_TAG_SECTION_HEADER_POLICY_UPDATE = "PolicyUpdate"; 56 private static final String XML_TAG_SECTION_HEADER_SUBSCRIPTION_UPDATE = "SubscriptionUpdate"; 57 private static final String XML_TAG_SECTION_HEADER_REQUIRED_PROTO_PORT_MAP = 58 "RequiredProtoPortMap"; 59 private static final String XML_TAG_SECTION_HEADER_PROTO_PORT = "ProtoPort"; 60 private static final String XML_TAG_SECTION_HEADER_AAA_SERVER_TRUSTED_NAMES = 61 "AAAServerTrustedNames"; 62 63 // XML value tags. 64 private static final String XML_TAG_FQDN = "FQDN"; 65 private static final String XML_TAG_FRIENDLY_NAME = "FriendlyName"; 66 private static final String XML_TAG_FRIENDLY_NAME_LIST = "FriendlyNameList"; 67 private static final String XML_TAG_ICON_URL = "IconURL"; 68 private static final String XML_TAG_HOME_NETWORK_IDS = "HomeNetworkIDs"; 69 private static final String XML_TAG_MATCH_ALL_OIS = "MatchAllOIs"; 70 private static final String XML_TAG_MATCH_ANY_OIS = "MatchAnyOIs"; 71 private static final String XML_TAG_OTHER_HOME_PARTNERS = "OtherHomePartners"; 72 private static final String XML_TAG_ROAMING_CONSORTIUM_OIS = "RoamingConsortiumOIs"; 73 private static final String XML_TAG_CREATION_TIME = "CreationTime"; 74 private static final String XML_TAG_EXPIRATION_TIME = "ExpirationTime"; 75 private static final String XML_TAG_REALM = "Realm"; 76 private static final String XML_TAG_CHECK_AAA_SERVER_CERT_STATUS = "CheckAAAServerCertStatus"; 77 private static final String XML_TAG_USERNAME = "Username"; 78 private static final String XML_TAG_PASSWORD = "Password"; 79 private static final String XML_TAG_MACHINE_MANAGED = "MachineManaged"; 80 private static final String XML_TAG_SOFT_TOKEN_APP = "SoftTokenApp"; 81 private static final String XML_TAG_ABLE_TO_SHARE = "AbleToShare"; 82 private static final String XML_TAG_EAP_TYPE = "EAPType"; 83 private static final String XML_TAG_NON_EAP_INNER_METHOD = "NonEAPInnerMethod"; 84 private static final String XML_TAG_CERT_TYPE = "CertType"; 85 private static final String XML_TAG_CERT_SHA256_FINGERPRINT = "CertSHA256Fingerprint"; 86 private static final String XML_TAG_IMSI = "IMSI"; 87 private static final String XML_TAG_MIN_HOME_DOWNLINK_BANDWIDTH = "MinHomeDownlinkBandwidth"; 88 private static final String XML_TAG_MIN_HOME_UPLINK_BANDWIDTH = "MinHomeUplinkBandwidth"; 89 private static final String XML_TAG_MIN_ROAMING_DOWNLINK_BANDWIDTH = 90 "MinRoamingDownlinkBandwidth"; 91 private static final String XML_TAG_MIN_ROAMING_UPLINK_BANDWIDTH = 92 "MinRoamingUplinkBandwidth"; 93 private static final String XML_TAG_EXCLUDED_SSID_LIST = "ExcludedSSIDList"; 94 private static final String XML_TAG_PROTO = "Proto"; 95 private static final String XML_TAG_PORTS = "Ports"; 96 private static final String XML_TAG_MAXIMUM_BSS_LOAD_VALUE = "MaximumBSSLoadValue"; 97 private static final String XML_TAG_FQDN_EXACT_MATCH = "FQDNExactMatch"; 98 private static final String XML_TAG_PRIORITY = "Priority"; 99 private static final String XML_TAG_COUNTRIES = "Countries"; 100 private static final String XML_TAG_UPDATE_INTERVAL = "UpdateInterval"; 101 private static final String XML_TAG_UPDATE_METHOD = "UpdateMethod"; 102 private static final String XML_TAG_RESTRICTION = "Restriction"; 103 private static final String XML_TAG_SERVER_URI = "ServerURI"; 104 private static final String XML_TAG_TRUST_ROOT_CERT_URL = "TrustRootCertURL"; 105 private static final String XML_TAG_TRUST_ROOT_CERT_SHA256_FINGERPRINT = 106 "TrustRootCertSHA256Fingerprint"; 107 private static final String XML_TAG_TRUST_ROOT_CERT_LIST = "TrustRootCertList"; 108 private static final String XML_TAG_UPDATE_IDENTIFIER = "UpdateIdentifier"; 109 private static final String XML_TAG_CREDENTIAL_PRIORITY = "CredentialPriority"; 110 private static final String XML_TAG_SUBSCRIPTION_CREATION_TIME = "SubscriptionCreationTime"; 111 private static final String XML_TAG_SUBSCRIPTION_EXPIRATION_TIME = 112 "SubscriptionExpirationTime"; 113 private static final String XML_TAG_SUBSCRIPTION_TYPE = "SubscriptionType"; 114 private static final String XML_TAG_USAGE_LIMIT_TIME_PERIOD = "UsageLimitTimePeriod"; 115 private static final String XML_TAG_USAGE_LIMIT_START_TIME = "UsageLimitStartTime"; 116 private static final String XML_TAG_USAGE_LIMIT_DATA_LIMIT = "UsageLimitDataLimit"; 117 private static final String XML_TAG_USAGE_LIMIT_TIME_LIMIT = "UsageLimitTimeLimit"; 118 private static final String XML_TAG_CARRIER_ID = "CarrierId"; 119 private static final String XML_TAG_SUBSCRIPTION_ID = "SubscriptionId"; 120 private static final String XML_TAG_IS_AUTO_JOIN = "AutoJoinEnabled"; 121 private static final String XML_TAG_IS_MAC_RANDOMIZATION_ENABLED = "IsMacRandomizationEnabled"; 122 private static final String XML_TAG_METERED_OVERRIDE = "MeteredOverride"; 123 private static final String XML_TAG_IS_CARRIER_MERGED = "IsCarrierMerged"; 124 private static final String XML_TAG_IS_OEM_PAID = "IsOemPaid"; 125 private static final String XML_TAG_IS_OEM_PRIVATE = "IsOemPrivate"; 126 private static final String XML_TAG_DECORATED_IDENTITY_PREFIX = "DecoratedIdentityPrefix"; 127 private static final String XML_TAG_SUBSCRIPTION_GROUP = "SubscriptionGroup"; 128 private static final String XML_TAG_MINIMUM_TLS_VERSION = "MinimumTlsVersion"; 129 130 /** 131 * Serialize a {@link PasspointConfiguration} to the output stream as a XML block. 132 * 133 * @param out The output stream to serialize to 134 * @param config The configuration to serialize 135 * @throws XmlPullParserException 136 * @throws IOException 137 */ serializePasspointConfiguration(XmlSerializer out, PasspointConfiguration config)138 public static void serializePasspointConfiguration(XmlSerializer out, 139 PasspointConfiguration config) throws XmlPullParserException, IOException { 140 XmlUtil.writeNextValue(out, XML_TAG_UPDATE_IDENTIFIER, config.getUpdateIdentifier()); 141 XmlUtil.writeNextValue(out, XML_TAG_CREDENTIAL_PRIORITY, config.getCredentialPriority()); 142 XmlUtil.writeNextValue(out, XML_TAG_TRUST_ROOT_CERT_LIST, config.getTrustRootCertList()); 143 XmlUtil.writeNextValue(out, XML_TAG_SUBSCRIPTION_CREATION_TIME, 144 config.getSubscriptionCreationTimeInMillis()); 145 XmlUtil.writeNextValue(out, XML_TAG_SUBSCRIPTION_EXPIRATION_TIME, 146 config.getSubscriptionExpirationTimeMillis()); 147 XmlUtil.writeNextValue(out, XML_TAG_SUBSCRIPTION_TYPE, config.getSubscriptionType()); 148 XmlUtil.writeNextValue(out, XML_TAG_USAGE_LIMIT_TIME_PERIOD, 149 config.getUsageLimitUsageTimePeriodInMinutes()); 150 XmlUtil.writeNextValue(out, XML_TAG_USAGE_LIMIT_START_TIME, 151 config.getUsageLimitStartTimeInMillis()); 152 XmlUtil.writeNextValue(out, XML_TAG_USAGE_LIMIT_DATA_LIMIT, 153 config.getUsageLimitDataLimit()); 154 XmlUtil.writeNextValue(out, XML_TAG_USAGE_LIMIT_TIME_LIMIT, 155 config.getUsageLimitTimeLimitInMinutes()); 156 serializeHomeSp(out, config.getHomeSp()); 157 serializeCredential(out, config.getCredential()); 158 serializePolicy(out, config.getPolicy()); 159 serializeUpdateParameter(out, XML_TAG_SECTION_HEADER_SUBSCRIPTION_UPDATE, 160 config.getSubscriptionUpdate()); 161 if (config.getServiceFriendlyNames() != null) { 162 XmlUtil.writeNextValue(out, XML_TAG_FRIENDLY_NAME_LIST, 163 config.getServiceFriendlyNames()); 164 } 165 XmlUtil.writeNextValue(out, XML_TAG_CARRIER_ID, config.getCarrierId()); 166 XmlUtil.writeNextValue(out, XML_TAG_SUBSCRIPTION_ID, config.getSubscriptionId()); 167 XmlUtil.writeNextValue(out, XML_TAG_IS_AUTO_JOIN, config.isAutojoinEnabled()); 168 XmlUtil.writeNextValue(out, XML_TAG_IS_MAC_RANDOMIZATION_ENABLED, 169 config.isMacRandomizationEnabled()); 170 XmlUtil.writeNextValue(out, XML_TAG_METERED_OVERRIDE, config.getMeteredOverride()); 171 XmlUtil.writeNextValue(out, XML_TAG_IS_CARRIER_MERGED, config.isCarrierMerged()); 172 XmlUtil.writeNextValue(out, XML_TAG_IS_OEM_PAID, config.isOemPaid()); 173 XmlUtil.writeNextValue(out, XML_TAG_IS_OEM_PRIVATE, config.isOemPrivate()); 174 if (config.getSubscriptionGroup() != null) { 175 XmlUtil.writeNextValue(out, XML_TAG_SUBSCRIPTION_GROUP, 176 config.getSubscriptionGroup().toString()); 177 } 178 if (SdkLevel.isAtLeastS()) { 179 XmlUtil.writeNextValue(out, XML_TAG_DECORATED_IDENTITY_PREFIX, 180 config.getDecoratedIdentityPrefix()); 181 } 182 serializeAaaServerTrustedNames(out, config.getAaaServerTrustedNames()); 183 } 184 185 /** 186 * Deserialize a {@link PasspointConfiguration} from an input stream containing XML block. 187 * 188 * @param in The input stream to read from 189 * @param outerTagDepth The tag depth of the current XML section 190 * @return {@link PasspointConfiguration} 191 * @throws XmlPullParserException 192 * @throws IOException 193 */ deserializePasspointConfiguration(XmlPullParser in, int outerTagDepth)194 public static PasspointConfiguration deserializePasspointConfiguration(XmlPullParser in, 195 int outerTagDepth) throws XmlPullParserException, IOException { 196 PasspointConfiguration config = new PasspointConfiguration(); 197 while (XmlUtil.nextElementWithin(in, outerTagDepth)) { 198 if (isValueElement(in)) { 199 // Value elements. 200 String[] name = new String[1]; 201 Object value = XmlUtil.readCurrentValue(in, name); 202 switch (name[0]) { 203 case XML_TAG_UPDATE_IDENTIFIER: 204 config.setUpdateIdentifier((int) value); 205 break; 206 case XML_TAG_CREDENTIAL_PRIORITY: 207 config.setCredentialPriority((int) value); 208 break; 209 case XML_TAG_TRUST_ROOT_CERT_LIST: 210 config.setTrustRootCertList((Map<String, byte[]>) value); 211 break; 212 case XML_TAG_SUBSCRIPTION_CREATION_TIME: 213 config.setSubscriptionCreationTimeInMillis((long) value); 214 break; 215 case XML_TAG_SUBSCRIPTION_EXPIRATION_TIME: 216 config.setSubscriptionExpirationTimeInMillis((long) value); 217 break; 218 case XML_TAG_SUBSCRIPTION_TYPE: 219 config.setSubscriptionType((String) value); 220 break; 221 case XML_TAG_USAGE_LIMIT_TIME_PERIOD: 222 config.setUsageLimitUsageTimePeriodInMinutes((long) value); 223 break; 224 case XML_TAG_USAGE_LIMIT_START_TIME: 225 config.setUsageLimitStartTimeInMillis((long) value); 226 break; 227 case XML_TAG_USAGE_LIMIT_DATA_LIMIT: 228 config.setUsageLimitDataLimit((long) value); 229 break; 230 case XML_TAG_USAGE_LIMIT_TIME_LIMIT: 231 config.setUsageLimitTimeLimitInMinutes((long) value); 232 break; 233 case XML_TAG_FRIENDLY_NAME_LIST: 234 config.setServiceFriendlyNames((Map<String, String>) value); 235 break; 236 case XML_TAG_CARRIER_ID: 237 config.setCarrierId((int) value); 238 break; 239 case XML_TAG_SUBSCRIPTION_ID: 240 config.setSubscriptionId((int) value); 241 break; 242 case XML_TAG_IS_AUTO_JOIN: 243 config.setAutojoinEnabled((boolean) value); 244 break; 245 case XML_TAG_IS_MAC_RANDOMIZATION_ENABLED: 246 config.setMacRandomizationEnabled((boolean) value); 247 break; 248 case XML_TAG_METERED_OVERRIDE: 249 config.setMeteredOverride((int) value); 250 break; 251 case XML_TAG_IS_CARRIER_MERGED: 252 config.setCarrierMerged((boolean) value); 253 break; 254 case XML_TAG_IS_OEM_PAID: 255 config.setOemPaid((boolean) value); 256 break; 257 case XML_TAG_IS_OEM_PRIVATE: 258 config.setOemPrivate((boolean) value); 259 break; 260 case XML_TAG_DECORATED_IDENTITY_PREFIX: 261 if (SdkLevel.isAtLeastS()) { 262 config.setDecoratedIdentityPrefix((String) value); 263 } 264 break; 265 case XML_TAG_SUBSCRIPTION_GROUP: 266 config.setSubscriptionGroup(ParcelUuid.fromString((String) value)); 267 break; 268 default: 269 Log.w(TAG, "Unknown value under " + "PasspointConfiguration: " 270 + in.getName()); 271 } 272 } else { 273 // Section elements. 274 switch (in.getName()) { 275 case XML_TAG_SECTION_HEADER_HOMESP: 276 config.setHomeSp(deserializeHomeSP(in, outerTagDepth + 1)); 277 break; 278 case XML_TAG_SECTION_HEADER_CREDENTIAL: 279 config.setCredential(deserializeCredential(in, outerTagDepth + 1)); 280 break; 281 case XML_TAG_SECTION_HEADER_POLICY: 282 config.setPolicy(deserializePolicy(in, outerTagDepth + 1)); 283 break; 284 case XML_TAG_SECTION_HEADER_SUBSCRIPTION_UPDATE: 285 config.setSubscriptionUpdate( 286 deserializeUpdateParameter(in, outerTagDepth + 1)); 287 break; 288 case XML_TAG_SECTION_HEADER_AAA_SERVER_TRUSTED_NAMES: 289 config.setAaaServerTrustedNames(deserializeAaaServerTrustedNames( 290 in, outerTagDepth + 1)); 291 break; 292 default: 293 Log.w(TAG, "Unknown section under " 294 + "PasspointConfiguration: " + in.getName()); 295 } 296 } 297 } 298 return config; 299 } 300 301 /** 302 * Serialize a {@link HomeSp} to an output stream as a XML block. 303 * 304 * @param out The output stream to serialize data to 305 * @param homeSp The {@link HomeSp} to serialize 306 * @throws XmlPullParserException 307 * @throws IOException 308 */ serializeHomeSp(XmlSerializer out, HomeSp homeSp)309 private static void serializeHomeSp(XmlSerializer out, HomeSp homeSp) 310 throws XmlPullParserException, IOException { 311 if (homeSp == null) { 312 return; 313 } 314 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_HOMESP); 315 XmlUtil.writeNextValue(out, XML_TAG_FQDN, homeSp.getFqdn()); 316 XmlUtil.writeNextValue(out, XML_TAG_FRIENDLY_NAME, homeSp.getFriendlyName()); 317 XmlUtil.writeNextValue(out, XML_TAG_ICON_URL, homeSp.getIconUrl()); 318 XmlUtil.writeNextValue(out, XML_TAG_HOME_NETWORK_IDS, homeSp.getHomeNetworkIds()); 319 XmlUtil.writeNextValue(out, XML_TAG_MATCH_ALL_OIS, homeSp.getMatchAllOis()); 320 XmlUtil.writeNextValue(out, XML_TAG_MATCH_ANY_OIS, homeSp.getMatchAnyOis()); 321 XmlUtil.writeNextValue(out, XML_TAG_OTHER_HOME_PARTNERS, homeSp.getOtherHomePartners()); 322 XmlUtil.writeNextValue(out, XML_TAG_ROAMING_CONSORTIUM_OIS, 323 homeSp.getRoamingConsortiumOis()); 324 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_HOMESP); 325 } 326 327 /** 328 * Serialize a {@link Credential} to an output stream as a XML block. 329 * 330 * @param out The output stream to serialize to 331 * @param credential The {@link Credential} to serialize 332 * @throws XmlPullParserException 333 * @throws IOException 334 */ serializeCredential(XmlSerializer out, Credential credential)335 private static void serializeCredential(XmlSerializer out, Credential credential) 336 throws XmlPullParserException, IOException { 337 if (credential == null) { 338 return; 339 } 340 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_CREDENTIAL); 341 XmlUtil.writeNextValue(out, XML_TAG_CREATION_TIME, credential.getCreationTimeInMillis()); 342 XmlUtil.writeNextValue(out, XML_TAG_EXPIRATION_TIME, 343 credential.getExpirationTimeInMillis()); 344 XmlUtil.writeNextValue(out, XML_TAG_REALM, credential.getRealm()); 345 XmlUtil.writeNextValue(out, XML_TAG_CHECK_AAA_SERVER_CERT_STATUS, 346 credential.getCheckAaaServerCertStatus()); 347 XmlUtil.writeNextValue(out, XML_TAG_MINIMUM_TLS_VERSION, 348 credential.getMinimumTlsVersion()); 349 serializeUserCredential(out, credential.getUserCredential()); 350 serializeCertCredential(out, credential.getCertCredential()); 351 serializeSimCredential(out, credential.getSimCredential()); 352 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_CREDENTIAL); 353 } 354 355 /** 356 * Serialize a {@link Policy} to an output stream as a XML block. 357 * 358 * @param out The output stream to serialize to 359 * @param policy The {@link Policy} to serialize 360 * @throws XmlPullParserException 361 * @throws IOException 362 */ serializePolicy(XmlSerializer out, Policy policy)363 private static void serializePolicy(XmlSerializer out, Policy policy) 364 throws XmlPullParserException, IOException { 365 if (policy == null) { 366 return; 367 } 368 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_POLICY); 369 XmlUtil.writeNextValue(out, XML_TAG_MIN_HOME_DOWNLINK_BANDWIDTH, 370 policy.getMinHomeDownlinkBandwidth()); 371 XmlUtil.writeNextValue(out, XML_TAG_MIN_HOME_UPLINK_BANDWIDTH, 372 policy.getMinHomeUplinkBandwidth()); 373 XmlUtil.writeNextValue(out, XML_TAG_MIN_ROAMING_DOWNLINK_BANDWIDTH, 374 policy.getMinRoamingDownlinkBandwidth()); 375 XmlUtil.writeNextValue(out, XML_TAG_MIN_ROAMING_UPLINK_BANDWIDTH, 376 policy.getMinRoamingUplinkBandwidth()); 377 XmlUtil.writeNextValue(out, XML_TAG_EXCLUDED_SSID_LIST, policy.getExcludedSsidList()); 378 XmlUtil.writeNextValue(out, XML_TAG_MAXIMUM_BSS_LOAD_VALUE, 379 policy.getMaximumBssLoadValue()); 380 serializeProtoPortMap(out, policy.getRequiredProtoPortMap()); 381 serializeUpdateParameter(out, XML_TAG_SECTION_HEADER_POLICY_UPDATE, 382 policy.getPolicyUpdate()); 383 serializePreferredRoamingPartnerList(out, policy.getPreferredRoamingPartnerList()); 384 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_POLICY); 385 } 386 387 /** 388 * Serialize a {@link android.net.wifi.hotspot2.pps.Credential.UserCredential} to an output 389 * stream as a XML block. 390 * 391 * @param out The output stream to serialize data to 392 * @param userCredential The UserCredential to serialize 393 * @throws XmlPullParserException 394 * @throws IOException 395 */ serializeUserCredential(XmlSerializer out, Credential.UserCredential userCredential)396 private static void serializeUserCredential(XmlSerializer out, 397 Credential.UserCredential userCredential) throws XmlPullParserException, IOException { 398 if (userCredential == null) { 399 return; 400 } 401 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_USER_CREDENTIAL); 402 XmlUtil.writeNextValue(out, XML_TAG_USERNAME, userCredential.getUsername()); 403 XmlUtil.writeNextValue(out, XML_TAG_PASSWORD, userCredential.getPassword()); 404 XmlUtil.writeNextValue(out, XML_TAG_MACHINE_MANAGED, userCredential.getMachineManaged()); 405 XmlUtil.writeNextValue(out, XML_TAG_SOFT_TOKEN_APP, userCredential.getSoftTokenApp()); 406 XmlUtil.writeNextValue(out, XML_TAG_ABLE_TO_SHARE, userCredential.getAbleToShare()); 407 XmlUtil.writeNextValue(out, XML_TAG_EAP_TYPE, userCredential.getEapType()); 408 XmlUtil.writeNextValue(out, XML_TAG_NON_EAP_INNER_METHOD, 409 userCredential.getNonEapInnerMethod()); 410 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_USER_CREDENTIAL); 411 } 412 413 /** 414 * Serialize a {@link android.net.wifi.hotspot2.pps.Credential.CertificateCredential} to an 415 * output stream as a XML block. 416 * 417 * @param out The output stream to serialize data to 418 * @param certCredential The CertificateCredential to serialize 419 * @throws XmlPullParserException 420 * @throws IOException 421 */ serializeCertCredential(XmlSerializer out, Credential.CertificateCredential certCredential)422 private static void serializeCertCredential(XmlSerializer out, 423 Credential.CertificateCredential certCredential) 424 throws XmlPullParserException, IOException { 425 if (certCredential == null) { 426 return; 427 } 428 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_CERT_CREDENTIAL); 429 XmlUtil.writeNextValue(out, XML_TAG_CERT_TYPE, certCredential.getCertType()); 430 XmlUtil.writeNextValue(out, XML_TAG_CERT_SHA256_FINGERPRINT, 431 certCredential.getCertSha256Fingerprint()); 432 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_CERT_CREDENTIAL); 433 } 434 435 /** 436 * Serialize a {@link android.net.wifi.hotspot2.pps.Credential.SimCredential} to an 437 * output stream as a XML block. 438 * 439 * @param out The output stream to serialize data to 440 * @param simCredential The SimCredential to serialize 441 * @throws XmlPullParserException 442 * @throws IOException 443 */ serializeSimCredential(XmlSerializer out, Credential.SimCredential simCredential)444 private static void serializeSimCredential(XmlSerializer out, 445 Credential.SimCredential simCredential) throws XmlPullParserException, IOException { 446 if (simCredential == null) { 447 return; 448 } 449 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_SIM_CREDENTIAL); 450 XmlUtil.writeNextValue(out, XML_TAG_IMSI, simCredential.getImsi()); 451 XmlUtil.writeNextValue(out, XML_TAG_EAP_TYPE, simCredential.getEapType()); 452 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_SIM_CREDENTIAL); 453 } 454 455 /** 456 * Serialize a preferred roaming partner list to an output stream as a XML block. 457 * 458 * @param out The output stream to serialize data to 459 * @param preferredRoamingPartnerList The partner list to serialize 460 * @throws XmlPullParserException 461 * @throws IOException 462 */ serializePreferredRoamingPartnerList(XmlSerializer out, List<Policy.RoamingPartner> preferredRoamingPartnerList)463 private static void serializePreferredRoamingPartnerList(XmlSerializer out, 464 List<Policy.RoamingPartner> preferredRoamingPartnerList) 465 throws XmlPullParserException, IOException { 466 if (preferredRoamingPartnerList == null) { 467 return; 468 } 469 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_PREFERRED_ROAMING_PARTNER_LIST); 470 for (Policy.RoamingPartner partner : preferredRoamingPartnerList) { 471 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_ROAMING_PARTNER); 472 XmlUtil.writeNextValue(out, XML_TAG_FQDN, partner.getFqdn()); 473 XmlUtil.writeNextValue(out, XML_TAG_FQDN_EXACT_MATCH, partner.getFqdnExactMatch()); 474 XmlUtil.writeNextValue(out, XML_TAG_PRIORITY, partner.getPriority()); 475 XmlUtil.writeNextValue(out, XML_TAG_COUNTRIES, partner.getCountries()); 476 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_ROAMING_PARTNER); 477 } 478 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_PREFERRED_ROAMING_PARTNER_LIST); 479 } 480 481 /** 482 * Serialize a {@link UpdateParameter} to an output stream as a XML block. The 483 * {@link UpdateParameter} are used for describing Subscription Update and Policy Update. 484 * 485 * @param out The output stream to serialize data to 486 * @param type The type the {@link UpdateParameter} is used for 487 * @param param The {@link UpdateParameter} to serialize 488 * @throws XmlPullParserException 489 * @throws IOException 490 */ serializeUpdateParameter(XmlSerializer out, String type, UpdateParameter param)491 private static void serializeUpdateParameter(XmlSerializer out, String type, 492 UpdateParameter param) throws XmlPullParserException, IOException { 493 if (param == null) { 494 return; 495 } 496 XmlUtil.writeNextSectionStart(out, type); 497 XmlUtil.writeNextValue(out, XML_TAG_UPDATE_INTERVAL, param.getUpdateIntervalInMinutes()); 498 XmlUtil.writeNextValue(out, XML_TAG_UPDATE_METHOD, param.getUpdateMethod()); 499 XmlUtil.writeNextValue(out, XML_TAG_RESTRICTION, param.getRestriction()); 500 XmlUtil.writeNextValue(out, XML_TAG_SERVER_URI, param.getServerUri()); 501 XmlUtil.writeNextValue(out, XML_TAG_USERNAME, param.getUsername()); 502 XmlUtil.writeNextValue(out, XML_TAG_PASSWORD, param.getBase64EncodedPassword()); 503 XmlUtil.writeNextValue(out, XML_TAG_TRUST_ROOT_CERT_URL, param.getTrustRootCertUrl()); 504 XmlUtil.writeNextValue(out, XML_TAG_TRUST_ROOT_CERT_SHA256_FINGERPRINT, 505 param.getTrustRootCertSha256Fingerprint()); 506 XmlUtil.writeNextSectionEnd(out, type); 507 } 508 509 /** 510 * Serialize a Protocol-to-Ports map to an output stream as a XML block. We're not able 511 * to use {@link XmlUtil#writeNextValue} to write this map, since that function only works for 512 * maps with String key. 513 * 514 * @param out The output stream to serialize data to 515 * @param protoPortMap The proto port map to serialize 516 * @throws XmlPullParserException 517 * @throws IOException 518 */ serializeProtoPortMap(XmlSerializer out, Map<Integer, String> protoPortMap)519 private static void serializeProtoPortMap(XmlSerializer out, Map<Integer, String> protoPortMap) 520 throws XmlPullParserException, IOException { 521 if (protoPortMap == null) { 522 return; 523 } 524 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_REQUIRED_PROTO_PORT_MAP); 525 for (Map.Entry<Integer, String> entry : protoPortMap.entrySet()) { 526 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_PROTO_PORT); 527 XmlUtil.writeNextValue(out, XML_TAG_PROTO, entry.getKey()); 528 XmlUtil.writeNextValue(out, XML_TAG_PORTS, entry.getValue()); 529 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_PROTO_PORT); 530 } 531 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_REQUIRED_PROTO_PORT_MAP); 532 } 533 534 /** 535 * Serialize a AAA server trusted name list to an output stream as a XML block. 536 * 537 * @param out The output stream to serialize data to 538 * @param aaaServerTrustedNames The name list to serialize 539 * @throws XmlPullParserException 540 * @throws IOException 541 */ serializeAaaServerTrustedNames( XmlSerializer out, String[] aaaServerTrustedNames)542 private static void serializeAaaServerTrustedNames( 543 XmlSerializer out, String[] aaaServerTrustedNames) 544 throws XmlPullParserException, IOException { 545 if (null == aaaServerTrustedNames) return; 546 if (aaaServerTrustedNames.length == 0) return; 547 548 XmlUtil.writeNextSectionStart(out, XML_TAG_SECTION_HEADER_AAA_SERVER_TRUSTED_NAMES); 549 for (String fqdn: aaaServerTrustedNames) { 550 XmlUtil.writeNextValue(out, XML_TAG_FQDN, fqdn); 551 } 552 XmlUtil.writeNextSectionEnd(out, XML_TAG_SECTION_HEADER_AAA_SERVER_TRUSTED_NAMES); 553 } 554 555 /** 556 * Deserialize a {@link HomeSp} from an input stream. 557 * 558 * @param in The input stream to read data from 559 * @param outerTagDepth The tag depth of the current XML section 560 * @return {@link HomeSp} 561 * @throws XmlPullParserException 562 * @throws IOException 563 */ deserializeHomeSP(XmlPullParser in, int outerTagDepth)564 private static HomeSp deserializeHomeSP(XmlPullParser in, int outerTagDepth) 565 throws XmlPullParserException, IOException { 566 HomeSp homeSp = new HomeSp(); 567 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 568 String[] valueName = new String[1]; 569 Object value = XmlUtil.readCurrentValue(in, valueName); 570 if (valueName[0] == null) { 571 throw new XmlPullParserException("Missing value name"); 572 } 573 switch (valueName[0]) { 574 case XML_TAG_FQDN: 575 homeSp.setFqdn((String) value); 576 break; 577 case XML_TAG_FRIENDLY_NAME: 578 homeSp.setFriendlyName((String) value); 579 break; 580 case XML_TAG_ICON_URL: 581 homeSp.setIconUrl((String) value); 582 break; 583 case XML_TAG_HOME_NETWORK_IDS: 584 homeSp.setHomeNetworkIds((Map<String, Long>) value); 585 break; 586 case XML_TAG_MATCH_ALL_OIS: 587 homeSp.setMatchAllOis((long[]) value); 588 break; 589 case XML_TAG_MATCH_ANY_OIS: 590 homeSp.setMatchAnyOis((long[]) value); 591 break; 592 case XML_TAG_ROAMING_CONSORTIUM_OIS: 593 homeSp.setRoamingConsortiumOis((long[]) value); 594 break; 595 case XML_TAG_OTHER_HOME_PARTNERS: 596 homeSp.setOtherHomePartners((String[]) value); 597 break; 598 default: 599 Log.w(TAG, "Unknown data under HomeSP: " + valueName[0]); 600 } 601 } 602 return homeSp; 603 } 604 605 /** 606 * Deserialize a {@link Credential} from an input stream. 607 * 608 * @param in The input stream to read data from 609 * @param outerTagDepth The tag depth of the current XML section 610 * @return {@link Credential} 611 * @throws XmlPullParserException 612 * @throws IOException 613 */ deserializeCredential(XmlPullParser in, int outerTagDepth)614 private static Credential deserializeCredential(XmlPullParser in, int outerTagDepth) 615 throws XmlPullParserException, IOException { 616 Credential credential = new Credential(); 617 while (XmlUtil.nextElementWithin(in, outerTagDepth)) { 618 if (isValueElement(in)) { 619 // Value elements. 620 String[] name = new String[1]; 621 Object value = XmlUtil.readCurrentValue(in, name); 622 switch (name[0]) { 623 case XML_TAG_CREATION_TIME: 624 credential.setCreationTimeInMillis((long) value); 625 break; 626 case XML_TAG_EXPIRATION_TIME: 627 credential.setExpirationTimeInMillis((long) value); 628 break; 629 case XML_TAG_REALM: 630 credential.setRealm((String) value); 631 break; 632 case XML_TAG_CHECK_AAA_SERVER_CERT_STATUS: 633 credential.setCheckAaaServerCertStatus((boolean) value); 634 break; 635 case XML_TAG_MINIMUM_TLS_VERSION: 636 credential.setMinimumTlsVersion((int) value); 637 break; 638 default: 639 Log.w(TAG, "Unknown value under Credential: " 640 + name[0]); 641 } 642 } else { 643 // Subsection elements. 644 switch (in.getName()) { 645 case XML_TAG_SECTION_HEADER_USER_CREDENTIAL: 646 credential.setUserCredential( 647 deserializeUserCredential(in, outerTagDepth + 1)); 648 break; 649 case XML_TAG_SECTION_HEADER_CERT_CREDENTIAL: 650 credential.setCertCredential( 651 deserializeCertCredential(in, outerTagDepth + 1)); 652 break; 653 case XML_TAG_SECTION_HEADER_SIM_CREDENTIAL: 654 credential.setSimCredential( 655 deserializeSimCredential(in, outerTagDepth + 1)); 656 break; 657 default: 658 Log.w(TAG, "Unknown section under Credential: " 659 + in.getName()); 660 } 661 } 662 } 663 return credential; 664 } 665 666 /** 667 * Deserialize a {@link Policy} from an input stream. 668 * 669 * @param in The input stream to read data from 670 * @param outerTagDepth The tag depth of the current XML section 671 * @return {@link Policy} 672 * @throws XmlPullParserException 673 * @throws IOException 674 */ deserializePolicy(XmlPullParser in, int outerTagDepth)675 private static Policy deserializePolicy(XmlPullParser in, int outerTagDepth) 676 throws XmlPullParserException, IOException { 677 Policy policy = new Policy(); 678 while (XmlUtil.nextElementWithin(in, outerTagDepth)) { 679 if (isValueElement(in)) { 680 // Value elements. 681 String[] name = new String[1]; 682 Object value = XmlUtil.readCurrentValue(in, name); 683 switch (name[0]) { 684 case XML_TAG_MIN_HOME_DOWNLINK_BANDWIDTH: 685 policy.setMinHomeDownlinkBandwidth((long) value); 686 break; 687 case XML_TAG_MIN_HOME_UPLINK_BANDWIDTH: 688 policy.setMinHomeUplinkBandwidth((long) value); 689 break; 690 case XML_TAG_MIN_ROAMING_DOWNLINK_BANDWIDTH: 691 policy.setMinRoamingDownlinkBandwidth((long) value); 692 break; 693 case XML_TAG_MIN_ROAMING_UPLINK_BANDWIDTH: 694 policy.setMinRoamingUplinkBandwidth((long) value); 695 break; 696 case XML_TAG_EXCLUDED_SSID_LIST: 697 policy.setExcludedSsidList((String[]) value); 698 break; 699 case XML_TAG_MAXIMUM_BSS_LOAD_VALUE: 700 policy.setMaximumBssLoadValue((int) value); 701 break; 702 } 703 } else { 704 // Subsection elements. 705 switch (in.getName()) { 706 case XML_TAG_SECTION_HEADER_REQUIRED_PROTO_PORT_MAP: 707 policy.setRequiredProtoPortMap( 708 deserializeProtoPortMap(in, outerTagDepth + 1)); 709 break; 710 case XML_TAG_SECTION_HEADER_POLICY_UPDATE: 711 policy.setPolicyUpdate(deserializeUpdateParameter(in, outerTagDepth + 1)); 712 break; 713 case XML_TAG_SECTION_HEADER_PREFERRED_ROAMING_PARTNER_LIST: 714 policy.setPreferredRoamingPartnerList( 715 deserializePreferredRoamingPartnerList(in, outerTagDepth + 1)); 716 break; 717 default: 718 Log.w(TAG, "Unknown section under Policy: " 719 + in.getName()); 720 } 721 } 722 } 723 return policy; 724 } 725 726 /** 727 * Deserialize a {@link android.net.wifi.hotspot2.pps.Credential.UserCredential} from an 728 * input stream. 729 * 730 * @param in The input stream to read data from 731 * @param outerTagDepth The tag depth of the current XML section 732 * @return {@link android.net.wifi.hotspot2.pps.Credential.UserCredential} 733 * @throws XmlPullParserException 734 * @throws IOException 735 */ deserializeUserCredential(XmlPullParser in, int outerTagDepth)736 private static Credential.UserCredential deserializeUserCredential(XmlPullParser in, 737 int outerTagDepth) throws XmlPullParserException, IOException { 738 Credential.UserCredential userCredential = new Credential.UserCredential(); 739 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 740 String[] valueName = new String[1]; 741 Object value = XmlUtil.readCurrentValue(in, valueName); 742 if (valueName[0] == null) { 743 throw new XmlPullParserException("Missing value name"); 744 } 745 switch (valueName[0]) { 746 case XML_TAG_USERNAME: 747 userCredential.setUsername((String) value); 748 break; 749 case XML_TAG_PASSWORD: 750 userCredential.setPassword((String) value); 751 break; 752 case XML_TAG_MACHINE_MANAGED: 753 userCredential.setMachineManaged((boolean) value); 754 break; 755 case XML_TAG_SOFT_TOKEN_APP: 756 userCredential.setSoftTokenApp((String) value); 757 break; 758 case XML_TAG_ABLE_TO_SHARE: 759 userCredential.setAbleToShare((boolean) value); 760 break; 761 case XML_TAG_EAP_TYPE: 762 userCredential.setEapType((int) value); 763 break; 764 case XML_TAG_NON_EAP_INNER_METHOD: 765 userCredential.setNonEapInnerMethod((String) value); 766 break; 767 default: 768 Log.w(TAG, "Unknown value under UserCredential: " 769 + valueName[0]); 770 } 771 } 772 return userCredential; 773 } 774 775 /** 776 * Deserialize a {@link android.net.wifi.hotspot2.pps.Credential.CertificateCredential} 777 * from an input stream. 778 * 779 * @param in The input stream to read data from 780 * @param outerTagDepth The tag depth of the current XML section 781 * @return {@link android.net.wifi.hotspot2.pps.Credential.CertificateCredential} 782 * @throws XmlPullParserException 783 * @throws IOException 784 */ deserializeCertCredential(XmlPullParser in, int outerTagDepth)785 private static Credential.CertificateCredential deserializeCertCredential(XmlPullParser in, 786 int outerTagDepth) throws XmlPullParserException, IOException { 787 Credential.CertificateCredential certCredential = new Credential.CertificateCredential(); 788 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 789 String[] valueName = new String[1]; 790 Object value = XmlUtil.readCurrentValue(in, valueName); 791 if (valueName[0] == null) { 792 throw new XmlPullParserException("Missing value name"); 793 } 794 switch (valueName[0]) { 795 case XML_TAG_CERT_TYPE: 796 certCredential.setCertType((String) value); 797 break; 798 case XML_TAG_CERT_SHA256_FINGERPRINT: 799 certCredential.setCertSha256Fingerprint((byte[]) value); 800 break; 801 default: 802 Log.w(TAG, "Unknown value under CertCredential: " 803 + valueName[0]); 804 } 805 } 806 return certCredential; 807 } 808 809 /** 810 * Deserialize a {@link android.net.wifi.hotspot2.pps.Credential.SimCredential} from an 811 * input stream. 812 * 813 * @param in The input stream to read data from 814 * @param outerTagDepth The tag depth of the current XML section 815 * @return {@link android.net.wifi.hotspot2.pps.Credential.SimCredential} 816 * @throws XmlPullParserException 817 * @throws IOException 818 */ deserializeSimCredential(XmlPullParser in, int outerTagDepth)819 private static Credential.SimCredential deserializeSimCredential(XmlPullParser in, 820 int outerTagDepth) throws XmlPullParserException, IOException { 821 Credential.SimCredential simCredential = new Credential.SimCredential(); 822 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 823 String[] valueName = new String[1]; 824 Object value = XmlUtil.readCurrentValue(in, valueName); 825 if (valueName[0] == null) { 826 throw new XmlPullParserException("Missing value name"); 827 } 828 switch (valueName[0]) { 829 case XML_TAG_IMSI: 830 simCredential.setImsi((String) value); 831 break; 832 case XML_TAG_EAP_TYPE: 833 simCredential.setEapType((int) value); 834 break; 835 default: 836 Log.w(TAG, "Unknown value under CertCredential: " 837 + valueName[0]); 838 } 839 } 840 return simCredential; 841 } 842 843 /** 844 * Deserialize a list of {@link android.net.wifi.hotspot2.pps.Policy.RoamingPartner} from an 845 * input stream. 846 * 847 * @param in The input stream to read data from 848 * @param outerTagDepth The tag depth of the current XML section 849 * @return List of {@link android.net.wifi.hotspot2.pps.Policy.RoamingPartner} 850 * @throws XmlPullParserException 851 * @throws IOException 852 */ deserializePreferredRoamingPartnerList( XmlPullParser in, int outerTagDepth)853 private static List<Policy.RoamingPartner> deserializePreferredRoamingPartnerList( 854 XmlPullParser in, int outerTagDepth) throws XmlPullParserException, IOException { 855 List<Policy.RoamingPartner> roamingPartnerList = new ArrayList<>(); 856 while (XmlUtil.gotoNextSectionWithNameOrEnd(in, XML_TAG_SECTION_HEADER_ROAMING_PARTNER, 857 outerTagDepth)) { 858 roamingPartnerList.add(deserializeRoamingPartner(in, outerTagDepth + 1)); 859 } 860 return roamingPartnerList; 861 } 862 863 /** 864 * Deserialize a {@link android.net.wifi.hotspot2.pps.Policy.RoamingPartner} from an input 865 * stream. 866 * 867 * @param in The input stream to read data from 868 * @param outerTagDepth The tag depth of the current XML section 869 * @return {@link android.net.wifi.hotspot2.pps.Policy.RoamingPartner} 870 * @throws XmlPullParserException 871 * @throws IOException 872 */ deserializeRoamingPartner(XmlPullParser in, int outerTagDepth)873 private static Policy.RoamingPartner deserializeRoamingPartner(XmlPullParser in, 874 int outerTagDepth) throws XmlPullParserException, IOException { 875 Policy.RoamingPartner partner = new Policy.RoamingPartner(); 876 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 877 String[] valueName = new String[1]; 878 Object value = XmlUtil.readCurrentValue(in, valueName); 879 if (valueName[0] == null) { 880 throw new XmlPullParserException("Missing value name"); 881 } 882 switch (valueName[0]) { 883 case XML_TAG_FQDN: 884 partner.setFqdn((String) value); 885 break; 886 case XML_TAG_FQDN_EXACT_MATCH: 887 partner.setFqdnExactMatch((boolean) value); 888 break; 889 case XML_TAG_PRIORITY: 890 partner.setPriority((int) value); 891 break; 892 case XML_TAG_COUNTRIES: 893 partner.setCountries((String) value); 894 break; 895 default: 896 Log.w(TAG, "Unknown value under RoamingPartner: " 897 + valueName[0]); 898 } 899 } 900 return partner; 901 } 902 903 /** 904 * Deserialize a {@link UpdateParameter} from an input stream. 905 * 906 * @param in The input stream to read data from 907 * @param outerTagDepth The tag depth of the current XML section 908 * @return {@link UpdateParameter} 909 * @throws XmlPullParserException 910 * @throws IOException 911 */ deserializeUpdateParameter(XmlPullParser in, int outerTagDepth)912 private static UpdateParameter deserializeUpdateParameter(XmlPullParser in, 913 int outerTagDepth) throws XmlPullParserException, IOException { 914 UpdateParameter param = new UpdateParameter(); 915 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 916 String[] valueName = new String[1]; 917 Object value = XmlUtil.readCurrentValue(in, valueName); 918 if (valueName[0] == null) { 919 throw new XmlPullParserException("Missing value name"); 920 } 921 switch (valueName[0]) { 922 case XML_TAG_UPDATE_INTERVAL: 923 param.setUpdateIntervalInMinutes((long) value); 924 break; 925 case XML_TAG_UPDATE_METHOD: 926 param.setUpdateMethod((String) value); 927 break; 928 case XML_TAG_RESTRICTION: 929 param.setRestriction((String) value); 930 break; 931 case XML_TAG_SERVER_URI: 932 param.setServerUri((String) value); 933 break; 934 case XML_TAG_USERNAME: 935 param.setUsername((String) value); 936 break; 937 case XML_TAG_PASSWORD: 938 param.setBase64EncodedPassword((String) value); 939 break; 940 case XML_TAG_TRUST_ROOT_CERT_URL: 941 param.setTrustRootCertUrl((String) value); 942 break; 943 case XML_TAG_TRUST_ROOT_CERT_SHA256_FINGERPRINT: 944 param.setTrustRootCertSha256Fingerprint((byte[]) value); 945 break; 946 default: 947 Log.w(TAG, "Unknown value under UpdateParameter: " 948 + valueName[0]); 949 } 950 } 951 return param; 952 } 953 954 /** 955 * Deserialize a Protocol-Port map from an input stream. 956 * 957 * @param in The input stream to read data from 958 * @param outerTagDepth The tag depth of the current XML section 959 * @return Proocol-Port map 960 * @throws XmlPullParserException 961 * @throws IOException 962 */ deserializeProtoPortMap(XmlPullParser in, int outerTagDepth)963 private static Map<Integer, String> deserializeProtoPortMap(XmlPullParser in, 964 int outerTagDepth) throws XmlPullParserException, IOException { 965 Map<Integer, String> protoPortMap = new HashMap<>(); 966 while (XmlUtil.gotoNextSectionWithNameOrEnd(in, XML_TAG_SECTION_HEADER_PROTO_PORT, 967 outerTagDepth)) { 968 int proto = (int) XmlUtil.readNextValueWithName(in, XML_TAG_PROTO); 969 String ports = (String) XmlUtil.readNextValueWithName(in, XML_TAG_PORTS); 970 protoPortMap.put(proto, ports); 971 } 972 return protoPortMap; 973 } 974 975 /** 976 * Deserializen a AAA server trusted name list from an input stream. 977 * 978 * @param in The input stream to read data from 979 * @param outerTagDepth The tag depth of the current XML section 980 * @return a name array 981 * @throws XmlPullParserException 982 * @throws IOException 983 */ deserializeAaaServerTrustedNames(XmlPullParser in, int outerTagDepth)984 private static String[] deserializeAaaServerTrustedNames(XmlPullParser in, int outerTagDepth) 985 throws XmlPullParserException, IOException { 986 ArrayList<String> list = new ArrayList<>(); 987 while (!XmlUtil.isNextSectionEnd(in, outerTagDepth)) { 988 String[] valueName = new String[1]; 989 Object value = XmlUtil.readCurrentValue(in, valueName); 990 if (valueName[0] == null) { 991 throw new XmlPullParserException("Missing value name"); 992 } 993 switch (valueName[0]) { 994 case XML_TAG_FQDN: 995 list.add((String) value); 996 break; 997 default: 998 Log.w(TAG, "Unknown data under " 999 + XML_TAG_SECTION_HEADER_AAA_SERVER_TRUSTED_NAMES 1000 + ": " + valueName[0]); 1001 } 1002 } 1003 return list.size() > 0 ? list.toArray(new String[0]) : null; 1004 } 1005 1006 /** 1007 * Determine if the current element is a value or a section. The "name" attribute of the 1008 * element is used as the indicator, when it is present, the element is considered a value 1009 * element. 1010 * 1011 * Value element: 1012 * <int name="test">12</int> 1013 * 1014 * Section element: 1015 * <Test> 1016 * ... 1017 * </Test> 1018 * 1019 * @param in XML input stream 1020 * @return true if the current element is a value 1021 */ isValueElement(XmlPullParser in)1022 private static boolean isValueElement(XmlPullParser in) { 1023 return in.getAttributeValue(null, "name") != null; 1024 } 1025 } 1026