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