SupplicantStaNetworkHal.java revision 64950d46f5469e5e6ce32ccc81a1f751c40f4202 
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 */
16package com.android.server.wifi;
17
18import android.hardware.wifi.supplicant.V1_0.ISupplicantStaNetwork;
19import android.hardware.wifi.supplicant.V1_0.ISupplicantStaNetworkCallback;
20import android.hardware.wifi.supplicant.V1_0.SupplicantStatus;
21import android.hardware.wifi.supplicant.V1_0.SupplicantStatusCode;
22import android.net.wifi.WifiConfiguration;
23import android.net.wifi.WifiEnterpriseConfig;
24import android.os.HandlerThread;
25import android.os.RemoteException;
26import android.text.TextUtils;
27import android.util.Log;
28import android.util.MutableBoolean;
29
30import com.android.internal.annotations.VisibleForTesting;
31import com.android.internal.util.ArrayUtils;
32
33import libcore.util.HexEncoding;
34
35import java.nio.charset.StandardCharsets;
36import java.util.ArrayList;
37import java.util.BitSet;
38import java.util.HashMap;
39import java.util.Map;
40/**
41 * Wrapper class for ISupplicantStaNetwork HAL calls. Gets and sets supplicant sta network variables
42 * and interacts with networks.
43 * Public fields should be treated as invalid until their 'get' method is called, which will set the
44 * value if it returns true
45 */
46public class SupplicantStaNetworkHal {
47    private static final String TAG = "SupplicantStaNetworkHal";
48    private static final boolean DBG = false;
49    private static final String ANY_BSSID_STR = "any";
50    private static final byte[] ANY_BSSID_BYTES = {0, 0, 0, 0, 0, 0};
51    private static final int BSSID_LENGTH = 6;
52    @VisibleForTesting
53    public static final String ID_STRING_KEY_FQDN = "fqdn";
54    @VisibleForTesting
55    public static final String ID_STRING_KEY_CREATOR_UID = "creatorUid";
56    @VisibleForTesting
57    public static final String ID_STRING_KEY_CONFIG_KEY = "configKey";
58
59    private final Object mLock = new Object();
60    private ISupplicantStaNetwork mISupplicantStaNetwork = null;
61    private final HandlerThread mHandlerThread;
62    private int mNetworkId;
63    private String mIfaceName;
64    private ArrayList<Byte> mSsid;
65    private byte[/* 6 */] mBssid;
66    private boolean mScanSsid;
67    private int mKeyMgmtMask;
68    private int mProtoMask;
69    private int mAuthAlgMask;
70    private int mGroupCipherMask;
71    private int mPairwiseCipherMask;
72    private String mPskPassphrase;
73    private ArrayList<Byte> mWepKey;
74    private int mWepTxKeyIdx;
75    private boolean mRequirePmf;
76    private String mIdStr;
77    private int mEapMethod;
78    private int mEapPhase2Method;
79    private ArrayList<Byte> mEapIdentity;
80    private ArrayList<Byte> mEapAnonymousIdentity;
81    private ArrayList<Byte> mEapPassword;
82    private String mEapCACert;
83    private String mEapCAPath;
84    private String mEapClientCert;
85    private String mEapPrivateKey;
86    private String mEapSubjectMatch;
87    private String mEapAltSubjectMatch;
88    private boolean mEapEngine;
89    private String mEapEngineID;
90    private String mEapDomainSuffixMatch;
91
92    SupplicantStaNetworkHal(ISupplicantStaNetwork iSupplicantStaNetwork,
93                            HandlerThread handlerThread) {
94        mISupplicantStaNetwork = iSupplicantStaNetwork;
95        mHandlerThread = handlerThread;
96    }
97
98    /**
99     * Read network variables from wpa_supplicant into the provided WifiConfiguration object.
100     *
101     * @param config        WifiConfiguration object to be populated.
102     * @param networkExtras Map of network extras parsed from wpa_supplicant.
103     * @return true if succeeds, false otherwise.
104     */
105    public boolean loadWifiConfiguration(WifiConfiguration config,
106                                         Map<String, String> networkExtras) {
107        if (config == null) return false;
108        /** SSID */
109        config.SSID = null;
110        if (getSsid() && !ArrayUtils.isEmpty(mSsid)) {
111            config.SSID = decodeSsid(mSsid);
112        } else {
113            Log.e(TAG, "failed to read ssid");
114            return false;
115        }
116        /** BSSID */
117        config.getNetworkSelectionStatus().setNetworkSelectionBSSID(null);
118        if (getBssid() && !ArrayUtils.isEmpty(mBssid)) {
119            config.getNetworkSelectionStatus().setNetworkSelectionBSSID(
120                    macAddressFromByteArray(mBssid));
121        }
122        /** Scan SSID (Is Hidden Network?) */
123        config.hiddenSSID = false;
124        if (getScanSsid()) {
125            config.hiddenSSID = mScanSsid;
126        }
127        /** Require PMF*/
128        config.requirePMF = false;
129        if (getRequirePmf()) {
130            config.requirePMF = mRequirePmf;
131        }
132        /** WEP keys **/
133        config.wepTxKeyIndex = -1;
134        if (getWepTxKeyIdx()) {
135            config.wepTxKeyIndex = mWepTxKeyIdx;
136        }
137        for (int i = 0; i < 4; i++) {
138            config.wepKeys[i] = null;
139            if (getWepKey(i) && !ArrayUtils.isEmpty(mWepKey)) {
140                config.wepKeys[i] = stringFromByteArrayList(mWepKey);
141            }
142        }
143        /** PSK pass phrase */
144        config.preSharedKey = null;
145        if (getPskPassphrase() && !TextUtils.isEmpty(mPskPassphrase)) {
146            config.preSharedKey = mPskPassphrase;
147        }
148        /** allowedKeyManagement */
149        if (getKeyMgmt()) {
150            config.allowedKeyManagement =
151                    supplicantToWifiConfigurationKeyMgmtMask(mKeyMgmtMask);
152        }
153        /** allowedProtocols */
154        if (getProto()) {
155            config.allowedProtocols =
156                    supplicantToWifiConfigurationProtoMask(mProtoMask);
157        }
158        /** allowedAuthAlgorithms */
159        if (getAuthAlg()) {
160            config.allowedAuthAlgorithms =
161                    supplicantToWifiConfigurationAuthAlgMask(mAuthAlgMask);
162        }
163        /** allowedGroupCiphers */
164        if (getGroupCipher()) {
165            config.allowedGroupCiphers =
166                    supplicantToWifiConfigurationGroupCipherMask(mGroupCipherMask);
167        }
168        /** allowedPairwiseCiphers */
169        if (getPairwiseCipher()) {
170            config.allowedPairwiseCiphers =
171                    supplicantToWifiConfigurationPairwiseCipherMask(mPairwiseCipherMask);
172        }
173        /** metadata: idstr */
174        if (getIdStr() && !TextUtils.isEmpty(mIdStr)) {
175            Map<String, String> metadata = WifiNative.parseNetworkExtra(mIdStr);
176            networkExtras.putAll(metadata);
177        } else {
178            Log.e(TAG, "getIdStr failed");
179            return false;
180        }
181        return loadWifiEnterpriseConfig(config.SSID, config.enterpriseConfig);
182    }
183
184    /**
185     * Save an entire WifiConfiguration to wpa_supplicant via HIDL.
186     *
187     * @param config WifiConfiguration object to be saved.
188     * @return true if succeeds, false otherwise.
189     */
190    public boolean saveWifiConfiguration(WifiConfiguration config) {
191        if (config == null) return false;
192        /** SSID */
193        if (config.SSID != null) {
194            if (!setSsid(encodeSsid(config.SSID))) {
195                Log.e(TAG, "failed to set SSID: " + config.SSID);
196                return false;
197            }
198        }
199        /** BSSID */
200        String bssidStr = config.getNetworkSelectionStatus().getNetworkSelectionBSSID();
201        if (bssidStr != null) {
202            byte[] bssid = macAddressToByteArray(bssidStr);
203            if (!setBssid(bssid)) {
204                Log.e(TAG, "failed to set BSSID: " + bssidStr);
205                return false;
206            }
207        }
208        /** Pre Shared Key */
209        if (config.preSharedKey != null && !setPskPassphrase(config.preSharedKey)) {
210            Log.e(TAG, "failed to set psk");
211            return false;
212        }
213        /** Wep Keys */
214        boolean hasSetKey = false;
215        if (config.wepKeys != null) {
216            for (int i = 0; i < config.wepKeys.length; i++) {
217                // Prevent client screw-up by passing in a WifiConfiguration we gave it
218                // by preventing "*" as a key.
219                if (config.wepKeys[i] != null && !config.wepKeys[i].equals("*")) {
220                    if (!setWepKey(i, stringToByteArrayList(config.wepKeys[i]))) {
221                        Log.e(TAG, "failed to set wep_key " + i);
222                        return false;
223                    }
224                    hasSetKey = true;
225                }
226            }
227        }
228        /** Wep Tx Key Idx */
229        if (hasSetKey) {
230            if (!setWepTxKeyIdx(config.wepTxKeyIndex)) {
231                Log.e(TAG, "failed to set wep_tx_keyidx: " + config.wepTxKeyIndex);
232                return false;
233            }
234        }
235        /** HiddenSSID */
236        if (!setScanSsid(config.hiddenSSID)) {
237            Log.e(TAG, config.SSID + ": failed to set hiddenSSID: " + config.hiddenSSID);
238            return false;
239        }
240        /** RequirePMF */
241        if (!setRequirePmf(config.requirePMF)) {
242            Log.e(TAG, config.SSID + ": failed to set requirePMF: " + config.requirePMF);
243            return false;
244        }
245        /** Key Management Scheme */
246        if (config.allowedKeyManagement.cardinality() != 0
247                && !setKeyMgmt(wifiConfigurationToSupplicantKeyMgmtMask(
248                config.allowedKeyManagement))) {
249            Log.e(TAG, "failed to set Key Management");
250            return false;
251        }
252        /** Security Protocol */
253        if (config.allowedProtocols.cardinality() != 0
254                && !setProto(wifiConfigurationToSupplicantProtoMask(config.allowedProtocols))) {
255            Log.e(TAG, "failed to set Security Protocol");
256            return false;
257        }
258        /** Auth Algorithm */
259        if (config.allowedAuthAlgorithms.cardinality() != 0
260                && !setAuthAlg(wifiConfigurationToSupplicantAuthAlgMask(
261                config.allowedAuthAlgorithms))) {
262            Log.e(TAG, "failed to set AuthAlgorithm");
263            return false;
264        }
265        /** Group Cipher */
266        if (config.allowedGroupCiphers.cardinality() != 0
267                && !setGroupCipher(wifiConfigurationToSupplicantGroupCipherMask(
268                config.allowedGroupCiphers))) {
269            Log.e(TAG, "failed to set Group Cipher");
270            return false;
271        }
272        /** Pairwise Cipher*/
273        if (config.allowedPairwiseCiphers.cardinality() != 0
274                && !setPairwiseCipher(wifiConfigurationToSupplicantPairwiseCipherMask(
275                        config.allowedPairwiseCiphers))) {
276            Log.e(TAG, "failed to set PairwiseCipher");
277            return false;
278        }
279        /** metadata: FQDN + ConfigKey + CreatorUid */
280        final Map<String, String> metadata = new HashMap<String, String>();
281        if (config.isPasspoint()) {
282            metadata.put(ID_STRING_KEY_FQDN, config.FQDN);
283        }
284        metadata.put(ID_STRING_KEY_CONFIG_KEY, config.configKey());
285        metadata.put(ID_STRING_KEY_CREATOR_UID, Integer.toString(config.creatorUid));
286        if (!setIdStr(WifiNative.createNetworkExtra(metadata))) {
287            Log.e(TAG, "failed to set id string");
288            return false;
289        }
290        /** UpdateIdentifier */
291        if (config.updateIdentifier != null
292                && !setUpdateIdentifier(Integer.parseInt(config.updateIdentifier))) {
293            Log.e(TAG, "failed to set update identifier");
294            return false;
295        }
296        // Finish here if no EAP config to set
297        if (config.enterpriseConfig == null
298                || config.enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.NONE) {
299            return true;
300        } else {
301            return saveWifiEnterpriseConfig(config.SSID, config.enterpriseConfig);
302        }
303    }
304
305    /**
306     * Read network variables from wpa_supplicant into the provided WifiEnterpriseConfig object.
307     *
308     * @param ssid SSID of the network. (Used for logging purposes only)
309     * @param eapConfig WifiEnterpriseConfig object to be populated.
310     * @return true if succeeds, false otherwise.
311     */
312    private boolean loadWifiEnterpriseConfig(String ssid, WifiEnterpriseConfig eapConfig) {
313        if (eapConfig == null) return false;
314        /** EAP method */
315        if (getEapMethod()) {
316            eapConfig.setEapMethod(supplicantToWifiConfigurationEapMethod(mEapMethod));
317        } else {
318            // Invalid eap method could be because it's not an enterprise config.
319            Log.e(TAG, "failed to get eap method. Assumimg not an enterprise network");
320            return true;
321        }
322        /** EAP Phase 2 method */
323        if (getEapPhase2Method()) {
324            eapConfig.setPhase2Method(
325                    supplicantToWifiConfigurationEapPhase2Method(mEapPhase2Method));
326        } else {
327            // We cannot have an invalid eap phase 2 method. Return failure.
328            Log.e(TAG, "failed to get eap phase2 method");
329            return false;
330        }
331        /** EAP Identity */
332        if (getEapIdentity() && !ArrayUtils.isEmpty(mEapIdentity)) {
333            eapConfig.setFieldValue(
334                    WifiEnterpriseConfig.IDENTITY_KEY, stringFromByteArrayList(mEapIdentity));
335        }
336        /** EAP Anonymous Identity */
337        if (getEapAnonymousIdentity() && !ArrayUtils.isEmpty(mEapAnonymousIdentity)) {
338            eapConfig.setFieldValue(
339                    WifiEnterpriseConfig.ANON_IDENTITY_KEY,
340                    stringFromByteArrayList(mEapAnonymousIdentity));
341        }
342        /** EAP Password */
343        if (getEapPassword() && !ArrayUtils.isEmpty(mEapPassword)) {
344            eapConfig.setFieldValue(
345                    WifiEnterpriseConfig.PASSWORD_KEY, stringFromByteArrayList(mEapPassword));
346        }
347        /** EAP Client Cert */
348        if (getEapClientCert() && !TextUtils.isEmpty(mEapClientCert)) {
349            eapConfig.setFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY, mEapClientCert);
350        }
351        /** EAP CA Cert */
352        if (getEapCACert() && !TextUtils.isEmpty(mEapCACert)) {
353            eapConfig.setFieldValue(WifiEnterpriseConfig.CA_CERT_KEY, mEapCACert);
354        }
355        /** EAP Subject Match */
356        if (getEapSubjectMatch() && !TextUtils.isEmpty(mEapSubjectMatch)) {
357            eapConfig.setFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY, mEapSubjectMatch);
358        }
359        /** EAP Engine ID */
360        if (getEapEngineID() && !TextUtils.isEmpty(mEapEngineID)) {
361            eapConfig.setFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY, mEapEngineID);
362        }
363        /** EAP Engine. Set this only if the engine id is non null. */
364        if (getEapEngine() && !TextUtils.isEmpty(mEapEngineID)) {
365            eapConfig.setFieldValue(
366                    WifiEnterpriseConfig.ENGINE_KEY,
367                    mEapEngine
368                            ? WifiEnterpriseConfig.ENGINE_ENABLE
369                            : WifiEnterpriseConfig.ENGINE_DISABLE);
370        }
371        /** EAP Private Key */
372        if (getEapPrivateKey() && !TextUtils.isEmpty(mEapPrivateKey)) {
373            eapConfig.setFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, mEapPrivateKey);
374        }
375        /** EAP Alt Subject Match */
376        if (getEapAltSubjectMatch() && !TextUtils.isEmpty(mEapAltSubjectMatch)) {
377            eapConfig.setFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY, mEapAltSubjectMatch);
378        }
379        /** EAP Domain Suffix Match */
380        if (getEapDomainSuffixMatch() && !TextUtils.isEmpty(mEapDomainSuffixMatch)) {
381            eapConfig.setFieldValue(
382                    WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY, mEapDomainSuffixMatch);
383        }
384        /** EAP CA Path*/
385        if (getEapCAPath() && !TextUtils.isEmpty(mEapCAPath)) {
386            eapConfig.setFieldValue(WifiEnterpriseConfig.CA_PATH_KEY, mEapCAPath);
387        }
388        return true;
389    }
390
391    /**
392     * Save network variables from the provided WifiEnterpriseConfig object to wpa_supplicant.
393     *
394     * @param ssid SSID of the network. (Used for logging purposes only)
395     * @param eapConfig WifiEnterpriseConfig object to be saved.
396     * @return true if succeeds, false otherwise.
397     */
398    private boolean saveWifiEnterpriseConfig(String ssid, WifiEnterpriseConfig eapConfig) {
399        if (eapConfig == null) return false;
400        /** EAP method */
401        if (!setEapMethod(wifiConfigurationToSupplicantEapMethod(eapConfig.getEapMethod()))) {
402            Log.e(TAG, ssid + ": failed to set eap method: " + eapConfig.getEapMethod());
403            return false;
404        }
405        /** EAP Phase 2 method */
406        if (!setEapPhase2Method(wifiConfigurationToSupplicantEapPhase2Method(
407                eapConfig.getPhase2Method()))) {
408            Log.e(TAG, ssid + ": failed to set eap phase 2 method: " + eapConfig.getPhase2Method());
409            return false;
410        }
411        String eapParam = null;
412        /** EAP Identity */
413        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.IDENTITY_KEY);
414        if (!TextUtils.isEmpty(eapParam) && !setEapIdentity(stringToByteArrayList(eapParam))) {
415            Log.e(TAG, ssid + ": failed to set eap identity: " + eapParam);
416            return false;
417        }
418        /** EAP Anonymous Identity */
419        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.ANON_IDENTITY_KEY);
420        if (!TextUtils.isEmpty(eapParam)
421                && !setEapAnonymousIdentity(stringToByteArrayList(eapParam))) {
422            Log.e(TAG, ssid + ": failed to set eap anonymous identity: " + eapParam);
423            return false;
424        }
425        /** EAP Password */
426        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.PASSWORD_KEY);
427        if (!TextUtils.isEmpty(eapParam) && !setEapPassword(stringToByteArrayList(eapParam))) {
428            Log.e(TAG, ssid + ": failed to set eap password");
429            return false;
430        }
431        /** EAP Client Cert */
432        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.CLIENT_CERT_KEY);
433        if (!TextUtils.isEmpty(eapParam) && !setEapClientCert(eapParam)) {
434            Log.e(TAG, ssid + ": failed to set eap client cert: " + eapParam);
435            return false;
436        }
437        /** EAP CA Cert */
438        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.CA_CERT_KEY);
439        if (!TextUtils.isEmpty(eapParam) && !setEapCACert(eapParam)) {
440            Log.e(TAG, ssid + ": failed to set eap ca cert: " + eapParam);
441            return false;
442        }
443        /** EAP Subject Match */
444        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.SUBJECT_MATCH_KEY);
445        if (!TextUtils.isEmpty(eapParam) && !setEapSubjectMatch(eapParam)) {
446            Log.e(TAG, ssid + ": failed to set eap subject match: " + eapParam);
447            return false;
448        }
449        /** EAP Engine ID */
450        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.ENGINE_ID_KEY);
451        if (!TextUtils.isEmpty(eapParam) && !setEapEngineID(eapParam)) {
452            Log.e(TAG, ssid + ": failed to set eap engine id: " + eapParam);
453            return false;
454        }
455        /** EAP Engine */
456        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.ENGINE_KEY);
457        if (!TextUtils.isEmpty(eapParam) && !setEapEngine(
458                eapParam.equals(WifiEnterpriseConfig.ENGINE_ENABLE) ? true : false)) {
459            Log.e(TAG, ssid + ": failed to set eap engine: " + eapParam);
460            return false;
461        }
462        /** EAP Private Key */
463        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY);
464        if (!TextUtils.isEmpty(eapParam) && !setEapPrivateKey(eapParam)) {
465            Log.e(TAG, ssid + ": failed to set eap private key: " + eapParam);
466            return false;
467        }
468        /** EAP Alt Subject Match */
469        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY);
470        if (!TextUtils.isEmpty(eapParam) && !setEapAltSubjectMatch(eapParam)) {
471            Log.e(TAG, ssid + ": failed to set eap alt subject match: " + eapParam);
472            return false;
473        }
474        /** EAP Domain Suffix Match */
475        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY);
476        if (!TextUtils.isEmpty(eapParam) && !setEapDomainSuffixMatch(eapParam)) {
477            Log.e(TAG, ssid + ": failed to set eap domain suffix match: " + eapParam);
478            return false;
479        }
480        /** EAP CA Path*/
481        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.CA_PATH_KEY);
482        if (!TextUtils.isEmpty(eapParam) && !setEapCAPath(eapParam)) {
483            Log.e(TAG, ssid + ": failed to set eap ca path: " + eapParam);
484            return false;
485        }
486
487        /** EAP Proactive Key Caching */
488        eapParam = eapConfig.getFieldValue(WifiEnterpriseConfig.OPP_KEY_CACHING);
489        if (!TextUtils.isEmpty(eapParam)
490                && !setEapProactiveKeyCaching(eapParam.equals("1") ? true : false)) {
491            Log.e(TAG, ssid + ": failed to set proactive key caching: " + eapParam);
492            return false;
493        }
494        return true;
495    }
496
497    /**
498     * Maps WifiConfiguration Key Management BitSet to Supplicant HIDL bitmask int
499     * TODO(b/32571829): Update mapping when fast transition keys are added
500     * @return bitmask int describing the allowed Key Management schemes, readable by the Supplicant
501     *         HIDL hal
502     */
503    private static int wifiConfigurationToSupplicantKeyMgmtMask(BitSet keyMgmt) {
504        int mask = 0;
505        for (int bit = keyMgmt.nextSetBit(0); bit != -1; bit = keyMgmt.nextSetBit(bit + 1)) {
506            switch (bit) {
507                case WifiConfiguration.KeyMgmt.NONE:
508                    mask |= ISupplicantStaNetwork.KeyMgmtMask.NONE;
509                    break;
510                case WifiConfiguration.KeyMgmt.WPA_PSK:
511                    mask |= ISupplicantStaNetwork.KeyMgmtMask.WPA_PSK;
512                    break;
513                case WifiConfiguration.KeyMgmt.WPA_EAP:
514                    mask |= ISupplicantStaNetwork.KeyMgmtMask.WPA_EAP;
515                    break;
516                case WifiConfiguration.KeyMgmt.IEEE8021X:
517                    mask |= ISupplicantStaNetwork.KeyMgmtMask.IEEE8021X;
518                    break;
519                case WifiConfiguration.KeyMgmt.OSEN:
520                    mask |= ISupplicantStaNetwork.KeyMgmtMask.OSEN;
521                    break;
522                case WifiConfiguration.KeyMgmt.FT_PSK:
523                    mask |= ISupplicantStaNetwork.KeyMgmtMask.FT_PSK;
524                    break;
525                case WifiConfiguration.KeyMgmt.FT_EAP:
526                    mask |= ISupplicantStaNetwork.KeyMgmtMask.FT_EAP;
527                    break;
528                case WifiConfiguration.KeyMgmt.WPA2_PSK: // This should never happen
529                default:
530                    throw new IllegalArgumentException(
531                            "Invalid protoMask bit in keyMgmt: " + bit);
532            }
533        }
534        return mask;
535    }
536
537    private static int wifiConfigurationToSupplicantProtoMask(BitSet protoMask) {
538        int mask = 0;
539        for (int bit = protoMask.nextSetBit(0); bit != -1; bit = protoMask.nextSetBit(bit + 1)) {
540            switch (bit) {
541                case WifiConfiguration.Protocol.WPA:
542                    mask |= ISupplicantStaNetwork.ProtoMask.WPA;
543                    break;
544                case WifiConfiguration.Protocol.RSN:
545                    mask |= ISupplicantStaNetwork.ProtoMask.RSN;
546                    break;
547                case WifiConfiguration.Protocol.OSEN:
548                    mask |= ISupplicantStaNetwork.ProtoMask.OSEN;
549                    break;
550                default:
551                    throw new IllegalArgumentException(
552                            "Invalid protoMask bit in wificonfig: " + bit);
553            }
554        }
555        return mask;
556    };
557
558    private static int wifiConfigurationToSupplicantAuthAlgMask(BitSet authAlgMask) {
559        int mask = 0;
560        for (int bit = authAlgMask.nextSetBit(0); bit != -1;
561                bit = authAlgMask.nextSetBit(bit + 1)) {
562            switch (bit) {
563                case WifiConfiguration.AuthAlgorithm.OPEN:
564                    mask |= ISupplicantStaNetwork.AuthAlgMask.OPEN;
565                    break;
566                case WifiConfiguration.AuthAlgorithm.SHARED:
567                    mask |= ISupplicantStaNetwork.AuthAlgMask.SHARED;
568                    break;
569                case WifiConfiguration.AuthAlgorithm.LEAP:
570                    mask |= ISupplicantStaNetwork.AuthAlgMask.LEAP;
571                    break;
572                default:
573                    throw new IllegalArgumentException(
574                            "Invalid authAlgMask bit in wificonfig: " + bit);
575            }
576        }
577        return mask;
578    };
579
580    private static int wifiConfigurationToSupplicantGroupCipherMask(BitSet groupCipherMask) {
581        int mask = 0;
582        for (int bit = groupCipherMask.nextSetBit(0); bit != -1; bit =
583                groupCipherMask.nextSetBit(bit + 1)) {
584            switch (bit) {
585                case WifiConfiguration.GroupCipher.WEP40:
586                    mask |= ISupplicantStaNetwork.GroupCipherMask.WEP40;
587                    break;
588                case WifiConfiguration.GroupCipher.WEP104:
589                    mask |= ISupplicantStaNetwork.GroupCipherMask.WEP104;
590                    break;
591                case WifiConfiguration.GroupCipher.TKIP:
592                    mask |= ISupplicantStaNetwork.GroupCipherMask.TKIP;
593                    break;
594                case WifiConfiguration.GroupCipher.CCMP:
595                    mask |= ISupplicantStaNetwork.GroupCipherMask.CCMP;
596                    break;
597                case WifiConfiguration.GroupCipher.GTK_NOT_USED:
598                    mask |= ISupplicantStaNetwork.GroupCipherMask.GTK_NOT_USED;
599                    break;
600                default:
601                    throw new IllegalArgumentException(
602                            "Invalid GroupCipherMask bit in wificonfig: " + bit);
603            }
604        }
605        return mask;
606    };
607
608    private static int wifiConfigurationToSupplicantPairwiseCipherMask(BitSet pairwiseCipherMask) {
609        int mask = 0;
610        for (int bit = pairwiseCipherMask.nextSetBit(0); bit != -1;
611                bit = pairwiseCipherMask.nextSetBit(bit + 1)) {
612            switch (bit) {
613                case WifiConfiguration.PairwiseCipher.NONE:
614                    mask |= ISupplicantStaNetwork.PairwiseCipherMask.NONE;
615                    break;
616                case WifiConfiguration.PairwiseCipher.TKIP:
617                    mask |= ISupplicantStaNetwork.PairwiseCipherMask.TKIP;
618                    break;
619                case WifiConfiguration.PairwiseCipher.CCMP:
620                    mask |= ISupplicantStaNetwork.PairwiseCipherMask.CCMP;
621                    break;
622                default:
623                    throw new IllegalArgumentException(
624                            "Invalid pairwiseCipherMask bit in wificonfig: " + bit);
625            }
626        }
627        return mask;
628    };
629
630    private static int supplicantToWifiConfigurationEapMethod(int value) {
631        switch (value) {
632            case ISupplicantStaNetwork.EapMethod.PEAP:
633                return WifiEnterpriseConfig.Eap.PEAP;
634            case ISupplicantStaNetwork.EapMethod.TLS:
635                return WifiEnterpriseConfig.Eap.TLS;
636            case ISupplicantStaNetwork.EapMethod.TTLS:
637                return WifiEnterpriseConfig.Eap.TTLS;
638            case ISupplicantStaNetwork.EapMethod.PWD:
639                return WifiEnterpriseConfig.Eap.PWD;
640            case ISupplicantStaNetwork.EapMethod.SIM:
641                return WifiEnterpriseConfig.Eap.SIM;
642            case ISupplicantStaNetwork.EapMethod.AKA:
643                return WifiEnterpriseConfig.Eap.AKA;
644            case ISupplicantStaNetwork.EapMethod.AKA_PRIME:
645                return WifiEnterpriseConfig.Eap.AKA_PRIME;
646            case ISupplicantStaNetwork.EapMethod.WFA_UNAUTH_TLS:
647                return WifiEnterpriseConfig.Eap.UNAUTH_TLS;
648            // WifiEnterpriseConfig.Eap.NONE:
649            default:
650                Log.e(TAG, "invalid eap method value from supplicant: " + value);
651                return -1;
652        }
653    };
654
655    private static int supplicantToWifiConfigurationEapPhase2Method(int value) {
656        switch (value) {
657            case ISupplicantStaNetwork.EapPhase2Method.NONE:
658                return WifiEnterpriseConfig.Phase2.NONE;
659            case ISupplicantStaNetwork.EapPhase2Method.PAP:
660                return WifiEnterpriseConfig.Phase2.PAP;
661            case ISupplicantStaNetwork.EapPhase2Method.MSPAP:
662                return WifiEnterpriseConfig.Phase2.MSCHAP;
663            case ISupplicantStaNetwork.EapPhase2Method.MSPAPV2:
664                return WifiEnterpriseConfig.Phase2.MSCHAPV2;
665            case ISupplicantStaNetwork.EapPhase2Method.GTC:
666                return WifiEnterpriseConfig.Phase2.GTC;
667            default:
668                Log.e(TAG, "invalid eap phase2 method value from supplicant: " + value);
669                return -1;
670        }
671    };
672
673    private static int supplicantMaskValueToWifiConfigurationBitSet(int supplicantMask,
674                                                             int supplicantValue, BitSet bitset,
675                                                             int bitSetPosition) {
676        bitset.set(bitSetPosition, (supplicantMask & supplicantValue) == supplicantValue);
677        int modifiedSupplicantMask = supplicantMask & ~supplicantValue;
678        return modifiedSupplicantMask;
679    }
680
681    private static BitSet supplicantToWifiConfigurationKeyMgmtMask(int mask) {
682        BitSet bitset = new BitSet();
683        mask = supplicantMaskValueToWifiConfigurationBitSet(
684                mask, ISupplicantStaNetwork.KeyMgmtMask.NONE, bitset,
685                WifiConfiguration.KeyMgmt.NONE);
686        mask = supplicantMaskValueToWifiConfigurationBitSet(
687                mask, ISupplicantStaNetwork.KeyMgmtMask.WPA_PSK, bitset,
688                WifiConfiguration.KeyMgmt.WPA_PSK);
689        mask = supplicantMaskValueToWifiConfigurationBitSet(
690                mask, ISupplicantStaNetwork.KeyMgmtMask.WPA_EAP, bitset,
691                WifiConfiguration.KeyMgmt.WPA_EAP);
692        mask = supplicantMaskValueToWifiConfigurationBitSet(
693                mask, ISupplicantStaNetwork.KeyMgmtMask.IEEE8021X, bitset,
694                WifiConfiguration.KeyMgmt.IEEE8021X);
695        mask = supplicantMaskValueToWifiConfigurationBitSet(
696                mask, ISupplicantStaNetwork.KeyMgmtMask.OSEN, bitset,
697                WifiConfiguration.KeyMgmt.OSEN);
698        mask = supplicantMaskValueToWifiConfigurationBitSet(
699                mask, ISupplicantStaNetwork.KeyMgmtMask.FT_PSK, bitset,
700                WifiConfiguration.KeyMgmt.FT_PSK);
701        mask = supplicantMaskValueToWifiConfigurationBitSet(
702                mask, ISupplicantStaNetwork.KeyMgmtMask.FT_EAP, bitset,
703                WifiConfiguration.KeyMgmt.FT_EAP);
704        if (mask != 0) {
705            throw new IllegalArgumentException(
706                    "invalid key mgmt mask from supplicant: " + mask);
707        }
708        return bitset;
709    }
710
711    private static BitSet supplicantToWifiConfigurationProtoMask(int mask) {
712        BitSet bitset = new BitSet();
713        mask = supplicantMaskValueToWifiConfigurationBitSet(
714                mask, ISupplicantStaNetwork.ProtoMask.WPA, bitset,
715                WifiConfiguration.Protocol.WPA);
716        mask = supplicantMaskValueToWifiConfigurationBitSet(
717                mask, ISupplicantStaNetwork.ProtoMask.RSN, bitset,
718                WifiConfiguration.Protocol.RSN);
719        mask = supplicantMaskValueToWifiConfigurationBitSet(
720                mask, ISupplicantStaNetwork.ProtoMask.OSEN, bitset,
721                WifiConfiguration.Protocol.OSEN);
722        if (mask != 0) {
723            throw new IllegalArgumentException(
724                    "invalid proto mask from supplicant: " + mask);
725        }
726        return bitset;
727    };
728
729    private static BitSet supplicantToWifiConfigurationAuthAlgMask(int mask) {
730        BitSet bitset = new BitSet();
731        mask = supplicantMaskValueToWifiConfigurationBitSet(
732                mask, ISupplicantStaNetwork.AuthAlgMask.OPEN, bitset,
733                WifiConfiguration.AuthAlgorithm.OPEN);
734        mask = supplicantMaskValueToWifiConfigurationBitSet(
735                mask, ISupplicantStaNetwork.AuthAlgMask.SHARED, bitset,
736                WifiConfiguration.AuthAlgorithm.SHARED);
737        mask = supplicantMaskValueToWifiConfigurationBitSet(
738                mask, ISupplicantStaNetwork.AuthAlgMask.LEAP, bitset,
739                WifiConfiguration.AuthAlgorithm.LEAP);
740        if (mask != 0) {
741            throw new IllegalArgumentException(
742                    "invalid auth alg mask from supplicant: " + mask);
743        }
744        return bitset;
745    };
746
747    private static BitSet supplicantToWifiConfigurationGroupCipherMask(int mask) {
748        BitSet bitset = new BitSet();
749        mask = supplicantMaskValueToWifiConfigurationBitSet(
750                mask, ISupplicantStaNetwork.GroupCipherMask.WEP40, bitset,
751                WifiConfiguration.GroupCipher.WEP40);
752        mask = supplicantMaskValueToWifiConfigurationBitSet(
753                mask, ISupplicantStaNetwork.GroupCipherMask.WEP104, bitset,
754                WifiConfiguration.GroupCipher.WEP104);
755        mask = supplicantMaskValueToWifiConfigurationBitSet(
756                mask, ISupplicantStaNetwork.GroupCipherMask.TKIP, bitset,
757                WifiConfiguration.GroupCipher.TKIP);
758        mask = supplicantMaskValueToWifiConfigurationBitSet(
759                mask, ISupplicantStaNetwork.GroupCipherMask.CCMP, bitset,
760                WifiConfiguration.GroupCipher.CCMP);
761        mask = supplicantMaskValueToWifiConfigurationBitSet(
762                mask, ISupplicantStaNetwork.GroupCipherMask.GTK_NOT_USED, bitset,
763                WifiConfiguration.GroupCipher.GTK_NOT_USED);
764        if (mask != 0) {
765            throw new IllegalArgumentException(
766                    "invalid group cipher mask from supplicant: " + mask);
767        }
768        return bitset;
769    };
770
771    private static BitSet supplicantToWifiConfigurationPairwiseCipherMask(int mask) {
772        BitSet bitset = new BitSet();
773        mask = supplicantMaskValueToWifiConfigurationBitSet(
774                mask, ISupplicantStaNetwork.PairwiseCipherMask.NONE, bitset,
775                WifiConfiguration.PairwiseCipher.NONE);
776        mask = supplicantMaskValueToWifiConfigurationBitSet(
777                mask, ISupplicantStaNetwork.PairwiseCipherMask.TKIP, bitset,
778                WifiConfiguration.PairwiseCipher.TKIP);
779        mask = supplicantMaskValueToWifiConfigurationBitSet(
780                mask, ISupplicantStaNetwork.PairwiseCipherMask.CCMP, bitset,
781                WifiConfiguration.PairwiseCipher.CCMP);
782        if (mask != 0) {
783            throw new IllegalArgumentException(
784                    "invalid pairwise cipher mask from supplicant: " + mask);
785        }
786        return bitset;
787    };
788
789    private static int wifiConfigurationToSupplicantEapMethod(int value) {
790        switch (value) {
791            case WifiEnterpriseConfig.Eap.PEAP:
792                return ISupplicantStaNetwork.EapMethod.PEAP;
793            case WifiEnterpriseConfig.Eap.TLS:
794                return ISupplicantStaNetwork.EapMethod.TLS;
795            case WifiEnterpriseConfig.Eap.TTLS:
796                return ISupplicantStaNetwork.EapMethod.TTLS;
797            case WifiEnterpriseConfig.Eap.PWD:
798                return ISupplicantStaNetwork.EapMethod.PWD;
799            case WifiEnterpriseConfig.Eap.SIM:
800                return ISupplicantStaNetwork.EapMethod.SIM;
801            case WifiEnterpriseConfig.Eap.AKA:
802                return ISupplicantStaNetwork.EapMethod.AKA;
803            case WifiEnterpriseConfig.Eap.AKA_PRIME:
804                return ISupplicantStaNetwork.EapMethod.AKA_PRIME;
805            case WifiEnterpriseConfig.Eap.UNAUTH_TLS:
806                return ISupplicantStaNetwork.EapMethod.WFA_UNAUTH_TLS;
807            // WifiEnterpriseConfig.Eap.NONE:
808            default:
809                Log.e(TAG, "invalid eap method value from WifiConfiguration: " + value);
810                return -1;
811        }
812    };
813
814    private static int wifiConfigurationToSupplicantEapPhase2Method(int value) {
815        switch (value) {
816            case WifiEnterpriseConfig.Phase2.NONE:
817                return ISupplicantStaNetwork.EapPhase2Method.NONE;
818            case WifiEnterpriseConfig.Phase2.PAP:
819                return ISupplicantStaNetwork.EapPhase2Method.PAP;
820            case WifiEnterpriseConfig.Phase2.MSCHAP:
821                return ISupplicantStaNetwork.EapPhase2Method.MSPAP;
822            case WifiEnterpriseConfig.Phase2.MSCHAPV2:
823                return ISupplicantStaNetwork.EapPhase2Method.MSPAPV2;
824            case WifiEnterpriseConfig.Phase2.GTC:
825                return ISupplicantStaNetwork.EapPhase2Method.GTC;
826            default:
827                Log.e(TAG, "invalid eap phase2 method value from WifiConfiguration: " + value);
828                return -1;
829        }
830    };
831
832    /** See ISupplicantNetwork.hal for documentation */
833    public boolean getId() {
834        synchronized (mLock) {
835            final String methodStr = "getId";
836            if (DBG) Log.i(TAG, methodStr);
837            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
838            try {
839                MutableBoolean statusOk = new MutableBoolean(false);
840                mISupplicantStaNetwork.getId((SupplicantStatus status, int idValue) -> {
841                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
842                    if (statusOk.value) {
843                        this.mNetworkId = idValue;
844                    } else {
845                        logFailureStatus(status, methodStr);
846                    }
847                });
848                return statusOk.value;
849            } catch (RemoteException e) {
850                handleRemoteException(e, methodStr);
851                return false;
852            }
853        }
854    }
855
856    /** See ISupplicantNetwork.hal for documentation */
857    private boolean getInterfaceName() {
858        synchronized (mLock) {
859            final String methodStr = "getInterfaceName";
860            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
861            try {
862                MutableBoolean statusOk = new MutableBoolean(false);
863                mISupplicantStaNetwork.getInterfaceName((SupplicantStatus status,
864                        String nameValue) -> {
865                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
866                    if (statusOk.value) {
867                        this.mIfaceName = nameValue;
868                    } else {
869                        logFailureStatus(status, methodStr);
870                    }
871                });
872                return statusOk.value;
873            } catch (RemoteException e) {
874                handleRemoteException(e, methodStr);
875                return false;
876            }
877        }
878    }
879
880    /** See ISupplicantStaNetwork.hal for documentation */
881    private boolean registerCallback(ISupplicantStaNetworkCallback callback) {
882        synchronized (mLock) {
883            final String methodStr = "registerCallback";
884            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
885            try {
886                SupplicantStatus status =  mISupplicantStaNetwork.registerCallback(callback);
887                return checkStatusAndLogFailure(status, methodStr);
888            } catch (RemoteException e) {
889                handleRemoteException(e, methodStr);
890                return false;
891            }
892        }
893    }
894
895    /** See ISupplicantStaNetwork.hal for documentation */
896    private boolean setSsid(java.util.ArrayList<Byte> ssid) {
897        synchronized (mLock) {
898            final String methodStr = "setSsid";
899            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
900            try {
901                SupplicantStatus status =  mISupplicantStaNetwork.setSsid(ssid);
902                return checkStatusAndLogFailure(status, methodStr);
903            } catch (RemoteException e) {
904                handleRemoteException(e, methodStr);
905                return false;
906            }
907        }
908    }
909    /** See ISupplicantStaNetwork.hal for documentation */
910    private boolean setBssid(byte[/* 6 */] bssid) {
911        synchronized (mLock) {
912            final String methodStr = "setBssid";
913            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
914            try {
915                SupplicantStatus status =  mISupplicantStaNetwork.setBssid(bssid);
916                return checkStatusAndLogFailure(status, methodStr);
917            } catch (RemoteException e) {
918                handleRemoteException(e, methodStr);
919                return false;
920            }
921        }
922    }
923    /** See ISupplicantStaNetwork.hal for documentation */
924    private boolean setScanSsid(boolean enable) {
925        synchronized (mLock) {
926            final String methodStr = "setScanSsid";
927            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
928            try {
929                SupplicantStatus status =  mISupplicantStaNetwork.setScanSsid(enable);
930                return checkStatusAndLogFailure(status, methodStr);
931            } catch (RemoteException e) {
932                handleRemoteException(e, methodStr);
933                return false;
934            }
935        }
936    }
937    /** See ISupplicantStaNetwork.hal for documentation */
938    private boolean setKeyMgmt(int keyMgmtMask) {
939        synchronized (mLock) {
940            final String methodStr = "setKeyMgmt";
941            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
942            try {
943                SupplicantStatus status =  mISupplicantStaNetwork.setKeyMgmt(keyMgmtMask);
944                return checkStatusAndLogFailure(status, methodStr);
945            } catch (RemoteException e) {
946                handleRemoteException(e, methodStr);
947                return false;
948            }
949        }
950    }
951    /** See ISupplicantStaNetwork.hal for documentation */
952    private boolean setProto(int protoMask) {
953        synchronized (mLock) {
954            final String methodStr = "setProto";
955            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
956            try {
957                SupplicantStatus status =  mISupplicantStaNetwork.setProto(protoMask);
958                return checkStatusAndLogFailure(status, methodStr);
959            } catch (RemoteException e) {
960                handleRemoteException(e, methodStr);
961                return false;
962            }
963        }
964    }
965    /** See ISupplicantStaNetwork.hal for documentation */
966    private boolean setAuthAlg(int authAlgMask) {
967        synchronized (mLock) {
968            final String methodStr = "setAuthAlg";
969            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
970            try {
971                SupplicantStatus status =  mISupplicantStaNetwork.setAuthAlg(authAlgMask);
972                return checkStatusAndLogFailure(status, methodStr);
973            } catch (RemoteException e) {
974                handleRemoteException(e, methodStr);
975                return false;
976            }
977        }
978    }
979    /** See ISupplicantStaNetwork.hal for documentation */
980    private boolean setGroupCipher(int groupCipherMask) {
981        synchronized (mLock) {
982            final String methodStr = "setGroupCipher";
983            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
984            try {
985                SupplicantStatus status =  mISupplicantStaNetwork.setGroupCipher(groupCipherMask);
986                return checkStatusAndLogFailure(status, methodStr);
987            } catch (RemoteException e) {
988                handleRemoteException(e, methodStr);
989                return false;
990            }
991        }
992    }
993    /** See ISupplicantStaNetwork.hal for documentation */
994    private boolean setPairwiseCipher(int pairwiseCipherMask) {
995        synchronized (mLock) {
996            final String methodStr = "setPairwiseCipher";
997            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
998            try {
999                SupplicantStatus status =
1000                        mISupplicantStaNetwork.setPairwiseCipher(pairwiseCipherMask);
1001                return checkStatusAndLogFailure(status, methodStr);
1002            } catch (RemoteException e) {
1003                handleRemoteException(e, methodStr);
1004                return false;
1005            }
1006        }
1007    }
1008    /** See ISupplicantStaNetwork.hal for documentation */
1009    private boolean setPskPassphrase(String psk) {
1010        synchronized (mLock) {
1011            final String methodStr = "setPskPassphrase";
1012            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1013            try {
1014                SupplicantStatus status =  mISupplicantStaNetwork.setPskPassphrase(psk);
1015                return checkStatusAndLogFailure(status, methodStr);
1016            } catch (RemoteException e) {
1017                handleRemoteException(e, methodStr);
1018                return false;
1019            }
1020        }
1021    }
1022    /** See ISupplicantStaNetwork.hal for documentation */
1023    private boolean setWepKey(int keyIdx, java.util.ArrayList<Byte> wepKey) {
1024        synchronized (mLock) {
1025            final String methodStr = "setWepKey";
1026            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1027            try {
1028                SupplicantStatus status =  mISupplicantStaNetwork.setWepKey(keyIdx, wepKey);
1029                return checkStatusAndLogFailure(status, methodStr);
1030            } catch (RemoteException e) {
1031                handleRemoteException(e, methodStr);
1032                return false;
1033            }
1034        }
1035    }
1036    /** See ISupplicantStaNetwork.hal for documentation */
1037    private boolean setWepTxKeyIdx(int keyIdx) {
1038        synchronized (mLock) {
1039            final String methodStr = "setWepTxKeyIdx";
1040            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1041            try {
1042                SupplicantStatus status =  mISupplicantStaNetwork.setWepTxKeyIdx(keyIdx);
1043                return checkStatusAndLogFailure(status, methodStr);
1044            } catch (RemoteException e) {
1045                handleRemoteException(e, methodStr);
1046                return false;
1047            }
1048        }
1049    }
1050    /** See ISupplicantStaNetwork.hal for documentation */
1051    private boolean setRequirePmf(boolean enable) {
1052        synchronized (mLock) {
1053            final String methodStr = "setRequirePmf";
1054            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1055            try {
1056                SupplicantStatus status =  mISupplicantStaNetwork.setRequirePmf(enable);
1057                return checkStatusAndLogFailure(status, methodStr);
1058            } catch (RemoteException e) {
1059                handleRemoteException(e, methodStr);
1060                return false;
1061            }
1062        }
1063    }
1064    /** See ISupplicantStaNetwork.hal for documentation */
1065    private boolean setUpdateIdentifier(int identifier) {
1066        synchronized (mLock) {
1067            final String methodStr = "setUpdateIdentifier";
1068            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1069            try {
1070                SupplicantStatus status =  mISupplicantStaNetwork.setUpdateIdentifier(identifier);
1071                return checkStatusAndLogFailure(status, methodStr);
1072            } catch (RemoteException e) {
1073                handleRemoteException(e, methodStr);
1074                return false;
1075            }
1076        }
1077    }
1078    /** See ISupplicantStaNetwork.hal for documentation */
1079    private boolean setEapMethod(int method) {
1080        synchronized (mLock) {
1081            final String methodStr = "setEapMethod";
1082            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1083            try {
1084                SupplicantStatus status =  mISupplicantStaNetwork.setEapMethod(method);
1085                return checkStatusAndLogFailure(status, methodStr);
1086            } catch (RemoteException e) {
1087                handleRemoteException(e, methodStr);
1088                return false;
1089            }
1090        }
1091    }
1092    /** See ISupplicantStaNetwork.hal for documentation */
1093    private boolean setEapPhase2Method(int method) {
1094        synchronized (mLock) {
1095            final String methodStr = "setEapPhase2Method";
1096            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1097            try {
1098                SupplicantStatus status =  mISupplicantStaNetwork.setEapPhase2Method(method);
1099                return checkStatusAndLogFailure(status, methodStr);
1100            } catch (RemoteException e) {
1101                handleRemoteException(e, methodStr);
1102                return false;
1103            }
1104        }
1105    }
1106    /** See ISupplicantStaNetwork.hal for documentation */
1107    private boolean setEapIdentity(java.util.ArrayList<Byte> identity) {
1108        synchronized (mLock) {
1109            final String methodStr = "setEapIdentity";
1110            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1111            try {
1112                SupplicantStatus status =  mISupplicantStaNetwork.setEapIdentity(identity);
1113                return checkStatusAndLogFailure(status, methodStr);
1114            } catch (RemoteException e) {
1115                handleRemoteException(e, methodStr);
1116                return false;
1117            }
1118        }
1119    }
1120    /** See ISupplicantStaNetwork.hal for documentation */
1121    private boolean setEapAnonymousIdentity(java.util.ArrayList<Byte> identity) {
1122        synchronized (mLock) {
1123            final String methodStr = "setEapAnonymousIdentity";
1124            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1125            try {
1126                SupplicantStatus status =  mISupplicantStaNetwork.setEapAnonymousIdentity(identity);
1127                return checkStatusAndLogFailure(status, methodStr);
1128            } catch (RemoteException e) {
1129                handleRemoteException(e, methodStr);
1130                return false;
1131            }
1132        }
1133    }
1134    /** See ISupplicantStaNetwork.hal for documentation */
1135    private boolean setEapPassword(java.util.ArrayList<Byte> password) {
1136        synchronized (mLock) {
1137            final String methodStr = "setEapPassword";
1138            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1139            try {
1140                SupplicantStatus status =  mISupplicantStaNetwork.setEapPassword(password);
1141                return checkStatusAndLogFailure(status, methodStr);
1142            } catch (RemoteException e) {
1143                handleRemoteException(e, methodStr);
1144                return false;
1145            }
1146        }
1147    }
1148    /** See ISupplicantStaNetwork.hal for documentation */
1149    private boolean setEapCACert(String path) {
1150        synchronized (mLock) {
1151            final String methodStr = "setEapCACert";
1152            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1153            try {
1154                SupplicantStatus status =  mISupplicantStaNetwork.setEapCACert(path);
1155                return checkStatusAndLogFailure(status, methodStr);
1156            } catch (RemoteException e) {
1157                handleRemoteException(e, methodStr);
1158                return false;
1159            }
1160        }
1161    }
1162    /** See ISupplicantStaNetwork.hal for documentation */
1163    private boolean setEapCAPath(String path) {
1164        synchronized (mLock) {
1165            final String methodStr = "setEapCAPath";
1166            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1167            try {
1168                SupplicantStatus status =  mISupplicantStaNetwork.setEapCAPath(path);
1169                return checkStatusAndLogFailure(status, methodStr);
1170            } catch (RemoteException e) {
1171                handleRemoteException(e, methodStr);
1172                return false;
1173            }
1174        }
1175    }
1176    /** See ISupplicantStaNetwork.hal for documentation */
1177    private boolean setEapClientCert(String path) {
1178        synchronized (mLock) {
1179            final String methodStr = "setEapClientCert";
1180            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1181            try {
1182                SupplicantStatus status =  mISupplicantStaNetwork.setEapClientCert(path);
1183                return checkStatusAndLogFailure(status, methodStr);
1184            } catch (RemoteException e) {
1185                handleRemoteException(e, methodStr);
1186                return false;
1187            }
1188        }
1189    }
1190    /** See ISupplicantStaNetwork.hal for documentation */
1191    private boolean setEapPrivateKey(String path) {
1192        synchronized (mLock) {
1193            final String methodStr = "setEapPrivateKey";
1194            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1195            try {
1196                SupplicantStatus status =  mISupplicantStaNetwork.setEapPrivateKey(path);
1197                return checkStatusAndLogFailure(status, methodStr);
1198            } catch (RemoteException e) {
1199                handleRemoteException(e, methodStr);
1200                return false;
1201            }
1202        }
1203    }
1204    /** See ISupplicantStaNetwork.hal for documentation */
1205    private boolean setEapSubjectMatch(String match) {
1206        synchronized (mLock) {
1207            final String methodStr = "setEapSubjectMatch";
1208            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1209            try {
1210                SupplicantStatus status =  mISupplicantStaNetwork.setEapSubjectMatch(match);
1211                return checkStatusAndLogFailure(status, methodStr);
1212            } catch (RemoteException e) {
1213                handleRemoteException(e, methodStr);
1214                return false;
1215            }
1216        }
1217    }
1218    /** See ISupplicantStaNetwork.hal for documentation */
1219    private boolean setEapAltSubjectMatch(String match) {
1220        synchronized (mLock) {
1221            final String methodStr = "setEapAltSubjectMatch";
1222            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1223            try {
1224                SupplicantStatus status =  mISupplicantStaNetwork.setEapAltSubjectMatch(match);
1225                return checkStatusAndLogFailure(status, methodStr);
1226            } catch (RemoteException e) {
1227                handleRemoteException(e, methodStr);
1228                return false;
1229            }
1230        }
1231    }
1232    /** See ISupplicantStaNetwork.hal for documentation */
1233    private boolean setEapEngine(boolean enable) {
1234        synchronized (mLock) {
1235            final String methodStr = "setEapEngine";
1236            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1237            try {
1238                SupplicantStatus status =  mISupplicantStaNetwork.setEapEngine(enable);
1239                return checkStatusAndLogFailure(status, methodStr);
1240            } catch (RemoteException e) {
1241                handleRemoteException(e, methodStr);
1242                return false;
1243            }
1244        }
1245    }
1246    /** See ISupplicantStaNetwork.hal for documentation */
1247    private boolean setEapEngineID(String id) {
1248        synchronized (mLock) {
1249            final String methodStr = "setEapEngineID";
1250            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1251            try {
1252                SupplicantStatus status =  mISupplicantStaNetwork.setEapEngineID(id);
1253                return checkStatusAndLogFailure(status, methodStr);
1254            } catch (RemoteException e) {
1255                handleRemoteException(e, methodStr);
1256                return false;
1257            }
1258        }
1259    }
1260    /** See ISupplicantStaNetwork.hal for documentation */
1261    private boolean setEapDomainSuffixMatch(String match) {
1262        synchronized (mLock) {
1263            final String methodStr = "setEapDomainSuffixMatch";
1264            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1265            try {
1266                SupplicantStatus status =  mISupplicantStaNetwork.setEapDomainSuffixMatch(match);
1267                return checkStatusAndLogFailure(status, methodStr);
1268            } catch (RemoteException e) {
1269                handleRemoteException(e, methodStr);
1270                return false;
1271            }
1272        }
1273    }
1274    /** See ISupplicantStaNetwork.hal for documentation */
1275    private boolean setEapProactiveKeyCaching(boolean enable) {
1276        synchronized (mLock) {
1277            final String methodStr = "setEapProactiveKeyCaching";
1278            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1279            try {
1280                SupplicantStatus status =  mISupplicantStaNetwork.setProactiveKeyCaching(enable);
1281                return checkStatusAndLogFailure(status, methodStr);
1282            } catch (RemoteException e) {
1283                handleRemoteException(e, methodStr);
1284                return false;
1285            }
1286        }
1287    }
1288    /** See ISupplicantStaNetwork.hal for documentation */
1289    private boolean setIdStr(String idString) {
1290        synchronized (mLock) {
1291            final String methodStr = "setIdStr";
1292            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1293            try {
1294                SupplicantStatus status =  mISupplicantStaNetwork.setIdStr(idString);
1295                return checkStatusAndLogFailure(status, methodStr);
1296            } catch (RemoteException e) {
1297                handleRemoteException(e, methodStr);
1298                return false;
1299            }
1300        }
1301    }
1302    /** See ISupplicantStaNetwork.hal for documentation */
1303    private boolean getSsid() {
1304        synchronized (mLock) {
1305            final String methodStr = "getSsid";
1306            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1307            try {
1308                MutableBoolean statusOk = new MutableBoolean(false);
1309                mISupplicantStaNetwork.getSsid((SupplicantStatus status,
1310                        java.util.ArrayList<Byte> ssidValue) -> {
1311                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1312                    if (statusOk.value) {
1313                        this.mSsid = ssidValue;
1314                    } else {
1315                        logFailureStatus(status, methodStr);
1316                    }
1317                });
1318                return statusOk.value;
1319            } catch (RemoteException e) {
1320                handleRemoteException(e, methodStr);
1321                return false;
1322            }
1323        }
1324    }
1325    /** See ISupplicantStaNetwork.hal for documentation */
1326    private boolean getBssid() {
1327        synchronized (mLock) {
1328            final String methodStr = "getBssid";
1329            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1330            try {
1331                MutableBoolean statusOk = new MutableBoolean(false);
1332                mISupplicantStaNetwork.getBssid((SupplicantStatus status,
1333                        byte[/* 6 */] bssidValue) -> {
1334                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1335                    if (statusOk.value) {
1336                        this.mBssid = bssidValue;
1337                    } else {
1338                        logFailureStatus(status, methodStr);
1339                    }
1340                });
1341                return statusOk.value;
1342            } catch (RemoteException e) {
1343                handleRemoteException(e, methodStr);
1344                return false;
1345            }
1346        }
1347    }
1348    /** See ISupplicantStaNetwork.hal for documentation */
1349    private boolean getScanSsid() {
1350        synchronized (mLock) {
1351            final String methodStr = "getScanSsid";
1352            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1353            try {
1354                MutableBoolean statusOk = new MutableBoolean(false);
1355                mISupplicantStaNetwork.getScanSsid((SupplicantStatus status,
1356                        boolean enabledValue) -> {
1357                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1358                    if (statusOk.value) {
1359                        this.mScanSsid = enabledValue;
1360                    } else {
1361                        logFailureStatus(status, methodStr);
1362                    }
1363                });
1364                return statusOk.value;
1365            } catch (RemoteException e) {
1366                handleRemoteException(e, methodStr);
1367                return false;
1368            }
1369        }
1370    }
1371    /** See ISupplicantStaNetwork.hal for documentation */
1372    private boolean getKeyMgmt() {
1373        synchronized (mLock) {
1374            final String methodStr = "getKeyMgmt";
1375            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1376            try {
1377                MutableBoolean statusOk = new MutableBoolean(false);
1378                mISupplicantStaNetwork.getKeyMgmt((SupplicantStatus status,
1379                        int keyMgmtMaskValue) -> {
1380                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1381                    if (statusOk.value) {
1382                        this.mKeyMgmtMask = keyMgmtMaskValue;
1383                    } else {
1384                        logFailureStatus(status, methodStr);
1385                    }
1386                });
1387                return statusOk.value;
1388            } catch (RemoteException e) {
1389                handleRemoteException(e, methodStr);
1390                return false;
1391            }
1392        }
1393    }
1394    /** See ISupplicantStaNetwork.hal for documentation */
1395    private boolean getProto() {
1396        synchronized (mLock) {
1397            final String methodStr = "getProto";
1398            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1399            try {
1400                MutableBoolean statusOk = new MutableBoolean(false);
1401                mISupplicantStaNetwork.getProto((SupplicantStatus status, int protoMaskValue) -> {
1402                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1403                    if (statusOk.value) {
1404                        this.mProtoMask = protoMaskValue;
1405                    } else {
1406                        logFailureStatus(status, methodStr);
1407                    }
1408                });
1409                return statusOk.value;
1410            } catch (RemoteException e) {
1411                handleRemoteException(e, methodStr);
1412                return false;
1413            }
1414        }
1415    }
1416    /** See ISupplicantStaNetwork.hal for documentation */
1417    private boolean getAuthAlg() {
1418        synchronized (mLock) {
1419            final String methodStr = "getAuthAlg";
1420            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1421            try {
1422                MutableBoolean statusOk = new MutableBoolean(false);
1423                mISupplicantStaNetwork.getAuthAlg((SupplicantStatus status,
1424                        int authAlgMaskValue) -> {
1425                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1426                    if (statusOk.value) {
1427                        this.mAuthAlgMask = authAlgMaskValue;
1428                    } else {
1429                        logFailureStatus(status, methodStr);
1430                    }
1431                });
1432                return statusOk.value;
1433            } catch (RemoteException e) {
1434                handleRemoteException(e, methodStr);
1435                return false;
1436            }
1437        }
1438    }
1439    /** See ISupplicantStaNetwork.hal for documentation */
1440    private boolean getGroupCipher() {
1441        synchronized (mLock) {
1442            final String methodStr = "getGroupCipher";
1443            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1444            try {
1445                MutableBoolean statusOk = new MutableBoolean(false);
1446                mISupplicantStaNetwork.getGroupCipher((SupplicantStatus status,
1447                        int groupCipherMaskValue) -> {
1448                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1449                    if (statusOk.value) {
1450                        this.mGroupCipherMask = groupCipherMaskValue;
1451                    } else {
1452                        logFailureStatus(status, methodStr);
1453                    }
1454                });
1455                return statusOk.value;
1456            } catch (RemoteException e) {
1457                handleRemoteException(e, methodStr);
1458                return false;
1459            }
1460        }
1461    }
1462    /** See ISupplicantStaNetwork.hal for documentation */
1463    private boolean getPairwiseCipher() {
1464        synchronized (mLock) {
1465            final String methodStr = "getPairwiseCipher";
1466            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1467            try {
1468                MutableBoolean statusOk = new MutableBoolean(false);
1469                mISupplicantStaNetwork.getPairwiseCipher((SupplicantStatus status,
1470                        int pairwiseCipherMaskValue) -> {
1471                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1472                    if (statusOk.value) {
1473                        this.mPairwiseCipherMask = pairwiseCipherMaskValue;
1474                    } else {
1475                        logFailureStatus(status, methodStr);
1476                    }
1477                });
1478                return statusOk.value;
1479            } catch (RemoteException e) {
1480                handleRemoteException(e, methodStr);
1481                return false;
1482            }
1483        }
1484    }
1485    /** See ISupplicantStaNetwork.hal for documentation */
1486    private boolean getPskPassphrase() {
1487        synchronized (mLock) {
1488            final String methodStr = "getPskPassphrase";
1489            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1490            try {
1491                MutableBoolean statusOk = new MutableBoolean(false);
1492                mISupplicantStaNetwork.getPskPassphrase((SupplicantStatus status,
1493                        String pskValue) -> {
1494                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1495                    if (statusOk.value) {
1496                        this.mPskPassphrase = pskValue;
1497                    } else {
1498                        logFailureStatus(status, methodStr);
1499                    }
1500                });
1501                return statusOk.value;
1502            } catch (RemoteException e) {
1503                handleRemoteException(e, methodStr);
1504                return false;
1505            }
1506        }
1507    }
1508    /** See ISupplicantStaNetwork.hal for documentation */
1509    private boolean getWepKey(int keyIdx) {
1510        synchronized (mLock) {
1511            final String methodStr = "keyIdx";
1512            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1513            try {
1514                MutableBoolean statusOk = new MutableBoolean(false);
1515                mISupplicantStaNetwork.getWepKey(keyIdx, (SupplicantStatus status,
1516                        java.util.ArrayList<Byte> wepKeyValue) -> {
1517                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1518                    if (statusOk.value) {
1519                        this.mWepKey = wepKeyValue;
1520                    } else {
1521                        Log.e(TAG, methodStr + ",  failed: " + status.debugMessage);
1522                    }
1523                });
1524                return statusOk.value;
1525            } catch (RemoteException e) {
1526                handleRemoteException(e, methodStr);
1527                return false;
1528            }
1529        }
1530    }
1531    /** See ISupplicantStaNetwork.hal for documentation */
1532    private boolean getWepTxKeyIdx() {
1533        synchronized (mLock) {
1534            final String methodStr = "getWepTxKeyIdx";
1535            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1536            try {
1537                MutableBoolean statusOk = new MutableBoolean(false);
1538                mISupplicantStaNetwork.getWepTxKeyIdx((SupplicantStatus status,
1539                        int keyIdxValue) -> {
1540                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1541                    if (statusOk.value) {
1542                        this.mWepTxKeyIdx = keyIdxValue;
1543                    } else {
1544                        logFailureStatus(status, methodStr);
1545                    }
1546                });
1547                return statusOk.value;
1548            } catch (RemoteException e) {
1549                handleRemoteException(e, methodStr);
1550                return false;
1551            }
1552        }
1553    }
1554    /** See ISupplicantStaNetwork.hal for documentation */
1555    private boolean getRequirePmf() {
1556        synchronized (mLock) {
1557            final String methodStr = "getRequirePmf";
1558            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1559            try {
1560                MutableBoolean statusOk = new MutableBoolean(false);
1561                mISupplicantStaNetwork.getRequirePmf((SupplicantStatus status,
1562                        boolean enabledValue) -> {
1563                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1564                    if (statusOk.value) {
1565                        this.mRequirePmf = enabledValue;
1566                    } else {
1567                        logFailureStatus(status, methodStr);
1568                    }
1569                });
1570                return statusOk.value;
1571            } catch (RemoteException e) {
1572                handleRemoteException(e, methodStr);
1573                return false;
1574            }
1575        }
1576    }
1577    /** See ISupplicantStaNetwork.hal for documentation */
1578    private boolean getEapMethod() {
1579        synchronized (mLock) {
1580            final String methodStr = "getEapMethod";
1581            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1582            try {
1583                MutableBoolean statusOk = new MutableBoolean(false);
1584                mISupplicantStaNetwork.getEapMethod((SupplicantStatus status,
1585                        int methodValue) -> {
1586                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1587                    if (statusOk.value) {
1588                        this.mEapMethod = methodValue;
1589                    } else {
1590                        logFailureStatus(status, methodStr);
1591                    }
1592                });
1593                return statusOk.value;
1594            } catch (RemoteException e) {
1595                handleRemoteException(e, methodStr);
1596                return false;
1597            }
1598        }
1599    }
1600    /** See ISupplicantStaNetwork.hal for documentation */
1601    private boolean getEapPhase2Method() {
1602        synchronized (mLock) {
1603            final String methodStr = "getEapPhase2Method";
1604            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1605            try {
1606                MutableBoolean statusOk = new MutableBoolean(false);
1607                mISupplicantStaNetwork.getEapPhase2Method((SupplicantStatus status,
1608                        int methodValue) -> {
1609                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1610                    if (statusOk.value) {
1611                        this.mEapPhase2Method = methodValue;
1612                    } else {
1613                        logFailureStatus(status, methodStr);
1614                    }
1615                });
1616                return statusOk.value;
1617            } catch (RemoteException e) {
1618                handleRemoteException(e, methodStr);
1619                return false;
1620            }
1621        }
1622    }
1623    /** See ISupplicantStaNetwork.hal for documentation */
1624    private boolean getEapIdentity() {
1625        synchronized (mLock) {
1626            final String methodStr = "getEapIdentity";
1627            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1628            try {
1629                MutableBoolean statusOk = new MutableBoolean(false);
1630                mISupplicantStaNetwork.getEapIdentity((SupplicantStatus status,
1631                        ArrayList<Byte> identityValue) -> {
1632                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1633                    if (statusOk.value) {
1634                        this.mEapIdentity = identityValue;
1635                    } else {
1636                        logFailureStatus(status, methodStr);
1637                    }
1638                });
1639                return statusOk.value;
1640            } catch (RemoteException e) {
1641                handleRemoteException(e, methodStr);
1642                return false;
1643            }
1644        }
1645    }
1646    /** See ISupplicantStaNetwork.hal for documentation */
1647    private boolean getEapAnonymousIdentity() {
1648        synchronized (mLock) {
1649            final String methodStr = "getEapAnonymousIdentity";
1650            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1651            try {
1652                MutableBoolean statusOk = new MutableBoolean(false);
1653                mISupplicantStaNetwork.getEapAnonymousIdentity((SupplicantStatus status,
1654                        ArrayList<Byte> identityValue) -> {
1655                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1656                    if (statusOk.value) {
1657                        this.mEapAnonymousIdentity = identityValue;
1658                    } else {
1659                        logFailureStatus(status, methodStr);
1660                    }
1661                });
1662                return statusOk.value;
1663            } catch (RemoteException e) {
1664                handleRemoteException(e, methodStr);
1665                return false;
1666            }
1667        }
1668    }
1669    /** See ISupplicantStaNetwork.hal for documentation */
1670    private boolean getEapPassword() {
1671        synchronized (mLock) {
1672            final String methodStr = "getEapPassword";
1673            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1674            try {
1675                MutableBoolean statusOk = new MutableBoolean(false);
1676                mISupplicantStaNetwork.getEapPassword((SupplicantStatus status,
1677                        ArrayList<Byte> passwordValue) -> {
1678                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1679                    if (statusOk.value) {
1680                        this.mEapPassword = passwordValue;
1681                    } else {
1682                        logFailureStatus(status, methodStr);
1683                    }
1684                });
1685                return statusOk.value;
1686            } catch (RemoteException e) {
1687                handleRemoteException(e, methodStr);
1688                return false;
1689            }
1690        }
1691    }
1692    /** See ISupplicantStaNetwork.hal for documentation */
1693    private boolean getEapCACert() {
1694        synchronized (mLock) {
1695            final String methodStr = "getEapCACert";
1696            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1697            try {
1698                MutableBoolean statusOk = new MutableBoolean(false);
1699                mISupplicantStaNetwork.getEapCACert((SupplicantStatus status, String pathValue) -> {
1700                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1701                    if (statusOk.value) {
1702                        this.mEapCACert = pathValue;
1703                    } else {
1704                        logFailureStatus(status, methodStr);
1705                    }
1706                });
1707                return statusOk.value;
1708            } catch (RemoteException e) {
1709                handleRemoteException(e, methodStr);
1710                return false;
1711            }
1712        }
1713    }
1714    /** See ISupplicantStaNetwork.hal for documentation */
1715    private boolean getEapCAPath() {
1716        synchronized (mLock) {
1717            final String methodStr = "getEapCAPath";
1718            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1719            try {
1720                MutableBoolean statusOk = new MutableBoolean(false);
1721                mISupplicantStaNetwork.getEapCAPath((SupplicantStatus status, String pathValue) -> {
1722                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1723                    if (statusOk.value) {
1724                        this.mEapCAPath = pathValue;
1725                    } else {
1726                        logFailureStatus(status, methodStr);
1727                    }
1728                });
1729                return statusOk.value;
1730            } catch (RemoteException e) {
1731                handleRemoteException(e, methodStr);
1732                return false;
1733            }
1734        }
1735    }
1736    /** See ISupplicantStaNetwork.hal for documentation */
1737    private boolean getEapClientCert() {
1738        synchronized (mLock) {
1739            final String methodStr = "getEapClientCert";
1740            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1741            try {
1742                MutableBoolean statusOk = new MutableBoolean(false);
1743                mISupplicantStaNetwork.getEapClientCert((SupplicantStatus status,
1744                        String pathValue) -> {
1745                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1746                    if (statusOk.value) {
1747                        this.mEapClientCert = pathValue;
1748                    } else {
1749                        logFailureStatus(status, methodStr);
1750                    }
1751                });
1752                return statusOk.value;
1753            } catch (RemoteException e) {
1754                handleRemoteException(e, methodStr);
1755                return false;
1756            }
1757        }
1758    }
1759    /** See ISupplicantStaNetwork.hal for documentation */
1760    private boolean getEapPrivateKey() {
1761        synchronized (mLock) {
1762            final String methodStr = "getEapPrivateKey";
1763            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1764            try {
1765                MutableBoolean statusOk = new MutableBoolean(false);
1766                mISupplicantStaNetwork.getEapPrivateKey((SupplicantStatus status,
1767                        String pathValue) -> {
1768                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1769                    if (statusOk.value) {
1770                        this.mEapPrivateKey = pathValue;
1771                    } else {
1772                        logFailureStatus(status, methodStr);
1773                    }
1774                });
1775                return statusOk.value;
1776            } catch (RemoteException e) {
1777                handleRemoteException(e, methodStr);
1778                return false;
1779            }
1780        }
1781    }
1782    /** See ISupplicantStaNetwork.hal for documentation */
1783    private boolean getEapSubjectMatch() {
1784        synchronized (mLock) {
1785            final String methodStr = "getEapSubjectMatch";
1786            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1787            try {
1788                MutableBoolean statusOk = new MutableBoolean(false);
1789                mISupplicantStaNetwork.getEapSubjectMatch((SupplicantStatus status,
1790                        String matchValue) -> {
1791                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1792                    if (statusOk.value) {
1793                        this.mEapSubjectMatch = matchValue;
1794                    } else {
1795                        logFailureStatus(status, methodStr);
1796                    }
1797                });
1798                return statusOk.value;
1799            } catch (RemoteException e) {
1800                handleRemoteException(e, methodStr);
1801                return false;
1802            }
1803        }
1804    }
1805    /** See ISupplicantStaNetwork.hal for documentation */
1806    private boolean getEapAltSubjectMatch() {
1807        synchronized (mLock) {
1808            final String methodStr = "getEapAltSubjectMatch";
1809            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1810            try {
1811                MutableBoolean statusOk = new MutableBoolean(false);
1812                mISupplicantStaNetwork.getEapAltSubjectMatch((SupplicantStatus status,
1813                        String matchValue) -> {
1814                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1815                    if (statusOk.value) {
1816                        this.mEapAltSubjectMatch = matchValue;
1817                    } else {
1818                        logFailureStatus(status, methodStr);
1819                    }
1820                });
1821                return statusOk.value;
1822            } catch (RemoteException e) {
1823                handleRemoteException(e, methodStr);
1824                return false;
1825            }
1826        }
1827    }
1828    /** See ISupplicantStaNetwork.hal for documentation */
1829    private boolean getEapEngine() {
1830        synchronized (mLock) {
1831            final String methodStr = "getEapEngine";
1832            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1833            try {
1834                MutableBoolean statusOk = new MutableBoolean(false);
1835                mISupplicantStaNetwork.getEapEngine((SupplicantStatus status,
1836                        boolean enabledValue) -> {
1837                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1838                    if (statusOk.value) {
1839                        this.mEapEngine = enabledValue;
1840                    } else {
1841                        logFailureStatus(status, methodStr);
1842                    }
1843                });
1844                return statusOk.value;
1845            } catch (RemoteException e) {
1846                handleRemoteException(e, methodStr);
1847                return false;
1848            }
1849        }
1850    }
1851    /** See ISupplicantStaNetwork.hal for documentation */
1852    private boolean getEapEngineID() {
1853        synchronized (mLock) {
1854            final String methodStr = "getEapEngineID";
1855            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1856            try {
1857                MutableBoolean statusOk = new MutableBoolean(false);
1858                mISupplicantStaNetwork.getEapEngineID((SupplicantStatus status, String idValue) -> {
1859                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1860                    if (statusOk.value) {
1861                        this.mEapEngineID = idValue;
1862                    } else {
1863                        logFailureStatus(status, methodStr);
1864                    }
1865                });
1866                return statusOk.value;
1867            } catch (RemoteException e) {
1868                handleRemoteException(e, methodStr);
1869                return false;
1870            }
1871        }
1872    }
1873    /** See ISupplicantStaNetwork.hal for documentation */
1874    private boolean getEapDomainSuffixMatch() {
1875        synchronized (mLock) {
1876            final String methodStr = "getEapDomainSuffixMatch";
1877            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1878            try {
1879                MutableBoolean statusOk = new MutableBoolean(false);
1880                mISupplicantStaNetwork.getEapDomainSuffixMatch((SupplicantStatus status,
1881                        String matchValue) -> {
1882                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1883                    if (statusOk.value) {
1884                        this.mEapDomainSuffixMatch = matchValue;
1885                    } else {
1886                        logFailureStatus(status, methodStr);
1887                    }
1888                });
1889                return statusOk.value;
1890            } catch (RemoteException e) {
1891                handleRemoteException(e, methodStr);
1892                return false;
1893            }
1894        }
1895    }
1896    /** See ISupplicantStaNetwork.hal for documentation */
1897    private boolean getIdStr() {
1898        synchronized (mLock) {
1899            final String methodStr = "getIdStr";
1900            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1901            try {
1902                MutableBoolean statusOk = new MutableBoolean(false);
1903                mISupplicantStaNetwork.getIdStr((SupplicantStatus status, String idString) -> {
1904                    statusOk.value = status.code == SupplicantStatusCode.SUCCESS;
1905                    if (statusOk.value) {
1906                        this.mIdStr = idString;
1907                    } else {
1908                        logFailureStatus(status, methodStr);
1909                    }
1910                });
1911                return statusOk.value;
1912            } catch (RemoteException e) {
1913                handleRemoteException(e, methodStr);
1914                return false;
1915            }
1916        }
1917    }
1918    /** See ISupplicantStaNetwork.hal for documentation */
1919    private boolean enable(boolean noConnect) {
1920        synchronized (mLock) {
1921            final String methodStr = "enable";
1922            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1923            try {
1924                SupplicantStatus status =  mISupplicantStaNetwork.enable(noConnect);
1925                return checkStatusAndLogFailure(status, methodStr);
1926            } catch (RemoteException e) {
1927                handleRemoteException(e, methodStr);
1928                return false;
1929            }
1930        }
1931    }
1932    /** See ISupplicantStaNetwork.hal for documentation */
1933    private boolean disable() {
1934        synchronized (mLock) {
1935            final String methodStr = "disable";
1936            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1937            try {
1938                SupplicantStatus status =  mISupplicantStaNetwork.disable();
1939                return checkStatusAndLogFailure(status, methodStr);
1940            } catch (RemoteException e) {
1941                handleRemoteException(e, methodStr);
1942                return false;
1943            }
1944        }
1945    }
1946    /** See ISupplicantStaNetwork.hal for documentation */
1947    public boolean select() {
1948        synchronized (mLock) {
1949            final String methodStr = "select";
1950            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1951            try {
1952                SupplicantStatus status =  mISupplicantStaNetwork.select();
1953                return checkStatusAndLogFailure(status, methodStr);
1954            } catch (RemoteException e) {
1955                handleRemoteException(e, methodStr);
1956                return false;
1957            }
1958        }
1959    }
1960    /** See ISupplicantStaNetwork.hal for documentation */
1961    private boolean sendNetworkEapSimGsmAuthResponse(
1962            ArrayList<ISupplicantStaNetwork.NetworkResponseEapSimGsmAuthParams> params) {
1963        synchronized (mLock) {
1964            final String methodStr = "sendNetworkEapSimGsmAuthResponse";
1965            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1966            try {
1967                SupplicantStatus status =
1968                        mISupplicantStaNetwork.sendNetworkEapSimGsmAuthResponse(params);
1969                return checkStatusAndLogFailure(status, methodStr);
1970            } catch (RemoteException e) {
1971                handleRemoteException(e, methodStr);
1972                return false;
1973            }
1974        }
1975    }
1976    /** See ISupplicantStaNetwork.hal for documentation */
1977    private boolean sendNetworkEapSimGsmAuthFailure() {
1978        synchronized (mLock) {
1979            final String methodStr = "sendNetworkEapSimGsmAuthFailure";
1980            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1981            try {
1982                SupplicantStatus status = mISupplicantStaNetwork.sendNetworkEapSimGsmAuthFailure();
1983                return checkStatusAndLogFailure(status, methodStr);
1984            } catch (RemoteException e) {
1985                handleRemoteException(e, methodStr);
1986                return false;
1987            }
1988        }
1989    }
1990    /** See ISupplicantStaNetwork.hal for documentation */
1991    private boolean sendNetworkEapSimUmtsAuthResponse(
1992            ISupplicantStaNetwork.NetworkResponseEapSimUmtsAuthParams params) {
1993        synchronized (mLock) {
1994            final String methodStr = "sendNetworkEapSimUmtsAuthResponse";
1995            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
1996            try {
1997                SupplicantStatus status =
1998                        mISupplicantStaNetwork.sendNetworkEapSimUmtsAuthResponse(params);
1999                return checkStatusAndLogFailure(status, methodStr);
2000            } catch (RemoteException e) {
2001                handleRemoteException(e, methodStr);
2002                return false;
2003            }
2004        }
2005    }
2006    /** See ISupplicantStaNetwork.hal for documentation */
2007    private boolean sendNetworkEapSimUmtsAutsResponse(byte[/* 14 */] auts) {
2008        synchronized (mLock) {
2009            final String methodStr = "sendNetworkEapSimUmtsAutsResponse";
2010            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
2011            try {
2012                SupplicantStatus status =
2013                        mISupplicantStaNetwork.sendNetworkEapSimUmtsAutsResponse(auts);
2014                return checkStatusAndLogFailure(status, methodStr);
2015            } catch (RemoteException e) {
2016                handleRemoteException(e, methodStr);
2017                return false;
2018            }
2019        }
2020    }
2021    /** See ISupplicantStaNetwork.hal for documentation */
2022    private boolean sendNetworkEapSimUmtsAuthFailure() {
2023        synchronized (mLock) {
2024            final String methodStr = "sendNetworkEapSimUmtsAuthFailure";
2025            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
2026            try {
2027                SupplicantStatus status = mISupplicantStaNetwork.sendNetworkEapSimUmtsAuthFailure();
2028                return checkStatusAndLogFailure(status, methodStr);
2029            } catch (RemoteException e) {
2030                handleRemoteException(e, methodStr);
2031                return false;
2032            }
2033        }
2034    }
2035    /** See ISupplicantStaNetwork.hal for documentation */
2036    private boolean sendNetworkEapIdentityResponse(ArrayList<Byte> identity) {
2037        synchronized (mLock) {
2038            final String methodStr = "sendNetworkEapIdentityResponse";
2039            if (!checkISupplicantStaNetworkAndLogFailure(methodStr)) return false;
2040            try {
2041                SupplicantStatus status =
2042                        mISupplicantStaNetwork.sendNetworkEapIdentityResponse(identity);
2043                return checkStatusAndLogFailure(status, methodStr);
2044            } catch (RemoteException e) {
2045                handleRemoteException(e, methodStr);
2046                return false;
2047            }
2048        }
2049    }
2050
2051    /**
2052     * Returns true if provided status code is SUCCESS, logs debug message and returns false
2053     * otherwise
2054     */
2055    private boolean checkStatusAndLogFailure(SupplicantStatus status, final String methodStr) {
2056        if (DBG) Log.i(TAG, methodStr);
2057        if (status.code != SupplicantStatusCode.SUCCESS) {
2058            Log.e(TAG, methodStr + " failed: "
2059                    + SupplicantStaIfaceHal.supplicantStatusCodeToString(status.code) + ", "
2060                    + status.debugMessage);
2061            return false;
2062        }
2063        return true;
2064    }
2065
2066    /**
2067     * Returns false if ISupplicantStaNetwork is null, and logs failure of methodStr
2068     */
2069    private boolean checkISupplicantStaNetworkAndLogFailure(final String methodStr) {
2070        if (mISupplicantStaNetwork == null) {
2071            Log.e(TAG, "Can't call " + methodStr + ", ISupplicantStaNetwork is null");
2072            return false;
2073        }
2074        return true;
2075    }
2076
2077    private void handleRemoteException(RemoteException e, String methodStr) {
2078        mISupplicantStaNetwork = null;
2079        Log.e(TAG, "ISupplicantStaNetwork." + methodStr + ":exception: " + e);
2080    }
2081
2082    private void logFailureStatus(SupplicantStatus status, String methodStr) {
2083        Log.e(TAG, methodStr + " failed: " + status.debugMessage);
2084    }
2085
2086    /**
2087     * @return the UTF_8 char byte values of str, as an ArrayList
2088     */
2089    private static ArrayList<Byte> stringToByteArrayList(String str) {
2090        ArrayList<Byte> byteArrayList = new ArrayList<Byte>();
2091        for (byte b : str.getBytes(StandardCharsets.UTF_8)) {
2092            byteArrayList.add(new Byte(b));
2093        }
2094        return byteArrayList;
2095    }
2096
2097    /**
2098     * @return the string decoded from UTF_8 byte values in byteArrayList
2099     *         returns null for null input
2100     */
2101    private static String stringFromByteArrayList(ArrayList<Byte> byteArrayList) {
2102        if (byteArrayList == null) return null;
2103        byte[] byteArray = new byte[byteArrayList.size()];
2104        int i = 0;
2105        for (Byte b : byteArrayList) {
2106            byteArray[i] = b;
2107            i++;
2108        }
2109        return new String(byteArray, StandardCharsets.UTF_8);
2110    }
2111
2112    /**
2113     * Converts a mac address string to an array of Byes
2114     * @param bssidStr string of format: "XX:XX:XX:XX:XX:XX", where X is any hexadecimal digit.
2115     *        Passing "any" is the same as 00:00:00:00:00:00
2116     * @throws IllegalArgumentException for various malformed inputs
2117     */
2118    private static byte[] macAddressToByteArray(String bssidStr) {
2119        if (bssidStr == null) {
2120            throw new IllegalArgumentException("null bssid String");
2121        }
2122        if (ANY_BSSID_STR.equals(bssidStr)) return ANY_BSSID_BYTES;
2123        String cleanBssid = bssidStr.replace(":", "");
2124        if (cleanBssid.length() != 12) {
2125            throw new IllegalArgumentException("invalid bssid String length: " + cleanBssid);
2126        }
2127        return HexEncoding.decode(cleanBssid.toCharArray(), false);
2128    }
2129
2130    /**
2131     * Converts an array of 6 bytes to a HexEncoded String with format: "XX:XX:XX:XX:XX:XX", where X
2132     * is any hexadecimal digit.
2133     * @param macArray byte array of bssid values, must have length 6
2134     * @throws IllegalArgumentException for malformed inputs
2135     */
2136    private static String macAddressFromByteArray(byte[] macArray) {
2137        if (macArray == null) {
2138            throw new IllegalArgumentException("null macArray");
2139        }
2140        if (macArray.length != 6) {
2141            throw new IllegalArgumentException("invalid macArray length: " + macArray.length);
2142        }
2143        StringBuilder sb = new StringBuilder();
2144        for (int i = 0; i < macArray.length; i++) {
2145            sb.append(new String(HexEncoding.encode(macArray, i, 1))).append(":");
2146        }
2147        String mac = sb.toString();
2148        return mac.substring(0, mac.length() - 1); //remove trailing ':'
2149    }
2150
2151    /**
2152     * Converts an ssid string to an arraylist of UTF_8 byte values.
2153     * Removes encapsulating quotation marks if they exist
2154     */
2155    private static ArrayList<Byte> encodeSsid(String ssid) {
2156        int length = ssid.length();
2157        if ((length > 1) && (ssid.charAt(0) == '"') && (ssid.charAt(length - 1) == '"')) {
2158            ssid = ssid.substring(1, ssid.length() - 1);
2159        }
2160        return stringToByteArrayList(ssid);
2161    }
2162
2163    /**
2164     * Converts an ArrayList<Byte> of UTF_8 byte values to an SSID String, encapsulated in quotes
2165     * Will return null given null ssidBytes
2166     */
2167    private static String decodeSsid(ArrayList<Byte> ssidBytes) {
2168        if (ssidBytes == null) return null;
2169        if (ssidBytes.size() == 0) return "\"\"";
2170        byte[] ssidArray = new byte[ssidBytes.size()];
2171        int i = 0;
2172        for (Byte b : ssidBytes) {
2173            ssidArray[i] = b;
2174            i++;
2175        }
2176        return "\"" + (new String(ssidArray, StandardCharsets.UTF_8)) + "\"";
2177    }
2178}
2179