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