• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-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_net_ledger.h"
17 
18 #include <string.h>
19 #include <securec.h>
20 
21 #include "anonymizer.h"
22 
23 #include "auth_interface.h"
24 #include "bus_center_event.h"
25 #include "bus_center_manager.h"
26 #include "g_enhance_lnn_func.h"
27 #include "g_enhance_lnn_func_pack.h"
28 #include "g_enhance_auth_func.h"
29 #include "g_enhance_auth_func_pack.h"
30 #include "lnn_data_cloud_sync.h"
31 #include "lnn_decision_db.h"
32 #include "lnn_distributed_net_ledger.h"
33 #include "lnn_event_monitor.h"
34 #include "lnn_event_monitor_impl.h"
35 #include "lnn_feature_capability.h"
36 #include "lnn_file_utils.h"
37 #include "lnn_huks_utils.h"
38 #include "lnn_local_net_ledger.h"
39 #include "lnn_log.h"
40 #include "lnn_meta_node_ledger.h"
41 #include "lnn_network_id.h"
42 #include "lnn_net_builder.h"
43 #include "lnn_p2p_info.h"
44 #include "lnn_settingdata_event_monitor.h"
45 #include "lnn_init_monitor.h"
46 #include "softbus_adapter_mem.h"
47 #include "softbus_def.h"
48 #include "softbus_error_code.h"
49 #include "softbus_utils.h"
50 #include "softbus_init_common.h"
51 
52 #define RETRY_TIMES                      5
53 #define DELAY_REG_DP_TIME                1000
54 #define UNKNOWN_CAP                      (-1)
55 static bool g_isRestore = false;
56 static bool g_isDeviceInfoSet = false;
57 
LnnInitNetLedger(void)58 int32_t LnnInitNetLedger(void)
59 {
60     LNN_LOGE(LNN_EVENT, "LnnInitNetLedger enter.");
61     if (LnnInitModuleNotifyWithRetrySync(INIT_DEPS_HUKS, LnnInitHuksInterface, RETRY_TIMES, DELAY_REG_DP_TIME) !=
62         SOFTBUS_OK) {
63         LNN_LOGE(LNN_LEDGER, "init huks interface fail");
64         return SOFTBUS_HUKS_INIT_FAILED;
65     }
66     if (LnnInitLocalLedger() != SOFTBUS_OK) {
67         LNN_LOGE(LNN_LEDGER, "init local net ledger fail!");
68         return SOFTBUS_NETWORK_LEDGER_INIT_FAILED;
69     }
70     if (LnnInitDistributedLedger() != SOFTBUS_OK) {
71         LNN_LOGE(LNN_LEDGER, "init distributed net ledger fail!");
72         return SOFTBUS_NETWORK_LEDGER_INIT_FAILED;
73     }
74     if (LnnInitMetaNodeLedger() != SOFTBUS_OK) {
75         LNN_LOGE(LNN_LEDGER, "init meta node ledger fail");
76         return SOFTBUS_NETWORK_LEDGER_INIT_FAILED;
77     }
78     if (LnnInitMetaNodeExtLedgerPacked() != SOFTBUS_OK) {
79         LNN_LOGE(LNN_LEDGER, "init meta node ext ledger fail");
80         return SOFTBUS_NETWORK_LEDGER_INIT_FAILED;
81     }
82     return SOFTBUS_OK;
83 }
84 
IsCapacityChange(NodeInfo * info)85 static bool IsCapacityChange(NodeInfo *info)
86 {
87     uint64_t softbusFeature = 0;
88     if (LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &softbusFeature) == SOFTBUS_OK) {
89         if (softbusFeature != info->feature) {
90             LNN_LOGW(LNN_LEDGER, "feature=%{public}" PRIu64 "->%{public}" PRIu64, info->feature, softbusFeature);
91             return true;
92         }
93     }
94     uint32_t authCapacity = 0;
95     if (LnnGetLocalNumU32Info(NUM_KEY_AUTH_CAP, &authCapacity) == SOFTBUS_OK) {
96         if (authCapacity != info->authCapacity) {
97             LNN_LOGW(LNN_LEDGER, "authCapacity=%{public}u->%{public}u", info->authCapacity, authCapacity);
98             info->authCapacity = authCapacity;
99             return true;
100         }
101     }
102     uint32_t heartbeatCapacity = 0;
103     if (LnnGetLocalNumU32Info(NUM_KEY_HB_CAP, &heartbeatCapacity) == SOFTBUS_OK) {
104         if (heartbeatCapacity != info->heartbeatCapacity) {
105             LNN_LOGW(LNN_LEDGER, "hbCapacity=%{public}u->%{public}u", info->heartbeatCapacity, heartbeatCapacity);
106             return true;
107         }
108     }
109     uint32_t staticNetCap = 0;
110     if (LnnGetLocalNumU32Info(NUM_KEY_STATIC_NET_CAP, &staticNetCap) == SOFTBUS_OK) {
111         if (staticNetCap != info->staticNetCap) {
112             LNN_LOGW(LNN_LEDGER, "staticNetCap=%{public}u->%{public}u", info->staticNetCap, staticNetCap);
113             return true;
114         }
115     }
116     int32_t sleRangeCap = 0;
117     if (LnnGetLocalNumInfo(NUM_KEY_SLE_RANGE_CAP, &sleRangeCap) == SOFTBUS_OK) {
118         if (sleRangeCap == UNKNOWN_CAP) {
119             LNN_LOGI(LNN_LEDGER, "sleRangeCap get illegal, recovery from cache");
120             int32_t ret = LnnSetLocalNumInfo(NUM_KEY_SLE_RANGE_CAP, info->sleRangeCapacity);
121             if (ret != SOFTBUS_OK) {
122                 LNN_LOGE(LNN_LEDGER, "LnnSetLocalNumInfo fail, ret = %{public}d", ret);
123                 return false;
124             }
125         } else if (sleRangeCap != info->sleRangeCapacity) {
126             LNN_LOGW(LNN_LEDGER, "sleRangeCap=%{public}d->%{public}d", info->sleRangeCapacity, sleRangeCap);
127             return true;
128         }
129     }
130     return false;
131 }
132 
IsLocalIrkInfoChange(NodeInfo * info)133 static bool IsLocalIrkInfoChange(NodeInfo *info)
134 {
135     unsigned char localIrk[LFINDER_IRK_LEN] = { 0 };
136     if (LnnGetLocalByteInfo(BYTE_KEY_IRK, localIrk, LFINDER_IRK_LEN) == SOFTBUS_OK) {
137         if (memcmp(info->rpaInfo.peerIrk, localIrk, LFINDER_IRK_LEN) != 0) {
138             LNN_LOGI(LNN_LEDGER, "local irk change");
139             if (memcpy_s(info->rpaInfo.peerIrk, LFINDER_IRK_LEN, localIrk, LFINDER_IRK_LEN) != EOK) {
140                 LNN_LOGE(LNN_LEDGER, "memcpy local irk fail");
141                 (void)memset_s(localIrk, LFINDER_IRK_LEN, 0, LFINDER_IRK_LEN);
142                 return true;
143             }
144             (void)memset_s(localIrk, LFINDER_IRK_LEN, 0, LFINDER_IRK_LEN);
145             return true;
146         }
147         LNN_LOGI(LNN_LEDGER, "local irk same");
148         (void)memset_s(localIrk, LFINDER_IRK_LEN, 0, LFINDER_IRK_LEN);
149         return false;
150     }
151     LNN_LOGI(LNN_LEDGER, "get local irk fail, ignore");
152     (void)memset_s(localIrk, LFINDER_IRK_LEN, 0, LFINDER_IRK_LEN);
153     return false;
154 }
155 
IsLocalBroadcastLinKeyChange(NodeInfo * info)156 static bool IsLocalBroadcastLinKeyChange(NodeInfo *info)
157 {
158     BroadcastCipherInfo linkKey;
159     (void)memset_s(&linkKey, sizeof(BroadcastCipherInfo), 0, sizeof(BroadcastCipherInfo));
160     if (LnnGetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_KEY, linkKey.key, SESSION_KEY_LENGTH) == SOFTBUS_OK &&
161         LnnGetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_IV, linkKey.iv, BROADCAST_IV_LEN) == SOFTBUS_OK) {
162         if (memcmp(info->cipherInfo.key, linkKey.key, SESSION_KEY_LENGTH) != 0 ||
163             memcmp(info->cipherInfo.iv, linkKey.iv, BROADCAST_IV_LEN) != 0) {
164             LNN_LOGI(LNN_LEDGER, "local link key change");
165             if (memcpy_s(info->cipherInfo.key, SESSION_KEY_LENGTH, linkKey.key, SESSION_KEY_LENGTH) != EOK ||
166                 memcpy_s(info->cipherInfo.iv, BROADCAST_IV_LEN, linkKey.iv, BROADCAST_IV_LEN) != EOK) {
167                 LNN_LOGE(LNN_LEDGER, "memcpy local link key fail");
168                 (void)memset_s(&linkKey, sizeof(BroadcastCipherInfo), 0, sizeof(BroadcastCipherInfo));
169                 return true;
170             }
171             (void)memset_s(&linkKey, sizeof(BroadcastCipherInfo), 0, sizeof(BroadcastCipherInfo));
172             return true;
173         }
174         LNN_LOGI(LNN_LEDGER, "local link key same");
175         (void)memset_s(&linkKey, sizeof(BroadcastCipherInfo), 0, sizeof(BroadcastCipherInfo));
176         return false;
177     }
178     LNN_LOGI(LNN_LEDGER, "get local link key fail, ignore");
179     (void)memset_s(&linkKey, sizeof(BroadcastCipherInfo), 0, sizeof(BroadcastCipherInfo));
180     return false;
181 }
182 
IsBleDirectlyOnlineFactorChange(NodeInfo * info)183 static bool IsBleDirectlyOnlineFactorChange(NodeInfo *info)
184 {
185     if (IsCapacityChange(info)) {
186         return true;
187     }
188     char softBusVersion[VERSION_MAX_LEN] = { 0 };
189     if (LnnGetLocalStrInfo(STRING_KEY_HICE_VERSION, softBusVersion, sizeof(softBusVersion)) == SOFTBUS_OK) {
190         if (strcmp(softBusVersion, info->softBusVersion) != 0) {
191             LNN_LOGW(LNN_LEDGER, "softbus version=%{public}s->%{public}s", softBusVersion, info->softBusVersion);
192             return true;
193         }
194     }
195     char *anonyNewUuid = NULL;
196     char uuid[UUID_BUF_LEN] = { 0 };
197     if ((LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) == SOFTBUS_OK) && (strcmp(uuid, info->uuid) != 0)) {
198         Anonymize(info->uuid, &anonyNewUuid);
199         LNN_LOGW(LNN_LEDGER, "uuid change, new=%{public}s", AnonymizeWrapper(anonyNewUuid));
200         AnonymizeFree(anonyNewUuid);
201         return true;
202     }
203     int32_t osType = 0;
204     if (LnnGetLocalNumInfo(NUM_KEY_OS_TYPE, &osType) == SOFTBUS_OK) {
205         if (osType != info->deviceInfo.osType) {
206             LNN_LOGW(LNN_LEDGER, "osType=%{public}d->%{public}d", info->deviceInfo.osType, osType);
207             return true;
208         }
209     }
210     int32_t level = 0;
211     if ((LnnGetLocalNumInfo(NUM_KEY_DEVICE_SECURITY_LEVEL, &level) == SOFTBUS_OK) &&
212         (level != info->deviceSecurityLevel)) {
213         LNN_LOGW(LNN_LEDGER, "deviceSecurityLevel=%{public}d->%{public}d", info->deviceSecurityLevel, level);
214         return true;
215     }
216     int32_t sleRangeCap = 0;
217     if (LnnGetLocalNumInfo(NUM_KEY_SLE_RANGE_CAP, &sleRangeCap) == SOFTBUS_OK) {
218         LNN_LOGW(LNN_LEDGER, "sleRangeCap=%{public}d->%{public}d", info->sleRangeCapacity, sleRangeCap);
219         return true;
220     }
221     if (IsLocalIrkInfoChange(info)) {
222         return true;
223     }
224     if (IsLocalBroadcastLinKeyChange(info)) {
225         return true;
226     }
227     return false;
228 }
229 
LnnSetLocalFeature(void)230 static void LnnSetLocalFeature(void)
231 {
232     uint64_t feature = 0;
233     if (LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &feature) != SOFTBUS_OK) {
234         LNN_LOGE(LNN_LEDGER, "set feature fail");
235         return;
236     }
237     if (IsSupportLpFeaturePacked()) {
238         feature |= 1 << BIT_BLE_SUPPORT_LP_HEARTBEAT;
239     }
240     if (LnnIsSupportLpSparkFeaturePacked()) {
241         feature |= 1 << BIT_SUPPORT_LP_SPARK_CAPABILITY;
242         (void)LnnClearFeatureCapability(&feature, BIT_SUPPORT_SPARK_GROUP_CAPABILITY);
243     }
244     if (LnnSetLocalNum64Info(NUM_KEY_FEATURE_CAPA, feature) != SOFTBUS_OK) {
245         LNN_LOGE(LNN_LEDGER, "set feature fail");
246     }
247 }
248 
ProcessLocalDeviceInfo(void)249 static void ProcessLocalDeviceInfo(void)
250 {
251     g_isRestore = true;
252     NodeInfo info;
253     (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
254     (void)LnnGetLocalDevInfoPacked(&info);
255     LnnDumpNodeInfo(&info, "load local deviceInfo success");
256     if (IsBleDirectlyOnlineFactorChange(&info)) {
257         info.stateVersion++;
258         if (info.stateVersion > MAX_STATE_VERSION) {
259             info.stateVersion = 1;
260         }
261         LnnSaveLocalDeviceInfoPacked(&info);
262     }
263     LNN_LOGI(LNN_LEDGER, "load local deviceInfo stateVersion=%{public}d", info.stateVersion);
264     if (LnnSetLocalNumInfo(NUM_KEY_STATE_VERSION, info.stateVersion) != SOFTBUS_OK) {
265         LNN_LOGE(LNN_LEDGER, "set state version fail");
266     }
267     if (LnnUpdateLocalNetworkId(info.networkId) != SOFTBUS_OK) {
268         LNN_LOGE(LNN_LEDGER, "set networkId fail");
269     }
270     if (LnnUpdateLocalDeviceName(&info.deviceInfo) != SOFTBUS_OK) {
271         LNN_LOGE(LNN_LEDGER, "set deviceName fail");
272     }
273     if (LnnUpdateLocalHuksKeyTime(info.huksKeyTime) != SOFTBUS_OK) {
274         LNN_LOGE(LNN_LEDGER, "set huks key time fail");
275     }
276     LnnNotifyNetworkIdChangeEvent(info.networkId);
277     if (info.networkIdTimestamp != 0) {
278         LnnUpdateLocalNetworkIdTime(info.networkIdTimestamp);
279         LNN_LOGD(LNN_LEDGER, "update networkIdTimestamp=%" PRId64, info.networkIdTimestamp);
280     }
281 }
282 
LnnLedgerInfoStatusSet(void)283 void LnnLedgerInfoStatusSet(void)
284 {
285     if (g_isDeviceInfoSet) {
286         return;
287     }
288     const NodeInfo *node = LnnGetLocalNodeInfo();
289     if (node == NULL) {
290         LNN_LOGE(LNN_LEDGER, "node is null");
291         return;
292     }
293 
294     InitDepsStatus uuidStat = node->uuid[0] != '\0' ? DEPS_STATUS_SUCCESS : DEPS_STATUS_FAILED;
295     LnnInitDeviceInfoStatusSet(LEDGER_INFO_UUID, uuidStat);
296     InitDepsStatus udidStat = node->deviceInfo.deviceUdid[0] != '\0' ? DEPS_STATUS_SUCCESS : DEPS_STATUS_FAILED;
297     LnnInitDeviceInfoStatusSet(LEDGER_INFO_UDID, udidStat);
298     InitDepsStatus netStat = node->networkId[0] != '\0' ? DEPS_STATUS_SUCCESS : DEPS_STATUS_FAILED;
299     LnnInitDeviceInfoStatusSet(LEDGER_INFO_NETWORKID, netStat);
300     if ((uuidStat == DEPS_STATUS_SUCCESS) && (udidStat == DEPS_STATUS_SUCCESS) && (netStat == DEPS_STATUS_SUCCESS)) {
301         LNN_LOGI(LNN_TEST, "Device info all ready.");
302         g_isDeviceInfoSet = true;
303         LnnInitSetDeviceInfoReady();
304     }
305 }
306 
RestoreLocalDeviceInfo(void)307 void RestoreLocalDeviceInfo(void)
308 {
309     LNN_LOGI(LNN_LEDGER, "restore local device info enter");
310     LnnSetLocalFeature();
311     if (g_isRestore) {
312         LNN_LOGI(LNN_LEDGER, "already init");
313         LnnLedgerInfoStatusSet();
314         return;
315     }
316     int32_t ret = LnnLoadLocalDeviceInfoPacked();
317     if (ret != SOFTBUS_OK) {
318         LNN_LOGI(LNN_LEDGER, "get local device info fail, ret=%{public}d", ret);
319         if (ret == SOFTBUS_HUKS_UPDATE_ERR || ret == SOFTBUS_PARSE_JSON_ERR) {
320             LNN_LOGE(LNN_LEDGER, "replace mainboard, device storage data need update");
321             LnnRemoveStorageConfigPath(LNN_FILE_ID_UUID);
322             LnnRemoveStorageConfigPath(LNN_FILE_ID_IRK_KEY);
323             if (LnnUpdateLocalUuidAndIrk() != SOFTBUS_OK) {
324                 LNN_LOGE(LNN_LEDGER, "update local uuid or irk fail");
325             }
326         }
327         const NodeInfo *temp = LnnGetLocalNodeInfo();
328         if (LnnSaveLocalDeviceInfoPacked(temp) != SOFTBUS_OK) {
329             LNN_LOGE(LNN_LEDGER, "save local device info fail");
330         } else {
331             LNN_LOGI(LNN_LEDGER, "save local device info success");
332         }
333     } else {
334         ProcessLocalDeviceInfo();
335     }
336     LnnLedgerInfoStatusSet();
337     LnnLoadPtkInfoPacked();
338     if (LnnLoadRemoteDeviceInfoPacked() != SOFTBUS_OK) {
339         LNN_LOGE(LNN_LEDGER, "load remote deviceInfo fail");
340         return;
341     }
342     LoadBleBroadcastKeyPacked();
343     LnnLoadLocalBroadcastCipherKeyPacked();
344 }
345 
LnnInitNetLedgerDelay(void)346 int32_t LnnInitNetLedgerDelay(void)
347 {
348     AuthLoadDeviceKeyPacked();
349     int32_t ret = LnnInitLocalLedgerDelay();
350     if (ret != SOFTBUS_OK) {
351         LNN_LOGE(LNN_LEDGER, "delay init local ledger fail");
352         return ret;
353     }
354     ret = LnnInitDecisionDbDelay();
355     if (ret != SOFTBUS_OK) {
356         LNN_LOGE(LNN_LEDGER, "delay init decision db fail");
357         return ret;
358     }
359     return SOFTBUS_OK;
360 }
361 
LnnInitEventMoniterDelay(void)362 int32_t LnnInitEventMoniterDelay(void)
363 {
364     int32_t ret = LnnInitCommonEventMonitorImpl();
365     if (ret != SOFTBUS_OK) {
366         LNN_LOGE(LNN_LEDGER, "delay init LnnInitCommonEventMonitorImpl fail");
367         return ret;
368     }
369     return SOFTBUS_OK;
370 }
371 
LnnInitHuksCeParamsDelay(void)372 int32_t LnnInitHuksCeParamsDelay(void)
373 {
374     int32_t ret = LnnGenerateCeParams(false);
375     if (ret != SOFTBUS_OK) {
376         LNN_LOGE(LNN_LEDGER, "delay init huks ce key fail, ret=%{public}d", ret);
377         return ret;
378     }
379     return SOFTBUS_OK;
380 }
381 
LnnDeinitNetLedger(void)382 void LnnDeinitNetLedger(void)
383 {
384     LnnDeinitMetaNodeLedger();
385     LnnDeinitDistributedLedger();
386     LnnDeinitLocalLedger();
387     LnnDeinitHuksInterface();
388     LnnInitMetaNodeExtLedgerPacked();
389     LnnDeInitCloudSyncModule();
390 }
391 
LnnGetNodeKeyInfoLocal(const char * networkId,int key,uint8_t * info,uint32_t infoLen)392 static int32_t LnnGetNodeKeyInfoLocal(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
393 {
394     if (networkId == NULL || info == NULL) {
395         LNN_LOGE(LNN_LEDGER, "params are null");
396         return SOFTBUS_INVALID_PARAM;
397     }
398     switch (key) {
399         case NODE_KEY_UDID:
400             return LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, (char *)info, infoLen);
401         case NODE_KEY_UUID:
402             return LnnGetLocalStrInfo(STRING_KEY_UUID, (char *)info, infoLen);
403         case NODE_KEY_MASTER_UDID:
404             return LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, (char *)info, infoLen);
405         case NODE_KEY_BR_MAC:
406             return LnnGetLocalStrInfo(STRING_KEY_BT_MAC, (char *)info, infoLen);
407         case NODE_KEY_IP_ADDRESS:
408             return LnnGetLocalStrInfoByIfnameIdx(STRING_KEY_IP, (char *)info, infoLen, WLAN_IF);
409         case NODE_KEY_DEV_NAME:
410             return LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, (char *)info, infoLen);
411         case NODE_KEY_BLE_OFFLINE_CODE:
412             return LnnGetLocalStrInfo(STRING_KEY_OFFLINE_CODE, (char *)info, infoLen);
413         case NODE_KEY_NETWORK_CAPABILITY:
414             return LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, (uint32_t *)info);
415         case NODE_KEY_NETWORK_TYPE:
416             return LnnGetLocalNumInfo(NUM_KEY_DISCOVERY_TYPE, (int32_t *)info);
417         case NODE_KEY_DATA_CHANGE_FLAG:
418             return LnnGetLocalNum16Info(NUM_KEY_DATA_CHANGE_FLAG, (int16_t *)info);
419         case NODE_KEY_NODE_ADDRESS:
420             return LnnGetLocalStrInfo(STRING_KEY_NODE_ADDR, (char *)info, infoLen);
421         case NODE_KEY_P2P_IP_ADDRESS:
422             return LnnGetLocalStrInfo(STRING_KEY_P2P_IP, (char *)info, infoLen);
423         case NODE_KEY_DEVICE_SECURITY_LEVEL:
424             return LnnGetLocalNumInfo(NUM_KEY_DEVICE_SECURITY_LEVEL, (int32_t *)info);
425         case NODE_KEY_DEVICE_SCREEN_STATUS:
426             return LnnGetLocalBoolInfo(BOOL_KEY_SCREEN_STATUS, (bool *)info, NODE_SCREEN_STATUS_LEN);
427         case NODE_KEY_STATIC_NETWORK_CAP:
428             return LnnGetLocalNumU32Info(NUM_KEY_STATIC_NET_CAP, (uint32_t *)info);
429         default:
430             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
431             return SOFTBUS_INVALID_NUM;
432     }
433 }
434 
LnnGetNodeKeyInfoRemote(const char * networkId,int key,uint8_t * info,uint32_t infoLen)435 static int32_t LnnGetNodeKeyInfoRemote(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
436 {
437     if (networkId == NULL || info == NULL) {
438         LNN_LOGE(LNN_LEDGER, "params are null");
439         return SOFTBUS_INVALID_PARAM;
440     }
441     switch (key) {
442         case NODE_KEY_UDID:
443             return LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_UDID, (char *)info, infoLen);
444         case NODE_KEY_UUID:
445             return LnnGetRemoteStrInfo(networkId, STRING_KEY_UUID, (char *)info, infoLen);
446         case NODE_KEY_BR_MAC:
447             return LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, (char *)info, infoLen);
448         case NODE_KEY_IP_ADDRESS:
449             return LnnGetRemoteStrInfoByIfnameIdx(networkId, STRING_KEY_IP, (char *)info, infoLen, WLAN_IF);
450         case NODE_KEY_DEV_NAME:
451             return LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_NAME, (char *)info, infoLen);
452         case NODE_KEY_BLE_OFFLINE_CODE:
453             return LnnGetRemoteStrInfo(networkId, STRING_KEY_OFFLINE_CODE, (char *)info, infoLen);
454         case NODE_KEY_NETWORK_CAPABILITY:
455             return LnnGetRemoteNumU32Info(networkId, NUM_KEY_NET_CAP, (uint32_t *)info);
456         case NODE_KEY_NETWORK_TYPE:
457             return LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, (int32_t *)info);
458         case NODE_KEY_DATA_CHANGE_FLAG:
459             return LnnGetRemoteNum16Info(networkId, NUM_KEY_DATA_CHANGE_FLAG, (int16_t *)info);
460         case NODE_KEY_NODE_ADDRESS:
461             return LnnGetRemoteStrInfo(networkId, STRING_KEY_NODE_ADDR, (char *)info, infoLen);
462         case NODE_KEY_P2P_IP_ADDRESS:
463             return LnnGetRemoteStrInfo(networkId, STRING_KEY_P2P_IP, (char *)info, infoLen);
464         case NODE_KEY_DEVICE_SECURITY_LEVEL:
465             return LnnGetRemoteNumInfo(networkId, NUM_KEY_DEVICE_SECURITY_LEVEL, (int32_t *)info);
466         case NODE_KEY_DEVICE_SCREEN_STATUS:
467             return LnnGetRemoteBoolInfo(networkId, BOOL_KEY_SCREEN_STATUS, (bool*)info);
468         case NODE_KEY_STATIC_NETWORK_CAP:
469             return LnnGetRemoteNumU32Info(networkId, NUM_KEY_STATIC_NET_CAP, (uint32_t *)info);
470         default:
471             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
472             return SOFTBUS_INVALID_NUM;
473     }
474 }
475 
LnnGetNodeKeyInfo(const char * networkId,int key,uint8_t * info,uint32_t infoLen)476 int32_t LnnGetNodeKeyInfo(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
477 {
478     bool isLocalNetworkId = false;
479     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
480     if (networkId == NULL || info == NULL) {
481         LNN_LOGE(LNN_LEDGER, "params are null");
482         return SOFTBUS_INVALID_PARAM;
483     }
484     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
485         LNN_LOGE(LNN_LEDGER, "get local network id fail");
486         return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
487     }
488     if (strncmp(localNetworkId, networkId, NETWORK_ID_BUF_LEN) == 0) {
489         isLocalNetworkId = true;
490     }
491     if (isLocalNetworkId) {
492         return LnnGetNodeKeyInfoLocal(networkId, key, info, infoLen);
493     } else {
494         return LnnGetNodeKeyInfoRemote(networkId, key, info, infoLen);
495     }
496 }
497 
LnnGetPrivateNodeKeyInfoLocal(const char * networkId,InfoKey key,uint8_t * info,uint32_t infoLen)498 static int32_t LnnGetPrivateNodeKeyInfoLocal(const char *networkId, InfoKey key, uint8_t *info, uint32_t infoLen)
499 {
500     if (networkId == NULL || info == NULL) {
501         LNN_LOGE(LNN_LEDGER, "params are null");
502         return SOFTBUS_INVALID_PARAM;
503     }
504     switch (key) {
505         case BYTE_KEY_IRK:
506             return LnnGetLocalByteInfo(BYTE_KEY_IRK, info, infoLen);
507         case BYTE_KEY_BROADCAST_CIPHER_KEY:
508             return LnnGetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_KEY, info, infoLen);
509         case BYTE_KEY_ACCOUNT_HASH:
510             return LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, info, infoLen);
511         case BYTE_KEY_REMOTE_PTK:
512             return LnnGetLocalByteInfo(BYTE_KEY_REMOTE_PTK, info, infoLen);
513         default:
514             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
515             return SOFTBUS_INVALID_PARAM;
516     }
517 }
518 
LnnGetPrivateNodeKeyInfoRemote(const char * networkId,InfoKey key,uint8_t * info,uint32_t infoLen)519 static int32_t LnnGetPrivateNodeKeyInfoRemote(const char *networkId, InfoKey key, uint8_t *info, uint32_t infoLen)
520 {
521     if (networkId == NULL || info == NULL) {
522         LNN_LOGE(LNN_LEDGER, "params are null");
523         return SOFTBUS_INVALID_PARAM;
524     }
525     switch (key) {
526         case BYTE_KEY_IRK:
527             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_IRK, info, infoLen);
528         case BYTE_KEY_BROADCAST_CIPHER_KEY:
529             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_BROADCAST_CIPHER_KEY, info, infoLen);
530         case BYTE_KEY_ACCOUNT_HASH:
531             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_ACCOUNT_HASH, info, infoLen);
532         case BYTE_KEY_REMOTE_PTK:
533             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_REMOTE_PTK, info, infoLen);
534         default:
535             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
536             return SOFTBUS_INVALID_PARAM;
537     }
538 }
539 
LnnGetPrivateNodeKeyInfo(const char * networkId,InfoKey key,uint8_t * info,uint32_t infoLen)540 static int32_t LnnGetPrivateNodeKeyInfo(const char *networkId, InfoKey key, uint8_t *info, uint32_t infoLen)
541 {
542     if (networkId == NULL || info == NULL) {
543         LNN_LOGE(LNN_LEDGER, "params are null");
544         return SOFTBUS_INVALID_PARAM;
545     }
546     bool isLocalNetworkId = false;
547     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
548     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
549         LNN_LOGE(LNN_LEDGER, "get local network id fail");
550         return SOFTBUS_NOT_FIND;
551     }
552     if (strncmp(localNetworkId, networkId, NETWORK_ID_BUF_LEN) == 0) {
553         isLocalNetworkId = true;
554     }
555     if (isLocalNetworkId) {
556         return LnnGetPrivateNodeKeyInfoLocal(networkId, key, info, infoLen);
557     } else {
558         return LnnGetPrivateNodeKeyInfoRemote(networkId, key, info, infoLen);
559     }
560 }
561 
LnnSetNodeDataChangeFlag(const char * networkId,uint16_t dataChangeFlag)562 int32_t LnnSetNodeDataChangeFlag(const char *networkId, uint16_t dataChangeFlag)
563 {
564     bool isLocalNetworkId = false;
565     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
566     if (networkId == NULL) {
567         LNN_LOGE(LNN_LEDGER, "params are null");
568         return SOFTBUS_INVALID_PARAM;
569     }
570     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
571         LNN_LOGE(LNN_LEDGER, "get local network id fail");
572         return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
573     }
574     if (strncmp(localNetworkId, networkId, NETWORK_ID_BUF_LEN) == 0) {
575         isLocalNetworkId = true;
576     }
577     if (isLocalNetworkId) {
578         return LnnSetLocalNum16Info(NUM_KEY_DATA_CHANGE_FLAG, (int16_t)dataChangeFlag);
579     }
580     LNN_LOGE(LNN_LEDGER, "remote networkId");
581     return SOFTBUS_NETWORK_INVALID_DEV_INFO;
582 }
583 
LnnSetDataLevel(const DataLevel * dataLevel,bool * isSwitchLevelChanged)584 int32_t LnnSetDataLevel(const DataLevel *dataLevel, bool *isSwitchLevelChanged)
585 {
586     if (dataLevel == NULL || isSwitchLevelChanged == NULL) {
587         LNN_LOGE(LNN_LEDGER, "LnnSetDataLevel data level or switch level change flag is null");
588         return SOFTBUS_INVALID_PARAM;
589     }
590     LNN_LOGI(LNN_LEDGER, "LnnSetDataLevel, dynamic: %{public}hu, static: %{public}hu, "
591         "switch: %{public}u, switchLen: %{public}hu", dataLevel->dynamicLevel, dataLevel->staticLevel,
592         dataLevel->switchLevel, dataLevel->switchLength);
593     uint16_t dynamicLevel = dataLevel->dynamicLevel;
594     if (LnnSetLocalNumU16Info(NUM_KEY_DATA_DYNAMIC_LEVEL, dynamicLevel) != SOFTBUS_OK) {
595         LNN_LOGE(LNN_LEDGER, "Set data dynamic level failed");
596         return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
597     }
598     uint16_t staticLevel = dataLevel->staticLevel;
599     if (LnnSetLocalNumU16Info(NUM_KEY_DATA_STATIC_LEVEL, staticLevel) != SOFTBUS_OK) {
600         LNN_LOGE(LNN_LEDGER, "Set data static level failed");
601         return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
602     }
603     uint32_t curSwitchLevel = 0;
604     if (LnnGetLocalNumU32Info(NUM_KEY_DATA_SWITCH_LEVEL, &curSwitchLevel) != SOFTBUS_OK) {
605         LNN_LOGE(LNN_LEDGER, "Get current data switch level faield");
606         return SOFTBUS_NETWORK_GET_LEDGER_INFO_ERR;
607     }
608     uint32_t switchLevel = dataLevel->switchLevel;
609     if (LnnSetLocalNumU32Info(NUM_KEY_DATA_SWITCH_LEVEL, switchLevel) != SOFTBUS_OK) {
610         LNN_LOGE(LNN_LEDGER, "Set data switch level faield");
611         return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
612     }
613     uint16_t switchLength = dataLevel->switchLength;
614     if (LnnSetLocalNumU16Info(NUM_KEY_DATA_SWITCH_LENGTH, switchLength) != SOFTBUS_OK) {
615         LNN_LOGE(LNN_LEDGER, "Set data switch length failed");
616         return SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR;
617     }
618     *isSwitchLevelChanged = (curSwitchLevel != switchLevel);
619     return SOFTBUS_OK;
620 }
621 
LnnGetNodeKeyInfoLen(int32_t key)622 int32_t LnnGetNodeKeyInfoLen(int32_t key)
623 {
624     switch (key) {
625         case NODE_KEY_UDID:
626             return UDID_BUF_LEN;
627         case NODE_KEY_UUID:
628             return UUID_BUF_LEN;
629         case NODE_KEY_MASTER_UDID:
630             return UDID_BUF_LEN;
631         case NODE_KEY_BR_MAC:
632             return MAC_LEN;
633         case NODE_KEY_IP_ADDRESS:
634             return IP_LEN;
635         case NODE_KEY_DEV_NAME:
636             return DEVICE_NAME_BUF_LEN;
637         case NODE_KEY_NETWORK_CAPABILITY:
638             return LNN_COMMON_LEN;
639         case NODE_KEY_NETWORK_TYPE:
640             return LNN_COMMON_LEN;
641         case NODE_KEY_DATA_CHANGE_FLAG:
642             return DATA_CHANGE_FLAG_BUF_LEN;
643         case NODE_KEY_NODE_ADDRESS:
644             return SHORT_ADDRESS_MAX_LEN;
645         case NODE_KEY_P2P_IP_ADDRESS:
646             return IP_LEN;
647         case NODE_KEY_DEVICE_SECURITY_LEVEL:
648             return LNN_COMMON_LEN;
649         case NODE_KEY_DEVICE_SCREEN_STATUS:
650             return DATA_DEVICE_SCREEN_STATUS_LEN;
651         default:
652             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
653             return SOFTBUS_INVALID_NUM;
654     }
655 }
656 
SoftbusDumpPrintAccountId(int fd,NodeBasicInfo * nodeInfo)657 static int32_t SoftbusDumpPrintAccountId(int fd, NodeBasicInfo *nodeInfo)
658 {
659     if (nodeInfo == NULL) {
660         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
661         return SOFTBUS_INVALID_PARAM;
662     }
663     char accountHash[SHA_256_HASH_LEN] = {0};
664     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_ACCOUNT_HASH,
665         (uint8_t *)&accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
666         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo account hash failed");
667         return SOFTBUS_NOT_FIND;
668     }
669     char accountHashStr[SHA_256_HEX_HASH_LEN] = {0};
670     if (ConvertBytesToHexString(accountHashStr, SHA_256_HEX_HASH_LEN,
671         (unsigned char *)accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
672         LNN_LOGE(LNN_LEDGER, "convert account to string fail.");
673         return SOFTBUS_BYTE_CONVERT_FAIL;
674     }
675     char *anonyAccountHash = NULL;
676     Anonymize(accountHashStr, &anonyAccountHash);
677     SOFTBUS_DPRINTF(fd, "AccountHash->%s\n", AnonymizeWrapper(anonyAccountHash));
678     AnonymizeFree(anonyAccountHash);
679     return SOFTBUS_OK;
680 }
681 
SoftbusDumpPrintUdid(int fd,NodeBasicInfo * nodeInfo)682 int32_t SoftbusDumpPrintUdid(int fd, NodeBasicInfo *nodeInfo)
683 {
684     if (nodeInfo == NULL) {
685         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
686         return SOFTBUS_INVALID_PARAM;
687     }
688     NodeDeviceInfoKey key;
689     key = NODE_KEY_UDID;
690     unsigned char udid[UDID_BUF_LEN] = {0};
691 
692     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
693         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo Udid failed");
694         return SOFTBUS_NOT_FIND;
695     }
696     char *anonyUdid = NULL;
697     Anonymize((char *)udid, &anonyUdid);
698     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "Udid", AnonymizeWrapper(anonyUdid));
699     AnonymizeFree(anonyUdid);
700     return SOFTBUS_OK;
701 }
702 
SoftbusDumpPrintUuid(int fd,NodeBasicInfo * nodeInfo)703 int32_t SoftbusDumpPrintUuid(int fd, NodeBasicInfo *nodeInfo)
704 {
705     if (nodeInfo == NULL) {
706         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
707         return SOFTBUS_INVALID_PARAM;
708     }
709     NodeDeviceInfoKey key;
710     key = NODE_KEY_UUID;
711     unsigned char uuid[UUID_BUF_LEN] = {0};
712 
713     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
714         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo Uuid failed");
715         return SOFTBUS_NOT_FIND;
716     }
717     char *anonyUuid = NULL;
718     Anonymize((char *)uuid, &anonyUuid);
719     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "Uuid", AnonymizeWrapper(anonyUuid));
720     AnonymizeFree(anonyUuid);
721     return SOFTBUS_OK;
722 }
723 
SoftbusDumpPrintMac(int fd,NodeBasicInfo * nodeInfo)724 int32_t SoftbusDumpPrintMac(int fd, NodeBasicInfo *nodeInfo)
725 {
726     if (nodeInfo == NULL) {
727         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
728         return SOFTBUS_INVALID_PARAM;
729     }
730     NodeDeviceInfoKey key;
731     key = NODE_KEY_BR_MAC;
732     unsigned char brMac[BT_MAC_LEN] = {0};
733     char *anonyBrMac = NULL;
734 
735     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, brMac, BT_MAC_LEN) != SOFTBUS_OK) {
736         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo brMac failed");
737         return SOFTBUS_NOT_FIND;
738     }
739     Anonymize((char *)brMac, &anonyBrMac);
740     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "BrMac", AnonymizeWrapper(anonyBrMac));
741     AnonymizeFree(anonyBrMac);
742     return SOFTBUS_OK;
743 }
744 
SoftbusDumpPrintIp(int fd,NodeBasicInfo * nodeInfo)745 int32_t SoftbusDumpPrintIp(int fd, NodeBasicInfo *nodeInfo)
746 {
747     if (nodeInfo == NULL) {
748         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
749         return SOFTBUS_INVALID_PARAM;
750     }
751     NodeDeviceInfoKey key;
752     key = NODE_KEY_IP_ADDRESS;
753     char ipAddr[IP_STR_MAX_LEN] = {0};
754     char *anonyIpAddr = NULL;
755 
756     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)ipAddr, IP_STR_MAX_LEN) != SOFTBUS_OK) {
757         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo ipAddr failed");
758         return SOFTBUS_NOT_FIND;
759     }
760     Anonymize((char *)ipAddr, &anonyIpAddr);
761     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "IpAddr", AnonymizeWrapper(anonyIpAddr));
762     AnonymizeFree(anonyIpAddr);
763     return SOFTBUS_OK;
764 }
765 
SoftbusDumpPrintUsbIp(int fd,const NodeBasicInfo * nodeInfo)766 int32_t SoftbusDumpPrintUsbIp(int fd, const NodeBasicInfo *nodeInfo)
767 {
768     if (nodeInfo == NULL) {
769         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
770         return SOFTBUS_INVALID_PARAM;
771     }
772     char ipAddr[IP_STR_MAX_LEN] = {0};
773     bool isLocalNetworkId = false;
774     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
775     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
776         LNN_LOGE(LNN_LEDGER, "get local network id fail");
777         return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
778     }
779     if (strncmp(localNetworkId, nodeInfo->networkId, NETWORK_ID_BUF_LEN) == 0) {
780         isLocalNetworkId = true;
781     }
782     if (isLocalNetworkId) {
783         LnnGetLocalStrInfoByIfnameIdx(STRING_KEY_IP, (char *)ipAddr, IP_STR_MAX_LEN, USB_IF);
784     } else {
785         LnnGetRemoteStrInfoByIfnameIdx(nodeInfo->networkId, STRING_KEY_IP, (char *)ipAddr, IP_STR_MAX_LEN, USB_IF);
786     }
787     char *anonyIp = NULL;
788     Anonymize(ipAddr, &anonyIp);
789     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "USB IpAddr", AnonymizeWrapper(anonyIp));
790     AnonymizeFree(anonyIp);
791     return SOFTBUS_OK;
792 }
793 
SoftbusDumpPrintDynamicNetCap(int fd,NodeBasicInfo * nodeInfo)794 int32_t SoftbusDumpPrintDynamicNetCap(int fd, NodeBasicInfo *nodeInfo)
795 {
796     if (nodeInfo == NULL) {
797         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
798         return SOFTBUS_INVALID_PARAM;
799     }
800     NodeDeviceInfoKey key;
801     key = NODE_KEY_NETWORK_CAPABILITY;
802     int32_t netCapacity = 0;
803     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&netCapacity, sizeof(netCapacity)) != SOFTBUS_OK) {
804         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo netCapacity failed");
805         return SOFTBUS_NOT_FIND;
806     }
807     SOFTBUS_DPRINTF(fd, "  %-15s->%d\n", "NetCapacity", netCapacity);
808     return SOFTBUS_OK;
809 }
810 
SoftbusDumpPrintNetType(int fd,NodeBasicInfo * nodeInfo)811 int32_t SoftbusDumpPrintNetType(int fd, NodeBasicInfo *nodeInfo)
812 {
813     if (nodeInfo == NULL) {
814         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
815         return SOFTBUS_INVALID_PARAM;
816     }
817     NodeDeviceInfoKey key;
818     key = NODE_KEY_NETWORK_TYPE;
819     int32_t netType = 0;
820     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&netType, sizeof(netType)) != SOFTBUS_OK) {
821         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo netType failed");
822         return SOFTBUS_NOT_FIND;
823     }
824     SOFTBUS_DPRINTF(fd, "  %-15s->%d\n", "NetType", netType);
825     return SOFTBUS_OK;
826 }
827 
SoftbusDumpPrintDeviceLevel(int fd,NodeBasicInfo * nodeInfo)828 static int32_t SoftbusDumpPrintDeviceLevel(int fd, NodeBasicInfo *nodeInfo)
829 {
830     if (nodeInfo == NULL) {
831         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
832         return SOFTBUS_INVALID_PARAM;
833     }
834     NodeDeviceInfoKey key;
835     key = NODE_KEY_DEVICE_SECURITY_LEVEL;
836     int32_t securityLevel = 0;
837     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&securityLevel, sizeof(securityLevel)) != SOFTBUS_OK) {
838         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo securityLevel failed");
839         return SOFTBUS_NOT_FIND;
840     }
841     SOFTBUS_DPRINTF(fd, "  %-15s->%d\n", "SecurityLevel", securityLevel);
842     return SOFTBUS_OK;
843 }
844 
SoftbusDumpPrintScreenStatus(int fd,NodeBasicInfo * nodeInfo)845 static int32_t SoftbusDumpPrintScreenStatus(int fd, NodeBasicInfo *nodeInfo)
846 {
847     if (nodeInfo == NULL) {
848         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
849         return SOFTBUS_INVALID_PARAM;
850     }
851     bool isScreenOn = false;
852     if (LnnGetNodeKeyInfo(nodeInfo->networkId, NODE_KEY_DEVICE_SCREEN_STATUS, (uint8_t *)&isScreenOn,
853         DATA_DEVICE_SCREEN_STATUS_LEN) != SOFTBUS_OK) {
854         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo isScreenOn failed");
855         return SOFTBUS_NOT_FIND;
856     }
857     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "isScreenOn", isScreenOn ? "on" : "off");
858     return SOFTBUS_OK;
859 }
860 
SoftbusDumpPrintStaticNetCap(int fd,NodeBasicInfo * nodeInfo)861 static int32_t SoftbusDumpPrintStaticNetCap(int fd, NodeBasicInfo *nodeInfo)
862 {
863     if (nodeInfo == NULL) {
864         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
865         return SOFTBUS_INVALID_PARAM;
866     }
867     NodeDeviceInfoKey key;
868     key = NODE_KEY_STATIC_NETWORK_CAP;
869     uint32_t staticNetCap = 0;
870     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&staticNetCap, sizeof(staticNetCap)) != SOFTBUS_OK) {
871         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo staticNetCap failed");
872         return SOFTBUS_NOT_FIND;
873     }
874     SOFTBUS_DPRINTF(fd, "  %-15s->%u\n", "StaticNetCap", staticNetCap);
875     return SOFTBUS_OK;
876 }
877 
SoftbusDumpPrintIrk(int fd,NodeBasicInfo * nodeInfo)878 static int32_t SoftbusDumpPrintIrk(int fd, NodeBasicInfo *nodeInfo)
879 {
880     if (nodeInfo == NULL) {
881         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
882         return SOFTBUS_INVALID_PARAM;
883     }
884     uint8_t irk[LFINDER_IRK_LEN] = {0};
885     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_IRK,
886         (uint8_t *)&irk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
887         LNN_LOGE(LNN_LEDGER, "LnnGetPrivateNodeKeyInfo irk failed");
888         return SOFTBUS_NOT_FIND;
889     }
890     char peerIrkStr[LFINDER_IRK_STR_LEN] = {0};
891     if (ConvertBytesToHexString(peerIrkStr, LFINDER_IRK_STR_LEN, irk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
892         LNN_LOGE(LNN_LEDGER, "convert irk to string fail.");
893         (void)memset_s(irk, LFINDER_IRK_LEN, 0, LFINDER_IRK_LEN);
894         return SOFTBUS_BYTE_CONVERT_FAIL;
895     }
896     char *anonyIrk = NULL;
897     LnnAnonymizeIrk(peerIrkStr, LFINDER_IRK_STR_LEN, &anonyIrk);
898     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "IRK", AnonymizeWrapper(anonyIrk));
899     AnonymizeFree(anonyIrk);
900     (void)memset_s(irk, LFINDER_IRK_LEN, 0, LFINDER_IRK_LEN);
901     (void)memset_s(peerIrkStr, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
902     return SOFTBUS_OK;
903 }
904 
SoftbusDumpPrintBroadcastCipher(int fd,NodeBasicInfo * nodeInfo)905 static int32_t SoftbusDumpPrintBroadcastCipher(int fd, NodeBasicInfo *nodeInfo)
906 {
907     if (nodeInfo == NULL) {
908         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
909         return SOFTBUS_INVALID_PARAM;
910     }
911     unsigned char broadcastCipher[SESSION_KEY_LENGTH] = {0};
912     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_BROADCAST_CIPHER_KEY,
913         (uint8_t *)&broadcastCipher, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
914         LNN_LOGE(LNN_LEDGER, "LnnGetPrivateNodeKeyInfo broadcastCipher failed");
915         return SOFTBUS_NOT_FIND;
916     }
917     char broadcastCipherStr[SESSION_KEY_STR_LEN] = {0};
918     if (ConvertBytesToHexString(broadcastCipherStr, SESSION_KEY_STR_LEN,
919         broadcastCipher, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
920         LNN_LOGE(LNN_LEDGER, "convert broadcastCipher to string fail.");
921         (void)memset_s(broadcastCipher, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
922         return SOFTBUS_BYTE_CONVERT_FAIL;
923     }
924     char *anonyBroadcastCipher = NULL;
925     LnnAnonymizeBroadcastCipher(broadcastCipherStr, SESSION_KEY_STR_LEN, &anonyBroadcastCipher);
926     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "BroadcastCipher", AnonymizeWrapper(anonyBroadcastCipher));
927     AnonymizeFree(anonyBroadcastCipher);
928     (void)memset_s(broadcastCipher, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
929     (void)memset_s(broadcastCipherStr, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
930     return SOFTBUS_OK;
931 }
932 
SoftbusDumpPrintRemotePtk(int fd,NodeBasicInfo * nodeInfo)933 static int32_t SoftbusDumpPrintRemotePtk(int fd, NodeBasicInfo *nodeInfo)
934 {
935     if (nodeInfo == NULL) {
936         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
937         return SOFTBUS_INVALID_PARAM;
938     }
939     char remotePtk[PTK_DEFAULT_LEN] = {0};
940     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_REMOTE_PTK,
941         (uint8_t *)&remotePtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
942         LNN_LOGE(LNN_LEDGER, "LnnGetPrivateNodeKeyInfo ptk failed");
943         return SOFTBUS_NOT_FIND;
944     }
945     char remotePtkStr[PTK_STR_LEN] = {0};
946     if (ConvertBytesToHexString(remotePtkStr, PTK_STR_LEN,
947         (unsigned char *)remotePtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
948         LNN_LOGE(LNN_LEDGER, "convert remotePtk to string fail.");
949         (void)memset_s(remotePtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
950         return SOFTBUS_BYTE_CONVERT_FAIL;
951     }
952     char *anonyRemotePtk = NULL;
953     LnnAnonymizePtk(remotePtkStr, PTK_STR_LEN, &anonyRemotePtk);
954     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "RemotePtk", AnonymizeWrapper(anonyRemotePtk));
955     AnonymizeFree(anonyRemotePtk);
956     (void)memset_s(remotePtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
957     (void)memset_s(remotePtkStr, PTK_STR_LEN, 0, PTK_STR_LEN);
958     return SOFTBUS_OK;
959 }
960 
SoftbusDumpPrintLocalPtk(int fd,NodeBasicInfo * nodeInfo)961 static int32_t SoftbusDumpPrintLocalPtk(int fd, NodeBasicInfo *nodeInfo)
962 {
963     if (nodeInfo == NULL) {
964         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
965         return SOFTBUS_INVALID_PARAM;
966     }
967     char peerUuid[UUID_BUF_LEN] = {0};
968     if (LnnGetRemoteStrInfo(nodeInfo->networkId, STRING_KEY_UUID, peerUuid, UUID_BUF_LEN) != SOFTBUS_OK) {
969         LNN_LOGE(LNN_LEDGER, "gey peerUuid failed");
970         return SOFTBUS_NOT_FIND;
971     }
972     char localPtk[PTK_DEFAULT_LEN] = {0};
973     if (LnnGetLocalPtkByUuidPacked(peerUuid, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
974         LNN_LOGE(LNN_LEDGER, "LnnGetLocalPtkByUuid failed");
975         return SOFTBUS_NOT_FIND;
976     }
977     char localPtkStr[PTK_STR_LEN] = {0};
978     if (ConvertBytesToHexString(localPtkStr, PTK_STR_LEN,
979         (unsigned char *)localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
980         LNN_LOGE(LNN_LEDGER, "convert localPtk to string fail.");
981         (void)memset_s(localPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
982         return SOFTBUS_BYTE_CONVERT_FAIL;
983     }
984     char *anonyLocalPtk = NULL;
985     LnnAnonymizePtk(localPtkStr, PTK_STR_LEN, &anonyLocalPtk);
986     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "LocalPtk", AnonymizeWrapper(anonyLocalPtk));
987     AnonymizeFree(anonyLocalPtk);
988     (void)memset_s(localPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
989     (void)memset_s(localPtkStr, PTK_STR_LEN, 0, PTK_STR_LEN);
990     return SOFTBUS_OK;
991 }
992 
SoftbusDumpDeviceInfo(int fd,NodeBasicInfo * nodeInfo)993 static void SoftbusDumpDeviceInfo(int fd, NodeBasicInfo *nodeInfo)
994 {
995     SOFTBUS_DPRINTF(fd, "DeviceInfo:\n");
996     if (fd <= 0 || nodeInfo == NULL) {
997         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
998         return;
999     }
1000     char *anonyNetworkId = NULL;
1001     Anonymize(nodeInfo->networkId, &anonyNetworkId);
1002     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "NetworkId", AnonymizeWrapper(anonyNetworkId));
1003     AnonymizeFree(anonyNetworkId);
1004     if (SoftbusDumpPrintUdid(fd, nodeInfo) != SOFTBUS_OK) {
1005         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintUdid failed");
1006     }
1007     if (SoftbusDumpPrintUuid(fd, nodeInfo) != SOFTBUS_OK) {
1008         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintUuid failed");
1009     }
1010     if (SoftbusDumpPrintDynamicNetCap(fd, nodeInfo) != SOFTBUS_OK) {
1011         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintDynamicNetCap failed");
1012     }
1013     if (SoftbusDumpPrintNetType(fd, nodeInfo) != SOFTBUS_OK) {
1014         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintNetType failed");
1015     }
1016     if (SoftbusDumpPrintDeviceLevel(fd, nodeInfo) != SOFTBUS_OK) {
1017         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintDeviceLevel failed");
1018     }
1019     if (SoftbusDumpPrintScreenStatus(fd, nodeInfo) != SOFTBUS_OK) {
1020         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintScreenStatus failed");
1021     }
1022     if (SoftbusDumpPrintStaticNetCap(fd, nodeInfo) != SOFTBUS_OK) {
1023         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintStaticNetCap failed");
1024     }
1025 }
1026 
SoftbusDumpDeviceAddr(int fd,NodeBasicInfo * nodeInfo)1027 static void SoftbusDumpDeviceAddr(int fd, NodeBasicInfo *nodeInfo)
1028 {
1029     SOFTBUS_DPRINTF(fd, "DeviceAddr:\n");
1030     if (fd <= 0 || nodeInfo == NULL) {
1031         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
1032         return;
1033     }
1034     if (SoftbusDumpPrintMac(fd, nodeInfo) != SOFTBUS_OK) {
1035         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintMac failed");
1036     }
1037     if (SoftbusDumpPrintIp(fd, nodeInfo) != SOFTBUS_OK) {
1038         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintIp failed");
1039     }
1040     if (SoftbusDumpPrintUsbIp(fd, nodeInfo) != SOFTBUS_OK) {
1041         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintUsbIp failed");
1042     }
1043 }
1044 
SoftbusDumpDeviceCipher(int fd,NodeBasicInfo * nodeInfo)1045 static void SoftbusDumpDeviceCipher(int fd, NodeBasicInfo *nodeInfo)
1046 {
1047     SOFTBUS_DPRINTF(fd, "DeviceCipher:\n");
1048     if (fd <= 0 || nodeInfo == NULL) {
1049         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
1050         return;
1051     }
1052     if (SoftbusDumpPrintIrk(fd, nodeInfo) != SOFTBUS_OK) {
1053         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintIrk failed");
1054     }
1055     if (SoftbusDumpPrintBroadcastCipher(fd, nodeInfo) != SOFTBUS_OK) {
1056         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintBroadcastCipher failed");
1057     }
1058     if (SoftbusDumpPrintRemotePtk(fd, nodeInfo) != SOFTBUS_OK) {
1059         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintRemotePtk failed");
1060     }
1061     if (SoftbusDumpPrintLocalPtk(fd, nodeInfo) != SOFTBUS_OK) {
1062         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintLocalPtk failed");
1063     }
1064 }
1065 
SoftBusDumpBusCenterPrintInfo(int fd,NodeBasicInfo * nodeInfo)1066 void SoftBusDumpBusCenterPrintInfo(int fd, NodeBasicInfo *nodeInfo)
1067 {
1068     if (fd <= 0 || nodeInfo == NULL) {
1069         LNN_LOGE(LNN_LEDGER, "param is null");
1070         return;
1071     }
1072     char *anonyDeviceName = NULL;
1073     AnonymizeDeviceName(nodeInfo->deviceName, &anonyDeviceName);
1074     SOFTBUS_DPRINTF(fd, "DeviceName->%s\n", AnonymizeWrapper(anonyDeviceName));
1075     AnonymizeFree(anonyDeviceName);
1076     SoftbusDumpPrintAccountId(fd, nodeInfo);
1077     SoftbusDumpDeviceInfo(fd, nodeInfo);
1078     SoftbusDumpDeviceAddr(fd, nodeInfo);
1079     SoftbusDumpDeviceCipher(fd, nodeInfo);
1080 }
1081 
LnnClearLocalPtkList(void)1082 static void LnnClearLocalPtkList(void)
1083 {
1084     LnnClearPtkListPacked();
1085 }
1086 
LnnUpdateLocalDeviceInfo(void)1087 int32_t LnnUpdateLocalDeviceInfo(void)
1088 {
1089     char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1090 
1091     ClearDeviceInfoPacked();
1092     AuthClearDeviceKeyPacked();
1093     LnnClearLocalPtkList();
1094 
1095     int32_t ret = LnnUpdateLocalUuidAndIrk();
1096     if (ret != SOFTBUS_OK) {
1097         LNN_LOGE(LNN_LEDGER, "update local uuid or irk failed");
1098         return ret;
1099     }
1100     ret = LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN);
1101     if (ret != SOFTBUS_OK) {
1102         LNN_LOGE(LNN_LEDGER, "get local networkId failed");
1103         return ret;
1104     }
1105     ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, networkId);
1106     if (ret != SOFTBUS_OK) {
1107         LNN_LOGE(LNN_LEDGER, "set local networkId failed");
1108         return ret;
1109     }
1110     ret = GenerateNewLocalCipherKeyPacked();
1111     if (ret != SOFTBUS_OK) {
1112         LNN_LOGE(LNN_LEDGER, "generate new local cipher key failed");
1113         return ret;
1114     }
1115     LnnRemoveDb();
1116     ret = InitTrustedDevInfoTable();
1117     if (ret != SOFTBUS_OK) {
1118         LNN_LOGE(LNN_LEDGER, "init trusted device info failed");
1119         return ret;
1120     }
1121     ret = LnnGenBroadcastCipherInfo();
1122     if (ret != SOFTBUS_OK) {
1123         LNN_LOGE(LNN_LEDGER, "generate cipher failed");
1124         return ret;
1125     }
1126     return SOFTBUS_OK;
1127 }
1128 
InitUdidChangedEvent(void)1129 int32_t InitUdidChangedEvent(void)
1130 {
1131     return HandleDeviceInfoIfUdidChanged();
1132 }
1133