1 /*
2 * Copyright (c) 2021-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_local_net_ledger.h"
17
18 #include <stddef.h>
19 #include <stdlib.h>
20 #include <string.h>
21
22 #include <securec.h>
23
24 #include "anonymizer.h"
25 #include "bus_center_adapter.h"
26 #include "bus_center_manager.h"
27 #include "lnn_cipherkey_manager.h"
28 #include "lnn_data_cloud_sync.h"
29 #include "lnn_device_info_recovery.h"
30 #include "lnn_log.h"
31 #include "lnn_ohos_account.h"
32 #include "lnn_p2p_info.h"
33 #include "lnn_feature_capability.h"
34 #include "lnn_settingdata_event_monitor.h"
35 #include "softbus_adapter_bt_common.h"
36 #include "softbus_adapter_crypto.h"
37 #include "softbus_adapter_thread.h"
38 #include "softbus_def.h"
39 #include "softbus_errcode.h"
40 #include "softbus_utils.h"
41 #include "softbus_hidumper_buscenter.h"
42
43 #define SOFTBUS_VERSION "hm.1.0.0"
44 #define VERSION_TYPE_LITE "LITE"
45 #define VERSION_TYPE_DEFAULT ""
46 #define SOFTBUS_BUSCENTER_DUMP_LOCALDEVICEINFO "local_device_info"
47 #define ALL_GROUP_TYPE 0xF
48 #define MAX_STATE_VERSION 0xFF
49 #define DEFAULT_SUPPORT_AUTHCAPACITY 0xF
50 #define DEFAULT_SUPPORT_HBCAPACITY 0x2
51 #define DEFAULT_CONN_SUB_FEATURE 1
52 #define CACHE_KEY_LENGTH 32
53 #define STATE_VERSION_VALUE_LENGTH 8
54 #define DEFAULT_DEVICE_NAME "OpenHarmony"
55
56 typedef struct {
57 NodeInfo localInfo;
58 SoftBusMutex lock;
59 LocalLedgerStatus status;
60 } LocalNetLedger;
61
62 static LocalNetLedger g_localNetLedger;
63
UpdateStateVersionAndStore(StateVersionChangeReason reason)64 static void UpdateStateVersionAndStore(StateVersionChangeReason reason)
65 {
66 int32_t ret;
67 g_localNetLedger.localInfo.stateVersion++;
68 if (g_localNetLedger.localInfo.stateVersion > MAX_STATE_VERSION) {
69 g_localNetLedger.localInfo.stateVersion = 1;
70 }
71 g_localNetLedger.localInfo.stateVersionReason = reason;
72 LNN_LOGI(LNN_LEDGER,
73 "reason=%{public}u changed, update local stateVersion=%{public}d, stateVersionReason=%{public}u", reason,
74 g_localNetLedger.localInfo.stateVersion, g_localNetLedger.localInfo.stateVersionReason);
75
76 if ((ret = LnnSaveLocalDeviceInfo(&g_localNetLedger.localInfo)) != SOFTBUS_OK) {
77 LNN_LOGE(LNN_LEDGER, "update local store fail");
78 }
79 }
80
LlGetNodeSoftBusVersion(void * buf,uint32_t len)81 static int32_t LlGetNodeSoftBusVersion(void *buf, uint32_t len)
82 {
83 NodeInfo *info = &g_localNetLedger.localInfo;
84 if (buf == NULL) {
85 return SOFTBUS_INVALID_PARAM;
86 }
87 if (strncpy_s((char *)buf, len, info->softBusVersion, strlen(info->softBusVersion)) != EOK) {
88 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
89 return SOFTBUS_MEM_ERR;
90 }
91 return SOFTBUS_OK;
92 }
93
LlGetDeviceUdid(void * buf,uint32_t len)94 static int32_t LlGetDeviceUdid(void *buf, uint32_t len)
95 {
96 const char *udid = NULL;
97 NodeInfo *info = &g_localNetLedger.localInfo;
98 if (buf == NULL) {
99 return SOFTBUS_INVALID_PARAM;
100 }
101 udid = LnnGetDeviceUdid(info);
102 if (udid == NULL) {
103 LNN_LOGE(LNN_LEDGER, "get device udid fail");
104 return SOFTBUS_ERR;
105 }
106 if (strlen(udid) <= 0) {
107 LNN_LOGE(LNN_LEDGER, "get local udid invalid");
108 return SOFTBUS_ERR;
109 }
110 if (strncpy_s((char *)buf, len, udid, strlen(udid)) != EOK) {
111 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
112 return SOFTBUS_MEM_ERR;
113 }
114 return SOFTBUS_OK;
115 }
116
LlGetNetworkId(void * buf,uint32_t len)117 static int32_t LlGetNetworkId(void *buf, uint32_t len)
118 {
119 NodeInfo *info = &g_localNetLedger.localInfo;
120 if (buf == NULL) {
121 return SOFTBUS_INVALID_PARAM;
122 }
123 if (strncpy_s((char *)buf, len, info->networkId, strlen(info->networkId)) != EOK) {
124 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
125 return SOFTBUS_MEM_ERR;
126 }
127 return SOFTBUS_OK;
128 }
129
LlGetOsVersion(void * buf,uint32_t len)130 static int32_t LlGetOsVersion(void *buf, uint32_t len)
131 {
132 NodeInfo *info = &g_localNetLedger.localInfo;
133 if (buf == NULL) {
134 LNN_LOGE(LNN_LEDGER, "buf of osVersion is null");
135 return SOFTBUS_INVALID_PARAM;
136 }
137 if (strcpy_s((char *)buf, len, info->deviceInfo.osVersion) != EOK) {
138 LNN_LOGE(LNN_LEDGER, "strcpy_s osVersion ERROR!");
139 return SOFTBUS_MEM_ERR;
140 }
141 return SOFTBUS_OK;
142 }
143
LlGetOffLineCode(void * buf,uint32_t len)144 static int32_t LlGetOffLineCode(void *buf, uint32_t len)
145 {
146 NodeInfo *info = &g_localNetLedger.localInfo;
147 if (buf == NULL) {
148 LNN_LOGE(LNN_LEDGER, "buf of offlinecode is null");
149 return SOFTBUS_INVALID_PARAM;
150 }
151 if (memcpy_s(buf, len, info->offlineCode, OFFLINE_CODE_BYTE_SIZE) != EOK) {
152 LNN_LOGE(LNN_LEDGER, "memcpy_s offlinecode ERROR");
153 return SOFTBUS_MEM_ERR;
154 }
155 return SOFTBUS_OK;
156 }
157
LlGetExtData(void * buf,uint32_t len)158 static int32_t LlGetExtData(void *buf, uint32_t len)
159 {
160 NodeInfo *info = &g_localNetLedger.localInfo;
161 if (buf == NULL) {
162 LNN_LOGE(LNN_LEDGER, "buf of offlinecode is null");
163 return SOFTBUS_INVALID_PARAM;
164 }
165 if (memcpy_s(buf, len, info->extData, EXTDATA_LEN) != EOK) {
166 LNN_LOGE(LNN_LEDGER, "memcpy_s offlinecode ERROR!");
167 return SOFTBUS_MEM_ERR;
168 }
169 return SOFTBUS_OK;
170 }
171
LlGetBleMac(void * buf,uint32_t len)172 static int32_t LlGetBleMac(void *buf, uint32_t len)
173 {
174 NodeInfo *info = &g_localNetLedger.localInfo;
175 const char *mac = NULL;
176 if (buf == NULL) {
177 return SOFTBUS_INVALID_PARAM;
178 }
179 mac = LnnGetBleMac(info);
180 if (mac == NULL) {
181 LNN_LOGE(LNN_LEDGER, "get ble mac fail.");
182 return SOFTBUS_ERR;
183 }
184 if (strcpy_s((char *)buf, len, mac) != EOK) {
185 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
186 return SOFTBUS_MEM_ERR;
187 }
188 return SOFTBUS_OK;
189 }
190
LlGetUuid(void * buf,uint32_t len)191 static int32_t LlGetUuid(void *buf, uint32_t len)
192 {
193 NodeInfo *info = &g_localNetLedger.localInfo;
194 if (buf == NULL) {
195 return SOFTBUS_INVALID_PARAM;
196 }
197 if (strncpy_s((char *)buf, len, info->uuid, strlen(info->uuid)) != EOK) {
198 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
199 return SOFTBUS_MEM_ERR;
200 }
201 return SOFTBUS_OK;
202 }
203
L1GetNodeScreenOnFlag(void * buf,uint32_t len)204 static int32_t L1GetNodeScreenOnFlag(void *buf, uint32_t len)
205 {
206 if (buf == NULL) {
207 LNN_LOGE(LNN_LEDGER, "buf is NULL");
208 return SOFTBUS_INVALID_PARAM;
209 }
210 if (len != NODE_SCREEN_STATUS_LEN) {
211 LNN_LOGE(LNN_LEDGER, "buf len=%{public}d is invalid", len);
212 return SOFTBUS_INVALID_PARAM;
213 }
214 *((bool *)buf) = g_localNetLedger.localInfo.isScreenOn;
215 return SOFTBUS_OK;
216 }
217
UpdateLocalDeviceUdid(const void * buf)218 static int32_t UpdateLocalDeviceUdid(const void *buf)
219 {
220 NodeInfo *info = &g_localNetLedger.localInfo;
221 if (buf == NULL) {
222 return SOFTBUS_INVALID_PARAM;
223 }
224 return LnnSetDeviceUdid(info, (char *)buf);
225 }
226
LlGetDeviceType(void * buf,uint32_t len)227 static int32_t LlGetDeviceType(void *buf, uint32_t len)
228 {
229 NodeInfo *info = &g_localNetLedger.localInfo;
230 char *deviceType = NULL;
231 if (buf == NULL) {
232 return SOFTBUS_INVALID_PARAM;
233 }
234 deviceType = LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId);
235 if (deviceType == NULL) {
236 LNN_LOGE(LNN_LEDGER, "deviceType fail");
237 return SOFTBUS_ERR;
238 }
239 if (strncpy_s((char *)buf, len, deviceType, strlen(deviceType)) != EOK) {
240 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
241 return SOFTBUS_MEM_ERR;
242 }
243 return SOFTBUS_OK;
244 }
245
LlGetWifiDirectAddr(void * buf,uint32_t len)246 static int32_t LlGetWifiDirectAddr(void *buf, uint32_t len)
247 {
248 const char *wifiDirectAddr = NULL;
249 if (buf == NULL || len < MAC_LEN) {
250 LNN_LOGE(LNN_LEDGER, "invalid param");
251 return SOFTBUS_INVALID_PARAM;
252 }
253 wifiDirectAddr = LnnGetWifiDirectAddr(&g_localNetLedger.localInfo);
254 if (wifiDirectAddr == NULL) {
255 LNN_LOGE(LNN_LEDGER, "get wifidirect addr fail");
256 return SOFTBUS_ERR;
257 }
258 if (strncpy_s((char *)buf, len, wifiDirectAddr, strlen(wifiDirectAddr)) != EOK) {
259 LNN_LOGE(LNN_LEDGER, "copy wifidirect addr failed");
260 return SOFTBUS_MEM_ERR;
261 }
262 return SOFTBUS_OK;
263 }
264
LlGetAccount(void * buf,uint32_t len)265 static int32_t LlGetAccount(void *buf, uint32_t len)
266 {
267 NodeInfo *info = &g_localNetLedger.localInfo;
268
269 if (buf == NULL) {
270 return SOFTBUS_INVALID_PARAM;
271 }
272 if (memcpy_s(buf, len, info->accountHash, SHA_256_HASH_LEN) != EOK) {
273 LNN_LOGE(LNN_LEDGER, "LlGetAccount copy error");
274 return SOFTBUS_MEM_ERR;
275 }
276 return SOFTBUS_OK;
277 }
278
LlUpdateAccount(const void * buf)279 static int32_t LlUpdateAccount(const void *buf)
280 {
281 if (buf == NULL) {
282 return SOFTBUS_INVALID_PARAM;
283 }
284
285 NodeInfo *info = &g_localNetLedger.localInfo;
286 if (memcpy_s(info->accountHash, SHA_256_HASH_LEN, buf, SHA_256_HASH_LEN) != EOK) {
287 LNN_LOGE(LNN_LEDGER, "LlUpdateAccount copy error");
288 return SOFTBUS_MEM_ERR;
289 }
290 return SOFTBUS_OK;
291 }
292
UpdateWifiDirectAddr(const void * wifiDirectAddr)293 static int32_t UpdateWifiDirectAddr(const void *wifiDirectAddr)
294 {
295 if (wifiDirectAddr == NULL) {
296 LNN_LOGE(LNN_LEDGER, "para error");
297 return SOFTBUS_INVALID_PARAM;
298 }
299 return LnnSetWifiDirectAddr(&g_localNetLedger.localInfo, (char *)wifiDirectAddr);
300 }
301
UpdateLocalDeviceType(const void * buf)302 static int32_t UpdateLocalDeviceType(const void *buf)
303 {
304 NodeInfo *info = &g_localNetLedger.localInfo;
305 uint16_t typeId;
306 if (buf == NULL) {
307 return SOFTBUS_INVALID_PARAM;
308 }
309 if (LnnConvertDeviceTypeToId((char *)buf, &typeId) == SOFTBUS_OK) {
310 info->deviceInfo.deviceTypeId = typeId;
311 LNN_LOGI(LNN_LEDGER, "update local deviceTypeId=%{public}u, deviceType=%{public}s", typeId, (char *)buf);
312 return SOFTBUS_OK;
313 }
314 LNN_LOGE(LNN_LEDGER, "set device type error");
315 return SOFTBUS_ERR;
316 }
317
UpdateNodeDataChangeFlag(const void * buf)318 static int32_t UpdateNodeDataChangeFlag(const void *buf)
319 {
320 NodeInfo *info = &g_localNetLedger.localInfo;
321 if (buf == NULL) {
322 return SOFTBUS_INVALID_PARAM;
323 }
324 return LnnSetDataChangeFlag(info, *(int16_t *)buf);
325 }
326
LocalUpdateNodeAccountId(const void * buf)327 static int32_t LocalUpdateNodeAccountId(const void *buf)
328 {
329 NodeInfo *info = &g_localNetLedger.localInfo;
330 if (buf == NULL) {
331 return SOFTBUS_INVALID_PARAM;
332 }
333
334 int64_t accountId = 0;
335 if (LnnGetAccountIdFromLocalCache(&accountId) != SOFTBUS_OK) {
336 LNN_LOGE(LNN_LEDGER, "get accountId info from cache fail");
337 }
338 if (accountId == *((int64_t *)buf) && *((int64_t *)buf) != 0) {
339 LNN_LOGI(LNN_LEDGER, "no new accountId login");
340 info->accountId = *((int64_t *)buf);
341 return SOFTBUS_OK;
342 }
343 if (info->accountId == 0) {
344 if (*((int64_t *)buf) == 0) {
345 LNN_LOGI(LNN_LEDGER, "no accountId login, default is 0");
346 return SOFTBUS_OK;
347 }
348 LNN_LOGI(LNN_LEDGER, "accountId login");
349 info->accountId = *((int64_t *)buf);
350 UpdateStateVersionAndStore(UPDATE_ACCOUNT_LONG);
351 return SOFTBUS_OK;
352 }
353 if (*((int64_t *)buf) == 0) {
354 LNN_LOGI(LNN_LEDGER, "accountId logout");
355 info->accountId = *((int64_t *)buf);
356 LnnSaveLocalDeviceInfo(info);
357 return SOFTBUS_OK;
358 }
359 LNN_LOGI(LNN_LEDGER, "accountId changed, accountId=%{public}" PRId64 "->%{public}" PRId64, info->accountId,
360 *((int64_t *)buf));
361 info->accountId = *((int64_t *)buf);
362 UpdateStateVersionAndStore(UPDATE_ACCOUNT_LONG);
363 return SOFTBUS_OK;
364 }
365
LocalUpdateBleStartTime(const void * buf)366 static int32_t LocalUpdateBleStartTime(const void *buf)
367 {
368 NodeInfo *info = &g_localNetLedger.localInfo;
369 if (buf == NULL) {
370 return SOFTBUS_INVALID_PARAM;
371 }
372 info->bleStartTimestamp = *((int64_t *)buf);
373 return SOFTBUS_OK;
374 }
375
LocalUpdateNetworkIdTimeStamp(const void * buf)376 static int32_t LocalUpdateNetworkIdTimeStamp(const void *buf)
377 {
378 NodeInfo *info = &g_localNetLedger.localInfo;
379 if (buf == NULL) {
380 return SOFTBUS_INVALID_PARAM;
381 }
382 info->networkIdTimestamp = *((int64_t *)buf);
383 LNN_LOGI(LNN_LEDGER, "local networkId timeStamp=%{public}" PRId64, info->networkIdTimestamp);
384 return SOFTBUS_OK;
385 }
386
LlGetDeviceName(void * buf,uint32_t len)387 static int32_t LlGetDeviceName(void *buf, uint32_t len)
388 {
389 NodeInfo *info = &g_localNetLedger.localInfo;
390 const char *deviceName = NULL;
391 if (buf == NULL) {
392 return SOFTBUS_INVALID_PARAM;
393 }
394 deviceName = LnnGetDeviceName(&info->deviceInfo);
395 if (deviceName == NULL) {
396 LNN_LOGE(LNN_LEDGER, "get device name fail");
397 return SOFTBUS_ERR;
398 }
399 if (strlen(deviceName) != 0) {
400 if (strncpy_s((char *)buf, len, deviceName, strlen(deviceName)) != EOK) {
401 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
402 return SOFTBUS_MEM_ERR;
403 }
404 } else {
405 LNN_LOGI(LNN_LEDGER, "device name not inited, user default value");
406 if (strncpy_s((char *)buf, len, DEFAULT_DEVICE_NAME, strlen(DEFAULT_DEVICE_NAME)) != EOK) {
407 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
408 return SOFTBUS_MEM_ERR;
409 }
410 }
411 return SOFTBUS_OK;
412 }
413
LlGetUnifiedName(void * buf,uint32_t len)414 static int32_t LlGetUnifiedName(void *buf, uint32_t len)
415 {
416 NodeInfo *info = &g_localNetLedger.localInfo;
417 if (buf == NULL) {
418 return SOFTBUS_INVALID_PARAM;
419 }
420 if (strncpy_s((char *)buf, len, info->deviceInfo.unifiedName, strlen(info->deviceInfo.unifiedName)) != EOK) {
421 LNN_LOGE(LNN_LEDGER, "strcpy err");
422 return SOFTBUS_MEM_ERR;
423 }
424 return SOFTBUS_OK;
425 }
426
LlGetUnifiedDefaultName(void * buf,uint32_t len)427 static int32_t LlGetUnifiedDefaultName(void *buf, uint32_t len)
428 {
429 NodeInfo *info = &g_localNetLedger.localInfo;
430 if (buf == NULL) {
431 return SOFTBUS_INVALID_PARAM;
432 }
433 if (strncpy_s((char *)buf, len, info->deviceInfo.unifiedDefaultName,
434 strlen(info->deviceInfo.unifiedDefaultName)) != EOK) {
435 LNN_LOGE(LNN_LEDGER, "strcpy err");
436 return SOFTBUS_MEM_ERR;
437 }
438 return SOFTBUS_OK;
439 }
440
LlGetNickName(void * buf,uint32_t len)441 static int32_t LlGetNickName(void *buf, uint32_t len)
442 {
443 NodeInfo *info = &g_localNetLedger.localInfo;
444 if (buf == NULL) {
445 return SOFTBUS_INVALID_PARAM;
446 }
447 if (strncpy_s((char *)buf, len, info->deviceInfo.nickName, strlen(info->deviceInfo.nickName)) != EOK) {
448 LNN_LOGE(LNN_LEDGER, "strcpy err");
449 return SOFTBUS_MEM_ERR;
450 }
451 return SOFTBUS_OK;
452 }
453
UpdateBrMac(void)454 static void UpdateBrMac(void)
455 {
456 char brMac[BT_MAC_LEN] = {0};
457 SoftBusBtAddr mac = {0};
458 int32_t ret = 0;
459 ret = SoftBusGetBtMacAddr(&mac);
460 if (ret != SOFTBUS_OK) {
461 LNN_LOGE(LNN_LEDGER, "get bt mac addr fail");
462 return;
463 }
464 ret = ConvertBtMacToStr(brMac, BT_MAC_LEN, mac.addr, sizeof(mac.addr));
465 if (ret != SOFTBUS_OK) {
466 LNN_LOGE(LNN_LEDGER, "convert bt mac to str fail");
467 return;
468 }
469 if (strcpy_s(g_localNetLedger.localInfo.connectInfo.macAddr, MAC_LEN, brMac) != EOK) {
470 LNN_LOGE(LNN_LEDGER, "str copy error!");
471 }
472 }
473
LlGetBtMac(void * buf,uint32_t len)474 static int32_t LlGetBtMac(void *buf, uint32_t len)
475 {
476 NodeInfo *info = &g_localNetLedger.localInfo;
477 const char *mac = NULL;
478 if (buf == NULL) {
479 return SOFTBUS_INVALID_PARAM;
480 }
481 mac = LnnGetBtMac(info);
482 if (mac == NULL) {
483 LNN_LOGE(LNN_LEDGER, "get bt mac fail.");
484 return SOFTBUS_ERR;
485 }
486 if (SoftBusGetBtState() == BLE_ENABLE && mac[0] == '\0') {
487 LNN_LOGE(LNN_LEDGER, "bt status is on update brmac");
488 UpdateBrMac();
489 }
490 if (strcpy_s((char *)buf, len, mac) != EOK) {
491 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR!");
492 return SOFTBUS_MEM_ERR;
493 }
494 return SOFTBUS_OK;
495 }
496
LlGetWlanIp(void * buf,uint32_t len)497 static int32_t LlGetWlanIp(void *buf, uint32_t len)
498 {
499 NodeInfo *info = &g_localNetLedger.localInfo;
500 const char *ip = NULL;
501 if (buf == NULL) {
502 return SOFTBUS_INVALID_PARAM;
503 }
504 ip = LnnGetWiFiIp(info);
505 if (ip == NULL) {
506 LNN_LOGE(LNN_LEDGER, "get wifi ip fail");
507 return SOFTBUS_ERR;
508 }
509 char *anonyIp = NULL;
510 Anonymize(ip, &anonyIp);
511 LNN_LOGD(LNN_LEDGER, "get LocalIp=%{public}s", anonyIp);
512 AnonymizeFree(anonyIp);
513 if (strncpy_s((char *)buf, len, ip, strlen(ip)) != EOK) {
514 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
515 return SOFTBUS_MEM_ERR;
516 }
517 return SOFTBUS_OK;
518 }
519
LlGetNetIfName(void * buf,uint32_t len)520 static int32_t LlGetNetIfName(void *buf, uint32_t len)
521 {
522 NodeInfo *info = &g_localNetLedger.localInfo;
523 const char *ifName = NULL;
524 if (buf == NULL) {
525 return SOFTBUS_INVALID_PARAM;
526 }
527 ifName = LnnGetNetIfName(info);
528 if (ifName == NULL) {
529 LNN_LOGE(LNN_LEDGER, "get bt mac fail");
530 return SOFTBUS_ERR;
531 }
532 if (strncpy_s((char *)buf, len, ifName, strlen(ifName)) != EOK) {
533 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
534 return SOFTBUS_MEM_ERR;
535 }
536 return SOFTBUS_OK;
537 }
538
L1GetMasterNodeUdid(void * buf,uint32_t len)539 static int32_t L1GetMasterNodeUdid(void *buf, uint32_t len)
540 {
541 NodeInfo *info = &g_localNetLedger.localInfo;
542 const char *udid = NULL;
543
544 if (buf == NULL || len < UDID_BUF_LEN) {
545 LNN_LOGE(LNN_LEDGER, "invalid get master node udid arguments");
546 return SOFTBUS_INVALID_PARAM;
547 }
548 udid = LnnGetMasterUdid(info);
549 if (udid == NULL) {
550 LNN_LOGE(LNN_LEDGER, "get master udid fail");
551 return SOFTBUS_ERR;
552 }
553 if (strncpy_s((char *)buf, len, udid, strlen(udid)) != EOK) {
554 LNN_LOGE(LNN_LEDGER, "copy master udid failed");
555 return SOFTBUS_MEM_ERR;
556 }
557 return SOFTBUS_OK;
558 }
559
LlGetAuthPort(void * buf,uint32_t len)560 static int32_t LlGetAuthPort(void *buf, uint32_t len)
561 {
562 NodeInfo *info = &g_localNetLedger.localInfo;
563 if (buf == NULL || len != LNN_COMMON_LEN) {
564 return SOFTBUS_INVALID_PARAM;
565 }
566 int32_t port = LnnGetAuthPort(info);
567 if (port <= 0) {
568 return SOFTBUS_ERR;
569 }
570 *((int32_t *)buf) = port;
571 return SOFTBUS_OK;
572 }
573
UpdateLocalAuthPort(const void * buf)574 static int32_t UpdateLocalAuthPort(const void *buf)
575 {
576 NodeInfo *info = &g_localNetLedger.localInfo;
577 if (buf == NULL) {
578 return SOFTBUS_INVALID_PARAM;
579 }
580 return LnnSetAuthPort(info, *(int *)buf);
581 }
582
LlGetSessionPort(void * buf,uint32_t len)583 static int32_t LlGetSessionPort(void *buf, uint32_t len)
584 {
585 NodeInfo *info = &g_localNetLedger.localInfo;
586 if (buf == NULL || len != LNN_COMMON_LEN) {
587 return SOFTBUS_INVALID_PARAM;
588 }
589 *((int32_t *)buf) = LnnGetSessionPort(info);
590 return SOFTBUS_OK;
591 }
592
UpdateLocalSessionPort(const void * buf)593 static int32_t UpdateLocalSessionPort(const void *buf)
594 {
595 NodeInfo *info = &g_localNetLedger.localInfo;
596 if (buf == NULL) {
597 return SOFTBUS_INVALID_PARAM;
598 }
599 return LnnSetSessionPort(info, *(int *)buf);
600 }
601
LlGetProxyPort(void * buf,uint32_t len)602 static int32_t LlGetProxyPort(void *buf, uint32_t len)
603 {
604 NodeInfo *info = &g_localNetLedger.localInfo;
605 if (buf == NULL || len != LNN_COMMON_LEN) {
606 return SOFTBUS_INVALID_PARAM;
607 }
608 *((int32_t *)buf) = LnnGetProxyPort(info);
609 return SOFTBUS_OK;
610 }
611
IsLocalLedgerReady(void)612 static bool IsLocalLedgerReady(void)
613 {
614 bool accountIdInited = (g_localNetLedger.localInfo.accountId != 0);
615 bool deviceNameInited = (strlen(g_localNetLedger.localInfo.deviceInfo.deviceName) != 0);
616 bool networkIdInited = (strlen(g_localNetLedger.localInfo.networkId) != 0);
617 bool btMacInited = (strlen(g_localNetLedger.localInfo.connectInfo.macAddr) != 0);
618 if (accountIdInited & deviceNameInited & networkIdInited & btMacInited) {
619 return true;
620 }
621 LNN_LOGI(LNN_LEDGER, "no need upload to cloud. stateVersion=%{public}d, accountIdInited=%{public}d, "
622 "deviceNameInited=%{public}d, networkIdInited=%{public}d, btMacInited=%{public}d",
623 g_localNetLedger.localInfo.stateVersion, accountIdInited, deviceNameInited, networkIdInited, btMacInited);
624 return false;
625 }
626
UpdateStateVersion(const void * buf)627 static int32_t UpdateStateVersion(const void *buf)
628 {
629 NodeInfo *info = &g_localNetLedger.localInfo;
630 if (buf == NULL) {
631 return SOFTBUS_INVALID_PARAM;
632 }
633 if (*(int32_t *)buf > MAX_STATE_VERSION) {
634 *(int32_t *)buf = 1;
635 }
636 if (info->stateVersion == *(int32_t *)buf) {
637 LNN_LOGI(LNN_LEDGER, "unchanged. no need update, stateVersion=%{public}d", info->stateVersion);
638 return SOFTBUS_OK;
639 }
640 info->stateVersion = *(int32_t *)buf;
641 if (!IsLocalLedgerReady()) {
642 return SOFTBUS_OK;
643 }
644 LNN_LOGI(LNN_LEDGER, "stateVersion is changed, stateVersion=%{public}d", info->stateVersion);
645 NodeInfo nodeInfo = {};
646 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
647 LNN_LOGE(LNN_LEDGER, "memcpy fail");
648 return SOFTBUS_MEM_ERR;
649 }
650 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
651 LNN_LOGE(LNN_LEDGER, "ledger stateversion change sync to cloud failed");
652 }
653 return SOFTBUS_OK;
654 }
655
UpdateLocalProxyPort(const void * buf)656 static int32_t UpdateLocalProxyPort(const void *buf)
657 {
658 NodeInfo *info = &g_localNetLedger.localInfo;
659 if (buf == NULL) {
660 return SOFTBUS_INVALID_PARAM;
661 }
662 return LnnSetProxyPort(info, *(int *)buf);
663 }
664
LlGetNetCap(void * buf,uint32_t len)665 static int32_t LlGetNetCap(void *buf, uint32_t len)
666 {
667 NodeInfo *info = &g_localNetLedger.localInfo;
668 if (buf == NULL || len != LNN_COMMON_LEN) {
669 return SOFTBUS_INVALID_PARAM;
670 }
671 *((uint32_t *)buf) = info->netCapacity;
672 return SOFTBUS_OK;
673 }
674
LlGetFeatureCapa(void * buf,uint32_t len)675 static int32_t LlGetFeatureCapa(void *buf, uint32_t len)
676 {
677 NodeInfo *info = &g_localNetLedger.localInfo;
678 if (buf == NULL || len != sizeof(uint64_t)) {
679 return SOFTBUS_INVALID_PARAM;
680 }
681 *((uint64_t *)buf) = info->feature;
682 return SOFTBUS_OK;
683 }
684
LlGetNetType(void * buf,uint32_t len)685 static int32_t LlGetNetType(void *buf, uint32_t len)
686 {
687 NodeInfo *info = &g_localNetLedger.localInfo;
688 if (buf == NULL || len != LNN_COMMON_LEN) {
689 return SOFTBUS_INVALID_PARAM;
690 }
691 *((int32_t *)buf) = (int32_t)info->discoveryType;
692 return SOFTBUS_OK;
693 }
694
LlGetDeviceTypeId(void * buf,uint32_t len)695 static int32_t LlGetDeviceTypeId(void *buf, uint32_t len)
696 {
697 NodeInfo *info = &g_localNetLedger.localInfo;
698 if (buf == NULL || len != LNN_COMMON_LEN) {
699 return SOFTBUS_INVALID_PARAM;
700 }
701 *((int32_t *)buf) = info->deviceInfo.deviceTypeId;
702 return SOFTBUS_OK;
703 }
704
LlGetOsType(void * buf,uint32_t len)705 static int32_t LlGetOsType(void *buf, uint32_t len)
706 {
707 NodeInfo *info = &g_localNetLedger.localInfo;
708 if (buf == NULL || len != sizeof(uint32_t)) {
709 LNN_LOGE(LNN_LEDGER, "buf of osType is null");
710 return SOFTBUS_INVALID_PARAM;
711 }
712 *((int32_t *)buf) = info->deviceInfo.osType;
713 return SOFTBUS_OK;
714 }
715
LlGetAuthCapability(void * buf,uint32_t len)716 static int32_t LlGetAuthCapability(void *buf, uint32_t len)
717 {
718 NodeInfo *info = &g_localNetLedger.localInfo;
719 if (buf == NULL || len != sizeof(uint32_t)) {
720 LNN_LOGE(LNN_LEDGER, "buf of authCapability is null");
721 return SOFTBUS_INVALID_PARAM;
722 }
723 *((int32_t *)buf) = info->authCapacity;
724 return SOFTBUS_OK;
725 }
726
L1GetMasterNodeWeight(void * buf,uint32_t len)727 static int32_t L1GetMasterNodeWeight(void *buf, uint32_t len)
728 {
729 NodeInfo *info = &g_localNetLedger.localInfo;
730
731 if (buf == NULL || len != LNN_COMMON_LEN) {
732 return SOFTBUS_INVALID_PARAM;
733 }
734 *((int32_t *)buf) = info->masterWeight;
735 return SOFTBUS_OK;
736 }
737
LlGetP2pMac(void * buf,uint32_t len)738 static int32_t LlGetP2pMac(void *buf, uint32_t len)
739 {
740 const char *mac = NULL;
741 if (buf == NULL || len < MAC_LEN) {
742 return SOFTBUS_INVALID_PARAM;
743 }
744 mac = LnnGetP2pMac(&g_localNetLedger.localInfo);
745 if (mac == NULL) {
746 LNN_LOGE(LNN_LEDGER, "get p2p mac fail");
747 return SOFTBUS_ERR;
748 }
749 if (strncpy_s((char *)buf, len, mac, strlen(mac)) != EOK) {
750 LNN_LOGE(LNN_LEDGER, "copy p2p mac failed");
751 return SOFTBUS_MEM_ERR;
752 }
753 return SOFTBUS_OK;
754 }
755
L1GetWifiCfg(void * buf,uint32_t len)756 static int32_t L1GetWifiCfg(void *buf, uint32_t len)
757 {
758 if (buf == NULL || len < WIFI_CFG_INFO_MAX_LEN) {
759 return SOFTBUS_INVALID_PARAM;
760 }
761 const char *wifiCfg = LnnGetWifiCfg(&g_localNetLedger.localInfo);
762 if (wifiCfg == NULL) {
763 LNN_LOGE(LNN_LEDGER, "get wifi cfg fail");
764 return SOFTBUS_ERR;
765 }
766 if (strncpy_s((char *)buf, len, wifiCfg, strlen(wifiCfg)) != EOK) {
767 LNN_LOGE(LNN_LEDGER, "copy wifi cfg failed");
768 return SOFTBUS_MEM_ERR;
769 }
770 return SOFTBUS_OK;
771 }
772
L1GetChanList5g(void * buf,uint32_t len)773 static int32_t L1GetChanList5g(void *buf, uint32_t len)
774 {
775 if (buf == NULL || len < WIFI_CFG_INFO_MAX_LEN) {
776 return SOFTBUS_INVALID_PARAM;
777 }
778 const char *chanList5g = LnnGetWifiCfg(&g_localNetLedger.localInfo);
779 if (chanList5g == NULL) {
780 LNN_LOGE(LNN_LEDGER, "get chan list 5g fail");
781 return SOFTBUS_ERR;
782 }
783 if (strncpy_s((char *)buf, len, chanList5g, strlen(chanList5g)) != EOK) {
784 LNN_LOGE(LNN_LEDGER, "copy chan list 5g failed");
785 return SOFTBUS_MEM_ERR;
786 }
787 return SOFTBUS_OK;
788 }
789
LlGetP2pGoMac(void * buf,uint32_t len)790 static int32_t LlGetP2pGoMac(void *buf, uint32_t len)
791 {
792 const char *mac = NULL;
793 if (buf == NULL || len < MAC_LEN) {
794 return SOFTBUS_INVALID_PARAM;
795 }
796 mac = LnnGetP2pGoMac(&g_localNetLedger.localInfo);
797 if (mac == NULL) {
798 LNN_LOGE(LNN_LEDGER, "get p2p go mac fail");
799 return SOFTBUS_ERR;
800 }
801 if (strncpy_s((char *)buf, len, mac, strlen(mac)) != EOK) {
802 LNN_LOGE(LNN_LEDGER, "copy p2p go mac failed");
803 return SOFTBUS_MEM_ERR;
804 }
805 return SOFTBUS_OK;
806 }
807
L1GetP2pRole(void * buf,uint32_t len)808 static int32_t L1GetP2pRole(void *buf, uint32_t len)
809 {
810 if (buf == NULL || len != LNN_COMMON_LEN) {
811 return SOFTBUS_INVALID_PARAM;
812 }
813 *((int32_t *)buf) = LnnGetP2pRole(&g_localNetLedger.localInfo);
814 return SOFTBUS_OK;
815 }
816
LlGetStateVersion(void * buf,uint32_t len)817 static int32_t LlGetStateVersion(void *buf, uint32_t len)
818 {
819 if (buf == NULL || len != LNN_COMMON_LEN) {
820 return SOFTBUS_INVALID_PARAM;
821 }
822 *((int32_t *)buf) = g_localNetLedger.localInfo.stateVersion;
823 return SOFTBUS_OK;
824 }
825
L1GetStaFrequency(void * buf,uint32_t len)826 static int32_t L1GetStaFrequency(void *buf, uint32_t len)
827 {
828 if (buf == NULL || len != LNN_COMMON_LEN) {
829 return SOFTBUS_INVALID_PARAM;
830 }
831 *((int32_t *)buf) = LnnGetStaFrequency(&g_localNetLedger.localInfo);
832 return SOFTBUS_OK;
833 }
834
L1GetNodeDataChangeFlag(void * buf,uint32_t len)835 static int32_t L1GetNodeDataChangeFlag(void *buf, uint32_t len)
836 {
837 if (buf == NULL || len != DATA_CHANGE_FLAG_BUF_LEN) {
838 return SOFTBUS_INVALID_PARAM;
839 }
840 *((int16_t *)buf) = (int16_t)LnnGetDataChangeFlag(&g_localNetLedger.localInfo);
841 return SOFTBUS_OK;
842 }
843
L1GetDataDynamicLevel(void * buf,uint32_t len)844 static int32_t L1GetDataDynamicLevel(void *buf, uint32_t len)
845 {
846 if (buf == NULL || len != DATA_DYNAMIC_LEVEL_BUF_LEN) {
847 return SOFTBUS_INVALID_PARAM;
848 }
849 *((uint16_t *)buf) = (uint16_t)LnnGetDataDynamicLevel(&g_localNetLedger.localInfo);
850 return SOFTBUS_OK;
851 }
852
UpdateDataDynamicLevel(const void * buf)853 static int32_t UpdateDataDynamicLevel(const void *buf)
854 {
855 if (buf == NULL) {
856 return SOFTBUS_INVALID_PARAM;
857 }
858 NodeInfo *info = &g_localNetLedger.localInfo;
859 return LnnSetDataDynamicLevel(info, *(uint16_t *)buf);
860 }
861
L1GetDataStaticLevel(void * buf,uint32_t len)862 static int32_t L1GetDataStaticLevel(void *buf, uint32_t len)
863 {
864 if (buf == NULL || len != DATA_STATIC_LEVEL_BUF_LEN) {
865 return SOFTBUS_INVALID_PARAM;
866 }
867 *((uint16_t *)buf) = (uint16_t)LnnGetDataStaticLevel(&g_localNetLedger.localInfo);
868 return SOFTBUS_OK;
869 }
870
UpdateDataStaticLevel(const void * buf)871 static int32_t UpdateDataStaticLevel(const void *buf)
872 {
873 if (buf == NULL) {
874 return SOFTBUS_INVALID_PARAM;
875 }
876 NodeInfo *info = &g_localNetLedger.localInfo;
877 return LnnSetDataStaticLevel(info, *(uint16_t *)buf);
878 }
879
L1GetDataSwitchLevel(void * buf,uint32_t len)880 static int32_t L1GetDataSwitchLevel(void *buf, uint32_t len)
881 {
882 if (buf == NULL || len != DATA_SWITCH_LEVEL_BUF_LEN) {
883 return SOFTBUS_INVALID_PARAM;
884 }
885 *((uint32_t *)buf) = (uint32_t)LnnGetDataSwitchLevel(&g_localNetLedger.localInfo);
886 return SOFTBUS_OK;
887 }
888
UpdateDataSwitchLevel(const void * buf)889 static int32_t UpdateDataSwitchLevel(const void *buf)
890 {
891 if (buf == NULL) {
892 return SOFTBUS_INVALID_PARAM;
893 }
894 NodeInfo *info = &g_localNetLedger.localInfo;
895 return LnnSetDataSwitchLevel(info, *(uint32_t *)buf);
896 }
897
L1GetDataSwitchLength(void * buf,uint32_t len)898 static int32_t L1GetDataSwitchLength(void *buf, uint32_t len)
899 {
900 if (buf == NULL || len != DATA_SWITCH_LENGTH_BUF_LEN) {
901 return SOFTBUS_INVALID_PARAM;
902 }
903 *((uint16_t *)buf) = (uint16_t)LnnGetDataSwitchLength(&g_localNetLedger.localInfo);
904 return SOFTBUS_OK;
905 }
906
UpdateDataSwitchLength(const void * buf)907 static int32_t UpdateDataSwitchLength(const void *buf)
908 {
909 if (buf == NULL) {
910 return SOFTBUS_INVALID_PARAM;
911 }
912 NodeInfo *info = &g_localNetLedger.localInfo;
913 return LnnSetDataSwitchLength(info, *(uint16_t *)buf);
914 }
915
LocalGetNodeAccountId(void * buf,uint32_t len)916 static int32_t LocalGetNodeAccountId(void *buf, uint32_t len)
917 {
918 if (buf == NULL || len != sizeof(int64_t)) {
919 return SOFTBUS_INVALID_PARAM;
920 }
921 *((int64_t *)buf) = g_localNetLedger.localInfo.accountId;
922 return SOFTBUS_OK;
923 }
924
LocalGetNodeBleStartTime(void * buf,uint32_t len)925 static int32_t LocalGetNodeBleStartTime(void *buf, uint32_t len)
926 {
927 if (buf == NULL || len != sizeof(int64_t)) {
928 return SOFTBUS_INVALID_PARAM;
929 }
930 *((int64_t *)buf) = g_localNetLedger.localInfo.bleStartTimestamp;
931 return SOFTBUS_OK;
932 }
933
LocalGetNetworkIdTimeStamp(void * buf,uint32_t len)934 static int32_t LocalGetNetworkIdTimeStamp(void *buf, uint32_t len)
935 {
936 if (buf == NULL || len != sizeof(int64_t)) {
937 return SOFTBUS_INVALID_PARAM;
938 }
939 *((int64_t *)buf) = g_localNetLedger.localInfo.networkIdTimestamp;
940 return SOFTBUS_OK;
941 }
942
InitLocalDeviceInfo(DeviceBasicInfo * info)943 static int32_t InitLocalDeviceInfo(DeviceBasicInfo *info)
944 {
945 char devType[DEVICE_TYPE_BUF_LEN] = TYPE_UNKNOWN;
946
947 if (info == NULL) {
948 LNN_LOGE(LNN_LEDGER, "fail:para error!");
949 return SOFTBUS_INVALID_PARAM;
950 }
951 (void)memset_s(info, sizeof(DeviceBasicInfo), 0, sizeof(DeviceBasicInfo));
952
953 // get device info
954 if (GetCommonDevInfo(COMM_DEVICE_KEY_DEVNAME, info->deviceName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
955 LNN_LOGE(LNN_LEDGER, "COMM_DEVICE_KEY_DEVNAME failed");
956 return SOFTBUS_ERR;
957 }
958 if (GetCommonOsType(&info->osType) != SOFTBUS_OK) {
959 LNN_LOGE(LNN_LEDGER, "get os type failed");
960 }
961 if (GetCommonOsVersion(info->osVersion, OS_VERSION_BUF_LEN) != SOFTBUS_OK) {
962 LNN_LOGE(LNN_LEDGER, "get os version failed");
963 }
964 if (GetCommonDeviceVersion(info->deviceVersion, DEVICE_VERSION_SIZE_MAX) != SOFTBUS_OK) {
965 LNN_LOGE(LNN_LEDGER, "get device version failed");
966 }
967 if (LnnGetUnifiedDeviceName(info->unifiedName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
968 LNN_LOGE(LNN_LEDGER, "get unifiedName fail");
969 }
970 if (LnnGetUnifiedDefaultDeviceName(info->unifiedDefaultName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
971 LNN_LOGE(LNN_LEDGER, "get unifiedDefaultName fail");
972 }
973 if (LnnGetSettingNickName(info->unifiedDefaultName, info->unifiedName,
974 info->nickName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
975 LNN_LOGE(LNN_LEDGER, "get nick name fail");
976 }
977 if (GetCommonDevInfo(COMM_DEVICE_KEY_DEVTYPE, devType, DEVICE_TYPE_BUF_LEN) != SOFTBUS_OK) {
978 LNN_LOGE(LNN_LEDGER, "GetCommonDevInfo: COMM_DEVICE_KEY_DEVTYPE failed");
979 return SOFTBUS_ERR;
980 }
981 if (UpdateLocalDeviceType(devType) != SOFTBUS_OK) {
982 LNN_LOGE(LNN_LEDGER, "UpdateLocalDeviceType failed");
983 }
984 return SOFTBUS_OK;
985 }
986
InitLocalVersionType(NodeInfo * info)987 static int32_t InitLocalVersionType(NodeInfo *info)
988 {
989 char versionType[VERSION_MAX_LEN] = "";
990 if (info == NULL) {
991 LNN_LOGE(LNN_LEDGER, "fail:para error");
992 return SOFTBUS_INVALID_PARAM;
993 }
994 if (GetCommonDevInfo(COMM_DEVICE_KEY_VERSION_TYPE, versionType, VERSION_MAX_LEN) != SOFTBUS_OK) {
995 LNN_LOGE(LNN_LEDGER, "COMM_DEVICE_KEY_VERSION_TYPE failed");
996 return SOFTBUS_ERR;
997 }
998 if (strncpy_s(info->versionType, VERSION_MAX_LEN, versionType, strlen(versionType)) != EOK) {
999 LNN_LOGE(LNN_LEDGER, "strncpy_s error");
1000 return SOFTBUS_MEM_ERR;
1001 }
1002 return SOFTBUS_OK;
1003 }
1004
InitOfflineCode(NodeInfo * info)1005 static int32_t InitOfflineCode(NodeInfo *info)
1006 {
1007 if (info == NULL) {
1008 LNN_LOGE(LNN_LEDGER, "info of offlinecode is null");
1009 return SOFTBUS_INVALID_PARAM;
1010 }
1011 if (memset_s(info->offlineCode, OFFLINE_CODE_BYTE_SIZE, 0, OFFLINE_CODE_BYTE_SIZE) != EOK) {
1012 LNN_LOGE(LNN_LEDGER, "offlineCode memset_s failed");
1013 return SOFTBUS_ERR;
1014 }
1015 if (SoftBusGenerateRandomArray(info->offlineCode, OFFLINE_CODE_BYTE_SIZE) != SOFTBUS_OK) {
1016 LNN_LOGE(LNN_LEDGER, "generate offlinecode error");
1017 return SOFTBUS_ERR;
1018 }
1019 return SOFTBUS_OK;
1020 }
1021
InitConnectInfo(ConnectInfo * info)1022 static int32_t InitConnectInfo(ConnectInfo *info)
1023 {
1024 if (info == NULL) {
1025 LNN_LOGE(LNN_LEDGER, "fail:para error");
1026 return SOFTBUS_INVALID_PARAM;
1027 }
1028 // get mac addr
1029 if (GetCommonDevInfo(COMM_DEVICE_KEY_BLE_MAC, info->bleMacAddr, MAC_LEN) != SOFTBUS_OK) {
1030 LNN_LOGE(LNN_LEDGER, "get ble mac fail!");
1031 return SOFTBUS_ERR;
1032 }
1033 return GetCommonDevInfo(COMM_DEVICE_KEY_BT_MAC, info->macAddr, MAC_LEN);
1034 }
1035
ModifyId(char * dstId,uint32_t dstLen,const char * sourceId)1036 static int32_t ModifyId(char *dstId, uint32_t dstLen, const char *sourceId)
1037 {
1038 if (dstId == NULL || sourceId == NULL || strlen(sourceId) > dstLen - 1) {
1039 LNN_LOGE(LNN_LEDGER, "id:para error");
1040 return SOFTBUS_INVALID_PARAM;
1041 }
1042 if (strncpy_s(dstId, dstLen, sourceId, strlen(sourceId)) != EOK) {
1043 LNN_LOGE(LNN_LEDGER, "strncpy_s error");
1044 return SOFTBUS_MEM_ERR;
1045 }
1046 return SOFTBUS_OK;
1047 }
1048
LnnGetLocalNodeInfo(void)1049 const NodeInfo *LnnGetLocalNodeInfo(void)
1050 {
1051 return &g_localNetLedger.localInfo;
1052 }
1053
LnnGetLocalNodeInfoSafe(NodeInfo * info)1054 int32_t LnnGetLocalNodeInfoSafe(NodeInfo *info)
1055 {
1056 if (SoftBusMutexLock(&g_localNetLedger.lock) != SOFTBUS_OK) {
1057 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1058 return SOFTBUS_LOCK_ERR;
1059 }
1060 if (memcpy_s(info, sizeof(NodeInfo), LnnGetLocalNodeInfo(), sizeof(NodeInfo)) != EOK) {
1061 LNN_LOGE(LNN_LEDGER, "memcpy node info fail");
1062 SoftBusMutexUnlock(&g_localNetLedger.lock);
1063 return SOFTBUS_MEM_ERR;
1064 }
1065 SoftBusMutexUnlock(&g_localNetLedger.lock);
1066 return SOFTBUS_OK;
1067 }
1068
UpdateLocalDeviceName(const void * name)1069 static int32_t UpdateLocalDeviceName(const void *name)
1070 {
1071 if (name == NULL) {
1072 return SOFTBUS_INVALID_PARAM;
1073 }
1074 NodeInfo localNodeInfo = {};
1075 (void)LnnGetLocalDevInfo(&localNodeInfo);
1076 const char *beforeName = LnnGetDeviceName(&g_localNetLedger.localInfo.deviceInfo);
1077 char *anonyBeforeName = NULL;
1078 Anonymize(beforeName, &anonyBeforeName);
1079 char *anonyName = NULL;
1080 Anonymize((char *)name, &anonyName);
1081 char *anonyDeviceName = NULL;
1082 Anonymize(localNodeInfo.deviceInfo.deviceName, &anonyDeviceName);
1083 LNN_LOGI(LNN_LEDGER, "device name=%{public}s->%{public}s, cache=%{public}s", anonyBeforeName, anonyName,
1084 anonyDeviceName);
1085 AnonymizeFree(anonyBeforeName);
1086 AnonymizeFree(anonyName);
1087 AnonymizeFree(anonyDeviceName);
1088 if (strcmp(beforeName, (char *)name) != 0) {
1089 if (LnnSetDeviceName(&g_localNetLedger.localInfo.deviceInfo, (char *)name) != SOFTBUS_OK) {
1090 LNN_LOGE(LNN_LEDGER, "set device name fail");
1091 return SOFTBUS_ERR;
1092 }
1093 if (strcmp((char *)name, localNodeInfo.deviceInfo.deviceName) == 0) {
1094 LNN_LOGI(LNN_LEDGER, "device name is same as localcache");
1095 return SOFTBUS_OK;
1096 }
1097 UpdateStateVersionAndStore(UPDATE_DEV_NAME);
1098 if (!IsLocalLedgerReady()) {
1099 return SOFTBUS_OK;
1100 }
1101 NodeInfo nodeInfo = {};
1102 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1103 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1104 return SOFTBUS_MEM_ERR;
1105 }
1106 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1107 LNN_LOGE(LNN_LEDGER, "ledger device name change sync to cloud failed");
1108 }
1109 }
1110 return SOFTBUS_OK;
1111 }
1112
UpdateUnifiedName(const void * name)1113 static int32_t UpdateUnifiedName(const void *name)
1114 {
1115 if (name == NULL) {
1116 return SOFTBUS_INVALID_PARAM;
1117 }
1118 NodeInfo localNodeInfo = {};
1119 (void)LnnGetLocalDevInfo(&localNodeInfo);
1120 const char *beforeName = g_localNetLedger.localInfo.deviceInfo.unifiedName;
1121 if (strcmp(beforeName, (char *)name) != 0) {
1122 if (strcpy_s(g_localNetLedger.localInfo.deviceInfo.unifiedName,
1123 DEVICE_NAME_BUF_LEN, (char *)name) != EOK) {
1124 return SOFTBUS_ERR;
1125 }
1126 if (strcmp((char *)name, localNodeInfo.deviceInfo.unifiedName) == 0) {
1127 LNN_LOGI(LNN_LEDGER, "device unified name is same as localcache");
1128 return SOFTBUS_OK;
1129 }
1130 UpdateStateVersionAndStore(UPDATE_DEV_UNIFIED_NAME);
1131 if (!IsLocalLedgerReady()) {
1132 return SOFTBUS_OK;
1133 }
1134 LNN_LOGI(LNN_LEDGER, "unified device name is changed");
1135 NodeInfo nodeInfo = {};
1136 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1137 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1138 return SOFTBUS_MEM_ERR;
1139 }
1140 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1141 LNN_LOGE(LNN_LEDGER, "ledger unified device name change sync to cloud failed");
1142 }
1143 }
1144 return SOFTBUS_OK;
1145 }
1146
UpdateUnifiedDefaultName(const void * name)1147 static int32_t UpdateUnifiedDefaultName(const void *name)
1148 {
1149 if (name == NULL) {
1150 return SOFTBUS_INVALID_PARAM;
1151 }
1152 NodeInfo localNodeInfo = {};
1153 (void)LnnGetLocalDevInfo(&localNodeInfo);
1154 const char *beforeName = g_localNetLedger.localInfo.deviceInfo.unifiedDefaultName;
1155 if (strcmp(beforeName, (char *)name) != 0) {
1156 if (strcpy_s(g_localNetLedger.localInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, (char *)name) !=
1157 EOK) {
1158 return SOFTBUS_ERR;
1159 }
1160 if (strcmp((char *)name, localNodeInfo.deviceInfo.unifiedDefaultName) == 0) {
1161 LNN_LOGI(LNN_LEDGER, "device unified default name is same as localcache");
1162 return SOFTBUS_OK;
1163 }
1164 UpdateStateVersionAndStore(UPDATE_DEV_UNIFIED_DEFAULT_NAME);
1165 if (!IsLocalLedgerReady()) {
1166 return SOFTBUS_OK;
1167 }
1168 LNN_LOGI(LNN_LEDGER, "device unified default name is changed");
1169 NodeInfo nodeInfo = {};
1170 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1171 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1172 return SOFTBUS_MEM_ERR;
1173 }
1174 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1175 LNN_LOGE(LNN_LEDGER, "ledger unified default device name change sync to cloud failed");
1176 }
1177 }
1178 return SOFTBUS_OK;
1179 }
1180
UpdateNickName(const void * name)1181 static int32_t UpdateNickName(const void *name)
1182 {
1183 if (name == NULL) {
1184 return SOFTBUS_INVALID_PARAM;
1185 }
1186 NodeInfo localNodeInfo = {};
1187 (void)LnnGetLocalDevInfo(&localNodeInfo);
1188 const char *beforeName = g_localNetLedger.localInfo.deviceInfo.nickName;
1189 if (strcmp(beforeName, (char *)name) != 0) {
1190 if (strcpy_s(g_localNetLedger.localInfo.deviceInfo.nickName, DEVICE_NAME_BUF_LEN, (char *)name) != EOK) {
1191 return SOFTBUS_ERR;
1192 }
1193 if (strcmp((char *)name, localNodeInfo.deviceInfo.nickName) == 0) {
1194 LNN_LOGI(LNN_LEDGER, "device nick name is same as localcache");
1195 return SOFTBUS_OK;
1196 }
1197 UpdateStateVersionAndStore(UPDATE_DEV_NICK_NAME);
1198 if (!IsLocalLedgerReady()) {
1199 return SOFTBUS_OK;
1200 }
1201 LNN_LOGI(LNN_LEDGER, "device nick name is changed");
1202 NodeInfo nodeInfo = {};
1203 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1204 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1205 return SOFTBUS_MEM_ERR;
1206 }
1207 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1208 LNN_LOGE(LNN_LEDGER, "ledger nick name change sync to cloud failed");
1209 }
1210 }
1211 return SOFTBUS_OK;
1212 }
1213
LnnUpdateLocalNetworkIdTime(int64_t time)1214 int32_t LnnUpdateLocalNetworkIdTime(int64_t time)
1215 {
1216 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1217 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1218 return SOFTBUS_LOCK_ERR;
1219 }
1220 g_localNetLedger.localInfo.networkIdTimestamp = time;
1221 SoftBusMutexUnlock(&g_localNetLedger.lock);
1222 return SOFTBUS_OK;
1223 }
1224
UpdateLocalNetworkId(const void * id)1225 static int32_t UpdateLocalNetworkId(const void *id)
1226 {
1227 if (ModifyId(g_localNetLedger.localInfo.lastNetworkId, NETWORK_ID_BUF_LEN,
1228 g_localNetLedger.localInfo.networkId) != SOFTBUS_OK) {
1229 return SOFTBUS_ERR;
1230 }
1231 if (ModifyId(g_localNetLedger.localInfo.networkId, NETWORK_ID_BUF_LEN, (char *)id) != SOFTBUS_OK) {
1232 return SOFTBUS_ERR;
1233 }
1234 char *anonyNetworkId = NULL;
1235 char *anonyOldNetworkId = NULL;
1236 Anonymize(g_localNetLedger.localInfo.networkId, &anonyNetworkId);
1237 Anonymize(g_localNetLedger.localInfo.lastNetworkId, &anonyOldNetworkId);
1238 g_localNetLedger.localInfo.networkIdTimestamp = (int64_t)SoftBusGetSysTimeMs();
1239 LNN_LOGI(LNN_LEDGER, "networkId change %{public}s -> %{public}s, networkIdTimestamp=%{public}" PRId64,
1240 anonyOldNetworkId, anonyNetworkId, g_localNetLedger.localInfo.networkIdTimestamp);
1241 UpdateStateVersionAndStore(UPDATE_NETWORKID);
1242 AnonymizeFree(anonyNetworkId);
1243 AnonymizeFree(anonyOldNetworkId);
1244 if (!IsLocalLedgerReady()) {
1245 return SOFTBUS_OK;
1246 }
1247 NodeInfo nodeInfo = {};
1248 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1249 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1250 return SOFTBUS_MEM_ERR;
1251 }
1252 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1253 LNN_LOGE(LNN_LEDGER, "ledger networkId change sync to cloud failed");
1254 }
1255 return SOFTBUS_OK;
1256 }
1257
LlUpdateLocalOffLineCode(const void * id)1258 static int32_t LlUpdateLocalOffLineCode(const void *id)
1259 {
1260 return ModifyId((char *)g_localNetLedger.localInfo.offlineCode, OFFLINE_CODE_BYTE_SIZE, (char *)id);
1261 }
1262
LlUpdateLocalExtData(const void * id)1263 static int32_t LlUpdateLocalExtData(const void *id)
1264 {
1265 return ModifyId((char *)g_localNetLedger.localInfo.extData, EXTDATA_LEN, (char *)id);
1266 }
1267
UpdateLocalBleMac(const void * mac)1268 static int32_t UpdateLocalBleMac(const void *mac)
1269 {
1270 if (mac == NULL) {
1271 LNN_LOGE(LNN_LEDGER, "para error");
1272 return SOFTBUS_INVALID_PARAM;
1273 }
1274 LnnSetBleMac(&g_localNetLedger.localInfo, (char *)mac);
1275 return SOFTBUS_OK;
1276 }
1277
UpdateLocalUuid(const void * id)1278 static int32_t UpdateLocalUuid(const void *id)
1279 {
1280 return ModifyId(g_localNetLedger.localInfo.uuid, UUID_BUF_LEN, (char *)id);
1281 }
1282
UpdateLocalParentId(const char * id)1283 int32_t UpdateLocalParentId(const char *id)
1284 {
1285 return ModifyId(g_localNetLedger.localInfo.parentId, ID_MAX_LEN, id);
1286 }
1287
UpdateLocalPublicId(const char * id)1288 int32_t UpdateLocalPublicId(const char *id)
1289 {
1290 return ModifyId(g_localNetLedger.localInfo.publicId, ID_MAX_LEN, id);
1291 }
1292
UpdateLocalRole(ConnectRole role)1293 int32_t UpdateLocalRole(ConnectRole role)
1294 {
1295 g_localNetLedger.localInfo.role = role;
1296 return SOFTBUS_OK;
1297 }
1298
UpdateLocalNetCapability(const void * capability)1299 static int32_t UpdateLocalNetCapability(const void *capability)
1300 {
1301 if (capability == NULL) {
1302 return SOFTBUS_INVALID_PARAM;
1303 }
1304 g_localNetLedger.localInfo.netCapacity = *(int32_t *)capability;
1305 return SOFTBUS_OK;
1306 }
1307
UpdateLocalFeatureCapability(const void * capability)1308 static int32_t UpdateLocalFeatureCapability(const void *capability)
1309 {
1310 if (capability == NULL) {
1311 return SOFTBUS_INVALID_PARAM;
1312 }
1313 g_localNetLedger.localInfo.feature |= *(uint64_t *)capability;
1314 return SOFTBUS_OK;
1315 }
1316
UpdateMasgerNodeWeight(const void * weight)1317 static int32_t UpdateMasgerNodeWeight(const void *weight)
1318 {
1319 if (weight == NULL) {
1320 return SOFTBUS_INVALID_PARAM;
1321 }
1322 g_localNetLedger.localInfo.masterWeight = *(int32_t *)weight;
1323 return SOFTBUS_OK;
1324 }
1325
UpdateLocalStatus(ConnectStatus status)1326 int32_t UpdateLocalStatus(ConnectStatus status)
1327 {
1328 g_localNetLedger.localInfo.status = status;
1329 return SOFTBUS_OK;
1330 }
1331
UpdateLocalWeight(int32_t weight)1332 int32_t UpdateLocalWeight(int32_t weight)
1333 {
1334 g_localNetLedger.localInfo.masterWeight = weight;
1335 return SOFTBUS_OK;
1336 }
1337
UpdateLocalDeviceIp(const void * ip)1338 static int32_t UpdateLocalDeviceIp(const void *ip)
1339 {
1340 if (ip == NULL) {
1341 LNN_LOGE(LNN_LEDGER, "para error");
1342 return SOFTBUS_INVALID_PARAM;
1343 }
1344 LnnSetWiFiIp(&g_localNetLedger.localInfo, (char *)ip);
1345 char *anonyIp = NULL;
1346 Anonymize((char *)ip, &anonyIp);
1347 LNN_LOGI(LNN_LEDGER, "set LocalIp=%{public}s", anonyIp);
1348 AnonymizeFree(anonyIp);
1349 return SOFTBUS_OK;
1350 }
1351
UpdateLocalBtMac(const void * mac)1352 static int32_t UpdateLocalBtMac(const void *mac)
1353 {
1354 if (mac == NULL) {
1355 LNN_LOGE(LNN_LEDGER, "para error");
1356 return SOFTBUS_INVALID_PARAM;
1357 }
1358 const char *beforeMac = LnnGetBtMac(&g_localNetLedger.localInfo);
1359 if (strcmp(beforeMac, (char *)mac) == 0) {
1360 LNN_LOGI(LNN_LEDGER, "unchanged. no need update");
1361 return SOFTBUS_OK;
1362 }
1363 LnnSetBtMac(&g_localNetLedger.localInfo, (char *)mac);
1364 NodeInfo localNodeInfo;
1365 (void)memset_s(&localNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1366 if (LnnGetLocalDevInfo(&localNodeInfo) == SOFTBUS_OK) {
1367 LnnSetBtMac(&localNodeInfo, (char *)mac);
1368 if (LnnSaveLocalDeviceInfo(&localNodeInfo) != SOFTBUS_OK) {
1369 LNN_LOGE(LNN_LEDGER, "update Bt mac to localdevinfo store fail");
1370 }
1371 } else {
1372 LNN_LOGE(LNN_LEDGER, "get local device info fail");
1373 }
1374 if (!IsLocalLedgerReady()) {
1375 return SOFTBUS_OK;
1376 }
1377 LNN_LOGI(LNN_LEDGER, "device bt mac is changed");
1378 NodeInfo nodeInfo = {};
1379 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1380 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1381 return SOFTBUS_MEM_ERR;
1382 }
1383 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1384 LNN_LOGE(LNN_LEDGER, "ledger btMac change sync to cloud failed");
1385 }
1386 return SOFTBUS_OK;
1387 }
1388
UpdateLocalNetIfName(const void * netIfName)1389 static int32_t UpdateLocalNetIfName(const void *netIfName)
1390 {
1391 if (netIfName == NULL) {
1392 LNN_LOGE(LNN_LEDGER, "para error");
1393 return SOFTBUS_INVALID_PARAM;
1394 }
1395 LnnSetNetIfName(&g_localNetLedger.localInfo, (char *)netIfName);
1396 return SOFTBUS_OK;
1397 }
1398
UpdateMasterNodeUdid(const void * udid)1399 static int32_t UpdateMasterNodeUdid(const void *udid)
1400 {
1401 char localUdid[UDID_BUF_LEN];
1402 ConnectRole role;
1403
1404 if (LlGetDeviceUdid(localUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1405 LNN_LOGE(LNN_LEDGER, "get local udid fail");
1406 } else {
1407 role = g_localNetLedger.localInfo.role;
1408 if (strcmp(localUdid, (char *)udid) == 0) {
1409 g_localNetLedger.localInfo.role = ROLE_CONTROLLER;
1410 } else {
1411 g_localNetLedger.localInfo.role = ROLE_LEAF;
1412 }
1413 LNN_LOGI(LNN_LEDGER, "update local role. role:%{public}d->%{public}d",
1414 role, g_localNetLedger.localInfo.role);
1415 }
1416 return LnnSetMasterUdid(&g_localNetLedger.localInfo, (const char *)udid);
1417 }
1418
UpdateP2pMac(const void * mac)1419 static int32_t UpdateP2pMac(const void *mac)
1420 {
1421 if (mac == NULL) {
1422 LNN_LOGE(LNN_LEDGER, "para error");
1423 return SOFTBUS_INVALID_PARAM;
1424 }
1425 return LnnSetP2pMac(&g_localNetLedger.localInfo, (char *)mac);
1426 }
1427
UpdateWifiCfg(const void * wifiCfg)1428 static int32_t UpdateWifiCfg(const void *wifiCfg)
1429 {
1430 if (wifiCfg == NULL) {
1431 LNN_LOGE(LNN_LEDGER, "para error");
1432 return SOFTBUS_INVALID_PARAM;
1433 }
1434 return LnnSetWifiCfg(&g_localNetLedger.localInfo, (char *)wifiCfg);
1435 }
1436
UpdateChanList5g(const void * chanList5g)1437 static int32_t UpdateChanList5g(const void *chanList5g)
1438 {
1439 if (chanList5g == NULL) {
1440 LNN_LOGE(LNN_LEDGER, "para error");
1441 return SOFTBUS_INVALID_PARAM;
1442 }
1443 return LnnSetChanList5g(&g_localNetLedger.localInfo, (char *)chanList5g);
1444 }
1445
UpdateP2pGoMac(const void * mac)1446 static int32_t UpdateP2pGoMac(const void *mac)
1447 {
1448 if (mac == NULL) {
1449 LNN_LOGE(LNN_LEDGER, "para error");
1450 return SOFTBUS_INVALID_PARAM;
1451 }
1452 return LnnSetP2pGoMac(&g_localNetLedger.localInfo, (char *)mac);
1453 }
1454
UpdateP2pRole(const void * p2pRole)1455 static int32_t UpdateP2pRole(const void *p2pRole)
1456 {
1457 if (p2pRole == NULL) {
1458 LNN_LOGE(LNN_LEDGER, "para error");
1459 return SOFTBUS_INVALID_PARAM;
1460 }
1461 return LnnSetP2pRole(&g_localNetLedger.localInfo, *(int32_t *)p2pRole);
1462 }
1463
UpdateStaFrequency(const void * staFrequency)1464 static int32_t UpdateStaFrequency(const void *staFrequency)
1465 {
1466 if (staFrequency == NULL) {
1467 LNN_LOGE(LNN_LEDGER, "para error");
1468 return SOFTBUS_INVALID_PARAM;
1469 }
1470 return LnnSetStaFrequency(&g_localNetLedger.localInfo, *(int32_t *)staFrequency);
1471 }
1472
LlUpdateSupportedProtocols(const void * transProtos)1473 static int32_t LlUpdateSupportedProtocols(const void *transProtos)
1474 {
1475 uint64_t *protocols = (uint64_t *)transProtos;
1476 return LnnSetSupportedProtocols(&g_localNetLedger.localInfo, *protocols);
1477 }
1478
LlGetSupportedProtocols(void * buf,uint32_t len)1479 static int32_t LlGetSupportedProtocols(void *buf, uint32_t len)
1480 {
1481 if (buf == NULL || len != sizeof(uint64_t)) {
1482 return SOFTBUS_INVALID_PARAM;
1483 }
1484 *((uint64_t *)buf) = LnnGetSupportedProtocols(&g_localNetLedger.localInfo);
1485 return SOFTBUS_OK;
1486 }
1487
LlGetNodeAddr(void * buf,uint32_t len)1488 static int32_t LlGetNodeAddr(void *buf, uint32_t len)
1489 {
1490 NodeInfo *info = &g_localNetLedger.localInfo;
1491 if (buf == NULL || len == 0) {
1492 return SOFTBUS_INVALID_PARAM;
1493 }
1494
1495 if (strcpy_s((char *)buf, len, info->nodeAddress) != EOK) {
1496 LNN_LOGE(LNN_LEDGER, "copy node addr to buf fail");
1497 return SOFTBUS_MEM_ERR;
1498 }
1499 return SOFTBUS_OK;
1500 }
1501
LlUpdateNodeAddr(const void * addr)1502 int32_t LlUpdateNodeAddr(const void *addr)
1503 {
1504 if (addr == NULL) {
1505 return SOFTBUS_INVALID_PARAM;
1506 }
1507
1508 NodeInfo *info = &g_localNetLedger.localInfo;
1509 if (strcpy_s(info->nodeAddress, sizeof(info->nodeAddress), (const char*)addr) != EOK) {
1510 LNN_LOGE(LNN_LEDGER, "copy node addr to buf fail");
1511 return SOFTBUS_MEM_ERR;
1512 }
1513 return SOFTBUS_OK;
1514 }
1515
LnnUpdateLocalNetworkId(const void * id)1516 int32_t LnnUpdateLocalNetworkId(const void *id)
1517 {
1518 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1519 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1520 return SOFTBUS_LOCK_ERR;
1521 }
1522 if (ModifyId(g_localNetLedger.localInfo.lastNetworkId, NETWORK_ID_BUF_LEN,
1523 g_localNetLedger.localInfo.networkId) != SOFTBUS_OK) {
1524 SoftBusMutexUnlock(&g_localNetLedger.lock);
1525 return SOFTBUS_ERR;
1526 }
1527 if (ModifyId(g_localNetLedger.localInfo.networkId, NETWORK_ID_BUF_LEN, (char *)id) != SOFTBUS_OK) {
1528 SoftBusMutexUnlock(&g_localNetLedger.lock);
1529 return SOFTBUS_ERR;
1530 }
1531 SoftBusMutexUnlock(&g_localNetLedger.lock);
1532 return SOFTBUS_OK;
1533 }
1534
LnnUpdateStateVersion(StateVersionChangeReason reason)1535 void LnnUpdateStateVersion(StateVersionChangeReason reason)
1536 {
1537 UpdateStateVersionAndStore(reason);
1538 if (!IsLocalLedgerReady()) {
1539 return;
1540 }
1541 NodeInfo nodeInfo = {};
1542 if (memcpy_s(&nodeInfo, sizeof(NodeInfo), &g_localNetLedger.localInfo, sizeof(NodeInfo)) != EOK) {
1543 LNN_LOGE(LNN_LEDGER, "memcpy fail");
1544 return;
1545 }
1546 if (LnnAsyncCallLedgerAllDataSyncToDB(&nodeInfo) != SOFTBUS_OK) {
1547 LNN_LOGE(LNN_LEDGER, "ledger stateversion change sync to cloud failed");
1548 }
1549 }
1550
LlGetStaticCapLen(void * buf,uint32_t len)1551 static int32_t LlGetStaticCapLen(void *buf, uint32_t len)
1552 {
1553 if (buf == NULL || len > sizeof(int32_t)) {
1554 LNN_LOGE(LNN_LEDGER, "invalid param");
1555 return SOFTBUS_INVALID_PARAM;
1556 }
1557 *((int64_t *)buf) = g_localNetLedger.localInfo.staticCapLen;
1558 return SOFTBUS_OK;
1559 }
1560
LlUpdateStaticCapLen(const void * len)1561 static int32_t LlUpdateStaticCapLen(const void *len)
1562 {
1563 if (len == NULL) {
1564 LNN_LOGE(LNN_LEDGER, "invalid length");
1565 return SOFTBUS_INVALID_PARAM;
1566 }
1567 g_localNetLedger.localInfo.staticCapLen = *(int32_t *)len;
1568 return SOFTBUS_OK;
1569 }
1570
LlGetDeviceSecurityLevel(void * buf,uint32_t len)1571 static int32_t LlGetDeviceSecurityLevel(void *buf, uint32_t len)
1572 {
1573 if (buf == NULL || len != sizeof(int32_t)) {
1574 LNN_LOGE(LNN_LEDGER, "invalid param");
1575 return SOFTBUS_INVALID_PARAM;
1576 }
1577 *((int32_t *)buf) = g_localNetLedger.localInfo.deviceSecurityLevel;
1578 return SOFTBUS_OK;
1579 }
1580
LlUpdateDeviceSecurityLevel(const void * buf)1581 static int32_t LlUpdateDeviceSecurityLevel(const void *buf)
1582 {
1583 NodeInfo *info = &g_localNetLedger.localInfo;
1584 if (buf == NULL) {
1585 LNN_LOGE(LNN_LEDGER, "invalid param");
1586 return SOFTBUS_INVALID_PARAM;
1587 }
1588 info->deviceSecurityLevel = *((int32_t *)buf);
1589 return SOFTBUS_OK;
1590 }
1591
LlUpdateStaticCapability(const void * staticCap)1592 static int32_t LlUpdateStaticCapability(const void *staticCap)
1593 {
1594 if (staticCap == NULL) {
1595 LNN_LOGE(LNN_LEDGER, "invalid param");
1596 return SOFTBUS_INVALID_PARAM;
1597 }
1598 NodeInfo *info = &g_localNetLedger.localInfo;
1599 return LnnSetStaticCapability(info, (uint8_t *)staticCap, info->staticCapLen);
1600 }
1601
LlGetStaticCapability(void * buf,uint32_t len)1602 static int32_t LlGetStaticCapability(void *buf, uint32_t len)
1603 {
1604 if (buf == NULL || len > STATIC_CAP_LEN) {
1605 LNN_LOGE(LNN_LEDGER, "invalid param");
1606 return SOFTBUS_INVALID_PARAM;
1607 }
1608 NodeInfo *info = &g_localNetLedger.localInfo;
1609 if (LnnGetStaticCapability(info, (uint8_t *)buf, len) != SOFTBUS_OK) {
1610 LNN_LOGE(LNN_LEDGER, "get static cap fail");
1611 return SOFTBUS_ERR;
1612 }
1613 return SOFTBUS_OK;
1614 }
1615
LlGetUdidHash(void * buf,uint32_t len)1616 static int32_t LlGetUdidHash(void *buf, uint32_t len)
1617 {
1618 if (buf == NULL || len < UDID_HASH_LEN) {
1619 LNN_LOGE(LNN_LEDGER, "invalid param");
1620 return SOFTBUS_INVALID_PARAM;
1621 }
1622 NodeInfo *info = &g_localNetLedger.localInfo;
1623 uint8_t hash[UDID_HASH_LEN] = {0};
1624 if (SoftBusGenerateStrHash((unsigned char *)info->deviceInfo.deviceUdid,
1625 strlen(info->deviceInfo.deviceUdid), (unsigned char *)hash) != SOFTBUS_OK) {
1626 LNN_LOGE(LNN_LEDGER, "restore manager fail because generate strhash");
1627 return SOFTBUS_ERR;
1628 }
1629 if (memcpy_s(buf, len, hash, UDID_HASH_LEN) != EOK) {
1630 LNN_LOGE(LNN_LEDGER, "memcpy cipher iv fail");
1631 return SOFTBUS_MEM_ERR;
1632 }
1633 return SOFTBUS_OK;
1634 }
1635
LlGetIrk(void * buf,uint32_t len)1636 static int32_t LlGetIrk(void *buf, uint32_t len)
1637 {
1638 if (buf == NULL || len == 0) {
1639 LNN_LOGE(LNN_LEDGER, "invalid param");
1640 return SOFTBUS_INVALID_PARAM;
1641 }
1642 NodeInfo *info = &g_localNetLedger.localInfo;
1643 if (memcpy_s(buf, len, info->rpaInfo.peerIrk, LFINDER_IRK_LEN) != EOK) {
1644 LNN_LOGE(LNN_LEDGER, "memcpy peerIrk fail");
1645 return SOFTBUS_MEM_ERR;
1646 }
1647 return SOFTBUS_OK;
1648 }
1649
LlGetPubMac(void * buf,uint32_t len)1650 static int32_t LlGetPubMac(void *buf, uint32_t len)
1651 {
1652 if (buf == NULL || len == 0) {
1653 LNN_LOGE(LNN_LEDGER, "invalid param");
1654 return SOFTBUS_INVALID_PARAM;
1655 }
1656 NodeInfo *info = &g_localNetLedger.localInfo;
1657 if (memcpy_s(buf, len, info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN) != EOK) {
1658 LNN_LOGE(LNN_LEDGER, "memcpy publicAddress fail");
1659 return SOFTBUS_MEM_ERR;
1660 }
1661 return SOFTBUS_OK;
1662 }
1663
LlGetCipherInfoKey(void * buf,uint32_t len)1664 static int32_t LlGetCipherInfoKey(void *buf, uint32_t len)
1665 {
1666 if (buf == NULL || len == 0) {
1667 LNN_LOGE(LNN_LEDGER, "invalid param");
1668 return SOFTBUS_INVALID_PARAM;
1669 }
1670 NodeInfo *info = &g_localNetLedger.localInfo;
1671 if (memcpy_s(buf, len, info->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
1672 LNN_LOGE(LNN_LEDGER, "memcpy cipher key fail");
1673 return SOFTBUS_MEM_ERR;
1674 }
1675 return SOFTBUS_OK;
1676 }
1677
LlGetCipherInfoIv(void * buf,uint32_t len)1678 static int32_t LlGetCipherInfoIv(void *buf, uint32_t len)
1679 {
1680 if (buf == NULL || len == 0) {
1681 LNN_LOGE(LNN_LEDGER, "invalid param");
1682 return SOFTBUS_INVALID_PARAM;
1683 }
1684 NodeInfo *info = &g_localNetLedger.localInfo;
1685 if (memcpy_s(buf, len, info->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
1686 LNN_LOGE(LNN_LEDGER, "memcpy cipher iv fail");
1687 return SOFTBUS_MEM_ERR;
1688 }
1689 return SOFTBUS_OK;
1690 }
1691
UpdateLocalIrk(const void * id)1692 static int32_t UpdateLocalIrk(const void *id)
1693 {
1694 if (id == NULL) {
1695 LNN_LOGE(LNN_LEDGER, "id is null");
1696 return SOFTBUS_INVALID_PARAM;
1697 }
1698 if (memcpy_s((char *)g_localNetLedger.localInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, id, LFINDER_IRK_LEN) != EOK) {
1699 LNN_LOGE(LNN_LEDGER, "memcpy peerIrk fail");
1700 return SOFTBUS_MEM_ERR;
1701 }
1702 return SOFTBUS_OK;
1703 }
1704
UpdateLocalPubMac(const void * id)1705 static int32_t UpdateLocalPubMac(const void *id)
1706 {
1707 if (id == NULL) {
1708 LNN_LOGE(LNN_LEDGER, "id is null");
1709 return SOFTBUS_INVALID_PARAM;
1710 }
1711 if (memcpy_s((char *)g_localNetLedger.localInfo.rpaInfo.publicAddress,
1712 LFINDER_MAC_ADDR_LEN, id, LFINDER_MAC_ADDR_LEN) != EOK) {
1713 LNN_LOGE(LNN_LEDGER, "memcpy publicAddress fail");
1714 return SOFTBUS_MEM_ERR;
1715 }
1716 return SOFTBUS_OK;
1717 }
1718
UpdateLocalCipherInfoKey(const void * id)1719 static int32_t UpdateLocalCipherInfoKey(const void *id)
1720 {
1721 if (id == NULL) {
1722 LNN_LOGE(LNN_LEDGER, "id is null");
1723 return SOFTBUS_INVALID_PARAM;
1724 }
1725 if (memcpy_s((char *)g_localNetLedger.localInfo.cipherInfo.key,
1726 SESSION_KEY_LENGTH, id, SESSION_KEY_LENGTH) != EOK) {
1727 LNN_LOGE(LNN_LEDGER, "memcpy cipherInfo.key fail");
1728 return SOFTBUS_MEM_ERR;
1729 }
1730 return SOFTBUS_OK;
1731 }
1732
UpdateLocalCipherInfoIv(const void * id)1733 static int32_t UpdateLocalCipherInfoIv(const void *id)
1734 {
1735 if (id == NULL) {
1736 LNN_LOGE(LNN_LEDGER, "id is null");
1737 return SOFTBUS_INVALID_PARAM;
1738 }
1739 if (memcpy_s((char *)g_localNetLedger.localInfo.cipherInfo.iv, BROADCAST_IV_LEN, id, BROADCAST_IV_LEN) != EOK) {
1740 LNN_LOGE(LNN_LEDGER, "memcpy cipherInfo.iv fail");
1741 return SOFTBUS_MEM_ERR;
1742 }
1743 return SOFTBUS_OK;
1744 }
1745
LlGetP2pIp(void * buf,uint32_t len)1746 static int32_t LlGetP2pIp(void *buf, uint32_t len)
1747 {
1748 if (buf == NULL) {
1749 LNN_LOGE(LNN_LEDGER, "invalid param");
1750 return SOFTBUS_INVALID_PARAM;
1751 }
1752 NodeInfo *info = &g_localNetLedger.localInfo;
1753 if (strcpy_s((char *)buf, len, info->p2pInfo.p2pIp) != EOK) {
1754 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1755 return SOFTBUS_MEM_ERR;
1756 }
1757 return SOFTBUS_OK;
1758 }
1759
LlUpdateLocalP2pIp(const void * p2pIp)1760 static int32_t LlUpdateLocalP2pIp(const void *p2pIp)
1761 {
1762 if (p2pIp == NULL) {
1763 LNN_LOGE(LNN_LEDGER, "invalid param");
1764 return SOFTBUS_INVALID_PARAM;
1765 }
1766 NodeInfo *info = &g_localNetLedger.localInfo;
1767 if (strcpy_s(info->p2pInfo.p2pIp, sizeof(info->p2pInfo.p2pIp), (const char *)p2pIp) != EOK) {
1768 LNN_LOGE(LNN_LEDGER, "STR COPY ERROR");
1769 return SOFTBUS_MEM_ERR;
1770 }
1771 return SOFTBUS_OK;
1772 }
1773
1774 static LocalLedgerKey g_localKeyTable[] = {
1775 {STRING_KEY_HICE_VERSION, VERSION_MAX_LEN, LlGetNodeSoftBusVersion, NULL},
1776 {STRING_KEY_DEV_UDID, UDID_BUF_LEN, LlGetDeviceUdid, UpdateLocalDeviceUdid},
1777 {STRING_KEY_NETWORKID, NETWORK_ID_BUF_LEN, LlGetNetworkId, UpdateLocalNetworkId},
1778 {STRING_KEY_OS_VERSION, OS_VERSION_BUF_LEN, LlGetOsVersion, NULL},
1779 {STRING_KEY_UUID, UUID_BUF_LEN, LlGetUuid, UpdateLocalUuid},
1780 {STRING_KEY_DEV_TYPE, DEVICE_TYPE_BUF_LEN, LlGetDeviceType, UpdateLocalDeviceType},
1781 {STRING_KEY_DEV_NAME, DEVICE_NAME_BUF_LEN, LlGetDeviceName, UpdateLocalDeviceName},
1782 {STRING_KEY_DEV_UNIFIED_NAME, DEVICE_NAME_BUF_LEN, LlGetUnifiedName, UpdateUnifiedName},
1783 {STRING_KEY_DEV_UNIFIED_DEFAULT_NAME, DEVICE_NAME_BUF_LEN, LlGetUnifiedDefaultName, UpdateUnifiedDefaultName},
1784 {STRING_KEY_DEV_NICK_NAME, DEVICE_NAME_BUF_LEN, LlGetNickName, UpdateNickName},
1785 {STRING_KEY_BT_MAC, MAC_LEN, LlGetBtMac, UpdateLocalBtMac},
1786 {STRING_KEY_WLAN_IP, IP_LEN, LlGetWlanIp, UpdateLocalDeviceIp},
1787 {STRING_KEY_NET_IF_NAME, NET_IF_NAME_LEN, LlGetNetIfName, UpdateLocalNetIfName},
1788 {STRING_KEY_MASTER_NODE_UDID, UDID_BUF_LEN, L1GetMasterNodeUdid, UpdateMasterNodeUdid},
1789 {STRING_KEY_NODE_ADDR, SHORT_ADDRESS_MAX_LEN, LlGetNodeAddr, LlUpdateNodeAddr},
1790 {STRING_KEY_P2P_MAC, MAC_LEN, LlGetP2pMac, UpdateP2pMac},
1791 {STRING_KEY_WIFI_CFG, WIFI_CFG_INFO_MAX_LEN, L1GetWifiCfg, UpdateWifiCfg},
1792 {STRING_KEY_CHAN_LIST_5G, CHANNEL_LIST_STR_LEN, L1GetChanList5g, UpdateChanList5g},
1793 {STRING_KEY_P2P_GO_MAC, MAC_LEN, LlGetP2pGoMac, UpdateP2pGoMac},
1794 {STRING_KEY_OFFLINE_CODE, OFFLINE_CODE_LEN, LlGetOffLineCode, LlUpdateLocalOffLineCode},
1795 {STRING_KEY_EXTDATA, EXTDATA_LEN, LlGetExtData, LlUpdateLocalExtData},
1796 {STRING_KEY_BLE_MAC, MAC_LEN, LlGetBleMac, UpdateLocalBleMac},
1797 {STRING_KEY_WIFIDIRECT_ADDR, MAC_LEN, LlGetWifiDirectAddr, UpdateWifiDirectAddr},
1798 {STRING_KEY_P2P_IP, IP_LEN, LlGetP2pIp, LlUpdateLocalP2pIp},
1799 {NUM_KEY_SESSION_PORT, -1, LlGetSessionPort, UpdateLocalSessionPort},
1800 {NUM_KEY_AUTH_PORT, -1, LlGetAuthPort, UpdateLocalAuthPort},
1801 {NUM_KEY_PROXY_PORT, -1, LlGetProxyPort, UpdateLocalProxyPort},
1802 {NUM_KEY_NET_CAP, -1, LlGetNetCap, UpdateLocalNetCapability},
1803 {NUM_KEY_FEATURE_CAPA, -1, LlGetFeatureCapa, UpdateLocalFeatureCapability},
1804 {NUM_KEY_DISCOVERY_TYPE, -1, LlGetNetType, NULL},
1805 {NUM_KEY_DEV_TYPE_ID, -1, LlGetDeviceTypeId, NULL},
1806 {NUM_KEY_OS_TYPE, -1, LlGetOsType, NULL},
1807 {NUM_KEY_AUTH_CAP, -1, LlGetAuthCapability, NULL},
1808 {NUM_KEY_MASTER_NODE_WEIGHT, -1, L1GetMasterNodeWeight, UpdateMasgerNodeWeight},
1809 {NUM_KEY_P2P_ROLE, -1, L1GetP2pRole, UpdateP2pRole},
1810 {NUM_KEY_STATE_VERSION, -1, LlGetStateVersion, UpdateStateVersion},
1811 {NUM_KEY_STA_FREQUENCY, -1, L1GetStaFrequency, UpdateStaFrequency},
1812 {NUM_KEY_TRANS_PROTOCOLS, sizeof(int64_t), LlGetSupportedProtocols, LlUpdateSupportedProtocols},
1813 {NUM_KEY_DATA_CHANGE_FLAG, sizeof(int16_t), L1GetNodeDataChangeFlag, UpdateNodeDataChangeFlag},
1814 {NUM_KEY_DATA_DYNAMIC_LEVEL, sizeof(uint16_t), L1GetDataDynamicLevel, UpdateDataDynamicLevel},
1815 {NUM_KEY_DATA_STATIC_LEVEL, sizeof(uint16_t), L1GetDataStaticLevel, UpdateDataStaticLevel},
1816 {NUM_KEY_DATA_SWITCH_LEVEL, sizeof(uint32_t), L1GetDataSwitchLevel, UpdateDataSwitchLevel},
1817 {NUM_KEY_DATA_SWITCH_LENGTH, sizeof(uint16_t), L1GetDataSwitchLength, UpdateDataSwitchLength},
1818 {NUM_KEY_ACCOUNT_LONG, sizeof(int64_t), LocalGetNodeAccountId, LocalUpdateNodeAccountId},
1819 {NUM_KEY_BLE_START_TIME, sizeof(int64_t), LocalGetNodeBleStartTime, LocalUpdateBleStartTime},
1820 {BYTE_KEY_IRK, LFINDER_IRK_LEN, LlGetIrk, UpdateLocalIrk},
1821 {BYTE_KEY_PUB_MAC, LFINDER_MAC_ADDR_LEN, LlGetPubMac, UpdateLocalPubMac},
1822 {BYTE_KEY_BROADCAST_CIPHER_KEY, SESSION_KEY_LENGTH, LlGetCipherInfoKey, UpdateLocalCipherInfoKey},
1823 {BYTE_KEY_BROADCAST_CIPHER_IV, BROADCAST_IV_LEN, LlGetCipherInfoIv, UpdateLocalCipherInfoIv},
1824 {NUM_KEY_STATIC_CAP_LEN, sizeof(int32_t), LlGetStaticCapLen, LlUpdateStaticCapLen},
1825 {NUM_KEY_DEVICE_SECURITY_LEVEL, sizeof(int32_t), LlGetDeviceSecurityLevel, LlUpdateDeviceSecurityLevel},
1826 {NUM_KEY_NETWORK_ID_TIMESTAMP, sizeof(int64_t), LocalGetNetworkIdTimeStamp, LocalUpdateNetworkIdTimeStamp},
1827 {BYTE_KEY_ACCOUNT_HASH, SHA_256_HASH_LEN, LlGetAccount, LlUpdateAccount},
1828 {BYTE_KEY_STATIC_CAPABILITY, STATIC_CAP_LEN, LlGetStaticCapability, LlUpdateStaticCapability},
1829 {BYTE_KEY_UDID_HASH, SHA_256_HASH_LEN, LlGetUdidHash, NULL},
1830 {BOOL_KEY_SCREEN_STATUS, NODE_SCREEN_STATUS_LEN, L1GetNodeScreenOnFlag, NULL},
1831 };
1832
LnnGetLocalStrInfo(InfoKey key,char * info,uint32_t len)1833 int32_t LnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len)
1834 {
1835 uint32_t i;
1836 int32_t ret;
1837 if (info == NULL) {
1838 LNN_LOGE(LNN_LEDGER, "para error");
1839 return SOFTBUS_INVALID_PARAM;
1840 }
1841 if (key >= STRING_KEY_END) {
1842 LNN_LOGE(LNN_LEDGER, "KEY error");
1843 return SOFTBUS_INVALID_PARAM;
1844 }
1845 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1846 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1847 return SOFTBUS_LOCK_ERR;
1848 }
1849 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1850 if (key == g_localKeyTable[i].key) {
1851 if (g_localKeyTable[i].getInfo != NULL) {
1852 ret = g_localKeyTable[i].getInfo((void *)info, len);
1853 SoftBusMutexUnlock(&g_localNetLedger.lock);
1854 return ret;
1855 }
1856 }
1857 }
1858 SoftBusMutexUnlock(&g_localNetLedger.lock);
1859 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1860 return SOFTBUS_ERR;
1861 }
1862
LnnGetLocalInfo(InfoKey key,void * info,uint32_t infoSize)1863 static int32_t LnnGetLocalInfo(InfoKey key, void* info, uint32_t infoSize)
1864 {
1865 uint32_t i;
1866 int32_t ret;
1867 if (info == NULL) {
1868 LNN_LOGE(LNN_LEDGER, "para error");
1869 return SOFTBUS_INVALID_PARAM;
1870 }
1871 if ((key < NUM_KEY_BEGIN || key >= NUM_KEY_END) &&
1872 (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END)) {
1873 LNN_LOGE(LNN_LEDGER, "KEY error");
1874 return SOFTBUS_INVALID_PARAM;
1875 }
1876 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1877 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1878 return SOFTBUS_LOCK_ERR;
1879 }
1880 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1881 if (key == g_localKeyTable[i].key) {
1882 if (g_localKeyTable[i].getInfo != NULL) {
1883 ret = g_localKeyTable[i].getInfo(info, infoSize);
1884 SoftBusMutexUnlock(&g_localNetLedger.lock);
1885 return ret;
1886 }
1887 }
1888 }
1889 SoftBusMutexUnlock(&g_localNetLedger.lock);
1890 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1891 return SOFTBUS_ERR;
1892 }
1893
LnnGetLocalBoolInfo(InfoKey key,bool * info,uint32_t len)1894 int32_t LnnGetLocalBoolInfo(InfoKey key, bool *info, uint32_t len)
1895 {
1896 uint32_t i;
1897 int32_t ret;
1898 if (key >= BOOL_KEY_END) {
1899 LNN_LOGE(LNN_LEDGER, "KEY error");
1900 return SOFTBUS_INVALID_PARAM;
1901 }
1902 if (info == NULL) {
1903 LNN_LOGE(LNN_LEDGER, "info is NULL");
1904 return SOFTBUS_INVALID_PARAM;
1905 }
1906 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1907 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1908 return SOFTBUS_LOCK_ERR;
1909 }
1910 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1911 if (key == g_localKeyTable[i].key) {
1912 if (g_localKeyTable[i].getInfo != NULL) {
1913 ret = g_localKeyTable[i].getInfo((void *)info, len);
1914 SoftBusMutexUnlock(&g_localNetLedger.lock);
1915 return ret;
1916 }
1917 }
1918 }
1919 SoftBusMutexUnlock(&g_localNetLedger.lock);
1920 LNN_LOGE(LNN_LEDGER, "KEY NOT exist");
1921 return SOFTBUS_ERR;
1922 }
1923
JudgeString(const char * info,int32_t len)1924 static bool JudgeString(const char *info, int32_t len)
1925 {
1926 return (len <= 0) ? false : IsValidString(info, (uint32_t)len);
1927 }
1928
LnnSetLocalUnifiedName(const char * unifiedName)1929 int32_t LnnSetLocalUnifiedName(const char *unifiedName)
1930 {
1931 if (unifiedName == NULL) {
1932 return SOFTBUS_INVALID_PARAM;
1933 }
1934 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1935 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1936 return SOFTBUS_LOCK_ERR;
1937 }
1938 if (strcpy_s(g_localNetLedger.localInfo.deviceInfo.unifiedName,
1939 DEVICE_NAME_BUF_LEN, unifiedName) != EOK) {
1940 SoftBusMutexUnlock(&g_localNetLedger.lock);
1941 return SOFTBUS_ERR;
1942 }
1943 SoftBusMutexUnlock(&g_localNetLedger.lock);
1944 return SOFTBUS_OK;
1945 }
1946
LnnSetLocalStrInfo(InfoKey key,const char * info)1947 int32_t LnnSetLocalStrInfo(InfoKey key, const char *info)
1948 {
1949 uint32_t i;
1950 int32_t ret;
1951 if (info == NULL) {
1952 LNN_LOGE(LNN_LEDGER, "para error");
1953 return SOFTBUS_INVALID_PARAM;
1954 }
1955 if (key >= STRING_KEY_END) {
1956 LNN_LOGE(LNN_LEDGER, "KEY error");
1957 return SOFTBUS_INVALID_PARAM;
1958 }
1959 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1960 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1961 return SOFTBUS_LOCK_ERR;
1962 }
1963 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1964 if (key == g_localKeyTable[i].key) {
1965 if (g_localKeyTable[i].setInfo != NULL && JudgeString(info, g_localKeyTable[i].maxLen)) {
1966 ret = g_localKeyTable[i].setInfo((void *)info);
1967 SoftBusMutexUnlock(&g_localNetLedger.lock);
1968 return ret;
1969 }
1970 LNN_LOGE(LNN_LEDGER, "key not support or info format error. key=%{public}d", key);
1971 SoftBusMutexUnlock(&g_localNetLedger.lock);
1972 return SOFTBUS_INVALID_PARAM;
1973 }
1974 }
1975 SoftBusMutexUnlock(&g_localNetLedger.lock);
1976 LNN_LOGE(LNN_LEDGER, "key not exist");
1977 return SOFTBUS_ERR;
1978 }
1979
LnnSetLocalInfo(InfoKey key,void * info)1980 static int32_t LnnSetLocalInfo(InfoKey key, void* info)
1981 {
1982 uint32_t i;
1983 int32_t ret;
1984 if ((key < NUM_KEY_BEGIN || key >= NUM_KEY_END) &&
1985 (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END)) {
1986 LNN_LOGE(LNN_LEDGER, "KEY error");
1987 return SOFTBUS_INVALID_PARAM;
1988 }
1989 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1990 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
1991 return SOFTBUS_LOCK_ERR;
1992 }
1993 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1994 if (key == g_localKeyTable[i].key) {
1995 if (g_localKeyTable[i].setInfo != NULL) {
1996 ret = g_localKeyTable[i].setInfo(info);
1997 SoftBusMutexUnlock(&g_localNetLedger.lock);
1998 return ret;
1999 }
2000 LNN_LOGE(LNN_LEDGER, "key not support. key=%{public}d", key);
2001 SoftBusMutexUnlock(&g_localNetLedger.lock);
2002 return SOFTBUS_ERR;
2003 }
2004 }
2005 SoftBusMutexUnlock(&g_localNetLedger.lock);
2006 LNN_LOGE(LNN_LEDGER, "key not exist");
2007 return SOFTBUS_ERR;
2008 }
2009
LnnFirstGetUdid(void)2010 static int32_t LnnFirstGetUdid(void)
2011 {
2012 NodeInfo *nodeInfo = &g_localNetLedger.localInfo;
2013 DeviceBasicInfo *deviceInfo = &nodeInfo->deviceInfo;
2014 if (GetCommonDevInfo(COMM_DEVICE_KEY_UDID, deviceInfo->deviceUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
2015 LNN_LOGE(LNN_LEDGER, "COMM_DEVICE_KEY_UDID failed");
2016 return SOFTBUS_ERR;
2017 }
2018 return SOFTBUS_OK;
2019 }
2020
LnnLoadBroadcastCipherInfo(BroadcastCipherKey * broadcastKey)2021 static int32_t LnnLoadBroadcastCipherInfo(BroadcastCipherKey *broadcastKey)
2022 {
2023 if (broadcastKey == NULL) {
2024 LNN_LOGE(LNN_LEDGER, "broadcastKey is null.");
2025 return SOFTBUS_ERR;
2026 }
2027 if (LnnGetLocalBroadcastCipherKey(broadcastKey) != SOFTBUS_OK) {
2028 LNN_LOGE(LNN_LEDGER, "get local info failed.");
2029 return SOFTBUS_ERR;
2030 }
2031 if (LnnSetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_KEY,
2032 broadcastKey->cipherInfo.key, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
2033 LNN_LOGE(LNN_LEDGER, "set key error.");
2034 return SOFTBUS_ERR;
2035 }
2036 if (LnnSetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_IV,
2037 broadcastKey->cipherInfo.iv, BROADCAST_IV_LEN) != SOFTBUS_OK) {
2038 LNN_LOGE(LNN_LEDGER, "set iv error.");
2039 return SOFTBUS_ERR;
2040 }
2041 LNN_LOGI(LNN_LEDGER, "load BroadcastCipherInfo success!");
2042 return SOFTBUS_OK;
2043 }
2044
LnnGenBroadcastCipherInfo(void)2045 static int32_t LnnGenBroadcastCipherInfo(void)
2046 {
2047 BroadcastCipherKey broadcastKey;
2048 int32_t ret = SOFTBUS_ERR;
2049 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
2050 do {
2051 if (LnnLoadLocalBroadcastCipherKey() == SOFTBUS_OK) {
2052 ret = LnnLoadBroadcastCipherInfo(&broadcastKey);
2053 break;
2054 }
2055 if (SoftBusGenerateRandomArray(broadcastKey.cipherInfo.key, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
2056 LNN_LOGE(LNN_LEDGER, "generate broadcast key error.");
2057 break;
2058 }
2059 if (SoftBusGenerateRandomArray(broadcastKey.cipherInfo.iv, BROADCAST_IV_LEN) != SOFTBUS_OK) {
2060 LNN_LOGE(LNN_LEDGER, "generate broadcast iv error.");
2061 break;
2062 }
2063 if (LnnSetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_KEY,
2064 broadcastKey.cipherInfo.key, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
2065 LNN_LOGE(LNN_LEDGER, "set key error.");
2066 break;
2067 }
2068 if (LnnSetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_IV,
2069 broadcastKey.cipherInfo.iv, BROADCAST_IV_LEN) != SOFTBUS_OK) {
2070 LNN_LOGE(LNN_LEDGER, "set iv error.");
2071 break;
2072 }
2073 if (LnnUpdateLocalBroadcastCipherKey(&broadcastKey) != SOFTBUS_OK) {
2074 LNN_LOGE(LNN_LEDGER, "update local broadcast key failed");
2075 break;
2076 }
2077 LNN_LOGI(LNN_LEDGER, "generate BroadcastCipherInfo success!");
2078 ret = SOFTBUS_OK;
2079 } while (0);
2080 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
2081 return ret;
2082 }
2083
LnnGetLocalNumInfo(InfoKey key,int32_t * info)2084 int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info)
2085 {
2086 return LnnGetLocalInfo(key, (void *)info, sizeof(int32_t));
2087 }
2088
LnnSetLocalNumInfo(InfoKey key,int32_t info)2089 int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info)
2090 {
2091 return LnnSetLocalInfo(key, (void *)&info);
2092 }
2093
LnnGetLocalNum64Info(InfoKey key,int64_t * info)2094 int32_t LnnGetLocalNum64Info(InfoKey key, int64_t *info)
2095 {
2096 return LnnGetLocalInfo(key, (void *)info, sizeof(int64_t));
2097 }
2098
LnnGetLocalNumU64Info(InfoKey key,uint64_t * info)2099 int32_t LnnGetLocalNumU64Info(InfoKey key, uint64_t *info)
2100 {
2101 return LnnGetLocalInfo(key, (void *)info, sizeof(uint64_t));
2102 }
2103
LnnSetLocalNum64Info(InfoKey key,int64_t info)2104 int32_t LnnSetLocalNum64Info(InfoKey key, int64_t info)
2105 {
2106 return LnnSetLocalInfo(key, (void *)&info);
2107 }
2108
LnnGetLocalNum16Info(InfoKey key,int16_t * info)2109 int32_t LnnGetLocalNum16Info(InfoKey key, int16_t *info)
2110 {
2111 return LnnGetLocalInfo(key, (void *)info, sizeof(int16_t));
2112 }
2113
LnnSetLocalNum16Info(InfoKey key,int16_t info)2114 int32_t LnnSetLocalNum16Info(InfoKey key, int16_t info)
2115 {
2116 return LnnSetLocalInfo(key, (void *)&info);
2117 }
2118
LnnGetLocalNumU16Info(InfoKey key,uint16_t * info)2119 int32_t LnnGetLocalNumU16Info(InfoKey key, uint16_t *info)
2120 {
2121 return LnnGetLocalInfo(key, (void *)info, sizeof(uint16_t));
2122 }
2123
LnnSetLocalNumU16Info(InfoKey key,uint16_t info)2124 int32_t LnnSetLocalNumU16Info(InfoKey key, uint16_t info)
2125 {
2126 return LnnSetLocalInfo(key, (void *)&info);
2127 }
2128
LnnGetLocalNumU32Info(InfoKey key,uint32_t * info)2129 int32_t LnnGetLocalNumU32Info(InfoKey key, uint32_t *info)
2130 {
2131 return LnnGetLocalInfo(key, (void *)info, sizeof(uint32_t));
2132 }
2133
LnnSetLocalNumU32Info(InfoKey key,uint32_t info)2134 int32_t LnnSetLocalNumU32Info(InfoKey key, uint32_t info)
2135 {
2136 return LnnSetLocalInfo(key, (void *)&info);
2137 }
2138
LnnSetLocalByteInfo(InfoKey key,const uint8_t * info,uint32_t len)2139 int32_t LnnSetLocalByteInfo(InfoKey key, const uint8_t *info, uint32_t len)
2140 {
2141 (void)len;
2142 return LnnSetLocalInfo(key, (void *)info);
2143 }
2144
LnnGetLocalByteInfo(InfoKey key,uint8_t * info,uint32_t len)2145 int32_t LnnGetLocalByteInfo(InfoKey key, uint8_t *info, uint32_t len)
2146 {
2147 return LnnGetLocalInfo(key, (void *)info, len);
2148 }
2149
LnnGetLocalDeviceInfo(NodeBasicInfo * info)2150 int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info)
2151 {
2152 int32_t rc;
2153 char type[DEVICE_TYPE_BUF_LEN] = {0};
2154
2155 if (info == NULL) {
2156 LNN_LOGE(LNN_LEDGER, "info is null");
2157 return SOFTBUS_INVALID_PARAM;
2158 }
2159 rc = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, info->deviceName, DEVICE_NAME_BUF_LEN);
2160 if (rc != SOFTBUS_OK) {
2161 LNN_LOGE(LNN_LEDGER, "get local device info failed");
2162 return SOFTBUS_ERR;
2163 }
2164 rc = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, info->networkId, NETWORK_ID_BUF_LEN);
2165 if (rc != SOFTBUS_OK) {
2166 LNN_LOGE(LNN_LEDGER, "get local network id info failed");
2167 return SOFTBUS_ERR;
2168 }
2169 rc = LnnGetLocalStrInfo(STRING_KEY_DEV_TYPE, type, DEVICE_TYPE_BUF_LEN);
2170 if (rc != SOFTBUS_OK) {
2171 LNN_LOGE(LNN_LEDGER, "get local device type failed");
2172 return SOFTBUS_ERR;
2173 }
2174 rc = LnnGetLocalStrInfo(STRING_KEY_OS_VERSION, info->osVersion, OS_VERSION_BUF_LEN);
2175 if (rc != SOFTBUS_OK) {
2176 LNN_LOGE(LNN_LEDGER, "get local os version failed");
2177 return SOFTBUS_ERR;
2178 }
2179 rc = LnnGetLocalNumInfo(NUM_KEY_OS_TYPE, &info->osType);
2180 if (rc != SOFTBUS_OK) {
2181 LNN_LOGE(LNN_LEDGER, "get local os type failed");
2182 return SOFTBUS_ERR;
2183 }
2184 return LnnConvertDeviceTypeToId(type, &info->deviceTypeId);
2185 }
2186
SoftBusDumpBusCenterLocalDeviceInfo(int fd)2187 int32_t SoftBusDumpBusCenterLocalDeviceInfo(int fd)
2188 {
2189 SOFTBUS_DPRINTF(fd, "-----LocalDeviceInfo-----\n");
2190 NodeBasicInfo localNodeInfo;
2191 if (LnnGetLocalDeviceInfo(&localNodeInfo) != 0) {
2192 LNN_LOGE(LNN_LEDGER, "LnnGetLocalDeviceInfo failed");
2193 return SOFTBUS_ERR;
2194 }
2195 SoftBusDumpBusCenterPrintInfo(fd, &localNodeInfo);
2196 return SOFTBUS_OK;
2197 }
2198
LnnInitLocalNodeInfo(NodeInfo * nodeInfo)2199 static int32_t LnnInitLocalNodeInfo(NodeInfo *nodeInfo)
2200 {
2201 if (InitOfflineCode(nodeInfo) != SOFTBUS_OK) {
2202 return SOFTBUS_ERR;
2203 }
2204 if (strcpy_s(nodeInfo->nodeAddress, sizeof(nodeInfo->nodeAddress), NODE_ADDR_LOOPBACK) != EOK) {
2205 LNN_LOGE(LNN_LEDGER, "fail:strncpy_s fail");
2206 return SOFTBUS_ERR;
2207 }
2208 if (InitLocalDeviceInfo(&nodeInfo->deviceInfo) != SOFTBUS_OK) {
2209 LNN_LOGE(LNN_LEDGER, "init local device info error");
2210 return SOFTBUS_ERR;
2211 }
2212 if (InitLocalVersionType(nodeInfo) != SOFTBUS_OK) {
2213 LNN_LOGE(LNN_LEDGER, "init local version type error");
2214 return SOFTBUS_ERR;
2215 }
2216 if (GetDeviceSecurityLevel(&nodeInfo->deviceSecurityLevel) != SOFTBUS_OK) {
2217 LNN_LOGE(LNN_LEDGER, "init local deviceSecurityLevel fail, deviceSecurityLevel=%{public}d",
2218 nodeInfo->deviceSecurityLevel);
2219 }
2220 if (InitConnectInfo(&nodeInfo->connectInfo) != SOFTBUS_OK) {
2221 LNN_LOGE(LNN_LEDGER, "init local connect info error");
2222 return SOFTBUS_ERR;
2223 }
2224 if (LnnInitLocalP2pInfo(nodeInfo) != SOFTBUS_OK) {
2225 LNN_LOGE(LNN_LEDGER, "init local p2p info error");
2226 return SOFTBUS_ERR;
2227 }
2228 return SOFTBUS_OK;
2229 }
2230
GenerateStateVersion(void)2231 static void GenerateStateVersion(void)
2232 {
2233 uint8_t randNum = 0;
2234 if (SoftBusGenerateRandomArray((unsigned char *)&randNum, sizeof(uint8_t)) != SOFTBUS_OK) {
2235 LNN_LOGE(LNN_LEDGER, "generate random num err.");
2236 }
2237 randNum = randNum % (MAX_STATE_VERSION + 1);
2238 g_localNetLedger.localInfo.stateVersion = randNum;
2239 LNN_LOGI(LNN_LEDGER, "init local stateVersion=%{public}d", g_localNetLedger.localInfo.stateVersion);
2240 }
2241
LnnInitLocalLedger(void)2242 int32_t LnnInitLocalLedger(void)
2243 {
2244 NodeInfo *nodeInfo = NULL;
2245 if (g_localNetLedger.status == LL_INIT_SUCCESS) {
2246 LNN_LOGI(LNN_LEDGER, "local net ledger already init");
2247 return SOFTBUS_OK;
2248 }
2249 g_localNetLedger.status = LL_INIT_UNKNOWN;
2250 nodeInfo = &g_localNetLedger.localInfo;
2251 (void)memset_s(nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
2252 if (strncpy_s(nodeInfo->softBusVersion, VERSION_MAX_LEN, SOFTBUS_VERSION, strlen(SOFTBUS_VERSION)) != EOK) {
2253 LNN_LOGE(LNN_LEDGER, "fail:strncpy_s fail");
2254 g_localNetLedger.status = LL_INIT_FAIL;
2255 return SOFTBUS_MEM_ERR;
2256 }
2257 nodeInfo->groupType = ALL_GROUP_TYPE;
2258 nodeInfo->discoveryType = 0;
2259 nodeInfo->netCapacity = LnnGetNetCapabilty();
2260 nodeInfo->authCapacity = DEFAULT_SUPPORT_AUTHCAPACITY;
2261 nodeInfo->feature = LnnGetFeatureCapabilty();
2262 nodeInfo->connSubFeature = DEFAULT_CONN_SUB_FEATURE;
2263 nodeInfo->heartbeatCapacity = DEFAULT_SUPPORT_HBCAPACITY;
2264 if (LnnInitLocalNodeInfo(nodeInfo) != SOFTBUS_OK) {
2265 g_localNetLedger.status = LL_INIT_FAIL;
2266 return SOFTBUS_ERR;
2267 }
2268 if (SoftBusMutexInit(&g_localNetLedger.lock, NULL) != SOFTBUS_OK) {
2269 LNN_LOGE(LNN_LEDGER, "mutex init fail");
2270 g_localNetLedger.status = LL_INIT_FAIL;
2271 return SOFTBUS_ERR;
2272 }
2273 if (SoftBusRegBusCenterVarDump(
2274 (char *)SOFTBUS_BUSCENTER_DUMP_LOCALDEVICEINFO, &SoftBusDumpBusCenterLocalDeviceInfo) != SOFTBUS_OK) {
2275 LNN_LOGE(LNN_LEDGER, "SoftBusRegBusCenterVarDump regist fail");
2276 return SOFTBUS_ERR;
2277 }
2278 if (LnnFirstGetUdid() != SOFTBUS_OK) {
2279 LNN_LOGE(LNN_LEDGER, "first get udid fail, try again in one second");
2280 }
2281 if (LnnGenBroadcastCipherInfo() != SOFTBUS_OK) {
2282 LNN_LOGE(LNN_LEDGER, "generate cipher fail");
2283 }
2284 GenerateStateVersion();
2285 g_localNetLedger.status = LL_INIT_SUCCESS;
2286 return SOFTBUS_OK;
2287 }
2288
LnnInitLocalLedgerDelay(void)2289 int32_t LnnInitLocalLedgerDelay(void)
2290 {
2291 NodeInfo *nodeInfo = &g_localNetLedger.localInfo;
2292 DeviceBasicInfo *deviceInfo = &nodeInfo->deviceInfo;
2293 if (GetCommonDevInfo(COMM_DEVICE_KEY_UDID, deviceInfo->deviceUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
2294 LNN_LOGE(LNN_LEDGER, "GetCommonDevInfo: COMM_DEVICE_KEY_UDID failed");
2295 return SOFTBUS_ERR;
2296 }
2297 if (LnnInitOhosAccount() != SOFTBUS_OK) {
2298 LNN_LOGE(LNN_LEDGER, "init default ohos account failed");
2299 return SOFTBUS_ERR;
2300 }
2301 return SOFTBUS_OK;
2302 }
2303
LnnDeinitLocalLedger(void)2304 void LnnDeinitLocalLedger(void)
2305 {
2306 if (g_localNetLedger.status == LL_INIT_SUCCESS) {
2307 SoftBusMutexDestroy(&g_localNetLedger.lock);
2308 }
2309 g_localNetLedger.status = LL_INIT_UNKNOWN;
2310 }
2311
LnnIsMasterNode(void)2312 bool LnnIsMasterNode(void)
2313 {
2314 bool ret = false;
2315 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
2316 LNN_LOGE(LNN_LEDGER, "lock mutex fail");
2317 return ret;
2318 }
2319 const char* masterUdid = g_localNetLedger.localInfo.masterUdid;
2320 const char* deviceUdid = g_localNetLedger.localInfo.deviceInfo.deviceUdid;
2321 ret = strncmp(masterUdid, deviceUdid, strlen(deviceUdid)) == 0;
2322 SoftBusMutexUnlock(&g_localNetLedger.lock);
2323 return ret;
2324 }
2325
LnnUpdateLocalScreenStatus(bool isScreenOn)2326 int32_t LnnUpdateLocalScreenStatus(bool isScreenOn)
2327 {
2328 if (SoftBusMutexLock(&g_localNetLedger.lock) != SOFTBUS_OK) {
2329 LNN_LOGE(LNN_LEDGER, "lock mutex failed");
2330 return SOFTBUS_LOCK_ERR;
2331 }
2332 LnnSetScreenStatus(&g_localNetLedger.localInfo, isScreenOn);
2333 SoftBusMutexUnlock(&g_localNetLedger.lock);
2334 return SOFTBUS_OK;
2335 }
2336