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