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 #include "auth_device_common_key.h"
23 #include "auth_interface.h"
24 #include "bus_center_event.h"
25 #include "bus_center_manager.h"
26 #include "lnn_ble_lpdevice.h"
27 #include "lnn_cipherkey_manager.h"
28 #include "lnn_data_cloud_sync.h"
29 #include "lnn_decision_db.h"
30 #include "lnn_device_info_recovery.h"
31 #include "lnn_distributed_net_ledger.h"
32 #include "lnn_event_monitor.h"
33 #include "lnn_event_monitor_impl.h"
34 #include "lnn_feature_capability.h"
35 #include "lnn_huks_utils.h"
36 #include "lnn_local_net_ledger.h"
37 #include "lnn_log.h"
38 #include "lnn_meta_node_interface.h"
39 #include "lnn_meta_node_ledger.h"
40 #include "lnn_p2p_info.h"
41 #include "lnn_settingdata_event_monitor.h"
42 #include "softbus_adapter_mem.h"
43 #include "lnn_oobe_manager.h"
44 #include "softbus_def.h"
45 #include "softbus_errcode.h"
46 #include "softbus_utils.h"
47 
48 static bool g_isRestore = false;
49 
LnnInitNetLedger(void)50 int32_t LnnInitNetLedger(void)
51 {
52     if (LnnInitHuksInterface() != SOFTBUS_OK) {
53         LNN_LOGE(LNN_LEDGER, "init huks interface fail");
54         return SOFTBUS_ERR;
55     }
56     if (LnnInitLocalLedger() != SOFTBUS_OK) {
57         LNN_LOGE(LNN_LEDGER, "init local net ledger fail!");
58         return SOFTBUS_ERR;
59     }
60     if (LnnInitDistributedLedger() != SOFTBUS_OK) {
61         LNN_LOGE(LNN_LEDGER, "init distributed net ledger fail!");
62         return SOFTBUS_ERR;
63     }
64     if (LnnInitMetaNodeLedger() != SOFTBUS_OK) {
65         LNN_LOGE(LNN_LEDGER, "init meta node ledger fail");
66         return SOFTBUS_ERR;
67     }
68     if (LnnInitMetaNodeExtLedger() != SOFTBUS_OK) {
69         LNN_LOGE(LNN_LEDGER, "init meta node ext ledger fail");
70         return SOFTBUS_ERR;
71     }
72     return SOFTBUS_OK;
73 }
74 
IsBleDirectlyOnlineFactorChange(NodeInfo * info)75 static bool IsBleDirectlyOnlineFactorChange(NodeInfo *info)
76 {
77     char softBusVersion[VERSION_MAX_LEN] = { 0 };
78     if (LnnGetLocalStrInfo(STRING_KEY_HICE_VERSION, softBusVersion, sizeof(softBusVersion)) == SOFTBUS_OK) {
79         if (strcmp(softBusVersion, info->softBusVersion) != 0) {
80             LNN_LOGW(LNN_LEDGER, "softbus version=%{public}s->%{public}s", softBusVersion, info->softBusVersion);
81             return true;
82         }
83     }
84     uint64_t softbusFeature = 0;
85     if (LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &softbusFeature) == SOFTBUS_OK) {
86         if (softbusFeature != info->feature) {
87             LNN_LOGW(LNN_LEDGER, "feature=%{public}" PRIu64 "->%{public}" PRIu64, info->feature, softbusFeature);
88             return true;
89         }
90     }
91     char *anonyNewUuid = NULL;
92     char uuid[UUID_BUF_LEN] = { 0 };
93     if ((LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) == SOFTBUS_OK) && (strcmp(uuid, info->uuid) != 0)) {
94         Anonymize(info->uuid, &anonyNewUuid);
95         LNN_LOGW(LNN_LEDGER, "uuid change, new=%{public}s", anonyNewUuid);
96         AnonymizeFree(anonyNewUuid);
97         return true;
98     }
99     int32_t osType = 0;
100     if (LnnGetLocalNumInfo(NUM_KEY_OS_TYPE, &osType) == SOFTBUS_OK) {
101         if (osType != info->deviceInfo.osType) {
102             LNN_LOGW(LNN_LEDGER, "osType=%{public}d->%{public}d", info->deviceInfo.osType, osType);
103             return true;
104         }
105     }
106     uint32_t authCapacity = 0;
107     if (LnnGetLocalNumU32Info(NUM_KEY_AUTH_CAP, &authCapacity) == SOFTBUS_OK) {
108         if (authCapacity != info->authCapacity) {
109             LNN_LOGW(LNN_LEDGER, "authCapacity=%{public}d->%{public}d", info->authCapacity, authCapacity);
110             return true;
111         }
112     }
113     int32_t level = 0;
114     if ((LnnGetLocalNumInfo(NUM_KEY_DEVICE_SECURITY_LEVEL, &level) == SOFTBUS_OK) &&
115         (level != info->deviceSecurityLevel)) {
116         LNN_LOGW(LNN_LEDGER, "deviceSecurityLevel=%{public}d->%{public}d", info->deviceSecurityLevel, level);
117         return true;
118     }
119     return false;
120 }
121 
LnnSetLocalFeature(void)122 static void LnnSetLocalFeature(void)
123 {
124     if (IsSupportLpFeature()) {
125         uint64_t feature = 1 << BIT_BLE_SUPPORT_LP_HEARTBEAT;
126         if (LnnSetLocalNum64Info(NUM_KEY_FEATURE_CAPA, feature) != SOFTBUS_OK) {
127             LNN_LOGE(LNN_LEDGER, "set feature fail");
128         }
129     } else {
130         LNN_LOGE(LNN_LEDGER, "not support mlps");
131     }
132 }
133 
ProcessLocalDeviceInfo(void)134 static void ProcessLocalDeviceInfo(void)
135 {
136     g_isRestore = true;
137     NodeInfo info;
138     (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
139     (void)LnnGetLocalDevInfo(&info);
140     LnnDumpNodeInfo(&info, "load local deviceInfo success");
141     if (IsBleDirectlyOnlineFactorChange(&info)) {
142         info.stateVersion++;
143         LnnSaveLocalDeviceInfo(&info);
144     }
145     LNN_LOGI(LNN_LEDGER, "load local deviceInfo stateVersion=%{public}d", info.stateVersion);
146     if (LnnSetLocalNumInfo(NUM_KEY_STATE_VERSION, info.stateVersion) != SOFTBUS_OK) {
147         LNN_LOGE(LNN_LEDGER, "set state version fail");
148     }
149     if (LnnUpdateLocalNetworkId(info.networkId) != SOFTBUS_OK) {
150         LNN_LOGE(LNN_LEDGER, "set networkId fail");
151     }
152     LnnNotifyNetworkIdChangeEvent(info.networkId);
153     LnnNotifyLocalNetworkIdChanged();
154     if (info.networkIdTimestamp != 0) {
155         LnnUpdateLocalNetworkIdTime(info.networkIdTimestamp);
156         LNN_LOGD(LNN_LEDGER, "update networkIdTimestamp=%" PRId64, info.networkIdTimestamp);
157     }
158 }
159 
RestoreLocalDeviceInfo(void)160 void RestoreLocalDeviceInfo(void)
161 {
162     LNN_LOGI(LNN_LEDGER, "restore local device info enter");
163     LnnSetLocalFeature();
164     if (g_isRestore) {
165         LNN_LOGI(LNN_LEDGER, "aready init");
166         return;
167     }
168     if (LnnLoadLocalDeviceInfo() != SOFTBUS_OK) {
169         LNN_LOGI(LNN_LEDGER, "get local device info fail");
170         const NodeInfo *temp = LnnGetLocalNodeInfo();
171         if (LnnSaveLocalDeviceInfo(temp) != SOFTBUS_OK) {
172             LNN_LOGE(LNN_LEDGER, "save local device info fail");
173         } else {
174             LNN_LOGI(LNN_LEDGER, "save local device info success");
175         }
176     } else {
177         ProcessLocalDeviceInfo();
178     }
179     AuthLoadDeviceKey();
180     LnnLoadPtkInfo();
181     if (LnnLoadRemoteDeviceInfo() != SOFTBUS_OK) {
182         LNN_LOGE(LNN_LEDGER, "load remote deviceInfo fail");
183         return;
184     }
185     LoadBleBroadcastKey();
186     LnnLoadLocalBroadcastCipherKey();
187 }
188 
LnnInitNetLedgerDelay(void)189 int32_t LnnInitNetLedgerDelay(void)
190 {
191     LnnLoadLocalDeviceAccountIdInfo();
192     RestoreLocalDeviceInfo();
193     if (LnnInitLocalLedgerDelay() != SOFTBUS_OK) {
194         LNN_LOGE(LNN_LEDGER, "delay init local ledger fail");
195         return SOFTBUS_ERR;
196     }
197     if (LnnInitDecisionDbDelay() != SOFTBUS_OK) {
198         LNN_LOGE(LNN_LEDGER, "delay init decision db fail");
199         return SOFTBUS_ERR;
200     }
201     return SOFTBUS_OK;
202 }
203 
LnnInitEventMoniterDelay(void)204 int32_t LnnInitEventMoniterDelay(void)
205 {
206     if (LnnInitCommonEventMonitorImpl() != SOFTBUS_OK) {
207         LNN_LOGE(LNN_LEDGER, "delay init LnnInitCommonEventMonitorImpl fail");
208         return SOFTBUS_ERR;
209     }
210     if (LnnInitDeviceNameMonitorImpl() != SOFTBUS_OK) {
211         LNN_LOGE(LNN_LEDGER, "delay init LnnInitDeviceNameMonitorImpl fail");
212         return SOFTBUS_ERR;
213     }
214     LnnInitOOBEStateMonitorImpl();
215     return SOFTBUS_OK;
216 }
217 
LnnDeinitNetLedger(void)218 void LnnDeinitNetLedger(void)
219 {
220     LnnDeinitMetaNodeLedger();
221     LnnDeinitDistributedLedger();
222     LnnDeinitLocalLedger();
223     LnnDeinitHuksInterface();
224     LnnDeinitMetaNodeExtLedger();
225     LnnDeInitCloudSyncModule();
226 }
227 
LnnGetNodeKeyInfoLocal(const char * networkId,int key,uint8_t * info,uint32_t infoLen)228 static int32_t LnnGetNodeKeyInfoLocal(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
229 {
230     if (networkId == NULL || info == NULL) {
231         LNN_LOGE(LNN_LEDGER, "params are null");
232         return SOFTBUS_ERR;
233     }
234     switch (key) {
235         case NODE_KEY_UDID:
236             return LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, (char *)info, infoLen);
237         case NODE_KEY_UUID:
238             return LnnGetLocalStrInfo(STRING_KEY_UUID, (char *)info, infoLen);
239         case NODE_KEY_MASTER_UDID:
240             return LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, (char *)info, infoLen);
241         case NODE_KEY_BR_MAC:
242             return LnnGetLocalStrInfo(STRING_KEY_BT_MAC, (char *)info, infoLen);
243         case NODE_KEY_IP_ADDRESS:
244             return LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, (char *)info, infoLen);
245         case NODE_KEY_DEV_NAME:
246             return LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, (char *)info, infoLen);
247         case NODE_KEY_BLE_OFFLINE_CODE:
248             return LnnGetLocalStrInfo(STRING_KEY_OFFLINE_CODE, (char *)info, infoLen);
249         case NODE_KEY_NETWORK_CAPABILITY:
250             return LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, (uint32_t *)info);
251         case NODE_KEY_NETWORK_TYPE:
252             return LnnGetLocalNumInfo(NUM_KEY_DISCOVERY_TYPE, (int32_t *)info);
253         case NODE_KEY_DATA_CHANGE_FLAG:
254             return LnnGetLocalNum16Info(NUM_KEY_DATA_CHANGE_FLAG, (int16_t *)info);
255         case NODE_KEY_NODE_ADDRESS:
256             return LnnGetLocalStrInfo(STRING_KEY_NODE_ADDR, (char *)info, infoLen);
257         case NODE_KEY_P2P_IP_ADDRESS:
258             return LnnGetLocalStrInfo(STRING_KEY_P2P_IP, (char *)info, infoLen);
259         case NODE_KEY_DEVICE_SECURITY_LEVEL:
260             return LnnGetLocalNumInfo(NUM_KEY_DEVICE_SECURITY_LEVEL, (int32_t *)info);
261         case NODE_KEY_DEVICE_SCREEN_STATUS:
262             return LnnGetLocalBoolInfo(BOOL_KEY_SCREEN_STATUS, (bool*)info, NODE_SCREEN_STATUS_LEN);
263         default:
264             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
265             return SOFTBUS_ERR;
266     }
267 }
268 
LnnGetNodeKeyInfoRemote(const char * networkId,int key,uint8_t * info,uint32_t infoLen)269 static int32_t LnnGetNodeKeyInfoRemote(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
270 {
271     if (networkId == NULL || info == NULL) {
272         LNN_LOGE(LNN_LEDGER, "params are null");
273         return SOFTBUS_INVALID_PARAM;
274     }
275     switch (key) {
276         case NODE_KEY_UDID:
277             return LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_UDID, (char *)info, infoLen);
278         case NODE_KEY_UUID:
279             return LnnGetRemoteStrInfo(networkId, STRING_KEY_UUID, (char *)info, infoLen);
280         case NODE_KEY_BR_MAC:
281             return LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, (char *)info, infoLen);
282         case NODE_KEY_IP_ADDRESS:
283             return LnnGetRemoteStrInfo(networkId, STRING_KEY_WLAN_IP, (char *)info, infoLen);
284         case NODE_KEY_DEV_NAME:
285             return LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_NAME, (char *)info, infoLen);
286         case NODE_KEY_BLE_OFFLINE_CODE:
287             return LnnGetRemoteStrInfo(networkId, STRING_KEY_OFFLINE_CODE, (char *)info, infoLen);
288         case NODE_KEY_NETWORK_CAPABILITY:
289             return LnnGetRemoteNumU32Info(networkId, NUM_KEY_NET_CAP, (uint32_t *)info);
290         case NODE_KEY_NETWORK_TYPE:
291             return LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, (int32_t *)info);
292         case NODE_KEY_DATA_CHANGE_FLAG:
293             return LnnGetRemoteNum16Info(networkId, NUM_KEY_DATA_CHANGE_FLAG, (int16_t *)info);
294         case NODE_KEY_NODE_ADDRESS:
295             return LnnGetRemoteStrInfo(networkId, STRING_KEY_NODE_ADDR, (char *)info, infoLen);
296         case NODE_KEY_P2P_IP_ADDRESS:
297             return LnnGetRemoteStrInfo(networkId, STRING_KEY_P2P_IP, (char *)info, infoLen);
298         case NODE_KEY_DEVICE_SECURITY_LEVEL:
299             return LnnGetRemoteNumInfo(networkId, NUM_KEY_DEVICE_SECURITY_LEVEL, (int32_t *)info);
300         case NODE_KEY_DEVICE_SCREEN_STATUS:
301             return LnnGetRemoteBoolInfo(networkId, BOOL_KEY_SCREEN_STATUS, (bool*)info);
302         default:
303             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
304             return SOFTBUS_ERR;
305     }
306 }
307 
LnnGetNodeKeyInfo(const char * networkId,int key,uint8_t * info,uint32_t infoLen)308 int32_t LnnGetNodeKeyInfo(const char *networkId, int key, uint8_t *info, uint32_t infoLen)
309 {
310     bool isLocalNetworkId = false;
311     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
312     if (networkId == NULL || info == NULL) {
313         LNN_LOGE(LNN_LEDGER, "params are null");
314         return SOFTBUS_INVALID_PARAM;
315     }
316     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
317         LNN_LOGE(LNN_LEDGER, "get local network id fail");
318         return SOFTBUS_ERR;
319     }
320     if (strncmp(localNetworkId, networkId, NETWORK_ID_BUF_LEN) == 0) {
321         isLocalNetworkId = true;
322     }
323     if (isLocalNetworkId) {
324         return LnnGetNodeKeyInfoLocal(networkId, key, info, infoLen);
325     } else {
326         return LnnGetNodeKeyInfoRemote(networkId, key, info, infoLen);
327     }
328 }
329 
LnnGetPrivateNodeKeyInfoLocal(const char * networkId,InfoKey key,uint8_t * info,uint32_t infoLen)330 static int32_t LnnGetPrivateNodeKeyInfoLocal(const char *networkId, InfoKey key, uint8_t *info, uint32_t infoLen)
331 {
332     if (networkId == NULL || info == NULL) {
333         LNN_LOGE(LNN_LEDGER, "params are null");
334         return SOFTBUS_INVALID_PARAM;
335     }
336     switch (key) {
337         case BYTE_KEY_IRK:
338             return LnnGetLocalByteInfo(BYTE_KEY_IRK, info, infoLen);
339         case BYTE_KEY_BROADCAST_CIPHER_KEY:
340             return LnnGetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_KEY, info, infoLen);
341         case BYTE_KEY_ACCOUNT_HASH:
342             return LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, info, infoLen);
343         case BYTE_KEY_REMOTE_PTK:
344             return LnnGetLocalByteInfo(BYTE_KEY_REMOTE_PTK, info, infoLen);
345         default:
346             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
347             return SOFTBUS_INVALID_PARAM;
348     }
349 }
350 
LnnGetPrivateNodeKeyInfoRemote(const char * networkId,InfoKey key,uint8_t * info,uint32_t infoLen)351 static int32_t LnnGetPrivateNodeKeyInfoRemote(const char *networkId, InfoKey key, uint8_t *info, uint32_t infoLen)
352 {
353     if (networkId == NULL || info == NULL) {
354         LNN_LOGE(LNN_LEDGER, "params are null");
355         return SOFTBUS_INVALID_PARAM;
356     }
357     switch (key) {
358         case BYTE_KEY_IRK:
359             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_IRK, info, infoLen);
360         case BYTE_KEY_BROADCAST_CIPHER_KEY:
361             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_BROADCAST_CIPHER_KEY, info, infoLen);
362         case BYTE_KEY_ACCOUNT_HASH:
363             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_ACCOUNT_HASH, info, infoLen);
364         case BYTE_KEY_REMOTE_PTK:
365             return LnnGetRemoteByteInfo(networkId, BYTE_KEY_REMOTE_PTK, info, infoLen);
366         default:
367             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
368             return SOFTBUS_INVALID_PARAM;
369     }
370 }
371 
LnnGetPrivateNodeKeyInfo(const char * networkId,InfoKey key,uint8_t * info,uint32_t infoLen)372 static int32_t LnnGetPrivateNodeKeyInfo(const char *networkId, InfoKey key, uint8_t *info, uint32_t infoLen)
373 {
374     if (networkId == NULL || info == NULL) {
375         LNN_LOGE(LNN_LEDGER, "params are null");
376         return SOFTBUS_INVALID_PARAM;
377     }
378     bool isLocalNetworkId = false;
379     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
380     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
381         LNN_LOGE(LNN_LEDGER, "get local network id fail");
382         return SOFTBUS_NOT_FIND;
383     }
384     if (strncmp(localNetworkId, networkId, NETWORK_ID_BUF_LEN) == 0) {
385         isLocalNetworkId = true;
386     }
387     if (isLocalNetworkId) {
388         return LnnGetPrivateNodeKeyInfoLocal(networkId, key, info, infoLen);
389     } else {
390         return LnnGetPrivateNodeKeyInfoRemote(networkId, key, info, infoLen);
391     }
392 }
393 
LnnSetNodeDataChangeFlag(const char * networkId,uint16_t dataChangeFlag)394 int32_t LnnSetNodeDataChangeFlag(const char *networkId, uint16_t dataChangeFlag)
395 {
396     bool isLocalNetworkId = false;
397     char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
398     if (networkId == NULL) {
399         LNN_LOGE(LNN_LEDGER, "params are null");
400         return SOFTBUS_INVALID_PARAM;
401     }
402     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
403         LNN_LOGE(LNN_LEDGER, "get local network id fail");
404         return SOFTBUS_ERR;
405     }
406     if (strncmp(localNetworkId, networkId, NETWORK_ID_BUF_LEN) == 0) {
407         isLocalNetworkId = true;
408     }
409     if (isLocalNetworkId) {
410         return LnnSetLocalNum16Info(NUM_KEY_DATA_CHANGE_FLAG, (int16_t)dataChangeFlag);
411     }
412     LNN_LOGE(LNN_LEDGER, "remote networkId");
413     return SOFTBUS_ERR;
414 }
415 
LnnSetDataLevel(const DataLevel * dataLevel,bool * isSwitchLevelChanged)416 int32_t LnnSetDataLevel(const DataLevel *dataLevel, bool *isSwitchLevelChanged)
417 {
418     if (dataLevel == NULL || isSwitchLevelChanged == NULL) {
419         LNN_LOGE(LNN_LEDGER, "LnnSetDataLevel data level or switch level change flag is null");
420         return SOFTBUS_ERR;
421     }
422     LNN_LOGI(LNN_LEDGER, "LnnSetDataLevel, dynamic: %{public}hu, static: %{public}hu, "
423         "switch: %{public}u, switchLen: %{public}hu", dataLevel->dynamicLevel, dataLevel->staticLevel,
424         dataLevel->switchLevel, dataLevel->switchLength);
425     uint16_t dynamicLevel = dataLevel->dynamicLevel;
426     if (LnnSetLocalNumU16Info(NUM_KEY_DATA_DYNAMIC_LEVEL, dynamicLevel) != SOFTBUS_OK) {
427         LNN_LOGE(LNN_LEDGER, "Set data dynamic level failed");
428         return SOFTBUS_ERR;
429     }
430     uint16_t staticLevel = dataLevel->staticLevel;
431     if (LnnSetLocalNumU16Info(NUM_KEY_DATA_STATIC_LEVEL, staticLevel) != SOFTBUS_OK) {
432         LNN_LOGE(LNN_LEDGER, "Set data static level failed");
433         return SOFTBUS_ERR;
434     }
435     uint32_t curSwitchLevel = 0;
436     if (LnnGetLocalNumU32Info(NUM_KEY_DATA_SWITCH_LEVEL, &curSwitchLevel) != SOFTBUS_OK) {
437         LNN_LOGE(LNN_LEDGER, "Get current data switch level faield");
438         return SOFTBUS_ERR;
439     }
440     uint32_t switchLevel = dataLevel->switchLevel;
441     if (LnnSetLocalNumU32Info(NUM_KEY_DATA_SWITCH_LEVEL, switchLevel) != SOFTBUS_OK) {
442         LNN_LOGE(LNN_LEDGER, "Set data switch level faield");
443         return SOFTBUS_ERR;
444     }
445     uint16_t switchLength = dataLevel->switchLength;
446     if (LnnSetLocalNumU16Info(NUM_KEY_DATA_SWITCH_LENGTH, switchLength) != SOFTBUS_OK) {
447         LNN_LOGE(LNN_LEDGER, "Set data switch length failed");
448         return SOFTBUS_ERR;
449     }
450     *isSwitchLevelChanged = (curSwitchLevel != switchLevel);
451     return SOFTBUS_OK;
452 }
453 
LnnGetNodeKeyInfoLen(int32_t key)454 int32_t LnnGetNodeKeyInfoLen(int32_t key)
455 {
456     switch (key) {
457         case NODE_KEY_UDID:
458             return UDID_BUF_LEN;
459         case NODE_KEY_UUID:
460             return UUID_BUF_LEN;
461         case NODE_KEY_MASTER_UDID:
462             return UDID_BUF_LEN;
463         case NODE_KEY_BR_MAC:
464             return MAC_LEN;
465         case NODE_KEY_IP_ADDRESS:
466             return IP_LEN;
467         case NODE_KEY_DEV_NAME:
468             return DEVICE_NAME_BUF_LEN;
469         case NODE_KEY_NETWORK_CAPABILITY:
470             return LNN_COMMON_LEN;
471         case NODE_KEY_NETWORK_TYPE:
472             return LNN_COMMON_LEN;
473         case NODE_KEY_DATA_CHANGE_FLAG:
474             return DATA_CHANGE_FLAG_BUF_LEN;
475         case NODE_KEY_NODE_ADDRESS:
476             return SHORT_ADDRESS_MAX_LEN;
477         case NODE_KEY_P2P_IP_ADDRESS:
478             return IP_LEN;
479         case NODE_KEY_DEVICE_SECURITY_LEVEL:
480             return LNN_COMMON_LEN;
481         case NODE_KEY_DEVICE_SCREEN_STATUS:
482             return DATA_DEVICE_SCREEN_STATUS_LEN;
483         default:
484             LNN_LOGE(LNN_LEDGER, "invalid node key type=%{public}d", key);
485             return SOFTBUS_ERR;
486     }
487 }
488 
SoftbusDumpPrintAccountId(int fd,NodeBasicInfo * nodeInfo)489 static int32_t SoftbusDumpPrintAccountId(int fd, NodeBasicInfo *nodeInfo)
490 {
491     if (nodeInfo == NULL) {
492         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
493         return SOFTBUS_INVALID_PARAM;
494     }
495     char accountHash[SHA_256_HASH_LEN] = {0};
496     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_ACCOUNT_HASH,
497         (uint8_t *)&accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
498         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo account hash failed");
499         return SOFTBUS_NOT_FIND;
500     }
501     char accountHashStr[SHA_256_HEX_HASH_LEN] = {0};
502     if (ConvertBytesToHexString(accountHashStr, SHA_256_HEX_HASH_LEN,
503         (unsigned char *)accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
504         LNN_LOGE(LNN_LEDGER, "convert account to string fail.");
505         return SOFTBUS_BYTE_CONVERT_FAIL;
506     }
507     char *anonyAccountHash = NULL;
508     Anonymize(accountHashStr, &anonyAccountHash);
509     SOFTBUS_DPRINTF(fd, "AccountHash->%s\n", anonyAccountHash);
510     AnonymizeFree(anonyAccountHash);
511     return SOFTBUS_OK;
512 }
513 
SoftbusDumpPrintUdid(int fd,NodeBasicInfo * nodeInfo)514 int32_t SoftbusDumpPrintUdid(int fd, NodeBasicInfo *nodeInfo)
515 {
516     NodeDeviceInfoKey key;
517     key = NODE_KEY_UDID;
518     unsigned char udid[UDID_BUF_LEN] = {0};
519 
520     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
521         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo Udid failed");
522         return SOFTBUS_NOT_FIND;
523     }
524     char *anonyUdid = NULL;
525     Anonymize((char *)udid, &anonyUdid);
526     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "Udid", anonyUdid);
527     AnonymizeFree(anonyUdid);
528     return SOFTBUS_OK;
529 }
530 
SoftbusDumpPrintUuid(int fd,NodeBasicInfo * nodeInfo)531 int32_t SoftbusDumpPrintUuid(int fd, NodeBasicInfo *nodeInfo)
532 {
533     NodeDeviceInfoKey key;
534     key = NODE_KEY_UUID;
535     unsigned char uuid[UUID_BUF_LEN] = {0};
536 
537     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
538         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo Uuid failed");
539         return SOFTBUS_NOT_FIND;
540     }
541     char *anonyUuid = NULL;
542     Anonymize((char *)uuid, &anonyUuid);
543     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "Uuid", anonyUuid);
544     AnonymizeFree(anonyUuid);
545     return SOFTBUS_OK;
546 }
547 
SoftbusDumpPrintMac(int fd,NodeBasicInfo * nodeInfo)548 int32_t SoftbusDumpPrintMac(int fd, NodeBasicInfo *nodeInfo)
549 {
550     NodeDeviceInfoKey key;
551     key = NODE_KEY_BR_MAC;
552     unsigned char brMac[BT_MAC_LEN] = {0};
553     char newBrMac[BT_MAC_LEN] = {0};
554 
555     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, brMac, BT_MAC_LEN) != SOFTBUS_OK) {
556         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo brMac failed");
557         return SOFTBUS_NOT_FIND;
558     }
559     DataMasking((char *)brMac, BT_MAC_LEN, MAC_DELIMITER, newBrMac);
560     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "BrMac", newBrMac);
561     return SOFTBUS_OK;
562 }
563 
SoftbusDumpPrintIp(int fd,NodeBasicInfo * nodeInfo)564 int32_t SoftbusDumpPrintIp(int fd, NodeBasicInfo *nodeInfo)
565 {
566     NodeDeviceInfoKey key;
567     key = NODE_KEY_IP_ADDRESS;
568     char ipAddr[IP_STR_MAX_LEN] = {0};
569     char newIpAddr[IP_STR_MAX_LEN] = {0};
570 
571     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)ipAddr, IP_STR_MAX_LEN) != SOFTBUS_OK) {
572         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo ipAddr failed");
573         return SOFTBUS_NOT_FIND;
574     }
575     DataMasking((char *)ipAddr, IP_STR_MAX_LEN, IP_DELIMITER, newIpAddr);
576     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "IpAddr", newIpAddr);
577     return SOFTBUS_OK;
578 }
579 
SoftbusDumpPrintNetCapacity(int fd,NodeBasicInfo * nodeInfo)580 int32_t SoftbusDumpPrintNetCapacity(int fd, NodeBasicInfo *nodeInfo)
581 {
582     NodeDeviceInfoKey key;
583     key = NODE_KEY_NETWORK_CAPABILITY;
584     int32_t netCapacity = 0;
585     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&netCapacity, sizeof(netCapacity)) != SOFTBUS_OK) {
586         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo netCapacity failed");
587         return SOFTBUS_NOT_FIND;
588     }
589     SOFTBUS_DPRINTF(fd, "  %-15s->%d\n", "NetCapacity", netCapacity);
590     return SOFTBUS_OK;
591 }
592 
SoftbusDumpPrintNetType(int fd,NodeBasicInfo * nodeInfo)593 int32_t SoftbusDumpPrintNetType(int fd, NodeBasicInfo *nodeInfo)
594 {
595     NodeDeviceInfoKey key;
596     key = NODE_KEY_NETWORK_TYPE;
597     int32_t netType = 0;
598     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&netType, sizeof(netType)) != SOFTBUS_OK) {
599         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo netType failed");
600         return SOFTBUS_NOT_FIND;
601     }
602     SOFTBUS_DPRINTF(fd, "  %-15s->%d\n", "NetType", netType);
603     return SOFTBUS_OK;
604 }
605 
SoftbusDumpPrintDeviceLevel(int fd,NodeBasicInfo * nodeInfo)606 static int32_t SoftbusDumpPrintDeviceLevel(int fd, NodeBasicInfo *nodeInfo)
607 {
608     if (nodeInfo == NULL) {
609         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
610         return SOFTBUS_INVALID_PARAM;
611     }
612     NodeDeviceInfoKey key;
613     key = NODE_KEY_DEVICE_SECURITY_LEVEL;
614     int32_t securityLevel = 0;
615     if (LnnGetNodeKeyInfo(nodeInfo->networkId, key, (uint8_t *)&securityLevel, sizeof(securityLevel)) != SOFTBUS_OK) {
616         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo securityLevel failed");
617         return SOFTBUS_NOT_FIND;
618     }
619     SOFTBUS_DPRINTF(fd, "  %-15s->%d\n", "SecurityLevel", securityLevel);
620     return SOFTBUS_OK;
621 }
622 
SoftbusDumpPrintScreenStatus(int fd,NodeBasicInfo * nodeInfo)623 static int32_t SoftbusDumpPrintScreenStatus(int fd, NodeBasicInfo *nodeInfo)
624 {
625     if (nodeInfo == NULL) {
626         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
627         return SOFTBUS_INVALID_PARAM;
628     }
629     bool isScreenOn = false;
630     if (LnnGetNodeKeyInfo(nodeInfo->networkId, NODE_KEY_DEVICE_SCREEN_STATUS, (uint8_t *)&isScreenOn,
631         DATA_DEVICE_SCREEN_STATUS_LEN) != SOFTBUS_OK) {
632         LNN_LOGE(LNN_LEDGER, "LnnGetNodeKeyInfo isScreenOn failed");
633         return SOFTBUS_NOT_FIND;
634     }
635     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "isScreenOn", isScreenOn ? "on" : "off");
636     return SOFTBUS_OK;
637 }
638 
SoftbusDumpPrintIrk(int fd,NodeBasicInfo * nodeInfo)639 static int32_t SoftbusDumpPrintIrk(int fd, NodeBasicInfo *nodeInfo)
640 {
641     if (nodeInfo == NULL) {
642         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
643         return SOFTBUS_INVALID_PARAM;
644     }
645     uint8_t irk[LFINDER_IRK_LEN] = {0};
646     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_IRK,
647         (uint8_t *)&irk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
648         LNN_LOGE(LNN_LEDGER, "LnnGetPrivateNodeKeyInfo irk failed");
649         return SOFTBUS_NOT_FIND;
650     }
651     char peerIrkStr[LFINDER_IRK_STR_LEN] = {0};
652     if (ConvertBytesToHexString(peerIrkStr, LFINDER_IRK_STR_LEN, irk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
653         LNN_LOGE(LNN_LEDGER, "convert irk to string fail.");
654         return SOFTBUS_BYTE_CONVERT_FAIL;
655     }
656     char *anonyIrk = NULL;
657     Anonymize(peerIrkStr, &anonyIrk);
658     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "IRK", anonyIrk);
659     AnonymizeFree(anonyIrk);
660     return SOFTBUS_OK;
661 }
662 
SoftbusDumpPrintBroadcastCipher(int fd,NodeBasicInfo * nodeInfo)663 static int32_t SoftbusDumpPrintBroadcastCipher(int fd, NodeBasicInfo *nodeInfo)
664 {
665     if (nodeInfo == NULL) {
666         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
667         return SOFTBUS_INVALID_PARAM;
668     }
669     unsigned char broadcastCipher[SESSION_KEY_LENGTH] = {0};
670     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_BROADCAST_CIPHER_KEY,
671         (uint8_t *)&broadcastCipher, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
672         LNN_LOGE(LNN_LEDGER, "LnnGetPrivateNodeKeyInfo broadcastCipher failed");
673         return SOFTBUS_NOT_FIND;
674     }
675     char broadcastCipherStr[SESSION_KEY_STR_LEN] = {0};
676     if (ConvertBytesToHexString(broadcastCipherStr, SESSION_KEY_STR_LEN,
677         broadcastCipher, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
678         LNN_LOGE(LNN_LEDGER, "convert broadcastCipher to string fail.");
679         return SOFTBUS_BYTE_CONVERT_FAIL;
680     }
681     char *anonyBroadcastCipher = NULL;
682     Anonymize((char *)broadcastCipherStr, &anonyBroadcastCipher);
683     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "BroadcastCipher", anonyBroadcastCipher);
684     AnonymizeFree(anonyBroadcastCipher);
685     return SOFTBUS_OK;
686 }
687 
SoftbusDumpPrintRemotePtk(int fd,NodeBasicInfo * nodeInfo)688 static int32_t SoftbusDumpPrintRemotePtk(int fd, NodeBasicInfo *nodeInfo)
689 {
690     if (nodeInfo == NULL) {
691         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
692         return SOFTBUS_INVALID_PARAM;
693     }
694     char remotePtk[PTK_DEFAULT_LEN] = {0};
695     if (LnnGetPrivateNodeKeyInfo(nodeInfo->networkId, BYTE_KEY_REMOTE_PTK,
696         (uint8_t *)&remotePtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
697         LNN_LOGE(LNN_LEDGER, "LnnGetPrivateNodeKeyInfo ptk failed");
698         return SOFTBUS_NOT_FIND;
699     }
700     char remotePtkStr[PTK_STR_LEN] = {0};
701     if (ConvertBytesToHexString(remotePtkStr, PTK_STR_LEN,
702         (unsigned char *)remotePtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
703         LNN_LOGE(LNN_LEDGER, "convert remotePtk to string fail.");
704         return SOFTBUS_BYTE_CONVERT_FAIL;
705     }
706     char *anonyRemotePtk = NULL;
707     Anonymize(remotePtkStr, &anonyRemotePtk);
708     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "RemotePtk", anonyRemotePtk);
709     AnonymizeFree(anonyRemotePtk);
710     return SOFTBUS_OK;
711 }
712 
SoftbusDumpPrintLocalPtk(int fd,NodeBasicInfo * nodeInfo)713 static int32_t SoftbusDumpPrintLocalPtk(int fd, NodeBasicInfo *nodeInfo)
714 {
715     if (nodeInfo == NULL) {
716         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
717         return SOFTBUS_INVALID_PARAM;
718     }
719     char peerUuid[UUID_BUF_LEN] = {0};
720     if (LnnGetRemoteStrInfo(nodeInfo->networkId, STRING_KEY_UUID, peerUuid, UUID_BUF_LEN) != SOFTBUS_OK) {
721         LNN_LOGE(LNN_LEDGER, "gey peerUuid failed");
722         return SOFTBUS_NOT_FIND;
723     }
724     char localPtk[PTK_DEFAULT_LEN] = {0};
725     if (LnnGetLocalPtkByUuid(peerUuid, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
726         LNN_LOGE(LNN_LEDGER, "LnnGetLocalPtkByUuid failed");
727         return SOFTBUS_NOT_FIND;
728     }
729     char localPtkStr[PTK_STR_LEN] = {0};
730     if (ConvertBytesToHexString(localPtkStr, PTK_STR_LEN,
731         (unsigned char *)localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
732         LNN_LOGE(LNN_LEDGER, "convert localPtk to string fail.");
733         return SOFTBUS_BYTE_CONVERT_FAIL;
734     }
735     char *anonyLocalPtk = NULL;
736     Anonymize(localPtkStr, &anonyLocalPtk);
737     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "LocalPtk", anonyLocalPtk);
738     AnonymizeFree(anonyLocalPtk);
739     return SOFTBUS_OK;
740 }
741 
SoftbusDumpDeviceInfo(int fd,NodeBasicInfo * nodeInfo)742 static void SoftbusDumpDeviceInfo(int fd, NodeBasicInfo *nodeInfo)
743 {
744     SOFTBUS_DPRINTF(fd, "DeviceInfo:\n");
745     if (fd <= 0 || nodeInfo == NULL) {
746         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
747         return;
748     }
749     char *anonyNetworkId = NULL;
750     Anonymize(nodeInfo->networkId, &anonyNetworkId);
751     SOFTBUS_DPRINTF(fd, "  %-15s->%s\n", "NetworkId", anonyNetworkId);
752     AnonymizeFree(anonyNetworkId);
753     if (SoftbusDumpPrintUdid(fd, nodeInfo) != SOFTBUS_OK) {
754         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintUdid failed");
755     }
756     if (SoftbusDumpPrintUuid(fd, nodeInfo) != SOFTBUS_OK) {
757         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintUuid failed");
758     }
759     if (SoftbusDumpPrintNetCapacity(fd, nodeInfo) != SOFTBUS_OK) {
760         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintNetCapacity failed");
761     }
762     if (SoftbusDumpPrintNetType(fd, nodeInfo) != SOFTBUS_OK) {
763         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintNetType failed");
764     }
765     if (SoftbusDumpPrintDeviceLevel(fd, nodeInfo) != SOFTBUS_OK) {
766         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintDeviceLevel failed");
767     }
768     if (SoftbusDumpPrintScreenStatus(fd, nodeInfo) != SOFTBUS_OK) {
769         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintScreenStatus failed");
770     }
771 }
772 
SoftbusDumpDeviceAddr(int fd,NodeBasicInfo * nodeInfo)773 static void SoftbusDumpDeviceAddr(int fd, NodeBasicInfo *nodeInfo)
774 {
775     SOFTBUS_DPRINTF(fd, "DeviceAddr:\n");
776     if (fd <= 0 || nodeInfo == NULL) {
777         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
778         return;
779     }
780     if (SoftbusDumpPrintMac(fd, nodeInfo) != SOFTBUS_OK) {
781         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintMac failed");
782     }
783     if (SoftbusDumpPrintIp(fd, nodeInfo) != SOFTBUS_OK) {
784         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintIp failed");
785     }
786 }
787 
SoftbusDumpDeviceCipher(int fd,NodeBasicInfo * nodeInfo)788 static void SoftbusDumpDeviceCipher(int fd, NodeBasicInfo *nodeInfo)
789 {
790     SOFTBUS_DPRINTF(fd, "DeviceCipher:\n");
791     if (fd <= 0 || nodeInfo == NULL) {
792         LNN_LOGE(LNN_LEDGER, "Invalid parameter");
793         return;
794     }
795     if (SoftbusDumpPrintIrk(fd, nodeInfo) != SOFTBUS_OK) {
796         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintIrk failed");
797     }
798     if (SoftbusDumpPrintBroadcastCipher(fd, nodeInfo) != SOFTBUS_OK) {
799         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintBroadcastCipher failed");
800     }
801     if (SoftbusDumpPrintRemotePtk(fd, nodeInfo) != SOFTBUS_OK) {
802         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintRemotePtk failed");
803     }
804     if (SoftbusDumpPrintLocalPtk(fd, nodeInfo) != SOFTBUS_OK) {
805         LNN_LOGE(LNN_LEDGER, "SoftbusDumpPrintLocalPtk failed");
806     }
807 }
808 
SoftBusDumpBusCenterPrintInfo(int fd,NodeBasicInfo * nodeInfo)809 void SoftBusDumpBusCenterPrintInfo(int fd, NodeBasicInfo *nodeInfo)
810 {
811     if (fd <= 0 || nodeInfo == NULL) {
812         LNN_LOGE(LNN_LEDGER, "param is null");
813         return;
814     }
815     char *anonyDeviceName = NULL;
816     Anonymize(nodeInfo->deviceName, &anonyDeviceName);
817     SOFTBUS_DPRINTF(fd, "DeviceName->%s\n", anonyDeviceName);
818     AnonymizeFree(anonyDeviceName);
819     SoftbusDumpPrintAccountId(fd, nodeInfo);
820     SoftbusDumpDeviceInfo(fd, nodeInfo);
821     SoftbusDumpDeviceAddr(fd, nodeInfo);
822     SoftbusDumpDeviceCipher(fd, nodeInfo);
823 }
824