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