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