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