1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <android-base/logging.h>
18 
19 #include <VtsCoreUtil.h>
20 #include <android/hardware/wifi/1.0/IWifi.h>
21 #include <android/hardware/wifi/supplicant/1.0/ISupplicantStaNetwork.h>
22 #include <android/hardware/wifi/supplicant/1.3/ISupplicantStaNetwork.h>
23 #include <android/hardware/wifi/supplicant/1.4/ISupplicantStaNetwork.h>
24 #include <gtest/gtest.h>
25 #include <hidl/GtestPrinter.h>
26 #include <hidl/ServiceManagement.h>
27 
28 #include "supplicant_hidl_call_util.h"
29 #include "supplicant_hidl_test_utils.h"
30 #include "wifi_hidl_test_utils.h"
31 
32 using ::android::sp;
33 using ::android::hardware::hidl_array;
34 using ::android::hardware::hidl_string;
35 using ::android::hardware::hidl_vec;
36 using ::android::hardware::Return;
37 using ::android::hardware::Void;
38 using ::android::hardware::wifi::supplicant::V1_0::IfaceType;
39 using ::android::hardware::wifi::supplicant::V1_0::ISupplicant;
40 using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaIface;
41 using ::android::hardware::wifi::supplicant::V1_0::ISupplicantStaNetwork;
42 using ::android::hardware::wifi::supplicant::V1_0::
43     ISupplicantStaNetworkCallback;
44 using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatus;
45 using ::android::hardware::wifi::supplicant::V1_0::SupplicantStatusCode;
46 using ::android::hardware::wifi::V1_0::IWifi;
47 
48 namespace {
49 constexpr char kTestSsidStr[] = "TestSsid1234";
50 constexpr char kTestPskPassphrase[] = "TestPsk123";
51 constexpr char kTestIdStr[] = "TestIdstr";
52 constexpr char kTestEapPasswdStr[] = "TestEapPasswd1234";
53 constexpr char kTestEapCert[] = "keystore://CERT";
54 constexpr char kTestEapPrivateKeyId[] = "key_id";
55 constexpr char kTestEapMatch[] = "match";
56 constexpr char kTestEapEngineID[] = "engine_id";
57 constexpr uint8_t kTestBssid[] = {0x56, 0x67, 0x67, 0xf4, 0x56, 0x92};
58 constexpr uint8_t kTestWepKey[] = {0x56, 0x67, 0x67, 0xf4, 0x56};
59 constexpr uint8_t kTestKc[] = {0x56, 0x67, 0x67, 0xf4, 0x76, 0x87, 0x98, 0x12};
60 constexpr uint8_t kTestSres[] = {0x56, 0x67, 0x67, 0xf4};
61 constexpr uint8_t kTestRes[] = {0x56, 0x67, 0x67, 0xf4, 0x67};
62 constexpr uint8_t kTestIk[] = {[0 ... 15] = 0x65};
63 constexpr uint8_t kTestCk[] = {[0 ... 15] = 0x45};
64 constexpr uint8_t kTestIdentity[] = {0x45, 0x67, 0x98, 0x67, 0x56};
65 constexpr uint8_t kTestPsk[] = {[0 ... 31] = 0x12};
66 constexpr uint8_t kTestAutParam[] = {[0 ... 13] = 0xe1};
67 constexpr uint32_t kTestWepTxKeyIdx = 2;
68 constexpr uint32_t kTestUpdateIdentifier = 21;
69 constexpr uint32_t kTestKeyMgmt = (ISupplicantStaNetwork::KeyMgmtMask::WPA_PSK |
70                                    ISupplicantStaNetwork::KeyMgmtMask::WPA_EAP);
71 constexpr uint32_t kTestProto = (ISupplicantStaNetwork::ProtoMask::OSEN |
72                                  ISupplicantStaNetwork::ProtoMask::RSN);
73 constexpr uint32_t kTestAuthAlg = (ISupplicantStaNetwork::AuthAlgMask::OPEN |
74                                    ISupplicantStaNetwork::AuthAlgMask::SHARED);
75 constexpr uint32_t kTestGroupCipher =
76     (ISupplicantStaNetwork::GroupCipherMask::CCMP |
77      ISupplicantStaNetwork::GroupCipherMask::WEP104);
78 constexpr uint32_t kTestPairwiseCipher =
79     (ISupplicantStaNetwork::PairwiseCipherMask::CCMP |
80      ISupplicantStaNetwork::PairwiseCipherMask::TKIP);
81 }  // namespace
82 
83 class SupplicantStaNetworkHidlTest : public SupplicantHidlTestBaseV1_0 {
84    public:
SetUp()85     virtual void SetUp() override {
86         SupplicantHidlTestBaseV1_0::SetUp();
87         sta_network_ = createSupplicantStaNetwork(supplicant_);
88         ASSERT_NE(sta_network_.get(), nullptr);
89         /* variable used to check if the underlying HAL version is 1.3 or
90          * higher. This is to skip tests which are using deprecated methods.
91          */
92         v1_3 = ::android::hardware::wifi::supplicant::V1_3::
93             ISupplicantStaNetwork::castFrom(sta_network_);
94         v1_4 = ::android::hardware::wifi::supplicant::V1_4::
95             ISupplicantStaNetwork::castFrom(sta_network_);
96 
97         ssid_.assign(kTestSsidStr, kTestSsidStr + strlen(kTestSsidStr));
98     }
99 
100    protected:
removeNetwork()101     void removeNetwork() {
102         sp<ISupplicantStaIface> sta_iface = getSupplicantStaIface(supplicant_);
103         ASSERT_NE(nullptr, sta_iface.get());
104         uint32_t net_id;
105         sta_network_->getId(
106             [&](const SupplicantStatus& status, int network_id) {
107                 ASSERT_EQ(SupplicantStatusCode::SUCCESS, status.code);
108                 net_id = network_id;
109             });
110         sta_iface->removeNetwork(net_id, [](const SupplicantStatus& status) {
111             ASSERT_EQ(SupplicantStatusCode::SUCCESS, status.code);
112         });
113     }
114 
115     sp<::android::hardware::wifi::supplicant::V1_3::ISupplicantStaNetwork>
116         v1_3 = nullptr;
117     sp<::android::hardware::wifi::supplicant::V1_4::ISupplicantStaNetwork>
118         v1_4 = nullptr;
119     // ISupplicantStaNetwork object used for all tests in this fixture.
120     sp<ISupplicantStaNetwork> sta_network_;
121     // SSID to use for various tests.
122     std::vector<uint8_t> ssid_;
123 };
124 
125 class NetworkCallback : public ISupplicantStaNetworkCallback {
onNetworkEapSimGsmAuthRequest(const ISupplicantStaNetworkCallback::NetworkRequestEapSimGsmAuthParams &)126     Return<void> onNetworkEapSimGsmAuthRequest(
127         const ISupplicantStaNetworkCallback::NetworkRequestEapSimGsmAuthParams&
128         /* params */) override {
129         return Void();
130     }
onNetworkEapSimUmtsAuthRequest(const ISupplicantStaNetworkCallback::NetworkRequestEapSimUmtsAuthParams &)131     Return<void> onNetworkEapSimUmtsAuthRequest(
132         const ISupplicantStaNetworkCallback::NetworkRequestEapSimUmtsAuthParams&
133         /* params */) override {
134         return Void();
135     }
onNetworkEapIdentityRequest()136     Return<void> onNetworkEapIdentityRequest() override { return Void(); }
137 };
138 
139 /*
140  * Create:
141  * Ensures that an instance of the ISupplicantStaNetwork proxy object is
142  * successfully created.
143  */
TEST_P(SupplicantStaNetworkHidlTest,Create)144 TEST_P(SupplicantStaNetworkHidlTest, Create) {
145     stopSupplicant(wifi_v1_0_instance_name_);
146     startSupplicantAndWaitForHidlService(wifi_v1_0_instance_name_,
147                                          supplicant_instance_name_);
148     sp<ISupplicant> supplicant =
149         getSupplicant(supplicant_instance_name_, isP2pOn_);
150     EXPECT_TRUE(turnOnExcessiveLogging(supplicant));
151     EXPECT_NE(nullptr, createSupplicantStaNetwork(supplicant).get());
152 }
153 
154 /*
155  * RegisterCallback
156  */
TEST_P(SupplicantStaNetworkHidlTest,RegisterCallback)157 TEST_P(SupplicantStaNetworkHidlTest, RegisterCallback) {
158     sta_network_->registerCallback(
159         new NetworkCallback(), [&](const SupplicantStatus& status) {
160             if (nullptr != v1_4) {
161                 EXPECT_EQ(SupplicantStatusCode::FAILURE_UNKNOWN, status.code);
162             } else {
163                 EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
164             }
165         });
166 }
167 
168 /*
169  * GetInterfaceName
170  */
TEST_P(SupplicantStaNetworkHidlTest,GetInterfaceName)171 TEST_P(SupplicantStaNetworkHidlTest, GetInterfaceName) {
172     const auto& status_and_interface_name =
173         HIDL_INVOKE(sta_network_, getInterfaceName);
174     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
175               status_and_interface_name.first.code);
176     EXPECT_FALSE(std::string(status_and_interface_name.second).empty());
177 }
178 
179 /*
180  * GetType
181  */
TEST_P(SupplicantStaNetworkHidlTest,GetType)182 TEST_P(SupplicantStaNetworkHidlTest, GetType) {
183     const auto& status_and_interface_type = HIDL_INVOKE(sta_network_, getType);
184     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
185               status_and_interface_type.first.code);
186     EXPECT_EQ(status_and_interface_type.second, IfaceType::STA);
187 }
188 
189 /* Tests out the various setter/getter methods. */
190 /*
191  * SetGetSsid
192  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetSsid)193 TEST_P(SupplicantStaNetworkHidlTest, SetGetSsid) {
194     sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) {
195         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
196     });
197     sta_network_->getSsid(
198         [&](const SupplicantStatus& status, const hidl_vec<uint8_t>& get_ssid) {
199             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
200             EXPECT_EQ(ssid_, std::vector<uint8_t>(get_ssid));
201         });
202 }
203 
204 /*
205  * SetGetBssid
206  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetBssid)207 TEST_P(SupplicantStaNetworkHidlTest, SetGetBssid) {
208     std::array<uint8_t, 6> set_bssid;
209     memcpy(set_bssid.data(), kTestBssid, set_bssid.size());
210     sta_network_->setBssid(set_bssid, [](const SupplicantStatus& status) {
211         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
212     });
213     sta_network_->getBssid([&](const SupplicantStatus& status,
214                                const hidl_array<uint8_t, 6>& get_bssid_hidl) {
215         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
216         std::array<uint8_t, 6> get_bssid;
217         memcpy(get_bssid.data(), get_bssid_hidl.data(), get_bssid.size());
218         EXPECT_EQ(set_bssid, get_bssid);
219     });
220 }
221 
222 /*
223  * SetGetKeyMgmt
224  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetKeyMgmt)225 TEST_P(SupplicantStaNetworkHidlTest, SetGetKeyMgmt) {
226     if (v1_3 != nullptr) {
227         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
228     }
229     sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) {
230         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
231     });
232     sta_network_->getKeyMgmt(
233         [&](const SupplicantStatus& status, uint32_t key_mgmt) {
234             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
235             EXPECT_EQ(key_mgmt, kTestKeyMgmt);
236         });
237 }
238 
239 /*
240  * SetGetProto
241  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetProto)242 TEST_P(SupplicantStaNetworkHidlTest, SetGetProto) {
243     if (v1_3 != nullptr) {
244         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
245     }
246     sta_network_->setProto(kTestProto, [](const SupplicantStatus& status) {
247         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
248     });
249     sta_network_->getProto([&](const SupplicantStatus& status, uint32_t proto) {
250         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
251         EXPECT_EQ(proto, kTestProto);
252     });
253 }
254 
255 /*
256  * SetGetKeyAuthAlg
257  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetAuthAlg)258 TEST_P(SupplicantStaNetworkHidlTest, SetGetAuthAlg) {
259     sta_network_->setAuthAlg(kTestAuthAlg, [](const SupplicantStatus& status) {
260         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
261     });
262     sta_network_->getAuthAlg(
263         [&](const SupplicantStatus& status, uint32_t auth_alg) {
264             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
265             EXPECT_EQ(auth_alg, kTestAuthAlg);
266         });
267 }
268 
269 /*
270  * SetGetGroupCipher
271  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetGroupCipher)272 TEST_P(SupplicantStaNetworkHidlTest, SetGetGroupCipher) {
273     if (v1_3 != nullptr) {
274         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
275     }
276     sta_network_->setGroupCipher(
277         kTestGroupCipher, [](const SupplicantStatus& status) {
278             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
279         });
280     sta_network_->getGroupCipher(
281         [&](const SupplicantStatus& status, uint32_t group_cipher) {
282             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
283             EXPECT_EQ(group_cipher, kTestGroupCipher);
284         });
285 }
286 
287 /*
288  * SetGetPairwiseCipher
289  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetPairwiseCipher)290 TEST_P(SupplicantStaNetworkHidlTest, SetGetPairwiseCipher) {
291     if (v1_3 != nullptr) {
292         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
293     }
294     sta_network_->setPairwiseCipher(
295         kTestPairwiseCipher, [](const SupplicantStatus& status) {
296             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
297         });
298     sta_network_->getPairwiseCipher(
299         [&](const SupplicantStatus& status, uint32_t pairwise_cipher) {
300             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
301             EXPECT_EQ(pairwise_cipher, kTestPairwiseCipher);
302         });
303 }
304 
305 /*
306  * SetGetPskPassphrase
307  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetPskPassphrase)308 TEST_P(SupplicantStaNetworkHidlTest, SetGetPskPassphrase) {
309     sta_network_->setPskPassphrase(
310         kTestPskPassphrase, [](const SupplicantStatus& status) {
311             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
312         });
313     sta_network_->getPskPassphrase(
314         [&](const SupplicantStatus& status, const hidl_string& psk) {
315             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
316             EXPECT_EQ(kTestPskPassphrase, std::string(psk.c_str()));
317         });
318 }
319 
320 /*
321  * SetGetPsk
322  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetPsk)323 TEST_P(SupplicantStaNetworkHidlTest, SetGetPsk) {
324     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
325               HIDL_INVOKE(sta_network_, setPsk, kTestPsk).code);
326     const auto& status_and_psk = HIDL_INVOKE(sta_network_, getPsk);
327     EXPECT_EQ(SupplicantStatusCode::SUCCESS, status_and_psk.first.code);
328     hidl_array<uint8_t, 32> expected_psk(kTestPsk);
329     EXPECT_EQ(expected_psk, status_and_psk.second);
330 }
331 
332 /*
333  * SetGetWepKeys
334  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetWepTxKeyIdx)335 TEST_P(SupplicantStaNetworkHidlTest, SetGetWepTxKeyIdx) {
336     sta_network_->setWepTxKeyIdx(
337         kTestWepTxKeyIdx, [](const SupplicantStatus& status) {
338             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
339         });
340     sta_network_->getWepTxKeyIdx(
341         [&](const SupplicantStatus& status, uint32_t key_idx) {
342             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
343             EXPECT_EQ(kTestWepTxKeyIdx, key_idx);
344         });
345 }
346 
347 /*
348  * SetGetWepKeys
349  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetWepKeys)350 TEST_P(SupplicantStaNetworkHidlTest, SetGetWepKeys) {
351     for (uint32_t i = 0;
352          i < static_cast<uint32_t>(
353                  ISupplicantStaNetwork::ParamSizeLimits::WEP_KEYS_MAX_NUM);
354          i++) {
355         std::vector<uint8_t> set_wep_key(std::begin(kTestWepKey),
356                                          std::end(kTestWepKey));
357         sta_network_->setWepKey(
358             i, set_wep_key, [](const SupplicantStatus& status) {
359                 EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
360             });
361         sta_network_->getWepKey(i, [&](const SupplicantStatus& status,
362                                        const hidl_vec<uint8_t>& get_wep_key) {
363             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
364             EXPECT_EQ(set_wep_key, std::vector<uint8_t>(get_wep_key));
365         });
366     }
367 }
368 
369 /*
370  * SetGetScanSsid
371  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetScanSsid)372 TEST_P(SupplicantStaNetworkHidlTest, SetGetScanSsid) {
373     sta_network_->setScanSsid(
374         true, [](const SupplicantStatus& status) {
375             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
376         });
377     sta_network_->getScanSsid(
378         [&](const SupplicantStatus& status, bool scan_ssid) {
379             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
380             EXPECT_EQ(true, scan_ssid);
381         });
382 }
383 
384 /*
385  * SetGetRequirePmf
386  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetRequirePmf)387 TEST_P(SupplicantStaNetworkHidlTest, SetGetRequirePmf) {
388     sta_network_->setRequirePmf(
389         true, [](const SupplicantStatus& status) {
390             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
391         });
392     sta_network_->getRequirePmf(
393         [&](const SupplicantStatus& status, bool require_pmf) {
394             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
395             EXPECT_EQ(true, require_pmf);
396         });
397 }
398 
399 /*
400  * SetGetIdStr
401  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetIdStr)402 TEST_P(SupplicantStaNetworkHidlTest, SetGetIdStr) {
403     sta_network_->setIdStr(
404         kTestIdStr, [](const SupplicantStatus& status) {
405             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
406         });
407     sta_network_->getIdStr(
408         [&](const SupplicantStatus& status, const hidl_string& id_str) {
409             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
410             EXPECT_EQ(kTestIdStr, std::string(id_str.c_str()));
411         });
412 }
413 
414 /*
415  * SetGetEapMethod
416  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapMethod)417 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapMethod) {
418     ISupplicantStaNetwork::EapMethod set_eap_method =
419         ISupplicantStaNetwork::EapMethod::PEAP;
420     sta_network_->setEapMethod(
421         set_eap_method, [](const SupplicantStatus& status) {
422             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
423         });
424     sta_network_->getEapMethod(
425         [&](const SupplicantStatus& status,
426             ISupplicantStaNetwork::EapMethod eap_method) {
427             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
428             EXPECT_EQ(set_eap_method, eap_method);
429         });
430 }
431 
432 /*
433  * SetGetEapPhase2Method
434  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapPhase2Method)435 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapPhase2Method) {
436     ISupplicantStaNetwork::EapMethod set_eap_method =
437         ISupplicantStaNetwork::EapMethod::PEAP;
438     sta_network_->setEapMethod(
439         set_eap_method, [](const SupplicantStatus& status) {
440             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
441         });
442     ISupplicantStaNetwork::EapPhase2Method set_eap_phase2_method =
443         ISupplicantStaNetwork::EapPhase2Method::NONE;
444     sta_network_->setEapPhase2Method(
445         set_eap_phase2_method, [](const SupplicantStatus& status) {
446             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
447         });
448     sta_network_->getEapPhase2Method(
449         [&](const SupplicantStatus& status,
450             ISupplicantStaNetwork::EapPhase2Method eap_phase2_method) {
451             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
452             EXPECT_EQ(set_eap_phase2_method, eap_phase2_method);
453         });
454 }
455 
456 /*
457  * SetGetEapIdentity
458  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapIdentity)459 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapIdentity) {
460     std::vector<uint8_t> set_identity(kTestIdentity, kTestIdentity + sizeof(kTestIdentity));
461     sta_network_->setEapIdentity(
462         set_identity, [](const SupplicantStatus& status) {
463             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
464         });
465     sta_network_->getEapIdentity(
466         [&](const SupplicantStatus& status, const std::vector<uint8_t>& identity) {
467             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
468             EXPECT_EQ(set_identity, identity);
469         });
470 }
471 
472 /*
473  * SetGetEapAnonymousIdentity
474  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapAnonymousIdentity)475 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapAnonymousIdentity) {
476     std::vector<uint8_t> set_identity(kTestIdentity, kTestIdentity + sizeof(kTestIdentity));
477     sta_network_->setEapAnonymousIdentity(
478         set_identity, [](const SupplicantStatus& status) {
479             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
480         });
481     sta_network_->getEapAnonymousIdentity(
482         [&](const SupplicantStatus& status, const std::vector<uint8_t>& identity) {
483             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
484             EXPECT_EQ(set_identity, identity);
485         });
486 }
487 
488 /*
489  * SetGetEapPassword
490  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapPassword)491 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapPassword) {
492     std::vector<uint8_t> set_eap_passwd(
493         kTestEapPasswdStr, kTestEapPasswdStr + strlen(kTestEapPasswdStr));
494     sta_network_->setEapPassword(
495         set_eap_passwd, [](const SupplicantStatus& status) {
496             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
497         });
498     sta_network_->getEapPassword([&](const SupplicantStatus& status,
499                                      const hidl_vec<uint8_t>& eap_passwd) {
500         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
501         EXPECT_EQ(set_eap_passwd, std::vector<uint8_t>(eap_passwd));
502     });
503 }
504 
505 /*
506  * SetGetEapCACert
507  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapCACert)508 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapCACert) {
509     sta_network_->setEapCACert(
510         kTestEapCert, [](const SupplicantStatus& status) {
511             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
512         });
513     sta_network_->getEapCACert([&](const SupplicantStatus& status,
514                                    const hidl_string& eap_cert) {
515         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
516         EXPECT_EQ(kTestEapCert, std::string(eap_cert.c_str()));
517     });
518 }
519 
520 /*
521  * SetGetEapCAPath
522  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapCAPath)523 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapCAPath) {
524     sta_network_->setEapCAPath(
525         kTestEapCert, [](const SupplicantStatus& status) {
526             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
527         });
528     sta_network_->getEapCAPath([&](const SupplicantStatus& status,
529                                    const hidl_string& eap_cert) {
530         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
531         EXPECT_EQ(kTestEapCert, std::string(eap_cert.c_str()));
532     });
533 }
534 
535 /*
536  * SetGetEapClientCert
537  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapClientCert)538 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapClientCert) {
539     sta_network_->setEapClientCert(
540         kTestEapCert, [](const SupplicantStatus& status) {
541             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
542         });
543     sta_network_->getEapClientCert([&](const SupplicantStatus& status,
544                                        const hidl_string& eap_cert) {
545         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
546         EXPECT_EQ(kTestEapCert, std::string(eap_cert.c_str()));
547     });
548 }
549 
550 /*
551  * SetGetEapPrivateKeyId
552  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapPrivateKeyId)553 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapPrivateKeyId) {
554     sta_network_->setEapPrivateKeyId(
555         kTestEapPrivateKeyId, [](const SupplicantStatus& status) {
556             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
557         });
558     sta_network_->getEapPrivateKeyId([&](const SupplicantStatus& status,
559                                          const hidl_string& key_id) {
560         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
561         EXPECT_EQ(kTestEapPrivateKeyId, std::string(key_id.c_str()));
562     });
563 }
564 
565 /*
566  * SetGetEapAltSubjectMatch
567  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapAltSubjectMatch)568 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapAltSubjectMatch) {
569     sta_network_->setEapAltSubjectMatch(
570         kTestEapMatch, [](const SupplicantStatus& status) {
571             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
572         });
573     sta_network_->getEapAltSubjectMatch([&](const SupplicantStatus& status,
574                                             const hidl_string& match) {
575         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
576         EXPECT_EQ(kTestEapMatch, std::string(match.c_str()));
577     });
578 }
579 
580 /*
581  * SetGetEapSubjectMatch
582  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapSubjectMatch)583 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapSubjectMatch) {
584     EXPECT_EQ(
585         SupplicantStatusCode::SUCCESS,
586         HIDL_INVOKE(sta_network_, setEapSubjectMatch, kTestEapMatch).code);
587     const auto& status_and_subject_match =
588         HIDL_INVOKE(sta_network_, getEapSubjectMatch);
589     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
590               status_and_subject_match.first.code);
591     EXPECT_EQ(kTestEapMatch,
592               std::string(status_and_subject_match.second.c_str()));
593 }
594 
595 /*
596  * SetGetEapDomainSuffixMatch
597  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapDomainSuffixMatch)598 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapDomainSuffixMatch) {
599     sta_network_->setEapDomainSuffixMatch(
600         kTestEapMatch, [](const SupplicantStatus& status) {
601             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
602         });
603     sta_network_->getEapDomainSuffixMatch([&](const SupplicantStatus& status,
604                                               const hidl_string& match) {
605         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
606         EXPECT_EQ(kTestEapMatch, std::string(match.c_str()));
607     });
608 }
609 
610 /*
611  * SetGetEapEngine
612  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapEngine)613 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapEngine) {
614     sta_network_->setEapEngine(
615         true, [](const SupplicantStatus& status) {
616             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
617         });
618     sta_network_->getEapEngine([&](const SupplicantStatus& status,
619                                    bool enable) {
620         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
621         EXPECT_EQ(true, enable);
622     });
623 }
624 
625 /*
626  * SetGetEapEngineID
627  */
TEST_P(SupplicantStaNetworkHidlTest,SetGetEapEngineID)628 TEST_P(SupplicantStaNetworkHidlTest, SetGetEapEngineID) {
629     sta_network_->setEapEngineID(
630         kTestEapEngineID, [](const SupplicantStatus& status) {
631             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
632         });
633     sta_network_->getEapEngineID([&](const SupplicantStatus& status,
634                                      const hidl_string& id) {
635         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
636         EXPECT_EQ(kTestEapEngineID, std::string(id.c_str()));
637     });
638 }
639 
640 /*
641  * Enable
642  */
TEST_P(SupplicantStaNetworkHidlTest,Enable)643 TEST_P(SupplicantStaNetworkHidlTest, Enable) {
644     if (v1_3 != nullptr) {
645         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
646     }
647     // wpa_supplicant doesn't perform any connection initiation
648     // unless atleast the Ssid and Ket mgmt params are set.
649     sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) {
650         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
651     });
652     sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) {
653         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
654     });
655 
656     sta_network_->enable(false, [](const SupplicantStatus& status) {
657         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
658     });
659     sta_network_->enable(true, [](const SupplicantStatus& status) {
660         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
661     });
662 
663     // Now remove the network and ensure that the calls fail.
664     removeNetwork();
665     sta_network_->enable(true, [](const SupplicantStatus& status) {
666         EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_INVALID, status.code);
667     });
668 }
669 
670 /*
671  * Disable
672  */
TEST_P(SupplicantStaNetworkHidlTest,Disable)673 TEST_P(SupplicantStaNetworkHidlTest, Disable) {
674     if (v1_3 != nullptr) {
675         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
676     }
677     // wpa_supplicant doesn't perform any connection initiation
678     // unless atleast the Ssid and Ket mgmt params are set.
679     sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) {
680         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
681     });
682     sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) {
683         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
684     });
685 
686     sta_network_->disable([](const SupplicantStatus& status) {
687         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
688     });
689     // Now remove the network and ensure that the calls fail.
690     removeNetwork();
691     sta_network_->disable([](const SupplicantStatus& status) {
692         EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_INVALID, status.code);
693     });
694 }
695 
696 /*
697  * Select.
698  */
TEST_P(SupplicantStaNetworkHidlTest,Select)699 TEST_P(SupplicantStaNetworkHidlTest, Select) {
700     if (v1_3 != nullptr) {
701         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
702     }
703     // wpa_supplicant doesn't perform any connection initiation
704     // unless atleast the Ssid and Ket mgmt params are set.
705     sta_network_->setSsid(ssid_, [](const SupplicantStatus& status) {
706         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
707     });
708     sta_network_->setKeyMgmt(kTestKeyMgmt, [](const SupplicantStatus& status) {
709         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
710     });
711 
712     sta_network_->select([](const SupplicantStatus& status) {
713         EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
714     });
715     // Now remove the network and ensure that the calls fail.
716     removeNetwork();
717     sta_network_->select([](const SupplicantStatus& status) {
718         EXPECT_EQ(SupplicantStatusCode::FAILURE_NETWORK_INVALID, status.code);
719     });
720 }
721 
722 /*
723  * SendNetworkEapSimGsmAuthResponse
724  */
TEST_P(SupplicantStaNetworkHidlTest,SendNetworkEapSimGsmAuthResponse)725 TEST_P(SupplicantStaNetworkHidlTest, SendNetworkEapSimGsmAuthResponse) {
726     std::vector<ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams>
727         params;
728     ISupplicantStaNetwork::NetworkResponseEapSimGsmAuthParams param;
729     memcpy(param.kc.data(), kTestKc, param.kc.size());
730     memcpy(param.sres.data(), kTestSres, param.sres.size());
731     params.push_back(param);
732     sta_network_->sendNetworkEapSimGsmAuthResponse(
733         params, [](const SupplicantStatus& status) {
734             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
735         });
736 }
737 
738 /*
739  * SendNetworkEapSimGsmAuthFailure
740  */
TEST_P(SupplicantStaNetworkHidlTest,SendNetworkEapSimGsmAuthFailure)741 TEST_P(SupplicantStaNetworkHidlTest, SendNetworkEapSimGsmAuthFailure) {
742     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
743               HIDL_INVOKE(sta_network_, sendNetworkEapSimGsmAuthFailure).code);
744 }
745 
746 /*
747  * SendNetworkEapSimUmtsAuthResponse
748  */
TEST_P(SupplicantStaNetworkHidlTest,SendNetworkEapSimUmtsAuthResponse)749 TEST_P(SupplicantStaNetworkHidlTest, SendNetworkEapSimUmtsAuthResponse) {
750     ISupplicantStaNetwork::NetworkResponseEapSimUmtsAuthParams params;
751     params.res = std::vector<uint8_t>(kTestRes, kTestRes + sizeof(kTestRes));
752     memcpy(params.ik.data(), kTestIk, params.ik.size());
753     memcpy(params.ck.data(), kTestCk, params.ck.size());
754     sta_network_->sendNetworkEapSimUmtsAuthResponse(
755         params, [](const SupplicantStatus& status) {
756             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
757         });
758 }
759 
760 /*
761  * SendNetworkEapSimUmtsAuthFailure
762  */
TEST_P(SupplicantStaNetworkHidlTest,SendNetworkEapSimUmtsAuthFailure)763 TEST_P(SupplicantStaNetworkHidlTest, SendNetworkEapSimUmtsAuthFailure) {
764     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
765               HIDL_INVOKE(sta_network_, sendNetworkEapSimUmtsAuthFailure).code);
766 }
767 
768 /*
769  * SendNetworkEapSimUmtsAutsResponse
770  */
TEST_P(SupplicantStaNetworkHidlTest,SendNetworkEapSimUmtsAutsResponse)771 TEST_P(SupplicantStaNetworkHidlTest, SendNetworkEapSimUmtsAutsResponse) {
772     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
773               HIDL_INVOKE(sta_network_, sendNetworkEapSimUmtsAutsResponse,
774                           kTestAutParam)
775                   .code);
776 }
777 
778 /*
779  * SendNetworkEapIdentityResponse
780  */
TEST_P(SupplicantStaNetworkHidlTest,SendNetworkEapIdentityResponse)781 TEST_P(SupplicantStaNetworkHidlTest, SendNetworkEapIdentityResponse) {
782     sta_network_->sendNetworkEapIdentityResponse(
783         std::vector<uint8_t>(kTestIdentity,
784                              kTestIdentity + sizeof(kTestIdentity)),
785         [](const SupplicantStatus& status) {
786             EXPECT_EQ(SupplicantStatusCode::SUCCESS, status.code);
787         });
788 }
789 
790 /*
791  * SetUpdateIdentifier
792  */
TEST_P(SupplicantStaNetworkHidlTest,SetUpdateIdentifier)793 TEST_P(SupplicantStaNetworkHidlTest, SetUpdateIdentifier) {
794     EXPECT_EQ(
795         SupplicantStatusCode::SUCCESS,
796         HIDL_INVOKE(sta_network_, setUpdateIdentifier, kTestUpdateIdentifier)
797             .code);
798 }
799 
800 /*
801  * SetProactiveKeyCaching
802  */
TEST_P(SupplicantStaNetworkHidlTest,SetProactiveKeyCaching)803 TEST_P(SupplicantStaNetworkHidlTest, SetProactiveKeyCaching) {
804     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
805               HIDL_INVOKE(sta_network_, setProactiveKeyCaching, true).code);
806     EXPECT_EQ(SupplicantStatusCode::SUCCESS,
807               HIDL_INVOKE(sta_network_, setProactiveKeyCaching, false).code);
808 }
809 
810 /*
811  * GetWpsNfcConfigurationToken
812  */
TEST_P(SupplicantStaNetworkHidlTest,GetWpsNfcConfigurationToken)813 TEST_P(SupplicantStaNetworkHidlTest, GetWpsNfcConfigurationToken) {
814     if (v1_3 != nullptr) {
815         GTEST_SKIP() << "Skipping test since HAL is 1.3 or higher";
816     }
817     ASSERT_EQ(SupplicantStatusCode::SUCCESS,
818               HIDL_INVOKE(sta_network_, setSsid, ssid_).code);
819     ASSERT_EQ(SupplicantStatusCode::SUCCESS,
820               HIDL_INVOKE(sta_network_, setKeyMgmt, kTestKeyMgmt).code);
821     ASSERT_EQ(
822         SupplicantStatusCode::SUCCESS,
823         HIDL_INVOKE(sta_network_, setPskPassphrase, kTestPskPassphrase).code);
824     const auto& status_and_token =
825         HIDL_INVOKE(sta_network_, getWpsNfcConfigurationToken);
826     EXPECT_EQ(SupplicantStatusCode::SUCCESS, status_and_token.first.code);
827     EXPECT_FALSE(0 == status_and_token.second.size());
828 }
829 
830 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantStaNetworkHidlTest);
831 INSTANTIATE_TEST_CASE_P(
832     PerInstance, SupplicantStaNetworkHidlTest,
833     testing::Combine(
834         testing::ValuesIn(
835             android::hardware::getAllHalInstanceNames(IWifi::descriptor)),
836         testing::ValuesIn(android::hardware::getAllHalInstanceNames(
837             ISupplicant::descriptor))),
838     android::hardware::PrintInstanceTupleNameToString<>);
839