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