1 /******************************************************************************
2  *
3  *  Copyright (C) 2003-2012 Broadcom Corporation
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 /******************************************************************************
20  *
21  *  This file contains the GATT client utility function.
22  *
23  ******************************************************************************/
24 
25 #define LOG_TAG "bt_bta_gattc"
26 
27 #include "bt_target.h"
28 
29 #include <string.h>
30 
31 #include "bt_common.h"
32 #include "bta_gattc_int.h"
33 #include "bta_sys.h"
34 #include "btcore/include/bdaddr.h"
35 #include "l2c_api.h"
36 #include "utl.h"
37 
38 /*****************************************************************************
39  *  Constants
40  ****************************************************************************/
41 
42 static const uint8_t base_uuid[LEN_UUID_128] = {
43     0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
44     0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
45 
46 static const BD_ADDR dummy_bda = {0, 0, 0, 0, 0, 0};
47 
48 /*******************************************************************************
49  *
50  * Function         bta_gatt_convert_uuid16_to_uuid128
51  *
52  * Description      Convert a 16 bits UUID to be an standard 128 bits one.
53  *
54  * Returns          true if two uuid match; false otherwise.
55  *
56  ******************************************************************************/
bta_gatt_convert_uuid16_to_uuid128(uint8_t uuid_128[LEN_UUID_128],uint16_t uuid_16)57 void bta_gatt_convert_uuid16_to_uuid128(uint8_t uuid_128[LEN_UUID_128],
58                                         uint16_t uuid_16) {
59   uint8_t* p = &uuid_128[LEN_UUID_128 - 4];
60 
61   memcpy(uuid_128, base_uuid, LEN_UUID_128);
62 
63   UINT16_TO_STREAM(p, uuid_16);
64 }
65 /*******************************************************************************
66  *
67  * Function         bta_gattc_uuid_compare
68  *
69  * Description      Compare two UUID to see if they are the same.
70  *
71  * Returns          true if two uuid match; false otherwise.
72  *
73  ******************************************************************************/
bta_gattc_uuid_compare(const tBT_UUID * p_src,const tBT_UUID * p_tar,bool is_precise)74 bool bta_gattc_uuid_compare(const tBT_UUID* p_src, const tBT_UUID* p_tar,
75                             bool is_precise) {
76   uint8_t su[LEN_UUID_128], tu[LEN_UUID_128];
77   const uint8_t *ps, *pt;
78 
79   /* any of the UUID is unspecified */
80   if (p_src == 0 || p_tar == 0) {
81     if (is_precise)
82       return false;
83     else
84       return true;
85   }
86 
87   /* If both are 16-bit, we can do a simple compare */
88   if (p_src->len == 2 && p_tar->len == 2) {
89     return p_src->uu.uuid16 == p_tar->uu.uuid16;
90   }
91 
92   /* One or both of the UUIDs is 128-bit */
93   if (p_src->len == LEN_UUID_16) {
94     /* convert a 16 bits UUID to 128 bits value */
95     bta_gatt_convert_uuid16_to_uuid128(su, p_src->uu.uuid16);
96     ps = su;
97   } else
98     ps = p_src->uu.uuid128;
99 
100   if (p_tar->len == LEN_UUID_16) {
101     /* convert a 16 bits UUID to 128 bits value */
102     bta_gatt_convert_uuid16_to_uuid128(tu, p_tar->uu.uuid16);
103     pt = tu;
104   } else
105     pt = p_tar->uu.uuid128;
106 
107   return (memcmp(ps, pt, LEN_UUID_128) == 0);
108 }
109 
110 /*******************************************************************************
111  *
112  * Function         bta_gattc_cl_get_regcb
113  *
114  * Description      get registration control block by client interface.
115  *
116  * Returns          pointer to the regcb
117  *
118  ******************************************************************************/
bta_gattc_cl_get_regcb(uint8_t client_if)119 tBTA_GATTC_RCB* bta_gattc_cl_get_regcb(uint8_t client_if) {
120   uint8_t i = 0;
121   tBTA_GATTC_RCB* p_clrcb = &bta_gattc_cb.cl_rcb[0];
122 
123   for (i = 0; i < BTA_GATTC_CL_MAX; i++, p_clrcb++) {
124     if (p_clrcb->in_use && p_clrcb->client_if == client_if) return p_clrcb;
125   }
126   return NULL;
127 }
128 /*******************************************************************************
129  *
130  * Function         bta_gattc_num_reg_app
131  *
132  * Description      find the number of registered application.
133  *
134  * Returns          pointer to the regcb
135  *
136  ******************************************************************************/
bta_gattc_num_reg_app(void)137 uint8_t bta_gattc_num_reg_app(void) {
138   uint8_t i = 0, j = 0;
139 
140   for (i = 0; i < BTA_GATTC_CL_MAX; i++) {
141     if (bta_gattc_cb.cl_rcb[i].in_use) j++;
142   }
143   return j;
144 }
145 /*******************************************************************************
146  *
147  * Function         bta_gattc_find_clcb_by_cif
148  *
149  * Description      get clcb by client interface and remote bd adddress
150  *
151  * Returns          pointer to the clcb
152  *
153  ******************************************************************************/
bta_gattc_find_clcb_by_cif(uint8_t client_if,BD_ADDR remote_bda,tBTA_TRANSPORT transport)154 tBTA_GATTC_CLCB* bta_gattc_find_clcb_by_cif(uint8_t client_if,
155                                             BD_ADDR remote_bda,
156                                             tBTA_TRANSPORT transport) {
157   tBTA_GATTC_CLCB* p_clcb = &bta_gattc_cb.clcb[0];
158   uint8_t i;
159 
160   for (i = 0; i < BTA_GATTC_CLCB_MAX; i++, p_clcb++) {
161     if (p_clcb->in_use && p_clcb->p_rcb->client_if == client_if &&
162         p_clcb->transport == transport && bdcmp(p_clcb->bda, remote_bda) == 0)
163       return p_clcb;
164   }
165   return NULL;
166 }
167 /*******************************************************************************
168  *
169  * Function         bta_gattc_find_clcb_by_conn_id
170  *
171  * Description      get clcb by connection ID
172  *
173  * Returns          pointer to the clcb
174  *
175  ******************************************************************************/
bta_gattc_find_clcb_by_conn_id(uint16_t conn_id)176 tBTA_GATTC_CLCB* bta_gattc_find_clcb_by_conn_id(uint16_t conn_id) {
177   tBTA_GATTC_CLCB* p_clcb = &bta_gattc_cb.clcb[0];
178   uint8_t i;
179 
180   for (i = 0; i < BTA_GATTC_CLCB_MAX; i++, p_clcb++) {
181     if (p_clcb->in_use && p_clcb->bta_conn_id == conn_id) return p_clcb;
182   }
183   return NULL;
184 }
185 
186 /*******************************************************************************
187  *
188  * Function         bta_gattc_clcb_alloc
189  *
190  * Description      allocate CLCB
191  *
192  * Returns          pointer to the clcb
193  *
194  ******************************************************************************/
bta_gattc_clcb_alloc(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,tBTA_TRANSPORT transport)195 tBTA_GATTC_CLCB* bta_gattc_clcb_alloc(tBTA_GATTC_IF client_if,
196                                       BD_ADDR remote_bda,
197                                       tBTA_TRANSPORT transport) {
198   uint8_t i_clcb = 0;
199   tBTA_GATTC_CLCB* p_clcb = NULL;
200 
201   for (i_clcb = 0; i_clcb < BTA_GATTC_CLCB_MAX; i_clcb++) {
202     if (!bta_gattc_cb.clcb[i_clcb].in_use) {
203 #if (BTA_GATT_DEBUG == TRUE)
204       APPL_TRACE_DEBUG("bta_gattc_clcb_alloc: found clcb[%d] available",
205                        i_clcb);
206 #endif
207       p_clcb = &bta_gattc_cb.clcb[i_clcb];
208       p_clcb->in_use = true;
209       p_clcb->status = BTA_GATT_OK;
210       p_clcb->transport = transport;
211       bdcpy(p_clcb->bda, remote_bda);
212 
213       p_clcb->p_rcb = bta_gattc_cl_get_regcb(client_if);
214 
215       p_clcb->p_srcb = bta_gattc_find_srcb(remote_bda);
216       if (p_clcb->p_srcb == NULL)
217         p_clcb->p_srcb = bta_gattc_srcb_alloc(remote_bda);
218 
219       if (p_clcb->p_rcb != NULL && p_clcb->p_srcb != NULL) {
220         p_clcb->p_srcb->num_clcb++;
221         p_clcb->p_rcb->num_clcb++;
222       } else {
223         /* release this clcb if clcb or srcb allocation failed */
224         p_clcb->in_use = false;
225         p_clcb = NULL;
226       }
227       break;
228     }
229   }
230   return p_clcb;
231 }
232 /*******************************************************************************
233  *
234  * Function         bta_gattc_find_alloc_clcb
235  *
236  * Description      find or allocate CLCB if not found.
237  *
238  * Returns          pointer to the clcb
239  *
240  ******************************************************************************/
bta_gattc_find_alloc_clcb(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,tBTA_TRANSPORT transport)241 tBTA_GATTC_CLCB* bta_gattc_find_alloc_clcb(tBTA_GATTC_IF client_if,
242                                            BD_ADDR remote_bda,
243                                            tBTA_TRANSPORT transport) {
244   tBTA_GATTC_CLCB* p_clcb;
245 
246   p_clcb = bta_gattc_find_clcb_by_cif(client_if, remote_bda, transport);
247   if (p_clcb == NULL) {
248     p_clcb = bta_gattc_clcb_alloc(client_if, remote_bda, transport);
249   }
250   return p_clcb;
251 }
252 
253 /*******************************************************************************
254  *
255  * Function         bta_gattc_clcb_dealloc
256  *
257  * Description      Deallocte a clcb
258  *
259  * Returns          pointer to the clcb
260  *
261  ******************************************************************************/
bta_gattc_clcb_dealloc(tBTA_GATTC_CLCB * p_clcb)262 void bta_gattc_clcb_dealloc(tBTA_GATTC_CLCB* p_clcb) {
263   tBTA_GATTC_SERV* p_srcb = NULL;
264 
265   if (p_clcb) {
266     p_srcb = p_clcb->p_srcb;
267     if (p_srcb->num_clcb) p_srcb->num_clcb--;
268 
269     if (p_clcb->p_rcb->num_clcb) p_clcb->p_rcb->num_clcb--;
270 
271     /* if the srcb is no longer needed, reset the state */
272     if (p_srcb->num_clcb == 0) {
273       p_srcb->connected = false;
274       p_srcb->state = BTA_GATTC_SERV_IDLE;
275       p_srcb->mtu = 0;
276 
277       /* clean up cache */
278       if (p_srcb->p_srvc_cache) {
279         list_free(p_srcb->p_srvc_cache);
280         p_srcb->p_srvc_cache = NULL;
281       }
282     }
283 
284     osi_free_and_reset((void**)&p_clcb->p_q_cmd);
285     memset(p_clcb, 0, sizeof(tBTA_GATTC_CLCB));
286   } else {
287     APPL_TRACE_ERROR("bta_gattc_clcb_dealloc p_clcb=NULL");
288   }
289 }
290 
291 /*******************************************************************************
292  *
293  * Function         bta_gattc_find_srcb
294  *
295  * Description      find server cache by remote bd address currently in use
296  *
297  * Returns          pointer to the server cache.
298  *
299  ******************************************************************************/
bta_gattc_find_srcb(BD_ADDR bda)300 tBTA_GATTC_SERV* bta_gattc_find_srcb(BD_ADDR bda) {
301   tBTA_GATTC_SERV* p_srcb = &bta_gattc_cb.known_server[0];
302   uint8_t i;
303 
304   for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i++, p_srcb++) {
305     if (p_srcb->in_use && bdcmp(p_srcb->server_bda, bda) == 0) return p_srcb;
306   }
307   return NULL;
308 }
309 
310 /*******************************************************************************
311  *
312  * Function         bta_gattc_find_srvr_cache
313  *
314  * Description      find server cache by remote bd address
315  *
316  * Returns          pointer to the server cache.
317  *
318  ******************************************************************************/
bta_gattc_find_srvr_cache(BD_ADDR bda)319 tBTA_GATTC_SERV* bta_gattc_find_srvr_cache(BD_ADDR bda) {
320   tBTA_GATTC_SERV* p_srcb = &bta_gattc_cb.known_server[0];
321   uint8_t i;
322 
323   for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i++, p_srcb++) {
324     if (bdcmp(p_srcb->server_bda, bda) == 0) return p_srcb;
325   }
326   return NULL;
327 }
328 /*******************************************************************************
329  *
330  * Function         bta_gattc_find_scb_by_cid
331  *
332  * Description      find server control block by connection ID
333  *
334  * Returns          pointer to the server cache.
335  *
336  ******************************************************************************/
bta_gattc_find_scb_by_cid(uint16_t conn_id)337 tBTA_GATTC_SERV* bta_gattc_find_scb_by_cid(uint16_t conn_id) {
338   tBTA_GATTC_CLCB* p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
339 
340   if (p_clcb)
341     return p_clcb->p_srcb;
342   else
343     return NULL;
344 }
345 /*******************************************************************************
346  *
347  * Function         bta_gattc_srcb_alloc
348  *
349  * Description      allocate server cache control block
350  *
351  * Returns          pointer to the server cache.
352  *
353  ******************************************************************************/
bta_gattc_srcb_alloc(BD_ADDR bda)354 tBTA_GATTC_SERV* bta_gattc_srcb_alloc(BD_ADDR bda) {
355   tBTA_GATTC_SERV *p_tcb = &bta_gattc_cb.known_server[0], *p_recycle = NULL;
356   bool found = false;
357   uint8_t i;
358 
359   for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i++, p_tcb++) {
360     if (!p_tcb->in_use) {
361       found = true;
362       break;
363     } else if (!p_tcb->connected) {
364       p_recycle = p_tcb;
365     }
366   }
367 
368   /* if not found, try to recycle one known device */
369   if (!found && !p_recycle)
370     p_tcb = NULL;
371   else if (!found && p_recycle)
372     p_tcb = p_recycle;
373 
374   if (p_tcb != NULL) {
375     if (p_tcb->p_srvc_cache != NULL) list_free(p_tcb->p_srvc_cache);
376 
377     osi_free_and_reset((void**)&p_tcb->p_srvc_list);
378     memset(p_tcb, 0, sizeof(tBTA_GATTC_SERV));
379 
380     p_tcb->in_use = true;
381     bdcpy(p_tcb->server_bda, bda);
382   }
383   return p_tcb;
384 }
385 /*******************************************************************************
386  *
387  * Function         bta_gattc_enqueue
388  *
389  * Description      enqueue a client request in clcb.
390  *
391  * Returns          success or failure.
392  *
393  ******************************************************************************/
bta_gattc_enqueue(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)394 bool bta_gattc_enqueue(tBTA_GATTC_CLCB* p_clcb, tBTA_GATTC_DATA* p_data) {
395   if (p_clcb->p_q_cmd == NULL) {
396     p_clcb->p_q_cmd = p_data;
397     return true;
398   }
399 
400   APPL_TRACE_ERROR("%s: already has a pending command!!", __func__);
401   /* skip the callback now. ----- need to send callback ? */
402   return false;
403 }
404 
405 /*******************************************************************************
406  *
407  * Function         bta_gattc_check_notif_registry
408  *
409  * Description      check if the service notificaition has been registered.
410  *
411  * Returns
412  *
413  ******************************************************************************/
bta_gattc_check_notif_registry(tBTA_GATTC_RCB * p_clreg,tBTA_GATTC_SERV * p_srcb,tBTA_GATTC_NOTIFY * p_notify)414 bool bta_gattc_check_notif_registry(tBTA_GATTC_RCB* p_clreg,
415                                     tBTA_GATTC_SERV* p_srcb,
416                                     tBTA_GATTC_NOTIFY* p_notify) {
417   uint8_t i;
418 
419   for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i++) {
420     if (p_clreg->notif_reg[i].in_use &&
421         bdcmp(p_clreg->notif_reg[i].remote_bda, p_srcb->server_bda) == 0 &&
422         p_clreg->notif_reg[i].handle == p_notify->handle) {
423       APPL_TRACE_DEBUG("Notification registered!");
424       return true;
425     }
426   }
427   return false;
428 }
429 /*******************************************************************************
430  *
431  * Function         bta_gattc_clear_notif_registration
432  *
433  * Description      Clear up the notification registration information by
434  *                  BD_ADDR.
435  *                  Where handle is between start_handle and end_handle, and
436  *                  start_handle and end_handle are boundaries of service
437  *                  containing characteristic.
438  *
439  * Returns          None.
440  *
441  ******************************************************************************/
bta_gattc_clear_notif_registration(tBTA_GATTC_SERV * p_srcb,uint16_t conn_id,uint16_t start_handle,uint16_t end_handle)442 void bta_gattc_clear_notif_registration(tBTA_GATTC_SERV* p_srcb,
443                                         uint16_t conn_id, uint16_t start_handle,
444                                         uint16_t end_handle) {
445   BD_ADDR remote_bda;
446   tBTA_GATTC_IF gatt_if;
447   tBTA_GATTC_RCB* p_clrcb;
448   uint8_t i;
449   tGATT_TRANSPORT transport;
450   uint16_t handle;
451 
452   if (GATT_GetConnectionInfor(conn_id, &gatt_if, remote_bda, &transport)) {
453     p_clrcb = bta_gattc_cl_get_regcb(gatt_if);
454     if (p_clrcb != NULL) {
455       for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i++) {
456         if (p_clrcb->notif_reg[i].in_use &&
457             !bdcmp(p_clrcb->notif_reg[i].remote_bda, remote_bda)) {
458           /* It's enough to get service or characteristic handle, as
459            * clear boundaries are always around service.
460            */
461           handle = p_clrcb->notif_reg[i].handle;
462           if (handle >= start_handle && handle <= end_handle)
463             memset(&p_clrcb->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
464         }
465       }
466     }
467   } else {
468     APPL_TRACE_ERROR(
469         "can not clear indication/notif registration for unknown app");
470   }
471   return;
472 }
473 
474 /*******************************************************************************
475  *
476  * Function         bta_gattc_mark_bg_conn
477  *
478  * Description      mark background connection status when a bg connection is
479  *                  initiated or terminated.
480  *
481  * Returns          true if success; false otherwise.
482  *
483  ******************************************************************************/
bta_gattc_mark_bg_conn(tBTA_GATTC_IF client_if,BD_ADDR_PTR remote_bda_ptr,bool add)484 bool bta_gattc_mark_bg_conn(tBTA_GATTC_IF client_if, BD_ADDR_PTR remote_bda_ptr,
485                             bool add) {
486   tBTA_GATTC_BG_TCK* p_bg_tck = &bta_gattc_cb.bg_track[0];
487   uint8_t i = 0;
488   tBTA_GATTC_CIF_MASK* p_cif_mask;
489 
490   for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i++, p_bg_tck++) {
491     if (p_bg_tck->in_use &&
492         ((remote_bda_ptr != NULL &&
493           bdcmp(p_bg_tck->remote_bda, remote_bda_ptr) == 0) ||
494          (remote_bda_ptr == NULL &&
495           bdcmp(p_bg_tck->remote_bda, dummy_bda) == 0))) {
496       p_cif_mask = &p_bg_tck->cif_mask;
497 
498       if (add) /* mask on the cif bit */
499         *p_cif_mask |= (1 << (client_if - 1));
500       else {
501         if (client_if != 0)
502           *p_cif_mask &= (~(1 << (client_if - 1)));
503         else
504           *p_cif_mask = 0;
505       }
506       /* no BG connection for this device, make it available */
507       if (p_bg_tck->cif_mask == 0) {
508         memset(p_bg_tck, 0, sizeof(tBTA_GATTC_BG_TCK));
509       }
510       return true;
511     }
512   }
513   if (!add) {
514     if (remote_bda_ptr) {
515       bdstr_t bdstr = {0};
516       APPL_TRACE_ERROR(
517           "%s unable to find the bg connection mask for: %s", __func__,
518           bdaddr_to_string((bt_bdaddr_t*)remote_bda_ptr, bdstr, sizeof(bdstr)));
519     }
520     return false;
521   } else /* adding a new device mask */
522   {
523     for (i = 0, p_bg_tck = &bta_gattc_cb.bg_track[0];
524          i < BTA_GATTC_KNOWN_SR_MAX; i++, p_bg_tck++) {
525       if (!p_bg_tck->in_use) {
526         p_bg_tck->in_use = true;
527         if (remote_bda_ptr)
528           bdcpy(p_bg_tck->remote_bda, remote_bda_ptr);
529         else
530           bdcpy(p_bg_tck->remote_bda, dummy_bda);
531 
532         p_cif_mask = &p_bg_tck->cif_mask;
533 
534         *p_cif_mask = (1 << (client_if - 1));
535         return true;
536       }
537     }
538     APPL_TRACE_ERROR("no available space to mark the bg connection status");
539     return false;
540   }
541 }
542 /*******************************************************************************
543  *
544  * Function         bta_gattc_check_bg_conn
545  *
546  * Description      check if this is a background connection background
547  *                  connection.
548  *
549  * Returns          true if success; false otherwise.
550  *
551  ******************************************************************************/
bta_gattc_check_bg_conn(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,uint8_t role)552 bool bta_gattc_check_bg_conn(tBTA_GATTC_IF client_if, BD_ADDR remote_bda,
553                              uint8_t role) {
554   tBTA_GATTC_BG_TCK* p_bg_tck = &bta_gattc_cb.bg_track[0];
555   uint8_t i = 0;
556   bool is_bg_conn = false;
557 
558   for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX && !is_bg_conn; i++, p_bg_tck++) {
559     if (p_bg_tck->in_use && (bdcmp(p_bg_tck->remote_bda, remote_bda) == 0 ||
560                              bdcmp(p_bg_tck->remote_bda, dummy_bda) == 0)) {
561       if (((p_bg_tck->cif_mask & (1 << (client_if - 1))) != 0) &&
562           role == HCI_ROLE_MASTER)
563         is_bg_conn = true;
564     }
565   }
566   return is_bg_conn;
567 }
568 /*******************************************************************************
569  *
570  * Function         bta_gattc_send_open_cback
571  *
572  * Description      send open callback
573  *
574  * Returns
575  *
576  ******************************************************************************/
bta_gattc_send_open_cback(tBTA_GATTC_RCB * p_clreg,tBTA_GATT_STATUS status,BD_ADDR remote_bda,uint16_t conn_id,tBTA_TRANSPORT transport,uint16_t mtu)577 void bta_gattc_send_open_cback(tBTA_GATTC_RCB* p_clreg, tBTA_GATT_STATUS status,
578                                BD_ADDR remote_bda, uint16_t conn_id,
579                                tBTA_TRANSPORT transport, uint16_t mtu) {
580   tBTA_GATTC cb_data;
581 
582   if (p_clreg->p_cback) {
583     memset(&cb_data, 0, sizeof(tBTA_GATTC));
584 
585     cb_data.open.status = status;
586     cb_data.open.client_if = p_clreg->client_if;
587     cb_data.open.conn_id = conn_id;
588     cb_data.open.mtu = mtu;
589     cb_data.open.transport = transport;
590     bdcpy(cb_data.open.remote_bda, remote_bda);
591 
592     (*p_clreg->p_cback)(BTA_GATTC_OPEN_EVT, &cb_data);
593   }
594 }
595 /*******************************************************************************
596  *
597  * Function         bta_gattc_conn_alloc
598  *
599  * Description      allocate connection tracking spot
600  *
601  * Returns          pointer to the clcb
602  *
603  ******************************************************************************/
bta_gattc_conn_alloc(BD_ADDR remote_bda)604 tBTA_GATTC_CONN* bta_gattc_conn_alloc(BD_ADDR remote_bda) {
605   uint8_t i_conn = 0;
606   tBTA_GATTC_CONN* p_conn = &bta_gattc_cb.conn_track[0];
607 
608   for (i_conn = 0; i_conn < BTA_GATTC_CONN_MAX; i_conn++, p_conn++) {
609     if (!p_conn->in_use) {
610 #if (BTA_GATT_DEBUG == TRUE)
611       APPL_TRACE_DEBUG("bta_gattc_conn_alloc: found conn_track[%d] available",
612                        i_conn);
613 #endif
614       p_conn->in_use = true;
615       bdcpy(p_conn->remote_bda, remote_bda);
616       return p_conn;
617     }
618   }
619   return NULL;
620 }
621 
622 /*******************************************************************************
623  *
624  * Function         bta_gattc_conn_find
625  *
626  * Description      allocate connection tracking spot
627  *
628  * Returns          pointer to the clcb
629  *
630  ******************************************************************************/
bta_gattc_conn_find(BD_ADDR remote_bda)631 tBTA_GATTC_CONN* bta_gattc_conn_find(BD_ADDR remote_bda) {
632   uint8_t i_conn = 0;
633   tBTA_GATTC_CONN* p_conn = &bta_gattc_cb.conn_track[0];
634 
635   for (i_conn = 0; i_conn < BTA_GATTC_CONN_MAX; i_conn++, p_conn++) {
636     if (p_conn->in_use && bdcmp(remote_bda, p_conn->remote_bda) == 0) {
637 #if (BTA_GATT_DEBUG == TRUE)
638       APPL_TRACE_DEBUG("bta_gattc_conn_find: found conn_track[%d] matched",
639                        i_conn);
640 #endif
641       return p_conn;
642     }
643   }
644   return NULL;
645 }
646 
647 /*******************************************************************************
648  *
649  * Function         bta_gattc_conn_find_alloc
650  *
651  * Description      find or allocate connection tracking spot
652  *
653  * Returns          pointer to the clcb
654  *
655  ******************************************************************************/
bta_gattc_conn_find_alloc(BD_ADDR remote_bda)656 tBTA_GATTC_CONN* bta_gattc_conn_find_alloc(BD_ADDR remote_bda) {
657   tBTA_GATTC_CONN* p_conn = bta_gattc_conn_find(remote_bda);
658 
659   if (p_conn == NULL) {
660     p_conn = bta_gattc_conn_alloc(remote_bda);
661   }
662   return p_conn;
663 }
664 
665 /*******************************************************************************
666  *
667  * Function         bta_gattc_conn_dealloc
668  *
669  * Description      de-allocate connection tracking spot
670  *
671  * Returns          pointer to the clcb
672  *
673  ******************************************************************************/
bta_gattc_conn_dealloc(BD_ADDR remote_bda)674 bool bta_gattc_conn_dealloc(BD_ADDR remote_bda) {
675   tBTA_GATTC_CONN* p_conn = bta_gattc_conn_find(remote_bda);
676 
677   if (p_conn != NULL) {
678     p_conn->in_use = false;
679     memset(p_conn->remote_bda, 0, BD_ADDR_LEN);
680     return true;
681   }
682   return false;
683 }
684 
685 /*******************************************************************************
686  *
687  * Function         bta_gattc_find_int_conn_clcb
688  *
689  * Description      try to locate a clcb when an internal connecion event
690  *                  arrives.
691  *
692  * Returns          pointer to the clcb
693  *
694  ******************************************************************************/
bta_gattc_find_int_conn_clcb(tBTA_GATTC_DATA * p_msg)695 tBTA_GATTC_CLCB* bta_gattc_find_int_conn_clcb(tBTA_GATTC_DATA* p_msg) {
696   tBTA_GATTC_CLCB* p_clcb = NULL;
697 
698   if (p_msg->int_conn.role == HCI_ROLE_SLAVE)
699     bta_gattc_conn_find_alloc(p_msg->int_conn.remote_bda);
700 
701   /* try to locate a logic channel */
702   p_clcb = bta_gattc_find_clcb_by_cif(p_msg->int_conn.client_if,
703                                       p_msg->int_conn.remote_bda,
704                                       p_msg->int_conn.transport);
705   if (p_clcb == NULL) {
706     /* for a background connection or listening connection */
707     if (/*p_msg->int_conn.role == HCI_ROLE_SLAVE ||  */
708         bta_gattc_check_bg_conn(p_msg->int_conn.client_if,
709                                 p_msg->int_conn.remote_bda,
710                                 p_msg->int_conn.role)) {
711       /* allocate a new channel */
712       p_clcb = bta_gattc_clcb_alloc(p_msg->int_conn.client_if,
713                                     p_msg->int_conn.remote_bda,
714                                     p_msg->int_conn.transport);
715     }
716   }
717   return p_clcb;
718 }
719 
720 /*******************************************************************************
721  *
722  * Function         bta_gattc_find_int_disconn_clcb
723  *
724  * Description      try to locate a clcb when an internal disconnect callback
725  *                  arrives.
726  *
727  * Returns          pointer to the clcb
728  *
729  ******************************************************************************/
bta_gattc_find_int_disconn_clcb(tBTA_GATTC_DATA * p_msg)730 tBTA_GATTC_CLCB* bta_gattc_find_int_disconn_clcb(tBTA_GATTC_DATA* p_msg) {
731   tBTA_GATTC_CLCB* p_clcb = NULL;
732 
733   bta_gattc_conn_dealloc(p_msg->int_conn.remote_bda);
734   p_clcb = bta_gattc_find_clcb_by_conn_id(p_msg->int_conn.hdr.layer_specific);
735   if (p_clcb == NULL) {
736     /* connection attempt failed, send connection callback event */
737     p_clcb = bta_gattc_find_clcb_by_cif(p_msg->int_conn.client_if,
738                                         p_msg->int_conn.remote_bda,
739                                         p_msg->int_conn.transport);
740   }
741   if (p_clcb == NULL) {
742     APPL_TRACE_DEBUG(" disconnection ID: [%d] not used by BTA",
743                      p_msg->int_conn.hdr.layer_specific);
744   }
745   return p_clcb;
746 }
747