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