1 /*
2 * Copyright (c) 2021-2025 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_distributed_net_ledger_common.h"
17
18 #include <stddef.h>
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include <securec.h>
24
25 #include "lnn_event.h"
26 #include "anonymizer.h"
27 #include "auth_common.h"
28 #include "auth_deviceprofile.h"
29 #include "bus_center_manager.h"
30 #include "bus_center_event.h"
31 #include "g_enhance_lnn_func.h"
32 #include "g_enhance_lnn_func_pack.h"
33 #include "lnn_connection_addr_utils.h"
34
35 #include "lnn_map.h"
36 #include "lnn_net_builder.h"
37 #include "lnn_node_info.h"
38 #include "lnn_lane_def.h"
39 #include "lnn_decision_db.h"
40 #include "lnn_deviceinfo_to_profile.h"
41 #include "lnn_feature_capability.h"
42 #include "lnn_local_net_ledger.h"
43 #include "lnn_log.h"
44 #include "lnn_ohos_account.h"
45 #include "softbus_adapter_mem.h"
46 #include "softbus_adapter_thread.h"
47 #include "softbus_adapter_crypto.h"
48 #include "softbus_bus_center.h"
49 #include "softbus_def.h"
50 #include "softbus_error_code.h"
51 #include "softbus_adapter_crypto.h"
52 #include "softbus_json_utils.h"
53 #include "softbus_utils.h"
54 #include "softbus_init_common.h"
55 #include "legacy/softbus_hidumper_buscenter.h"
56 #include "legacy/softbus_hisysevt_bus_center.h"
57
58 DistributedNetLedger g_distributedNetLedger;
59
LnnGetDistributedNetLedger(void)60 DistributedNetLedger* LnnGetDistributedNetLedger(void)
61 {
62 return &g_distributedNetLedger;
63 }
64
UpdateNetworkInfo(const char * udid)65 static void UpdateNetworkInfo(const char *udid)
66 {
67 NodeBasicInfo basic;
68 if (memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo)) != EOK) {
69 LNN_LOGE(LNN_LEDGER, "memset_s basic fail!");
70 }
71 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
72 LNN_LOGE(LNN_LEDGER, "GetBasicInfoByUdid fail.");
73 return;
74 }
75 LnnNotifyBasicInfoChanged(&basic, TYPE_NETWORK_INFO);
76 }
77
UpdateDeviceNameInfo(const char * udid,const char * oldDeviceName)78 static void UpdateDeviceNameInfo(const char *udid, const char *oldDeviceName)
79 {
80 NodeBasicInfo basic;
81 if (memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo)) != EOK) {
82 LNN_LOGE(LNN_LEDGER, "memset_s basic fail!");
83 return;
84 }
85 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
86 LNN_LOGE(LNN_LEDGER, "GetBasicInfoByUdid fail.");
87 return;
88 }
89 char *anonyOldDeviceName = NULL;
90 AnonymizeDeviceName(oldDeviceName, &anonyOldDeviceName);
91 char *anonyDeviceName = NULL;
92 AnonymizeDeviceName(basic.deviceName, &anonyDeviceName);
93 LNN_LOGI(LNN_LEDGER, "report deviceName update, name:%{public}s -> %{public}s.",
94 AnonymizeWrapper(anonyOldDeviceName), AnonymizeWrapper(anonyDeviceName));
95 AnonymizeFree(anonyOldDeviceName);
96 AnonymizeFree(anonyDeviceName);
97 LnnNotifyBasicInfoChanged(&basic, TYPE_DEVICE_NAME);
98 }
99
LnnSetAuthTypeValue(uint32_t * authTypeValue,AuthType type)100 int32_t LnnSetAuthTypeValue(uint32_t *authTypeValue, AuthType type)
101 {
102 if (authTypeValue == NULL || type >= AUTH_TYPE_BUTT) {
103 LNN_LOGE(LNN_LEDGER, "in para error!");
104 return SOFTBUS_INVALID_PARAM;
105 }
106 *authTypeValue = (*authTypeValue) | (1 << (uint32_t)type);
107 return SOFTBUS_OK;
108 }
109
LnnClearAuthTypeValue(uint32_t * authTypeValue,AuthType type)110 int32_t LnnClearAuthTypeValue(uint32_t *authTypeValue, AuthType type)
111 {
112 if (authTypeValue == NULL || type >= AUTH_TYPE_BUTT) {
113 LNN_LOGE(LNN_LEDGER, "in para error!");
114 return SOFTBUS_INVALID_PARAM;
115 }
116 *authTypeValue = (*authTypeValue) & (~(1 << (uint32_t)type));
117 return SOFTBUS_OK;
118 }
119
GetNodeInfoFromMap(const DoubleHashMap * map,const char * id)120 NodeInfo *GetNodeInfoFromMap(const DoubleHashMap *map, const char *id)
121 {
122 if (map == NULL || id == NULL) {
123 LNN_LOGE(LNN_LEDGER, "para error!");
124 return NULL;
125 }
126 NodeInfo *info = NULL;
127 if ((info = (NodeInfo *)LnnMapGet(&map->udidMap, id)) != NULL) {
128 return info;
129 }
130 if ((info = (NodeInfo *)LnnMapGet(&map->macMap, id)) != NULL) {
131 return info;
132 }
133 if ((info = (NodeInfo *)LnnMapGet(&map->ipMap, id)) != NULL) {
134 return info;
135 }
136 LNN_LOGE(LNN_LEDGER, "id not exist!");
137 return NULL;
138 }
139
InitDistributedInfo(DoubleHashMap * map)140 static int32_t InitDistributedInfo(DoubleHashMap *map)
141 {
142 if (map == NULL) {
143 LNN_LOGE(LNN_LEDGER, "fail:para error!");
144 return SOFTBUS_INVALID_PARAM;
145 }
146 LnnMapInit(&map->udidMap);
147 LnnMapInit(&map->ipMap);
148 LnnMapInit(&map->macMap);
149 return SOFTBUS_OK;
150 }
151
DeinitDistributedInfo(DoubleHashMap * map)152 static void DeinitDistributedInfo(DoubleHashMap *map)
153 {
154 if (map == NULL) {
155 LNN_LOGE(LNN_LEDGER, "fail: para error!");
156 return;
157 }
158 LnnMapDelete(&map->udidMap);
159 LnnMapDelete(&map->ipMap);
160 LnnMapDelete(&map->macMap);
161 }
162
InitConnectionCode(ConnectionCode * cnnCode)163 static int32_t InitConnectionCode(ConnectionCode *cnnCode)
164 {
165 if (cnnCode == NULL) {
166 LNN_LOGE(LNN_LEDGER, "fail: para error!");
167 return SOFTBUS_INVALID_PARAM;
168 }
169 LnnMapInit(&cnnCode->connectionCode);
170 return SOFTBUS_OK;
171 }
172
DeinitConnectionCode(ConnectionCode * cnnCode)173 static void DeinitConnectionCode(ConnectionCode *cnnCode)
174 {
175 if (cnnCode == NULL) {
176 LNN_LOGE(LNN_LEDGER, "fail: para error!");
177 return;
178 }
179 LnnMapDelete(&cnnCode->connectionCode);
180 return;
181 }
182
LnnDeinitDistributedLedger(void)183 void LnnDeinitDistributedLedger(void)
184 {
185 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
186 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
187 return;
188 }
189 g_distributedNetLedger.status = DL_INIT_UNKNOWN;
190 DeinitDistributedInfo(&g_distributedNetLedger.distributedInfo);
191 DeinitConnectionCode(&g_distributedNetLedger.cnnCode);
192 if (SoftBusMutexUnlock(&g_distributedNetLedger.lock) != 0) {
193 LNN_LOGE(LNN_LEDGER, "unlock mutex fail!");
194 }
195 SoftBusMutexDestroy(&g_distributedNetLedger.lock);
196 }
197
NewWifiDiscovered(const NodeInfo * oldInfo,NodeInfo * newInfo)198 static void NewWifiDiscovered(const NodeInfo *oldInfo, NodeInfo *newInfo)
199 {
200 const char *macAddr = NULL;
201 if (oldInfo == NULL || newInfo == NULL) {
202 LNN_LOGE(LNN_LEDGER, "para error!");
203 return;
204 }
205 newInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
206 newInfo->stateVersion = oldInfo->stateVersion;
207 macAddr = LnnGetBtMac(newInfo);
208 if (macAddr == NULL) {
209 LNN_LOGE(LNN_LEDGER, "LnnGetBtMac Fail!");
210 return;
211 }
212 if (strcmp(macAddr, DEFAULT_MAC) == 0) {
213 LnnSetBtMac(newInfo, LnnGetBtMac(oldInfo));
214 }
215 }
216
UpdateNodeIpInfo(const NodeInfo * oldInfo,NodeInfo * newInfo,int32_t ifnameIdx)217 static void UpdateNodeIpInfo(const NodeInfo *oldInfo, NodeInfo *newInfo, int32_t ifnameIdx)
218 {
219 if (oldInfo == NULL || newInfo == NULL) {
220 LNN_LOGE(LNN_LEDGER, "para error!");
221 return;
222 }
223 newInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
224 const char *ipAddr = NULL;
225 ipAddr = LnnGetWiFiIp(newInfo, ifnameIdx);
226 if (ipAddr == NULL) {
227 LNN_LOGE(LNN_LEDGER, "LnnGetWiFiIp Fail %{public}d!", ifnameIdx);
228 return;
229 }
230 if (strcmp(ipAddr, DEFAULT_IP) == 0 || strcmp(ipAddr, LOCAL_IP) == 0 || strcmp(ipAddr, LOCAL_IPV6_STR) == 0) {
231 LnnSetWiFiIp(newInfo, LnnGetWiFiIp(oldInfo, ifnameIdx), ifnameIdx);
232 }
233 newInfo->connectInfo.ifInfo[ifnameIdx].authPort = oldInfo->connectInfo.ifInfo[ifnameIdx].authPort;
234 newInfo->connectInfo.ifInfo[ifnameIdx].proxyPort = oldInfo->connectInfo.ifInfo[ifnameIdx].proxyPort;
235 newInfo->connectInfo.ifInfo[ifnameIdx].sessionPort = oldInfo->connectInfo.ifInfo[ifnameIdx].sessionPort;
236 if (ifnameIdx == WLAN_IF) {
237 (void)LnnSetNetCapability(&newInfo->netCapacity, BIT_WIFI);
238 (void)LnnSetNetCapability(&newInfo->netCapacity, BIT_WIFI_P2P);
239 if ((oldInfo->netCapacity & (1 << BIT_WIFI_5G)) != 0) {
240 (void)LnnSetNetCapability(&(newInfo->netCapacity), BIT_WIFI_5G);
241 }
242 if ((oldInfo->netCapacity & (1 << BIT_WIFI_24G)) != 0) {
243 (void)LnnSetNetCapability(&(newInfo->netCapacity), BIT_WIFI_24G);
244 }
245 } else if (ifnameIdx == USB_IF) {
246 if ((oldInfo->netCapacity & (1 << BIT_USB)) != 0) {
247 (void)LnnSetNetCapability(&(newInfo->netCapacity), BIT_USB);
248 }
249 }
250 }
251
RetainOfflineCode(const NodeInfo * oldInfo,NodeInfo * newInfo)252 static void RetainOfflineCode(const NodeInfo *oldInfo, NodeInfo *newInfo)
253 {
254 if (oldInfo == NULL || newInfo == NULL) {
255 LNN_LOGE(LNN_LEDGER, "para error!");
256 return;
257 }
258 if (memcpy_s(newInfo->offlineCode, OFFLINE_CODE_BYTE_SIZE,
259 oldInfo->offlineCode, OFFLINE_CODE_BYTE_SIZE) != SOFTBUS_OK) {
260 LNN_LOGE(LNN_LEDGER, "memcpy offlineCode error!");
261 return;
262 }
263 }
ConvertNodeInfoToBasicInfo(const NodeInfo * info,NodeBasicInfo * basic)264 static int32_t ConvertNodeInfoToBasicInfo(const NodeInfo *info, NodeBasicInfo *basic)
265 {
266 if (info == NULL || basic == NULL) {
267 LNN_LOGE(LNN_LEDGER, "para error!");
268 return SOFTBUS_INVALID_PARAM;
269 }
270 if (strcpy_s(basic->deviceName, DEVICE_NAME_BUF_LEN, info->deviceInfo.deviceName) != EOK) {
271 LNN_LOGE(LNN_LEDGER, "strcpy_s name error!");
272 return SOFTBUS_MEM_ERR;
273 }
274 if (strcpy_s(basic->networkId, NETWORK_ID_BUF_LEN, info->networkId) != EOK) {
275 LNN_LOGE(LNN_LEDGER, "strcpy_s networkID error!");
276 return SOFTBUS_MEM_ERR;
277 }
278 if (strcpy_s(basic->osVersion, OS_VERSION_BUF_LEN, info->deviceInfo.osVersion) != EOK) {
279 LNN_LOGE(LNN_LEDGER, "strcpy_s osVersion error!");
280 return SOFTBUS_MEM_ERR;
281 }
282 basic->deviceTypeId = info->deviceInfo.deviceTypeId;
283 basic->osType = info->deviceInfo.osType;
284 return SOFTBUS_OK;
285 }
286
IsMetaNode(NodeInfo * info)287 bool IsMetaNode(NodeInfo *info)
288 {
289 if (info == NULL) {
290 return false;
291 }
292 return info->metaInfo.isMetaNode;
293 }
294
GetDLOnlineNodeNumLocked(int32_t * infoNum,bool isNeedMeta)295 static int32_t GetDLOnlineNodeNumLocked(int32_t *infoNum, bool isNeedMeta)
296 {
297 NodeInfo *info = NULL;
298 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
299 MapIterator *it = LnnMapInitIterator(&map->udidMap);
300
301 if (it == NULL) {
302 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
303 }
304 *infoNum = 0;
305 while (LnnMapHasNext(it)) {
306 it = LnnMapNext(it);
307 if (it == NULL) {
308 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
309 }
310 info = (NodeInfo *)it->node->value;
311 if (!isNeedMeta) {
312 if (LnnIsNodeOnline(info)) {
313 (*infoNum)++;
314 }
315 } else {
316 if (LnnIsNodeOnline(info) || IsMetaNode(info)) {
317 (*infoNum)++;
318 }
319 }
320 }
321 LnnMapDeinitIterator(it);
322 return SOFTBUS_OK;
323 }
324
FillDLOnlineNodeInfoLocked(NodeBasicInfo * info,int32_t infoNum,bool isNeedMeta)325 static int32_t FillDLOnlineNodeInfoLocked(NodeBasicInfo *info, int32_t infoNum, bool isNeedMeta)
326 {
327 NodeInfo *nodeInfo = NULL;
328 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
329 MapIterator *it = LnnMapInitIterator(&map->udidMap);
330 int32_t i = 0;
331
332 if (it == NULL) {
333 LNN_LOGE(LNN_LEDGER, "it is null");
334 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
335 }
336 while (LnnMapHasNext(it) && i < infoNum) {
337 it = LnnMapNext(it);
338 if (it == NULL) {
339 LnnMapDeinitIterator(it);
340 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
341 }
342 nodeInfo = (NodeInfo *)it->node->value;
343 if (!isNeedMeta) {
344 if (LnnIsNodeOnline(nodeInfo)) {
345 ConvertNodeInfoToBasicInfo(nodeInfo, info + i);
346 ++i;
347 }
348 } else {
349 if (LnnIsNodeOnline(nodeInfo) || IsMetaNode(nodeInfo)) {
350 ConvertNodeInfoToBasicInfo(nodeInfo, info + i);
351 ++i;
352 }
353 }
354 }
355 LnnMapDeinitIterator(it);
356 return SOFTBUS_OK;
357 }
358
IsNetworkIdChanged(NodeInfo * newInfo,NodeInfo * oldInfo)359 static bool IsNetworkIdChanged(NodeInfo *newInfo, NodeInfo *oldInfo)
360 {
361 if (newInfo == NULL || oldInfo == NULL) {
362 LNN_LOGE(LNN_LEDGER, "para error!");
363 return false;
364 }
365 if (strcmp(newInfo->networkId, oldInfo->networkId) == 0) {
366 return false;
367 }
368 return true;
369 }
370
PostOnlineNodesToCb(const INodeStateCb * callBack)371 void PostOnlineNodesToCb(const INodeStateCb *callBack)
372 {
373 NodeInfo *info = NULL;
374 NodeBasicInfo basic;
375 if (memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo)) != EOK) {
376 LNN_LOGE(LNN_LEDGER, "memset_s basic fail!");
377 }
378 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
379 if (callBack->onNodeOnline == NULL) {
380 LNN_LOGE(LNN_LEDGER, "onNodeOnline IS null!");
381 return;
382 }
383 MapIterator *it = LnnMapInitIterator(&map->udidMap);
384 if (it == NULL) {
385 return;
386 }
387 while (LnnMapHasNext(it)) {
388 it = LnnMapNext(it);
389 if (it == NULL) {
390 return;
391 }
392 info = (NodeInfo *)it->node->value;
393 if (LnnIsNodeOnline(info)) {
394 ConvertNodeInfoToBasicInfo(info, &basic);
395 callBack->onNodeOnline(&basic);
396 }
397 }
398 LnnMapDeinitIterator(it);
399 }
400
LnnGetNodeInfoById(const char * id,IdCategory type)401 NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type)
402 {
403 NodeInfo *info = NULL;
404 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
405 if (id == NULL) {
406 LNN_LOGE(LNN_LEDGER, "para error");
407 return info;
408 }
409 if (type == CATEGORY_UDID) {
410 return GetNodeInfoFromMap(map, id);
411 }
412 MapIterator *it = LnnMapInitIterator(&map->udidMap);
413 LNN_CHECK_AND_RETURN_RET_LOGE(it != NULL, NULL, LNN_LEDGER, "LnnMapInitIterator is null");
414
415 while (LnnMapHasNext(it)) {
416 it = LnnMapNext(it);
417 LNN_CHECK_AND_RETURN_RET_LOGE(it != NULL, info, LNN_LEDGER, "it next is null");
418 info = (NodeInfo *)it->node->value;
419 if (info == NULL) {
420 continue;
421 }
422 if (type == CATEGORY_NETWORK_ID) {
423 if (strcmp(info->networkId, id) == 0 ||
424 (strlen(info->lastNetworkId) != 0 && strcmp(info->lastNetworkId, id) == 0)) {
425 LnnMapDeinitIterator(it);
426 return info;
427 }
428 } else if (type == CATEGORY_UUID) {
429 if (strcmp(info->uuid, id) == 0) {
430 LnnMapDeinitIterator(it);
431 return info;
432 }
433 } else {
434 LNN_LOGE(LNN_LEDGER, "type error");
435 }
436 }
437 LnnMapDeinitIterator(it);
438 return NULL;
439 }
440
LnnGetNodeInfoByDeviceId(const char * id)441 static NodeInfo *LnnGetNodeInfoByDeviceId(const char *id)
442 {
443 NodeInfo *info = NULL;
444 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
445 NodeInfo *udidInfo = GetNodeInfoFromMap(map, id);
446 if (udidInfo != NULL) {
447 return udidInfo;
448 }
449 MapIterator *it = LnnMapInitIterator(&map->udidMap);
450 if (it == NULL) {
451 return info;
452 }
453 while (LnnMapHasNext(it)) {
454 it = LnnMapNext(it);
455 if (it == NULL) {
456 return info;
457 }
458 info = (NodeInfo *)it->node->value;
459 if (info == NULL) {
460 continue;
461 }
462 if (strcmp(info->networkId, id) == 0 ||
463 (strlen(info->lastNetworkId) != 0 && strcmp(info->lastNetworkId, id) == 0)) {
464 LnnMapDeinitIterator(it);
465 return info;
466 }
467 if (strcmp(info->uuid, id) == 0) {
468 LnnMapDeinitIterator(it);
469 return info;
470 }
471 if (StrCmpIgnoreCase(info->connectInfo.macAddr, id) == 0) {
472 LnnMapDeinitIterator(it);
473 return info;
474 }
475 if (strcmp(info->connectInfo.ifInfo[WLAN_IF].deviceIp, id) == 0) {
476 LnnMapDeinitIterator(it);
477 return info;
478 }
479 if (strcmp(info->connectInfo.ifInfo[USB_IF].deviceIp, id) == 0) {
480 LnnMapDeinitIterator(it);
481 return info;
482 }
483 LNN_LOGE(LNN_LEDGER, "type error");
484 }
485 LnnMapDeinitIterator(it);
486 return NULL;
487 }
488
LnnGetRemoteNodeInfoById(const char * id,IdCategory type,NodeInfo * info)489 int32_t LnnGetRemoteNodeInfoById(const char *id, IdCategory type, NodeInfo *info)
490 {
491 if (id == NULL || info == NULL) {
492 LNN_LOGE(LNN_LEDGER, "param error");
493 return SOFTBUS_INVALID_PARAM;
494 }
495 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
496 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
497 return SOFTBUS_LOCK_ERR;
498 }
499 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
500 if (nodeInfo == NULL) {
501 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
502 char *anonyId = NULL;
503 Anonymize(id, &anonyId);
504 LNN_LOGI(LNN_LEDGER, "can not find target node, id=%{public}s, type=%{public}d",
505 AnonymizeWrapper(anonyId), type);
506 AnonymizeFree(anonyId);
507 return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
508 }
509 if (memcpy_s(info, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
510 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
511 return SOFTBUS_MEM_ERR;
512 }
513 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
514 return SOFTBUS_OK;
515 }
516
517 /* key means networkId/udid/uuid/macAddr/ip */
LnnGetRemoteNodeInfoByKey(const char * key,NodeInfo * info)518 int32_t LnnGetRemoteNodeInfoByKey(const char *key, NodeInfo *info)
519 {
520 if (key == NULL || info == NULL) {
521 LNN_LOGE(LNN_LEDGER, "param error");
522 return SOFTBUS_INVALID_PARAM;
523 }
524 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
525 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
526 return SOFTBUS_LOCK_ERR;
527 }
528 NodeInfo *nodeInfo = LnnGetNodeInfoByDeviceId(key);
529 if (nodeInfo == NULL) {
530 LNN_LOGI(LNN_LEDGER, "can not find target node");
531 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
532 return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
533 }
534 if (memcpy_s(info, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
535 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
536 return SOFTBUS_MEM_ERR;
537 }
538 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
539 return SOFTBUS_OK;
540 }
541
LnnGetOnlineStateById(const char * id,IdCategory type)542 bool LnnGetOnlineStateById(const char *id, IdCategory type)
543 {
544 bool state = false;
545 if (!IsValidString(id, ID_MAX_LEN)) {
546 LNN_LOGE(LNN_LEDGER, "id is invalid");
547 return state;
548 }
549
550 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
551 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
552 return state;
553 }
554 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
555 if (nodeInfo == NULL) {
556 LNN_LOGI(LNN_LEDGER, "can not find target node");
557 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
558 return state;
559 }
560 state = (nodeInfo->status == STATUS_ONLINE) ? true : false;
561 if (!state) {
562 state = nodeInfo->metaInfo.isMetaNode;
563 }
564 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
565 return state;
566 }
567
CreateCnnCodeKey(const char * uuid,DiscoveryType type)568 static char *CreateCnnCodeKey(const char *uuid, DiscoveryType type)
569 {
570 if (uuid == NULL || strlen(uuid) >= UUID_BUF_LEN) {
571 LNN_LOGE(LNN_LEDGER, "para error!");
572 return NULL;
573 }
574 char *key = (char *)SoftBusCalloc(INT_TO_STR_SIZE + UUID_BUF_LEN);
575 if (key == NULL) {
576 LNN_LOGE(LNN_LEDGER, "SoftBusCalloc fail!");
577 return NULL;
578 }
579 if (sprintf_s(key, INT_TO_STR_SIZE + UUID_BUF_LEN, "%d%s", type, uuid) == -1) {
580 LNN_LOGE(LNN_LEDGER, "type convert char error!");
581 goto EXIT_FAIL;
582 }
583 return key;
584 EXIT_FAIL:
585 SoftBusFree(key);
586 return NULL;
587 }
588
DestroyCnnCodeKey(char * key)589 static void DestroyCnnCodeKey(char *key)
590 {
591 if (key == NULL) {
592 return;
593 }
594 SoftBusFree(key);
595 }
596
597
AddCnnCode(Map * cnnCode,const char * uuid,DiscoveryType type,int64_t authSeqNum)598 static int32_t AddCnnCode(Map *cnnCode, const char *uuid, DiscoveryType type, int64_t authSeqNum)
599 {
600 short seq = (short)authSeqNum;
601 char *key = CreateCnnCodeKey(uuid, type);
602 if (key == NULL) {
603 LNN_LOGE(LNN_LEDGER, "CreateCnnCodeKey error!");
604 return SOFTBUS_MEM_ERR;
605 }
606 if (LnnMapSet(cnnCode, key, (void *)&seq, sizeof(short)) != SOFTBUS_OK) {
607 LNN_LOGE(LNN_LEDGER, "LnnMapSet error!");
608 DestroyCnnCodeKey(key);
609 return SOFTBUS_NETWORK_MAP_SET_FAILED;
610 }
611 DestroyCnnCodeKey(key);
612 return SOFTBUS_OK;
613 }
614
RemoveCnnCode(Map * cnnCode,const char * uuid,DiscoveryType type)615 static void RemoveCnnCode(Map *cnnCode, const char *uuid, DiscoveryType type)
616 {
617 char *key = CreateCnnCodeKey(uuid, type);
618 if (key == NULL) {
619 LNN_LOGE(LNN_LEDGER, "CreateCnnCodeKey error!");
620 return;
621 }
622 if (LnnMapErase(cnnCode, key) != SOFTBUS_OK) {
623 LNN_LOGE(LNN_LEDGER, "LnnMapErase error!");
624 }
625 DestroyCnnCodeKey(key);
626 return;
627 }
628
LnnGetCnnCode(const char * uuid,DiscoveryType type)629 short LnnGetCnnCode(const char *uuid, DiscoveryType type)
630 {
631 char *key = CreateCnnCodeKey(uuid, type);
632 if (key == NULL) {
633 LNN_LOGE(LNN_LEDGER, "CreateCnnCodeKey error!");
634 return INVALID_CONNECTION_CODE_VALUE;
635 }
636 short *ptr = (short *)LnnMapGet(&g_distributedNetLedger.cnnCode.connectionCode, key);
637 if (ptr == NULL) {
638 LNN_LOGE(LNN_LEDGER, " KEY not exist.");
639 DestroyCnnCodeKey(key);
640 return INVALID_CONNECTION_CODE_VALUE;
641 }
642 DestroyCnnCodeKey(key);
643 return (*ptr);
644 }
645
MergeLnnInfo(const NodeInfo * oldInfo,NodeInfo * info)646 static void MergeLnnInfo(const NodeInfo *oldInfo, NodeInfo *info)
647 {
648 int32_t i, j;
649
650 for (i = 0; i < CONNECTION_ADDR_MAX; ++i) {
651 info->relation[i] += oldInfo->relation[i];
652 info->relation[i] &= LNN_RELATION_MASK;
653 for (j = 0; j < AUTH_SIDE_MAX; ++j) {
654 if (oldInfo->authChannelId[i][j] != 0 && info->authChannelId[i][j] == 0) {
655 info->authChannelId[i][j] = oldInfo->authChannelId[i][j];
656 }
657 }
658 if (oldInfo->authChannelId[i][AUTH_AS_CLIENT_SIDE] != 0 ||
659 oldInfo->authChannelId[i][AUTH_AS_SERVER_SIDE] != 0 || info->authChannelId[i][AUTH_AS_CLIENT_SIDE] != 0 ||
660 info->authChannelId[i][AUTH_AS_SERVER_SIDE] != 0) {
661 LNN_LOGD(LNN_LEDGER,
662 "Merge authChannelId. authChannelId:%{public}d|%{public}d->%{public}d|%{public}d, addrType=%{public}d",
663 oldInfo->authChannelId[i][AUTH_AS_CLIENT_SIDE], oldInfo->authChannelId[i][AUTH_AS_SERVER_SIDE],
664 info->authChannelId[i][AUTH_AS_CLIENT_SIDE], info->authChannelId[i][AUTH_AS_SERVER_SIDE], i);
665 }
666 }
667 if (strcpy_s(info->lastNetworkId, NETWORK_ID_BUF_LEN, oldInfo->lastNetworkId) != EOK) {
668 LNN_LOGE(LNN_LEDGER, "cpy lastNetworkId fail");
669 }
670 }
671
LnnUpdateNetworkId(const NodeInfo * newInfo)672 int32_t LnnUpdateNetworkId(const NodeInfo *newInfo)
673 {
674 const char *udid = NULL;
675 DoubleHashMap *map = NULL;
676 NodeInfo *oldInfo = NULL;
677
678 udid = LnnGetDeviceUdid(newInfo);
679 map = &g_distributedNetLedger.distributedInfo;
680 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
681 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
682 return SOFTBUS_LOCK_ERR;
683 }
684 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
685 if (oldInfo == NULL) {
686 LNN_LOGE(LNN_LEDGER, "no online node newInfo!");
687 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
688 return SOFTBUS_NETWORK_MAP_GET_FAILED;
689 }
690 if (strcpy_s(oldInfo->lastNetworkId, NETWORK_ID_BUF_LEN, oldInfo->networkId) != EOK) {
691 LNN_LOGE(LNN_LEDGER, "old networkId cpy fail");
692 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
693 return SOFTBUS_MEM_ERR;
694 }
695 if (strcpy_s(oldInfo->networkId, NETWORK_ID_BUF_LEN, newInfo->networkId) != EOK) {
696 LNN_LOGE(LNN_LEDGER, "networkId cpy fail");
697 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
698 return SOFTBUS_MEM_ERR;
699 }
700 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
701 return SOFTBUS_OK;
702 }
703
UpdateNewNodeAccountHash(NodeInfo * info)704 static void UpdateNewNodeAccountHash(NodeInfo *info)
705 {
706 char accountString[LONG_TO_STRING_MAX_LEN] = {0};
707 if (sprintf_s(accountString, LONG_TO_STRING_MAX_LEN, "%" PRId64, info->accountId) == -1) {
708 LNN_LOGE(LNN_LEDGER, "long to string fail");
709 return;
710 }
711 char *anonyAccountId = NULL;
712 Anonymize(accountString, &anonyAccountId);
713 LNN_LOGI(LNN_LEDGER, "accountString=%{public}s", AnonymizeWrapper(anonyAccountId));
714 AnonymizeFree(anonyAccountId);
715 int ret = SoftBusGenerateStrHash((uint8_t *)accountString,
716 strlen(accountString), (unsigned char *)info->accountHash);
717 if (ret != SOFTBUS_OK) {
718 LNN_LOGE(LNN_LEDGER, "account hash fail, ret=%{public}d", ret);
719 return;
720 }
721 }
722
CheckUserIdCheckSumChange(NodeInfo * oldInfo,const NodeInfo * newInfo)723 static void CheckUserIdCheckSumChange(NodeInfo *oldInfo, const NodeInfo *newInfo)
724 {
725 if (oldInfo == NULL || newInfo == NULL) {
726 LNN_LOGE(LNN_LEDGER, "invalid param");
727 return;
728 }
729 int32_t userIdCheckSum = 0;
730 int32_t ret = memcpy_s(&userIdCheckSum, sizeof(int32_t), newInfo->userIdCheckSum, USERID_CHECKSUM_LEN);
731 if (ret != EOK) {
732 LNN_LOGE(LNN_LEDGER, "memcpy failed! userIdchecksum:%{public}d", userIdCheckSum);
733 return;
734 }
735 if (userIdCheckSum == 0) {
736 LNN_LOGW(LNN_LEDGER, "useridchecksum all zero");
737 return;
738 }
739 bool isChange = false;
740 ret = memcmp(newInfo->userIdCheckSum, oldInfo->userIdCheckSum, USERID_CHECKSUM_LEN);
741 if (ret != 0) {
742 isChange = true;
743 }
744 NotifyForegroundUseridChange((char *)newInfo->networkId, newInfo->discoveryType, isChange);
745 if (isChange) {
746 LNN_LOGI(LNN_LEDGER, "userIdCheckSum changed!");
747 LnnSetDLConnUserIdCheckSum((char *)newInfo->networkId, userIdCheckSum);
748 }
749 }
750
UpdateFileInfo(NodeInfo * newInfo,NodeInfo * oldInfo)751 static int32_t UpdateFileInfo(NodeInfo *newInfo, NodeInfo *oldInfo)
752 {
753 LnnDumpRemotePtk(oldInfo->remotePtk, newInfo->remotePtk, "update node info");
754 if (memcpy_s(oldInfo->remotePtk, PTK_DEFAULT_LEN, newInfo->remotePtk, PTK_DEFAULT_LEN) != EOK) {
755 LNN_LOGE(LNN_LEDGER, "copy ptk failed");
756 return SOFTBUS_MEM_ERR;
757 }
758 if (memcmp(newInfo->cipherInfo.key, oldInfo->cipherInfo.key, SESSION_KEY_LENGTH) != 0 ||
759 memcmp(newInfo->cipherInfo.iv, oldInfo->cipherInfo.iv, BROADCAST_IV_LEN) != 0) {
760 LNN_LOGI(LNN_LEDGER, "remote link key change");
761 if (memcpy_s(oldInfo->cipherInfo.key, SESSION_KEY_LENGTH, newInfo->cipherInfo.key, SESSION_KEY_LENGTH) != EOK ||
762 memcpy_s(oldInfo->cipherInfo.iv, BROADCAST_IV_LEN, newInfo->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
763 LNN_LOGE(LNN_LEDGER, "copy link key failed");
764 return SOFTBUS_MEM_ERR;
765 }
766 }
767 if (memcmp(newInfo->rpaInfo.peerIrk, oldInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN) != 0) {
768 LNN_LOGI(LNN_LEDGER, "remote irk change");
769 if (memcpy_s(oldInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN, newInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN) != EOK) {
770 LNN_LOGE(LNN_LEDGER, "copy irk failed");
771 return SOFTBUS_MEM_ERR;
772 }
773 }
774 LNN_LOGI(LNN_LEDGER, "update file info success");
775 return SOFTBUS_OK;
776 }
777
UpdateRemoteNodeInfo(NodeInfo * oldInfo,NodeInfo * newInfo,int32_t connectionType,char * deviceName)778 static int32_t UpdateRemoteNodeInfo(NodeInfo *oldInfo, NodeInfo *newInfo, int32_t connectionType, char *deviceName)
779 {
780 if (oldInfo == NULL || newInfo == NULL) {
781 LNN_LOGE(LNN_LEDGER, "param error");
782 return SOFTBUS_INVALID_PARAM;
783 }
784 if (LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_WIFI) || LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_LSA)) {
785 oldInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
786 oldInfo->connectInfo.ifInfo[WLAN_IF].authPort = newInfo->connectInfo.ifInfo[WLAN_IF].authPort;
787 oldInfo->connectInfo.ifInfo[WLAN_IF].proxyPort = newInfo->connectInfo.ifInfo[WLAN_IF].proxyPort;
788 oldInfo->connectInfo.ifInfo[WLAN_IF].sessionPort = newInfo->connectInfo.ifInfo[WLAN_IF].sessionPort;
789 }
790 if (LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_USB)) {
791 oldInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
792 oldInfo->connectInfo.ifInfo[USB_IF].authPort = newInfo->connectInfo.ifInfo[USB_IF].authPort;
793 oldInfo->connectInfo.ifInfo[USB_IF].proxyPort = newInfo->connectInfo.ifInfo[USB_IF].proxyPort;
794 oldInfo->connectInfo.ifInfo[USB_IF].sessionPort = newInfo->connectInfo.ifInfo[USB_IF].sessionPort;
795 }
796 if (deviceName != NULL) {
797 if (strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, oldInfo->deviceInfo.deviceName) != EOK) {
798 LNN_LOGE(LNN_LEDGER, "strcpy_s fail");
799 return SOFTBUS_STRCPY_ERR;
800 }
801 }
802 if (strcpy_s(oldInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.deviceName) != EOK ||
803 strcpy_s(oldInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.nickName) != EOK ||
804 strcpy_s(oldInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.unifiedName) != EOK ||
805 strcpy_s(oldInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN,
806 newInfo->deviceInfo.unifiedDefaultName) != EOK) {
807 LNN_LOGE(LNN_LEDGER, "strcpy_s fail");
808 return SOFTBUS_STRCPY_ERR;
809 }
810 if (memcpy_s(oldInfo->accountHash, SHA_256_HASH_LEN, newInfo->accountHash, SHA_256_HASH_LEN) != EOK) {
811 LNN_LOGE(LNN_LEDGER, "copy account hash failed");
812 return SOFTBUS_MEM_ERR;
813 }
814 if (UpdateFileInfo(newInfo, oldInfo) != SOFTBUS_OK) {
815 LNN_LOGE(LNN_LEDGER, "update file info failed");
816 return SOFTBUS_MEM_ERR;
817 }
818 oldInfo->accountId = newInfo->accountId;
819 oldInfo->userId = newInfo->userId;
820 if (connectionType == CONNECTION_ADDR_BLE) {
821 oldInfo->localStateVersion = newInfo->localStateVersion;
822 oldInfo->stateVersion = newInfo->stateVersion;
823 }
824 oldInfo->staticNetCap = newInfo->staticNetCap;
825 return SOFTBUS_OK;
826 }
827
RemoteNodeInfoRetrieve(NodeInfo * newInfo,int32_t connectionType)828 static int32_t RemoteNodeInfoRetrieve(NodeInfo *newInfo, int32_t connectionType)
829 {
830 if (newInfo == NULL) {
831 LNN_LOGE(LNN_LEDGER, "param error");
832 return SOFTBUS_INVALID_PARAM;
833 }
834 NodeInfo deviceInfo;
835 (void)memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
836 uint8_t udidHash[SHA_256_HASH_LEN] = {0};
837 char hashStr[SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
838 int32_t ret = SoftBusGenerateStrHash((const unsigned char *)newInfo->deviceInfo.deviceUdid,
839 strlen(newInfo->deviceInfo.deviceUdid), udidHash);
840 if (ret != SOFTBUS_OK) {
841 LNN_LOGE(LNN_LEDGER, "generate udidhash fail");
842 return ret;
843 }
844 ret = ConvertBytesToHexString(hashStr, SHORT_UDID_HASH_HEX_LEN + 1, udidHash,
845 SHORT_UDID_HASH_HEX_LEN / HEXIFY_UNIT_LEN);
846 if (ret != SOFTBUS_OK) {
847 LNN_LOGE(LNN_LEDGER, "convert udidhash to hexstr fail");
848 return ret;
849 }
850 ret = LnnRetrieveDeviceInfoPacked(hashStr, &deviceInfo);
851 if (ret != SOFTBUS_OK) {
852 LNN_LOGE(LNN_LEDGER, "no this device info.");
853 return ret;
854 }
855 ret = UpdateRemoteNodeInfo(&deviceInfo, newInfo, connectionType, NULL);
856 if (ret != SOFTBUS_OK) {
857 return ret;
858 }
859 ret = LnnSaveRemoteDeviceInfoPacked(&deviceInfo);
860 if (ret != SOFTBUS_OK) {
861 LNN_LOGE(LNN_LEDGER, "save remote devInfo fail");
862 return ret;
863 }
864 return SOFTBUS_OK;
865 }
866
UpdateDeviceInfoToMlps(const char * udid)867 static void UpdateDeviceInfoToMlps(const char *udid)
868 {
869 LpDeviceStateInfo *info = (LpDeviceStateInfo *)SoftBusCalloc(sizeof(LpDeviceStateInfo));
870 if (info == NULL) {
871 LNN_LOGE(LNN_LEDGER, "calloc info fail");
872 return;
873 }
874 if (strcpy_s(info->udid, UDID_BUF_LEN, udid) != EOK) {
875 LNN_LOGE(LNN_LEDGER, "strcpy_s outUdid fail");
876 SoftBusFree(info);
877 return;
878 }
879 info->isOnline = true;
880 SendDeviceStateToMlpsPacked(info);
881 }
882
LnnUpdateNodeInfo(NodeInfo * newInfo,int32_t connectionType)883 int32_t LnnUpdateNodeInfo(NodeInfo *newInfo, int32_t connectionType)
884 {
885 const char *udid = NULL;
886 DoubleHashMap *map = NULL;
887 NodeInfo *oldInfo = NULL;
888 bool isIrkChanged = false;
889 bool isAccountChanged = false;
890 char deviceName[DEVICE_NAME_BUF_LEN] = { 0 };
891 UpdateNewNodeAccountHash(newInfo);
892 udid = LnnGetDeviceUdid(newInfo);
893 map = &g_distributedNetLedger.distributedInfo;
894 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
895 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
896 return SOFTBUS_LOCK_ERR;
897 }
898 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
899 if (oldInfo == NULL) {
900 LNN_LOGE(LNN_LEDGER, "no online node newInfo!");
901 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
902 return SOFTBUS_NETWORK_MAP_GET_FAILED;
903 }
904 isAccountChanged = !(memcmp(oldInfo->accountHash, newInfo->accountHash, sizeof(oldInfo->accountHash)) == 0);
905 if (memcmp(newInfo->rpaInfo.peerIrk, oldInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN) != 0) {
906 isIrkChanged = true;
907 }
908 int32_t ret = UpdateRemoteNodeInfo(oldInfo, newInfo, connectionType, deviceName);
909 if (ret != SOFTBUS_OK) {
910 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
911 return ret;
912 }
913 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
914 if (memcmp(deviceName, newInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN) != 0) {
915 UpdateDeviceNameInfo(newInfo->deviceInfo.deviceUdid, deviceName);
916 }
917 if (isIrkChanged) {
918 LnnInsertLinkFinderInfoPacked(oldInfo->networkId);
919 }
920 CheckUserIdCheckSumChange(oldInfo, newInfo);
921 ret = RemoteNodeInfoRetrieve(newInfo, connectionType);
922 if (isAccountChanged) {
923 UpdateDeviceInfoToMlps(udid);
924 }
925 return ret;
926 }
927
LnnAddMetaInfo(NodeInfo * info)928 int32_t LnnAddMetaInfo(NodeInfo *info)
929 {
930 if (info == NULL) {
931 LNN_LOGE(LNN_LEDGER, "param error");
932 return SOFTBUS_INVALID_PARAM;
933 }
934 const char *udid = NULL;
935 DoubleHashMap *map = NULL;
936 NodeInfo *oldInfo = NULL;
937 udid = LnnGetDeviceUdid(info);
938 map = &g_distributedNetLedger.distributedInfo;
939 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
940 LNN_LOGE(LNN_LEDGER, "LnnAddMetaInfo lock mutex fail!");
941 return SOFTBUS_LOCK_ERR;
942 }
943 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
944 if (oldInfo != NULL && strcmp(oldInfo->networkId, info->networkId) == 0) {
945 LNN_LOGI(LNN_LEDGER, "old capa=%{public}u new capa=%{public}u", oldInfo->netCapacity, info->netCapacity);
946 oldInfo->connectInfo.ifInfo[WLAN_IF].sessionPort = info->connectInfo.ifInfo[WLAN_IF].sessionPort;
947 oldInfo->connectInfo.ifInfo[WLAN_IF].authPort = info->connectInfo.ifInfo[WLAN_IF].authPort;
948 oldInfo->connectInfo.ifInfo[WLAN_IF].proxyPort = info->connectInfo.ifInfo[WLAN_IF].proxyPort;
949 oldInfo->netCapacity = info->netCapacity;
950 if (strcpy_s(oldInfo->connectInfo.ifInfo[WLAN_IF].deviceIp, IP_LEN,
951 info->connectInfo.ifInfo[WLAN_IF].deviceIp) != EOK) {
952 LNN_LOGE(LNN_LEDGER, "strcpy ip fail!");
953 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
954 return SOFTBUS_STRCPY_ERR;
955 }
956 if (strcpy_s(oldInfo->uuid, UUID_BUF_LEN, info->uuid) != EOK) {
957 LNN_LOGE(LNN_LEDGER, "strcpy uuid fail!");
958 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
959 return SOFTBUS_STRCPY_ERR;
960 }
961 MetaInfo temp = info->metaInfo;
962 if (memcpy_s(info, sizeof(NodeInfo), oldInfo, sizeof(NodeInfo)) != EOK) {
963 LNN_LOGE(LNN_LEDGER, "LnnAddMetaInfo copy fail!");
964 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
965 return SOFTBUS_MEM_ERR;
966 }
967 info->metaInfo.isMetaNode = true;
968 info->metaInfo.metaDiscType = info->metaInfo.metaDiscType | temp.metaDiscType;
969 }
970 LnnSetAuthTypeValue(&info->AuthTypeValue, ONLINE_METANODE);
971 int32_t ret = LnnMapSet(&map->udidMap, udid, info, sizeof(NodeInfo));
972 if (ret != SOFTBUS_OK) {
973 LNN_LOGE(LNN_LEDGER, "lnn map set failed, ret=%{public}d", ret);
974 }
975 LNN_LOGI(LNN_LEDGER, "LnnAddMetaInfo success");
976 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
977 return SOFTBUS_OK;
978 }
979
LnnDeleteMetaInfo(const char * udid,AuthLinkType type)980 int32_t LnnDeleteMetaInfo(const char *udid, AuthLinkType type)
981 {
982 NodeInfo *info = NULL;
983 DiscoveryType discType = ConvertToDiscoveryType(type);
984 if (discType == DISCOVERY_TYPE_COUNT) {
985 LNN_LOGE(LNN_LEDGER, "DeleteMetaInfo type error fail!");
986 return SOFTBUS_NETWORK_DELETE_INFO_ERR;
987 }
988 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
989 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
990 LNN_LOGE(LNN_LEDGER, "DeleteAddMetaInfo lock mutex fail!");
991 return SOFTBUS_LOCK_ERR;
992 }
993 info = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
994 if (info == NULL) {
995 LNN_LOGE(LNN_LEDGER, "DeleteAddMetaInfo para error!");
996 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
997 return SOFTBUS_NETWORK_DELETE_INFO_ERR;
998 }
999 info->metaInfo.metaDiscType = (uint32_t)info->metaInfo.metaDiscType & ~(1 << (uint32_t)discType);
1000 if (info->metaInfo.metaDiscType == 0) {
1001 info->metaInfo.isMetaNode = false;
1002 }
1003 LnnClearAuthTypeValue(&info->AuthTypeValue, ONLINE_METANODE);
1004 (void)memset_s(info->remoteMetaPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
1005 int32_t ret = LnnMapSet(&map->udidMap, udid, info, sizeof(NodeInfo));
1006 if (ret != SOFTBUS_OK) {
1007 LNN_LOGE(LNN_LEDGER, "lnn map set failed, ret=%{public}d", ret);
1008 }
1009 LNN_LOGI(LNN_LEDGER, "LnnDeleteMetaInfo success, discType=%{public}d", discType);
1010 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1011 return SOFTBUS_OK;
1012 }
1013
OnlinePreventBrConnection(const NodeInfo * info)1014 static void OnlinePreventBrConnection(const NodeInfo *info)
1015 {
1016 int32_t osType = 0;
1017 if (LnnGetOsTypeByNetworkId(info->networkId, &osType)) {
1018 LNN_LOGE(LNN_LEDGER, "get remote osType fail");
1019 }
1020 if (osType == OH_OS_TYPE) {
1021 LNN_LOGI(LNN_LEDGER, "not pend br connection");
1022 return;
1023 }
1024 const NodeInfo *localNodeInfo = LnnGetLocalNodeInfo();
1025 if (localNodeInfo == NULL) {
1026 LNN_LOGE(LNN_LEDGER, "get local node info fail");
1027 return;
1028 }
1029 ConnectOption option;
1030 option.type = CONNECT_BR;
1031 if (strcpy_s(option.brOption.brMac, BT_MAC_LEN, info->connectInfo.macAddr) != EOK) {
1032 LNN_LOGE(LNN_LEDGER, "copy br mac fail");
1033 return;
1034 }
1035 bool preventFlag = false;
1036 do {
1037 LNN_LOGI(LNN_LEDGER, "check the ble start timestamp, local=%{public}" PRId64", peer=%{public}" PRId64"",
1038 localNodeInfo->bleStartTimestamp, info->bleStartTimestamp);
1039 if (localNodeInfo->bleStartTimestamp < info->bleStartTimestamp) {
1040 LNN_LOGI(LNN_LEDGER, "peer later, prevent br connection");
1041 preventFlag = true;
1042 break;
1043 }
1044 if (localNodeInfo->bleStartTimestamp > info->bleStartTimestamp) {
1045 LNN_LOGI(LNN_LEDGER, "local later, do not prevent br connection");
1046 break;
1047 }
1048 if (strcmp(info->softBusVersion, SOFTBUS_VERSION_FOR_INITCONNECTFLAG) < 0) {
1049 LNN_LOGI(LNN_LEDGER, "peer is old version, peerVersion=%{public}s", info->softBusVersion);
1050 preventFlag = true;
1051 break;
1052 }
1053 if (strcmp(info->networkId, localNodeInfo->networkId) <= 0) {
1054 LNN_LOGI(LNN_LEDGER, "peer network id is smaller");
1055 preventFlag = true;
1056 break;
1057 }
1058 } while (false);
1059 if (preventFlag) {
1060 LNN_LOGI(LNN_LEDGER, "prevent br connection for a while");
1061 ConnPreventConnection(&option, CONNECTION_FREEZE_TIMEOUT_MILLIS);
1062 }
1063 }
1064
NotifyMigrateUpgrade(NodeInfo * info)1065 static void NotifyMigrateUpgrade(NodeInfo *info)
1066 {
1067 NodeBasicInfo basic;
1068 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1069 if (LnnGetBasicInfoByUdid(info->deviceInfo.deviceUdid, &basic) == SOFTBUS_OK) {
1070 LnnNotifyMigrate(true, &basic);
1071 } else {
1072 LNN_LOGE(LNN_LEDGER, "NotifyMigrateUpgrade, GetBasicInfoByUdid fail!");
1073 }
1074 }
1075
FilterWifiInfo(NodeInfo * info)1076 static void FilterWifiInfo(NodeInfo *info)
1077 {
1078 (void)LnnClearDiscoveryType(info, DISCOVERY_TYPE_WIFI);
1079 info->authChannelId[CONNECTION_ADDR_WLAN][AUTH_AS_CLIENT_SIDE] = 0;
1080 info->authChannelId[CONNECTION_ADDR_WLAN][AUTH_AS_SERVER_SIDE] = 0;
1081 }
1082
FilterUsbInfo(NodeInfo * info)1083 static void FilterUsbInfo(NodeInfo *info)
1084 {
1085 (void)LnnClearDiscoveryType(info, DISCOVERY_TYPE_USB);
1086 info->authChannelId[CONNECTION_ADDR_NCM][AUTH_AS_CLIENT_SIDE] = 0;
1087 info->authChannelId[CONNECTION_ADDR_NCM][AUTH_AS_SERVER_SIDE] = 0;
1088 }
1089
FilterBrInfo(NodeInfo * info)1090 static void FilterBrInfo(NodeInfo *info)
1091 {
1092 (void)LnnClearDiscoveryType(info, DISCOVERY_TYPE_BR);
1093 info->authChannelId[CONNECTION_ADDR_BR][AUTH_AS_CLIENT_SIDE] = 0;
1094 info->authChannelId[CONNECTION_ADDR_BR][AUTH_AS_SERVER_SIDE] = 0;
1095 }
1096
IsDeviceInfoChanged(NodeInfo * info)1097 static bool IsDeviceInfoChanged(NodeInfo *info)
1098 {
1099 if (info == NULL) {
1100 LNN_LOGI(LNN_LEDGER, "invalid param");
1101 return false;
1102 }
1103 NodeInfo deviceInfo;
1104 if (memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo)) != EOK) {
1105 LNN_LOGE(LNN_LEDGER, "memset_s basic fail!");
1106 return false;
1107 }
1108 uint8_t udidHash[SHA_256_HASH_LEN] = {0};
1109 char hashStr[SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1110 if (SoftBusGenerateStrHash((const unsigned char *)info->deviceInfo.deviceUdid,
1111 strlen(info->deviceInfo.deviceUdid), udidHash) != SOFTBUS_OK) {
1112 LNN_LOGI(LNN_LEDGER, "generate udidhash fail");
1113 return false;
1114 }
1115 if (ConvertBytesToHexString(hashStr, SHORT_UDID_HASH_HEX_LEN + 1, udidHash,
1116 SHORT_UDID_HASH_HEX_LEN / HEXIFY_UNIT_LEN) != SOFTBUS_OK) {
1117 LNN_LOGI(LNN_LEDGER, "convert udidhash to hexstr fail");
1118 return false;
1119 }
1120 int32_t ret = LnnRetrieveDeviceInfoPacked(hashStr, &deviceInfo);
1121 if (ret == SOFTBUS_NETWORK_NOT_FOUND) {
1122 return true;
1123 }
1124 if (ret != SOFTBUS_OK) {
1125 LNN_LOGI(LNN_LEDGER, "get deviceInfo by udidhash fail");
1126 return false;
1127 }
1128 return memcmp(info, &deviceInfo, (size_t)&(((NodeInfo *)0)->relation)) != 0 ? true : false;
1129 }
1130
GetAndSaveRemoteDeviceInfo(NodeInfo * deviceInfo,NodeInfo * info)1131 static void GetAndSaveRemoteDeviceInfo(NodeInfo *deviceInfo, NodeInfo *info)
1132 {
1133 if (strcpy_s(deviceInfo->networkId, sizeof(deviceInfo->networkId), info->networkId) != EOK) {
1134 LNN_LOGE(LNN_LEDGER, "strcpy_s networkId fail");
1135 return;
1136 }
1137 if (strcpy_s(deviceInfo->uuid, sizeof(deviceInfo->uuid), info->uuid) != EOK) {
1138 LNN_LOGE(LNN_LEDGER, "strcpy_s uuid fail");
1139 return;
1140 }
1141 if (memcpy_s(deviceInfo->rpaInfo.peerIrk, sizeof(deviceInfo->rpaInfo.peerIrk), info->rpaInfo.peerIrk,
1142 sizeof(info->rpaInfo.peerIrk)) != EOK) {
1143 LNN_LOGE(LNN_LEDGER, "memcpy_s Irk fail");
1144 return;
1145 }
1146 if (memcpy_s(deviceInfo->cipherInfo.key, sizeof(deviceInfo->cipherInfo.key), info->cipherInfo.key,
1147 sizeof(info->cipherInfo.key)) != EOK) {
1148 LNN_LOGE(LNN_LEDGER, "memcpy_s cipherInfo.key fail");
1149 return;
1150 }
1151 if (memcpy_s(deviceInfo->cipherInfo.iv, sizeof(deviceInfo->cipherInfo.iv), info->cipherInfo.iv,
1152 sizeof(info->cipherInfo.iv)) != EOK) {
1153 LNN_LOGE(LNN_LEDGER, "memcpy_s cipherInfo.iv fail");
1154 return;
1155 }
1156 LnnDumpRemotePtk(deviceInfo->remotePtk, info->remotePtk, "get and save remote device info");
1157 if (memcpy_s(deviceInfo->remotePtk, PTK_DEFAULT_LEN, info->remotePtk, PTK_DEFAULT_LEN) != EOK) {
1158 LNN_LOGE(LNN_LEDGER, "memcpy_s ptk fail");
1159 return;
1160 }
1161 deviceInfo->netCapacity = info->netCapacity;
1162 deviceInfo->accountId = info->accountId;
1163 deviceInfo->staticNetCap = info->staticNetCap;
1164 if (LnnSaveRemoteDeviceInfoPacked(deviceInfo) != SOFTBUS_OK) {
1165 LNN_LOGE(LNN_LEDGER, "save remote devInfo fail");
1166 return;
1167 }
1168 }
1169
BleDirectlyOnlineProc(NodeInfo * info)1170 static void BleDirectlyOnlineProc(NodeInfo *info)
1171 {
1172 if (!LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)) {
1173 NodeInfo deviceInfo;
1174 if (memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo)) != EOK) {
1175 LNN_LOGE(LNN_LEDGER, "memset_s basic fail!");
1176 }
1177 uint8_t udidHash[SHA_256_HASH_LEN] = {0};
1178 char hashStr[SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1179 if (SoftBusGenerateStrHash((const unsigned char *)info->deviceInfo.deviceUdid,
1180 strlen(info->deviceInfo.deviceUdid), udidHash) != SOFTBUS_OK) {
1181 LNN_LOGE(LNN_LEDGER, "generate udidhash fail");
1182 return;
1183 }
1184 if (ConvertBytesToHexString(hashStr, SHORT_UDID_HASH_HEX_LEN + 1, udidHash,
1185 SHORT_UDID_HASH_HEX_LEN / HEXIFY_UNIT_LEN) != SOFTBUS_OK) {
1186 LNN_LOGE(LNN_LEDGER, "convert udidhash to hexstr fail");
1187 return;
1188 }
1189 if (LnnRetrieveDeviceInfoPacked(hashStr, &deviceInfo) != SOFTBUS_OK) {
1190 LNN_LOGE(LNN_LEDGER, "get deviceInfo by udidhash fail");
1191 return;
1192 }
1193 char *anonyDevNetworkId = NULL;
1194 char *anonyNetworkId = NULL;
1195 Anonymize(deviceInfo.networkId, &anonyDevNetworkId);
1196 Anonymize(info->networkId, &anonyNetworkId);
1197 LNN_LOGI(LNN_LEDGER, "oldNetworkId=%{public}s, newNetworkid=%{public}s",
1198 AnonymizeWrapper(anonyDevNetworkId), AnonymizeWrapper(anonyNetworkId));
1199 AnonymizeFree(anonyDevNetworkId);
1200 AnonymizeFree(anonyNetworkId);
1201 GetAndSaveRemoteDeviceInfo(&deviceInfo, info);
1202 (void)memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1203 return;
1204 }
1205 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI)) {
1206 FilterWifiInfo(info);
1207 }
1208 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_USB)) {
1209 FilterUsbInfo(info);
1210 }
1211 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
1212 FilterBrInfo(info);
1213 }
1214 if (IsDeviceInfoChanged(info)) {
1215 LNN_LOGI(LNN_LEDGER, "device info changed");
1216 if (LnnSaveRemoteDeviceInfoPacked(info) != SOFTBUS_OK) {
1217 LNN_LOGE(LNN_LEDGER, "save remote devInfo fail");
1218 }
1219 } else {
1220 LnnUpdateRemoteDeviceInfoPacked(info);
1221 }
1222 }
1223
NodeOnlineProc(NodeInfo * info)1224 static void NodeOnlineProc(NodeInfo *info)
1225 {
1226 NodeInfo nodeInfo;
1227 if (memcpy_s(&nodeInfo, sizeof(nodeInfo), info, sizeof(NodeInfo)) != EOK) {
1228 return;
1229 }
1230 BleDirectlyOnlineProc(&nodeInfo);
1231 }
1232
InitInfoAbility(NodeInfo * info,NodeInfoAbility * infoAbility)1233 static void InitInfoAbility(NodeInfo *info, NodeInfoAbility *infoAbility)
1234 {
1235 if (infoAbility == NULL) {
1236 return;
1237 }
1238 infoAbility->isOffline = true;
1239 infoAbility->oldWifiFlag = false;
1240 infoAbility->oldUsbFlag = false;
1241 infoAbility->oldBrFlag = false;
1242 infoAbility->oldBleFlag = false;
1243 infoAbility->isChanged = false;
1244 infoAbility->isMigrateEvent = false;
1245 infoAbility->isNetworkChanged = false;
1246 infoAbility->newWifiFlag = LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI);
1247 infoAbility->newUsbFlag = LnnHasDiscoveryType(info, DISCOVERY_TYPE_USB);
1248 infoAbility->newBleBrFlag =
1249 LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE) || LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR);
1250 }
1251
UsbUpdateHandle(NodeInfo * oldInfo,NodeInfo * newInfo,NodeInfoAbility * infoAbility)1252 static void UsbUpdateHandle(NodeInfo *oldInfo, NodeInfo *newInfo, NodeInfoAbility *infoAbility)
1253 {
1254 LNN_CHECK_AND_RETURN_LOGE(oldInfo != NULL, LNN_BUILDER, "oldInfo is null");
1255 LNN_CHECK_AND_RETURN_LOGE(newInfo != NULL, LNN_BUILDER, "newInfo is null");
1256 LNN_CHECK_AND_RETURN_LOGE(infoAbility != NULL, LNN_BUILDER, "infoAbility is null");
1257 if (infoAbility->oldUsbFlag) {
1258 UpdateNodeIpInfo(oldInfo, newInfo, USB_IF);
1259 }
1260 if (infoAbility->newUsbFlag) {
1261 if (infoAbility->oldBleFlag || infoAbility->oldBrFlag) {
1262 NewWifiDiscovered(oldInfo, newInfo);
1263 }
1264 if (infoAbility->oldWifiFlag) {
1265 UpdateNodeIpInfo(oldInfo, newInfo, WLAN_IF);
1266 }
1267 (void)LnnSetNetCapability(&(newInfo->netCapacity), BIT_USB);
1268 infoAbility->isNetworkChanged = true;
1269 }
1270 }
1271
GetNodeInfoDiscovery(NodeInfo * oldInfo,NodeInfo * info,NodeInfoAbility * infoAbility)1272 static void GetNodeInfoDiscovery(NodeInfo *oldInfo, NodeInfo *info, NodeInfoAbility *infoAbility)
1273 {
1274 InitInfoAbility(info, infoAbility);
1275 if (oldInfo != NULL) {
1276 info->metaInfo = oldInfo->metaInfo;
1277 }
1278 if (oldInfo != NULL && LnnIsNodeOnline(oldInfo)) {
1279 char *anonyUuid = NULL;
1280 Anonymize(oldInfo->uuid, &anonyUuid);
1281 LNN_LOGI(LNN_LEDGER, "addOnlineNode find online node, uuid=%{public}s", AnonymizeWrapper(anonyUuid));
1282 AnonymizeFree(anonyUuid);
1283 infoAbility->isOffline = false;
1284 infoAbility->isChanged = IsNetworkIdChanged(info, oldInfo);
1285 infoAbility->oldWifiFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_WIFI);
1286 infoAbility->oldUsbFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_USB);
1287 infoAbility->oldBleFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_BLE);
1288 infoAbility->oldBrFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_BR);
1289 if ((infoAbility->oldBleFlag || infoAbility->oldBrFlag) && infoAbility->newWifiFlag) {
1290 NewWifiDiscovered(oldInfo, info);
1291 infoAbility->isNetworkChanged = true;
1292 } else if (infoAbility->oldWifiFlag && infoAbility->newBleBrFlag) {
1293 RetainOfflineCode(oldInfo, info);
1294 UpdateNodeIpInfo(oldInfo, info, WLAN_IF);
1295 infoAbility->isNetworkChanged = true;
1296 } else {
1297 RetainOfflineCode(oldInfo, info);
1298 LNN_LOGE(LNN_LEDGER, "flag error, oldBleFlag=%{public}d, oldBrFlag=%{public}d, oldWifiFlag=%{public}d,"
1299 "newWifiFlag=%{public}d, newBleBrFlag=%{public}d", infoAbility->oldBleFlag, infoAbility->oldBrFlag,
1300 infoAbility->oldWifiFlag, infoAbility->newWifiFlag, infoAbility->newBleBrFlag);
1301 }
1302 UsbUpdateHandle(oldInfo, info, infoAbility);
1303 if ((infoAbility->oldBleFlag || infoAbility->oldBrFlag) && !infoAbility->oldWifiFlag &&
1304 infoAbility->newWifiFlag) {
1305 infoAbility->isMigrateEvent = true;
1306 }
1307 // update lnn discovery type
1308 info->discoveryType |= oldInfo->discoveryType;
1309 info->AuthTypeValue = oldInfo->AuthTypeValue;
1310 info->heartbeatTimestamp = oldInfo->heartbeatTimestamp;
1311 MergeLnnInfo(oldInfo, info);
1312 UpdateProfile(info);
1313 }
1314 }
1315
DfxRecordLnnSetNodeOfflineEnd(const char * udid,int32_t onlineNum,int32_t reason)1316 static void DfxRecordLnnSetNodeOfflineEnd(const char *udid, int32_t onlineNum, int32_t reason)
1317 {
1318 LnnEventExtra extra = { 0 };
1319 LnnEventExtraInit(&extra);
1320 extra.onlineNum = onlineNum;
1321 extra.errcode = reason;
1322 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
1323
1324 char udidData[UDID_BUF_LEN] = { 0 };
1325 if (udid != NULL && strnlen(udid, UDID_BUF_LEN) != UDID_BUF_LEN && strncpy_s(udidData,
1326 UDID_BUF_LEN, udid, UDID_BUF_LEN - 1) == EOK) {
1327 extra.peerUdid = udidData;
1328 }
1329 LNN_EVENT(EVENT_SCENE_LEAVE_LNN, EVENT_STAGE_LEAVE_LNN, extra);
1330 }
1331
TryUpdateDeviceSecurityLevel(NodeInfo * info)1332 static void TryUpdateDeviceSecurityLevel(NodeInfo *info)
1333 {
1334 NodeInfo deviceInfo;
1335 (void)memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1336 uint8_t udidHash[SHA_256_HASH_LEN] = {0};
1337 char hashStr[SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1338 if (SoftBusGenerateStrHash((const unsigned char *)info->deviceInfo.deviceUdid,
1339 strlen(info->deviceInfo.deviceUdid), udidHash) != SOFTBUS_OK) {
1340 LNN_LOGE(LNN_LEDGER, "generate udidhash fail");
1341 return;
1342 }
1343 if (ConvertBytesToHexString(hashStr, SHORT_UDID_HASH_HEX_LEN + 1, udidHash,
1344 SHORT_UDID_HASH_HEX_LEN / HEXIFY_UNIT_LEN) != SOFTBUS_OK) {
1345 LNN_LOGE(LNN_LEDGER, "convert udidhash to hexstr fail");
1346 return;
1347 }
1348 if (LnnRetrieveDeviceInfoPacked(hashStr, &deviceInfo) != SOFTBUS_OK) {
1349 LNN_LOGE(LNN_LEDGER, "get deviceInfo by udidhash fail");
1350 return;
1351 }
1352 LNN_LOGI(LNN_LEDGER, "deviceSecurityLevel new=%{public}d, old=%{public}d",
1353 info->deviceSecurityLevel, deviceInfo.deviceSecurityLevel);
1354 if (deviceInfo.deviceSecurityLevel > 0) {
1355 info->deviceSecurityLevel = deviceInfo.deviceSecurityLevel;
1356 }
1357 }
1358
ReversionLastAuthSeq(NodeInfo * info)1359 static void ReversionLastAuthSeq(NodeInfo *info)
1360 {
1361 NodeInfo deviceInfo;
1362 (void)memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1363 uint8_t udidHash[SHA_256_HASH_LEN] = {0};
1364 char hashStr[SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1365 if (SoftBusGenerateStrHash((const unsigned char *)info->deviceInfo.deviceUdid,
1366 strlen(info->deviceInfo.deviceUdid), udidHash) != SOFTBUS_OK) {
1367 LNN_LOGE(LNN_LEDGER, "generate udidhash fail");
1368 return;
1369 }
1370 if (ConvertBytesToHexString(hashStr, SHORT_UDID_HASH_HEX_LEN + 1, udidHash,
1371 SHORT_UDID_HASH_HEX_LEN / HEXIFY_UNIT_LEN) != SOFTBUS_OK) {
1372 LNN_LOGE(LNN_LEDGER, "convert udidhash to hexstr fail");
1373 return;
1374 }
1375 if (LnnRetrieveDeviceInfoPacked(hashStr, &deviceInfo) != SOFTBUS_OK) {
1376 LNN_LOGE(LNN_LEDGER, "get deviceInfo by udidhash fail");
1377 return;
1378 }
1379 if (info->lastAuthSeq == 0 && deviceInfo.lastAuthSeq != 0) {
1380 info->lastAuthSeq = deviceInfo.lastAuthSeq;
1381 LNN_LOGI(LNN_LEDGER, "reversion lastAuthSeq:0->%{public}" PRId64, info->lastAuthSeq);
1382 }
1383 }
1384
UpdateTrustedDb(int64_t accountId,const char * deviceId)1385 static void UpdateTrustedDb(int64_t accountId, const char *deviceId)
1386 {
1387 int64_t localAccountId = 0;
1388 int32_t ret = LnnGetLocalNum64Info(NUM_KEY_ACCOUNT_LONG, &localAccountId);
1389 if (ret != SOFTBUS_OK) {
1390 LNN_LOGE(LNN_LEDGER, "get local accountId fail");
1391 return;
1392 }
1393 int32_t localUserId = GetActiveOsAccountIds();
1394 if ((localAccountId == accountId && LnnIsDefaultOhosAccount()) || localAccountId != accountId) {
1395 if (LnnFindDeviceUdidTrustedInfoFromDb(deviceId) == SOFTBUS_NOT_FIND &&
1396 DpHasAccessControlProfile(deviceId, true, localUserId)) {
1397 LnnInsertSpecificTrustedDevInfo(deviceId);
1398 }
1399 }
1400 }
1401
LnnAddOnlineNode(NodeInfo * info)1402 ReportCategory LnnAddOnlineNode(NodeInfo *info)
1403 {
1404 if (info == NULL) {
1405 return REPORT_NONE;
1406 }
1407 // judge map
1408 info->onlineTimestamp = (uint64_t)LnnUpTimeMs();
1409 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
1410 LNN_LOGI(LNN_LEDGER, "DiscoveryType = BR.");
1411 AddCnnCode(&g_distributedNetLedger.cnnCode.connectionCode, info->uuid, DISCOVERY_TYPE_BR, info->authSeqNum);
1412 }
1413 NodeInfoAbility infoAbility;
1414 const char *udid = LnnGetDeviceUdid(info);
1415 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1416 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1417 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1418 return REPORT_NONE;
1419 }
1420 NodeInfo *oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1421 GetNodeInfoDiscovery(oldInfo, info, &infoAbility);
1422 LnnSetNodeConnStatus(info, STATUS_ONLINE);
1423 LnnSetAuthTypeValue(&info->AuthTypeValue, ONLINE_HICHAIN);
1424 UpdateNewNodeAccountHash(info);
1425 TryUpdateDeviceSecurityLevel(info);
1426 ReversionLastAuthSeq(info);
1427 int32_t ret = LnnMapSet(&map->udidMap, udid, info, sizeof(NodeInfo));
1428 if (ret != SOFTBUS_OK) {
1429 LNN_LOGE(LNN_LEDGER, "lnn map set failed, ret=%{public}d", ret);
1430 }
1431 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1432 NodeOnlineProc(info);
1433 UpdateTrustedDb(info->accountId, info->deviceInfo.deviceUdid);
1434 if (infoAbility.isNetworkChanged) {
1435 UpdateNetworkInfo(info->deviceInfo.deviceUdid);
1436 }
1437 if (infoAbility.isOffline) {
1438 if (!infoAbility.oldWifiFlag && !infoAbility.newWifiFlag && infoAbility.newBleBrFlag) {
1439 OnlinePreventBrConnection(info);
1440 }
1441 InsertToProfile(info);
1442 return REPORT_ONLINE;
1443 }
1444 if (infoAbility.isMigrateEvent) {
1445 NotifyMigrateUpgrade(info);
1446 }
1447 if (infoAbility.isChanged) {
1448 return REPORT_CHANGE;
1449 }
1450 return REPORT_NONE;
1451 }
1452
LnnUpdateAccountInfo(const NodeInfo * info)1453 int32_t LnnUpdateAccountInfo(const NodeInfo *info)
1454 {
1455 if (info == NULL) {
1456 LNN_LOGE(LNN_LEDGER, "info is null");
1457 return SOFTBUS_INVALID_PARAM;
1458 }
1459 const char *udid = NULL;
1460 DoubleHashMap *map = NULL;
1461 NodeInfo *oldInfo = NULL;
1462 udid = LnnGetDeviceUdid(info);
1463 bool isAccountChanged = false;
1464
1465 map = &g_distributedNetLedger.distributedInfo;
1466 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1467 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1468 return SOFTBUS_LOCK_ERR;
1469 }
1470 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1471 if (oldInfo != NULL) {
1472 isAccountChanged = !(memcmp(oldInfo->accountHash, info->accountHash, sizeof(oldInfo->accountHash)) == 0);
1473 oldInfo->accountId = info->accountId;
1474 UpdateNewNodeAccountHash(oldInfo);
1475 oldInfo->userId = info->userId;
1476 }
1477 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1478 if (isAccountChanged) {
1479 UpdateDeviceInfoToMlps(udid);
1480 }
1481 return SOFTBUS_OK;
1482 }
1483
LnnUpdateRemoteDeviceName(const NodeInfo * info)1484 int32_t LnnUpdateRemoteDeviceName(const NodeInfo *info)
1485 {
1486 if (info == NULL) {
1487 LNN_LOGE(LNN_LEDGER, "info is null");
1488 return SOFTBUS_INVALID_PARAM;
1489 }
1490 const char *udid = NULL;
1491 DoubleHashMap *map = NULL;
1492 NodeInfo *oldInfo = NULL;
1493 NodeBasicInfo basic;
1494 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1495 bool isNeedUpdate = false;
1496 udid = LnnGetDeviceUdid(info);
1497
1498 map = &g_distributedNetLedger.distributedInfo;
1499 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1500 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1501 return SOFTBUS_LOCK_ERR;
1502 }
1503 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1504
1505 do {
1506 if (oldInfo == NULL) {
1507 LNN_LOGE(LNN_LEDGER, "oldInfo is null");
1508 break;
1509 }
1510 isNeedUpdate = (strcmp(oldInfo->deviceInfo.deviceName, info->deviceInfo.deviceName) != 0);
1511 if (!isNeedUpdate) {
1512 LNN_LOGI(LNN_LEDGER, "devicename not change");
1513 break;
1514 }
1515 if (strcpy_s(oldInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN,
1516 info->deviceInfo.deviceName) != EOK) {
1517 isNeedUpdate = false;
1518 LNN_LOGE(LNN_LEDGER, "strcpy_s fail");
1519 break;
1520 }
1521 if (ConvertNodeInfoToBasicInfo(oldInfo, &basic) != SOFTBUS_OK) {
1522 LNN_LOGE(LNN_LEDGER, "ConvertNodeInfoToBasicInfo fail");
1523 isNeedUpdate = false;
1524 break;
1525 }
1526 } while (false);
1527
1528 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1529 if (isNeedUpdate) {
1530 char *anonyDeviceName = NULL;
1531 AnonymizeDeviceName(basic.deviceName, &anonyDeviceName);
1532 LNN_LOGI(LNN_LEDGER, "report deviceName update, name=%{public}s", AnonymizeWrapper(anonyDeviceName));
1533 AnonymizeFree(anonyDeviceName);
1534 LnnNotifyBasicInfoChanged(&basic, TYPE_DEVICE_NAME);
1535 }
1536 return SOFTBUS_OK;
1537 }
1538
LnnUpdateGroupType(const NodeInfo * info)1539 int32_t LnnUpdateGroupType(const NodeInfo *info)
1540 {
1541 if (info == NULL) {
1542 LNN_LOGE(LNN_LEDGER, "info is null");
1543 return SOFTBUS_INVALID_PARAM;
1544 }
1545 const char *udid = NULL;
1546 DoubleHashMap *map = NULL;
1547 NodeInfo *oldInfo = NULL;
1548 udid = LnnGetDeviceUdid(info);
1549 uint32_t groupType = AuthGetGroupType(udid, info->uuid);
1550 LNN_LOGI(LNN_LEDGER, "groupType=%{public}u", groupType);
1551 int32_t ret = SOFTBUS_NETWORK_MAP_GET_FAILED;
1552 map = &g_distributedNetLedger.distributedInfo;
1553 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1554 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1555 return SOFTBUS_LOCK_ERR;
1556 }
1557 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1558 if (oldInfo != NULL) {
1559 oldInfo->groupType = groupType;
1560 ret = SOFTBUS_OK;
1561 }
1562 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1563 return ret;
1564 }
1565
NotifyMigrateDegrade(const char * udid)1566 static void NotifyMigrateDegrade(const char *udid)
1567 {
1568 NodeBasicInfo basic;
1569 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1570 if (LnnGetBasicInfoByUdid(udid, &basic) == SOFTBUS_OK) {
1571 LnnNotifyMigrate(false, &basic);
1572 } else {
1573 LNN_LOGE(LNN_LEDGER, "NotifyMigrateDegrade, GetBasicInfoByUdid fail!");
1574 }
1575 }
1576
ClearAuthChannelId(NodeInfo * info,ConnectionAddrType type,int32_t authId)1577 static ReportCategory ClearAuthChannelId(NodeInfo *info, ConnectionAddrType type, int32_t authId)
1578 {
1579 if ((LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI) && LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_WIFI) ||
1580 (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE) && LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_BLE) ||
1581 (LnnHasDiscoveryType(info, DISCOVERY_TYPE_SESSION_KEY) &&
1582 LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_SESSION_KEY) ||
1583 (LnnHasDiscoveryType(info, DISCOVERY_TYPE_USB) && LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_USB)) {
1584 if (info->authChannelId[type][AUTH_AS_CLIENT_SIDE] == authId) {
1585 info->authChannelId[type][AUTH_AS_CLIENT_SIDE] = 0;
1586 }
1587 if (info->authChannelId[type][AUTH_AS_SERVER_SIDE] == authId) {
1588 info->authChannelId[type][AUTH_AS_SERVER_SIDE] = 0;
1589 }
1590 if (info->authChannelId[type][AUTH_AS_CLIENT_SIDE] != 0 ||
1591 info->authChannelId[type][AUTH_AS_SERVER_SIDE] != 0) {
1592 LNN_LOGI(LNN_LEDGER,
1593 "authChannelId not clear, not need to report offline. authChannelId=%{public}d|%{public}d",
1594 info->authChannelId[type][AUTH_AS_CLIENT_SIDE], info->authChannelId[type][AUTH_AS_SERVER_SIDE]);
1595 return REPORT_NONE;
1596 }
1597 }
1598 info->authChannelId[type][AUTH_AS_CLIENT_SIDE] = 0;
1599 info->authChannelId[type][AUTH_AS_SERVER_SIDE] = 0;
1600 return REPORT_OFFLINE;
1601 }
1602
LnnClearIpInfo(NodeInfo * info,ConnectionAddrType type)1603 static void LnnClearIpInfo(NodeInfo *info, ConnectionAddrType type)
1604 {
1605 if (info == NULL) {
1606 LNN_LOGE(LNN_LEDGER, "info is null");
1607 return;
1608 }
1609 if (LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_WIFI) {
1610 LnnSetWiFiIp(info, LOCAL_IP, WLAN_IF);
1611 }
1612 if (LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_USB) {
1613 LnnSetWiFiIp(info, LOCAL_IPV6_STR, USB_IF);
1614 (void)LnnClearNetCapability(&(info->netCapacity), BIT_USB);
1615 }
1616 LnnClearDiscoveryType(info, LnnConvAddrTypeToDiscType(type));
1617 }
1618
LnnSetNodeOffline(const char * udid,ConnectionAddrType type,int32_t authId)1619 ReportCategory LnnSetNodeOffline(const char *udid, ConnectionAddrType type, int32_t authId)
1620 {
1621 NodeInfo *info = NULL;
1622
1623 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1624 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1625 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1626 return REPORT_NONE;
1627 }
1628 info = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1629 if (info == NULL) {
1630 LNN_LOGE(LNN_LEDGER, "PARA ERROR!");
1631 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1632 return REPORT_NONE;
1633 }
1634 if (type != CONNECTION_ADDR_MAX && info->relation[type] > 0) {
1635 info->relation[type]--;
1636 }
1637 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR) && LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_BR) {
1638 RemoveCnnCode(&g_distributedNetLedger.cnnCode.connectionCode, info->uuid, DISCOVERY_TYPE_BR);
1639 }
1640 if (ClearAuthChannelId(info, type, authId) == REPORT_NONE) {
1641 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1642 return REPORT_NONE;
1643 }
1644 LnnClearIpInfo(info, type);
1645 if (info->discoveryType != 0) {
1646 LNN_LOGI(LNN_LEDGER, "after clear, not need to report offline. discoveryType=%{public}u", info->discoveryType);
1647 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1648 UpdateNetworkInfo(udid);
1649 if (type == CONNECTION_ADDR_WLAN) {
1650 NotifyMigrateDegrade(udid);
1651 }
1652 return REPORT_NONE;
1653 }
1654 if (!LnnIsNodeOnline(info)) {
1655 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1656 LNN_LOGI(LNN_LEDGER, "the state is already offline, no need to report offline");
1657 return REPORT_NONE;
1658 }
1659 LnnSetNodeConnStatus(info, STATUS_OFFLINE);
1660 LnnClearAuthTypeValue(&info->AuthTypeValue, ONLINE_HICHAIN);
1661 info->offlineTimestamp = (uint64_t)LnnUpTimeMs();
1662 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1663 LNN_LOGI(LNN_LEDGER, "need to report offline");
1664 DfxRecordLnnSetNodeOfflineEnd(udid, (int32_t)MapGetSize(&map->udidMap), SOFTBUS_OK);
1665 return REPORT_OFFLINE;
1666 }
1667
LnnGetBasicInfoByUdid(const char * udid,NodeBasicInfo * basicInfo)1668 int32_t LnnGetBasicInfoByUdid(const char *udid, NodeBasicInfo *basicInfo)
1669 {
1670 if (udid == NULL || basicInfo == NULL) {
1671 LNN_LOGE(LNN_LEDGER, "PARA ERROR");
1672 return SOFTBUS_INVALID_PARAM;
1673 }
1674 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1675 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1676 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1677 return SOFTBUS_LOCK_ERR;
1678 }
1679 NodeInfo *info = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1680 int32_t ret = ConvertNodeInfoToBasicInfo(info, basicInfo);
1681 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1682 return ret;
1683 }
1684
LnnRemoveNode(const char * udid)1685 void LnnRemoveNode(const char *udid)
1686 {
1687 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1688 if (udid == NULL) {
1689 return;
1690 }
1691 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1692 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1693 return;
1694 }
1695 LnnMapErase(&map->udidMap, udid);
1696 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1697 }
1698
LnnConvertDLidToUdid(const char * id,IdCategory type)1699 const char *LnnConvertDLidToUdid(const char *id, IdCategory type)
1700 {
1701 NodeInfo *info = NULL;
1702 if (id == NULL) {
1703 return NULL;
1704 }
1705 info = LnnGetNodeInfoById(id, type);
1706 if (info == NULL) {
1707 LNN_LOGE(LNN_LEDGER, "uuid not find node info.");
1708 return NULL;
1709 }
1710 return LnnGetDeviceUdid(info);
1711 }
1712
LnnConvertDlId(const char * srcId,IdCategory srcIdType,IdCategory dstIdType,char * dstIdBuf,uint32_t dstIdBufLen)1713 int32_t LnnConvertDlId(const char *srcId, IdCategory srcIdType, IdCategory dstIdType,
1714 char *dstIdBuf, uint32_t dstIdBufLen)
1715 {
1716 NodeInfo *info = NULL;
1717 const char *id = NULL;
1718 int32_t rc = SOFTBUS_OK;
1719
1720 if (srcId == NULL || dstIdBuf == NULL) {
1721 return SOFTBUS_INVALID_PARAM;
1722 }
1723 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1724 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1725 return SOFTBUS_LOCK_ERR;
1726 }
1727 info = LnnGetNodeInfoById(srcId, srcIdType);
1728 if (info == NULL) {
1729 LNN_LOGE(LNN_LEDGER, "no node info srcIdType=%{public}d", srcIdType);
1730 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1731 return SOFTBUS_NOT_FIND;
1732 }
1733 switch (dstIdType) {
1734 case CATEGORY_UDID:
1735 id = info->deviceInfo.deviceUdid;
1736 break;
1737 case CATEGORY_UUID:
1738 id = info->uuid;
1739 break;
1740 case CATEGORY_NETWORK_ID:
1741 id = info->networkId;
1742 break;
1743 default:
1744 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1745 return SOFTBUS_INVALID_PARAM;
1746 }
1747 if (strcpy_s(dstIdBuf, dstIdBufLen, id) != EOK) {
1748 LNN_LOGE(LNN_LEDGER, "copy id fail");
1749 rc = SOFTBUS_MEM_ERR;
1750 }
1751 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1752 return rc;
1753 }
1754
LnnGetLnnRelation(const char * id,IdCategory type,uint8_t * relation,uint32_t len)1755 int32_t LnnGetLnnRelation(const char *id, IdCategory type, uint8_t *relation, uint32_t len)
1756 {
1757 NodeInfo *info = NULL;
1758
1759 if (id == NULL || relation == NULL) {
1760 return SOFTBUS_INVALID_PARAM;
1761 }
1762 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1763 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1764 return SOFTBUS_LOCK_ERR;
1765 }
1766 info = LnnGetNodeInfoById(id, type);
1767 if (info == NULL || !LnnIsNodeOnline(info)) {
1768 LNN_LOGE(LNN_LEDGER, "node not online");
1769 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1770 return SOFTBUS_NOT_FIND;
1771 }
1772 if (memcpy_s(relation, len, info->relation, CONNECTION_ADDR_MAX) != EOK) {
1773 LNN_LOGE(LNN_LEDGER, "copy relation fail");
1774 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1775 return SOFTBUS_MEM_ERR;
1776 }
1777 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1778 return SOFTBUS_OK;
1779 }
1780
UpdateDeviceNameToDLedger(NodeInfo * newInfo,NodeInfo * oldInfo)1781 static void UpdateDeviceNameToDLedger(NodeInfo *newInfo, NodeInfo *oldInfo)
1782 {
1783 if (strlen(newInfo->deviceInfo.deviceName) != 0) {
1784 if (strcpy_s(oldInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.deviceName) != EOK) {
1785 LNN_LOGE(LNN_LEDGER, "strcpy_s deviceName to distributed ledger fail");
1786 }
1787 }
1788 if (strlen(newInfo->deviceInfo.unifiedName) != 0) {
1789 if (strcpy_s(oldInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.unifiedName) != EOK) {
1790 LNN_LOGE(LNN_LEDGER, "strcpy_s unifiedName to distributed ledger fail");
1791 }
1792 }
1793 if (strlen(newInfo->deviceInfo.unifiedDefaultName) != 0) {
1794 if (strcpy_s(oldInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN,
1795 newInfo->deviceInfo.unifiedDefaultName) != EOK) {
1796 LNN_LOGE(LNN_LEDGER, "strcpy_s unifiedDefaultName to distributed ledger fail");
1797 }
1798 }
1799 if (strlen(newInfo->deviceInfo.nickName) != 0) {
1800 if (strcpy_s(oldInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.nickName) != EOK) {
1801 LNN_LOGE(LNN_LEDGER, "strcpy_s nickName to distributed ledger fail");
1802 }
1803 }
1804 }
1805
UpdateDevBasicInfoToDLedger(NodeInfo * newInfo,NodeInfo * oldInfo)1806 static void UpdateDevBasicInfoToDLedger(NodeInfo *newInfo, NodeInfo *oldInfo)
1807 {
1808 if (strcmp(newInfo->networkId, oldInfo->networkId) == 0 || oldInfo->status != STATUS_ONLINE ||
1809 !LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_BLE)
1810 || LnnFindDeviceUdidTrustedInfoFromDb(newInfo->deviceInfo.deviceUdid) != SOFTBUS_OK) {
1811 oldInfo->stateVersion = newInfo->stateVersion;
1812 }
1813
1814 UpdateDeviceNameToDLedger(newInfo, oldInfo);
1815 if (strcpy_s(oldInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, newInfo->deviceInfo.deviceUdid) != EOK) {
1816 LNN_LOGE(LNN_LEDGER, "strcpy_s deviceUdid to distributed ledger fail");
1817 }
1818 if (strcpy_s(oldInfo->deviceInfo.deviceVersion, DEVICE_VERSION_SIZE_MAX, newInfo->deviceInfo.deviceVersion) !=
1819 EOK) {
1820 LNN_LOGE(LNN_LEDGER, "strcpy_s deviceVersion to distributed ledger fail");
1821 }
1822 if (strcpy_s(oldInfo->deviceInfo.productId, PRODUCT_ID_SIZE_MAX, newInfo->deviceInfo.productId) != EOK) {
1823 LNN_LOGE(LNN_LEDGER, "strcpy_s productId to distributed ledger fail");
1824 }
1825 if (strcpy_s(oldInfo->deviceInfo.modelName, MODEL_NAME_SIZE_MAX, newInfo->deviceInfo.modelName) != EOK) {
1826 LNN_LOGE(LNN_LEDGER, "strcpy_s modelName to distributed ledger fail");
1827 }
1828 oldInfo->deviceInfo.deviceTypeId = newInfo->deviceInfo.deviceTypeId;
1829 oldInfo->isBleP2p = newInfo->isBleP2p;
1830 oldInfo->supportedProtocols = newInfo->supportedProtocols;
1831 oldInfo->wifiVersion = newInfo->wifiVersion;
1832 oldInfo->bleVersion = newInfo->bleVersion;
1833 oldInfo->accountId = newInfo->accountId;
1834 oldInfo->feature = newInfo->feature;
1835 oldInfo->connSubFeature = newInfo->connSubFeature;
1836 oldInfo->authCapacity = newInfo->authCapacity;
1837 oldInfo->deviceInfo.osType = newInfo->deviceInfo.osType;
1838 oldInfo->updateTimestamp = newInfo->updateTimestamp;
1839 oldInfo->deviceSecurityLevel = newInfo->deviceSecurityLevel;
1840 oldInfo->staticNetCap = newInfo->staticNetCap;
1841 oldInfo->sleRangeCapacity = newInfo->sleRangeCapacity;
1842 }
1843
UpdateDistributedLedger(NodeInfo * newInfo,NodeInfo * oldInfo)1844 static void UpdateDistributedLedger(NodeInfo *newInfo, NodeInfo *oldInfo)
1845 {
1846 if (newInfo == NULL || oldInfo == NULL) {
1847 LNN_LOGE(LNN_LEDGER, "param error");
1848 return;
1849 }
1850 if (strcpy_s(oldInfo->softBusVersion, VERSION_MAX_LEN, newInfo->softBusVersion) != EOK) {
1851 LNN_LOGE(LNN_LEDGER, "strcpy_s softBusVersion to distributed ledger fail");
1852 }
1853 if (strcpy_s(oldInfo->pkgVersion, VERSION_MAX_LEN, newInfo->pkgVersion) != EOK) {
1854 LNN_LOGE(LNN_LEDGER, "strcpy_s pkgVersion to distributed ledger fail");
1855 }
1856 if (strcpy_s(oldInfo->connectInfo.macAddr, MAC_LEN, newInfo->connectInfo.macAddr) != EOK) {
1857 LNN_LOGE(LNN_LEDGER, "strcpy_s macAddr to distributed ledger fail");
1858 }
1859 if (strcpy_s(oldInfo->connectInfo.sleMacAddr, MAC_LEN, newInfo->connectInfo.sleMacAddr) != EOK) {
1860 LNN_LOGE(LNN_LEDGER, "strcpy_s sleAddr to distributed ledger fail");
1861 }
1862 if (strcpy_s(oldInfo->deviceInfo.osVersion, OS_VERSION_BUF_LEN, newInfo->deviceInfo.osVersion) != EOK) {
1863 LNN_LOGE(LNN_LEDGER, "strcpy_s osVersion to distributed ledger fail");
1864 }
1865 if (strcpy_s(oldInfo->p2pInfo.p2pMac, MAC_LEN, newInfo->p2pInfo.p2pMac) != EOK) {
1866 LNN_LOGE(LNN_LEDGER, "strcpy_s p2pMac to distributed ledger fail");
1867 }
1868 if (strcpy_s(oldInfo->accountUid, ACCOUNT_UID_STR_LEN, newInfo->accountUid) != EOK) {
1869 LNN_LOGE(LNN_LEDGER, "strcpy_s accountUid to cache info fail");
1870 }
1871 if (memcpy_s((char *)oldInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN, (char *)newInfo->rpaInfo.peerIrk,
1872 LFINDER_IRK_LEN) != EOK) {
1873 LNN_LOGE(LNN_LEDGER, "memcpy_s peerIrk to distributed ledger fail");
1874 }
1875 if (memcpy_s((char *)oldInfo->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, (char *)newInfo->rpaInfo.publicAddress,
1876 LFINDER_MAC_ADDR_LEN) != EOK) {
1877 LNN_LOGE(LNN_LEDGER, "memcpy_s publicAddress to distributed ledger fail");
1878 }
1879 if (memcpy_s((char *)oldInfo->cipherInfo.key, SESSION_KEY_LENGTH, newInfo->cipherInfo.key, SESSION_KEY_LENGTH) !=
1880 EOK) {
1881 LNN_LOGE(LNN_LEDGER, "memcpy_s cipherInfo key to distributed ledger fail");
1882 }
1883 if (memcpy_s((char *)oldInfo->cipherInfo.iv, BROADCAST_IV_LEN, newInfo->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
1884 LNN_LOGE(LNN_LEDGER, "memcpy_s cipherInfo iv to distributed ledger fail");
1885 }
1886 UpdateDevBasicInfoToDLedger(newInfo, oldInfo);
1887 }
1888
IsIgnoreUpdateToLedger(int32_t oldStateVersion,uint64_t oldTimestamp,int32_t newStateVersion,uint64_t newTimestamp)1889 static bool IsIgnoreUpdateToLedger(
1890 int32_t oldStateVersion, uint64_t oldTimestamp, int32_t newStateVersion, uint64_t newTimestamp)
1891 {
1892 bool isIgnore = oldTimestamp > newTimestamp || (oldTimestamp == 0 && oldStateVersion > newStateVersion);
1893 if (isIgnore) {
1894 LNN_LOGE(LNN_BUILDER,
1895 "sync info is older, oldDLeger.stateVersion=%{public}d, oldDLegerTimestamp=%{public}" PRIu64
1896 ", newSyncInfo.stateVersion=%{public}d, newTimestamp=%{public}" PRIu64 "",
1897 oldStateVersion, oldTimestamp, newStateVersion, newTimestamp);
1898 }
1899 return isIgnore;
1900 }
1901
LnnUpdateDistributedNodeInfo(NodeInfo * newInfo,const char * udid)1902 int32_t LnnUpdateDistributedNodeInfo(NodeInfo *newInfo, const char *udid)
1903 {
1904 if (newInfo == NULL || udid == NULL) {
1905 LNN_LOGE(LNN_LEDGER, "param error");
1906 return SOFTBUS_INVALID_PARAM;
1907 }
1908 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1909 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1910 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1911 return SOFTBUS_LOCK_ERR;
1912 }
1913 NodeInfo *oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1914 if (oldInfo == NULL) {
1915 LNN_LOGI(LNN_LEDGER, "no this device info in ledger, need to insert");
1916 int32_t ret = LnnMapSet(&map->udidMap, udid, newInfo, sizeof(NodeInfo));
1917 if (ret != SOFTBUS_OK) {
1918 LNN_LOGE(LNN_LEDGER, "lnn map set failed, ret=%{public}d", ret);
1919 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1920 return SOFTBUS_NETWORK_MAP_SET_FAILED;
1921 }
1922 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1923 LNN_LOGD(LNN_LEDGER, "DB data new device nodeinfo insert to distributed ledger success.");
1924 return SOFTBUS_OK;
1925 }
1926 if (IsIgnoreUpdateToLedger(oldInfo->stateVersion, oldInfo->updateTimestamp, newInfo->stateVersion,
1927 newInfo->updateTimestamp)) {
1928 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1929 return SOFTBUS_OK;
1930 }
1931 UpdateDistributedLedger(newInfo, oldInfo);
1932 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1933 LNN_LOGD(LNN_LEDGER, "DB data update to distributed ledger success.");
1934 return SOFTBUS_OK;
1935 }
1936
GetAllOnlineAndMetaNodeInfo(NodeBasicInfo ** info,int32_t * infoNum,bool isNeedMeta)1937 static int32_t GetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum, bool isNeedMeta)
1938 {
1939 if (info == NULL || infoNum == NULL) {
1940 LNN_LOGE(LNN_LEDGER, "key params are null");
1941 return SOFTBUS_INVALID_PARAM;
1942 }
1943 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1944 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1945 return SOFTBUS_LOCK_ERR;
1946 }
1947 int32_t ret = SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
1948 do {
1949 *info = NULL;
1950 if (GetDLOnlineNodeNumLocked(infoNum, isNeedMeta) != SOFTBUS_OK) {
1951 LNN_LOGE(LNN_LEDGER, "get online node num failed");
1952 break;
1953 }
1954 if (*infoNum == 0) {
1955 ret = SOFTBUS_OK;
1956 break;
1957 }
1958 *info = (NodeBasicInfo*)SoftBusCalloc((*infoNum) * sizeof(NodeBasicInfo));
1959 if (*info == NULL) {
1960 LNN_LOGE(LNN_LEDGER, "malloc node info buffer failed");
1961 break;
1962 }
1963 if (FillDLOnlineNodeInfoLocked(*info, *infoNum, isNeedMeta) != SOFTBUS_OK) {
1964 LNN_LOGE(LNN_LEDGER, "fill online node num failed");
1965 break;
1966 }
1967 ret = SOFTBUS_OK;
1968 } while (false);
1969 if (ret != SOFTBUS_OK) {
1970 if (*info != NULL) {
1971 SoftBusFree(*info);
1972 *info = NULL;
1973 }
1974 *infoNum = 0;
1975 }
1976 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1977 return ret;
1978 }
1979
LnnIsLSANode(const NodeBasicInfo * info)1980 bool LnnIsLSANode(const NodeBasicInfo *info)
1981 {
1982 NodeInfo *nodeInfo = LnnGetNodeInfoById(info->networkId, CATEGORY_NETWORK_ID);
1983 if (nodeInfo != NULL && LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_LSA)) {
1984 return true;
1985 }
1986 return false;
1987 }
1988
LnnGetAllOnlineNodeNum(int32_t * nodeNum)1989 int32_t LnnGetAllOnlineNodeNum(int32_t *nodeNum)
1990 {
1991 if (nodeNum == NULL) {
1992 return SOFTBUS_INVALID_PARAM;
1993 }
1994 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1995 LNN_LOGE(LNN_LEDGER, "lock fail");
1996 return SOFTBUS_LOCK_ERR;
1997 }
1998 /* node num include meta node */
1999 if (GetDLOnlineNodeNumLocked(nodeNum, true) != SOFTBUS_OK) {
2000 LNN_LOGE(LNN_LEDGER, "get online node num failed");
2001 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2002 return SOFTBUS_NOT_FIND;
2003 }
2004 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2005 return SOFTBUS_OK;
2006 }
2007
2008 /* use after locking */
GetOnlineAndOfflineWithinTimeNumLocked(int32_t * udidNum,uint64_t currentTime,uint64_t timeRange)2009 static int32_t GetOnlineAndOfflineWithinTimeNumLocked(int32_t *udidNum, uint64_t currentTime, uint64_t timeRange)
2010 {
2011 NodeInfo *info = NULL;
2012 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
2013 MapIterator *it = LnnMapInitIterator(&map->udidMap);
2014 if (it == NULL) {
2015 LNN_LOGE(LNN_LEDGER, "it is null");
2016 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
2017 }
2018 *udidNum = 0;
2019 while (LnnMapHasNext(it)) {
2020 it = LnnMapNext(it);
2021 if (it == NULL) {
2022 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
2023 }
2024 info = (NodeInfo *)it->node->value;
2025 if (IsMetaNode(info)) {
2026 continue;
2027 }
2028 if (!LnnIsNodeOnline(info) && ((currentTime < info->offlineTimestamp) ||
2029 ((currentTime - info->offlineTimestamp) > timeRange))) {
2030 continue;
2031 }
2032 (*udidNum)++;
2033 }
2034 LnnMapDeinitIterator(it);
2035 return SOFTBUS_OK;
2036 }
2037
FillOnlineAndOfflineWithinTimeUdidsLocked(char * udids,int32_t udidNum,uint64_t currentTime,uint64_t timeRange)2038 static int32_t FillOnlineAndOfflineWithinTimeUdidsLocked(
2039 char *udids, int32_t udidNum, uint64_t currentTime, uint64_t timeRange)
2040 {
2041 NodeInfo *nodeInfo = NULL;
2042 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
2043 MapIterator *it = LnnMapInitIterator(&map->udidMap);
2044 int32_t i = 0;
2045 if (it == NULL) {
2046 LNN_LOGE(LNN_LEDGER, "it is null");
2047 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
2048 }
2049 while (LnnMapHasNext(it) && i < udidNum) {
2050 it = LnnMapNext(it);
2051 if (it == NULL) {
2052 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
2053 }
2054 nodeInfo = (NodeInfo *)it->node->value;
2055 if (IsMetaNode(nodeInfo)) {
2056 continue;
2057 }
2058 if (!LnnIsNodeOnline(nodeInfo) && ((currentTime < nodeInfo->offlineTimestamp) ||
2059 ((currentTime - nodeInfo->offlineTimestamp) > timeRange))) {
2060 continue;
2061 }
2062 if (strcpy_s(udids + i * UDID_BUF_LEN, UDID_BUF_LEN, nodeInfo->deviceInfo.deviceUdid) != EOK) {
2063 LNN_LOGE(LNN_LEDGER, "strcpy fail");
2064 LnnMapDeinitIterator(it);
2065 return SOFTBUS_STRCPY_ERR;
2066 }
2067 ++i;
2068 }
2069 LnnMapDeinitIterator(it);
2070 return SOFTBUS_OK;
2071 }
2072
LnnGetOnlineAndOfflineWithinTimeUdids(char ** udids,int32_t * udidNum,uint64_t timeRange)2073 int32_t LnnGetOnlineAndOfflineWithinTimeUdids(char **udids, int32_t *udidNum, uint64_t timeRange)
2074 {
2075 if (udids == NULL || udidNum == NULL) {
2076 LNN_LOGE(LNN_LEDGER, "key params are null");
2077 return SOFTBUS_INVALID_PARAM;
2078 }
2079 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != SOFTBUS_OK) {
2080 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
2081 return SOFTBUS_LOCK_ERR;
2082 }
2083 uint64_t currentTime = (uint64_t)LnnUpTimeMs();
2084 int32_t ret = SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
2085 do {
2086 *udids = NULL;
2087 if (GetOnlineAndOfflineWithinTimeNumLocked(udidNum, currentTime, timeRange) != SOFTBUS_OK) {
2088 LNN_LOGE(LNN_LEDGER, "get online node num failed");
2089 break;
2090 }
2091 if (*udidNum == 0) {
2092 LNN_LOGE(LNN_LEDGER, "get node num 0");
2093 ret = SOFTBUS_OK;
2094 break;
2095 }
2096 *udids = (char *)SoftBusCalloc((*udidNum) * UDID_BUF_LEN);
2097 if (*udids == NULL) {
2098 LNN_LOGE(LNN_LEDGER, "malloc node info buffer failed");
2099 break;
2100 }
2101 if (FillOnlineAndOfflineWithinTimeUdidsLocked(*udids, *udidNum, currentTime, timeRange) != SOFTBUS_OK) {
2102 LNN_LOGE(LNN_LEDGER, "fill online node udids failed");
2103 break;
2104 }
2105 ret = SOFTBUS_OK;
2106 } while (false);
2107 if (ret != SOFTBUS_OK) {
2108 if (*udids != NULL) {
2109 SoftBusFree(*udids);
2110 *udids = NULL;
2111 }
2112 *udidNum = 0;
2113 }
2114 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2115 return ret;
2116 }
2117
LnnGetAllOnlineNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)2118 int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
2119 {
2120 return GetAllOnlineAndMetaNodeInfo(info, infoNum, false);
2121 }
2122
LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)2123 int32_t LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
2124 {
2125 return GetAllOnlineAndMetaNodeInfo(info, infoNum, true);
2126 }
2127
SoftBusDumpBusCenterRemoteDeviceInfo(int32_t fd)2128 int32_t SoftBusDumpBusCenterRemoteDeviceInfo(int32_t fd)
2129 {
2130 SOFTBUS_DPRINTF(fd, "-----RemoteDeviceInfo-----\n");
2131 NodeBasicInfo *remoteNodeInfo = NULL;
2132 int32_t infoNum = 0;
2133 if (LnnGetAllOnlineNodeInfo(&remoteNodeInfo, &infoNum) != 0) {
2134 LNN_LOGE(LNN_LEDGER, "LnnGetAllOnlineNodeInfo failed");
2135 return SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
2136 }
2137 SOFTBUS_DPRINTF(fd, "remote device num = %d\n", infoNum);
2138 for (int32_t i = 0; i < infoNum; i++) {
2139 SOFTBUS_DPRINTF(fd, "\n[NO.%d]\n", i + 1);
2140 SoftBusDumpBusCenterPrintInfo(fd, remoteNodeInfo + i);
2141 }
2142 SoftBusFree(remoteNodeInfo);
2143 return SOFTBUS_OK;
2144 }
2145
LnnInitDistributedLedger(void)2146 int32_t LnnInitDistributedLedger(void)
2147 {
2148 if (g_distributedNetLedger.status == DL_INIT_SUCCESS) {
2149 LNN_LOGI(LNN_LEDGER, "Distributed Ledger already init");
2150 return SOFTBUS_OK;
2151 }
2152
2153 int32_t ret = InitDistributedInfo(&g_distributedNetLedger.distributedInfo);
2154 if (ret != SOFTBUS_OK) {
2155 LNN_LOGE(LNN_LEDGER, "InitDistributedInfo ERROR");
2156 g_distributedNetLedger.status = DL_INIT_FAIL;
2157 return ret;
2158 }
2159
2160 ret = InitConnectionCode(&g_distributedNetLedger.cnnCode);
2161 if (ret != SOFTBUS_OK) {
2162 LNN_LOGE(LNN_LEDGER, "InitConnectionCode ERROR");
2163 g_distributedNetLedger.status = DL_INIT_FAIL;
2164 return ret;
2165 }
2166 if (SoftBusMutexInit(&g_distributedNetLedger.lock, NULL) != SOFTBUS_OK) {
2167 g_distributedNetLedger.status = DL_INIT_FAIL;
2168 return SOFTBUS_LOCK_ERR;
2169 }
2170 ret = SoftBusRegBusCenterVarDump((char*)SOFTBUS_BUSCENTER_DUMP_REMOTEDEVICEINFO,
2171 &SoftBusDumpBusCenterRemoteDeviceInfo);
2172 if (ret != SOFTBUS_OK) {
2173 LNN_LOGE(LNN_LEDGER, "SoftBusRegBusCenterVarDump regist fail");
2174 return ret;
2175 }
2176 g_distributedNetLedger.status = DL_INIT_SUCCESS;
2177 return SOFTBUS_OK;
2178 }
2179
LnnGetOnlineNodeByUdidHash(const char * recvUdidHash)2180 const NodeInfo *LnnGetOnlineNodeByUdidHash(const char *recvUdidHash)
2181 {
2182 int32_t i;
2183 int32_t infoNum = 0;
2184 NodeBasicInfo *info = NULL;
2185 unsigned char shortUdidHash[SHORT_UDID_HASH_LEN + 1] = {0};
2186
2187 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
2188 LNN_LOGE(LNN_LEDGER, "get all online node info fail");
2189 return NULL;
2190 }
2191 if (info == NULL || infoNum == 0) {
2192 if (info != NULL) {
2193 SoftBusFree(info);
2194 }
2195 return NULL;
2196 }
2197 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2198 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
2199 SoftBusFree(info);
2200 return NULL;
2201 }
2202 for (i = 0; i < infoNum; ++i) {
2203 const NodeInfo *nodeInfo = LnnGetNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID);
2204 if (nodeInfo == NULL) {
2205 LNN_LOGI(LNN_LEDGER, "nodeInfo is null");
2206 continue;
2207 }
2208 if (GenerateStrHashAndConvertToHexString((const unsigned char *)nodeInfo->deviceInfo.deviceUdid,
2209 SHORT_UDID_HASH_LEN, shortUdidHash, SHORT_UDID_HASH_LEN + 1) != SOFTBUS_OK) {
2210 continue;
2211 }
2212 if (memcmp(shortUdidHash, recvUdidHash, SHORT_UDID_HASH_LEN) == 0) {
2213 char *anoyUdid = NULL;
2214 char *anoyUdidHash = NULL;
2215 Anonymize(nodeInfo->deviceInfo.deviceUdid, &anoyUdid);
2216 Anonymize((const char *)shortUdidHash, &anoyUdidHash);
2217 LNN_LOGI(LNN_LEDGER, "node is online. nodeUdid=%{public}s, shortUdidHash=%{public}s",
2218 AnonymizeWrapper(anoyUdid), AnonymizeWrapper(anoyUdidHash));
2219 AnonymizeFree(anoyUdid);
2220 AnonymizeFree(anoyUdidHash);
2221 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2222 SoftBusFree(info);
2223 return nodeInfo;
2224 }
2225 }
2226 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2227 SoftBusFree(info);
2228 return NULL;
2229 }
2230
RefreshDeviceOnlineStateInfo(DeviceInfo * device,const InnerDeviceInfoAddtions * additions)2231 static void RefreshDeviceOnlineStateInfo(DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
2232 {
2233 if (additions->medium == COAP || additions->medium == BLE) {
2234 device->isOnline = ((LnnGetOnlineNodeByUdidHash(device->devId)) != NULL) ? true : false;
2235 }
2236 }
2237
LnnRefreshDeviceOnlineStateAndDevIdInfo(const char * pkgName,DeviceInfo * device,const InnerDeviceInfoAddtions * additions)2238 void LnnRefreshDeviceOnlineStateAndDevIdInfo(const char *pkgName, DeviceInfo *device,
2239 const InnerDeviceInfoAddtions *additions)
2240 {
2241 (void)pkgName;
2242 RefreshDeviceOnlineStateInfo(device, additions);
2243 if (device->devId[0] != '\0') {
2244 char *anoyUdidHash = NULL;
2245 Anonymize(device->devId, &anoyUdidHash);
2246 LNN_LOGI(LNN_LEDGER, "device found. medium=%{public}d, udidhash=%{public}s, onlineStatus=%{public}d",
2247 additions->medium, AnonymizeWrapper(anoyUdidHash), device->isOnline);
2248 AnonymizeFree(anoyUdidHash);
2249 }
2250 }
2251
LnnGetOsTypeByNetworkId(const char * networkId,int32_t * osType)2252 int32_t LnnGetOsTypeByNetworkId(const char *networkId, int32_t *osType)
2253 {
2254 if (networkId == NULL || osType == NULL) {
2255 LNN_LOGE(LNN_LEDGER, "invalid param");
2256 return SOFTBUS_INVALID_PARAM;
2257 }
2258 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2259 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2260 return SOFTBUS_LOCK_ERR;
2261 }
2262 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2263 if (nodeInfo == NULL) {
2264 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2265 char *anonyNetworkId = NULL;
2266 Anonymize(networkId, &anonyNetworkId);
2267 LNN_LOGE(LNN_LEDGER, "get info by networkId=%{public}s failed", AnonymizeWrapper(anonyNetworkId));
2268 AnonymizeFree(anonyNetworkId);
2269 return SOFTBUS_NOT_FIND;
2270 }
2271 *osType = nodeInfo->deviceInfo.osType;
2272 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2273 return SOFTBUS_OK;
2274 }
2275
IsAvailableMeta(const char * peerNetWorkId)2276 bool IsAvailableMeta(const char *peerNetWorkId)
2277 {
2278 int32_t value = 0;
2279 int32_t ret = LnnGetRemoteNumInfo(peerNetWorkId, NUM_KEY_META_NODE, &value);
2280 if (ret != SOFTBUS_OK) {
2281 LNN_LOGE(LNN_LEDGER, "GetAuthType fail, ret=%{public}d", ret);
2282 return false;
2283 }
2284 return ((uint32_t)value & (1 << ONLINE_METANODE));
2285 }
2286
IsRemoteDeviceSupportBleGuide(const char * id,IdCategory type)2287 bool IsRemoteDeviceSupportBleGuide(const char *id, IdCategory type)
2288 {
2289 if (id == NULL) {
2290 LNN_LOGE(LNN_LEDGER, "invalid param");
2291 return true;
2292 }
2293 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2294 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2295 return true;
2296 }
2297 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2298 if (nodeInfo == NULL) {
2299 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2300 char *anonyUuid = NULL;
2301 Anonymize(id, &anonyUuid);
2302 LNN_LOGW(LNN_LEDGER, "get info by id=%{public}s, type=%{public}d", AnonymizeWrapper(anonyUuid), type);
2303 AnonymizeFree(anonyUuid);
2304 return false;
2305 }
2306 if (!nodeInfo->isSupportSv && !nodeInfo->isBleP2p && nodeInfo->deviceInfo.deviceTypeId == TYPE_TV_ID) {
2307 LNN_LOGI(LNN_LEDGER,
2308 "peer device unsupport ble guide, isSupportSv=%{public}d, isBleP2p=%{public}d, deviceTypeId=%{public}d",
2309 nodeInfo->isSupportSv, nodeInfo->isBleP2p, nodeInfo->deviceInfo.deviceTypeId);
2310 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2311 return false;
2312 }
2313 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2314 return true;
2315 }
2316