1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "wifi_settings.h"
17 #include "define.h"
18 #include "wifi_cert_utils.h"
19 #include "wifi_global_func.h"
20 #include "wifi_log.h"
21 #include "wifi_config_country_freqs.h"
22 #include "mac_address.h"
23 #ifndef OHOS_ARCH_LITE
24 #include <sys/sendfile.h>
25 #include "wifi_country_code_define.h"
26 #include "network_parser.h"
27 #include "softap_parser.h"
28 #include "package_parser.h"
29 #include "wifi_backup_config.h"
30 #include "json/json.h"
31 #endif
32 #ifdef SUPPORT_ClOUD_WIFI_ASSET
33 #include "wifi_asset_manager.h"
34 #endif
35 #ifdef INIT_LIB_ENABLE
36 #include "parameter.h"
37 #endif
38 #if defined(FEATURE_ENCRYPTION_SUPPORT) || defined(SUPPORT_LOCAL_RANDOM_MAC)
39 #include "wifi_encryption_util.h"
40 #endif
41 #include "wifi_config_center.h"
42
43 namespace OHOS {
44 namespace Wifi {
45 #ifdef DTFUZZ_TEST
46 static WifiSettings* gWifiSettings = nullptr;
47 #endif
48
GetInstance()49 WifiSettings &WifiSettings::GetInstance()
50 {
51 #ifndef DTFUZZ_TEST
52 static WifiSettings gWifiSettings;
53 return gWifiSettings;
54 #else
55 if (gWifiSettings == nullptr) {
56 gWifiSettings = new (std::nothrow) WifiSettings();
57 }
58 return *gWifiSettings;
59 #endif
60 }
61
WifiSettings()62 WifiSettings::WifiSettings()
63 : mNetworkId(0),
64 mApMaxConnNum(MAX_AP_CONN),
65 mMaxNumConfigs(MAX_CONFIGS_NUM)
66 {
67 }
68
~WifiSettings()69 WifiSettings::~WifiSettings()
70 {
71 SyncDeviceConfig();
72 SyncHotspotConfig();
73 {
74 std::unique_lock<std::mutex> lock(mApMutex);
75 SyncBlockList();
76 }
77 SyncWifiP2pGroupInfoConfig();
78 SyncP2pVendorConfig();
79 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
80 SyncWifiConfig();
81 }
82
Init()83 int WifiSettings::Init()
84 {
85 /* read ini config */
86 mSavedDeviceConfig.SetConfigFilePath(DEVICE_CONFIG_FILE_PATH);
87 mSavedHotspotConfig.SetConfigFilePath(HOTSPOT_CONFIG_FILE_PATH);
88 mSavedBlockInfo.SetConfigFilePath(BLOCK_LIST_FILE_PATH);
89 mSavedWifiConfig.SetConfigFilePath(WIFI_CONFIG_FILE_PATH);
90 mSavedWifiP2pGroupInfo.SetConfigFilePath(WIFI_P2P_GROUP_INFO_FILE_PATH);
91 mSavedWifiP2pVendorConfig.SetConfigFilePath(WIFI_P2P_VENDOR_CONFIG_FILE_PATH);
92 mTrustListPolicies.SetConfigFilePath(WIFI_TRUST_LIST_POLICY_FILE_PATH);
93 mMovingFreezePolicy.SetConfigFilePath(WIFI_MOVING_FREEZE_POLICY_FILE_PATH);
94 mSavedWifiStoreRandomMac.SetConfigFilePath(WIFI_STA_RANDOM_MAC_FILE_PATH);
95 #ifndef OHOS_ARCH_LITE
96 MergeWifiConfig();
97 MergeSoftapConfig();
98 #endif
99 #if defined(FEATURE_ENCRYPTION_SUPPORT) || defined(SUPPORT_LOCAL_RANDOM_MAC)
100 SetUpHks();
101 #endif
102 InitWifiConfig();
103 ReloadDeviceConfig();
104 InitHotspotConfig();
105 InitP2pVendorConfig();
106 ReloadWifiP2pGroupInfoConfig();
107 ReloadTrustListPolicies();
108 ReloadMovingFreezePolicy();
109 ReloadStaRandomMac();
110 InitPackageInfoConfig();
111 IncreaseNumRebootsSinceLastUse();
112 return 0;
113 }
114
AddDeviceConfig(const WifiDeviceConfig & config)115 int WifiSettings::AddDeviceConfig(const WifiDeviceConfig &config)
116 {
117 if (config.ssid.empty() || (config.keyMgmt == KEY_MGMT_WPA_PSK && config.preSharedKey.length() == 0)) {
118 LOGE("AddDeviceConfig fail, networkId:%{public}d, keyMgmt:%{public}s",
119 config.networkId, config.keyMgmt.c_str());
120 return -1;
121 }
122 std::unique_lock<std::mutex> lock(mStaMutex);
123 auto iter = mWifiDeviceConfig.find(config.networkId);
124 if (iter != mWifiDeviceConfig.end()) {
125 #ifdef SUPPORT_ClOUD_WIFI_ASSET
126 if (WifiAssetManager::GetInstance().IsWifiConfigChanged(config, iter->second)) {
127 WifiAssetManager::GetInstance().WifiAssetUpdate(config);
128 }
129 #endif
130 iter->second = config;
131 } else {
132 if (mWifiDeviceConfig.size() > WIFI_DEVICE_CONFIG_MAX_MUN) {
133 LOGE("AddDeviceConfig Exceeding the maximum value!");
134 return -1;
135 }
136 mWifiDeviceConfig.emplace(std::make_pair(config.networkId, config));
137 #ifdef SUPPORT_ClOUD_WIFI_ASSET
138 WifiAssetManager::GetInstance().WifiAssetAdd(config, USER_ID_DEFAULT, false);
139 #endif
140 }
141 return config.networkId;
142 }
143
SyncAfterDecryped(WifiDeviceConfig & config)144 void WifiSettings::SyncAfterDecryped(WifiDeviceConfig &config)
145 {
146 #ifdef FEATURE_ENCRYPTION_SUPPORT
147 if (IsWifiDeviceConfigDeciphered(config)) {
148 return;
149 }
150 DecryptionDeviceConfig(config);
151 #ifdef SUPPORT_ClOUD_WIFI_ASSET
152 WifiAssetManager::GetInstance().WifiAssetAdd(config);
153 #endif
154 #endif
155 }
156
RemoveDevice(int networkId)157 int WifiSettings::RemoveDevice(int networkId)
158 {
159 std::unique_lock<std::mutex> lock(mStaMutex);
160 auto iter = mWifiDeviceConfig.find(networkId);
161 if (iter != mWifiDeviceConfig.end()) {
162 if (!iter->second.wifiEapConfig.clientCert.empty()) {
163 if (WifiCertUtils::UninstallCert(iter->second.wifiEapConfig.clientCert) != 0) {
164 LOGE("uninstall cert %{public}s fail", iter->second.wifiEapConfig.clientCert.c_str());
165 } else {
166 LOGD("uninstall cert %{public}s success", iter->second.wifiEapConfig.clientCert.c_str());
167 }
168 }
169 #ifdef SUPPORT_ClOUD_WIFI_ASSET
170 WifiAssetManager::GetInstance().WifiAssetRemove(iter->second);
171 #endif
172 mWifiDeviceConfig.erase(iter);
173 }
174 return 0;
175 }
176
ClearDeviceConfig(void)177 void WifiSettings::ClearDeviceConfig(void)
178 {
179 std::unique_lock<std::mutex> lock(mStaMutex);
180 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
181 if (iter->second.wifiEapConfig.clientCert.empty()) {
182 continue;
183 }
184 if (WifiCertUtils::UninstallCert(iter->second.wifiEapConfig.clientCert) != 0) {
185 LOGE("uninstall cert %{public}s fail", iter->second.wifiEapConfig.clientCert.c_str());
186 } else {
187 LOGD("uninstall cert %{public}s success", iter->second.wifiEapConfig.clientCert.c_str());
188 }
189 }
190 mWifiDeviceConfig.clear();
191 return;
192 }
193
GetDeviceConfig(std::vector<WifiDeviceConfig> & results,int instId)194 int WifiSettings::GetDeviceConfig(std::vector<WifiDeviceConfig> &results, int instId)
195 {
196 if (!deviceConfigLoadFlag.test_and_set()) {
197 LOGD("Reload wifi config");
198 ReloadDeviceConfig();
199 }
200 std::unique_lock<std::mutex> lock(mStaMutex);
201 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
202 // -1: Connect by system, use default uid.
203 if ((iter->second.uid == -1 || iter->second.isShared) && iter->second.instanceId == instId) {
204 results.push_back(iter->second);
205 }
206 }
207 return 0;
208 }
209
GetDeviceConfig(const int & networkId,WifiDeviceConfig & config,int instId)210 int WifiSettings::GetDeviceConfig(const int &networkId, WifiDeviceConfig &config, int instId)
211 {
212 if (!deviceConfigLoadFlag.test_and_set()) {
213 LOGD("Reload wifi config");
214 ReloadDeviceConfig();
215 }
216 std::unique_lock<std::mutex> lock(mStaMutex);
217 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
218 if (iter->second.networkId == networkId && iter->second.instanceId == instId) {
219 SyncAfterDecryped(iter->second);
220 config = iter->second;
221 return 0;
222 }
223 }
224 return -1;
225 }
226
GetDeviceConfig(const std::string & index,const int & indexType,WifiDeviceConfig & config,int instId)227 int WifiSettings::GetDeviceConfig(const std::string &index, const int &indexType,
228 WifiDeviceConfig &config, int instId)
229 {
230 if (!deviceConfigLoadFlag.test_and_set()) {
231 LOGD("Reload wifi config");
232 ReloadDeviceConfig();
233 }
234 std::unique_lock<std::mutex> lock(mStaMutex);
235 if (indexType == DEVICE_CONFIG_INDEX_SSID) {
236 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
237 if (iter->second.ssid == index && iter->second.instanceId == instId) {
238 SyncAfterDecryped(iter->second);
239 config = iter->second;
240 return 0;
241 }
242 }
243 } else {
244 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
245 if (iter->second.bssid == index && iter->second.instanceId == instId) {
246 SyncAfterDecryped(iter->second);
247 config = iter->second;
248 return 0;
249 }
250 }
251 }
252 return -1;
253 }
254
GetDeviceConfig(const std::string & ssid,const std::string & keymgmt,WifiDeviceConfig & config,int instId)255 int WifiSettings::GetDeviceConfig(const std::string &ssid, const std::string &keymgmt,
256 WifiDeviceConfig &config, int instId)
257 {
258 if (!deviceConfigLoadFlag.test_and_set()) {
259 LOGD("Reload wifi config");
260 ReloadDeviceConfig();
261 }
262
263 std::unique_lock<std::mutex> lock(mStaMutex);
264 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
265 if ((iter->second.ssid == ssid) && (InKeyMgmtBitset(iter->second, keymgmt))
266 && (iter->second.uid == -1 || iter->second.isShared) && iter->second.instanceId == instId) {
267 SyncAfterDecryped(iter->second);
268 config = iter->second;
269 return 0;
270 }
271 }
272
273 return -1;
274 }
275
SetUserConnectChoice(int networkId)276 void WifiSettings::SetUserConnectChoice(int networkId)
277 {
278 WifiDeviceConfig selectConfig;
279 if (GetDeviceConfig(networkId, selectConfig) != 0 || selectConfig.ssid.empty()) {
280 LOGE("%{public}s, not find networkId:%{public}d", __FUNCTION__, networkId);
281 return;
282 }
283 LOGI("%{public}s enter, networkId:%{public}d, ssid: %{public}s", __FUNCTION__, networkId,
284 SsidAnonymize(selectConfig.ssid).c_str());
285 if (selectConfig.networkSelectionStatus.status != WifiDeviceConfigStatus::ENABLED) {
286 selectConfig.networkSelectionStatus.status = WifiDeviceConfigStatus::ENABLED;
287 }
288 struct timespec times = {0, 0};
289 clock_gettime(CLOCK_BOOTTIME, ×);
290 long currentTime = static_cast<int64_t>(times.tv_sec) * MSEC + times.tv_nsec / (MSEC * MSEC);
291 std::vector<WifiDeviceConfig> savedNetwork;
292 GetDeviceConfig(savedNetwork);
293 for (const auto &config : savedNetwork) {
294 if (config.networkId == selectConfig.networkId) {
295 if (config.networkSelectionStatus.connectChoice != INVALID_NETWORK_ID) {
296 LOGI("%{public}s remove user select preference of %{public}d,"
297 "set time %{public}ld from %{public}s, networkId: %{public}d", __FUNCTION__,
298 config.networkSelectionStatus.connectChoice, currentTime, SsidAnonymize(config.ssid).c_str(),
299 config.networkId);
300 ClearNetworkConnectChoice(config.networkId);
301 }
302 continue;
303 }
304 if (config.networkSelectionStatus.seenInLastQualifiedNetworkSelection || config.hiddenSSID) {
305 LOGI("%{public}s add select net:%{public}d set time:%{public}ld to net:%{public}d with ssid:%{public}s",
306 __FUNCTION__, selectConfig.networkId, currentTime, config.networkId,
307 SsidAnonymize(config.ssid).c_str());
308 SetNetworkConnectChoice(config.networkId, selectConfig.networkId, currentTime);
309 }
310 }
311 }
312
ClearAllNetworkConnectChoice()313 void WifiSettings::ClearAllNetworkConnectChoice()
314 {
315 std::vector<WifiDeviceConfig> savedNetwork;
316 if (GetDeviceConfig(savedNetwork) != 0) {
317 LOGI("%{public}s GetDeviceConfig fail", __FUNCTION__);
318 return;
319 }
320 for (auto &config : savedNetwork) {
321 if (config.networkSelectionStatus.connectChoice != INVALID_NETWORK_ID) {
322 config.networkSelectionStatus.connectChoice = INVALID_NETWORK_ID;
323 config.networkSelectionStatus.connectChoiceTimestamp = INVALID_NETWORK_SELECTION_DISABLE_TIMESTAMP;
324 AddDeviceConfig(config);
325 }
326 }
327 }
328
ClearNetworkConnectChoice(int networkId)329 bool WifiSettings::ClearNetworkConnectChoice(int networkId)
330 {
331 WifiDeviceConfig config;
332 if (GetDeviceConfig(networkId, config) != 0) {
333 LOGI("%{public}s, cannot find networkId %{public}d", __FUNCTION__, networkId);
334 return false;
335 }
336 config.networkSelectionStatus.connectChoice = INVALID_NETWORK_ID;
337 config.networkSelectionStatus.connectChoiceTimestamp = INVALID_NETWORK_SELECTION_DISABLE_TIMESTAMP;
338 AddDeviceConfig(config);
339 return true;
340 }
341
RemoveConnectChoiceFromAllNetwork(int networkId)342 void WifiSettings::RemoveConnectChoiceFromAllNetwork(int networkId)
343 {
344 if (networkId == INVALID_NETWORK_ID) {
345 LOGE("%{public}s network is invalid %{public}d", __FUNCTION__, networkId);
346 return;
347 }
348 std::vector<WifiDeviceConfig> savedConfig;
349 if (GetDeviceConfig(savedConfig) != 0) {
350 LOGI("%{public}s GetDeviceConfig fail", __FUNCTION__);
351 return;
352 }
353 for (auto &config : savedConfig) {
354 if (config.networkSelectionStatus.connectChoice == networkId) {
355 ClearNetworkConnectChoice(config.networkId);
356 }
357 }
358 }
359
SetNetworkConnectChoice(int networkId,int selectNetworkId,long timestamp)360 bool WifiSettings::SetNetworkConnectChoice(int networkId, int selectNetworkId, long timestamp)
361 {
362 WifiDeviceConfig config;
363 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config) != 0) {
364 LOGI("%{public}s, not find networkId %{public}d", __FUNCTION__, networkId);
365 return false;
366 }
367 config.networkSelectionStatus.connectChoice = selectNetworkId;
368 config.networkSelectionStatus.connectChoiceTimestamp = timestamp;
369 AddDeviceConfig(config);
370 return true;
371 }
372
ClearNetworkCandidateScanResult(int networkId)373 bool WifiSettings::ClearNetworkCandidateScanResult(int networkId)
374 {
375 WifiDeviceConfig config;
376 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config) != 0) {
377 LOGI("%{public}s, not find networkId %{public}d", __FUNCTION__, networkId);
378 return false;
379 }
380 config.networkSelectionStatus.seenInLastQualifiedNetworkSelection = false;
381 AddDeviceConfig(config);
382 return true;
383 }
384
SetNetworkCandidateScanResult(int networkId)385 bool WifiSettings::SetNetworkCandidateScanResult(int networkId)
386 {
387 WifiDeviceConfig config;
388 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config) != 0) {
389 LOGI("%{public}s, not find networkId %{public}d", __FUNCTION__, networkId);
390 return false;
391 }
392 config.networkSelectionStatus.seenInLastQualifiedNetworkSelection = true;
393 AddDeviceConfig(config);
394 return true;
395 }
396
SetDeviceEphemeral(int networkId,bool isEphemeral)397 int WifiSettings::SetDeviceEphemeral(int networkId, bool isEphemeral)
398 {
399 std::unique_lock<std::mutex> lock(mStaMutex);
400 auto iter = mWifiDeviceConfig.find(networkId);
401 if (iter == mWifiDeviceConfig.end()) {
402 return -1;
403 }
404 iter->second.isEphemeral = isEphemeral;
405 return 0;
406 }
407
SetDeviceAfterConnect(int networkId)408 int WifiSettings::SetDeviceAfterConnect(int networkId)
409 {
410 std::unique_lock<std::mutex> lock(mStaMutex);
411 auto iter = mWifiDeviceConfig.find(networkId);
412 if (iter == mWifiDeviceConfig.end()) {
413 return -1;
414 }
415 LOGD("Set Device After Connect");
416 iter->second.lastConnectTime = time(0);
417 iter->second.numRebootsSinceLastUse = 0;
418 iter->second.numAssociation++;
419 iter->second.networkSelectionStatus.networkDisableCount = 0;
420 return 0;
421 }
422
SetDeviceRandomizedMacSuccessEver(int networkId)423 int WifiSettings::SetDeviceRandomizedMacSuccessEver(int networkId)
424 {
425 std::unique_lock<std::mutex> lock(mStaMutex);
426 auto iter = mWifiDeviceConfig.find(networkId);
427 if (iter == mWifiDeviceConfig.end()) {
428 return -1;
429 }
430 iter->second.randomizedMacSuccessEver = true;
431 return 0;
432 }
433
SetDeviceEverConnected(int networkId)434 int WifiSettings::SetDeviceEverConnected(int networkId)
435 {
436 std::unique_lock<std::mutex> lock(mStaMutex);
437 auto iter = mWifiDeviceConfig.find(networkId);
438 if (iter == mWifiDeviceConfig.end()) {
439 return -1;
440 }
441 iter->second.everConnected = true;
442 return 0;
443 }
444
SetAcceptUnvalidated(int networkId,bool state)445 int WifiSettings::SetAcceptUnvalidated(int networkId, bool state)
446 {
447 std::unique_lock<std::mutex> lock(mStaMutex);
448 auto iter = mWifiDeviceConfig.find(networkId);
449 if (iter == mWifiDeviceConfig.end()) {
450 return -1;
451 }
452 iter->second.acceptUnvalidated = state;
453 return 0;
454 }
455
GetDeviceEverConnected(int networkId)456 bool WifiSettings::GetDeviceEverConnected(int networkId)
457 {
458 std::unique_lock<std::mutex> lock(mStaMutex);
459 auto iter = mWifiDeviceConfig.find(networkId);
460 if (iter == mWifiDeviceConfig.end()) {
461 return false;
462 }
463 return iter->second.everConnected;
464 }
465
GetAcceptUnvalidated(int networkId)466 bool WifiSettings::GetAcceptUnvalidated(int networkId)
467 {
468 std::unique_lock<std::mutex> lock(mStaMutex);
469 auto iter = mWifiDeviceConfig.find(networkId);
470 if (iter == mWifiDeviceConfig.end()) {
471 return false;
472 }
473 return iter->second.acceptUnvalidated;
474 }
475
GetCandidateConfigWithoutUid(const std::string & ssid,const std::string & keymgmt,WifiDeviceConfig & config)476 int WifiSettings::GetCandidateConfigWithoutUid(const std::string &ssid, const std::string &keymgmt,
477 WifiDeviceConfig &config)
478 {
479 std::vector<WifiDeviceConfig> configs;
480 if (GetAllCandidateConfigWithoutUid(configs) != 0) {
481 return -1;
482 }
483 for (const auto &it : configs) {
484 // -1: Connect by system, use default uid.
485 if (it.uid != -1 && !(it.isShared) && it.ssid == ssid && it.keyMgmt == keymgmt) {
486 config = it;
487 return it.networkId;
488 }
489 }
490 return -1;
491 }
492
GetCandidateConfig(const int uid,const std::string & ssid,const std::string & keymgmt,WifiDeviceConfig & config)493 int WifiSettings::GetCandidateConfig(const int uid, const std::string &ssid, const std::string &keymgmt,
494 WifiDeviceConfig &config)
495 {
496 std::vector<WifiDeviceConfig> configs;
497 if (GetAllCandidateConfig(uid, configs) != 0) {
498 return -1;
499 }
500
501 for (const auto &it : configs) {
502 if (it.ssid == ssid && it.keyMgmt == keymgmt) {
503 config = it;
504 return it.networkId;
505 }
506 }
507 return -1;
508 }
509
GetCandidateConfig(const int uid,const int & networkId,WifiDeviceConfig & config)510 int WifiSettings::GetCandidateConfig(const int uid, const int &networkId, WifiDeviceConfig &config)
511 {
512 std::vector<WifiDeviceConfig> configs;
513 if (GetAllCandidateConfig(uid, configs) != 0) {
514 return -1;
515 }
516
517 for (const auto &it : configs) {
518 if (it.networkId == networkId) {
519 config = it;
520 return it.networkId;
521 }
522 }
523 return -1;
524 }
525
GetAllCandidateConfigWithoutUid(std::vector<WifiDeviceConfig> & configs)526 int WifiSettings::GetAllCandidateConfigWithoutUid(std::vector<WifiDeviceConfig> &configs)
527 {
528 if (!deviceConfigLoadFlag.test_and_set()) {
529 LOGD("Reload wifi config");
530 ReloadDeviceConfig();
531 }
532
533 std::unique_lock<std::mutex> lock(mStaMutex);
534 bool found = false;
535 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
536 if (iter->second.uid != -1 && !iter->second.isShared) {
537 configs.push_back(iter->second);
538 found = true;
539 }
540 }
541 return found ? 0 : -1;
542 }
543
GetAllCandidateConfig(const int uid,std::vector<WifiDeviceConfig> & configs)544 int WifiSettings::GetAllCandidateConfig(const int uid, std::vector<WifiDeviceConfig> &configs)
545 {
546 if (!deviceConfigLoadFlag.test_and_set()) {
547 LOGD("Reload wifi config");
548 ReloadDeviceConfig();
549 }
550
551 std::unique_lock<std::mutex> lock(mStaMutex);
552 bool found = false;
553 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
554 if (iter->second.uid == uid) {
555 configs.push_back(iter->second);
556 found = true;
557 }
558 }
559 return found ? 0 : -1;
560 }
561
IncreaseDeviceConnFailedCount(const std::string & index,const int & indexType,int count)562 int WifiSettings::IncreaseDeviceConnFailedCount(const std::string &index, const int &indexType, int count)
563 {
564 std::unique_lock<std::mutex> lock(mStaMutex);
565 if (indexType == DEVICE_CONFIG_INDEX_SSID) {
566 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
567 if (iter->second.ssid == index) {
568 iter->second.connFailedCount += count;
569 LOGI("WifiSettings::IncreaseDeviceConnFailedCount ssid=%{public}s,connFailedCount=%{public}d,"
570 "count=%{public}d",
571 SsidAnonymize(index).c_str(), iter->second.connFailedCount, count);
572 return 0;
573 }
574 }
575 } else {
576 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
577 if (iter->second.bssid == index) {
578 iter->second.connFailedCount += count;
579 LOGI("WifiSettings::IncreaseDeviceConnFailedCount bssid=%{public}s,connFailedCount=%{public}d,"
580 "count=%{public}d",
581 SsidAnonymize(index).c_str(), iter->second.connFailedCount, count);
582 return 0;
583 }
584 }
585 }
586 LOGE("WifiSettings::IncreaseDeviceConnFailedCount failed %{public}s,count=%{public}d",
587 SsidAnonymize(index).c_str(), count);
588 return -1;
589 }
590
SetDeviceConnFailedCount(const std::string & index,const int & indexType,int count)591 int WifiSettings::SetDeviceConnFailedCount(const std::string &index, const int &indexType, int count)
592 {
593 std::unique_lock<std::mutex> lock(mStaMutex);
594 if (indexType == DEVICE_CONFIG_INDEX_SSID) {
595 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
596 if (iter->second.ssid == index) {
597 iter->second.connFailedCount = count;
598 LOGI("WifiSettings::SetDeviceConnFailedCount bssid=%{public}s,connFailedCount=%{public}d,"
599 "count=%{public}d",
600 SsidAnonymize(index).c_str(), iter->second.connFailedCount, count);
601 return 0;
602 }
603 }
604 } else {
605 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
606 if (iter->second.bssid == index) {
607 iter->second.connFailedCount = count;
608 LOGI("WifiSettings::SetDeviceConnFailedCount bssid=%{public}s,connFailedCount=%{public}d,"
609 "count=%{public}d",
610 SsidAnonymize(index).c_str(), iter->second.connFailedCount, count);
611 return 0;
612 }
613 }
614 }
615 LOGE("WifiSettings::SetDeviceConnFailedCount failed %{public}s,count=%{public}d",
616 SsidAnonymize(index).c_str(), count);
617 return -1;
618 }
619
SyncDeviceConfig()620 int WifiSettings::SyncDeviceConfig()
621 {
622 #ifndef CONFIG_NO_CONFIG_WRITE
623 std::unique_lock<std::mutex> lock(mStaMutex);
624 std::vector<WifiDeviceConfig> tmp;
625 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); ++iter) {
626 if (!iter->second.isEphemeral && iter->second.instanceId == 0) {
627 tmp.push_back(iter->second);
628 }
629 }
630 RemoveExcessDeviceConfigs(tmp);
631 mSavedDeviceConfig.SetValue(tmp);
632 return mSavedDeviceConfig.SaveConfig();
633 #else
634 return 0;
635 #endif
636 }
637
FindKeyMgmtPosition(const std::string & keyMgmt)638 static int FindKeyMgmtPosition(const std::string& keyMgmt)
639 {
640 for (int index = 0; index < KEY_MGMT_TOTAL_NUM; ++index) {
641 if (KEY_MGMT_ARRAY[index] == keyMgmt) {
642 return index;
643 }
644 }
645 return -1;
646 }
647
InKeyMgmtBitset(const WifiDeviceConfig & config,const std::string & keyMgmt)648 bool WifiSettings::InKeyMgmtBitset(const WifiDeviceConfig& config, const std::string& keyMgmt)
649 {
650 if (keyMgmt != "WPA-PSK+SAE") {
651 int index = FindKeyMgmtPosition(keyMgmt);
652 if (index < 0) {
653 return false;
654 }
655 return (config.keyMgmtBitset & (1 << index)) != 0;
656 } else {
657 return InKeyMgmtBitset(config, KEY_MGMT_WPA_PSK) || InKeyMgmtBitset(config, KEY_MGMT_SAE);
658 }
659 }
660
SetKeyMgmtBitset(WifiDeviceConfig & config)661 void WifiSettings::SetKeyMgmtBitset(WifiDeviceConfig &config)
662 {
663 // Currently only set when keyMgmtBitset does not match keyMgmt
664 if (InKeyMgmtBitset(config, config.keyMgmt)) {
665 return;
666 }
667 int index = FindKeyMgmtPosition(config.keyMgmt);
668 // Invalid keyMgmt
669 if (index < 0) {
670 return;
671 }
672 config.keyMgmtBitset |= (1 << index);
673 if (config.keyMgmt == KEY_MGMT_WPA_PSK) {
674 index = FindKeyMgmtPosition(KEY_MGMT_SAE);
675 config.keyMgmtBitset |= (1 << index);
676 }
677 }
678
GetAllSuitableEncryption(const WifiDeviceConfig & config,const std::string & keyMgmt,std::vector<std::string> & candidateKeyMgmtList)679 void WifiSettings::GetAllSuitableEncryption(const WifiDeviceConfig &config,
680 const std::string &keyMgmt, std::vector<std::string> &candidateKeyMgmtList)
681 {
682 if (keyMgmt == "WPA-PSK+SAE") {
683 if (InKeyMgmtBitset(config, KEY_MGMT_WPA_PSK)) {
684 candidateKeyMgmtList.emplace_back(KEY_MGMT_WPA_PSK);
685 }
686 if (InKeyMgmtBitset(config, KEY_MGMT_SAE)) {
687 candidateKeyMgmtList.emplace_back(KEY_MGMT_SAE);
688 }
689 } else {
690 if (InKeyMgmtBitset(config, keyMgmt)) {
691 candidateKeyMgmtList.emplace_back(keyMgmt);
692 }
693 }
694 }
695
ReloadDeviceConfig()696 int WifiSettings::ReloadDeviceConfig()
697 {
698 #ifndef CONFIG_NO_CONFIG_WRITE
699 std::unique_lock<std::mutex> lock(mStaMutex);
700 int ret = mSavedDeviceConfig.LoadConfig();
701 if (ret < 0) {
702 deviceConfigLoadFlag.clear();
703 LOGD("Loading device config failed: %{public}d", ret);
704 return -1;
705 }
706 deviceConfigLoadFlag.test_and_set();
707 std::vector<WifiDeviceConfig> tmp;
708 mSavedDeviceConfig.GetValue(tmp);
709 mNetworkId = 0;
710 mWifiDeviceConfig.clear();
711 for (std::size_t i = 0; i < tmp.size(); ++i) {
712 WifiDeviceConfig &item = tmp[i];
713 SetKeyMgmtBitset(item);
714 item.networkId = mNetworkId++;
715 mWifiDeviceConfig.emplace(item.networkId, item);
716 }
717 LOGI("ReloadDeviceConfig load deviceConfig size: %{public}d", static_cast<int>(mWifiDeviceConfig.size()));
718 if (!mEncryptionOnBootFalg.test_and_set()) {
719 mWifiEncryptionThread = std::make_unique<WifiEventHandler>("WifiEncryptionThread");
720 mWifiEncryptionThread->PostAsyncTask([this]() {
721 LOGI("ReloadDeviceConfig EncryptionWifiDeviceConfigOnBoot start.");
722 EncryptionWifiDeviceConfigOnBoot();
723 });
724 }
725 return 0;
726 #else
727 std::unique_lock<std::mutex> lock(mStaMutex);
728 mWifiDeviceConfig.clear();
729 return 0;
730 #endif
731 }
732
GetNextNetworkId()733 int WifiSettings::GetNextNetworkId()
734 {
735 std::unique_lock<std::mutex> lock(mStaMutex);
736 return mNetworkId++;
737 }
738
AddWpsDeviceConfig(const WifiDeviceConfig & config)739 int WifiSettings::AddWpsDeviceConfig(const WifiDeviceConfig &config)
740 {
741 int ret = mSavedDeviceConfig.LoadConfig();
742 if (ret < 0) {
743 LOGE("Add Wps config loading config failed: %{public}d", ret);
744 return -1;
745 }
746 std::vector<WifiDeviceConfig> tmp;
747 mSavedDeviceConfig.GetValue(tmp);
748 std::unique_lock<std::mutex> lock(mStaMutex);
749 mWifiDeviceConfig.clear();
750 mNetworkId = 0;
751 mWifiDeviceConfig.emplace(mNetworkId++, config);
752 for (std::size_t i = 0; i < tmp.size(); ++i) {
753 WifiDeviceConfig &item = tmp[i];
754 item.networkId = mNetworkId++;
755 mWifiDeviceConfig.emplace(item.networkId, item);
756 }
757 return 0;
758 }
759
760 #ifndef OHOS_ARCH_LITE
OnRestore(UniqueFd & fd,const std::string & restoreInfo)761 int WifiSettings::OnRestore(UniqueFd &fd, const std::string &restoreInfo)
762 {
763 LOGI("OnRestore enter.");
764 const std::string versionForXml = "9";
765 std::string key;
766 std::string iv;
767 std::string version;
768 ParseBackupJson(restoreInfo, key, iv, version);
769
770 std::vector<WifiDeviceConfig> deviceConfigs;
771 int ret = 0;
772 if (version == versionForXml) {
773 ret = GetConfigbyBackupXml(deviceConfigs, fd);
774 } else {
775 ret = GetConfigbyBackupFile(deviceConfigs, fd, key, iv);
776 }
777 std::fill(key.begin(), key.end(), 0);
778 if (ret < 0) {
779 LOGE("OnRestore fail to get config from backup.");
780 return ret;
781 }
782
783 LOGI("OnRestore end. Restore count: %{public}d", static_cast<int>(deviceConfigs.size()));
784 ConfigsDeduplicateAndSave(deviceConfigs);
785 return 0;
786 }
787
OnBackup(UniqueFd & fd,const std::string & backupInfo)788 int WifiSettings::OnBackup(UniqueFd &fd, const std::string &backupInfo)
789 {
790 LOGI("OnBackup enter.");
791 std::string key;
792 std::string iv;
793 std::string version;
794 ParseBackupJson(backupInfo, key, iv, version);
795 if (key.size() == 0 || iv.size() == 0) {
796 LOGE("OnBackup key or iv is empty.");
797 return -1;
798 }
799 mSavedDeviceConfig.LoadConfig();
800 std::vector<WifiDeviceConfig> localConfigs;
801 mSavedDeviceConfig.GetValue(localConfigs);
802
803 std::vector<WifiBackupConfig> backupConfigs;
804 for (auto &config : localConfigs) {
805 if (config.wifiEapConfig.eap.length() != 0 || config.isPasspoint == true) {
806 continue;
807 }
808 #ifdef FEATURE_ENCRYPTION_SUPPORT
809 DecryptionDeviceConfig(config);
810 #endif
811 WifiBackupConfig backupConfig;
812 ConvertDeviceCfgToBackupCfg(config, backupConfig);
813 backupConfigs.push_back(backupConfig);
814 }
815 std::vector<WifiDeviceConfig>().swap(localConfigs);
816
817 WifiConfigFileImpl<WifiBackupConfig> wifiBackupConfig;
818 wifiBackupConfig.SetConfigFilePath(BACKUP_CONFIG_FILE_PATH);
819 wifiBackupConfig.SetEncryptionInfo(key, iv);
820 wifiBackupConfig.SetValue(backupConfigs);
821 wifiBackupConfig.SaveConfig();
822 wifiBackupConfig.UnsetEncryptionInfo();
823 std::fill(key.begin(), key.end(), 0);
824
825 fd = UniqueFd(open(BACKUP_CONFIG_FILE_PATH, O_RDONLY));
826 if (fd.Get() < 0) {
827 LOGE("OnBackup open fail.");
828 return -1;
829 }
830 LOGI("OnBackup end. Backup count: %{public}d, fd: %{public}d.", static_cast<int>(backupConfigs.size()), fd.Get());
831 return 0;
832 }
833
SetBackupReplyCode(int replyCode)834 std::string WifiSettings::SetBackupReplyCode(int replyCode)
835 {
836 Json::Value root;
837 Json::Value resultInfo;
838 Json::Value errorInfo;
839
840 errorInfo["type"] = "ErrorInfo";
841 errorInfo["errorCode"] = std::to_string(replyCode);
842 errorInfo["errorInfo"] = "";
843
844 resultInfo.append(errorInfo);
845 root["resultInfo"] = resultInfo;
846
847 Json::FastWriter writer;
848 return writer.write(root);
849 }
850
RemoveBackupFile()851 void WifiSettings::RemoveBackupFile()
852 {
853 remove(BACKUP_CONFIG_FILE_PATH);
854 }
855 #endif
856
AddRandomMac(WifiStoreRandomMac & randomMacInfo)857 bool WifiSettings::AddRandomMac(WifiStoreRandomMac &randomMacInfo)
858 {
859 std::unique_lock<std::mutex> lock(mStaMutex);
860 if (!MacAddress::IsValidMac(randomMacInfo.randomMac)) {
861 LOGE("%{public}s failed randomMac is inValid.", __func__);
862 return false;
863 }
864 bool isAdded = false;
865 std::string fuzzyBssid = "";
866 if (IsPskEncryption(randomMacInfo.keyMgmt)) {
867 fuzzyBssid = FuzzyBssid(randomMacInfo.peerBssid);
868 if (fuzzyBssid.empty()) {
869 LOGI("AddRandomMac fuzzyBssid is empty.");
870 return false;
871 }
872 }
873
874 for (auto &ele : mWifiStoreRandomMac) {
875 if (IsPskEncryption(ele.keyMgmt)) {
876 if (ele.randomMac != randomMacInfo.randomMac) {
877 continue;
878 }
879 if (ele.fuzzyBssids.find(fuzzyBssid) != ele.fuzzyBssids.end()) {
880 LOGI("AddRandomMac is contains fuzzyBssid:%{public}s", MacAnonymize(fuzzyBssid).c_str());
881 return true;
882 }
883 if (ele.fuzzyBssids.size() <= FUZZY_BSSID_MAX_MATCH_CNT) {
884 ele.fuzzyBssids.insert(fuzzyBssid);
885 LOGI("AddRandomMac insert fuzzyBssid:%{public}s", MacAnonymize(fuzzyBssid).c_str());
886 isAdded = true;
887 break;
888 } else {
889 LOGI("AddRandomMac ele.fuzzyBssids.size is max count");
890 return false;
891 }
892 }
893 if (ele.ssid == randomMacInfo.ssid && ele.keyMgmt == randomMacInfo.keyMgmt) {
894 return true;
895 }
896 }
897
898 LOGI("AddRandomMac isAdded:%{public}d", isAdded);
899 if (!isAdded) {
900 if (IsPskEncryption(randomMacInfo.keyMgmt)) {
901 randomMacInfo.fuzzyBssids.insert(fuzzyBssid);
902 }
903 mWifiStoreRandomMac.push_back(randomMacInfo);
904 }
905
906 mSavedWifiStoreRandomMac.SetValue(mWifiStoreRandomMac);
907 mSavedWifiStoreRandomMac.SaveConfig();
908 return isAdded;
909 }
910
GetRandomMac(WifiStoreRandomMac & randomMacInfo)911 bool WifiSettings::GetRandomMac(WifiStoreRandomMac &randomMacInfo)
912 {
913 std::unique_lock<std::mutex> lock(mStaMutex);
914 std::string fuzzyBssid = "";
915 if (IsPskEncryption(randomMacInfo.keyMgmt)) {
916 fuzzyBssid = FuzzyBssid(randomMacInfo.peerBssid);
917 if (fuzzyBssid.empty()) {
918 LOGI("GetStaRandomMac fuzzyBssid is empty.");
919 return false;
920 }
921 }
922
923 for (auto &item : mWifiStoreRandomMac) {
924 if (!MacAddress::IsValidMac(item.randomMac)) {
925 continue;
926 }
927 if (IsPskEncryption(item.keyMgmt)) {
928 if (item.fuzzyBssids.find(fuzzyBssid) != item.fuzzyBssids.end()) {
929 LOGI("GetStaRandomMac fuzzyBssids contains fuzzyBssid:%{public}s",
930 MacAnonymize(fuzzyBssid).c_str());
931 randomMacInfo.randomMac = item.randomMac;
932 break;
933 }
934 } else {
935 if (item.ssid == randomMacInfo.ssid && item.keyMgmt == randomMacInfo.keyMgmt) {
936 randomMacInfo.randomMac = item.randomMac;
937 break;
938 }
939 }
940 }
941 return randomMacInfo.randomMac.empty();
942 }
943
ReloadTrustListPolicies()944 const std::vector<TrustListPolicy> WifiSettings::ReloadTrustListPolicies()
945 {
946 std::unique_lock<std::mutex> lock(mScanMutex);
947 mTrustListPolicies.LoadConfig();
948 if (mTrustListPolicies.GetValue().size() <= 0) {
949 std::vector<TrustListPolicy> policies;
950 TrustListPolicy policy;
951 policies.push_back(policy);
952 mTrustListPolicies.SetValue(policies);
953 mTrustListPolicies.SaveConfig();
954 mTrustListPolicies.LoadConfig();
955 }
956
957 return mTrustListPolicies.GetValue();
958 }
959
ReloadMovingFreezePolicy()960 const MovingFreezePolicy WifiSettings::ReloadMovingFreezePolicy()
961 {
962 std::unique_lock<std::mutex> lock(mScanMutex);
963 mMovingFreezePolicy.LoadConfig();
964
965 if (mMovingFreezePolicy.GetValue().size() <= 0) {
966 std::vector<MovingFreezePolicy> policies;
967 MovingFreezePolicy policy;
968 policies.push_back(policy);
969 mMovingFreezePolicy.SetValue(policies);
970 mMovingFreezePolicy.SaveConfig();
971 mMovingFreezePolicy.LoadConfig();
972 }
973
974 if (mMovingFreezePolicy.GetValue().size() <= 0) {
975 return MovingFreezePolicy();
976 }
977 return mMovingFreezePolicy.GetValue()[0];
978 }
979
GetPackageInfoMap(std::map<std::string,std::vector<PackageInfo>> & packageInfoMap)980 int WifiSettings::GetPackageInfoMap(std::map<std::string, std::vector<PackageInfo>> &packageInfoMap)
981 {
982 std::unique_lock<std::mutex> lock(mPackageConfMutex);
983 packageInfoMap = mPackageInfoMap;
984 return 0;
985 }
986
SyncHotspotConfig()987 int WifiSettings::SyncHotspotConfig()
988 {
989 std::unique_lock<std::mutex> lock(mApMutex);
990 std::vector<HotspotConfig> tmp;
991
992 for (int i = 0; i < AP_INSTANCE_MAX_NUM; i++) {
993 auto iter = mHotspotConfig.find(i);
994 if (iter != mHotspotConfig.end()) {
995 tmp.push_back(iter->second);
996 }
997 }
998 mSavedHotspotConfig.SetValue(tmp);
999 mSavedHotspotConfig.SaveConfig();
1000
1001 return 0;
1002 }
1003
SetHotspotConfig(const HotspotConfig & config,int id)1004 int WifiSettings::SetHotspotConfig(const HotspotConfig &config, int id)
1005 {
1006 std::unique_lock<std::mutex> lock(mApMutex);
1007 if (id < 0 || id >= AP_INSTANCE_MAX_NUM) {
1008 LOGE("SetHotspotConfig id is out of range");
1009 return -1;
1010 }
1011 mHotspotConfig[id] = config;
1012 return 0;
1013 }
1014
GetHotspotConfig(HotspotConfig & config,int id)1015 int WifiSettings::GetHotspotConfig(HotspotConfig &config, int id)
1016 {
1017 std::unique_lock<std::mutex> lock(mApMutex);
1018 auto iter = mHotspotConfig.find(id);
1019 if (iter != mHotspotConfig.end()) {
1020 config = iter->second;
1021 return 0;
1022 }
1023 return -1;
1024 }
1025
ClearHotspotConfig()1026 void WifiSettings::ClearHotspotConfig()
1027 {
1028 std::unique_lock<std::mutex> lock(mApMutex);
1029 mHotspotConfig.clear();
1030 HotspotConfig config;
1031 #ifdef INIT_LIB_ENABLE
1032 std::string ssid = GetMarketName();
1033 #endif
1034 config.SetSecurityType(KeyMgmt::WPA2_PSK);
1035 config.SetBand(BandType::BAND_2GHZ);
1036 config.SetChannel(AP_CHANNEL_DEFAULT);
1037 config.SetMaxConn(GetApMaxConnNum());
1038 config.SetBandWidth(AP_BANDWIDTH_DEFAULT);
1039 #ifdef INIT_LIB_ENABLE
1040 config.SetSsid(ssid);
1041 #else
1042 config.SetSsid("OHOS_" + GetRandomStr(RANDOM_STR_LEN));
1043 #endif
1044 config.SetPreSharedKey(GetRandomStr(RANDOM_PASSWD_LEN));
1045 auto ret = mHotspotConfig.emplace(0, config);
1046 if (!ret.second) {
1047 mHotspotConfig[0] = config;
1048 }
1049 }
1050
GetBlockList(std::vector<StationInfo> & results,int id)1051 int WifiSettings::GetBlockList(std::vector<StationInfo> &results, int id)
1052 {
1053 std::unique_lock<std::mutex> lock(mApMutex);
1054 for (auto iter = mBlockListInfo.begin(); iter != mBlockListInfo.end(); iter++) {
1055 results.push_back(iter->second);
1056 }
1057 return 0;
1058 }
1059
ManageBlockList(const StationInfo & info,int mode,int id)1060 int WifiSettings::ManageBlockList(const StationInfo &info, int mode, int id)
1061 {
1062 std::unique_lock<std::mutex> lock(mApMutex);
1063 auto iter = mBlockListInfo.find(info.bssid);
1064 if (MODE_ADD == mode || MODE_UPDATE == mode) {
1065 if (iter != mBlockListInfo.end()) {
1066 iter->second = info;
1067 } else {
1068 mBlockListInfo.emplace(std::make_pair(info.bssid, info));
1069 }
1070 } else if (MODE_DEL == mode) {
1071 if (iter != mBlockListInfo.end()) {
1072 mBlockListInfo.erase(iter);
1073 }
1074 } else {
1075 return -1;
1076 }
1077 SyncBlockList();
1078 return 0;
1079 }
1080
SyncWifiP2pGroupInfoConfig()1081 int WifiSettings::SyncWifiP2pGroupInfoConfig()
1082 {
1083 std::unique_lock<std::mutex> lock(mP2pMutex);
1084 mSavedWifiP2pGroupInfo.SetValue(mGroupInfoList);
1085 return mSavedWifiP2pGroupInfo.SaveConfig();
1086 }
1087
SetWifiP2pGroupInfo(const std::vector<WifiP2pGroupInfo> & groups)1088 int WifiSettings::SetWifiP2pGroupInfo(const std::vector<WifiP2pGroupInfo> &groups)
1089 {
1090 std::unique_lock<std::mutex> lock(mP2pMutex);
1091 mGroupInfoList = groups;
1092 return 0;
1093 }
1094
RemoveWifiP2pGroupInfo()1095 int WifiSettings::RemoveWifiP2pGroupInfo()
1096 {
1097 std::unique_lock<std::mutex> lock(mP2pMutex);
1098 mGroupInfoList.clear();
1099 return 0;
1100 }
1101
RemoveWifiP2pSupplicantGroupInfo()1102 int WifiSettings::RemoveWifiP2pSupplicantGroupInfo()
1103 {
1104 std::filesystem::path pathName = P2P_SUPPLICANT_CONFIG_FILE;
1105 std::error_code code;
1106 if (!std::filesystem::exists(pathName, code)) {
1107 LOGE("p2p_supplicant file do not exists!, file:%{public}s", P2P_SUPPLICANT_CONFIG_FILE);
1108 return -1;
1109 }
1110 std::error_code ec;
1111 int retval = std::filesystem::remove(P2P_SUPPLICANT_CONFIG_FILE, ec);
1112 if (!ec) { // successful
1113 LOGI("p2p_supplicant file removed successful, retval:%{public}d value:%{public}d message:%{public}s",
1114 retval, ec.value(), ec.message().c_str());
1115 return 0;
1116 } // unsuccessful
1117 LOGE("p2p_supplicant file removed unsuccessful, value:%{public}d value:%{public}d message:%{public}s",
1118 retval, ec.value(), ec.message().c_str());
1119 return -1;
1120 }
1121
GetWifiP2pGroupInfo(std::vector<WifiP2pGroupInfo> & groups)1122 int WifiSettings::GetWifiP2pGroupInfo(std::vector<WifiP2pGroupInfo> &groups)
1123 {
1124 std::unique_lock<std::mutex> lock(mP2pMutex);
1125 groups = mGroupInfoList;
1126 return 0;
1127 }
1128
SyncP2pVendorConfig()1129 int WifiSettings::SyncP2pVendorConfig()
1130 {
1131 std::unique_lock<std::mutex> lock(mP2pMutex);
1132 std::vector<P2pVendorConfig> tmp;
1133 tmp.push_back(mP2pVendorConfig);
1134 mSavedWifiP2pVendorConfig.SetValue(tmp);
1135 return mSavedWifiP2pVendorConfig.SaveConfig();
1136 }
1137
SetP2pDeviceName(const std::string & deviceName)1138 int WifiSettings::SetP2pDeviceName(const std::string &deviceName)
1139 {
1140 std::unique_lock<std::mutex> lock(mP2pMutex);
1141 mP2pVendorConfig.SetDeviceName(deviceName);
1142 std::vector<P2pVendorConfig> tmp;
1143 tmp.push_back(mP2pVendorConfig);
1144 mSavedWifiP2pVendorConfig.SetValue(tmp);
1145 return mSavedWifiP2pVendorConfig.SaveConfig();
1146 }
1147
SetP2pVendorConfig(const P2pVendorConfig & config)1148 int WifiSettings::SetP2pVendorConfig(const P2pVendorConfig &config)
1149 {
1150 std::unique_lock<std::mutex> lock(mP2pMutex);
1151 mP2pVendorConfig = config;
1152 return 0;
1153 }
1154
GetP2pVendorConfig(P2pVendorConfig & config)1155 int WifiSettings::GetP2pVendorConfig(P2pVendorConfig &config)
1156 {
1157 std::unique_lock<std::mutex> lock(mP2pMutex);
1158 config = mP2pVendorConfig;
1159 return 0;
1160 }
1161
GetScanAlwaysState(int instId)1162 bool WifiSettings::GetScanAlwaysState(int instId)
1163 {
1164 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1165 auto iter = mWifiConfig.find(instId);
1166 if (iter != mWifiConfig.end()) {
1167 return iter->second.scanAlwaysSwitch;
1168 }
1169 return mWifiConfig[0].scanAlwaysSwitch;
1170 }
1171
GetSignalLevel(const int & rssi,const int & band,int instId)1172 int WifiSettings::GetSignalLevel(const int &rssi, const int &band, int instId)
1173 {
1174 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1175 int level = 0;
1176 auto iter = mWifiConfig.find(instId);
1177 if (iter != mWifiConfig.end()) {
1178 do {
1179 if (band == static_cast<int>(BandType::BAND_5GHZ)) {
1180 if (rssi < iter->second.firstRssiLevel5G) {
1181 break;
1182 }
1183 ++level;
1184 if (rssi < iter->second.secondRssiLevel5G) {
1185 break;
1186 }
1187 ++level;
1188 if (rssi < iter->second.thirdRssiLevel5G) {
1189 break;
1190 }
1191 ++level;
1192 if (rssi < iter->second.fourthRssiLevel5G) {
1193 break;
1194 }
1195 ++level;
1196 } else {
1197 if (rssi < iter->second.firstRssiLevel2G) {
1198 break;
1199 }
1200 ++level;
1201 if (rssi < iter->second.secondRssiLevel2G) {
1202 break;
1203 }
1204 ++level;
1205 if (rssi < iter->second.thirdRssiLevel2G) {
1206 break;
1207 }
1208 ++level;
1209 if (rssi < iter->second.fourthRssiLevel2G) {
1210 break;
1211 }
1212 ++level;
1213 }
1214 } while (0);
1215 }
1216 return level;
1217 }
1218
GetOperatorWifiType(int instId)1219 int WifiSettings::GetOperatorWifiType(int instId)
1220 {
1221 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1222 auto iter = mWifiConfig.find(instId);
1223 if (iter != mWifiConfig.end()) {
1224 return iter->second.staAirplaneMode;
1225 }
1226 return mWifiConfig[0].staAirplaneMode;
1227 }
1228
SetOperatorWifiType(int type,int instId)1229 int WifiSettings::SetOperatorWifiType(int type, int instId)
1230 {
1231 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1232 mWifiConfig[instId].staAirplaneMode = type;
1233 struct timespec times = {0, 0};
1234 clock_gettime(CLOCK_REALTIME, ×);
1235 int64_t curTimeMs = static_cast<int64_t>(times.tv_sec) * MSEC + times.tv_nsec / (MSEC * MSEC);
1236 LOGI("set persist wifi state, current time is:%{public}" PRId64, curTimeMs);
1237 mWifiConfig[instId].persistWifiTime = curTimeMs;
1238 SyncWifiConfig();
1239 return 0;
1240 }
1241
GetLastAirplaneMode(int instId)1242 int WifiSettings::GetLastAirplaneMode(int instId)
1243 {
1244 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1245 auto iter = mWifiConfig.find(instId);
1246 if (iter != mWifiConfig.end()) {
1247 return iter->second.lastAirplaneMode;
1248 }
1249 return mWifiConfig[0].lastAirplaneMode;
1250 }
1251
SetLastAirplaneMode(int mode,int instId)1252 int WifiSettings::SetLastAirplaneMode(int mode, int instId)
1253 {
1254 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1255 mWifiConfig[instId].lastAirplaneMode = mode;
1256 SyncWifiConfig();
1257 return 0;
1258 }
1259
1260 #ifndef OHOS_ARCH_LITE
SetWifiToggleCaller(int callerPid,int instId)1261 int WifiSettings::SetWifiToggleCaller(int callerPid, int instId)
1262 {
1263 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1264 mWifiConfig[instId].toggleWifiCaller = callerPid;
1265 SyncWifiConfig();
1266 return 0;
1267 }
1268 #endif
1269
GetCanOpenStaWhenAirplaneMode(int instId)1270 bool WifiSettings::GetCanOpenStaWhenAirplaneMode(int instId)
1271 {
1272 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1273 auto iter = mWifiConfig.find(instId);
1274 if (iter != mWifiConfig.end()) {
1275 return iter->second.canOpenStaWhenAirplane;
1276 }
1277 return mWifiConfig[0].canOpenStaWhenAirplane;
1278 }
1279
SetWifiFlagOnAirplaneMode(bool ifOpen,int instId)1280 int WifiSettings::SetWifiFlagOnAirplaneMode(bool ifOpen, int instId)
1281 {
1282 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1283 mWifiConfig[instId].openWifiWhenAirplane = ifOpen;
1284 SyncWifiConfig();
1285 return 0;
1286 }
1287
GetWifiFlagOnAirplaneMode(int instId)1288 bool WifiSettings::GetWifiFlagOnAirplaneMode(int instId)
1289 {
1290 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1291 auto iter = mWifiConfig.find(instId);
1292 if (iter != mWifiConfig.end()) {
1293 return iter->second.openWifiWhenAirplane;
1294 }
1295 return mWifiConfig[0].openWifiWhenAirplane;
1296 }
1297
SetWifiDisabledByAirplane(bool disabledByAirplane,int instId)1298 int WifiSettings::SetWifiDisabledByAirplane(bool disabledByAirplane, int instId)
1299 {
1300 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1301 mWifiConfig[instId].wifiDisabledByAirplane = disabledByAirplane;
1302 SyncWifiConfig();
1303 return 0;
1304 }
1305
GetWifiDisabledByAirplane(int instId)1306 bool WifiSettings::GetWifiDisabledByAirplane(int instId)
1307 {
1308 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1309 auto iter = mWifiConfig.find(instId);
1310 if (iter != mWifiConfig.end()) {
1311 return iter->second.wifiDisabledByAirplane;
1312 }
1313 return mWifiConfig[0].wifiDisabledByAirplane;
1314 }
1315
GetStaLastRunState(int instId)1316 int WifiSettings::GetStaLastRunState(int instId)
1317 {
1318 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1319 auto iter = mWifiConfig.find(instId);
1320 if (iter != mWifiConfig.end()) {
1321 return iter->second.staLastState;
1322 }
1323 return mWifiConfig[0].staLastState;
1324 }
1325
SetStaLastRunState(int bRun,int instId)1326 int WifiSettings::SetStaLastRunState(int bRun, int instId)
1327 {
1328 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1329 mWifiConfig[instId].staLastState = bRun;
1330 SyncWifiConfig();
1331 return 0;
1332 }
1333
GetDhcpIpType(int instId)1334 int WifiSettings::GetDhcpIpType(int instId)
1335 {
1336 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1337 auto iter = mWifiConfig.find(instId);
1338 if (iter != mWifiConfig.end()) {
1339 return iter->second.dhcpIpType;
1340 }
1341 return mWifiConfig[0].dhcpIpType;
1342 }
1343
GetWhetherToAllowNetworkSwitchover(int instId)1344 bool WifiSettings::GetWhetherToAllowNetworkSwitchover(int instId)
1345 {
1346 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1347 auto iter = mWifiConfig.find(instId);
1348 if (iter != mWifiConfig.end()) {
1349 return iter->second.whetherToAllowNetworkSwitchover;
1350 }
1351 return mWifiConfig[0].whetherToAllowNetworkSwitchover;
1352 }
1353
GetScoretacticsScoreSlope(int instId)1354 int WifiSettings::GetScoretacticsScoreSlope(int instId)
1355 {
1356 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1357 auto iter = mWifiConfig.find(instId);
1358 if (iter != mWifiConfig.end()) {
1359 return iter->second.scoretacticsScoreSlope;
1360 }
1361 return mWifiConfig[0].scoretacticsScoreSlope;
1362 }
1363
GetScoretacticsInitScore(int instId)1364 int WifiSettings::GetScoretacticsInitScore(int instId)
1365 {
1366 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1367 auto iter = mWifiConfig.find(instId);
1368 if (iter != mWifiConfig.end()) {
1369 return iter->second.scoretacticsInitScore;
1370 }
1371 return mWifiConfig[0].scoretacticsInitScore;
1372 }
1373
GetScoretacticsSameBssidScore(int instId)1374 int WifiSettings::GetScoretacticsSameBssidScore(int instId)
1375 {
1376 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1377 auto iter = mWifiConfig.find(instId);
1378 if (iter != mWifiConfig.end()) {
1379 return iter->second.scoretacticsSameBssidScore;
1380 }
1381 return mWifiConfig[0].scoretacticsSameBssidScore;
1382 }
1383
GetScoretacticsSameNetworkScore(int instId)1384 int WifiSettings::GetScoretacticsSameNetworkScore(int instId)
1385 {
1386 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1387 auto iter = mWifiConfig.find(instId);
1388 if (iter != mWifiConfig.end()) {
1389 return iter->second.scoretacticsSameNetworkScore;
1390 }
1391 return mWifiConfig[0].scoretacticsSameNetworkScore;
1392 }
1393
GetScoretacticsFrequency5GHzScore(int instId)1394 int WifiSettings::GetScoretacticsFrequency5GHzScore(int instId)
1395 {
1396 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1397 auto iter = mWifiConfig.find(instId);
1398 if (iter != mWifiConfig.end()) {
1399 return iter->second.scoretacticsFrequency5GHzScore;
1400 }
1401 return mWifiConfig[0].scoretacticsFrequency5GHzScore;
1402 }
1403
GetScoretacticsLastSelectionScore(int instId)1404 int WifiSettings::GetScoretacticsLastSelectionScore(int instId)
1405 {
1406 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1407 auto iter = mWifiConfig.find(instId);
1408 if (iter != mWifiConfig.end()) {
1409 return iter->second.scoretacticsLastSelectionScore;
1410 }
1411 return mWifiConfig[0].scoretacticsLastSelectionScore;
1412 }
1413
GetScoretacticsSecurityScore(int instId)1414 int WifiSettings::GetScoretacticsSecurityScore(int instId)
1415 {
1416 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1417 auto iter = mWifiConfig.find(instId);
1418 if (iter != mWifiConfig.end()) {
1419 return iter->second.scoretacticsSecurityScore;
1420 }
1421 return mWifiConfig[0].scoretacticsSecurityScore;
1422 }
1423
GetScoretacticsNormalScore(int instId)1424 int WifiSettings::GetScoretacticsNormalScore(int instId)
1425 {
1426 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1427 auto iter = mWifiConfig.find(instId);
1428 if (iter != mWifiConfig.end()) {
1429 return iter->second.scoretacticsNormalScore;
1430 }
1431 return mWifiConfig[0].scoretacticsNormalScore;
1432 }
1433
GetSavedDeviceAppraisalPriority(int instId)1434 int WifiSettings::GetSavedDeviceAppraisalPriority(int instId)
1435 {
1436 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1437 auto iter = mWifiConfig.find(instId);
1438 if (iter != mWifiConfig.end()) {
1439 return iter->second.savedDeviceAppraisalPriority;
1440 }
1441 return mWifiConfig[0].savedDeviceAppraisalPriority;
1442 }
1443
IsModulePreLoad(const std::string & name)1444 bool WifiSettings::IsModulePreLoad(const std::string &name)
1445 {
1446 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1447 if (name == WIFI_SERVICE_STA) {
1448 return true;
1449 } else if (name == WIFI_SERVICE_SCAN) {
1450 return true;
1451 } else if (name == WIFI_SERVICE_AP) {
1452 return mWifiConfig[0].preLoadAp;
1453 } else if (name == WIFI_SERVICE_P2P) {
1454 return true;
1455 } else if (name == WIFI_SERVICE_AWARE) {
1456 return mWifiConfig[0].preLoadAware;
1457 } else if (name == WIFI_SERVICE_ENHANCE) {
1458 return mWifiConfig[0].preLoadEnhance;
1459 } else {
1460 return false;
1461 }
1462 }
1463
GetSupportHwPnoFlag(int instId)1464 bool WifiSettings::GetSupportHwPnoFlag(int instId)
1465 {
1466 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1467 auto iter = mWifiConfig.find(instId);
1468 if (iter != mWifiConfig.end()) {
1469 return iter->second.supportHwPnoFlag;
1470 }
1471 return mWifiConfig[0].supportHwPnoFlag;
1472 }
1473
GetMinRssi2Dot4Ghz(int instId)1474 int WifiSettings::GetMinRssi2Dot4Ghz(int instId)
1475 {
1476 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1477 auto iter = mWifiConfig.find(instId);
1478 if (iter != mWifiConfig.end()) {
1479 return iter->second.minRssi2Dot4Ghz;
1480 }
1481 return mWifiConfig[0].minRssi2Dot4Ghz;
1482 }
1483
GetMinRssi5Ghz(int instId)1484 int WifiSettings::GetMinRssi5Ghz(int instId)
1485 {
1486 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1487 auto iter = mWifiConfig.find(instId);
1488 if (iter != mWifiConfig.end()) {
1489 return iter->second.minRssi5Ghz;
1490 }
1491 return mWifiConfig[0].minRssi5Ghz;
1492 }
1493
SetRealMacAddress(const std::string & macAddress,int instId)1494 int WifiSettings::SetRealMacAddress(const std::string &macAddress, int instId)
1495 {
1496 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1497 mWifiConfig[instId].realMacAddress = macAddress;
1498 SyncWifiConfig();
1499 return 0;
1500 }
1501
GetRealMacAddress(std::string & macAddress,int instId)1502 int WifiSettings::GetRealMacAddress(std::string &macAddress, int instId)
1503 {
1504 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1505 auto iter = mWifiConfig.find(instId);
1506 if (iter != mWifiConfig.end()) {
1507 macAddress = iter->second.realMacAddress;
1508 return 0;
1509 }
1510 macAddress = mWifiConfig[0].realMacAddress;
1511 return 0;
1512 }
1513
SetDefaultFrequenciesByCountryBand(const BandType band,std::vector<int> & frequencies,int instId)1514 void WifiSettings::SetDefaultFrequenciesByCountryBand(const BandType band, std::vector<int> &frequencies, int instId)
1515 {
1516 for (auto& item : g_countryDefaultFreqs) {
1517 if (item.band == band) {
1518 frequencies = item.freqs;
1519 }
1520 }
1521 }
1522
SetScanOnlySwitchState(const int & state,int instId)1523 void WifiSettings::SetScanOnlySwitchState(const int &state, int instId)
1524 {
1525 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1526 mWifiConfig[instId].scanOnlySwitch = state;
1527 SyncWifiConfig();
1528 }
1529
GetScanOnlySwitchState(int instId)1530 int WifiSettings::GetScanOnlySwitchState(int instId)
1531 {
1532 std::unique_lock<std::mutex> lock(mWifiConfigMutex);
1533 if (WifiConfigCenter::GetInstance().GetSystemMode() == SystemMode::M_FACTORY_MODE) {
1534 LOGI("factory mode, not allow scan only.");
1535 return 0;
1536 }
1537 auto iter = mWifiConfig.find(instId);
1538 if (iter != mWifiConfig.end()) {
1539 return iter->second.scanOnlySwitch;
1540 }
1541 return mWifiConfig[0].scanOnlySwitch;
1542 }
1543
EncryptionDeviceConfig(WifiDeviceConfig & config) const1544 bool WifiSettings::EncryptionDeviceConfig(WifiDeviceConfig &config) const
1545 {
1546 #ifdef FEATURE_ENCRYPTION_SUPPORT
1547 if (config.version == 1) {
1548 return true;
1549 }
1550 WifiEncryptionInfo mWifiEncryptionInfo;
1551 mWifiEncryptionInfo.SetFile(GetTClassName<WifiDeviceConfig>());
1552
1553 config.encryptedData = "";
1554 config.IV = "";
1555 if (!config.preSharedKey.empty()) {
1556 EncryptedData encry;
1557 if (WifiEncryption(mWifiEncryptionInfo, config.preSharedKey, encry) == HKS_SUCCESS) {
1558 config.encryptedData = encry.encryptedPassword;
1559 config.IV = encry.IV;
1560 } else {
1561 LOGE("EncryptionDeviceConfig WifiEncryption preSharedKey failed");
1562 WriteWifiEncryptionFailHiSysEvent(ENCRYPTION_EVENT,
1563 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
1564 return false;
1565 }
1566 }
1567
1568 if (config.wepTxKeyIndex < 0 || config.wepTxKeyIndex >= WEPKEYS_SIZE) {
1569 config.wepTxKeyIndex = 0;
1570 }
1571 config.encryWepKeys[config.wepTxKeyIndex] = "";
1572 config.IVWep = "";
1573 if (!config.wepKeys[config.wepTxKeyIndex].empty()) {
1574 EncryptedData encryWep;
1575 if (WifiEncryption(mWifiEncryptionInfo, config.wepKeys[config.wepTxKeyIndex], encryWep) == HKS_SUCCESS) {
1576 config.encryWepKeys[config.wepTxKeyIndex] = encryWep.encryptedPassword;
1577 config.IVWep = encryWep.IV;
1578 } else {
1579 LOGE("EncryptionDeviceConfig WifiEncryption wepKeys failed");
1580 WriteWifiEncryptionFailHiSysEvent(ENCRYPTION_EVENT,
1581 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
1582 return false;
1583 }
1584 }
1585
1586 config.wifiEapConfig.encryptedData = "";
1587 config.wifiEapConfig.IV = "";
1588 if (!config.wifiEapConfig.eap.empty()) {
1589 EncryptedData encryEap;
1590 if (WifiEncryption(mWifiEncryptionInfo, config.wifiEapConfig.password, encryEap) == HKS_SUCCESS) {
1591 config.wifiEapConfig.encryptedData = encryEap.encryptedPassword;
1592 config.wifiEapConfig.IV = encryEap.IV;
1593 } else {
1594 LOGE("EncryptionDeviceConfig WifiEncryption eap failed");
1595 WriteWifiEncryptionFailHiSysEvent(ENCRYPTION_EVENT,
1596 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
1597 return false;
1598 }
1599 }
1600 if (!EncryptionWapiConfig(mWifiEncryptionInfo, config)) {
1601 return false;
1602 }
1603 config.version = 1;
1604 #endif
1605 return true;
1606 }
1607
IncreaseNumRebootsSinceLastUse()1608 int WifiSettings::IncreaseNumRebootsSinceLastUse()
1609 {
1610 std::unique_lock<std::mutex> lock(mStaMutex);
1611 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
1612 iter->second.numRebootsSinceLastUse++;
1613 }
1614 return 0;
1615 }
1616
EncryptionWifiDeviceConfigOnBoot()1617 void WifiSettings::EncryptionWifiDeviceConfigOnBoot()
1618 {
1619 #ifdef FEATURE_ENCRYPTION_SUPPORT
1620 std::unique_lock<std::mutex> lock(mConfigOnBootMutex);
1621 if (mSavedDeviceConfig.LoadConfig() < 0) {
1622 return;
1623 }
1624 std::vector<WifiDeviceConfig> tmp;
1625 mSavedDeviceConfig.GetValue(tmp);
1626 int count = 0;
1627
1628 for (std::size_t i = 0; i < tmp.size(); ++i) {
1629 WifiDeviceConfig &item = tmp[i];
1630 if (item.version == -1 && EncryptionDeviceConfig(item)) {
1631 count ++;
1632 }
1633 }
1634 if (count > 0) {
1635 mSavedDeviceConfig.SetValue(tmp);
1636 mSavedDeviceConfig.SaveConfig();
1637 ReloadDeviceConfig();
1638 }
1639 LOGI("EncryptionWifiDeviceConfigOnBoot end count:%{public}d", count);
1640 #endif
1641 }
1642
ReloadStaRandomMac()1643 int WifiSettings::ReloadStaRandomMac()
1644 {
1645 std::unique_lock<std::mutex> lock(mStaMutex);
1646 if (mSavedWifiStoreRandomMac.LoadConfig()) {
1647 return -1;
1648 }
1649 mWifiStoreRandomMac.clear();
1650 mSavedWifiStoreRandomMac.GetValue(mWifiStoreRandomMac);
1651 bool shouldReset = false;
1652 for (const auto &item: mWifiStoreRandomMac) {
1653 if (item.version == -1) {
1654 shouldReset = true;
1655 break;
1656 }
1657 }
1658 LOGI("%{public}s shouldReset:%{public}s", __func__, shouldReset ? "true" : "false");
1659 if (shouldReset) {
1660 for (auto &item: mWifiStoreRandomMac) {
1661 item.version = 0;
1662 }
1663 mSavedWifiStoreRandomMac.SetValue(mWifiStoreRandomMac);
1664 mSavedWifiStoreRandomMac.SaveConfig();
1665 }
1666 return 0;
1667 }
1668
InitPackageInfoConfig()1669 void WifiSettings::InitPackageInfoConfig()
1670 {
1671 #ifndef OHOS_ARCH_LITE
1672 std::unique_ptr<PackageXmlParser> xmlParser = std::make_unique<PackageXmlParser>();
1673 bool ret = xmlParser->LoadConfiguration(PACKAGE_FILTER_CONFIG_FILE_PATH);
1674 if (!ret) {
1675 LOGE("PackageXmlParser load fail");
1676 return;
1677 }
1678 ret = xmlParser->Parse();
1679 if (!ret) {
1680 LOGE("PackageXmlParser Parse fail");
1681 return;
1682 }
1683 std::map<std::string, std::vector<PackageInfo>> scanControlPackageMap;
1684 std::vector<PackageInfo> candidateList;
1685 std::map<std::string, std::vector<PackageInfo>> variableMap;
1686 std::vector<PackageInfo> permissionTrustList;
1687 xmlParser->GetScanControlPackages(scanControlPackageMap);
1688 xmlParser->GetCandidateFilterPackages(candidateList);
1689 xmlParser->GetCorePackages(variableMap);
1690 xmlParser->GetAclAuthPackages(permissionTrustList);
1691
1692 std::unique_lock<std::mutex> lock(mPackageConfMutex);
1693 mPackageInfoMap.insert(scanControlPackageMap.begin(), scanControlPackageMap.end());
1694 mPackageInfoMap.insert_or_assign("CandidateFilterPackages", candidateList);
1695 mPackageInfoMap.insert(variableMap.begin(), variableMap.end());
1696 mPackageInfoMap.insert_or_assign("AclAuthPackages", permissionTrustList);
1697 #endif
1698 }
1699
GetPackageName(std::string tag)1700 std::string WifiSettings::GetPackageName(std::string tag)
1701 {
1702 std::unique_lock<std::mutex> lock(mPackageConfMutex);
1703 for (auto iter = mPackageInfoMap.begin(); iter != mPackageInfoMap.end(); iter++) {
1704 if (iter->first == tag && !iter->second.empty()) {
1705 return iter->second[0].name;
1706 }
1707 }
1708 return "";
1709 }
1710
InitDefaultHotspotConfig()1711 void WifiSettings::InitDefaultHotspotConfig()
1712 {
1713 HotspotConfig cfg;
1714 #ifdef INIT_LIB_ENABLE
1715 std::string ssid = GetMarketName();
1716 #endif
1717 cfg.SetSecurityType(KeyMgmt::WPA2_PSK);
1718 cfg.SetBand(BandType::BAND_2GHZ);
1719 cfg.SetChannel(AP_CHANNEL_DEFAULT);
1720 cfg.SetMaxConn(GetApMaxConnNum());
1721 cfg.SetBandWidth(AP_BANDWIDTH_DEFAULT);
1722 #ifdef INIT_LIB_ENABLE
1723 cfg.SetSsid(ssid);
1724 #else
1725 cfg.SetSsid("OHOS_" + GetRandomStr(RANDOM_STR_LEN));
1726 #endif
1727 cfg.SetPreSharedKey(GetRandomStr(RANDOM_PASSWD_LEN));
1728 auto ret = mHotspotConfig.emplace(0, cfg);
1729 if (!ret.second) {
1730 mHotspotConfig[0] = cfg;
1731 }
1732 }
1733
InitHotspotConfig()1734 void WifiSettings::InitHotspotConfig()
1735 {
1736 /* init hotspot config */
1737 if (mSavedHotspotConfig.LoadConfig() >= 0) {
1738 std::vector<HotspotConfig> tmp;
1739 mSavedHotspotConfig.GetValue(tmp);
1740 if (tmp.size() > 0) {
1741 for (size_t i = 0; i < tmp.size(); i++) {
1742 mHotspotConfig[i] = tmp[i];
1743 }
1744 } else {
1745 LOGI("load hotspot config success, but tmp.size() = 0, use default config");
1746 InitDefaultHotspotConfig();
1747 }
1748 } else {
1749 LOGI("load hotspot config fail, use default config");
1750 InitDefaultHotspotConfig();
1751 }
1752 /* init block list info */
1753 if (mSavedBlockInfo.LoadConfig() >= 0) {
1754 std::vector<StationInfo> tmp;
1755 mSavedBlockInfo.GetValue(tmp);
1756 for (std::size_t i = 0; i < tmp.size(); ++i) {
1757 StationInfo &item = tmp[i];
1758 mBlockListInfo.emplace(item.bssid, item);
1759 }
1760 }
1761 return;
1762 }
1763
SyncBlockList()1764 int WifiSettings::SyncBlockList()
1765 {
1766 std::vector<StationInfo> tmp;
1767 for (auto iter = mBlockListInfo.begin(); iter != mBlockListInfo.end(); ++iter) {
1768 tmp.push_back(iter->second);
1769 }
1770 mSavedBlockInfo.SetValue(tmp);
1771 return mSavedBlockInfo.SaveConfig();
1772 }
1773
ReloadWifiP2pGroupInfoConfig()1774 int WifiSettings::ReloadWifiP2pGroupInfoConfig()
1775 {
1776 std::unique_lock<std::mutex> lock(mP2pMutex);
1777 bool invalidGroupExist = false;
1778 if (mSavedWifiP2pGroupInfo.LoadConfig()) {
1779 return -1;
1780 }
1781 mSavedWifiP2pGroupInfo.GetValue(mGroupInfoList);
1782 for (auto iter = mGroupInfoList.begin(); iter != mGroupInfoList.end();) {
1783 int networkId = iter->GetNetworkId();
1784 std::string passPhrase = iter->GetPassphrase();
1785 if (passPhrase.empty()) {
1786 LOGI("ReloadWifiP2pGroupInfoConfig erase invalid networkId:%{public}d", networkId);
1787 iter = mGroupInfoList.erase(iter);
1788 invalidGroupExist = true;
1789 } else {
1790 ++iter;
1791 }
1792 }
1793 if (invalidGroupExist) {
1794 mSavedWifiP2pGroupInfo.SetValue(mGroupInfoList);
1795 mSavedWifiP2pGroupInfo.SaveConfig();
1796 }
1797 return 0;
1798 }
1799
InitDefaultP2pVendorConfig()1800 void WifiSettings::InitDefaultP2pVendorConfig()
1801 {
1802 mP2pVendorConfig.SetRandomMacSupport(false);
1803 mP2pVendorConfig.SetIsAutoListen(false);
1804 mP2pVendorConfig.SetDeviceName("");
1805 mP2pVendorConfig.SetPrimaryDeviceType("");
1806 mP2pVendorConfig.SetSecondaryDeviceType("");
1807 }
1808
InitP2pVendorConfig()1809 void WifiSettings::InitP2pVendorConfig()
1810 {
1811 if (mSavedWifiP2pVendorConfig.LoadConfig() >= 0) {
1812 std::vector<P2pVendorConfig> tmp;
1813 mSavedWifiP2pVendorConfig.GetValue(tmp);
1814 if (tmp.size() > 0) {
1815 mP2pVendorConfig = tmp[0];
1816 } else {
1817 InitDefaultP2pVendorConfig();
1818 }
1819 } else {
1820 InitDefaultP2pVendorConfig();
1821 }
1822 return;
1823 }
1824
GetApMaxConnNum()1825 int WifiSettings::GetApMaxConnNum()
1826 {
1827 return mApMaxConnNum;
1828 }
1829
InitDefaultWifiConfig()1830 void WifiSettings::InitDefaultWifiConfig()
1831 {
1832 WifiConfig wifiConfig;
1833 mWifiConfig[0] = wifiConfig;
1834 }
1835
InitWifiConfig()1836 void WifiSettings::InitWifiConfig()
1837 {
1838 if (mSavedWifiConfig.LoadConfig() < 0) {
1839 return;
1840 }
1841 std::vector<WifiConfig> tmp;
1842 mSavedWifiConfig.GetValue(tmp);
1843 if (tmp.size() > 0) {
1844 for (size_t i = 0; i < tmp.size(); ++i) {
1845 mWifiConfig[i] = tmp[i];
1846 }
1847 } else {
1848 InitDefaultWifiConfig();
1849 }
1850 return;
1851 }
1852
SyncWifiConfig()1853 int WifiSettings::SyncWifiConfig()
1854 {
1855 std::vector<WifiConfig> tmp;
1856 for (auto &item : mWifiConfig) {
1857 tmp.push_back(item.second);
1858 }
1859 mSavedWifiConfig.SetValue(tmp);
1860 return mSavedWifiConfig.SaveConfig();
1861 }
1862
RemoveExcessDeviceConfigs(std::vector<WifiDeviceConfig> & configs) const1863 int WifiSettings::RemoveExcessDeviceConfigs(std::vector<WifiDeviceConfig> &configs) const
1864 {
1865 int maxNumConfigs = mMaxNumConfigs;
1866 if (maxNumConfigs < 0) {
1867 return 1;
1868 }
1869 int numExcessNetworks = static_cast<int>(configs.size()) - maxNumConfigs;
1870 if (numExcessNetworks <= 0) {
1871 return 1;
1872 }
1873 sort(configs.begin(), configs.end(), [](WifiDeviceConfig a, WifiDeviceConfig b) {
1874 if (a.lastConnectTime != b.lastConnectTime) {
1875 return a.lastConnectTime < b.lastConnectTime;
1876 } else if (a.numRebootsSinceLastUse != b.numRebootsSinceLastUse) {
1877 return a.numRebootsSinceLastUse > b.numRebootsSinceLastUse;
1878 } else if (a.numAssociation != b.numAssociation) {
1879 return a.numAssociation < b.numAssociation;
1880 } else {
1881 return a.networkId < b.networkId;
1882 }
1883 });
1884 std::stringstream removeConfig;
1885 int maxIndex = numExcessNetworks > MAX_CONFIGS_NUM ? MAX_CONFIGS_NUM : numExcessNetworks;
1886 for (int i = 0; i < maxIndex; i++) {
1887 removeConfig << SsidAnonymize(configs[i].ssid) << ",";
1888 }
1889 LOGI("saved config size greater than %{public}d, remove ssid(print up to 1000)=%{public}s",
1890 maxNumConfigs, removeConfig.str().c_str());
1891 std::vector<WifiDeviceConfig> newVec(configs.begin(), configs.begin() + numExcessNetworks);
1892 #ifdef SUPPORT_ClOUD_WIFI_ASSET
1893 WifiAssetManager::GetInstance().WifiAssetRemovePack(newVec);
1894 #endif
1895 configs.erase(configs.begin(), configs.begin() + numExcessNetworks);
1896 return 0;
1897 }
1898
FuzzyBssid(const std::string bssid)1899 std::string WifiSettings::FuzzyBssid(const std::string bssid)
1900 {
1901 if (bssid.empty() || bssid.length() != MAC_STRING_SIZE) {
1902 return "";
1903 }
1904 return "xx" + bssid.substr(COMPARE_MAC_OFFSET, COMPARE_MAC_LENGTH) + "xx";
1905 }
1906
1907 #ifndef OHOS_ARCH_LITE
MergeWifiConfig()1908 void WifiSettings::MergeWifiConfig()
1909 {
1910 std::filesystem::path wifiPathNmae = WIFI_CONFIG_FILE_PATH;
1911 std::filesystem::path devicePathName = DEVICE_CONFIG_FILE_PATH;
1912 std::filesystem::path randomMacPathName = WIFI_STA_RANDOM_MAC_FILE_PATH;
1913 std::filesystem::path dualWifiPathName = DUAL_WIFI_CONFIG_FILE_PATH;
1914 std::error_code wifiConfigCode;
1915 std::error_code deviceConfigCode;
1916 std::error_code randomMacCode;
1917 std::error_code dualWifiCode;
1918 if (std::filesystem::exists(wifiPathNmae, wifiConfigCode)
1919 || std::filesystem::exists(devicePathName, deviceConfigCode)
1920 || std::filesystem::exists(randomMacPathName, randomMacCode)) {
1921 LOGI("file exists don't need to merge");
1922 return;
1923 }
1924 if (!std::filesystem::exists(dualWifiPathName, dualWifiCode)) {
1925 LOGI("dual frame file do not exists, don't need to merge");
1926 return;
1927 }
1928 std::unique_ptr<NetworkXmlParser> xmlParser = std::make_unique<NetworkXmlParser>();
1929 bool ret = xmlParser->LoadConfiguration(DUAL_WIFI_CONFIG_FILE_PATH);
1930 if (!ret) {
1931 LOGE("MergeWifiConfig load fail");
1932 return;
1933 }
1934 ret = xmlParser->Parse();
1935 if (!ret) {
1936 LOGE("MergeWifiConfig Parse fail");
1937 return;
1938 }
1939 std::vector<WifiDeviceConfig> wifideviceConfig = xmlParser->GetNetworks();
1940 if (wifideviceConfig.size() == 0) {
1941 LOGE("MergeWifiConfig wifideviceConfig empty");
1942 return;
1943 }
1944 mSavedDeviceConfig.SetValue(wifideviceConfig);
1945 mSavedDeviceConfig.SaveConfig();
1946 std::unique_lock<std::mutex> lock(mStaMutex);
1947 std::vector<WifiStoreRandomMac> wifiStoreRandomMac = xmlParser->GetRandomMacmap();
1948 mSavedWifiStoreRandomMac.SetValue(wifiStoreRandomMac);
1949 mSavedWifiStoreRandomMac.SaveConfig();
1950 }
1951
MergeSoftapConfig()1952 void WifiSettings::MergeSoftapConfig()
1953 {
1954 LOGI("Enter mergeSoftapConfig");
1955 std::filesystem::path wifiPathNmae = WIFI_CONFIG_FILE_PATH;
1956 std::filesystem::path hostapdPathName = HOTSPOT_CONFIG_FILE_PATH;
1957 std::filesystem::path dualApPathName = DUAL_SOFTAP_CONFIG_FILE_PATH;
1958 std::error_code wifiConfigCode;
1959 std::error_code hotspotConfigCode;
1960 std::error_code dualApCode;
1961 if (std::filesystem::exists(wifiPathNmae, wifiConfigCode)
1962 || std::filesystem::exists(hostapdPathName, hotspotConfigCode)) {
1963 LOGI("MergeSoftapConfig file exists don't need to merge");
1964 return;
1965 }
1966 if (!std::filesystem::exists(dualApPathName, dualApCode)) {
1967 LOGI("MergeSoftapConfig dual frame file do not exists, don't need to merge");
1968 return;
1969 }
1970 std::unique_ptr<SoftapXmlParser> xmlParser = std::make_unique<SoftapXmlParser>();
1971 bool ret = xmlParser->LoadConfiguration(DUAL_SOFTAP_CONFIG_FILE_PATH);
1972 if (!ret) {
1973 LOGE("MergeSoftapConfig fail");
1974 return;
1975 }
1976 ret = xmlParser->Parse();
1977 if (!ret) {
1978 LOGE("MergeSoftapConfig Parse fail");
1979 return;
1980 }
1981 std::vector<HotspotConfig> hotspotConfig = xmlParser->GetSoftapConfigs();
1982 if (hotspotConfig.size() == 0) {
1983 LOGE("MergeSoftapConfig hotspotConfig empty");
1984 return;
1985 }
1986 mSavedHotspotConfig.SetValue(hotspotConfig);
1987 mSavedHotspotConfig.SaveConfig();
1988 }
1989
ConfigsDeduplicateAndSave(std::vector<WifiDeviceConfig> & newConfigs)1990 void WifiSettings::ConfigsDeduplicateAndSave(std::vector<WifiDeviceConfig> &newConfigs)
1991 {
1992 if (newConfigs.size() == 0) {
1993 LOGE("NewConfigs is empty!");
1994 return;
1995 }
1996 mSavedDeviceConfig.LoadConfig();
1997 std::vector<WifiDeviceConfig> localConfigs;
1998 mSavedDeviceConfig.GetValue(localConfigs);
1999
2000 std::set<std::string> tmp;
2001 for (const auto &localConfig : localConfigs) {
2002 std::string configKey = localConfig.ssid + localConfig.keyMgmt;
2003 tmp.insert(configKey);
2004 }
2005 std::vector<WifiDeviceConfig> addConfigs;
2006 for (auto &config : newConfigs) {
2007 std::string configKey = config.ssid + config.keyMgmt;
2008 auto iter = tmp.find(configKey);
2009 if (iter == tmp.end()) {
2010 tmp.insert(configKey);
2011 #ifdef FEATURE_ENCRYPTION_SUPPORT
2012 EncryptionDeviceConfig(config);
2013 #endif
2014 localConfigs.push_back(config);
2015 addConfigs.push_back(config);
2016 }
2017 }
2018 #ifdef SUPPORT_ClOUD_WIFI_ASSET
2019 LOGD("WifiAsset ConfigsDeduplicateAndSave");
2020 WifiAssetManager::GetInstance().WifiAssetAddPack(addConfigs);
2021 #endif
2022 std::vector<WifiDeviceConfig>().swap(newConfigs);
2023 mSavedDeviceConfig.SetValue(localConfigs);
2024 mSavedDeviceConfig.SaveConfig();
2025 ReloadDeviceConfig();
2026 }
2027
ParseBackupJson(const std::string & backupInfo,std::string & key,std::string & iv,std::string & version)2028 void WifiSettings::ParseBackupJson(const std::string &backupInfo, std::string &key, std::string &iv,
2029 std::string &version)
2030 {
2031 const std::string type = "detail";
2032 const std::string encryptionSymkey = "encryption_symkey";
2033 const std::string gcmParamsIv = "gcmParams_iv";
2034 const std::string apiVersion = "api_version";
2035 std::string keyStr;
2036 std::string ivStr;
2037
2038 ParseJson(backupInfo, type, encryptionSymkey, keyStr);
2039 ParseJson(backupInfo, type, gcmParamsIv, ivStr);
2040 ParseJson(backupInfo, type, apiVersion, version);
2041 LOGI("ParseBackupJson version: %{public}s.", version.c_str());
2042 ConvertDecStrToHexStr(keyStr, key);
2043 std::fill(keyStr.begin(), keyStr.end(), 0);
2044 LOGI("ParseBackupJson key.size: %{public}d.", static_cast<int>(key.size()));
2045 ConvertDecStrToHexStr(ivStr, iv);
2046 LOGI("ParseBackupJson iv.size: %{public}d.", static_cast<int>(iv.size()));
2047 }
2048
GetConfigbyBackupXml(std::vector<WifiDeviceConfig> & deviceConfigs,UniqueFd & fd)2049 int WifiSettings::GetConfigbyBackupXml(std::vector<WifiDeviceConfig> &deviceConfigs, UniqueFd &fd)
2050 {
2051 const std::string wifiBackupXmlBegin = "<WifiBackupData>";
2052 const std::string wifiBackupXmlEnd = "</WifiBackupData>";
2053 struct stat statBuf;
2054 if (fd.Get() < 0 || fstat(fd.Get(), &statBuf) < 0) {
2055 LOGE("GetConfigbyBackupXml fstat fd fail.");
2056 return -1;
2057 }
2058 char *buffer = (char *)malloc(statBuf.st_size);
2059 if (buffer == nullptr) {
2060 LOGE("GetConfigbyBackupXml malloc fail.");
2061 return -1;
2062 }
2063 ssize_t bufferLen = read(fd.Get(), buffer, statBuf.st_size);
2064 if (bufferLen < 0) {
2065 LOGE("GetConfigbyBackupXml read fail.");
2066 free(buffer);
2067 buffer = nullptr;
2068 return -1;
2069 }
2070 std::string backupData = std::string(buffer, buffer + bufferLen);
2071 if (memset_s(buffer, statBuf.st_size, 0, statBuf.st_size) != EOK) {
2072 LOGE("GetConfigbyBackupXml memset_s fail.");
2073 free(buffer);
2074 buffer = nullptr;
2075 return -1;
2076 }
2077 free(buffer);
2078 buffer = nullptr;
2079
2080 std::string wifiBackupXml;
2081 SplitStringBySubstring(backupData, wifiBackupXml, wifiBackupXmlBegin, wifiBackupXmlEnd);
2082 std::fill(backupData.begin(), backupData.end(), 0);
2083 std::unique_ptr<NetworkXmlParser> xmlParser = std::make_unique<NetworkXmlParser>();
2084 bool ret = xmlParser->LoadConfigurationMemory(wifiBackupXml.c_str());
2085 if (!ret) {
2086 LOGE("GetConfigbyBackupXml load fail");
2087 return -1;
2088 }
2089 ret = xmlParser->Parse();
2090 if (!ret) {
2091 LOGE("GetConfigbyBackupXml Parse fail");
2092 return -1;
2093 }
2094 deviceConfigs = xmlParser->GetNetworks();
2095 std::fill(wifiBackupXml.begin(), wifiBackupXml.end(), 0);
2096 return 0;
2097 }
2098
GetConfigbyBackupFile(std::vector<WifiDeviceConfig> & deviceConfigs,UniqueFd & fd,const std::string & key,const std::string & iv)2099 int WifiSettings::GetConfigbyBackupFile(std::vector<WifiDeviceConfig> &deviceConfigs, UniqueFd &fd,
2100 const std::string &key, const std::string &iv)
2101 {
2102 if (key.size() == 0 || iv.size() == 0) {
2103 LOGE("GetConfigbyBackupFile key or iv is empty.");
2104 return -1;
2105 }
2106 struct stat statBuf;
2107 if (fd.Get() < 0 || fstat(fd.Get(), &statBuf) < 0) {
2108 LOGE("GetConfigbyBackupFile fstat fd fail.");
2109 return -1;
2110 }
2111 int destFd = open(BACKUP_CONFIG_FILE_PATH, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
2112 if (destFd < 0) {
2113 LOGE("GetConfigbyBackupFile open file fail.");
2114 return -1;
2115 }
2116 if (sendfile(destFd, fd.Get(), nullptr, statBuf.st_size) < 0) {
2117 LOGE("GetConfigbyBackupFile fd sendfile(size: %{public}d) to destFd fail.", static_cast<int>(statBuf.st_size));
2118 close(destFd);
2119 return -1;
2120 }
2121 close(destFd);
2122
2123 WifiConfigFileImpl<WifiBackupConfig> wifiBackupConfig;
2124 wifiBackupConfig.SetConfigFilePath(BACKUP_CONFIG_FILE_PATH);
2125 wifiBackupConfig.SetEncryptionInfo(key, iv);
2126 wifiBackupConfig.LoadConfig();
2127 std::vector<WifiBackupConfig> backupConfigs;
2128 wifiBackupConfig.GetValue(backupConfigs);
2129 wifiBackupConfig.UnsetEncryptionInfo();
2130
2131 for (const auto &backupCfg : backupConfigs) {
2132 WifiDeviceConfig config;
2133 ConvertBackupCfgToDeviceCfg(backupCfg, config);
2134 deviceConfigs.push_back(config);
2135 }
2136 return 0;
2137 }
2138 #endif
2139 #ifdef FEATURE_ENCRYPTION_SUPPORT
IsWifiDeviceConfigDeciphered(const WifiDeviceConfig & config) const2140 bool WifiSettings::IsWifiDeviceConfigDeciphered(const WifiDeviceConfig &config) const
2141 {
2142 int keyIndex = (config.wepTxKeyIndex < 0 || config.wepTxKeyIndex >= WEPKEYS_SIZE) ? 0 : config.wepTxKeyIndex;
2143 if (!config.preSharedKey.empty() || !config.wepKeys[keyIndex].empty() || !config.wifiEapConfig.password.empty()) {
2144 return true;
2145 }
2146 if (config.keyMgmt == KEY_MGMT_NONE) {
2147 return true;
2148 }
2149 return false;
2150 }
2151
DecryptionWapiConfig(const WifiEncryptionInfo & wifiEncryptionInfo,WifiDeviceConfig & config) const2152 void WifiSettings::DecryptionWapiConfig(const WifiEncryptionInfo &wifiEncryptionInfo, WifiDeviceConfig &config) const
2153 {
2154 if (config.keyMgmt != KEY_MGMT_WAPI_CERT) {
2155 return;
2156 }
2157
2158 EncryptedData *encryWapiAs = new EncryptedData(config.wifiWapiConfig.encryptedAsCertData,
2159 config.wifiWapiConfig.asCertDataIV);
2160 std::string decryWapiAs = "";
2161 if (WifiDecryption(wifiEncryptionInfo, *encryWapiAs, decryWapiAs) == HKS_SUCCESS) {
2162 config.wifiWapiConfig.wapiAsCertData = decryWapiAs;
2163 } else {
2164 WriteWifiEncryptionFailHiSysEvent(DECRYPTION_EVENT,
2165 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2166 config.wifiWapiConfig.wapiAsCertData = "";
2167 }
2168 delete encryWapiAs;
2169 encryWapiAs = nullptr;
2170
2171 EncryptedData *encryWapiUser = new EncryptedData(config.wifiWapiConfig.encryptedUserCertData,
2172 config.wifiWapiConfig.userCertDataIV);
2173 std::string decryWapiUser = "";
2174 if (WifiDecryption(wifiEncryptionInfo, *encryWapiUser, decryWapiUser) == HKS_SUCCESS) {
2175 config.wifiWapiConfig.wapiUserCertData = decryWapiUser;
2176 } else {
2177 WriteWifiEncryptionFailHiSysEvent(DECRYPTION_EVENT,
2178 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2179 config.wifiWapiConfig.wapiUserCertData = "";
2180 }
2181 delete encryWapiUser;
2182 encryWapiUser = nullptr;
2183 }
2184
DecryptionDeviceConfig(WifiDeviceConfig & config)2185 int WifiSettings::DecryptionDeviceConfig(WifiDeviceConfig &config)
2186 {
2187 if (IsWifiDeviceConfigDeciphered(config)) {
2188 LOGD("DecryptionDeviceConfig IsWifiDeviceConfigDeciphered true");
2189 return 0;
2190 }
2191 WifiEncryptionInfo mWifiEncryptionInfo;
2192 mWifiEncryptionInfo.SetFile(GetTClassName<WifiDeviceConfig>());
2193 EncryptedData *encry = new EncryptedData(config.encryptedData, config.IV);
2194 std::string decry = "";
2195 if (WifiDecryption(mWifiEncryptionInfo, *encry, decry) == HKS_SUCCESS) {
2196 config.preSharedKey = decry;
2197 } else {
2198 WriteWifiEncryptionFailHiSysEvent(DECRYPTION_EVENT,
2199 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2200 config.preSharedKey = "";
2201 std::string().swap(config.preSharedKey);
2202 }
2203 delete encry;
2204
2205 if (config.wepTxKeyIndex < 0 || config.wepTxKeyIndex >= WEPKEYS_SIZE) {
2206 config.wepTxKeyIndex = 0;
2207 }
2208 EncryptedData *encryWep = new EncryptedData(config.encryWepKeys[config.wepTxKeyIndex], config.IVWep);
2209 std::string decryWep = "";
2210 if (WifiDecryption(mWifiEncryptionInfo, *encryWep, decryWep) == HKS_SUCCESS) {
2211 config.wepKeys[config.wepTxKeyIndex] = decryWep;
2212 } else {
2213 WriteWifiEncryptionFailHiSysEvent(DECRYPTION_EVENT,
2214 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2215 config.wepKeys[config.wepTxKeyIndex] = "";
2216 }
2217 delete encryWep;
2218 encryWep = nullptr;
2219
2220 EncryptedData *encryEap = new EncryptedData(config.wifiEapConfig.encryptedData, config.wifiEapConfig.IV);
2221 std::string decryEap = "";
2222 if (WifiDecryption(mWifiEncryptionInfo, *encryEap, decryEap) == HKS_SUCCESS) {
2223 config.wifiEapConfig.password = decryEap;
2224 } else {
2225 WriteWifiEncryptionFailHiSysEvent(DECRYPTION_EVENT,
2226 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2227 config.wifiEapConfig.password = "";
2228 }
2229 delete encryEap;
2230 encryEap = nullptr;
2231 DecryptionWapiConfig(mWifiEncryptionInfo, config);
2232 LOGD("DecryptionDeviceConfig end");
2233 return 0;
2234 }
2235
EncryptionWapiConfig(const WifiEncryptionInfo & wifiEncryptionInfo,WifiDeviceConfig & config) const2236 bool WifiSettings::EncryptionWapiConfig(const WifiEncryptionInfo &wifiEncryptionInfo, WifiDeviceConfig &config) const
2237 {
2238 if (config.keyMgmt != KEY_MGMT_WAPI_CERT) {
2239 return true;
2240 }
2241
2242 if (config.wifiWapiConfig.wapiAsCertData.empty() || config.wifiWapiConfig.wapiUserCertData.empty()) {
2243 LOGE("EncryptionDeviceConfig wapiCertData empty");
2244 return false;
2245 }
2246
2247 config.wifiWapiConfig.encryptedAsCertData = "";
2248 config.wifiWapiConfig.asCertDataIV = "";
2249
2250 EncryptedData encryWapiAs;
2251 if (WifiEncryption(wifiEncryptionInfo, config.wifiWapiConfig.wapiAsCertData, encryWapiAs) == HKS_SUCCESS) {
2252 config.wifiWapiConfig.encryptedAsCertData = encryWapiAs.encryptedPassword;
2253 config.wifiWapiConfig.asCertDataIV = encryWapiAs.IV;
2254 } else {
2255 LOGE("EncryptionDeviceConfig WifiEncryption wapiAsCertData failed");
2256 WriteWifiEncryptionFailHiSysEvent(ENCRYPTION_EVENT,
2257 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2258 return false;
2259 }
2260
2261 config.wifiWapiConfig.encryptedUserCertData = "";
2262 config.wifiWapiConfig.userCertDataIV = "";
2263
2264 EncryptedData encryWapiUser;
2265 if (WifiEncryption(wifiEncryptionInfo, config.wifiWapiConfig.wapiUserCertData, encryWapiUser) == HKS_SUCCESS) {
2266 config.wifiWapiConfig.encryptedUserCertData = encryWapiUser.encryptedPassword;
2267 config.wifiWapiConfig.userCertDataIV = encryWapiUser.IV;
2268 } else {
2269 LOGE("EncryptionDeviceConfig WifiEncryption wapiUserCertData failed");
2270 WriteWifiEncryptionFailHiSysEvent(ENCRYPTION_EVENT,
2271 SsidAnonymize(config.ssid), config.keyMgmt, STA_MOUDLE_EVENT);
2272 return false;
2273 }
2274 return true;
2275 }
2276
2277 #endif
2278 #ifdef SUPPORT_ClOUD_WIFI_ASSET
ApplyCloudWifiConfig(const std::vector<WifiDeviceConfig> & newWifiDeviceConfigs,const std::set<int> & wifiLinkedNetworkIds,std::map<int,WifiDeviceConfig> & tempConfigs)2279 void WifiSettings::ApplyCloudWifiConfig(const std::vector<WifiDeviceConfig> &newWifiDeviceConfigs,
2280 const std::set<int> &wifiLinkedNetworkIds, std::map<int, WifiDeviceConfig> &tempConfigs)
2281 {
2282 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
2283 if (wifiLinkedNetworkIds.count(iter->second.networkId) != 0) {
2284 tempConfigs.emplace(std::make_pair(iter->second.networkId, iter->second));
2285 LOGI("UpdateWifiConfigFromCloud, connected network %{public}s", SsidAnonymize(iter->second.ssid).c_str());
2286 continue;
2287 }
2288 if (WifiAssetManager::GetInstance().IsWifiConfigUpdated(newWifiDeviceConfigs, iter->second)) {
2289 #ifdef FEATURE_ENCRYPTION_SUPPORT
2290 EncryptionDeviceConfig(iter->second);
2291 #endif
2292 LOGI("UpdateWifiConfigFromCloud, modify network %{public}s", SsidAnonymize(iter->second.ssid).c_str());
2293 tempConfigs.emplace(std::make_pair(iter->second.networkId, iter->second));
2294 continue;
2295 }
2296 #ifdef FEATURE_ENCRYPTION_SUPPORT
2297 if (!IsWifiDeviceConfigDeciphered(iter->second)) {
2298 LOGI("UpdateWifiConfigFromCloud, encrypted network %{public}s", SsidAnonymize(iter->second.ssid).c_str());
2299 tempConfigs.emplace(std::make_pair(iter->second.networkId, iter->second));
2300 continue;
2301 }
2302 #endif
2303 LOGI("UpdateWifiConfigFromCloud remove from cloud %{public}s", SsidAnonymize(iter->second.ssid).c_str());
2304 }
2305 }
2306
UpdateWifiConfigFromCloud(const std::vector<WifiDeviceConfig> & newWifiDeviceConfigs,const std::set<int> & wifiLinkedNetworkIds)2307 void WifiSettings::UpdateWifiConfigFromCloud(const std::vector<WifiDeviceConfig> &newWifiDeviceConfigs,
2308 const std::set<int> &wifiLinkedNetworkIds)
2309 {
2310 std::unique_lock<std::mutex> lock(mStaMutex);
2311 std::map<int, WifiDeviceConfig> tempConfigs;
2312 ApplyCloudWifiConfig(newWifiDeviceConfigs, wifiLinkedNetworkIds, tempConfigs);
2313 for (auto iter : newWifiDeviceConfigs) {
2314 bool find = false;
2315 for (auto oriIter = mWifiDeviceConfig.begin(); oriIter != mWifiDeviceConfig.end(); oriIter++) {
2316 if (oriIter->second.ssid == iter.ssid && oriIter->second.keyMgmt == iter.keyMgmt) {
2317 find = true;
2318 break;
2319 }
2320 }
2321 if (find) {
2322 continue;
2323 }
2324 iter.networkId = mNetworkId;
2325 iter.version = 0;
2326 #ifdef FEATURE_ENCRYPTION_SUPPORT
2327 EncryptionDeviceConfig(iter);
2328 #endif
2329 LOGI("%{public}s networkId: %{public}d, ssid: %{public}s, keyMgmt: %{public}s, psksize: %{public}d",
2330 __FUNCTION__, iter.networkId, SsidAnonymize(iter.ssid).c_str(), iter.keyMgmt.c_str(),
2331 static_cast<int>((iter.preSharedKey).length()));
2332 tempConfigs.emplace(std::make_pair(iter.networkId, iter));
2333 mNetworkId++;
2334 }
2335 for (auto& iter : tempConfigs) {
2336 SetKeyMgmtBitset(iter.second);
2337 }
2338 mWifiDeviceConfig.swap(tempConfigs);
2339 }
2340
UpLoadLocalDeviceConfigToCloud()2341 void WifiSettings::UpLoadLocalDeviceConfigToCloud()
2342 {
2343 std::unique_lock<std::mutex> lock(mStaMutex);
2344 LOGI("UpLoadLocalDeviceConfigToCloud enter");
2345 std::vector<WifiDeviceConfig> tmp;
2346 for (auto iter = mWifiDeviceConfig.begin(); iter != mWifiDeviceConfig.end(); iter++) {
2347 #ifdef FEATURE_ENCRYPTION_SUPPORT
2348 if (IsWifiDeviceConfigDeciphered(iter->second)) {
2349 tmp.push_back(iter->second);
2350 }
2351 #else
2352 tmp.push_back(iter->second);
2353 #endif
2354 }
2355 WifiAssetManager::GetInstance().WifiAssetAddPack(tmp, USER_ID_DEFAULT, true, true);
2356 }
2357 #endif
2358 } // namespace Wifi
2359 } // namespace OHOS
2360