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