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