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