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 #ifdef SUPPORT_ClOUD_WIFI_ASSET
16 #include "wifi_asset_manager.h"
17 #include "wifi_settings.h"
18 #include "wifi_common_util.h"
19 #include "wifi_config_center.h"
20 #include "parameters.h"
21
22 namespace OHOS {
23 namespace Wifi {
24 static AssetValue g_userIdValue = {.u32 = USER_ID_DEFAULT};
25 static AssetValue g_trustAccountValue = {.u32 = SEC_ASSET_SYNC_TYPE_TRUSTED_ACCOUNT};
26 const std::string WIFI_ASSET_NETWORK_ON_SYNC = "WifiAssetNetworkOnSync";
SplitString(const std::string & input,const char spChar,std::vector<std::string> & outArray)27 static void SplitString(const std::string &input, const char spChar, std::vector<std::string> &outArray)
28 {
29 std::stringstream sstr(input);
30 std::string token;
31 while (getline(sstr, token, spChar)) {
32 outArray.push_back(token);
33 }
34 }
35
CheckEap(const WifiDeviceConfig & config)36 static bool CheckEap(const WifiDeviceConfig &config)
37 {
38 if (config.keyMgmt != KEY_MGMT_EAP && config.keyMgmt != KEY_MGMT_SUITE_B_192) {
39 return false;
40 }
41 if (config.wifiEapConfig.eap == EAP_METHOD_TLS) {
42 if (config.wifiEapConfig.identity.empty() ||
43 (config.wifiEapConfig.certEntry.size() == 0 &&
44 (config.wifiEapConfig.clientCert.empty() || config.wifiEapConfig.privateKey.empty()))) {
45 return false;
46 }
47 return true;
48 }
49 if ((config.wifiEapConfig.eap == EAP_METHOD_PEAP) || (config.wifiEapConfig.eap == EAP_METHOD_PWD) ||
50 (config.wifiEapConfig.eap == EAP_METHOD_TTLS)) {
51 if (config.wifiEapConfig.identity.empty() || config.wifiEapConfig.password.empty()) {
52 return false;
53 }
54 return true;
55 }
56 return true;
57 }
58
CheckWapi(const WifiDeviceConfig & config)59 static bool CheckWapi(const WifiDeviceConfig &config)
60 {
61 if (config.keyMgmt == KEY_MGMT_WAPI_PSK) {
62 if (config.wifiWapiConfig.wapiPskType < static_cast<int>(WapiPskType::WAPI_PSK_ASCII) ||
63 config.wifiWapiConfig.wapiPskType > static_cast<int>(WapiPskType::WAPI_PSK_HEX)) {
64 return false;
65 }
66 return true;
67 }
68 if (config.wifiWapiConfig.wapiAsCertData.empty() || config.wifiWapiConfig.wapiUserCertData.empty()) {
69 return false;
70 }
71 return true;
72 }
73
IsWapiOrEap(const WifiDeviceConfig & config)74 static bool IsWapiOrEap(const WifiDeviceConfig &config)
75 {
76 if (config.keyMgmt == KEY_MGMT_WAPI_CERT || config.keyMgmt == KEY_MGMT_WAPI_PSK) {
77 return CheckWapi(config);
78 }
79 if (config.keyMgmt == KEY_MGMT_EAP || config.keyMgmt == KEY_MGMT_SUITE_B_192) {
80 return CheckEap(config);
81 }
82 return false;
83 }
84
WifiAssetValid(const WifiDeviceConfig & config)85 static bool WifiAssetValid(const WifiDeviceConfig &config)
86 {
87 if (config.uid != -1) {
88 LOGD("WifiAssetValid WifiDeviceConfig ssid: %{public}s is not created by user, uid : %{public}d",
89 SsidAnonymize(config.ssid).c_str(), config.uid);
90 return false;
91 }
92 if (IsWapiOrEap(config)) {
93 LOGD("WifiAssetValid WifiDeviceConfig ssid: %{public}s is %{public}s",
94 SsidAnonymize(config.ssid).c_str(), config.keyMgmt.c_str());
95 return false;
96 }
97 return true;
98 }
99
ArrayToWifiDeviceConfig(WifiDeviceConfig & config,std::vector<std::string> & outArray)100 static bool ArrayToWifiDeviceConfig(WifiDeviceConfig &config, std::vector<std::string> &outArray)
101 {
102 if (outArray.size() != SIZE_OF_ITEM) {
103 LOGE("WifiAsset ArrayToWifiDeviceConfig, Error Number Tag Saved In Asset");
104 return false;
105 }
106 size_t index = 0;
107 while (index < outArray.size()) {
108 config.ssid = HexToString(outArray[index++]);
109 config.keyMgmt = HexToString(outArray[index++]);
110 config.preSharedKey = HexToString(outArray[index++]);
111 for (int u = 0; u < WEPKEYS_SIZE; u++) {
112 config.wepKeys[u] = HexToString(outArray[index++]);
113 }
114 config.wepTxKeyIndex = CheckDataLegal(outArray[index++]);
115 config.hiddenSSID = CheckDataLegal(outArray[index++]);
116 config.wifiProxyconfig.manualProxyConfig.serverHostName = HexToString(outArray[index++]);
117 config.wifiProxyconfig.manualProxyConfig.serverPort = CheckDataLegal(outArray[index++]);
118 config.wifiProxyconfig.manualProxyConfig.exclusionObjectList = HexToString(outArray[index++]);
119 config.version = CheckDataLegal(outArray[index++]);
120 }
121 if (config.keyMgmt != KEY_MGMT_NONE && (config.preSharedKey).length() == 0) {
122 LOGE("WifiAsset ArrayToWifiDeviceConfig, ssid : %{public}s psk empty!", SsidAnonymize(config.ssid).c_str());
123 return false;
124 }
125 return true;
126 }
127
WifiAssetTriggerSync()128 void WifiAssetManager::WifiAssetTriggerSync()
129 {
130 AssetValue syncValue = {.u32 = SEC_ASSET_NEED_SYNC};
131 AssetAttr attrMove[] = {
132 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
133 {.tag = SEC_ASSET_TAG_OPERATION_TYPE, .value = syncValue},
134 {.tag = SEC_ASSET_TAG_SYNC_TYPE, .value = g_trustAccountValue},
135 };
136 int32_t ret = 0;
137 AssetResultSet resultSetSingel = {0};
138 /* The AssetQuery function is only used as a synchronous operation */
139 ret = AssetQuery(attrMove, sizeof(attrMove) / sizeof(attrMove[0]), &resultSetSingel);
140 LOGI("WifiAssetTriggerSync ret = %{public}d", ret);
141 AssetFreeResultSet(&resultSetSingel);
142 }
143
WifiAssetAttrAdd(const WifiDeviceConfig & config,bool flagSync=true)144 static int32_t WifiAssetAttrAdd(const WifiDeviceConfig &config, bool flagSync = true)
145 {
146 int32_t ret = SEC_ASSET_INVALID_ARGUMENT;
147 if (config.keyMgmt != KEY_MGMT_NONE && (config.preSharedKey).length() == 0) {
148 LOGE("WifiAssetAttrAdd, ssid : %{public}s psk empty!", SsidAnonymize(config.ssid).c_str());
149 return ret;
150 }
151 std::string aliasId = config.ssid + config.keyMgmt;
152 /* secret */
153 std::string secretWifiDevice = "";
154 secretWifiDevice += StringToHex(config.ssid) + ";";
155 secretWifiDevice += StringToHex(config.keyMgmt) + ";";
156 secretWifiDevice += StringToHex(config.preSharedKey) + ";";
157 for (int i = 0; i < WEPKEYS_SIZE; i++) {
158 secretWifiDevice += StringToHex(config.wepKeys[i]) +";";
159 }
160 secretWifiDevice += std::to_string(config.wepTxKeyIndex) + ";";
161 secretWifiDevice += std::to_string(config.hiddenSSID) + ";";
162 secretWifiDevice += StringToHex(config.wifiProxyconfig.manualProxyConfig.serverHostName) + ";";
163 secretWifiDevice += std::to_string(config.wifiProxyconfig.manualProxyConfig.serverPort) + ";";
164 secretWifiDevice += StringToHex(config.wifiProxyconfig.manualProxyConfig.exclusionObjectList) + ";";
165 secretWifiDevice += std::to_string(config.version);
166 AssetValue secret = {.blob = {static_cast<uint32_t>(secretWifiDevice.size()),
167 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(secretWifiDevice.c_str()))}};
168 AssetValue aliasValue = {.blob = {static_cast<uint32_t>(aliasId.size()),
169 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(aliasId.c_str()))}};
170 AssetValue authTypeValue = {.u32 = SEC_ASSET_AUTH_TYPE_NONE};
171 AssetAttr attr[] = {
172 {.tag = SEC_ASSET_TAG_ALIAS, .value = aliasValue},
173 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
174 {.tag = SEC_ASSET_TAG_AUTH_TYPE, .value = authTypeValue},
175 {.tag = SEC_ASSET_TAG_SECRET, .value = secret},
176 {.tag = SEC_ASSET_TAG_SYNC_TYPE, .value = g_trustAccountValue},
177 };
178 ret = AssetAdd(attr, sizeof(attr) / sizeof(attr[0]));
179 if (flagSync && ret == SEC_ASSET_SUCCESS) {
180 WifiAssetManager::GetInstance().WifiAssetTriggerSync();
181 }
182 return ret;
183 }
184
WifiAssetAttrQuery(const AssetResultSet & resultSet,int32_t userId,std::vector<WifiDeviceConfig> & assetWifiConfig)185 static void WifiAssetAttrQuery(const AssetResultSet &resultSet, int32_t userId,
186 std::vector<WifiDeviceConfig> &assetWifiConfig)
187 {
188 for (uint32_t i = 0; i < resultSet.count; i++) {
189 AssetAttr *checkItem = AssetParseAttr(resultSet.results + i, SEC_ASSET_TAG_ALIAS);
190 if (checkItem == nullptr) {
191 LOGE("WifiAssetAttrQuery ASSET_TAG_ALIAS is nullptr");
192 continue;
193 }
194 std::string strAlias =
195 std::string(reinterpret_cast<const char *>(checkItem->value.blob.data), checkItem->value.blob.size);
196 AssetValue returnValue = {.u32 = SEC_ASSET_RETURN_ALL};
197 AssetValue aliasValue = {.blob = checkItem->value.blob};
198 AssetAttr attrSingle[] = {
199 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
200 {.tag = SEC_ASSET_TAG_ALIAS, .value = aliasValue},
201 {.tag = SEC_ASSET_TAG_RETURN_TYPE, .value = returnValue},
202 };
203 AssetResultSet resultSetSingel = {0};
204 int ret = AssetQuery(attrSingle, sizeof(attrSingle) / sizeof(attrSingle[0]), &resultSetSingel);
205 if (ret != SEC_ASSET_SUCCESS) {
206 LOGE("WifiAssetQuery Failed, ret %{public}d, %{public}s", ret, SsidAnonymize(strAlias).c_str());
207 AssetFreeResultSet(&resultSetSingel);
208 continue;
209 };
210 AssetAttr *checkItemSingle = AssetParseAttr(resultSetSingel.results, SEC_ASSET_TAG_SECRET);
211 if (checkItemSingle == nullptr) {
212 LOGE("WifiAssetParseAttr Failed, ret %{public}d, %{public}s", ret, SsidAnonymize(strAlias).c_str());
213 AssetFreeResultSet(&resultSetSingel);
214 continue;
215 }
216 std::string strSecret = std::string(
217 reinterpret_cast<const char *>(checkItemSingle->value.blob.data), checkItemSingle->value.blob.size);
218 WifiDeviceConfig AssetWifiDeviceConfig;
219 std::vector<std::string> outArray;
220 SplitString(strSecret, ';', outArray);
221 if (ArrayToWifiDeviceConfig(AssetWifiDeviceConfig, outArray)) {
222 assetWifiConfig.push_back(AssetWifiDeviceConfig);
223 }
224 AssetFreeResultSet(&resultSetSingel);
225 }
226 }
227
GetInstance()228 WifiAssetManager &WifiAssetManager::GetInstance()
229 {
230 static WifiAssetManager gWifiAsset;
231 return gWifiAsset;
232 }
233
WifiAssetManager()234 WifiAssetManager::WifiAssetManager()
235 {
236 if (assetServiceThread_ == nullptr) {
237 assetServiceThread_ = std::make_unique<WifiEventHandler>("WifiEventAddAsset");
238 }
239 staCallback_.callbackModuleName = WIFI_ASSET_NETWORK_ON_SYNC;
240 staCallback_.OnStaConnChanged = [&](OperateResState state, const WifiLinkedInfo &info, int instId) {
241 this->DealStaConnChanged(state, info, instId);
242 };
243 firstSync_.store(false);
244 }
245
~WifiAssetManager()246 WifiAssetManager::~WifiAssetManager()
247 {
248 if (assetServiceThread_ != nullptr) {
249 assetServiceThread_.reset();
250 }
251 }
252
InitUpLoadLocalDeviceSync()253 void WifiAssetManager::InitUpLoadLocalDeviceSync()
254 {
255 if (firstSync_.load()) {
256 LOGE("WifiAssetManager, local data is sync");
257 return;
258 }
259 WifiSettings::GetInstance().UpLoadLocalDeviceConfigToCloud();
260 }
261
CloudAssetSync()262 void WifiAssetManager::CloudAssetSync()
263 {
264 if (!(firstSync_.load())) {
265 LOGE("WifiAssetManager, local data not sync");
266 return;
267 }
268 WifiAssetQuery(USER_ID_DEFAULT);
269 }
270
WifiAssetAdd(const WifiDeviceConfig & config,int32_t userId,bool flagSync)271 void WifiAssetManager::WifiAssetAdd(const WifiDeviceConfig &config, int32_t userId, bool flagSync)
272 {
273 if (!WifiAssetValid(config) || !assetServiceThread_) {
274 return;
275 }
276 assetServiceThread_->PostAsyncTask([=]() {
277 int32_t ret = WifiAssetAttrAdd(config, flagSync);
278 if (ret != SEC_ASSET_SUCCESS && ret != SEC_ASSET_DUPLICATED) {
279 LOGE("WifiAssetAdd Failed, ret: %{public}d, ssid: %{public}s", ret, SsidAnonymize(config.ssid).c_str());
280 } else {
281 LOGI("WifiAssetAdd Success, ssid : %{public}s", SsidAnonymize(config.ssid).c_str());
282 }
283 });
284 }
285
WifiAssetQuery(int32_t userId)286 void WifiAssetManager::WifiAssetQuery(int32_t userId)
287 {
288 if (!assetServiceThread_) {
289 LOGE("WifiAssetQuery, assetServiceThread_ is null");
290 return;
291 }
292 assetServiceThread_->PostAsyncTask([=]() {
293 int32_t ret = 0;
294 AssetValue returnValue = {.u32 = SEC_ASSET_RETURN_ATTRIBUTES};
295 AssetAttr attrQu[] = {
296 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
297 {.tag = SEC_ASSET_TAG_RETURN_TYPE, .value = returnValue},
298 };
299 AssetResultSet resultSet = {0};
300 LOGI("WifiAssetQuery start");
301 ret = AssetQuery(attrQu, sizeof(attrQu) / sizeof(attrQu[0]), &resultSet);
302 if (ret != SEC_ASSET_SUCCESS) {
303 LOGE("WifiAssetQuery Failed, Error Code is %{public}d", ret);
304 AssetFreeResultSet(&resultSet);
305 return;
306 };
307 std::vector<WifiDeviceConfig> assetWifiConfig;
308 if (resultSet.count != 0) {
309 WifiAssetAttrQuery(resultSet, userId, assetWifiConfig);
310 } else {
311 LOGE("WifiAssetQuery empty!");
312 }
313 AssetFreeResultSet(&resultSet);
314 std::set<int> wifiLinkedNetworkIds = WifiConfigCenter::GetInstance().GetAllWifiLinkedNetworkId();
315 WifiSettings::GetInstance().UpdateWifiConfigFromCloud(assetWifiConfig, wifiLinkedNetworkIds);
316 WifiSettings::GetInstance().SyncDeviceConfig();
317 });
318 }
319
WifiAssetUpdate(const WifiDeviceConfig & config,int32_t userId)320 void WifiAssetManager::WifiAssetUpdate(const WifiDeviceConfig &config, int32_t userId)
321 {
322 WifiAssetRemove(config, userId, false);
323 WifiAssetAdd(config, userId, true);
324 }
325
WifiAssetRemove(const WifiDeviceConfig & config,int32_t userId,bool flagSync)326 void WifiAssetManager::WifiAssetRemove(const WifiDeviceConfig &config, int32_t userId, bool flagSync)
327 {
328 if (!(WifiAssetValid(config)) || !assetServiceThread_) {
329 return;
330 }
331 assetServiceThread_->PostAsyncTask([=]() {
332 std::string aliasId = config.ssid + config.keyMgmt;
333 AssetValue aliasValue = {.blob = {static_cast<uint32_t>(aliasId.size()),
334 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(aliasId.c_str()))}};
335 int32_t ret = 0;
336 AssetAttr attrMove[] = {
337 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
338 {.tag = SEC_ASSET_TAG_ALIAS, .value = aliasValue},
339 };
340 ret = AssetRemove(attrMove, sizeof(attrMove) / sizeof(attrMove[0]));
341 if (ret != SEC_ASSET_SUCCESS) {
342 LOGE("WifiAssetRemove Failed, ret: %{public}d, %{public}s", ret, SsidAnonymize(config.ssid).c_str());
343 } else {
344 LOGI("WifiAssetRemove Success, ssid : %{public}s", SsidAnonymize(config.ssid).c_str());
345 }
346 if (flagSync) {
347 WifiAssetTriggerSync();
348 }
349 });
350 }
351
WifiAssetAddPack(const std::vector<WifiDeviceConfig> & wifiDeviceConfigs,int32_t userId,bool flagSync,bool firstSync)352 void WifiAssetManager::WifiAssetAddPack(const std::vector<WifiDeviceConfig> &wifiDeviceConfigs,
353 int32_t userId, bool flagSync, bool firstSync)
354 {
355 if (!assetServiceThread_) {
356 LOGE("WifiAssetAddPack, assetServiceThread_ is null");
357 return;
358 }
359 if (wifiDeviceConfigs.size() == 0) {
360 LOGI("WifiAssetAddPack, pack is null");
361 if (firstSync) {
362 firstSync_.store(true);
363 }
364 return;
365 }
366 assetServiceThread_->PostAsyncTask([=]() {
367 for (auto mapConfig : wifiDeviceConfigs) {
368 if (!WifiAssetValid(mapConfig)) {
369 continue;
370 }
371 int32_t ret = WifiAssetAttrAdd(mapConfig, false);
372 if (ret != SEC_ASSET_SUCCESS && ret != SEC_ASSET_DUPLICATED) {
373 LOGE("WifiAssetAddPack Failed, ret: %{public}d, ssid : %{public}s", ret,
374 SsidAnonymize(mapConfig.ssid).c_str());
375 } else {
376 LOGI("WifiAssetAddPack Success, ssid : %{public}s", SsidAnonymize(mapConfig.ssid).c_str());
377 }
378 }
379 if (flagSync) {
380 WifiAssetTriggerSync();
381 }
382 if (firstSync) {
383 firstSync_.store(true);
384 }
385 });
386 }
387
WifiAssetRemovePackInner(const std::vector<WifiDeviceConfig> & wifiDeviceConfigs,int32_t userId,bool flagSync)388 static void WifiAssetRemovePackInner(const std::vector<WifiDeviceConfig> &wifiDeviceConfigs,
389 int32_t userId, bool flagSync)
390 {
391 for (auto mapConfig: wifiDeviceConfigs) {
392 if (!WifiAssetValid(mapConfig)) {
393 continue;
394 }
395 std::string aliasId = mapConfig.ssid + mapConfig.keyMgmt;
396 AssetValue aliasValue = {.blob = {static_cast<uint32_t>(aliasId.size()),
397 const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(aliasId.c_str()))}};
398 AssetAttr attrMove[] = {
399 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
400 {.tag = SEC_ASSET_TAG_ALIAS, .value = aliasValue},
401 };
402 int32_t ret = AssetRemove(attrMove, sizeof(attrMove) / sizeof(attrMove[0]));
403 if (ret != SEC_ASSET_SUCCESS) {
404 LOGE("WifiAssetRemovePackInner Failed, ret: %{public}d, ssid : %{public}s", ret,
405 SsidAnonymize(mapConfig.ssid).c_str());
406 } else {
407 LOGI("WifiAssetRemovePackInner Success, ssid : %{public}s", SsidAnonymize(mapConfig.ssid).c_str());
408 }
409 }
410 if (flagSync) {
411 WifiAssetManager::GetInstance().WifiAssetTriggerSync();
412 }
413 }
414
WifiAssetUpdatePack(const std::vector<WifiDeviceConfig> & wifiDeviceConfigs,int32_t userId)415 void WifiAssetManager::WifiAssetUpdatePack(const std::vector<WifiDeviceConfig> &wifiDeviceConfigs, int32_t userId)
416 {
417 WifiAssetRemovePack(wifiDeviceConfigs, userId, false);
418 WifiAssetAddPack(wifiDeviceConfigs, userId, true);
419 }
420
WifiAssetRemovePack(const std::vector<WifiDeviceConfig> & wifiDeviceConfigs,int32_t userId,bool flagSync)421 void WifiAssetManager::WifiAssetRemovePack(const std::vector<WifiDeviceConfig> &wifiDeviceConfigs,
422 int32_t userId, bool flagSync)
423 {
424 if (!assetServiceThread_ || wifiDeviceConfigs.size() == 0) {
425 return;
426 }
427 assetServiceThread_->PostAsyncTask([=]() { WifiAssetRemovePackInner(wifiDeviceConfigs, userId, flagSync); });
428 }
429
WifiAssetRemoveAll(int32_t userId,bool flagSync)430 void WifiAssetManager::WifiAssetRemoveAll(int32_t userId, bool flagSync)
431 {
432 if (!assetServiceThread_) {
433 return;
434 }
435 assetServiceThread_->PostAsyncTask([=]() {
436 int32_t ret = 0;
437 AssetAttr attrMove[] = {
438 {.tag = SEC_ASSET_TAG_USER_ID, .value = g_userIdValue},
439 };
440 ret = AssetRemove(attrMove, sizeof(attrMove) / sizeof(attrMove[0]));
441 if (ret != SEC_ASSET_SUCCESS) {
442 LOGE("WifiAssetRemoveAll Failed, Error Code is %{public}d", ret);
443 } else {
444 LOGI("WifiAssetRemoveAll Success");
445 }
446 if (flagSync) {
447 WifiAssetTriggerSync();
448 }
449 });
450 }
IsWifiConfigUpdated(const std::vector<WifiDeviceConfig> newWifiDeviceConfigs,WifiDeviceConfig & config)451 bool WifiAssetManager::IsWifiConfigUpdated(const std::vector<WifiDeviceConfig> newWifiDeviceConfigs,
452 WifiDeviceConfig &config)
453 {
454 if (!WifiAssetValid(config)) {
455 return true;
456 }
457 for (auto iter : newWifiDeviceConfigs) {
458 if (config.ssid != iter.ssid || config.keyMgmt != iter.keyMgmt) {
459 continue;
460 }
461 if (IsWifiConfigChanged(iter, config)) {
462 config.preSharedKey = iter.preSharedKey;
463 config.hiddenSSID = iter.hiddenSSID;
464 config.wepTxKeyIndex = iter.wepTxKeyIndex;
465 for (int u = 0; u < WEPKEYS_SIZE; u++) {
466 config.wepKeys[u] = iter.wepKeys[u];
467 }
468 config.wifiProxyconfig.manualProxyConfig.serverHostName =
469 iter.wifiProxyconfig.manualProxyConfig.serverHostName;
470
471 config.wifiProxyconfig.manualProxyConfig.serverPort =
472 iter.wifiProxyconfig.manualProxyConfig.serverPort;
473
474 config.wifiProxyconfig.manualProxyConfig.exclusionObjectList =
475 iter.wifiProxyconfig.manualProxyConfig.exclusionObjectList;
476 config.version = 0;
477 LOGI("WifiAsset IsWifiConfigUpdated, ssid : %{public}s, psksize : %{public}d",
478 SsidAnonymize(config.ssid).c_str(), static_cast<int>((config.preSharedKey).length()));
479 }
480 return true;
481 }
482 return false;
483 }
484
IsWifiConfigChanged(const WifiDeviceConfig & config,const WifiDeviceConfig & oriConfig)485 bool WifiAssetManager::IsWifiConfigChanged(const WifiDeviceConfig &config, const WifiDeviceConfig &oriConfig)
486 {
487 if (!WifiAssetValid(config)) {
488 return false;
489 }
490 if (config.ssid != oriConfig.ssid || config.keyMgmt != oriConfig.keyMgmt) {
491 return true;
492 }
493 if (config.preSharedKey != oriConfig.preSharedKey || config.hiddenSSID != oriConfig.hiddenSSID) {
494 return true;
495 }
496 if (config.wepTxKeyIndex != oriConfig.wepTxKeyIndex) {
497 return true;
498 }
499
500 for (int u = 0; u < WEPKEYS_SIZE; u++) {
501 if (config.wepKeys[u] != oriConfig.wepKeys[u]) {
502 return true;
503 }
504 }
505
506 if (config.wifiProxyconfig.manualProxyConfig.serverHostName !=
507 oriConfig.wifiProxyconfig.manualProxyConfig.serverHostName) {
508 return true;
509 }
510
511 if (config.wifiProxyconfig.manualProxyConfig.serverPort !=
512 oriConfig.wifiProxyconfig.manualProxyConfig.serverPort) {
513 return true;
514 }
515
516 if (config.wifiProxyconfig.manualProxyConfig.exclusionObjectList !=
517 oriConfig.wifiProxyconfig.manualProxyConfig.exclusionObjectList) {
518 return true;
519 }
520 return false;
521 }
522
GetStaCallback() const523 StaServiceCallback WifiAssetManager::GetStaCallback() const
524 {
525 return staCallback_;
526 }
527
DealStaConnChanged(OperateResState state,const WifiLinkedInfo & info,int instId)528 void WifiAssetManager::DealStaConnChanged(OperateResState state, const WifiLinkedInfo &info, int instId)
529 {
530 if (state == OperateResState::CONNECT_AP_CONNECTED) {
531 LOGI("WifiAsset network connected");
532 if (info.networkId != currentConnectedNetworkId_ &&
533 system::GetParameter("persist.wifi.is_connect_from_user", "") == "1") {
534 WifiAssetTriggerSync();
535 }
536 currentConnectedNetworkId_ = info.networkId;
537 } else if (state == OperateResState::DISCONNECT_DISCONNECTED) {
538 currentConnectedNetworkId_ = -1;
539 }
540 }
541 } // namespace Wifi
542 } // namespace OHOS
543 #endif