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_errcode.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_ERR;
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     uint64_t currentTimeMs = GetCurrentTime();
281     LNN_CHECK_AND_RETURN_RET_LOGE(info->connectInfo.latestTime + BLE_ADV_LOST_TIME >= currentTimeMs, SOFTBUS_ERR,
282         LNN_LEDGER, "ble mac out date, lastAdvTime=%{public}" PRIu64 ", now=%{public}" PRIu64,
283         info->connectInfo.latestTime, currentTimeMs);
284     if (memcpy_s(buf, len, info->connectInfo.bleMacAddr, MAC_LEN) != EOK) {
285         return SOFTBUS_MEM_ERR;
286     }
287     return SOFTBUS_OK;
288 }
289 
LnnUpdateNodeBleMac(const char * networkId,char * bleMac,uint32_t len)290 void LnnUpdateNodeBleMac(const char *networkId, char *bleMac, uint32_t len)
291 {
292     if ((networkId == NULL) || (bleMac == NULL) || (len != MAC_LEN)) {
293         LNN_LOGE(LNN_LEDGER, "invalid arg");
294         return;
295     }
296     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
297         LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
298         return;
299     }
300     NodeInfo *info = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
301     if (info == NULL) {
302         LNN_LOGE(LNN_LEDGER, "get node info fail.");
303         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
304         return;
305     }
306     if (memcpy_s(info->connectInfo.bleMacAddr, MAC_LEN, bleMac, len) != EOK) {
307         LNN_LOGE(LNN_LEDGER, "memcpy fail.");
308         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
309         return;
310     }
311     info->connectInfo.latestTime = GetCurrentTime();
312 
313     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
314 }
315 
IsNodeInfoScreenStatusSupport(const NodeInfo * info)316 int32_t IsNodeInfoScreenStatusSupport(const NodeInfo *info)
317 {
318     if (!LnnIsSupportHeartbeatCap(info->heartbeatCapacity, BIT_SUPPORT_SCREEN_STATUS)) {
319         return SOFTBUS_NETWORK_NOT_SUPPORT;
320     }
321     return SOFTBUS_OK;
322 }
323 
LnnSetRemoteScreenStatusInfo(const char * networkId,bool isScreenOn)324 bool LnnSetRemoteScreenStatusInfo(const char *networkId, bool isScreenOn)
325 {
326     if (networkId == NULL) {
327         LNN_LOGE(LNN_LEDGER, "invalid arg");
328         return false;
329     }
330     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != SOFTBUS_OK) {
331         LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
332         return false;
333     }
334     char *anonyNetworkId = NULL;
335     Anonymize(networkId, &anonyNetworkId);
336     NodeInfo *info = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
337     if (info == NULL) {
338         LNN_LOGE(LNN_LEDGER, "networkId=%{public}s, get node info fail.", anonyNetworkId);
339         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
340         AnonymizeFree(anonyNetworkId);
341         return false;
342     }
343     if (IsNodeInfoScreenStatusSupport(info) != SOFTBUS_OK) {
344         LNN_LOGE(LNN_LEDGER, "networkId=%{public}s, node screen status is not supported", anonyNetworkId);
345         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
346         AnonymizeFree(anonyNetworkId);
347         return false;
348     }
349 
350     info->isScreenOn = isScreenOn;
351     LNN_LOGI(LNN_LEDGER, "set %{public}s screen status to %{public}s", anonyNetworkId, isScreenOn ? "on" : "off");
352     SoftBusMutexUnlock(&LnnGetDistributedNetLedger()->lock);
353     AnonymizeFree(anonyNetworkId);
354     return true;
355 }
356 
DlGetAuthPort(const char * networkId,bool checkOnline,void * buf,uint32_t len)357 static int32_t DlGetAuthPort(const char *networkId, bool checkOnline, void *buf, uint32_t len)
358 {
359     (void)checkOnline;
360     NodeInfo *info = NULL;
361     if (len != LNN_COMMON_LEN) {
362         return SOFTBUS_INVALID_PARAM;
363     }
364     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
365     *((int32_t *)buf) = LnnGetAuthPort(info);
366     return SOFTBUS_OK;
367 }
368 
DlGetSessionPort(const char * networkId,bool checkOnline,void * buf,uint32_t len)369 static int32_t DlGetSessionPort(const char *networkId, bool checkOnline, void *buf, uint32_t len)
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) = LnnGetSessionPort(info);
378     return SOFTBUS_OK;
379 }
380 
DlGetProxyPort(const char * networkId,bool checkOnline,void * buf,uint32_t len)381 static int32_t DlGetProxyPort(const char *networkId, bool checkOnline, void *buf, uint32_t len)
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) = LnnGetProxyPort(info);
390     return SOFTBUS_OK;
391 }
392 
DlGetNetCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)393 static int32_t DlGetNetCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
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     *((uint32_t *)buf) = info->netCapacity;
402     return SOFTBUS_OK;
403 }
404 
DlGetFeatureCap(const char * networkId,bool checkOnline,void * buf,uint32_t len)405 static int32_t DlGetFeatureCap(const char *networkId, bool checkOnline, void *buf, uint32_t len)
406 {
407     (void)checkOnline;
408     NodeInfo *info = NULL;
409     if (len != LNN_COMMON_LEN_64) {
410         return SOFTBUS_INVALID_PARAM;
411     }
412     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
413     *((uint64_t *)buf) = info->feature;
414     return SOFTBUS_OK;
415 }
416 
DlGetNetType(const char * networkId,bool checkOnline,void * buf,uint32_t len)417 static int32_t DlGetNetType(const char *networkId, bool checkOnline, void *buf, uint32_t len)
418 {
419     (void)checkOnline;
420     NodeInfo *info = NULL;
421     if (len != LNN_COMMON_LEN) {
422         return SOFTBUS_INVALID_PARAM;
423     }
424     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
425     *((int32_t *)buf) = (int32_t)info->discoveryType;
426     return SOFTBUS_OK;
427 }
428 
DlGetMasterWeight(const char * networkId,bool checkOnline,void * buf,uint32_t len)429 static int32_t DlGetMasterWeight(const char *networkId, bool checkOnline, void *buf, uint32_t len)
430 {
431     (void)checkOnline;
432     NodeInfo *info = NULL;
433 
434     if (len != LNN_COMMON_LEN) {
435         return SOFTBUS_INVALID_PARAM;
436     }
437     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
438     *((int32_t *)buf) = info->masterWeight;
439     return SOFTBUS_OK;
440 }
441 
DlGetP2pMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)442 static int32_t DlGetP2pMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
443 {
444     (void)checkOnline;
445     NodeInfo *info = NULL;
446     const char *mac = NULL;
447 
448     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
449     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
450         LNN_LOGE(LNN_LEDGER, "node is offline");
451         return SOFTBUS_NETWORK_NODE_OFFLINE;
452     }
453     mac = LnnGetP2pMac(info);
454     if (mac == NULL) {
455         LNN_LOGE(LNN_LEDGER, "get p2p mac fail");
456         return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
457     }
458     if (strcpy_s((char*)buf, len, mac) != EOK) {
459         LNN_LOGE(LNN_LEDGER, "copy p2p mac to buf fail");
460         return SOFTBUS_MEM_ERR;
461     }
462     return SOFTBUS_OK;
463 }
464 
DlGetWifiDirectAddr(const char * networkId,bool checkOnline,void * buf,uint32_t len)465 static int32_t DlGetWifiDirectAddr(const char *networkId, bool checkOnline, void *buf, uint32_t len)
466 {
467     (void)checkOnline;
468     NodeInfo *info = NULL;
469     const char *wifiDirectAddr = NULL;
470 
471     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
472     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
473         LNN_LOGE(LNN_LEDGER, "node is offline");
474         return SOFTBUS_NETWORK_NODE_OFFLINE;
475     }
476     wifiDirectAddr = LnnGetWifiDirectAddr(info);
477     if (wifiDirectAddr == NULL) {
478         LNN_LOGE(LNN_LEDGER, "get wifidirect addr fail");
479         return SOFTBUS_ERR;
480     }
481     if (strcpy_s((char*)buf, len, wifiDirectAddr) != EOK) {
482         LNN_LOGE(LNN_LEDGER, "copy wifidirect addr to buf fail");
483         return SOFTBUS_MEM_ERR;
484     }
485     return SOFTBUS_OK;
486 }
487 
DlGetNodeAddr(const char * networkId,bool checkOnline,void * buf,uint32_t len)488 static int32_t DlGetNodeAddr(const char *networkId, bool checkOnline, void *buf, uint32_t len)
489 {
490     (void)checkOnline;
491     NodeInfo *info = NULL;
492     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
493     if (!LnnIsNodeOnline(info)) {
494         LNN_LOGE(LNN_LEDGER, "node is offline");
495         return SOFTBUS_NETWORK_NODE_OFFLINE;
496     }
497     if (strcpy_s((char*)buf, len, info->nodeAddress) != EOK) {
498         LNN_LOGE(LNN_LEDGER, "copy node addr to buf fail");
499         return SOFTBUS_MEM_ERR;
500     }
501     return SOFTBUS_OK;
502 }
503 
DlGetP2pGoMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)504 static int32_t DlGetP2pGoMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
505 {
506     (void)checkOnline;
507     NodeInfo *info = NULL;
508     const char *mac = NULL;
509 
510     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
511     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
512         LNN_LOGE(LNN_LEDGER, "node is offline");
513         return SOFTBUS_NETWORK_NODE_OFFLINE;
514     }
515     mac = LnnGetP2pGoMac(info);
516     if (mac == NULL) {
517         LNN_LOGE(LNN_LEDGER, "get p2p go mac fail");
518         return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
519     }
520     if (strcpy_s((char*)buf, len, mac) != EOK) {
521         LNN_LOGE(LNN_LEDGER, "copy p2p go mac to buf fail");
522         return SOFTBUS_MEM_ERR;
523     }
524     return SOFTBUS_OK;
525 }
526 
DlGetWifiCfg(const char * networkId,bool checkOnline,void * buf,uint32_t len)527 static int32_t DlGetWifiCfg(const char *networkId, bool checkOnline, void *buf, uint32_t len)
528 {
529     (void)checkOnline;
530     NodeInfo *info = NULL;
531     const char *wifiCfg = NULL;
532 
533     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
534     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
535         LNN_LOGE(LNN_LEDGER, "node is offline");
536         return SOFTBUS_NETWORK_NODE_OFFLINE;
537     }
538     wifiCfg = LnnGetWifiCfg(info);
539     if (wifiCfg == NULL) {
540         LNN_LOGE(LNN_LEDGER, "get wifi cfg fail");
541         return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
542     }
543     if (strcpy_s((char*)buf, len, wifiCfg) != EOK) {
544         LNN_LOGE(LNN_LEDGER, "copy wifi cfg to buf fail");
545         return SOFTBUS_MEM_ERR;
546     }
547     return SOFTBUS_OK;
548 }
549 
DlGetChanList5g(const char * networkId,bool checkOnline,void * buf,uint32_t len)550 static int32_t DlGetChanList5g(const char *networkId, bool checkOnline, void *buf, uint32_t len)
551 {
552     (void)checkOnline;
553     NodeInfo *info = NULL;
554     const char *chanList5g = NULL;
555 
556     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
557     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
558         LNN_LOGE(LNN_LEDGER, "node is offline");
559         return SOFTBUS_NETWORK_NODE_OFFLINE;
560     }
561     chanList5g = LnnGetChanList5g(info);
562     if (chanList5g == NULL) {
563         LNN_LOGE(LNN_LEDGER, "get chan list 5g fail");
564         return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
565     }
566     if (strcpy_s((char*)buf, len, chanList5g) != EOK) {
567         LNN_LOGE(LNN_LEDGER, "copy chan list 5g to buf fail");
568         return SOFTBUS_MEM_ERR;
569     }
570     return SOFTBUS_OK;
571 }
572 
DlGetP2pRole(const char * networkId,bool checkOnline,void * buf,uint32_t len)573 static int32_t DlGetP2pRole(const char *networkId, bool checkOnline, void *buf, uint32_t len)
574 {
575     (void)checkOnline;
576     NodeInfo *info = NULL;
577 
578     if (len != LNN_COMMON_LEN) {
579         return SOFTBUS_INVALID_PARAM;
580     }
581     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
582     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
583         LNN_LOGE(LNN_LEDGER, "node is offline");
584         return SOFTBUS_NETWORK_NODE_OFFLINE;
585     }
586     *((int32_t *)buf) = LnnGetP2pRole(info);
587     return SOFTBUS_OK;
588 }
589 
DlGetStateVersion(const char * networkId,bool checkOnline,void * buf,uint32_t len)590 static int32_t DlGetStateVersion(const char *networkId, bool checkOnline, void *buf, uint32_t len)
591 {
592     (void)checkOnline;
593     NodeInfo *info = NULL;
594 
595     if (len != LNN_COMMON_LEN) {
596         return SOFTBUS_INVALID_PARAM;
597     }
598     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
599     if (!LnnIsNodeOnline(info)) {
600         LNN_LOGE(LNN_LEDGER, "node is offline");
601         return SOFTBUS_NETWORK_NODE_OFFLINE;
602     }
603     *((int32_t *)buf) = info->stateVersion;
604     return SOFTBUS_OK;
605 }
606 
DlGetStaFrequency(const char * networkId,bool checkOnline,void * buf,uint32_t len)607 static int32_t DlGetStaFrequency(const char *networkId, bool checkOnline, void *buf, uint32_t len)
608 {
609     (void)checkOnline;
610     NodeInfo *info = NULL;
611 
612     if (len != LNN_COMMON_LEN) {
613         return SOFTBUS_INVALID_PARAM;
614     }
615     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
616     if ((!LnnIsNodeOnline(info)) && (!info->metaInfo.isMetaNode)) {
617         LNN_LOGE(LNN_LEDGER, "node is offline");
618         return SOFTBUS_NETWORK_NODE_OFFLINE;
619     }
620     *((int32_t *)buf) = LnnGetStaFrequency(info);
621     return SOFTBUS_OK;
622 }
623 
DlGetNodeDataChangeFlag(const char * networkId,bool checkOnline,void * buf,uint32_t len)624 static int32_t DlGetNodeDataChangeFlag(const char *networkId, bool checkOnline, void *buf, uint32_t len)
625 {
626     (void)checkOnline;
627     NodeInfo *info = NULL;
628 
629     if (len != DATA_CHANGE_FLAG_BUF_LEN) {
630         return SOFTBUS_INVALID_PARAM;
631     }
632     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
633     if (!LnnIsNodeOnline(info)) {
634         LNN_LOGE(LNN_LEDGER, "node is offline");
635         return SOFTBUS_NETWORK_NODE_OFFLINE;
636     }
637     *((int16_t *)buf) = (int16_t)LnnGetDataChangeFlag(info);
638     return SOFTBUS_OK;
639 }
640 
DlGetNodeTlvNegoFlag(const char * networkId,bool checkOnline,void * buf,uint32_t len)641 static int32_t DlGetNodeTlvNegoFlag(const char *networkId, bool checkOnline, void *buf, uint32_t len)
642 {
643     NodeInfo *info = NULL;
644     if (len != sizeof(bool)) {
645         return SOFTBUS_INVALID_PARAM;
646     }
647     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
648     if (checkOnline && !LnnIsNodeOnline(info) && !IsMetaNode(info)) {
649         LNN_LOGE(LNN_LEDGER, "node is offline");
650         return SOFTBUS_NETWORK_NODE_OFFLINE;
651     }
652     *((bool *)buf) = IsFeatureSupport(info->feature, BIT_WIFI_DIRECT_TLV_NEGOTIATION);
653     return SOFTBUS_OK;
654 }
655 
DlGetNodeScreenOnFlag(const char * networkId,bool checkOnline,void * buf,uint32_t len)656 static int32_t DlGetNodeScreenOnFlag(const char *networkId, bool checkOnline, void *buf, uint32_t len)
657 {
658     NodeInfo *info = NULL;
659     if (len != sizeof(bool)) {
660         return SOFTBUS_INVALID_PARAM;
661     }
662     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
663     char *anonyNetworkId = NULL;
664     Anonymize(networkId, &anonyNetworkId);
665     int32_t ret = IsNodeInfoScreenStatusSupport(info);
666     if (ret != SOFTBUS_OK) {
667         LNN_LOGI(LNN_LEDGER, "%{public}s get node screen not support", anonyNetworkId);
668         AnonymizeFree(anonyNetworkId);
669         return ret;
670     }
671     if (checkOnline && !LnnIsNodeOnline(info) && !IsMetaNode(info)) {
672         LNN_LOGE(LNN_LEDGER, "%{public}s node is offline", anonyNetworkId);
673         AnonymizeFree(anonyNetworkId);
674         return SOFTBUS_NETWORK_NODE_OFFLINE;
675     }
676     AnonymizeFree(anonyNetworkId);
677     *((bool *)buf) = info->isScreenOn;
678     return SOFTBUS_OK;
679 }
680 
DlGetAccountHash(const char * networkId,bool checkOnline,void * buf,uint32_t len)681 static int32_t DlGetAccountHash(const char *networkId, bool checkOnline, void *buf, uint32_t len)
682 {
683     (void)checkOnline;
684     NodeInfo *info = NULL;
685     if (len != SHA_256_HASH_LEN) {
686         return SOFTBUS_INVALID_PARAM;
687     }
688     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
689     if (!LnnIsNodeOnline(info)) {
690         LNN_LOGE(LNN_LEDGER, "node is offline");
691         return SOFTBUS_NETWORK_NODE_OFFLINE;
692     }
693     if (memcpy_s(buf, len, info->accountHash, SHA_256_HASH_LEN) != EOK) {
694         LNN_LOGE(LNN_LEDGER, "memcpy account hash fail");
695         return SOFTBUS_MEM_ERR;
696     }
697     return SOFTBUS_OK;
698 }
699 
DlGetDeviceIrk(const char * networkId,bool checkOnline,void * buf,uint32_t len)700 static int32_t DlGetDeviceIrk(const char *networkId, bool checkOnline, void *buf, uint32_t len)
701 {
702     (void)checkOnline;
703     NodeInfo *info = NULL;
704     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
705     if (memcpy_s(buf, len, info->rpaInfo.peerIrk, LFINDER_IRK_LEN) != EOK) {
706         LNN_LOGE(LNN_LEDGER, "memcpy peerIrk fail");
707         return SOFTBUS_MEM_ERR;
708     }
709     return SOFTBUS_OK;
710 }
711 
DlGetDevicePubMac(const char * networkId,bool checkOnline,void * buf,uint32_t len)712 static int32_t DlGetDevicePubMac(const char *networkId, bool checkOnline, void *buf, uint32_t len)
713 {
714     (void)checkOnline;
715     NodeInfo *info = NULL;
716     RETURN_IF_GET_NODE_VALID(networkId, buf, info);
717     if (memcpy_s(buf, len, info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN) != EOK) {
718         LNN_LOGE(LNN_LEDGER, "memcpy publicAddress fail");
719         return SOFTBUS_MEM_ERR;
720     }
721     return SOFTBUS_OK;
722 }
723 
DlGetDeviceCipherInfoKey(const char * networkId,bool checkOnline,void * buf,uint32_t len)724 static int32_t DlGetDeviceCipherInfoKey(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->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
730         LNN_LOGE(LNN_LEDGER, "memcpy cipher key fail");
731         return SOFTBUS_MEM_ERR;
732     }
733     return SOFTBUS_OK;
734 }
735 
DlGetDeviceCipherInfoIv(const char * networkId,bool checkOnline,void * buf,uint32_t len)736 static int32_t DlGetDeviceCipherInfoIv(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->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
742         LNN_LOGE(LNN_LEDGER, "memcpy cipher iv fail");
743         return SOFTBUS_MEM_ERR;
744     }
745     return SOFTBUS_OK;
746 }
747 
DlGetNodeP2pIp(const char * networkId,bool checkOnline,void * buf,uint32_t len)748 static int32_t DlGetNodeP2pIp(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 (strcpy_s((char *)buf, len, info->p2pInfo.p2pIp) != EOK) {
754         LNN_LOGE(LNN_LEDGER, "copy p2pIp to buf fail");
755         return SOFTBUS_MEM_ERR;
756     }
757     return SOFTBUS_OK;
758 }
759 
760 static DistributedLedgerKey g_dlKeyTable[] = {
761     {STRING_KEY_HICE_VERSION, DlGetNodeSoftBusVersion},
762     {STRING_KEY_DEV_UDID, DlGetDeviceUdid},
763     {STRING_KEY_UUID, DlGetDeviceUuid},
764     {STRING_KEY_DEV_TYPE, DlGetDeviceType},
765     {STRING_KEY_DEV_NAME, DlGetDeviceName},
766     {STRING_KEY_BT_MAC, DlGetBtMac},
767     {STRING_KEY_WLAN_IP, DlGetWlanIp},
768     {STRING_KEY_MASTER_NODE_UDID, DlGetMasterUdid},
769     {STRING_KEY_P2P_MAC, DlGetP2pMac},
770     {STRING_KEY_WIFI_CFG, DlGetWifiCfg},
771     {STRING_KEY_CHAN_LIST_5G, DlGetChanList5g},
772     {STRING_KEY_P2P_GO_MAC, DlGetP2pGoMac},
773     {STRING_KEY_NODE_ADDR, DlGetNodeAddr},
774     {STRING_KEY_OFFLINE_CODE, DlGetDeviceOfflineCode},
775     {STRING_KEY_BLE_MAC, DlGetNodeBleMac},
776     {STRING_KEY_WIFIDIRECT_ADDR, DlGetWifiDirectAddr},
777     {STRING_KEY_P2P_IP, DlGetNodeP2pIp},
778     {NUM_KEY_META_NODE, DlGetAuthType},
779     {NUM_KEY_SESSION_PORT, DlGetSessionPort},
780     {NUM_KEY_AUTH_PORT, DlGetAuthPort},
781     {NUM_KEY_PROXY_PORT, DlGetProxyPort},
782     {NUM_KEY_NET_CAP, DlGetNetCap},
783     {NUM_KEY_FEATURE_CAPA, DlGetFeatureCap},
784     {NUM_KEY_DISCOVERY_TYPE, DlGetNetType},
785     {NUM_KEY_MASTER_NODE_WEIGHT, DlGetMasterWeight},
786     {NUM_KEY_STA_FREQUENCY, DlGetStaFrequency},
787     {NUM_KEY_P2P_ROLE, DlGetP2pRole},
788     {NUM_KEY_STATE_VERSION, DlGetStateVersion},
789     {NUM_KEY_DATA_CHANGE_FLAG, DlGetNodeDataChangeFlag},
790     {NUM_KEY_DEV_TYPE_ID, DlGetDeviceTypeId},
791     {NUM_KEY_STATIC_CAP_LEN, DlGetStaticCapLen},
792     {NUM_KEY_DEVICE_SECURITY_LEVEL, DlGetDeviceSecurityLevel},
793     {BOOL_KEY_TLV_NEGOTIATION, DlGetNodeTlvNegoFlag},
794     {BOOL_KEY_SCREEN_STATUS, DlGetNodeScreenOnFlag},
795     {BYTE_KEY_ACCOUNT_HASH, DlGetAccountHash},
796     {BYTE_KEY_IRK, DlGetDeviceIrk},
797     {BYTE_KEY_PUB_MAC, DlGetDevicePubMac},
798     {BYTE_KEY_BROADCAST_CIPHER_KEY, DlGetDeviceCipherInfoKey},
799     {BYTE_KEY_BROADCAST_CIPHER_IV, DlGetDeviceCipherInfoIv},
800     {BYTE_KEY_REMOTE_PTK, DlGetRemotePtk},
801     {BYTE_KEY_STATIC_CAPABILITY, DlGetStaticCap},
802 };
803 
LnnSetDLDeviceInfoName(const char * udid,const char * name)804 bool LnnSetDLDeviceInfoName(const char *udid, const char *name)
805 {
806     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
807     NodeInfo *info = NULL;
808     if (udid == NULL || name == NULL) {
809         LNN_LOGE(LNN_LEDGER, "para error");
810         return false;
811     }
812     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
813         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
814         return false;
815     }
816     info = GetNodeInfoFromMap(map, udid);
817     if (info == NULL) {
818         LNN_LOGE(LNN_LEDGER, "udid not exist");
819         goto EXIT;
820     }
821     if (strcmp(LnnGetDeviceName(&info->deviceInfo), name) == 0) {
822         LNN_LOGI(LNN_LEDGER, "devicename not change");
823         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
824         return true;
825     }
826     if (LnnSetDeviceName(&info->deviceInfo, name) != SOFTBUS_OK) {
827         LNN_LOGE(LNN_LEDGER, "set device name error");
828         goto EXIT;
829     }
830     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
831     return true;
832 EXIT:
833     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
834     return false;
835 }
836 
LnnSetDLDeviceNickName(const char * networkId,const char * name)837 bool LnnSetDLDeviceNickName(const char *networkId, const char *name)
838 {
839     NodeInfo *node = NULL;
840     if (networkId == NULL || name == NULL) {
841         LNN_LOGE(LNN_LEDGER, "invalid param");
842         return false;
843     }
844     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
845         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
846         return false;
847     }
848     node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
849     if (node == NULL) {
850         LNN_LOGE(LNN_LEDGER, "networkId not found");
851         goto EXIT;
852     }
853     if (strcpy_s(node->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, name) != EOK) {
854         goto EXIT;
855     }
856     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
857     return true;
858 EXIT:
859     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
860     return false;
861 }
862 
LnnSetDLUnifiedDeviceName(const char * udid,const char * name)863 int32_t LnnSetDLUnifiedDeviceName(const char *udid, const char *name)
864 {
865     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
866     NodeInfo *info = NULL;
867     if (udid == NULL || name == NULL) {
868         LNN_LOGE(LNN_LEDGER, "param error");
869         return SOFTBUS_INVALID_PARAM;
870     }
871     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
872         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
873         return SOFTBUS_LOCK_ERR;
874     }
875     info = GetNodeInfoFromMap(map, udid);
876     if (info == NULL) {
877         LNN_LOGE(LNN_LEDGER, "udid not exist");
878         goto EXIT;
879     }
880     if (strcmp(info->deviceInfo.unifiedName, name) == 0) {
881         LNN_LOGI(LNN_LEDGER, "deviceunifiedname not change");
882         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
883         return SOFTBUS_OK;
884     }
885     if (strncpy_s(info->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
886         LNN_LOGE(LNN_LEDGER, "set deviceunifiedname error");
887         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
888         return SOFTBUS_STRCPY_ERR;
889     }
890     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
891     return SOFTBUS_OK;
892 EXIT:
893     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
894     return SOFTBUS_NOT_FIND;
895 }
896 
LnnSetDLUnifiedDefaultDeviceName(const char * udid,const char * name)897 int32_t LnnSetDLUnifiedDefaultDeviceName(const char *udid, const char *name)
898 {
899     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
900     NodeInfo *info = NULL;
901     if (udid == NULL || name == NULL) {
902         LNN_LOGE(LNN_LEDGER, "param error");
903         return SOFTBUS_INVALID_PARAM;
904     }
905     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
906         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
907         return SOFTBUS_LOCK_ERR;
908     }
909     info = GetNodeInfoFromMap(map, udid);
910     if (info == NULL) {
911         LNN_LOGE(LNN_LEDGER, "udid not exist");
912         goto EXIT;
913     }
914     if (strcmp(info->deviceInfo.unifiedDefaultName, name) == 0) {
915         LNN_LOGI(LNN_LEDGER, "deviceunifiedDefaultName not change");
916         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
917         return SOFTBUS_OK;
918     }
919     if (strncpy_s(info->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
920         LNN_LOGE(LNN_LEDGER, "set deviceunifiedDefaultName error");
921         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
922         return SOFTBUS_STRCPY_ERR;
923     }
924     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
925     return SOFTBUS_OK;
926 EXIT:
927     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
928     return SOFTBUS_NOT_FIND;
929 }
930 
LnnSetDLDeviceNickNameByUdid(const char * udid,const char * name)931 int32_t LnnSetDLDeviceNickNameByUdid(const char *udid, const char *name)
932 {
933     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
934     NodeInfo *info = NULL;
935     if (udid == NULL || name == NULL) {
936         LNN_LOGE(LNN_LEDGER, "param error");
937         return SOFTBUS_INVALID_PARAM;
938     }
939     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
940         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
941         return SOFTBUS_LOCK_ERR;
942     }
943     info = GetNodeInfoFromMap(map, udid);
944     if (info == NULL) {
945         LNN_LOGE(LNN_LEDGER, "udid not exist");
946         goto EXIT;
947     }
948     if (strcmp(info->deviceInfo.nickName, name) == 0) {
949         LNN_LOGI(LNN_LEDGER, "devicenickName not change");
950         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
951         return SOFTBUS_OK;
952     }
953     if (strncpy_s(info->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
954         LNN_LOGE(LNN_LEDGER, "set devicenickName error");
955         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
956         return SOFTBUS_STRCPY_ERR;
957     }
958     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
959     return SOFTBUS_OK;
960 EXIT:
961     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
962     return SOFTBUS_NOT_FIND;
963 }
964 
LnnSetDLDeviceStateVersion(const char * udid,int32_t stateVersion)965 int32_t LnnSetDLDeviceStateVersion(const char *udid, int32_t stateVersion)
966 {
967     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
968     NodeInfo *info = NULL;
969     if (udid == NULL) {
970         LNN_LOGE(LNN_LEDGER, "param error");
971         return SOFTBUS_INVALID_PARAM;
972     }
973     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
974         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
975         return SOFTBUS_LOCK_ERR;
976     }
977     info = GetNodeInfoFromMap(map, udid);
978     if (info == NULL) {
979         LNN_LOGE(LNN_LEDGER, "udid not exist");
980         goto EXIT;
981     }
982     if (info->stateVersion == stateVersion) {
983         LNN_LOGI(LNN_LEDGER, "device stateversion not change");
984         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
985         return SOFTBUS_OK;
986     }
987     info->stateVersion = stateVersion;
988     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
989     return SOFTBUS_OK;
990 EXIT:
991     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
992     return SOFTBUS_NOT_FIND;
993 }
994 
LnnSetDLDeviceBroadcastCipherKey(const char * udid,const void * cipherKey)995 int32_t LnnSetDLDeviceBroadcastCipherKey(const char *udid, const void *cipherKey)
996 {
997     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
998     NodeInfo *info = NULL;
999     if (udid == NULL) {
1000         LNN_LOGE(LNN_LEDGER, "param error");
1001         return SOFTBUS_INVALID_PARAM;
1002     }
1003     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1004         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1005         return SOFTBUS_LOCK_ERR;
1006     }
1007     info = GetNodeInfoFromMap(map, udid);
1008     if (info == NULL) {
1009         LNN_LOGE(LNN_LEDGER, "udid not exist");
1010         goto EXIT;
1011     }
1012     if (memcpy_s((char *)info->cipherInfo.key, SESSION_KEY_LENGTH, cipherKey, SESSION_KEY_LENGTH) != EOK) {
1013         LNN_LOGE(LNN_LEDGER, "set BroadcastcipherKey error");
1014         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1015         return SOFTBUS_MEM_ERR;
1016     }
1017     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1018     return SOFTBUS_OK;
1019 EXIT:
1020     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1021     return SOFTBUS_NOT_FIND;
1022 }
1023 
LnnSetDLDeviceBroadcastCipherIv(const char * udid,const void * cipherIv)1024 int32_t LnnSetDLDeviceBroadcastCipherIv(const char *udid, const void *cipherIv)
1025 {
1026     DoubleHashMap *map = &(LnnGetDistributedNetLedger()->distributedInfo);
1027     NodeInfo *info = NULL;
1028     if (udid == NULL) {
1029         LNN_LOGE(LNN_LEDGER, "param error");
1030         return SOFTBUS_INVALID_PARAM;
1031     }
1032     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1033         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1034         return SOFTBUS_LOCK_ERR;
1035     }
1036     info = GetNodeInfoFromMap(map, udid);
1037     if (info == NULL) {
1038         LNN_LOGE(LNN_LEDGER, "udid not exist");
1039         goto EXIT;
1040     }
1041     if (memcpy_s((char *)info->cipherInfo.iv, BROADCAST_IV_LEN, cipherIv, BROADCAST_IV_LEN) != EOK) {
1042         LNN_LOGE(LNN_LEDGER, "set BroadcastcipherKey error");
1043         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1044         return SOFTBUS_MEM_ERR;
1045     }
1046     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1047     return SOFTBUS_OK;
1048 EXIT:
1049     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1050     return SOFTBUS_NOT_FIND;
1051 }
1052 
LnnSetDLP2pInfo(const char * networkId,const P2pInfo * info)1053 bool LnnSetDLP2pInfo(const char *networkId, const P2pInfo *info)
1054 {
1055     NodeInfo *node = NULL;
1056     if (networkId == NULL || info == NULL) {
1057         LNN_LOGE(LNN_LEDGER, "invalid param");
1058         return false;
1059     }
1060     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1061         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1062         return false;
1063     }
1064     node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1065     if (node == NULL) {
1066         LNN_LOGE(LNN_LEDGER, "udid not found");
1067         goto EXIT;
1068     }
1069     if (LnnSetP2pRole(node, info->p2pRole) != SOFTBUS_OK ||
1070         LnnSetP2pMac(node, info->p2pMac) != SOFTBUS_OK ||
1071         LnnSetP2pGoMac(node, info->goMac) != SOFTBUS_OK) {
1072         LNN_LOGE(LNN_LEDGER, "set p2p info fail");
1073         goto EXIT;
1074     }
1075     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1076     return true;
1077 EXIT:
1078     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1079     return false;
1080 }
1081 
LnnSetDlPtk(const char * networkId,const char * remotePtk)1082 bool LnnSetDlPtk(const char *networkId, const char *remotePtk)
1083 {
1084     NodeInfo *node = NULL;
1085     if (networkId == NULL || remotePtk == NULL) {
1086         LNN_LOGE(LNN_LEDGER, "invalid param");
1087         return false;
1088     }
1089     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1090         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1091         return false;
1092     }
1093     node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1094     if (node == NULL) {
1095         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1096         LNN_LOGE(LNN_LEDGER, "get node info fail");
1097         return false;
1098     }
1099     LnnDumpRemotePtk(node->remotePtk, remotePtk, "set remote ptk");
1100     if (LnnSetPtk(node, remotePtk) != SOFTBUS_OK) {
1101         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1102         LNN_LOGE(LNN_LEDGER, "set ptk fail");
1103         return false;
1104     }
1105     char udidHash[SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
1106     if (LnnGenerateHexStringHash(
1107         (const unsigned char *)node->deviceInfo.deviceUdid, udidHash, SHORT_UDID_HASH_HEX_LEN) != SOFTBUS_OK) {
1108         SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1109         LNN_LOGE(LNN_LEDGER, "Generate UDID HexStringHash fail");
1110         return false;
1111     }
1112     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1113     NodeInfo cacheInfo;
1114     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1115     if (LnnRetrieveDeviceInfo(udidHash, &cacheInfo) != SOFTBUS_OK) {
1116         LNN_LOGD(LNN_LEDGER, "no this device info in deviceCacheInfoMap, ignore update");
1117         return true;
1118     }
1119     if (memcmp(cacheInfo.remotePtk, remotePtk, PTK_DEFAULT_LEN) == 0) {
1120         LNN_LOGD(LNN_LEDGER, "ptk is same, ignore update");
1121         return true;
1122     }
1123     if (memcpy_s(cacheInfo.remotePtk, PTK_DEFAULT_LEN, remotePtk, PTK_DEFAULT_LEN) != EOK) {
1124         LNN_LOGE(LNN_LEDGER, "memcpy_s ptk fail");
1125         return true;
1126     }
1127     (void)LnnSaveRemoteDeviceInfo(&cacheInfo);
1128     return true;
1129 }
1130 
LnnGetRemoteStrInfo(const char * networkId,InfoKey key,char * info,uint32_t len)1131 int32_t LnnGetRemoteStrInfo(const char *networkId, InfoKey key, char *info, uint32_t len)
1132 {
1133     uint32_t i;
1134     int32_t ret;
1135     if (!IsValidString(networkId, ID_MAX_LEN)) {
1136         return SOFTBUS_INVALID_PARAM;
1137     }
1138     if (info == NULL) {
1139         LNN_LOGE(LNN_LEDGER, "info is null");
1140         return SOFTBUS_INVALID_PARAM;
1141     }
1142     if (key >= STRING_KEY_END) {
1143         LNN_LOGE(LNN_LEDGER, "KEY error");
1144         return SOFTBUS_INVALID_PARAM;
1145     }
1146     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1147         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1148         return SOFTBUS_LOCK_ERR;
1149     }
1150     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1151         if (key == g_dlKeyTable[i].key) {
1152             if (g_dlKeyTable[i].getInfo != NULL) {
1153                 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, len);
1154                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1155                 return ret;
1156             }
1157         }
1158     }
1159     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1160     LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1161     return SOFTBUS_NOT_FIND;
1162 }
1163 
LnnGetRemoteNumInfo(const char * networkId,InfoKey key,int32_t * info)1164 int32_t LnnGetRemoteNumInfo(const char *networkId, InfoKey key, int32_t *info)
1165 {
1166     uint32_t i;
1167     int32_t ret;
1168     if (!IsValidString(networkId, ID_MAX_LEN)) {
1169         LNN_LOGE(LNN_LEDGER, "networkId is invalid");
1170         return SOFTBUS_INVALID_PARAM;
1171     }
1172     if (info == NULL) {
1173         LNN_LOGE(LNN_LEDGER, "info is null");
1174         return SOFTBUS_INVALID_PARAM;
1175     }
1176     if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1177         LNN_LOGE(LNN_LEDGER, "KEY error");
1178         return SOFTBUS_INVALID_PARAM;
1179     }
1180     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1181         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1182         return SOFTBUS_LOCK_ERR;
1183     }
1184     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1185         if (key == g_dlKeyTable[i].key) {
1186             if (g_dlKeyTable[i].getInfo != NULL) {
1187                 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN);
1188                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1189                 return ret;
1190             }
1191         }
1192     }
1193     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1194     LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1195     return SOFTBUS_NOT_FIND;
1196 }
1197 
LnnGetRemoteNumU32Info(const char * networkId,InfoKey key,uint32_t * info)1198 int32_t LnnGetRemoteNumU32Info(const char *networkId, InfoKey key, uint32_t *info)
1199 {
1200     uint32_t i;
1201     int32_t ret;
1202     if (!IsValidString(networkId, ID_MAX_LEN)) {
1203         LNN_LOGE(LNN_LEDGER, "networkId is invalid");
1204         return SOFTBUS_INVALID_PARAM;
1205     }
1206     if (info == NULL) {
1207         LNN_LOGE(LNN_LEDGER, "info is null");
1208         return SOFTBUS_INVALID_PARAM;
1209     }
1210     if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1211         LNN_LOGE(LNN_LEDGER, "KEY error");
1212         return SOFTBUS_INVALID_PARAM;
1213     }
1214     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1215         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1216         return SOFTBUS_LOCK_ERR;
1217     }
1218     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1219         if (key == g_dlKeyTable[i].key) {
1220             if (g_dlKeyTable[i].getInfo != NULL) {
1221                 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN);
1222                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1223                 return ret;
1224             }
1225         }
1226     }
1227     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1228     LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1229     return SOFTBUS_NOT_FIND;
1230 }
1231 
LnnGetRemoteNumU64Info(const char * networkId,InfoKey key,uint64_t * info)1232 int32_t LnnGetRemoteNumU64Info(const char *networkId, InfoKey key, uint64_t *info)
1233 {
1234     uint32_t i;
1235     int32_t ret;
1236     if (!IsValidString(networkId, ID_MAX_LEN)) {
1237         return SOFTBUS_INVALID_PARAM;
1238     }
1239     if (info == NULL) {
1240         LNN_LOGE(LNN_LEDGER, "info is null");
1241         return SOFTBUS_INVALID_PARAM;
1242     }
1243     if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1244         LNN_LOGE(LNN_LEDGER, "KEY error");
1245         return SOFTBUS_INVALID_PARAM;
1246     }
1247     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1248         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1249         return SOFTBUS_LOCK_ERR;
1250     }
1251     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1252         if (key == g_dlKeyTable[i].key) {
1253             if (g_dlKeyTable[i].getInfo != NULL) {
1254                 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, LNN_COMMON_LEN_64);
1255                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1256                 return ret;
1257             }
1258         }
1259     }
1260     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1261     LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1262     return SOFTBUS_NOT_FIND;
1263 }
1264 
LnnGetRemoteNum16Info(const char * networkId,InfoKey key,int16_t * info)1265 int32_t LnnGetRemoteNum16Info(const char *networkId, InfoKey key, int16_t *info)
1266 {
1267     uint32_t i;
1268     int32_t ret;
1269     if (!IsValidString(networkId, ID_MAX_LEN)) {
1270         return SOFTBUS_INVALID_PARAM;
1271     }
1272     if (info == NULL) {
1273         LNN_LOGE(LNN_LEDGER, "info is null");
1274         return SOFTBUS_INVALID_PARAM;
1275     }
1276     if (key < NUM_KEY_BEGIN || key >= NUM_KEY_END) {
1277         LNN_LOGE(LNN_LEDGER, "KEY error");
1278         return SOFTBUS_INVALID_PARAM;
1279     }
1280     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1281         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1282         return SOFTBUS_LOCK_ERR;
1283     }
1284     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1285         if (key == g_dlKeyTable[i].key) {
1286             if (g_dlKeyTable[i].getInfo != NULL) {
1287                 ret = g_dlKeyTable[i].getInfo(networkId, true, (void *)info, sizeof(int16_t));
1288                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1289                 return ret;
1290             }
1291         }
1292     }
1293     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1294     LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1295     return SOFTBUS_NOT_FIND;
1296 }
1297 
LnnGetRemoteBoolInfoCommon(const char * networkId,bool checkOnline,InfoKey key,bool * info)1298 static int32_t LnnGetRemoteBoolInfoCommon(const char *networkId, bool checkOnline, InfoKey key, bool *info)
1299 {
1300     uint32_t i;
1301     int32_t ret;
1302     if (!IsValidString(networkId, ID_MAX_LEN)) {
1303         return SOFTBUS_INVALID_PARAM;
1304     }
1305     if (info == NULL) {
1306         LNN_LOGE(LNN_LEDGER, "info is null");
1307         return SOFTBUS_INVALID_PARAM;
1308     }
1309     if (key < BOOL_KEY_BEGIN || key >= BOOL_KEY_END) {
1310         LNN_LOGE(LNN_LEDGER, "KEY error");
1311         return SOFTBUS_INVALID_PARAM;
1312     }
1313     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1314         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1315         return SOFTBUS_LOCK_ERR;
1316     }
1317     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1318         if (key == g_dlKeyTable[i].key) {
1319             if (g_dlKeyTable[i].getInfo != NULL) {
1320                 ret = g_dlKeyTable[i].getInfo(networkId, checkOnline, (void *)info, sizeof(bool));
1321                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1322                 return ret;
1323             }
1324         }
1325     }
1326     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1327     LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1328     return SOFTBUS_NOT_FIND;
1329 }
1330 
LnnGetRemoteBoolInfo(const char * networkId,InfoKey key,bool * info)1331 int32_t LnnGetRemoteBoolInfo(const char *networkId, InfoKey key, bool *info)
1332 {
1333     return LnnGetRemoteBoolInfoCommon(networkId, true, key, info);
1334 }
1335 
LnnGetRemoteBoolInfoIgnoreOnline(const char * networkId,InfoKey key,bool * info)1336 int32_t LnnGetRemoteBoolInfoIgnoreOnline(const char *networkId, InfoKey key, bool *info)
1337 {
1338     return LnnGetRemoteBoolInfoCommon(networkId, false, key, info);
1339 }
1340 
LnnGetRemoteByteInfo(const char * networkId,InfoKey key,uint8_t * info,uint32_t len)1341 int32_t LnnGetRemoteByteInfo(const char *networkId, InfoKey key, uint8_t *info, uint32_t len)
1342 {
1343     uint32_t i;
1344     int32_t ret;
1345     if (!IsValidString(networkId, ID_MAX_LEN) || info == NULL) {
1346         LNN_LOGE(LNN_LEDGER, "para error.");
1347         return SOFTBUS_INVALID_PARAM;
1348     }
1349     if (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END) {
1350         LNN_LOGE(LNN_LEDGER, "KEY error.");
1351         return SOFTBUS_INVALID_PARAM;
1352     }
1353     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1354         LNN_LOGE(LNN_LEDGER, "lock mutex fail!");
1355         return SOFTBUS_LOCK_ERR;
1356     }
1357     for (i = 0; i < sizeof(g_dlKeyTable) / sizeof(DistributedLedgerKey); i++) {
1358         if (key == g_dlKeyTable[i].key) {
1359             if (g_dlKeyTable[i].getInfo != NULL) {
1360                 ret = g_dlKeyTable[i].getInfo(networkId, true, info, len);
1361                 SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1362                 return ret;
1363             }
1364         }
1365     }
1366     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1367     LNN_LOGE(LNN_LEDGER, "KEY NOT exist.");
1368     return SOFTBUS_NOT_FIND;
1369 }
1370 
LnnGetNetworkIdByBtMac(const char * btMac,char * buf,uint32_t len)1371 int32_t LnnGetNetworkIdByBtMac(const char *btMac, char *buf, uint32_t len)
1372 {
1373     if (btMac == NULL || btMac[0] == '\0' || buf == NULL) {
1374         LNN_LOGE(LNN_LEDGER, "btMac is empty");
1375         return SOFTBUS_INVALID_PARAM;
1376     }
1377     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1378         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1379         return SOFTBUS_LOCK_ERR;
1380     }
1381     MapIterator *it = LnnMapInitIterator(&(LnnGetDistributedNetLedger()->distributedInfo.udidMap));
1382     if (it == NULL) {
1383         LNN_LOGE(LNN_LEDGER, "it is null");
1384         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1385         return SOFTBUS_ERR;
1386     }
1387     while (LnnMapHasNext(it)) {
1388         it = LnnMapNext(it);
1389         if (it == NULL) {
1390             (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1391             return SOFTBUS_ERR;
1392         }
1393         NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
1394         if ((LnnIsNodeOnline(nodeInfo) || nodeInfo->metaInfo.isMetaNode) &&
1395             StrCmpIgnoreCase(nodeInfo->connectInfo.macAddr, btMac) == 0) {
1396             if (strcpy_s(buf, len, nodeInfo->networkId) != EOK) {
1397                 LNN_LOGE(LNN_LEDGER, "strcpy_s networkId fail");
1398                 LnnMapDeinitIterator(it);
1399                 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1400                 return SOFTBUS_MEM_ERR;
1401             }
1402             LnnMapDeinitIterator(it);
1403             (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1404             return SOFTBUS_OK;
1405         }
1406     }
1407     LnnMapDeinitIterator(it);
1408     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1409     return SOFTBUS_NOT_FIND;
1410 }
1411 
LnnGetNetworkIdByUdidHash(const uint8_t * udidHash,uint32_t udidHashLen,char * buf,uint32_t len)1412 int32_t LnnGetNetworkIdByUdidHash(const uint8_t *udidHash, uint32_t udidHashLen, char *buf, uint32_t len)
1413 {
1414     if (udidHash == NULL || buf == NULL || udidHashLen == 0) {
1415         LNN_LOGE(LNN_LEDGER, "udidHash is empty");
1416         return SOFTBUS_INVALID_PARAM;
1417     }
1418     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1419         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1420         return SOFTBUS_LOCK_ERR;
1421     }
1422     MapIterator *it = LnnMapInitIterator(&(LnnGetDistributedNetLedger()->distributedInfo.udidMap));
1423     if (it == NULL) {
1424         LNN_LOGE(LNN_LEDGER, "it is null");
1425         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1426         return SOFTBUS_ERR;
1427     }
1428     uint8_t nodeUdidHash[SHA_256_HASH_LEN] = {0};
1429     while (LnnMapHasNext(it)) {
1430         it = LnnMapNext(it);
1431         if (it == NULL) {
1432             (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1433             return SOFTBUS_ERR;
1434         }
1435         NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
1436         if (LnnIsNodeOnline(nodeInfo) || nodeInfo->metaInfo.isMetaNode) {
1437             if (SoftBusGenerateStrHash((uint8_t*)nodeInfo->deviceInfo.deviceUdid,
1438                 strlen(nodeInfo->deviceInfo.deviceUdid), nodeUdidHash) != SOFTBUS_OK) {
1439                 continue;
1440             }
1441             if (memcmp(nodeUdidHash, udidHash, SHA_256_HASH_LEN) != 0) {
1442                 continue;
1443             }
1444             if (strcpy_s(buf, len, nodeInfo->networkId) != EOK) {
1445                 LNN_LOGE(LNN_LEDGER, "strcpy_s networkId fail");
1446                 LnnMapDeinitIterator(it);
1447                 (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1448                 return SOFTBUS_MEM_ERR;
1449             }
1450             LnnMapDeinitIterator(it);
1451             (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1452             return SOFTBUS_OK;
1453         }
1454     }
1455     LnnMapDeinitIterator(it);
1456     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1457     return SOFTBUS_NOT_FIND;
1458 }
1459 
LnnGetConnSubFeatureByUdidHashStr(const char * udidHashStr,uint64_t * connSubFeature)1460 int32_t LnnGetConnSubFeatureByUdidHashStr(const char *udidHashStr, uint64_t *connSubFeature)
1461 {
1462     if (udidHashStr == NULL || udidHashStr[0] == '\0' || connSubFeature == NULL) {
1463         LNN_LOGE(LNN_LEDGER, "para is empty");
1464         return SOFTBUS_INVALID_PARAM;
1465     }
1466     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1467         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1468         return SOFTBUS_LOCK_ERR;
1469     }
1470     MapIterator *it = LnnMapInitIterator(&(LnnGetDistributedNetLedger()->distributedInfo.udidMap));
1471     if (it == NULL) {
1472         LNN_LOGE(LNN_LEDGER, "it is null");
1473         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1474         return SOFTBUS_ERR;
1475     }
1476     unsigned char shortUdidHashStr[SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1477     while (LnnMapHasNext(it)) {
1478         it = LnnMapNext(it);
1479         if (it == NULL) {
1480             (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1481             return SOFTBUS_ERR;
1482         }
1483         NodeInfo *nodeInfo = (NodeInfo *)it->node->value;
1484         if (LnnIsNodeOnline(nodeInfo)) {
1485             if (GenerateStrHashAndConvertToHexString((const unsigned char *)nodeInfo->deviceInfo.deviceUdid,
1486                 SHORT_UDID_HASH_HEX_LEN, shortUdidHashStr, SHORT_UDID_HASH_HEX_LEN + 1) != SOFTBUS_OK) {
1487                 continue;
1488             }
1489             if (memcmp(shortUdidHashStr, udidHashStr, SHORT_UDID_HASH_HEX_LEN) != 0) {
1490                 continue;
1491             }
1492             *connSubFeature = nodeInfo->connSubFeature;
1493             LnnMapDeinitIterator(it);
1494             (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1495             return SOFTBUS_OK;
1496         }
1497     }
1498     LnnMapDeinitIterator(it);
1499     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1500     return SOFTBUS_NOT_FIND;
1501 }
1502 
LnnGetNetworkIdByUuid(const char * uuid,char * buf,uint32_t len)1503 int32_t LnnGetNetworkIdByUuid(const char *uuid, char *buf, uint32_t len)
1504 {
1505     if (!IsValidString(uuid, ID_MAX_LEN)) {
1506         LNN_LOGE(LNN_LEDGER, "uuid is invalid");
1507         return SOFTBUS_INVALID_PARAM;
1508     }
1509 
1510     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1511         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1512         return SOFTBUS_LOCK_ERR;
1513     }
1514     NodeInfo *nodeInfo = LnnGetNodeInfoById(uuid, CATEGORY_UUID);
1515     if (nodeInfo == NULL) {
1516         LNN_LOGE(LNN_LEDGER, "get info fail");
1517         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1518         return SOFTBUS_NOT_FIND;
1519     }
1520     if (strncpy_s(buf, len, nodeInfo->networkId, strlen(nodeInfo->networkId)) != EOK) {
1521         LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1522         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1523         return SOFTBUS_MEM_ERR;
1524     }
1525     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1526     return SOFTBUS_OK;
1527 }
1528 
LnnGetNetworkIdByUdid(const char * udid,char * buf,uint32_t len)1529 int32_t LnnGetNetworkIdByUdid(const char *udid, char *buf, uint32_t len)
1530 {
1531     if (!IsValidString(udid, ID_MAX_LEN)) {
1532         LNN_LOGE(LNN_LEDGER, "udid is invalid");
1533         return SOFTBUS_INVALID_PARAM;
1534     }
1535 
1536     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1537         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1538         return SOFTBUS_LOCK_ERR;
1539     }
1540     NodeInfo *nodeInfo = LnnGetNodeInfoById(udid, CATEGORY_UDID);
1541     if (nodeInfo == NULL) {
1542         LNN_LOGE(LNN_LEDGER, "get info fail");
1543         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1544         return SOFTBUS_NOT_FIND;
1545     }
1546     if (strncpy_s(buf, len, nodeInfo->networkId, strlen(nodeInfo->networkId)) != EOK) {
1547         LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1548         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1549         return SOFTBUS_MEM_ERR;
1550     }
1551     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1552     return SOFTBUS_OK;
1553 }
1554 
LnnGetDLOnlineTimestamp(const char * networkId,uint64_t * timestamp)1555 int32_t LnnGetDLOnlineTimestamp(const char *networkId, uint64_t *timestamp)
1556 {
1557     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1558         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1559         return SOFTBUS_LOCK_ERR;
1560     }
1561     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1562     if (nodeInfo == NULL) {
1563         LNN_LOGE(LNN_LEDGER, "get info fail");
1564         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1565         return SOFTBUS_NOT_FIND;
1566     }
1567     *timestamp = nodeInfo->onlinetTimestamp;
1568     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1569     return SOFTBUS_OK;
1570 }
1571 
LnnGetDLHeartbeatTimestamp(const char * networkId,uint64_t * timestamp)1572 int32_t LnnGetDLHeartbeatTimestamp(const char *networkId, uint64_t *timestamp)
1573 {
1574     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1575         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1576         return SOFTBUS_LOCK_ERR;
1577     }
1578     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1579     if (nodeInfo == NULL) {
1580         LNN_LOGE(LNN_LEDGER, "get info fail");
1581         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1582         return SOFTBUS_NOT_FIND;
1583     }
1584     *timestamp = nodeInfo->heartbeatTimeStamp;
1585     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1586     return SOFTBUS_OK;
1587 }
1588 
LnnSetDLHeartbeatTimestamp(const char * networkId,uint64_t timestamp)1589 int32_t LnnSetDLHeartbeatTimestamp(const char *networkId, uint64_t timestamp)
1590 {
1591     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1592         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1593         return SOFTBUS_LOCK_ERR;
1594     }
1595     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1596     if (nodeInfo == NULL) {
1597         LNN_LOGE(LNN_LEDGER, "get info fail");
1598         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1599         return SOFTBUS_NOT_FIND;
1600     }
1601     nodeInfo->heartbeatTimeStamp = timestamp;
1602     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1603     return SOFTBUS_OK;
1604 }
1605 
LnnGetDLBleDirectTimestamp(const char * networkId,uint64_t * timestamp)1606 int32_t LnnGetDLBleDirectTimestamp(const char *networkId, uint64_t *timestamp)
1607 {
1608     if (networkId == NULL || timestamp == NULL) {
1609         LNN_LOGE(LNN_LEDGER, "invalid param");
1610         return SOFTBUS_INVALID_PARAM;
1611     }
1612     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1613         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1614         return SOFTBUS_LOCK_ERR;
1615     }
1616     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1617     if (nodeInfo == NULL) {
1618         LNN_LOGE(LNN_LEDGER, "get info fail");
1619         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1620         return SOFTBUS_NOT_FIND;
1621     }
1622     *timestamp = nodeInfo->bleDirectTimeStamp;
1623     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1624     return SOFTBUS_OK;
1625 }
1626 
LnnGetDLUpdateTimestamp(const char * udid,uint64_t * timestamp)1627 int32_t LnnGetDLUpdateTimestamp(const char *udid, uint64_t *timestamp)
1628 {
1629     if (udid == NULL || timestamp == NULL) {
1630         LNN_LOGE(LNN_LEDGER, "invalid param");
1631         return SOFTBUS_INVALID_PARAM;
1632     }
1633     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1634         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1635         return SOFTBUS_LOCK_ERR;
1636     }
1637     NodeInfo *nodeInfo = LnnGetNodeInfoById(udid, CATEGORY_UDID);
1638     if (nodeInfo == NULL) {
1639         LNN_LOGE(LNN_LEDGER, "get info fail");
1640         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1641         return SOFTBUS_NOT_FIND;
1642     }
1643     *timestamp = nodeInfo->updateTimestamp;
1644     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1645     return SOFTBUS_OK;
1646 }
1647 
LnnGetDLAuthCapacity(const char * networkId,uint32_t * authCapacity)1648 int32_t LnnGetDLAuthCapacity(const char *networkId, uint32_t *authCapacity)
1649 {
1650     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1651         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1652         return SOFTBUS_LOCK_ERR;
1653     }
1654     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1655     if (nodeInfo == NULL) {
1656         LNN_LOGE(LNN_LEDGER, "get info fail");
1657         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1658         return SOFTBUS_NOT_FIND;
1659     }
1660     *authCapacity = nodeInfo->authCapacity;
1661     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1662     return SOFTBUS_OK;
1663 }
1664 
LnnSetDLBleDirectTimestamp(const char * networkId,uint64_t timestamp)1665 int32_t LnnSetDLBleDirectTimestamp(const char *networkId, uint64_t timestamp)
1666 {
1667     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1668         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1669         return SOFTBUS_LOCK_ERR;
1670     }
1671     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1672     if (nodeInfo == NULL) {
1673         LNN_LOGE(LNN_LEDGER, "get info fail");
1674         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1675         return SOFTBUS_NOT_FIND;
1676     }
1677     nodeInfo->bleDirectTimeStamp = timestamp;
1678     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1679     return SOFTBUS_OK;
1680 }
1681 
LnnSetDLConnCapability(const char * networkId,uint32_t connCapability)1682 int32_t LnnSetDLConnCapability(const char *networkId, uint32_t connCapability)
1683 {
1684     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1685         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1686         return SOFTBUS_LOCK_ERR;
1687     }
1688     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1689     if (nodeInfo == NULL) {
1690         LNN_LOGE(LNN_LEDGER, "get info fail");
1691         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1692         return SOFTBUS_NOT_FIND;
1693     }
1694     nodeInfo->netCapacity = connCapability;
1695     if (LnnSaveRemoteDeviceInfo(nodeInfo) != SOFTBUS_OK) {
1696         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1697         LNN_LOGE(LNN_LEDGER, "save remote netCapacity fail");
1698         return SOFTBUS_ERR;
1699     }
1700     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1701     return SOFTBUS_OK;
1702 }
1703 
LnnSetDLBatteryInfo(const char * networkId,const BatteryInfo * info)1704 int32_t LnnSetDLBatteryInfo(const char *networkId, const BatteryInfo *info)
1705 {
1706     if (networkId == NULL || info == NULL) {
1707         return SOFTBUS_INVALID_PARAM;
1708     }
1709     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1710         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1711         return SOFTBUS_LOCK_ERR;
1712     }
1713     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1714     if (nodeInfo == NULL) {
1715         LNN_LOGE(LNN_LEDGER, "get info fail");
1716         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1717         return SOFTBUS_NOT_FIND;
1718     }
1719     nodeInfo->batteryInfo.batteryLevel = info->batteryLevel;
1720     nodeInfo->batteryInfo.isCharging = info->isCharging;
1721     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1722     return SOFTBUS_OK;
1723 }
1724 
LnnSetDLBssTransInfo(const char * networkId,const BssTransInfo * info)1725 int32_t LnnSetDLBssTransInfo(const char *networkId, const BssTransInfo *info)
1726 {
1727     if (networkId == NULL || info == NULL) {
1728         return SOFTBUS_INVALID_PARAM;
1729     }
1730     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1731         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1732         return SOFTBUS_LOCK_ERR;
1733     }
1734     NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1735     if (nodeInfo == NULL) {
1736         LNN_LOGE(LNN_LEDGER, "get info fail");
1737         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1738         return SOFTBUS_NOT_FIND;
1739     }
1740     if (memcpy_s(&(nodeInfo->bssTransInfo), sizeof(BssTransInfo), info,
1741         sizeof(BssTransInfo)) != SOFTBUS_OK) {
1742         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1743         return SOFTBUS_MEM_ERR;
1744     }
1745     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1746     return SOFTBUS_OK;
1747 }
1748 
LnnSetDLNodeAddr(const char * id,IdCategory type,const char * addr)1749 int32_t LnnSetDLNodeAddr(const char *id, IdCategory type, const char *addr)
1750 {
1751     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1752         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1753         return SOFTBUS_LOCK_ERR;
1754     }
1755     NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
1756     if (nodeInfo == NULL) {
1757         LNN_LOGE(LNN_LEDGER, "get info fail");
1758         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1759         return SOFTBUS_NOT_FIND;
1760     }
1761     int ret = strcpy_s(nodeInfo->nodeAddress, sizeof(nodeInfo->nodeAddress), addr);
1762     if (ret != EOK) {
1763         LNN_LOGE(LNN_LEDGER, "set node addr failed! ret=%{public}d", ret);
1764     }
1765     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1766     return ret == EOK ? SOFTBUS_OK : SOFTBUS_ERR;
1767 }
1768 
LnnSetDLProxyPort(const char * id,IdCategory type,int32_t proxyPort)1769 int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort)
1770 {
1771     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1772         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1773         return SOFTBUS_LOCK_ERR;
1774     }
1775     NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
1776     if (nodeInfo == NULL) {
1777         LNN_LOGE(LNN_LEDGER, "get info fail");
1778         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1779         return SOFTBUS_NOT_FIND;
1780     }
1781     nodeInfo->connectInfo.proxyPort = proxyPort;
1782     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1783     return SOFTBUS_OK;
1784 }
1785 
LnnSetDLSessionPort(const char * id,IdCategory type,int32_t sessionPort)1786 int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort)
1787 {
1788     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1789         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1790         return SOFTBUS_LOCK_ERR;
1791     }
1792     NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
1793     if (nodeInfo == NULL) {
1794         LNN_LOGE(LNN_LEDGER, "get info fail");
1795         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1796         return SOFTBUS_NOT_FIND;
1797     }
1798     nodeInfo->connectInfo.sessionPort = sessionPort;
1799     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1800     return SOFTBUS_OK;
1801 }
1802 
LnnSetDLAuthPort(const char * id,IdCategory type,int32_t authPort)1803 int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort)
1804 {
1805     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1806         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1807         return SOFTBUS_LOCK_ERR;
1808     }
1809     NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
1810     if (nodeInfo == NULL) {
1811         LNN_LOGE(LNN_LEDGER, "get info fail");
1812         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1813         return SOFTBUS_NOT_FIND;
1814     }
1815     nodeInfo->connectInfo.authPort = authPort;
1816     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1817     return SOFTBUS_OK;
1818 }
1819 
LnnSetDLP2pIp(const char * id,IdCategory type,const char * p2pIp)1820 int32_t LnnSetDLP2pIp(const char *id, IdCategory type, const char *p2pIp)
1821 {
1822     if (id == NULL || p2pIp == NULL) {
1823         LNN_LOGE(LNN_LEDGER, "invalid param");
1824         return SOFTBUS_INVALID_PARAM;
1825     }
1826     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1827         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1828         return SOFTBUS_LOCK_ERR;
1829     }
1830     NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
1831     if (nodeInfo == NULL) {
1832         LNN_LOGE(LNN_LEDGER, "get info fail");
1833         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1834         return SOFTBUS_NOT_FIND;
1835     }
1836     if (strcpy_s(nodeInfo->p2pInfo.p2pIp, sizeof(nodeInfo->p2pInfo.p2pIp), p2pIp) != EOK) {
1837         LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1838         (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1839         return SOFTBUS_MEM_ERR;
1840     }
1841     (void)SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1842     return SOFTBUS_OK;
1843 }
1844 
LnnSetDLWifiDirectAddr(const char * networkId,const char * addr)1845 bool LnnSetDLWifiDirectAddr(const char *networkId, const char *addr)
1846 {
1847     NodeInfo *node = NULL;
1848     if (networkId == NULL || addr == NULL) {
1849         LNN_LOGE(LNN_LEDGER, "invalid param");
1850         return false;
1851     }
1852     if (SoftBusMutexLock(&(LnnGetDistributedNetLedger()->lock)) != 0) {
1853         LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1854         return false;
1855     }
1856     node = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
1857     if (node == NULL) {
1858         LNN_LOGE(LNN_LEDGER, "udid not found");
1859         goto EXIT;
1860     }
1861     if (LnnSetWifiDirectAddr(node, addr) != SOFTBUS_OK) {
1862         LNN_LOGE(LNN_LEDGER, "set wifidirect addr fail");
1863         goto EXIT;
1864     }
1865     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1866     return true;
1867 EXIT:
1868     SoftBusMutexUnlock(&(LnnGetDistributedNetLedger()->lock));
1869     return false;
1870 }