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