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.h"
17
18 #include <stddef.h>
19 #include <stdlib.h>
20 #include <string.h>
21
22 #include <securec.h>
23
24 #include "lnn_connection_addr_utils.h"
25 #include "lnn_fast_offline.h"
26 #include "lnn_lane_info.h"
27 #include "lnn_map.h"
28 #include "lnn_node_info.h"
29 #include "lnn_lane_def.h"
30 #include "lnn_deviceinfo_to_profile.h"
31 #include "lnn_device_info_recovery.h"
32 #include "lnn_feature_capability.h"
33 #include "lnn_local_net_ledger.h"
34 #include "softbus_adapter_mem.h"
35 #include "softbus_adapter_thread.h"
36 #include "softbus_adapter_crypto.h"
37 #include "softbus_bus_center.h"
38 #include "softbus_def.h"
39 #include "softbus_errcode.h"
40 #include "softbus_log.h"
41 #include "softbus_adapter_crypto.h"
42 #include "softbus_utils.h"
43 #include "softbus_hidumper_buscenter.h"
44 #include "bus_center_manager.h"
45 #include "softbus_hisysevt_bus_center.h"
46 #include "bus_center_event.h"
47
48 #define TIME_THOUSANDS_FACTOR (1000)
49 #define BLE_ADV_LOST_TIME 5000
50 #define LONG_TO_STRING_MAX_LEN 21
51 #define LNN_COMMON_LEN_64 8
52 #define SOFTBUS_BUSCENTER_DUMP_REMOTEDEVICEINFO "remote_device_info"
53
54 #define RETURN_IF_GET_NODE_VALID(networkId, buf, info) do { \
55 if ((networkId) == NULL || (buf) == NULL) { \
56 return SOFTBUS_INVALID_PARAM; \
57 } \
58 (info) = LnnGetNodeInfoById((networkId), (CATEGORY_NETWORK_ID)); \
59 if ((info) == NULL) { \
60 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get node info fail."); \
61 return SOFTBUS_ERR; \
62 } \
63 } while (0) \
64
65 #define CONNECTION_FREEZE_TIMEOUT_MILLIS (10 * 1000)
66
67 // softbus version for support initConnectFlag
68 #define SOFTBUS_VERSION_FOR_INITCONNECTFLAG "11.1.0.001"
69
70 typedef struct {
71 Map udidMap;
72 Map ipMap;
73 Map macMap;
74 } DoubleHashMap;
75
76 typedef enum {
77 DL_INIT_UNKNOWN = 0,
78 DL_INIT_FAIL,
79 DL_INIT_SUCCESS,
80 } DistributedLedgerStatus;
81
82 typedef struct {
83 Map connectionCode;
84 } ConnectionCode;
85
86 typedef struct {
87 DoubleHashMap distributedInfo;
88 ConnectionCode cnnCode;
89 int32_t countMax;
90 SoftBusMutex lock;
91 DistributedLedgerStatus status;
92 } DistributedNetLedger;
93
94 static DistributedNetLedger g_distributedNetLedger;
95
UpdateNetworkInfo(const char * udid)96 static void UpdateNetworkInfo(const char *udid)
97 {
98 NodeBasicInfo basic = { 0 };
99 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
100 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetBasicInfoByUdid fail.");
101 return;
102 }
103 LnnNotifyBasicInfoChanged(&basic, TYPE_NETWORK_INFO);
104 }
105
GetCurrentTime(void)106 static uint64_t GetCurrentTime(void)
107 {
108 SoftBusSysTime now = { 0 };
109 if (SoftBusGetTime(&now) != SOFTBUS_OK) {
110 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetCurrentTime fail.");
111 return 0;
112 }
113 return (uint64_t)now.sec * TIME_THOUSANDS_FACTOR + (uint64_t)now.usec / TIME_THOUSANDS_FACTOR;
114 }
115
LnnSetAuthTypeValue(uint32_t * authTypeValue,AuthType type)116 NO_SANITIZE("cfi") int32_t LnnSetAuthTypeValue(uint32_t *authTypeValue, AuthType type)
117 {
118 if (authTypeValue == NULL || type >= AUTH_TYPE_BUTT) {
119 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "in para error!");
120 return SOFTBUS_INVALID_PARAM;
121 }
122 *authTypeValue = (*authTypeValue) | (1 << (uint32_t)type);
123 return SOFTBUS_OK;
124 }
125
LnnClearAuthTypeValue(uint32_t * authTypeValue,AuthType type)126 NO_SANITIZE("cfi") int32_t LnnClearAuthTypeValue(uint32_t *authTypeValue, AuthType type)
127 {
128 if (authTypeValue == NULL || type >= AUTH_TYPE_BUTT) {
129 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "in para error!");
130 return SOFTBUS_INVALID_PARAM;
131 }
132 *authTypeValue = (*authTypeValue) & (~(1 << (uint32_t)type));
133 return SOFTBUS_OK;
134 }
135
GetNodeInfoFromMap(const DoubleHashMap * map,const char * id)136 static NodeInfo *GetNodeInfoFromMap(const DoubleHashMap *map, const char *id)
137 {
138 if (map == NULL || id == NULL) {
139 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
140 return NULL;
141 }
142 NodeInfo *info = NULL;
143 if ((info = (NodeInfo *)LnnMapGet(&map->udidMap, id)) != NULL) {
144 return info;
145 }
146 if ((info = (NodeInfo *)LnnMapGet(&map->macMap, id)) != NULL) {
147 return info;
148 }
149 if ((info = (NodeInfo *)LnnMapGet(&map->ipMap, id)) != NULL) {
150 return info;
151 }
152 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "id not exist!");
153 return NULL;
154 }
155
InitDistributedInfo(DoubleHashMap * map)156 static int32_t InitDistributedInfo(DoubleHashMap *map)
157 {
158 if (map == NULL) {
159 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:para error!");
160 return SOFTBUS_INVALID_PARAM;
161 }
162 LnnMapInit(&map->udidMap);
163 LnnMapInit(&map->ipMap);
164 LnnMapInit(&map->macMap);
165 return SOFTBUS_OK;
166 }
167
DeinitDistributedInfo(DoubleHashMap * map)168 static void DeinitDistributedInfo(DoubleHashMap *map)
169 {
170 if (map == NULL) {
171 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail: para error!");
172 return;
173 }
174 LnnMapDelete(&map->udidMap);
175 LnnMapDelete(&map->ipMap);
176 LnnMapDelete(&map->macMap);
177 }
178
InitConnectionCode(ConnectionCode * cnnCode)179 static int32_t InitConnectionCode(ConnectionCode *cnnCode)
180 {
181 if (cnnCode == NULL) {
182 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail: para error!");
183 return SOFTBUS_INVALID_PARAM;
184 }
185 LnnMapInit(&cnnCode->connectionCode);
186 return SOFTBUS_OK;
187 }
188
DeinitConnectionCode(ConnectionCode * cnnCode)189 static void DeinitConnectionCode(ConnectionCode *cnnCode)
190 {
191 if (cnnCode == NULL) {
192 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail: para error!");
193 return;
194 }
195 LnnMapDelete(&cnnCode->connectionCode);
196 return;
197 }
198
LnnDeinitDistributedLedger(void)199 NO_SANITIZE("cfi") void LnnDeinitDistributedLedger(void)
200 {
201 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
202 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
203 return;
204 }
205 g_distributedNetLedger.status = DL_INIT_UNKNOWN;
206 DeinitDistributedInfo(&g_distributedNetLedger.distributedInfo);
207 DeinitConnectionCode(&g_distributedNetLedger.cnnCode);
208 if (SoftBusMutexUnlock(&g_distributedNetLedger.lock) != 0) {
209 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "unlock mutex fail!");
210 }
211 SoftBusMutexDestroy(&g_distributedNetLedger.lock);
212 }
213
NewWifiDiscovered(const NodeInfo * oldInfo,NodeInfo * newInfo)214 static void NewWifiDiscovered(const NodeInfo *oldInfo, NodeInfo *newInfo)
215 {
216 const char *macAddr = NULL;
217 if (oldInfo == NULL || newInfo == NULL) {
218 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
219 return;
220 }
221 newInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
222 macAddr = LnnGetBtMac(newInfo);
223 if (macAddr == NULL) {
224 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnGetBtMac Fail!");
225 return;
226 }
227 if (strcmp(macAddr, DEFAULT_MAC) == 0) {
228 LnnSetBtMac(newInfo, LnnGetBtMac(oldInfo));
229 }
230 }
231
NewBrBleDiscovered(const NodeInfo * oldInfo,NodeInfo * newInfo)232 static void NewBrBleDiscovered(const NodeInfo *oldInfo, NodeInfo *newInfo)
233 {
234 const char *ipAddr = NULL;
235 if (oldInfo == NULL || newInfo == NULL) {
236 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
237 return;
238 }
239 newInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
240 ipAddr = LnnGetWiFiIp(newInfo);
241 if (ipAddr == NULL) {
242 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnGetWiFiIp Fail!");
243 return;
244 }
245 if (strcmp(ipAddr, DEFAULT_IP) == 0) {
246 LnnSetWiFiIp(newInfo, LnnGetWiFiIp(oldInfo));
247 }
248
249 newInfo->connectInfo.authPort = oldInfo->connectInfo.authPort;
250 newInfo->connectInfo.proxyPort = oldInfo->connectInfo.proxyPort;
251 newInfo->connectInfo.sessionPort = oldInfo->connectInfo.sessionPort;
252 }
253
RetainOfflineCode(const NodeInfo * oldInfo,NodeInfo * newInfo)254 static void RetainOfflineCode(const NodeInfo *oldInfo, NodeInfo *newInfo)
255 {
256 if (oldInfo == NULL || newInfo == NULL) {
257 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
258 return;
259 }
260 if (memcpy_s(newInfo->offlineCode, OFFLINE_CODE_BYTE_SIZE,
261 oldInfo->offlineCode, OFFLINE_CODE_BYTE_SIZE) != SOFTBUS_OK) {
262 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy offlineCode error!");
263 return;
264 }
265 }
ConvertNodeInfoToBasicInfo(const NodeInfo * info,NodeBasicInfo * basic)266 static int32_t ConvertNodeInfoToBasicInfo(const NodeInfo *info, NodeBasicInfo *basic)
267 {
268 if (info == NULL || basic == NULL) {
269 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
270 return SOFTBUS_INVALID_PARAM;
271 }
272 if (strncpy_s(basic->deviceName, DEVICE_NAME_BUF_LEN, info->deviceInfo.deviceName,
273 strlen(info->deviceInfo.deviceName)) != EOK) {
274 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strncpy_s name error!");
275 return SOFTBUS_MEM_ERR;
276 }
277
278 if (strncpy_s(basic->networkId, NETWORK_ID_BUF_LEN, info->networkId, strlen(info->networkId)) != EOK) {
279 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strncpy_s networkID error!");
280 return SOFTBUS_MEM_ERR;
281 }
282 basic->deviceTypeId = info->deviceInfo.deviceTypeId;
283 return SOFTBUS_OK;
284 }
285
isMetaNode(NodeInfo * info)286 static bool isMetaNode(NodeInfo *info)
287 {
288 if (info == NULL) {
289 return false;
290 }
291 return info->metaInfo.isMetaNode;
292 }
293
GetDLOnlineNodeNumLocked(int32_t * infoNum,bool isNeedMeta)294 static int32_t GetDLOnlineNodeNumLocked(int32_t *infoNum, bool isNeedMeta)
295 {
296 NodeInfo *info = NULL;
297 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
298 MapIterator *it = LnnMapInitIterator(&map->udidMap);
299
300 if (it == NULL) {
301 return SOFTBUS_ERR;
302 }
303 *infoNum = 0;
304 while (LnnMapHasNext(it)) {
305 it = LnnMapNext(it);
306 if (it == NULL) {
307 return SOFTBUS_ERR;
308 }
309 info = (NodeInfo *)it->node->value;
310 if (!isNeedMeta) {
311 if (LnnIsNodeOnline(info)) {
312 (*infoNum)++;
313 }
314 } else {
315 if (LnnIsNodeOnline(info) || isMetaNode(info)) {
316 (*infoNum)++;
317 }
318 }
319 }
320 LnnMapDeinitIterator(it);
321 return SOFTBUS_OK;
322 }
323
FillDLOnlineNodeInfoLocked(NodeBasicInfo * info,int32_t infoNum,bool isNeedMeta)324 static int32_t FillDLOnlineNodeInfoLocked(NodeBasicInfo *info, int32_t infoNum, bool isNeedMeta)
325 {
326 NodeInfo *nodeInfo = NULL;
327 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
328 MapIterator *it = LnnMapInitIterator(&map->udidMap);
329 int32_t i = 0;
330
331 if (it == NULL) {
332 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "it is null");
333 return SOFTBUS_ERR;
334 }
335 while (LnnMapHasNext(it) && i < infoNum) {
336 it = LnnMapNext(it);
337 if (it == NULL) {
338 LnnMapDeinitIterator(it);
339 return SOFTBUS_ERR;
340 }
341 nodeInfo = (NodeInfo *)it->node->value;
342 if (!isNeedMeta) {
343 if (LnnIsNodeOnline(nodeInfo)) {
344 ConvertNodeInfoToBasicInfo(nodeInfo, info + i);
345 ++i;
346 }
347 } else {
348 if (LnnIsNodeOnline(nodeInfo) || isMetaNode(nodeInfo)) {
349 ConvertNodeInfoToBasicInfo(nodeInfo, info + i);
350 ++i;
351 }
352 }
353 }
354 LnnMapDeinitIterator(it);
355 return SOFTBUS_OK;
356 }
357
IsNetworkIdChanged(NodeInfo * newInfo,NodeInfo * oldInfo)358 static bool IsNetworkIdChanged(NodeInfo *newInfo, NodeInfo *oldInfo)
359 {
360 if (newInfo == NULL || oldInfo == NULL) {
361 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
362 return false;
363 }
364 if (strcmp(newInfo->networkId, oldInfo->networkId) == 0) {
365 return false;
366 }
367 return true;
368 }
369
PostOnlineNodesToCb(const INodeStateCb * callBack)370 void PostOnlineNodesToCb(const INodeStateCb *callBack)
371 {
372 NodeInfo *info = NULL;
373 NodeBasicInfo basic;
374 if (memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo)) != EOK) {
375 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memset_s basic fail!");
376 }
377 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
378 if (callBack->onNodeOnline == NULL) {
379 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "onNodeOnline IS null!");
380 return;
381 }
382 MapIterator *it = LnnMapInitIterator(&map->udidMap);
383 if (it == NULL) {
384 return;
385 }
386 while (LnnMapHasNext(it)) {
387 it = LnnMapNext(it);
388 if (it == NULL) {
389 return;
390 }
391 info = (NodeInfo *)it->node->value;
392 if (LnnIsNodeOnline(info)) {
393 ConvertNodeInfoToBasicInfo(info, &basic);
394 callBack->onNodeOnline(&basic);
395 }
396 }
397 LnnMapDeinitIterator(it);
398 }
399
LnnGetNodeInfoById(const char * id,IdCategory type)400 NO_SANITIZE("cfi") NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type)
401 {
402 NodeInfo *info = NULL;
403 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
404 if (id == NULL) {
405 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error");
406 return info;
407 }
408 if (type == CATEGORY_UDID) {
409 return GetNodeInfoFromMap(map, id);
410 }
411 MapIterator *it = LnnMapInitIterator(&map->udidMap);
412 LNN_CHECK_AND_RETURN_RET_LOG(it != NULL, NULL, "LnnMapInitIterator is null");
413
414 while (LnnMapHasNext(it)) {
415 it = LnnMapNext(it);
416 LNN_CHECK_AND_RETURN_RET_LOG(it != NULL, info, "it next is null");
417 info = (NodeInfo *)it->node->value;
418 if (info == NULL) {
419 continue;
420 }
421 if (type == CATEGORY_NETWORK_ID) {
422 if (strcmp(info->networkId, id) == 0) {
423 LnnMapDeinitIterator(it);
424 return info;
425 }
426 } else if (type == CATEGORY_UUID) {
427 if (strcmp(info->uuid, id) == 0) {
428 LnnMapDeinitIterator(it);
429 return info;
430 }
431 } else {
432 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "type error");
433 }
434 }
435 LLOGE("get node info by id failed");
436 LnnMapDeinitIterator(it);
437 return NULL;
438 }
439
LnnGetNodeInfoByDeviceId(const char * id)440 static NodeInfo *LnnGetNodeInfoByDeviceId(const char *id)
441 {
442 NodeInfo *info = NULL;
443 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
444 NodeInfo *udidInfo = GetNodeInfoFromMap(map, id);
445 if (udidInfo != NULL) {
446 return udidInfo;
447 }
448 MapIterator *it = LnnMapInitIterator(&map->udidMap);
449 if (it == NULL) {
450 return info;
451 }
452 while (LnnMapHasNext(it)) {
453 it = LnnMapNext(it);
454 if (it == NULL) {
455 return info;
456 }
457 info = (NodeInfo *)it->node->value;
458 if (info == NULL) {
459 continue;
460 }
461 if (strcmp(info->networkId, id) == 0) {
462 LnnMapDeinitIterator(it);
463 return info;
464 }
465 if (strcmp(info->uuid, id) == 0) {
466 LnnMapDeinitIterator(it);
467 return info;
468 }
469 if (strcmp(info->connectInfo.macAddr, id) == 0) {
470 LnnMapDeinitIterator(it);
471 return info;
472 }
473 if (strcmp(info->connectInfo.deviceIp, id) == 0) {
474 LnnMapDeinitIterator(it);
475 return info;
476 }
477 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "type error");
478 }
479 LnnMapDeinitIterator(it);
480 return NULL;
481 }
482
LnnGetRemoteNodeInfoById(const char * id,IdCategory type,NodeInfo * info)483 NO_SANITIZE("cfi") int32_t LnnGetRemoteNodeInfoById(const char *id, IdCategory type, NodeInfo *info)
484 {
485 if (id == NULL || info == NULL) {
486 LLOGE("param error");
487 return SOFTBUS_INVALID_PARAM;
488 }
489 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
490 LLOGE("lock mutex fail");
491 return SOFTBUS_LOCK_ERR;
492 }
493 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
494 if (nodeInfo == NULL) {
495 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
496 LLOGI("can not find target node");
497 return SOFTBUS_ERR;
498 }
499 if (memcpy_s(info, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
500 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
501 return SOFTBUS_MEM_ERR;
502 }
503 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
504 return SOFTBUS_OK;
505 }
506
507 /* key means networkId/udid/uuid/macAddr/ip */
LnnGetRemoteNodeInfoByKey(const char * key,NodeInfo * info)508 int32_t LnnGetRemoteNodeInfoByKey(const char *key, NodeInfo *info)
509 {
510 if (key == NULL || info == NULL) {
511 LLOGE("param error");
512 return SOFTBUS_INVALID_PARAM;
513 }
514 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
515 LLOGE("lock mutex fail");
516 return SOFTBUS_LOCK_ERR;
517 }
518 NodeInfo *nodeInfo = LnnGetNodeInfoByDeviceId(key);
519 if (nodeInfo == NULL) {
520 LLOGI("can not find target node");
521 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
522 return SOFTBUS_ERR;
523 }
524 if (memcpy_s(info, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
525 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
526 return SOFTBUS_MEM_ERR;
527 }
528 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
529 return SOFTBUS_OK;
530 }
531
LnnGetOnlineStateById(const char * id,IdCategory type)532 bool LnnGetOnlineStateById(const char *id, IdCategory type)
533 {
534 bool state = false;
535 if (!IsValidString(id, ID_MAX_LEN)) {
536 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "id is invalid");
537 return state;
538 }
539
540 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
541 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
542 return state;
543 }
544 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
545 if (nodeInfo == NULL) {
546 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
547 return state;
548 }
549 state = (nodeInfo->status == STATUS_ONLINE) ? true : false;
550 if (!state) {
551 state = nodeInfo->metaInfo.isMetaNode;
552 }
553 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
554 return state;
555 }
556
DlGetDeviceUuid(const char * networkId,void * buf,uint32_t len)557 static int32_t DlGetDeviceUuid(const char *networkId, void *buf, uint32_t len)
558 {
559 NodeInfo *info = NULL;
560 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
561 if (strncpy_s(buf, len, info->uuid, strlen(info->uuid)) != EOK) {
562 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
563 return SOFTBUS_MEM_ERR;
564 }
565 return SOFTBUS_OK;
566 }
567
DlGetDeviceOfflineCode(const char * networkId,void * buf,uint32_t len)568 static int32_t DlGetDeviceOfflineCode(const char *networkId, void *buf, uint32_t len)
569 {
570 NodeInfo *info = NULL;
571 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
572 if (memcpy_s(buf, len, info->offlineCode, OFFLINE_CODE_BYTE_SIZE) != EOK) {
573 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s offlinecode ERROR!");
574 return SOFTBUS_MEM_ERR;
575 }
576 return SOFTBUS_OK;
577 }
578
DlGetDeviceUdid(const char * networkId,void * buf,uint32_t len)579 static int32_t DlGetDeviceUdid(const char *networkId, void *buf, uint32_t len)
580 {
581 const char *udid = NULL;
582 NodeInfo *info = NULL;
583 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
584 udid = LnnGetDeviceUdid(info);
585 if (udid == NULL) {
586 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get device udid fail");
587 return SOFTBUS_ERR;
588 }
589 if (strncpy_s(buf, len, udid, strlen(udid)) != EOK) {
590 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
591 return SOFTBUS_MEM_ERR;
592 }
593 return SOFTBUS_OK;
594 }
595
DlGetNodeSoftBusVersion(const char * networkId,void * buf,uint32_t len)596 static int32_t DlGetNodeSoftBusVersion(const char *networkId, void *buf, uint32_t len)
597 {
598 NodeInfo *info = NULL;
599 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
600 if (strncpy_s(buf, len, info->softBusVersion, strlen(info->softBusVersion)) != EOK) {
601 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
602 return SOFTBUS_MEM_ERR;
603 }
604 return SOFTBUS_OK;
605 }
606
DlGetDeviceType(const char * networkId,void * buf,uint32_t len)607 static int32_t DlGetDeviceType(const char *networkId, void *buf, uint32_t len)
608 {
609 NodeInfo *info = NULL;
610 char *deviceType = NULL;
611 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
612 deviceType = LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId);
613 if (deviceType == NULL) {
614 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "deviceType fail.");
615 return SOFTBUS_ERR;
616 }
617 if (strncpy_s(buf, len, deviceType, strlen(deviceType)) != EOK) {
618 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "MEM COPY ERROR!");
619 return SOFTBUS_MEM_ERR;
620 }
621 return SOFTBUS_OK;
622 }
623
DlGetDeviceTypeId(const char * networkId,void * buf,uint32_t len)624 static int32_t DlGetDeviceTypeId(const char *networkId, void *buf, uint32_t len)
625 {
626 NodeInfo *info = NULL;
627 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
628 *((int32_t *)buf) = info->deviceInfo.deviceTypeId;
629 return SOFTBUS_OK;
630 }
631
DlGetAuthType(const char * networkId,void * buf,uint32_t len)632 static int32_t DlGetAuthType(const char *networkId, void *buf, uint32_t len)
633 {
634 NodeInfo *info = NULL;
635 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
636 *((uint32_t *)buf) = info->AuthTypeValue;
637 return SOFTBUS_OK;
638 }
639
DlGetDeviceName(const char * networkId,void * buf,uint32_t len)640 static int32_t DlGetDeviceName(const char *networkId, void *buf, uint32_t len)
641 {
642 NodeInfo *info = NULL;
643 const char *deviceName = NULL;
644 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
645 deviceName = LnnGetDeviceName(&info->deviceInfo);
646 if (deviceName == NULL) {
647 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get device name fail.");
648 return SOFTBUS_ERR;
649 }
650 if (strncpy_s(buf, len, deviceName, strlen(deviceName)) != EOK) {
651 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
652 return SOFTBUS_MEM_ERR;
653 }
654 return SOFTBUS_OK;
655 }
656
DlGetBtMac(const char * networkId,void * buf,uint32_t len)657 static int32_t DlGetBtMac(const char *networkId, void *buf, uint32_t len)
658 {
659 NodeInfo *info = NULL;
660 const char *mac = NULL;
661 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
662 mac = LnnGetBtMac(info);
663 if (mac == NULL) {
664 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get bt mac fail.");
665 return SOFTBUS_ERR;
666 }
667 if (strncpy_s(buf, len, mac, strlen(mac)) != EOK) {
668 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
669 return SOFTBUS_MEM_ERR;
670 }
671 return SOFTBUS_OK;
672 }
673
DlGetWlanIp(const char * networkId,void * buf,uint32_t len)674 static int32_t DlGetWlanIp(const char *networkId, void *buf, uint32_t len)
675 {
676 NodeInfo *info = NULL;
677 const char *ip = NULL;
678 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
679 ip = LnnGetWiFiIp(info);
680 if (ip == NULL) {
681 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get wifi ip fail.");
682 return SOFTBUS_ERR;
683 }
684 if (strncpy_s(buf, len, ip, strlen(ip)) != EOK) {
685 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
686 return SOFTBUS_MEM_ERR;
687 }
688 return SOFTBUS_OK;
689 }
690
DlGetMasterUdid(const char * networkId,void * buf,uint32_t len)691 static int32_t DlGetMasterUdid(const char *networkId, void *buf, uint32_t len)
692 {
693 NodeInfo *info = NULL;
694 const char *masterUdid = NULL;
695
696 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
697 if (!LnnIsNodeOnline(info)) {
698 return SOFTBUS_ERR;
699 }
700 masterUdid = LnnGetMasterUdid(info);
701 if (masterUdid == NULL) {
702 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get master uiid fail");
703 return SOFTBUS_ERR;
704 }
705 if (strncpy_s(buf, len, masterUdid, strlen(masterUdid)) != EOK) {
706 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy master udid to buf fail");
707 return SOFTBUS_MEM_ERR;
708 }
709 return SOFTBUS_OK;
710 }
711
DlGetNodeBleMac(const char * networkId,void * buf,uint32_t len)712 static int32_t DlGetNodeBleMac(const char *networkId, void *buf, uint32_t len)
713 {
714 NodeInfo *info = NULL;
715
716 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
717 uint64_t currentTimeMs = GetCurrentTime();
718 LNN_CHECK_AND_RETURN_RET_LOG(info->connectInfo.latestTime + BLE_ADV_LOST_TIME >= currentTimeMs, SOFTBUS_ERR,
719 "ble mac out date, lastAdvTime:%llu, now:%llu", info->connectInfo.latestTime, currentTimeMs);
720
721 if (memcpy_s(buf, len, info->connectInfo.bleMacAddr, MAC_LEN) != EOK) {
722 return SOFTBUS_MEM_ERR;
723 }
724 return SOFTBUS_OK;
725 }
726
LnnUpdateNodeBleMac(const char * networkId,char * bleMac,uint32_t len)727 void LnnUpdateNodeBleMac(const char *networkId, char *bleMac, uint32_t len)
728 {
729 if ((networkId == NULL) || (bleMac == NULL) || (len != MAC_LEN)) {
730 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid arg");
731 return;
732 }
733 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
734 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
735 return;
736 }
737 NodeInfo *info = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
738 if (info == NULL) {
739 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get node info fail.");
740 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
741 return;
742 }
743 if (memcpy_s(info->connectInfo.bleMacAddr, MAC_LEN, bleMac, len) != EOK) {
744 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy fail.");
745 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
746 return;
747 }
748 info->connectInfo.latestTime = GetCurrentTime();
749
750 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
751 }
752
DlGetAuthPort(const char * networkId,void * buf,uint32_t len)753 static int32_t DlGetAuthPort(const char *networkId, void *buf, uint32_t len)
754 {
755 NodeInfo *info = NULL;
756 if (len != LNN_COMMON_LEN) {
757 return SOFTBUS_INVALID_PARAM;
758 }
759 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
760 *((int32_t *)buf) = LnnGetAuthPort(info);
761 return SOFTBUS_OK;
762 }
763
DlGetSessionPort(const char * networkId,void * buf,uint32_t len)764 static int32_t DlGetSessionPort(const char *networkId, void *buf, uint32_t len)
765 {
766 NodeInfo *info = NULL;
767 if (len != LNN_COMMON_LEN) {
768 return SOFTBUS_INVALID_PARAM;
769 }
770 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
771 *((int32_t *)buf) = LnnGetSessionPort(info);
772 return SOFTBUS_OK;
773 }
774
DlGetProxyPort(const char * networkId,void * buf,uint32_t len)775 static int32_t DlGetProxyPort(const char *networkId, void *buf, uint32_t len)
776 {
777 NodeInfo *info = NULL;
778 if (len != LNN_COMMON_LEN) {
779 return SOFTBUS_INVALID_PARAM;
780 }
781 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
782 *((int32_t *)buf) = LnnGetProxyPort(info);
783 return SOFTBUS_OK;
784 }
785
DlGetNetCap(const char * networkId,void * buf,uint32_t len)786 static int32_t DlGetNetCap(const char *networkId, void *buf, uint32_t len)
787 {
788 NodeInfo *info = NULL;
789 if (len != LNN_COMMON_LEN) {
790 return SOFTBUS_INVALID_PARAM;
791 }
792 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
793 *((int32_t *)buf) = info->netCapacity;
794 return SOFTBUS_OK;
795 }
796
DlGetFeatureCap(const char * networkId,void * buf,uint32_t len)797 static int32_t DlGetFeatureCap(const char *networkId, void *buf, uint32_t len)
798 {
799 NodeInfo *info = NULL;
800 if (len != LNN_COMMON_LEN_64) {
801 return SOFTBUS_INVALID_PARAM;
802 }
803 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
804 *((uint64_t *)buf) = info->feature;
805 return SOFTBUS_OK;
806 }
807
DlGetNetType(const char * networkId,void * buf,uint32_t len)808 static int32_t DlGetNetType(const char *networkId, void *buf, uint32_t len)
809 {
810 NodeInfo *info = NULL;
811 if (len != LNN_COMMON_LEN) {
812 return SOFTBUS_INVALID_PARAM;
813 }
814 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
815 *((int32_t *)buf) = info->discoveryType;
816 return SOFTBUS_OK;
817 }
818
DlGetMasterWeight(const char * networkId,void * buf,uint32_t len)819 static int32_t DlGetMasterWeight(const char *networkId, void *buf, uint32_t len)
820 {
821 NodeInfo *info = NULL;
822
823 if (len != LNN_COMMON_LEN) {
824 return SOFTBUS_INVALID_PARAM;
825 }
826 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
827 *((int32_t *)buf) = info->masterWeight;
828 return SOFTBUS_OK;
829 }
830
DlGetP2pMac(const char * networkId,void * buf,uint32_t len)831 static int32_t DlGetP2pMac(const char *networkId, void *buf, uint32_t len)
832 {
833 NodeInfo *info = NULL;
834 const char *mac = NULL;
835
836 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
837 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
838 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
839 return SOFTBUS_ERR;
840 }
841 mac = LnnGetP2pMac(info);
842 if (mac == NULL) {
843 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get p2p mac fail");
844 return SOFTBUS_ERR;
845 }
846 if (strcpy_s(buf, len, mac) != EOK) {
847 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy p2p mac to buf fail");
848 return SOFTBUS_MEM_ERR;
849 }
850 return SOFTBUS_OK;
851 }
852
DlGetNodeAddr(const char * networkId,void * buf,uint32_t len)853 static int32_t DlGetNodeAddr(const char *networkId, void *buf, uint32_t len)
854 {
855 NodeInfo *info = NULL;
856 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
857 if (!LnnIsNodeOnline(info)) {
858 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
859 return SOFTBUS_ERR;
860 }
861
862 if (strcpy_s(buf, len, info->nodeAddress) != EOK) {
863 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy node addr to buf fail");
864 return SOFTBUS_MEM_ERR;
865 }
866 return SOFTBUS_OK;
867 }
868
DlGetP2pGoMac(const char * networkId,void * buf,uint32_t len)869 static int32_t DlGetP2pGoMac(const char *networkId, void *buf, uint32_t len)
870 {
871 NodeInfo *info = NULL;
872 const char *mac = NULL;
873
874 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
875 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
876 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
877 return SOFTBUS_ERR;
878 }
879 mac = LnnGetP2pGoMac(info);
880 if (mac == NULL) {
881 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get p2p go mac fail");
882 return SOFTBUS_ERR;
883 }
884 if (strcpy_s(buf, len, mac) != EOK) {
885 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy p2p go mac to buf fail");
886 return SOFTBUS_MEM_ERR;
887 }
888 return SOFTBUS_OK;
889 }
890
DlGetWifiCfg(const char * networkId,void * buf,uint32_t len)891 static int32_t DlGetWifiCfg(const char *networkId, void *buf, uint32_t len)
892 {
893 NodeInfo *info = NULL;
894 const char *wifiCfg = NULL;
895
896 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
897 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
898 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
899 return SOFTBUS_ERR;
900 }
901 wifiCfg = LnnGetWifiCfg(info);
902 if (wifiCfg == NULL) {
903 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get wifi cfg fail");
904 return SOFTBUS_ERR;
905 }
906 if (strcpy_s(buf, len, wifiCfg) != EOK) {
907 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy wifi cfg to buf fail");
908 return SOFTBUS_MEM_ERR;
909 }
910 return SOFTBUS_OK;
911 }
912
DlGetChanList5g(const char * networkId,void * buf,uint32_t len)913 static int32_t DlGetChanList5g(const char *networkId, void *buf, uint32_t len)
914 {
915 NodeInfo *info = NULL;
916 const char *chanList5g = NULL;
917
918 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
919 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
920 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
921 return SOFTBUS_ERR;
922 }
923 chanList5g = LnnGetChanList5g(info);
924 if (chanList5g == NULL) {
925 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get chan list 5g fail");
926 return SOFTBUS_ERR;
927 }
928 if (strcpy_s(buf, len, chanList5g) != EOK) {
929 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy chan list 5g to buf fail");
930 return SOFTBUS_MEM_ERR;
931 }
932 return SOFTBUS_OK;
933 }
934
DlGetP2pRole(const char * networkId,void * buf,uint32_t len)935 static int32_t DlGetP2pRole(const char *networkId, void *buf, uint32_t len)
936 {
937 NodeInfo *info = NULL;
938
939 if (len != LNN_COMMON_LEN) {
940 return SOFTBUS_INVALID_PARAM;
941 }
942 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
943 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
944 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
945 return SOFTBUS_ERR;
946 }
947 *((int32_t *)buf) = LnnGetP2pRole(info);
948 return SOFTBUS_OK;
949 }
950
DlGetStateVersion(const char * networkId,void * buf,uint32_t len)951 static int32_t DlGetStateVersion(const char *networkId, void *buf, uint32_t len)
952 {
953 NodeInfo *info = NULL;
954
955 if (len != LNN_COMMON_LEN) {
956 return SOFTBUS_INVALID_PARAM;
957 }
958 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
959 if (!LnnIsNodeOnline(info)) {
960 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
961 return SOFTBUS_ERR;
962 }
963 *((int32_t *)buf) = info->stateVersion;
964 return SOFTBUS_OK;
965 }
966
DlGetStaFrequency(const char * networkId,void * buf,uint32_t len)967 static int32_t DlGetStaFrequency(const char *networkId, void *buf, uint32_t len)
968 {
969 NodeInfo *info = NULL;
970
971 if (len != LNN_COMMON_LEN) {
972 return SOFTBUS_INVALID_PARAM;
973 }
974 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
975 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
976 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
977 return SOFTBUS_ERR;
978 }
979 *((int32_t *)buf) = LnnGetStaFrequency(info);
980 return SOFTBUS_OK;
981 }
982
DlGetNodeDataChangeFlag(const char * networkId,void * buf,uint32_t len)983 static int32_t DlGetNodeDataChangeFlag(const char *networkId, void *buf, uint32_t len)
984 {
985 NodeInfo *info = NULL;
986
987 if (len != DATA_CHANGE_FLAG_BUF_LEN) {
988 return SOFTBUS_INVALID_PARAM;
989 }
990 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
991 if (!LnnIsNodeOnline(info)) {
992 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node is offline");
993 return SOFTBUS_ERR;
994 }
995 *((int16_t *)buf) = LnnGetDataChangeFlag(info);
996 return SOFTBUS_OK;
997 }
998
DlGetNodeTlvNegoFlag(const char * networkId,void * buf,uint32_t len)999 static int32_t DlGetNodeTlvNegoFlag(const char *networkId, void *buf, uint32_t len)
1000 {
1001 NodeInfo *info = NULL;
1002 if (len != sizeof(bool)) {
1003 return SOFTBUS_INVALID_PARAM;
1004 }
1005 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
1006 if (!LnnIsNodeOnline(info)) {
1007 LLOGE("node is offline");
1008 return SOFTBUS_ERR;
1009 }
1010 *((bool *)buf) = IsFeatureSupport(info->feature, BIT_WIFI_DIRECT_TLV_NEGOTIATION);
1011 return SOFTBUS_OK;
1012 }
1013
DlGetAccountHash(const char * networkId,void * buf,uint32_t len)1014 static int32_t DlGetAccountHash(const char *networkId, void *buf, uint32_t len)
1015 {
1016 NodeInfo *info = NULL;
1017 if (len != SHA_256_HASH_LEN) {
1018 return SOFTBUS_INVALID_PARAM;
1019 }
1020 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
1021 if (!LnnIsNodeOnline(info)) {
1022 LLOGE("node is offline");
1023 return SOFTBUS_ERR;
1024 }
1025 if (memcpy_s(buf, len, info->accountHash, SHA_256_HASH_LEN) != EOK) {
1026 LLOGE("memcpy account hash fail");
1027 return SOFTBUS_MEM_ERR;
1028 }
1029 return SOFTBUS_OK;
1030 }
1031
1032 static DistributedLedgerKey g_dlKeyTable[] = {
1033 {STRING_KEY_HICE_VERSION, DlGetNodeSoftBusVersion},
1034 {STRING_KEY_DEV_UDID, DlGetDeviceUdid},
1035 {STRING_KEY_UUID, DlGetDeviceUuid},
1036 {STRING_KEY_DEV_TYPE, DlGetDeviceType},
1037 {STRING_KEY_DEV_NAME, DlGetDeviceName},
1038 {STRING_KEY_BT_MAC, DlGetBtMac},
1039 {STRING_KEY_WLAN_IP, DlGetWlanIp},
1040 {STRING_KEY_MASTER_NODE_UDID, DlGetMasterUdid},
1041 {STRING_KEY_P2P_MAC, DlGetP2pMac},
1042 {STRING_KEY_WIFI_CFG, DlGetWifiCfg},
1043 {STRING_KEY_CHAN_LIST_5G, DlGetChanList5g},
1044 {STRING_KEY_P2P_GO_MAC, DlGetP2pGoMac},
1045 {STRING_KEY_NODE_ADDR, DlGetNodeAddr},
1046 {STRING_KEY_OFFLINE_CODE, DlGetDeviceOfflineCode},
1047 {STRING_KEY_BLE_MAC, DlGetNodeBleMac},
1048 {NUM_KEY_META_NODE, DlGetAuthType},
1049 {NUM_KEY_SESSION_PORT, DlGetSessionPort},
1050 {NUM_KEY_AUTH_PORT, DlGetAuthPort},
1051 {NUM_KEY_PROXY_PORT, DlGetProxyPort},
1052 {NUM_KEY_NET_CAP, DlGetNetCap},
1053 {NUM_KEY_FEATURE_CAPA, DlGetFeatureCap},
1054 {NUM_KEY_DISCOVERY_TYPE, DlGetNetType},
1055 {NUM_KEY_MASTER_NODE_WEIGHT, DlGetMasterWeight},
1056 {NUM_KEY_STA_FREQUENCY, DlGetStaFrequency},
1057 {NUM_KEY_P2P_ROLE, DlGetP2pRole},
1058 {NUM_KEY_STATE_VERSION, DlGetStateVersion},
1059 {NUM_KEY_DATA_CHANGE_FLAG, DlGetNodeDataChangeFlag},
1060 {NUM_KEY_DEV_TYPE_ID, DlGetDeviceTypeId},
1061 {BOOL_KEY_TLV_NEGOTIATION, DlGetNodeTlvNegoFlag},
1062 {BYTE_KEY_ACCOUNT_HASH, DlGetAccountHash},
1063 };
1064
CreateCnnCodeKey(const char * uuid,DiscoveryType type)1065 static char *CreateCnnCodeKey(const char *uuid, DiscoveryType type)
1066 {
1067 if (uuid == NULL || strlen(uuid) >= UUID_BUF_LEN) {
1068 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
1069 return NULL;
1070 }
1071 char *key = (char *)SoftBusCalloc(INT_TO_STR_SIZE + UUID_BUF_LEN);
1072 if (key == NULL) {
1073 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "SoftBusCalloc fail!");
1074 return NULL;
1075 }
1076 if (sprintf_s(key, INT_TO_STR_SIZE + UUID_BUF_LEN, "%d%s", type, uuid) == -1) {
1077 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "type convert char error!");
1078 goto EXIT_FAIL;
1079 }
1080 return key;
1081 EXIT_FAIL:
1082 SoftBusFree(key);
1083 return NULL;
1084 }
1085
DestroyCnnCodeKey(char * key)1086 static void DestroyCnnCodeKey(char *key)
1087 {
1088 if (key == NULL) {
1089 return;
1090 }
1091 SoftBusFree(key);
1092 }
1093
1094
AddCnnCode(Map * cnnCode,const char * uuid,DiscoveryType type,int64_t authSeqNum)1095 static int32_t AddCnnCode(Map *cnnCode, const char *uuid, DiscoveryType type, int64_t authSeqNum)
1096 {
1097 short seq = (short)authSeqNum;
1098 char *key = CreateCnnCodeKey(uuid, type);
1099 if (key == NULL) {
1100 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "CreateCnnCodeKey error!");
1101 return SOFTBUS_ERR;
1102 }
1103 if (LnnMapSet(cnnCode, key, (void *)&seq, sizeof(short)) != SOFTBUS_OK) {
1104 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnMapSet error!");
1105 DestroyCnnCodeKey(key);
1106 return SOFTBUS_ERR;
1107 }
1108 DestroyCnnCodeKey(key);
1109 return SOFTBUS_OK;
1110 }
1111
RemoveCnnCode(Map * cnnCode,const char * uuid,DiscoveryType type)1112 static void RemoveCnnCode(Map *cnnCode, const char *uuid, DiscoveryType type)
1113 {
1114 char *key = CreateCnnCodeKey(uuid, type);
1115 if (key == NULL) {
1116 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "CreateCnnCodeKey error!");
1117 return;
1118 }
1119 if (LnnMapErase(cnnCode, key) != SOFTBUS_OK) {
1120 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnMapErase error!");
1121 }
1122 DestroyCnnCodeKey(key);
1123 return;
1124 }
1125
LnnGetCnnCode(const char * uuid,DiscoveryType type)1126 NO_SANITIZE("cfi") short LnnGetCnnCode(const char *uuid, DiscoveryType type)
1127 {
1128 char *key = CreateCnnCodeKey(uuid, type);
1129 if (key == NULL) {
1130 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "CreateCnnCodeKey error!");
1131 return INVALID_CONNECTION_CODE_VALUE;
1132 }
1133 short *ptr = (short *)LnnMapGet(&g_distributedNetLedger.cnnCode.connectionCode, key);
1134 if (ptr == NULL) {
1135 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, " KEY not exist.");
1136 DestroyCnnCodeKey(key);
1137 return INVALID_CONNECTION_CODE_VALUE;
1138 }
1139 DestroyCnnCodeKey(key);
1140 return (*ptr);
1141 }
1142
MergeLnnInfo(const NodeInfo * oldInfo,NodeInfo * info)1143 static void MergeLnnInfo(const NodeInfo *oldInfo, NodeInfo *info)
1144 {
1145 int32_t i;
1146
1147 for (i = 0; i < CONNECTION_ADDR_MAX; ++i) {
1148 info->relation[i] += oldInfo->relation[i];
1149 info->relation[i] &= LNN_RELATION_MASK;
1150 if (oldInfo->authChannelId[i] != 0) {
1151 info->authChannelId[i] = oldInfo->authChannelId[i];
1152 }
1153 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO,
1154 "Update authChannelId: %d, addrType=%d.", info->authChannelId[i], i);
1155 }
1156 }
1157
UpdateAuthSeq(const NodeInfo * oldInfo,NodeInfo * info)1158 static void UpdateAuthSeq(const NodeInfo *oldInfo, NodeInfo *info)
1159 {
1160 DiscoveryType type;
1161 for (type = DISCOVERY_TYPE_WIFI; type < DISCOVERY_TYPE_P2P; type++) {
1162 if (LnnHasDiscoveryType(info, type)) {
1163 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO,
1164 "UpdateAuthSeq: authSeq=%" PRId64 ", type=%d.", info->authSeq[type], type);
1165 continue;
1166 }
1167 info->authSeq[type] = oldInfo->authSeq[type];
1168 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO,
1169 "UpdateAuthSeq: authSeq=%" PRId64 ", type=%d.", info->authSeq[type], type);
1170 }
1171 }
1172
LnnUpdateNodeInfo(NodeInfo * newInfo)1173 NO_SANITIZE("cfi") int32_t LnnUpdateNodeInfo(NodeInfo *newInfo)
1174 {
1175 const char *udid = NULL;
1176 DoubleHashMap *map = NULL;
1177 NodeInfo *oldInfo = NULL;
1178
1179 udid = LnnGetDeviceUdid(newInfo);
1180 map = &g_distributedNetLedger.distributedInfo;
1181 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1182 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1183 return SOFTBUS_LOCK_ERR;
1184 }
1185 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1186 if (oldInfo == NULL) {
1187 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "no online node newInfo!");
1188 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1189 return SOFTBUS_ERR;
1190 }
1191 if (LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_WIFI) ||
1192 LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_LSA)) {
1193 oldInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
1194 oldInfo->connectInfo.authPort = newInfo->connectInfo.authPort;
1195 oldInfo->connectInfo.proxyPort = newInfo->connectInfo.proxyPort;
1196 oldInfo->connectInfo.sessionPort = newInfo->connectInfo.sessionPort;
1197 }
1198 if (strcpy_s(oldInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.deviceName) != 0) {
1199 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s fail");
1200 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1201 return SOFTBUS_ERR;
1202 }
1203 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1204 return SOFTBUS_OK;
1205 }
1206
LnnAddMetaInfo(NodeInfo * info)1207 NO_SANITIZE("cfi") int32_t LnnAddMetaInfo(NodeInfo *info)
1208 {
1209 const char *udid = NULL;
1210 DoubleHashMap *map = NULL;
1211 NodeInfo *oldInfo = NULL;
1212 udid = LnnGetDeviceUdid(info);
1213 map = &g_distributedNetLedger.distributedInfo;
1214 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1215 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnAddMetaInfo lock mutex fail!");
1216 return SOFTBUS_LOCK_ERR;
1217 }
1218 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1219 if (oldInfo != NULL && strcmp(oldInfo->networkId, info->networkId) == 0) {
1220 MetaInfo temp = info->metaInfo;
1221 if (memcpy_s(info, sizeof(NodeInfo), oldInfo, sizeof(NodeInfo)) != EOK) {
1222 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnAddMetaInfo copy fail!");
1223 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1224 return SOFTBUS_MEM_ERR;
1225 }
1226 info->metaInfo.isMetaNode = true;
1227 info->metaInfo.metaDiscType = info->metaInfo.metaDiscType | temp.metaDiscType;
1228 }
1229 LnnSetAuthTypeValue(&info->AuthTypeValue, ONLINE_METANODE);
1230 int32_t ret = LnnMapSet(&map->udidMap, udid, info, sizeof(NodeInfo));
1231 if (ret != SOFTBUS_OK) {
1232 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lnn map set failed, ret=%d", ret);
1233 }
1234 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "LnnAddMetaInfo success");
1235 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1236 return SOFTBUS_OK;
1237 }
1238
LnnDeleteMetaInfo(const char * udid,ConnectionAddrType type)1239 NO_SANITIZE("cfi") int32_t LnnDeleteMetaInfo(const char *udid, ConnectionAddrType type)
1240 {
1241 NodeInfo *info = NULL;
1242 DiscoveryType discType = LnnConvAddrTypeToDiscType(type);
1243 if (discType == DISCOVERY_TYPE_COUNT) {
1244 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "DeleteMetaInfo type error fail!");
1245 return SOFTBUS_ERR;
1246 }
1247 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1248 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1249 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "DeleteAddMetaInfo lock mutex fail!");
1250 return SOFTBUS_LOCK_ERR;
1251 }
1252 info = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1253 if (info == NULL) {
1254 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "DeleteAddMetaInfo para error!");
1255 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1256 return SOFTBUS_ERR;
1257 }
1258 info->metaInfo.metaDiscType = (uint32_t)info->metaInfo.metaDiscType & ~(1 << (uint32_t)discType);
1259 if (info->metaInfo.metaDiscType == 0) {
1260 info->metaInfo.isMetaNode = false;
1261 }
1262 LnnClearAuthTypeValue(&info->AuthTypeValue, ONLINE_METANODE);
1263 int32_t ret = LnnMapSet(&map->udidMap, udid, info, sizeof(NodeInfo));
1264 if (ret != SOFTBUS_OK) {
1265 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lnn map set failed, ret=%d", ret);
1266 }
1267 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "LnnDeleteMetaInfo success");
1268 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1269 return SOFTBUS_OK;
1270 }
1271
UpdateNewNodeAccountHash(NodeInfo * info)1272 static void UpdateNewNodeAccountHash(NodeInfo *info)
1273 {
1274 char accountString[LONG_TO_STRING_MAX_LEN] = {0};
1275 if (sprintf_s(accountString, LONG_TO_STRING_MAX_LEN, "%" PRId64, info->accountId) == -1) {
1276 LLOGE("long to string fail");
1277 return;
1278 }
1279 LLOGD("account string:%s", accountString);
1280 int ret = SoftBusGenerateStrHash((uint8_t *)accountString,
1281 strlen(accountString), (unsigned char *)info->accountHash);
1282 if (ret != SOFTBUS_OK) {
1283 LLOGE("account hash fail,ret:%d", ret);
1284 return;
1285 }
1286 }
1287
OnlinePreventBrConnection(const NodeInfo * info)1288 static void OnlinePreventBrConnection(const NodeInfo *info)
1289 {
1290 const NodeInfo *localNodeInfo = LnnGetLocalNodeInfo();
1291 if (localNodeInfo == NULL) {
1292 LLOGE("get local node info fail");
1293 return;
1294 }
1295 ConnectOption option = {0};
1296 option.type = CONNECT_BR;
1297 if (strcpy_s(option.brOption.brMac, BT_MAC_LEN, info->connectInfo.macAddr) != EOK) {
1298 LLOGE("copy br mac fail");
1299 return;
1300 }
1301
1302 bool preventFlag = false;
1303 do {
1304 LLOGI("check the ble start timestamp, local:%"PRId64", peer:%"PRId64"",
1305 localNodeInfo->bleStartTimestamp, info->bleStartTimestamp);
1306 if (localNodeInfo->bleStartTimestamp < info->bleStartTimestamp) {
1307 LLOGI("peer later, prevent br connection");
1308 preventFlag = true;
1309 break;
1310 }
1311 if (localNodeInfo->bleStartTimestamp > info->bleStartTimestamp) {
1312 LLOGI("local later, do not prevent br connection");
1313 break;
1314 }
1315 if (strcmp(info->softBusVersion, SOFTBUS_VERSION_FOR_INITCONNECTFLAG) < 0) {
1316 LLOGI("peer is old version, peerVersion:%s", info->softBusVersion);
1317 preventFlag = true;
1318 break;
1319 }
1320 if (strcmp(info->networkId, localNodeInfo->networkId) <= 0) {
1321 LLOGI("peer network id is smaller");
1322 preventFlag = true;
1323 break;
1324 }
1325 } while (false);
1326 if (preventFlag) {
1327 LLOGI("prevent br connection for a while");
1328 ConnPreventConnection(&option, CONNECTION_FREEZE_TIMEOUT_MILLIS);
1329 }
1330 }
1331
NotifyMigrateUpgrade(NodeInfo * info)1332 static void NotifyMigrateUpgrade(NodeInfo *info)
1333 {
1334 NodeBasicInfo basic;
1335 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1336 if (LnnGetBasicInfoByUdid(info->deviceInfo.deviceUdid, &basic) == SOFTBUS_OK) {
1337 LnnNotifyMigrate(true, &basic);
1338 } else {
1339 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "NotifyMigrateUpgrade,GetBasicInfoByUdid fail!");
1340 }
1341 }
1342
FilterWifiInfo(NodeInfo * info)1343 static void FilterWifiInfo(NodeInfo *info)
1344 {
1345 (void)LnnClearDiscoveryType(info, DISCOVERY_TYPE_WIFI);
1346 info->authChannelId[CONNECTION_ADDR_WLAN] = 0;
1347 }
1348
FilterBrInfo(NodeInfo * info)1349 static void FilterBrInfo(NodeInfo *info)
1350 {
1351 (void)LnnClearDiscoveryType(info, DISCOVERY_TYPE_BR);
1352 info->authChannelId[CONNECTION_ADDR_BR] = 0;
1353 }
1354
BleDirectlyOnlineProc(NodeInfo * info)1355 static void BleDirectlyOnlineProc(NodeInfo *info)
1356 {
1357 if (!LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)) {
1358 return;
1359 }
1360 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI)) {
1361 FilterWifiInfo(info);
1362 }
1363 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
1364 FilterBrInfo(info);
1365 }
1366 if (LnnSaveRemoteDeviceInfo(info) != SOFTBUS_OK) {
1367 LLOGE("save remote devInfo fail");
1368 return;
1369 }
1370 }
1371
NodeOnlineProc(NodeInfo * info)1372 static void NodeOnlineProc(NodeInfo *info)
1373 {
1374 NodeInfo nodeInfo;
1375 if (memcpy_s(&nodeInfo, sizeof(nodeInfo), info, sizeof(NodeInfo)) != EOK) {
1376 return;
1377 }
1378 BleDirectlyOnlineProc(&nodeInfo);
1379 }
1380
LnnAddOnlineNode(NodeInfo * info)1381 NO_SANITIZE("cfi") ReportCategory LnnAddOnlineNode(NodeInfo *info)
1382 {
1383 // judge map
1384 info->onlinetTimestamp = LnnUpTimeMs();
1385 if (info == NULL) {
1386 return REPORT_NONE;
1387 }
1388 const char *udid = NULL;
1389 DoubleHashMap *map = NULL;
1390 NodeInfo *oldInfo = NULL;
1391 bool isOffline = true;
1392 bool oldWifiFlag = false;
1393 bool oldBrFlag = false;
1394 bool oldBleFlag = false;
1395 bool isChanged = false;
1396 bool isMigrateEvent = false;
1397 bool isNetworkChanged = false;
1398 bool newWifiFlag = LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI);
1399 bool newBleBrFlag = LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)
1400 || LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR);
1401 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
1402 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "DiscoveryType = BR.");
1403 AddCnnCode(&g_distributedNetLedger.cnnCode.connectionCode, info->uuid, DISCOVERY_TYPE_BR,
1404 info->authSeqNum);
1405 }
1406
1407 udid = LnnGetDeviceUdid(info);
1408 map = &g_distributedNetLedger.distributedInfo;
1409 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1410 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1411 return REPORT_NONE;
1412 }
1413 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1414 if (oldInfo != NULL) {
1415 info->metaInfo = oldInfo->metaInfo;
1416 oldInfo->groupType = info->groupType;
1417 }
1418 if (oldInfo != NULL && LnnIsNodeOnline(oldInfo)) {
1419 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "addOnlineNode find online node");
1420 UpdateAuthSeq(oldInfo, info);
1421 isOffline = false;
1422 isChanged = IsNetworkIdChanged(info, oldInfo);
1423 oldWifiFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_WIFI);
1424 oldBleFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_BLE);
1425 oldBrFlag = LnnHasDiscoveryType(oldInfo, DISCOVERY_TYPE_BR);
1426 if ((oldBleFlag || oldBrFlag) && newWifiFlag) {
1427 NewWifiDiscovered(oldInfo, info);
1428 isNetworkChanged = true;
1429 } else if (oldWifiFlag && newBleBrFlag) {
1430 RetainOfflineCode(oldInfo, info);
1431 NewBrBleDiscovered(oldInfo, info);
1432 isNetworkChanged = true;
1433 } else {
1434 RetainOfflineCode(oldInfo, info);
1435 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "flag error");
1436 }
1437 if ((oldBleFlag || oldBrFlag) && !oldWifiFlag && newWifiFlag) {
1438 isMigrateEvent = true;
1439 }
1440 // update lnn discovery type
1441 info->discoveryType |= oldInfo->discoveryType;
1442 info->heartbeatTimeStamp = oldInfo->heartbeatTimeStamp;
1443 MergeLnnInfo(oldInfo, info);
1444 UpdateProfile(info);
1445 }
1446 LnnSetNodeConnStatus(info, STATUS_ONLINE);
1447 LnnSetAuthTypeValue(&info->AuthTypeValue, ONLINE_HICHAIN);
1448 UpdateNewNodeAccountHash(info);
1449 int32_t ret = LnnMapSet(&map->udidMap, udid, info, sizeof(NodeInfo));
1450 if (ret != SOFTBUS_OK) {
1451 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lnn map set failed, ret=%d", ret);
1452 }
1453 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1454 NodeOnlineProc(info);
1455 if (isNetworkChanged) {
1456 UpdateNetworkInfo(info->deviceInfo.deviceUdid);
1457 }
1458 if (isOffline) {
1459 if (!oldWifiFlag && !newWifiFlag && newBleBrFlag) {
1460 OnlinePreventBrConnection(info);
1461 }
1462 InsertToProfile(info);
1463 return REPORT_ONLINE;
1464 }
1465 if (isMigrateEvent) {
1466 NotifyMigrateUpgrade(info);
1467 }
1468 if (isChanged) {
1469 return REPORT_CHANGE;
1470 }
1471 return REPORT_NONE;
1472 }
1473
LnnUpdateAccountInfo(const NodeInfo * info)1474 NO_SANITIZE("cfi") int32_t LnnUpdateAccountInfo(const NodeInfo *info)
1475 {
1476 if (info == NULL) {
1477 LLOGE("info is null");
1478 }
1479 const char *udid = NULL;
1480 DoubleHashMap *map = NULL;
1481 NodeInfo *oldInfo = NULL;
1482 udid = LnnGetDeviceUdid(info);
1483 map = &g_distributedNetLedger.distributedInfo;
1484 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1485 LLOGE("lock mutex fail!");
1486 return REPORT_NONE;
1487 }
1488 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1489 if (oldInfo != NULL) {
1490 oldInfo->accountId = info->accountId;
1491 UpdateNewNodeAccountHash(oldInfo);
1492 }
1493 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1494 return SOFTBUS_OK;
1495 }
1496
LnnUpdateGroupType(const NodeInfo * info)1497 NO_SANITIZE("cfi") int32_t LnnUpdateGroupType(const NodeInfo *info)
1498 {
1499 if (info == NULL) {
1500 LLOGE("info is null");
1501 return SOFTBUS_ERR;
1502 }
1503 const char *udid = NULL;
1504 DoubleHashMap *map = NULL;
1505 NodeInfo *oldInfo = NULL;
1506 udid = LnnGetDeviceUdid(info);
1507 int32_t groupType = AuthGetGroupType(udid, info->uuid);
1508 LLOGI("groupType = %d", groupType);
1509 int32_t ret = SOFTBUS_ERR;
1510 map = &g_distributedNetLedger.distributedInfo;
1511 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1512 LLOGE("lock mutex fail!");
1513 return REPORT_NONE;
1514 }
1515 oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1516 if (oldInfo != NULL) {
1517 oldInfo->groupType = groupType;
1518 ret = SOFTBUS_OK;
1519 }
1520 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1521 return ret;
1522 }
1523
NotifyMigrateDegrade(const char * udid)1524 static void NotifyMigrateDegrade(const char *udid)
1525 {
1526 NodeBasicInfo basic;
1527 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1528 if (LnnGetBasicInfoByUdid(udid, &basic) == SOFTBUS_OK) {
1529 LnnNotifyMigrate(false, &basic);
1530 } else {
1531 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "NotifyMigrateDegrade,GetBasicInfoByUdid fail!");
1532 }
1533 }
1534
LnnSetNodeOffline(const char * udid,ConnectionAddrType type,int32_t authId)1535 NO_SANITIZE("cfi") ReportCategory LnnSetNodeOffline(const char *udid, ConnectionAddrType type, int32_t authId)
1536 {
1537 NodeInfo *info = NULL;
1538
1539 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1540 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1541 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1542 return REPORT_NONE;
1543 }
1544 info = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1545 if (info == NULL) {
1546 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
1547 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1548 return REPORT_NONE;
1549 }
1550 if (type != CONNECTION_ADDR_MAX && info->relation[type] > 0) {
1551 info->relation[type]--;
1552 }
1553 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR) && LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_BR) {
1554 RemoveCnnCode(&g_distributedNetLedger.cnnCode.connectionCode, info->uuid, DISCOVERY_TYPE_BR);
1555 }
1556 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI) && LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_WIFI &&
1557 info->authChannelId[type] != authId) {
1558 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "authChannelId != authId, not need to report offline.");
1559 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1560 return REPORT_NONE;
1561 }
1562 info->authChannelId[type] = 0;
1563 if (LnnConvAddrTypeToDiscType(type) == DISCOVERY_TYPE_WIFI) {
1564 LnnSetWiFiIp(info, LOCAL_IP);
1565 }
1566 LnnClearDiscoveryType(info, LnnConvAddrTypeToDiscType(type));
1567 if (info->discoveryType != 0) {
1568 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "discoveryType=%u after clear, not need to report offline.",
1569 info->discoveryType);
1570 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1571 UpdateNetworkInfo(udid);
1572 if (type == CONNECTION_ADDR_WLAN) {
1573 NotifyMigrateDegrade(udid);
1574 }
1575 return REPORT_NONE;
1576 }
1577 if (!LnnIsNodeOnline(info)) {
1578 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1579 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "the state is already offline, no need to report offline.");
1580 return REPORT_NONE;
1581 }
1582 LnnSetNodeConnStatus(info, STATUS_OFFLINE);
1583 LnnClearAuthTypeValue(&info->AuthTypeValue, ONLINE_HICHAIN);
1584 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1585 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "need to report offline.");
1586 return REPORT_OFFLINE;
1587 }
1588
LnnGetBasicInfoByUdid(const char * udid,NodeBasicInfo * basicInfo)1589 NO_SANITIZE("cfi") int32_t LnnGetBasicInfoByUdid(const char *udid, NodeBasicInfo *basicInfo)
1590 {
1591 if (udid == NULL || basicInfo == NULL) {
1592 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
1593 return SOFTBUS_INVALID_PARAM;
1594 }
1595 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1596 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1597 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1598 return SOFTBUS_LOCK_ERR;
1599 }
1600 NodeInfo *info = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
1601 int32_t ret = ConvertNodeInfoToBasicInfo(info, basicInfo);
1602 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1603 return ret;
1604 }
1605
LnnRemoveNode(const char * udid)1606 NO_SANITIZE("cfi") void LnnRemoveNode(const char *udid)
1607 {
1608 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1609 if (udid == NULL) {
1610 return;
1611 }
1612 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1613 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1614 return;
1615 }
1616 LnnMapErase(&map->udidMap, udid);
1617 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1618 }
1619
LnnConvertDLidToUdid(const char * id,IdCategory type)1620 NO_SANITIZE("cfi") const char *LnnConvertDLidToUdid(const char *id, IdCategory type)
1621 {
1622 NodeInfo *info = NULL;
1623 if (id == NULL) {
1624 return NULL;
1625 }
1626 info = LnnGetNodeInfoById(id, type);
1627 if (info == NULL) {
1628 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "uuid not find node info.");
1629 return NULL;
1630 }
1631 return LnnGetDeviceUdid(info);
1632 }
1633
LnnConvertDlId(const char * srcId,IdCategory srcIdType,IdCategory dstIdType,char * dstIdBuf,uint32_t dstIdBufLen)1634 NO_SANITIZE("cfi") int32_t LnnConvertDlId(const char *srcId, IdCategory srcIdType, IdCategory dstIdType,
1635 char *dstIdBuf, uint32_t dstIdBufLen)
1636 {
1637 NodeInfo *info = NULL;
1638 const char *id = NULL;
1639 int32_t rc = SOFTBUS_OK;
1640
1641 if (srcId == NULL || dstIdBuf == NULL) {
1642 return SOFTBUS_INVALID_PARAM;
1643 }
1644 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1645 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail");
1646 return SOFTBUS_LOCK_ERR;
1647 }
1648 info = LnnGetNodeInfoById(srcId, srcIdType);
1649 if (info == NULL) {
1650 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "no node info for: %d", srcIdType);
1651 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1652 return SOFTBUS_NOT_FIND;
1653 }
1654 switch (dstIdType) {
1655 case CATEGORY_UDID:
1656 id = info->deviceInfo.deviceUdid;
1657 break;
1658 case CATEGORY_UUID:
1659 id = info->uuid;
1660 break;
1661 case CATEGORY_NETWORK_ID:
1662 id = info->networkId;
1663 break;
1664 default:
1665 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1666 return SOFTBUS_INVALID_PARAM;
1667 }
1668 if (strcpy_s(dstIdBuf, dstIdBufLen, id) != EOK) {
1669 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy id fail");
1670 rc = SOFTBUS_MEM_ERR;
1671 }
1672 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1673 return rc;
1674 }
1675
LnnGetLnnRelation(const char * id,IdCategory type,uint8_t * relation,uint32_t len)1676 NO_SANITIZE("cfi") int32_t LnnGetLnnRelation(const char *id, IdCategory type, uint8_t *relation, uint32_t len)
1677 {
1678 NodeInfo *info = NULL;
1679
1680 if (id == NULL || relation == NULL) {
1681 return SOFTBUS_INVALID_PARAM;
1682 }
1683 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1684 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail");
1685 return SOFTBUS_LOCK_ERR;
1686 }
1687 info = LnnGetNodeInfoById(id, type);
1688 if (info == NULL || !LnnIsNodeOnline(info)) {
1689 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "node not online");
1690 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1691 return SOFTBUS_NOT_FIND;
1692 }
1693 if (memcpy_s(relation, len, info->relation, CONNECTION_ADDR_MAX) != EOK) {
1694 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy relation fail");
1695 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1696 return SOFTBUS_MEM_ERR;
1697 }
1698 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1699 return SOFTBUS_OK;
1700 }
1701
LnnSetDLDeviceInfoName(const char * udid,const char * name)1702 NO_SANITIZE("cfi") bool LnnSetDLDeviceInfoName(const char *udid, const char *name)
1703 {
1704 DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
1705 NodeInfo *info = NULL;
1706 if (udid == NULL || name == NULL) {
1707 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
1708 return false;
1709 }
1710 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1711 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1712 return false;
1713 }
1714 info = GetNodeInfoFromMap(map, udid);
1715 if (info == NULL) {
1716 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "udid not exist !");
1717 goto EXIT;
1718 }
1719 if (strcmp(LnnGetDeviceName(&info->deviceInfo), name) == 0) {
1720 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "devicename not change!");
1721 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1722 return true;
1723 }
1724 if (LnnSetDeviceName(&info->deviceInfo, name) != SOFTBUS_OK) {
1725 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set device name error!");
1726 goto EXIT;
1727 }
1728 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1729 return true;
1730 EXIT:
1731 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1732 return false;
1733 }
1734
LnnSetDLP2pInfo(const char * networkId,const P2pInfo * info)1735 NO_SANITIZE("cfi") bool LnnSetDLP2pInfo(const char *networkId, const P2pInfo *info)
1736 {
1737 NodeInfo *node = NULL;
1738 if (networkId == NULL || info == NULL) {
1739 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
1740 return false;
1741 }
1742 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1743 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail.");
1744 return false;
1745 }
1746 node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1747 if (node == NULL) {
1748 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "udid not found.");
1749 goto EXIT;
1750 }
1751 if (LnnSetP2pRole(node, info->p2pRole) != SOFTBUS_OK ||
1752 LnnSetP2pMac(node, info->p2pMac) != SOFTBUS_OK ||
1753 LnnSetP2pGoMac(node, info->goMac) != SOFTBUS_OK) {
1754 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set p2p info fail.");
1755 goto EXIT;
1756 }
1757 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1758 return true;
1759 EXIT:
1760 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1761 return false;
1762 }
1763
LnnGetRemoteStrInfo(const char * networkId,InfoKey key,char * info,uint32_t len)1764 NO_SANITIZE("cfi") int32_t LnnGetRemoteStrInfo(const char *networkId, InfoKey key, char *info, uint32_t len)
1765 {
1766 uint32_t i;
1767 int32_t ret;
1768 if (!IsValidString(networkId, ID_MAX_LEN)) {
1769 return SOFTBUS_INVALID_PARAM;
1770 }
1771 if (info == NULL) {
1772 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "info is null");
1773 return SOFTBUS_INVALID_PARAM;
1774 }
1775 if (key >= STRING_KEY_END) {
1776 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1777 return SOFTBUS_INVALID_PARAM;
1778 }
1779 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1780 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1781 return SOFTBUS_LOCK_ERR;
1782 }
1783 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1784 if (key == g_dlKeyTable[i].key) {
1785 if (g_dlKeyTable[i].getInfo != NULL) {
1786 ret = g_dlKeyTable[i].getInfo(networkId, (void *)info, len);
1787 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1788 return ret;
1789 }
1790 }
1791 }
1792 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1793 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY NOT exist.");
1794 return SOFTBUS_ERR;
1795 }
1796
LnnGetRemoteNumInfo(const char * networkId,InfoKey key,int32_t * info)1797 NO_SANITIZE("cfi") int32_t LnnGetRemoteNumInfo(const char *networkId, InfoKey key, int32_t *info)
1798 {
1799 uint32_t i;
1800 int32_t ret;
1801 if (!IsValidString(networkId, ID_MAX_LEN)) {
1802 return SOFTBUS_INVALID_PARAM;
1803 }
1804 if (info == NULL) {
1805 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "info is null");
1806 return SOFTBUS_INVALID_PARAM;
1807 }
1808 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1809 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1810 return SOFTBUS_INVALID_PARAM;
1811 }
1812 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1813 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1814 return SOFTBUS_LOCK_ERR;
1815 }
1816 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1817 if (key == g_dlKeyTable[i].key) {
1818 if (g_dlKeyTable[i].getInfo != NULL) {
1819 ret = g_dlKeyTable[i].getInfo(networkId, (void *)info, LNN_COMMON_LEN);
1820 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1821 return ret;
1822 }
1823 }
1824 }
1825 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1826 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY NOT exist.");
1827 return SOFTBUS_ERR;
1828 }
1829
LnnGetRemoteNumU64Info(const char * networkId,InfoKey key,uint64_t * info)1830 NO_SANITIZE("cfi") int32_t LnnGetRemoteNumU64Info(const char *networkId, InfoKey key, uint64_t *info)
1831 {
1832 uint32_t i;
1833 int32_t ret;
1834 if (!IsValidString(networkId, ID_MAX_LEN)) {
1835 return SOFTBUS_INVALID_PARAM;
1836 }
1837 if (info == NULL) {
1838 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "info is null");
1839 return SOFTBUS_INVALID_PARAM;
1840 }
1841 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1842 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1843 return SOFTBUS_INVALID_PARAM;
1844 }
1845 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1846 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1847 return SOFTBUS_LOCK_ERR;
1848 }
1849 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1850 if (key == g_dlKeyTable[i].key) {
1851 if (g_dlKeyTable[i].getInfo != NULL) {
1852 ret = g_dlKeyTable[i].getInfo(networkId, (void *)info, LNN_COMMON_LEN_64);
1853 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1854 return ret;
1855 }
1856 }
1857 }
1858 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1859 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY NOT exist.");
1860 return SOFTBUS_ERR;
1861 }
1862
LnnGetRemoteNum16Info(const char * networkId,InfoKey key,int16_t * info)1863 NO_SANITIZE("cfi") int32_t LnnGetRemoteNum16Info(const char *networkId, InfoKey key, int16_t *info)
1864 {
1865 uint32_t i;
1866 int32_t ret;
1867 if (!IsValidString(networkId, ID_MAX_LEN)) {
1868 return SOFTBUS_INVALID_PARAM;
1869 }
1870 if (info == NULL) {
1871 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "info is null");
1872 return SOFTBUS_INVALID_PARAM;
1873 }
1874 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1875 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1876 return SOFTBUS_INVALID_PARAM;
1877 }
1878 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1879 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1880 return SOFTBUS_LOCK_ERR;
1881 }
1882 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1883 if (key == g_dlKeyTable[i].key) {
1884 if (g_dlKeyTable[i].getInfo != NULL) {
1885 ret = g_dlKeyTable[i].getInfo(networkId, (void *)info, sizeof(int16_t));
1886 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1887 return ret;
1888 }
1889 }
1890 }
1891 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1892 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY NOT exist.");
1893 return SOFTBUS_ERR;
1894 }
1895
LnnGetRemoteBoolInfo(const char * networkId,InfoKey key,bool * info)1896 NO_SANITIZE("cfi") int32_t LnnGetRemoteBoolInfo(const char *networkId, InfoKey key, bool *info)
1897 {
1898 uint32_t i;
1899 int32_t ret;
1900 if (!IsValidString(networkId, ID_MAX_LEN)) {
1901 return SOFTBUS_INVALID_PARAM;
1902 }
1903 if (info == NULL) {
1904 LLOGE("info is null");
1905 return SOFTBUS_INVALID_PARAM;
1906 }
1907 if (key < BOOL_KEY_BEGIN || key >= BOOL_KEY_END) {
1908 LLOGE("KEY error.");
1909 return SOFTBUS_INVALID_PARAM;
1910 }
1911 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1912 LLOGE("lock mutex fail!");
1913 return SOFTBUS_LOCK_ERR;
1914 }
1915 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1916 if (key == g_dlKeyTable[i].key) {
1917 if (g_dlKeyTable[i].getInfo != NULL) {
1918 ret = g_dlKeyTable[i].getInfo(networkId, (void *)info, sizeof(bool));
1919 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1920 return ret;
1921 }
1922 }
1923 }
1924 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1925 LLOGE("KEY NOT exist.");
1926 return SOFTBUS_ERR;
1927 }
1928
LnnGetRemoteByteInfo(const char * networkId,InfoKey key,uint8_t * info,uint32_t len)1929 NO_SANITIZE("cfi") int32_t LnnGetRemoteByteInfo(const char *networkId, InfoKey key, uint8_t *info, uint32_t len)
1930 {
1931 uint32_t i;
1932 int32_t ret;
1933 if (!IsValidString(networkId, ID_MAX_LEN)) {
1934 return SOFTBUS_INVALID_PARAM;
1935 }
1936 if (info == NULL) {
1937 LLOGE("para error.");
1938 return SOFTBUS_INVALID_PARAM;
1939 }
1940 if (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END) {
1941 LLOGE("KEY error.");
1942 return SOFTBUS_INVALID_PARAM;
1943 }
1944 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1945 LLOGE("lock mutex fail!");
1946 return SOFTBUS_LOCK_ERR;
1947 }
1948 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1949 if (key == g_dlKeyTable[i].key) {
1950 if (g_dlKeyTable[i].getInfo != NULL) {
1951 ret = g_dlKeyTable[i].getInfo(networkId, info, len);
1952 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1953 return ret;
1954 }
1955 }
1956 }
1957 SoftBusMutexUnlock(&g_distributedNetLedger.lock);
1958 LLOGE("KEY NOT exist.");
1959 return SOFTBUS_ERR;
1960 }
1961
GetAllOnlineAndMetaNodeInfo(NodeBasicInfo ** info,int32_t * infoNum,bool isNeedMeta)1962 static int32_t GetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum, bool isNeedMeta)
1963 {
1964 if (info == NULL || infoNum == NULL) {
1965 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "key params are null");
1966 return SOFTBUS_INVALID_PARAM;
1967 }
1968 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
1969 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1970 return SOFTBUS_LOCK_ERR;
1971 }
1972 int32_t ret = SOFTBUS_ERR;
1973 do {
1974 *info = NULL;
1975 if (GetDLOnlineNodeNumLocked(infoNum, isNeedMeta) != SOFTBUS_OK) {
1976 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get online node num failed");
1977 break;
1978 }
1979 if (*infoNum == 0) {
1980 ret = SOFTBUS_OK;
1981 break;
1982 }
1983 *info = SoftBusMalloc((*infoNum) * sizeof(NodeBasicInfo));
1984 if (*info == NULL) {
1985 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "malloc node info buffer failed");
1986 break;
1987 }
1988 if (FillDLOnlineNodeInfoLocked(*info, *infoNum, isNeedMeta) != SOFTBUS_OK) {
1989 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fill online node num failed");
1990 break;
1991 }
1992 ret = SOFTBUS_OK;
1993 } while (false);
1994 if (ret != SOFTBUS_OK) {
1995 if (*info != NULL) {
1996 SoftBusFree(*info);
1997 *info = NULL;
1998 }
1999 *infoNum = 0;
2000 }
2001 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2002 return ret;
2003 }
2004
LnnIsLSANode(const NodeBasicInfo * info)2005 NO_SANITIZE("cfi") bool LnnIsLSANode(const NodeBasicInfo *info)
2006 {
2007 NodeInfo *nodeInfo = LnnGetNodeInfoById(info->networkId, CATEGORY_NETWORK_ID);
2008 if (nodeInfo != NULL && LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_LSA)) {
2009 return true;
2010 }
2011 return false;
2012 }
2013
LnnGetAllOnlineNodeNum(int32_t * nodeNum)2014 int32_t LnnGetAllOnlineNodeNum(int32_t *nodeNum)
2015 {
2016 if (nodeNum == NULL) {
2017 return SOFTBUS_INVALID_PARAM;
2018 }
2019 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2020 LLOGE("lock fail");
2021 return SOFTBUS_LOCK_ERR;
2022 }
2023 /* node num include meta node */
2024 if (GetDLOnlineNodeNumLocked(nodeNum, true) != SOFTBUS_OK) {
2025 LLOGE("get online node num failed");
2026 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2027 return SOFTBUS_ERR;
2028 }
2029 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2030 return SOFTBUS_OK;
2031 }
2032
LnnGetAllOnlineNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)2033 NO_SANITIZE("cfi") int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
2034 {
2035 return GetAllOnlineAndMetaNodeInfo(info, infoNum, false);
2036 }
2037
LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo ** info,int32_t * infoNum)2038 NO_SANITIZE("cfi") int32_t LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
2039 {
2040 return GetAllOnlineAndMetaNodeInfo(info, infoNum, true);
2041 }
2042
LnnGetNetworkIdByBtMac(const char * btMac,char * buf,uint32_t len)2043 NO_SANITIZE("cfi") int32_t LnnGetNetworkIdByBtMac(const char *btMac, char *buf, uint32_t len)
2044 {
2045 if (btMac == NULL || btMac[0] == '\0' || buf == NULL) {
2046 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "btMac is empty");
2047 return SOFTBUS_INVALID_PARAM;
2048 }
2049 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2050 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2051 return SOFTBUS_LOCK_ERR;
2052 }
2053 MapIterator *it = LnnMapInitIterator(&g_distributedNetLedger.distributedInfo.udidMap);
2054 if (it == NULL) {
2055 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "it is null");
2056 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2057 return SOFTBUS_ERR;
2058 }
2059 while (LnnMapHasNext(it)) {
2060 it = LnnMapNext(it);
2061 if (it == NULL) {
2062 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2063 return SOFTBUS_ERR;
2064 }
2065 NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
2066 if ((LnnIsNodeOnline(nodeInfo) || nodeInfo->metaInfo.isMetaNode) &&
2067 StrCmpIgnoreCase(nodeInfo->connectInfo.macAddr, btMac) == 0) {
2068 if (strcpy_s(buf, len, nodeInfo->networkId) != EOK) {
2069 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s networkId fail!");
2070 }
2071 LnnMapDeinitIterator(it);
2072 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2073 return SOFTBUS_OK;
2074 }
2075 }
2076 LnnMapDeinitIterator(it);
2077 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2078 return SOFTBUS_ERR;
2079 }
2080
LnnGetNetworkIdByUdidHash(const char * udidHash,char * buf,uint32_t len)2081 NO_SANITIZE("cfi") int32_t LnnGetNetworkIdByUdidHash(const char *udidHash, char *buf, uint32_t len)
2082 {
2083 if (udidHash == NULL || udidHash[0] == '\0' || buf == NULL) {
2084 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "udidHash is empty");
2085 return SOFTBUS_INVALID_PARAM;
2086 }
2087 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2088 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2089 return SOFTBUS_LOCK_ERR;
2090 }
2091 MapIterator *it = LnnMapInitIterator(&g_distributedNetLedger.distributedInfo.udidMap);
2092 if (it == NULL) {
2093 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "it is null");
2094 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2095 return SOFTBUS_ERR;
2096 }
2097 char nodeUdidHash[SHA_256_HASH_LEN] = {0};
2098 while (LnnMapHasNext(it)) {
2099 it = LnnMapNext(it);
2100 if (it == NULL) {
2101 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2102 return SOFTBUS_ERR;
2103 }
2104 NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
2105 if (LnnIsNodeOnline(nodeInfo) || nodeInfo->metaInfo.isMetaNode) {
2106 if (SoftBusGenerateStrHash((uint8_t*)nodeInfo->deviceInfo.deviceUdid,
2107 strlen(nodeInfo->deviceInfo.deviceUdid), (uint8_t*)nodeUdidHash) != SOFTBUS_OK) {
2108 continue;
2109 }
2110 if (memcmp(nodeUdidHash, udidHash, SHA_256_HASH_LEN) != 0) {
2111 continue;
2112 }
2113 if (strcpy_s(buf, len, nodeInfo->networkId) != EOK) {
2114 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s networkId fail!");
2115 }
2116 LnnMapDeinitIterator(it);
2117 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2118 return SOFTBUS_OK;
2119 }
2120 }
2121 LnnMapDeinitIterator(it);
2122 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2123 return SOFTBUS_ERR;
2124 }
2125
LnnGetNetworkIdByUuid(const char * uuid,char * buf,uint32_t len)2126 NO_SANITIZE("cfi") int32_t LnnGetNetworkIdByUuid(const char *uuid, char *buf, uint32_t len)
2127 {
2128 if (!IsValidString(uuid, ID_MAX_LEN)) {
2129 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "uuid is invalid");
2130 return SOFTBUS_INVALID_PARAM;
2131 }
2132
2133 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2134 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2135 return SOFTBUS_LOCK_ERR;
2136 }
2137 NodeInfo *nodeInfo = LnnGetNodeInfoById(uuid, CATEGORY_UUID);
2138 if (nodeInfo == NULL) {
2139 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2140 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2141 return SOFTBUS_ERR;
2142 }
2143 if (strncpy_s(buf, len, nodeInfo->networkId, strlen(nodeInfo->networkId)) != EOK) {
2144 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
2145 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2146 return SOFTBUS_MEM_ERR;
2147 }
2148 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2149 return SOFTBUS_OK;
2150 }
2151
LnnGetNetworkIdByUdid(const char * udid,char * buf,uint32_t len)2152 NO_SANITIZE("cfi") int32_t LnnGetNetworkIdByUdid(const char *udid, char *buf, uint32_t len)
2153 {
2154 if (!IsValidString(udid, ID_MAX_LEN)) {
2155 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "udid is invalid");
2156 return SOFTBUS_INVALID_PARAM;
2157 }
2158
2159 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2160 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2161 return SOFTBUS_LOCK_ERR;
2162 }
2163 NodeInfo *nodeInfo = LnnGetNodeInfoById(udid, CATEGORY_UDID);
2164 if (nodeInfo == NULL) {
2165 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2166 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2167 return SOFTBUS_ERR;
2168 }
2169 if (strncpy_s(buf, len, nodeInfo->networkId, strlen(nodeInfo->networkId)) != EOK) {
2170 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
2171 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2172 return SOFTBUS_MEM_ERR;
2173 }
2174 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2175 return SOFTBUS_OK;
2176 }
2177
LnnGetAllAuthSeq(const char * udid,int64_t * authSeq,uint32_t num)2178 NO_SANITIZE("cfi") int32_t LnnGetAllAuthSeq(const char *udid, int64_t *authSeq, uint32_t num)
2179 {
2180 if (!IsValidString(udid, ID_MAX_LEN) || authSeq == NULL || num != DISCOVERY_TYPE_COUNT) {
2181 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "[offline]udid is invalid");
2182 return SOFTBUS_INVALID_PARAM;
2183 }
2184 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2185 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "[offline]lock mutex fail!");
2186 return SOFTBUS_LOCK_ERR;
2187 }
2188 NodeInfo *nodeInfo = LnnGetNodeInfoById(udid, CATEGORY_UDID);
2189 if (nodeInfo == NULL) {
2190 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "[offline] get node info fail");
2191 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2192 return SOFTBUS_ERR;
2193 }
2194 if (memcpy_s(authSeq, sizeof(int64_t) * num, nodeInfo->authSeq, sizeof(nodeInfo->authSeq)) != EOK) {
2195 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "[offline]memcpy_s authSeq fail");
2196 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2197 return SOFTBUS_MEM_ERR;
2198 }
2199 DiscoveryType type;
2200 for (type = DISCOVERY_TYPE_WIFI; type < DISCOVERY_TYPE_P2P; type++) {
2201 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO,
2202 "[offline]LnnGetAllAuthSeq: authSeq=%" PRId64 ", type=%d.", authSeq[type], type);
2203 }
2204 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2205 return SOFTBUS_OK;
2206 }
2207
LnnGetDLOnlineTimestamp(const char * networkId,uint64_t * timestamp)2208 NO_SANITIZE("cfi") int32_t LnnGetDLOnlineTimestamp(const char *networkId, uint64_t *timestamp)
2209 {
2210 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2211 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2212 return SOFTBUS_LOCK_ERR;
2213 }
2214 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2215 if (nodeInfo == NULL) {
2216 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2217 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2218 return SOFTBUS_ERR;
2219 }
2220 *timestamp = nodeInfo->onlinetTimestamp;
2221 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2222 return SOFTBUS_OK;
2223 }
2224
LnnGetDLHeartbeatTimestamp(const char * networkId,uint64_t * timestamp)2225 NO_SANITIZE("cfi") int32_t LnnGetDLHeartbeatTimestamp(const char *networkId, uint64_t *timestamp)
2226 {
2227 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2228 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2229 return SOFTBUS_LOCK_ERR;
2230 }
2231 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2232 if (nodeInfo == NULL) {
2233 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2234 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2235 return SOFTBUS_ERR;
2236 }
2237 *timestamp = nodeInfo->heartbeatTimeStamp;
2238 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2239 return SOFTBUS_OK;
2240 }
2241
LnnSetDLHeartbeatTimestamp(const char * networkId,uint64_t timestamp)2242 NO_SANITIZE("cfi") int32_t LnnSetDLHeartbeatTimestamp(const char *networkId, uint64_t timestamp)
2243 {
2244 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2245 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2246 return SOFTBUS_LOCK_ERR;
2247 }
2248 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2249 if (nodeInfo == NULL) {
2250 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2251 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2252 return SOFTBUS_ERR;
2253 }
2254 nodeInfo->heartbeatTimeStamp = timestamp;
2255 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2256 return SOFTBUS_OK;
2257 }
2258
LnnSetDLConnCapability(const char * networkId,uint32_t connCapability)2259 NO_SANITIZE("cfi") int32_t LnnSetDLConnCapability(const char *networkId, uint32_t connCapability)
2260 {
2261 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2262 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2263 return SOFTBUS_LOCK_ERR;
2264 }
2265 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2266 if (nodeInfo == NULL) {
2267 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2268 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2269 return SOFTBUS_ERR;
2270 }
2271 nodeInfo->netCapacity = connCapability;
2272 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2273 return SOFTBUS_OK;
2274 }
2275
LnnSetDLBatteryInfo(const char * networkId,const BatteryInfo * info)2276 NO_SANITIZE("cfi") int32_t LnnSetDLBatteryInfo(const char *networkId, const BatteryInfo *info)
2277 {
2278 if (networkId == NULL || info == NULL) {
2279 return SOFTBUS_INVALID_PARAM;
2280 }
2281 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2282 LLOGE("lock mutex fail!");
2283 return SOFTBUS_LOCK_ERR;
2284 }
2285 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2286 if (nodeInfo == NULL) {
2287 LLOGE("get info fail");
2288 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2289 return SOFTBUS_ERR;
2290 }
2291 nodeInfo->batteryInfo.batteryLevel = info->batteryLevel;
2292 nodeInfo->batteryInfo.isCharging = info->isCharging;
2293 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2294 return SOFTBUS_OK;
2295 }
2296
LnnSetDLBssTransInfo(const char * networkId,const BssTransInfo * info)2297 NO_SANITIZE("cfi") int32_t LnnSetDLBssTransInfo(const char *networkId, const BssTransInfo *info)
2298 {
2299 if (networkId == NULL || info == NULL) {
2300 return SOFTBUS_INVALID_PARAM;
2301 }
2302 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2303 LLOGE("lock mutex fail!");
2304 return SOFTBUS_LOCK_ERR;
2305 }
2306 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2307 if (nodeInfo == NULL) {
2308 LLOGE("get info fail");
2309 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2310 return SOFTBUS_ERR;
2311 }
2312 if (memcpy_s(&(nodeInfo->bssTransInfo), sizeof(BssTransInfo), info,
2313 sizeof(BssTransInfo)) != SOFTBUS_OK) {
2314 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2315 return SOFTBUS_MEM_ERR;
2316 }
2317 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2318 return SOFTBUS_OK;
2319 }
2320
LnnSetDLNodeAddr(const char * id,IdCategory type,const char * addr)2321 NO_SANITIZE("cfi") int32_t LnnSetDLNodeAddr(const char *id, IdCategory type, const char *addr)
2322 {
2323 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2324 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2325 return SOFTBUS_LOCK_ERR;
2326 }
2327 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2328 if (nodeInfo == NULL) {
2329 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2330 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2331 return SOFTBUS_ERR;
2332 }
2333 int ret = strcpy_s(nodeInfo->nodeAddress, sizeof(nodeInfo->nodeAddress), addr);
2334 if (ret != EOK) {
2335 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set node addr failed!ret=%d", ret);
2336 }
2337 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2338 return ret == EOK ? SOFTBUS_OK : SOFTBUS_ERR;
2339 }
2340
LnnSetDLProxyPort(const char * id,IdCategory type,int32_t proxyPort)2341 int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort)
2342 {
2343 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2344 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2345 return SOFTBUS_ERR;
2346 }
2347 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2348 if (nodeInfo == NULL) {
2349 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2350 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2351 return SOFTBUS_ERR;
2352 }
2353 nodeInfo->connectInfo.proxyPort = proxyPort;
2354 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2355 return SOFTBUS_OK;
2356 }
2357
LnnSetDLSessionPort(const char * id,IdCategory type,int32_t sessionPort)2358 int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort)
2359 {
2360 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2361 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2362 return SOFTBUS_ERR;
2363 }
2364 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2365 if (nodeInfo == NULL) {
2366 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2367 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2368 return SOFTBUS_ERR;
2369 }
2370 nodeInfo->connectInfo.sessionPort = sessionPort;
2371 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2372 return SOFTBUS_OK;
2373 }
2374
LnnSetDLAuthPort(const char * id,IdCategory type,int32_t authPort)2375 int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort)
2376 {
2377 if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
2378 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
2379 return SOFTBUS_ERR;
2380 }
2381 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2382 if (nodeInfo == NULL) {
2383 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
2384 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2385 return SOFTBUS_ERR;
2386 }
2387 nodeInfo->connectInfo.authPort = authPort;
2388 (void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
2389 return SOFTBUS_OK;
2390 }
2391
SoftBusDumpBusCenterRemoteDeviceInfo(int32_t fd)2392 int32_t SoftBusDumpBusCenterRemoteDeviceInfo(int32_t fd)
2393 {
2394 SOFTBUS_DPRINTF(fd, "-----RemoteDeviceInfo-----\n");
2395 NodeBasicInfo *remoteNodeInfo = NULL;
2396 int32_t infoNum = 0;
2397 if (LnnGetAllOnlineNodeInfo(&remoteNodeInfo, &infoNum) != 0) {
2398 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnGetAllOnlineNodeInfo failed!");
2399 return SOFTBUS_ERR;
2400 }
2401 SOFTBUS_DPRINTF(fd, "remote device num = %d\n", infoNum);
2402 for (int32_t i = 0; i < infoNum; i++) {
2403 SOFTBUS_DPRINTF(fd, "\n[NO.%d]\n", i + 1);
2404 SoftBusDumpBusCenterPrintInfo(fd, remoteNodeInfo + i);
2405 }
2406 return SOFTBUS_OK;
2407 }
2408
LnnInitDistributedLedger(void)2409 NO_SANITIZE("cfi") int32_t LnnInitDistributedLedger(void)
2410 {
2411 if (g_distributedNetLedger.status == DL_INIT_SUCCESS) {
2412 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "Distributed Ledger already init");
2413 return SOFTBUS_OK;
2414 }
2415
2416 if (InitDistributedInfo(&g_distributedNetLedger.distributedInfo) != SOFTBUS_OK) {
2417 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "InitDistributedInfo ERROR!");
2418 g_distributedNetLedger.status = DL_INIT_FAIL;
2419 return SOFTBUS_ERR;
2420 }
2421
2422 if (InitConnectionCode(&g_distributedNetLedger.cnnCode) != SOFTBUS_OK) {
2423 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "InitConnectionCode ERROR!");
2424 g_distributedNetLedger.status = DL_INIT_FAIL;
2425 return SOFTBUS_ERR;
2426 }
2427 if (SoftBusMutexInit(&g_distributedNetLedger.lock, NULL) != SOFTBUS_OK) {
2428 g_distributedNetLedger.status = DL_INIT_FAIL;
2429 return SOFTBUS_ERR;
2430 }
2431 if (SoftBusRegBusCenterVarDump(SOFTBUS_BUSCENTER_DUMP_REMOTEDEVICEINFO,
2432 &SoftBusDumpBusCenterRemoteDeviceInfo) != SOFTBUS_OK) {
2433 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SoftBusRegBusCenterVarDump regist fail");
2434 return SOFTBUS_ERR;
2435 }
2436 g_distributedNetLedger.status = DL_INIT_SUCCESS;
2437 return SOFTBUS_OK;
2438 }
2439
LnnGetOnlineNodeByUdidHash(const char * recvUdidHash)2440 NO_SANITIZE("cfi") const NodeInfo *LnnGetOnlineNodeByUdidHash(const char *recvUdidHash)
2441 {
2442 int32_t i;
2443 int32_t infoNum = 0;
2444 NodeBasicInfo *info = NULL;
2445 unsigned char shortUdidHash[SHORT_UDID_HASH_LEN + 1] = {0};
2446
2447 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
2448 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get all online node info fail");
2449 return NULL;
2450 }
2451 if (info == NULL || infoNum == 0) {
2452 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "none online node");
2453 if (info != NULL) {
2454 SoftBusFree(info);
2455 }
2456 return NULL;
2457 }
2458 for (i = 0; i < infoNum; ++i) {
2459 const NodeInfo *nodeInfo = LnnGetNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID);
2460 if (nodeInfo == NULL) {
2461 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "nodeInfo is null.");
2462 continue;
2463 }
2464 if (GenerateStrHashAndConvertToHexString((const unsigned char *)nodeInfo->deviceInfo.deviceUdid,
2465 SHORT_UDID_HASH_LEN, shortUdidHash, SHORT_UDID_HASH_LEN + 1) != SOFTBUS_OK) {
2466 continue;
2467 }
2468 if (memcmp(shortUdidHash, recvUdidHash, SHORT_UDID_HASH_LEN) == 0) {
2469 char *anoyUdid = NULL;
2470 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "node udid:%s, shortUdidHash:%s is online",
2471 ToSecureStrDeviceID(nodeInfo->deviceInfo.deviceUdid, &anoyUdid),
2472 AnonymizesUDID((const char *)shortUdidHash));
2473 SoftBusFree(anoyUdid);
2474 SoftBusFree(info);
2475 return nodeInfo;
2476 }
2477 }
2478 SoftBusFree(info);
2479 return NULL;
2480 }
2481
RefreshDeviceInfoByDevId(DeviceInfo * device,const InnerDeviceInfoAddtions * addtions)2482 static void RefreshDeviceInfoByDevId(DeviceInfo *device, const InnerDeviceInfoAddtions *addtions)
2483 {
2484 if (addtions->medium != COAP) {
2485 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameter error");
2486 return;
2487 }
2488 unsigned char shortUdidHash[SHORT_UDID_HASH_LEN + 1] = {0};
2489 if (GenerateStrHashAndConvertToHexString((const unsigned char *)device->devId,
2490 SHORT_UDID_HASH_LEN, shortUdidHash, SHORT_UDID_HASH_LEN + 1) != SOFTBUS_OK) {
2491 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "refresh device info get short udid hash fail");
2492 return;
2493 }
2494 if (memset_s(device->devId, DISC_MAX_DEVICE_ID_LEN, 0, DISC_MAX_DEVICE_ID_LEN) != EOK) {
2495 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "refresh device info memset_s fail");
2496 return;
2497 }
2498 if (memcpy_s(device->devId, DISC_MAX_DEVICE_ID_LEN, shortUdidHash, SHORT_UDID_HASH_LEN) != EOK) {
2499 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s device short udid hash fail");
2500 }
2501 }
2502
RefreshDeviceOnlineStateInfo(DeviceInfo * device,const InnerDeviceInfoAddtions * addtions)2503 static void RefreshDeviceOnlineStateInfo(DeviceInfo *device, const InnerDeviceInfoAddtions *addtions)
2504 {
2505 if (addtions->medium == COAP) {
2506 device->isOnline = LnnGetOnlineStateById(device->devId, CATEGORY_UDID);
2507 }
2508 if (addtions->medium == BLE) {
2509 device->isOnline = ((LnnGetOnlineNodeByUdidHash(device->devId)) != NULL) ? true : false;
2510 }
2511 }
2512
LnnRefreshDeviceOnlineStateAndDevIdInfo(const char * pkgName,DeviceInfo * device,const InnerDeviceInfoAddtions * addtions)2513 NO_SANITIZE("cfi") void LnnRefreshDeviceOnlineStateAndDevIdInfo(const char *pkgName, DeviceInfo *device,
2514 const InnerDeviceInfoAddtions *addtions)
2515 {
2516 (void)pkgName;
2517 RefreshDeviceOnlineStateInfo(device, addtions);
2518 RefreshDeviceInfoByDevId(device, addtions);
2519 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "device found by medium=%d, udidhash=%s, online status=%d",
2520 addtions->medium, AnonymizesUDID(device->devId), device->isOnline);
2521 }
2522