1 /*
2 * Copyright (c) 2021 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 "bus_center_adapter.h"
25 #include "bus_center_manager.h"
26 #include "lnn_device_info_recovery.h"
27 #include "lnn_ohos_account.h"
28 #include "lnn_p2p_info.h"
29 #include "lnn_feature_capability.h"
30 #include "softbus_adapter_crypto.h"
31 #include "softbus_adapter_thread.h"
32 #include "softbus_def.h"
33 #include "softbus_errcode.h"
34 #include "softbus_log.h"
35 #include "softbus_utils.h"
36 #include "softbus_hidumper_buscenter.h"
37
38 #define SOFTBUS_VERSION "hm.1.0.0"
39 #define VERSION_TYPE_LITE "LITE"
40 #define VERSION_TYPE_DEFAULT ""
41 #define SOFTBUS_BUSCENTER_DUMP_LOCALDEVICEINFO "local_device_info"
42 #define ALL_GROUP_TYPE 0xF
43 #define MAX_STATE_VERSION 0xFF
44
45 typedef struct {
46 NodeInfo localInfo;
47 SoftBusMutex lock;
48 LocalLedgerStatus status;
49 } LocalNetLedger;
50
51 static LocalNetLedger g_localNetLedger;
52
UpDateStateVersionAndStore()53 static void UpDateStateVersionAndStore()
54 {
55 int32_t ret;
56 g_localNetLedger.localInfo.stateVersion++;
57 if (g_localNetLedger.localInfo.stateVersion > MAX_STATE_VERSION) {
58 g_localNetLedger.localInfo.stateVersion = 0;
59 }
60 if ((ret = LnnSaveLocalDeviceInfo(&g_localNetLedger.localInfo)) != SOFTBUS_OK) {
61 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "update local store fail!");
62 }
63 }
64
LlGetNodeSoftBusVersion(void * buf,uint32_t len)65 static int32_t LlGetNodeSoftBusVersion(void *buf, uint32_t len)
66 {
67 NodeInfo *info = &g_localNetLedger.localInfo;
68 if (buf == NULL) {
69 return SOFTBUS_INVALID_PARAM;
70 }
71 if (strncpy_s(buf, len, info->softBusVersion, strlen(info->softBusVersion)) != EOK) {
72 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
73 return SOFTBUS_MEM_ERR;
74 }
75 return SOFTBUS_OK;
76 }
77
LlGetDeviceUdid(void * buf,uint32_t len)78 static int32_t LlGetDeviceUdid(void *buf, uint32_t len)
79 {
80 const char *udid = NULL;
81 NodeInfo *info = &g_localNetLedger.localInfo;
82 if (buf == NULL) {
83 return SOFTBUS_INVALID_PARAM;
84 }
85 udid = LnnGetDeviceUdid(info);
86 if (udid == NULL) {
87 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get device udid fail");
88 return SOFTBUS_ERR;
89 }
90 if (strlen(udid) <= 0) {
91 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid invalid!\n");
92 return SOFTBUS_ERR;
93 }
94 if (strncpy_s(buf, len, udid, strlen(udid)) != EOK) {
95 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
96 return SOFTBUS_MEM_ERR;
97 }
98 return SOFTBUS_OK;
99 }
100
LlGetNetworkId(void * buf,uint32_t len)101 static int32_t LlGetNetworkId(void *buf, uint32_t len)
102 {
103 NodeInfo *info = &g_localNetLedger.localInfo;
104 if (buf == NULL) {
105 return SOFTBUS_INVALID_PARAM;
106 }
107 if (strncpy_s(buf, len, info->networkId, strlen(info->networkId)) != EOK) {
108 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
109 return SOFTBUS_MEM_ERR;
110 }
111 return SOFTBUS_OK;
112 }
113
LlGetOffLineCode(void * buf,uint32_t len)114 static int32_t LlGetOffLineCode(void *buf, uint32_t len)
115 {
116 NodeInfo *info = &g_localNetLedger.localInfo;
117 if (buf == NULL) {
118 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "buf of offlinecode is null!");
119 return SOFTBUS_INVALID_PARAM;
120 }
121 if (memcpy_s(buf, len, info->offlineCode, OFFLINE_CODE_BYTE_SIZE) != EOK) {
122 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s offlinecode ERROR!");
123 return SOFTBUS_MEM_ERR;
124 }
125 return SOFTBUS_OK;
126 }
127
LlGetExtData(void * buf,uint32_t len)128 static int32_t LlGetExtData(void *buf, uint32_t len)
129 {
130 NodeInfo *info = &g_localNetLedger.localInfo;
131 if (buf == NULL) {
132 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "buf of offlinecode is null!");
133 return SOFTBUS_INVALID_PARAM;
134 }
135 if (memcpy_s(buf, len, info->extData, EXTDATA_LEN) != EOK) {
136 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s offlinecode ERROR!");
137 return SOFTBUS_MEM_ERR;
138 }
139 return SOFTBUS_OK;
140 }
141
LlGetUuid(void * buf,uint32_t len)142 static int32_t LlGetUuid(void *buf, uint32_t len)
143 {
144 NodeInfo *info = &g_localNetLedger.localInfo;
145 if (buf == NULL) {
146 return SOFTBUS_INVALID_PARAM;
147 }
148 if (strncpy_s(buf, len, info->uuid, strlen(info->uuid)) != EOK) {
149 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
150 return SOFTBUS_MEM_ERR;
151 }
152 return SOFTBUS_OK;
153 }
154
UpdateLocalDeviceUdid(const void * buf)155 static int32_t UpdateLocalDeviceUdid(const void *buf)
156 {
157 NodeInfo *info = &g_localNetLedger.localInfo;
158 if (buf == NULL) {
159 return SOFTBUS_INVALID_PARAM;
160 }
161 return LnnSetDeviceUdid(info, (char *)buf);
162 }
163
LlGetDeviceType(void * buf,uint32_t len)164 static int32_t LlGetDeviceType(void *buf, uint32_t len)
165 {
166 NodeInfo *info = &g_localNetLedger.localInfo;
167 char *deviceType = NULL;
168 if (buf == NULL) {
169 return SOFTBUS_INVALID_PARAM;
170 }
171 deviceType = LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId);
172 if (deviceType == NULL) {
173 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "deviceType fail.");
174 return SOFTBUS_ERR;
175 }
176 if (strncpy_s(buf, len, deviceType, strlen(deviceType)) != EOK) {
177 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
178 return SOFTBUS_MEM_ERR;
179 }
180 return SOFTBUS_OK;
181 }
182
LlGetAccount(void * buf,uint32_t len)183 static int32_t LlGetAccount(void *buf, uint32_t len)
184 {
185 NodeInfo *info = &g_localNetLedger.localInfo;
186
187 if (buf == NULL) {
188 return SOFTBUS_INVALID_PARAM;
189 }
190 if (memcpy_s(buf, len, info->accountHash, SHA_256_HASH_LEN) != EOK) {
191 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LlGetAccount copy error.");
192 return SOFTBUS_MEM_ERR;
193 }
194 return SOFTBUS_OK;
195 }
196
LlUpdateAccount(const void * buf)197 static int32_t LlUpdateAccount(const void *buf)
198 {
199 if (buf == NULL) {
200 return SOFTBUS_INVALID_PARAM;
201 }
202
203 NodeInfo *info = &g_localNetLedger.localInfo;
204 if (memcpy_s(info->accountHash, SHA_256_HASH_LEN, buf, SHA_256_HASH_LEN) != EOK) {
205 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LlUpdateAccount copy error.");
206 return SOFTBUS_MEM_ERR;
207 }
208 return SOFTBUS_OK;
209 }
210
UpdateLocalDeviceType(const void * buf)211 static int32_t UpdateLocalDeviceType(const void *buf)
212 {
213 NodeInfo *info = &g_localNetLedger.localInfo;
214 uint16_t typeId;
215 if (buf == NULL) {
216 return SOFTBUS_INVALID_PARAM;
217 }
218 if (LnnConvertDeviceTypeToId((char *)buf, &typeId) == SOFTBUS_OK) {
219 info->deviceInfo.deviceTypeId = typeId;
220 return SOFTBUS_OK;
221 }
222 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set device type error.");
223 return SOFTBUS_ERR;
224 }
225
UpdateNodeDataChangeFlag(const void * buf)226 static int32_t UpdateNodeDataChangeFlag(const void *buf)
227 {
228 NodeInfo *info = &g_localNetLedger.localInfo;
229 if (buf == NULL) {
230 return SOFTBUS_INVALID_PARAM;
231 }
232 return LnnSetDataChangeFlag(info, *(int16_t *)buf);
233 }
234
LocalUpdateNodeAccountId(const void * buf)235 static int32_t LocalUpdateNodeAccountId(const void *buf)
236 {
237 NodeInfo *info = &g_localNetLedger.localInfo;
238 if (buf == NULL) {
239 return SOFTBUS_INVALID_PARAM;
240 }
241 info->accountId = *((int64_t *)buf);
242 return SOFTBUS_OK;
243 }
244
LocalUpdateBleStartTime(const void * buf)245 static int32_t LocalUpdateBleStartTime(const void *buf)
246 {
247 NodeInfo *info = &g_localNetLedger.localInfo;
248 if (buf == NULL) {
249 return SOFTBUS_INVALID_PARAM;
250 }
251 info->bleStartTimestamp = *((int64_t *)buf);
252 return SOFTBUS_OK;
253 }
254
LlGetDeviceName(void * buf,uint32_t len)255 static int32_t LlGetDeviceName(void *buf, uint32_t len)
256 {
257 NodeInfo *info = &g_localNetLedger.localInfo;
258 const char *deviceName = NULL;
259 if (buf == NULL) {
260 return SOFTBUS_INVALID_PARAM;
261 }
262 deviceName = LnnGetDeviceName(&info->deviceInfo);
263 if (deviceName == NULL) {
264 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get device name fail.");
265 return SOFTBUS_ERR;
266 }
267 if (strncpy_s(buf, len, deviceName, strlen(deviceName)) != EOK) {
268 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
269 return SOFTBUS_MEM_ERR;
270 }
271 return SOFTBUS_OK;
272 }
273
LlGetBtMac(void * buf,uint32_t len)274 static int32_t LlGetBtMac(void *buf, uint32_t len)
275 {
276 NodeInfo *info = &g_localNetLedger.localInfo;
277 const char *mac = NULL;
278 if (buf == NULL) {
279 return SOFTBUS_INVALID_PARAM;
280 }
281 mac = LnnGetBtMac(info);
282 if (mac == NULL) {
283 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get bt mac fail.");
284 return SOFTBUS_ERR;
285 }
286 if (strncpy_s(buf, len, mac, strlen(mac)) != EOK) {
287 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
288 return SOFTBUS_MEM_ERR;
289 }
290 return SOFTBUS_OK;
291 }
292
LlGetWlanIp(void * buf,uint32_t len)293 static int32_t LlGetWlanIp(void *buf, uint32_t len)
294 {
295 NodeInfo *info = &g_localNetLedger.localInfo;
296 const char *ip = NULL;
297 if (buf == NULL) {
298 return SOFTBUS_INVALID_PARAM;
299 }
300 ip = LnnGetWiFiIp(info);
301 if (ip == NULL) {
302 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get wifi ip fail.");
303 return SOFTBUS_ERR;
304 }
305 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "get LocalIp =%s", AnonymizesIp(ip));
306 if (strncpy_s(buf, len, ip, strlen(ip)) != EOK) {
307 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
308 return SOFTBUS_MEM_ERR;
309 }
310 return SOFTBUS_OK;
311 }
312
LlGetNetIfName(void * buf,uint32_t len)313 static int32_t LlGetNetIfName(void *buf, uint32_t len)
314 {
315 NodeInfo *info = &g_localNetLedger.localInfo;
316 const char *ifName = NULL;
317 if (buf == NULL) {
318 return SOFTBUS_INVALID_PARAM;
319 }
320 ifName = LnnGetNetIfName(info);
321 if (ifName == NULL) {
322 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get bt mac fail.");
323 return SOFTBUS_ERR;
324 }
325 if (strncpy_s(buf, len, ifName, strlen(ifName)) != EOK) {
326 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
327 return SOFTBUS_MEM_ERR;
328 }
329 return SOFTBUS_OK;
330 }
331
L1GetMasterNodeUdid(void * buf,uint32_t len)332 static int32_t L1GetMasterNodeUdid(void *buf, uint32_t len)
333 {
334 NodeInfo *info = &g_localNetLedger.localInfo;
335 const char *udid = NULL;
336
337 if (buf == NULL || len < UDID_BUF_LEN) {
338 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid get master node udid arguments");
339 return SOFTBUS_INVALID_PARAM;
340 }
341 udid = LnnGetMasterUdid(info);
342 if (udid == NULL) {
343 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get master udid fail.");
344 return SOFTBUS_ERR;
345 }
346 if (strncpy_s(buf, len, udid, strlen(udid)) != EOK) {
347 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy master udid failed");
348 return SOFTBUS_MEM_ERR;
349 }
350 return SOFTBUS_OK;
351 }
352
LlGetAuthPort(void * buf,uint32_t len)353 static int32_t LlGetAuthPort(void *buf, uint32_t len)
354 {
355 NodeInfo *info = &g_localNetLedger.localInfo;
356 if (buf == NULL || len != LNN_COMMON_LEN) {
357 return SOFTBUS_INVALID_PARAM;
358 }
359 int32_t port = LnnGetAuthPort(info);
360 if (port <= 0) {
361 return SOFTBUS_ERR;
362 }
363 *((int32_t *)buf) = port;
364 return SOFTBUS_OK;
365 }
366
UpdateLocalAuthPort(const void * buf)367 static int32_t UpdateLocalAuthPort(const void *buf)
368 {
369 NodeInfo *info = &g_localNetLedger.localInfo;
370 if (buf == NULL) {
371 return SOFTBUS_INVALID_PARAM;
372 }
373 return LnnSetAuthPort(info, *(int *)buf);
374 }
375
LlGetSessionPort(void * buf,uint32_t len)376 static int32_t LlGetSessionPort(void *buf, uint32_t len)
377 {
378 NodeInfo *info = &g_localNetLedger.localInfo;
379 if (buf == NULL || len != LNN_COMMON_LEN) {
380 return SOFTBUS_INVALID_PARAM;
381 }
382 *((int32_t *)buf) = LnnGetSessionPort(info);
383 return SOFTBUS_OK;
384 }
385
UpdateLocalSessionPort(const void * buf)386 static int32_t UpdateLocalSessionPort(const void *buf)
387 {
388 NodeInfo *info = &g_localNetLedger.localInfo;
389 if (buf == NULL) {
390 return SOFTBUS_INVALID_PARAM;
391 }
392 return LnnSetSessionPort(info, *(int *)buf);
393 }
394
LlGetProxyPort(void * buf,uint32_t len)395 static int32_t LlGetProxyPort(void *buf, uint32_t len)
396 {
397 NodeInfo *info = &g_localNetLedger.localInfo;
398 if (buf == NULL || len != LNN_COMMON_LEN) {
399 return SOFTBUS_INVALID_PARAM;
400 }
401 *((int32_t *)buf) = LnnGetProxyPort(info);
402 return SOFTBUS_OK;
403 }
404
UpdateStateVersion(const void * buf)405 static int32_t UpdateStateVersion(const void *buf)
406 {
407 NodeInfo *info = &g_localNetLedger.localInfo;
408 if (buf == NULL) {
409 return SOFTBUS_INVALID_PARAM;
410 }
411 if (*(int32_t *)buf > MAX_STATE_VERSION) {
412 *(int32_t *)buf = 0;
413 }
414 info->stateVersion = *(int32_t *)buf;
415 return SOFTBUS_OK;
416 }
417
UpdateLocalProxyPort(const void * buf)418 static int32_t UpdateLocalProxyPort(const void *buf)
419 {
420 NodeInfo *info = &g_localNetLedger.localInfo;
421 if (buf == NULL) {
422 return SOFTBUS_INVALID_PARAM;
423 }
424 return LnnSetProxyPort(info, *(int *)buf);
425 }
426
LlGetNetCap(void * buf,uint32_t len)427 static int32_t LlGetNetCap(void *buf, uint32_t len)
428 {
429 NodeInfo *info = &g_localNetLedger.localInfo;
430 if (buf == NULL || len != LNN_COMMON_LEN) {
431 return SOFTBUS_INVALID_PARAM;
432 }
433 *((int32_t *)buf) = info->netCapacity;
434 return SOFTBUS_OK;
435 }
436
LlGetFeatureCapa(void * buf,uint32_t len)437 static int32_t LlGetFeatureCapa(void *buf, uint32_t len)
438 {
439 NodeInfo *info = &g_localNetLedger.localInfo;
440 if (buf == NULL || len != sizeof(uint64_t)) {
441 return SOFTBUS_INVALID_PARAM;
442 }
443 *((uint64_t *)buf) = info->feature;
444 return SOFTBUS_OK;
445 }
446
LlGetNetType(void * buf,uint32_t len)447 static int32_t LlGetNetType(void *buf, uint32_t len)
448 {
449 NodeInfo *info = &g_localNetLedger.localInfo;
450 if (buf == NULL || len != LNN_COMMON_LEN) {
451 return SOFTBUS_INVALID_PARAM;
452 }
453 *((int32_t *)buf) = info->discoveryType;
454 return SOFTBUS_OK;
455 }
456
LlGetDeviceTypeId(void * buf,uint32_t len)457 static int32_t LlGetDeviceTypeId(void *buf, uint32_t len)
458 {
459 NodeInfo *info = &g_localNetLedger.localInfo;
460 if (buf == NULL || len != LNN_COMMON_LEN) {
461 return SOFTBUS_INVALID_PARAM;
462 }
463 *((int32_t *)buf) = info->deviceInfo.deviceTypeId;
464 return SOFTBUS_OK;
465 }
466
L1GetMasterNodeWeight(void * buf,uint32_t len)467 static int32_t L1GetMasterNodeWeight(void *buf, uint32_t len)
468 {
469 NodeInfo *info = &g_localNetLedger.localInfo;
470
471 if (buf == NULL || len != LNN_COMMON_LEN) {
472 return SOFTBUS_INVALID_PARAM;
473 }
474 *((int32_t *)buf) = info->masterWeight;
475 return SOFTBUS_OK;
476 }
477
LlGetP2pMac(void * buf,uint32_t len)478 static int32_t LlGetP2pMac(void *buf, uint32_t len)
479 {
480 const char *mac = NULL;
481 if (buf == NULL || len < MAC_LEN) {
482 return SOFTBUS_INVALID_PARAM;
483 }
484 mac = LnnGetP2pMac(&g_localNetLedger.localInfo);
485 if (mac == NULL) {
486 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get p2p mac fail.");
487 return SOFTBUS_ERR;
488 }
489 if (strncpy_s(buf, len, mac, strlen(mac)) != EOK) {
490 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy p2p mac failed");
491 return SOFTBUS_MEM_ERR;
492 }
493 return SOFTBUS_OK;
494 }
495
L1GetWifiCfg(void * buf,uint32_t len)496 static int32_t L1GetWifiCfg(void *buf, uint32_t len)
497 {
498 if (buf == NULL || len < WIFI_CFG_INFO_MAX_LEN) {
499 return SOFTBUS_INVALID_PARAM;
500 }
501 const char *wifiCfg = LnnGetWifiCfg(&g_localNetLedger.localInfo);
502 if (wifiCfg == NULL) {
503 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get wifi cfg fail.");
504 return SOFTBUS_ERR;
505 }
506 if (strncpy_s(buf, len, wifiCfg, strlen(wifiCfg)) != EOK) {
507 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy wifi cfg failed");
508 return SOFTBUS_MEM_ERR;
509 }
510 return SOFTBUS_OK;
511 }
512
L1GetChanList5g(void * buf,uint32_t len)513 static int32_t L1GetChanList5g(void *buf, uint32_t len)
514 {
515 if (buf == NULL || len < WIFI_CFG_INFO_MAX_LEN) {
516 return SOFTBUS_INVALID_PARAM;
517 }
518 const char *chanList5g = LnnGetWifiCfg(&g_localNetLedger.localInfo);
519 if (chanList5g == NULL) {
520 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get chan list 5g fail.");
521 return SOFTBUS_ERR;
522 }
523 if (strncpy_s(buf, len, chanList5g, strlen(chanList5g)) != EOK) {
524 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy chan list 5g failed");
525 return SOFTBUS_MEM_ERR;
526 }
527 return SOFTBUS_OK;
528 }
529
LlGetP2pGoMac(void * buf,uint32_t len)530 static int32_t LlGetP2pGoMac(void *buf, uint32_t len)
531 {
532 const char *mac = NULL;
533 if (buf == NULL || len < MAC_LEN) {
534 return SOFTBUS_INVALID_PARAM;
535 }
536 mac = LnnGetP2pGoMac(&g_localNetLedger.localInfo);
537 if (mac == NULL) {
538 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get p2p go mac fail.");
539 return SOFTBUS_ERR;
540 }
541 if (strncpy_s(buf, len, mac, strlen(mac)) != EOK) {
542 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy p2p go mac failed");
543 return SOFTBUS_MEM_ERR;
544 }
545 return SOFTBUS_OK;
546 }
547
L1GetP2pRole(void * buf,uint32_t len)548 static int32_t L1GetP2pRole(void *buf, uint32_t len)
549 {
550 if (buf == NULL || len != LNN_COMMON_LEN) {
551 return SOFTBUS_INVALID_PARAM;
552 }
553 *((int32_t *)buf) = LnnGetP2pRole(&g_localNetLedger.localInfo);
554 return SOFTBUS_OK;
555 }
556
LlGetStateVersion(void * buf,uint32_t len)557 static int32_t LlGetStateVersion(void *buf, uint32_t len)
558 {
559 if (buf == NULL || len != LNN_COMMON_LEN) {
560 return SOFTBUS_INVALID_PARAM;
561 }
562 *((int32_t *)buf) = g_localNetLedger.localInfo.stateVersion;
563 return SOFTBUS_OK;
564 }
565
L1GetStaFrequency(void * buf,uint32_t len)566 static int32_t L1GetStaFrequency(void *buf, uint32_t len)
567 {
568 if (buf == NULL || len != LNN_COMMON_LEN) {
569 return SOFTBUS_INVALID_PARAM;
570 }
571 *((int32_t *)buf) = LnnGetStaFrequency(&g_localNetLedger.localInfo);
572 return SOFTBUS_OK;
573 }
574
L1GetNodeDataChangeFlag(void * buf,uint32_t len)575 static int32_t L1GetNodeDataChangeFlag(void *buf, uint32_t len)
576 {
577 if (buf == NULL || len != DATA_CHANGE_FLAG_BUF_LEN) {
578 return SOFTBUS_INVALID_PARAM;
579 }
580 *((int16_t *)buf) = LnnGetDataChangeFlag(&g_localNetLedger.localInfo);
581 return SOFTBUS_OK;
582 }
583
LocalGetNodeAccountId(void * buf,uint32_t len)584 static int32_t LocalGetNodeAccountId(void *buf, uint32_t len)
585 {
586 if (buf == NULL || len != sizeof(int64_t)) {
587 return SOFTBUS_INVALID_PARAM;
588 }
589 *((int64_t *)buf) = g_localNetLedger.localInfo.accountId;
590 return SOFTBUS_OK;
591 }
592
LocalGetNodeBleStartTime(void * buf,uint32_t len)593 static int32_t LocalGetNodeBleStartTime(void *buf, uint32_t len)
594 {
595 if (buf == NULL || len != sizeof(int64_t)) {
596 return SOFTBUS_INVALID_PARAM;
597 }
598 *((int64_t *)buf) = g_localNetLedger.localInfo.bleStartTimestamp;
599 return SOFTBUS_OK;
600 }
601
InitLocalDeviceInfo(DeviceBasicInfo * info)602 static int32_t InitLocalDeviceInfo(DeviceBasicInfo *info)
603 {
604 char devType[DEVICE_TYPE_BUF_LEN] = TYPE_UNKNOWN;
605
606 if (info == NULL) {
607 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:para error!");
608 return SOFTBUS_INVALID_PARAM;
609 }
610 (void)memset_s(info, sizeof(DeviceBasicInfo), 0, sizeof(DeviceBasicInfo));
611
612 // get device info
613 if (GetCommonDevInfo(COMM_DEVICE_KEY_DEVNAME, info->deviceName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
614 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetCommonDevInfo: COMM_DEVICE_KEY_DEVNAME failed");
615 return SOFTBUS_ERR;
616 }
617 if (GetCommonDevInfo(COMM_DEVICE_KEY_DEVTYPE, devType, DEVICE_TYPE_BUF_LEN) != SOFTBUS_OK) {
618 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetCommonDevInfo: COMM_DEVICE_KEY_DEVTYPE failed");
619 return SOFTBUS_ERR;
620 }
621 if (UpdateLocalDeviceType(devType) != SOFTBUS_OK) {
622 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "UpdateLocalDeviceType failed");
623 }
624 return SOFTBUS_OK;
625 }
626
InitLocalVersionType(NodeInfo * info)627 static int32_t InitLocalVersionType(NodeInfo *info)
628 {
629 char versionType[VERSION_MAX_LEN] = "";
630 if (info == NULL) {
631 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:para error!");
632 return SOFTBUS_INVALID_PARAM;
633 }
634 if (GetCommonDevInfo(COMM_DEVICE_KEY_VERSION_TYPE, versionType, VERSION_MAX_LEN) != SOFTBUS_OK) {
635 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetCommonDevInfo: COMM_DEVICE_KEY_VERSION_TYPE failed");
636 return SOFTBUS_ERR;
637 }
638 if (strncpy_s(info->versionType, VERSION_MAX_LEN, versionType, strlen(versionType)) != EOK) {
639 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strncpy_s error");
640 return SOFTBUS_MEM_ERR;
641 }
642 return SOFTBUS_OK;
643 }
644
InitOfflineCode(NodeInfo * info)645 static int32_t InitOfflineCode(NodeInfo *info)
646 {
647 if (info == NULL) {
648 LLOGE("info of offlinecode is null!");
649 return SOFTBUS_INVALID_PARAM;
650 }
651 if (memset_s(info->offlineCode, OFFLINE_CODE_BYTE_SIZE, 0, OFFLINE_CODE_BYTE_SIZE) != EOK) {
652 LLOGE("offlineCode memset_s failed");
653 return SOFTBUS_ERR;
654 }
655 if (SoftBusGenerateRandomArray(info->offlineCode, OFFLINE_CODE_BYTE_SIZE) != SOFTBUS_OK) {
656 LLOGE("generate offlinecode error.");
657 return SOFTBUS_ERR;
658 }
659 return SOFTBUS_OK;
660 }
661
InitConnectInfo(ConnectInfo * info)662 static int32_t InitConnectInfo(ConnectInfo *info)
663 {
664 if (info == NULL) {
665 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:para error!");
666 return SOFTBUS_INVALID_PARAM;
667 }
668 // get mac addr
669 return GetCommonDevInfo(COMM_DEVICE_KEY_BT_MAC, info->macAddr, MAC_LEN);
670 }
671
ModifyId(char * dstId,uint32_t dstLen,const char * sourceId)672 static int32_t ModifyId(char *dstId, uint32_t dstLen, const char *sourceId)
673 {
674 if (dstId == NULL || sourceId == NULL || strlen(sourceId) > dstLen - 1) {
675 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "id:para error!");
676 return SOFTBUS_INVALID_PARAM;
677 }
678 if (strncpy_s(dstId, dstLen, sourceId, strlen(sourceId)) != EOK) {
679 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strncpy_s error");
680 return SOFTBUS_MEM_ERR;
681 }
682 return SOFTBUS_OK;
683 }
684
LnnGetLocalNodeInfo(void)685 NO_SANITIZE("cfi") const NodeInfo *LnnGetLocalNodeInfo(void)
686 {
687 return &g_localNetLedger.localInfo;
688 }
689
UpdateLocalDeviceName(const void * name)690 static int32_t UpdateLocalDeviceName(const void *name)
691 {
692 if (name == NULL) {
693 return SOFTBUS_INVALID_PARAM;
694 }
695 const char *beforeName = LnnGetDeviceName(&g_localNetLedger.localInfo.deviceInfo);
696 if (strcmp(beforeName, name) != 0) {
697 if (LnnSetDeviceName(&g_localNetLedger.localInfo.deviceInfo, (char *)name) != SOFTBUS_OK) {
698 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set device name fail.");
699 return SOFTBUS_ERR;
700 }
701 UpDateStateVersionAndStore();
702 }
703 return SOFTBUS_OK;
704 }
705
UpdateLocalNetworkId(const void * id)706 static int32_t UpdateLocalNetworkId(const void *id)
707 {
708 if (ModifyId(g_localNetLedger.localInfo.networkId, NETWORK_ID_BUF_LEN, (char *)id) != SOFTBUS_OK) {
709 return SOFTBUS_ERR;
710 }
711 UpDateStateVersionAndStore();
712 return SOFTBUS_OK;
713 }
714
LlUpdateLocalOffLineCode(const void * id)715 static int32_t LlUpdateLocalOffLineCode(const void *id)
716 {
717 return ModifyId((char *)g_localNetLedger.localInfo.offlineCode, OFFLINE_CODE_BYTE_SIZE, (char *)id);
718 }
719
LlUpdateLocalExtData(const void * id)720 static int32_t LlUpdateLocalExtData(const void *id)
721 {
722 return ModifyId((char *)g_localNetLedger.localInfo.extData, EXTDATA_LEN, (char *)id);
723 }
724
UpdateLocalUuid(const void * id)725 static int32_t UpdateLocalUuid(const void *id)
726 {
727 return ModifyId(g_localNetLedger.localInfo.uuid, UUID_BUF_LEN, (char *)id);
728 }
729
UpdateLocalParentId(const char * id)730 NO_SANITIZE("cfi") int32_t UpdateLocalParentId(const char *id)
731 {
732 return ModifyId(g_localNetLedger.localInfo.parentId, ID_MAX_LEN, id);
733 }
734
UpdateLocalPublicId(const char * id)735 NO_SANITIZE("cfi") int32_t UpdateLocalPublicId(const char *id)
736 {
737 return ModifyId(g_localNetLedger.localInfo.publicId, ID_MAX_LEN, id);
738 }
739
UpdateLocalRole(ConnectRole role)740 NO_SANITIZE("cfi") int32_t UpdateLocalRole(ConnectRole role)
741 {
742 g_localNetLedger.localInfo.role = role;
743 return SOFTBUS_OK;
744 }
745
UpdateLocalNetCapability(const void * capability)746 static int32_t UpdateLocalNetCapability(const void *capability)
747 {
748 if (capability == NULL) {
749 return SOFTBUS_INVALID_PARAM;
750 }
751 g_localNetLedger.localInfo.netCapacity = *(int32_t *)capability;
752 return SOFTBUS_OK;
753 }
754
UpdateLocalFeatureCapability(const void * capability)755 static int32_t UpdateLocalFeatureCapability(const void *capability)
756 {
757 if (capability == NULL) {
758 return SOFTBUS_INVALID_PARAM;
759 }
760 g_localNetLedger.localInfo.feature |= *(uint64_t *)capability;
761 return SOFTBUS_OK;
762 }
763
UpdateMasgerNodeWeight(const void * weight)764 static int32_t UpdateMasgerNodeWeight(const void *weight)
765 {
766 if (weight == NULL) {
767 return SOFTBUS_INVALID_PARAM;
768 }
769 g_localNetLedger.localInfo.masterWeight = *(int32_t *)weight;
770 return SOFTBUS_OK;
771 }
772
UpdateLocalStatus(ConnectStatus status)773 NO_SANITIZE("cfi") int32_t UpdateLocalStatus(ConnectStatus status)
774 {
775 g_localNetLedger.localInfo.status = status;
776 return SOFTBUS_OK;
777 }
778
UpdateLocalWeight(int32_t weight)779 NO_SANITIZE("cfi") int32_t UpdateLocalWeight(int32_t weight)
780 {
781 g_localNetLedger.localInfo.masterWeight = weight;
782 return SOFTBUS_OK;
783 }
784
UpdateLocalDeviceIp(const void * ip)785 static int32_t UpdateLocalDeviceIp(const void *ip)
786 {
787 if (ip == NULL) {
788 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
789 return SOFTBUS_INVALID_PARAM;
790 }
791 LnnSetWiFiIp(&g_localNetLedger.localInfo, ip);
792 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "set LocalIp =%s", AnonymizesIp(ip));
793 return SOFTBUS_OK;
794 }
795
UpdateLocalBtMac(const void * mac)796 static int32_t UpdateLocalBtMac(const void *mac)
797 {
798 if (mac == NULL) {
799 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
800 return SOFTBUS_INVALID_PARAM;
801 }
802 LnnSetBtMac(&g_localNetLedger.localInfo, (char *)mac);
803 return SOFTBUS_OK;
804 }
805
UpdateLocalNetIfName(const void * netIfName)806 static int32_t UpdateLocalNetIfName(const void *netIfName)
807 {
808 if (netIfName == NULL) {
809 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
810 return SOFTBUS_INVALID_PARAM;
811 }
812 LnnSetNetIfName(&g_localNetLedger.localInfo, (char *)netIfName);
813 return SOFTBUS_OK;
814 }
815
UpdateMasterNodeUdid(const void * udid)816 static int32_t UpdateMasterNodeUdid(const void *udid)
817 {
818 char localUdid[UDID_BUF_LEN];
819 ConnectRole role;
820
821 if (LlGetDeviceUdid(localUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
822 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid fail");
823 } else {
824 role = g_localNetLedger.localInfo.role;
825 if (strcmp(localUdid, udid) == 0) {
826 g_localNetLedger.localInfo.role = ROLE_CONTROLLER;
827 } else {
828 g_localNetLedger.localInfo.role = ROLE_LEAF;
829 }
830 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "update local role from %d to %d",
831 role, g_localNetLedger.localInfo.role);
832 }
833 return LnnSetMasterUdid(&g_localNetLedger.localInfo, (const char *)udid);
834 }
835
UpdateP2pMac(const void * mac)836 static int32_t UpdateP2pMac(const void *mac)
837 {
838 if (mac == NULL) {
839 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
840 return SOFTBUS_INVALID_PARAM;
841 }
842 return LnnSetP2pMac(&g_localNetLedger.localInfo, (char *)mac);
843 }
844
UpdateWifiCfg(const void * wifiCfg)845 static int32_t UpdateWifiCfg(const void *wifiCfg)
846 {
847 if (wifiCfg == NULL) {
848 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
849 return SOFTBUS_INVALID_PARAM;
850 }
851 return LnnSetWifiCfg(&g_localNetLedger.localInfo, (char *)wifiCfg);
852 }
853
UpdateChanList5g(const void * chanList5g)854 static int32_t UpdateChanList5g(const void *chanList5g)
855 {
856 if (chanList5g == NULL) {
857 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
858 return SOFTBUS_INVALID_PARAM;
859 }
860 return LnnSetChanList5g(&g_localNetLedger.localInfo, (char *)chanList5g);
861 }
862
UpdateP2pGoMac(const void * mac)863 static int32_t UpdateP2pGoMac(const void *mac)
864 {
865 if (mac == NULL) {
866 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
867 return SOFTBUS_INVALID_PARAM;
868 }
869 return LnnSetP2pGoMac(&g_localNetLedger.localInfo, (char *)mac);
870 }
871
UpdateP2pRole(const void * p2pRole)872 static int32_t UpdateP2pRole(const void *p2pRole)
873 {
874 if (p2pRole == NULL) {
875 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
876 return SOFTBUS_INVALID_PARAM;
877 }
878 return LnnSetP2pRole(&g_localNetLedger.localInfo, *(int32_t *)p2pRole);
879 }
880
UpdateStaFrequency(const void * staFrequency)881 static int32_t UpdateStaFrequency(const void *staFrequency)
882 {
883 if (staFrequency == NULL) {
884 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
885 return SOFTBUS_INVALID_PARAM;
886 }
887 return LnnSetStaFrequency(&g_localNetLedger.localInfo, *(int32_t *)staFrequency);
888 }
889
LlUpdateSupportedProtocols(const void * transProtos)890 static int32_t LlUpdateSupportedProtocols(const void *transProtos)
891 {
892 uint64_t *protocols = (uint64_t *)transProtos;
893 return LnnSetSupportedProtocols(&g_localNetLedger.localInfo, *protocols);
894 }
895
LlGetSupportedProtocols(void * buf,uint32_t len)896 static int32_t LlGetSupportedProtocols(void *buf, uint32_t len)
897 {
898 if (buf == NULL || len != sizeof(uint64_t)) {
899 return SOFTBUS_INVALID_PARAM;
900 }
901 *((uint64_t *)buf) = LnnGetSupportedProtocols(&g_localNetLedger.localInfo);
902 return SOFTBUS_OK;
903 }
904
LlGetNodeAddr(void * buf,uint32_t len)905 static int32_t LlGetNodeAddr(void *buf, uint32_t len)
906 {
907 NodeInfo *info = &g_localNetLedger.localInfo;
908 if (buf == NULL || len == 0) {
909 return SOFTBUS_INVALID_PARAM;
910 }
911
912 if (strcpy_s((char *)buf, len, info->nodeAddress) != EOK) {
913 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy node addr to buf fail");
914 return SOFTBUS_MEM_ERR;
915 }
916 return SOFTBUS_OK;
917 }
918
LlUpdateNodeAddr(const void * addr)919 int32_t LlUpdateNodeAddr(const void *addr)
920 {
921 if (addr == NULL) {
922 return SOFTBUS_INVALID_PARAM;
923 }
924
925 NodeInfo *info = &g_localNetLedger.localInfo;
926 if (strcpy_s(info->nodeAddress, sizeof(info->nodeAddress), (const char*)addr) != EOK) {
927 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy node addr to buf fail");
928 return SOFTBUS_MEM_ERR;
929 }
930 return SOFTBUS_OK;
931 }
932
LnnUpdateLocalNetworkId(const void * id)933 int32_t LnnUpdateLocalNetworkId(const void *id)
934 {
935 if (ModifyId(g_localNetLedger.localInfo.networkId, NETWORK_ID_BUF_LEN, (char *)id) != SOFTBUS_OK) {
936 return SOFTBUS_ERR;
937 }
938 return SOFTBUS_OK;
939 }
940
LnnUpdateStateVersion()941 void LnnUpdateStateVersion()
942 {
943 return UpDateStateVersionAndStore();
944 }
945
946 static LocalLedgerKey g_localKeyTable[] = {
947 {STRING_KEY_HICE_VERSION, VERSION_MAX_LEN, LlGetNodeSoftBusVersion, NULL},
948 {STRING_KEY_DEV_UDID, UDID_BUF_LEN, LlGetDeviceUdid, UpdateLocalDeviceUdid},
949 {STRING_KEY_NETWORKID, NETWORK_ID_BUF_LEN, LlGetNetworkId, UpdateLocalNetworkId},
950 {STRING_KEY_UUID, UUID_BUF_LEN, LlGetUuid, UpdateLocalUuid},
951 {STRING_KEY_DEV_TYPE, DEVICE_TYPE_BUF_LEN, LlGetDeviceType, UpdateLocalDeviceType},
952 {STRING_KEY_DEV_NAME, DEVICE_NAME_BUF_LEN, LlGetDeviceName, UpdateLocalDeviceName},
953 {STRING_KEY_BT_MAC, MAC_LEN, LlGetBtMac, UpdateLocalBtMac},
954 {STRING_KEY_WLAN_IP, IP_LEN, LlGetWlanIp, UpdateLocalDeviceIp},
955 {STRING_KEY_NET_IF_NAME, NET_IF_NAME_LEN, LlGetNetIfName, UpdateLocalNetIfName},
956 {STRING_KEY_MASTER_NODE_UDID, UDID_BUF_LEN, L1GetMasterNodeUdid, UpdateMasterNodeUdid},
957 {STRING_KEY_NODE_ADDR, SHORT_ADDRESS_MAX_LEN, LlGetNodeAddr, LlUpdateNodeAddr},
958 {STRING_KEY_P2P_MAC, MAC_LEN, LlGetP2pMac, UpdateP2pMac},
959 { STRING_KEY_WIFI_CFG, WIFI_CFG_INFO_MAX_LEN, L1GetWifiCfg, UpdateWifiCfg},
960 { STRING_KEY_CHAN_LIST_5G, CHANNEL_LIST_STR_LEN, L1GetChanList5g, UpdateChanList5g},
961 {STRING_KEY_P2P_GO_MAC, MAC_LEN, LlGetP2pGoMac, UpdateP2pGoMac},
962 {STRING_KEY_OFFLINE_CODE, OFFLINE_CODE_LEN, LlGetOffLineCode, LlUpdateLocalOffLineCode},
963 {STRING_KEY_EXTDATA, EXTDATA_LEN, LlGetExtData, LlUpdateLocalExtData},
964 {NUM_KEY_SESSION_PORT, -1, LlGetSessionPort, UpdateLocalSessionPort},
965 {NUM_KEY_AUTH_PORT, -1, LlGetAuthPort, UpdateLocalAuthPort},
966 {NUM_KEY_PROXY_PORT, -1, LlGetProxyPort, UpdateLocalProxyPort},
967 {NUM_KEY_NET_CAP, -1, LlGetNetCap, UpdateLocalNetCapability},
968 {NUM_KEY_FEATURE_CAPA, -1, LlGetFeatureCapa, UpdateLocalFeatureCapability},
969 {NUM_KEY_DISCOVERY_TYPE, -1, LlGetNetType, NULL},
970 {NUM_KEY_DEV_TYPE_ID, -1, LlGetDeviceTypeId, NULL},
971 {NUM_KEY_MASTER_NODE_WEIGHT, -1, L1GetMasterNodeWeight, UpdateMasgerNodeWeight},
972 {NUM_KEY_P2P_ROLE, -1, L1GetP2pRole, UpdateP2pRole},
973 {NUM_KEY_STATE_VERSION, -1, LlGetStateVersion, UpdateStateVersion},
974 { NUM_KEY_STA_FREQUENCY, -1, L1GetStaFrequency, UpdateStaFrequency},
975 {NUM_KEY_TRANS_PROTOCOLS, sizeof(int64_t), LlGetSupportedProtocols, LlUpdateSupportedProtocols},
976 {NUM_KEY_DATA_CHANGE_FLAG, sizeof(int16_t), L1GetNodeDataChangeFlag, UpdateNodeDataChangeFlag},
977 {NUM_KEY_ACCOUNT_LONG, sizeof(int64_t), LocalGetNodeAccountId, LocalUpdateNodeAccountId},
978 {NUM_KEY_BLE_START_TIME, sizeof(int64_t), LocalGetNodeBleStartTime, LocalUpdateBleStartTime},
979 {BYTE_KEY_ACCOUNT_HASH, SHA_256_HASH_LEN, LlGetAccount, LlUpdateAccount},
980 };
981
LnnGetLocalStrInfo(InfoKey key,char * info,uint32_t len)982 NO_SANITIZE("cfi") int32_t LnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len)
983 {
984 uint32_t i;
985 int32_t ret;
986 if (info == NULL) {
987 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error.");
988 return SOFTBUS_INVALID_PARAM;
989 }
990 if (key >= STRING_KEY_END) {
991 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
992 return SOFTBUS_INVALID_PARAM;
993 }
994 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
995 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
996 return SOFTBUS_LOCK_ERR;
997 }
998 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
999 if (key == g_localKeyTable[i].key) {
1000 if (g_localKeyTable[i].getInfo != NULL) {
1001 ret = g_localKeyTable[i].getInfo((void *)info, len);
1002 SoftBusMutexUnlock(&g_localNetLedger.lock);
1003 return ret;
1004 }
1005 }
1006 }
1007 SoftBusMutexUnlock(&g_localNetLedger.lock);
1008 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY NOT exist.");
1009 return SOFTBUS_ERR;
1010 }
1011
LnnGetLocalInfo(InfoKey key,void * info,uint32_t infoSize)1012 NO_SANITIZE("cfi") static int32_t LnnGetLocalInfo(InfoKey key, void* info, uint32_t infoSize)
1013 {
1014 uint32_t i;
1015 int32_t ret;
1016 if (info == NULL) {
1017 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error.");
1018 return SOFTBUS_INVALID_PARAM;
1019 }
1020 if ((key < NUM_KEY_BEGIN || key >= NUM_KEY_END) &&
1021 (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END)) {
1022 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1023 return SOFTBUS_INVALID_PARAM;
1024 }
1025 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1026 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1027 return SOFTBUS_LOCK_ERR;
1028 }
1029 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1030 if (key == g_localKeyTable[i].key) {
1031 if (g_localKeyTable[i].getInfo != NULL) {
1032 ret = g_localKeyTable[i].getInfo(info, infoSize);
1033 SoftBusMutexUnlock(&g_localNetLedger.lock);
1034 return ret;
1035 }
1036 }
1037 }
1038 SoftBusMutexUnlock(&g_localNetLedger.lock);
1039 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY NOT exist.");
1040 return SOFTBUS_ERR;
1041 }
1042
JudgeString(const char * info,int32_t len)1043 static bool JudgeString(const char *info, int32_t len)
1044 {
1045 return (len <= 0) ? false : IsValidString(info, (uint32_t)len);
1046 }
1047
LnnSetLocalStrInfo(InfoKey key,const char * info)1048 NO_SANITIZE("cfi") int32_t LnnSetLocalStrInfo(InfoKey key, const char *info)
1049 {
1050 uint32_t i;
1051 int32_t ret;
1052 if (info == NULL) {
1053 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error.");
1054 return SOFTBUS_INVALID_PARAM;
1055 }
1056 if (key >= STRING_KEY_END) {
1057 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1058 return SOFTBUS_INVALID_PARAM;
1059 }
1060 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1061 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1062 return SOFTBUS_LOCK_ERR;
1063 }
1064 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1065 if (key == g_localKeyTable[i].key) {
1066 if (g_localKeyTable[i].setInfo != NULL && JudgeString(info, g_localKeyTable[i].maxLen)) {
1067 ret = g_localKeyTable[i].setInfo((void *)info);
1068 SoftBusMutexUnlock(&g_localNetLedger.lock);
1069 return ret;
1070 }
1071 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "key=%d not support or info format error", key);
1072 SoftBusMutexUnlock(&g_localNetLedger.lock);
1073 return SOFTBUS_INVALID_PARAM;
1074 }
1075 }
1076 SoftBusMutexUnlock(&g_localNetLedger.lock);
1077 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "key not exist.");
1078 return SOFTBUS_ERR;
1079 }
1080
LnnSetLocalInfo(InfoKey key,void * info)1081 NO_SANITIZE("cfi") static int32_t LnnSetLocalInfo(InfoKey key, void* info)
1082 {
1083 uint32_t i;
1084 int32_t ret;
1085 if ((key < NUM_KEY_BEGIN || key >= NUM_KEY_END) &&
1086 (key < BYTE_KEY_BEGIN || key >= BYTE_KEY_END)) {
1087 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "KEY error.");
1088 return SOFTBUS_INVALID_PARAM;
1089 }
1090 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1091 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1092 return SOFTBUS_LOCK_ERR;
1093 }
1094 for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) {
1095 if (key == g_localKeyTable[i].key) {
1096 if (g_localKeyTable[i].setInfo != NULL) {
1097 ret = g_localKeyTable[i].setInfo(info);
1098 SoftBusMutexUnlock(&g_localNetLedger.lock);
1099 return ret;
1100 }
1101 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "key=%d not support", key);
1102 SoftBusMutexUnlock(&g_localNetLedger.lock);
1103 return SOFTBUS_ERR;
1104 }
1105 }
1106 SoftBusMutexUnlock(&g_localNetLedger.lock);
1107 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "key not exist.");
1108 return SOFTBUS_ERR;
1109 }
1110
LnnFirstGetUdid(void)1111 NO_SANITIZE("cfi") static int32_t LnnFirstGetUdid(void)
1112 {
1113 NodeInfo *nodeInfo = &g_localNetLedger.localInfo;
1114 DeviceBasicInfo *deviceInfo = &nodeInfo->deviceInfo;
1115 if (GetCommonDevInfo(COMM_DEVICE_KEY_UDID, deviceInfo->deviceUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1116 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetCommonDevInfo: COMM_DEVICE_KEY_UDID failed");
1117 return SOFTBUS_ERR;
1118 }
1119 return SOFTBUS_OK;
1120 }
1121
LnnGetLocalNumInfo(InfoKey key,int32_t * info)1122 NO_SANITIZE("cfi") int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info)
1123 {
1124 return LnnGetLocalInfo(key, (void*)info, sizeof(int32_t));
1125 }
1126
LnnGetLocalNum64Info(InfoKey key,int64_t * info)1127 NO_SANITIZE("cfi") int32_t LnnGetLocalNum64Info(InfoKey key, int64_t *info)
1128 {
1129 return LnnGetLocalInfo(key, (void*)info, sizeof(int64_t));
1130 }
1131
LnnGetLocalNumU64Info(InfoKey key,uint64_t * info)1132 NO_SANITIZE("cfi") int32_t LnnGetLocalNumU64Info(InfoKey key, uint64_t *info)
1133 {
1134 return LnnGetLocalInfo(key, (void*)info, sizeof(uint64_t));
1135 }
1136
LnnSetLocalNum64Info(InfoKey key,int64_t info)1137 NO_SANITIZE("cfi") int32_t LnnSetLocalNum64Info(InfoKey key, int64_t info)
1138 {
1139 return LnnSetLocalInfo(key, (void*)&info);
1140 }
1141
LnnGetLocalNum16Info(InfoKey key,int16_t * info)1142 NO_SANITIZE("cfi") int32_t LnnGetLocalNum16Info(InfoKey key, int16_t *info)
1143 {
1144 return LnnGetLocalInfo(key, (void*)info, sizeof(int16_t));
1145 }
1146
LnnSetLocalNum16Info(InfoKey key,int16_t info)1147 NO_SANITIZE("cfi") int32_t LnnSetLocalNum16Info(InfoKey key, int16_t info)
1148 {
1149 return LnnSetLocalInfo(key, (void*)&info);
1150 }
1151
LnnSetLocalNumInfo(InfoKey key,int32_t info)1152 NO_SANITIZE("cfi") int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info)
1153 {
1154 return LnnSetLocalInfo(key, (void*)&info);
1155 }
1156
LnnSetLocalByteInfo(InfoKey key,const uint8_t * info,uint32_t len)1157 int32_t LnnSetLocalByteInfo(InfoKey key, const uint8_t *info, uint32_t len)
1158 {
1159 (void)len;
1160 return LnnSetLocalInfo(key, (void *)info);
1161 }
1162
LnnGetLocalByteInfo(InfoKey key,uint8_t * info,uint32_t len)1163 NO_SANITIZE("cfi") int32_t LnnGetLocalByteInfo(InfoKey key, uint8_t *info, uint32_t len)
1164 {
1165 return LnnGetLocalInfo(key, (void *)info, len);
1166 }
1167
LnnGetLocalDeviceInfo(NodeBasicInfo * info)1168 NO_SANITIZE("cfi") int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info)
1169 {
1170 int32_t rc;
1171 char type[DEVICE_TYPE_BUF_LEN] = {0};
1172
1173 if (info == NULL) {
1174 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "info is null");
1175 return SOFTBUS_INVALID_PARAM;
1176 }
1177 rc = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, info->deviceName, DEVICE_NAME_BUF_LEN);
1178 if (rc != SOFTBUS_OK) {
1179 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local device info failed");
1180 return SOFTBUS_ERR;
1181 }
1182 rc = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, info->networkId, NETWORK_ID_BUF_LEN);
1183 if (rc != SOFTBUS_OK) {
1184 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local network id info failed");
1185 return SOFTBUS_ERR;
1186 }
1187 rc = LnnGetLocalStrInfo(STRING_KEY_DEV_TYPE, type, DEVICE_TYPE_BUF_LEN);
1188 if (rc != SOFTBUS_OK) {
1189 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local device type failed");
1190 return SOFTBUS_ERR;
1191 }
1192 return LnnConvertDeviceTypeToId(type, &info->deviceTypeId);
1193 }
1194
SoftBusDumpBusCenterLocalDeviceInfo(int fd)1195 int32_t SoftBusDumpBusCenterLocalDeviceInfo(int fd)
1196 {
1197 SOFTBUS_DPRINTF(fd, "-----LocalDeviceInfo-----\n");
1198 NodeBasicInfo localNodeInfo;
1199 if (LnnGetLocalDeviceInfo(&localNodeInfo) != 0) {
1200 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnGetLocalDeviceInfo failed!");
1201 return SOFTBUS_ERR;
1202 }
1203 SoftBusDumpBusCenterPrintInfo(fd, &localNodeInfo);
1204 return SOFTBUS_OK;
1205 }
1206
LnnInitLocalLedger(void)1207 NO_SANITIZE("cfi") int32_t LnnInitLocalLedger(void)
1208 {
1209 NodeInfo *nodeInfo = NULL;
1210 if (g_localNetLedger.status == LL_INIT_SUCCESS) {
1211 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "local net ledger already init.");
1212 return SOFTBUS_OK;
1213 }
1214 g_localNetLedger.status = LL_INIT_UNKNOWN;
1215 nodeInfo = &g_localNetLedger.localInfo;
1216 (void)memset_s(nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1217 if (strncpy_s(nodeInfo->softBusVersion, VERSION_MAX_LEN, SOFTBUS_VERSION, strlen(SOFTBUS_VERSION)) != EOK) {
1218 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:strncpy_s fail!");
1219 g_localNetLedger.status = LL_INIT_FAIL;
1220 return SOFTBUS_MEM_ERR;
1221 }
1222 nodeInfo->groupType = ALL_GROUP_TYPE;
1223 nodeInfo->discoveryType = 0;
1224 nodeInfo->netCapacity = LnnGetNetCapabilty();
1225 nodeInfo->feature = LnnGetFeatureCapabilty();
1226 DeviceBasicInfo *deviceInfo = &nodeInfo->deviceInfo;
1227 if (InitOfflineCode(nodeInfo) != SOFTBUS_OK) {
1228 goto EXIT;
1229 }
1230 if (strcpy_s(nodeInfo->nodeAddress, sizeof(nodeInfo->nodeAddress), NODE_ADDR_LOOPBACK) != EOK) {
1231 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:strncpy_s fail!");
1232 goto EXIT;
1233 }
1234 if (InitLocalDeviceInfo(deviceInfo) != SOFTBUS_OK) {
1235 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init local device info error!");
1236 goto EXIT;
1237 }
1238 if (InitLocalVersionType(nodeInfo) != SOFTBUS_OK) {
1239 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init local version type error!");
1240 goto EXIT;
1241 }
1242 if (InitConnectInfo(&nodeInfo->connectInfo) != SOFTBUS_OK) {
1243 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init local connect info error!");
1244 goto EXIT;
1245 }
1246 if (LnnInitLocalP2pInfo(nodeInfo) != SOFTBUS_OK) {
1247 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init local p2p info error!");
1248 goto EXIT;
1249 }
1250
1251 if (SoftBusMutexInit(&g_localNetLedger.lock, NULL) != SOFTBUS_OK) {
1252 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "mutex init fail!");
1253 goto EXIT;
1254 }
1255 if (SoftBusRegBusCenterVarDump(
1256 SOFTBUS_BUSCENTER_DUMP_LOCALDEVICEINFO, &SoftBusDumpBusCenterLocalDeviceInfo) != SOFTBUS_OK) {
1257 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SoftBusRegBusCenterVarDump regist fail");
1258 return SOFTBUS_ERR;
1259 }
1260 if (LnnFirstGetUdid() != SOFTBUS_OK) {
1261 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "first get udid fail, try again in one second.");
1262 }
1263 g_localNetLedger.status = LL_INIT_SUCCESS;
1264 return SOFTBUS_OK;
1265 EXIT:
1266 g_localNetLedger.status = LL_INIT_FAIL;
1267 return SOFTBUS_ERR;
1268 }
1269
LnnInitLocalLedgerDelay(void)1270 NO_SANITIZE("cfi") int32_t LnnInitLocalLedgerDelay(void)
1271 {
1272 NodeInfo *nodeInfo = &g_localNetLedger.localInfo;
1273 DeviceBasicInfo *deviceInfo = &nodeInfo->deviceInfo;
1274 if (GetCommonDevInfo(COMM_DEVICE_KEY_UDID, deviceInfo->deviceUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1275 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetCommonDevInfo: COMM_DEVICE_KEY_UDID failed");
1276 return SOFTBUS_ERR;
1277 }
1278 if (LnnInitOhosAccount() != SOFTBUS_OK) {
1279 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init default ohos account failed");
1280 return SOFTBUS_ERR;
1281 }
1282 return SOFTBUS_OK;
1283 }
1284
LnnDeinitLocalLedger(void)1285 NO_SANITIZE("cfi") void LnnDeinitLocalLedger(void)
1286 {
1287 if (g_localNetLedger.status == LL_INIT_SUCCESS) {
1288 SoftBusMutexDestroy(&g_localNetLedger.lock);
1289 }
1290 g_localNetLedger.status = LL_INIT_UNKNOWN;
1291 }
1292
LnnIsMasterNode(void)1293 NO_SANITIZE("cfi") bool LnnIsMasterNode(void)
1294 {
1295 bool ret = false;
1296 if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) {
1297 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
1298 return ret;
1299 }
1300 const char* masterUdid = g_localNetLedger.localInfo.masterUdid;
1301 const char* deviceUdid = g_localNetLedger.localInfo.deviceInfo.deviceUdid;
1302 ret = strncmp(masterUdid, deviceUdid, strlen(deviceUdid)) == 0;
1303 SoftBusMutexUnlock(&g_localNetLedger.lock);
1304 return ret;
1305 }
1306