1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "softbus_conn_manager.h"
17 
18 #include <securec.h>
19 #include <stdatomic.h>
20 
21 #include "common_list.h"
22 #include "conn_event.h"
23 #include "conn_log.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_adapter_thread.h"
26 #include "softbus_base_listener.h"
27 #include "softbus_conn_ble_manager.h"
28 #include "softbus_conn_br_manager.h"
29 #include "softbus_conn_interface.h"
30 #include "softbus_datahead_transform.h"
31 #include "softbus_def.h"
32 #include "softbus_errcode.h"
33 #include "softbus_feature_config.h"
34 #include "softbus_socket.h"
35 #include "softbus_tcp_connect_manager.h"
36 #include "softbus_utils.h"
37 
38 ConnectFuncInterface *g_connManager[CONNECT_TYPE_MAX] = { 0 };
39 static SoftBusList *g_listenerList = NULL;
40 static _Atomic bool g_isInited = false;
41 #define SEC_TIME 1000LL
42 
43 typedef struct TagConnListenerNode {
44     ListNode node;
45     ConnModule moduleId;
46     ConnectCallback callback;
47 } ConnListenerNode;
48 
ModuleCheck(ConnModule moduleId)49 static int32_t ModuleCheck(ConnModule moduleId)
50 {
51     ConnModule id[] = { MODULE_TRUST_ENGINE, MODULE_HICHAIN, MODULE_AUTH_SDK, MODULE_AUTH_CONNECTION,
52         MODULE_MESSAGE_SERVICE, MODULE_AUTH_CHANNEL, MODULE_AUTH_MSG, MODULE_BLUETOOTH_MANAGER, MODULE_CONNECTION,
53         MODULE_DIRECT_CHANNEL, MODULE_PROXY_CHANNEL, MODULE_DEVICE_AUTH, MODULE_P2P_LINK, MODULE_UDP_INFO,
54         MODULE_PKG_VERIFY, MODULE_META_AUTH, MODULE_P2P_NEGO, MODULE_BLE_NET, MODULE_BLE_CONN };
55     int32_t i;
56     int32_t idNum = sizeof(id) / sizeof(ConnModule);
57 
58     for (i = 0; i < idNum; i++) {
59         if (moduleId == id[i]) {
60             return SOFTBUS_OK;
61         }
62     }
63     CONN_LOGW(CONN_COMMON, "check module fail. moduleId=%{public}d", moduleId);
64     return SOFTBUS_CONN_INTERNAL_ERR;
65 }
66 
ConnTypeCheck(ConnectType type)67 static int32_t ConnTypeCheck(ConnectType type)
68 {
69     if (type >= CONNECT_TYPE_MAX) {
70         CONN_LOGW(CONN_COMMON, "type is over max. type=%{public}d", type);
71         return SOFTBUS_CONN_INVALID_CONN_TYPE;
72     }
73 
74     if (g_connManager[type] == NULL) {
75         CONN_LOGD(CONN_COMMON, "type=%{public}d", type);
76         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
77     }
78     return SOFTBUS_OK;
79 }
80 
GetAllListener(ConnListenerNode ** node)81 static int32_t GetAllListener(ConnListenerNode **node)
82 {
83     ConnListenerNode *listenerNode = NULL;
84     int32_t cnt = 0;
85 
86     if (g_listenerList == NULL) {
87         CONN_LOGE(CONN_COMMON, "listener list is null");
88         return cnt;
89     }
90 
91     if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
92         CONN_LOGE(CONN_COMMON, "lock mutex failed");
93         return 0;
94     }
95 
96     if (g_listenerList->cnt == 0) {
97         CONN_LOGE(CONN_COMMON, "listener cnt is null");
98         (void)SoftBusMutexUnlock(&g_listenerList->lock);
99         return cnt;
100     }
101 
102     *node = SoftBusCalloc(g_listenerList->cnt * sizeof(ConnListenerNode));
103     if (*node == NULL) {
104         CONN_LOGE(CONN_COMMON, "malloc failed");
105         (void)SoftBusMutexUnlock(&g_listenerList->lock);
106         return cnt;
107     }
108     LIST_FOR_EACH_ENTRY(listenerNode, &g_listenerList->list, ConnListenerNode, node) {
109         if (memcpy_s(*node + cnt, sizeof(ConnListenerNode), listenerNode, sizeof(ConnListenerNode)) != EOK) {
110             CONN_LOGE(CONN_COMMON, "mem error");
111             continue;
112         }
113         cnt++;
114     }
115     (void)SoftBusMutexUnlock(&g_listenerList->lock);
116     return cnt;
117 }
118 
GetListenerByModuleId(ConnModule moduleId,ConnListenerNode * node)119 static int32_t GetListenerByModuleId(ConnModule moduleId, ConnListenerNode *node)
120 {
121     ConnListenerNode *listenerNode = NULL;
122 
123     if (g_listenerList == NULL) {
124         CONN_LOGE(CONN_COMMON, "listener list is null");
125         return SOFTBUS_INVALID_PARAM;
126     }
127     int ret = SOFTBUS_OK;
128     if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
129         CONN_LOGE(CONN_COMMON, "lock mutex failed");
130         return SOFTBUS_LOCK_ERR;
131     }
132     LIST_FOR_EACH_ENTRY(listenerNode, &g_listenerList->list, ConnListenerNode, node) {
133         if (listenerNode->moduleId == moduleId) {
134             if (memcpy_s(node, sizeof(ConnListenerNode), listenerNode, sizeof(ConnListenerNode)) != EOK) {
135                 ret = SOFTBUS_MEM_ERR;
136             }
137             (void)SoftBusMutexUnlock(&g_listenerList->lock);
138             return ret;
139         }
140     }
141     (void)SoftBusMutexUnlock(&g_listenerList->lock);
142     return SOFTBUS_CONN_INTERNAL_ERR;
143 }
144 
AddListener(ConnModule moduleId,const ConnectCallback * callback)145 static int32_t AddListener(ConnModule moduleId, const ConnectCallback *callback)
146 {
147     ConnListenerNode *item = NULL;
148     ConnListenerNode *listNode = NULL;
149 
150     if (g_listenerList == NULL) {
151         CONN_LOGE(CONN_COMMON, "listener list is null");
152         return SOFTBUS_INVALID_PARAM;
153     }
154     if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
155         CONN_LOGE(CONN_COMMON, "lock mutex failed");
156         return SOFTBUS_LOCK_ERR;
157     }
158     LIST_FOR_EACH_ENTRY(listNode, &g_listenerList->list, ConnListenerNode, node) {
159         if (listNode->moduleId == moduleId) {
160             (void)SoftBusMutexUnlock(&g_listenerList->lock);
161             return SOFTBUS_CONN_INTERNAL_ERR;
162         }
163     }
164     item = (ConnListenerNode *)SoftBusCalloc(sizeof(ConnListenerNode));
165     if (item == NULL) {
166         CONN_LOGE(CONN_COMMON, "malloc failed");
167         (void)SoftBusMutexUnlock(&g_listenerList->lock);
168         return SOFTBUS_MALLOC_ERR;
169     }
170     item->moduleId = moduleId;
171     item->callback = *callback;
172 
173     ListAdd(&(g_listenerList->list), &(item->node));
174     g_listenerList->cnt++;
175     (void)SoftBusMutexUnlock(&g_listenerList->lock);
176     return SOFTBUS_OK;
177 }
178 
DelListener(ConnModule moduleId)179 static void DelListener(ConnModule moduleId)
180 {
181     ConnListenerNode *removeNode = NULL;
182     if (g_listenerList == NULL) {
183         CONN_LOGE(CONN_COMMON, "listenerList is null");
184         return;
185     }
186 
187     if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
188         CONN_LOGE(CONN_COMMON, "lock mutex failed");
189         return;
190     }
191 
192     LIST_FOR_EACH_ENTRY(removeNode, &g_listenerList->list, ConnListenerNode, node) {
193         if (removeNode->moduleId == moduleId) {
194             ListDelete(&(removeNode->node));
195             SoftBusFree(removeNode);
196             g_listenerList->cnt--;
197             break;
198         }
199     }
200     (void)SoftBusMutexUnlock(&g_listenerList->lock);
201     return;
202 }
203 
ConnGetHeadSize(void)204 uint32_t ConnGetHeadSize(void)
205 {
206     return sizeof(ConnPktHead);
207 }
208 
209 SoftBusMutex g_ReqLock;
210 static uint32_t g_ReqId = 1;
211 
ConnGetNewRequestId(ConnModule moduleId)212 uint32_t ConnGetNewRequestId(ConnModule moduleId)
213 {
214 #define REQID_MAX 1000000
215     (void)moduleId;
216     CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_ReqLock) == SOFTBUS_OK, g_ReqId, CONN_COMMON, "lock failed");
217     g_ReqId++;
218     g_ReqId = g_ReqId % REQID_MAX + 1;
219 
220     uint32_t reqId = g_ReqId;
221     (void)SoftBusMutexUnlock(&g_ReqLock);
222     return reqId;
223 }
224 
ConnManagerRecvData(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)225 void ConnManagerRecvData(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
226 {
227     CONN_CHECK_AND_RETURN_LOGW(data != NULL, CONN_COMMON,
228         "dispatch data failed: data is null, connectionId=%{public}u, module=%{public}d", connectionId, moduleId);
229     CONN_CHECK_AND_RETURN_LOGW(len > (int32_t)sizeof(ConnPktHead), CONN_COMMON,
230         "dispatch data failed: dataLen=%{public}d < connection header size, "
231         "connectionId=%{public}u, module=%{public}d", len, connectionId, moduleId);
232 
233     ConnListenerNode listener = { 0 };
234     int32_t status = GetListenerByModuleId(moduleId, &listener);
235     CONN_CHECK_AND_RETURN_LOGW(status == SOFTBUS_OK, CONN_COMMON,
236         "dispatch data failed: get module listener failed or not register, "
237         "connectionId=%{public}u, module=%{public}d, dataLen=%{public}d, err=%{public}d",
238         connectionId, moduleId, len, status);
239 
240     int32_t pktLen = len - (int32_t)sizeof(ConnPktHead);
241     char *pkt = data + sizeof(ConnPktHead);
242     listener.callback.OnDataReceived(connectionId, moduleId, seq, pkt, pktLen);
243 }
244 
ConnManagerConnected(uint32_t connectionId,const ConnectionInfo * info)245 void ConnManagerConnected(uint32_t connectionId, const ConnectionInfo *info)
246 {
247     ConnListenerNode *node = NULL;
248     ConnListenerNode *listener = NULL;
249 
250     int32_t num = GetAllListener(&node);
251     if (num == 0 || node == NULL) {
252         CONN_LOGE(CONN_COMMON, "get node failed, connId=%{public}u", connectionId);
253         SoftBusFree(node);
254         return;
255     }
256 
257     for (int32_t i = 0; i < num; i++) {
258         listener = node + i;
259         listener->callback.OnConnected(connectionId, info);
260     }
261     SoftBusFree(node);
262     return;
263 }
264 
ConnManagerReusedConnected(uint32_t connectionId,const ConnectionInfo * info)265 void ConnManagerReusedConnected(uint32_t connectionId, const ConnectionInfo *info)
266 {
267     ConnListenerNode *node = NULL;
268     ConnListenerNode *listener = NULL;
269 
270     int32_t num = GetAllListener(&node);
271     if (num == 0 || node == NULL) {
272         CONN_LOGE(CONN_COMMON, "get node failed, connId=%{public}u", connectionId);
273         SoftBusFree(node);
274         return;
275     }
276 
277     for (int32_t i = 0; i < num; i++) {
278         listener = node + i;
279         if (listener->callback.OnReusedConnected != NULL) {
280             listener->callback.OnReusedConnected(connectionId, info);
281         }
282     }
283     SoftBusFree(node);
284     return;
285 }
286 
ConnManagerDisconnected(uint32_t connectionId,const ConnectionInfo * info)287 void ConnManagerDisconnected(uint32_t connectionId, const ConnectionInfo *info)
288 {
289     ConnListenerNode *node = NULL;
290     ConnListenerNode *listener = NULL;
291 
292     int32_t num = GetAllListener(&node);
293     if (num == 0 || node == NULL) {
294         CONN_LOGE(CONN_COMMON, "get node failed, connId=%{public}u", connectionId);
295         SoftBusFree(node);
296         return;
297     }
298     for (int32_t i = 0; i < num; i++) {
299         listener = node + i;
300         listener->callback.OnDisconnected(connectionId, info);
301     }
302     SoftBusFree(node);
303     return;
304 }
305 
ConnSetConnectCallback(ConnModule moduleId,const ConnectCallback * callback)306 int32_t ConnSetConnectCallback(ConnModule moduleId, const ConnectCallback *callback)
307 {
308     if (ModuleCheck(moduleId) != SOFTBUS_OK) {
309         CONN_LOGE(CONN_COMMON, "module check failed, moduleId=%{public}d", moduleId);
310         return SOFTBUS_INVALID_PARAM;
311     }
312 
313     if (callback == NULL) {
314         CONN_LOGE(CONN_COMMON, "callback is null");
315         return SOFTBUS_INVALID_PARAM;
316     }
317 
318     if ((callback->OnConnected == NULL) || (callback->OnDisconnected == NULL) || (callback->OnDataReceived == NULL)) {
319         CONN_LOGE(CONN_COMMON, "callback member is null");
320         return SOFTBUS_INVALID_PARAM;
321     }
322     return AddListener(moduleId, callback);
323 }
324 
ConnUnSetConnectCallback(ConnModule moduleId)325 void ConnUnSetConnectCallback(ConnModule moduleId)
326 {
327     DelListener(moduleId);
328     return;
329 }
330 
ConnTypeIsSupport(ConnectType type)331 int32_t ConnTypeIsSupport(ConnectType type)
332 {
333     return ConnTypeCheck(type);
334 }
335 
ConnConnectDevice(const ConnectOption * info,uint32_t requestId,const ConnectResult * result)336 int32_t ConnConnectDevice(const ConnectOption *info, uint32_t requestId, const ConnectResult *result)
337 {
338     if (info == NULL) {
339         return SOFTBUS_INVALID_PARAM;
340     }
341 
342     if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
343         CONN_LOGW(CONN_COMMON, "connect type is err. type=%{public}d", info->type);
344         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
345     }
346 
347     if (g_connManager[info->type]->ConnectDevice == NULL) {
348         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
349     }
350     ConnEventExtra extra = {
351         .requestId = requestId,
352         .linkType = info->type,
353         .result = EVENT_STAGE_RESULT_OK
354     };
355     if (info->type == CONNECT_BR) {
356         extra.peerBrMac = info->brOption.brMac;
357     }
358     if (info->type == CONNECT_BLE) {
359         extra.peerBleMac = info->bleOption.bleMac;
360         extra.connProtocol = info->bleOption.protocol;
361     }
362     if (info->type == CONNECT_TCP) {
363         extra.peerWifiMac = info->socketOption.addr;
364     }
365     CONN_EVENT(EVENT_SCENE_CONNECT, EVENT_STAGE_CONNECT_START, extra);
366     return g_connManager[info->type]->ConnectDevice(info, requestId, result);
367 }
368 
ConnGetTypeByConnectionId(uint32_t connectionId,ConnectType * type)369 int32_t ConnGetTypeByConnectionId(uint32_t connectionId, ConnectType *type)
370 {
371     CONN_CHECK_AND_RETURN_RET_LOGW(type != NULL, SOFTBUS_INVALID_PARAM, CONN_COMMON, "param error");
372 
373     ConnectType temp;
374     temp = (connectionId >> CONNECT_TYPE_SHIFT);
375     if (ConnTypeCheck(temp) != SOFTBUS_OK) {
376         CONN_LOGE(CONN_COMMON, "connectionId type is err. type=%{public}u", temp);
377         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
378     }
379     *type = temp;
380     return SOFTBUS_OK;
381 }
382 
ConnPostBytes(uint32_t connectionId,ConnPostData * data)383 int32_t ConnPostBytes(uint32_t connectionId, ConnPostData *data)
384 {
385     ConnectType type;
386     ConnPktHead *head = NULL;
387 
388     if (data == NULL || data->buf == NULL) {
389         return SOFTBUS_INVALID_PARAM;
390     }
391 
392     if (data->len <= sizeof(ConnPktHead) || data->len > INT32_MAX) {
393         SoftBusFree(data->buf);
394         return SOFTBUS_CONN_MANAGER_PKT_LEN_INVALID;
395     }
396 
397     if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
398         SoftBusFree(data->buf);
399         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
400     }
401 
402     if (g_connManager[type]->PostBytes == NULL) {
403         SoftBusFree(data->buf);
404         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
405     }
406 
407     head = (ConnPktHead *)data->buf;
408     head->magic = MAGIC_NUMBER;
409     head->flag = data->flag;
410     head->module = data->module;
411     head->len = data->len - sizeof(ConnPktHead);
412     head->seq = data->seq;
413     PackConnPktHead(head);
414     return g_connManager[type]->PostBytes(
415         connectionId, (uint8_t *)data->buf, data->len, data->pid, data->flag, data->module, data->seq);
416 }
417 
ConnDisconnectDevice(uint32_t connectionId)418 int32_t ConnDisconnectDevice(uint32_t connectionId)
419 {
420     ConnectType type;
421     if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
422         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
423     }
424 
425     if (g_connManager[type]->DisconnectDevice == NULL) {
426         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
427     }
428     return g_connManager[type]->DisconnectDevice(connectionId);
429 }
430 
ConnDisconnectDeviceAllConn(const ConnectOption * option)431 int32_t ConnDisconnectDeviceAllConn(const ConnectOption *option)
432 {
433     if (option == NULL) {
434         return SOFTBUS_INVALID_PARAM;
435     }
436 
437     if (ConnTypeCheck(option->type) != SOFTBUS_OK) {
438         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
439     }
440 
441     if (g_connManager[option->type]->DisconnectDeviceNow == NULL) {
442         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
443     }
444     return g_connManager[option->type]->DisconnectDeviceNow(option);
445 }
446 
ConnGetConnectionInfo(uint32_t connectionId,ConnectionInfo * info)447 int32_t ConnGetConnectionInfo(uint32_t connectionId, ConnectionInfo *info)
448 {
449     ConnectType type;
450     if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
451         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
452     }
453 
454     if (g_connManager[type]->GetConnectionInfo == NULL) {
455         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
456     }
457 
458     return g_connManager[type]->GetConnectionInfo(connectionId, info);
459 }
460 
ConnStartLocalListening(const LocalListenerInfo * info)461 int32_t ConnStartLocalListening(const LocalListenerInfo *info)
462 {
463     if (info == NULL) {
464         return SOFTBUS_INVALID_PARAM;
465     }
466 
467     if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
468         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
469     }
470 
471     if (g_connManager[info->type]->StartLocalListening == NULL) {
472         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
473     }
474 
475     return g_connManager[info->type]->StartLocalListening(info);
476 }
477 
ConnStopLocalListening(const LocalListenerInfo * info)478 int32_t ConnStopLocalListening(const LocalListenerInfo *info)
479 {
480     if (info == NULL) {
481         return SOFTBUS_INVALID_PARAM;
482     }
483 
484     if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
485         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
486     }
487 
488     if (g_connManager[info->type]->StopLocalListening == NULL) {
489         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
490     }
491 
492     return g_connManager[info->type]->StopLocalListening(info);
493 }
494 
495 ConnectCallback g_connManagerCb = { 0 };
496 
ConnSocketsAndBaseListenerInit(void)497 static int32_t ConnSocketsAndBaseListenerInit(void)
498 {
499     if (atomic_load_explicit(&g_isInited, memory_order_acquire)) {
500         return SOFTBUS_CONN_INTERNAL_ERR;
501     }
502 
503     int32_t ret = ConnInitSockets();
504     if (ret != SOFTBUS_OK) {
505         CONN_LOGE(CONN_INIT, "ConnInitSockets failed! ret=%{public}" PRId32 " \r\n", ret);
506         return ret;
507     }
508 
509     ret = InitBaseListener();
510     if (ret != SOFTBUS_OK) {
511         CONN_LOGE(CONN_INIT, "InitBaseListener failed! ret=%{public}" PRId32 " \r\n", ret);
512         return ret;
513     }
514     return SOFTBUS_OK;
515 }
516 
ConnServerInit(void)517 int32_t ConnServerInit(void)
518 {
519     int32_t ret = ConnSocketsAndBaseListenerInit();
520     CONN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, CONN_COMMON, "init failed.");
521     g_connManagerCb.OnConnected = ConnManagerConnected;
522     g_connManagerCb.OnReusedConnected = ConnManagerReusedConnected;
523     g_connManagerCb.OnDisconnected = ConnManagerDisconnected;
524     g_connManagerCb.OnDataReceived = ConnManagerRecvData;
525     int isSupportTcp = 0;
526     ConnectFuncInterface *connectObj = NULL;
527     (void)SoftbusGetConfig(SOFTBUS_INT_SUPPORT_TCP_PROXY, (unsigned char *)&isSupportTcp, sizeof(isSupportTcp));
528     if (isSupportTcp) {
529         connectObj = ConnInitTcp(&g_connManagerCb);
530         if (connectObj != NULL) {
531             g_connManager[CONNECT_TCP] = connectObj;
532             CONN_LOGD(CONN_COMMON, "init tcp ok");
533         }
534     }
535 
536     connectObj = ConnInitBr(&g_connManagerCb);
537     if (connectObj != NULL) {
538         g_connManager[CONNECT_BR] = connectObj;
539         CONN_LOGD(CONN_COMMON, "init br ok");
540     }
541 
542     connectObj = ConnInitBle(&g_connManagerCb);
543     if (connectObj != NULL) {
544         g_connManager[CONNECT_BLE] = connectObj;
545         CONN_LOGD(CONN_COMMON, "init ble ok");
546     }
547 
548     if (g_listenerList == NULL) {
549         g_listenerList = CreateSoftBusList();
550         if (g_listenerList == NULL) {
551             CONN_LOGE(CONN_COMMON, "create list failed");
552             return SOFTBUS_CREATE_LIST_ERR;
553         }
554     }
555     CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexInit(&g_ReqLock, NULL) == SOFTBUS_OK,
556         SOFTBUS_CONN_INTERNAL_ERR, CONN_COMMON, "g_ReqLock init lock failed.");
557 
558     atomic_store_explicit(&g_isInited, true, memory_order_release);
559     CONN_LOGI(CONN_COMMON, "connect manager init success.");
560     return SOFTBUS_OK;
561 }
562 
ConnServerDeinit(void)563 void ConnServerDeinit(void)
564 {
565     if (!atomic_load_explicit(&g_isInited, memory_order_acquire)) {
566         return;
567     }
568 
569     ConnListenerNode *item = NULL;
570     if (g_listenerList != NULL) {
571         while (!IsListEmpty(&g_listenerList->list)) {
572             item = LIST_ENTRY((&g_listenerList->list)->next, ConnListenerNode, node);
573             ListDelete(&item->node);
574             SoftBusFree(item);
575         }
576         DestroySoftBusList(g_listenerList);
577         g_listenerList = NULL;
578     }
579 
580     DeinitBaseListener();
581     SoftBusMutexDestroy(&g_ReqLock);
582 
583     atomic_store_explicit(&g_isInited, false, memory_order_release);
584 }
585 
CheckActiveConnection(const ConnectOption * info,bool needOccupy)586 bool CheckActiveConnection(const ConnectOption *info, bool needOccupy)
587 {
588     if (info == NULL) {
589         return false;
590     }
591 
592     if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
593         CONN_LOGE(CONN_COMMON, "connect type is err. type=%{public}d", info->type);
594         return false;
595     }
596 
597     if (g_connManager[info->type]->CheckActiveConnection == NULL) {
598         return false;
599     }
600 
601     return g_connManager[info->type]->CheckActiveConnection(info, needOccupy);
602 }
603 
ConnUpdateConnection(uint32_t connectionId,UpdateOption * option)604 int32_t ConnUpdateConnection(uint32_t connectionId, UpdateOption *option)
605 {
606     if (option == NULL) {
607         return SOFTBUS_INVALID_PARAM;
608     }
609 
610     ConnectType type;
611     if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
612         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
613     }
614     if (g_connManager[type]->UpdateConnection == NULL) {
615         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
616     }
617     return g_connManager[type]->UpdateConnection(connectionId, option);
618 }
619 
ConnPreventConnection(const ConnectOption * option,uint32_t time)620 int32_t ConnPreventConnection(const ConnectOption *option, uint32_t time)
621 {
622     if (option == NULL) {
623         return SOFTBUS_INVALID_PARAM;
624     }
625 
626     if (ConnTypeCheck(option->type) != SOFTBUS_OK) {
627         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
628     }
629 
630     if (g_connManager[option->type]->PreventConnection == NULL) {
631         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
632     }
633     return g_connManager[option->type]->PreventConnection(option, time);
634 }
635 
ConnConfigPostLimit(const LimitConfiguration * configuration)636 int32_t ConnConfigPostLimit(const LimitConfiguration *configuration)
637 {
638     if (configuration == NULL) {
639         return SOFTBUS_INVALID_PARAM;
640     }
641 
642     if (ConnTypeCheck(configuration->type) != SOFTBUS_OK) {
643         return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
644     }
645 
646     if (g_connManager[configuration->type]->ConfigPostLimit == NULL) {
647         return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
648     }
649     return g_connManager[configuration->type]->ConfigPostLimit(configuration);
650 }