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_manager.h"
17 
18 #include <pthread.h>
19 #include <securec.h>
20 
21 #include "anonymizer.h"
22 #include "bus_center_server_proxy.h"
23 #include "common_list.h"
24 #include "lnn_log.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_adapter_thread.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_feature_config.h"
30 #include "softbus_utils.h"
31 
32 #define DEFAULT_NODE_STATE_CB_CNT 10
33 #define MAX_IPC_LEN 1024
34 
35 static int32_t g_maxNodeStateCbCount;
36 static SoftBusList *g_publishMsgList = NULL;
37 static SoftBusList *g_discoveryMsgList = NULL;
38 static bool g_isInited = false;
39 static SoftBusMutex g_isInitedLock;
40 static char g_regDataLevelChangePkgName[PKG_NAME_SIZE_MAX] = {0};
41 
42 typedef struct {
43     ListNode node;
44     ConnectionAddr addr;
45     OnJoinLNNResult cb;
46 } JoinLNNCbListItem;
47 
48 typedef struct {
49     ListNode node;
50     char networkId[NETWORK_ID_BUF_LEN];
51     OnLeaveLNNResult cb;
52 } LeaveLNNCbListItem;
53 
54 typedef struct {
55     ListNode node;
56     char networkId[NETWORK_ID_BUF_LEN];
57     ITimeSyncCb cb;
58 } TimeSyncCallbackItem;
59 
60 typedef struct {
61     ListNode node;
62     INodeStateCb cb;
63     char pkgName[PKG_NAME_SIZE_MAX];
64 } NodeStateCallbackItem;
65 
66 typedef struct {
67     ListNode joinLNNCbList;
68     ListNode leaveLNNCbList;
69     ListNode nodeStateCbList;
70     ListNode timeSyncCbList;
71     int32_t nodeStateCbListCnt;
72     IPublishCb publishCb;
73     IRefreshCallback refreshCb;
74     IDataLevelCb dataLevelCb;
75     bool isInit;
76     SoftBusMutex lock;
77 } BusCenterClient;
78 
79 typedef struct {
80     char pkgName[PKG_NAME_SIZE_MAX];
81     PublishInfo *info;
82     ListNode node;
83 } DiscPublishMsg;
84 
85 typedef struct {
86     char pkgName[PKG_NAME_SIZE_MAX];
87     SubscribeInfo *info;
88     ListNode node;
89 } DiscSubscribeMsg;
90 
91 static BusCenterClient g_busCenterClient = {
92     .nodeStateCbListCnt = 0,
93     .publishCb.OnPublishResult = NULL,
94     .refreshCb.OnDeviceFound = NULL,
95     .refreshCb.OnDiscoverResult = NULL,
96     .dataLevelCb.onDataLevelChanged = NULL,
97     .isInit = false,
98 };
99 
IsUdidHashEmpty(const ConnectionAddr * addr)100 static bool IsUdidHashEmpty(const ConnectionAddr *addr)
101 {
102     for (uint32_t i = 0; i < UDID_HASH_LEN; i++) {
103         if (addr->info.ble.udidHash[i] != 0) {
104             return false;
105         }
106     }
107     return true;
108 }
109 
IsSameConnectionAddr(const ConnectionAddr * addr1,const ConnectionAddr * addr2)110 static bool IsSameConnectionAddr(const ConnectionAddr *addr1, const ConnectionAddr *addr2)
111 {
112     if (addr1->type != addr2->type) {
113         return false;
114     }
115     if (addr1->type == CONNECTION_ADDR_BR) {
116         return strncmp(addr1->info.br.brMac, addr2->info.br.brMac, BT_MAC_LEN) == 0;
117     }
118     if (addr1->type == CONNECTION_ADDR_BLE) {
119         if (IsUdidHashEmpty(addr2)) {
120             return strncmp(addr1->info.ble.bleMac, addr2->info.ble.bleMac, BT_MAC_LEN) == 0;
121         }
122         return memcmp(addr1->info.ble.udidHash, addr2->info.ble.udidHash, UDID_HASH_LEN) == 0 ||
123             strncmp(addr1->info.ble.bleMac, addr2->info.ble.bleMac, BT_MAC_LEN) == 0;
124     }
125     if (addr1->type == CONNECTION_ADDR_WLAN || addr1->type == CONNECTION_ADDR_ETH) {
126         return (strncmp(addr1->info.ip.ip, addr2->info.ip.ip, IP_STR_MAX_LEN) == 0)
127             && (addr1->info.ip.port == addr2->info.ip.port);
128     }
129     if (addr1->type == CONNECTION_ADDR_SESSION) {
130         return ((addr1->info.session.sessionId == addr2->info.session.sessionId) &&
131             (addr1->info.session.channelId == addr2->info.session.channelId) &&
132             (addr1->info.session.type == addr2->info.session.type));
133     }
134     return false;
135 }
136 
FindJoinLNNCbItem(ConnectionAddr * addr,OnJoinLNNResult cb)137 static JoinLNNCbListItem *FindJoinLNNCbItem(ConnectionAddr *addr, OnJoinLNNResult cb)
138 {
139     JoinLNNCbListItem *item = NULL;
140 
141     LIST_FOR_EACH_ENTRY(item, &g_busCenterClient.joinLNNCbList, JoinLNNCbListItem, node) {
142         if (IsSameConnectionAddr(&item->addr, addr) &&
143             (cb == NULL || cb == item->cb)) {
144             return item;
145         }
146     }
147     return NULL;
148 }
149 
AddJoinLNNCbItem(ConnectionAddr * target,OnJoinLNNResult cb)150 static int32_t AddJoinLNNCbItem(ConnectionAddr *target, OnJoinLNNResult cb)
151 {
152     JoinLNNCbListItem *item = NULL;
153 
154     item = (JoinLNNCbListItem *)SoftBusMalloc(sizeof(*item));
155     if (item == NULL) {
156         LNN_LOGE(LNN_STATE, "malloc join LNN cb item fail");
157         return SOFTBUS_MALLOC_ERR;
158     }
159     ListInit(&item->node);
160     item->addr = *target;
161     item->cb = cb;
162     ListAdd(&g_busCenterClient.joinLNNCbList, &item->node);
163     return SOFTBUS_OK;
164 }
165 
FindLeaveLNNCbItem(const char * networkId,OnLeaveLNNResult cb)166 static LeaveLNNCbListItem *FindLeaveLNNCbItem(const char *networkId, OnLeaveLNNResult cb)
167 {
168     LeaveLNNCbListItem *item = NULL;
169 
170     LIST_FOR_EACH_ENTRY(item, &g_busCenterClient.leaveLNNCbList, LeaveLNNCbListItem, node) {
171         if (strcmp(item->networkId, networkId) == 0 &&
172             (cb == NULL || cb == item->cb)) {
173             return item;
174         }
175     }
176     return NULL;
177 }
178 
AddLeaveLNNCbItem(const char * networkId,OnLeaveLNNResult cb)179 static int32_t AddLeaveLNNCbItem(const char *networkId, OnLeaveLNNResult cb)
180 {
181     LeaveLNNCbListItem *item = NULL;
182 
183     item = (LeaveLNNCbListItem *)SoftBusMalloc(sizeof(*item));
184     if (item == NULL) {
185         LNN_LOGE(LNN_STATE, "malloc join LNN cb item fail");
186         return SOFTBUS_MALLOC_ERR;
187     }
188     ListInit(&item->node);
189     if (strncpy_s(item->networkId, NETWORK_ID_BUF_LEN, networkId, strlen(networkId)) != EOK) {
190         LNN_LOGE(LNN_STATE, "strcpy network id fail");
191         SoftBusFree(item);
192         return SOFTBUS_ERR;
193     }
194     item->cb = cb;
195     ListAdd(&g_busCenterClient.leaveLNNCbList, &item->node);
196     return SOFTBUS_OK;
197 }
198 
FindTimeSyncCbItem(const char * networkId,ITimeSyncCb * cb)199 static TimeSyncCallbackItem *FindTimeSyncCbItem(const char *networkId, ITimeSyncCb *cb)
200 {
201     TimeSyncCallbackItem *item = NULL;
202 
203     LIST_FOR_EACH_ENTRY(item, &g_busCenterClient.timeSyncCbList, TimeSyncCallbackItem, node) {
204         if (strcmp(item->networkId, networkId) == 0 &&
205             (cb == NULL || cb->onTimeSyncResult == item->cb.onTimeSyncResult)) {
206             return item;
207         }
208     }
209     return NULL;
210 }
211 
AddTimeSyncCbItem(const char * networkId,ITimeSyncCb * cb)212 static int32_t AddTimeSyncCbItem(const char *networkId, ITimeSyncCb *cb)
213 {
214     TimeSyncCallbackItem *item = NULL;
215 
216     item = (TimeSyncCallbackItem *)SoftBusMalloc(sizeof(*item));
217     if (item == NULL) {
218         LNN_LOGE(LNN_STATE, "malloc time sync cb item fail");
219         return SOFTBUS_MALLOC_ERR;
220     }
221     ListInit(&item->node);
222     if (strncpy_s(item->networkId, NETWORK_ID_BUF_LEN, networkId, strlen(networkId)) != EOK) {
223         LNN_LOGE(LNN_STATE, "strcpy network id fail");
224         SoftBusFree(item);
225         return SOFTBUS_ERR;
226     }
227     item->cb = *cb;
228     ListAdd(&g_busCenterClient.timeSyncCbList, &item->node);
229     return SOFTBUS_OK;
230 }
231 
ClearJoinLNNList(void)232 static void ClearJoinLNNList(void)
233 {
234     JoinLNNCbListItem *item = NULL;
235     JoinLNNCbListItem *next = NULL;
236 
237     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_busCenterClient.joinLNNCbList, JoinLNNCbListItem, node) {
238         ListDelete(&item->node);
239         SoftBusFree(item);
240     }
241 }
242 
ClearLeaveLNNList(void)243 static void ClearLeaveLNNList(void)
244 {
245     LeaveLNNCbListItem *item = NULL;
246     LeaveLNNCbListItem *next = NULL;
247 
248     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_busCenterClient.leaveLNNCbList, LeaveLNNCbListItem, node) {
249         ListDelete(&item->node);
250         SoftBusFree(item);
251     }
252 }
253 
ClearTimeSyncList(ListNode * list)254 static void ClearTimeSyncList(ListNode *list)
255 {
256     TimeSyncCallbackItem *item = NULL;
257     TimeSyncCallbackItem *next = NULL;
258 
259     LIST_FOR_EACH_ENTRY_SAFE(item, next, list, TimeSyncCallbackItem, node) {
260         ListDelete(&item->node);
261         SoftBusFree(item);
262     }
263 }
264 
ClearNodeStateCbList(ListNode * list)265 static void ClearNodeStateCbList(ListNode *list)
266 {
267     NodeStateCallbackItem *item = NULL;
268     NodeStateCallbackItem *next = NULL;
269 
270     LIST_FOR_EACH_ENTRY_SAFE(item, next, list, NodeStateCallbackItem, node) {
271         ListDelete(&item->node);
272         SoftBusFree(item);
273     }
274 }
275 
DuplicateNodeStateCbList(ListNode * list)276 static void DuplicateNodeStateCbList(ListNode *list)
277 {
278     NodeStateCallbackItem *item = NULL;
279     NodeStateCallbackItem *copyItem = NULL;
280 
281     LIST_FOR_EACH_ENTRY(item, &g_busCenterClient.nodeStateCbList, NodeStateCallbackItem, node) {
282         copyItem = (NodeStateCallbackItem *)SoftBusCalloc(sizeof(NodeStateCallbackItem));
283         if (copyItem == NULL) {
284             LNN_LOGE(LNN_STATE, "malloc node state callback item fail");
285             continue;
286         }
287         (void)strncpy_s(copyItem->pkgName, PKG_NAME_SIZE_MAX, item->pkgName, PKG_NAME_SIZE_MAX - 1);
288         ListInit(&copyItem->node);
289         copyItem->cb = item->cb;
290         ListAdd(list, &copyItem->node);
291     }
292 }
293 
DuplicateTimeSyncResultCbList(ListNode * list,const char * networkId)294 static void DuplicateTimeSyncResultCbList(ListNode *list, const char *networkId)
295 {
296     TimeSyncCallbackItem *item = NULL;
297     TimeSyncCallbackItem *copyItem = NULL;
298 
299     LIST_FOR_EACH_ENTRY(item, &g_busCenterClient.timeSyncCbList, TimeSyncCallbackItem, node) {
300         if (strcmp(item->networkId, networkId) != 0) {
301             continue;
302         }
303         copyItem = (TimeSyncCallbackItem *)SoftBusMalloc(sizeof(TimeSyncCallbackItem));
304         if (copyItem == NULL) {
305             LNN_LOGE(LNN_STATE, "malloc time sync callback item fail");
306             continue;
307         }
308         copyItem->cb = item->cb;
309         ListInit(&copyItem->node);
310         if (strncpy_s(copyItem->networkId, NETWORK_ID_BUF_LEN, item->networkId, strlen(item->networkId)) != EOK) {
311             LNN_LOGE(LNN_STATE, "copy networkId fail");
312             SoftBusFree(copyItem);
313             continue;
314         }
315         ListAdd(list, &copyItem->node);
316     }
317 }
318 
FreeDiscPublishMsg(DiscPublishMsg ** msgNode)319 static void FreeDiscPublishMsg(DiscPublishMsg **msgNode)
320 {
321     if (*msgNode != NULL && (*msgNode)->info != NULL) {
322         SoftBusFree((char *)(*msgNode)->info->capability);
323         SoftBusFree((*msgNode)->info->capabilityData);
324         SoftBusFree((*msgNode)->info);
325     }
326     SoftBusFree(*msgNode);
327     *msgNode = NULL;
328 }
329 
FreeDiscSubscribeMsg(DiscSubscribeMsg ** msgNode)330 static void FreeDiscSubscribeMsg(DiscSubscribeMsg **msgNode)
331 {
332     if (*msgNode != NULL && (*msgNode)->info != NULL) {
333         SoftBusFree((char *)(*msgNode)->info->capability);
334         SoftBusFree((*msgNode)->info->capabilityData);
335         SoftBusFree((*msgNode)->info);
336     }
337     SoftBusFree(*msgNode);
338     *msgNode = NULL;
339 }
340 
BuildDiscPublishMsg(DiscPublishMsg ** msgNode,const PublishInfo * info,const char * pkgName)341 static int32_t BuildDiscPublishMsg(DiscPublishMsg **msgNode, const PublishInfo *info, const char *pkgName)
342 {
343     *msgNode = (DiscPublishMsg *)SoftBusCalloc(sizeof(DiscPublishMsg));
344     if (*msgNode == NULL) {
345         LNN_LOGE(LNN_STATE, "calloc msgNode failed");
346         return SOFTBUS_MALLOC_ERR;
347     }
348     (*msgNode)->info = (PublishInfo *)SoftBusCalloc(sizeof(PublishInfo));
349     if ((*msgNode)->info == NULL) {
350         FreeDiscPublishMsg(msgNode);
351         LNN_LOGE(LNN_STATE, "calloc info failed");
352         return SOFTBUS_MALLOC_ERR;
353     }
354     (*msgNode)->info->capability = (char *)SoftBusCalloc(strlen(info->capability) + 1);
355     if ((*msgNode)->info->capability == NULL) {
356         FreeDiscPublishMsg(msgNode);
357         LNN_LOGE(LNN_STATE, "calloc capability failed");
358         return SOFTBUS_MALLOC_ERR;
359     }
360     (*msgNode)->info->publishId = info->publishId;
361     (*msgNode)->info->mode = info->mode;
362     (*msgNode)->info->medium = info->medium;
363     (*msgNode)->info->freq = info->freq;
364     (*msgNode)->info->dataLen = info->dataLen;
365     (*msgNode)->info->ranging = info->ranging;
366     if (strcpy_s((char *)(*msgNode)->info->capability, strlen(info->capability) + 1, info->capability) != EOK ||
367         strcpy_s((*msgNode)->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
368         FreeDiscPublishMsg(msgNode);
369         LNN_LOGE(LNN_STATE, "copy capability or pkgName failed");
370         return SOFTBUS_ERR;
371     }
372     if (info->dataLen > 0) {
373         (*msgNode)->info->capabilityData = (unsigned char *)SoftBusCalloc(info->dataLen + 1);
374         if ((*msgNode)->info->capabilityData == NULL) {
375             FreeDiscPublishMsg(msgNode);
376             LNN_LOGE(LNN_STATE, "calloc failed");
377             return SOFTBUS_MALLOC_ERR;
378         }
379         if (strcpy_s((char *)(*msgNode)->info->capabilityData, info->dataLen + 1,
380             (const char *)info->capabilityData) != EOK) {
381             FreeDiscPublishMsg(msgNode);
382             LNN_LOGE(LNN_STATE, "copy capabilityData failed");
383             return SOFTBUS_ERR;
384         }
385     }
386     return SOFTBUS_OK;
387 }
388 
BuildDiscSubscribeMsg(DiscSubscribeMsg ** msgNode,const SubscribeInfo * info,const char * pkgName)389 static int32_t BuildDiscSubscribeMsg(DiscSubscribeMsg **msgNode, const SubscribeInfo *info, const char *pkgName)
390 {
391     *msgNode = (DiscSubscribeMsg *)SoftBusCalloc(sizeof(DiscSubscribeMsg));
392     if (*msgNode == NULL) {
393         LNN_LOGE(LNN_STATE, "calloc msgNode failed");
394         return SOFTBUS_MALLOC_ERR;
395     }
396     (*msgNode)->info = (SubscribeInfo *)SoftBusCalloc(sizeof(SubscribeInfo));
397     if ((*msgNode)->info == NULL) {
398         FreeDiscSubscribeMsg(msgNode);
399         LNN_LOGE(LNN_STATE, "calloc info failed");
400         return SOFTBUS_MALLOC_ERR;
401     }
402     (*msgNode)->info->capability = (char *)SoftBusCalloc(strlen(info->capability) + 1);
403     if ((*msgNode)->info->capability == NULL) {
404         FreeDiscSubscribeMsg(msgNode);
405         LNN_LOGE(LNN_STATE, "calloc capability failed");
406         return SOFTBUS_MALLOC_ERR;
407     }
408     (*msgNode)->info->subscribeId = info->subscribeId;
409     (*msgNode)->info->mode = info->mode;
410     (*msgNode)->info->medium = info->medium;
411     (*msgNode)->info->freq = info->freq;
412     (*msgNode)->info->dataLen = info->dataLen;
413     if (strcpy_s((char *)(*msgNode)->info->capability, strlen(info->capability) + 1, info->capability) != EOK ||
414         strcpy_s((*msgNode)->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
415         FreeDiscSubscribeMsg(msgNode);
416         LNN_LOGE(LNN_STATE, "copy capability or pkgName failed");
417         return SOFTBUS_ERR;
418     }
419     if (info->dataLen > 0) {
420         (*msgNode)->info->capabilityData = (unsigned char *)SoftBusCalloc(info->dataLen + 1);
421         if ((*msgNode)->info->capabilityData == NULL) {
422             FreeDiscSubscribeMsg(msgNode);
423             LNN_LOGE(LNN_STATE, "calloc failed");
424             return SOFTBUS_MALLOC_ERR;
425         }
426         if (strcpy_s((char *)(*msgNode)->info->capabilityData, info->dataLen + 1,
427             (const char *)info->capabilityData) != EOK) {
428             FreeDiscSubscribeMsg(msgNode);
429             LNN_LOGE(LNN_STATE, "copy capabilityData failed");
430             return SOFTBUS_ERR;
431         }
432     }
433     return SOFTBUS_OK;
434 }
435 
AddDiscPublishMsg(const char * pkgName,const PublishInfo * info)436 static int32_t AddDiscPublishMsg(const char *pkgName, const PublishInfo *info)
437 {
438     LNN_CHECK_AND_RETURN_RET_LOGW(g_isInited, SOFTBUS_NO_INIT, LNN_STATE, "disc publish list not init");
439     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_publishMsgList->lock)) == SOFTBUS_OK,
440         SOFTBUS_LOCK_ERR, LNN_STATE, "lock failed");
441 
442     DiscPublishMsg *msgNode = NULL;
443     LIST_FOR_EACH_ENTRY(msgNode, &(g_publishMsgList->list), DiscPublishMsg, node) {
444         if (msgNode->info->publishId == info->publishId &&
445             strcmp(msgNode->info->capability, info->capability) == 0 && strcmp(msgNode->pkgName, pkgName) == 0) {
446             (void)SoftBusMutexUnlock(&(g_publishMsgList->lock));
447             return SOFTBUS_OK;
448         }
449     }
450 
451     if (BuildDiscPublishMsg(&msgNode, info, pkgName) != SOFTBUS_OK) {
452         (void)SoftBusMutexUnlock(&(g_publishMsgList->lock));
453         LNN_LOGE(LNN_STATE, "build DiscPublishMsg failed");
454         return SOFTBUS_ERR;
455     }
456     ListTailInsert(&(g_publishMsgList->list), &(msgNode->node));
457     (void)SoftBusMutexUnlock(&(g_publishMsgList->lock));
458     return SOFTBUS_OK;
459 }
460 
DeleteDiscPublishMsg(const char * pkgName,int32_t publishId)461 static int32_t DeleteDiscPublishMsg(const char *pkgName, int32_t publishId)
462 {
463     LNN_CHECK_AND_RETURN_RET_LOGW(g_isInited, SOFTBUS_NO_INIT, LNN_STATE, "disc publish list not init");
464     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_publishMsgList->lock)) == SOFTBUS_OK,
465         SOFTBUS_LOCK_ERR, LNN_STATE, "lock failed");
466 
467     DiscPublishMsg *msgNode = NULL;
468     DiscPublishMsg *next = NULL;
469     LIST_FOR_EACH_ENTRY_SAFE(msgNode, next, &(g_publishMsgList->list), DiscPublishMsg, node) {
470         if (msgNode->info->publishId == publishId && strcmp(msgNode->pkgName, pkgName) == 0) {
471             ListDelete(&(msgNode->node));
472             FreeDiscPublishMsg(&msgNode);
473             break;
474         }
475     }
476     (void)SoftBusMutexUnlock(&(g_publishMsgList->lock));
477     return SOFTBUS_OK;
478 }
479 
AddDiscSubscribeMsg(const char * pkgName,const SubscribeInfo * info)480 static int32_t AddDiscSubscribeMsg(const char *pkgName, const SubscribeInfo *info)
481 {
482     LNN_CHECK_AND_RETURN_RET_LOGW(g_isInited, SOFTBUS_NO_INIT, LNN_STATE, "disc subscribe list not init");
483     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discoveryMsgList->lock)) == SOFTBUS_OK,
484         SOFTBUS_LOCK_ERR, LNN_STATE, "lock failed");
485 
486     DiscSubscribeMsg *msgNode = NULL;
487     LIST_FOR_EACH_ENTRY(msgNode, &(g_discoveryMsgList->list), DiscSubscribeMsg, node) {
488         if (msgNode->info->subscribeId == info->subscribeId &&
489             strcmp(msgNode->info->capability, info->capability) == 0 && strcmp(msgNode->pkgName, pkgName) == 0) {
490             (void)SoftBusMutexUnlock(&(g_discoveryMsgList->lock));
491             return SOFTBUS_OK;
492         }
493     }
494 
495     if (BuildDiscSubscribeMsg(&msgNode, info, pkgName) != SOFTBUS_OK) {
496         (void)SoftBusMutexUnlock(&(g_discoveryMsgList->lock));
497         LNN_LOGE(LNN_STATE, "build DiscSubscribeMsg failed");
498         return SOFTBUS_ERR;
499     }
500     ListTailInsert(&(g_discoveryMsgList->list), &(msgNode->node));
501     (void)SoftBusMutexUnlock(&(g_discoveryMsgList->lock));
502     return SOFTBUS_OK;
503 }
504 
DeleteDiscSubscribeMsg(const char * pkgName,int32_t refreshId)505 static int32_t DeleteDiscSubscribeMsg(const char *pkgName, int32_t refreshId)
506 {
507     LNN_CHECK_AND_RETURN_RET_LOGW(g_isInited, SOFTBUS_NO_INIT, LNN_STATE, "disc subscribe list not init");
508     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discoveryMsgList->lock)) == SOFTBUS_OK,
509         SOFTBUS_LOCK_ERR, LNN_STATE, "lock failed");
510 
511     DiscSubscribeMsg *msgNode = NULL;
512     DiscSubscribeMsg *next = NULL;
513     LIST_FOR_EACH_ENTRY_SAFE(msgNode, next, &(g_discoveryMsgList->list), DiscSubscribeMsg, node) {
514         if (msgNode->info->subscribeId == refreshId && strcmp(msgNode->pkgName, pkgName) == 0) {
515             ListDelete(&(msgNode->node));
516             FreeDiscSubscribeMsg(&msgNode);
517             break;
518         }
519     }
520     (void)SoftBusMutexUnlock(&(g_discoveryMsgList->lock));
521     return SOFTBUS_OK;
522 }
523 
DiscoveryMsgListInit()524 static int32_t DiscoveryMsgListInit()
525 {
526     if (g_isInited) {
527         LNN_LOGI(LNN_STATE, "disc msg list already init");
528         return SOFTBUS_OK;
529     }
530     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexInit(&g_isInitedLock, NULL) == SOFTBUS_OK,
531         SOFTBUS_LOCK_ERR, LNN_STATE, "lock init failed");
532     if (SoftBusMutexLock(&g_isInitedLock) != SOFTBUS_OK) {
533         LNN_LOGE(LNN_STATE, "lock failed");
534         (void)SoftBusMutexDestroy(&g_isInitedLock);
535         return SOFTBUS_LOCK_ERR;
536     }
537     g_publishMsgList = CreateSoftBusList();
538     g_discoveryMsgList = CreateSoftBusList();
539     if (g_publishMsgList == NULL || g_discoveryMsgList == NULL) {
540         LNN_LOGE(LNN_STATE, "init disc msg list failed");
541         DestroySoftBusList(g_publishMsgList);
542         DestroySoftBusList(g_discoveryMsgList);
543         g_publishMsgList = NULL;
544         g_discoveryMsgList = NULL;
545         (void)SoftBusMutexUnlock(&g_isInitedLock);
546         return SOFTBUS_ERR;
547     }
548     g_isInited = true;
549     (void)SoftBusMutexUnlock(&g_isInitedLock);
550     static uint32_t callCount = 0;
551     LNN_LOGI(LNN_STATE, "disc list init success, callCount=%{public}u", callCount++);
552     return SOFTBUS_OK;
553 }
554 
DiscoveryMsgListDeInit()555 static int32_t DiscoveryMsgListDeInit()
556 {
557     if (!g_isInited) {
558         LNN_LOGI(LNN_STATE, "disc msg list no need deInit");
559         return SOFTBUS_OK;
560     }
561     (void)SoftBusMutexDestroy(&g_isInitedLock);
562     DestroySoftBusList(g_publishMsgList);
563     DestroySoftBusList(g_discoveryMsgList);
564     g_publishMsgList = NULL;
565     g_discoveryMsgList = NULL;
566     g_isInited = false;
567 
568     LNN_LOGI(LNN_STATE, "disc list deinit success");
569     return SOFTBUS_OK;
570 }
571 
BusCenterClientDeinit(void)572 void BusCenterClientDeinit(void)
573 {
574     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
575         LNN_LOGE(LNN_INIT, "lock in deinit");
576     }
577     if (DiscoveryMsgListDeInit() != SOFTBUS_OK) {
578         LNN_LOGE(LNN_INIT, "DiscoveryMsgListDeInit fail");
579         (void)SoftBusMutexUnlock(&g_busCenterClient.lock);
580         return;
581     }
582     ClearJoinLNNList();
583     ClearLeaveLNNList();
584     ClearTimeSyncList(&g_busCenterClient.timeSyncCbList);
585     ClearNodeStateCbList(&g_busCenterClient.nodeStateCbList);
586     g_busCenterClient.nodeStateCbListCnt = 0;
587     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
588         LNN_LOGE(LNN_INIT, "unlock in deinit");
589     }
590     g_busCenterClient.dataLevelCb.onDataLevelChanged = NULL;
591     SoftBusMutexDestroy(&g_busCenterClient.lock);
592     BusCenterServerProxyDeInit();
593 }
594 
BusCenterClientInit(void)595 int32_t BusCenterClientInit(void)
596 {
597     if (SoftbusGetConfig(SOFTBUS_INT_MAX_NODE_STATE_CB_CNT,
598         (unsigned char *)&g_maxNodeStateCbCount, sizeof(g_maxNodeStateCbCount)) != SOFTBUS_OK) {
599         LNN_LOGE(LNN_INIT, "Cannot get NodeStateCbCount from config file");
600         g_maxNodeStateCbCount = DEFAULT_NODE_STATE_CB_CNT;
601     }
602     LNN_LOGI(LNN_INIT, "NodeStateCbCount=%{public}u", g_maxNodeStateCbCount);
603 
604     if (SoftBusMutexInit(&g_busCenterClient.lock, NULL) != SOFTBUS_OK) {
605         LNN_LOGE(LNN_INIT, "g_busCenterClient.lock init failed");
606         return SOFTBUS_ERR;
607     }
608     if (DiscoveryMsgListInit() != SOFTBUS_OK) {
609         LNN_LOGE(LNN_INIT, "DiscoveryMsgListInit fail");
610         return SOFTBUS_ERR;
611     }
612 
613     ListInit(&g_busCenterClient.joinLNNCbList);
614     ListInit(&g_busCenterClient.leaveLNNCbList);
615     ListInit(&g_busCenterClient.nodeStateCbList);
616     ListInit(&g_busCenterClient.timeSyncCbList);
617     g_busCenterClient.isInit = true;
618     if (BusCenterServerProxyInit() != SOFTBUS_OK) {
619         LNN_LOGE(LNN_INIT, "bus center server proxy init failed");
620         BusCenterClientDeinit();
621         return SOFTBUS_ERR;
622     }
623     LNN_LOGI(LNN_INIT, "BusCenterClientInit init OK");
624     return SOFTBUS_OK;
625 }
626 
GetAllNodeDeviceInfoInner(const char * pkgName,NodeBasicInfo ** info,int32_t * infoNum)627 int32_t GetAllNodeDeviceInfoInner(const char *pkgName, NodeBasicInfo **info, int32_t *infoNum)
628 {
629     int32_t ret = ServerIpcGetAllOnlineNodeInfo(pkgName, (void **)info, sizeof(NodeBasicInfo), infoNum);
630     if (ret != SOFTBUS_OK) {
631         LNN_LOGE(LNN_STATE, "Server GetAllOnlineNodeInfo failed, ret=%{public}d", ret);
632     }
633     return ret;
634 }
635 
GetLocalNodeDeviceInfoInner(const char * pkgName,NodeBasicInfo * info)636 int32_t GetLocalNodeDeviceInfoInner(const char *pkgName, NodeBasicInfo *info)
637 {
638     int32_t ret = ServerIpcGetLocalDeviceInfo(pkgName, info, sizeof(*info));
639     if (ret != SOFTBUS_OK) {
640         LNN_LOGE(LNN_STATE, "Server GetLocalNodeDeviceInfo failed, ret=%{public}d", ret);
641     }
642     return ret;
643 }
644 
GetNodeKeyInfoInner(const char * pkgName,const char * networkId,NodeDeviceInfoKey key,uint8_t * info,int32_t infoLen)645 int32_t GetNodeKeyInfoInner(const char *pkgName, const char *networkId, NodeDeviceInfoKey key,
646     uint8_t *info, int32_t infoLen)
647 {
648     int32_t ret = ServerIpcGetNodeKeyInfo(pkgName, networkId, key, info, infoLen);
649     if (ret != SOFTBUS_OK) {
650         LNN_LOGE(LNN_STATE, "Server GetNodeKeyInfo failed, ret=%{public}d", ret);
651     }
652     return ret;
653 }
654 
SetNodeDataChangeFlagInner(const char * pkgName,const char * networkId,uint16_t dataChangeFlag)655 int32_t SetNodeDataChangeFlagInner(const char *pkgName, const char *networkId, uint16_t dataChangeFlag)
656 {
657     int32_t ret = ServerIpcSetNodeDataChangeFlag(pkgName, networkId, dataChangeFlag);
658     if (ret != SOFTBUS_OK) {
659         LNN_LOGE(LNN_STATE, "Server SetNodeDataChangeFlag failed, ret=%{public}d", ret);
660     }
661     return ret;
662 }
663 
RegDataLevelChangeCbInner(const char * pkgName,IDataLevelCb * callback)664 int32_t RegDataLevelChangeCbInner(const char *pkgName, IDataLevelCb *callback)
665 {
666     LNN_LOGI(LNN_STATE, "enter");
667     g_busCenterClient.dataLevelCb = *callback;
668     if (strcpy_s(g_regDataLevelChangePkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
669         LNN_LOGE(LNN_STATE, "copy pkgName fail");
670         return SOFTBUS_MEM_ERR;
671     }
672     int32_t ret = ServerIpcRegDataLevelChangeCb(pkgName);
673     if (ret != SOFTBUS_OK) {
674         LNN_LOGE(LNN_STATE, "Server RegDataLevelChangeCb failed, ret=%{public}d", ret);
675     }
676     return ret;
677 }
678 
RestartRegDataLevelChange(void)679 void RestartRegDataLevelChange(void)
680 {
681     LNN_LOGI(LNN_STATE, "enter");
682     if (g_regDataLevelChangePkgName[0] == '\0') {
683         LNN_LOGI(LNN_STATE, "restart regDataLevelChange is not used");
684         return;
685     }
686     int32_t ret = ServerIpcRegDataLevelChangeCb(g_regDataLevelChangePkgName);
687     if (ret != SOFTBUS_OK) {
688         LNN_LOGE(LNN_STATE, "Server RegDataLevelChangeCb failed, ret=%{public}d", ret);
689         return;
690     }
691     LNN_LOGI(LNN_STATE, "Server RegDataLevelChangeCb succeed");
692 }
693 
UnregDataLevelChangeCbInner(const char * pkgName)694 int32_t UnregDataLevelChangeCbInner(const char *pkgName)
695 {
696     LNN_LOGI(LNN_STATE, "UnregDataLevelChangeCbInner enter");
697     g_busCenterClient.dataLevelCb.onDataLevelChanged = NULL;
698     int32_t ret = ServerIpcUnregDataLevelChangeCb(pkgName);
699     if (ret != SOFTBUS_OK) {
700         LNN_LOGE(LNN_STATE, "Server UnregDataLevelChangeCb failed, ret=%{public}d", ret);
701     }
702     return ret;
703 }
704 
SetDataLevelInner(const DataLevel * dataLevel)705 int32_t SetDataLevelInner(const DataLevel *dataLevel)
706 {
707     int32_t ret = ServerIpcSetDataLevel(dataLevel);
708     if (ret != SOFTBUS_OK) {
709         LNN_LOGE(LNN_STATE, "Server SetDataLevel failed, ret=%{public}d", ret);
710     }
711     return ret;
712 }
713 
JoinLNNInner(const char * pkgName,ConnectionAddr * target,OnJoinLNNResult cb)714 int32_t JoinLNNInner(const char *pkgName, ConnectionAddr *target, OnJoinLNNResult cb)
715 {
716     int32_t rc;
717 
718     if (!g_busCenterClient.isInit) {
719         LNN_LOGE(LNN_STATE, "join lnn not init");
720         return SOFTBUS_NO_INIT;
721     }
722     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
723         LNN_LOGE(LNN_STATE, "lock join lnn cb list in join");
724         return SOFTBUS_LOCK_ERR;
725     }
726 
727     do {
728         if (FindJoinLNNCbItem(target, cb) != NULL) {
729             LNN_LOGE(LNN_STATE, "join request already exist");
730             rc = SOFTBUS_ALREADY_EXISTED;
731             break;
732         }
733         rc = ServerIpcJoinLNN(pkgName, target, sizeof(*target));
734         if (rc != SOFTBUS_OK) {
735             LNN_LOGE(LNN_STATE, "request join lnn failed, ret=%{public}d", rc);
736         } else {
737             rc = AddJoinLNNCbItem(target, cb);
738         }
739     } while (false);
740     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
741         LNN_LOGE(LNN_STATE, "unlock join lnn cb list in join");
742     }
743     return rc;
744 }
745 
LeaveLNNInner(const char * pkgName,const char * networkId,OnLeaveLNNResult cb)746 int32_t LeaveLNNInner(const char *pkgName, const char *networkId, OnLeaveLNNResult cb)
747 {
748     int32_t rc;
749 
750     if (!g_busCenterClient.isInit) {
751         LNN_LOGE(LNN_STATE, "leave lnn not init");
752         return SOFTBUS_NO_INIT;
753     }
754     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
755         LNN_LOGE(LNN_STATE, "lock leave lnn cb list in leave");
756     }
757     rc = SOFTBUS_ERR;
758     do {
759         if (FindLeaveLNNCbItem(networkId, cb) != NULL) {
760             LNN_LOGE(LNN_STATE, "leave request already exist");
761             break;
762         }
763         rc = ServerIpcLeaveLNN(pkgName, networkId);
764         if (rc != SOFTBUS_OK) {
765             LNN_LOGE(LNN_STATE, "request leave lnn failed, ret=%{public}d", rc);
766         } else {
767             rc = AddLeaveLNNCbItem(networkId, cb);
768         }
769     } while (false);
770     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
771         LNN_LOGE(LNN_STATE, "unlock leave lnn cb list in leave");
772     }
773     return rc;
774 }
775 
IsSameNodeStateCb(const INodeStateCb * callback1,const INodeStateCb * callback2)776 static bool IsSameNodeStateCb(const INodeStateCb *callback1, const INodeStateCb *callback2)
777 {
778     if (callback1->events != callback2->events) {
779         return false;
780     }
781     if ((callback1->events & EVENT_NODE_STATE_ONLINE) &&
782         callback1->onNodeOnline != callback2->onNodeOnline) {
783         return false;
784     }
785     if ((callback1->events & EVENT_NODE_STATE_OFFLINE) &&
786         callback1->onNodeOffline != callback2->onNodeOffline) {
787         return false;
788     }
789     if ((callback1->events & EVENT_NODE_STATE_INFO_CHANGED) &&
790         callback1->onNodeBasicInfoChanged != callback2->onNodeBasicInfoChanged) {
791         return false;
792     }
793     if ((callback1->events & EVENT_NODE_STATUS_CHANGED) &&
794         callback1->onNodeStatusChanged != callback2->onNodeStatusChanged) {
795         return false;
796     }
797     if ((callback1->events & EVENT_NODE_HICHAIN_PROOF_EXCEPTION) &&
798         callback1->onHichainProofException != callback2->onHichainProofException) {
799         return false;
800     }
801     return true;
802 }
803 
RegNodeDeviceStateCbInner(const char * pkgName,INodeStateCb * callback)804 int32_t RegNodeDeviceStateCbInner(const char *pkgName, INodeStateCb *callback)
805 {
806     NodeStateCallbackItem *item = NULL;
807     int32_t rc = SOFTBUS_ERR;
808 
809     if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1)) {
810         LNN_LOGE(LNN_STATE, "Package name is empty or length exceeds");
811         return SOFTBUS_INVALID_PARAM;
812     }
813     if (!g_busCenterClient.isInit) {
814         LNN_LOGE(LNN_STATE, "reg node state cb not init");
815         return SOFTBUS_NO_INIT;
816     }
817     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
818         LNN_LOGE(LNN_STATE, "lock node state cb list in reg");
819     }
820     LIST_FOR_EACH_ENTRY(item, &g_busCenterClient.nodeStateCbList, NodeStateCallbackItem, node) {
821         if (IsSameNodeStateCb(&item->cb, callback)) {
822             (void)SoftBusMutexUnlock(&g_busCenterClient.lock);
823             LNN_LOGI(LNN_STATE, "warn: reg node state callback repeatedly");
824             return SOFTBUS_OK;
825         }
826     }
827     do {
828         if (g_busCenterClient.nodeStateCbListCnt >= g_maxNodeStateCbCount) {
829             break;
830         }
831         item = (NodeStateCallbackItem *)SoftBusCalloc(sizeof(*item));
832         if (item == NULL) {
833             rc = SOFTBUS_MALLOC_ERR;
834             break;
835         }
836         (void)strncpy_s(item->pkgName, PKG_NAME_SIZE_MAX, pkgName, PKG_NAME_SIZE_MAX - 1);
837         ListInit(&item->node);
838         item->cb = *callback;
839         ListAdd(&g_busCenterClient.nodeStateCbList, &item->node);
840         g_busCenterClient.nodeStateCbListCnt++;
841         rc = SOFTBUS_OK;
842     } while (false);
843     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
844         LNN_LOGE(LNN_STATE, "unlock node state cb list");
845     }
846     return rc;
847 }
848 
UnregNodeDeviceStateCbInner(INodeStateCb * callback)849 int32_t UnregNodeDeviceStateCbInner(INodeStateCb *callback)
850 {
851     NodeStateCallbackItem *item = NULL;
852     NodeStateCallbackItem *next = NULL;
853 
854     if (!g_busCenterClient.isInit) {
855         LNN_LOGE(LNN_STATE, "unreg node state cb not init");
856         return SOFTBUS_NO_INIT;
857     }
858     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
859         LNN_LOGE(LNN_STATE, "lock node state cb list in unreg");
860     }
861     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_busCenterClient.nodeStateCbList, NodeStateCallbackItem, node) {
862         if (IsSameNodeStateCb(&item->cb, callback)) {
863             ListDelete(&item->node);
864             SoftBusFree(item);
865             g_busCenterClient.nodeStateCbListCnt--;
866             break;
867         }
868     }
869     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
870         LNN_LOGE(LNN_STATE, "unlock node state cb list in unreg");
871     }
872     return SOFTBUS_OK;
873 }
874 
StartTimeSyncInner(const char * pkgName,const char * targetNetworkId,TimeSyncAccuracy accuracy,TimeSyncPeriod period,ITimeSyncCb * cb)875 int32_t StartTimeSyncInner(const char *pkgName, const char *targetNetworkId, TimeSyncAccuracy accuracy,
876     TimeSyncPeriod period, ITimeSyncCb *cb)
877 {
878     int32_t rc;
879 
880     if (!g_busCenterClient.isInit) {
881         LNN_LOGE(LNN_STATE, "start time sync not init");
882         return SOFTBUS_NO_INIT;
883     }
884     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
885         LNN_LOGE(LNN_STATE, "lock time sync cb list");
886     }
887     rc = SOFTBUS_ERR;
888     do {
889         if (FindTimeSyncCbItem(targetNetworkId, cb) != NULL) {
890             LNN_LOGE(LNN_STATE, "repeat pkgName request, StopTimeSync first! pkgName=%{public}s", pkgName);
891             break;
892         }
893         rc = ServerIpcStartTimeSync(pkgName, targetNetworkId, accuracy, period);
894         if (rc != SOFTBUS_OK) {
895             LNN_LOGE(LNN_STATE, "start time sync failed, ret=%{public}d", rc);
896         } else {
897             rc = AddTimeSyncCbItem(targetNetworkId, cb);
898         }
899     } while (false);
900     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
901         LNN_LOGE(LNN_STATE, "unlock time sync cb list");
902     }
903     return rc;
904 }
905 
StopTimeSyncInner(const char * pkgName,const char * targetNetworkId)906 int32_t StopTimeSyncInner(const char *pkgName, const char *targetNetworkId)
907 {
908     int32_t rc;
909     TimeSyncCallbackItem *item = NULL;
910 
911     if (!g_busCenterClient.isInit) {
912         LNN_LOGE(LNN_STATE, "stop time sync cb list not init");
913         return SOFTBUS_NO_INIT;
914     }
915     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
916         LNN_LOGE(LNN_STATE, "lock time sync cb list");
917     }
918     rc = SOFTBUS_ERR;
919     while ((item = FindTimeSyncCbItem(targetNetworkId, NULL)) != NULL) {
920         rc = ServerIpcStopTimeSync(pkgName, targetNetworkId);
921         if (rc != SOFTBUS_OK) {
922             LNN_LOGE(LNN_STATE, "stop time sync failed, ret=%{public}d", rc);
923         } else {
924             ListDelete(&item->node);
925             SoftBusFree(item);
926         }
927     }
928     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
929         LNN_LOGE(LNN_STATE, "unlock time sync cb list");
930     }
931     return rc;
932 }
933 
PublishLNNInner(const char * pkgName,const PublishInfo * info,const IPublishCb * cb)934 int32_t PublishLNNInner(const char *pkgName, const PublishInfo *info, const IPublishCb *cb)
935 {
936     g_busCenterClient.publishCb = *cb;
937     int32_t ret = ServerIpcPublishLNN(pkgName, info);
938     if (ret != SOFTBUS_OK) {
939         LNN_LOGE(LNN_STATE, "Server PublishLNNInner failed, ret=%{public}d", ret);
940         return ret;
941     }
942     if (AddDiscPublishMsg(pkgName, info) != SOFTBUS_OK) {
943         LNN_LOGE(LNN_STATE, "add publish msg error");
944     }
945     return SOFTBUS_OK;
946 }
947 
StopPublishLNNInner(const char * pkgName,int32_t publishId)948 int32_t StopPublishLNNInner(const char *pkgName, int32_t publishId)
949 {
950     int32_t ret = ServerIpcStopPublishLNN(pkgName, publishId);
951     if (ret != SOFTBUS_OK) {
952         LNN_LOGE(LNN_STATE, "Server StopPublishLNNInner failed, ret=%{public}d", ret);
953         return ret;
954     }
955     if (DeleteDiscPublishMsg(pkgName, publishId) != SOFTBUS_OK) {
956         LNN_LOGE(LNN_STATE, "del publish msg error");
957     }
958     return SOFTBUS_OK;
959 }
960 
RefreshLNNInner(const char * pkgName,const SubscribeInfo * info,const IRefreshCallback * cb)961 int32_t RefreshLNNInner(const char *pkgName, const SubscribeInfo *info, const IRefreshCallback *cb)
962 {
963     g_busCenterClient.refreshCb = *cb;
964     int32_t ret = ServerIpcRefreshLNN(pkgName, info);
965     if (ret != SOFTBUS_OK) {
966         LNN_LOGE(LNN_STATE, "Server RefreshLNNInner failed, ret=%{public}d", ret);
967         return ret;
968     }
969     if (AddDiscSubscribeMsg(pkgName, info) != SOFTBUS_OK) {
970         LNN_LOGE(LNN_STATE, "add subscribe msg error");
971     }
972     return SOFTBUS_OK;
973 }
974 
StopRefreshLNNInner(const char * pkgName,int32_t refreshId)975 int32_t StopRefreshLNNInner(const char *pkgName, int32_t refreshId)
976 {
977     int32_t ret = ServerIpcStopRefreshLNN(pkgName, refreshId);
978     if (ret != SOFTBUS_OK) {
979         LNN_LOGE(LNN_STATE, "Server StopRefreshLNNInner failed, ret=%{public}d", ret);
980         return ret;
981     }
982     if (DeleteDiscSubscribeMsg(pkgName, refreshId) != SOFTBUS_OK) {
983         LNN_LOGE(LNN_STATE, "del subscribe msg error");
984     }
985     return SOFTBUS_OK;
986 }
987 
ActiveMetaNodeInner(const char * pkgName,const MetaNodeConfigInfo * info,char * metaNodeId)988 int32_t ActiveMetaNodeInner(const char *pkgName, const MetaNodeConfigInfo *info, char *metaNodeId)
989 {
990     return ServerIpcActiveMetaNode(pkgName, info, metaNodeId);
991 }
992 
DeactiveMetaNodeInner(const char * pkgName,const char * metaNodeId)993 int32_t DeactiveMetaNodeInner(const char *pkgName, const char *metaNodeId)
994 {
995     return ServerIpcDeactiveMetaNode(pkgName, metaNodeId);
996 }
997 
GetAllMetaNodeInfoInner(const char * pkgName,MetaNodeInfo * infos,int32_t * infoNum)998 int32_t GetAllMetaNodeInfoInner(const char *pkgName, MetaNodeInfo *infos, int32_t *infoNum)
999 {
1000     return ServerIpcGetAllMetaNodeInfo(pkgName, infos, infoNum);
1001 }
1002 
ShiftLNNGearInner(const char * pkgName,const char * callerId,const char * targetNetworkId,const GearMode * mode)1003 int32_t ShiftLNNGearInner(const char *pkgName, const char *callerId, const char *targetNetworkId, const GearMode *mode)
1004 {
1005     return ServerIpcShiftLNNGear(pkgName, callerId, targetNetworkId, mode);
1006 }
1007 
LnnOnJoinResult(void * addr,const char * networkId,int32_t retCode)1008 int32_t LnnOnJoinResult(void *addr, const char *networkId, int32_t retCode)
1009 {
1010     JoinLNNCbListItem *item = NULL;
1011     ConnectionAddr *connAddr = (ConnectionAddr *)addr;
1012 
1013     if (connAddr == NULL) {
1014         return SOFTBUS_INVALID_PARAM;
1015     }
1016     if (!g_busCenterClient.isInit) {
1017         return SOFTBUS_ERR;
1018     }
1019 
1020     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1021         LNN_LOGE(LNN_STATE, "lock join lnn cb list in join result");
1022         return SOFTBUS_LOCK_ERR;
1023     }
1024     while ((item = FindJoinLNNCbItem((ConnectionAddr *)addr, NULL)) != NULL) {
1025         ListDelete(&item->node);
1026         if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1027             LNN_LOGE(LNN_STATE, "unlock join lnn cb list in join result");
1028         }
1029         if (item->cb != NULL) {
1030             item->cb(connAddr, networkId, retCode);
1031         }
1032         SoftBusFree(item);
1033         if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1034             LNN_LOGE(LNN_STATE, "lock join lnn cb list in join result");
1035             return SOFTBUS_LOCK_ERR;
1036         }
1037     }
1038     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1039         LNN_LOGE(LNN_STATE, "unlock join lnn cb list in join result");
1040     }
1041     return SOFTBUS_OK;
1042 }
1043 
LnnOnLeaveResult(const char * networkId,int32_t retCode)1044 int32_t LnnOnLeaveResult(const char *networkId, int32_t retCode)
1045 {
1046     LeaveLNNCbListItem *item = NULL;
1047 
1048     if (networkId == NULL) {
1049         LNN_LOGE(LNN_STATE, "networkId is null");
1050         return SOFTBUS_INVALID_PARAM;
1051     }
1052     if (!g_busCenterClient.isInit) {
1053         LNN_LOGE(LNN_STATE, "leave cb not init");
1054         return SOFTBUS_ERR;
1055     }
1056 
1057     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1058         LNN_LOGE(LNN_STATE, "lock leave lnn cb list fail");
1059         return SOFTBUS_LOCK_ERR;
1060     }
1061     while ((item = FindLeaveLNNCbItem(networkId, NULL)) != NULL) {
1062         ListDelete(&item->node);
1063         if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1064             LNN_LOGE(LNN_STATE, "unlock leave lnn cb list fail");
1065         }
1066         if (item->cb != NULL) {
1067             item->cb(networkId, retCode);
1068         }
1069         SoftBusFree(item);
1070         if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1071             LNN_LOGE(LNN_STATE, "lock leave lnn cb list fail");
1072             return SOFTBUS_LOCK_ERR;
1073         }
1074     }
1075     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1076         LNN_LOGE(LNN_STATE, "unlock leave lnn cb list fail");
1077     }
1078     return SOFTBUS_OK;
1079 }
1080 
LnnOnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info)1081 int32_t LnnOnNodeOnlineStateChanged(const char *pkgName, bool isOnline, void *info)
1082 {
1083     NodeStateCallbackItem *item = NULL;
1084     NodeBasicInfo *basicInfo = (NodeBasicInfo *)info;
1085     ListNode dupList;
1086 
1087     if (basicInfo == NULL || pkgName == NULL) {
1088         return SOFTBUS_INVALID_PARAM;
1089     }
1090     if (!g_busCenterClient.isInit) {
1091         return SOFTBUS_ERR;
1092     }
1093 
1094     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1095         LNN_LOGE(LNN_STATE, "lock node state cb list in notify");
1096         return SOFTBUS_LOCK_ERR;
1097     }
1098     ListInit(&dupList);
1099     DuplicateNodeStateCbList(&dupList);
1100     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1101         LNN_LOGE(LNN_STATE, "unlock node state cb list in notify");
1102     }
1103     LIST_FOR_EACH_ENTRY(item, &dupList, NodeStateCallbackItem, node) {
1104         if (isOnline == true) {
1105             if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1106                 (item->cb.events & EVENT_NODE_STATE_ONLINE) != 0) {
1107                 item->cb.onNodeOnline(basicInfo);
1108             }
1109         } else {
1110             if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1111                 (item->cb.events & EVENT_NODE_STATE_OFFLINE) != 0) {
1112                 item->cb.onNodeOffline(basicInfo);
1113             }
1114         }
1115     }
1116     ClearNodeStateCbList(&dupList);
1117     return SOFTBUS_OK;
1118 }
1119 
LnnOnNodeBasicInfoChanged(const char * pkgName,void * info,int32_t type)1120 int32_t LnnOnNodeBasicInfoChanged(const char *pkgName, void *info, int32_t type)
1121 {
1122     NodeStateCallbackItem *item = NULL;
1123     NodeBasicInfo *basicInfo = (NodeBasicInfo *)info;
1124     ListNode dupList;
1125 
1126     if (basicInfo == NULL || pkgName == NULL) {
1127         LNN_LOGE(LNN_STATE, "info or pkgName is null");
1128         return SOFTBUS_INVALID_PARAM;
1129     }
1130     if (!g_busCenterClient.isInit) {
1131         return SOFTBUS_ERR;
1132     }
1133 
1134     if ((type < 0) || (type > TYPE_NETWORK_INFO)) {
1135         LNN_LOGE(LNN_STATE, "OnNodeBasicInfoChanged invalid type. type=%{public}d", type);
1136         return SOFTBUS_INVALID_PARAM;
1137     }
1138 
1139     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1140         LNN_LOGE(LNN_STATE, "lock node basic info cb list in notify");
1141     }
1142     ListInit(&dupList);
1143     DuplicateNodeStateCbList(&dupList);
1144     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1145         LNN_LOGE(LNN_STATE, "unlock node basic info cb list in notify");
1146     }
1147     LIST_FOR_EACH_ENTRY(item, &dupList, NodeStateCallbackItem, node) {
1148         if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1149             (item->cb.events & EVENT_NODE_STATE_INFO_CHANGED) != 0) {
1150             item->cb.onNodeBasicInfoChanged((NodeBasicInfoType)type, basicInfo);
1151         }
1152     }
1153     ClearNodeStateCbList(&dupList);
1154     return SOFTBUS_OK;
1155 }
1156 
LnnOnNodeStatusChanged(const char * pkgName,void * info,int32_t type)1157 int32_t LnnOnNodeStatusChanged(const char *pkgName, void *info, int32_t type)
1158 {
1159     if (pkgName == NULL || info == NULL) {
1160         LNN_LOGE(LNN_STATE, "pkgName or info is null");
1161         return SOFTBUS_INVALID_PARAM;
1162     }
1163     NodeStateCallbackItem *item = NULL;
1164     NodeStatus *nodeStatus = (NodeStatus *)info;
1165     ListNode dupList;
1166     if (!g_busCenterClient.isInit) {
1167         LNN_LOGE(LNN_STATE, "buscenter client not init");
1168         return SOFTBUS_NO_INIT;
1169     }
1170 
1171     if ((type < 0) || (type > TYPE_STATUS_MAX)) {
1172         LNN_LOGE(LNN_STATE, "LnnOnNodeStatusChanged invalid type. type=%{public}d", type);
1173         return SOFTBUS_INVALID_PARAM;
1174     }
1175 
1176     if (SoftBusMutexLock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1177         LNN_LOGE(LNN_STATE, "lock node status cb list in notify");
1178         return SOFTBUS_LOCK_ERR;
1179     }
1180     ListInit(&dupList);
1181     DuplicateNodeStateCbList(&dupList);
1182     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1183         LNN_LOGE(LNN_STATE, "unlock node status cb list in notify");
1184     }
1185     char *anonyPkgName = NULL;
1186     Anonymize(pkgName, &anonyPkgName);
1187     LNN_LOGI(LNN_STATE, "LnnOnNodeStatusChanged, pkgName=%{public}s, type=%{public}d, screen=%{public}d", anonyPkgName,
1188         type, nodeStatus->reserved[0]);
1189     LIST_FOR_EACH_ENTRY(item, &dupList, NodeStateCallbackItem, node) {
1190         if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1191             (item->cb.events & EVENT_NODE_STATUS_CHANGED) != 0 && item->cb.onNodeStatusChanged != NULL) {
1192             LNN_LOGI(LNN_STATE, "LnnOnNodeStatusChanged, pkgName=%{public}s, type=%{public}d, screen=%{public}d",
1193                 anonyPkgName, type, nodeStatus->reserved[0]);
1194             item->cb.onNodeStatusChanged((NodeStatusType)type, nodeStatus);
1195         }
1196     }
1197     AnonymizeFree(anonyPkgName);
1198     ClearNodeStateCbList(&dupList);
1199     return SOFTBUS_OK;
1200 }
1201 
LnnOnLocalNetworkIdChanged(const char * pkgName)1202 int32_t LnnOnLocalNetworkIdChanged(const char *pkgName)
1203 {
1204     NodeStateCallbackItem *item = NULL;
1205     ListNode dupList;
1206 
1207     if (pkgName == NULL) {
1208         LNN_LOGE(LNN_STATE, "info or pkgName is null");
1209         return SOFTBUS_INVALID_PARAM;
1210     }
1211     if (!g_busCenterClient.isInit) {
1212         LNN_LOGE(LNN_STATE, "buscenter client not init");
1213         return SOFTBUS_NO_INIT;
1214     }
1215 
1216     if (SoftBusMutexLock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1217         LNN_LOGE(LNN_STATE, "lock local networkId cb list in notify");
1218         return SOFTBUS_LOCK_ERR;
1219     }
1220     ListInit(&dupList);
1221     DuplicateNodeStateCbList(&dupList);
1222     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1223         LNN_LOGE(LNN_STATE, "unlock local networkId cb list in notify");
1224     }
1225     LIST_FOR_EACH_ENTRY(item, &dupList, NodeStateCallbackItem, node) {
1226         if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1227             (item->cb.onLocalNetworkIdChanged) != NULL) {
1228             item->cb.onLocalNetworkIdChanged();
1229         }
1230     }
1231     ClearNodeStateCbList(&dupList);
1232     return SOFTBUS_OK;
1233 }
1234 
LnnOnNodeDeviceNotTrusted(const char * pkgName,const char * msg)1235 int32_t LnnOnNodeDeviceNotTrusted(const char *pkgName, const char *msg)
1236 {
1237     NodeStateCallbackItem *item = NULL;
1238     ListNode dupList;
1239 
1240     if (pkgName == NULL) {
1241         LNN_LOGE(LNN_STATE, "pkgName is null");
1242         return SOFTBUS_INVALID_PARAM;
1243     }
1244     if (!g_busCenterClient.isInit) {
1245         LNN_LOGE(LNN_STATE, "buscenter client not init");
1246         return SOFTBUS_NO_INIT;
1247     }
1248 
1249     if (SoftBusMutexLock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1250         LNN_LOGE(LNN_STATE, "lock local cb list in notify");
1251         return SOFTBUS_LOCK_ERR;
1252     }
1253     ListInit(&dupList);
1254     DuplicateNodeStateCbList(&dupList);
1255     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1256         LNN_LOGE(LNN_STATE, "unlock local cb list in notify");
1257     }
1258     LIST_FOR_EACH_ENTRY(item, &dupList, NodeStateCallbackItem, node) {
1259         if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1260             (item->cb.onNodeDeviceNotTrusted) != NULL) {
1261             item->cb.onNodeDeviceNotTrusted(msg);
1262         }
1263     }
1264     ClearNodeStateCbList(&dupList);
1265     return SOFTBUS_OK;
1266 }
1267 
LnnOnHichainProofException(const char * pkgName,const char * proofInfo,uint32_t proofLen,uint16_t deviceTypeId,int32_t errCode)1268 int32_t LnnOnHichainProofException(
1269     const char *pkgName, const char *proofInfo, uint32_t proofLen, uint16_t deviceTypeId, int32_t errCode)
1270 {
1271     NodeStateCallbackItem *item = NULL;
1272     ListNode dupList;
1273 
1274     if (pkgName == NULL) {
1275         LNN_LOGE(LNN_STATE, "pkgName is null");
1276         return SOFTBUS_INVALID_PARAM;
1277     }
1278     if (!g_busCenterClient.isInit) {
1279         LNN_LOGE(LNN_STATE, "buscenter client not init");
1280         return SOFTBUS_NO_INIT;
1281     }
1282     if (SoftBusMutexLock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1283         LNN_LOGE(LNN_STATE, "lock auth restrict cb list in notify");
1284         return SOFTBUS_LOCK_ERR;
1285     }
1286     ListInit(&dupList);
1287     DuplicateNodeStateCbList(&dupList);
1288     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != SOFTBUS_OK) {
1289         LNN_LOGE(LNN_STATE, "unlock auth restrict cb list in notify");
1290     }
1291     LIST_FOR_EACH_ENTRY(item, &dupList, NodeStateCallbackItem, node) {
1292         if (((strcmp(item->pkgName, pkgName) == 0) || (strlen(pkgName) == 0)) &&
1293             (item->cb.events & EVENT_NODE_HICHAIN_PROOF_EXCEPTION) != 0 && item->cb.onHichainProofException != NULL) {
1294             item->cb.onHichainProofException(proofInfo, proofLen, deviceTypeId, errCode);
1295             char *anonyPkgName = NULL;
1296             char *anonyProofInfo = NULL;
1297             Anonymize(pkgName, &anonyPkgName);
1298             Anonymize(proofInfo, &anonyProofInfo);
1299             LNN_LOGI(LNN_STATE,
1300                 "onHichainProofException, pkgName=%{public}s, proofInfo=%{public}s, errCode=%{public}d, "
1301                 "type=%{public}hu",
1302                 AnonymizeWrapper(anonyPkgName), AnonymizeWrapper(anonyProofInfo), errCode, deviceTypeId);
1303             AnonymizeFree(anonyPkgName);
1304             AnonymizeFree(anonyProofInfo);
1305         }
1306     }
1307     ClearNodeStateCbList(&dupList);
1308     return SOFTBUS_OK;
1309 }
1310 
LnnOnTimeSyncResult(const void * info,int32_t retCode)1311 int32_t LnnOnTimeSyncResult(const void *info, int32_t retCode)
1312 {
1313     TimeSyncCallbackItem *item = NULL;
1314     TimeSyncResultInfo *basicInfo = (TimeSyncResultInfo *)info;
1315     ListNode dupList;
1316 
1317     if (info == NULL) {
1318         LNN_LOGE(LNN_STATE, "info or list is null");
1319         return SOFTBUS_INVALID_PARAM;
1320     }
1321     if (!g_busCenterClient.isInit) {
1322         LNN_LOGE(LNN_STATE, "time sync cb not init");
1323         return SOFTBUS_ERR;
1324     }
1325 
1326     if (SoftBusMutexLock(&g_busCenterClient.lock) != 0) {
1327         LNN_LOGE(LNN_STATE, "lock time sync cb list in time sync result");
1328         return SOFTBUS_LOCK_ERR;
1329     }
1330     ListInit(&dupList);
1331     DuplicateTimeSyncResultCbList(&dupList, basicInfo->target.targetNetworkId);
1332     if (SoftBusMutexUnlock(&g_busCenterClient.lock) != 0) {
1333         LNN_LOGE(LNN_STATE, "unlock time sync cb list in time sync result");
1334     }
1335     LIST_FOR_EACH_ENTRY(item, &dupList, TimeSyncCallbackItem, node) {
1336         if (item->cb.onTimeSyncResult != NULL) {
1337             item->cb.onTimeSyncResult((TimeSyncResultInfo *)info, retCode);
1338         }
1339     }
1340     ClearTimeSyncList(&dupList);
1341     return SOFTBUS_OK;
1342 }
1343 
LnnOnPublishLNNResult(int32_t publishId,int32_t reason)1344 void LnnOnPublishLNNResult(int32_t publishId, int32_t reason)
1345 {
1346     if (g_busCenterClient.publishCb.OnPublishResult != NULL) {
1347         g_busCenterClient.publishCb.OnPublishResult(publishId, (PublishResult)reason);
1348     }
1349 }
1350 
LnnOnRefreshLNNResult(int32_t refreshId,int32_t reason)1351 void LnnOnRefreshLNNResult(int32_t refreshId, int32_t reason)
1352 {
1353     if (g_busCenterClient.refreshCb.OnDiscoverResult != NULL) {
1354         g_busCenterClient.refreshCb.OnDiscoverResult(refreshId, (RefreshResult)reason);
1355     }
1356 }
1357 
LnnOnRefreshDeviceFound(const void * device)1358 void LnnOnRefreshDeviceFound(const void *device)
1359 {
1360     if (g_busCenterClient.refreshCb.OnDeviceFound != NULL) {
1361         g_busCenterClient.refreshCb.OnDeviceFound((const DeviceInfo *)device);
1362     }
1363 }
1364 
LnnOnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)1365 void LnnOnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
1366 {
1367     if (g_busCenterClient.dataLevelCb.onDataLevelChanged == NULL) {
1368         LNN_LOGW(LNN_STATE, "data level callback is null");
1369         return;
1370     }
1371     DataLevel dataLevel = {
1372         .dynamicLevel = dataLevelInfo->dynamicLevel,
1373         .staticLevel = dataLevelInfo->staticLevel,
1374         .switchLevel = dataLevelInfo->switchLevel,
1375         .switchLength = dataLevelInfo->switchLength
1376     };
1377     g_busCenterClient.dataLevelCb.onDataLevelChanged(networkId, dataLevel);
1378 }
1379 
DiscRecoveryPublish()1380 int32_t DiscRecoveryPublish()
1381 {
1382     if (!g_isInited) {
1383         LNN_LOGI(LNN_STATE, "no need recovery publish");
1384         return SOFTBUS_OK;
1385     }
1386     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_publishMsgList->lock)) == SOFTBUS_OK,
1387         SOFTBUS_LOCK_ERR, LNN_STATE, "lock failed");
1388 
1389     DiscPublishMsg *msgNode = NULL;
1390     int32_t ret = SOFTBUS_OK;
1391     LIST_FOR_EACH_ENTRY(msgNode, &(g_publishMsgList->list), DiscPublishMsg, node) {
1392         if (ServerIpcPublishLNN(msgNode->pkgName, msgNode->info) != SOFTBUS_OK) {
1393             LNN_LOGE(LNN_STATE, "recovery publish error, pkgName=%{public}s, capability=%{public}s",
1394                 msgNode->pkgName, msgNode->info->capability);
1395             ret = SOFTBUS_ERR;
1396         } else {
1397             LNN_LOGI(LNN_STATE, "recovery publish success, pkgName=%{public}s, capability=%{public}s",
1398                 msgNode->pkgName, msgNode->info->capability);
1399         }
1400     }
1401 
1402     (void)SoftBusMutexUnlock(&(g_publishMsgList->lock));
1403     return ret;
1404 }
1405 
DiscRecoverySubscribe()1406 int32_t DiscRecoverySubscribe()
1407 {
1408     if (!g_isInited) {
1409         LNN_LOGI(LNN_STATE, "no need recovery subscribe");
1410         return SOFTBUS_OK;
1411     }
1412     LNN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discoveryMsgList->lock)) == SOFTBUS_OK,
1413         SOFTBUS_LOCK_ERR, LNN_STATE, "lock failed");
1414 
1415     DiscSubscribeMsg *msgNode = NULL;
1416     int32_t ret = SOFTBUS_OK;
1417     LIST_FOR_EACH_ENTRY(msgNode, &(g_discoveryMsgList->list), DiscSubscribeMsg, node) {
1418         if (ServerIpcRefreshLNN(msgNode->pkgName, msgNode->info) != SOFTBUS_OK) {
1419             LNN_LOGE(LNN_STATE, "recovery subscribe error, pkgName=%{public}s, capability=%{public}s",
1420                 msgNode->pkgName, msgNode->info->capability);
1421             ret = SOFTBUS_ERR;
1422         } else {
1423             LNN_LOGI(LNN_STATE, "recovery subscribe success, pkgName=%{public}s, capability=%{public}s",
1424                 msgNode->pkgName, msgNode->info->capability);
1425         }
1426     }
1427 
1428     (void)SoftBusMutexUnlock(&(g_discoveryMsgList->lock));
1429     return ret;
1430 }
1431