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_br_manager.h"
17
18 #include <securec.h>
19
20 #include "bus_center_decision_center.h"
21 #include "conn_event.h"
22 #include "conn_log.h"
23 #include "lnn_node_info.h"
24 #include "message_handler.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_adapter_timer.h"
27 #include "softbus_conn_ble_manager.h"
28 #include "softbus_conn_br_pending_packet.h"
29 #include "softbus_conn_br_trans.h"
30 #include "softbus_conn_common.h"
31 #include "softbus_json_utils.h"
32 #include "softbus_utils.h"
33
34 enum BrServerState {
35 BR_STATE_AVAILABLE,
36 BR_STATE_CONNECTING,
37 BR_STATE_MAX,
38 };
39
40 enum BrMgrLooperMsg {
41 MSG_NEXT_CMD,
42 MSG_CONNECT_REQUEST,
43 MSG_CONNECT_SUCCESS,
44 MSG_CONNECT_TIMEOUT,
45 MSG_CONNECT_FAIL,
46 MSG_SERVER_ACCEPTED,
47 MSG_DATA_RECEIVED,
48 MSG_CONNECTION_EXECEPTION,
49 MSG_CONNECTION_RESUME,
50 MGR_DISCONNECT_REQUEST,
51 MSG_UNPEND,
52 MSG_RESET,
53 };
54
55 typedef struct {
56 uint32_t connectionId;
57 int32_t error;
58 } ErrorContext;
59
60 typedef struct {
61 ListNode node;
62 char addr[BT_MAC_LEN];
63 ConnBrPendInfo *pendInfo;
64 } BrPending;
65
66 typedef struct {
67 SoftBusList *connections;
68 ConnBrState *state;
69 ListNode waitings;
70 SoftBusList *pendings;
71 ConnBrDevice *connecting;
72 } ConnBrManager;
73
74 typedef int32_t (*DeviceAction)(ConnBrDevice *device, const char *anomizeAddress);
75 static void TransitionToState(enum BrServerState target);
76 static void ReceivedControlData(ConnBrConnection *connection, const uint8_t *data, uint32_t dataLen);
77 static void BrManagerMsgHandler(SoftBusMessage *msg);
78 static int BrCompareManagerLooperEventFunc(const SoftBusMessage *msg, void *args);
79 static int32_t PendingDevice(ConnBrDevice *device, const char *anomizeAddress);
80 static int32_t BrPendConnection(const ConnectOption *option, uint32_t time);
81 static void ProcessAclCollisionException(ConnBrDevice *device, const char *anomizeAddress, uint32_t duration);
82 static void UnpendConnection(const char *addr);
83
84 static ConnBrManager g_brManager = { 0 };
85 static ConnectCallback g_connectCallback = { 0 };
86 static SoftBusHandlerWrapper g_brManagerAsyncHandler = {
87 .handler = {
88 .name = (char *)"BrManagerAsyncHandler",
89 .HandleMessage = BrManagerMsgHandler,
90 // assign when initiation
91 .looper = NULL,
92
93 },
94 .eventCompareFunc = BrCompareManagerLooperEventFunc,
95 };
96
97 static bool g_brStateTurnOn;
98
NipRecvDataFromBr(uint32_t connId,const char * buf,int32_t len)99 void __attribute__((weak)) NipRecvDataFromBr(uint32_t connId, const char *buf, int32_t len)
100 {
101 (void)connId;
102 (void)buf;
103 }
104
NipConnectDevice(uint32_t connId,const char * mac)105 void __attribute__((weak)) NipConnectDevice(uint32_t connId, const char *mac)
106 {
107 (void)connId;
108 (void)mac;
109 }
110
NipDisconnectDevice(uint32_t connId)111 void __attribute__((weak)) NipDisconnectDevice(uint32_t connId)
112 {
113 (void)connId;
114 }
115
DfxRecordBrConnectFail(uint32_t reqId,uint32_t pId,ConnBrDevice * device,const ConnectStatistics * statistics,int32_t reason)116 static void DfxRecordBrConnectFail(
117 uint32_t reqId, uint32_t pId, ConnBrDevice *device, const ConnectStatistics *statistics, int32_t reason)
118 {
119 if (statistics == NULL) {
120 CONN_LOGW(CONN_BR, "statistics is null");
121 return;
122 }
123
124 CONN_LOGD(CONN_BR, "traceId=%{public}u, reason=%{public}d", statistics->connectTraceId, reason);
125 uint64_t costTime = SoftBusGetSysTimeMs() - statistics->startTime;
126 SoftbusRecordConnResult(pId, SOFTBUS_HISYSEVT_CONN_TYPE_BR, SOFTBUS_EVT_CONN_FAIL, costTime, reason);
127 ConnEventExtra extra = { .requestId = reqId,
128 .linkType = CONNECT_BR,
129 .costTime = costTime,
130 .errcode = reason,
131 .result = EVENT_STAGE_RESULT_FAILED };
132 if (device != NULL) {
133 extra.peerBrMac = device->addr;
134 }
135 CONN_EVENT(EVENT_SCENE_CONNECT, EVENT_STAGE_CONNECT_END, extra);
136 }
137
DfxRecordBrConnectSuccess(uint32_t pId,ConnBrConnection * connection,ConnectStatistics * statistics)138 static void DfxRecordBrConnectSuccess(uint32_t pId, ConnBrConnection *connection, ConnectStatistics *statistics)
139 {
140 if (statistics == NULL) {
141 CONN_LOGW(CONN_BR, "statistics is null");
142 return;
143 }
144
145 CONN_LOGD(CONN_BR, "traceId=%{public}u", statistics->connectTraceId);
146 uint64_t costTime = SoftBusGetSysTimeMs() - statistics->startTime;
147 SoftbusRecordConnResult(
148 pId, SOFTBUS_HISYSEVT_CONN_TYPE_BR, SOFTBUS_EVT_CONN_SUCC, costTime, SOFTBUS_HISYSEVT_CONN_OK);
149 ConnEventExtra extra = { .requestId = statistics->reqId,
150 .connectionId = connection->connectionId,
151 .peerBrMac = connection->addr,
152 .linkType = CONNECT_BR,
153 .costTime = costTime,
154 .isReuse = statistics->reuse ? 1 : 0,
155 .result = EVENT_STAGE_RESULT_OK
156 };
157 CONN_EVENT(EVENT_SCENE_CONNECT, EVENT_STAGE_CONNECT_END, extra);
158 }
159
NewDevice(ConnBrDevice ** outDevice,const char * addr)160 static int32_t NewDevice(ConnBrDevice **outDevice, const char *addr)
161 {
162 ConnBrDevice *device = (ConnBrDevice *)SoftBusCalloc(sizeof(ConnBrDevice));
163 if (device == NULL) {
164 return SOFTBUS_MALLOC_ERR;
165 }
166 ListInit(&device->node);
167 if (memcpy_s(device->addr, BT_MAC_LEN, addr, BT_MAC_LEN) != EOK) {
168 SoftBusFree(device);
169 return SOFTBUS_MEM_ERR;
170 }
171 device->state = BR_DEVICE_STATE_INIT;
172 ListInit(&device->requests);
173 *outDevice = device;
174 return SOFTBUS_OK;
175 }
176
FreeDevice(ConnBrDevice * device)177 static void FreeDevice(ConnBrDevice *device)
178 {
179 ConnBrRequest *it = NULL;
180 ConnBrRequest *next = NULL;
181 LIST_FOR_EACH_ENTRY_SAFE(it, next, &device->requests, ConnBrRequest, node) {
182 ListDelete(&it->node);
183 SoftBusFree(it);
184 }
185 ListDelete(&device->node);
186 SoftBusFree(device);
187 }
188
NewRequest(ConnBrRequest ** outRequest,uint32_t requestId,ConnectStatistics statistics,const ConnectResult * result)189 static int32_t NewRequest(
190 ConnBrRequest **outRequest, uint32_t requestId, ConnectStatistics statistics, const ConnectResult *result)
191 {
192 ConnBrRequest *request = (ConnBrRequest *)SoftBusCalloc(sizeof(ConnBrRequest));
193 if (request == NULL) {
194 return SOFTBUS_MALLOC_ERR;
195 }
196 ListInit(&request->node);
197 request->requestId = requestId;
198 request->result = *result;
199 request->statistics = statistics;
200
201 *outRequest = request;
202 return SOFTBUS_OK;
203 }
204
Convert2ConnectionInfo(ConnBrConnection * connection,ConnectionInfo * info)205 static int32_t Convert2ConnectionInfo(ConnBrConnection *connection, ConnectionInfo *info)
206 {
207 info->isAvailable = connection->state == BR_CONNECTION_STATE_CONNECTED ? 1 : 0;
208 info->isServer = connection->side == CONN_SIDE_SERVER ? 1 : 0;
209 info->type = CONNECT_BR;
210 if (strcpy_s(info->brInfo.brMac, BT_MAC_LEN, connection->addr) != EOK) {
211 return SOFTBUS_STRCPY_ERR;
212 }
213 return SOFTBUS_OK;
214 }
215
ConvertCtxToDevice(ConnBrDevice ** outDevice,const ConnBrConnectRequestContext * ctx)216 static int32_t ConvertCtxToDevice(ConnBrDevice **outDevice, const ConnBrConnectRequestContext *ctx)
217 {
218 ConnBrRequest *request = NULL;
219 int32_t status = NewRequest(&request, ctx->requestId, ctx->statistics, &ctx->result);
220 if (status != SOFTBUS_OK) {
221 return status;
222 }
223 ConnBrDevice *device = NULL;
224 status = NewDevice(&device, ctx->addr);
225 if (status != SOFTBUS_OK) {
226 SoftBusFree(request);
227 return status;
228 }
229 device->connectionId = ctx->connectionId;
230 device->waitTimeoutDelay = ctx->waitTimeoutDelay;
231 ListAdd(&device->requests, &request->node);
232 *outDevice = device;
233 return SOFTBUS_OK;
234 }
235
NameAvailableState(void)236 static char *NameAvailableState(void)
237 {
238 return (char *)("available state");
239 }
240
NameConnectingState(void)241 static char *NameConnectingState(void)
242 {
243 return (char *)("connecting state");
244 }
245
EnterAvailableState(void)246 static void EnterAvailableState(void)
247 {
248 CONN_LOGD(CONN_BR, "br manager enter avaible state");
249 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_NEXT_CMD, 0, 0, NULL, 0);
250 }
251
EnterConnectingState(void)252 static void EnterConnectingState(void)
253 {
254 CONN_LOGD(CONN_BR, "br manager enter connecting state");
255 }
256
ExitAvailableState(void)257 static void ExitAvailableState(void)
258 {
259 CONN_LOGD(CONN_BR, "br manager exit avaible state");
260 }
261
ExitConnectingState(void)262 static void ExitConnectingState(void)
263 {
264 CONN_LOGD(CONN_BR, "br manager exit connecting state");
265 }
266
NotifyDeviceConnectResult(const ConnBrDevice * device,ConnBrConnection * connection,bool isReuse,int32_t reason)267 static void NotifyDeviceConnectResult(
268 const ConnBrDevice *device, ConnBrConnection *connection, bool isReuse, int32_t reason)
269 {
270 char anomizeAddress[BT_MAC_LEN] = { 0 };
271 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, device->addr, BT_MAC_LEN);
272 int32_t status = ConnBleRemoveKeepAlive(
273 device->bleKeepAliveInfo.keepAliveBleConnectionId, device->bleKeepAliveInfo.keepAliveBleRequestId);
274 CONN_LOGD(CONN_BR, "remove ble keep alive res=%{public}d", status);
275
276 ConnBrRequest *it = NULL;
277 if (connection == NULL) {
278 LIST_FOR_EACH_ENTRY(it, &device->requests, ConnBrRequest, node) {
279 CONN_LOGD(CONN_BR, "br notify connect request failed, requestId=%{public}u, addr=%{public}s, "
280 "reason=%{public}d", it->requestId, anomizeAddress, reason);
281 DfxRecordBrConnectFail(it->requestId, DEFAULT_PID, (ConnBrDevice *)device, &it->statistics, reason);
282 it->result.OnConnectFailed(it->requestId, reason);
283 CONN_LOGE(CONN_BR, "br notify connect request failed done, requestId=%{public}u, addr=%{public}s, "
284 "reason=%{public}d", it->requestId, anomizeAddress, reason);
285 }
286 return;
287 }
288
289 if (reason == 0) {
290 NipConnectDevice(connection->connectionId, connection->addr);
291 } else {
292 NipDisconnectDevice(connection->connectionId);
293 }
294
295 ConnectionInfo info = { 0 };
296 status = Convert2ConnectionInfo(connection, &info);
297 if (status != SOFTBUS_OK) {
298 CONN_LOGE(CONN_BR, "convert br connection info failed, error=%{public}d", status);
299 }
300
301 ConnectOption option;
302 (void)memset_s(&option, sizeof(option), 0, sizeof(option));
303 option.type = CONNECT_BR;
304 if (strcpy_s(option.brOption.brMac, BT_MAC_LEN, info.brInfo.brMac) == SOFTBUS_OK) {
305 LnnDCClearConnectException(&option);
306 }
307
308 LIST_FOR_EACH_ENTRY(it, &device->requests, ConnBrRequest, node) {
309 // not need sync reference count when establish connection, initial reference count is 1
310 it->statistics.reuse = isReuse;
311 if (isReuse) {
312 ConnBrUpdateConnectionRc(connection, 1);
313 }
314 isReuse = true;
315 CONN_LOGD(CONN_BR, "br notify connect request success, requestId=%{public}u, addr=%{public}s, "
316 "connection=%{public}u", it->requestId, anomizeAddress, connection->connectionId);
317 it->statistics.reqId = it->requestId;
318 DfxRecordBrConnectSuccess(DEFAULT_PID, connection, &it->statistics);
319 it->result.OnConnectSuccessed(it->requestId, connection->connectionId, &info);
320 CONN_LOGD(CONN_BR, "br notify connect request success done, requestId=%{public}u, addr=%{public}s, "
321 "connection=%{public}u", it->requestId, anomizeAddress, connection->connectionId);
322 }
323 }
324
KeepAliveBleIfSameAddress(ConnBrDevice * device)325 static void KeepAliveBleIfSameAddress(ConnBrDevice *device)
326 {
327 uint32_t connectionId = 0;
328 char anomizeAddress[BT_MAC_LEN] = { 0 };
329 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, device->addr, BT_MAC_LEN);
330 ConnBleConnection *bleConnection = ConnBleGetConnectionByAddr(device->addr, CONN_SIDE_ANY, BLE_GATT);
331 CONN_CHECK_AND_RETURN_LOGW(
332 bleConnection != NULL, CONN_BR, "can not get ble conn, no need to keep alive");
333 connectionId = bleConnection->connectionId;
334 ConnBleReturnConnection(&bleConnection);
335 device->bleKeepAliveInfo.keepAliveBleRequestId = ConnGetNewRequestId(MODULE_CONNECTION);
336 device->bleKeepAliveInfo.keepAliveBleConnectionId = connectionId;
337 int32_t status = ConnBleKeepAlive(
338 connectionId, device->bleKeepAliveInfo.keepAliveBleRequestId, BLE_CONNECT_KEEP_ALIVE_TIMEOUT_MILLIS);
339 if (status != SOFTBUS_OK) {
340 CONN_LOGE(CONN_BR, "ble keep alive failed, connId=%{public}u, requestId=%{public}u", connectionId,
341 device->bleKeepAliveInfo.keepAliveBleRequestId);
342 return;
343 }
344 CONN_LOGI(CONN_BR, "keep ble alive, addr=%{public}s, connId=%{public}u", anomizeAddress, connectionId);
345 return;
346 }
347
ConnectDeviceDirectly(ConnBrDevice * device,const char * anomizeAddress)348 static int32_t ConnectDeviceDirectly(ConnBrDevice *device, const char *anomizeAddress)
349 {
350 CONN_LOGI(CONN_BR, "schedule connect request, addr=%{public}s", anomizeAddress);
351 int32_t status = SOFTBUS_OK;
352 ConnBrConnection *connection = ConnBrCreateConnection(device->addr, CONN_SIDE_CLIENT, INVALID_SOCKET_HANDLE);
353 CONN_CHECK_AND_RETURN_RET_LOGE(connection != NULL, SOFTBUS_CONN_BR_INTERNAL_ERR, CONN_BR, "connection is null");
354 KeepAliveBleIfSameAddress(device);
355 char *address = (char *)SoftBusCalloc(BT_MAC_LEN);
356 do {
357 if (address == NULL || strcpy_s(address, BT_MAC_LEN, device->addr) != EOK) {
358 CONN_LOGW(CONN_BR, "copy br address failed, addr=%{public}s", anomizeAddress);
359 status = SOFTBUS_MEM_ERR;
360 break;
361 }
362
363 status = ConnBrSaveConnection(connection);
364 if (status != SOFTBUS_OK) {
365 break;
366 }
367 status = ConnBrConnect(connection);
368 if (status != SOFTBUS_OK) {
369 break;
370 }
371 g_brManager.connecting = device;
372 uint32_t waitTimeoutDelay = 0;
373 if (device->waitTimeoutDelay < BR_CONNECT_TIMEOUT_MIN_MILLIS) {
374 waitTimeoutDelay = BR_CONNECT_TIMEOUT_MIN_MILLIS;
375 } else if (device->waitTimeoutDelay > BR_CONNECT_TIMEOUT_MAX_MILLIS) {
376 waitTimeoutDelay = BR_CONNECT_TIMEOUT_MAX_MILLIS;
377 } else {
378 waitTimeoutDelay = device->waitTimeoutDelay;
379 }
380
381 status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_CONNECT_TIMEOUT, connection->connectionId, 0,
382 address, waitTimeoutDelay);
383 if (status != SOFTBUS_OK) {
384 break;
385 }
386 TransitionToState(BR_STATE_CONNECTING);
387 } while (false);
388
389 ConnEventExtra extra = { .connectionId = (int32_t)connection->connectionId,
390 .peerBrMac = connection->addr,
391 .linkType = CONNECT_BR,
392 .errcode = status,
393 .result = status == SOFTBUS_OK ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED };
394 CONN_EVENT(EVENT_SCENE_CONNECT, EVENT_STAGE_CONNECT_DEVICE_DIRECTLY, extra);
395 if (status != SOFTBUS_OK) {
396 ConnBrRemoveConnection(connection);
397 SoftBusFree(address);
398 }
399 ConnBrReturnConnection(&connection);
400 return status;
401 }
402
PendingDevice(ConnBrDevice * device,const char * anomizeAddress)403 static int32_t PendingDevice(ConnBrDevice *device, const char *anomizeAddress)
404 {
405 CONN_LOGI(CONN_BR, "pend connect request, addr=%{public}s, deviceState=%{public}d", anomizeAddress, device->state);
406 ConnBrDevice *connectingDevice = g_brManager.connecting;
407 char connectingAnomizeAddress[BT_MAC_LEN] = { 0 };
408 if (g_brManager.connecting != NULL) {
409 ConvertAnonymizeMacAddress(connectingAnomizeAddress, BT_MAC_LEN, connectingDevice->addr, BT_MAC_LEN);
410 }
411
412 ConnBrDevice *targetDevice = NULL;
413 if (g_brManager.connecting != NULL && StrCmpIgnoreCase(g_brManager.connecting->addr, device->addr) == 0) {
414 targetDevice = g_brManager.connecting;
415 } else {
416 ConnBrDevice *it = NULL;
417 LIST_FOR_EACH_ENTRY(it, &g_brManager.waitings, ConnBrDevice, node) {
418 if (StrCmpIgnoreCase(it->addr, device->addr) == 0) {
419 targetDevice = it;
420 break;
421 }
422 }
423 }
424 CONN_LOGD(CONN_BR, "pengding current br connect request, addr=%{public}s, connectingAddress=%{public}s",
425 anomizeAddress, connectingAnomizeAddress);
426 if (targetDevice == NULL) {
427 ListTailInsert(&g_brManager.waitings, &device->node);
428 return SOFTBUS_OK;
429 }
430
431 ConnBrRequest *requestIt = NULL;
432 ConnBrRequest *requestNext = NULL;
433 LIST_FOR_EACH_ENTRY_SAFE(requestIt, requestNext, &device->requests, ConnBrRequest, node) {
434 ListDelete(&requestIt->node);
435 ListAdd(&targetDevice->requests, &requestIt->node);
436 }
437 FreeDevice(device);
438 return SOFTBUS_OK;
439 }
440
BrReuseConnection(ConnBrDevice * device,ConnBrConnection * connection)441 static bool BrReuseConnection(ConnBrDevice *device, ConnBrConnection *connection)
442 {
443 CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&connection->lock) == SOFTBUS_OK, false, CONN_BR,
444 "br reuse connection failed: lock failed, connId=%{public}u", connection->connectionId);
445 enum ConnBrConnectionState state = connection->state;
446 (void)SoftBusMutexUnlock(&connection->lock);
447 if (state != BR_CONNECTION_STATE_CONNECTED) {
448 return false;
449 }
450 NotifyDeviceConnectResult(device, connection, true, 0);
451 return true;
452 }
453
CheckPending(const char * addr)454 static bool CheckPending(const char *addr)
455 {
456 CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_brManager.pendings->lock) == SOFTBUS_OK, false, CONN_BR,
457 "check pending failed: lock pendings failed");
458 bool pending = false;
459 BrPending *it = NULL;
460 LIST_FOR_EACH_ENTRY(it, &g_brManager.pendings->list, BrPending, node) {
461 if (StrCmpIgnoreCase(it->addr, addr) == 0) {
462 pending = true;
463 break;
464 }
465 }
466 SoftBusMutexUnlock(&g_brManager.pendings->lock);
467 return pending;
468 }
469
CheckPendingAndactionIfAbsent(ConnBrDevice * device,DeviceAction actionIfAbsent,const char * anomizeAddress)470 static void CheckPendingAndactionIfAbsent(ConnBrDevice *device, DeviceAction actionIfAbsent,
471 const char *anomizeAddress)
472 {
473 if (CheckPending(device->addr)) {
474 device->state = BR_DEVICE_STATE_PENDING;
475 PendingDevice(device, anomizeAddress);
476 return;
477 }
478 device->state = BR_DEVICE_STATE_WAIT_SCHEDULE;
479 int32_t ret = actionIfAbsent(device, anomizeAddress);
480 if (ret != SOFTBUS_OK) {
481 NotifyDeviceConnectResult(device, NULL, false, ret);
482 FreeDevice(device);
483 }
484 return;
485 }
486
AttempReuseConnect(ConnBrDevice * device,DeviceAction actionIfAbsent)487 static void AttempReuseConnect(ConnBrDevice *device, DeviceAction actionIfAbsent)
488 {
489 char anomizeAddress[BT_MAC_LEN] = { 0 };
490 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, device->addr, BT_MAC_LEN);
491
492 ConnBrConnection *clientConnection = ConnBrGetConnectionByAddr(device->addr, CONN_SIDE_CLIENT);
493 ConnBrConnection *serverConnection = ConnBrGetConnectionByAddr(device->addr, CONN_SIDE_SERVER);
494 if (clientConnection == NULL && serverConnection == NULL) {
495 CheckPendingAndactionIfAbsent(device, actionIfAbsent, anomizeAddress);
496 return;
497 }
498 ConnBrConnection *connection = ConnBrGetConnectionById(device->connectionId);
499 do {
500 if (connection != NULL && strcmp(device->addr, connection->addr) == 0 &&
501 BrReuseConnection(device, connection)) {
502 CONN_LOGI(CONN_BR, "reuse by connId, addr=%{public}s, connId=%{public}u", anomizeAddress,
503 connection->connectionId);
504 FreeDevice(device);
505 break;
506 }
507 if (clientConnection != NULL && BrReuseConnection(device, clientConnection)) {
508 FreeDevice(device);
509 CONN_LOGI(CONN_BR, "reuse client, addr=%{public}s, connectionId=%{public}u", anomizeAddress,
510 clientConnection->connectionId);
511 break;
512 }
513 if (serverConnection != NULL && BrReuseConnection(device, serverConnection)) {
514 FreeDevice(device);
515 CONN_LOGI(CONN_BR, "reuse server, addr=%{public}s, connId=%{public}u", anomizeAddress,
516 serverConnection->connectionId);
517 break;
518 }
519 device->state = BR_DEVICE_STATE_WAIT_EVENT;
520 PendingDevice(device, anomizeAddress);
521 } while (false);
522
523 if (clientConnection != NULL) {
524 ConnBrReturnConnection(&clientConnection);
525 }
526 if (serverConnection != NULL) {
527 ConnBrReturnConnection(&serverConnection);
528 }
529 if (connection != NULL) {
530 ConnBrReturnConnection(&connection);
531 }
532 }
533
ConnectRequestOnAvailableState(const ConnBrConnectRequestContext * ctx)534 static void ConnectRequestOnAvailableState(const ConnBrConnectRequestContext *ctx)
535 {
536 if (!g_brStateTurnOn) {
537 CONN_LOGE(CONN_BR, "br state is turn off, requestId=%{public}u, error=%{public}d", ctx->requestId,
538 SOFTBUS_CONN_BR_STATE_TURN_OFF);
539 DfxRecordBrConnectFail(ctx->requestId, DEFAULT_PID, NULL, &ctx->statistics, SOFTBUS_CONN_BR_STATE_TURN_OFF);
540 ctx->result.OnConnectFailed(ctx->requestId, SOFTBUS_CONN_BR_STATE_TURN_OFF);
541 return;
542 }
543 ConnBrDevice *device = NULL;
544 int32_t status = ConvertCtxToDevice(&device, ctx);
545 if (status != SOFTBUS_OK) {
546 CONN_LOGE(CONN_BR, "ConvertCtxToDevice failed, requestId=%{public}u, error=%{public}d", ctx->requestId, status);
547 DfxRecordBrConnectFail(ctx->requestId, DEFAULT_PID, device, &ctx->statistics, status);
548 ctx->result.OnConnectFailed(ctx->requestId, status);
549 return;
550 }
551 char anomizeAddress[BT_MAC_LEN] = { 0 };
552 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, device->addr, BT_MAC_LEN);
553 device->state = BR_DEVICE_STATE_WAIT_SCHEDULE;
554 PendingDevice(device, anomizeAddress);
555 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_NEXT_CMD, 0, 0, NULL, 0);
556 }
557
ConnectRequestOnConnectingState(const ConnBrConnectRequestContext * ctx)558 static void ConnectRequestOnConnectingState(const ConnBrConnectRequestContext *ctx)
559 {
560 ConnBrDevice *device = NULL;
561 int32_t status = ConvertCtxToDevice(&device, ctx);
562 if (status != SOFTBUS_OK) {
563 CONN_LOGE(CONN_BR, "ConvertCtxToDevice failed, requestId=%{public}u, error=%{public}d", ctx->requestId, status);
564 DfxRecordBrConnectFail(ctx->requestId, DEFAULT_PID, device, &ctx->statistics, status);
565 ctx->result.OnConnectFailed(ctx->requestId, status);
566 return;
567 }
568 AttempReuseConnect(device, PendingDevice);
569 }
570
HandlePendingRequestOnAvailableState(void)571 static void HandlePendingRequestOnAvailableState(void)
572 {
573 ConnBrDevice *target = NULL;
574 ConnBrDevice *it = NULL;
575 LIST_FOR_EACH_ENTRY(it, &g_brManager.waitings, ConnBrDevice, node) {
576 if (it->state == BR_DEVICE_STATE_WAIT_SCHEDULE) {
577 target = it;
578 break;
579 }
580 }
581 if (target == NULL) {
582 return;
583 }
584 ListDelete(&target->node);
585 AttempReuseConnect(target, ConnectDeviceDirectly);
586 }
587
ServerAccepted(uint32_t connectionId)588 static void ServerAccepted(uint32_t connectionId)
589 {
590 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
591 if (connection == NULL) {
592 CONN_LOGE(CONN_BR, "can not get br connection, connectionId=%{public}u", connectionId);
593 return;
594 }
595
596 char anomizeAddress[BT_MAC_LEN] = { 0 };
597 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, connection->addr, BT_MAC_LEN);
598 CONN_LOGI(CONN_BR, "accept new connection, connId=%{public}u, peerAddr=%{public}s", connectionId, anomizeAddress);
599
600 ConnectionInfo info = { 0 };
601 int32_t status = Convert2ConnectionInfo(connection, &info);
602 if (status != SOFTBUS_OK) {
603 CONN_LOGE(CONN_BR, "convert connection info failed, error=%{public}d", status);
604 }
605 g_connectCallback.OnConnected(connectionId, &info);
606 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_UNPEND, 0, 0, connection->addr);
607 UnpendConnection(connection->addr);
608
609 ConnBrDevice *connectingDevice = g_brManager.connecting;
610 if (connectingDevice != NULL && StrCmpIgnoreCase(connectingDevice->addr, connection->addr) == 0) {
611 CONN_LOGW(CONN_BR, "both ends request br connection, connId=%{public}u, peerAddr=%{public}s", connectionId,
612 anomizeAddress);
613 ConnBrReturnConnection(&connection);
614 return;
615 }
616
617 ConnBrDevice *it = NULL;
618 ConnBrDevice *next = NULL;
619 LIST_FOR_EACH_ENTRY_SAFE(it, next, &g_brManager.waitings, ConnBrDevice, node) {
620 if (StrCmpIgnoreCase(it->addr, connection->addr) == 0 && BrReuseConnection(it, connection)) {
621 ListDelete(&it->node);
622 FreeDevice(it);
623 }
624 }
625 ConnEventExtra extra = { .connectionId = (int32_t)connectionId,
626 .peerBrMac = connection->addr,
627 .linkType = CONNECT_BR,
628 .result = EVENT_STAGE_RESULT_OK };
629 CONN_EVENT(EVENT_SCENE_CONNECT, EVENT_STAGE_CONNECT_SERVER_ACCEPTED, extra);
630 ConnBrReturnConnection(&connection);
631 }
632
ClientConnected(uint32_t connectionId)633 static void ClientConnected(uint32_t connectionId)
634 {
635 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
636 if (connection == NULL) {
637 CONN_LOGE(CONN_BR, "can not get br connection. connectionId=%{public}u", connectionId);
638 return;
639 }
640 char anomizeAddress[BT_MAC_LEN] = { 0 };
641 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, connection->addr, BT_MAC_LEN);
642
643 ConnBrDevice *it = NULL;
644 ConnBrDevice *targetDevice = NULL;
645 LIST_FOR_EACH_ENTRY(it, &g_brManager.waitings, ConnBrDevice, node) {
646 if (StrCmpIgnoreCase(it->addr, connection->addr) == 0) {
647 targetDevice = it;
648 break;
649 }
650 }
651 if (targetDevice != NULL) {
652 CONN_LOGI(CONN_BR, "reuse conn, connId=%{public}u, address=%{public}s", connectionId, anomizeAddress);
653 connection->retryCount = 0;
654 NotifyDeviceConnectResult(targetDevice, connection, false, 0);
655 ListDelete(&targetDevice->node);
656 ConnBrReturnConnection(&connection);
657 return;
658 }
659
660 ConnBrDevice *connectingDevice = g_brManager.connecting;
661 if (connectingDevice == NULL || StrCmpIgnoreCase(connectingDevice->addr, connection->addr) != 0) {
662 CONN_LOGE(CONN_BR, "no connecting device, connId=%{public}u, address=%{public}s", connectionId, anomizeAddress);
663 ConnBrUpdateConnectionRc(connection, -1);
664 ConnBrReturnConnection(&connection);
665 return;
666 }
667 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_CONNECT_TIMEOUT, connectionId, 0, NULL);
668 CONN_LOGI(CONN_BR, "connect ok, connectionId=%{public}d, addr=%{public}s", connectionId, anomizeAddress);
669
670 connection->retryCount = 0;
671 NotifyDeviceConnectResult(connectingDevice, connection, false, 0);
672 FreeDevice(connectingDevice);
673 g_brManager.connecting = NULL;
674 TransitionToState(BR_STATE_AVAILABLE);
675 ConnBrReturnConnection(&connection);
676 }
677
IsNeedWaitCallbackError(uint32_t connectionId,int32_t * error)678 static bool IsNeedWaitCallbackError(uint32_t connectionId, int32_t *error)
679 {
680 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
681 CONN_CHECK_AND_RETURN_RET_LOGE(connection != NULL, false, CONN_BR,
682 "get conntion failed, connId=%{public}d", connectionId);
683
684 if (SoftBusMutexLock(&connection->lock) != SOFTBUS_OK) {
685 CONN_LOGE(CONN_BR, "lock failed, connId=%{public}u", connectionId);
686 ConnBrReturnConnection(&connection);
687 return false;
688 }
689 int32_t result = 0;
690 BrUnderlayerStatus *it = NULL;
691 LIST_FOR_EACH_ENTRY(it, &connection->connectProcessStatus->list, BrUnderlayerStatus, node) {
692 // to Find the last error result.
693 if ((it->result) != 0) {
694 result = it->result;
695 }
696 }
697 (void)SoftBusMutexUnlock(&connection->lock);
698 ConnBrReturnConnection(&connection);
699 if (result > 0 && result <= CONN_BR_CONNECT_UNDERLAYER_ERROR_UNDEFINED) {
700 *error = SOFTBUS_CONN_BR_UNDERLAYBASE_ERR + result;
701 return false;
702 }
703 return true;
704 }
705
AuthenticationFailedAndRetry(ConnBrConnection * connection,ConnBrDevice * connectingDevice,const char * anomizeAddress)706 static int32_t AuthenticationFailedAndRetry(ConnBrConnection *connection, ConnBrDevice *connectingDevice,
707 const char *anomizeAddress)
708 {
709 bool collision = false;
710 BrUnderlayerStatus *it = NULL;
711 LIST_FOR_EACH_ENTRY(it, &connection->connectProcessStatus->list, BrUnderlayerStatus, node) {
712 if (it->result == CONN_BR_CONNECT_UNDERLAYER_ERROR_CONNECTION_EXISTS ||
713 it->result == CONN_BR_CONNECT_UNDERLAYER_ERROR_CONTROLLER_BUSY ||
714 it->result == CONN_BR_CONNECT_UNDERLAYER_ERROR_CONN_SDP_BUSY ||
715 it->result == CONN_BR_CONNECT_UNDERLAYER_ERROR_CONN_AUTH_FAILED ||
716 it->result == CONN_BR_CONNECT_UNDERLAYER_ERROR_CONN_RFCOM_DM) {
717 connection->retryCount += 1;
718 collision = true;
719 break;
720 }
721 }
722 if (collision && connection->retryCount < MAX_RETRY_COUNT) {
723 CONN_LOGW(CONN_BR, "acl collision, wait for retry, id=%{public}u, addr=%{public}s, result=%{public}d",
724 connection->connectionId, anomizeAddress, it->result);
725 uint32_t time = it->result == CONN_BR_CONNECT_UNDERLAYER_ERROR_CONN_RFCOM_DM ?
726 BR_CONNECTION_ACL_RETRY_CONNECT_COLLISION_MILLIS : BR_CONNECTION_ACL_CONNECT_COLLISION_MILLIS;
727 // NOTICE: assign connecting NULL first to prevent recursively pending in connecting
728 g_brManager.connecting = NULL;
729 ProcessAclCollisionException(connectingDevice, anomizeAddress, time);
730 return SOFTBUS_OK;
731 }
732 return SOFTBUS_CONN_BR_UNDERLAY_CONNECT_FAIL;
733 }
734
ClientConnectFailed(uint32_t connectionId,int32_t error)735 static void ClientConnectFailed(uint32_t connectionId, int32_t error)
736 {
737 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
738 if (connection == NULL) {
739 CONN_LOGE(CONN_BR, "can not get br connection, connectionId=%{public}u, error=%{public}d", connectionId, error);
740 return;
741 }
742 char anomizeAddress[BT_MAC_LEN] = { 0 };
743 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, connection->addr, BT_MAC_LEN);
744
745 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_CONNECT_TIMEOUT, connectionId, 0, NULL);
746 CONN_LOGI(CONN_BR, "connId=%{public}u, addr=%{public}s, error=%{public}d", connectionId, anomizeAddress, error);
747 ConnBrDisconnectNow(connection);
748
749 ConnBrDevice *connectingDevice = g_brManager.connecting;
750 if (connectingDevice == NULL || StrCmpIgnoreCase(connectingDevice->addr, connection->addr) != 0) {
751 CONN_LOGE(CONN_BR, "no connecting device, connId=%{public}u, addr=%{public}s, error=%{public}d", connectionId,
752 anomizeAddress, error);
753 ConnBrDevice *it = NULL;
754 LIST_FOR_EACH_ENTRY(it, &g_brManager.waitings, ConnBrDevice, node) {
755 if (StrCmpIgnoreCase(it->addr, connection->addr) == 0) {
756 it->state = BR_DEVICE_STATE_WAIT_SCHEDULE;
757 break;
758 }
759 }
760 ConnBrRemoveConnection(connection);
761 ConnBrReturnConnection(&connection);
762 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_NEXT_CMD, 0, 0, NULL, 0);
763 return;
764 }
765
766 do {
767 bool reuseServerConnection = false;
768 ConnBrConnection *serverConnection = ConnBrGetConnectionByAddr(connection->addr, CONN_SIDE_SERVER);
769 if (serverConnection != NULL) {
770 if (BrReuseConnection(connectingDevice, serverConnection)) {
771 CONN_LOGI(CONN_BR, "reuse server connection, connId=%{public}u, addr=%{public}s",
772 serverConnection->connectionId, anomizeAddress);
773 reuseServerConnection = true;
774 }
775 ConnBrReturnConnection(&serverConnection);
776 if (reuseServerConnection) {
777 break;
778 }
779 }
780
781 if (AuthenticationFailedAndRetry(connection, connectingDevice, anomizeAddress) == SOFTBUS_OK) {
782 break;
783 }
784 NotifyDeviceConnectResult(connectingDevice, NULL, false, error);
785 } while (false);
786 ConnBrRemoveConnection(connection);
787 ConnBrReturnConnection(&connection);
788 if (g_brManager.connecting != NULL) {
789 FreeDevice(g_brManager.connecting);
790 g_brManager.connecting = NULL;
791 }
792 TransitionToState(BR_STATE_AVAILABLE);
793 }
794
ClientConnectTimeoutOnConnectingState(uint32_t connectionId,const char * address)795 static void ClientConnectTimeoutOnConnectingState(uint32_t connectionId, const char *address)
796 {
797 char anomizeAddress[BT_MAC_LEN] = { 0 };
798 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, address, BT_MAC_LEN);
799
800 CONN_LOGI(CONN_BR, "addr=%{public}s, connId=%{public}u", anomizeAddress, connectionId);
801 ConnBrDevice *connectingDevice = g_brManager.connecting;
802 if (connectingDevice == NULL || StrCmpIgnoreCase(connectingDevice->addr, address) != 0) {
803 CONN_LOGE(
804 CONN_BR, "connecting device mismatch. addr=%{public}s, connId=%{public}u", anomizeAddress, connectionId);
805 return;
806 }
807 NotifyDeviceConnectResult(connectingDevice, NULL, false, SOFTBUS_CONN_BR_CONNECT_TIMEOUT_ERR);
808 FreeDevice(connectingDevice);
809 g_brManager.connecting = NULL;
810 TransitionToState(BR_STATE_AVAILABLE);
811 }
812
DataReceived(ConnBrDataReceivedContext * ctx)813 static void DataReceived(ConnBrDataReceivedContext *ctx)
814 {
815 if (ctx->dataLen < sizeof(ConnPktHead)) {
816 CONN_LOGE(CONN_BR, "dataLength(=%{public}u) is less than header size, connId=%{public}u",
817 ctx->dataLen, ctx->connectionId);
818 SoftBusFree(ctx->data);
819 return;
820 }
821 ConnPktHead *head = (ConnPktHead *)ctx->data;
822 ConnBrConnection *connection = ConnBrGetConnectionById(ctx->connectionId);
823 if (connection == NULL) {
824 CONN_LOGE(CONN_BR,
825 "connection not exist, connId=%{public}u, "
826 "Len=%{public}u, Flg=%{public}d, Module=%{public}d, Seq=%{public}" PRId64 "",
827 ctx->connectionId, ctx->dataLen, head->flag, head->module, head->seq);
828 SoftBusFree(ctx->data);
829 return;
830 }
831 CONN_LOGD(CONN_BR, "connId=%{public}u, Len=%{public}u, Flg=%{public}d, Module=%{public}d, Seq=%{public}" PRId64 "",
832 ctx->connectionId, ctx->dataLen, head->flag, head->module, head->seq);
833 if (head->module == MODULE_CONNECTION) {
834 ReceivedControlData(connection, ctx->data + ConnGetHeadSize(), ctx->dataLen - ConnGetHeadSize());
835 } else if (head->module == MODULE_NIP_BR_CHANNEL && head->seq == (int64_t)BR_NIP_SEQ) {
836 NipRecvDataFromBr(ctx->connectionId, (char *)ctx->data, (int32_t)(ctx->dataLen));
837 } else {
838 g_connectCallback.OnDataReceived(
839 ctx->connectionId, (ConnModule)head->module, head->seq, (char *)ctx->data, (int32_t)(ctx->dataLen));
840 }
841 SoftBusFree(ctx->data);
842 ctx->data = NULL;
843 ConnBrReturnConnection(&connection);
844 }
845
ReceivedControlData(ConnBrConnection * connection,const uint8_t * data,uint32_t dataLen)846 static void ReceivedControlData(ConnBrConnection *connection, const uint8_t *data, uint32_t dataLen)
847 {
848 cJSON *json = cJSON_ParseWithLength((const char *)data, dataLen);
849 if (json == NULL) {
850 CONN_LOGE(CONN_BR, "parse json failed, connId=%{public}u", connection->connectionId);
851 return;
852 }
853
854 int32_t method = 0;
855 if (!GetJsonObjectNumberItem(json, KEY_METHOD, &method)) {
856 CONN_LOGE(CONN_BR, "parse method failed, connId=%{public}u", connection->connectionId);
857 cJSON_Delete(json);
858 return;
859 }
860 CONN_LOGD(CONN_BR, "connId=%{public}u, method=%{public}d", connection->connectionId, method);
861 int32_t status = SOFTBUS_OK;
862 switch (method) {
863 case BR_METHOD_NOTIFY_REQUEST:
864 status = ConnBrOnReferenceRequest(connection, json);
865 break;
866 case BR_METHOD_NOTIFY_RESPONSE:
867 status = ConnBrOnReferenceResponse(connection, json);
868 break;
869 case BR_METHOD_NOTIFY_ACK:
870 status = ConnBrOnAckRequest(connection, json);
871 break;
872 case BR_METHOD_ACK_RESPONSE:
873 status = ConnBrOnAckResponse(connection, json);
874 break;
875 default:
876 CONN_LOGE(
877 CONN_BR, "UNSUPPORT method, connId=%{public}u, method=%{public}d", connection->connectionId, method);
878 break;
879 }
880 if (status != SOFTBUS_OK) {
881 CONN_LOGE(CONN_BR, "unexpected error, connId=%{public}u, method=%{public}d, error=%{public}d",
882 connection->connectionId, method, status);
883 }
884 cJSON_Delete(json);
885 }
886
ConnectionException(uint32_t connectionId,int32_t error)887 static void ConnectionException(uint32_t connectionId, int32_t error)
888 {
889 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
890 CONN_CHECK_AND_RETURN_LOGW(
891 connection != NULL, CONN_BR, "br connection exception: connection not exist, connId=%{public}u", connectionId);
892
893 char anomizeAddress[BT_MAC_LEN] = { 0 };
894 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, connection->addr, BT_MAC_LEN);
895 CONN_LOGI(CONN_BR, "release all resource, connId=%{public}u, addr=%{public}s, error=%{public}d", connectionId,
896 anomizeAddress, error);
897 ConnBrDisconnectNow(connection);
898
899 ConnBrDevice *it = NULL;
900 LIST_FOR_EACH_ENTRY(it, &g_brManager.waitings, ConnBrDevice, node) {
901 if (StrCmpIgnoreCase(it->addr, connection->addr) == 0) {
902 it->state = BR_DEVICE_STATE_WAIT_SCHEDULE;
903 break;
904 }
905 }
906 ConnectionInfo info = { 0 };
907 int32_t status = Convert2ConnectionInfo(connection, &info);
908 if (status != SOFTBUS_OK) {
909 CONN_LOGE(CONN_BR, "convert br connection info failed, error=%{public}d", status);
910 }
911 ConnBrRemoveConnection(connection);
912 ConnBrReturnConnection(&connection);
913 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_NEXT_CMD, 0, 0, NULL, 0);
914 g_connectCallback.OnDisconnected(connectionId, &info);
915 }
916
ConnectionResume(uint32_t connectionId)917 static void ConnectionResume(uint32_t connectionId)
918 {
919 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
920 CONN_CHECK_AND_RETURN_LOGW(connection != NULL, CONN_BR,
921 "br resume connection failed: connection not exist, connId=%{public}u", connectionId);
922 ConnBrDevice *it = NULL;
923 ConnBrDevice *next = NULL;
924 LIST_FOR_EACH_ENTRY_SAFE(it, next, &g_brManager.waitings, ConnBrDevice, node) {
925 if (StrCmpIgnoreCase(it->addr, connection->addr) == 0 && BrReuseConnection(it, connection)) {
926 ListDelete(&it->node);
927 FreeDevice(it);
928 }
929 }
930 ConnBrReturnConnection(&connection);
931 }
932
DisconnectRequest(uint32_t connectionId)933 static void DisconnectRequest(uint32_t connectionId)
934 {
935 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
936 CONN_CHECK_AND_RETURN_LOGW(connection != NULL, CONN_BR,
937 "br disconnect request failed: connection is not exist, connId=%{public}u", connectionId);
938 ConnBrUpdateConnectionRc(connection, -1);
939 ConnBrReturnConnection(&connection);
940 }
941
UnpendConnection(const char * addr)942 static void UnpendConnection(const char *addr)
943 {
944 char anomizeAddress[BT_MAC_LEN] = { 0 };
945 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, addr, BT_MAC_LEN);
946
947 CONN_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_brManager.pendings->lock) == SOFTBUS_OK, CONN_BR,
948 "unpend connection: lock failed, addr=%{public}s", anomizeAddress);
949 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_UNPEND, 0, 0, (char *)addr);
950 do {
951 BrPending *target = NULL;
952 BrPending *pendingIt = NULL;
953 LIST_FOR_EACH_ENTRY(pendingIt, &g_brManager.pendings->list, BrPending, node) {
954 if (StrCmpIgnoreCase(pendingIt->addr, addr) == 0) {
955 target = pendingIt;
956 break;
957 }
958 }
959 if (target == NULL) {
960 CONN_LOGD(CONN_BR, "unpend connection, address is not pending, addr=%{public}s", anomizeAddress);
961 break;
962 }
963 ListDelete(&target->node);
964 SoftBusFree(target);
965 g_brManager.pendings->cnt -= 1;
966 ConnBrDevice *deviceIt = NULL;
967 LIST_FOR_EACH_ENTRY(deviceIt, &g_brManager.waitings, ConnBrDevice, node) {
968 if (StrCmpIgnoreCase(deviceIt->addr, addr) == 0) {
969 deviceIt->state = BR_DEVICE_STATE_WAIT_SCHEDULE;
970 break;
971 }
972 }
973 CONN_LOGI(CONN_BR, "ok, addr=%{public}s", anomizeAddress);
974 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_NEXT_CMD, 0, 0, NULL, 0);
975 } while (false);
976 SoftBusMutexUnlock(&g_brManager.pendings->lock);
977 }
978
Reset(int32_t reason)979 static void Reset(int32_t reason)
980 {
981 CONN_LOGW(CONN_BR, "br manager process RESET event, reason=%{public}d", reason);
982 if (g_brManager.connecting != NULL) {
983 ConnBrConnection *connection = ConnBrGetConnectionByAddr(g_brManager.connecting->addr, CONN_SIDE_CLIENT);
984 if (connection != NULL) {
985 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_CONNECT_TIMEOUT, connection->connectionId, 0, NULL);
986 ConnBrReturnConnection(&connection);
987 }
988 NotifyDeviceConnectResult(g_brManager.connecting, NULL, false, SOFTBUS_CONN_BLUETOOTH_OFF);
989 FreeDevice(g_brManager.connecting);
990 g_brManager.connecting = NULL;
991 }
992 ConnBrDevice *deviceIt = NULL;
993 ConnBrDevice *deviceNext = NULL;
994 LIST_FOR_EACH_ENTRY_SAFE(deviceIt, deviceNext, &g_brManager.waitings, ConnBrDevice, node) {
995 ListDelete(&deviceIt->node);
996 NotifyDeviceConnectResult(deviceIt, NULL, false, SOFTBUS_CONN_BLUETOOTH_OFF);
997 FreeDevice(deviceIt);
998 }
999
1000 int32_t status = SoftBusMutexLock(&g_brManager.pendings->lock);
1001 if (status != SOFTBUS_OK) {
1002 CONN_LOGE(CONN_BR, "lock pendings failed, error=%{public}d", status);
1003 return;
1004 }
1005 BrPending *pendingIt = NULL;
1006 BrPending *pendingNext = NULL;
1007 LIST_FOR_EACH_ENTRY_SAFE(pendingIt, pendingNext, &g_brManager.pendings->list, BrPending, node) {
1008 ListDelete(&pendingIt->node);
1009 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_UNPEND, 0, 0, pendingIt->addr);
1010 SoftBusFree(pendingIt);
1011 g_brManager.pendings->cnt -= 1;
1012 }
1013 SoftBusMutexUnlock(&g_brManager.pendings->lock);
1014
1015 status = SoftBusMutexLock(&g_brManager.connections->lock);
1016 if (status != SOFTBUS_OK) {
1017 CONN_LOGE(CONN_BR, "lock connections failed, error=%{public}d", status);
1018 return;
1019 }
1020 ConnBrConnection *connectionIt = NULL;
1021 LIST_FOR_EACH_ENTRY(connectionIt, &g_brManager.connections->list, ConnBrConnection, node) {
1022 // MUST NOT remove connection, connection close notify will cleanup
1023 ConnBrDisconnectNow(connectionIt);
1024 }
1025 SoftBusMutexUnlock(&g_brManager.connections->lock);
1026 TransitionToState(BR_STATE_AVAILABLE);
1027 }
1028
TransitionToState(enum BrServerState target)1029 static void TransitionToState(enum BrServerState target)
1030 {
1031 static ConnBrState statesTable[BR_STATE_MAX] = {
1032 [BR_STATE_AVAILABLE] = {
1033 .name = NameAvailableState,
1034 .enter = EnterAvailableState,
1035 .exit = ExitAvailableState,
1036 .connectRequest = ConnectRequestOnAvailableState,
1037 .handlePendingRequest = HandlePendingRequestOnAvailableState,
1038 .serverAccepted = ServerAccepted,
1039 .clientConnected = ClientConnected,
1040 .clientConnectFailed = ClientConnectFailed,
1041 .clientConnectTimeout = NULL,
1042 .dataReceived = DataReceived,
1043 .connectionException = ConnectionException,
1044 .connectionResume = ConnectionResume,
1045 .disconnectRequest = DisconnectRequest,
1046 .unpend = UnpendConnection,
1047 .reset = Reset,
1048 },
1049 [BR_STATE_CONNECTING] = {
1050 .name = NameConnectingState,
1051 .enter = EnterConnectingState,
1052 .exit = ExitConnectingState,
1053 .connectRequest = ConnectRequestOnConnectingState,
1054 .handlePendingRequest = NULL,
1055 .serverAccepted = ServerAccepted,
1056 .clientConnected = ClientConnected,
1057 .clientConnectFailed = ClientConnectFailed,
1058 .clientConnectTimeout = ClientConnectTimeoutOnConnectingState,
1059 .dataReceived = DataReceived,
1060 .connectionException = ConnectionException,
1061 .connectionResume = ConnectionResume,
1062 .disconnectRequest = DisconnectRequest,
1063 .unpend = UnpendConnection,
1064 .reset = Reset,
1065 },
1066 };
1067
1068 if (g_brManager.state == statesTable + target) {
1069 return;
1070 }
1071 if (g_brManager.state != NULL) {
1072 g_brManager.state->exit();
1073 }
1074 g_brManager.state = statesTable + target;
1075 g_brManager.state->enter();
1076 }
1077
1078 // memory management rules in BrManagerMsgHandler
1079 // 1. DO NOT free memory in case of not contain nested dynamic memory;
1080 // 2. MUST free nested dynamic memory which layer large than 1, msg->obj self layer is 1;
1081 typedef struct {
1082 int32_t cmd;
1083 void (*func)(SoftBusMessage *msg);
1084 } MsgHandlerCommand;
1085
HandlePendingRequestFunc(SoftBusMessage * msg)1086 static void HandlePendingRequestFunc(SoftBusMessage *msg)
1087 {
1088 (void)msg;
1089 if (g_brManager.state->handlePendingRequest != NULL) {
1090 g_brManager.state->handlePendingRequest();
1091 return;
1092 }
1093 }
1094
ConnectRequestFunc(SoftBusMessage * msg)1095 static void ConnectRequestFunc(SoftBusMessage *msg)
1096 {
1097 if (g_brManager.state->connectRequest == NULL) {
1098 return;
1099 }
1100 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1101 ConnBrConnectRequestContext *ctx = (ConnBrConnectRequestContext *)msg->obj;
1102 g_brManager.state->connectRequest(ctx);
1103 }
1104
ClientConnectedFunc(SoftBusMessage * msg)1105 static void ClientConnectedFunc(SoftBusMessage *msg)
1106 {
1107 if (g_brManager.state->clientConnected != NULL) {
1108 g_brManager.state->clientConnected((uint32_t)msg->arg1);
1109 return;
1110 }
1111 }
1112
ClientConnectTimeoutFunc(SoftBusMessage * msg)1113 static void ClientConnectTimeoutFunc(SoftBusMessage *msg)
1114 {
1115 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1116 if (g_brManager.state->clientConnectTimeout != NULL) {
1117 g_brManager.state->clientConnectTimeout((uint32_t)msg->arg1, (char *)msg->obj);
1118 return;
1119 }
1120 }
1121
ClientConnectFailedFunc(SoftBusMessage * msg)1122 static void ClientConnectFailedFunc(SoftBusMessage *msg)
1123 {
1124 if (g_brManager.state->clientConnectFailed == NULL) {
1125 return;
1126 }
1127 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1128 ErrorContext *ctx = (ErrorContext *)(msg->obj);
1129 g_brManager.state->clientConnectFailed(ctx->connectionId, ctx->error);
1130 }
1131
ServerAcceptedFunc(SoftBusMessage * msg)1132 static void ServerAcceptedFunc(SoftBusMessage *msg)
1133 {
1134 if (g_brManager.state->serverAccepted != NULL) {
1135 g_brManager.state->serverAccepted((uint32_t)msg->arg1);
1136 return;
1137 }
1138 }
1139
DataReceivedFunc(SoftBusMessage * msg)1140 static void DataReceivedFunc(SoftBusMessage *msg)
1141 {
1142 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1143 ConnBrDataReceivedContext *ctx = (ConnBrDataReceivedContext *)msg->obj;
1144 if (g_brManager.state->dataReceived == NULL) {
1145 SoftBusFree(ctx->data);
1146 return;
1147 }
1148
1149 g_brManager.state->dataReceived(ctx);
1150 }
1151
ConnectionExceptionFunc(SoftBusMessage * msg)1152 static void ConnectionExceptionFunc(SoftBusMessage *msg)
1153 {
1154 if (g_brManager.state->connectionException == NULL) {
1155 return;
1156 }
1157 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1158 ErrorContext *ctx = (ErrorContext *)(msg->obj);
1159 g_brManager.state->connectionException(ctx->connectionId, ctx->error);
1160 }
1161
ConnectionResumeFunc(SoftBusMessage * msg)1162 static void ConnectionResumeFunc(SoftBusMessage *msg)
1163 {
1164 if (g_brManager.state->connectionResume != NULL) {
1165 g_brManager.state->connectionResume((uint32_t)msg->arg1);
1166 return;
1167 }
1168 }
1169
DisconnectRequestFunc(SoftBusMessage * msg)1170 static void DisconnectRequestFunc(SoftBusMessage *msg)
1171 {
1172 if (g_brManager.state->disconnectRequest != NULL) {
1173 g_brManager.state->disconnectRequest((uint32_t)msg->arg1);
1174 return;
1175 }
1176 }
1177
UnpendFunc(SoftBusMessage * msg)1178 static void UnpendFunc(SoftBusMessage *msg)
1179 {
1180 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1181 if (g_brManager.state->unpend != NULL) {
1182 g_brManager.state->unpend((const char *)msg->obj);
1183 return;
1184 }
1185 }
1186
ResetFunc(SoftBusMessage * msg)1187 static void ResetFunc(SoftBusMessage *msg)
1188 {
1189 if (g_brManager.state->reset == NULL) {
1190 return;
1191 }
1192 CONN_CHECK_AND_RETURN_LOGW(msg->obj != NULL, CONN_BR, "obj is null");
1193 ErrorContext *ctx = (ErrorContext *)(msg->obj);
1194 g_brManager.state->reset(ctx->error);
1195 }
1196
1197 static MsgHandlerCommand g_commands[] = {
1198 {MSG_NEXT_CMD, HandlePendingRequestFunc},
1199 {MSG_CONNECT_REQUEST, ConnectRequestFunc},
1200 {MSG_CONNECT_SUCCESS, ClientConnectedFunc},
1201 {MSG_CONNECT_TIMEOUT, ClientConnectTimeoutFunc},
1202 {MSG_CONNECT_FAIL, ClientConnectFailedFunc},
1203 {MSG_SERVER_ACCEPTED, ServerAcceptedFunc},
1204 {MSG_DATA_RECEIVED, DataReceivedFunc},
1205 {MSG_CONNECTION_EXECEPTION, ConnectionExceptionFunc},
1206 {MSG_CONNECTION_RESUME, ConnectionResumeFunc},
1207 {MGR_DISCONNECT_REQUEST, DisconnectRequestFunc},
1208 {MSG_UNPEND, UnpendFunc},
1209 {MSG_RESET, ResetFunc},
1210 };
1211
BrManagerMsgHandler(SoftBusMessage * msg)1212 static void BrManagerMsgHandler(SoftBusMessage *msg)
1213 {
1214 COMM_CHECK_AND_RETURN_LOGW(msg != NULL, CONN_BR, "msg is null");
1215 if (msg->what != MSG_DATA_RECEIVED && msg->what != MSG_NEXT_CMD && msg->what != MSG_CONNECT_REQUEST &&
1216 msg->what != MSG_CONNECTION_EXECEPTION && msg->what != MGR_DISCONNECT_REQUEST) {
1217 CONN_LOGI(CONN_BR, "recvMsg=%{public}d, state=%{public}s", msg->what, g_brManager.state->name());
1218 }
1219 size_t commandSize = sizeof(g_commands) / sizeof(g_commands[0]);
1220 for (size_t i = 0; i < commandSize; i++) {
1221 if (g_commands[i].cmd == msg->what) {
1222 g_commands[i].func(msg);
1223 return;
1224 }
1225 }
1226 CONN_LOGE(CONN_BR, "unexpected msg, what=%{public}d", msg->what);
1227 }
1228
BrCompareManagerLooperEventFunc(const SoftBusMessage * msg,void * args)1229 static int BrCompareManagerLooperEventFunc(const SoftBusMessage *msg, void *args)
1230 {
1231 SoftBusMessage *ctx = (SoftBusMessage *)args;
1232 if (msg->what != ctx->what) {
1233 return COMPARE_FAILED;
1234 }
1235 switch (ctx->what) {
1236 case MSG_CONNECT_TIMEOUT: {
1237 if (msg->arg1 == ctx->arg1) {
1238 return COMPARE_SUCCESS;
1239 }
1240 return COMPARE_FAILED;
1241 }
1242 case MSG_UNPEND: {
1243 if (StrCmpIgnoreCase((const char *)msg->obj, (const char *)ctx->obj) == 0) {
1244 return COMPARE_SUCCESS;
1245 }
1246 return COMPARE_FAILED;
1247 }
1248 default:
1249 break;
1250 }
1251 if (ctx->arg1 != 0 || ctx->arg2 != 0 || ctx->obj != NULL) {
1252 CONN_LOGE(CONN_BR,
1253 "failed to avoid fault silence, what=%{public}d, arg1=%{public}" PRIu64 ", arg2=%{public}" PRIu64
1254 ", objIsNull=%{public}d",
1255 ctx->what, ctx->arg1, ctx->arg2, ctx->obj == NULL);
1256 return COMPARE_FAILED;
1257 }
1258 return COMPARE_SUCCESS;
1259 }
1260
OnServerAccepted(uint32_t connectionId)1261 static void OnServerAccepted(uint32_t connectionId)
1262 {
1263 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_SERVER_ACCEPTED, connectionId, 0, NULL, 0);
1264 }
1265
OnClientConnected(uint32_t connectionId)1266 static void OnClientConnected(uint32_t connectionId)
1267 {
1268 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_CONNECT_SUCCESS, connectionId, 0, NULL, 0);
1269 }
1270
OnClientConnectFailed(uint32_t connectionId,int32_t error)1271 static void OnClientConnectFailed(uint32_t connectionId, int32_t error)
1272 {
1273 CONN_LOGW(CONN_BR, "connId=%{public}u, error=%{public}d", connectionId, error);
1274 ErrorContext *ctx = (ErrorContext *)SoftBusCalloc(sizeof(ErrorContext));
1275 CONN_CHECK_AND_RETURN_LOGE(ctx != NULL, CONN_BR,
1276 "OnClientConnectFailed: calloc ctx failed, connId=%{public}u, error=%{public}d", connectionId, error);
1277 bool needWait = IsNeedWaitCallbackError(connectionId, &error);
1278 ctx->connectionId = connectionId;
1279 ctx->error = error;
1280 uint32_t timeoutDelay = needWait ? BR_CONNECT_WAIT_CALLBACK_TIMEOUT_MAX_MILLIS : 0;
1281 if (ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_CONNECT_FAIL, connectionId,
1282 0, ctx, timeoutDelay) != SOFTBUS_OK) {
1283 SoftBusFree(ctx);
1284 }
1285 }
1286
OnDataReceived(uint32_t connectionId,uint8_t * data,uint32_t dataLen)1287 static void OnDataReceived(uint32_t connectionId, uint8_t *data, uint32_t dataLen)
1288 {
1289 ConnBrDataReceivedContext *ctx = (ConnBrDataReceivedContext *)SoftBusCalloc(sizeof(ConnBrDataReceivedContext));
1290 if (ctx == NULL) {
1291 CONN_LOGE(
1292 CONN_BR, "calloc data received context failed, connId=%{public}u, len=%{public}u", connectionId, dataLen);
1293 SoftBusFree(data);
1294 return;
1295 }
1296 ctx->connectionId = connectionId;
1297 ctx->data = data;
1298 ctx->dataLen = dataLen;
1299
1300 int32_t status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_DATA_RECEIVED, 0, 0, ctx, 0);
1301 if (status != SOFTBUS_OK) {
1302 CONN_LOGE(CONN_BR, "post msg to looper failed, connId=%{public}u, len=%{public}u", connectionId, dataLen);
1303 SoftBusFree(data);
1304 SoftBusFree(ctx);
1305 }
1306 }
1307
OnConnectionException(uint32_t connectionId,int32_t error)1308 static void OnConnectionException(uint32_t connectionId, int32_t error)
1309 {
1310 ErrorContext *ctx = (ErrorContext *)SoftBusCalloc(sizeof(ErrorContext));
1311 CONN_CHECK_AND_RETURN_LOGE(ctx != NULL, CONN_BR,
1312 "br connection exception: calloc ctx failed, connId=%{public}u, error=%{public}d", connectionId, error);
1313 ctx->connectionId = connectionId;
1314 ctx->error = error;
1315 if (ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_CONNECTION_EXECEPTION, connectionId, 0, ctx, 0) !=
1316 SOFTBUS_OK) {
1317 SoftBusFree(ctx);
1318 }
1319 }
1320
OnConnectionResume(uint32_t connectionId)1321 static void OnConnectionResume(uint32_t connectionId)
1322 {
1323 ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_CONNECTION_RESUME, connectionId, 0, NULL, 0);
1324 }
1325
OnPostByteFinshed(uint32_t connectionId,uint32_t len,int32_t pid,int32_t flag,int32_t module,int64_t seq,int32_t error)1326 static void OnPostByteFinshed(
1327 uint32_t connectionId, uint32_t len, int32_t pid, int32_t flag, int32_t module, int64_t seq, int32_t error)
1328 {
1329 CONN_LOGI(CONN_BR,
1330 "connId=%{public}u, pid=%{public}u, "
1331 "Len=%{public}u, Flg=%{public}d, Module=%{public}d, Seq=%{public}" PRId64 ", error=%{public}d",
1332 connectionId, pid, len, flag, module, seq, error);
1333 if (error != SOFTBUS_OK) {
1334 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
1335 if (connection == NULL) {
1336 // maybe fail reason is that connection not exist, so log level is warning
1337 CONN_LOGW(CONN_BR, "connection not exist, connId=%{public}u", connectionId);
1338 return;
1339 }
1340 ConnBrDisconnectNow(connection);
1341 ConnBrReturnConnection(&connection);
1342 }
1343 }
1344
AllocateConnectionIdUnsafe()1345 static uint32_t AllocateConnectionIdUnsafe()
1346 {
1347 static uint16_t nextId = 0;
1348
1349 uint32_t connectionId = (CONNECT_BR << CONNECT_TYPE_SHIFT) + (++nextId);
1350 ConnBrConnection *it = NULL;
1351 LIST_FOR_EACH_ENTRY(it, &g_brManager.connections->list, ConnBrConnection, node) {
1352 if (connectionId == it->connectionId) {
1353 return 0;
1354 }
1355 }
1356 return connectionId;
1357 }
1358
ConnBrSaveConnection(ConnBrConnection * connection)1359 int32_t ConnBrSaveConnection(ConnBrConnection *connection)
1360 {
1361 CONN_CHECK_AND_RETURN_RET_LOGW(
1362 connection != NULL, SOFTBUS_INVALID_PARAM, CONN_BR, "br save connection: connection is null");
1363
1364 int32_t status = SoftBusMutexLock(&g_brManager.connections->lock);
1365 if (status != SOFTBUS_OK) {
1366 CONN_LOGE(CONN_BR, "lock manager connections failed, error=%{public}d", status);
1367 return status;
1368 }
1369 uint32_t connectionId = 0;
1370 do {
1371 connectionId = AllocateConnectionIdUnsafe();
1372 } while (connectionId == 0);
1373
1374 connection->connectionId = connectionId;
1375 connection->objectRc += 1;
1376 ListAdd(&g_brManager.connections->list, &connection->node);
1377 (void)SoftBusMutexUnlock(&g_brManager.connections->lock);
1378 return SOFTBUS_OK;
1379 }
1380
ConnBrRemoveConnection(ConnBrConnection * connection)1381 void ConnBrRemoveConnection(ConnBrConnection *connection)
1382 {
1383 CONN_CHECK_AND_RETURN_LOGW(connection != NULL, CONN_BR, "br remove connection: connection is null");
1384 CONN_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_brManager.connections->lock) == SOFTBUS_OK, CONN_BR,
1385 "br remove connection: lock manager connections failed, connId=%{public}u", connection->connectionId);
1386
1387 ConnBrConnection *it = NULL;
1388 ConnBrConnection *target = NULL;
1389 LIST_FOR_EACH_ENTRY(it, &g_brManager.connections->list, ConnBrConnection, node) {
1390 if (it->connectionId == connection->connectionId) {
1391 target = it;
1392 break;
1393 }
1394 }
1395 if (target != NULL) {
1396 CONN_LOGW(CONN_BR, "connId=%{public}u", connection->connectionId);
1397 ListDelete(&connection->node);
1398 ConnBrReturnConnection(&connection);
1399 } else {
1400 CONN_LOGW(CONN_BR, "connection not exist, connId=%{public}u", connection->connectionId);
1401 }
1402 (void)SoftBusMutexUnlock(&g_brManager.connections->lock);
1403 }
1404
ConnBrGetConnectionByAddr(const char * addr,ConnSideType side)1405 ConnBrConnection *ConnBrGetConnectionByAddr(const char *addr, ConnSideType side)
1406 {
1407 CONN_CHECK_AND_RETURN_RET_LOGW(addr != NULL, NULL, CONN_BR, "addr is null");
1408
1409 char animizeAddress[BT_MAC_LEN] = { 0 };
1410 ConvertAnonymizeMacAddress(animizeAddress, BT_MAC_LEN, addr, BT_MAC_LEN);
1411
1412 int32_t status = SoftBusMutexLock(&g_brManager.connections->lock);
1413 if (status != SOFTBUS_OK) {
1414 CONN_LOGE(
1415 CONN_BR, "lock manager connections failed, addr=%{public}s, error=%{public}d", animizeAddress, status);
1416 return NULL;
1417 }
1418
1419 ConnBrConnection *it = NULL;
1420 ConnBrConnection *target = NULL;
1421 LIST_FOR_EACH_ENTRY(it, &g_brManager.connections->list, ConnBrConnection, node) {
1422 if (StrCmpIgnoreCase(it->addr, addr) == 0 && (side == CONN_SIDE_ANY ? true : it->side == side)) {
1423 target = it;
1424 }
1425 }
1426 if (target != NULL) {
1427 status = SoftBusMutexLock(&target->lock);
1428 if (status != SOFTBUS_OK) {
1429 CONN_LOGE(CONN_BR, "lock connection failed, error=%{public}d", status);
1430 SoftBusMutexUnlock(&g_brManager.connections->lock);
1431 return NULL;
1432 }
1433 target->objectRc += 1;
1434 SoftBusMutexUnlock(&target->lock);
1435 }
1436 SoftBusMutexUnlock(&g_brManager.connections->lock);
1437 return target;
1438 }
1439
ConnBrGetConnectionById(uint32_t connectionId)1440 ConnBrConnection *ConnBrGetConnectionById(uint32_t connectionId)
1441 {
1442 int32_t status = SoftBusMutexLock(&g_brManager.connections->lock);
1443 CONN_CHECK_AND_RETURN_RET_LOGE(status == SOFTBUS_OK, NULL, CONN_BR,
1444 "br get connection by id: lock manager connections failed, connId=%{public}u, error=%{public}d", connectionId,
1445 status);
1446
1447 ConnBrConnection *it = NULL;
1448 ConnBrConnection *target = NULL;
1449 LIST_FOR_EACH_ENTRY(it, &g_brManager.connections->list, ConnBrConnection, node) {
1450 if (it->connectionId == connectionId) {
1451 target = it;
1452 break;
1453 }
1454 }
1455 if (target != NULL) {
1456 status = SoftBusMutexLock(&target->lock);
1457 if (status != SOFTBUS_OK) {
1458 CONN_LOGE(CONN_BR, "lock connection failed, connId=%{public}u, error=%{public}d", connectionId, status);
1459 SoftBusMutexUnlock(&g_brManager.connections->lock);
1460 return NULL;
1461 }
1462 target->objectRc += 1;
1463 SoftBusMutexUnlock(&target->lock);
1464 }
1465 SoftBusMutexUnlock(&g_brManager.connections->lock);
1466 return target;
1467 }
1468
ConnBrReturnConnection(ConnBrConnection ** connectionPtr)1469 void ConnBrReturnConnection(ConnBrConnection **connectionPtr)
1470 {
1471 CONN_CHECK_AND_RETURN_LOGW(connectionPtr != NULL, CONN_BR, "br return connection: connectionPtr is null");
1472 CONN_CHECK_AND_RETURN_LOGW(*connectionPtr != NULL, CONN_BR, "br return connection: *connectionPtr is null");
1473
1474 ConnBrConnection *connection = *connectionPtr;
1475 CONN_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&connection->lock) == SOFTBUS_OK, CONN_BR,
1476 "br return connection: lock failed, connId=%{public}u", connection->connectionId);
1477 connection->objectRc -= 1;
1478 int32_t objectRc = connection->objectRc;
1479 SoftBusMutexUnlock(&connection->lock);
1480 if (objectRc <= 0) {
1481 CONN_LOGI(CONN_BR, "release br connection. connectionId=%{public}u", connection->connectionId);
1482 ConnBrFreeConnection(connection);
1483 }
1484 *connectionPtr = NULL;
1485 }
1486
BrConnectDevice(const ConnectOption * option,uint32_t requestId,const ConnectResult * result)1487 static int32_t BrConnectDevice(const ConnectOption *option, uint32_t requestId, const ConnectResult *result)
1488 {
1489 CONN_CHECK_AND_RETURN_RET_LOGW(option != NULL, SOFTBUS_INVALID_PARAM, CONN_BR,
1490 "BrConnectDevice: option is null, requestId=%{public}u", requestId);
1491 CONN_CHECK_AND_RETURN_RET_LOGW(option->type == CONNECT_BR, SOFTBUS_INVALID_PARAM, CONN_BR,
1492 "BrConnectDevice: not br connect type, requestId=%{public}u, type=%{public}d", requestId, option->type);
1493 CONN_CHECK_AND_RETURN_RET_LOGW(result != NULL, SOFTBUS_INVALID_PARAM, CONN_BR,
1494 "BrConnectDevice: result callback is null, requestId=%{public}u", requestId);
1495 CONN_CHECK_AND_RETURN_RET_LOGW(result->OnConnectSuccessed != NULL, SOFTBUS_INVALID_PARAM, CONN_BR,
1496 "BrConnectDevice: result callback OnConnectSuccessed is null, requestId=%{public}u", requestId);
1497 CONN_CHECK_AND_RETURN_RET_LOGW(result->OnConnectFailed != NULL, SOFTBUS_INVALID_PARAM, CONN_BR,
1498 "BrConnectDevice: result callback OnConnectFailed is null, requestId=%{public}u", requestId);
1499
1500 char anomizeAddress[BT_MAC_LEN] = { 0 };
1501 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, option->brOption.brMac, BT_MAC_LEN);
1502
1503 ConnBrConnectRequestContext *ctx =
1504 (ConnBrConnectRequestContext *)SoftBusCalloc(sizeof(ConnBrConnectRequestContext));
1505 CONN_CHECK_AND_RETURN_RET_LOGE(ctx != NULL, SOFTBUS_MEM_ERR, CONN_BR,
1506 "BrConnectDevice: calloc connect request context failed: requestId=%{public}u, addr=%{public}s", requestId,
1507 anomizeAddress);
1508 uint32_t traceId = SoftbusGetConnectTraceId();
1509 ctx->statistics.startTime = SoftBusGetSysTimeMs();
1510 ctx->statistics.connectTraceId = traceId;
1511 ctx->requestId = requestId;
1512 if (strcpy_s(ctx->addr, BT_MAC_LEN, option->brOption.brMac) != EOK) {
1513 CONN_LOGE(CONN_BR, "copy address failed, requestId=%{public}u, address=%{public}s", requestId, anomizeAddress);
1514 SoftBusFree(ctx);
1515 return SOFTBUS_STRCPY_ERR;
1516 }
1517 ctx->result = *result;
1518 ctx->connectionId = option->brOption.connectionId;
1519 ctx->waitTimeoutDelay = option->brOption.waitTimeoutDelay;
1520 int32_t status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_CONNECT_REQUEST, 0, 0, ctx, 0);
1521 if (status != SOFTBUS_OK) {
1522 CONN_LOGE(CONN_BR, "post msg to looper failed, requestId=%{public}u, addr=%{public}s, error=%{public}d",
1523 requestId, anomizeAddress, status);
1524 SoftBusFree(ctx);
1525 return status;
1526 }
1527 ConnEventExtra extra = { .requestId = (int32_t)requestId,
1528 .peerBrMac = option->brOption.brMac,
1529 .linkType = CONNECT_BR,
1530 .result = EVENT_STAGE_RESULT_OK };
1531 CONN_EVENT(EVENT_SCENE_CONNECT, EVENT_STAGE_CONNECT_DEVICE, extra);
1532 CONN_LOGI(CONN_BR, "receive connect request, requestId=%{public}u, address=%{public}s, connectTraceId=%{public}u",
1533 requestId, anomizeAddress, traceId);
1534 return SOFTBUS_OK;
1535 }
1536
BrDisconnectDevice(uint32_t connectionId)1537 static int32_t BrDisconnectDevice(uint32_t connectionId)
1538 {
1539 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
1540 CONN_CHECK_AND_RETURN_RET_LOGW(connection != NULL, SOFTBUS_CONN_BR_CONNECTION_NOT_EXIST_ERR, CONN_BR,
1541 "br disconnect device: connection not exist, connId=%{public}u", connectionId);
1542 char animizeAddress[BT_MAC_LEN] = { 0 };
1543 ConvertAnonymizeMacAddress(animizeAddress, BT_MAC_LEN, connection->addr, BT_MAC_LEN);
1544 NipDisconnectDevice(connectionId);
1545 ConnBrReturnConnection(&connection);
1546 int32_t status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MGR_DISCONNECT_REQUEST, connectionId, 0, NULL, 0);
1547 CONN_LOGI(
1548 CONN_BR, "connId=%{public}u, address=%{public}s, status=%{public}d", connectionId, animizeAddress, status);
1549 return status;
1550 }
1551
BrDisconnectDeviceNow(const ConnectOption * option)1552 static int32_t BrDisconnectDeviceNow(const ConnectOption *option)
1553 {
1554 CONN_CHECK_AND_RETURN_RET_LOGW(
1555 option != NULL, SOFTBUS_INVALID_PARAM, CONN_BR, "br disconnect device now: option is null");
1556 CONN_CHECK_AND_RETURN_RET_LOGW(option->type == CONNECT_BR, SOFTBUS_INVALID_PARAM, CONN_BR,
1557 "br disconnect device now: not br type, type=%{public}d", option->type);
1558
1559 char animizeAddress[BT_MAC_LEN] = { 0 };
1560 ConvertAnonymizeMacAddress(animizeAddress, BT_MAC_LEN, option->brOption.brMac, BT_MAC_LEN);
1561 CONN_LOGI(CONN_BR, "addr=%{public}s, side=%{public}d", animizeAddress, option->brOption.sideType);
1562
1563 ConnBrConnection *connection = ConnBrGetConnectionByAddr(option->brOption.brMac, option->brOption.sideType);
1564 CONN_CHECK_AND_RETURN_RET_LOGW(connection != NULL, SOFTBUS_CONN_BR_CONNECTION_NOT_EXIST_ERR, CONN_BR,
1565 "br disconnect device now: connection not exist, address=%{public}s, side=%{public}d", animizeAddress,
1566 option->brOption.sideType);
1567 NipDisconnectDevice(connection->connectionId);
1568 ConnBrDisconnectNow(connection);
1569 ConnBrReturnConnection(&connection);
1570 return SOFTBUS_OK;
1571 }
1572
BrGetConnectionInfo(uint32_t connectionId,ConnectionInfo * info)1573 static int32_t BrGetConnectionInfo(uint32_t connectionId, ConnectionInfo *info)
1574 {
1575 CONN_CHECK_AND_RETURN_RET_LOGW(
1576 info != NULL, SOFTBUS_INVALID_PARAM, CONN_BR, "br get connection info: info is null");
1577 ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
1578 CONN_CHECK_AND_RETURN_RET_LOGW(connection != NULL, SOFTBUS_CONN_BR_CONNECTION_NOT_EXIST_ERR, CONN_BR,
1579 "br get connection info: connection not exist, connId=%{public}u", connectionId);
1580
1581 int32_t status = Convert2ConnectionInfo(connection, info);
1582 ConnBrReturnConnection(&connection);
1583 return status;
1584 }
1585
BrStartLocalListening(const LocalListenerInfo * info)1586 static int32_t BrStartLocalListening(const LocalListenerInfo *info)
1587 {
1588 (void)info;
1589 return ConnBrStartServer();
1590 }
1591
BrStopLocalListening(const LocalListenerInfo * info)1592 static int32_t BrStopLocalListening(const LocalListenerInfo *info)
1593 {
1594 (void)info;
1595 return ConnBrStopServer();
1596 }
1597
BrCheckActiveConnection(const ConnectOption * option,bool needOccupy)1598 static bool BrCheckActiveConnection(const ConnectOption *option, bool needOccupy)
1599 {
1600 CONN_CHECK_AND_RETURN_RET_LOGW(option != NULL, false, CONN_BR, "BrCheckActiveConnection: option is null");
1601 CONN_CHECK_AND_RETURN_RET_LOGW(option->type == CONNECT_BR, false, CONN_BR,
1602 "BrCheckActiveConnection: not br type, type=%{public}d", option->type);
1603
1604 char anomizeAddress[BT_MAC_LEN] = { 0 };
1605 ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, option->brOption.brMac, BT_MAC_LEN);
1606
1607 ConnBrConnection *connection = ConnBrGetConnectionByAddr(option->brOption.brMac, option->brOption.sideType);
1608 CONN_CHECK_AND_RETURN_RET_LOGW(
1609 connection != NULL, false, CONN_BR, "BrCheckActiveConnection: connection is not exist addr=%{public}s",
1610 anomizeAddress);
1611 bool isActive = (connection->state == BR_CONNECTION_STATE_CONNECTED);
1612 if (isActive && needOccupy) {
1613 ConnBrOccupy(connection);
1614 }
1615 ConnBrReturnConnection(&connection);
1616 return isActive;
1617 }
1618
ProcessAclCollisionException(ConnBrDevice * device,const char * anomizeAddress,uint32_t duration)1619 static void ProcessAclCollisionException(ConnBrDevice *device, const char *anomizeAddress, uint32_t duration)
1620 {
1621 CONN_LOGI(CONN_BR, "addr=%{public}s, duration=%{public}u", anomizeAddress, duration);
1622 ConnectOption option;
1623 (void)memset_s(&option, sizeof(option), 0, sizeof(option));
1624 option.type = CONNECT_BR;
1625 if (strcpy_s(option.brOption.brMac, BT_MAC_LEN, device->addr) != EOK) {
1626 CONN_LOGE(CONN_BR, "copy br mac fail, addr=%{public}s", anomizeAddress);
1627 return;
1628 }
1629 BrPendConnection(&option, duration);
1630 device->state = BR_DEVICE_STATE_PENDING;
1631 PendingDevice(device, anomizeAddress);
1632 }
1633
BrPendConnection(const ConnectOption * option,uint32_t time)1634 static int32_t BrPendConnection(const ConnectOption *option, uint32_t time)
1635 {
1636 CONN_CHECK_AND_RETURN_RET_LOGW((option != NULL && time != 0 && time <= BR_CONNECTION_PEND_TIMEOUT_MAX_MILLIS),
1637 SOFTBUS_INVALID_PARAM, CONN_BR, "BrPendConnection: option is null or pend time is 0");
1638 CONN_CHECK_AND_RETURN_RET_LOGW(option->type == CONNECT_BR, SOFTBUS_INVALID_PARAM, CONN_BR,
1639 "BrPendConnection: not br type, type=%{public}d", option->type);
1640
1641 char animizeAddress[BT_MAC_LEN] = { 0 };
1642 ConvertAnonymizeMacAddress(animizeAddress, BT_MAC_LEN, option->brOption.brMac, BT_MAC_LEN);
1643 CONN_LOGI(CONN_BR, "addr=%{public}s, side=%{public}d", animizeAddress, option->brOption.sideType);
1644
1645 int32_t status = SoftBusMutexLock(&g_brManager.pendings->lock);
1646 if (status != SOFTBUS_OK) {
1647 CONN_LOGE(CONN_BR, "lock pendings failed: error=%{public}d", status);
1648 return SOFTBUS_LOCK_ERR;
1649 }
1650 do {
1651 char *copyAddr = (char *)SoftBusCalloc(BT_MAC_LEN);
1652 if (copyAddr == NULL || strcpy_s(copyAddr, BT_MAC_LEN, option->brOption.brMac) != EOK) {
1653 CONN_LOGE(CONN_BR, "copy addr failed, addr=%s", animizeAddress);
1654 // it is safe, SoftBusFree will check NULL situation
1655 SoftBusFree(copyAddr);
1656 status = SOFTBUS_MALLOC_ERR;
1657 break;
1658 }
1659 BrPending *target = NULL;
1660 BrPending *it = NULL;
1661 LIST_FOR_EACH_ENTRY(it, &g_brManager.pendings->list, BrPending, node) {
1662 if (StrCmpIgnoreCase(it->addr, option->brOption.brMac) == 0) {
1663 target = it;
1664 break;
1665 }
1666 }
1667
1668 if (target != NULL) {
1669 CONN_LOGD(CONN_BR, "br pend connection, address pending, refresh timeout only, addr=%s", animizeAddress);
1670 ConnRemoveMsgFromLooper(&g_brManagerAsyncHandler, MSG_UNPEND, 0, 0, copyAddr);
1671 status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_UNPEND, 0, 0, copyAddr,
1672 (time < BR_CONNECTION_PEND_TIMEOUT_MAX_MILLIS ? time : BR_CONNECTION_PEND_TIMEOUT_MAX_MILLIS));
1673 if (status != SOFTBUS_OK) {
1674 CONN_LOGE(CONN_BR, "post msg failed, addr=%{public}s, error=%{public}d", animizeAddress, status);
1675 SoftBusFree(copyAddr);
1676 }
1677 break;
1678 }
1679
1680 BrPending *pending = (BrPending *)SoftBusCalloc(sizeof(BrPending));
1681 if (pending == NULL) {
1682 CONN_LOGE(CONN_BR, "calloc pending object failed");
1683 status = SOFTBUS_MALLOC_ERR;
1684 break;
1685 }
1686 ListInit(&pending->node);
1687 if (strcpy_s(pending->addr, BT_MAC_LEN, option->brOption.brMac) != EOK) {
1688 SoftBusFree(copyAddr);
1689 SoftBusFree(pending);
1690 status = SOFTBUS_STRCPY_ERR;
1691 break;
1692 }
1693 ListAdd(&g_brManager.pendings->list, &pending->node);
1694 g_brManager.pendings->cnt += 1;
1695 status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_UNPEND, 0, 0, copyAddr,
1696 (time < BR_CONNECTION_PEND_TIMEOUT_MAX_MILLIS ? time : BR_CONNECTION_PEND_TIMEOUT_MAX_MILLIS));
1697 if (status != SOFTBUS_OK) {
1698 CONN_LOGE(CONN_BR, "post msg to looper failed, addr=%{public}s, error=%{public}d", animizeAddress, status);
1699 SoftBusFree(copyAddr);
1700 SoftBusFree(pending);
1701 break;
1702 }
1703 CONN_LOGD(CONN_BR, "br pend connection success, address=%{public}s", animizeAddress);
1704 } while (false);
1705 SoftBusMutexUnlock(&g_brManager.pendings->lock);
1706 return status;
1707 }
1708
BrInitLooper(void)1709 static int32_t BrInitLooper(void)
1710 {
1711 g_brManagerAsyncHandler.handler.looper = GetLooper(LOOP_TYPE_CONN);
1712 if (g_brManagerAsyncHandler.handler.looper == NULL) {
1713 return SOFTBUS_LOOPER_ERR;
1714 }
1715 return SOFTBUS_OK;
1716 }
1717
DumpLocalBtMac(void)1718 static void DumpLocalBtMac(void)
1719 {
1720 SoftBusBtAddr addr = { 0 };
1721 int32_t status = SoftBusGetBtMacAddr(&addr);
1722 if (status != SOFTBUS_OK) {
1723 CONN_LOGE(CONN_BR, "get bt Smac failed, error=%{public}d", status);
1724 return;
1725 }
1726 char myBtMac[BT_MAC_LEN] = { 0 };
1727 status = ConvertBtMacToStr(myBtMac, BT_MAC_LEN, addr.addr, sizeof(addr.addr));
1728 if (status != SOFTBUS_OK) {
1729 CONN_LOGW(CONN_BR, "convert bt mac to str fail, error=%{public}d", status);
1730 return;
1731 }
1732 char anomizeMyAddress[BT_MAC_LEN] = { 0 };
1733 ConvertAnonymizeMacAddress(anomizeMyAddress, BT_MAC_LEN, myBtMac, BT_MAC_LEN);
1734 CONN_LOGD(CONN_BR, "local bt address, anomizeMyAddress=%{public}s", anomizeMyAddress);
1735 }
1736
OnBtStateChanged(int listenerId,int state)1737 static void OnBtStateChanged(int listenerId, int state)
1738 {
1739 (void)listenerId;
1740 int32_t status = SOFTBUS_OK;
1741 if (state == SOFTBUS_BR_STATE_TURN_ON) {
1742 g_brStateTurnOn = true;
1743 DumpLocalBtMac();
1744 status = ConnBrStartServer();
1745 CONN_LOGI(CONN_BR, "recv bt on, start server, status=%{public}d", status);
1746 return;
1747 }
1748
1749 if (state == SOFTBUS_BR_STATE_TURN_OFF) {
1750 g_brStateTurnOn = false;
1751 status = ConnBrStopServer();
1752 CONN_LOGI(CONN_BR, "recv bt off, stop server, status=%{public}d", status);
1753
1754 ErrorContext *ctx = (ErrorContext *)SoftBusCalloc(sizeof(ErrorContext));
1755 if (ctx == NULL) {
1756 CONN_LOGE(CONN_BR, "calloc ctx object failed");
1757 return;
1758 }
1759 ctx->error = SOFTBUS_CONN_BLUETOOTH_OFF;
1760 status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MSG_RESET, 0, 0, ctx, 0);
1761 if (status != SOFTBUS_OK) {
1762 CONN_LOGE(CONN_BR, "post msg to looper failed");
1763 SoftBusFree(ctx);
1764 }
1765 return;
1766 }
1767 }
1768
InitBrManager()1769 static int32_t InitBrManager()
1770 {
1771 SoftBusList *connections = CreateSoftBusList();
1772 SoftBusList *pendings = CreateSoftBusList();
1773 CONN_CHECK_AND_RETURN_RET_LOGE(
1774 connections != NULL && pendings != NULL, SOFTBUS_CREATE_LIST_ERR,
1775 CONN_INIT, "InitBrManager: create list failed");
1776 g_brManager.connections = connections;
1777 g_brManager.pendings = pendings;
1778 ListInit(&g_brManager.waitings);
1779 g_brManager.state = NULL;
1780 g_brManager.connecting = NULL;
1781
1782 static SoftBusBtStateListener listener = {
1783 .OnBtAclStateChanged = NULL,
1784 .OnBtStateChanged = OnBtStateChanged,
1785 };
1786 int32_t listenerId = SoftBusAddBtStateListener(&listener);
1787 CONN_CHECK_AND_RETURN_RET_LOGW(listenerId >= 0, SOFTBUS_CONN_BR_INTERNAL_ERR, CONN_INIT,
1788 "InitBrManager: add bt state change listener failed, invalid listenerId=%{public}d", listenerId);
1789 TransitionToState(BR_STATE_AVAILABLE);
1790 return SOFTBUS_OK;
1791 }
1792
CheckConnCallbackPara(const ConnectCallback * callback)1793 static int32_t CheckConnCallbackPara(const ConnectCallback *callback)
1794 {
1795 CONN_CHECK_AND_RETURN_RET_LOGW(callback != NULL, SOFTBUS_INVALID_PARAM, CONN_INIT,
1796 "ConnInitBr: callback is null");
1797 CONN_CHECK_AND_RETURN_RET_LOGW(callback->OnConnected != NULL, SOFTBUS_INVALID_PARAM, CONN_INIT,
1798 "ConnInitBr: callback OnConnected is null");
1799 CONN_CHECK_AND_RETURN_RET_LOGW(callback->OnDisconnected != NULL, SOFTBUS_INVALID_PARAM, CONN_INIT,
1800 "ConnInitBr: callback OnDisconnected is null");
1801 CONN_CHECK_AND_RETURN_RET_LOGW(callback->OnDataReceived != NULL, SOFTBUS_INVALID_PARAM, CONN_INIT,
1802 "ConnInitBr: callback OnDataReceived is null");
1803 return SOFTBUS_OK;
1804 }
1805
InitBrEventListener(void)1806 static int32_t InitBrEventListener(void)
1807 {
1808 int32_t ret = BrInitLooper();
1809 CONN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_CONN_BR_INTERNAL_ERR, CONN_INIT,
1810 "ConnInitBr: init looper failed, error=%{public}d", ret);
1811 SppSocketDriver *sppDriver = InitSppSocketDriver();
1812 CONN_CHECK_AND_RETURN_RET_LOGE(sppDriver != NULL, SOFTBUS_CONN_BR_INTERNAL_ERR, CONN_INIT,
1813 "ConnInitBr: init spp socket driver failed");
1814
1815 ConnBrEventListener connectionEventListener = {
1816 .onServerAccepted = OnServerAccepted,
1817 .onClientConnected = OnClientConnected,
1818 .onClientConnectFailed = OnClientConnectFailed,
1819 .onDataReceived = OnDataReceived,
1820 .onConnectionException = OnConnectionException,
1821 .onConnectionResume = OnConnectionResume,
1822 };
1823 ret = ConnBrConnectionMuduleInit(g_brManagerAsyncHandler.handler.looper, sppDriver, &connectionEventListener);
1824 CONN_CHECK_AND_RETURN_RET_LOGE(
1825 ret == SOFTBUS_OK, ret, CONN_INIT, "ConnInitBr: init connection failed, error=%{public}d ", ret);
1826
1827 ConnBrTransEventListener transEventListener = {
1828 .onPostByteFinshed = OnPostByteFinshed,
1829 };
1830 ret = ConnBrTransMuduleInit(sppDriver, &transEventListener);
1831 CONN_CHECK_AND_RETURN_RET_LOGE(
1832 ret == SOFTBUS_OK, ret, CONN_INIT, "ConnInitBr: init trans failed, error=%{public}d", ret);
1833 return SOFTBUS_OK;
1834 }
1835
ConnInitBr(const ConnectCallback * callback)1836 ConnectFuncInterface *ConnInitBr(const ConnectCallback *callback)
1837 {
1838 CONN_CHECK_AND_RETURN_RET_LOGW(
1839 CheckConnCallbackPara(callback) == SOFTBUS_OK, NULL, CONN_INIT, "ConnInitBr callback para failed");
1840 CONN_CHECK_AND_RETURN_RET_LOGE(
1841 InitBrEventListener() == SOFTBUS_OK, NULL, CONN_INIT, "InitBrEventListener init failed");
1842
1843 int32_t ret = InitBrManager();
1844 CONN_CHECK_AND_RETURN_RET_LOGE(
1845 ret == SOFTBUS_OK, NULL, CONN_INIT, "ConnInitBr: init manager failed, error=%{public}d", ret);
1846 ret = ConnBrInitBrPendingPacket();
1847 CONN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, NULL, CONN_INIT,
1848 "conn init br failed: init pending packet failed, error=%{public}d", ret);
1849
1850 g_connectCallback = *callback;
1851 static ConnectFuncInterface connectFuncInterface = {
1852 .ConnectDevice = BrConnectDevice,
1853 .PostBytes = ConnBrPostBytes,
1854 .DisconnectDevice = BrDisconnectDevice,
1855 .DisconnectDeviceNow = BrDisconnectDeviceNow,
1856 .GetConnectionInfo = BrGetConnectionInfo,
1857 .StartLocalListening = BrStartLocalListening,
1858 .StopLocalListening = BrStopLocalListening,
1859 .CheckActiveConnection = BrCheckActiveConnection,
1860 .UpdateConnection = NULL,
1861 .PreventConnection = BrPendConnection,
1862 .ConfigPostLimit = ConnBrTransConfigPostLimit,
1863 };
1864 CONN_LOGI(CONN_INIT, "ok");
1865 return &connectFuncInterface;
1866 }
1867