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_common.c
18  *
19  * @brief implement common function to be called.
20  *
21  */
22 
23 #include "att_common.h"
24 #include "att_connect.h"
25 
26 #include <stdlib.h>
27 
28 #include "alarm.h"
29 #include "log.h"
30 
31 #include "platform/include/allocator.h"
32 
33 #include "../btm/btm_thread.h"
34 
35 static AttConnectInfo g_connectInfo[MAXCONNECT] = {0};
36 static AttConnectingInfo g_connecting[MAXCONNECT] = {0};
37 static AttClientDataCallback g_attClientCallback;
38 static AttServerDataCallback g_attServerCallback;
39 static AttClientSendDataCallback g_attClientSendDataCB;
40 static AttServerSendDataCallback g_attServerSendDataCB;
41 static AttConnectedCallback g_attConnect;
42 #define FUNCTIONLIST 256
43 recvDataFunction g_functionList[FUNCTIONLIST];
44 
45 typedef struct LeRecvSendDataCallbackAsyncContext {
46     uint16_t aclHandle;
47     int result;
48 } LeRecvSendDataCallbackAsyncContext;
49 
50 typedef struct BREDRRecvSendDataCallbackAsyncContext {
51     uint16_t lcid;
52     int result;
53 } BREDRRecvSendDataCallbackAsyncContext;
54 
55 typedef struct TransactionTimeOutContext {
56     uint16_t connectHandle;
57 } TransactionTimeOutContext;
58 
59 typedef struct AttRecvDataAsyncContext {
60     uint16_t lcid;
61     Packet *packet;
62     void *ctx;
63 } AttRecvDataAsyncContext;
64 
65 typedef struct AttRecvLeDataAsyncContext {
66     uint16_t aclHandle;
67     Packet *packet;
68 } AttRecvLeDataAsyncContext;
69 
70 typedef struct AttConnectRegisterContext {
71     AttConnectCallback connectBack;
72     void *context;
73 } AttConnectRegisterContext;
74 
75 static void AttTransactionTimeOut(const void *parameter);
76 
77 static void AttClientDataRegisterAsync(const void *context);
78 static void AttClientDataRegisterAsyncDestroy(const void *context);
79 static void AttClientDataDeregisterAsync(const void *context);
80 static void AttClientDataDeregisterAsyncDestroy(const void *context);
81 
82 static void AttServerDataRegisterAsync(const void *context);
83 static void AttServerDataRegisterAsyncDestroy(const void *context);
84 static void AttServerDataDeregisterAsync(const void *context);
85 static void AttServerDataDeregisterAsyncDestroy(const void *context);
86 
87 static void LeRecvSendDataCallbackAsync(const void *context);
88 static void LeRecvSendDataCallbackAsyncDestroy(const void *context);
89 
90 static void BREDRRecvSendDataCallbackAsync(const void *context);
91 static void BREDRRecvSendDataCallbackAsyncDestroy(const void *context);
92 
93 static void AttTransactionTimeOutAsync(const void *context);
94 static void AttTransactionTimeOutAsyncDestroy(const void *context);
95 
96 static recvDataFunction GetFunction(uint8_t opcode);
97 
98 static void AttRecvDataAsync(const void *context);
99 static void AttRecvDataAsyncDestroy(const void *context);
100 static void AttRecvLeDataAsync(const void *context);
101 static void AttRecvLeDataAsyncDestroy(const void *context);
102 
103 static void AttConnectRegisterAsync(const void *context);
104 static void AttConnectRegisterAsyncDestroy(const void *context);
105 static void AttConnectDeregisterAsync(const void *context);
106 static void AttConnectDeregisterAsyncDestroy(const void *context);
107 
108 static void AttBREDRSendRespCallbackAsync(const void *context);
109 static void AttBREDRSendRespCallbackAsyncDestroy(const void *context);
110 static void AttBREDRSendRespCallback(uint16_t lcid, int result);
111 
112 static void AttLeSendRespCallbackAsync(const void *context);
113 static void AttLeSendRespCallbackAsyncDestroy(const void *context);
114 static void AttLeSendRespCallback(uint16_t aclHandle, int result);
115 
AttTransactionTimeOutAsync(const void * context)116 static void AttTransactionTimeOutAsync(const void *context)
117 {
118     LOG_INFO("%{public}s enter", __FUNCTION__);
119 
120     TransactionTimeOutContext *transTimeOutPtr = (TransactionTimeOutContext *)context;
121     AttConnectInfo *connect = NULL;
122     int listSize;
123     AttClientDataCallback *attClientDataCallback = NULL;
124     AttServerDataCallback *attServerDataCallback = NULL;
125     uint16_t index = 0;
126 
127     AttGetConnectInfoIndexByConnectHandle(transTimeOutPtr->connectHandle, &index, &connect);
128 
129     if (connect == NULL) {
130         LOG_INFO("%{public}s connect == NULL and goto ATTTRANSACTIONTIMEOUT_END", __FUNCTION__);
131         goto ATTTRANSACTIONTIMEOUT_END;
132     }
133 
134     if (!connect->serverSendFlag) {
135         attClientDataCallback = AttGetATTClientCallback();
136         if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
137             LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL",
138                 __FUNCTION__);
139         } else {
140             attClientDataCallback->attClientCallback(
141                 connect->retGattConnectHandle, ATT_TRANSACTION_TIME_OUT_ID, NULL, NULL, attClientDataCallback->context);
142         }
143     } else {
144         connect->serverSendFlag = false;
145         attServerDataCallback = AttGetATTServerCallback();
146         if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
147             LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL",
148                 __FUNCTION__);
149         } else {
150             attServerDataCallback->attServerCallback(
151                 connect->retGattConnectHandle, ATT_TRANSACTION_TIME_OUT_ID, NULL, NULL, attServerDataCallback->context);
152         }
153     }
154 
155     InitiativeDisconnect(transTimeOutPtr->connectHandle);
156     listSize = ListGetSize(connect->instruct);
157     for (; listSize > 0; --listSize) {
158         ListRemoveLast(connect->instruct);
159     }
160 
161 ATTTRANSACTIONTIMEOUT_END:
162     MEM_MALLOC.free(transTimeOutPtr);
163     return;
164 }
165 
AttTransactionTimeOutAsyncDestroy(const void * context)166 static void AttTransactionTimeOutAsyncDestroy(const void *context)
167 {
168     LOG_INFO("%{public}s enter", __FUNCTION__);
169 
170     TransactionTimeOutContext *transTimeOutPtr = (TransactionTimeOutContext *)context;
171 
172     MEM_MALLOC.free(transTimeOutPtr);
173 
174     return;
175 }
176 
177 /**
178  * @brief att transaction timeout.
179  *
180  * @param parameter Indicates the pointer to parameter.
181  */
AttTransactionTimeOut(const void * parameter)182 static void AttTransactionTimeOut(const void *parameter)
183 {
184     LOG_INFO("%{public}s enter", __FUNCTION__);
185 
186     AttConnectInfo *connect = (AttConnectInfo *)parameter;
187     TransactionTimeOutContext *transTimeOutPtr = MEM_MALLOC.alloc(sizeof(TransactionTimeOutContext));
188     if (transTimeOutPtr == NULL) {
189         LOG_ERROR("point to NULL");
190         return;
191     }
192     transTimeOutPtr->connectHandle = connect->retGattConnectHandle;
193 
194     AttAsyncProcess(AttTransactionTimeOutAsync, AttTransactionTimeOutAsyncDestroy, transTimeOutPtr);
195 
196     return;
197 }
198 
199 /**
200  * @brief get AttConnectInfo information.
201  *
202  * @return Returns the pointer to AttConnectInfo.
203  */
AttGetConnectStart()204 AttConnectInfo *AttGetConnectStart()
205 {
206     LOG_INFO("%{public}s enter", __FUNCTION__);
207 
208     return g_connectInfo;
209 }
210 
211 /**
212  * @brief lookup AttConnectInfo info by aclHandle.
213  *
214  * @param1 aclHandle Indicates the aclHandle.
215  * @param2 connect Indicates the second rank pointer to AttConnectInfo.
216  */
AttGetConnectInfoIndexByAclHandle(uint16_t aclHandle,AttConnectInfo ** connect)217 void AttGetConnectInfoIndexByAclHandle(uint16_t aclHandle, AttConnectInfo **connect)
218 {
219     LOG_INFO("%{public}s enter, aclHandle = %hu", __FUNCTION__, aclHandle);
220 
221     uint16_t index = 0;
222 
223     for (; index < MAXCONNECT; ++index) {
224         if (g_connectInfo[index].aclHandle == aclHandle) {
225             break;
226         }
227     }
228 
229     if (index != MAXCONNECT) {
230         *connect = &g_connectInfo[index];
231     } else {
232         *connect = NULL;
233     }
234 
235     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
236     return;
237 }
238 
239 /**
240  * @brief lookup AttConnectInfo info by cid.
241  *
242  * @param1 cid Indicates the cid.
243  * @param2 connect Indicates the second rank pointer to AttConnectInfo.
244  */
AttGetConnectInfoIndexByCid(uint16_t cid,AttConnectInfo ** connect)245 void AttGetConnectInfoIndexByCid(uint16_t cid, AttConnectInfo **connect)
246 {
247     LOG_INFO("%{public}s enter, cid = %hu", __FUNCTION__, cid);
248 
249     uint16_t index = 0;
250 
251     for (; index < MAXCONNECT; ++index) {
252         if (g_connectInfo[index].transportType == BT_TRANSPORT_BR_EDR) {
253             if (g_connectInfo[index].AttConnectID.bredrcid == cid) {
254                 break;
255             }
256         }
257         if (g_connectInfo[index].transportType == BT_TRANSPORT_LE) {
258             if (g_connectInfo[index].aclHandle == cid) {
259                 break;
260             }
261         }
262     }
263 
264     if (index != MAXCONNECT) {
265         *connect = &g_connectInfo[index];
266     } else {
267         *connect = NULL;
268     }
269 
270     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
271     return;
272 }
273 
274 /**
275  * @brief lookup AttConnectInfo info by cid and output parameter index.
276  *
277  * @param1 cid Indicates the cid.
278  * @param2 index Indicates the pointer to index.
279  * @param3 connect Indicates second rank pointer to AttConnectInfo.
280  */
AttGetConnectInfoIndexByCidOutIndex(uint16_t cid,uint16_t * index,AttConnectInfo ** connect)281 void AttGetConnectInfoIndexByCidOutIndex(uint16_t cid, uint16_t *index, AttConnectInfo **connect)
282 {
283     LOG_INFO("%{public}s enter,cid = %hu", __FUNCTION__, cid);
284 
285     uint16_t indexNumber = 0;
286 
287     for (; indexNumber < MAXCONNECT; ++indexNumber) {
288         if (g_connectInfo[indexNumber].AttConnectID.bredrcid == cid) {
289             break;
290         }
291     }
292 
293     *index = indexNumber;
294 
295     if (indexNumber != MAXCONNECT) {
296         *connect = &g_connectInfo[indexNumber];
297     } else {
298         *connect = NULL;
299     }
300 
301     LOG_INFO("%{public}s return: *index = %hu", __FUNCTION__, *index);
302     return;
303 }
304 
305 /**
306  * @brief lookup AttConnectInfo info by connectHandle and output parameter index.
307  *
308  * @param1 connectHandle Indicates the connectHandle.
309  * @param2 index Indicates the pointer to index.
310  * @param3 connect Indicates the Secondary pointer to AttConnectInfo.
311  */
AttGetConnectInfoIndexByConnectHandle(uint16_t connectHandle,uint16_t * index,AttConnectInfo ** connect)312 void AttGetConnectInfoIndexByConnectHandle(uint16_t connectHandle, uint16_t *index, AttConnectInfo **connect)
313 {
314     LOG_INFO("%{public}s enter, connectHandle = %hu", __FUNCTION__, connectHandle);
315 
316     uint16_t inindex = 0;
317 
318     for (; inindex < MAXCONNECT; ++inindex) {
319         if (g_connectInfo[inindex].retGattConnectHandle == connectHandle) {
320             break;
321         }
322     }
323 
324     *index = inindex;
325 
326     if (inindex != MAXCONNECT) {
327         *connect = &g_connectInfo[inindex];
328 
329         goto ATTGETCONNECTINFOINDEXBYCONNECTHANDLE_END;
330     } else {
331         *connect = NULL;
332         *index = MAXCONNECT;
333         goto ATTGETCONNECTINFOINDEXBYCONNECTHANDLE_END;
334     }
335 
336 ATTGETCONNECTINFOINDEXBYCONNECTHANDLE_END:
337     LOG_INFO("%{public}s return: *index = %hu", __FUNCTION__, *index);
338     return;
339 }
340 
341 /**
342  * @brief gatt register client data to att in self thread..
343  *
344  * @param context Indicates the pointer to context.
345  */
AttClientDataRegisterAsync(const void * context)346 static void AttClientDataRegisterAsync(const void *context)
347 {
348     LOG_INFO("%{public}s enter", __FUNCTION__);
349 
350     AttClientDataCallback *attClientDataCallbackAsyncPtr = (AttClientDataCallback *)context;
351 
352     g_attClientCallback.attClientCallback = attClientDataCallbackAsyncPtr->attClientCallback;
353     g_attClientCallback.context = attClientDataCallbackAsyncPtr->context;
354 
355     MEM_MALLOC.free(attClientDataCallbackAsyncPtr);
356 
357     return;
358 }
359 
360 /**
361  * @brief destroy gatt register client data to att in self thread..
362  *
363  * @param context Indicates the pointer to context.
364  */
AttClientDataRegisterAsyncDestroy(const void * context)365 static void AttClientDataRegisterAsyncDestroy(const void *context)
366 {
367     LOG_INFO("%{public}s enter", __FUNCTION__);
368 
369     AttClientDataCallback *attClientDataCallbackAsyncPtr = (AttClientDataCallback *)context;
370 
371     MEM_MALLOC.free(attClientDataCallbackAsyncPtr);
372 
373     return;
374 }
375 
376 /**
377  * @brief gatt register client data to att.
378  *
379  * @param1 dataCallback Indicates the pointer to callback.
380  * @param2 context Indicates the pointer to context.
381  */
ATT_ClientDataRegister(attCallback dataCallback,void * context)382 void ATT_ClientDataRegister(attCallback dataCallback, void *context)
383 {
384     LOG_INFO("%{public}s enter", __FUNCTION__);
385 
386     AttClientDataCallback *attClientDataCallbackAsyncPtr = MEM_MALLOC.alloc(sizeof(AttClientDataCallback));
387     if (attClientDataCallbackAsyncPtr == NULL) {
388         LOG_ERROR("point to NULL");
389         return;
390     }
391     attClientDataCallbackAsyncPtr->attClientCallback = dataCallback;
392     attClientDataCallbackAsyncPtr->context = context;
393 
394     AttAsyncProcess(AttClientDataRegisterAsync, AttClientDataRegisterAsyncDestroy, attClientDataCallbackAsyncPtr);
395 
396     return;
397 }
398 
399 /**
400  * @brief gatt deregister client data to att in self thread..
401  *
402  * @param context Indicates the pointer to context.
403  */
AttClientDataDeregisterAsync(const void * context)404 static void AttClientDataDeregisterAsync(const void *context)
405 {
406     LOG_INFO("%{public}s enter", __FUNCTION__);
407 
408     g_attClientCallback.attClientCallback = NULL;
409     g_attClientCallback.context = NULL;
410 
411     return;
412 }
413 
414 /**
415  * @brief destroy gatt deregister client data to att in self thread..
416  *
417  * @param context Indicates the pointer to context.
418  */
AttClientDataDeregisterAsyncDestroy(const void * context)419 static void AttClientDataDeregisterAsyncDestroy(const void *context)
420 {
421     LOG_INFO("%{public}s enter", __FUNCTION__);
422 
423     return;
424 }
425 
426 /**
427  * @brief gatt deregister client data to att.
428  *
429  */
ATT_ClientDataDeregister()430 void ATT_ClientDataDeregister()
431 {
432     LOG_INFO("%{public}s enter", __FUNCTION__);
433 
434     AttAsyncProcess(AttClientDataDeregisterAsync, AttClientDataDeregisterAsyncDestroy, NULL);
435 
436     return;
437 }
438 
439 /**
440  * @brief gatt register server data to att in self thread..
441  *
442  * @param context Indicates the pointer to context.
443  */
AttServerDataRegisterAsync(const void * context)444 static void AttServerDataRegisterAsync(const void *context)
445 {
446     LOG_INFO("%{public}s enter", __FUNCTION__);
447 
448     AttServerDataCallback *attServerDataCallbackAsyncPtr = (AttServerDataCallback *)context;
449 
450     g_attServerCallback.attServerCallback = attServerDataCallbackAsyncPtr->attServerCallback;
451     g_attServerCallback.context = attServerDataCallbackAsyncPtr->context;
452 
453     MEM_MALLOC.free(attServerDataCallbackAsyncPtr);
454 
455     return;
456 }
457 
458 /**
459  * @brief destroy gatt register server data to att in self thread..
460  *
461  * @param context Indicates the pointer to context.
462  */
AttServerDataRegisterAsyncDestroy(const void * context)463 static void AttServerDataRegisterAsyncDestroy(const void *context)
464 {
465     LOG_INFO("%{public}s enter", __FUNCTION__);
466 
467     AttServerDataCallback *attServerDataCallbackAsyncPtr = (AttServerDataCallback *)context;
468 
469     MEM_MALLOC.free(attServerDataCallbackAsyncPtr);
470 
471     return;
472 }
473 
474 /**
475  * @brief gatt register server data to att.
476  *
477  * @param1 dataCallback Indicates the pointer to callback.
478  * @param2 context Indicates the pointer to context.
479  */
ATT_ServerDataRegister(attCallback dataCallback,void * context)480 void ATT_ServerDataRegister(attCallback dataCallback, void *context)
481 {
482     LOG_INFO("%{public}s enter", __FUNCTION__);
483 
484     AttServerDataCallback *attServerDataCallbackAsyncPtr = MEM_MALLOC.alloc(sizeof(AttServerDataCallback));
485     if (attServerDataCallbackAsyncPtr == NULL) {
486         LOG_ERROR("point to NULL");
487         return;
488     }
489     attServerDataCallbackAsyncPtr->attServerCallback = dataCallback;
490     attServerDataCallbackAsyncPtr->context = context;
491 
492     AttAsyncProcess(AttServerDataRegisterAsync, AttServerDataRegisterAsyncDestroy, attServerDataCallbackAsyncPtr);
493 
494     return;
495 }
496 
497 /**
498  * @brief destroy gatt deregister server data to att in self thread..
499  *
500  * @param context Indicates the pointer to context.
501  */
AttServerDataDeregisterAsync(const void * context)502 static void AttServerDataDeregisterAsync(const void *context)
503 {
504     LOG_INFO("%{public}s enter", __FUNCTION__);
505 
506     g_attServerCallback.attServerCallback = NULL;
507     g_attServerCallback.context = NULL;
508 
509     return;
510 }
511 
512 /**
513  * @brief destroy gatt deregister server data to att in self thread..
514  *
515  * @param context Indicates the pointer to context.
516  */
AttServerDataDeregisterAsyncDestroy(const void * context)517 static void AttServerDataDeregisterAsyncDestroy(const void *context)
518 {
519     LOG_INFO("%{public}s enter", __FUNCTION__);
520 
521     return;
522 }
523 
524 /**
525  * @brief gatt deregister server data to att.
526  *
527  */
ATT_ServerDataDeregister()528 void ATT_ServerDataDeregister()
529 {
530     LOG_INFO("%{public}s enter", __FUNCTION__);
531 
532     AttAsyncProcess(AttServerDataDeregisterAsync, AttServerDataDeregisterAsyncDestroy, NULL);
533 
534     return;
535 }
536 
537 /**
538  * @brief get AttClientDataCallback information.
539  *
540  * @return Returns the pointer to AttClientDataCallback.
541  */
AttGetATTClientCallback()542 AttClientDataCallback *AttGetATTClientCallback()
543 {
544     LOG_INFO("%{public}s enter", __FUNCTION__);
545 
546     return &g_attClientCallback;
547 }
548 
549 /**
550  * @brief get AttServerDataCallback information.
551  *
552  * @return Returns the pointer to AttServerDataCallback.
553  */
AttGetATTServerCallback()554 AttServerDataCallback *AttGetATTServerCallback()
555 {
556     LOG_INFO("%{public}s enter", __FUNCTION__);
557 
558     return &g_attServerCallback;
559 }
560 
561 /**
562  * @brief initiative execut instructions by Scheduling.
563  *
564  * @param connect Indicates the pointer to AttConnectInfo.
565  * @return Returns <b>0</b> if the operation is successful; returns <b>!0</b> if the operation fails.
566  */
AttSendSequenceScheduling(const AttConnectInfo * connect)567 int AttSendSequenceScheduling(const AttConnectInfo *connect)
568 {
569     LOG_INFO("%{public}s enter, listsize = %u", __FUNCTION__, ListGetSize(connect->instruct));
570 
571     int ret = BT_SUCCESS;
572 
573     if (ListGetSize(connect->instruct) == 1) {
574         ListNode *listNodePtr = ListGetFirstNode(connect->instruct);
575         if (listNodePtr == NULL) {
576             LOG_INFO("%{public}s listNodePtr == NULL", __FUNCTION__);
577             ret = BT_OPERATION_FAILED;
578             goto ATTSENDSEQUENCESCHEDULING_END;
579         }
580         Packet *packet = ListGetNodeData(listNodePtr);
581         if (connect->transportType == BT_TRANSPORT_LE) {
582             ret = L2CIF_LeSendFixChannelData(connect->aclHandle, (uint16_t)LE_CID, packet, LeRecvSendDataCallback);
583         }
584         if (connect->transportType == BT_TRANSPORT_BR_EDR) {
585             ret = L2CIF_SendData(connect->AttConnectID.bredrcid, packet, BREDRRecvSendDataCallback);
586         }
587         if (ret != BT_SUCCESS) {
588             LOG_INFO("%{public}s call l2cap interface return not success", __FUNCTION__);
589         } else {
590             AlarmSet(
591                 connect->alarm, (uint64_t)INSTRUCTIONTIMEOUT, (void (*)(void *))AttTransactionTimeOut, (void *)connect);
592         }
593     }
594 
595 ATTSENDSEQUENCESCHEDULING_END:
596     return ret;
597 }
598 
599 /**
600  * @brief execut instructions by Scheduling after receiving response.
601  *
602  * @param connect Indicates the pointer to AttConnectInfo.
603  */
AttReceiveSequenceScheduling(const AttConnectInfo * connect)604 void AttReceiveSequenceScheduling(const AttConnectInfo *connect)
605 {
606     LOG_INFO("%{public}s enter, listsize = %u, transportType = %hhu",
607         __FUNCTION__,
608         ListGetSize(connect->instruct),
609         connect->transportType);
610 
611     int ret = BT_OPERATION_FAILED;
612 
613     if (ListGetSize(connect->instruct) > 0) {
614         ListNode *listNodePtr = ListGetFirstNode(connect->instruct);
615         if (listNodePtr == NULL) {
616             LOG_INFO("%{public}s listNodePtr == NULL", __FUNCTION__);
617             goto ATTRECEIVESEQUENCESCHEDULING_END;
618         }
619         Packet *PacketPtr = ListGetNodeData(listNodePtr);
620         if (connect->transportType == BT_TRANSPORT_LE) {
621             ret = L2CIF_LeSendFixChannelData(connect->aclHandle, (uint16_t)LE_CID, PacketPtr, LeRecvSendDataCallback);
622         }
623         if (connect->transportType == BT_TRANSPORT_BR_EDR) {
624             ret = L2CIF_SendData(connect->AttConnectID.bredrcid, PacketPtr, BREDRRecvSendDataCallback);
625         }
626 
627         if (ret != BT_SUCCESS) {
628             LOG_INFO("%{public}s call l2cap interface return not success", __FUNCTION__);
629         } else {
630             AlarmSet(connect->alarm,
631                 (uint64_t)INSTRUCTIONTIMEOUT,
632                 (void (*)(void *))AttTransactionTimeOut,
633                 (AttConnectInfo *)connect);
634         }
635     }
636 
637 ATTRECEIVESEQUENCESCHEDULING_END:
638     return;
639 }
640 
641 /**
642  * @brief get AttConnectingInfo information.
643  *
644  * @return Returns the pointer to AttConnectingInfo.
645  */
AttGetConnectingStart()646 AttConnectingInfo *AttGetConnectingStart()
647 {
648     LOG_INFO("%{public}s enter", __FUNCTION__);
649 
650     return g_connecting;
651 }
652 
653 /**
654  * @brief lookup AttConnectingInfo info by cid.
655  *
656  * @param1 cid Indicates the cid.
657  * @param2 connecting Indicates the Secondary pointer to AttConnectingInfo.
658  */
AttGetConnectingIndexByCid(uint16_t cid,AttConnectingInfo ** connecting)659 void AttGetConnectingIndexByCid(uint16_t cid, AttConnectingInfo **connecting)
660 {
661     LOG_INFO("%{public}s enter, cid = %hu", __FUNCTION__, cid);
662 
663     uint16_t index = 0;
664 
665     for (; index < MAXCONNECT; ++index) {
666         if (g_connecting[index].cid == cid) {
667             break;
668         }
669     }
670 
671     if (index != MAXCONNECT) {
672         *connecting = &g_connecting[index];
673         goto ATTGETCONNECTINGINDEXBYCID_END;
674     } else {
675         *connecting = NULL;
676         goto ATTGETCONNECTINGINDEXBYCID_END;
677     }
678 
679 ATTGETCONNECTINGINDEXBYCID_END:
680     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
681     return;
682 }
683 
684 /**
685  * @brief lookup AttConnectingInfo info by cid and output parameter index.
686  *
687  * @param1 cid Indicates the cid.
688  * @param2 index Indicates the pointer to index.
689  * @param3 connecting Indicates the Secondary pointer to AttConnectingInfo.
690  */
AttGetConnectingIndexByCidOutIndex(uint16_t cid,uint16_t * index,AttConnectingInfo ** connecting)691 void AttGetConnectingIndexByCidOutIndex(uint16_t cid, uint16_t *index, AttConnectingInfo **connecting)
692 {
693     LOG_INFO("%{public}s enter,cid = %hu", __FUNCTION__, cid);
694 
695     uint16_t indexNumber = 0;
696 
697     for (; indexNumber < MAXCONNECT; ++indexNumber) {
698         if (g_connecting[indexNumber].cid == cid) {
699             break;
700         }
701     }
702 
703     if (indexNumber != MAXCONNECT) {
704         *connecting = &g_connecting[indexNumber];
705         *index = indexNumber;
706         goto ATTGETCONNECTINGINDEXBYCIDOUTINDEX_END;
707     } else {
708         *connecting = NULL;
709         *index = MAXCONNECT;
710         goto ATTGETCONNECTINGINDEXBYCIDOUTINDEX_END;
711     }
712 
713 ATTGETCONNECTINGINDEXBYCIDOUTINDEX_END:
714     LOG_INFO("%{public}s return: *index = %hu", __FUNCTION__, *index);
715     return;
716 }
717 
718 /**
719  * @brief lookup AttConnectingInfo info by connectHandle.
720  *
721  * @param1 connectHandle Indicates the connectHandle.
722  * @param2 connecting Indicates the Secondary pointer to AttConnectingInfo.
723  */
AttGetConnectingIndexByConnectHandle(uint16_t connectHandle,AttConnectingInfo ** connecting)724 void AttGetConnectingIndexByConnectHandle(uint16_t connectHandle, AttConnectingInfo **connecting)
725 {
726     LOG_INFO("%{public}s enter, connectHandle = %hu", __FUNCTION__, connectHandle);
727 
728     uint16_t index = 0;
729 
730     for (; index < MAXCONNECT; ++index) {
731         if (g_connecting[index].connectHandle == connectHandle) {
732             break;
733         }
734     }
735 
736     if (index != MAXCONNECT) {
737         *connecting = &g_connecting[index];
738         goto ATTGETCONNECTINGINDEXBYCONNECTHANDLE_END;
739     } else {
740         *connecting = NULL;
741         goto ATTGETCONNECTINGINDEXBYCONNECTHANDLE_END;
742     }
743 
744 ATTGETCONNECTINGINDEXBYCONNECTHANDLE_END:
745     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
746     return;
747 }
748 
749 /**
750  * @brief lookup AttConnectingInfo info by cid and connectHandle, result to output parameter index.
751  *
752  * @param1 cid Indicates the cid.
753  * @param2 connectHandle Indicates the connectHandle.
754  * @param3 index Indicates the pointer to index.
755  * @param4 connecting Indicates the Secondary pointer to AttConnectingInfo.
756  */
AttGetConnectingIndexByCidConnectHandle(uint16_t cid,uint16_t connectHandle,uint16_t * index,AttConnectingInfo ** connecting)757 void AttGetConnectingIndexByCidConnectHandle(
758     uint16_t cid, uint16_t connectHandle, uint16_t *index, AttConnectingInfo **connecting)
759 {
760     LOG_INFO("%{public}s enter, cid = %hu,connectHandle = %hu", __FUNCTION__, cid, connectHandle);
761 
762     uint16_t inindex = 0;
763 
764     for (; inindex < MAXCONNECT; ++inindex) {
765         if ((g_connecting[inindex].cid == cid) && (g_connecting[inindex].connectHandle == connectHandle)) {
766             break;
767         }
768     }
769 
770     *index = inindex;
771 
772     if (inindex != MAXCONNECT) {
773         *connecting = &g_connecting[inindex];
774         goto ATTGETCONNECTINGINDEXBYCIDCONNECTHANDLE_END;
775     } else {
776         *connecting = NULL;
777         goto ATTGETCONNECTINGINDEXBYCIDCONNECTHANDLE_END;
778     }
779 
780 ATTGETCONNECTINGINDEXBYCIDCONNECTHANDLE_END:
781     LOG_INFO("%{public}s return: *index = %hu", __FUNCTION__, *index);
782     return;
783 }
784 
785 /**
786  * @brief lookup AttConnectingInfo info by addr.
787  *
788  * @param1 addr Indicates the pointer to const BtAddr.
789  * @param2 connecting Indicates the second rank pointer to AttConnectingInfo.
790  */
AttGetConnectingIndexByAddr(const BtAddr * addr,AttConnectingInfo ** connecting)791 void AttGetConnectingIndexByAddr(const BtAddr *addr, AttConnectingInfo **connecting)
792 {
793     LOG_INFO("%{public}s enter", __FUNCTION__);
794 
795     uint16_t index = 0;
796 
797     for (; index < MAXCONNECT; ++index) {
798         if (!memcmp(g_connecting[index].addr.addr, addr->addr, ADDRESSLEN)) {
799             break;
800         }
801     }
802 
803     if (index != MAXCONNECT) {
804         *connecting = &g_connecting[index];
805         goto ATTGETCONNECTINGINDEXBYADDR_END;
806     } else {
807         *connecting = NULL;
808         goto ATTGETCONNECTINGINDEXBYADDR_END;
809     }
810 
811 ATTGETCONNECTINGINDEXBYADDR_END:
812     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
813     return;
814 }
815 
816 /**
817  * @brief lookup AttConnectingInfo info by addr cid.
818  *
819  * @param1 addr Indicates the pointer to addr.
820  * @param2 addr Indicates the cid.
821  * @param3 connect Indicates the second rank pointer to AttConnectingInfo.
822  */
AttGetConnectingIndexByAddrUninitializedCid(const BtAddr * addr,AttConnectingInfo ** connecting)823 void AttGetConnectingIndexByAddrUninitializedCid(const BtAddr *addr, AttConnectingInfo **connecting)
824 {
825     LOG_INFO("%{public}s enter", __FUNCTION__);
826 
827     uint16_t index = 0;
828 
829     for (; index < MAXCONNECT; ++index) {
830         if ((!memcmp(g_connecting[index].addr.addr, addr->addr, ADDRESSLEN)) && (g_connecting[index].cid == 0)) {
831             break;
832         }
833     }
834 
835     LOG_INFO("%{public}s,index = %hu", __FUNCTION__, index);
836 
837     if (index != MAXCONNECT) {
838         *connecting = &g_connecting[index];
839         goto ATTGETCONNECTINGINDEXBYADDRUNINITIALIZEDCID_END;
840     } else {
841         *connecting = NULL;
842         goto ATTGETCONNECTINGINDEXBYADDRUNINITIALIZEDCID_END;
843     }
844 
845 ATTGETCONNECTINGINDEXBYADDRUNINITIALIZEDCID_END:
846     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
847     return;
848 }
849 
850 /**
851  * @brief lookup AttConnectingInfo info by addr aclhandle cid.
852  *
853  * @param1 addr Indicates pointer to addr.
854  * @param2 addr Indicates the aclHandle.
855  * @param3 addr Indicates the cid.
856  * @param2 connect Indicates the second rank pointer to AttConnectingInfo.
857  */
AttGetConnectingIndexByAddrAclhandleCid(const BtAddr * addr,uint16_t aclHandle,uint16_t cid,AttConnectingInfo ** connecting)858 void AttGetConnectingIndexByAddrAclhandleCid(
859     const BtAddr *addr, uint16_t aclHandle, uint16_t cid, AttConnectingInfo **connecting)
860 {
861     LOG_INFO("%{public}s enter, aclHandle = %hu, cid = %hu", __FUNCTION__, aclHandle, cid);
862     uint16_t index = 0;
863 
864     for (; index < MAXCONNECT; ++index) {
865         if ((!memcmp(g_connecting[index].addr.addr, addr->addr, ADDRESSLEN)) &&
866             (g_connecting[index].aclHandle == aclHandle) && (g_connecting[index].cid == cid)) {
867             break;
868         }
869     }
870 
871     if (index != MAXCONNECT) {
872         *connecting = &g_connecting[index];
873         goto ATTGETCONNECTINGINDEXBYADDRACLHANDLECID_END;
874     } else {
875         *connecting = NULL;
876         goto ATTGETCONNECTINGINDEXBYADDRACLHANDLECID_END;
877     }
878 
879 ATTGETCONNECTINGINDEXBYADDRACLHANDLECID_END:
880     LOG_INFO("%{public}s return: index = %hu", __FUNCTION__, index);
881     return;
882 }
883 
884 /**
885  * @brief client call back copy.
886  *
887  * @param1 attSendDataCb Indicates the pointer to attSendDataCallback.
888  * @param2 context Indicates the pointer to context.
889  */
AttClientCallBackCopyToCommon(attSendDataCallback attSendDataCB,const void * context)890 void AttClientCallBackCopyToCommon(attSendDataCallback attSendDataCB, const void *context)
891 {
892     LOG_INFO("%{public}s enter", __FUNCTION__);
893 
894     g_attClientSendDataCB.attSendDataCB = attSendDataCB;
895     g_attClientSendDataCB.context = (void *)context;
896 
897     return;
898 }
899 /**
900  * @brief server call back copy.
901  *
902  * @param1 attSendDataCb Indicates the pointer to attSendDataCallback.
903  * @param2 context Indicates the pointer to context.
904  */
AttServerCallBackCopyToCommon(attSendDataCallback attSendDataCB,const void * context)905 void AttServerCallBackCopyToCommon(attSendDataCallback attSendDataCB, const void *context)
906 {
907     LOG_INFO("%{public}s enter", __FUNCTION__);
908 
909     g_attServerSendDataCB.attSendDataCB = attSendDataCB;
910     g_attServerSendDataCB.context = (void *)context;
911 
912     return;
913 }
914 
915 /**
916  * @brief le receive senddata callback async.
917  *
918  * @param context Indicates the pointer to context.
919  */
LeRecvSendDataCallbackAsync(const void * context)920 static void LeRecvSendDataCallbackAsync(const void *context)
921 {
922     LOG_INFO("%{public}s enter", __FUNCTION__);
923 
924     LeRecvSendDataCallbackAsyncContext *leRecvSendDataCallPtr = (LeRecvSendDataCallbackAsyncContext *)context;
925     AttConnectInfo *connect = NULL;
926 
927     AttGetConnectInfoIndexByCid(leRecvSendDataCallPtr->aclHandle, &connect);
928 
929     if (connect == NULL) {
930         goto RECVSENDDATACALLBACK_END;
931     }
932 
933     if (g_attClientSendDataCB.attSendDataCB != NULL) {
934         g_attClientSendDataCB.attSendDataCB(
935             connect->retGattConnectHandle, leRecvSendDataCallPtr->result, g_attClientSendDataCB.context);
936     }
937     if (leRecvSendDataCallPtr->result == BT_SUCCESS) {
938         AlarmSet(connect->alarm, (uint64_t)INSTRUCTIONTIMEOUT, (void (*)(void *))AttTransactionTimeOut, connect);
939     } else {
940         LOG_WARN("L2CAP error code = %{public}d", leRecvSendDataCallPtr->result);
941         AlarmCancel(connect->alarm);
942     }
943 
944 RECVSENDDATACALLBACK_END:
945     MEM_MALLOC.free(leRecvSendDataCallPtr);
946     return;
947 }
948 
949 /**
950  * @brief le receive senddata callback async destroy.
951  *
952  * @param context Indicates the pointer to context.
953  */
LeRecvSendDataCallbackAsyncDestroy(const void * context)954 static void LeRecvSendDataCallbackAsyncDestroy(const void *context)
955 {
956     LOG_INFO("%{public}s enter", __FUNCTION__);
957 
958     LeRecvSendDataCallbackAsyncContext *leRecvSendDataCallPtr = (LeRecvSendDataCallbackAsyncContext *)context;
959 
960     MEM_MALLOC.free(leRecvSendDataCallPtr);
961 
962     return;
963 }
964 
965 /**
966  * @brief receive senddata callback.
967  *
968  * @param1 aclHandle Indicates the aclHandle.
969  * @param2 result Indicates the result.
970  */
LeRecvSendDataCallback(uint16_t aclHandle,int result)971 void LeRecvSendDataCallback(uint16_t aclHandle, int result)
972 {
973     LOG_INFO("%{public}s enter", __FUNCTION__);
974 
975     LeRecvSendDataCallbackAsyncContext *leRecvSendDataCallPtr =
976         MEM_MALLOC.alloc(sizeof(LeRecvSendDataCallbackAsyncContext));
977     if (leRecvSendDataCallPtr == NULL) {
978         LOG_ERROR("point to NULL");
979         return;
980     }
981 
982     leRecvSendDataCallPtr->aclHandle = aclHandle;
983     leRecvSendDataCallPtr->result = result;
984 
985     AttAsyncProcess(LeRecvSendDataCallbackAsync, LeRecvSendDataCallbackAsyncDestroy, leRecvSendDataCallPtr);
986 
987     return;
988 }
989 
990 /**
991  * @brief BREDR receive senddata callback async.
992  *
993  * @param context Indicates the pointer to context.
994  */
BREDRRecvSendDataCallbackAsync(const void * context)995 static void BREDRRecvSendDataCallbackAsync(const void *context)
996 {
997     LOG_INFO("%{public}s enter", __FUNCTION__);
998 
999     BREDRRecvSendDataCallbackAsyncContext *bredrRecvSendDataCallPtr = (BREDRRecvSendDataCallbackAsyncContext *)context;
1000     AttConnectInfo *connect = NULL;
1001 
1002     AttGetConnectInfoIndexByCid(bredrRecvSendDataCallPtr->lcid, &connect);
1003 
1004     if (connect == NULL) {
1005         goto BREDRRECVSENDDATACALLBACK_END;
1006     }
1007 
1008     if (g_attClientSendDataCB.attSendDataCB != NULL) {
1009         g_attClientSendDataCB.attSendDataCB(
1010             connect->retGattConnectHandle, bredrRecvSendDataCallPtr->result, g_attClientSendDataCB.context);
1011     }
1012     if (bredrRecvSendDataCallPtr->result == BT_SUCCESS) {
1013         AlarmSet(connect->alarm, (uint64_t)INSTRUCTIONTIMEOUT, (void (*)(void *))AttTransactionTimeOut, connect);
1014     } else {
1015         LOG_WARN("L2CAP error code = %{public}d", bredrRecvSendDataCallPtr->result);
1016         AlarmCancel(connect->alarm);
1017     }
1018 
1019 BREDRRECVSENDDATACALLBACK_END:
1020     MEM_MALLOC.free(bredrRecvSendDataCallPtr);
1021     return;
1022 }
1023 
1024 /**
1025  * @brief BREDR receive senddata callback async destroy.
1026  *
1027  * @param context Indicates the pointer to context.
1028  */
BREDRRecvSendDataCallbackAsyncDestroy(const void * context)1029 static void BREDRRecvSendDataCallbackAsyncDestroy(const void *context)
1030 {
1031     LOG_INFO("%{public}s enter", __FUNCTION__);
1032 
1033     BREDRRecvSendDataCallbackAsyncContext *bredrRecvSendDataCallPtr = (BREDRRecvSendDataCallbackAsyncContext *)context;
1034 
1035     MEM_MALLOC.free(bredrRecvSendDataCallPtr);
1036 
1037     return;
1038 }
1039 
1040 /**
1041  * @brief receive senddata callback.
1042  *
1043  * @param1 lcid Indicates the lcid.
1044  * @param2 result Indicates the result.
1045  * @param3 context Indicates the pointer to context.
1046  */
BREDRRecvSendDataCallback(uint16_t lcid,int result)1047 void BREDRRecvSendDataCallback(uint16_t lcid, int result)
1048 {
1049     LOG_INFO("%{public}s enter", __FUNCTION__);
1050 
1051     BREDRRecvSendDataCallbackAsyncContext *bredrSendDataCallPtr =
1052         MEM_MALLOC.alloc(sizeof(BREDRRecvSendDataCallbackAsyncContext));
1053     if (bredrSendDataCallPtr == NULL) {
1054         LOG_ERROR("point to NULL");
1055         return;
1056     }
1057 
1058     bredrSendDataCallPtr->lcid = lcid;
1059     bredrSendDataCallPtr->result = result;
1060 
1061     AttAsyncProcess(BREDRRecvSendDataCallbackAsync, BREDRRecvSendDataCallbackAsyncDestroy, bredrSendDataCallPtr);
1062 
1063     return;
1064 }
1065 
1066 /**
1067  * @brief receive delect callback.
1068  *
1069  */
AttCallBackDelectCopyToCommon()1070 void AttCallBackDelectCopyToCommon()
1071 {
1072     LOG_INFO("%{public}s enter", __FUNCTION__);
1073 
1074     g_attServerSendDataCB.attSendDataCB = NULL;
1075     g_attServerSendDataCB.context = NULL;
1076 
1077     return;
1078 }
1079 
1080 /**
1081  * @brief switch thread.
1082  *
1083  * @param1 callback Indicates the pointer to function pointer.
1084  * @param2 destroyCallback Indicates the pointer to function pointer.
1085  * @param3 context Indicates the pointer to context.
1086  */
AttAsyncProcess(void (* callback)(const void * context),void (* destroyCallback)(const void * context),const void * context)1087 void AttAsyncProcess(
1088     void (*callback)(const void *context), void (*destroyCallback)(const void *context), const void *context)
1089 {
1090     LOG_INFO("%{public}s enter", __FUNCTION__);
1091 
1092     int ret;
1093 
1094     ret = BTM_RunTaskInProcessingQueue(PROCESSING_QUEUE_ID_ATT, (void (*)(void *))callback, (void *)context);
1095     if (ret != BT_SUCCESS) {
1096         if (destroyCallback != NULL) {
1097             destroyCallback(context);
1098         }
1099     }
1100 
1101     return;
1102 }
1103 
1104 /**
1105  * @brief shut down clear connect information.
1106  *
1107  * @param connectInfo Indicates the pointer to AttConnectInfo.
1108  */
AttShutDownClearConnectInfo(AttConnectInfo * connectInfo)1109 void AttShutDownClearConnectInfo(AttConnectInfo *connectInfo)
1110 {
1111     LOG_INFO("%{public}s enter", __FUNCTION__);
1112 
1113     connectInfo->aclHandle = 0;
1114     (void)memset_s(&connectInfo->AttConnectID, sizeof(connectInfo->AttConnectID), 0, sizeof(connectInfo->AttConnectID));
1115     connectInfo->retGattConnectHandle = 0;
1116     connectInfo->transportType = 0;
1117     (void)memset_s(&connectInfo->addr, sizeof(connectInfo->addr), 0, sizeof(BtAddr));
1118     connectInfo->mtu = 0;
1119     connectInfo->sendMtu = 0;
1120     connectInfo->receiveMtu = 0;
1121     connectInfo->mtuFlag = false;
1122     connectInfo->initPassConnFlag = 0;
1123     connectInfo->serverSendFlag = false;
1124 
1125     g_attClientCallback.attClientCallback = NULL;
1126     g_attServerCallback.attServerCallback = NULL;
1127     g_attClientSendDataCB.attSendDataCB = NULL;
1128     g_attServerSendDataCB.attSendDataCB = NULL;
1129     g_attConnect.attConnect.attBREDRConnectCompleted = NULL;
1130     g_attConnect.attConnect.attBREDRConnectInd = NULL;
1131     g_attConnect.attConnect.attBREDRDisconnectCompleted = NULL;
1132     g_attConnect.attConnect.attLEConnectCompleted = NULL;
1133     g_attConnect.attConnect.attLEDisconnectCompleted = NULL;
1134 
1135     return;
1136 }
1137 
1138 /**
1139  * @brief client callback btbadparam.
1140  *
1141  */
ClientCallbackBTBADPARAM(const AttConnectInfo * connect)1142 void ClientCallbackBTBADPARAM(const AttConnectInfo *connect)
1143 {
1144     LOG_INFO("%{public}s enter", __FUNCTION__);
1145 
1146     if (connect == NULL) {
1147         return;
1148     }
1149 
1150     if (g_attClientSendDataCB.attSendDataCB != NULL) {
1151         g_attClientSendDataCB.attSendDataCB(connect->retGattConnectHandle, BT_BAD_PARAM, g_attClientSendDataCB.context);
1152     }
1153 
1154     return;
1155 }
1156 
1157 /**
1158  * @brief server callback btbadparam.
1159  *
1160  */
ServerCallbackBTBADPARAM(const AttConnectInfo * connect)1161 void ServerCallbackBTBADPARAM(const AttConnectInfo *connect)
1162 {
1163     LOG_INFO("%{public}s enter", __FUNCTION__);
1164 
1165     if (g_attServerSendDataCB.attSendDataCB != NULL) {
1166         g_attServerSendDataCB.attSendDataCB(connect->retGattConnectHandle, BT_BAD_PARAM, g_attServerSendDataCB.context);
1167     }
1168 
1169     return;
1170 }
1171 
1172 /**
1173  * @brief client callback return value.
1174  *
1175  * @param1 ret Indicates the ret.
1176  * @param2 connect Indicates the pointer of AttConnectInfo.
1177  */
ClientCallbackReturnValue(int ret,const AttConnectInfo * connect)1178 void ClientCallbackReturnValue(int ret, const AttConnectInfo *connect)
1179 {
1180     LOG_INFO("%{public}s enter", __FUNCTION__);
1181 
1182     if (ret != BT_SUCCESS) {
1183         if (g_attClientSendDataCB.attSendDataCB != NULL) {
1184             g_attClientSendDataCB.attSendDataCB(connect->retGattConnectHandle, ret, g_attClientSendDataCB.context);
1185         }
1186     }
1187 
1188     return;
1189 }
1190 
1191 /**
1192  * @brief server callback return value.
1193  *
1194  * @param1 ret Indicates the ret.
1195  * @param2 connect Indicates the pointer of AttConnectInfo.
1196  */
ServerCallbackReturnValue(int ret,const AttConnectInfo * connect)1197 void ServerCallbackReturnValue(int ret, const AttConnectInfo *connect)
1198 {
1199     LOG_INFO("%{public}s enter", __FUNCTION__);
1200 
1201     if (ret != BT_SUCCESS) {
1202         if (g_attServerSendDataCB.attSendDataCB != NULL) {
1203             g_attServerSendDataCB.attSendDataCB(connect->retGattConnectHandle, ret, g_attServerSendDataCB.context);
1204         }
1205     }
1206 
1207     return;
1208 }
1209 
1210 /**
1211  * @brief receive  bredr connect instructions data in self thread.
1212  *
1213  * @param context Indicates the pointer to context.
1214  */
AttRecvDataAsync(const void * context)1215 static void AttRecvDataAsync(const void *context)
1216 {
1217     LOG_INFO("%{public}s enter", __FUNCTION__);
1218 
1219     uint8_t opcode = 0;
1220     AttConnectInfo *connect = NULL;
1221     AttRecvDataAsyncContext *attRecvDataAsyncPtr = (AttRecvDataAsyncContext *)context;
1222     AttGetConnectInfoIndexByCid(attRecvDataAsyncPtr->lcid, &connect);
1223     if (connect != NULL) {
1224         PacketExtractHead(attRecvDataAsyncPtr->packet, &opcode, sizeof(uint8_t));
1225         Buffer *buffer = PacketContinuousPayload(attRecvDataAsyncPtr->packet);
1226         recvDataFunction functionPtr = GetFunction(opcode);
1227         if (functionPtr != NULL) {
1228             functionPtr(connect, buffer);
1229         } else {
1230             LOG_WARN("%{public}s UnKnow OpCode : %hhu", __FUNCTION__, opcode);
1231             if ((opcode & 0b01000000) == 0) {
1232                 AttErrorCode(connect, opcode);
1233             }
1234         }
1235     }
1236 
1237     PacketFree(attRecvDataAsyncPtr->packet);
1238     MEM_MALLOC.free(attRecvDataAsyncPtr);
1239 
1240     return;
1241 }
1242 
1243 /**
1244  * @brief destroy receive bredr connect instructions data in self thread.
1245  *
1246  * @param context Indicates the pointer to context.
1247  */
AttRecvDataAsyncDestroy(const void * context)1248 static void AttRecvDataAsyncDestroy(const void *context)
1249 {
1250     LOG_INFO("%{public}s enter", __FUNCTION__);
1251 
1252     AttRecvDataAsyncContext *attRecvDataAsyncPtr = (AttRecvDataAsyncContext *)context;
1253 
1254     PacketFree(attRecvDataAsyncPtr->packet);
1255     MEM_MALLOC.free(attRecvDataAsyncPtr);
1256 
1257     return;
1258 }
1259 
1260 /**
1261  * @brief receive  bredr connect instructions data.
1262  *
1263  * @param1 lcid Indicates the lcid.
1264  * @param2 packet Indicates the pointer to Packet.
1265  * @param3 ctx Indicates the pointer to  context.
1266  */
AttRecvData(uint16_t lcid,const Packet * packet,const void * ctx)1267 void AttRecvData(uint16_t lcid, const Packet *packet, const void *ctx)
1268 {
1269     LOG_INFO("%{public}s enter,lcid = %hu", __FUNCTION__, lcid);
1270 
1271     Packet *packetPtr = PacketRefMalloc((Packet *)packet);
1272     AttRecvDataAsyncContext *attRecvDataAsyncPtr = MEM_MALLOC.alloc(sizeof(AttRecvDataAsyncContext));
1273     if (attRecvDataAsyncPtr == NULL) {
1274         LOG_ERROR("point to NULL");
1275         return;
1276     }
1277     attRecvDataAsyncPtr->lcid = lcid;
1278     attRecvDataAsyncPtr->packet = packetPtr;
1279     attRecvDataAsyncPtr->ctx = (void *)ctx;
1280 
1281     AttAsyncProcess(AttRecvDataAsync, AttRecvDataAsyncDestroy, attRecvDataAsyncPtr);
1282 
1283     return;
1284 }
1285 
1286 /**
1287  * @brief receive le connect instructions data in self thread.
1288  *
1289  * @param context Indicates the pointer to context.
1290  */
AttRecvLeDataAsync(const void * context)1291 static void AttRecvLeDataAsync(const void *context)
1292 {
1293     LOG_INFO("%{public}s enter", __FUNCTION__);
1294 
1295     uint8_t opcode = 0;
1296     AttConnectInfo *connect = NULL;
1297     AttRecvLeDataAsyncContext *attRecvLeDataAsyncPtr = (AttRecvLeDataAsyncContext *)context;
1298     AttGetConnectInfoIndexByAclHandle(attRecvLeDataAsyncPtr->aclHandle, &connect);
1299     if (connect != NULL) {
1300         PacketExtractHead(attRecvLeDataAsyncPtr->packet, &opcode, sizeof(uint8_t));
1301         Buffer *buffer = PacketContinuousPayload(attRecvLeDataAsyncPtr->packet);
1302         recvDataFunction functionPtr = GetFunction(opcode);
1303         if (functionPtr != NULL) {
1304             functionPtr(connect, buffer);
1305         } else {
1306             LOG_WARN("UnKnow OpCode : %hhu", opcode);
1307             if ((opcode & 0b01000000) == 0) {
1308                 AttErrorCode(connect, opcode);
1309             }
1310         }
1311     }
1312 
1313     PacketFree(attRecvLeDataAsyncPtr->packet);
1314     MEM_MALLOC.free(attRecvLeDataAsyncPtr);
1315 
1316     return;
1317 }
1318 
1319 /**
1320  * @brief destroy le bredr connect instructions data in self thread.
1321  *
1322  * @param context Indicates the pointer to context.
1323  */
AttRecvLeDataAsyncDestroy(const void * context)1324 static void AttRecvLeDataAsyncDestroy(const void *context)
1325 {
1326     LOG_INFO("%{public}s enter", __FUNCTION__);
1327 
1328     AttRecvLeDataAsyncContext *attRecvLeDataAsyncPtr = (AttRecvLeDataAsyncContext *)context;
1329 
1330     PacketFree(attRecvLeDataAsyncPtr->packet);
1331     MEM_MALLOC.free(attRecvLeDataAsyncPtr);
1332 
1333     return;
1334 }
1335 
1336 /**
1337  * @brief receive  le connect instructions data.
1338  *
1339  * @param1 aclHandle Indicates the aclHandle.
1340  * @param2 packet Indicates the pointer to Packet.
1341  */
AttRecvLeData(uint16_t aclHandle,const Packet * packet)1342 void AttRecvLeData(uint16_t aclHandle, const Packet *packet)
1343 {
1344     LOG_INFO("%{public}s enter, aclHandle = %hu", __FUNCTION__, aclHandle);
1345 
1346     Packet *packetPtr = PacketRefMalloc((Packet *)packet);
1347     AttRecvLeDataAsyncContext *attRecvLeDataAsyncPtr = MEM_MALLOC.alloc(sizeof(AttRecvLeDataAsyncContext));
1348     if (attRecvLeDataAsyncPtr == NULL) {
1349         LOG_ERROR("point to NULL");
1350         return;
1351     }
1352     attRecvLeDataAsyncPtr->aclHandle = aclHandle;
1353     attRecvLeDataAsyncPtr->packet = packetPtr;
1354 
1355     AttAsyncProcess(AttRecvLeDataAsync, AttRecvLeDataAsyncDestroy, attRecvLeDataAsyncPtr);
1356 
1357     return;
1358 }
1359 
1360 /**
1361  * @brief get function.
1362  *
1363  * @param1 opcode Indicates the opcode.
1364  * @return Returns the recvDataFunction.
1365  */
GetFunction(uint8_t opcode)1366 static recvDataFunction GetFunction(uint8_t opcode)
1367 {
1368     return g_functionList[opcode];
1369 }
1370 
1371 /**
1372  * @brief get function array dress.
1373  *
1374  * @return Returns the pointer to recvDataFunction.
1375  */
GetFunctionArrayDress()1376 recvDataFunction *GetFunctionArrayDress()
1377 {
1378     return g_functionList;
1379 }
1380 
1381 /**
1382  * @brief get att connect callback.
1383  *
1384  * @return Returns the pointer to AttConnectedCallback.
1385  */
AttGetATTConnectCallback()1386 AttConnectedCallback *AttGetATTConnectCallback()
1387 {
1388     LOG_INFO("%{public}s enter", __FUNCTION__);
1389 
1390     return &g_attConnect;
1391 }
1392 
AttConnectRegisterAsync(const void * context)1393 static void AttConnectRegisterAsync(const void *context)
1394 {
1395     LOG_INFO("%{public}s enter", __FUNCTION__);
1396 
1397     AttConnectRegisterContext *attConnRegPtr = (AttConnectRegisterContext *)context;
1398     AttConnectedCallback *attConnectCallback = AttGetATTConnectCallback();
1399 
1400     attConnectCallback->attConnect = attConnRegPtr->connectBack;
1401     attConnectCallback->context = attConnRegPtr->context;
1402 
1403     MEM_MALLOC.free(attConnRegPtr);
1404 
1405     return;
1406 }
1407 
AttConnectRegisterAsyncDestroy(const void * context)1408 static void AttConnectRegisterAsyncDestroy(const void *context)
1409 {
1410     LOG_INFO("%{public}s enter", __FUNCTION__);
1411 
1412     AttConnectRegisterContext *attConnRegPtr = (AttConnectRegisterContext *)context;
1413 
1414     MEM_MALLOC.free(attConnRegPtr);
1415 
1416     return;
1417 }
1418 
1419 /**
1420  * @brief gatt register connect to att.
1421  *
1422  * @param1 connectBack Indicates the struct to callback.
1423  * @param2 context Indicates the pointer to context.
1424  */
ATT_ConnectRegister(AttConnectCallback connectBack,void * context)1425 void ATT_ConnectRegister(AttConnectCallback connectBack, void *context)
1426 {
1427     LOG_INFO("%{public}s enter", __FUNCTION__);
1428 
1429     AttConnectRegisterContext *attConnRegPtr = MEM_MALLOC.alloc(sizeof(AttConnectRegisterContext));
1430     if (attConnRegPtr == NULL) {
1431         LOG_ERROR("point to NULL");
1432         return;
1433     }
1434 
1435     (void)memcpy_s(
1436         &(attConnRegPtr->connectBack), sizeof(attConnRegPtr->connectBack), &connectBack, sizeof(AttConnectCallback));
1437     attConnRegPtr->context = context;
1438 
1439     AttAsyncProcess(AttConnectRegisterAsync, AttConnectRegisterAsyncDestroy, attConnRegPtr);
1440 
1441     return;
1442 }
1443 
AttConnectDeregisterAsync(const void * context)1444 static void AttConnectDeregisterAsync(const void *context)
1445 {
1446     LOG_INFO("%{public}s enter", __FUNCTION__);
1447 
1448     AttConnectedCallback *attConnectCallback = AttGetATTConnectCallback();
1449 
1450     attConnectCallback->attConnect.attLEConnectCompleted = NULL;
1451     attConnectCallback->attConnect.attLEDisconnectCompleted = NULL;
1452     attConnectCallback->attConnect.attBREDRConnectCompleted = NULL;
1453     attConnectCallback->attConnect.attBREDRDisconnectCompleted = NULL;
1454     attConnectCallback->attConnect.attBREDRConnectInd = NULL;
1455     attConnectCallback->context = NULL;
1456 
1457     return;
1458 }
1459 
AttConnectDeregisterAsyncDestroy(const void * context)1460 static void AttConnectDeregisterAsyncDestroy(const void *context)
1461 {
1462     LOG_INFO("%{public}s enter", __FUNCTION__);
1463 
1464     return;
1465 }
1466 
1467 /**
1468  * @brief gatt deregister connect to att.
1469  *
1470  */
ATT_ConnectDeregister()1471 void ATT_ConnectDeregister()
1472 {
1473     LOG_INFO("%{public}s enter", __FUNCTION__);
1474 
1475     AttAsyncProcess(AttConnectDeregisterAsync, AttConnectDeregisterAsyncDestroy, NULL);
1476 
1477     return;
1478 }
1479 
AttBREDRSendRespCallbackAsync(const void * context)1480 static void AttBREDRSendRespCallbackAsync(const void *context)
1481 {
1482     LOG_INFO("%{public}s enter", __FUNCTION__);
1483 
1484     BREDRRecvSendDataCallbackAsyncContext *attBredrSendRspPtr = (BREDRRecvSendDataCallbackAsyncContext *)context;
1485     AttConnectInfo *connect = NULL;
1486 
1487     AttGetConnectInfoIndexByCid(attBredrSendRspPtr->lcid, &connect);
1488 
1489     if (connect == NULL) {
1490         LOG_INFO("%{public}s connect == NULL", __FUNCTION__);
1491         goto ATTBREDRSENDRESPCALLBACK_END;
1492     }
1493 
1494     if (attBredrSendRspPtr->result != BT_SUCCESS) {
1495         LOG_WARN("L2CAP Send Resp error ,error code = %{public}d", attBredrSendRspPtr->result);
1496     }
1497 
1498     if (g_attServerSendDataCB.attSendDataCB != NULL) {
1499         g_attServerSendDataCB.attSendDataCB(
1500             connect->retGattConnectHandle, attBredrSendRspPtr->result, g_attServerSendDataCB.context);
1501     }
1502 
1503 ATTBREDRSENDRESPCALLBACK_END:
1504     MEM_MALLOC.free(attBredrSendRspPtr);
1505     return;
1506 }
1507 
AttBREDRSendRespCallbackAsyncDestroy(const void * context)1508 static void AttBREDRSendRespCallbackAsyncDestroy(const void *context)
1509 {
1510     LOG_INFO("%{public}s enter", __FUNCTION__);
1511 
1512     BREDRRecvSendDataCallbackAsyncContext *attBredrSendRspPtr = (BREDRRecvSendDataCallbackAsyncContext *)context;
1513 
1514     MEM_MALLOC.free(attBredrSendRspPtr);
1515 
1516     return;
1517 }
1518 
1519 /**
1520  * @brief callback of send response.
1521  *
1522  * @param1 lcid Indicates the lcid.
1523  * @param2 result Indicates the result.
1524  */
AttBREDRSendRespCallback(uint16_t lcid,int result)1525 static void AttBREDRSendRespCallback(uint16_t lcid, int result)
1526 {
1527     LOG_INFO("%{public}s enter", __FUNCTION__);
1528 
1529     BREDRRecvSendDataCallbackAsyncContext *attBredrSendRspPtr =
1530         MEM_MALLOC.alloc(sizeof(BREDRRecvSendDataCallbackAsyncContext));
1531     if (attBredrSendRspPtr == NULL) {
1532         LOG_ERROR("point to NULL");
1533         return;
1534     }
1535 
1536     attBredrSendRspPtr->lcid = lcid;
1537     attBredrSendRspPtr->result = result;
1538 
1539     AttAsyncProcess(AttBREDRSendRespCallbackAsync, AttBREDRSendRespCallbackAsyncDestroy, attBredrSendRspPtr);
1540 
1541     return;
1542 }
1543 
AttLeSendRespCallbackAsync(const void * context)1544 static void AttLeSendRespCallbackAsync(const void *context)
1545 {
1546     LOG_INFO("%{public}s enter", __FUNCTION__);
1547 
1548     LeRecvSendDataCallbackAsyncContext *attLeSendRspPtr = (LeRecvSendDataCallbackAsyncContext *)context;
1549     AttConnectInfo *connect = NULL;
1550 
1551     AttGetConnectInfoIndexByCid(attLeSendRspPtr->aclHandle, &connect);
1552 
1553     if (connect == NULL) {
1554         LOG_INFO("%{public}s connect == NULL", __FUNCTION__);
1555         goto ATTLESENDRESPCALLBACK_END;
1556     }
1557 
1558     if (attLeSendRspPtr->result != BT_SUCCESS) {
1559         LOG_WARN("L2CAP Send Resp error ,error code = %{public}d", attLeSendRspPtr->result);
1560     }
1561 
1562     if (g_attServerSendDataCB.attSendDataCB != NULL) {
1563         g_attServerSendDataCB.attSendDataCB(
1564             connect->retGattConnectHandle, attLeSendRspPtr->result, g_attServerSendDataCB.context);
1565     }
1566 
1567 ATTLESENDRESPCALLBACK_END:
1568     MEM_MALLOC.free(attLeSendRspPtr);
1569     return;
1570 }
1571 
AttLeSendRespCallbackAsyncDestroy(const void * context)1572 static void AttLeSendRespCallbackAsyncDestroy(const void *context)
1573 {
1574     LOG_INFO("%{public}s enter", __FUNCTION__);
1575 
1576     LeRecvSendDataCallbackAsyncContext *attLeSendRspPtr = (LeRecvSendDataCallbackAsyncContext *)context;
1577 
1578     MEM_MALLOC.free(attLeSendRspPtr);
1579 
1580     return;
1581 }
1582 
AttLeSendRespCallback(uint16_t aclHandle,int result)1583 static void AttLeSendRespCallback(uint16_t aclHandle, int result)
1584 {
1585     LOG_INFO("%{public}s enter", __FUNCTION__);
1586 
1587     LeRecvSendDataCallbackAsyncContext *attLeSendRspPtr = MEM_MALLOC.alloc(sizeof(LeRecvSendDataCallbackAsyncContext));
1588     if (attLeSendRspPtr == NULL) {
1589         LOG_ERROR("point to NULL");
1590         return;
1591     }
1592 
1593     attLeSendRspPtr->aclHandle = aclHandle;
1594     attLeSendRspPtr->result = result;
1595 
1596     AttAsyncProcess(AttLeSendRespCallbackAsync, AttLeSendRespCallbackAsyncDestroy, attLeSendRspPtr);
1597 
1598     return;
1599 }
1600 
1601 /**
1602  * @brief call l2cap interface to send data.
1603  *
1604  * @param1 connect Indicates the pointer to const AttConnectInfo.
1605  * @param2 packet Indicates the pointer to Packet.
1606  * @return Returns <b>0</b> if the operation is successful; returns <b>!0</b> if the operation fails.
1607  */
AttResponseSendData(const AttConnectInfo * connect,const Packet * packet)1608 int AttResponseSendData(const AttConnectInfo *connect, const Packet *packet)
1609 {
1610     LOG_INFO("%{public}s enter", __FUNCTION__);
1611 
1612     int ret = BT_OPERATION_FAILED;
1613 
1614     if (connect == NULL) {
1615         LOG_INFO("%{public}s connect == NULL", __FUNCTION__);
1616         ret = BT_BAD_PARAM;
1617         return ret;
1618     }
1619 
1620     if (connect->transportType == BT_TRANSPORT_BR_EDR) {
1621         ret = L2CIF_SendData(connect->AttConnectID.bredrcid, (Packet *)packet, AttBREDRSendRespCallback);
1622     }
1623     if (connect->transportType == BT_TRANSPORT_LE) {
1624         ret = L2CIF_LeSendFixChannelData(connect->aclHandle, (uint16_t)LE_CID, (Packet *)packet, AttLeSendRespCallback);
1625     }
1626 
1627     return ret;
1628 }
1629 
1630 /**
1631  * @brief callback error code.
1632  *
1633  * @param1 connect Indicates the pointer to const AttConnectInfo.
1634  * @param2 opcode Indicates the opcode.
1635  */
AttErrorCode(const AttConnectInfo * connect,uint8_t opcode)1636 void AttErrorCode(const AttConnectInfo *connect, uint8_t opcode)
1637 {
1638     LOG_INFO("%{public}s enter", __FUNCTION__);
1639 
1640     if (connect == NULL) {
1641         LOG_INFO("%{public}s connect == NULL", __FUNCTION__);
1642         goto ATTERRORCODE_END;
1643     }
1644 
1645     AttServerDataCallback *attServerDataCallback = NULL;
1646     uint8_t errorCode = opcode;
1647     attServerDataCallback = AttGetATTServerCallback();
1648     attServerDataCallback->attServerCallback(
1649         connect->retGattConnectHandle, ATT_UNKNOW_OPCODE_ID, &errorCode, NULL, attServerDataCallback->context);
1650 
1651 ATTERRORCODE_END:
1652     return;
1653 }
1654 
Min(uint16_t param1,uint16_t param2)1655 uint16_t Min(uint16_t param1, uint16_t param2)
1656 {
1657     if (param1 < param2) {
1658         return param1;
1659     } else {
1660         return param2;
1661     }
1662 }
1663