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 /**
17 * @file att_connect.c
18 *
19 * @brief implement connect function to be called.
20 *
21 */
22
23 #include "att_connect.h"
24
25 #include <string.h>
26
27 #include "log.h"
28
29 #include "platform/include/allocator.h"
30
31 typedef struct AttDisconnectReqAsync {
32 uint16_t connectHandle;
33 } AttDisconnectReqAsync;
34
35 typedef struct AttConnectRspAsync {
36 uint16_t connectHandle;
37 uint16_t result;
38 uint16_t status;
39 AttConnect *g_attConnectParaObj;
40 } AttConnectRspAsync;
41
42 typedef struct AttConnectReqAsync {
43 uint8_t transportType;
44 AttConnect *connParaPtr;
45 BtAddr *btAddress;
46 uint16_t *bredrconnectHandle;
47 } AttConnectReqAsync;
48
49 typedef struct AttLeConnectedAsyncContext {
50 BtAddr *addr;
51 uint16_t aclHandle;
52 uint8_t role;
53 uint8_t status;
54 } AttLeConnectedAsyncContext;
55
56 typedef struct AttLeDisconnectedAsyncContext {
57 uint16_t aclHandle;
58 uint8_t status;
59 uint8_t reason;
60 } AttLeDisconnectedAsyncContext;
61
62 typedef struct DisconnectRespCallbackContext {
63 uint16_t lcid;
64 int result;
65 } DisconnectRespCallbackContext;
66
67 typedef struct ConnectCallBackContext {
68 BtAddr *addr;
69 int result;
70 } ConnectCallBackContext;
71
72 typedef struct ConnectReqCallbackContext {
73 BtAddr *addr;
74 uint16_t lcid;
75 int result;
76 } ConnectReqCallbackContext;
77
78 typedef struct ConfigReqCallbackContext {
79 uint16_t lcid;
80 int result;
81 } ConfigReqCallbackContext;
82
83 typedef struct ConnectRspResultCallbackContext {
84 uint16_t lcid;
85 int result;
86 } ConnectRspResultCallbackContext;
87
88 typedef struct BREDRDisconnectReqCallBackContext {
89 uint16_t lcid;
90 int result;
91 void *context;
92 } BREDRDisconnectReqCallBackContext;
93
94 typedef struct LeDisconnectReqCallBackContext {
95 uint16_t aclHandle;
96 int result;
97 } LeDisconnectReqCallBackContext;
98
99 typedef struct ConnectRspPendingContext {
100 uint16_t lcid;
101 int result;
102 } ConnectRspPendingContext;
103
104 typedef struct AttReceiveConnectReqContext {
105 uint16_t lcid;
106 uint8_t id;
107 L2capConnectionInfo *info;
108 uint16_t lpsm;
109 void *ctx;
110 } AttReceiveConnectReqContext;
111
112 typedef struct AttReceiveConnectionRspContext {
113 uint16_t lcid;
114 L2capConnectionInfo *info;
115 uint16_t result;
116 uint16_t status;
117 void *ctx;
118 } AttReceiveConnectionRspContext;
119
120 typedef struct AttReceiveConfigRspContext {
121 uint16_t lcid;
122 L2capConfigInfo *info;
123 uint16_t result;
124 void *ctx;
125 } AttReceiveConfigRspContext;
126
127 typedef struct AttReceiveDisconnectReqContext {
128 uint16_t lcid;
129 uint8_t id;
130 void *ctx;
131 } AttReceiveDisconnectReqContext;
132
133 typedef struct AttDisconnectAbnormalContext {
134 uint16_t lcid;
135 uint8_t reason;
136 void *ctx;
137 } AttDisconnectAbnormalContext;
138
139 typedef struct AttRecvDisconnectionRspContext {
140 uint16_t lcid;
141 void *ctx;
142 } AttRecvDisconnectionRspContext;
143
144 typedef struct ConfigRspCallbackContext {
145 uint16_t lcid;
146 int result;
147 } ConfigRspCallbackContext;
148
149 typedef struct AttReceiveConfigReqContext {
150 uint16_t lcid;
151 uint8_t id;
152 L2capConfigInfo *cfg;
153 void *ctx;
154 } AttReceiveConfigReqContext;
155
156 typedef struct ConnectTimeOutContext {
157 uint16_t connectHandle;
158 } ConnectTimeOutContext;
159
160 typedef struct ConnectCancelContext {
161 BtAddr addr;
162 } ConnectCancelContext;
163
164 typedef struct GAPSecCallbackContext {
165 uint16_t result;
166 GapServiceSecurityInfo serviceInfo;
167 uint16_t connectHandle;
168 } GAPSecCallbackContext;
169
170 static void AttRecvConfigReqAssignBredrConnect(const L2capConfigInfo *cfg, AttConnectingInfo *connecting);
171 static void AttClearConnectingInfo(AttConnectingInfo *connecting);
172 static void AttClearConnectInfo(AttConnectInfo *connect);
173 static int AttBredrConnectStatusChange(uint8_t inputStatus, uint8_t *outStatus, uint8_t flag);
174 static void AttCopyToConnectingInfo(
175 const BtAddr *addr, uint16_t aclHandle, uint16_t lcid, uint8_t id, AttConnectingInfo *connecting);
176
177 static void AttAssignGAPRequestSecurity(
178 GapRequestSecurityParam *gapSecurity, uint8_t direction, const AttConnectingInfo *connecting);
179
180 static void AttConnectReqAssignBredrConnect(AttConnectingInfo **connecting, const BtAddr *btAddress,
181 const AttConnect *connParaPtr, uint16_t *bredrconnectHandle);
182 static void AttConnectRequestLEParaAssign(
183 L2capLeConnectionParameter *l2capObjptr, const AttConnectReqAsync *attConnectReqAsyncPtr);
184
185 static void GAPSecCallback(uint16_t result, GapServiceSecurityInfo serviceInfo, const void *context);
186
187 static int AttBredrConnectProcess(AttConnectingInfo *connecting);
188 static void AttBredrConnectTimeOut(void *parameter);
189 static void AttConnectCompletedCallback(AttConnectingInfo *connecting, uint16_t result);
190 static void AttCopyToConnectInfo(const AttConnectingInfo *connecting, AttConnectInfo **connect);
191 static void AttConnectInfoAddLe(
192 const BtAddr *addr, uint16_t aclHandle, AttConnectInfo **connect, uint8_t initPassConnFlag);
193
194 static void L2cifConnectReqCallback(const BtAddr *addr, uint16_t lcid, int result, const void *context);
195 static void L2cifConnectRspPendingCallback(uint16_t lcid, int result);
196 static void L2cifConnectRspResultCallback(uint16_t lcid, int result);
197 static void L2cifConfigReqCallback(uint16_t lcid, int result);
198 static void L2cifConfigRspCallback(uint16_t lcid, int result);
199
200 static int AttLeConnectProcess(const BtAddr *addr, L2capLeConnectionParameter var, const AttConnectingInfo *connecting);
201 static void DisconnectRespCallback(uint16_t lcid, int result);
202
203 static void AttConnectRequestAsync(const void *context);
204 static void AttConnectRequestAsyncDestroy(const void *context);
205 static void AttConnectRsponseAsync(const void *context);
206 static void AttConnectRsponseAsyncDestroy(const void *context);
207 static void AttDisconnectRequestAsync(const void *context);
208 static void AttDisconnectRequestAsyncDestroy(const void *context);
209 static void AttLeConnectedAsync(const void *context);
210 static void AttLeConnectedAsyncDestroy(const void *context);
211 static void AttLeDisconnectedAsync(const void *context);
212 static void AttLeDisconnectedAsyncDestroy(const void *context);
213 static void DisconnectRespCallbackAsync(const void *context);
214 static void DisconnectRespCallbackAsyncDestroy(const void *context);
215 static void L2cifLeConnectCallBackAsync(const void *context);
216 static void L2cifLeConnectCallBackAsyncDestroy(const void *context);
217 static void L2cifConnectReqCallbackAsync(const void *context);
218 static void L2cifConnectReqCallbackAsyncDestroy(const void *context);
219 static void L2cifConfigReqCallbackAsync(const void *context);
220 static void L2cifConfigReqCallbackAsyncDestroy(const void *context);
221 static void L2cifConnectRspResultCallbackAsync(const void *context);
222 static void L2cifConnectRspResultCallbackAsyncDestroy(const void *context);
223 static void L2cifConnectRspPendingCallbackAsync(const void *context);
224 static void L2cifConnectRspPendingCallbackAsyncDestroy(const void *context);
225 static void AttReceiveConnectionReqAsync(const void *context);
226 static void AttReceiveConnectionReqAsyncDestroy(const void *context);
227 static void AttReceiveConnectionRspAsync(const void *context);
228 static void AttReceiveConnectionRspAsyncDestroy(const void *context);
229 static void AttReceiveConfigRspAsync(const void *context);
230 static void AttReceiveConfigRspAsyncDestroy(const void *context);
231 static void AttReceiveDisconnectionReqAsync(const void *context);
232 static void AttReceiveDisconnectionReqAsyncDestroy(const void *context);
233 static void AttDisconnectAbnormalAsync(const void *context);
234 static void AttDisconnectAbnormalAsyncDestroy(const void *context);
235 static void AttRecvDisconnectionRspAsync(const void *context);
236 static void AttRecvDisconnectionRspAsyncDestroy(const void *context);
237 static void L2cifConfigRspCallbackAsync(const void *context);
238 static void L2cifConfigRspCallbackAsyncDestroy(const void *context);
239 static void AttReceiveConfigReqAsync(const void *context);
240 static void AttReceiveConfigReqAsyncDestroy(const void *context);
241 static void AttBredrConnectTimeOutAsync(const void *context);
242 static void AttBredrConnectTimeOutAsyncDestroy(const void *context);
243 static void GAPSecCallbackAsync(const void *context);
244 static void GAPSecCallbackAsyncDestroy(const void *context);
245
246 /**
247 * @brief disconnect response call back async.
248 *
249 * @param ctx Indicates the pointer to context.
250 */
DisconnectRespCallbackAsync(const void * context)251 static void DisconnectRespCallbackAsync(const void *context)
252 {
253 LOG_INFO("%{public}s enter", __FUNCTION__);
254
255 DisconnectRespCallbackContext *disConnectRspPtr = (DisconnectRespCallbackContext *)context;
256 AttBredrDisconnectCallback bredrDisConnObj;
257 int listSize;
258 AttConnectedCallback *attConnectCallback = NULL;
259 AttConnectInfo *connect = NULL;
260
261 AttGetConnectInfoIndexByCid(disConnectRspPtr->lcid, &connect);
262
263 if (connect == NULL) {
264 goto DISCONNECTRESPCALLBACK_END;
265 }
266
267 AlarmCancel(connect->alarm);
268
269 attConnectCallback = AttGetATTConnectCallback();
270 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attBREDRDisconnectCompleted == NULL)) {
271 LOG_WARN("%{public}s attConnectCallback or attBREDRDisconnectCompleted is NULL", __FUNCTION__);
272 } else {
273 if (disConnectRspPtr->result == BT_SUCCESS) {
274 bredrDisConnObj.reason = PASSIVECONNECT_DISCONNECT_SUCCESS;
275 } else {
276 bredrDisConnObj.reason = PASSIVECONNECT_DISCONNECT_FAIL;
277 }
278 attConnectCallback->attConnect.attBREDRDisconnectCompleted(
279 connect->retGattConnectHandle, &bredrDisConnObj, attConnectCallback->context);
280 }
281
282 listSize = ListGetSize(connect->instruct);
283 for (; listSize > 0; --listSize) {
284 ListRemoveLast(connect->instruct);
285 }
286 AttClearConnectInfo(connect);
287
288 DISCONNECTRESPCALLBACK_END:
289 MEM_MALLOC.free(disConnectRspPtr);
290 return;
291 }
292
293 /**
294 * @brief disconnect response call back async destroy.
295 *
296 * @param ctx Indicates the pointer to context.
297 */
DisconnectRespCallbackAsyncDestroy(const void * context)298 static void DisconnectRespCallbackAsyncDestroy(const void *context)
299 {
300 LOG_INFO("%{public}s enter", __FUNCTION__);
301
302 DisconnectRespCallbackContext *disConnectRspPtr = (DisconnectRespCallbackContext *)context;
303
304 MEM_MALLOC.free(disConnectRspPtr);
305
306 return;
307 }
308
309 /**
310 * @brief disconnect response call back.
311 *
312 * @param1 lcid Indicates the lcid.
313 * @param2 result Indicates the result.
314 */
DisconnectRespCallback(uint16_t lcid,int result)315 static void DisconnectRespCallback(uint16_t lcid, int result)
316 {
317 LOG_INFO("%{public}s enter", __FUNCTION__);
318
319 DisconnectRespCallbackContext *disConnectRspPtr = MEM_MALLOC.alloc(sizeof(DisconnectRespCallbackContext));
320 if (disConnectRspPtr == NULL) {
321 LOG_ERROR("point to NULL");
322 return;
323 }
324 disConnectRspPtr->lcid = lcid;
325 disConnectRspPtr->result = result;
326
327 AttAsyncProcess(DisconnectRespCallbackAsync, DisconnectRespCallbackAsyncDestroy, disConnectRspPtr);
328
329 return;
330 }
331
332 /**
333 * @brief att assign bredr connect receive config request parameter.
334 *
335 * @param1 cfg Indicates the pointer to const L2capConfigInfo.
336 * @param2 connecting Indicates the pointer to AttConnectingInfo.
337 */
AttRecvConfigReqAssignBredrConnect(const L2capConfigInfo * cfg,AttConnectingInfo * connecting)338 static void AttRecvConfigReqAssignBredrConnect(const L2capConfigInfo *cfg, AttConnectingInfo *connecting)
339 {
340 LOG_INFO("%{public}s enter", __FUNCTION__);
341
342 connecting->remotel2capConfigInfoObj.mtu = cfg->mtu;
343 connecting->remotel2capConfigInfoObj.flushTimeout = cfg->flushTimeout;
344 connecting->remotel2capConfigInfoObj.rfc.mode = cfg->rfc.mode;
345 connecting->mtu = Min(connecting->locall2capConfigInfoObj.mtu, connecting->remotel2capConfigInfoObj.mtu);
346
347 return;
348 }
349
350 /**
351 * @brief att clear connecting information.
352 *
353 * @param connecting Indicates the pointer to AttConnectingInfo.
354 */
AttClearConnectingInfo(AttConnectingInfo * connecting)355 static void AttClearConnectingInfo(AttConnectingInfo *connecting)
356 {
357 LOG_INFO("%{public}s enter", __FUNCTION__);
358
359 connecting->aclHandle = 0;
360 connecting->cid = 0;
361 connecting->id = 0;
362 connecting->mtu = 0;
363 connecting->connectHandle = 0;
364 connecting->initiativeConnectStatus = 0;
365 connecting->passiveConnectSatatus = 0;
366 connecting->initPassConnFlag = 0;
367 (void)memset_s(
368 &connecting->locall2capConfigInfoObj, sizeof(connecting->locall2capConfigInfoObj), 0, sizeof(L2capConfigInfo));
369 (void)memset_s(&connecting->remotel2capConfigInfoObj,
370 sizeof(connecting->remotel2capConfigInfoObj),
371 0,
372 sizeof(L2capConfigInfo));
373 (void)memset_s(&connecting->addr, sizeof(connecting->addr), 0, sizeof(BtAddr));
374
375 if (connecting->transportType == BT_TRANSPORT_BR_EDR) {
376 if (connecting->bredrAlarm != NULL) {
377 AlarmCancel(connecting->bredrAlarm);
378 }
379 }
380
381 return;
382 }
383
384 /**
385 * @brief att clear connected information.
386 *
387 * @param connect Indicates the pointer to AttConnectInfo.
388 */
AttClearConnectInfo(AttConnectInfo * connect)389 static void AttClearConnectInfo(AttConnectInfo *connect)
390 {
391 LOG_INFO("%{public}s enter", __FUNCTION__);
392
393 connect->aclHandle = 0;
394 connect->AttConnectID.bredrcid = 0;
395 connect->AttConnectID.lecid = 0;
396 connect->retGattConnectHandle = 0;
397 connect->transportType = 0;
398 connect->mtu = 0;
399 connect->mtuFlag = false;
400 connect->initPassConnFlag = 0;
401 connect->sendMtu = 0;
402 connect->receiveMtu = 0;
403 connect->serverSendFlag = false;
404 (void)memset_s(&connect->addr, sizeof(connect->addr), 0, sizeof(BtAddr));
405
406 if (connect->alarm != NULL) {
407 AlarmCancel(connect->alarm);
408 }
409
410 return;
411 }
412
413 /**
414 * @brief att bredr connect statuc change.
415 *
416 * @param1 inputStatus Indicates the input parameter.
417 * @param2 outStatus Indicates the pointer to output parameter.
418 * @param3 flag Indicates the flag of connect mode.
419 * @return Returns <b>0</b> if the operation is successful; returns <b>!0</b> if the operation fails.
420 */
AttBredrConnectStatusChange(uint8_t inputStatus,uint8_t * outStatus,uint8_t flag)421 static int AttBredrConnectStatusChange(uint8_t inputStatus, uint8_t *outStatus, uint8_t flag)
422 {
423 LOG_INFO("%{public}s enter,inputStatus = %hhu,flag=%hhu", __FUNCTION__, inputStatus, flag);
424
425 int ret = BT_OPERATION_FAILED;
426
427 if (flag == INITIATIVECONNECT) {
428 if (inputStatus == DISCONNECTED) {
429 ret = BT_OPERATION_FAILED;
430 goto ATTBREDRCONNECTSTATUSCHANGE_END;
431 }
432 if (inputStatus == CONNECTING) {
433 *outStatus = CONFIGED;
434 } else if (inputStatus == CONFIGED) {
435 *outStatus = CONNECTED;
436 }
437 } else if (flag == PASSIVECONNECT) {
438 if (inputStatus == DISCONNECTED) {
439 ret = BT_OPERATION_FAILED;
440 goto ATTBREDRCONNECTSTATUSCHANGE_END;
441 }
442 if (inputStatus == CONNECTIND) {
443 *outStatus = CONFIGED;
444 } else if (inputStatus == CONFIGED) {
445 *outStatus = CONNECTED;
446 }
447 }
448
449 ret = BT_SUCCESS;
450
451 ATTBREDRCONNECTSTATUSCHANGE_END:
452 return ret;
453 }
454
455 /**
456 * @brief att connecting information storage.
457 *
458 * @param1 addr Indicates the pointer to BtAddr.
459 * @param2 aclHandle Indicates the aclHandle.
460 * @param3 lcid Indicates the lcid.
461 * @param4 id Indicates the id.
462 * @param5 connecting Indicates the pointer to AttConnectingInfo.
463 */
AttCopyToConnectingInfo(const BtAddr * addr,uint16_t aclHandle,uint16_t lcid,uint8_t id,AttConnectingInfo * connecting)464 static void AttCopyToConnectingInfo(
465 const BtAddr *addr, uint16_t aclHandle, uint16_t lcid, uint8_t id, AttConnectingInfo *connecting)
466 {
467 LOG_INFO("%{public}s enter,aclHandle=%hu,lcid=%hu,id=%hhu", __FUNCTION__, aclHandle, lcid, id);
468
469 uint16_t index = 0;
470
471 AttGetConnectingIndexByCidOutIndex(0, &index, &connecting);
472
473 if (connecting != NULL) {
474 connecting->cid = lcid;
475 (void)memcpy_s(connecting->addr.addr, ADDRESSLEN, addr->addr, ADDRESSLEN);
476 connecting->addr.type = addr->type;
477 connecting->connectHandle = index + 1;
478 connecting->initPassConnFlag = PASSIVECONNECT;
479 connecting->passiveConnectSatatus = DISCONNECTED;
480 connecting->id = id;
481 connecting->aclHandle = aclHandle;
482 connecting->mtu = DEFAULTBREDRMTU;
483 }
484
485 return;
486 }
487
488 /**
489 * @brief gap security callback async.
490 *
491 * @param ctx Indicates the pointer to context.
492 */
GAPSecCallbackAsync(const void * context)493 static void GAPSecCallbackAsync(const void *context)
494 {
495 LOG_INFO("%{public}s enter", __FUNCTION__);
496
497 GAPSecCallbackContext *gapSecCallbackPtr = (GAPSecCallbackContext *)context;
498 AttConnectingInfo *connecting = NULL;
499 AttConnectedCallback *attConnectCallback = NULL;
500 AttBredrConnectCallback bredrConnectCallback;
501
502 AttGetConnectingIndexByConnectHandle(gapSecCallbackPtr->connectHandle, &connecting);
503 attConnectCallback = AttGetATTConnectCallback();
504
505 if (gapSecCallbackPtr->result != 0) {
506 LOG_INFO("%{public}s gap security authen callback error", __FUNCTION__);
507 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attBREDRConnectCompleted == NULL)) {
508 LOG_WARN("%{public}s attConnectCallback or attBREDRConnectCompleted is NULL", __FUNCTION__);
509 goto GAPSECCALLBACK_END;
510 }
511 bredrConnectCallback.addr.type = connecting->addr.type;
512 (void)memcpy_s(bredrConnectCallback.addr.addr, ADDRESSLEN, connecting->addr.addr, ADDRESSLEN);
513 bredrConnectCallback.status = SECURITY_AUTHENTICATION_FAIL;
514 bredrConnectCallback.mtu = DEFAULTBREDRMTU;
515 attConnectCallback->attConnect.attBREDRConnectCompleted(
516 connecting->connectHandle, &bredrConnectCallback, attConnectCallback->context);
517 AttClearConnectingInfo(connecting);
518 goto GAPSECCALLBACK_END;
519 }
520
521 if (connecting->initPassConnFlag == INITIATIVECONNECT) {
522 AttBredrConnectProcess(connecting);
523 } else if (connecting->initPassConnFlag == PASSIVECONNECT) {
524 if (connecting->passiveConnectSatatus == DISCONNECTED) {
525 connecting->passiveConnectSatatus = CONNECTIND;
526 }
527 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attBREDRConnectInd == NULL)) {
528 LOG_WARN("%{public}s attConnectCallback or attConnectCallback->attConnect.attBREDRConnectInd is NULL",
529 __FUNCTION__);
530 goto GAPSECCALLBACK_END;
531 }
532
533 attConnectCallback->attConnect.attBREDRConnectInd(connecting->connectHandle, attConnectCallback->context);
534 }
535
536 GAPSECCALLBACK_END:
537 MEM_MALLOC.free(gapSecCallbackPtr);
538 return;
539 }
540
541 /**
542 * @brief gap security callback async destroy.
543 *
544 * @param ctx Indicates the pointer to context.
545 */
GAPSecCallbackAsyncDestroy(const void * context)546 static void GAPSecCallbackAsyncDestroy(const void *context)
547 {
548 LOG_INFO("%{public}s enter", __FUNCTION__);
549
550 GAPSecCallbackContext *gapSecCallbackPtr = (GAPSecCallbackContext *)context;
551
552 MEM_MALLOC.free(gapSecCallbackPtr);
553
554 return;
555 }
556
557 /**
558 * @brief gap security callback.
559 *
560 * @param1 result Indicates the result.
561 * @param2 serviceInfo Indicates the struct GapServiceSecurityInfo.
562 * @param3 context Indicates the pointer to context.
563 */
GAPSecCallback(uint16_t result,GapServiceSecurityInfo serviceInfo,const void * context)564 static void GAPSecCallback(uint16_t result, GapServiceSecurityInfo serviceInfo, const void *context)
565 {
566 LOG_INFO("%{public}s enter,result = %hu", __FUNCTION__, result);
567
568 uint16_t connectHandle = *(uint16_t *)context;
569 GAPSecCallbackContext *gapSecCallbackPtr = MEM_MALLOC.alloc(sizeof(GAPSecCallbackContext));
570 if (gapSecCallbackPtr == NULL) {
571 LOG_ERROR("point to NULL");
572 return;
573 }
574
575 gapSecCallbackPtr->result = result;
576 (void)memcpy_s(&(gapSecCallbackPtr->serviceInfo),
577 sizeof(gapSecCallbackPtr->serviceInfo),
578 &serviceInfo,
579 sizeof(GapServiceSecurityInfo));
580 gapSecCallbackPtr->connectHandle = connectHandle;
581
582 AttAsyncProcess(GAPSecCallbackAsync, GAPSecCallbackAsyncDestroy, gapSecCallbackPtr);
583
584 return;
585 }
586
587 /**
588 * @brief assign gap request security parameter.
589 *
590 * @param1 gapSecurity Indicates the pointer to GapRequestSecurityParam.
591 * @param2 direction Indicates the direction.
592 * @param3 connecting Indicates the pointer to AttConnectingInfo.
593 */
AttAssignGAPRequestSecurity(GapRequestSecurityParam * gapSecurity,uint8_t direction,const AttConnectingInfo * connecting)594 static void AttAssignGAPRequestSecurity(
595 GapRequestSecurityParam *gapSecurity, uint8_t direction, const AttConnectingInfo *connecting)
596 {
597 LOG_INFO("%{public}s enter,direction = %hhu", __FUNCTION__, direction);
598
599 if (direction == OUTGOING) {
600 gapSecurity->info.direction = OUTGOING;
601 gapSecurity->info.serviceId = GATT_CLIENT;
602 } else if (direction == INCOMING) {
603 gapSecurity->info.direction = INCOMING;
604 gapSecurity->info.serviceId = GATT_SERVER;
605 }
606 gapSecurity->info.protocolId = SEC_PROTOCOL_L2CAP;
607 gapSecurity->info.channelId.l2capPsm = 0x001F;
608 gapSecurity->callback = (void (*)(uint16_t, GapServiceSecurityInfo, void *))GAPSecCallback;
609 gapSecurity->context = &(((AttConnectingInfo *)connecting)->connectHandle);
610
611 return;
612 }
613
614 /**
615 * @brief assign bredr connecting request parameter.
616 *
617 * @param1 connecting Indicates the pointer to AttConnectingInfo.
618 * @param2 btAddress Indicates the pointer to const BtAddr.
619 * @param3 connParaPtr Indicates the pointer to const AttConnect.
620 * @param4 bredrconnectHandle Indicates the pointer to bredr connecthandle.
621 */
AttConnectReqAssignBredrConnect(AttConnectingInfo ** connecting,const BtAddr * btAddress,const AttConnect * connParaPtr,uint16_t * bredrconnectHandle)622 static void AttConnectReqAssignBredrConnect(AttConnectingInfo **connecting, const BtAddr *btAddress,
623 const AttConnect *connParaPtr, uint16_t *bredrconnectHandle)
624 {
625 LOG_INFO("%{public}s enter", __FUNCTION__);
626
627 uint16_t index = 0;
628
629 AttGetConnectingIndexByCidConnectHandle(0, 0, &index, connecting);
630
631 if (*connecting == NULL) {
632 goto ATTCONNECTREQASSIGNBREDRCONNECT_END;
633 }
634
635 (void)memcpy_s((*connecting)->addr.addr, ADDRESSLEN, btAddress->addr, ADDRESSLEN);
636 (*connecting)->addr.type = btAddress->type;
637 (*connecting)->connectHandle = index + 1;
638 *bredrconnectHandle = index + 1;
639 (*connecting)->initPassConnFlag = INITIATIVECONNECT;
640 (*connecting)->initiativeConnectStatus = CONNECTING;
641 (*connecting)->locall2capConfigInfoObj.mtu = connParaPtr->bredrConnParaVar.mtu;
642 (*connecting)->locall2capConfigInfoObj.flushTimeout = connParaPtr->bredrConnParaVar.flushTimeout;
643 (*connecting)->locall2capConfigInfoObj.rfc.mode = connParaPtr->bredrConnParaVar.mode;
644 (*connecting)->mtu = DEFAULTBREDRMTU;
645 (*connecting)->transportType = BT_TRANSPORT_BR_EDR;
646
647 ATTCONNECTREQASSIGNBREDRCONNECT_END:
648 return;
649 }
650
651 /**
652 * @brief att bredr connect timeout async.
653 *
654 * @param ctx Indicates the pointer to context.
655 */
AttBredrConnectTimeOutAsync(const void * context)656 static void AttBredrConnectTimeOutAsync(const void *context)
657 {
658 LOG_INFO("%{public}s enter", __FUNCTION__);
659
660 ConnectTimeOutContext *attBredrTimeOutPtr = (ConnectTimeOutContext *)context;
661 AttConnectingInfo *connecting = NULL;
662
663 AttGetConnectingIndexByConnectHandle(attBredrTimeOutPtr->connectHandle, &connecting);
664
665 if (connecting == NULL) {
666 LOG_INFO("%{public}s connecting == NULL and goto ATTBREDRCONNECTTIMEOUT_END", __FUNCTION__);
667 goto ATTBREDRCONNECTTIMEOUT_END;
668 }
669
670 AttConnectCompletedCallback(connecting, ATT_CONNECT_TIMEOUT);
671
672 ATTBREDRCONNECTTIMEOUT_END:
673 MEM_MALLOC.free(attBredrTimeOutPtr);
674 return;
675 }
676
677 /**
678 * @brief att bredr connect timeout async destroy.
679 *
680 * @param ctx Indicates the pointer to context.
681 */
AttBredrConnectTimeOutAsyncDestroy(const void * context)682 static void AttBredrConnectTimeOutAsyncDestroy(const void *context)
683 {
684 LOG_INFO("%{public}s enter", __FUNCTION__);
685
686 ConnectTimeOutContext *attBredrTimeOutPtr = (ConnectTimeOutContext *)context;
687
688 MEM_MALLOC.free(attBredrTimeOutPtr);
689
690 return;
691 }
692
693 /**
694 * @brief att bredr connect timeout.
695 *
696 * @param parameter Indicates the pointer to parameter.
697 */
AttBredrConnectTimeOut(void * parameter)698 static void AttBredrConnectTimeOut(void *parameter)
699 {
700 LOG_INFO("%{public}s enter", __FUNCTION__);
701
702 AttConnectingInfo *connecting = (AttConnectingInfo *)parameter;
703 ConnectTimeOutContext *attBredrTimeOutPtr = MEM_MALLOC.alloc(sizeof(ConnectTimeOutContext));
704 if (attBredrTimeOutPtr == NULL) {
705 LOG_ERROR("point to NULL");
706 return;
707 }
708 attBredrTimeOutPtr->connectHandle = connecting->connectHandle;
709
710 AttAsyncProcess(AttBredrConnectTimeOutAsync, AttBredrConnectTimeOutAsyncDestroy, attBredrTimeOutPtr);
711
712 return;
713 }
714
715 /**
716 * @brief att connect completed call back.
717 *
718 * @param1 connecting Indicates the pointer to AttConnectingInfo.
719 * @param2 result Indicates the result.
720 */
AttConnectCompletedCallback(AttConnectingInfo * connecting,uint16_t result)721 static void AttConnectCompletedCallback(AttConnectingInfo *connecting, uint16_t result)
722 {
723 LOG_INFO("%{public}s enter, result = %hu", __FUNCTION__, result);
724
725 AttConnectInfo *connect = NULL;
726
727 if (connecting == NULL) {
728 LOG_INFO("%{public}s enter, result = %hu", __FUNCTION__, result);
729 return;
730 }
731
732 if (result != ATT_CONNECT_TIMEOUT) {
733 AlarmCancel(connecting->bredrAlarm);
734 }
735
736 AttBredrConnectCallback bredrConnectCallback;
737 AttConnectedCallback *attConnectCallback = AttGetATTConnectCallback();
738 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attBREDRConnectCompleted == NULL)) {
739 LOG_WARN("%{public}s attConnectCallback or attBREDRConnectCompleted is NULL", __FUNCTION__);
740 goto ATTCONNECTCOMPLETEDCALLBACK_END;
741 }
742
743 (void)memcpy_s(bredrConnectCallback.addr.addr, ADDRESSLEN, connecting->addr.addr, ADDRESSLEN);
744 bredrConnectCallback.addr.type = connecting->addr.type;
745 bredrConnectCallback.status = result;
746 bredrConnectCallback.mtu = connecting->mtu;
747
748 if (result == BREDR_CONNECT_SUCCESS) {
749 AttCopyToConnectInfo(connecting, &connect);
750 if (connect == NULL) {
751 goto ATTCONNECTCOMPLETEDCALLBACK_END;
752 }
753 attConnectCallback->attConnect.attBREDRConnectCompleted(
754 connect->retGattConnectHandle, &bredrConnectCallback, attConnectCallback->context);
755 goto ATTCONNECTCOMPLETEDCALLBACK_END;
756 }
757 if (connecting->initPassConnFlag == INITIATIVECONNECT) {
758 if (connecting->initiativeConnectStatus == DISCONNECTED) {
759 goto ATTCONNECTCOMPLETEDCALLBACK_END;
760 } else {
761 attConnectCallback->attConnect.attBREDRConnectCompleted(
762 connecting->connectHandle, &bredrConnectCallback, attConnectCallback->context);
763 }
764 }
765 if (connecting->initPassConnFlag == PASSIVECONNECT) {
766 if (connecting->passiveConnectSatatus == DISCONNECTED) {
767 goto ATTCONNECTCOMPLETEDCALLBACK_END;
768 } else {
769 attConnectCallback->attConnect.attBREDRConnectCompleted(
770 connecting->connectHandle, &bredrConnectCallback, attConnectCallback->context);
771 }
772 }
773
774 ATTCONNECTCOMPLETEDCALLBACK_END:
775 AttClearConnectingInfo(connecting);
776 return;
777 }
778
779 /**
780 * @brief att copy to connected.
781 *
782 * @param connecting Indicates the pointer to AttConnectingInfo.
783 */
AttCopyToConnectInfo(const AttConnectingInfo * connecting,AttConnectInfo ** connect)784 static void AttCopyToConnectInfo(const AttConnectingInfo *connecting, AttConnectInfo **connect)
785 {
786 LOG_INFO("%{public}s enter ", __FUNCTION__);
787
788 uint16_t index = 0;
789
790 AttGetConnectInfoIndexByCidOutIndex(0, &index, connect);
791
792 if (*connect == NULL) {
793 LOG_INFO("%{public}s connect == NULL", __FUNCTION__);
794 goto ATTCOPYTOCONNECTINFO_END;
795 }
796
797 (*connect)->aclHandle = connecting->aclHandle;
798 (*connect)->AttConnectID.bredrcid = connecting->cid;
799 (*connect)->retGattConnectHandle = index + 1;
800 (*connect)->transportType = BT_TRANSPORT_BR_EDR;
801 (*connect)->initPassConnFlag = connecting->initPassConnFlag;
802 (*connect)->addr.type = connecting->addr.type;
803 (void)memcpy_s((*connect)->addr.addr, ADDRESSLEN, connecting->addr.addr, ADDRESSLEN);
804 (*connect)->mtu = connecting->mtu;
805
806 ATTCOPYTOCONNECTINFO_END:
807 return;
808 }
809
810 /**
811 * @brief add le connect information to AttConnectInfo.
812 *
813 * @param1 addr Indicates the pointer to const BtAddr.
814 * @param2 aclHandle Indicates the aclHandle.
815 * @param3 connect Indicates the secondary pointer to AttConnectInfo.
816 */
AttConnectInfoAddLe(const BtAddr * addr,uint16_t aclHandle,AttConnectInfo ** connect,uint8_t initPassConnFlag)817 static void AttConnectInfoAddLe(
818 const BtAddr *addr, uint16_t aclHandle, AttConnectInfo **connect, uint8_t initPassConnFlag)
819 {
820 LOG_INFO("%{public}s enter,aclHandle = %hu", __FUNCTION__, aclHandle);
821
822 uint16_t index = 0;
823 AttGetConnectInfoIndexByConnectHandle(0, &index, connect);
824
825 if ((*connect) == NULL) {
826 LOG_INFO("%{public}s *connect == NULL", __FUNCTION__);
827 goto ATTCONNECTINFOADDLE_END;
828 }
829
830 (*connect)->aclHandle = aclHandle;
831 (*connect)->AttConnectID.lecid = LE_CID;
832 (*connect)->retGattConnectHandle = index + 1;
833 (*connect)->transportType = BT_TRANSPORT_LE;
834 (*connect)->addr.type = addr->type;
835 (*connect)->mtu = DEFAULTLEATTMTU;
836 (*connect)->initPassConnFlag = initPassConnFlag;
837 (void)memcpy_s((*connect)->addr.addr, ADDRESSLEN, addr->addr, ADDRESSLEN);
838
839 ATTCONNECTINFOADDLE_END:
840 return;
841 }
842
843 /**
844 * @brief call l2cap interface for le connect call back async.
845 *
846 * @param ctx Indicates the pointer to context.
847 */
L2cifLeConnectCallBackAsync(const void * context)848 static void L2cifLeConnectCallBackAsync(const void *context)
849 {
850 LOG_INFO("%{public}s enter", __FUNCTION__);
851
852 ConnectCallBackContext *connectCallContextPtr = (ConnectCallBackContext *)context;
853 AttConnectingInfo *connecting = NULL;
854 AttLeConnectCallback data;
855 AttConnectedCallback *attConnectCallback = NULL;
856
857 AttGetConnectingIndexByAddr(connectCallContextPtr->addr, &connecting);
858
859 if (connecting == NULL) {
860 goto L2CIFLECONNECTCALLBACK_END;
861 }
862
863 attConnectCallback = AttGetATTConnectCallback();
864 if (connectCallContextPtr->result == BT_SUCCESS) {
865 connecting->transportType = BT_TRANSPORT_LE;
866 } else {
867 LOG_WARN("%{public}s:L2CIF_ConnectReq error", __FUNCTION__);
868 (void)memcpy_s(&data.addr, sizeof(BtAddr), connectCallContextPtr->addr, sizeof(BtAddr));
869 data.status = LE_CONNECT_FAIL;
870 attConnectCallback->attConnect.attLEConnectCompleted(0, &data, attConnectCallback->context);
871 AttClearConnectingInfo(connecting);
872 }
873
874 L2CIFLECONNECTCALLBACK_END:
875 MEM_MALLOC.free(connectCallContextPtr->addr);
876 MEM_MALLOC.free(connectCallContextPtr);
877 return;
878 }
879
880 /**
881 * @brief call l2cap interface for le connect call back async destroy.
882 *
883 * @param ctx Indicates the pointer to context.
884 */
L2cifLeConnectCallBackAsyncDestroy(const void * context)885 static void L2cifLeConnectCallBackAsyncDestroy(const void *context)
886 {
887 LOG_INFO("%{public}s enter", __FUNCTION__);
888
889 ConnectCallBackContext *connectCallContextPtr = (ConnectCallBackContext *)context;
890
891 MEM_MALLOC.free(connectCallContextPtr->addr);
892 MEM_MALLOC.free(connectCallContextPtr);
893
894 return;
895 }
896
897 /**
898 * @brief call l2cap interface for le connect call back.
899 *
900 * @param1 addr Indicates the pointer to const BtAddr.
901 * @param2 result Indicates the result.
902 */
L2cifLeConnectCallBack(const BtAddr * addr,int result)903 void L2cifLeConnectCallBack(const BtAddr *addr, int result)
904 {
905 LOG_INFO("%{public}s enter result = %{public}d", __FUNCTION__, result);
906
907 BtAddr *btaddr = NULL;
908 ConnectCallBackContext *connectCallContextPtr = NULL;
909
910 btaddr = MEM_MALLOC.alloc(sizeof(BtAddr));
911 if (btaddr == NULL) {
912 LOG_ERROR("point to NULL");
913 return;
914 }
915 (void)memcpy_s(btaddr->addr, ADDRESSLEN, addr, ADDRESSLEN);
916 btaddr->type = addr->type;
917
918 connectCallContextPtr = MEM_MALLOC.alloc(sizeof(ConnectCallBackContext));
919 if (connectCallContextPtr == NULL) {
920 LOG_ERROR("point to NULL");
921 return;
922 }
923 connectCallContextPtr->addr = btaddr;
924 connectCallContextPtr->result = result;
925
926 AttAsyncProcess(L2cifLeConnectCallBackAsync, L2cifLeConnectCallBackAsyncDestroy, connectCallContextPtr);
927
928 return;
929 }
930
931 /**
932 * @brief call l2cap interface for le connect.
933 *
934 * @param1 addr Indicates the pointer to const BtAddr.
935 * @param2 var Indicates the struct L2capLeConnectionParameter.
936 * @param3 connecting Indicates the pointer to AttConnectingInfo.
937 * @return Returns <b>0</b> if the operation is successful; returns <b>!0</b> if the operation fails.
938 */
AttLeConnectProcess(const BtAddr * addr,L2capLeConnectionParameter var,const AttConnectingInfo * connecting)939 static int AttLeConnectProcess(const BtAddr *addr, L2capLeConnectionParameter var, const AttConnectingInfo *connecting)
940 {
941 LOG_INFO("%{public}s enter", __FUNCTION__);
942
943 int ret;
944
945 ret = L2CIF_LeConnect(addr, &var, L2cifLeConnectCallBack);
946
947 return ret;
948 }
949
950 /**
951 * @brief callback of bredr connect request async.
952 *
953 * @param ctx Indicates the pointer to context.
954 */
L2cifConnectReqCallbackAsync(const void * context)955 static void L2cifConnectReqCallbackAsync(const void *context)
956 {
957 LOG_INFO("%{public}s enter", __FUNCTION__);
958
959 ConnectReqCallbackContext *connectReqContextPtr = NULL;
960 AttConnectingInfo *connecting = NULL;
961
962 connectReqContextPtr = (ConnectReqCallbackContext *)context;
963 AttGetConnectingIndexByAddrUninitializedCid(connectReqContextPtr->addr, &connecting);
964
965 if (connecting == NULL) {
966 goto L2CIFCONNECTREQCALLBACK_END;
967 }
968
969 if (connectReqContextPtr->result == BT_SUCCESS) {
970 connecting->cid = connectReqContextPtr->lcid;
971 connecting->transportType = BT_TRANSPORT_BR_EDR;
972 connecting->mtu = DEFAULTBREDRMTU;
973 } else {
974 LOG_WARN("%{public}s:L2CIF_ConnectReq error", __FUNCTION__);
975 AlarmCancel(connecting->bredrAlarm);
976 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
977 AttClearConnectingInfo(connecting);
978 }
979
980 L2CIFCONNECTREQCALLBACK_END:
981 MEM_MALLOC.free(connectReqContextPtr->addr);
982 MEM_MALLOC.free(connectReqContextPtr);
983 return;
984 }
985
986 /**
987 * @brief callback of bredr connect request async destroy.
988 *
989 * @param ctx Indicates the pointer to context.
990 */
L2cifConnectReqCallbackAsyncDestroy(const void * context)991 static void L2cifConnectReqCallbackAsyncDestroy(const void *context)
992 {
993 LOG_INFO("%{public}s enter", __FUNCTION__);
994
995 ConnectReqCallbackContext *connectReqContextPtr = (ConnectReqCallbackContext *)context;
996
997 MEM_MALLOC.free(connectReqContextPtr->addr);
998 MEM_MALLOC.free(connectReqContextPtr);
999
1000 return;
1001 }
1002
1003 /**
1004 * @brief callback of bredr connect request.
1005 *
1006 * @param addr Indicates the pointer to BtAddr.
1007 * @param lcid Indicates the lcid.
1008 * @param result Indicates the result.
1009 */
L2cifConnectReqCallback(const BtAddr * addr,uint16_t lcid,int result,const void * context)1010 static void L2cifConnectReqCallback(const BtAddr *addr, uint16_t lcid, int result, const void *context)
1011 {
1012 LOG_INFO("%{public}s enter", __FUNCTION__);
1013
1014 BtAddr *btaddr = NULL;
1015 ConnectReqCallbackContext *connectReqContextPtr = NULL;
1016
1017 btaddr = MEM_MALLOC.alloc(sizeof(BtAddr));
1018 if (btaddr == NULL) {
1019 LOG_ERROR("point to NULL");
1020 return;
1021 }
1022 (void)memcpy_s(btaddr->addr, ADDRESSLEN, addr, ADDRESSLEN);
1023 btaddr->type = addr->type;
1024
1025 connectReqContextPtr = MEM_MALLOC.alloc(sizeof(ConnectReqCallbackContext));
1026 if (connectReqContextPtr == NULL) {
1027 LOG_ERROR("point to NULL");
1028 return;
1029 }
1030 connectReqContextPtr->addr = btaddr;
1031 connectReqContextPtr->lcid = lcid;
1032 connectReqContextPtr->result = result;
1033
1034 AttAsyncProcess(L2cifConnectReqCallbackAsync, L2cifConnectReqCallbackAsyncDestroy, connectReqContextPtr);
1035
1036 return;
1037 }
1038
1039 /**
1040 * @brief call l2cap interface for bredr connect.
1041 *
1042 * @param connecting Indicates the pointer to AttConnectingInfo.
1043 * @return Returns <b>0</b> if the operation is successful; returns <b>!0</b> if the operation fails.
1044 */
AttBredrConnectProcess(AttConnectingInfo * connecting)1045 static int AttBredrConnectProcess(AttConnectingInfo *connecting)
1046 {
1047 LOG_INFO("%{public}s enter", __FUNCTION__);
1048
1049 int ret;
1050
1051 AlarmSet(connecting->bredrAlarm, (uint64_t)CONNECTTIMEOUT, AttBredrConnectTimeOut, connecting);
1052
1053 ret = L2CIF_ConnectReq(&(connecting->addr),
1054 BT_PSM_ATT,
1055 BT_PSM_ATT,
1056 NULL,
1057 (void (*)(const BtAddr *, uint16_t, int, void *))L2cifConnectReqCallback);
1058
1059 return ret;
1060 }
1061
1062 /**
1063 * @brief gatt send connect request para assign.
1064 *
1065 * @param1 l2capObjptr Indicates the pointer to L2capLeConnectionParameter.
1066 * @param2 attConnectReqAsyncPtr Indicates the pointer to AttConnectReqAsync.
1067 */
AttConnectRequestLEParaAssign(L2capLeConnectionParameter * l2capObjptr,const AttConnectReqAsync * attConnectReqAsyncPtr)1068 static void AttConnectRequestLEParaAssign(
1069 L2capLeConnectionParameter *l2capObjptr, const AttConnectReqAsync *attConnectReqAsyncPtr)
1070 {
1071 LOG_INFO("%{public}s enter", __FUNCTION__);
1072
1073 l2capObjptr->connIntervalMin = attConnectReqAsyncPtr->connParaPtr->leConnParaVar.connIntervalMin;
1074 l2capObjptr->connIntervalMax = attConnectReqAsyncPtr->connParaPtr->leConnParaVar.connIntervalMax;
1075 l2capObjptr->connLatency = attConnectReqAsyncPtr->connParaPtr->leConnParaVar.connLatency;
1076 l2capObjptr->supervisionTimeout = attConnectReqAsyncPtr->connParaPtr->leConnParaVar.supervisionTimeout;
1077
1078 return;
1079 }
1080
1081 /**
1082 * @brief send connect request in self thread.
1083 *
1084 * @param context Indicates the pointer to context.
1085 */
AttConnectRequestAsync(const void * context)1086 static void AttConnectRequestAsync(const void *context)
1087 {
1088 LOG_INFO("%{public}s enter", __FUNCTION__);
1089
1090 uint16_t index;
1091 L2capLeConnectionParameter l2capObj;
1092 GapRequestSecurityParam gapReqSecurity;
1093 AttConnectingInfo *connecting = NULL;
1094 AttConnectReqAsync *attConnectReqAsyncPtr = (AttConnectReqAsync *)context;
1095
1096 if (attConnectReqAsyncPtr->btAddress == NULL) {
1097 LOG_WARN("%{public}s:btAddress == NULL and goto ATT_CONNECTREQ_END", __FUNCTION__);
1098 goto ATT_CONNECTREQ_END;
1099 }
1100
1101 if (attConnectReqAsyncPtr->transportType == BT_TRANSPORT_BR_EDR) {
1102 AttConnectReqAssignBredrConnect(&connecting,
1103 attConnectReqAsyncPtr->btAddress,
1104 attConnectReqAsyncPtr->connParaPtr,
1105 attConnectReqAsyncPtr->bredrconnectHandle);
1106 AttAssignGAPRequestSecurity(&gapReqSecurity, OUTGOING, connecting);
1107 GAPIF_RequestSecurityAsync(&(connecting->addr), &gapReqSecurity);
1108 } else if (attConnectReqAsyncPtr->transportType == BT_TRANSPORT_LE) {
1109 AttConnectRequestLEParaAssign(&l2capObj, attConnectReqAsyncPtr);
1110 connecting = AttGetConnectingStart();
1111 for (index = 0; index < MAXCONNECT; ++index, connecting++) {
1112 if (connecting->connectHandle == 0) {
1113 (void)memcpy_s(connecting->addr.addr, ADDRESSLEN, attConnectReqAsyncPtr->btAddress->addr, ADDRESSLEN);
1114 connecting->addr.type = attConnectReqAsyncPtr->btAddress->type;
1115 connecting->connectHandle = index + 1;
1116 connecting->transportType = BT_TRANSPORT_LE;
1117 connecting->cid = LE_CID;
1118 connecting->initPassConnFlag = INITIATIVECONNECT;
1119 break;
1120 }
1121 }
1122 AttLeConnectProcess(attConnectReqAsyncPtr->btAddress, l2capObj, connecting);
1123 }
1124
1125 ATT_CONNECTREQ_END:
1126
1127 MEM_MALLOC.free(attConnectReqAsyncPtr->connParaPtr);
1128 MEM_MALLOC.free(attConnectReqAsyncPtr->btAddress);
1129 MEM_MALLOC.free(attConnectReqAsyncPtr->bredrconnectHandle);
1130 MEM_MALLOC.free(attConnectReqAsyncPtr);
1131
1132 return;
1133 }
1134
1135 /**
1136 * @brief destroy connect request data in self thread.
1137 *
1138 * @param context Indicates the pointer to context.
1139 */
AttConnectRequestAsyncDestroy(const void * context)1140 static void AttConnectRequestAsyncDestroy(const void *context)
1141 {
1142 LOG_INFO("%{public}s enter", __FUNCTION__);
1143
1144 AttConnectReqAsync *attConnectReqAsyncPtr = (AttConnectReqAsync *)context;
1145
1146 MEM_MALLOC.free(attConnectReqAsyncPtr->connParaPtr);
1147 MEM_MALLOC.free(attConnectReqAsyncPtr->btAddress);
1148 MEM_MALLOC.free(attConnectReqAsyncPtr->bredrconnectHandle);
1149 MEM_MALLOC.free(attConnectReqAsyncPtr);
1150
1151 return;
1152 }
1153
1154 /**
1155 * @brief gatt send connect request to att.
1156 *
1157 * @param1 transportType Indicates the connect type.
1158 * @param2 connParaPtr Indicates the pointer to connect parameter.
1159 * @param3 btAddress Indicates the pointer to address.
1160 * @param4 bredrconnectHandle Indicates the pointer to connecthandle be outputted.
1161 * @return Returns the result of connect request.
1162 */
ATT_ConnectReq(uint8_t transportType,const AttConnect * connParaPtr,const BtAddr * btAddress,const uint16_t * bredrconnectHandle)1163 void ATT_ConnectReq(
1164 uint8_t transportType, const AttConnect *connParaPtr, const BtAddr *btAddress, const uint16_t *bredrconnectHandle)
1165 {
1166 LOG_INFO("%{public}s enter", __FUNCTION__);
1167
1168 AttConnect *connectAsyncPtr = MEM_MALLOC.alloc(sizeof(AttConnect));
1169 BtAddr *btAddrAsyncPtr = MEM_MALLOC.alloc(sizeof(BtAddr));
1170 uint16_t *bredrConnectHandleAsyncPtr = MEM_MALLOC.alloc(sizeof(uint16_t));
1171 AttConnectReqAsync *attConnectReqAsyncPtr = MEM_MALLOC.alloc(sizeof(AttConnectReqAsync));
1172 if (connectAsyncPtr == NULL) {
1173 LOG_ERROR("point to NULL");
1174 return;
1175 }
1176 if (btAddrAsyncPtr == NULL) {
1177 LOG_ERROR("point to NULL");
1178 return;
1179 }
1180 if (bredrConnectHandleAsyncPtr == NULL) {
1181 LOG_ERROR("point to NULL");
1182 return;
1183 }
1184 if (attConnectReqAsyncPtr == NULL) {
1185 LOG_ERROR("point to NULL");
1186 return;
1187 }
1188
1189 if (transportType == BT_TRANSPORT_BR_EDR) {
1190 connectAsyncPtr->bredrConnParaVar = connParaPtr->bredrConnParaVar;
1191 } else if (transportType == BT_TRANSPORT_LE) {
1192 connectAsyncPtr->leConnParaVar = connParaPtr->leConnParaVar;
1193 }
1194
1195 (void)memcpy_s(btAddrAsyncPtr, sizeof(BtAddr), btAddress, sizeof(BtAddr));
1196
1197 attConnectReqAsyncPtr->transportType = transportType;
1198 attConnectReqAsyncPtr->connParaPtr = connectAsyncPtr;
1199 attConnectReqAsyncPtr->btAddress = btAddrAsyncPtr;
1200 attConnectReqAsyncPtr->bredrconnectHandle = bredrConnectHandleAsyncPtr;
1201
1202 AttAsyncProcess(AttConnectRequestAsync, AttConnectRequestAsyncDestroy, attConnectReqAsyncPtr);
1203
1204 return;
1205 }
1206
1207 /**
1208 * @brief gatt send connect request to att async.
1209 *
1210 * @param ctx Indicates the pointer to context.
1211 */
L2cifConfigReqCallbackAsync(const void * context)1212 static void L2cifConfigReqCallbackAsync(const void *context)
1213 {
1214 LOG_INFO("%{public}s enter", __FUNCTION__);
1215
1216 AttConnectingInfo *connecting = NULL;
1217 ConfigReqCallbackContext *configReqPtr = (ConfigReqCallbackContext *)context;
1218
1219 AttGetConnectingIndexByCid(configReqPtr->lcid, &connecting);
1220
1221 if (connecting == NULL) {
1222 goto L2CIFCONFIGREQCALLBACK_END;
1223 }
1224
1225 if (configReqPtr->result != BT_SUCCESS) {
1226 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
1227 AttClearConnectingInfo(connecting);
1228 }
1229
1230 L2CIFCONFIGREQCALLBACK_END:
1231 MEM_MALLOC.free(configReqPtr);
1232 return;
1233 }
1234
1235 /**
1236 * @brief gatt send connect request to att async destroy.
1237 *
1238 * @param ctx Indicates the pointer to context.
1239 */
L2cifConfigReqCallbackAsyncDestroy(const void * context)1240 static void L2cifConfigReqCallbackAsyncDestroy(const void *context)
1241 {
1242 LOG_INFO("%{public}s enter", __FUNCTION__);
1243
1244 ConfigReqCallbackContext *configReqPtr = (ConfigReqCallbackContext *)context;
1245
1246 MEM_MALLOC.free(configReqPtr);
1247
1248 return;
1249 }
1250
1251 /**
1252 * @brief gatt send connect request to att.
1253 *
1254 * @param1 lcid Indicates the connect lcid.
1255 * @param2 result Indicates the variable of result.
1256 */
L2cifConfigReqCallback(uint16_t lcid,int result)1257 static void L2cifConfigReqCallback(uint16_t lcid, int result)
1258 {
1259 LOG_INFO("%{public}s enter, lcid = %hu, result = %{public}d", __FUNCTION__, lcid, result);
1260
1261 ConfigReqCallbackContext *configReqPtr = MEM_MALLOC.alloc(sizeof(ConfigReqCallbackContext));
1262 if (configReqPtr == NULL) {
1263 LOG_ERROR("point to NULL");
1264 return;
1265 }
1266
1267 configReqPtr->lcid = lcid;
1268 configReqPtr->result = result;
1269
1270 AttAsyncProcess(L2cifConfigReqCallbackAsync, L2cifConfigReqCallbackAsyncDestroy, configReqPtr);
1271
1272 return;
1273 }
1274
1275 /**
1276 * @brief gatt send connect response to att async.
1277 *
1278 * @param ctx Indicates the pointer to context.
1279 */
L2cifConnectRspResultCallbackAsync(const void * context)1280 static void L2cifConnectRspResultCallbackAsync(const void *context)
1281 {
1282 LOG_INFO("%{public}s enter", __FUNCTION__);
1283
1284 AttConnectingInfo *connecting = NULL;
1285 ConnectRspResultCallbackContext *connectRspPtr = (ConnectRspResultCallbackContext *)context;
1286
1287 AttGetConnectingIndexByCid(connectRspPtr->lcid, &connecting);
1288
1289 if (connecting == NULL) {
1290 goto L2CIFCONNECTRSPRESULTCALLBACK_END;
1291 }
1292
1293 if (connectRspPtr->result == L2CAP_SUCCESS) {
1294 L2CIF_ConfigReq(connecting->cid, &(connecting->locall2capConfigInfoObj), L2cifConfigReqCallback);
1295 }
1296
1297 L2CIFCONNECTRSPRESULTCALLBACK_END:
1298 MEM_MALLOC.free(connectRspPtr);
1299 return;
1300 }
1301
1302 /**
1303 * @brief gatt send connect response to att async destroy.
1304 *
1305 * @param ctx Indicates the pointer to context.
1306 */
L2cifConnectRspResultCallbackAsyncDestroy(const void * context)1307 static void L2cifConnectRspResultCallbackAsyncDestroy(const void *context)
1308 {
1309 LOG_INFO("%{public}s enter", __FUNCTION__);
1310
1311 ConnectRspResultCallbackContext *connectRspPtr = (ConnectRspResultCallbackContext *)context;
1312
1313 MEM_MALLOC.free(connectRspPtr);
1314
1315 return;
1316 }
1317
1318 /**
1319 * @brief gatt send connect response to att.
1320 *
1321 * @param1 lcid Indicates the connect lcid.
1322 * @param2 result Indicates the variable of result.
1323 */
L2cifConnectRspResultCallback(uint16_t lcid,int result)1324 static void L2cifConnectRspResultCallback(uint16_t lcid, int result)
1325 {
1326 LOG_INFO("%{public}s enter, lcid = %hu, result = %{public}d", __FUNCTION__, lcid, result);
1327
1328 ConnectRspResultCallbackContext *connectRspPtr = MEM_MALLOC.alloc(sizeof(ConnectRspResultCallbackContext));
1329 if (connectRspPtr == NULL) {
1330 LOG_ERROR("point to NULL");
1331 return;
1332 }
1333
1334 connectRspPtr->lcid = lcid;
1335 connectRspPtr->result = result;
1336
1337 AttAsyncProcess(L2cifConnectRspResultCallbackAsync, L2cifConnectRspResultCallbackAsyncDestroy, connectRspPtr);
1338
1339 return;
1340 }
1341
1342 /**
1343 * @brief perform the connect rsp operation in self thread.
1344 *
1345 * @param context Indicates the pointer to context.
1346 */
AttConnectRsponseAsync(const void * context)1347 static void AttConnectRsponseAsync(const void *context)
1348 {
1349 LOG_INFO("%{public}s enter", __FUNCTION__);
1350
1351 AttConnectingInfo *connecting = NULL;
1352 AttConnectRspAsync *attConnectRspAsyncPtr = (AttConnectRspAsync *)context;
1353
1354 AttGetConnectingIndexByConnectHandle(attConnectRspAsyncPtr->connectHandle, &connecting);
1355
1356 if (connecting == NULL) {
1357 LOG_INFO("connecting == NULL and goto ATTCONNECTRSP_END");
1358 goto ATTCONNECTRSP_END;
1359 }
1360
1361 connecting->locall2capConfigInfoObj.mtu = attConnectRspAsyncPtr->g_attConnectParaObj->bredrConnParaVar.mtu;
1362 connecting->locall2capConfigInfoObj.flushTimeout =
1363 attConnectRspAsyncPtr->g_attConnectParaObj->bredrConnParaVar.flushTimeout;
1364 connecting->locall2capConfigInfoObj.rfc.mode = attConnectRspAsyncPtr->g_attConnectParaObj->bredrConnParaVar.mode;
1365
1366 L2CIF_ConnectRsp(connecting->cid,
1367 connecting->id,
1368 attConnectRspAsyncPtr->result,
1369 attConnectRspAsyncPtr->status,
1370 L2cifConnectRspResultCallback);
1371
1372 ATTCONNECTRSP_END:
1373
1374 MEM_MALLOC.free(attConnectRspAsyncPtr->g_attConnectParaObj);
1375 MEM_MALLOC.free(attConnectRspAsyncPtr);
1376 return;
1377 }
1378
1379 /**
1380 * @brief destroy connect response data in self thread.
1381 *
1382 * @param context Indicates the pointer to context.
1383 */
AttConnectRsponseAsyncDestroy(const void * context)1384 static void AttConnectRsponseAsyncDestroy(const void *context)
1385 {
1386 LOG_INFO("%{public}s enter", __FUNCTION__);
1387
1388 AttConnectRspAsync *attConnectRspAsyncPtr = (AttConnectRspAsync *)context;
1389
1390 MEM_MALLOC.free(attConnectRspAsyncPtr->g_attConnectParaObj);
1391 MEM_MALLOC.free(attConnectRspAsyncPtr);
1392
1393 return;
1394 }
1395
1396 /**
1397 * @brief gatt send connect response to att.
1398 *
1399 * @param1 connectHandle Indicates the connect handle.
1400 * @param2 result Indicates the variable of result.
1401 * @param3 status Indicates the result of status.
1402 * @param4 g_attConnectParaObj Indicates the pointer to connect parameter.
1403 * @return Returns the result of connect response.
1404 */
ATT_ConnectRsp(uint16_t connectHandle,uint16_t result,uint16_t status,const AttConnect * cfg)1405 void ATT_ConnectRsp(uint16_t connectHandle, uint16_t result, uint16_t status, const AttConnect *cfg)
1406 {
1407 LOG_INFO("%{public}s enter,connectHandle = %hu,result = %hu,status=%hu, mtu = %{public}d",
1408 __FUNCTION__,
1409 connectHandle,
1410 result,
1411 status,
1412 cfg->bredrConnParaVar.mtu);
1413
1414 AttConnect *attConnectBredrConnPtr = NULL;
1415 AttConnectRspAsync *attConnectRspAsyncPtr = NULL;
1416
1417 attConnectBredrConnPtr = MEM_MALLOC.alloc(sizeof(AttConnect));
1418 attConnectRspAsyncPtr = MEM_MALLOC.alloc(sizeof(AttConnectRspAsync));
1419 if (attConnectBredrConnPtr == NULL) {
1420 LOG_ERROR("point to NULL");
1421 return;
1422 }
1423 if (attConnectRspAsyncPtr == NULL) {
1424 LOG_ERROR("point to NULL");
1425 return;
1426 }
1427
1428 attConnectBredrConnPtr->bredrConnParaVar.mtu = cfg->bredrConnParaVar.mtu;
1429 attConnectBredrConnPtr->bredrConnParaVar.flushTimeout = cfg->bredrConnParaVar.flushTimeout;
1430 attConnectBredrConnPtr->bredrConnParaVar.mode = cfg->bredrConnParaVar.mode;
1431
1432 attConnectRspAsyncPtr->connectHandle = connectHandle;
1433 attConnectRspAsyncPtr->result = result;
1434 attConnectRspAsyncPtr->status = status;
1435 attConnectRspAsyncPtr->g_attConnectParaObj = attConnectBredrConnPtr;
1436
1437 AttAsyncProcess(AttConnectRsponseAsync, AttConnectRsponseAsyncDestroy, attConnectRspAsyncPtr);
1438
1439 return;
1440 }
1441
1442 /**
1443 * @brief gatt send disconnect request to att async.
1444 *
1445 * @param ctx Indicates the pointer to context.
1446 */
L2cifBREDRDisconnectReqCallBackAsync(const void * context)1447 void L2cifBREDRDisconnectReqCallBackAsync(const void *context)
1448 {
1449 LOG_INFO("%{public}s enter", __FUNCTION__);
1450
1451 AttConnectInfo *connect = NULL;
1452 BREDRDisconnectReqCallBackContext *disBredrConnectReqPtr = (BREDRDisconnectReqCallBackContext *)context;
1453 AttBredrDisconnectCallback BredrData;
1454 AttConnectedCallback *attConnectCallback = NULL;
1455
1456 AttGetConnectInfoIndexByCid(disBredrConnectReqPtr->lcid, &connect);
1457
1458 if (connect == NULL) {
1459 goto L2CIFDISCONNECTREQCALLBACK_END;
1460 }
1461
1462 attConnectCallback = AttGetATTConnectCallback();
1463 if (disBredrConnectReqPtr->result != BT_SUCCESS) {
1464 if (connect->transportType == BT_TRANSPORT_BR_EDR) {
1465 BredrData.reason = INITIATIVECONNECT_DISCONNECT_FAIL;
1466 attConnectCallback->attConnect.attBREDRDisconnectCompleted(
1467 connect->retGattConnectHandle, &BredrData, attConnectCallback->context);
1468 }
1469 }
1470
1471 L2CIFDISCONNECTREQCALLBACK_END:
1472 MEM_MALLOC.free(disBredrConnectReqPtr);
1473 return;
1474 }
1475
1476 /**
1477 * @brief gatt send disconnect request to att async destroy.
1478 *
1479 * @param ctx Indicates the pointer to context.
1480 */
L2cifBREDRDisconnectReqCallBackAsyncDestroy(const void * context)1481 void L2cifBREDRDisconnectReqCallBackAsyncDestroy(const void *context)
1482 {
1483 LOG_INFO("%{public}s enter", __FUNCTION__);
1484
1485 BREDRDisconnectReqCallBackContext *disBredrConnectReqPtr = (BREDRDisconnectReqCallBackContext *)context;
1486
1487 MEM_MALLOC.free(disBredrConnectReqPtr);
1488
1489 return;
1490 }
1491
1492 /**
1493 * @brief gatt send disconnect request to att.
1494 *
1495 * @param lcid Indicates the connect lcid.
1496 * @return Returns the result of disconnect request.
1497 */
L2cifBREDRDisconnectReqCallBack(uint16_t lcid,int result)1498 void L2cifBREDRDisconnectReqCallBack(uint16_t lcid, int result)
1499 {
1500 LOG_INFO("%{public}s enter, result = %{public}d", __FUNCTION__, result);
1501
1502 BREDRDisconnectReqCallBackContext *disBredrConnectReqPtr =
1503 MEM_MALLOC.alloc(sizeof(BREDRDisconnectReqCallBackContext));
1504 if (disBredrConnectReqPtr == NULL) {
1505 LOG_ERROR("point to NULL");
1506 return;
1507 }
1508
1509 disBredrConnectReqPtr->lcid = lcid;
1510 disBredrConnectReqPtr->result = result;
1511
1512 AttAsyncProcess(
1513 L2cifBREDRDisconnectReqCallBackAsync, L2cifBREDRDisconnectReqCallBackAsyncDestroy, disBredrConnectReqPtr);
1514
1515 return;
1516 }
1517
1518 /**
1519 * @brief le disconnect request callback async.
1520 *
1521 * @param ctx Indicates the pointer to context.
1522 */
LeDisconnectReqCallBackAsync(const void * context)1523 void LeDisconnectReqCallBackAsync(const void *context)
1524 {
1525 LOG_INFO("%{public}s enter", __FUNCTION__);
1526
1527 AttConnectInfo *connect = NULL;
1528 LeDisconnectReqCallBackContext *disLeConnectReqPtr = (LeDisconnectReqCallBackContext *)context;
1529 AttLeDisconnectCallback leData;
1530 AttConnectedCallback *attConnectCallback = NULL;
1531
1532 AttGetConnectInfoIndexByCid(disLeConnectReqPtr->aclHandle, &connect);
1533
1534 if (connect == NULL) {
1535 goto LEDISCONNECTREQCALLBACK_END;
1536 }
1537
1538 attConnectCallback = AttGetATTConnectCallback();
1539 if (disLeConnectReqPtr->result != BT_SUCCESS) {
1540 if (connect->transportType == BT_TRANSPORT_LE) {
1541 leData.status = LE_DISCONNECT_FAIL;
1542 if (attConnectCallback->attConnect.attLEDisconnectCompleted != NULL) {
1543 attConnectCallback->attConnect.attLEDisconnectCompleted(
1544 connect->retGattConnectHandle, &leData, attConnectCallback->context);
1545 }
1546 }
1547 }
1548
1549 LEDISCONNECTREQCALLBACK_END:
1550 MEM_MALLOC.free(disLeConnectReqPtr);
1551 return;
1552 }
1553
1554 /**
1555 * @brief le disconnect request callback async destroy.
1556 *
1557 * @param ctx Indicates the pointer to context.
1558 */
LeDisconnectReqCallBackAsyncDestroy(const void * context)1559 void LeDisconnectReqCallBackAsyncDestroy(const void *context)
1560 {
1561 LOG_INFO("%{public}s enter", __FUNCTION__);
1562
1563 LeDisconnectReqCallBackContext *disLeConnectReqPtr = (LeDisconnectReqCallBackContext *)context;
1564
1565 MEM_MALLOC.free(disLeConnectReqPtr);
1566
1567 return;
1568 }
1569
1570 /**
1571 * @brief le disconnect request callback.
1572 *
1573 * @param aclHandle Indicates the aclHandle.
1574 * @param result Indicates the result.
1575 */
LeDisconnectReqCallback(uint16_t aclHandle,int result)1576 void LeDisconnectReqCallback(uint16_t aclHandle, int result)
1577 {
1578 LOG_INFO("%{public}s enter, result = %{public}d", __FUNCTION__, result);
1579
1580 LeDisconnectReqCallBackContext *disLeConnectReqPtr = MEM_MALLOC.alloc(sizeof(LeDisconnectReqCallBackContext));
1581 if (disLeConnectReqPtr == NULL) {
1582 LOG_ERROR("point to NULL");
1583 return;
1584 }
1585
1586 disLeConnectReqPtr->aclHandle = aclHandle;
1587 disLeConnectReqPtr->result = result;
1588
1589 AttAsyncProcess(LeDisconnectReqCallBackAsync, LeDisconnectReqCallBackAsyncDestroy, disLeConnectReqPtr);
1590
1591 return;
1592 }
1593
1594 /**
1595 * @brief send disconnect request in self thread.
1596 *
1597 * @param context Indicates the pointer to context.
1598 */
AttDisconnectRequestAsync(const void * context)1599 static void AttDisconnectRequestAsync(const void *context)
1600 {
1601 LOG_INFO("%{public}s enter", __FUNCTION__);
1602
1603 AttDisconnectReqAsync *attDisconnectReqAsyncPtr = (AttDisconnectReqAsync *)context;
1604
1605 InitiativeDisconnect(attDisconnectReqAsyncPtr->connectHandle);
1606
1607 MEM_MALLOC.free(attDisconnectReqAsyncPtr);
1608 return;
1609 }
1610
1611 /**
1612 * @brief destroy disconnect request async destroy.
1613 *
1614 * @param context Indicates the pointer to context.
1615 */
AttDisconnectRequestAsyncDestroy(const void * context)1616 static void AttDisconnectRequestAsyncDestroy(const void *context)
1617 {
1618 LOG_INFO("%{public}s enter", __FUNCTION__);
1619
1620 AttDisconnectReqAsync *attDisconnectReqAsyncPtr = (AttDisconnectReqAsync *)context;
1621
1622 MEM_MALLOC.free(attDisconnectReqAsyncPtr);
1623
1624 return;
1625 }
1626
1627 /**
1628 * @brief gatt send disconnect request to att.
1629 *
1630 * @param connectHandle Indicates the connect handle.
1631 * @return Returns the result of disconnect request.
1632 */
ATT_DisconnectReq(uint16_t connectHandle)1633 void ATT_DisconnectReq(uint16_t connectHandle)
1634 {
1635 LOG_INFO("%{public}s enter,connectHandle = %hu", __FUNCTION__, connectHandle);
1636
1637 AttDisconnectReqAsync *attDisconnectReqAsyncPtr = MEM_MALLOC.alloc(sizeof(AttDisconnectReqAsync));
1638 if (attDisconnectReqAsyncPtr == NULL) {
1639 LOG_ERROR("point to NULL");
1640 return;
1641 }
1642 attDisconnectReqAsyncPtr->connectHandle = connectHandle;
1643
1644 AttAsyncProcess(AttDisconnectRequestAsync, AttDisconnectRequestAsyncDestroy, attDisconnectReqAsyncPtr);
1645
1646 return;
1647 }
1648
1649 /**
1650 * @brief receive le connected async.
1651 *
1652 * @param ctx Indicates the pointer to context.
1653 */
AttLeConnectedAsync(const void * context)1654 NO_SANITIZE("cfi") static void AttLeConnectedAsync(const void *context)
1655 {
1656 LOG_INFO("%{public}s enter", __FUNCTION__);
1657
1658 AttLeConnectedAsyncContext *attLeConnectedAsyncPtr = (AttLeConnectedAsyncContext *)context;
1659 AttLeConnectCallback leConnectCallbackParaObj;
1660 AttConnectInfo *connect = NULL;
1661 AttConnectingInfo *connecting = NULL;
1662 uint8_t initPassConnFlag = 0;
1663 AttConnectedCallback *attConnectCallback = AttGetATTConnectCallback();
1664
1665 if (attLeConnectedAsyncPtr->role == LEROLEMASTER) {
1666 AttGetConnectingIndexByAddrAclhandleCid(attLeConnectedAsyncPtr->addr, 0, LE_CID, &connecting);
1667
1668 if (connecting != NULL) {
1669 AttClearConnectingInfo(connecting);
1670 }
1671
1672 initPassConnFlag = INITIATIVECONNECT;
1673 } else if (attLeConnectedAsyncPtr->role == LEROLESLAVE) {
1674 initPassConnFlag = PASSIVECONNECT;
1675 }
1676
1677 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attLEConnectCompleted == NULL)) {
1678 LOG_WARN("%{public}s attConnectCallback or attLEConnectCompleted is NULL", __FUNCTION__);
1679 goto ATTLECONNECTED_END;
1680 }
1681
1682 leConnectCallbackParaObj.addr.type = attLeConnectedAsyncPtr->addr->type;
1683 leConnectCallbackParaObj.role = attLeConnectedAsyncPtr->role;
1684 (void)memcpy_s(leConnectCallbackParaObj.addr.addr, ADDRESSLEN, attLeConnectedAsyncPtr->addr->addr, ADDRESSLEN);
1685
1686 if (attLeConnectedAsyncPtr->status == BT_SUCCESS) {
1687 leConnectCallbackParaObj.status = LE_CONNECT_SUCCESS;
1688 AttConnectInfoAddLe(
1689 attLeConnectedAsyncPtr->addr, attLeConnectedAsyncPtr->aclHandle, &connect, initPassConnFlag);
1690 if (connect != NULL) {
1691 attConnectCallback->attConnect.attLEConnectCompleted(
1692 connect->retGattConnectHandle, &leConnectCallbackParaObj, attConnectCallback->context);
1693 }
1694 } else {
1695 leConnectCallbackParaObj.status = LE_CONNECT_FAIL;
1696 attConnectCallback->attConnect.attLEConnectCompleted(0, &leConnectCallbackParaObj, attConnectCallback->context);
1697 }
1698
1699 ATTLECONNECTED_END:
1700 MEM_MALLOC.free(attLeConnectedAsyncPtr->addr);
1701 MEM_MALLOC.free(attLeConnectedAsyncPtr);
1702 return;
1703 }
1704
1705 /**
1706 * @brief receive le connected async destroy.
1707 *
1708 * @param ctx Indicates the pointer to context.
1709 */
AttLeConnectedAsyncDestroy(const void * context)1710 static void AttLeConnectedAsyncDestroy(const void *context)
1711 {
1712 LOG_INFO("%{public}s enter", __FUNCTION__);
1713
1714 AttLeConnectedAsyncContext *attLeConnectedAsyncPtr = (AttLeConnectedAsyncContext *)context;
1715
1716 MEM_MALLOC.free(attLeConnectedAsyncPtr->addr);
1717 MEM_MALLOC.free(attLeConnectedAsyncPtr);
1718
1719 return;
1720 }
1721
1722 /**
1723 * @brief receive le connected.
1724 *
1725 * @param1 addr Indicates the pointer to BtAddr.
1726 * @param2 aclHandle Indicates the aclHandle.
1727 * @param3 role Indicates the role.
1728 * @param4 status Indicates the status.
1729 */
AttLeConnected(const BtAddr * addr,uint16_t aclHandle,uint8_t role,uint8_t status)1730 void AttLeConnected(const BtAddr *addr, uint16_t aclHandle, uint8_t role, uint8_t status)
1731 {
1732 LOG_INFO("%{public}s enter, aclHandle = %hu, role = %hhu", __FUNCTION__, aclHandle, role);
1733
1734 BtAddr *btAddrPtr = MEM_MALLOC.alloc(sizeof(BtAddr));
1735 if (btAddrPtr == NULL) {
1736 LOG_ERROR("point to NULL");
1737 return;
1738 }
1739 (void)memcpy_s(btAddrPtr->addr, ADDRESSLEN, addr, ADDRESSLEN);
1740 btAddrPtr->type = addr->type;
1741
1742 AttLeConnectedAsyncContext *attLeConnectedAsyncPtr = MEM_MALLOC.alloc(sizeof(AttLeConnectedAsyncContext));
1743 if (attLeConnectedAsyncPtr == NULL) {
1744 LOG_ERROR("point to NULL");
1745 return;
1746 }
1747 attLeConnectedAsyncPtr->addr = btAddrPtr;
1748 attLeConnectedAsyncPtr->aclHandle = aclHandle;
1749 attLeConnectedAsyncPtr->role = role;
1750 attLeConnectedAsyncPtr->status = status;
1751
1752 AttAsyncProcess(AttLeConnectedAsync, AttLeConnectedAsyncDestroy, attLeConnectedAsyncPtr);
1753
1754 return;
1755 }
1756
1757 /**
1758 * @brief receive le disconnected async.
1759 *
1760 * @param ctx Indicates the pointer to context.
1761 */
AttLeDisconnectedAsync(const void * context)1762 static void AttLeDisconnectedAsync(const void *context)
1763 {
1764 LOG_INFO("%{public}s enter", __FUNCTION__);
1765
1766 AttLeDisconnectedAsyncContext *attLeDisconnectedPtr = (AttLeDisconnectedAsyncContext *)context;
1767 AttLeDisconnectCallback leDisConnCallbackObj;
1768 int listSize;
1769 AttConnectInfo *connect = NULL;
1770 AttConnectedCallback *attConnectCallback = AttGetATTConnectCallback();
1771
1772 leDisConnCallbackObj.reason = attLeDisconnectedPtr->reason;
1773 if (attLeDisconnectedPtr->status == BT_SUCCESS) {
1774 leDisConnCallbackObj.status = LE_DISCONNECT_SUCCESS;
1775 } else {
1776 leDisConnCallbackObj.status = LE_DISCONNECT_FAIL;
1777 }
1778
1779 AttGetConnectInfoIndexByAclHandle(attLeDisconnectedPtr->aclHandle, &connect);
1780
1781 if (connect == NULL) {
1782 goto ATTLEDISCONNECTED_END;
1783 }
1784
1785 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attLEDisconnectCompleted == NULL)) {
1786 LOG_WARN("%{public}s attConnectCallback or attLEDisconnectCompleted is NULL", __FUNCTION__);
1787 } else {
1788 attConnectCallback->attConnect.attLEDisconnectCompleted(
1789 connect->retGattConnectHandle, &leDisConnCallbackObj, attConnectCallback->context);
1790 }
1791
1792 if (leDisConnCallbackObj.status == LE_DISCONNECT_SUCCESS) {
1793 listSize = ListGetSize(connect->instruct);
1794 LOG_INFO("%{public}s listSize = %u", __FUNCTION__, listSize);
1795 for (; listSize > 0; --listSize) {
1796 ListRemoveLast(connect->instruct);
1797 }
1798 AttClearConnectInfo(connect);
1799 }
1800
1801 ATTLEDISCONNECTED_END:
1802 MEM_MALLOC.free(attLeDisconnectedPtr);
1803 return;
1804 }
1805
1806 /**
1807 * @brief receive le disconnected async destroy.
1808 *
1809 * @param ctx Indicates the pointer to context.
1810 */
AttLeDisconnectedAsyncDestroy(const void * context)1811 static void AttLeDisconnectedAsyncDestroy(const void *context)
1812 {
1813 LOG_INFO("%{public}s enter", __FUNCTION__);
1814
1815 AttLeDisconnectedAsyncContext *attLeDisconnectedPtr = (AttLeDisconnectedAsyncContext *)context;
1816
1817 MEM_MALLOC.free(attLeDisconnectedPtr);
1818
1819 return;
1820 }
1821
1822 /**
1823 * @brief receive le disconnected.
1824 *
1825 * @param1 aclHandle Indicates the aclHandle.
1826 * @param2 status Indicates the status.
1827 * @param3 reason Indicates the reason.
1828 */
AttLeDisconnected(uint16_t aclHandle,uint8_t status,uint8_t reason)1829 void AttLeDisconnected(uint16_t aclHandle, uint8_t status, uint8_t reason)
1830 {
1831 LOG_INFO("%{public}s enter, aclHandle = %hu,status = %hhu,reason = %hhu", __FUNCTION__, aclHandle, status, reason);
1832
1833 AttLeDisconnectedAsyncContext *attLeDisconnectedPtr = MEM_MALLOC.alloc(sizeof(AttLeDisconnectedAsyncContext));
1834 if (attLeDisconnectedPtr == NULL) {
1835 LOG_ERROR("point to NULL");
1836 return;
1837 }
1838
1839 attLeDisconnectedPtr->aclHandle = aclHandle;
1840 attLeDisconnectedPtr->status = status;
1841 attLeDisconnectedPtr->reason = reason;
1842
1843 AttAsyncProcess(AttLeDisconnectedAsync, AttLeDisconnectedAsyncDestroy, attLeDisconnectedPtr);
1844
1845 return;
1846 }
1847
1848 /**
1849 * @brief bredr connect response pending call backt async.
1850 *
1851 * @param ctx Indicates the pointer to context.
1852 */
L2cifConnectRspPendingCallbackAsync(const void * context)1853 static void L2cifConnectRspPendingCallbackAsync(const void *context)
1854 {
1855 LOG_INFO("%{public}s enter", __FUNCTION__);
1856
1857 AttConnectingInfo *connecting = NULL;
1858 ConnectRspPendingContext *connectRspPendingPtr = (ConnectRspPendingContext *)context;
1859 GapRequestSecurityParam gapReqSecurity;
1860
1861 AttGetConnectingIndexByCid(connectRspPendingPtr->lcid, &connecting);
1862
1863 if (connecting == NULL) {
1864 goto L2CIFCONNECTRSPPENDINGCALLBACK_END;
1865 }
1866
1867 if (connectRspPendingPtr->result == BT_SUCCESS) {
1868 AttAssignGAPRequestSecurity(&gapReqSecurity, INCOMING, connecting);
1869 GAPIF_RequestSecurityAsync(&(connecting->addr), &gapReqSecurity);
1870 } else {
1871 LOG_WARN("%{public}s:L2CIF_ConnectRsp error", __FUNCTION__);
1872 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
1873 AttClearConnectingInfo(connecting);
1874 }
1875
1876 L2CIFCONNECTRSPPENDINGCALLBACK_END:
1877 MEM_MALLOC.free(connectRspPendingPtr);
1878 return;
1879 }
1880
1881 /**
1882 * @brief bredr connect response pending call backt async destroy.
1883 *
1884 * @param ctx Indicates the pointer to context.
1885 */
L2cifConnectRspPendingCallbackAsyncDestroy(const void * context)1886 static void L2cifConnectRspPendingCallbackAsyncDestroy(const void *context)
1887 {
1888 LOG_INFO("%{public}s enter", __FUNCTION__);
1889
1890 ConnectRspPendingContext *connectRspPendingPtr = (ConnectRspPendingContext *)context;
1891
1892 MEM_MALLOC.free(connectRspPendingPtr);
1893
1894 return;
1895 }
1896
1897 /**
1898 * @brief bredr connect response pending call backt.
1899 *
1900 * @param1 lcid Indicates the lcid.
1901 * @param2 result Indicates the result.
1902 */
L2cifConnectRspPendingCallback(uint16_t lcid,int result)1903 static void L2cifConnectRspPendingCallback(uint16_t lcid, int result)
1904 {
1905 LOG_INFO("%{public}s enter, lcid = %hu, result = %{public}d", __FUNCTION__, lcid, result);
1906
1907 ConnectRspPendingContext *connectRspPendingPtr = MEM_MALLOC.alloc(sizeof(ConnectRspPendingContext));
1908 if (connectRspPendingPtr == NULL) {
1909 LOG_ERROR("point to NULL");
1910 return;
1911 }
1912
1913 connectRspPendingPtr->lcid = lcid;
1914 connectRspPendingPtr->result = result;
1915
1916 AttAsyncProcess(
1917 L2cifConnectRspPendingCallbackAsync, L2cifConnectRspPendingCallbackAsyncDestroy, connectRspPendingPtr);
1918
1919 return;
1920 }
1921
1922 /**
1923 * @brief received bredr connect request async.
1924 *
1925 * @param ctx Indicates the pointer to context.
1926 */
AttReceiveConnectionReqAsync(const void * context)1927 static void AttReceiveConnectionReqAsync(const void *context)
1928 {
1929 LOG_INFO("%{public}s enter", __FUNCTION__);
1930
1931 AttReceiveConnectReqContext *attRecevieConnectPtr = (AttReceiveConnectReqContext *)context;
1932
1933 AttConnectingInfo *connecting = AttGetConnectingStart();
1934
1935 if (connecting == NULL) {
1936 LOG_WARN("%{public}s connecting == NULL", __FUNCTION__);
1937 L2CIF_ConnectRsp(attRecevieConnectPtr->lcid,
1938 attRecevieConnectPtr->id,
1939 L2CAP_NO_RESOURCES_AVAILABLE,
1940 L2CAP_NO_FURTHER_INFORMATION_AVAILABLE,
1941 NULL);
1942 goto ATTRECEIVECONNECTIONREQ_END;
1943 }
1944
1945 AttCopyToConnectingInfo(&(attRecevieConnectPtr->info->addr),
1946 attRecevieConnectPtr->info->handle,
1947 attRecevieConnectPtr->lcid,
1948 attRecevieConnectPtr->id,
1949 connecting);
1950
1951 L2CIF_ConnectRsp(attRecevieConnectPtr->lcid,
1952 attRecevieConnectPtr->id,
1953 CONNECTIONPENDING,
1954 AUTHENTICATIONPENDING,
1955 L2cifConnectRspPendingCallback);
1956
1957 ATTRECEIVECONNECTIONREQ_END:
1958 MEM_MALLOC.free(attRecevieConnectPtr->info);
1959 MEM_MALLOC.free(attRecevieConnectPtr);
1960 return;
1961 }
1962
1963 /**
1964 * @brief received bredr connect request async destroy.
1965 *
1966 * @param ctx Indicates the pointer to context.
1967 */
AttReceiveConnectionReqAsyncDestroy(const void * context)1968 static void AttReceiveConnectionReqAsyncDestroy(const void *context)
1969 {
1970 LOG_INFO("%{public}s enter", __FUNCTION__);
1971
1972 AttReceiveConnectReqContext *attRecevieConnectPtr = (AttReceiveConnectReqContext *)context;
1973
1974 MEM_MALLOC.free(attRecevieConnectPtr->info);
1975 MEM_MALLOC.free(attRecevieConnectPtr);
1976
1977 return;
1978 }
1979
1980 /**
1981 * @brief received bredr connect request.
1982 *
1983 * @param1 lcid Indicates the lcid.
1984 * @param2 id Indicates the id.
1985 * @param3 info Indicates the pointer to L2capConnectionInfo.
1986 * @param4 lpsm Indicates the lpsm.
1987 * @param5 ctx Indicates the pointer to context.
1988 */
AttReceiveConnectionReq(uint16_t lcid,uint8_t id,const L2capConnectionInfo * info,uint16_t lpsm,const void * ctx)1989 void AttReceiveConnectionReq(uint16_t lcid, uint8_t id, const L2capConnectionInfo *info, uint16_t lpsm, const void *ctx)
1990 {
1991 LOG_INFO("%{public}s enter", __FUNCTION__);
1992
1993 L2capConnectionInfo *connectInfoPtr = NULL;
1994 AttReceiveConnectReqContext *attRecevieConnectPtr = NULL;
1995
1996 connectInfoPtr = MEM_MALLOC.alloc(sizeof(L2capConnectionInfo));
1997 if (connectInfoPtr == NULL) {
1998 LOG_ERROR("point to NULL");
1999 return;
2000 }
2001 (void)memcpy_s(&(connectInfoPtr->addr), sizeof(BtAddr), &(info->addr), sizeof(BtAddr));
2002 connectInfoPtr->handle = info->handle;
2003
2004 attRecevieConnectPtr = MEM_MALLOC.alloc(sizeof(AttReceiveConnectReqContext));
2005 if (attRecevieConnectPtr == NULL) {
2006 LOG_ERROR("point to NULL");
2007 return;
2008 }
2009 attRecevieConnectPtr->lcid = lcid;
2010 attRecevieConnectPtr->id = id;
2011 attRecevieConnectPtr->info = connectInfoPtr;
2012 attRecevieConnectPtr->lpsm = lpsm;
2013 attRecevieConnectPtr->ctx = (void *)ctx;
2014
2015 AttAsyncProcess(AttReceiveConnectionReqAsync, AttReceiveConnectionReqAsyncDestroy, attRecevieConnectPtr);
2016
2017 return;
2018 }
2019
2020 /**
2021 * @brief received bredr connect response async.
2022 *
2023 * @param ctx Indicates the pointer to context.
2024 */
AttReceiveConnectionRspAsync(const void * context)2025 static void AttReceiveConnectionRspAsync(const void *context)
2026 {
2027 LOG_INFO("%{public}s enter", __FUNCTION__);
2028
2029 AttReceiveConnectionRspContext *attRecevieRspConnectPtr = (AttReceiveConnectionRspContext *)context;
2030 AttConnectingInfo *connecting = NULL;
2031 L2capConfigInfo l2capConfigInfoPtr;
2032
2033 AttGetConnectingIndexByCid(attRecevieRspConnectPtr->lcid, &connecting);
2034
2035 if (connecting == NULL) {
2036 goto ATTRECVCONNECTIONRSP_END;
2037 }
2038
2039 connecting->aclHandle = attRecevieRspConnectPtr->info->handle;
2040
2041 if (attRecevieRspConnectPtr->result == L2CAP_CONNECTION_SUCCESSFUL) {
2042 if (connecting->locall2capConfigInfoObj.rfc.mode == BR_EDR_BASIC_MODE) {
2043 l2capConfigInfoPtr.mtu = connecting->locall2capConfigInfoObj.mtu;
2044 l2capConfigInfoPtr.flushTimeout = connecting->locall2capConfigInfoObj.flushTimeout;
2045 l2capConfigInfoPtr.rfc.mode = connecting->locall2capConfigInfoObj.rfc.mode;
2046 }
2047 L2CIF_ConfigReq(attRecevieRspConnectPtr->lcid, &l2capConfigInfoPtr, L2cifConfigReqCallback);
2048 } else if (attRecevieRspConnectPtr->result == L2CAP_CONNECTION_PENDING) {
2049 goto ATTRECVCONNECTIONRSP_END;
2050 } else {
2051 attRecevieRspConnectPtr->result = BREDR_CONNECT_FAIL;
2052 AttConnectCompletedCallback(connecting, attRecevieRspConnectPtr->result);
2053 }
2054
2055 ATTRECVCONNECTIONRSP_END:
2056 MEM_MALLOC.free(attRecevieRspConnectPtr->info);
2057 MEM_MALLOC.free(attRecevieRspConnectPtr);
2058 return;
2059 }
2060
2061 /**
2062 * @brief received bredr connect response async destroy.
2063 *
2064 * @param ctx Indicates the pointer to context.
2065 */
AttReceiveConnectionRspAsyncDestroy(const void * context)2066 static void AttReceiveConnectionRspAsyncDestroy(const void *context)
2067 {
2068 LOG_INFO("%{public}s enter", __FUNCTION__);
2069
2070 AttReceiveConnectionRspContext *attRecevieRspConnectPtr = (AttReceiveConnectionRspContext *)context;
2071
2072 MEM_MALLOC.free(attRecevieRspConnectPtr->info);
2073 MEM_MALLOC.free(attRecevieRspConnectPtr);
2074
2075 return;
2076 }
2077
2078 /**
2079 * @brief received bredr connect response.
2080 *
2081 * @param1 lcid Indicates the lcid.
2082 * @param2 info Indicates the pointer to L2capConnectionInfo.
2083 * @param3 result Indicates the result.
2084 * @param4 status Indicates the status.
2085 * @param5 ctx Indicates the pointer to context.
2086 */
AttReceiveConnectionRsp(uint16_t lcid,const L2capConnectionInfo * info,uint16_t result,uint16_t status,const void * ctx)2087 void AttReceiveConnectionRsp(
2088 uint16_t lcid, const L2capConnectionInfo *info, uint16_t result, uint16_t status, const void *ctx)
2089 {
2090 LOG_INFO("%{public}s enter, result = %hu, status = %hu", __FUNCTION__, result, status);
2091
2092 L2capConnectionInfo *connectInfoPtr = NULL;
2093 AttReceiveConnectionRspContext *attRecevieRspConnectPtr = NULL;
2094
2095 connectInfoPtr = MEM_MALLOC.alloc(sizeof(L2capConnectionInfo));
2096 if (connectInfoPtr == NULL) {
2097 LOG_ERROR("point to NULL");
2098 return;
2099 }
2100 (void)memcpy_s(&(connectInfoPtr->addr), sizeof(BtAddr), &(info->addr), sizeof(BtAddr));
2101 connectInfoPtr->handle = info->handle;
2102
2103 attRecevieRspConnectPtr = MEM_MALLOC.alloc(sizeof(AttReceiveConnectionRspContext));
2104 if (attRecevieRspConnectPtr == NULL) {
2105 LOG_ERROR("point to NULL");
2106 return;
2107 }
2108 attRecevieRspConnectPtr->lcid = lcid;
2109 attRecevieRspConnectPtr->info = connectInfoPtr;
2110 attRecevieRspConnectPtr->result = result;
2111 attRecevieRspConnectPtr->status = status;
2112 attRecevieRspConnectPtr->ctx = (void *)ctx;
2113
2114 AttAsyncProcess(AttReceiveConnectionRspAsync, AttReceiveConnectionRspAsyncDestroy, attRecevieRspConnectPtr);
2115
2116 return;
2117 }
2118
2119 /**
2120 * @brief receive config response async.
2121 *
2122 * @param ctx Indicates the pointer to context.
2123 */
AttReceiveConfigRspAsync(const void * context)2124 static void AttReceiveConfigRspAsync(const void *context)
2125 {
2126 LOG_INFO("%{public}s enter", __FUNCTION__);
2127
2128 AttReceiveConfigRspContext *attRecevieConfigRspPtr = (AttReceiveConfigRspContext *)context;
2129 uint8_t outPara = 0;
2130 AttConnectingInfo *connecting = NULL;
2131
2132 AttGetConnectingIndexByCid(attRecevieConfigRspPtr->lcid, &connecting);
2133
2134 if (connecting == NULL) {
2135 goto ATTRECVCONFIGRSP_END;
2136 }
2137
2138 if (attRecevieConfigRspPtr->result == L2CAP_SUCCESS) {
2139 if (connecting->initPassConnFlag == INITIATIVECONNECT) {
2140 AttBredrConnectStatusChange(connecting->initiativeConnectStatus, &outPara, INITIATIVECONNECT);
2141 connecting->initiativeConnectStatus = outPara;
2142 if (connecting->initiativeConnectStatus == CONNECTED) {
2143 AttConnectCompletedCallback(connecting, BREDR_CONNECT_SUCCESS);
2144 }
2145 } else if (connecting->initPassConnFlag == PASSIVECONNECT) {
2146 AttBredrConnectStatusChange(connecting->passiveConnectSatatus, &outPara, PASSIVECONNECT);
2147 connecting->passiveConnectSatatus = outPara;
2148 if (connecting->passiveConnectSatatus == CONNECTED) {
2149 AttConnectCompletedCallback(connecting, BREDR_CONNECT_SUCCESS);
2150 }
2151 }
2152 } else if (attRecevieConfigRspPtr->result == L2CAP_PENDING) {
2153 goto ATTRECVCONFIGRSP_END;
2154 } else {
2155 if (connecting->initPassConnFlag == INITIATIVECONNECT) {
2156 connecting->initiativeConnectStatus = DISCONNECTED;
2157 } else if (connecting->initPassConnFlag == PASSIVECONNECT) {
2158 connecting->passiveConnectSatatus = DISCONNECTED;
2159 }
2160 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
2161 }
2162
2163 ATTRECVCONFIGRSP_END:
2164 MEM_MALLOC.free(attRecevieConfigRspPtr->info);
2165 MEM_MALLOC.free(attRecevieConfigRspPtr);
2166 return;
2167 }
2168
2169 /**
2170 * @brief receive config response async destroy.
2171 *
2172 * @param ctx Indicates the pointer to context.
2173 */
AttReceiveConfigRspAsyncDestroy(const void * context)2174 static void AttReceiveConfigRspAsyncDestroy(const void *context)
2175 {
2176 LOG_INFO("%{public}s enter", __FUNCTION__);
2177
2178 AttReceiveConfigRspContext *attRecevieConfigRspPtr = (AttReceiveConfigRspContext *)context;
2179
2180 MEM_MALLOC.free(attRecevieConfigRspPtr->info);
2181 MEM_MALLOC.free(attRecevieConfigRspPtr);
2182
2183 return;
2184 }
2185
2186 /**
2187 * @brief receive config response.
2188 *
2189 * @param1 lcid Indicates the lcid.
2190 * @param2 cfg Indicates the pointer to const L2capConfigInfo.
2191 * @param3 result Indicates the result.
2192 * @param4 ctx Indicates the pointer to context.
2193 */
AttReceiveConfigRsp(uint16_t lcid,const L2capConfigInfo * cfg,uint16_t result,const void * ctx)2194 void AttReceiveConfigRsp(uint16_t lcid, const L2capConfigInfo *cfg, uint16_t result, const void *ctx)
2195 {
2196 LOG_INFO("%{public}s enter, lcid = %hu, mtu = %hu, flushTimeout = %hu, mode = %hhu, result = %hu",
2197 __FUNCTION__,
2198 lcid,
2199 cfg->mtu,
2200 cfg->flushTimeout,
2201 cfg->rfc.mode,
2202 result);
2203
2204 L2capConfigInfo *configInfoPtr = NULL;
2205 AttReceiveConfigRspContext *attRecevieConfigRspPtr = NULL;
2206
2207 configInfoPtr = MEM_MALLOC.alloc(sizeof(L2capConfigInfo));
2208 if (configInfoPtr == NULL) {
2209 LOG_ERROR("point to NULL");
2210 return;
2211 }
2212 (void)memcpy_s(configInfoPtr, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo));
2213
2214 attRecevieConfigRspPtr = MEM_MALLOC.alloc(sizeof(AttReceiveConfigRspContext));
2215 if (attRecevieConfigRspPtr == NULL) {
2216 LOG_ERROR("point to NULL");
2217 return;
2218 }
2219 attRecevieConfigRspPtr->lcid = lcid;
2220 attRecevieConfigRspPtr->info = configInfoPtr;
2221 attRecevieConfigRspPtr->result = result;
2222 attRecevieConfigRspPtr->ctx = (void *)ctx;
2223
2224 AttAsyncProcess(AttReceiveConfigRspAsync, AttReceiveConfigRspAsyncDestroy, attRecevieConfigRspPtr);
2225
2226 return;
2227 }
2228
2229 /**
2230 * @brief receive disconnect req async.
2231 *
2232 * @param1 ctx Indicates the pointer to context.
2233 */
AttReceiveDisconnectionReqAsync(const void * context)2234 static void AttReceiveDisconnectionReqAsync(const void *context)
2235 {
2236 LOG_INFO("%{public}s enter", __FUNCTION__);
2237
2238 AttReceiveDisconnectReqContext *attRecDisReqPtr = NULL;
2239
2240 attRecDisReqPtr = (AttReceiveDisconnectReqContext *)context;
2241
2242 L2CIF_DisconnectionRsp(attRecDisReqPtr->lcid, attRecDisReqPtr->id, DisconnectRespCallback);
2243
2244 MEM_MALLOC.free(attRecDisReqPtr);
2245
2246 return;
2247 }
2248
2249 /**
2250 * @brief receive disconnect req async destroy.
2251 *
2252 * @param1 ctx Indicates the pointer to context.
2253 */
AttReceiveDisconnectionReqAsyncDestroy(const void * context)2254 static void AttReceiveDisconnectionReqAsyncDestroy(const void *context)
2255 {
2256 LOG_INFO("%{public}s enter", __FUNCTION__);
2257
2258 AttReceiveDisconnectReqContext *attRecDisReqPtr = NULL;
2259
2260 attRecDisReqPtr = (AttReceiveDisconnectReqContext *)context;
2261
2262 MEM_MALLOC.free(attRecDisReqPtr);
2263
2264 return;
2265 }
2266
2267 /**
2268 * @brief receive disconnect request.
2269 *
2270 * @param1 lcid Indicates the lcid.
2271 * @param2 id Indicates the id.
2272 * @param3 ctx Indicates the pointer to context.
2273 */
AttReceiveDisconnectionReq(uint16_t lcid,uint8_t id,const void * ctx)2274 void AttReceiveDisconnectionReq(uint16_t lcid, uint8_t id, const void *ctx)
2275 {
2276 LOG_INFO("%{public}s enter, lcid = %hu, id = %hhu", __FUNCTION__, lcid, id);
2277
2278 AttReceiveDisconnectReqContext *attRecDisReqPtr = NULL;
2279
2280 attRecDisReqPtr = MEM_MALLOC.alloc(sizeof(AttReceiveDisconnectReqContext));
2281 if (attRecDisReqPtr == NULL) {
2282 LOG_ERROR("point to NULL");
2283 return;
2284 }
2285
2286 attRecDisReqPtr->lcid = lcid;
2287 attRecDisReqPtr->id = id;
2288 attRecDisReqPtr->ctx = (void *)ctx;
2289
2290 AttAsyncProcess(AttReceiveDisconnectionReqAsync, AttReceiveDisconnectionReqAsyncDestroy, attRecDisReqPtr);
2291
2292 return;
2293 }
2294
2295 /**
2296 * @brief receive disconnect abnormal async.
2297 *
2298 * @param ctx Indicates the pointer to context.
2299 */
AttDisconnectAbnormalAsync(const void * context)2300 static void AttDisconnectAbnormalAsync(const void *context)
2301 {
2302 LOG_INFO("%{public}s enter", __FUNCTION__);
2303
2304 AttDisconnectAbnormalContext *attDisconnectAbnormalPtr = (AttDisconnectAbnormalContext *)context;
2305 AttBredrDisconnectCallback bredrDisConnObj;
2306 int listSize;
2307 AttConnectedCallback *attConnectCallback = NULL;
2308 AttConnectInfo *connect = NULL;
2309
2310 if (attDisconnectAbnormalPtr->reason == L2CAP_STATE_COLLISION) {
2311 AttConnectingInfo *connecting = NULL;
2312 GapRequestSecurityParam gapReqSecurity;
2313 AttGetConnectingIndexByCid(attDisconnectAbnormalPtr->lcid, &connecting);
2314 if (connecting == NULL) {
2315 goto ATTDISCONNECTABNORMAL_END;
2316 }
2317 connecting->cid = 0;
2318 AttAssignGAPRequestSecurity(&gapReqSecurity, OUTGOING, connecting);
2319 GAPIF_RequestSecurityAsync(&(connecting->addr), &gapReqSecurity);
2320 }
2321
2322 AttGetConnectInfoIndexByCid(attDisconnectAbnormalPtr->lcid, &connect);
2323 if (connect == NULL) {
2324 goto ATTDISCONNECTABNORMAL_END;
2325 }
2326
2327 AlarmCancel(connect->alarm);
2328
2329 attConnectCallback = AttGetATTConnectCallback();
2330 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attBREDRDisconnectCompleted == NULL)) {
2331 LOG_WARN("%{public}s attConnectCallback or attBREDRDisconnectCompleted is NULL", __FUNCTION__);
2332 } else {
2333 bredrDisConnObj.reason = DISCONNECT_ABNORMAL;
2334 attConnectCallback->attConnect.attBREDRDisconnectCompleted(
2335 connect->retGattConnectHandle, &bredrDisConnObj, attConnectCallback->context);
2336 }
2337
2338 listSize = ListGetSize(connect->instruct);
2339 for (; listSize > 0; --listSize) {
2340 ListRemoveLast(connect->instruct);
2341 }
2342 AttClearConnectInfo(connect);
2343
2344 ATTDISCONNECTABNORMAL_END:
2345 MEM_MALLOC.free(attDisconnectAbnormalPtr);
2346 return;
2347 }
2348
2349 /**
2350 * @brief receive disconnect abnormal async destroy.
2351 *
2352 * @param ctx Indicates the pointer to context.
2353 */
AttDisconnectAbnormalAsyncDestroy(const void * context)2354 static void AttDisconnectAbnormalAsyncDestroy(const void *context)
2355 {
2356 LOG_INFO("%{public}s enter", __FUNCTION__);
2357
2358 AttDisconnectAbnormalContext *attDisconnectAbnormalPtr = (AttDisconnectAbnormalContext *)context;
2359
2360 MEM_MALLOC.free(attDisconnectAbnormalPtr);
2361
2362 return;
2363 }
2364
2365 /**
2366 * @brief receive disconnect abnormal.
2367 *
2368 * @param1 lcid Indicates the lcid.
2369 * @param2 reason Indicates the reason.
2370 * @param3 ctx Indicates the pointer to context.
2371 */
AttDisconnectAbnormal(uint16_t lcid,uint8_t reason,const void * ctx)2372 void AttDisconnectAbnormal(uint16_t lcid, uint8_t reason, const void *ctx)
2373 {
2374 LOG_INFO("%{public}s enter,lcid = %hu, reason = %hhu", __FUNCTION__, lcid, reason);
2375
2376 AttDisconnectAbnormalContext *attDisconnectAbnormalPtr = MEM_MALLOC.alloc(sizeof(AttDisconnectAbnormalContext));
2377 if (attDisconnectAbnormalPtr == NULL) {
2378 LOG_ERROR("point to NULL");
2379 return;
2380 }
2381
2382 attDisconnectAbnormalPtr->lcid = lcid;
2383 attDisconnectAbnormalPtr->reason = reason;
2384 attDisconnectAbnormalPtr->ctx = (void *)ctx;
2385
2386 AttAsyncProcess(AttDisconnectAbnormalAsync, AttDisconnectAbnormalAsyncDestroy, attDisconnectAbnormalPtr);
2387
2388 return;
2389 }
2390
2391 /**
2392 * @brief receive disconnect response async.
2393 *
2394 * @param2 ctx Indicates the pointer to context.
2395 */
AttRecvDisconnectionRspAsync(const void * context)2396 static void AttRecvDisconnectionRspAsync(const void *context)
2397 {
2398 LOG_INFO("%{public}s enter", __FUNCTION__);
2399
2400 AttRecvDisconnectionRspContext *attRecvDisconnRspPtr = (AttRecvDisconnectionRspContext *)context;
2401 AttBredrDisconnectCallback bredrDisConnObj;
2402 int listSize;
2403 AttConnectInfo *connect = NULL;
2404 AttConnectedCallback *attConnectCallback = NULL;
2405
2406 AttGetConnectInfoIndexByCid(attRecvDisconnRspPtr->lcid, &connect);
2407
2408 if (connect == NULL) {
2409 goto ATTRECVDISCONNECTIONRSP_END;
2410 }
2411
2412 attConnectCallback = AttGetATTConnectCallback();
2413
2414 AlarmCancel(connect->alarm);
2415
2416 if ((attConnectCallback == NULL) || (attConnectCallback->attConnect.attBREDRDisconnectCompleted == NULL)) {
2417 LOG_WARN("%{public}s attConnectCallback or attBREDRDisconnectCompleted is NULL", __FUNCTION__);
2418 } else {
2419 bredrDisConnObj.reason = INITIATIVECONNECT_DISCONNECT_SUCCESS;
2420 attConnectCallback->attConnect.attBREDRDisconnectCompleted(
2421 connect->retGattConnectHandle, &bredrDisConnObj, attConnectCallback->context);
2422 }
2423
2424 listSize = ListGetSize(connect->instruct);
2425 for (; listSize > 0; --listSize) {
2426 ListRemoveLast(connect->instruct);
2427 }
2428
2429 AttClearConnectInfo(connect);
2430
2431 ATTRECVDISCONNECTIONRSP_END:
2432 MEM_MALLOC.free(attRecvDisconnRspPtr);
2433 return;
2434 }
2435
2436 /**
2437 * @brief receive disconnect response async destroy.
2438 *
2439 * @param2 ctx Indicates the pointer to context.
2440 */
AttRecvDisconnectionRspAsyncDestroy(const void * context)2441 static void AttRecvDisconnectionRspAsyncDestroy(const void *context)
2442 {
2443 LOG_INFO("%{public}s enter", __FUNCTION__);
2444
2445 AttRecvDisconnectionRspContext *attRecvDisconnRspPtr = (AttRecvDisconnectionRspContext *)context;
2446
2447 MEM_MALLOC.free(attRecvDisconnRspPtr);
2448
2449 return;
2450 }
2451
2452 /**
2453 * @brief receive disconnect response.
2454 *
2455 * @param1 lcid Indicates the lcid.
2456 * @param2 ctx Indicates the pointer to context.
2457 */
AttRecvDisconnectionRsp(uint16_t lcid,const void * ctx)2458 void AttRecvDisconnectionRsp(uint16_t lcid, const void *ctx)
2459 {
2460 LOG_INFO("%{public}s enter,lcid = %hu", __FUNCTION__, lcid);
2461
2462 AttRecvDisconnectionRspContext *attRecvDisconnRspPtr = MEM_MALLOC.alloc(sizeof(AttRecvDisconnectionRspContext));
2463 if (attRecvDisconnRspPtr == NULL) {
2464 LOG_ERROR("point to NULL");
2465 return;
2466 }
2467
2468 attRecvDisconnRspPtr->lcid = lcid;
2469 attRecvDisconnRspPtr->ctx = (void *)ctx;
2470
2471 AttAsyncProcess(AttRecvDisconnectionRspAsync, AttRecvDisconnectionRspAsyncDestroy, attRecvDisconnRspPtr);
2472
2473 return;
2474 }
2475
2476 /**
2477 * @brief receive configrsp callback async.
2478 *
2479 * @param ctx Indicates the pointer to context.
2480 */
L2cifConfigRspCallbackAsync(const void * context)2481 static void L2cifConfigRspCallbackAsync(const void *context)
2482 {
2483 LOG_INFO("%{public}s enter", __FUNCTION__);
2484
2485 ConfigRspCallbackContext *configRspPtr = (ConfigRspCallbackContext *)context;
2486 AttConnectingInfo *connecting = NULL;
2487 uint8_t outPara = 0;
2488 int ret;
2489
2490 AttGetConnectingIndexByCid(configRspPtr->lcid, &connecting);
2491 if (connecting == NULL) {
2492 goto L2CIFCONFIGRSPCALLBACK_END;
2493 }
2494 if (configRspPtr->result == BT_SUCCESS) {
2495 if (connecting->initPassConnFlag == INITIATIVECONNECT) {
2496 ret = AttBredrConnectStatusChange(connecting->initiativeConnectStatus, &outPara, INITIATIVECONNECT);
2497 if (ret == BT_OPERATION_FAILED) {
2498 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
2499 goto L2CIFCONFIGRSPCALLBACK_END;
2500 }
2501 connecting->initiativeConnectStatus = outPara;
2502 if (connecting->initiativeConnectStatus == CONNECTED) {
2503 AttConnectCompletedCallback(connecting, BREDR_CONNECT_SUCCESS);
2504 }
2505 } else if (connecting->initPassConnFlag == PASSIVECONNECT) {
2506 ret = AttBredrConnectStatusChange(connecting->passiveConnectSatatus, &outPara, PASSIVECONNECT);
2507 if (ret == BT_OPERATION_FAILED) {
2508 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
2509 goto L2CIFCONFIGRSPCALLBACK_END;
2510 }
2511 connecting->passiveConnectSatatus = outPara;
2512 if (connecting->passiveConnectSatatus == CONNECTED) {
2513 AttConnectCompletedCallback(connecting, BREDR_CONNECT_SUCCESS);
2514 }
2515 }
2516 } else {
2517 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
2518 }
2519 L2CIFCONFIGRSPCALLBACK_END:
2520 MEM_MALLOC.free(configRspPtr);
2521 return;
2522 }
2523
2524 /**
2525 * @brief receive configrsp callback async destroy.
2526 *
2527 * @param ctx Indicates the pointer to context.
2528 */
L2cifConfigRspCallbackAsyncDestroy(const void * context)2529 static void L2cifConfigRspCallbackAsyncDestroy(const void *context)
2530 {
2531 LOG_INFO("%{public}s enter", __FUNCTION__);
2532
2533 ConfigRspCallbackContext *configRspPtr = (ConfigRspCallbackContext *)context;
2534
2535 MEM_MALLOC.free(configRspPtr);
2536
2537 return;
2538 }
2539
2540 /**
2541 * @brief receive configrsp callback.
2542 *
2543 * @param1 lcid Indicates the lcid.
2544 * @param2 result Indicates the result.
2545 */
L2cifConfigRspCallback(uint16_t lcid,int result)2546 static void L2cifConfigRspCallback(uint16_t lcid, int result)
2547 {
2548 LOG_INFO("%{public}s enter,lcid = %hu, result = %{public}d", __FUNCTION__, lcid, result);
2549
2550 ConfigRspCallbackContext *configRspPtr = MEM_MALLOC.alloc(sizeof(ConfigRspCallbackContext));
2551 if (configRspPtr == NULL) {
2552 LOG_ERROR("point to NULL");
2553 return;
2554 }
2555
2556 configRspPtr->lcid = lcid;
2557 configRspPtr->result = result;
2558
2559 AttAsyncProcess(L2cifConfigRspCallbackAsync, L2cifConfigRspCallbackAsyncDestroy, configRspPtr);
2560
2561 return;
2562 }
2563
2564 /**
2565 * @brief receive Config request async.
2566 *
2567 * @param ctx Indicates the pointer to context.
2568 */
AttReceiveConfigReqAsync(const void * context)2569 static void AttReceiveConfigReqAsync(const void *context)
2570 {
2571 LOG_INFO("%{public}s enter", __FUNCTION__);
2572
2573 AttReceiveConfigReqContext *attRecevieConfigReqPtr = (AttReceiveConfigReqContext *)context;
2574 AttConnectingInfo *connecting = NULL;
2575
2576 AttGetConnectingIndexByCid(attRecevieConfigReqPtr->lcid, &connecting);
2577
2578 if (connecting == NULL) {
2579 L2CIF_ConfigRsp(attRecevieConfigReqPtr->lcid,
2580 attRecevieConfigReqPtr->id,
2581 attRecevieConfigReqPtr->cfg,
2582 L2CAP_REJECTED,
2583 NULL);
2584 AttConnectCompletedCallback(connecting, BREDR_CONNECT_FAIL);
2585 goto ATTRECVCONFIGREQ_END;
2586 }
2587
2588 AttRecvConfigReqAssignBredrConnect(attRecevieConfigReqPtr->cfg, connecting);
2589
2590 if (attRecevieConfigReqPtr->cfg->rfc.mode != L2CAP_BASIC_MODE) {
2591 L2CIF_ConfigRsp(
2592 connecting->cid, attRecevieConfigReqPtr->id, &(connecting->remotel2capConfigInfoObj), L2CAP_REJECTED, NULL);
2593 goto ATTRECVCONFIGREQ_END;
2594 }
2595
2596 L2CIF_ConfigRsp(connecting->cid,
2597 attRecevieConfigReqPtr->id,
2598 &(connecting->remotel2capConfigInfoObj),
2599 L2CAP_SUCCESS,
2600 L2cifConfigRspCallback);
2601
2602 ATTRECVCONFIGREQ_END:
2603 MEM_MALLOC.free(attRecevieConfigReqPtr->cfg);
2604 MEM_MALLOC.free(attRecevieConfigReqPtr);
2605 return;
2606 }
2607
2608 /**
2609 * @brief receive Config request async destroy.
2610 *
2611 * @param ctx Indicates the pointer to context.
2612 */
AttReceiveConfigReqAsyncDestroy(const void * context)2613 static void AttReceiveConfigReqAsyncDestroy(const void *context)
2614 {
2615 LOG_INFO("%{public}s enter", __FUNCTION__);
2616
2617 AttReceiveConfigReqContext *attRecevieConfigReqPtr = (AttReceiveConfigReqContext *)context;
2618
2619 MEM_MALLOC.free(attRecevieConfigReqPtr->cfg);
2620 MEM_MALLOC.free(attRecevieConfigReqPtr);
2621
2622 return;
2623 }
2624
2625 /**
2626 * @brief receive disconnect response.
2627 *
2628 * @param1 lcid Indicates the lcid.
2629 * @param2 id Indicates the id.
2630 * @param3 cfg Indicates the pointer to const L2capConfigInfo.
2631 * @param4 ctx Indicates the pointer to context.
2632 */
AttReceiveConfigReq(uint16_t lcid,uint8_t id,const L2capConfigInfo * cfg,const void * ctx)2633 void AttReceiveConfigReq(uint16_t lcid, uint8_t id, const L2capConfigInfo *cfg, const void *ctx)
2634 {
2635 LOG_INFO("%{public}s enter,lcid = %hu, id = %hhu, mtu = %hu, flushTimeout = %hu, mode = %hhu",
2636 __FUNCTION__,
2637 lcid,
2638 id,
2639 cfg->mtu,
2640 cfg->flushTimeout,
2641 cfg->rfc.mode);
2642
2643 L2capConfigInfo *configInfoPtr = NULL;
2644 AttReceiveConfigReqContext *attRecevieConfigReqPtr = NULL;
2645
2646 configInfoPtr = MEM_MALLOC.alloc(sizeof(L2capConfigInfo));
2647 if (configInfoPtr == NULL) {
2648 LOG_ERROR("point to NULL");
2649 return;
2650 }
2651 (void)memcpy_s(configInfoPtr, sizeof(L2capConfigInfo), cfg, sizeof(L2capConfigInfo));
2652
2653 attRecevieConfigReqPtr = MEM_MALLOC.alloc(sizeof(AttReceiveConfigReqContext));
2654 attRecevieConfigReqPtr->lcid = lcid;
2655 attRecevieConfigReqPtr->id = id;
2656 attRecevieConfigReqPtr->cfg = configInfoPtr;
2657 attRecevieConfigReqPtr->ctx = (void *)ctx;
2658
2659 AttAsyncProcess(AttReceiveConfigReqAsync, AttReceiveConfigReqAsyncDestroy, attRecevieConfigReqPtr);
2660
2661 return;
2662 }
2663
2664 /**
2665 * @brief Initiative disconnect.
2666 *
2667 * @param1 connectHandle Att connectinfo handle.
2668 */
InitiativeDisconnect(uint16_t connectHandle)2669 void InitiativeDisconnect(uint16_t connectHandle)
2670 {
2671 LOG_DEBUG("%{public}s enter", __FUNCTION__);
2672
2673 uint16_t transportType;
2674 uint16_t index = 0;
2675 AttConnectInfo *connect = NULL;
2676 AttConnectingInfo *connecting = NULL;
2677 AttGetConnectInfoIndexByConnectHandle(connectHandle, &index, &connect);
2678 if (connect == NULL) {
2679 LOG_WARN("InitiativeDisconnect connect == NULL");
2680 return;
2681 }
2682
2683 transportType = connect->transportType;
2684 if (transportType == BT_TRANSPORT_BR_EDR) {
2685 AttGetConnectingIndexByAddrAclhandleCid(
2686 &(connect->addr), connect->aclHandle, connect->AttConnectID.bredrcid, &connecting);
2687 } else {
2688 AttGetConnectingIndexByAddrAclhandleCid(
2689 &(connect->addr), connect->aclHandle, connect->AttConnectID.lecid, &connecting);
2690 }
2691
2692 if (connecting != NULL) {
2693 if (transportType == BT_TRANSPORT_BR_EDR) {
2694 AlarmCancel(connecting->bredrAlarm);
2695 }
2696 }
2697
2698 if (transportType == BT_TRANSPORT_BR_EDR) {
2699 L2CIF_DisconnectionReq(connect->AttConnectID.bredrcid, L2cifBREDRDisconnectReqCallBack);
2700 } else if (transportType == BT_TRANSPORT_LE) {
2701 L2CIF_LeDisconnect(connect->aclHandle, LeDisconnectReqCallback);
2702 }
2703
2704 return;
2705 }
2706
AttLeConnectCancelAsyn(const void * context)2707 static void AttLeConnectCancelAsyn(const void *context)
2708 {
2709 LOG_INFO("%{public}s enter", __FUNCTION__);
2710
2711 AttConnectingInfo *connecting = NULL;
2712 ConnectCancelContext *connectCancelPtr = (ConnectCancelContext *)context;
2713 AttGetConnectingIndexByAddr(&connectCancelPtr->addr, &connecting);
2714
2715 if (connecting != NULL) {
2716 AttClearConnectingInfo(connecting);
2717 }
2718
2719 L2CIF_LeConnectCancel(&connectCancelPtr->addr);
2720 MEM_MALLOC.free(connectCancelPtr);
2721 return;
2722 }
2723
AttLeConnectCancelAsyndestroy(const void * context)2724 static void AttLeConnectCancelAsyndestroy(const void *context)
2725 {
2726 LOG_INFO("%{public}s enter", __FUNCTION__);
2727
2728 ConnectCancelContext *connectCancelPtr = (ConnectCancelContext *)context;
2729 MEM_MALLOC.free(connectCancelPtr);
2730 }
2731
ATT_LeConnectCancel(const BtAddr * addr)2732 int ATT_LeConnectCancel(const BtAddr *addr)
2733 {
2734 LOG_INFO("%{public}s enter", __FUNCTION__);
2735
2736 if (addr == NULL) {
2737 return BT_BAD_PARAM;
2738 }
2739
2740 ConnectCancelContext *context = MEM_MALLOC.alloc(sizeof(ConnectCancelContext));
2741 if (context == NULL) {
2742 return BT_NO_MEMORY;
2743 }
2744
2745 context->addr.type = addr->type;
2746 (void)memcpy_s(context->addr.addr, ADDRESSLEN, addr->addr, ADDRESSLEN);
2747 AttAsyncProcess(AttLeConnectCancelAsyn, AttLeConnectCancelAsyndestroy, context);
2748 return BT_SUCCESS;
2749 }
2750