granicus.if.org Git - esp-idf/blob - components/bt/bluedroid/bta/gatt/bta_gatts_utils.c

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