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 "client_bus_center.h"
17 
18 #include <securec.h>
19 #include <string.h>
20 
21 #include "client_bus_center_manager.h"
22 #include "data_level.h"
23 #include "client_trans_session_manager.h"
24 #include "lnn_event.h"
25 #include "lnn_log.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_client_frame_manager.h"
28 #include "softbus_def.h"
29 #include "softbus_errcode.h"
30 #include "softbus_type_def.h"
31 #include "softbus_utils.h"
32 
33 static const char *g_dbPkgName = "distributeddata-default";
34 
CommonInit(const char *pkgName)35 static int32_t CommonInit(const char *pkgName)
36 {
37     if (InitSoftBus(pkgName) != SOFTBUS_OK) {
38         LNN_LOGE(LNN_INIT, "init softbus failed");
39         return SOFTBUS_NETWORK_NOT_INIT;
40     }
41     if (CheckPackageName(pkgName) != SOFTBUS_OK) {
42         LNN_LOGE(LNN_INIT, "check packageName failed");
43         return SOFTBUS_INVALID_PARAM;
44     }
45     return SOFTBUS_OK;
46 }
47 
IsValidNodeStateCb(INodeStateCb *callback)48 static bool IsValidNodeStateCb(INodeStateCb *callback)
49 {
50     if (callback == NULL) {
51         return false;
52     }
53     if (callback->events == 0) {
54         return false;
55     }
56     if ((callback->events & EVENT_NODE_STATE_ONLINE) != 0 &&
57         callback->onNodeOnline == NULL) {
58         return false;
59     }
60     if ((callback->events & EVENT_NODE_STATE_OFFLINE) != 0 &&
61         callback->onNodeOffline == NULL) {
62         return false;
63     }
64     if ((callback->events & EVENT_NODE_STATE_INFO_CHANGED) != 0 &&
65         callback->onNodeBasicInfoChanged == NULL) {
66         return false;
67     }
68     if ((callback->events & EVENT_NODE_STATUS_CHANGED) != 0 &&
69         callback->onNodeStatusChanged == NULL) {
70         return false;
71     }
72     if ((callback->events & EVENT_NODE_HICHAIN_PROOF_EXCEPTION) != 0 &&
73         callback->onHichainProofException == NULL) {
74         return false;
75     }
76     return true;
77 }
78 
PublishInfoCheck(const PublishInfo *info)79 static int32_t PublishInfoCheck(const PublishInfo *info)
80 {
81     if ((info->mode != DISCOVER_MODE_PASSIVE) && (info->mode != DISCOVER_MODE_ACTIVE)) {
82         LNN_LOGE(LNN_STATE, "mode is invalid");
83         return SOFTBUS_INVALID_PARAM;
84     }
85     if ((info->medium < AUTO) || (info->medium > COAP)) {
86         LNN_LOGE(LNN_STATE, "medium is invalid");
87         return SOFTBUS_INVALID_PARAM;
88     }
89     if ((info->freq < LOW) || (info->freq >= FREQ_BUTT)) {
90         LNN_LOGE(LNN_STATE, "freq is invalid");
91         return SOFTBUS_INVALID_PARAM;
92     }
93     if (info->capability == NULL) {
94         LNN_LOGE(LNN_STATE, "capability is invalid");
95         return SOFTBUS_INVALID_PARAM;
96     }
97     if ((info->capabilityData == NULL) && (info->dataLen != 0)) {
98         LNN_LOGE(LNN_STATE, "data is invalid");
99         return SOFTBUS_INVALID_PARAM;
100     }
101     if (info->dataLen == 0) {
102         return SOFTBUS_OK;
103     }
104     if ((info->capabilityData != NULL) &&
105         ((info->dataLen > MAX_CAPABILITYDATA_LEN) ||
106         (strnlen((char *)(info->capabilityData), MAX_CAPABILITYDATA_LEN) == MAX_CAPABILITYDATA_LEN))) {
107         LNN_LOGE(LNN_STATE, "data exceeds the maximum length");
108         return SOFTBUS_INVALID_PARAM;
109     }
110     return SOFTBUS_OK;
111 }
112 
SubscribeInfoCheck(const SubscribeInfo *info)113 static int32_t SubscribeInfoCheck(const SubscribeInfo *info)
114 {
115     if ((info->mode != DISCOVER_MODE_PASSIVE) && (info->mode != DISCOVER_MODE_ACTIVE)) {
116         LNN_LOGE(LNN_STATE, "mode is invalid");
117         return SOFTBUS_INVALID_PARAM;
118     }
119     if ((info->medium < AUTO) || (info->medium > COAP)) {
120         LNN_LOGE(LNN_STATE, "medium is invalid");
121         return SOFTBUS_INVALID_PARAM;
122     }
123     if ((info->freq < LOW) || (info->freq >= FREQ_BUTT)) {
124         LNN_LOGE(LNN_STATE, "freq is invalid");
125         return SOFTBUS_INVALID_PARAM;
126     }
127     if (info->capability == NULL) {
128         LNN_LOGE(LNN_STATE, "capability is invalid");
129         return SOFTBUS_INVALID_PARAM;
130     }
131     if ((info->capabilityData == NULL) && (info->dataLen != 0)) {
132         LNN_LOGE(LNN_STATE, "data is invalid");
133         return SOFTBUS_INVALID_PARAM;
134     }
135     if (info->dataLen == 0) {
136         return SOFTBUS_OK;
137     }
138     if ((info->capabilityData != NULL) &&
139         ((info->dataLen > MAX_CAPABILITYDATA_LEN) ||
140         (strnlen((char *)(info->capabilityData), MAX_CAPABILITYDATA_LEN) == MAX_CAPABILITYDATA_LEN))) {
141         LNN_LOGE(LNN_STATE, "data exceeds the maximum length");
142         return SOFTBUS_INVALID_PARAM;
143     }
144     return SOFTBUS_OK;
145 }
146 
DfxRecordSdkJoinLnnEnd(const char *packageName, int32_t reason)147 static void DfxRecordSdkJoinLnnEnd(const char *packageName, int32_t reason)
148 {
149     if (reason == SOFTBUS_OK) {
150         return;
151     }
152 
153     LnnEventExtra extra = { 0 };
154     LnnEventExtraInit(&extra);
155     extra.errcode = reason;
156     extra.result = EVENT_STAGE_RESULT_FAILED;
157 
158     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
159     if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
160         PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
161         extra.callerPkg = pkgName;
162     }
163     LNN_EVENT(EVENT_SCENE_LNN, EVENT_STAGE_LNN_JOIN_SDK, extra);
164 }
165 
DfxRecordSdkLeaveLnnEnd(const char *packageName, int32_t reason)166 static void DfxRecordSdkLeaveLnnEnd(const char *packageName, int32_t reason)
167 {
168     if (reason == SOFTBUS_OK) {
169         return;
170     }
171 
172     LnnEventExtra extra = { 0 };
173     LnnEventExtraInit(&extra);
174     extra.errcode = reason;
175     extra.result = EVENT_STAGE_RESULT_FAILED;
176 
177     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
178     if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
179         PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
180         extra.callerPkg = pkgName;
181     }
182     LNN_EVENT(EVENT_SCENE_LNN, EVENT_STAGE_LNN_LEAVE_SDK, extra);
183 }
184 
DfxRecordSdkShiftGearStart(const char *packageName, const GearMode *mode)185 static void DfxRecordSdkShiftGearStart(const char *packageName, const GearMode *mode)
186 {
187     LnnEventExtra extra = { 0 };
188     LnnEventExtraInit(&extra);
189     if (mode != NULL) {
190         extra.gearCycle = mode->cycle;
191         extra.gearDuration = mode->duration;
192     }
193     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
194     if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
195         PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
196         extra.callerPkg = pkgName;
197     }
198     LNN_EVENT(EVENT_SCENE_LNN, EVENT_STAGE_LNN_SHIFT_GEAR, extra);
199 }
200 
DfxRecordLnnDiscServerEnd(int32_t serverType, const char *packageName, int32_t reason)201 static void DfxRecordLnnDiscServerEnd(int32_t serverType, const char *packageName, int32_t reason)
202 {
203     if (reason == SOFTBUS_OK) {
204         return;
205     }
206 
207     LnnEventExtra extra = { 0 };
208     LnnEventExtraInit(&extra);
209     extra.discServerType = serverType;
210     extra.errcode = reason;
211     extra.result = EVENT_STAGE_RESULT_FAILED;
212 
213     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
214     if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
215         PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
216         extra.callerPkg = pkgName;
217     }
218     LNN_EVENT(EVENT_SCENE_LNN, EVENT_STAGE_LNN_DISC_SDK, extra);
219 }
220 
DfxRecordRegNodeStart(const char *packageName)221 static void DfxRecordRegNodeStart(const char *packageName)
222 {
223     LnnEventExtra extra = { 0 };
224     LnnEventExtraInit(&extra);
225     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
226     if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
227         PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
228         extra.callerPkg = pkgName;
229     }
230     LNN_EVENT(EVENT_SCENE_LNN, EVENT_STAGE_LNN_REG_NODE, extra);
231 }
232 
GetAllNodeDeviceInfo(const char *pkgName, NodeBasicInfo **info, int32_t *infoNum)233 int32_t GetAllNodeDeviceInfo(const char *pkgName, NodeBasicInfo **info, int32_t *infoNum)
234 {
235     if (pkgName == NULL || info == NULL || infoNum == NULL) {
236         LNN_LOGE(LNN_STATE, "params are null");
237         return SOFTBUS_INVALID_PARAM;
238     }
239     int32_t ret = CommonInit(pkgName);
240     if (ret != SOFTBUS_OK) {
241         return ret;
242     }
243     return GetAllNodeDeviceInfoInner(pkgName, info, infoNum);
244 }
245 
FreeNodeInfo(NodeBasicInfo *info)246 void FreeNodeInfo(NodeBasicInfo *info)
247 {
248     if (info == NULL) {
249         return;
250     }
251     SoftBusFree(info);
252 }
253 
GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info)254 int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info)
255 {
256     if (pkgName == NULL || info == NULL) {
257         LNN_LOGE(LNN_STATE, "params are null");
258         return SOFTBUS_INVALID_PARAM;
259     }
260     int32_t ret = CommonInit(pkgName);
261     if (ret != SOFTBUS_OK) {
262         return ret;
263     }
264     return GetLocalNodeDeviceInfoInner(pkgName, info);
265 }
266 
GetNodeKeyInfo(const char *pkgName, const char *networkId, NodeDeviceInfoKey key, uint8_t *info, int32_t infoLen)267 int32_t GetNodeKeyInfo(const char *pkgName, const char *networkId, NodeDeviceInfoKey key,
268     uint8_t *info, int32_t infoLen)
269 {
270     if (pkgName == NULL || infoLen <= 0) {
271         LNN_LOGE(LNN_STATE, "pkgName is null");
272         return SOFTBUS_INVALID_PARAM;
273     }
274     if (!IsValidString(networkId, NETWORK_ID_BUF_LEN) || info == NULL) {
275         LNN_LOGE(LNN_STATE, "invalid params");
276         return SOFTBUS_INVALID_PARAM;
277     }
278     int32_t ret = CommonInit(pkgName);
279     if (ret != SOFTBUS_OK) {
280         return ret;
281     }
282     if (memset_s(info, infoLen, 0, infoLen) != EOK) {
283         LNN_LOGE(LNN_STATE, "memset nodekey info failed");
284         return SOFTBUS_MEM_ERR;
285     }
286     return GetNodeKeyInfoInner(pkgName, networkId, key, info, infoLen);
287 }
288 
SetNodeDataChangeFlag(const char *pkgName, const char *networkId, uint16_t dataChangeFlag)289 int32_t SetNodeDataChangeFlag(const char *pkgName, const char *networkId, uint16_t dataChangeFlag)
290 {
291     if (pkgName == NULL) {
292         LNN_LOGE(LNN_STATE, "pkgName is null");
293         return SOFTBUS_INVALID_PARAM;
294     }
295     if (!IsValidString(networkId, NETWORK_ID_BUF_LEN)) {
296         LNN_LOGE(LNN_STATE, "invalid params");
297         return SOFTBUS_INVALID_PARAM;
298     }
299     int32_t ret = CommonInit(pkgName);
300     if (ret != SOFTBUS_OK) {
301         return ret;
302     }
303     return SetNodeDataChangeFlagInner(pkgName, networkId, dataChangeFlag);
304 }
305 
RegDataLevelChangeCb(const char *pkgName, IDataLevelCb *callback)306 int32_t RegDataLevelChangeCb(const char *pkgName, IDataLevelCb *callback)
307 {
308     if (pkgName == NULL) {
309         LNN_LOGE(LNN_STATE, "pkgName is null");
310         return SOFTBUS_INVALID_PARAM;
311     }
312     if (strcmp(g_dbPkgName, pkgName) != 0) {
313         LNN_LOGE(LNN_STATE, "pkgName is invalid");
314         return SOFTBUS_INVALID_PARAM;
315     }
316     int32_t ret = CommonInit(pkgName);
317     if (ret != SOFTBUS_OK) {
318         LNN_LOGE(LNN_STATE, "CommonInit failed");
319         return ret;
320     }
321     return RegDataLevelChangeCbInner(pkgName, callback);
322 }
323 
UnregDataLevelChangeCb(const char *pkgName)324 int32_t UnregDataLevelChangeCb(const char *pkgName)
325 {
326     if (pkgName == NULL) {
327         LNN_LOGE(LNN_STATE, "pkgName is null");
328         return SOFTBUS_INVALID_PARAM;
329     }
330     if (strcmp(g_dbPkgName, pkgName) != 0) {
331         LNN_LOGE(LNN_STATE, "pkgName is invalid");
332         return SOFTBUS_INVALID_PARAM;
333     }
334     return UnregDataLevelChangeCbInner(pkgName);
335 }
336 
SetDataLevel(const DataLevel *dataLevel)337 int32_t SetDataLevel(const DataLevel *dataLevel)
338 {
339     if (dataLevel == NULL) {
340         LNN_LOGE(LNN_STATE, "invalid param");
341         return SOFTBUS_INVALID_PARAM;
342     }
343     LNN_LOGI(LNN_STATE, "SetDataLevel, dynamic: %{public}hu, static: %{public}hu, "
344         "switch: %{public}u, switchLen: %{public}hu", dataLevel->dynamicLevel, dataLevel->staticLevel,
345         dataLevel->switchLevel, dataLevel->switchLength);
346     return SetDataLevelInner(dataLevel);
347 }
348 
JoinLNN(const char *pkgName, ConnectionAddr *target, OnJoinLNNResult cb)349 int32_t JoinLNN(const char *pkgName, ConnectionAddr *target, OnJoinLNNResult cb)
350 {
351     if (pkgName == NULL || target == NULL || cb == NULL) {
352         DfxRecordSdkJoinLnnEnd(pkgName, SOFTBUS_INVALID_PARAM);
353         LNN_LOGE(LNN_STATE, "params are NULL");
354         return SOFTBUS_INVALID_PARAM;
355     }
356     int32_t ret = CommonInit(pkgName);
357     if (ret != SOFTBUS_OK) {
358         DfxRecordSdkJoinLnnEnd(pkgName, ret);
359         return ret;
360     }
361     ret = JoinLNNInner(pkgName, target, cb);
362     DfxRecordSdkJoinLnnEnd(pkgName, ret);
363     return ret;
364 }
365 
LeaveLNN(const char *pkgName, const char *networkId, OnLeaveLNNResult cb)366 int32_t LeaveLNN(const char *pkgName, const char *networkId, OnLeaveLNNResult cb)
367 {
368     if (!IsValidString(networkId, NETWORK_ID_BUF_LEN) || cb == NULL || !IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1)) {
369         DfxRecordSdkLeaveLnnEnd(pkgName, SOFTBUS_INVALID_PARAM);
370         LNN_LOGE(LNN_STATE, "networkId or cb is NULL");
371         return SOFTBUS_INVALID_PARAM;
372     }
373     int32_t ret = LeaveLNNInner(pkgName, networkId, cb);
374     DfxRecordSdkLeaveLnnEnd(pkgName, ret);
375     return ret;
376 }
377 
RegNodeDeviceStateCb(const char *pkgName, INodeStateCb *callback)378 int32_t RegNodeDeviceStateCb(const char *pkgName, INodeStateCb *callback)
379 {
380     DfxRecordRegNodeStart(pkgName);
381     if (pkgName == NULL || IsValidNodeStateCb(callback) == false) {
382         LNN_LOGE(LNN_STATE, "invalid parameters");
383         return SOFTBUS_INVALID_PARAM;
384     }
385     int32_t ret = CommonInit(pkgName);
386     if (ret != SOFTBUS_OK) {
387         return ret;
388     }
389     return RegNodeDeviceStateCbInner(pkgName, callback);
390 }
391 
UnregNodeDeviceStateCb(INodeStateCb *callback)392 int32_t UnregNodeDeviceStateCb(INodeStateCb *callback)
393 {
394     if (callback == NULL) {
395         LNN_LOGE(LNN_STATE, "para callback = null");
396         return SOFTBUS_INVALID_PARAM;
397     }
398     return UnregNodeDeviceStateCbInner(callback);
399 }
400 
StartTimeSync(const char *pkgName, const char *targetNetworkId, TimeSyncAccuracy accuracy, TimeSyncPeriod period, ITimeSyncCb *cb)401 int32_t StartTimeSync(const char *pkgName, const char *targetNetworkId, TimeSyncAccuracy accuracy,
402     TimeSyncPeriod period, ITimeSyncCb *cb)
403 {
404     if (pkgName == NULL || !IsValidString(targetNetworkId, NETWORK_ID_BUF_LEN) ||
405         cb == NULL || cb->onTimeSyncResult == NULL) {
406         LNN_LOGE(LNN_STATE, "invalid parameters");
407         return SOFTBUS_INVALID_PARAM;
408     }
409     int32_t ret = CommonInit(pkgName);
410     if (ret != SOFTBUS_OK) {
411         return ret;
412     }
413     return StartTimeSyncInner(pkgName, targetNetworkId, accuracy, period, cb);
414 }
415 
StopTimeSync(const char *pkgName, const char *targetNetworkId)416 int32_t StopTimeSync(const char *pkgName, const char *targetNetworkId)
417 {
418     if (pkgName == NULL || !IsValidString(targetNetworkId, NETWORK_ID_BUF_LEN)) {
419         LNN_LOGE(LNN_STATE, "invalid parameters");
420         return SOFTBUS_INVALID_PARAM;
421     }
422     int32_t ret = CommonInit(pkgName);
423     if (ret != SOFTBUS_OK) {
424         return ret;
425     }
426     return StopTimeSyncInner(pkgName, targetNetworkId);
427 }
428 
PublishLNN(const char *pkgName, const PublishInfo *info, const IPublishCb *cb)429 int32_t PublishLNN(const char *pkgName, const PublishInfo *info, const IPublishCb *cb)
430 {
431     if (pkgName == NULL || info == NULL || cb == NULL) {
432         DfxRecordLnnDiscServerEnd(DISC_SERVER_PUBLISH, pkgName, SOFTBUS_INVALID_PARAM);
433         LNN_LOGE(LNN_STATE, "invalid parameters");
434         return SOFTBUS_INVALID_PARAM;
435     }
436     int32_t ret = CommonInit(pkgName);
437     if (ret != SOFTBUS_OK) {
438         DfxRecordLnnDiscServerEnd(DISC_SERVER_PUBLISH, pkgName, ret);
439         return ret;
440     }
441     if (PublishInfoCheck(info) != SOFTBUS_OK) {
442         DfxRecordLnnDiscServerEnd(DISC_SERVER_PUBLISH, pkgName, SOFTBUS_INVALID_PARAM);
443         return SOFTBUS_INVALID_PARAM;
444     }
445     ret = PublishLNNInner(pkgName, info, cb);
446     DfxRecordLnnDiscServerEnd(DISC_SERVER_PUBLISH, pkgName, ret);
447     return ret;
448 }
449 
StopPublishLNN(const char *pkgName, int32_t publishId)450 int32_t StopPublishLNN(const char *pkgName, int32_t publishId)
451 {
452     if (pkgName == NULL) {
453         DfxRecordLnnDiscServerEnd(DISC_SERVER_STOP_PUBLISH, pkgName, SOFTBUS_INVALID_PARAM);
454         LNN_LOGE(LNN_STATE, "invalid parameters");
455         return SOFTBUS_INVALID_PARAM;
456     }
457     int32_t ret = CommonInit(pkgName);
458     if (ret != SOFTBUS_OK) {
459         DfxRecordLnnDiscServerEnd(DISC_SERVER_STOP_PUBLISH, pkgName, ret);
460         return ret;
461     }
462     ret = StopPublishLNNInner(pkgName, publishId);
463     DfxRecordLnnDiscServerEnd(DISC_SERVER_STOP_PUBLISH, pkgName, ret);
464     return ret;
465 }
466 
RefreshLNN(const char *pkgName, const SubscribeInfo *info, const IRefreshCallback *cb)467 int32_t RefreshLNN(const char *pkgName, const SubscribeInfo *info, const IRefreshCallback *cb)
468 {
469     if (pkgName == NULL || info == NULL || cb == NULL) {
470         DfxRecordLnnDiscServerEnd(DISC_SERVER_DISCOVERY, pkgName, SOFTBUS_INVALID_PARAM);
471         LNN_LOGE(LNN_STATE, "invalid parameters");
472         return SOFTBUS_INVALID_PARAM;
473     }
474     int32_t ret = CommonInit(pkgName);
475     if (ret != SOFTBUS_OK) {
476         DfxRecordLnnDiscServerEnd(DISC_SERVER_DISCOVERY, pkgName, ret);
477         return ret;
478     }
479     if (SubscribeInfoCheck(info) != SOFTBUS_OK) {
480         DfxRecordLnnDiscServerEnd(DISC_SERVER_DISCOVERY, pkgName, SOFTBUS_INVALID_PARAM);
481         return SOFTBUS_INVALID_PARAM;
482     }
483     ret = RefreshLNNInner(pkgName, info, cb);
484     DfxRecordLnnDiscServerEnd(DISC_SERVER_DISCOVERY, pkgName, ret);
485     return ret;
486 }
487 
StopRefreshLNN(const char *pkgName, int32_t refreshId)488 int32_t StopRefreshLNN(const char *pkgName, int32_t refreshId)
489 {
490     if (pkgName == NULL) {
491         DfxRecordLnnDiscServerEnd(DISC_SERVER_STOP_DISCOVERY, pkgName, SOFTBUS_INVALID_PARAM);
492         LNN_LOGE(LNN_STATE, "invalid parameters");
493         return SOFTBUS_INVALID_PARAM;
494     }
495     int32_t ret = CommonInit(pkgName);
496     if (ret != SOFTBUS_OK) {
497         DfxRecordLnnDiscServerEnd(DISC_SERVER_STOP_DISCOVERY, pkgName, ret);
498         return ret;
499     }
500     ret = StopRefreshLNNInner(pkgName, refreshId);
501     DfxRecordLnnDiscServerEnd(DISC_SERVER_STOP_DISCOVERY, pkgName, ret);
502     return ret;
503 }
504 
ActiveMetaNode(const char *pkgName, const MetaNodeConfigInfo *info, char *metaNodeId)505 int32_t ActiveMetaNode(const char *pkgName, const MetaNodeConfigInfo *info, char *metaNodeId)
506 {
507     if (pkgName == NULL || info == NULL || metaNodeId == NULL) {
508         LNN_LOGE(LNN_STATE, "invalid active meta node para");
509         return SOFTBUS_INVALID_PARAM;
510     }
511     int32_t ret = CommonInit(pkgName);
512     if (ret != SOFTBUS_OK) {
513         return ret;
514     }
515     return ActiveMetaNodeInner(pkgName, info, metaNodeId);
516 }
517 
DeactiveMetaNode(const char *pkgName, const char *metaNodeId)518 int32_t DeactiveMetaNode(const char *pkgName, const char *metaNodeId)
519 {
520     if (pkgName == NULL || metaNodeId == NULL) {
521         LNN_LOGE(LNN_STATE, "invalid deactive meta node para");
522         return SOFTBUS_INVALID_PARAM;
523     }
524     int32_t ret = CommonInit(pkgName);
525     if (ret != SOFTBUS_OK) {
526         return ret;
527     }
528     return DeactiveMetaNodeInner(pkgName, metaNodeId);
529 }
530 
GetAllMetaNodeInfo(const char *pkgName, MetaNodeInfo *infos, int32_t *infoNum)531 int32_t GetAllMetaNodeInfo(const char *pkgName, MetaNodeInfo *infos, int32_t *infoNum)
532 {
533     if (pkgName == NULL || infos == NULL || infoNum == NULL || *infoNum > MAX_META_NODE_NUM) {
534         LNN_LOGE(LNN_STATE, "invalid query meta node info para");
535         return SOFTBUS_INVALID_PARAM;
536     }
537     int32_t ret = CommonInit(pkgName);
538     if (ret != SOFTBUS_OK) {
539         return ret;
540     }
541     return GetAllMetaNodeInfoInner(pkgName, infos, infoNum);
542 }
543 
ShiftLNNGear(const char *pkgName, const char *callerId, const char *targetNetworkId, const GearMode *mode)544 int32_t ShiftLNNGear(const char *pkgName, const char *callerId, const char *targetNetworkId, const GearMode *mode)
545 {
546     DfxRecordSdkShiftGearStart(pkgName, mode);
547     if (pkgName == NULL || callerId == NULL || mode == NULL) {
548         LNN_LOGE(LNN_STATE, "invalid shift lnn gear para");
549         return SOFTBUS_INVALID_PARAM;
550     }
551     int32_t ret = CommonInit(pkgName);
552     if (ret != SOFTBUS_OK) {
553         return ret;
554     }
555     size_t len = strnlen(callerId, CALLER_ID_MAX_LEN);
556     if (len == 0 || len >= CALLER_ID_MAX_LEN) {
557         LNN_LOGE(LNN_STATE, "invalid shift lnn gear callerId len=%{public}zu", len);
558         return SOFTBUS_INVALID_PARAM;
559     }
560     if (targetNetworkId != NULL &&
561         strnlen(targetNetworkId, NETWORK_ID_BUF_LEN) != NETWORK_ID_BUF_LEN - 1) {
562         LNN_LOGE(LNN_STATE, "invalid shift lnn gear targetNetworkId");
563         return SOFTBUS_INVALID_PARAM;
564     }
565     return ShiftLNNGearInner(pkgName, callerId, targetNetworkId, mode);
566 }
567 
SyncTrustedRelationShip(const char *pkgName, const char *msg, uint32_t msgLen)568 int32_t SyncTrustedRelationShip(const char *pkgName, const char *msg, uint32_t msgLen)
569 {
570     if (pkgName == NULL || msg == NULL) {
571         LNN_LOGE(LNN_STATE, "invalid SyncTrustedRelationShip para");
572         return SOFTBUS_INVALID_PARAM;
573     }
574     int32_t ret = CommonInit(pkgName);
575     if (ret != SOFTBUS_OK) {
576         LNN_LOGE(LNN_STATE, "common init fail, ret=%{public}d", ret);
577         return ret;
578     }
579     return SyncTrustedRelationShipInner(pkgName, msg, msgLen);
580 }