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