• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "lnn_data_cloud_sync.h"
17 
18 #include <securec.h>
19 #include <stdlib.h>
20 
21 #include "anonymizer.h"
22 #include "g_enhance_lnn_func.h"
23 #include "g_enhance_lnn_func_pack.h"
24 #include "lnn_async_callback_utils.h"
25 #include "lnn_decision_db.h"
26 #include "lnn_distributed_net_ledger.h"
27 #include "lnn_heartbeat_utils.h"
28 #include "lnn_kv_adapter_wrapper.h"
29 #include "lnn_local_net_ledger.h"
30 #include "lnn_log.h"
31 #include "lnn_map.h"
32 #include "lnn_node_info.h"
33 #include "lnn_p2p_info.h"
34 #include "softbus_adapter_json.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_adapter_thread.h"
37 #include "softbus_error_code.h"
38 #include "softbus_json_utils.h"
39 #include "softbus_utils.h"
40 #include "softbus_init_common.h"
41 
42 #define APPID                "dsoftbus"
43 #define STOREID              "dsoftbus_kv_db"
44 #define FIELDNAME_MAX_LEN    32
45 #define KEY_MAX_LEN          128
46 #define SPLIT_MAX_LEN        128
47 #define SPLIT_KEY_NUM        3
48 #define SPLIT_VALUE_NUM      3
49 #define PUT_VALUE_MAX_LEN    156
50 #define UDID_HASH_HEX_LEN    16
51 #define SOFTBUS_STRTOLL_BASE 10
52 
53 static int32_t g_dbId = 0;
54 
55 typedef struct {
56     int32_t stateVersion;
57     uint64_t timestamp;
58 } CloudSyncValue;
59 
DBCipherInfoSyncToCache(NodeInfo * cacheInfo,char * fieldName,const char * value,size_t valueLength,const char * udid)60 static int32_t DBCipherInfoSyncToCache(
61     NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength, const char *udid)
62 {
63     if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0 && valueLength < SESSION_KEY_STR_LEN) {
64         if (ConvertHexStringToBytes((unsigned char *)cacheInfo->cipherInfo.key, SESSION_KEY_LENGTH, value,
65             valueLength) != SOFTBUS_OK) {
66             LNN_LOGE(LNN_BUILDER, "convert cipherkey to bytes fail. cipher info sync to cache fail");
67             return SOFTBUS_KV_CONVERT_BYTES_FAILED;
68         }
69     } else if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0 && valueLength < BROADCAST_IV_STR_LEN) {
70         if (ConvertHexStringToBytes((unsigned char *)cacheInfo->cipherInfo.iv, BROADCAST_IV_LEN, value,
71             valueLength) != SOFTBUS_OK) {
72             LNN_LOGE(LNN_BUILDER, "convert cipheriv to bytes fail. cipher info sync to cache fail");
73             return SOFTBUS_KV_CONVERT_BYTES_FAILED;
74         }
75     } else if (strcmp(fieldName, DEVICE_INFO_JSON_BROADCAST_KEY_TABLE) == 0) {
76         LnnSetRemoteBroadcastCipherInfoPacked(value, udid);
77     } else if (strcmp(fieldName, DEVICE_INFO_DISTRIBUTED_SWITCH) == 0) {
78         LNN_LOGD(LNN_BUILDER, "distributed switch info no need update into nodeinfo");
79     } else {
80         char *anonyFieldName = NULL;
81         Anonymize(fieldName, &anonyFieldName);
82         LNN_LOGE(LNN_BUILDER, "fail:cipher info %{public}s valuelength over range", AnonymizeWrapper(anonyFieldName));
83         AnonymizeFree(anonyFieldName);
84         return SOFTBUS_INVALID_PARAM;
85     }
86     LNN_LOGD(LNN_BUILDER, "success.");
87     return SOFTBUS_OK;
88 }
89 
DBDeviceNameInfoSyncToCache(NodeInfo * cacheInfo,char * fieldName,const char * value,size_t valueLength)90 static int32_t DBDeviceNameInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
91 {
92     if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
93         if (strcpy_s(cacheInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, value) != EOK) {
94             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s devicename fail");
95             return SOFTBUS_STRCPY_ERR;
96         }
97         char *anonyDeviceName = NULL;
98         AnonymizeDeviceName(cacheInfo->deviceInfo.deviceName, &anonyDeviceName);
99         LNN_LOGI(LNN_BUILDER, "success. deviceName=%{public}s", AnonymizeWrapper(anonyDeviceName));
100         AnonymizeFree(anonyDeviceName);
101     } else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
102         if (strcpy_s(cacheInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, value) != EOK) {
103             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifiedname fail");
104             return SOFTBUS_STRCPY_ERR;
105         }
106     } else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
107         if (strcpy_s(cacheInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, value) != EOK) {
108             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifieddefaultname fail");
109             return SOFTBUS_STRCPY_ERR;
110         }
111     } else if (strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
112         if (strcpy_s(cacheInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, value) != EOK) {
113             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s nickname fail");
114             return SOFTBUS_STRCPY_ERR;
115         }
116     } else {
117         LNN_LOGE(LNN_BUILDER, "fail:device basicinfo valuelength over range");
118         return SOFTBUS_INVALID_PARAM;
119     }
120     return SOFTBUS_OK;
121 }
122 
DBDeviceBasicInfoSyncToCache(NodeInfo * cacheInfo,char * fieldName,const char * value,size_t valueLength)123 static int32_t DBDeviceBasicInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
124 {
125     int32_t ret = SOFTBUS_OK;
126     if (strcmp(fieldName, DEVICE_INFO_DEVICE_UDID) == 0 && valueLength < UDID_BUF_LEN) {
127         if (strcpy_s(cacheInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, value) != EOK) {
128             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s deviceUdid fail");
129             return SOFTBUS_STRCPY_ERR;
130         }
131         char *anonyUdid = NULL;
132         Anonymize(cacheInfo->deviceInfo.deviceUdid, &anonyUdid);
133         LNN_LOGI(LNN_BUILDER, "success, udid=%{public}s", AnonymizeWrapper(anonyUdid));
134         AnonymizeFree(anonyUdid);
135     } else if (strcmp(fieldName, DEVICE_INFO_DEVICE_TYPE) == 0) {
136         cacheInfo->deviceInfo.deviceTypeId = atoi(value);
137     } else if (strcmp(fieldName, DEVICE_INFO_OS_TYPE) == 0) {
138         cacheInfo->deviceInfo.osType = atoi(value);
139     } else if (strcmp(fieldName, DEVICE_INFO_OS_VERSION) == 0 && valueLength < OS_VERSION_BUF_LEN) {
140         if (strcpy_s(cacheInfo->deviceInfo.osVersion, OS_VERSION_BUF_LEN, value) != EOK) {
141             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s osVersion fail");
142             return SOFTBUS_STRCPY_ERR;
143         }
144     } else if (strcmp(fieldName, DEVICE_INFO_DEVICE_UUID) == 0 && valueLength < UUID_BUF_LEN) {
145         if (strcpy_s(cacheInfo->uuid, UUID_BUF_LEN, value) != EOK) {
146             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s uuid fail");
147             return SOFTBUS_STRCPY_ERR;
148         }
149         char *anoyUuid = NULL;
150         Anonymize(cacheInfo->uuid, &anoyUuid);
151         LNN_LOGI(LNN_BUILDER, "success, uuid=%{public}s", AnonymizeWrapper(anoyUuid));
152         AnonymizeFree(anoyUuid);
153     } else if ((ret = DBDeviceNameInfoSyncToCache(cacheInfo, fieldName, value, valueLength)) != SOFTBUS_OK) {
154         LNN_LOGE(LNN_BUILDER, "fail:DB device name info sync to cache fail");
155         return ret;
156     }
157     LNN_LOGD(LNN_BUILDER, "success.");
158     return SOFTBUS_OK;
159 }
160 
DBNumInfoSyncToCache(NodeInfo * cacheInfo,char * fieldName,const char * value)161 static int32_t DBNumInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value)
162 {
163     if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0) {
164         cacheInfo->stateVersion = atoi(value);
165         LNN_LOGI(LNN_BUILDER, "success. stateVersion=%{public}d", cacheInfo->stateVersion);
166     } else if (strcmp(fieldName, DEVICE_INFO_TRANSPORT_PROTOCOL) == 0) {
167         cacheInfo->supportedProtocols = atoll(value);
168     } else if (strcmp(fieldName, DEVICE_INFO_WIFI_VERSION) == 0) {
169         cacheInfo->wifiVersion = atoll(value);
170     } else if (strcmp(fieldName, DEVICE_INFO_BLE_VERSION) == 0) {
171         cacheInfo->bleVersion = atoll(value);
172     } else if (strcmp(fieldName, DEVICE_INFO_ACCOUNT_ID) == 0) {
173         cacheInfo->accountId = atoll(value);
174     } else if (strcmp(fieldName, DEVICE_INFO_FEATURE) == 0) {
175         cacheInfo->feature = (uint64_t)atoll(value);
176         LNN_LOGI(LNN_BUILDER, "success. feature=%{public}" PRIu64 "", cacheInfo->feature);
177     } else if (strcmp(fieldName, DEVICE_INFO_CONN_SUB_FEATURE) == 0) {
178         cacheInfo->connSubFeature = atoll(value);
179         LNN_LOGI(LNN_BUILDER, "success. connSubFeature=%{public}" PRIu64 "", cacheInfo->connSubFeature);
180     } else if (strcmp(fieldName, DEVICE_INFO_AUTH_CAP) == 0) {
181         cacheInfo->authCapacity = (uint32_t)atoi(value);
182         LNN_LOGI(LNN_BUILDER, "success. authCapacity=%{public}u", cacheInfo->authCapacity);
183     } else if (strcmp(fieldName, DEVICE_INFO_HB_CAP) == 0) {
184         cacheInfo->heartbeatCapacity = (uint32_t)atoi(value);
185         LNN_LOGI(LNN_BUILDER, "success. heartbeatCapacity=%{public}u", cacheInfo->heartbeatCapacity);
186     } else if (strcmp(fieldName, DEVICE_INFO_SLE_RANGE_CAP) == 0) {
187         cacheInfo->sleRangeCapacity = (uint32_t)atoi(value);
188         LNN_LOGI(LNN_BUILDER, "success. sleRangeCapacity=%{public}u", cacheInfo->sleRangeCapacity);
189     }
190     LNN_LOGD(LNN_BUILDER, "success.");
191     return SOFTBUS_OK;
192 }
193 
DBConnectMacInfoSyncToCache(NodeInfo * cacheInfo,char * fieldName,const char * value,size_t valueLength)194 static int32_t DBConnectMacInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
195 {
196     if (strcmp(fieldName, DEVICE_INFO_BT_MAC) == 0 && valueLength < MAC_LEN) {
197         if (strcpy_s(cacheInfo->connectInfo.macAddr, MAC_LEN, value) != EOK) {
198             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s macAddress fail");
199             return SOFTBUS_STRCPY_ERR;
200         }
201     } else if (strcmp(fieldName, DEVICE_INFO_P2P_MAC_ADDR) == 0 && valueLength < MAC_LEN) {
202         if (strcpy_s(cacheInfo->p2pInfo.p2pMac, MAC_LEN, value) != EOK) {
203             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s p2pMac fail");
204             return SOFTBUS_STRCPY_ERR;
205         }
206     } else if (strcmp(fieldName, DEVICE_INFO_DEVICE_IRK) == 0 && valueLength < LFINDER_IRK_STR_LEN) {
207         if (ConvertHexStringToBytes((unsigned char *)cacheInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN, value,
208             valueLength) != SOFTBUS_OK) {
209             LNN_LOGE(LNN_BUILDER, "convert peerIrk to bytes fail. rpa info sync to cache fail");
210             return SOFTBUS_KV_CONVERT_BYTES_FAILED;
211         }
212     } else if (strcmp(fieldName, DEVICE_INFO_DEVICE_PUB_MAC) == 0 && valueLength < LFINDER_MAC_ADDR_STR_LEN) {
213         if (ConvertHexStringToBytes((unsigned char *)cacheInfo->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, value,
214             valueLength) != SOFTBUS_OK) {
215             LNN_LOGE(LNN_BUILDER, "convert publicAddress to bytes fail. rpa info sync to cache fail");
216             return SOFTBUS_KV_CONVERT_BYTES_FAILED;
217         }
218     } else if (strcmp(fieldName, DEVICE_INFO_SLE_ADDR) == 0 && valueLength < LFINDER_MAC_ADDR_STR_LEN) {
219         if (strcpy_s(cacheInfo->connectInfo.sleMacAddr, MAC_LEN, value) != EOK) {
220             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s sleMacAddr fail");
221             return SOFTBUS_STRCPY_ERR;
222         }
223     } else {
224         char *anonyFieldName = NULL;
225         Anonymize(fieldName, &anonyFieldName);
226         LNN_LOGE(LNN_BUILDER, "fail:connect info %{public}s valuelength over range", AnonymizeWrapper(anonyFieldName));
227         AnonymizeFree(anonyFieldName);
228         return SOFTBUS_INVALID_PARAM;
229     }
230     return SOFTBUS_OK;
231 }
232 
DBConnectInfoSyncToCache(NodeInfo * cacheInfo,char * fieldName,const char * value,size_t valueLength)233 static int32_t DBConnectInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
234 {
235     int32_t ret = SOFTBUS_OK;
236     if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0 && valueLength < NETWORK_ID_BUF_LEN) {
237         if (strcpy_s(cacheInfo->networkId, NETWORK_ID_BUF_LEN, value) != EOK) {
238             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s networkid fail");
239             return SOFTBUS_STRCPY_ERR;
240         }
241         char *anonyNetworkId = NULL;
242         Anonymize(cacheInfo->networkId, &anonyNetworkId);
243         LNN_LOGI(LNN_BUILDER, "success. networkId=%{public}s", AnonymizeWrapper(anonyNetworkId));
244         AnonymizeFree(anonyNetworkId);
245     } else if (strcmp(fieldName, DEVICE_INFO_PKG_VERSION) == 0 && valueLength < VERSION_MAX_LEN) {
246         if (strcpy_s(cacheInfo->pkgVersion, VERSION_MAX_LEN, value) != EOK) {
247             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s pkgVersion fail");
248             return SOFTBUS_STRCPY_ERR;
249         }
250     } else if (strcmp(fieldName, DEVICE_INFO_SW_VERSION) == 0 && valueLength < VERSION_MAX_LEN) {
251         if (strcpy_s(cacheInfo->softBusVersion, VERSION_MAX_LEN, value) != EOK) {
252             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s softbusVersion fail");
253             return SOFTBUS_STRCPY_ERR;
254         }
255     } else if ((ret = DBConnectMacInfoSyncToCache(cacheInfo, fieldName, value, valueLength)) != SOFTBUS_OK) {
256         LNN_LOGE(LNN_BUILDER, "fail:DB ConnectMacInfo Sync To Cache fail");
257         return ret;
258     }
259     LNN_LOGD(LNN_BUILDER, "success.");
260     return SOFTBUS_OK;
261 }
262 
JudgeFieldNameIsDeviceBasicInfo(char * fieldName)263 static bool JudgeFieldNameIsDeviceBasicInfo(char *fieldName)
264 {
265     if (fieldName == NULL) {
266         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
267         return false;
268     }
269     if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0 || strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0 ||
270         strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0 ||
271         strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0 || strcmp(fieldName, DEVICE_INFO_DEVICE_UDID) == 0 ||
272         strcmp(fieldName, DEVICE_INFO_DEVICE_TYPE) == 0 || strcmp(fieldName, DEVICE_INFO_OS_TYPE) == 0 ||
273         strcmp(fieldName, DEVICE_INFO_OS_VERSION) == 0 || strcmp(fieldName, DEVICE_INFO_DEVICE_UUID) == 0) {
274         return true;
275     }
276     return false;
277 }
278 
JudgeFieldNameIsNumInfo(char * fieldName)279 static bool JudgeFieldNameIsNumInfo(char *fieldName)
280 {
281     if (fieldName == NULL) {
282         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
283         return false;
284     }
285     if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0 || strcmp(fieldName, DEVICE_INFO_TRANSPORT_PROTOCOL) == 0 ||
286         strcmp(fieldName, DEVICE_INFO_WIFI_VERSION) == 0 || strcmp(fieldName, DEVICE_INFO_BLE_VERSION) == 0 ||
287         strcmp(fieldName, DEVICE_INFO_ACCOUNT_ID) == 0 || strcmp(fieldName, DEVICE_INFO_FEATURE) == 0 ||
288         strcmp(fieldName, DEVICE_INFO_CONN_SUB_FEATURE) == 0 || strcmp(fieldName, DEVICE_INFO_AUTH_CAP) == 0 ||
289         strcmp(fieldName, DEVICE_INFO_SLE_RANGE_CAP) == 0) {
290         return true;
291     }
292     return false;
293 }
294 
JudgeFieldNameIsConnectInfo(char * fieldName)295 static bool JudgeFieldNameIsConnectInfo(char *fieldName)
296 {
297     if (fieldName == NULL) {
298         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
299         return false;
300     }
301     if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0 || strcmp(fieldName, DEVICE_INFO_PKG_VERSION) == 0 ||
302         strcmp(fieldName, DEVICE_INFO_BT_MAC) == 0 || strcmp(fieldName, DEVICE_INFO_P2P_MAC_ADDR) == 0 ||
303         strcmp(fieldName, DEVICE_INFO_DEVICE_IRK) == 0 || strcmp(fieldName, DEVICE_INFO_DEVICE_PUB_MAC) == 0 ||
304         strcmp(fieldName, DEVICE_INFO_PTK) == 0 || strcmp(fieldName, DEVICE_INFO_SW_VERSION) == 0 ||
305         strcmp(fieldName, DEVICE_INFO_SLE_ADDR) == 0) {
306         return true;
307     }
308     return false;
309 }
310 
JudgeFieldNameIsCipherInfo(char * fieldName)311 static bool JudgeFieldNameIsCipherInfo(char *fieldName)
312 {
313     if (fieldName == NULL) {
314         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
315         return false;
316     }
317     if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0 ||
318         strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0 ||
319         strcmp(fieldName, DEVICE_INFO_JSON_BROADCAST_KEY_TABLE) == 0 ||
320         strcmp(fieldName, DEVICE_INFO_JSON_KEY_TOTAL_LIFE) == 0 ||
321         strcmp(fieldName, DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN) == 0 ||
322         strcmp(fieldName, DEVICE_INFO_JSON_KEY_CURRENT_INDEX) == 0 ||
323         strcmp(fieldName, DEVICE_INFO_DISTRIBUTED_SWITCH) == 0) {
324         return true;
325     }
326     return false;
327 }
328 
DBDataChangeBatchSyncToCacheInternal(NodeInfo * cacheInfo,char * fieldName,const char * value,size_t valueLength,const char * udid)329 static int32_t DBDataChangeBatchSyncToCacheInternal(
330     NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength, const char *udid)
331 {
332     if (cacheInfo == NULL || fieldName == NULL || value == NULL || udid == NULL || strlen(udid) > UDID_BUF_LEN - 1) {
333         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
334         return SOFTBUS_INVALID_PARAM;
335     }
336     int32_t ret = SOFTBUS_OK;
337     if (JudgeFieldNameIsDeviceBasicInfo(fieldName)) {
338         ret = DBDeviceBasicInfoSyncToCache(cacheInfo, fieldName, value, valueLength);
339         if (ret != SOFTBUS_OK) {
340             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s device basic info to cache fail");
341             return ret;
342         }
343     } else if (JudgeFieldNameIsNumInfo(fieldName)) {
344         ret = DBNumInfoSyncToCache(cacheInfo, fieldName, value);
345         if (ret != SOFTBUS_OK) {
346             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s device name fail");
347             return ret;
348         }
349     } else if (JudgeFieldNameIsConnectInfo(fieldName)) {
350         ret = DBConnectInfoSyncToCache(cacheInfo, fieldName, value, valueLength);
351         if (ret != SOFTBUS_OK) {
352             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s connect info fail");
353             return ret;
354         }
355     } else if (JudgeFieldNameIsCipherInfo(fieldName)) {
356         ret = DBCipherInfoSyncToCache(cacheInfo, fieldName, value, valueLength, udid);
357         if (ret != SOFTBUS_OK) {
358             LNN_LOGE(LNN_BUILDER, "fail:strcpy_s cipher info fail");
359             return ret;
360         }
361     } else if (strcmp(fieldName, DEVICE_INFO_BLE_P2P) == 0) {
362         if (strcmp(value, "true") == 0) {
363             cacheInfo->isBleP2p = true;
364         } else {
365             cacheInfo->isBleP2p = false;
366         }
367     } else {
368         LNN_LOGE(LNN_BUILDER, "fail:invalid fieldname");
369         return SOFTBUS_INVALID_PARAM;
370     }
371     return SOFTBUS_OK;
372 }
373 
SplitKeyOrValue(const char * key,char splitKeyValue[][SPLIT_MAX_LEN],int32_t size)374 static int32_t SplitKeyOrValue(const char *key, char splitKeyValue[][SPLIT_MAX_LEN], int32_t size)
375 {
376     if (key == NULL || splitKeyValue == NULL) {
377         LNN_LOGE(LNN_BUILDER, "key or splitKeyValue is NULL");
378         return SOFTBUS_INVALID_PARAM;
379     }
380     int index = 0;
381     char *infoStr = NULL;
382     char *nextToken = NULL;
383     char tmp[PUT_VALUE_MAX_LEN] = { 0 };
384     if (strcpy_s(tmp, PUT_VALUE_MAX_LEN, key) != EOK) {
385         LNN_LOGE(LNN_BUILDER, "strcpy_s key fail");
386         return SOFTBUS_STRCPY_ERR;
387     }
388     infoStr = strtok_s(tmp, "#", &nextToken);
389     while (infoStr != NULL) {
390         if (index > size - 1) {
391             LNN_LOGD(LNN_BUILDER, "index over range");
392             break;
393         }
394         if (strcpy_s(splitKeyValue[index++], SPLIT_MAX_LEN, infoStr) != EOK) {
395             LNN_LOGE(LNN_BUILDER, "strcpy_s SplitKeyOrValue fail");
396             return SOFTBUS_STRCPY_ERR;
397         }
398         infoStr = strtok_s(NULL, "#", &nextToken);
399     }
400     return SOFTBUS_OK;
401 }
402 
GetInfoFromSplitKey(char splitKey[][SPLIT_MAX_LEN],int64_t * accountId,char * deviceUdid,char * fieldName)403 static int32_t GetInfoFromSplitKey(
404     char splitKey[][SPLIT_MAX_LEN], int64_t *accountId, char *deviceUdid, char *fieldName)
405 {
406     if (splitKey == NULL || accountId == NULL || deviceUdid == NULL || fieldName == NULL) {
407         LNN_LOGE(LNN_BUILDER, "invalid param");
408         return SOFTBUS_INVALID_PARAM;
409     }
410     *accountId = atol(splitKey[0]);
411     if (strcpy_s(deviceUdid, UDID_BUF_LEN, splitKey[1]) != EOK) {
412         LNN_LOGE(LNN_BUILDER, "fail:strcpy_s deviceUdid fail.");
413         return SOFTBUS_STRCPY_ERR;
414     }
415     if (strcpy_s(fieldName, FIELDNAME_MAX_LEN, splitKey[SPLIT_VALUE_NUM - 1]) != EOK) {
416         LNN_LOGE(LNN_BUILDER, "fail:strcpy_s fieldName fail.");
417         return SOFTBUS_STRCPY_ERR;
418     }
419     return SOFTBUS_OK;
420 }
421 
SplitString(char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN],char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN],const char * key,const char * value,CloudSyncValue * parseValue)422 static int32_t SplitString(char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN], char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN],
423     const char *key, const char *value, CloudSyncValue *parseValue)
424 {
425     if (key == NULL || value == NULL || splitKey == NULL || splitValue == NULL || parseValue == NULL) {
426         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
427         return SOFTBUS_INVALID_PARAM;
428     }
429     int32_t ret = SplitKeyOrValue(key, splitKey, SPLIT_KEY_NUM);
430     if (ret != SOFTBUS_OK) {
431         LNN_LOGE(LNN_BUILDER, "split key error");
432         return ret;
433     }
434     ret = SplitKeyOrValue(value, splitValue, SPLIT_VALUE_NUM);
435     if (ret != SOFTBUS_OK) {
436         LNN_LOGE(LNN_BUILDER, "split value error");
437         return ret;
438     }
439     parseValue->stateVersion = atoi(splitValue[1]);
440     parseValue->timestamp = strtoull(splitValue[SPLIT_VALUE_NUM - 1], NULL, SOFTBUS_STRTOLL_BASE);
441     return SOFTBUS_OK;
442 }
443 
HandleDBAddChangeInternal(const char * key,const char * value,NodeInfo * cacheInfo)444 static int32_t HandleDBAddChangeInternal(const char *key, const char *value, NodeInfo *cacheInfo)
445 {
446     LNN_LOGD(LNN_BUILDER, "enter.");
447     if (key == NULL || value == NULL) {
448         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
449         return SOFTBUS_INVALID_PARAM;
450     }
451     int32_t ret = SOFTBUS_OK;
452     int64_t accountId = 0;
453     char deviceUdid[UDID_BUF_LEN] = { 0 };
454     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
455     CloudSyncValue parseValue = { 0 };
456     char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN] = { 0 };
457     char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN] = { 0 };
458     ret = SplitString(splitKey, splitValue, key, value, &parseValue);
459     if (ret != SOFTBUS_OK) {
460         LNN_LOGE(LNN_BUILDER, "split string error");
461         return ret;
462     }
463     ret = GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName);
464     if (ret != SOFTBUS_OK) {
465         LNN_LOGE(LNN_BUILDER, "get info from splitkey error");
466         return ret;
467     }
468     char trueValue[SPLIT_MAX_LEN] = { 0 };
469     if (strcpy_s(trueValue, SPLIT_MAX_LEN, splitValue[0]) != EOK) {
470         LNN_LOGE(LNN_BUILDER, "fail:strcpy_s true value fail.");
471         return SOFTBUS_STRCPY_ERR;
472     }
473     NodeInfo localCacheInfo = { 0 };
474     ret = LnnGetLocalCacheNodeInfoPacked(&localCacheInfo);
475     if (ret != SOFTBUS_OK) {
476         LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
477         return ret;
478     }
479     if (strcmp(deviceUdid, localCacheInfo.deviceInfo.deviceUdid) == 0) {
480         return SOFTBUS_OK;
481     }
482     ret = DBDataChangeBatchSyncToCacheInternal(cacheInfo, fieldName, trueValue, strlen(trueValue), deviceUdid);
483     if (ret != SOFTBUS_OK) {
484         LNN_LOGE(LNN_BUILDER, "fail:DB data change batch sync to cache fail");
485         return ret;
486     }
487     cacheInfo->localStateVersion = localCacheInfo.stateVersion;
488     cacheInfo->updateTimestamp = parseValue.timestamp;
489     return SOFTBUS_OK;
490 }
491 
SetDBNameDataToDLedger(NodeInfo * cacheInfo,char * deviceUdid,char * fieldName)492 static int32_t SetDBNameDataToDLedger(NodeInfo *cacheInfo, char *deviceUdid, char *fieldName)
493 {
494     if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0) {
495         if (!LnnSetDLDeviceInfoName(deviceUdid, cacheInfo->deviceInfo.deviceName)) {
496             LNN_LOGE(LNN_BUILDER, "set device name to distributedLedger fail");
497             return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
498         }
499     } else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0) {
500         if (LnnSetDLUnifiedDeviceName(deviceUdid, cacheInfo->deviceInfo.unifiedName) != SOFTBUS_OK) {
501             LNN_LOGE(LNN_BUILDER, "set device unifiedName to distributedLedger fail");
502             return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
503         }
504     } else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0) {
505         if (LnnSetDLUnifiedDefaultDeviceName(deviceUdid, cacheInfo->deviceInfo.unifiedDefaultName) != SOFTBUS_OK) {
506             LNN_LOGE(LNN_BUILDER, "set device unifiedDefaultName to distributedLedger fail");
507             return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
508         }
509     } else if (strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0) {
510         if (LnnSetDLDeviceNickNameByUdid(deviceUdid, cacheInfo->deviceInfo.nickName) != SOFTBUS_OK) {
511             LNN_LOGE(LNN_BUILDER, "set device nickName to distributedLedger fail");
512             return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
513         }
514     } else {
515         char *anonyFieldName = NULL;
516         Anonymize(fieldName, &anonyFieldName);
517         LNN_LOGD(LNN_BUILDER, "%{public}s no need update to DLedger", AnonymizeWrapper(anonyFieldName));
518         AnonymizeFree(anonyFieldName);
519         return SOFTBUS_OK;
520     }
521     return SOFTBUS_OK;
522 }
523 
SetDBDataToDistributedLedger(NodeInfo * cacheInfo,char * deviceUdid,size_t udidLength,char * fieldName)524 static int32_t SetDBDataToDistributedLedger(NodeInfo *cacheInfo, char *deviceUdid, size_t udidLength, char *fieldName)
525 {
526     if (cacheInfo == NULL || deviceUdid == NULL || udidLength > UDID_BUF_LEN - 1 || fieldName == NULL) {
527         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
528         return SOFTBUS_INVALID_PARAM;
529     }
530     int32_t ret = SOFTBUS_OK;
531     if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0) {
532         ret = LnnSetDLDeviceBroadcastCipherKey(deviceUdid, cacheInfo->cipherInfo.key);
533         if (ret != SOFTBUS_OK) {
534             LNN_LOGE(LNN_BUILDER, "set device cipherkey to distributedLedger fail");
535             return ret;
536         }
537     } else if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0) {
538         ret = LnnSetDLDeviceBroadcastCipherIv(deviceUdid, cacheInfo->cipherInfo.iv);
539         if (ret != SOFTBUS_OK) {
540             LNN_LOGE(LNN_BUILDER, "set device cipheriv to distributedLedger fail");
541             return ret;
542         }
543     } else if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0) {
544         ret = LnnUpdateNetworkId(cacheInfo);
545         if (ret != SOFTBUS_OK) {
546             LNN_LOGE(LNN_BUILDER, "set device networkId to distributedLedger fail");
547             return ret;
548         }
549     } else if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0) {
550         ret = LnnSetDLDeviceStateVersion(deviceUdid, cacheInfo->stateVersion);
551         if (ret != SOFTBUS_OK) {
552             LNN_LOGE(LNN_BUILDER, "set device stateversion to distributedLedger fail");
553             return ret;
554         }
555     } else if ((ret = SetDBNameDataToDLedger(cacheInfo, deviceUdid, fieldName)) != SOFTBUS_OK) {
556         LNN_LOGE(LNN_BUILDER, "set DB name data to distributedLedger fail");
557         return ret;
558     }
559     return SOFTBUS_OK;
560 }
561 
UpdateInfoToLedger(NodeInfo * cacheInfo,char * deviceUdid,char * fieldName,char * value)562 static void UpdateInfoToLedger(NodeInfo *cacheInfo, char *deviceUdid, char *fieldName, char *value)
563 {
564     LNN_LOGI(LNN_BUILDER, "enter");
565     if (cacheInfo == NULL || deviceUdid == NULL || strlen(deviceUdid) > UDID_BUF_LEN - 1 || fieldName == NULL ||
566         value == NULL) {
567         LNN_LOGE(LNN_BUILDER, "fail:invalid param");
568         return;
569     }
570     if (DBDataChangeBatchSyncToCacheInternal(cacheInfo, fieldName, value, strlen(value), deviceUdid) != SOFTBUS_OK) {
571         LNN_LOGE(LNN_BUILDER, "fail:DB data change sync to cache fail");
572         return;
573     }
574     if (SetDBDataToDistributedLedger(cacheInfo, deviceUdid, strlen(deviceUdid), fieldName) != SOFTBUS_OK) {
575         LNN_LOGE(LNN_BUILDER, "set DB data to distributedLedger fail");
576     }
577 }
578 
IsIgnoreUpdate(int32_t oldStateVersion,uint64_t oldTimestamp,int32_t newStateVersion,uint64_t newTimestamp)579 static bool IsIgnoreUpdate(
580     int32_t oldStateVersion, uint64_t oldTimestamp, int32_t newStateVersion, uint64_t newTimestamp)
581 {
582     bool isIgnore = oldTimestamp > newTimestamp || (oldTimestamp == 0 && oldStateVersion > newStateVersion);
583     if (isIgnore) {
584         LNN_LOGE(LNN_BUILDER,
585             "fail: sync info is older, oldCacheInfo.stateVersion=%{public}d, oldTimestamp=%{public}" PRIu64
586             ", newSyncInfo.stateVersion=%{public}d, newTimestamp=%{public}" PRIu64 "",
587             oldStateVersion, oldTimestamp, newStateVersion, newTimestamp);
588     }
589     return isIgnore;
590 }
591 
HandleDBUpdateInternal(char * deviceUdid,char * fieldName,char * trueValue,const CloudSyncValue * parseValue,int32_t localStateVersion)592 static int32_t HandleDBUpdateInternal(
593     char *deviceUdid, char *fieldName, char *trueValue, const CloudSyncValue *parseValue, int32_t localStateVersion)
594 {
595     if (deviceUdid == NULL || fieldName == NULL || trueValue == NULL) {
596         LNN_LOGE(LNN_BUILDER, "fail:invalid param.");
597         return SOFTBUS_INVALID_PARAM;
598     }
599     char udidHash[UDID_HASH_HEX_LEN + 1] = { 0 };
600     if (LnnGenerateHexStringHash((const unsigned char *)deviceUdid, udidHash, UDID_HASH_HEX_LEN) != SOFTBUS_OK) {
601         LNN_LOGE(LNN_BUILDER, "Generate UDID HexStringHash fail");
602         return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
603     }
604     NodeInfo cacheInfo = { 0 };
605     if (LnnRetrieveDeviceInfoPacked(udidHash, &cacheInfo) != SOFTBUS_OK) {
606         LNN_LOGI(LNN_BUILDER, "no this device info in deviceCacheInfoMap, ignore update");
607         return SOFTBUS_OK;
608     }
609     if (IsIgnoreUpdate(cacheInfo.stateVersion, cacheInfo.updateTimestamp, parseValue->stateVersion,
610         parseValue->timestamp)) {
611         (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
612         return SOFTBUS_OK;
613     }
614     LNN_LOGI(LNN_BUILDER, "update peer stateVersion=%{public}d->%{public}d, localStateVersion=%{public}d->%{public}d",
615         cacheInfo.stateVersion, parseValue->stateVersion, cacheInfo.localStateVersion, localStateVersion);
616     cacheInfo.stateVersion = parseValue->stateVersion;
617     UpdateInfoToLedger(&cacheInfo, deviceUdid, fieldName, trueValue);
618     cacheInfo.localStateVersion = localStateVersion;
619     (void)LnnSaveRemoteDeviceInfoPacked(&cacheInfo);
620     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
621     return SOFTBUS_OK;
622 }
623 
PrintDeviceUdidAndTrueValue(char * deviceUdid,char * fieldName,char * trueValue,int32_t stateVersion)624 static void PrintDeviceUdidAndTrueValue(char *deviceUdid, char *fieldName, char *trueValue, int32_t stateVersion)
625 {
626     char *anonyDeviceUdid = NULL;
627     Anonymize(deviceUdid, &anonyDeviceUdid);
628     char *anonyTrueValue = NULL;
629     Anonymize(trueValue, &anonyTrueValue);
630     LNN_LOGI(LNN_BUILDER,
631         "deviceUdid=%{public}s, fieldName=%{public}s update to %{public}s success, stateVersion=%{public}d",
632         AnonymizeWrapper(anonyDeviceUdid), fieldName, AnonymizeWrapper(anonyTrueValue), stateVersion);
633     AnonymizeFree(anonyDeviceUdid);
634     AnonymizeFree(anonyTrueValue);
635 }
636 
HandleDBUpdateChangeInternal(const char * key,const char * value)637 static int32_t HandleDBUpdateChangeInternal(const char *key, const char *value)
638 {
639     if (key == NULL || value == NULL) {
640         LNN_LOGE(LNN_BUILDER, "fail:invalid param.");
641         return SOFTBUS_INVALID_PARAM;
642     }
643     int32_t ret = SOFTBUS_OK;
644     int64_t accountId = 0;
645     char deviceUdid[UDID_BUF_LEN] = { 0 };
646     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
647     CloudSyncValue parseValue = { 0 };
648     char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN] = { 0 };
649     char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN] = { 0 };
650     if (SplitString(splitKey, splitValue, key, value, &parseValue) != SOFTBUS_OK) {
651         LNN_LOGE(LNN_BUILDER, "split string error");
652         return SOFTBUS_SPLIT_STRING_FAIL;
653     }
654     ret = GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName);
655     if (ret != SOFTBUS_OK) {
656         LNN_LOGE(LNN_BUILDER, "get info from splitkey error");
657         return ret;
658     }
659     NodeInfo localCacheInfo = { 0 };
660     ret = LnnGetLocalCacheNodeInfoPacked(&localCacheInfo);
661     if (ret != SOFTBUS_OK) {
662         LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
663         return ret;
664     }
665     if (strcmp(deviceUdid, localCacheInfo.deviceInfo.deviceUdid) == 0) {
666         return SOFTBUS_OK;
667     }
668     char trueValue[SPLIT_MAX_LEN] = { 0 };
669     if (strcpy_s(trueValue, SPLIT_MAX_LEN, splitValue[0]) != EOK) {
670         LNN_LOGE(LNN_BUILDER, "fail:strcpy_s true value fail.");
671         return SOFTBUS_STRCPY_ERR;
672     }
673     ret = HandleDBUpdateInternal(deviceUdid, fieldName, trueValue, &parseValue, localCacheInfo.stateVersion);
674     if (ret != SOFTBUS_OK) {
675         LNN_LOGE(LNN_BUILDER, "handle DB update change internal fail");
676         (void)memset_s(trueValue, strlen(trueValue), 0, strlen(trueValue));
677         return ret;
678     }
679     PrintDeviceUdidAndTrueValue(deviceUdid, fieldName, trueValue, parseValue.stateVersion);
680     (void)memset_s(trueValue, strlen(trueValue), 0, strlen(trueValue));
681     return SOFTBUS_OK;
682 }
683 
HandleDBDeleteChangeInternal(const char * key,const char * value)684 static int32_t HandleDBDeleteChangeInternal(const char *key, const char *value)
685 {
686     (void)value;
687     if (key == NULL) {
688         LNN_LOGE(LNN_BUILDER, "fail:invalid param key");
689         return SOFTBUS_INVALID_PARAM;
690     }
691     int64_t accountId = 0;
692     char deviceUdid[UDID_BUF_LEN] = { 0 };
693     char fieldName[FIELDNAME_MAX_LEN] = { 0 };
694     char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN] = { 0 };
695     int32_t ret = SplitKeyOrValue(key, splitKey, SPLIT_KEY_NUM);
696     if (ret != SOFTBUS_OK) {
697         LNN_LOGE(LNN_BUILDER, "split key error");
698         return ret;
699     }
700     ret = GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName);
701     if (ret != SOFTBUS_OK) {
702         LNN_LOGE(LNN_BUILDER, "get info from splitkey error");
703         return ret;
704     }
705     char udidHash[UDID_HASH_HEX_LEN + 1] = { 0 };
706     if (LnnGenerateHexStringHash((const unsigned char *)deviceUdid, udidHash, UDID_HASH_HEX_LEN) != SOFTBUS_OK) {
707         LNN_LOGE(LNN_BUILDER, "Generate UDID HexStringHash fail");
708         return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
709     }
710     NodeInfo cacheInfo = { 0 };
711     if (LnnRetrieveDeviceInfoPacked(udidHash, &cacheInfo) != SOFTBUS_OK) {
712         LNN_LOGI(LNN_BUILDER, "no device info in deviceCacheInfoMap, no need to delete");
713         return SOFTBUS_OK;
714     }
715 
716     LnnDeleteDeviceInfoPacked(deviceUdid);
717     LnnRemoveNode(deviceUdid);
718     LNN_LOGI(LNN_BUILDER, "success");
719     return SOFTBUS_OK;
720 }
721 
FreeKeyAndValue(const char ** key,const char ** value,int32_t keySize)722 static void FreeKeyAndValue(const char **key, const char **value, int32_t keySize)
723 {
724     for (int32_t i = 0; i < keySize; i++) {
725         SoftBusFree((void *)key[i]);
726         SoftBusFree((void *)value[i]);
727     }
728     SoftBusFree(key);
729     SoftBusFree(value);
730 }
731 
FreeKeyOrValue(const char ** object,int32_t size)732 static void FreeKeyOrValue(const char **object, int32_t size)
733 {
734     for (int32_t i = 0; i < size; i++) {
735         SoftBusFree((void *)object[i]);
736     }
737     SoftBusFree(object);
738 }
739 
CheckParamValidity(const char ** key,const char ** value,int32_t keySize)740 static int32_t CheckParamValidity(const char **key, const char **value, int32_t keySize)
741 {
742     if (key == NULL || value == NULL || keySize == 0) {
743         LNN_LOGE(LNN_BUILDER, "invalid param or keySize is none");
744         if (key == NULL && value != NULL && keySize != 0) {
745             FreeKeyOrValue(value, keySize);
746         } else if (key != NULL && value == NULL && keySize != 0) {
747             FreeKeyOrValue(key, keySize);
748         }
749         return SOFTBUS_INVALID_PARAM;
750     }
751     return SOFTBUS_OK;
752 }
753 
LnnDBDataAddChangeSyncToCache(const char ** key,const char ** value,int32_t keySize)754 int32_t LnnDBDataAddChangeSyncToCache(const char **key, const char **value, int32_t keySize)
755 {
756     int32_t ret = CheckParamValidity(key, value, keySize);
757     if (ret != SOFTBUS_OK) {
758         return ret;
759     }
760     NodeInfo cacheInfo = { 0 };
761     for (int32_t i = 0; i < keySize; i++) {
762         ret = HandleDBAddChangeInternal(key[i], value[i], &cacheInfo);
763         if (ret != SOFTBUS_OK) {
764             LNN_LOGE(LNN_BUILDER, "fail:handle db data add change internal fail");
765             FreeKeyAndValue(key, value, keySize);
766             (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
767             return ret;
768         }
769     }
770     FreeKeyAndValue(key, value, keySize);
771     char udidHash[UDID_HASH_HEX_LEN + 1] = { 0 };
772     if (LnnGenerateHexStringHash((const unsigned char *)cacheInfo.deviceInfo.deviceUdid, udidHash, UDID_HASH_HEX_LEN) !=
773         SOFTBUS_OK) {
774         LNN_LOGE(LNN_BUILDER, "Generate UDID HexStringHash fail");
775         return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
776     }
777     NodeInfo oldCacheInfo = { 0 };
778     if (LnnRetrieveDeviceInfoPacked(udidHash, &oldCacheInfo) == SOFTBUS_OK &&
779         IsIgnoreUpdate(oldCacheInfo.stateVersion, oldCacheInfo.updateTimestamp, cacheInfo.stateVersion,
780             cacheInfo.updateTimestamp)) {
781         return SOFTBUS_KV_IGNORE_OLD_DEVICE_INFO;
782     }
783     (void)LnnSaveRemoteDeviceInfoPacked(&cacheInfo);
784     char *anonyUdid = NULL;
785     Anonymize(cacheInfo.deviceInfo.deviceUdid, &anonyUdid);
786     LNN_LOGI(LNN_BUILDER,
787         "success. udid=%{public}s, stateVersion=%{public}d, localStateVersion=%{public}d, updateTimestamp=%{public}"
788         "" PRIu64, AnonymizeWrapper(anonyUdid), cacheInfo.stateVersion, cacheInfo.localStateVersion,
789         cacheInfo.updateTimestamp);
790     AnonymizeFree(anonyUdid);
791     ret = LnnUpdateDistributedNodeInfo(&cacheInfo, cacheInfo.deviceInfo.deviceUdid);
792     if (ret != SOFTBUS_OK) {
793         LNN_LOGE(LNN_BUILDER, "fail:Cache info add sync to Ledger fail");
794         (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
795         return ret;
796     }
797     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
798     return SOFTBUS_OK;
799 }
800 
PrintSyncNodeInfoEx(const NodeInfo * cacheInfo)801 static void PrintSyncNodeInfoEx(const NodeInfo *cacheInfo)
802 {
803     char *anonyProductId = NULL;
804     Anonymize(cacheInfo->deviceInfo.productId, &anonyProductId);
805     char *anonyModelName = NULL;
806     Anonymize(cacheInfo->deviceInfo.modelName, &anonyModelName);
807     LNN_LOGI(LNN_BUILDER,
808         "Sync NodeInfoEx: BROADCAST_CIPHER_KEY=%{public}02x, BROADCAST_CIPHER_IV=%{public}02x, IRK=%{public}02x,"
809         " PUB_MAC=%{public}02x, PTK=%{public}02x, PRODUCT_ID=%{public}s, MODEL_NAME=%{public}s, "
810         "SLE_CAP=%{public}d",
811         *cacheInfo->cipherInfo.key, *cacheInfo->cipherInfo.iv, *cacheInfo->rpaInfo.peerIrk,
812         *cacheInfo->rpaInfo.publicAddress, *cacheInfo->remotePtk,
813         AnonymizeWrapper(anonyProductId), AnonymizeWrapper(anonyModelName), cacheInfo->sleRangeCapacity);
814     AnonymizeFree(anonyProductId);
815     AnonymizeFree(anonyModelName);
816 }
817 
PrintSyncNodeInfo(const NodeInfo * cacheInfo)818 static void PrintSyncNodeInfo(const NodeInfo *cacheInfo)
819 {
820     LNN_CHECK_AND_RETURN_LOGE(cacheInfo != NULL, LNN_BUILDER, "invalid param");
821     char accountId[INT64_TO_STR_MAX_LEN] = {0};
822     if (!Int64ToString(cacheInfo->accountId, accountId, INT64_TO_STR_MAX_LEN)) {
823         LNN_LOGE(LNN_BUILDER, "accountId to str fail");
824     }
825     char *anonyAccountId = NULL;
826     Anonymize(accountId, &anonyAccountId);
827     char *anonyP2pMac = NULL;
828     Anonymize(cacheInfo->p2pInfo.p2pMac, &anonyP2pMac);
829     char *anonyMacAddr = NULL;
830     Anonymize(cacheInfo->connectInfo.macAddr, &anonyMacAddr);
831     char *anonyUdid = NULL;
832     Anonymize(cacheInfo->deviceInfo.deviceUdid, &anonyUdid);
833     char *anonyUuid = NULL;
834     Anonymize(cacheInfo->uuid, &anonyUuid);
835     char *anonyNetworkId = NULL;
836     Anonymize(cacheInfo->networkId, &anonyNetworkId);
837     char *anonyDeviceName = NULL;
838     AnonymizeDeviceName(cacheInfo->deviceInfo.deviceName, &anonyDeviceName);
839     LNN_LOGI(LNN_BUILDER,
840         "Sync NodeInfo: WIFI_VERSION=%{public}" PRId64 ", BLE_VERSION=%{public}" PRId64 ", ACCOUNT_ID=%{public}s, "
841         "TRANSPORT_PROTOCOL=%{public}" PRIu64 ", FEATURE=%{public}" PRIu64 ", CONN_SUB_FEATURE=%{public}" PRIu64 ", "
842         "TIMESTAMP=%{public}" PRIu64 ", P2P_MAC_ADDR=%{public}s, PKG_VERSION=%{public}s, DEVICE_NAME=%{public}s, "
843         "STATIC_NET_CAP=%{public}u, AUTH_CAP=%{public}u, HB_CAP=%{public}u, OS_TYPE=%{public}d, OS_VERSION=%{public}s, "
844         "BLE_P2P=%{public}d, BT_MAC=%{public}s, DEVICE_TYPE=%{public}d, SW_VERSION=%{public}s, DEVICE_UDID=%{public}s, "
845         "DEVICE_UUID=%{public}s, STATE_VERSION=%{public}d, NETWORK_ID=%{public}s",
846         cacheInfo->wifiVersion, cacheInfo->bleVersion, AnonymizeWrapper(anonyAccountId), cacheInfo->supportedProtocols,
847         cacheInfo->feature, cacheInfo->connSubFeature, cacheInfo->updateTimestamp, AnonymizeWrapper(anonyP2pMac),
848         cacheInfo->pkgVersion, AnonymizeWrapper(anonyDeviceName), cacheInfo->staticNetCap, cacheInfo->authCapacity,
849         cacheInfo->heartbeatCapacity, cacheInfo->deviceInfo.osType, cacheInfo->deviceInfo.osVersion,
850         cacheInfo->isBleP2p, AnonymizeWrapper(anonyMacAddr), cacheInfo->deviceInfo.deviceTypeId,
851         cacheInfo->softBusVersion, AnonymizeWrapper(anonyUdid), AnonymizeWrapper(anonyUuid), cacheInfo->stateVersion,
852         AnonymizeWrapper(anonyNetworkId));
853     AnonymizeFree(anonyAccountId);
854     AnonymizeFree(anonyP2pMac);
855     AnonymizeFree(anonyMacAddr);
856     AnonymizeFree(anonyUdid);
857     AnonymizeFree(anonyUuid);
858     AnonymizeFree(anonyNetworkId);
859     AnonymizeFree(anonyDeviceName);
860     PrintSyncNodeInfoEx(cacheInfo);
861 }
862 
UpdateDeviceNameToCache(const NodeInfo * newInfo,NodeInfo * oldInfo)863 static void UpdateDeviceNameToCache(const NodeInfo *newInfo, NodeInfo *oldInfo)
864 {
865     if (strlen(newInfo->deviceInfo.deviceName) != 0) {
866         if (strcpy_s(oldInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.deviceName) != EOK) {
867             LNN_LOGE(LNN_LEDGER, "strcpy_s deviceName to cache info fail");
868         }
869     }
870     if (strlen(newInfo->deviceInfo.unifiedName) != 0) {
871         if (strcpy_s(oldInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.unifiedName) != EOK) {
872             LNN_LOGE(LNN_LEDGER, "strcpy_s unifiedName to cache info fail");
873         }
874     }
875     if (strlen(newInfo->deviceInfo.unifiedDefaultName) != 0) {
876         if (strcpy_s(oldInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN,
877             newInfo->deviceInfo.unifiedDefaultName) != EOK) {
878             LNN_LOGE(LNN_LEDGER, "strcpy_s unifiedDefaultName to cache info fail");
879         }
880     }
881     if (strlen(newInfo->deviceInfo.nickName) != 0) {
882         if (strcpy_s(oldInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.nickName) != EOK) {
883             LNN_LOGE(LNN_LEDGER, "strcpy_s nickName to cache info fail");
884         }
885     }
886 }
887 
UpdateDevBasicInfoToCache(const NodeInfo * newInfo,NodeInfo * oldInfo)888 static void UpdateDevBasicInfoToCache(const NodeInfo *newInfo, NodeInfo *oldInfo)
889 {
890     UpdateDeviceNameToCache(newInfo, oldInfo);
891     if (strcpy_s(oldInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, newInfo->deviceInfo.deviceUdid) != EOK) {
892         LNN_LOGE(LNN_LEDGER, "strcpy_s deviceUdid to cache info fail");
893     }
894     if (strcpy_s(oldInfo->deviceInfo.deviceVersion, DEVICE_VERSION_SIZE_MAX, newInfo->deviceInfo.deviceVersion) !=
895         EOK) {
896         LNN_LOGE(LNN_LEDGER, "strcpy_s deviceVersion to cache info fail");
897     }
898     if (strcpy_s(oldInfo->uuid, UUID_BUF_LEN, newInfo->uuid) != EOK) {
899         LNN_LOGE(LNN_LEDGER, "strcpy_s uuid to cache info fail");
900     }
901     if (strcpy_s(oldInfo->networkId, NETWORK_ID_BUF_LEN, newInfo->networkId) != EOK) {
902         LNN_LOGE(LNN_LEDGER, "strcpy_s networkid to cache info fail");
903     }
904     if (strcpy_s(oldInfo->deviceInfo.productId, PRODUCT_ID_SIZE_MAX, newInfo->deviceInfo.productId) != EOK) {
905         LNN_LOGE(LNN_LEDGER, "strcpy_s productId to cache info fail");
906     }
907     if (strcpy_s(oldInfo->deviceInfo.modelName, MODEL_NAME_SIZE_MAX, newInfo->deviceInfo.modelName) != EOK) {
908         LNN_LOGE(LNN_LEDGER, "strcpy_s modelName to cache info fail");
909     }
910     oldInfo->deviceInfo.deviceTypeId = newInfo->deviceInfo.deviceTypeId;
911     oldInfo->isBleP2p = newInfo->isBleP2p;
912     oldInfo->supportedProtocols = newInfo->supportedProtocols;
913     oldInfo->wifiVersion = newInfo->wifiVersion;
914     oldInfo->bleVersion = newInfo->bleVersion;
915     oldInfo->accountId = newInfo->accountId;
916     oldInfo->feature = newInfo->feature;
917     oldInfo->connSubFeature = newInfo->connSubFeature;
918     oldInfo->authCapacity = newInfo->authCapacity;
919     oldInfo->deviceInfo.osType = newInfo->deviceInfo.osType;
920     oldInfo->updateTimestamp = newInfo->updateTimestamp;
921     oldInfo->deviceSecurityLevel = newInfo->deviceSecurityLevel;
922     oldInfo->heartbeatCapacity = newInfo->heartbeatCapacity;
923     oldInfo->staticNetCap = newInfo->staticNetCap;
924     if (LnnFindDeviceUdidTrustedInfoFromDb(newInfo->deviceInfo.deviceUdid) != SOFTBUS_OK) {
925         oldInfo->stateVersion = newInfo->stateVersion;
926         oldInfo->localStateVersion = newInfo->localStateVersion;
927     }
928 }
929 
LnnUpdateOldCacheInfo(const NodeInfo * newInfo,NodeInfo * oldInfo)930 static int32_t LnnUpdateOldCacheInfo(const NodeInfo *newInfo, NodeInfo *oldInfo)
931 {
932     if (newInfo == NULL || oldInfo == NULL) {
933         LNN_LOGE(LNN_LEDGER, "param error");
934         return SOFTBUS_INVALID_PARAM;
935     }
936     if (strcpy_s(oldInfo->softBusVersion, VERSION_MAX_LEN, newInfo->softBusVersion) != EOK) {
937         LNN_LOGE(LNN_LEDGER, "strcpy_s softBusVersion to cache info fail");
938     }
939     if (strcpy_s(oldInfo->pkgVersion, VERSION_MAX_LEN, newInfo->pkgVersion) != EOK) {
940         LNN_LOGE(LNN_LEDGER, "strcpy_s pkgVersion to cache info fail");
941     }
942     if (strcpy_s(oldInfo->connectInfo.macAddr, MAC_LEN, newInfo->connectInfo.macAddr) != EOK) {
943         LNN_LOGE(LNN_LEDGER, "strcpy_s macAddr to cache info fail");
944     }
945     if (strcpy_s(oldInfo->deviceInfo.osVersion, OS_VERSION_BUF_LEN, newInfo->deviceInfo.osVersion) != EOK) {
946         LNN_LOGE(LNN_LEDGER, "strcpy_s osVersion to cache info fail");
947     }
948     if (strcpy_s(oldInfo->p2pInfo.p2pMac, MAC_LEN, newInfo->p2pInfo.p2pMac) != EOK) {
949         LNN_LOGE(LNN_LEDGER, "strcpy_s p2pMac to cache info fail");
950     }
951     if (strcpy_s(oldInfo->accountUid, ACCOUNT_UID_STR_LEN, newInfo->accountUid) != EOK) {
952         LNN_LOGE(LNN_LEDGER, "strcpy_s accountUid to cache info fail");
953     }
954     if (memcpy_s((char *)oldInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN, (char *)newInfo->rpaInfo.peerIrk,
955         LFINDER_IRK_LEN) != EOK) {
956         LNN_LOGE(LNN_LEDGER, "memcpy_s peerIrk to cache info fail");
957     }
958     if (memcpy_s((char *)oldInfo->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, (char *)newInfo->rpaInfo.publicAddress,
959         LFINDER_MAC_ADDR_LEN) != EOK) {
960         LNN_LOGE(LNN_LEDGER, "memcpy_s publicAddress to cache info fail");
961     }
962     if (memcpy_s((char *)oldInfo->cipherInfo.key, SESSION_KEY_LENGTH, newInfo->cipherInfo.key, SESSION_KEY_LENGTH) !=
963         EOK) {
964         LNN_LOGE(LNN_LEDGER, "memcpy_s cipherInfo key to cache info fail");
965     }
966     if (memcpy_s((char *)oldInfo->cipherInfo.iv, BROADCAST_IV_LEN, newInfo->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
967         LNN_LOGE(LNN_LEDGER, "memcpy_s cipherInfo iv to cache info fail");
968     }
969     if (memcpy_s(oldInfo->remotePtk, PTK_DEFAULT_LEN, newInfo->remotePtk, PTK_DEFAULT_LEN) != EOK) {
970         LNN_LOGE(LNN_LEDGER, "memcpy_s remotePtk to cache info fail");
971     }
972     UpdateDevBasicInfoToCache(newInfo, oldInfo);
973     return SOFTBUS_OK;
974 }
975 
LnnIsdeviceNameChangeAck(NodeInfo * cacheInfo,NodeInfo * oldCacheInfo)976 static void LnnIsdeviceNameChangeAck(NodeInfo *cacheInfo, NodeInfo *oldCacheInfo)
977 {
978     if (strncmp(cacheInfo->deviceInfo.deviceName, oldCacheInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN)!= 0) {
979         NodeInfo info;
980         (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
981         if (LnnGetLocalNodeInfoSafe(&info) != SOFTBUS_OK) {
982             LNN_LOGE(LNN_BUILDER, "save local device info fail");
983             return;
984         }
985         if (LnnLedgerAllDataSyncToDB(&info, true, cacheInfo->deviceInfo.deviceUdid) != SOFTBUS_OK) {
986             LNN_LOGE(LNN_BUILDER, "devicename change ack fail");
987         }
988     }
989 }
990 
LnnSaveAndUpdateDistributedNode(NodeInfo * cacheInfo,NodeInfo * oldCacheInfo)991 static int32_t LnnSaveAndUpdateDistributedNode(NodeInfo *cacheInfo, NodeInfo *oldCacheInfo)
992 {
993     if (cacheInfo == NULL || oldCacheInfo == NULL) {
994         LNN_LOGE(LNN_BUILDER, "invalid param");
995         return SOFTBUS_INVALID_PARAM;
996     }
997     NodeInfo localCacheInfo = { 0 };
998     int32_t ret = LnnGetLocalCacheNodeInfoPacked(&localCacheInfo);
999     if (ret != SOFTBUS_OK || cacheInfo->accountId != localCacheInfo.accountId) {
1000         char accountId[INT64_TO_STR_MAX_LEN] = {0};
1001         char localAccountId[INT64_TO_STR_MAX_LEN] = {0};
1002         if (!Int64ToString(cacheInfo->accountId, accountId, INT64_TO_STR_MAX_LEN)) {
1003             LNN_LOGE(LNN_BUILDER, "accountId to str fail");
1004         }
1005         if (!Int64ToString(localCacheInfo.accountId, localAccountId, INT64_TO_STR_MAX_LEN)) {
1006             LNN_LOGE(LNN_BUILDER, "local accountId to str fail");
1007         }
1008         char *anonyAccountId = NULL;
1009         char *anonyLocalAccountId = NULL;
1010         Anonymize(accountId, &anonyAccountId);
1011         Anonymize(localAccountId, &anonyLocalAccountId);
1012         LNN_LOGE(LNN_BUILDER, "don't set, ret=%{public}d, accountId=%{public}s, local accountId=%{public}s",
1013             ret, AnonymizeWrapper(anonyAccountId), AnonymizeWrapper(anonyLocalAccountId));
1014         AnonymizeFree(anonyAccountId);
1015         AnonymizeFree(anonyLocalAccountId);
1016         return ret;
1017     }
1018     LnnIsdeviceNameChangeAck(cacheInfo, oldCacheInfo);
1019     cacheInfo->localStateVersion = localCacheInfo.stateVersion;
1020     if (LnnUpdateOldCacheInfo(cacheInfo, oldCacheInfo) != SOFTBUS_OK ||
1021         LnnSaveRemoteDeviceInfoPacked(oldCacheInfo) != SOFTBUS_OK) {
1022         LNN_LOGE(LNN_BUILDER, "update cache info fail, use cloud sync data");
1023         (void)LnnSaveRemoteDeviceInfoPacked(cacheInfo);
1024     }
1025     char *anonyUdid = NULL;
1026     Anonymize(cacheInfo->deviceInfo.deviceUdid, &anonyUdid);
1027     LNN_LOGI(LNN_BUILDER,
1028         "success. udid=%{public}s, stateVersion=%{public}d, localStateVersion=%{public}d, updateTimestamp=%{public}"
1029         "" PRIu64, AnonymizeWrapper(anonyUdid), cacheInfo->stateVersion,
1030         cacheInfo->localStateVersion, cacheInfo->updateTimestamp);
1031     AnonymizeFree(anonyUdid);
1032     if (LnnUpdateDistributedNodeInfo(cacheInfo, cacheInfo->deviceInfo.deviceUdid) != SOFTBUS_OK) {
1033         LNN_LOGE(LNN_BUILDER, "fail:Cache info sync to Ledger fail");
1034         return SOFTBUS_MEM_ERR;
1035     }
1036     return SOFTBUS_OK;
1037 }
1038 
LnnDBDataChangeSyncToCacheInner(const char * key,const char * value)1039 int32_t LnnDBDataChangeSyncToCacheInner(const char *key, const char *value)
1040 {
1041     if (key == NULL || value == NULL) {
1042         LNN_LOGE(LNN_BUILDER, "invalid param");
1043         return SOFTBUS_INVALID_PARAM;
1044     }
1045     cJSON *json = cJSON_Parse(value);
1046     if (json == NULL) {
1047         LNN_LOGE(LNN_BUILDER, "parse json fail");
1048         return SOFTBUS_PARSE_JSON_ERR;
1049     }
1050     NodeInfo cacheInfo = { 0 };
1051     int32_t ret = LnnUnPackCloudSyncDeviceInfoPacked(json, &cacheInfo);
1052     if (ret != SOFTBUS_OK) {
1053         cJSON_Delete(json);
1054         return ret;
1055     }
1056     cJSON_Delete(json);
1057     PrintSyncNodeInfo(&cacheInfo);
1058     char udidHash[UDID_HASH_HEX_LEN + 1] = { 0 };
1059     if (LnnGenerateHexStringHash((const unsigned char *)cacheInfo.deviceInfo.deviceUdid, udidHash, UDID_HASH_HEX_LEN) !=
1060         SOFTBUS_OK) {
1061         LNN_LOGE(LNN_BUILDER, "Generate UDID HexStringHash fail");
1062         return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
1063     }
1064     NodeInfo oldCacheInfo = { 0 };
1065     ret = LnnRetrieveDeviceInfoPacked(udidHash, &oldCacheInfo);
1066     if (ret == SOFTBUS_OK && IsIgnoreUpdate(oldCacheInfo.stateVersion, oldCacheInfo.updateTimestamp,
1067         cacheInfo.stateVersion, cacheInfo.updateTimestamp)) {
1068         return SOFTBUS_KV_IGNORE_OLD_DEVICE_INFO;
1069     }
1070     if (ret == SOFTBUS_NETWORK_NOT_FOUND) {
1071         LNN_LOGW(LNN_BUILDER, "not found device");
1072         oldCacheInfo.isAuthExchangeUdid = true;
1073     }
1074     ret = LnnSaveAndUpdateDistributedNode(&cacheInfo, &oldCacheInfo);
1075     if (ret != SOFTBUS_OK) {
1076         LNN_LOGE(LNN_BUILDER, "save and update distribute node info fail");
1077         (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1078         return ret;
1079     }
1080     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1081     return SOFTBUS_OK;
1082 }
1083 
LnnDBDataChangeSyncToCache(const char * key,const char * value,ChangeType changeType)1084 int32_t LnnDBDataChangeSyncToCache(const char *key, const char *value, ChangeType changeType)
1085 {
1086     if (key == NULL) {
1087         LNN_LOGE(LNN_BUILDER, "fail:invalid param key.");
1088         return SOFTBUS_INVALID_PARAM;
1089     }
1090     int32_t ret = SOFTBUS_OK;
1091     switch (changeType) {
1092         case DB_UPDATE:
1093             ret = HandleDBUpdateChangeInternal(key, value);
1094             if (ret != SOFTBUS_OK) {
1095                 LNN_LOGE(LNN_BUILDER, "fail:handle db data update change internal fail");
1096                 return ret;
1097             }
1098             break;
1099         case DB_DELETE:
1100             ret = HandleDBDeleteChangeInternal(key, value);
1101             if (ret != SOFTBUS_OK) {
1102                 LNN_LOGE(LNN_BUILDER, "fail:handle db data delete change internal fail");
1103                 return ret;
1104             }
1105             break;
1106         default:
1107             LNN_LOGE(LNN_BUILDER, "changeType is invalid");
1108             return SOFTBUS_INVALID_PARAM;
1109     }
1110     LNN_LOGD(LNN_BUILDER, "success.");
1111     return SOFTBUS_OK;
1112 }
1113 
LnnLedgerDataChangeSyncToDB(const char * key,const char * value,size_t valueLength)1114 int32_t LnnLedgerDataChangeSyncToDB(const char *key, const char *value, size_t valueLength)
1115 {
1116     if (key == NULL || value == NULL || valueLength > KEY_MAX_LEN - 1) {
1117         LNN_LOGE(LNN_BUILDER, "fail:Ledger param is invalid.");
1118         return SOFTBUS_INVALID_PARAM;
1119     }
1120     NodeInfo localCacheInfo = { 0 };
1121     int32_t ret = LnnGetLocalCacheNodeInfoPacked(&localCacheInfo);
1122     if (ret != SOFTBUS_OK) {
1123         LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
1124         return ret;
1125     }
1126     if (localCacheInfo.accountId == 0) {
1127         LNN_LOGI(LNN_LEDGER, "no account info. no need sync to DB");
1128         return SOFTBUS_OK;
1129     }
1130     uint64_t nowTime = SoftBusGetSysTimeMs();
1131     char putKey[KEY_MAX_LEN] = { 0 };
1132     if (sprintf_s(putKey, KEY_MAX_LEN, "%ld#%s#%s", localCacheInfo.accountId, localCacheInfo.deviceInfo.deviceUdid,
1133         key) < 0) {
1134         LNN_LOGE(LNN_BUILDER, "sprintf_s key fail");
1135         return SOFTBUS_SPRINTF_ERR;
1136     }
1137     char putValue[PUT_VALUE_MAX_LEN] = { 0 };
1138     if (sprintf_s(putValue, PUT_VALUE_MAX_LEN, "%s#%d#%llu", value, localCacheInfo.stateVersion, nowTime) < 0) {
1139         LNN_LOGE(LNN_BUILDER, "sprintf_s value fail");
1140         return SOFTBUS_SPRINTF_ERR;
1141     }
1142 
1143     int32_t dbId = g_dbId;
1144     ret = LnnPutDBData(dbId, putKey, strlen(putKey), putValue, strlen(putValue));
1145     if (ret != SOFTBUS_OK) {
1146         LNN_LOGE(LNN_BUILDER, "fail:data sync to DB fail, errorcode=%{public}d", ret);
1147         return ret;
1148     }
1149     LNN_LOGI(LNN_BUILDER, "Lnn ledger %{public}s change sync to DB success. stateVersion=%{public}d", key,
1150         localCacheInfo.stateVersion);
1151 
1152     ret = LnnCloudSync(dbId);
1153     if (ret != SOFTBUS_OK) {
1154         LNN_LOGE(LNN_BUILDER, "fail:data change cloud sync fail, errorcode=%{public}d", ret);
1155         return ret;
1156     }
1157     return SOFTBUS_OK;
1158 }
1159 
PackBroadcastCipherKeyInner(cJSON * json,NodeInfo * info)1160 static int32_t PackBroadcastCipherKeyInner(cJSON *json, NodeInfo *info)
1161 {
1162     if (LnnPackCloudSyncDeviceInfoPacked(json, info) != SOFTBUS_OK) {
1163         LNN_LOGE(LNN_BUILDER, "pack cloud sync info fail");
1164         return SOFTBUS_KV_CLOUD_SYNC_FAIL;
1165     }
1166     CloudSyncInfo syncInfo = { 0 };
1167     if (LnnGetLocalBroadcastCipherInfoPacked(&syncInfo) != SOFTBUS_OK) {
1168         LNN_LOGE(LNN_BUILDER, "get local cipher info fail");
1169         return SOFTBUS_KV_CLOUD_SYNC_FAIL;
1170     }
1171     if (!AddStringToJsonObject(json, DEVICE_INFO_JSON_BROADCAST_KEY_TABLE, syncInfo.broadcastCipherKey)) {
1172         JSON_Free(syncInfo.broadcastCipherKey);
1173         LNN_LOGE(LNN_BUILDER, "add string info fail");
1174         return SOFTBUS_KV_CLOUD_SYNC_FAIL;
1175     }
1176     JSON_Free(syncInfo.broadcastCipherKey);
1177     return SOFTBUS_OK;
1178 }
1179 
LnnLedgerAllDataSyncToDB(NodeInfo * info,bool isAckSeq,char * peerudid)1180 int32_t LnnLedgerAllDataSyncToDB(NodeInfo *info, bool isAckSeq, char *peerudid)
1181 {
1182     if (info == NULL) {
1183         LNN_LOGE(LNN_BUILDER, "invalid param, info is NULL");
1184         return SOFTBUS_INVALID_PARAM;
1185     }
1186     if (info->accountId == 0) {
1187         LNN_LOGI(LNN_BUILDER, "ledger accountid is null, all data no need sync to cloud");
1188         return SOFTBUS_KV_CLOUD_DISABLED;
1189     }
1190     char putKey[KEY_MAX_LEN] = { 0 };
1191     if (sprintf_s(putKey, KEY_MAX_LEN, "%ld#%s", info->accountId, info->deviceInfo.deviceUdid) < 0) {
1192         return SOFTBUS_MEM_ERR;
1193     }
1194     info->updateTimestamp = SoftBusGetSysTimeMs();
1195     cJSON *json = cJSON_CreateObject();
1196     if (json == NULL) {
1197         return SOFTBUS_CREATE_JSON_ERR;
1198     }
1199     int32_t ret = PackBroadcastCipherKeyInner(json, info);
1200     if (ret != SOFTBUS_OK) {
1201         cJSON_Delete(json);
1202         return ret;
1203     }
1204     if (isAckSeq && peerudid != NULL && (ret = LnnPackCloudSyncAckSeqPacked(json, peerudid)) != SOFTBUS_OK) {
1205         cJSON_Delete(json);
1206         return ret;
1207     }
1208     char *putValue = cJSON_PrintUnformatted(json);
1209     if (putValue == NULL) {
1210         LNN_LOGE(LNN_BUILDER, "cJSON_PrintUnformatted fail");
1211         cJSON_Delete(json);
1212         return SOFTBUS_CREATE_JSON_ERR;
1213     }
1214     cJSON_Delete(json);
1215     int32_t dbId = g_dbId;
1216     LnnSetCloudAbility(true);
1217     ret = LnnPutDBData(dbId, putKey, strlen(putKey), putValue, strlen(putValue));
1218     cJSON_free(putValue);
1219     if (ret != SOFTBUS_OK) {
1220         LNN_LOGE(LNN_BUILDER, "fail:data batch sync to DB fail, errorcode=%{public}d", ret);
1221         return SOFTBUS_KV_PUT_DB_FAIL;
1222     }
1223     LNN_LOGI(LNN_BUILDER, "sync all data to db success. stateVersion=%{public}d", info->stateVersion);
1224     ret = LnnCloudSync(dbId);
1225     if (ret != SOFTBUS_OK) {
1226         LNN_LOGE(LNN_BUILDER, "fail:data batch cloud sync fail, errorcode=%{public}d", ret);
1227     }
1228     return ret;
1229 }
1230 
ProcessSyncToDB(void * para)1231 static void ProcessSyncToDB(void *para)
1232 {
1233     NodeInfo *info = (NodeInfo *)para;
1234     (void)LnnLedgerAllDataSyncToDB(info, false, NULL);
1235     SoftBusFree(info);
1236 }
1237 
LnnAsyncCallLedgerAllDataSyncToDB(NodeInfo * info)1238 int32_t LnnAsyncCallLedgerAllDataSyncToDB(NodeInfo *info)
1239 {
1240     if (info == NULL) {
1241         LNN_LOGE(LNN_LANE, "invalid param");
1242         return SOFTBUS_INVALID_PARAM;
1243     }
1244     NodeInfo *data = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1245     if (data == NULL) {
1246         LNN_LOGE(LNN_LANE, "calloc mem fail!");
1247         return SOFTBUS_MALLOC_ERR;
1248     }
1249     *data = *info;
1250     int32_t rc = LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_LNN), ProcessSyncToDB, data);
1251     if (rc != SOFTBUS_OK) {
1252         SoftBusFree(data);
1253         return rc;
1254     }
1255     return rc;
1256 }
1257 
LnnDeleteSyncToDB(void)1258 int32_t LnnDeleteSyncToDB(void)
1259 {
1260     NodeInfo localCacheInfo = { 0 };
1261     int32_t ret = LnnGetLocalCacheNodeInfoPacked(&localCacheInfo);
1262     if (ret != SOFTBUS_OK) {
1263         LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
1264         return ret;
1265     }
1266     char key[KEY_MAX_LEN] = { 0 };
1267     if (sprintf_s(key, KEY_MAX_LEN, "%ld#%s", localCacheInfo.accountId, localCacheInfo.deviceInfo.deviceUdid) < 0) {
1268         LNN_LOGE(LNN_BUILDER, "sprintf_s key fail");
1269         return SOFTBUS_SPRINTF_ERR;
1270     }
1271 
1272     int32_t dbId = g_dbId;
1273     ret = LnnDeleteDBDataByPrefix(dbId, key, strlen(key));
1274     if (ret != 0) {
1275         LNN_LOGE(LNN_BUILDER, "fail:data delete sync to DB fail");
1276         return ret;
1277     }
1278     LNN_LOGI(LNN_BUILDER, "success.");
1279     ret = LnnCloudSync(dbId);
1280     if (ret != SOFTBUS_OK) {
1281         LNN_LOGE(LNN_BUILDER, "fail:data delete cloud sync fail, errorcode=%{public}d", ret);
1282         return ret;
1283     }
1284     return SOFTBUS_OK;
1285 }
1286 
LnnDeleteDevInfoSyncToDB(const char * udid,int64_t accountId)1287 int32_t LnnDeleteDevInfoSyncToDB(const char *udid, int64_t accountId)
1288 {
1289     if (udid == NULL) {
1290         LNN_LOGE(LNN_LANE, "invalid param");
1291         return SOFTBUS_INVALID_PARAM;
1292     }
1293     char key[KEY_MAX_LEN] = { 0 };
1294     if (sprintf_s(key, KEY_MAX_LEN, "%ld#%s", accountId, udid) < 0) {
1295         LNN_LOGE(LNN_BUILDER, "sprintf_s key fail");
1296         return SOFTBUS_SPRINTF_ERR;
1297     }
1298     int32_t dbId = g_dbId;
1299     int32_t ret = LnnDeleteDBDataByPrefix(dbId, key, strlen(key));
1300     if (ret != SOFTBUS_OK) {
1301         LNN_LOGE(LNN_BUILDER, "fail:data delete sync to DB fail");
1302         return ret;
1303     }
1304     ret = LnnCloudSync(dbId);
1305     if (ret != SOFTBUS_OK) {
1306         LNN_LOGE(LNN_BUILDER, "fail:data delete cloud sync fail, errorcode=%{public}d", ret);
1307         return ret;
1308     }
1309     char *anonyUdid = NULL;
1310     Anonymize(udid, &anonyUdid);
1311     LNN_LOGI(LNN_BUILDER, "delete udid=%{public}s success.", AnonymizeWrapper(anonyUdid));
1312     AnonymizeFree(anonyUdid);
1313     return SOFTBUS_OK;
1314 }
1315 
LnnSetCloudAbility(const bool isEnableCloud)1316 int32_t LnnSetCloudAbility(const bool isEnableCloud)
1317 {
1318     LNN_LOGI(LNN_BUILDER, "enter.");
1319     int32_t dbId = 0;
1320     dbId = g_dbId;
1321     int32_t ret = LnnSetCloudAbilityInner(dbId, isEnableCloud);
1322     if (ret != SOFTBUS_OK) {
1323         LNN_LOGE(LNN_BUILDER, "set cloud ability fail");
1324         return ret;
1325     }
1326     return SOFTBUS_OK;
1327 }
1328 
LnnInitCloudSyncModule(void)1329 void LnnInitCloudSyncModule(void)
1330 {
1331     LNN_LOGI(LNN_BUILDER, "enter.");
1332     int32_t dbId = 0;
1333     if (LnnCreateKvAdapter(&dbId, APPID, strlen(APPID), STOREID, strlen(STOREID)) != SOFTBUS_OK) {
1334         LNN_LOGE(LNN_BUILDER, "Lnn Init Cloud Sync Module fail");
1335         return;
1336     }
1337     LnnRegisterDataChangeListener(dbId, APPID, strlen(APPID), STOREID, strlen(STOREID));
1338     g_dbId = dbId;
1339 }
1340 
LnnDeInitCloudSyncModule(void)1341 void LnnDeInitCloudSyncModule(void)
1342 {
1343     LNN_LOGI(LNN_BUILDER, "enter.");
1344     int32_t dbId = g_dbId;
1345     LnnUnRegisterDataChangeListener(dbId);
1346     if (LnnDestroyKvAdapter(dbId) != SOFTBUS_OK) {
1347         LNN_LOGE(LNN_BUILDER, "DeInit Cloud Sync module fail");
1348     }
1349     g_dbId = 0;
1350 }
1351