1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "lnn_distributed_net_ledger_common.h"
17
18 #include <stddef.h>
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include <securec.h>
24
25 #include "anonymizer.h"
26 #include "bus_center_manager.h"
27 #include "g_enhance_lnn_func.h"
28 #include "g_enhance_lnn_func_pack.h"
29 #include "lnn_node_info.h"
30 #include "lnn_feature_capability.h"
31 #include "lnn_heartbeat_utils.h"
32 #include "lnn_log.h"
33 #include "lnn_node_info.h"
34 #include "softbus_error_code.h"
35 #include "softbus_utils.h"
36 #include "softbus_init_common.h"
37
GetCurrentTime(void)38 static uint64_t GetCurrentTime(void)
39 {
40 SoftBusSysTime now = { 0 };
41 if (SoftBusGetTime(&now) != SOFTBUS_OK) {
42 LNN_LOGE(LNN_LEDGER, "GetCurrentTime fail.");
43 return 0;
44 }
45 return (uint64_t)now.sec * TIME_THOUSANDS_FACTOR + (uint64_t)now.usec / TIME_THOUSANDS_FACTOR;
46 }
47
DlGetDeviceUuid(const char * networkId,bool checkOnline,void * buf,uint32_t len)48 static int32_t DlGetDeviceUuid(const char *networkId, bool checkOnline, void *buf, uint32_t len)
49 {
50 (void)checkOnline;
51 NodeInfo *info = NULL;
52 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
53 if (strncpy_s((char*)buf, len, info->uuid, strlen(info->uuid)) != EOK) {
54 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
55 return SOFTBUS_MEM_ERR;
56 }
57 return SOFTBUS_OK;
58 }
59
DlGetDeviceOfflineCode(const char * networkId,bool checkOnline,void * buf,uint32_t len)60 static int32_t DlGetDeviceOfflineCode(const char *networkId, bool checkOnline, void *buf, uint32_t len)
61 {
62 (void)checkOnline;
63 NodeInfo *info = NULL;
64 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
65 if (memcpy_s(buf, len, info->offlineCode, OFFLINE_CODE_BYTE_SIZE) != EOK) {
66 LNN_LOGE(LNN_LEDGER, "memcpy_s offlinecode ERROR!");
67 return SOFTBUS_MEM_ERR;
68 }
69 return SOFTBUS_OK;
70 }
71
DlGetDeviceUdid(const char * networkId,bool checkOnline,void * buf,uint32_t len)72 static int32_t DlGetDeviceUdid(const char *networkId, bool checkOnline, void *buf, uint32_t len)
73 {
74 (void)checkOnline;
75 const char *udid = NULL;
76 NodeInfo *info = NULL;
77 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
78 udid = LnnGetDeviceUdid(info);
79 if (udid == NULL) {
80 LNN_LOGE(LNN_LEDGER, "get device udid fail");
81 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
82 }
83 if (strncpy_s((char*)buf, len, udid, strlen(udid)) != EOK) {
84 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
85 return SOFTBUS_MEM_ERR;
86 }
87 return SOFTBUS_OK;
88 }
89
DlGetNodeSoftBusVersion(const char * networkId,bool checkOnline,void * buf,uint32_t len)90 static int32_t DlGetNodeSoftBusVersion(const char *networkId, bool checkOnline, void *buf, uint32_t len)
91 {
92 (void)checkOnline;
93 NodeInfo *info = NULL;
94 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
95 if (strncpy_s((char*)buf, len, info->softBusVersion, strlen(info->softBusVersion)) != EOK) {
96 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
97 return SOFTBUS_MEM_ERR;
98 }
99 return SOFTBUS_OK;
100 }
101
DlGetDeviceType(const char * networkId,bool checkOnline,void * buf,uint32_t len)102 static int32_t DlGetDeviceType(const char *networkId, bool checkOnline, void *buf, uint32_t len)
103 {
104 (void)checkOnline;
105 NodeInfo *info = NULL;
106 char *deviceType = NULL;
107 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
108 deviceType = LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId);
109 if (deviceType == NULL) {
110 LNN_LOGE(LNN_LEDGER, "deviceType fail.");
111 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
112 }
113 if (strncpy_s((char*)buf, len, deviceType, strlen(deviceType)) != EOK) {
114 LNN_LOGE(LNN_LEDGER, "MEM COPY ERROR!");
115 return SOFTBUS_MEM_ERR;
116 }
117 return SOFTBUS_OK;
118 }
119
DlGetDeviceTypeId(const char * networkId,bool checkOnline,void * buf,uint32_t len)120 static int32_t DlGetDeviceTypeId(const char *networkId, bool checkOnline, void *buf, uint32_t len)
121 {
122 (void)checkOnline;
123 (void)len;
124 NodeInfo *info = NULL;
125 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
126 *((int32_t *)buf) = info->deviceInfo.deviceTypeId;
127 return SOFTBUS_OK;
128 }
129
DlGetAuthType(const char * networkId,bool checkOnline,void * buf,uint32_t len)130 static int32_t DlGetAuthType(const char *networkId, bool checkOnline, void *buf, uint32_t len)
131 {
132 (void)checkOnline;
133 NodeInfo *info = NULL;
134 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
135 *((uint32_t *)buf) = info->AuthTypeValue;
136 return SOFTBUS_OK;
137 }
138
DlGetDeviceName(const char * networkId,bool checkOnline,void * buf,uint32_t len)139 static int32_t DlGetDeviceName(const char *networkId, bool checkOnline, void *buf, uint32_t len)
140 {
141 (void)checkOnline;
142 NodeInfo *info = NULL;
143 const char *deviceName = NULL;
144 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
145 deviceName = LnnGetDeviceName(&info->deviceInfo);
146 if (deviceName == NULL) {
147 LNN_LOGE(LNN_LEDGER, "get device name fail.");
148 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
149 }
150 if (strncpy_s((char*)buf, len, deviceName, strlen(deviceName)) != EOK) {
151 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
152 return SOFTBUS_MEM_ERR;
153 }
154 return SOFTBUS_OK;
155 }
156
DlGetBtMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)157 static int32_t DlGetBtMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
158 {
159 (void)checkOnline;
160 NodeInfo *info = NULL;
161 const char *mac = NULL;
162 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
163 mac = LnnGetBtMac(info);
164 if (mac == NULL) {
165 LNN_LOGE(LNN_LEDGER, "get bt mac fail.");
166 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
167 }
168 if (strncpy_s((char*)buf, len, mac, strlen(mac)) != EOK) {
169 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
170 return SOFTBUS_MEM_ERR;
171 }
172 return SOFTBUS_OK;
173 }
174
DlGetWlanIp(const char * networkId,bool checkOnline,void * buf,uint32_t len,int32_t ifnameIdx)175 static int32_t DlGetWlanIp(const char *networkId, bool checkOnline, void *buf, uint32_t len, int32_t ifnameIdx)
176 {
177 (void)checkOnline;
178 NodeInfo *info = NULL;
179 const char *ip = NULL;
180 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
181 ip = LnnGetWiFiIp(info, ifnameIdx);
182 if (ip == NULL) {
183 LNN_LOGE(LNN_LEDGER, "get wifi ip fail.");
184 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
185 }
186 if (strncpy_s((char*)buf, len, ip, strlen(ip)) != EOK) {
187 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
188 return SOFTBUS_MEM_ERR;
189 }
190 return SOFTBUS_OK;
191 }
192
DlGetMasterUdid(const char * networkId,bool checkOnline,void * buf,uint32_t len)193 static int32_t DlGetMasterUdid(const char *networkId, bool checkOnline, void *buf, uint32_t len)
194 {
195 (void)checkOnline;
196 NodeInfo *info = NULL;
197 const char *masterUdid = NULL;
198
199 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
200 if (!LnnIsNodeOnline(info)) {
201 return SOFTBUS_NETWORK_NODE_OFFLINE;
202 }
203 masterUdid = LnnGetMasterUdid(info);
204 if (masterUdid == NULL) {
205 LNN_LOGE(LNN_LEDGER, "get master uiid fail");
206 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
207 }
208 if (strncpy_s((char*)buf, len, masterUdid, strlen(masterUdid)) != EOK) {
209 LNN_LOGE(LNN_LEDGER, "copy master udid to buf fail");
210 return SOFTBUS_MEM_ERR;
211 }
212 return SOFTBUS_OK;
213 }
214
DlGetRemotePtk(const char * networkId,bool checkOnline,void * buf,uint32_t len)215 static int32_t DlGetRemotePtk(const char *networkId, bool checkOnline, void *buf, uint32_t len)
216 {
217 (void)checkOnline;
218 if (len != PTK_DEFAULT_LEN) {
219 LNN_LOGE(LNN_LEDGER, "length error");
220 return SOFTBUS_INVALID_PARAM;
221 }
222 NodeInfo *info = NULL;
223 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
224 if (memcpy_s(buf, len, info->remotePtk, PTK_DEFAULT_LEN) != EOK) {
225 LNN_LOGE(LNN_LEDGER, "memcpy remote ptk err");
226 return SOFTBUS_MEM_ERR;
227 }
228 return SOFTBUS_OK;
229 }
230
DlGetStaticCapLen(const char * networkId,bool checkOnline,void * buf,uint32_t len)231 static int32_t DlGetStaticCapLen(const char *networkId, bool checkOnline, void *buf, uint32_t len)
232 {
233 (void)checkOnline;
234 NodeInfo *info = NULL;
235 if (len != LNN_COMMON_LEN) {
236 LNN_LOGE(LNN_LEDGER, "invalid param");
237 return SOFTBUS_INVALID_PARAM;
238 }
239 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
240 if (!LnnIsNodeOnline(info)) {
241 LNN_LOGE(LNN_LEDGER, "device is offline");
242 return SOFTBUS_NETWORK_NODE_OFFLINE;
243 }
244 *((int32_t *)buf) = info->staticCapLen;
245 return SOFTBUS_OK;
246 }
247
DlGetDeviceSecurityLevel(const char * networkId,bool checkOnline,void * buf,uint32_t len)248 static int32_t DlGetDeviceSecurityLevel(const char *networkId, bool checkOnline, void *buf, uint32_t len)
249 {
250 (void)checkOnline;
251 NodeInfo *info = NULL;
252 if (len != LNN_COMMON_LEN) {
253 LNN_LOGE(LNN_LEDGER, "invalid param");
254 return SOFTBUS_INVALID_PARAM;
255 }
256 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
257 *((int32_t *)buf) = info->deviceSecurityLevel;
258 return SOFTBUS_OK;
259 }
260
DlGetStaticCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)261 static int32_t DlGetStaticCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
262 {
263 (void)checkOnline;
264 if (len > STATIC_CAP_LEN) {
265 LNN_LOGE(LNN_LEDGER, "length error");
266 return SOFTBUS_INVALID_PARAM;
267 }
268 NodeInfo *info = NULL;
269 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
270 if (memcpy_s(buf, len, info->staticCapability, STATIC_CAP_LEN) != EOK) {
271 LNN_LOGE(LNN_LEDGER, "memcpy static cap err");
272 return SOFTBUS_MEM_ERR;
273 }
274 return SOFTBUS_OK;
275 }
276
DlGetNodeBleMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)277 static int32_t DlGetNodeBleMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
278 {
279 (void)checkOnline;
280 NodeInfo *info = NULL;
281
282 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
283 if (strlen(info->connectInfo.bleMacAddr) == 0) {
284 LNN_LOGE(LNN_LEDGER, "ble mac is invalid.");
285 return SOFTBUS_INVALID_PARAM;
286 }
287 if (info->bleMacRefreshSwitch != 0) {
288 uint64_t currentTimeMs = GetCurrentTime();
289 LNN_CHECK_AND_RETURN_RET_LOGE(info->connectInfo.latestTime + BLE_ADV_LOST_TIME >= currentTimeMs,
290 SOFTBUS_NETWORK_GET_BLE_MAC_TIMEOUT, LNN_LEDGER,
291 "ble mac out date, lastAdvTime=%{public}" PRIu64 ", now=%{public}" PRIu64, info->connectInfo.latestTime,
292 currentTimeMs);
293 }
294 if (strcpy_s((char *)buf, len, info->connectInfo.bleMacAddr) != EOK) {
295 return SOFTBUS_MEM_ERR;
296 }
297 return SOFTBUS_OK;
298 }
299
LnnUpdateNodeBleMac(const char * networkId,char * bleMac,uint32_t len)300 void LnnUpdateNodeBleMac(const char *networkId, char *bleMac, uint32_t len)
301 {
302 if ((networkId == NULL) || (bleMac == NULL) || (len != MAC_LEN)) {
303 LNN_LOGE(LNN_LEDGER, "invalid arg");
304 return;
305 }
306 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
307 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
308 return;
309 }
310 NodeInfo *info = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
311 if (info == NULL) {
312 LNN_LOGE(LNN_LEDGER, "get node info fail.");
313 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
314 return;
315 }
316 if (memcpy_s(info->connectInfo.bleMacAddr, MAC_LEN, bleMac, len) != EOK) {
317 LNN_LOGE(LNN_LEDGER, "memcpy fail.");
318 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
319 return;
320 }
321 info->connectInfo.latestTime = GetCurrentTime();
322
323 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
324 }
325
IsNodeInfoScreenStatusSupport(const NodeInfo * info)326 int32_t IsNodeInfoScreenStatusSupport(const NodeInfo *info)
327 {
328 if (!LnnIsSupportHeartbeatCap(info->heartbeatCapacity, BIT_SUPPORT_SCREEN_STATUS)) {
329 return SOFTBUS_NETWORK_NOT_SUPPORT;
330 }
331 return SOFTBUS_OK;
332 }
333
LnnSetRemoteScreenStatusInfo(const char * networkId,bool isScreenOn)334 bool LnnSetRemoteScreenStatusInfo(const char *networkId, bool isScreenOn)
335 {
336 if (networkId == NULL) {
337 LNN_LOGE(LNN_LEDGER, "invalid arg");
338 return false;
339 }
340 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != SOFTBUS_OK) {
341 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
342 return false;
343 }
344 char *anonyNetworkId = NULL;
345 Anonymize(networkId, &anonyNetworkId);
346 NodeInfo *info = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
347 if (info == NULL) {
348 LNN_LOGE(LNN_LEDGER, "networkId=%{public}s, get node info fail.", AnonymizeWrapper(anonyNetworkId));
349 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
350 AnonymizeFree(anonyNetworkId);
351 return false;
352 }
353 if (IsNodeInfoScreenStatusSupport(info) != SOFTBUS_OK) {
354 LNN_LOGE(LNN_LEDGER, "networkId=%{public}s, node screen status is not supported",
355 AnonymizeWrapper(anonyNetworkId));
356 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
357 AnonymizeFree(anonyNetworkId);
358 return false;
359 }
360
361 info->isScreenOn = isScreenOn;
362 LNN_LOGI(LNN_LEDGER, "set %{public}s screen status to %{public}s",
363 AnonymizeWrapper(anonyNetworkId), isScreenOn ? "on" : "off");
364 SoftBusMutexUnlock(&LnnGetDistributedNetLedger()->lock);
365 AnonymizeFree(anonyNetworkId);
366 return true;
367 }
368
DlGetAuthPort(const char * networkId,bool checkOnline,void * buf,uint32_t len,int32_t ifnameIdx)369 static int32_t DlGetAuthPort(const char *networkId, bool checkOnline, void *buf, uint32_t len, int32_t ifnameIdx)
370 {
371 (void)checkOnline;
372 NodeInfo *info = NULL;
373 if (len != LNN_COMMON_LEN) {
374 return SOFTBUS_INVALID_PARAM;
375 }
376 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
377 *((int32_t *)buf) = LnnGetAuthPort(info, ifnameIdx);
378 return SOFTBUS_OK;
379 }
380
DlGetSessionPort(const char * networkId,bool checkOnline,void * buf,uint32_t len,int32_t ifnameIdx)381 static int32_t DlGetSessionPort(const char *networkId, bool checkOnline, void *buf, uint32_t len, int32_t ifnameIdx)
382 {
383 (void)checkOnline;
384 NodeInfo *info = NULL;
385 if (len != LNN_COMMON_LEN) {
386 return SOFTBUS_INVALID_PARAM;
387 }
388 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
389 *((int32_t *)buf) = LnnGetSessionPort(info, ifnameIdx);
390 return SOFTBUS_OK;
391 }
392
DlGetProxyPort(const char * networkId,bool checkOnline,void * buf,uint32_t len,int32_t ifnameIdx)393 static int32_t DlGetProxyPort(const char *networkId, bool checkOnline, void *buf, uint32_t len, int32_t ifnameIdx)
394 {
395 (void)checkOnline;
396 NodeInfo *info = NULL;
397 if (len != LNN_COMMON_LEN) {
398 return SOFTBUS_INVALID_PARAM;
399 }
400 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
401 *((int32_t *)buf) = LnnGetProxyPort(info, ifnameIdx);
402 return SOFTBUS_OK;
403 }
404
DlGetNetCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)405 static int32_t DlGetNetCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
406 {
407 (void)checkOnline;
408 NodeInfo *info = NULL;
409 if (len != LNN_COMMON_LEN) {
410 return SOFTBUS_INVALID_PARAM;
411 }
412 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
413 *((uint32_t *)buf) = info->netCapacity;
414 return SOFTBUS_OK;
415 }
416
DlGetFeatureCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)417 static int32_t DlGetFeatureCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
418 {
419 (void)checkOnline;
420 NodeInfo *info = NULL;
421 if (len != LNN_COMMON_LEN_64) {
422 return SOFTBUS_INVALID_PARAM;
423 }
424 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
425 *((uint64_t *)buf) = info->feature;
426 return SOFTBUS_OK;
427 }
428
DlGetConnSubFeatureCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)429 static int32_t DlGetConnSubFeatureCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
430 {
431 (void)checkOnline;
432 NodeInfo *info = NULL;
433 if (len != LNN_COMMON_LEN_64) {
434 return SOFTBUS_INVALID_PARAM;
435 }
436 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
437 *((uint64_t *)buf) = info->connSubFeature;
438 return SOFTBUS_OK;
439 }
440
DlGetNetType(const char * networkId,bool checkOnline,void * buf,uint32_t len)441 static int32_t DlGetNetType(const char *networkId, bool checkOnline, void *buf, uint32_t len)
442 {
443 (void)checkOnline;
444 NodeInfo *info = NULL;
445 if (len != LNN_COMMON_LEN) {
446 return SOFTBUS_INVALID_PARAM;
447 }
448 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
449 *((int32_t *)buf) = (int32_t)info->discoveryType;
450 return SOFTBUS_OK;
451 }
452
DlGetMasterWeight(const char * networkId,bool checkOnline,void * buf,uint32_t len)453 static int32_t DlGetMasterWeight(const char *networkId, bool checkOnline, void *buf, uint32_t len)
454 {
455 (void)checkOnline;
456 NodeInfo *info = NULL;
457
458 if (len != LNN_COMMON_LEN) {
459 return SOFTBUS_INVALID_PARAM;
460 }
461 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
462 *((int32_t *)buf) = info->masterWeight;
463 return SOFTBUS_OK;
464 }
465
DlGetP2pMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)466 static int32_t DlGetP2pMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
467 {
468 (void)checkOnline;
469 NodeInfo *info = NULL;
470 const char *mac = NULL;
471
472 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
473 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
474 LNN_LOGE(LNN_LEDGER, "node is offline");
475 return SOFTBUS_NETWORK_NODE_OFFLINE;
476 }
477 mac = LnnGetP2pMac(info);
478 if (mac == NULL) {
479 LNN_LOGE(LNN_LEDGER, "get p2p mac fail");
480 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
481 }
482 if (strcpy_s((char*)buf, len, mac) != EOK) {
483 LNN_LOGE(LNN_LEDGER, "copy p2p mac to buf fail");
484 return SOFTBUS_MEM_ERR;
485 }
486 return SOFTBUS_OK;
487 }
488
DlGetWifiDirectAddr(const char * networkId,bool checkOnline,void * buf,uint32_t len)489 static int32_t DlGetWifiDirectAddr(const char *networkId, bool checkOnline, void *buf, uint32_t len)
490 {
491 (void)checkOnline;
492 NodeInfo *info = NULL;
493 const char *wifiDirectAddr = NULL;
494
495 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
496 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
497 LNN_LOGE(LNN_LEDGER, "node is offline");
498 return SOFTBUS_NETWORK_NODE_OFFLINE;
499 }
500 wifiDirectAddr = LnnGetWifiDirectAddr(info);
501 if (wifiDirectAddr == NULL) {
502 LNN_LOGE(LNN_LEDGER, "get wifidirect addr fail");
503 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
504 }
505 if (strcpy_s((char*)buf, len, wifiDirectAddr) != EOK) {
506 LNN_LOGE(LNN_LEDGER, "copy wifidirect addr to buf fail");
507 return SOFTBUS_MEM_ERR;
508 }
509 return SOFTBUS_OK;
510 }
511
DlGetNodeAddr(const char * networkId,bool checkOnline,void * buf,uint32_t len)512 static int32_t DlGetNodeAddr(const char *networkId, bool checkOnline, void *buf, uint32_t len)
513 {
514 (void)checkOnline;
515 NodeInfo *info = NULL;
516 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
517 if (!LnnIsNodeOnline(info)) {
518 LNN_LOGE(LNN_LEDGER, "node is offline");
519 return SOFTBUS_NETWORK_NODE_OFFLINE;
520 }
521 if (strcpy_s((char*)buf, len, info->nodeAddress) != EOK) {
522 LNN_LOGE(LNN_LEDGER, "copy node addr to buf fail");
523 return SOFTBUS_MEM_ERR;
524 }
525 return SOFTBUS_OK;
526 }
527
DlGetP2pGoMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)528 static int32_t DlGetP2pGoMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
529 {
530 (void)checkOnline;
531 NodeInfo *info = NULL;
532 const char *mac = NULL;
533
534 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
535 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
536 LNN_LOGE(LNN_LEDGER, "node is offline");
537 return SOFTBUS_NETWORK_NODE_OFFLINE;
538 }
539 mac = LnnGetP2pGoMac(info);
540 if (mac == NULL) {
541 LNN_LOGE(LNN_LEDGER, "get p2p go mac fail");
542 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
543 }
544 if (strcpy_s((char*)buf, len, mac) != EOK) {
545 LNN_LOGE(LNN_LEDGER, "copy p2p go mac to buf fail");
546 return SOFTBUS_MEM_ERR;
547 }
548 return SOFTBUS_OK;
549 }
550
DlGetWifiCfg(const char * networkId,bool checkOnline,void * buf,uint32_t len)551 static int32_t DlGetWifiCfg(const char *networkId, bool checkOnline, void *buf, uint32_t len)
552 {
553 (void)checkOnline;
554 NodeInfo *info = NULL;
555 const char *wifiCfg = NULL;
556
557 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
558 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
559 LNN_LOGE(LNN_LEDGER, "node is offline");
560 return SOFTBUS_NETWORK_NODE_OFFLINE;
561 }
562 wifiCfg = LnnGetWifiCfg(info);
563 if (wifiCfg == NULL) {
564 LNN_LOGE(LNN_LEDGER, "get wifi cfg fail");
565 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
566 }
567 if (strcpy_s((char*)buf, len, wifiCfg) != EOK) {
568 LNN_LOGE(LNN_LEDGER, "copy wifi cfg to buf fail");
569 return SOFTBUS_MEM_ERR;
570 }
571 return SOFTBUS_OK;
572 }
573
DlGetChanList5g(const char * networkId,bool checkOnline,void * buf,uint32_t len)574 static int32_t DlGetChanList5g(const char *networkId, bool checkOnline, void *buf, uint32_t len)
575 {
576 (void)checkOnline;
577 NodeInfo *info = NULL;
578 const char *chanList5g = NULL;
579
580 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
581 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
582 LNN_LOGE(LNN_LEDGER, "node is offline");
583 return SOFTBUS_NETWORK_NODE_OFFLINE;
584 }
585 chanList5g = LnnGetChanList5g(info);
586 if (chanList5g == NULL) {
587 LNN_LOGE(LNN_LEDGER, "get chan list 5g fail");
588 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
589 }
590 if (strcpy_s((char*)buf, len, chanList5g) != EOK) {
591 LNN_LOGE(LNN_LEDGER, "copy chan list 5g to buf fail");
592 return SOFTBUS_MEM_ERR;
593 }
594 return SOFTBUS_OK;
595 }
596
DlGetP2pRole(const char * networkId,bool checkOnline,void * buf,uint32_t len)597 static int32_t DlGetP2pRole(const char *networkId, bool checkOnline, void *buf, uint32_t len)
598 {
599 (void)checkOnline;
600 NodeInfo *info = NULL;
601
602 if (len != LNN_COMMON_LEN) {
603 return SOFTBUS_INVALID_PARAM;
604 }
605 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
606 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
607 LNN_LOGE(LNN_LEDGER, "node is offline");
608 return SOFTBUS_NETWORK_NODE_OFFLINE;
609 }
610 *((int32_t *)buf) = LnnGetP2pRole(info);
611 return SOFTBUS_OK;
612 }
613
DlGetStateVersion(const char * networkId,bool checkOnline,void * buf,uint32_t len)614 static int32_t DlGetStateVersion(const char *networkId, bool checkOnline, void *buf, uint32_t len)
615 {
616 (void)checkOnline;
617 NodeInfo *info = NULL;
618
619 if (len != LNN_COMMON_LEN) {
620 return SOFTBUS_INVALID_PARAM;
621 }
622 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
623 if (!LnnIsNodeOnline(info)) {
624 LNN_LOGE(LNN_LEDGER, "node is offline");
625 return SOFTBUS_NETWORK_NODE_OFFLINE;
626 }
627 *((int32_t *)buf) = info->stateVersion;
628 return SOFTBUS_OK;
629 }
630
DlGetStaFrequency(const char * networkId,bool checkOnline,void * buf,uint32_t len)631 static int32_t DlGetStaFrequency(const char *networkId, bool checkOnline, void *buf, uint32_t len)
632 {
633 (void)checkOnline;
634 NodeInfo *info = NULL;
635
636 if (len != LNN_COMMON_LEN) {
637 return SOFTBUS_INVALID_PARAM;
638 }
639 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
640 if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
641 LNN_LOGE(LNN_LEDGER, "node is offline");
642 return SOFTBUS_NETWORK_NODE_OFFLINE;
643 }
644 *((int32_t *)buf) = LnnGetStaFrequency(info);
645 return SOFTBUS_OK;
646 }
647
DlGetNodeDataChangeFlag(const char * networkId,bool checkOnline,void * buf,uint32_t len)648 static int32_t DlGetNodeDataChangeFlag(const char *networkId, bool checkOnline, void *buf, uint32_t len)
649 {
650 (void)checkOnline;
651 NodeInfo *info = NULL;
652
653 if (len != DATA_CHANGE_FLAG_BUF_LEN) {
654 return SOFTBUS_INVALID_PARAM;
655 }
656 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
657 if (!LnnIsNodeOnline(info)) {
658 LNN_LOGE(LNN_LEDGER, "node is offline");
659 return SOFTBUS_NETWORK_NODE_OFFLINE;
660 }
661 *((int16_t *)buf) = (int16_t)LnnGetDataChangeFlag(info);
662 return SOFTBUS_OK;
663 }
664
DlGetNodeTlvNegoFlag(const char * networkId,bool checkOnline,void * buf,uint32_t len)665 static int32_t DlGetNodeTlvNegoFlag(const char *networkId, bool checkOnline, void *buf, uint32_t len)
666 {
667 NodeInfo *info = NULL;
668 if (len != sizeof(bool)) {
669 return SOFTBUS_INVALID_PARAM;
670 }
671 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
672 if (checkOnline && !LnnIsNodeOnline(info) && !IsMetaNode(info)) {
673 LNN_LOGE(LNN_LEDGER, "node is offline");
674 return SOFTBUS_NETWORK_NODE_OFFLINE;
675 }
676 *((bool *)buf) = IsFeatureSupport(info->feature, BIT_WIFI_DIRECT_TLV_NEGOTIATION);
677 return SOFTBUS_OK;
678 }
679
DlGetNodeScreenOnFlag(const char * networkId,bool checkOnline,void * buf,uint32_t len)680 static int32_t DlGetNodeScreenOnFlag(const char *networkId, bool checkOnline, void *buf, uint32_t len)
681 {
682 NodeInfo *info = NULL;
683 if (len != sizeof(bool)) {
684 return SOFTBUS_INVALID_PARAM;
685 }
686 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
687 char *anonyNetworkId = NULL;
688 Anonymize(networkId, &anonyNetworkId);
689 int32_t ret = IsNodeInfoScreenStatusSupport(info);
690 if (ret != SOFTBUS_OK) {
691 LNN_LOGI(LNN_LEDGER, "%{public}s get node screen not support", AnonymizeWrapper(anonyNetworkId));
692 AnonymizeFree(anonyNetworkId);
693 return ret;
694 }
695 if (checkOnline && !LnnIsNodeOnline(info) && !IsMetaNode(info)) {
696 LNN_LOGE(LNN_LEDGER, "%{public}s node is offline", AnonymizeWrapper(anonyNetworkId));
697 AnonymizeFree(anonyNetworkId);
698 return SOFTBUS_NETWORK_NODE_OFFLINE;
699 }
700 AnonymizeFree(anonyNetworkId);
701 *((bool *)buf) = info->isScreenOn;
702 return SOFTBUS_OK;
703 }
704
DlGetAccountHash(const char * networkId,bool checkOnline,void * buf,uint32_t len)705 static int32_t DlGetAccountHash(const char *networkId, bool checkOnline, void *buf, uint32_t len)
706 {
707 (void)checkOnline;
708 NodeInfo *info = NULL;
709 if (len != SHA_256_HASH_LEN) {
710 return SOFTBUS_INVALID_PARAM;
711 }
712 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
713 if (!LnnIsNodeOnline(info)) {
714 LNN_LOGE(LNN_LEDGER, "node is offline");
715 return SOFTBUS_NETWORK_NODE_OFFLINE;
716 }
717 if (memcpy_s(buf, len, info->accountHash, SHA_256_HASH_LEN) != EOK) {
718 LNN_LOGE(LNN_LEDGER, "memcpy account hash fail");
719 return SOFTBUS_MEM_ERR;
720 }
721 return SOFTBUS_OK;
722 }
723
DlGetDeviceIrk(const char * networkId,bool checkOnline,void * buf,uint32_t len)724 static int32_t DlGetDeviceIrk(const char *networkId, bool checkOnline, void *buf, uint32_t len)
725 {
726 (void)checkOnline;
727 NodeInfo *info = NULL;
728 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
729 if (memcpy_s(buf, len, info->rpaInfo.peerIrk, LFINDER_IRK_LEN) != EOK) {
730 LNN_LOGE(LNN_LEDGER, "memcpy peerIrk fail");
731 return SOFTBUS_MEM_ERR;
732 }
733 return SOFTBUS_OK;
734 }
735
DlGetDevicePubMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)736 static int32_t DlGetDevicePubMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
737 {
738 (void)checkOnline;
739 NodeInfo *info = NULL;
740 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
741 if (memcpy_s(buf, len, info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN) != EOK) {
742 LNN_LOGE(LNN_LEDGER, "memcpy publicAddress fail");
743 return SOFTBUS_MEM_ERR;
744 }
745 return SOFTBUS_OK;
746 }
747
DlGetDeviceCipherInfoKey(const char * networkId,bool checkOnline,void * buf,uint32_t len)748 static int32_t DlGetDeviceCipherInfoKey(const char *networkId, bool checkOnline, void *buf, uint32_t len)
749 {
750 (void)checkOnline;
751 NodeInfo *info = NULL;
752 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
753 if (memcpy_s(buf, len, info->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
754 LNN_LOGE(LNN_LEDGER, "memcpy cipher key fail");
755 return SOFTBUS_MEM_ERR;
756 }
757 return SOFTBUS_OK;
758 }
759
DlGetDeviceCipherInfoIv(const char * networkId,bool checkOnline,void * buf,uint32_t len)760 static int32_t DlGetDeviceCipherInfoIv(const char *networkId, bool checkOnline, void *buf, uint32_t len)
761 {
762 (void)checkOnline;
763 NodeInfo *info = NULL;
764 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
765 if (memcpy_s(buf, len, info->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
766 LNN_LOGE(LNN_LEDGER, "memcpy cipher iv fail");
767 return SOFTBUS_MEM_ERR;
768 }
769 return SOFTBUS_OK;
770 }
771
DlGetNodeP2pIp(const char * networkId,bool checkOnline,void * buf,uint32_t len)772 static int32_t DlGetNodeP2pIp(const char *networkId, bool checkOnline, void *buf, uint32_t len)
773 {
774 (void)checkOnline;
775 NodeInfo *info = NULL;
776 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
777 if (strcpy_s((char *)buf, len, info->p2pInfo.p2pIp) != EOK) {
778 LNN_LOGE(LNN_LEDGER, "copy p2pIp to buf fail");
779 return SOFTBUS_MEM_ERR;
780 }
781 return SOFTBUS_OK;
782 }
783
DlGetStaticNetCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)784 static int32_t DlGetStaticNetCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
785 {
786 (void)checkOnline;
787 NodeInfo *info = NULL;
788 if (len != LNN_COMMON_LEN) {
789 return SOFTBUS_INVALID_PARAM;
790 }
791 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
792 *((uint32_t *)buf) = info->staticNetCap;
793 return SOFTBUS_OK;
794 }
795
DlGetSleRangeCapacity(const char * networkId,bool checkOnline,void * buf,uint32_t len)796 static int32_t DlGetSleRangeCapacity(const char *networkId, bool checkOnline, void *buf, uint32_t len)
797 {
798 (void)checkOnline;
799 NodeInfo *info = NULL;
800 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
801 *((int32_t *)buf) = info->sleRangeCapacity;
802 return SOFTBUS_OK;
803 }
804
DlGetUserId(const char * networkId,bool checkOnline,void * buf,uint32_t len)805 static int32_t DlGetUserId(const char *networkId, bool checkOnline, void *buf, uint32_t len)
806 {
807 (void)checkOnline;
808 NodeInfo *info = NULL;
809 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
810 *((int32_t *)buf) = info->userId;
811 return SOFTBUS_OK;
812 }
813
DlGetSleAddr(const char * networkId,bool checkOnline,void * buf,uint32_t len)814 static int32_t DlGetSleAddr(const char *networkId, bool checkOnline, void *buf, uint32_t len)
815 {
816 (void)checkOnline;
817 NodeInfo *info = NULL;
818 RETURN_IF_GET_NODE_VALID(networkId, buf, info);
819 errno_t rc = memcpy_s(buf, len, info->connectInfo.sleMacAddr, MAC_LEN);
820 if (rc != EOK) {
821 LNN_LOGE(LNN_LEDGER, "memcpy_s fail, ret %d", rc);
822 return SOFTBUS_MEM_ERR;
823 }
824 return SOFTBUS_OK;
825 }
826
827 static DistributedLedgerKey g_dlKeyTable[] = {
828 {STRING_KEY_HICE_VERSION, DlGetNodeSoftBusVersion},
829 {STRING_KEY_DEV_UDID, DlGetDeviceUdid},
830 {STRING_KEY_UUID, DlGetDeviceUuid},
831 {STRING_KEY_DEV_TYPE, DlGetDeviceType},
832 {STRING_KEY_DEV_NAME, DlGetDeviceName},
833 {STRING_KEY_BT_MAC, DlGetBtMac},
834 {STRING_KEY_MASTER_NODE_UDID, DlGetMasterUdid},
835 {STRING_KEY_P2P_MAC, DlGetP2pMac},
836 {STRING_KEY_WIFI_CFG, DlGetWifiCfg},
837 {STRING_KEY_CHAN_LIST_5G, DlGetChanList5g},
838 {STRING_KEY_P2P_GO_MAC, DlGetP2pGoMac},
839 {STRING_KEY_NODE_ADDR, DlGetNodeAddr},
840 {STRING_KEY_OFFLINE_CODE, DlGetDeviceOfflineCode},
841 {STRING_KEY_BLE_MAC, DlGetNodeBleMac},
842 {STRING_KEY_WIFIDIRECT_ADDR, DlGetWifiDirectAddr},
843 {STRING_KEY_P2P_IP, DlGetNodeP2pIp},
844 {STRING_KEY_SLE_ADDR, DlGetSleAddr},
845 {NUM_KEY_META_NODE, DlGetAuthType},
846 {NUM_KEY_NET_CAP, DlGetNetCap},
847 {NUM_KEY_FEATURE_CAPA, DlGetFeatureCap},
848 {NUM_KEY_DISCOVERY_TYPE, DlGetNetType},
849 {NUM_KEY_MASTER_NODE_WEIGHT, DlGetMasterWeight},
850 {NUM_KEY_STA_FREQUENCY, DlGetStaFrequency},
851 {NUM_KEY_P2P_ROLE, DlGetP2pRole},
852 {NUM_KEY_STATE_VERSION, DlGetStateVersion},
853 {NUM_KEY_DATA_CHANGE_FLAG, DlGetNodeDataChangeFlag},
854 {NUM_KEY_DEV_TYPE_ID, DlGetDeviceTypeId},
855 {NUM_KEY_STATIC_CAP_LEN, DlGetStaticCapLen},
856 {NUM_KEY_DEVICE_SECURITY_LEVEL, DlGetDeviceSecurityLevel},
857 {NUM_KEY_CONN_SUB_FEATURE_CAPA, DlGetConnSubFeatureCap},
858 {NUM_KEY_STATIC_NET_CAP, DlGetStaticNetCap},
859 {NUM_KEY_SLE_RANGE_CAP, DlGetSleRangeCapacity},
860 {NUM_KEY_USERID, DlGetUserId},
861 {BOOL_KEY_TLV_NEGOTIATION, DlGetNodeTlvNegoFlag},
862 {BOOL_KEY_SCREEN_STATUS, DlGetNodeScreenOnFlag},
863 {BYTE_KEY_ACCOUNT_HASH, DlGetAccountHash},
864 {BYTE_KEY_IRK, DlGetDeviceIrk},
865 {BYTE_KEY_PUB_MAC, DlGetDevicePubMac},
866 {BYTE_KEY_BROADCAST_CIPHER_KEY, DlGetDeviceCipherInfoKey},
867 {BYTE_KEY_BROADCAST_CIPHER_IV, DlGetDeviceCipherInfoIv},
868 {BYTE_KEY_REMOTE_PTK, DlGetRemotePtk},
869 {BYTE_KEY_STATIC_CAPABILITY, DlGetStaticCap}
870 };
871
872 static DistributedLedgerKeyByIfname g_dlKeyByIfnameTable[] = {
873 {STRING_KEY_IP, DlGetWlanIp},
874 {NUM_KEY_SESSION_PORT, DlGetSessionPort},
875 {NUM_KEY_AUTH_PORT, DlGetAuthPort},
876 {NUM_KEY_PROXY_PORT, DlGetProxyPort},
877 };
878
LnnSetDLDeviceInfoName(const char * udid,const char * name)879 bool LnnSetDLDeviceInfoName(const char *udid, const char *name)
880 {
881 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
882 NodeInfo *info = NULL;
883 if (udid == NULL || name == NULL) {
884 LNN_LOGE(LNN_LEDGER, "para error");
885 return false;
886 }
887 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
888 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
889 return false;
890 }
891 info = GetNodeInfoFromMap(map, udid);
892 if (info == NULL) {
893 LNN_LOGE(LNN_LEDGER, "udid not exist");
894 goto EXIT;
895 }
896 if (strcmp(LnnGetDeviceName(&info->deviceInfo), name) == 0) {
897 LNN_LOGI(LNN_LEDGER, "devicename not change");
898 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
899 return true;
900 }
901 if (LnnSetDeviceName(&info->deviceInfo, name) != SOFTBUS_OK) {
902 LNN_LOGE(LNN_LEDGER, "set device name error");
903 goto EXIT;
904 }
905 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
906 return true;
907 EXIT:
908 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
909 return false;
910 }
911
LnnSetDLDeviceNickName(const char * networkId,const char * name)912 bool LnnSetDLDeviceNickName(const char *networkId, const char *name)
913 {
914 NodeInfo *node = NULL;
915 if (networkId == NULL || name == NULL) {
916 LNN_LOGE(LNN_LEDGER, "invalid param");
917 return false;
918 }
919 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
920 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
921 return false;
922 }
923 node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
924 if (node == NULL) {
925 LNN_LOGE(LNN_LEDGER, "networkId not found");
926 goto EXIT;
927 }
928 if (strcpy_s(node->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, name) != EOK) {
929 goto EXIT;
930 }
931 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
932 return true;
933 EXIT:
934 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
935 return false;
936 }
937
LnnSetDLUnifiedDeviceName(const char * udid,const char * name)938 int32_t LnnSetDLUnifiedDeviceName(const char *udid, const char *name)
939 {
940 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
941 NodeInfo *info = NULL;
942 if (udid == NULL || name == NULL) {
943 LNN_LOGE(LNN_LEDGER, "param error");
944 return SOFTBUS_INVALID_PARAM;
945 }
946 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
947 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
948 return SOFTBUS_LOCK_ERR;
949 }
950 info = GetNodeInfoFromMap(map, udid);
951 if (info == NULL) {
952 LNN_LOGE(LNN_LEDGER, "udid not exist");
953 goto EXIT;
954 }
955 if (strcmp(info->deviceInfo.unifiedName, name) == 0) {
956 LNN_LOGI(LNN_LEDGER, "deviceunifiedname not change");
957 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
958 return SOFTBUS_OK;
959 }
960 if (strncpy_s(info->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
961 LNN_LOGE(LNN_LEDGER, "set deviceunifiedname error");
962 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
963 return SOFTBUS_STRCPY_ERR;
964 }
965 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
966 return SOFTBUS_OK;
967 EXIT:
968 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
969 return SOFTBUS_NOT_FIND;
970 }
971
LnnSetDLUnifiedDefaultDeviceName(const char * udid,const char * name)972 int32_t LnnSetDLUnifiedDefaultDeviceName(const char *udid, const char *name)
973 {
974 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
975 NodeInfo *info = NULL;
976 if (udid == NULL || name == NULL) {
977 LNN_LOGE(LNN_LEDGER, "param error");
978 return SOFTBUS_INVALID_PARAM;
979 }
980 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
981 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
982 return SOFTBUS_LOCK_ERR;
983 }
984 info = GetNodeInfoFromMap(map, udid);
985 if (info == NULL) {
986 LNN_LOGE(LNN_LEDGER, "udid not exist");
987 goto EXIT;
988 }
989 if (strcmp(info->deviceInfo.unifiedDefaultName, name) == 0) {
990 LNN_LOGI(LNN_LEDGER, "deviceunifiedDefaultName not change");
991 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
992 return SOFTBUS_OK;
993 }
994 if (strncpy_s(info->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
995 LNN_LOGE(LNN_LEDGER, "set deviceunifiedDefaultName error");
996 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
997 return SOFTBUS_STRCPY_ERR;
998 }
999 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1000 return SOFTBUS_OK;
1001 EXIT:
1002 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1003 return SOFTBUS_NOT_FIND;
1004 }
1005
LnnSetDLDeviceNickNameByUdid(const char * udid,const char * name)1006 int32_t LnnSetDLDeviceNickNameByUdid(const char *udid, const char *name)
1007 {
1008 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
1009 NodeInfo *info = NULL;
1010 if (udid == NULL || name == NULL) {
1011 LNN_LOGE(LNN_LEDGER, "param error");
1012 return SOFTBUS_INVALID_PARAM;
1013 }
1014 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1015 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1016 return SOFTBUS_LOCK_ERR;
1017 }
1018 info = GetNodeInfoFromMap(map, udid);
1019 if (info == NULL) {
1020 LNN_LOGE(LNN_LEDGER, "udid not exist");
1021 goto EXIT;
1022 }
1023 if (strcmp(info->deviceInfo.nickName, name) == 0) {
1024 LNN_LOGI(LNN_LEDGER, "devicenickName not change");
1025 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1026 return SOFTBUS_OK;
1027 }
1028 if (strncpy_s(info->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
1029 LNN_LOGE(LNN_LEDGER, "set devicenickName error");
1030 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1031 return SOFTBUS_STRCPY_ERR;
1032 }
1033 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1034 return SOFTBUS_OK;
1035 EXIT:
1036 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1037 return SOFTBUS_NOT_FIND;
1038 }
1039
LnnSetDLDeviceStateVersion(const char * udid,int32_t stateVersion)1040 int32_t LnnSetDLDeviceStateVersion(const char *udid, int32_t stateVersion)
1041 {
1042 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
1043 NodeInfo *info = NULL;
1044 if (udid == NULL) {
1045 LNN_LOGE(LNN_LEDGER, "param error");
1046 return SOFTBUS_INVALID_PARAM;
1047 }
1048 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1049 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1050 return SOFTBUS_LOCK_ERR;
1051 }
1052 info = GetNodeInfoFromMap(map, udid);
1053 if (info == NULL) {
1054 LNN_LOGE(LNN_LEDGER, "udid not exist");
1055 goto EXIT;
1056 }
1057 if (info->stateVersion == stateVersion) {
1058 LNN_LOGI(LNN_LEDGER, "device stateversion not change");
1059 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1060 return SOFTBUS_OK;
1061 }
1062 info->stateVersion = stateVersion;
1063 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1064 return SOFTBUS_OK;
1065 EXIT:
1066 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1067 return SOFTBUS_NOT_FIND;
1068 }
1069
LnnSetDLDeviceBroadcastCipherKey(const char * udid,const void * cipherKey)1070 int32_t LnnSetDLDeviceBroadcastCipherKey(const char *udid, const void *cipherKey)
1071 {
1072 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
1073 NodeInfo *info = NULL;
1074 if (udid == NULL) {
1075 LNN_LOGE(LNN_LEDGER, "param error");
1076 return SOFTBUS_INVALID_PARAM;
1077 }
1078 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1079 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1080 return SOFTBUS_LOCK_ERR;
1081 }
1082 info = GetNodeInfoFromMap(map, udid);
1083 if (info == NULL) {
1084 LNN_LOGE(LNN_LEDGER, "udid not exist");
1085 goto EXIT;
1086 }
1087 if (memcpy_s((char *)info->cipherInfo.key, SESSION_KEY_LENGTH, cipherKey, SESSION_KEY_LENGTH) != EOK) {
1088 LNN_LOGE(LNN_LEDGER, "set BroadcastcipherKey error");
1089 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1090 return SOFTBUS_MEM_ERR;
1091 }
1092 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1093 return SOFTBUS_OK;
1094 EXIT:
1095 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1096 return SOFTBUS_NOT_FIND;
1097 }
1098
LnnSetDLDeviceBroadcastCipherIv(const char * udid,const void * cipherIv)1099 int32_t LnnSetDLDeviceBroadcastCipherIv(const char *udid, const void *cipherIv)
1100 {
1101 DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
1102 NodeInfo *info = NULL;
1103 if (udid == NULL) {
1104 LNN_LOGE(LNN_LEDGER, "param error");
1105 return SOFTBUS_INVALID_PARAM;
1106 }
1107 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1108 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1109 return SOFTBUS_LOCK_ERR;
1110 }
1111 info = GetNodeInfoFromMap(map, udid);
1112 if (info == NULL) {
1113 LNN_LOGE(LNN_LEDGER, "udid not exist");
1114 goto EXIT;
1115 }
1116 if (memcpy_s((char *)info->cipherInfo.iv, BROADCAST_IV_LEN, cipherIv, BROADCAST_IV_LEN) != EOK) {
1117 LNN_LOGE(LNN_LEDGER, "set BroadcastcipherKey error");
1118 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1119 return SOFTBUS_MEM_ERR;
1120 }
1121 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1122 return SOFTBUS_OK;
1123 EXIT:
1124 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1125 return SOFTBUS_NOT_FIND;
1126 }
1127
LnnSetDLP2pInfo(const char * networkId,const P2pInfo * info)1128 bool LnnSetDLP2pInfo(const char *networkId, const P2pInfo *info)
1129 {
1130 NodeInfo *node = NULL;
1131 if (networkId == NULL || info == NULL) {
1132 LNN_LOGE(LNN_LEDGER, "invalid param");
1133 return false;
1134 }
1135 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1136 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1137 return false;
1138 }
1139 node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1140 if (node == NULL) {
1141 LNN_LOGE(LNN_LEDGER, "udid not found");
1142 goto EXIT;
1143 }
1144 if (LnnSetP2pRole(node, info->p2pRole) != SOFTBUS_OK ||
1145 LnnSetP2pMac(node, info->p2pMac) != SOFTBUS_OK ||
1146 LnnSetP2pGoMac(node, info->goMac) != SOFTBUS_OK) {
1147 LNN_LOGE(LNN_LEDGER, "set p2p info fail");
1148 goto EXIT;
1149 }
1150 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1151 return true;
1152 EXIT:
1153 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1154 return false;
1155 }
1156
LnnSetDlPtk(const char * networkId,const char * remotePtk)1157 bool LnnSetDlPtk(const char *networkId, const char *remotePtk)
1158 {
1159 NodeInfo *node = NULL;
1160 if (networkId == NULL || remotePtk == NULL) {
1161 LNN_LOGE(LNN_LEDGER, "invalid param");
1162 return false;
1163 }
1164 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1165 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1166 return false;
1167 }
1168 node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1169 if (node == NULL) {
1170 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1171 LNN_LOGE(LNN_LEDGER, "get node info fail");
1172 return false;
1173 }
1174 LnnDumpRemotePtk(node->remotePtk, remotePtk, "set remote ptk");
1175 if (LnnSetPtk(node, remotePtk) != SOFTBUS_OK) {
1176 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1177 LNN_LOGE(LNN_LEDGER, "set ptk fail");
1178 return false;
1179 }
1180 char udidHash[SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
1181 if (LnnGenerateHexStringHash(
1182 (const unsigned char *)node->deviceInfo.deviceUdid, udidHash, SHORT_UDID_HASH_HEX_LEN) != SOFTBUS_OK) {
1183 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1184 LNN_LOGE(LNN_LEDGER, "Generate UDID HexStringHash fail");
1185 return false;
1186 }
1187 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1188 NodeInfo cacheInfo;
1189 (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1190 if (LnnRetrieveDeviceInfoPacked(udidHash, &cacheInfo) != SOFTBUS_OK) {
1191 LNN_LOGD(LNN_LEDGER, "no this device info in deviceCacheInfoMap, ignore update");
1192 return true;
1193 }
1194 if (memcmp(cacheInfo.remotePtk, remotePtk, PTK_DEFAULT_LEN) == 0) {
1195 LNN_LOGD(LNN_LEDGER, "ptk is same, ignore update");
1196 return true;
1197 }
1198 if (memcpy_s(cacheInfo.remotePtk, PTK_DEFAULT_LEN, remotePtk, PTK_DEFAULT_LEN) != EOK) {
1199 LNN_LOGE(LNN_LEDGER, "memcpy_s ptk fail");
1200 return true;
1201 }
1202 (void)LnnSaveRemoteDeviceInfoPacked(&cacheInfo);
1203 return true;
1204 }
1205
LnnGetRemoteStrInfo(const char * networkId,InfoKey key,char * info,uint32_t len)1206 int32_t LnnGetRemoteStrInfo(const char *networkId, InfoKey key, char *info, uint32_t len)
1207 {
1208 uint32_t i;
1209 int32_t ret;
1210 if (!IsValidString(networkId, ID_MAX_LEN)) {
1211 return SOFTBUS_INVALID_PARAM;
1212 }
1213 if (info == NULL) {
1214 LNN_LOGE(LNN_LEDGER, "info is null");
1215 return SOFTBUS_INVALID_PARAM;
1216 }
1217 if (key >= STRING_KEY_END) {
1218 LNN_LOGE(LNN_LEDGER, "KEY error");
1219 return SOFTBUS_INVALID_PARAM;
1220 }
1221 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1222 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1223 return SOFTBUS_LOCK_ERR;
1224 }
1225 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1226 if (key == g_dlKeyTable[i].key) {
1227 if (g_dlKeyTable[i].getInfo != NULL) {
1228 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, len);
1229 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1230 return ret;
1231 }
1232 }
1233 }
1234 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1235 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1236 return SOFTBUS_NOT_FIND;
1237 }
1238
LnnGetRemoteStrInfoByIfnameIdx(const char * networkId,InfoKey key,char * info,uint32_t len,int32_t ifIdx)1239 int32_t LnnGetRemoteStrInfoByIfnameIdx(const char *networkId, InfoKey key, char *info, uint32_t len, int32_t ifIdx)
1240 {
1241 uint32_t i;
1242 int32_t ret;
1243 if (!IsValidString(networkId, ID_MAX_LEN)) {
1244 return SOFTBUS_INVALID_PARAM;
1245 }
1246 if (info == NULL) {
1247 LNN_LOGE(LNN_LEDGER, "info is null");
1248 return SOFTBUS_INVALID_PARAM;
1249 }
1250 if (key >= STRING_KEY_END) {
1251 LNN_LOGE(LNN_LEDGER, "KEY error");
1252 return SOFTBUS_INVALID_PARAM;
1253 }
1254 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1255 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1256 return SOFTBUS_LOCK_ERR;
1257 }
1258 for (i = 0; i < sizeof(g_dlKeyByIfnameTable) / sizeof(DistributedLedgerKeyByIfname); i++) {
1259 if (key == g_dlKeyByIfnameTable[i].key) {
1260 if (g_dlKeyByIfnameTable[i].getInfo != NULL) {
1261 ret = g_dlKeyByIfnameTable[i].getInfo(networkId, true, (void *)info, len, ifIdx);
1262 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1263 return ret;
1264 }
1265 }
1266 }
1267 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1268 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1269 return SOFTBUS_NOT_FIND;
1270 }
1271
LnnGetRemoteNumInfo(const char * networkId,InfoKey key,int32_t * info)1272 int32_t LnnGetRemoteNumInfo(const char *networkId, InfoKey key, int32_t *info)
1273 {
1274 uint32_t i;
1275 int32_t ret;
1276 if (!IsValidString(networkId, ID_MAX_LEN)) {
1277 LNN_LOGE(LNN_LEDGER, "networkId is invalid");
1278 return SOFTBUS_INVALID_PARAM;
1279 }
1280 if (info == NULL) {
1281 LNN_LOGE(LNN_LEDGER, "info is null");
1282 return SOFTBUS_INVALID_PARAM;
1283 }
1284 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1285 LNN_LOGE(LNN_LEDGER, "KEY error");
1286 return SOFTBUS_INVALID_PARAM;
1287 }
1288 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1289 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1290 return SOFTBUS_LOCK_ERR;
1291 }
1292 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1293 if (key == g_dlKeyTable[i].key) {
1294 if (g_dlKeyTable[i].getInfo != NULL) {
1295 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN);
1296 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1297 return ret;
1298 }
1299 }
1300 }
1301 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1302 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1303 return SOFTBUS_NOT_FIND;
1304 }
1305
LnnGetRemoteNumInfoByIfnameIdx(const char * networkId,InfoKey key,int32_t * info,int32_t ifIdx)1306 int32_t LnnGetRemoteNumInfoByIfnameIdx(const char *networkId, InfoKey key, int32_t *info, int32_t ifIdx)
1307 {
1308 uint32_t i;
1309 int32_t ret;
1310 if (!IsValidString(networkId, ID_MAX_LEN)) {
1311 LNN_LOGE(LNN_LEDGER, "networkId is invalid");
1312 return SOFTBUS_INVALID_PARAM;
1313 }
1314 if (info == NULL) {
1315 LNN_LOGE(LNN_LEDGER, "info is null");
1316 return SOFTBUS_INVALID_PARAM;
1317 }
1318 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1319 LNN_LOGE(LNN_LEDGER, "KEY error");
1320 return SOFTBUS_INVALID_PARAM;
1321 }
1322 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1323 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1324 return SOFTBUS_LOCK_ERR;
1325 }
1326 for (i = 0; i < sizeof(g_dlKeyByIfnameTable) / sizeof(DistributedLedgerKeyByIfname); i++) {
1327 if (key == g_dlKeyByIfnameTable[i].key) {
1328 if (g_dlKeyByIfnameTable[i].getInfo != NULL) {
1329 ret = g_dlKeyByIfnameTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN, ifIdx);
1330 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1331 return ret;
1332 }
1333 }
1334 }
1335 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1336 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1337 return SOFTBUS_NOT_FIND;
1338 }
1339
LnnGetRemoteNumU32Info(const char * networkId,InfoKey key,uint32_t * info)1340 int32_t LnnGetRemoteNumU32Info(const char *networkId, InfoKey key, uint32_t *info)
1341 {
1342 uint32_t i;
1343 int32_t ret;
1344 if (!IsValidString(networkId, ID_MAX_LEN)) {
1345 LNN_LOGE(LNN_LEDGER, "networkId is invalid");
1346 return SOFTBUS_INVALID_PARAM;
1347 }
1348 if (info == NULL) {
1349 LNN_LOGE(LNN_LEDGER, "info is null");
1350 return SOFTBUS_INVALID_PARAM;
1351 }
1352 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1353 LNN_LOGE(LNN_LEDGER, "KEY error");
1354 return SOFTBUS_INVALID_PARAM;
1355 }
1356 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1357 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1358 return SOFTBUS_LOCK_ERR;
1359 }
1360 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1361 if (key == g_dlKeyTable[i].key) {
1362 if (g_dlKeyTable[i].getInfo != NULL) {
1363 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN);
1364 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1365 return ret;
1366 }
1367 }
1368 }
1369 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1370 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1371 return SOFTBUS_NOT_FIND;
1372 }
1373
LnnGetRemoteNumU64Info(const char * networkId,InfoKey key,uint64_t * info)1374 int32_t LnnGetRemoteNumU64Info(const char *networkId, InfoKey key, uint64_t *info)
1375 {
1376 uint32_t i;
1377 int32_t ret;
1378 if (!IsValidString(networkId, ID_MAX_LEN)) {
1379 return SOFTBUS_INVALID_PARAM;
1380 }
1381 if (info == NULL) {
1382 LNN_LOGE(LNN_LEDGER, "info is null");
1383 return SOFTBUS_INVALID_PARAM;
1384 }
1385 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1386 LNN_LOGE(LNN_LEDGER, "KEY error");
1387 return SOFTBUS_INVALID_PARAM;
1388 }
1389 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1390 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1391 return SOFTBUS_LOCK_ERR;
1392 }
1393 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1394 if (key == g_dlKeyTable[i].key) {
1395 if (g_dlKeyTable[i].getInfo != NULL) {
1396 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN_64);
1397 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1398 return ret;
1399 }
1400 }
1401 }
1402 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1403 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1404 return SOFTBUS_NOT_FIND;
1405 }
1406
LnnGetRemoteNum16Info(const char * networkId,InfoKey key,int16_t * info)1407 int32_t LnnGetRemoteNum16Info(const char *networkId, InfoKey key, int16_t *info)
1408 {
1409 uint32_t i;
1410 int32_t ret;
1411 if (!IsValidString(networkId, ID_MAX_LEN)) {
1412 return SOFTBUS_INVALID_PARAM;
1413 }
1414 if (info == NULL) {
1415 LNN_LOGE(LNN_LEDGER, "info is null");
1416 return SOFTBUS_INVALID_PARAM;
1417 }
1418 if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1419 LNN_LOGE(LNN_LEDGER, "KEY error");
1420 return SOFTBUS_INVALID_PARAM;
1421 }
1422 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1423 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1424 return SOFTBUS_LOCK_ERR;
1425 }
1426 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1427 if (key == g_dlKeyTable[i].key) {
1428 if (g_dlKeyTable[i].getInfo != NULL) {
1429 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, sizeof(int16_t));
1430 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1431 return ret;
1432 }
1433 }
1434 }
1435 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1436 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1437 return SOFTBUS_NOT_FIND;
1438 }
1439
LnnGetRemoteBoolInfoCommon(const char * networkId,bool checkOnline,InfoKey key,bool * info)1440 static int32_t LnnGetRemoteBoolInfoCommon(const char *networkId, bool checkOnline, InfoKey key, bool *info)
1441 {
1442 uint32_t i;
1443 int32_t ret;
1444 if (!IsValidString(networkId, ID_MAX_LEN)) {
1445 return SOFTBUS_INVALID_PARAM;
1446 }
1447 if (info == NULL) {
1448 LNN_LOGE(LNN_LEDGER, "info is null");
1449 return SOFTBUS_INVALID_PARAM;
1450 }
1451 if (key < BOOL_KEY_BEGIN || key >= BOOL_KEY_END) {
1452 LNN_LOGE(LNN_LEDGER, "KEY error");
1453 return SOFTBUS_INVALID_PARAM;
1454 }
1455 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1456 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1457 return SOFTBUS_LOCK_ERR;
1458 }
1459 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1460 if (key == g_dlKeyTable[i].key) {
1461 if (g_dlKeyTable[i].getInfo != NULL) {
1462 ret = g_dlKeyTable[i].getInfo(networkId, checkOnline, (void *)info, sizeof(bool));
1463 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1464 return ret;
1465 }
1466 }
1467 }
1468 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1469 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1470 return SOFTBUS_NOT_FIND;
1471 }
1472
LnnGetRemoteBoolInfo(const char * networkId,InfoKey key,bool * info)1473 int32_t LnnGetRemoteBoolInfo(const char *networkId, InfoKey key, bool *info)
1474 {
1475 return LnnGetRemoteBoolInfoCommon(networkId, true, key, info);
1476 }
1477
LnnGetRemoteBoolInfoIgnoreOnline(const char * networkId,InfoKey key,bool * info)1478 int32_t LnnGetRemoteBoolInfoIgnoreOnline(const char *networkId, InfoKey key, bool *info)
1479 {
1480 return LnnGetRemoteBoolInfoCommon(networkId, false, key, info);
1481 }
1482
LnnGetRemoteByteInfo(const char * networkId,InfoKey key,uint8_t * info,uint32_t len)1483 int32_t LnnGetRemoteByteInfo(const char *networkId, InfoKey key, uint8_t *info, uint32_t len)
1484 {
1485 uint32_t i;
1486 int32_t ret;
1487 if (!IsValidString(networkId, ID_MAX_LEN) || info == NULL) {
1488 LNN_LOGE(LNN_LEDGER, "para error.");
1489 return SOFTBUS_INVALID_PARAM;
1490 }
1491 if (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END) {
1492 LNN_LOGE(LNN_LEDGER, "KEY error.");
1493 return SOFTBUS_INVALID_PARAM;
1494 }
1495 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1496 LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1497 return SOFTBUS_LOCK_ERR;
1498 }
1499 for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1500 if (key == g_dlKeyTable[i].key) {
1501 if (g_dlKeyTable[i].getInfo != NULL) {
1502 ret = g_dlKeyTable[i].getInfo(networkId, true, info, len);
1503 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1504 return ret;
1505 }
1506 }
1507 }
1508 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1509 LNN_LOGE(LNN_LEDGER, "KEY NOT exist.");
1510 return SOFTBUS_NOT_FIND;
1511 }
1512
LnnGetNetworkIdByBtMac(const char * btMac,char * buf,uint32_t len)1513 int32_t LnnGetNetworkIdByBtMac(const char *btMac, char *buf, uint32_t len)
1514 {
1515 if (btMac == NULL || btMac[0] == '\0' || buf == NULL) {
1516 LNN_LOGE(LNN_LEDGER, "btMac is empty");
1517 return SOFTBUS_INVALID_PARAM;
1518 }
1519 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1520 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1521 return SOFTBUS_LOCK_ERR;
1522 }
1523 MapIterator *it = LnnMapInitIterator(&(LnnGetDistributedNetLedger()->distributedInfo.udidMap));
1524 if (it == NULL) {
1525 LNN_LOGE(LNN_LEDGER, "it is null");
1526 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1527 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
1528 }
1529 while (LnnMapHasNext(it)) {
1530 it = LnnMapNext(it);
1531 if (it == NULL) {
1532 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1533 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
1534 }
1535 NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
1536 if ((LnnIsNodeOnline(nodeInfo) || nodeInfo->metaInfo.isMetaNode) &&
1537 StrCmpIgnoreCase(nodeInfo->connectInfo.macAddr, btMac) == 0) {
1538 if (strcpy_s(buf, len, nodeInfo->networkId) != EOK) {
1539 LNN_LOGE(LNN_LEDGER, "strcpy_s networkId fail");
1540 LnnMapDeinitIterator(it);
1541 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1542 return SOFTBUS_MEM_ERR;
1543 }
1544 LnnMapDeinitIterator(it);
1545 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1546 return SOFTBUS_OK;
1547 }
1548 }
1549 LnnMapDeinitIterator(it);
1550 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1551 return SOFTBUS_NOT_FIND;
1552 }
1553
LnnGetNetworkIdByUdidHash(const uint8_t * udidHash,uint32_t udidHashLen,char * buf,uint32_t len,bool needOnline)1554 int32_t LnnGetNetworkIdByUdidHash(const uint8_t *udidHash, uint32_t udidHashLen, char *buf, uint32_t len,
1555 bool needOnline)
1556 {
1557 if (udidHash == NULL || buf == NULL || udidHashLen == 0) {
1558 LNN_LOGE(LNN_LEDGER, "udidHash is empty");
1559 return SOFTBUS_INVALID_PARAM;
1560 }
1561 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1562 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1563 return SOFTBUS_LOCK_ERR;
1564 }
1565 MapIterator *it = LnnMapInitIterator(&(LnnGetDistributedNetLedger()->distributedInfo.udidMap));
1566 if (it == NULL) {
1567 LNN_LOGE(LNN_LEDGER, "it is null");
1568 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1569 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
1570 }
1571 uint8_t nodeUdidHash[SHA_256_HASH_LEN] = {0};
1572 while (LnnMapHasNext(it)) {
1573 it = LnnMapNext(it);
1574 if (it == NULL) {
1575 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1576 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
1577 }
1578 NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
1579 if (!needOnline || LnnIsNodeOnline(nodeInfo) || nodeInfo->metaInfo.isMetaNode) {
1580 if (SoftBusGenerateStrHash((uint8_t*)nodeInfo->deviceInfo.deviceUdid,
1581 strlen(nodeInfo->deviceInfo.deviceUdid), nodeUdidHash) != SOFTBUS_OK) {
1582 continue;
1583 }
1584 if (memcmp(nodeUdidHash, udidHash, SHA_256_HASH_LEN) != 0) {
1585 continue;
1586 }
1587 if (strcpy_s(buf, len, nodeInfo->networkId) != EOK) {
1588 LNN_LOGE(LNN_LEDGER, "strcpy_s networkId fail");
1589 LnnMapDeinitIterator(it);
1590 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1591 return SOFTBUS_MEM_ERR;
1592 }
1593 LnnMapDeinitIterator(it);
1594 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1595 return SOFTBUS_OK;
1596 }
1597 }
1598 LnnMapDeinitIterator(it);
1599 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1600 return SOFTBUS_NOT_FIND;
1601 }
1602
LnnGetConnSubFeatureByUdidHashStr(const char * udidHashStr,uint64_t * connSubFeature)1603 int32_t LnnGetConnSubFeatureByUdidHashStr(const char *udidHashStr, uint64_t *connSubFeature)
1604 {
1605 if (udidHashStr == NULL || udidHashStr[0] == '\0' || connSubFeature == NULL) {
1606 LNN_LOGE(LNN_LEDGER, "para is empty");
1607 return SOFTBUS_INVALID_PARAM;
1608 }
1609 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1610 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1611 return SOFTBUS_LOCK_ERR;
1612 }
1613 MapIterator *it = LnnMapInitIterator(&(LnnGetDistributedNetLedger()->distributedInfo.udidMap));
1614 if (it == NULL) {
1615 LNN_LOGE(LNN_LEDGER, "it is null");
1616 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1617 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
1618 }
1619 unsigned char shortUdidHashStr[SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1620 while (LnnMapHasNext(it)) {
1621 it = LnnMapNext(it);
1622 if (it == NULL) {
1623 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1624 return SOFTBUS_NETWORK_MAP_INIT_FAILED;
1625 }
1626 NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
1627 if (LnnIsNodeOnline(nodeInfo)) {
1628 if (GenerateStrHashAndConvertToHexString((const unsigned char *)nodeInfo->deviceInfo.deviceUdid,
1629 SHORT_UDID_HASH_HEX_LEN, shortUdidHashStr, SHORT_UDID_HASH_HEX_LEN + 1) != SOFTBUS_OK) {
1630 continue;
1631 }
1632 if (memcmp(shortUdidHashStr, udidHashStr, SHORT_UDID_HASH_HEX_LEN) != 0) {
1633 continue;
1634 }
1635 *connSubFeature = nodeInfo->connSubFeature;
1636 LnnMapDeinitIterator(it);
1637 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1638 return SOFTBUS_OK;
1639 }
1640 }
1641 LnnMapDeinitIterator(it);
1642 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1643 return SOFTBUS_NOT_FIND;
1644 }
1645
LnnGetNetworkIdByUuid(const char * uuid,char * buf,uint32_t len)1646 int32_t LnnGetNetworkIdByUuid(const char *uuid, char *buf, uint32_t len)
1647 {
1648 if (!IsValidString(uuid, ID_MAX_LEN)) {
1649 LNN_LOGE(LNN_LEDGER, "uuid is invalid");
1650 return SOFTBUS_INVALID_PARAM;
1651 }
1652
1653 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1654 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1655 return SOFTBUS_LOCK_ERR;
1656 }
1657 NodeInfo *nodeInfo = LnnGetNodeInfoById(uuid, CATEGORY_UUID);
1658 if (nodeInfo == NULL) {
1659 LNN_LOGE(LNN_LEDGER, "get info fail");
1660 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1661 return SOFTBUS_NOT_FIND;
1662 }
1663 if (strncpy_s(buf, len, nodeInfo->networkId, strlen(nodeInfo->networkId)) != EOK) {
1664 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1665 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1666 return SOFTBUS_MEM_ERR;
1667 }
1668 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1669 return SOFTBUS_OK;
1670 }
1671
LnnGetNetworkIdByUdid(const char * udid,char * buf,uint32_t len)1672 int32_t LnnGetNetworkIdByUdid(const char *udid, char *buf, uint32_t len)
1673 {
1674 if (!IsValidString(udid, ID_MAX_LEN)) {
1675 LNN_LOGE(LNN_LEDGER, "udid is invalid");
1676 return SOFTBUS_INVALID_PARAM;
1677 }
1678
1679 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1680 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1681 return SOFTBUS_LOCK_ERR;
1682 }
1683 NodeInfo *nodeInfo = LnnGetNodeInfoById(udid, CATEGORY_UDID);
1684 if (nodeInfo == NULL) {
1685 LNN_LOGE(LNN_LEDGER, "get info fail");
1686 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1687 return SOFTBUS_NOT_FIND;
1688 }
1689 if (strncpy_s(buf, len, nodeInfo->networkId, strlen(nodeInfo->networkId)) != EOK) {
1690 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1691 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1692 return SOFTBUS_MEM_ERR;
1693 }
1694 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1695 return SOFTBUS_OK;
1696 }
1697
LnnGetDLOnlineTimestamp(const char * networkId,uint64_t * timestamp)1698 int32_t LnnGetDLOnlineTimestamp(const char *networkId, uint64_t *timestamp)
1699 {
1700 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1701 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1702 return SOFTBUS_LOCK_ERR;
1703 }
1704 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1705 if (nodeInfo == NULL) {
1706 LNN_LOGE(LNN_LEDGER, "get info fail");
1707 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1708 return SOFTBUS_NOT_FIND;
1709 }
1710 *timestamp = nodeInfo->onlineTimestamp;
1711 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1712 return SOFTBUS_OK;
1713 }
1714
LnnGetDLHeartbeatTimestamp(const char * networkId,uint64_t * timestamp)1715 int32_t LnnGetDLHeartbeatTimestamp(const char *networkId, uint64_t *timestamp)
1716 {
1717 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1718 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1719 return SOFTBUS_LOCK_ERR;
1720 }
1721 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1722 if (nodeInfo == NULL) {
1723 LNN_LOGE(LNN_LEDGER, "get info fail");
1724 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1725 return SOFTBUS_NOT_FIND;
1726 }
1727 *timestamp = nodeInfo->heartbeatTimestamp;
1728 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1729 return SOFTBUS_OK;
1730 }
1731
LnnSetDLHeartbeatTimestamp(const char * networkId,uint64_t timestamp)1732 int32_t LnnSetDLHeartbeatTimestamp(const char *networkId, uint64_t timestamp)
1733 {
1734 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1735 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1736 return SOFTBUS_LOCK_ERR;
1737 }
1738 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1739 if (nodeInfo == NULL) {
1740 LNN_LOGE(LNN_LEDGER, "get info fail");
1741 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1742 return SOFTBUS_NOT_FIND;
1743 }
1744 nodeInfo->heartbeatTimestamp = timestamp;
1745 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1746 return SOFTBUS_OK;
1747 }
1748
LnnSetDLSleHbTimestamp(const char * networkId,const uint64_t timestamp)1749 int32_t LnnSetDLSleHbTimestamp(const char *networkId, const uint64_t timestamp)
1750 {
1751 LNN_CHECK_AND_RETURN_RET_LOGE(networkId != NULL, SOFTBUS_INVALID_PARAM, LNN_LEDGER, "invalid param");
1752 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1753 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1754 return SOFTBUS_LOCK_ERR;
1755 }
1756 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1757 if (nodeInfo == NULL) {
1758 LNN_LOGE(LNN_LEDGER, "get info fail");
1759 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1760 return SOFTBUS_NOT_FIND;
1761 }
1762 nodeInfo->sleHbTiemstamp = timestamp;
1763 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1764 return SOFTBUS_OK;
1765 }
1766
LnnGetDLSleHbTimestamp(const char * networkId,uint64_t * timestamp)1767 int32_t LnnGetDLSleHbTimestamp(const char *networkId, uint64_t *timestamp)
1768 {
1769 if (networkId == NULL || timestamp == NULL) {
1770 LNN_LOGE(LNN_LEDGER, "invalid param");
1771 return SOFTBUS_INVALID_PARAM;
1772 }
1773 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1774 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1775 return SOFTBUS_LOCK_ERR;
1776 }
1777 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1778 if (nodeInfo == NULL) {
1779 LNN_LOGE(LNN_LEDGER, "get info fail");
1780 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1781 return SOFTBUS_NOT_FIND;
1782 }
1783 *timestamp = nodeInfo->sleHbTiemstamp;
1784 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1785 return SOFTBUS_OK;
1786 }
1787
LnnGetDLBleDirectTimestamp(const char * networkId,uint64_t * timestamp)1788 int32_t LnnGetDLBleDirectTimestamp(const char *networkId, uint64_t *timestamp)
1789 {
1790 if (networkId == NULL || timestamp == NULL) {
1791 LNN_LOGE(LNN_LEDGER, "invalid param");
1792 return SOFTBUS_INVALID_PARAM;
1793 }
1794 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1795 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1796 return SOFTBUS_LOCK_ERR;
1797 }
1798 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1799 if (nodeInfo == NULL) {
1800 LNN_LOGE(LNN_LEDGER, "get info fail");
1801 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1802 return SOFTBUS_NOT_FIND;
1803 }
1804 *timestamp = nodeInfo->bleDirectTimestamp;
1805 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1806 return SOFTBUS_OK;
1807 }
1808
LnnGetDLUpdateTimestamp(const char * udid,uint64_t * timestamp)1809 int32_t LnnGetDLUpdateTimestamp(const char *udid, uint64_t *timestamp)
1810 {
1811 if (udid == NULL || timestamp == NULL) {
1812 LNN_LOGE(LNN_LEDGER, "invalid param");
1813 return SOFTBUS_INVALID_PARAM;
1814 }
1815 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1816 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1817 return SOFTBUS_LOCK_ERR;
1818 }
1819 NodeInfo *nodeInfo = LnnGetNodeInfoById(udid, CATEGORY_UDID);
1820 if (nodeInfo == NULL) {
1821 LNN_LOGE(LNN_LEDGER, "get info fail");
1822 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1823 return SOFTBUS_NOT_FIND;
1824 }
1825 *timestamp = nodeInfo->updateTimestamp;
1826 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1827 return SOFTBUS_OK;
1828 }
1829
LnnGetDLAuthCapacity(const char * networkId,uint32_t * authCapacity)1830 int32_t LnnGetDLAuthCapacity(const char *networkId, uint32_t *authCapacity)
1831 {
1832 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1833 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1834 return SOFTBUS_LOCK_ERR;
1835 }
1836 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1837 if (nodeInfo == NULL) {
1838 LNN_LOGE(LNN_LEDGER, "get info fail");
1839 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1840 return SOFTBUS_NOT_FIND;
1841 }
1842 *authCapacity = nodeInfo->authCapacity;
1843 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1844 return SOFTBUS_OK;
1845 }
1846
LnnSetDLBleDirectTimestamp(const char * networkId,uint64_t timestamp)1847 int32_t LnnSetDLBleDirectTimestamp(const char *networkId, uint64_t timestamp)
1848 {
1849 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1850 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1851 return SOFTBUS_LOCK_ERR;
1852 }
1853 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1854 if (nodeInfo == NULL) {
1855 LNN_LOGE(LNN_LEDGER, "get info fail");
1856 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1857 return SOFTBUS_NOT_FIND;
1858 }
1859 nodeInfo->bleDirectTimestamp = timestamp;
1860 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1861 return SOFTBUS_OK;
1862 }
1863
LnnSetDLConnCapability(const char * networkId,uint32_t connCapability)1864 int32_t LnnSetDLConnCapability(const char *networkId, uint32_t connCapability)
1865 {
1866 NodeInfo recoveryInfo;
1867 (void)memset_s(&recoveryInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1868 NodeInfo tempNodeInfo;
1869 (void)memset_s(&tempNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1870 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1871 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1872 return SOFTBUS_LOCK_ERR;
1873 }
1874 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1875 if (nodeInfo == NULL) {
1876 LNN_LOGE(LNN_LEDGER, "get info fail");
1877 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1878 return SOFTBUS_NOT_FIND;
1879 }
1880 nodeInfo->netCapacity = connCapability;
1881 if (memcpy_s(&tempNodeInfo, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
1882 LNN_LOGE(LNN_LEDGER, "memcpy_s fail");
1883 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1884 return SOFTBUS_MEM_ERR;
1885 }
1886 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1887 int32_t ret = LnnRetrieveDeviceInfoByUdidPacked(tempNodeInfo.deviceInfo.deviceUdid, &recoveryInfo);
1888 if (ret != SOFTBUS_OK) {
1889 LNN_LOGE(LNN_LEDGER, "retrive device info fail, ret=%{public}d", ret);
1890 if (LnnSaveRemoteDeviceInfoPacked(&tempNodeInfo) != SOFTBUS_OK) {
1891 LNN_LOGE(LNN_LEDGER, "save remote info fail");
1892 }
1893 return ret;
1894 }
1895 recoveryInfo.netCapacity = connCapability;
1896 ret = LnnSaveRemoteDeviceInfoPacked(&recoveryInfo);
1897 if (ret != SOFTBUS_OK) {
1898 LNN_LOGE(LNN_LEDGER, "save remote device info fail, ret=%{public}d", ret);
1899 return ret;
1900 }
1901 return SOFTBUS_OK;
1902 }
1903
LnnSetDLConnUserIdCheckSum(const char * networkId,int32_t userIdCheckSum)1904 int32_t LnnSetDLConnUserIdCheckSum(const char *networkId, int32_t userIdCheckSum)
1905 {
1906 if (networkId == NULL) {
1907 return SOFTBUS_INVALID_PARAM;
1908 }
1909
1910 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1911 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1912 return SOFTBUS_LOCK_ERR;
1913 }
1914 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1915 if (nodeInfo == NULL) {
1916 LNN_LOGE(LNN_LEDGER, "get info fail");
1917 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1918 return SOFTBUS_NOT_FIND;
1919 }
1920 int32_t ret = memcpy_s(nodeInfo->userIdCheckSum, USERID_CHECKSUM_LEN, &userIdCheckSum, sizeof(int32_t));
1921 if (ret != EOK) {
1922 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1923 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1924 return ret;
1925 }
1926 ret = LnnSaveRemoteDeviceInfoPacked(nodeInfo);
1927 if (ret != SOFTBUS_OK) {
1928 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1929 LNN_LOGE(LNN_LEDGER, "save remote useridchecksum faile");
1930 return ret;
1931 }
1932 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1933 return SOFTBUS_OK;
1934 }
1935
LnnSetDLConnUserId(const char * networkId,int32_t userId)1936 int32_t LnnSetDLConnUserId(const char *networkId, int32_t userId)
1937 {
1938 if (networkId == NULL) {
1939 return SOFTBUS_INVALID_PARAM;
1940 }
1941 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1942 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1943 return SOFTBUS_LOCK_ERR;
1944 }
1945 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1946 if (nodeInfo == NULL) {
1947 LNN_LOGE(LNN_LEDGER, "get info fail");
1948 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1949 return SOFTBUS_NOT_FIND;
1950 }
1951 nodeInfo->userId = userId;
1952 int32_t ret = LnnSaveRemoteDeviceInfoPacked(nodeInfo);
1953 if (ret != SOFTBUS_OK) {
1954 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1955 LNN_LOGE(LNN_LEDGER, "save remote userid faile");
1956 return ret;
1957 }
1958 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1959 return SOFTBUS_OK;
1960 }
1961
LnnSetDLBatteryInfo(const char * networkId,const BatteryInfo * info)1962 int32_t LnnSetDLBatteryInfo(const char *networkId, const BatteryInfo *info)
1963 {
1964 if (networkId == NULL || info == NULL) {
1965 return SOFTBUS_INVALID_PARAM;
1966 }
1967 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1968 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1969 return SOFTBUS_LOCK_ERR;
1970 }
1971 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1972 if (nodeInfo == NULL) {
1973 LNN_LOGE(LNN_LEDGER, "get info fail");
1974 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1975 return SOFTBUS_NOT_FIND;
1976 }
1977 nodeInfo->batteryInfo.batteryLevel = info->batteryLevel;
1978 nodeInfo->batteryInfo.isCharging = info->isCharging;
1979 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1980 return SOFTBUS_OK;
1981 }
1982
LnnSetDLBssTransInfo(const char * networkId,const BssTransInfo * info)1983 int32_t LnnSetDLBssTransInfo(const char *networkId, const BssTransInfo *info)
1984 {
1985 if (networkId == NULL || info == NULL) {
1986 return SOFTBUS_INVALID_PARAM;
1987 }
1988 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1989 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1990 return SOFTBUS_LOCK_ERR;
1991 }
1992 NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1993 if (nodeInfo == NULL) {
1994 LNN_LOGE(LNN_LEDGER, "get info fail");
1995 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1996 return SOFTBUS_NOT_FIND;
1997 }
1998 if (memcpy_s(&(nodeInfo->bssTransInfo), sizeof(BssTransInfo), info,
1999 sizeof(BssTransInfo)) != SOFTBUS_OK) {
2000 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2001 return SOFTBUS_MEM_ERR;
2002 }
2003 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2004 return SOFTBUS_OK;
2005 }
2006
LnnSetDLNodeAddr(const char * id,IdCategory type,const char * addr)2007 int32_t LnnSetDLNodeAddr(const char *id, IdCategory type, const char *addr)
2008 {
2009 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2010 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2011 return SOFTBUS_LOCK_ERR;
2012 }
2013 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2014 if (nodeInfo == NULL) {
2015 LNN_LOGE(LNN_LEDGER, "get info fail");
2016 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2017 return SOFTBUS_NOT_FIND;
2018 }
2019 int ret = strcpy_s(nodeInfo->nodeAddress, sizeof(nodeInfo->nodeAddress), addr);
2020 if (ret != EOK) {
2021 LNN_LOGE(LNN_LEDGER, "set node addr failed! ret=%{public}d", ret);
2022 }
2023 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2024 return ret == EOK ? SOFTBUS_OK : SOFTBUS_STRCPY_ERR;
2025 }
2026
LnnSetDLProxyPort(const char * id,IdCategory type,int32_t proxyPort)2027 int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort)
2028 {
2029 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2030 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2031 return SOFTBUS_LOCK_ERR;
2032 }
2033 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2034 if (nodeInfo == NULL) {
2035 LNN_LOGE(LNN_LEDGER, "get info fail");
2036 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2037 return SOFTBUS_NOT_FIND;
2038 }
2039 nodeInfo->connectInfo.ifInfo[WLAN_IF].proxyPort = proxyPort;
2040 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2041 return SOFTBUS_OK;
2042 }
2043
LnnSetDLSessionPort(const char * id,IdCategory type,int32_t sessionPort)2044 int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort)
2045 {
2046 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2047 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2048 return SOFTBUS_LOCK_ERR;
2049 }
2050 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2051 if (nodeInfo == NULL) {
2052 LNN_LOGE(LNN_LEDGER, "get info fail");
2053 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2054 return SOFTBUS_NOT_FIND;
2055 }
2056 nodeInfo->connectInfo.ifInfo[WLAN_IF].sessionPort = sessionPort;
2057 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2058 return SOFTBUS_OK;
2059 }
2060
LnnSetDLAuthPort(const char * id,IdCategory type,int32_t authPort)2061 int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort)
2062 {
2063 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2064 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2065 return SOFTBUS_LOCK_ERR;
2066 }
2067 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2068 if (nodeInfo == NULL) {
2069 LNN_LOGE(LNN_LEDGER, "get info fail");
2070 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2071 return SOFTBUS_NOT_FIND;
2072 }
2073 nodeInfo->connectInfo.ifInfo[WLAN_IF].authPort = authPort;
2074 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2075 return SOFTBUS_OK;
2076 }
2077
LnnSetDLP2pIp(const char * id,IdCategory type,const char * p2pIp)2078 int32_t LnnSetDLP2pIp(const char *id, IdCategory type, const char *p2pIp)
2079 {
2080 if (id == NULL || p2pIp == NULL) {
2081 LNN_LOGE(LNN_LEDGER, "invalid param");
2082 return SOFTBUS_INVALID_PARAM;
2083 }
2084 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2085 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2086 return SOFTBUS_LOCK_ERR;
2087 }
2088 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2089 if (nodeInfo == NULL) {
2090 LNN_LOGE(LNN_LEDGER, "get info fail");
2091 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2092 return SOFTBUS_NOT_FIND;
2093 }
2094 if (strcpy_s(nodeInfo->p2pInfo.p2pIp, sizeof(nodeInfo->p2pInfo.p2pIp), p2pIp) != EOK) {
2095 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
2096 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2097 return SOFTBUS_MEM_ERR;
2098 }
2099 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2100 return SOFTBUS_OK;
2101 }
2102
LnnSetDLWifiDirectAddr(const char * networkId,const char * addr)2103 bool LnnSetDLWifiDirectAddr(const char *networkId, const char *addr)
2104 {
2105 NodeInfo *node = NULL;
2106 if (networkId == NULL || addr == NULL) {
2107 LNN_LOGE(LNN_LEDGER, "invalid param");
2108 return false;
2109 }
2110 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2111 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2112 return false;
2113 }
2114 node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
2115 if (node == NULL) {
2116 LNN_LOGE(LNN_LEDGER, "udid not found");
2117 goto EXIT;
2118 }
2119 if (LnnSetWifiDirectAddr(node, addr) != SOFTBUS_OK) {
2120 LNN_LOGE(LNN_LEDGER, "set wifidirect addr fail");
2121 goto EXIT;
2122 }
2123 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2124 return true;
2125 EXIT:
2126 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2127 return false;
2128 }
2129
LnnSaveBroadcastLinkKey(const char * udid,const BroadcastCipherInfo * info)2130 bool LnnSaveBroadcastLinkKey(const char *udid, const BroadcastCipherInfo *info)
2131 {
2132 if (udid == NULL || info == NULL) {
2133 LNN_LOGE(LNN_LEDGER, "invalid param");
2134 return false;
2135 }
2136 char udidHash[SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
2137 if (LnnGenerateHexStringHash((const unsigned char *)udid, udidHash, SHORT_UDID_HASH_HEX_LEN) != SOFTBUS_OK) {
2138 LNN_LOGE(LNN_LEDGER, "generate udid hex string hash fail");
2139 return false;
2140 }
2141 NodeInfo cacheInfo;
2142 (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
2143 if (LnnRetrieveDeviceInfoPacked(udidHash, &cacheInfo) != SOFTBUS_OK) {
2144 LNN_LOGI(LNN_LEDGER, "no this device info, ignore update");
2145 return true;
2146 }
2147 if (memcmp(cacheInfo.cipherInfo.key, info->key, SESSION_KEY_LENGTH) == 0 &&
2148 memcmp(cacheInfo.cipherInfo.iv, info->iv, BROADCAST_IV_LEN) == 0) {
2149 LNN_LOGI(LNN_LEDGER, "remote link key same, ignore update");
2150 return true;
2151 }
2152 if (memcpy_s(cacheInfo.cipherInfo.key, SESSION_KEY_LENGTH, info->key, SESSION_KEY_LENGTH) != EOK ||
2153 memcpy_s(cacheInfo.cipherInfo.iv, BROADCAST_IV_LEN, info->iv, BROADCAST_IV_LEN) != EOK) {
2154 LNN_LOGE(LNN_LEDGER, "copy link key failed");
2155 return false;
2156 }
2157 (void)LnnSaveRemoteDeviceInfoPacked(&cacheInfo);
2158 return true;
2159 }
2160
LnnSetDLSleRangeInfo(const char * id,IdCategory type,int32_t sleCap,const char * addr)2161 int32_t LnnSetDLSleRangeInfo(const char *id, IdCategory type, int32_t sleCap, const char *addr)
2162 {
2163 if (id == NULL || addr == NULL) {
2164 LNN_LOGE(LNN_LEDGER, "inavalid param");
2165 return SOFTBUS_INVALID_PARAM;
2166 }
2167 if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
2168 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2169 return SOFTBUS_LOCK_ERR;
2170 }
2171 NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
2172 if (nodeInfo == NULL) {
2173 LNN_LOGE(LNN_LEDGER, "get info fail");
2174 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2175 return SOFTBUS_NOT_FIND;
2176 }
2177 nodeInfo->sleRangeCapacity = sleCap;
2178 int32_t ret = strcpy_s(nodeInfo->connectInfo.sleMacAddr, sizeof(nodeInfo->connectInfo.sleMacAddr), addr);
2179 if (ret != EOK) {
2180 LNN_LOGE(LNN_LEDGER, "set sle addr failed! ret=%{public}d", ret);
2181 }
2182 // sle range info save in disk
2183 NodeInfo tempNodeInfo;
2184 (void)memset_s(&tempNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
2185 NodeInfo recoveryInfo;
2186 (void)memset_s(&recoveryInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
2187 if (memcpy_s(&tempNodeInfo, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
2188 LNN_LOGE(LNN_LEDGER, "memcpy_s fail");
2189 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2190 return SOFTBUS_MEM_ERR;
2191 }
2192 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
2193 ret = LnnRetrieveDeviceInfoByUdidPacked(tempNodeInfo.deviceInfo.deviceUdid, &recoveryInfo);
2194 if (ret != SOFTBUS_OK) {
2195 LNN_LOGE(LNN_LEDGER, "retrive device info fail, ret=%{public}d", ret);
2196 if (LnnSaveRemoteDeviceInfoPacked(&tempNodeInfo) != SOFTBUS_OK) {
2197 LNN_LOGE(LNN_LEDGER, "save remote info fail");
2198 }
2199 return ret;
2200 }
2201 recoveryInfo.sleRangeCapacity = sleCap;
2202 ret = strcpy_s(recoveryInfo.connectInfo.sleMacAddr, sizeof(recoveryInfo.connectInfo.sleMacAddr), addr);
2203 if (ret != EOK) {
2204 LNN_LOGE(LNN_LEDGER, "recovery info set sle addr failed! ret=%{public}d", ret);
2205 }
2206 ret = LnnSaveRemoteDeviceInfoPacked(&recoveryInfo);
2207 if (ret != SOFTBUS_OK) {
2208 LNN_LOGE(LNN_LEDGER, "save remote device info fail, ret=%{public}d", ret);
2209 return ret;
2210 }
2211 return SOFTBUS_OK;
2212 }