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#include "bt_target.h"
26
27#if defined(BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE)
28
29#include <string.h>
30#include "utl.h"
31#include "gki.h"
32#include "bta_sys.h"
33#include "bta_gatts_int.h"
34#include "bd.h"
35
36static const UINT8  base_uuid[LEN_UUID_128] = {0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
37    0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
38
39/*******************************************************************************
40**
41** Function         bta_gatt_convert_uuid16_to_uuid128
42**
43** Description      Convert a 16 bits UUID to be an standard 128 bits one.
44**
45** Returns          TRUE if two uuid match; FALSE otherwise.
46**
47*******************************************************************************/
48static void bta_gatt_convert_uuid16_to_uuid128(UINT8 uuid_128[LEN_UUID_128], UINT16 uuid_16)
49{
50    UINT8   *p = &uuid_128[LEN_UUID_128 - 4];
51
52    memcpy (uuid_128, base_uuid, LEN_UUID_128);
53
54    UINT16_TO_STREAM(p, uuid_16);
55}
56/*******************************************************************************
57**
58** Function         bta_gatts_alloc_srvc_cb
59**
60** Description      allocate a service control block.
61**
62** Returns          pointer to the control block, or otherwise NULL when failed.
63**
64*******************************************************************************/
65UINT8 bta_gatts_alloc_srvc_cb(tBTA_GATTS_CB *p_cb, UINT8 rcb_idx)
66{
67    UINT8 i;
68
69    for (i = 0; i < BTA_GATTS_MAX_SRVC_NUM; i ++)
70    {
71        if (!p_cb->srvc_cb[i].in_use)
72        {
73            p_cb->srvc_cb[i].in_use = TRUE;
74            p_cb->srvc_cb[i].rcb_idx = rcb_idx;
75            return i;
76        }
77    }
78    return BTA_GATTS_INVALID_APP;
79}
80
81/*******************************************************************************
82**
83** Function         bta_gatts_find_app_rcb_by_app_if
84**
85** Description      find the index of the application control block by app ID.
86**
87** Returns          pointer to the control block if success, otherwise NULL
88**
89*******************************************************************************/
90tBTA_GATTS_RCB *bta_gatts_find_app_rcb_by_app_if(tBTA_GATTS_IF server_if)
91{
92    UINT8 i;
93    tBTA_GATTS_RCB *p_reg;
94
95    for (i = 0, p_reg = bta_gatts_cb.rcb; i < BTA_GATTS_MAX_APP_NUM; i ++, p_reg++)
96    {
97        if (p_reg->in_use && p_reg->gatt_if == server_if)
98            return p_reg;
99    }
100    return NULL;
101}
102
103/*******************************************************************************
104**
105** Function         bta_gatts_find_app_rcb_idx_by_app_if
106**
107** Description      find the index of the application control block by app ID.
108**
109** Returns          index of the control block, or BTA_GATTS_INVALID_APP if failed.
110**
111*******************************************************************************/
112
113UINT8 bta_gatts_find_app_rcb_idx_by_app_if(tBTA_GATTS_CB *p_cb, tBTA_GATTS_IF server_if)
114{
115    UINT8 i;
116
117    for (i = 0; i < BTA_GATTS_MAX_APP_NUM; i ++)
118    {
119        if (p_cb->rcb[i].in_use && p_cb->rcb[i].gatt_if == server_if)
120            return i;
121    }
122    return BTA_GATTS_INVALID_APP;
123}
124/*******************************************************************************
125**
126** Function         bta_gatts_find_srvc_cb_by_srvc_id
127**
128** Description      find the service control block by service ID.
129**
130** Returns          pointer to the rcb.
131**
132*******************************************************************************/
133tBTA_GATTS_SRVC_CB * bta_gatts_find_srvc_cb_by_srvc_id(tBTA_GATTS_CB *p_cb, UINT16 service_id)
134{
135    UINT8 i;
136    APPL_TRACE_DEBUG("bta_gatts_find_srvc_cb_by_srvc_id  service_id=%d", service_id);
137    for (i = 0; i < BTA_GATTS_MAX_SRVC_NUM; i ++)
138    {
139        if (p_cb->srvc_cb[i].in_use &&
140            p_cb->srvc_cb[i].service_id == service_id)
141        {
142            APPL_TRACE_DEBUG("bta_gatts_find_srvc_cb_by_srvc_id  found service cb index =%d", i);
143            return &p_cb->srvc_cb[i];
144        }
145    }
146    return NULL;
147}
148/*******************************************************************************
149**
150** Function         bta_gatts_find_srvc_cb_by_attr_id
151**
152** Description      find the service control block by attribute ID.
153**
154** Returns          pointer to the rcb.
155**
156*******************************************************************************/
157tBTA_GATTS_SRVC_CB * bta_gatts_find_srvc_cb_by_attr_id(tBTA_GATTS_CB *p_cb, UINT16 attr_id)
158{
159    UINT8 i;
160
161    for (i = 0; i < (BTA_GATTS_MAX_SRVC_NUM); i ++)
162    {
163        if (/* middle service */
164            (i < (BTA_GATTS_MAX_SRVC_NUM - 1) &&
165             p_cb->srvc_cb[i].in_use &&
166             p_cb->srvc_cb[i + 1].in_use &&
167             attr_id >= p_cb->srvc_cb[i].service_id &&
168             attr_id < p_cb->srvc_cb[i + 1].service_id) ||
169            /* last active service */
170            (i < (BTA_GATTS_MAX_SRVC_NUM - 1) &&
171             p_cb->srvc_cb[i].in_use &&
172             !p_cb->srvc_cb[i + 1].in_use &&
173             attr_id >= p_cb->srvc_cb[i].service_id)    ||
174            /* last service incb */
175            (i == (BTA_GATTS_MAX_SRVC_NUM - 1) &&
176             attr_id >= p_cb->srvc_cb[i].service_id)
177           )
178        {
179            return &p_cb->srvc_cb[i];
180        }
181    }
182    return NULL;
183}
184/*******************************************************************************
185**
186** Function         bta_gatts_uuid_compare
187**
188** Description      Compare two UUID to see if they are the same.
189**
190** Returns          TRUE if two uuid match; FALSE otherwise.
191**
192*******************************************************************************/
193BOOLEAN bta_gatts_uuid_compare(tBT_UUID tar, tBT_UUID src)
194{
195    UINT8  su[LEN_UUID_128], tu[LEN_UUID_128];
196    UINT8  *ps, *pt;
197
198    /* any of the UUID is unspecified */
199    if (src.len == 0 || tar.len == 0)
200    {
201        return TRUE;
202    }
203
204    /* If both are 16-bit, we can do a simple compare */
205    if (src.len == 2 && tar.len == 2)
206    {
207        return src.uu.uuid16 == tar.uu.uuid16;
208    }
209
210    /* One or both of the UUIDs is 128-bit */
211    if (src.len == LEN_UUID_16)
212    {
213        /* convert a 16 bits UUID to 128 bits value */
214        bta_gatt_convert_uuid16_to_uuid128(su, src.uu.uuid16);
215        ps = su;
216    }
217    else
218        ps = src.uu.uuid128;
219
220    if (tar.len == LEN_UUID_16)
221    {
222        /* convert a 16 bits UUID to 128 bits value */
223        bta_gatt_convert_uuid16_to_uuid128(tu, tar.uu.uuid16);
224        pt = tu;
225    }
226    else
227        pt = tar.uu.uuid128;
228
229    return(memcmp(ps, pt, LEN_UUID_128) == 0);
230}
231
232
233
234
235#endif
236