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
36 static 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 *******************************************************************************/
bta_gatt_convert_uuid16_to_uuid128(UINT8 uuid_128[LEN_UUID_128],UINT16 uuid_16)48 static 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 *******************************************************************************/
bta_gatts_alloc_srvc_cb(tBTA_GATTS_CB * p_cb,UINT8 rcb_idx)65 UINT8 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 *******************************************************************************/
bta_gatts_find_app_rcb_by_app_if(tBTA_GATTS_IF server_if)90 tBTA_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
bta_gatts_find_app_rcb_idx_by_app_if(tBTA_GATTS_CB * p_cb,tBTA_GATTS_IF server_if)113 UINT8 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 *******************************************************************************/
bta_gatts_find_srvc_cb_by_srvc_id(tBTA_GATTS_CB * p_cb,UINT16 service_id)133 tBTA_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 *******************************************************************************/
bta_gatts_find_srvc_cb_by_attr_id(tBTA_GATTS_CB * p_cb,UINT16 attr_id)157 tBTA_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 *******************************************************************************/
bta_gatts_uuid_compare(tBT_UUID tar,tBT_UUID src)193 BOOLEAN 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