| /****************************************************************************** |
| * |
| * Copyright (C) 1999-2013 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #define LOG_TAG "bt_srvc" |
| |
| #include "bt_target.h" |
| #include "bt_utils.h" |
| #include "gatt_api.h" |
| #include "gatt_int.h" |
| #include "osi/include/log.h" |
| #include "srvc_dis_int.h" |
| #include "srvc_eng_int.h" |
| #include "btcore/include/uuid.h" |
| |
| #if (BLE_INCLUDED == TRUE) |
| |
| #define DIS_MAX_NUM_INC_SVR 0 |
| #define DIS_MAX_CHAR_NUM 9 |
| #define DIS_MAX_ATTR_NUM (DIS_MAX_CHAR_NUM * 2 + DIS_MAX_NUM_INC_SVR + 1) |
| |
| #ifndef DIS_ATTR_DB_SIZE |
| #define DIS_ATTR_DB_SIZE GATT_DB_MEM_SIZE(DIS_MAX_NUM_INC_SVR, DIS_MAX_CHAR_NUM, 0) |
| #endif |
| |
| #define uint64_t_TO_STREAM(p, u64) {*(p)++ = (uint8_t)(u64); *(p)++ = (uint8_t)((u64) >> 8);*(p)++ = (uint8_t)((u64) >> 16); *(p)++ = (uint8_t)((u64) >> 24); \ |
| *(p)++ = (uint8_t)((u64) >> 32); *(p)++ = (uint8_t)((u64) >> 40);*(p)++ = (uint8_t)((u64) >> 48); *(p)++ = (uint8_t)((u64) >> 56);} |
| |
| #define STREAM_TO_UINT64(u64, p) {(u64) = (((uint64_t)(*(p))) + ((((uint64_t)(*((p) + 1)))) << 8) + ((((uint64_t)(*((p) + 2)))) << 16) + ((((uint64_t)(*((p) + 3)))) << 24) \ |
| + ((((uint64_t)(*((p) + 4)))) << 32) + ((((uint64_t)(*((p) + 5)))) << 40) + ((((uint64_t)(*((p) + 6)))) << 48) + ((((uint64_t)(*((p) + 7)))) << 56)); (p) += 8;} |
| |
| static const uint16_t dis_attr_uuid[DIS_MAX_CHAR_NUM] = |
| { |
| GATT_UUID_SYSTEM_ID, |
| GATT_UUID_MODEL_NUMBER_STR, |
| GATT_UUID_SERIAL_NUMBER_STR, |
| GATT_UUID_FW_VERSION_STR, |
| GATT_UUID_HW_VERSION_STR, |
| GATT_UUID_SW_VERSION_STR, |
| GATT_UUID_MANU_NAME, |
| GATT_UUID_IEEE_DATA, |
| GATT_UUID_PNP_ID |
| }; |
| |
| tDIS_CB dis_cb; |
| |
| static tDIS_ATTR_MASK dis_uuid_to_attr(uint16_t uuid) |
| { |
| switch (uuid) |
| { |
| case GATT_UUID_SYSTEM_ID: |
| return DIS_ATTR_SYS_ID_BIT; |
| case GATT_UUID_MODEL_NUMBER_STR: |
| return DIS_ATTR_MODEL_NUM_BIT; |
| case GATT_UUID_SERIAL_NUMBER_STR: |
| return DIS_ATTR_SERIAL_NUM_BIT; |
| case GATT_UUID_FW_VERSION_STR: |
| return DIS_ATTR_FW_NUM_BIT; |
| case GATT_UUID_HW_VERSION_STR: |
| return DIS_ATTR_HW_NUM_BIT; |
| case GATT_UUID_SW_VERSION_STR: |
| return DIS_ATTR_SW_NUM_BIT; |
| case GATT_UUID_MANU_NAME: |
| return DIS_ATTR_MANU_NAME_BIT; |
| case GATT_UUID_IEEE_DATA: |
| return DIS_ATTR_IEEE_DATA_BIT; |
| case GATT_UUID_PNP_ID: |
| return DIS_ATTR_PNP_ID_BIT; |
| default: |
| return 0; |
| }; |
| } |
| |
| /******************************************************************************* |
| ** dis_valid_handle_range |
| ** |
| ** validate a handle to be a DIS attribute handle or not. |
| *******************************************************************************/ |
| bool dis_valid_handle_range(uint16_t handle) |
| { |
| if (handle >= dis_cb.service_handle && handle <= dis_cb.max_handle) |
| return true; |
| else |
| return false; |
| } |
| /******************************************************************************* |
| ** dis_write_attr_value |
| ** |
| ** Process write DIS attribute request. |
| *******************************************************************************/ |
| uint8_t dis_write_attr_value(UNUSED_ATTR tGATT_WRITE_REQ *p_data, tGATT_STATUS *p_status) |
| { |
| *p_status = GATT_WRITE_NOT_PERMIT; |
| return SRVC_ACT_RSP; |
| } |
| /******************************************************************************* |
| ** DIS Attributes Database Server Request callback |
| *******************************************************************************/ |
| uint8_t dis_read_attr_value (UNUSED_ATTR uint8_t clcb_idx, uint16_t handle, |
| tGATT_VALUE *p_value, |
| bool is_long, tGATT_STATUS *p_status) |
| { |
| tDIS_DB_ENTRY *p_db_attr = dis_cb.dis_attr; |
| uint8_t *p = p_value->value, i, *pp; |
| uint16_t offset = p_value->offset; |
| uint8_t act = SRVC_ACT_RSP; |
| tGATT_STATUS st = GATT_NOT_FOUND; |
| |
| for (i = 0; i < DIS_MAX_CHAR_NUM; i ++, p_db_attr ++) |
| { |
| if (handle == p_db_attr->handle) |
| { |
| if ((p_db_attr->uuid == GATT_UUID_PNP_ID || p_db_attr->uuid == GATT_UUID_SYSTEM_ID)&& |
| is_long == true) |
| { |
| st = GATT_NOT_LONG; |
| break; |
| } |
| st = GATT_SUCCESS; |
| |
| switch (p_db_attr->uuid) |
| { |
| case GATT_UUID_MANU_NAME: |
| case GATT_UUID_MODEL_NUMBER_STR: |
| case GATT_UUID_SERIAL_NUMBER_STR: |
| case GATT_UUID_FW_VERSION_STR: |
| case GATT_UUID_HW_VERSION_STR: |
| case GATT_UUID_SW_VERSION_STR: |
| case GATT_UUID_IEEE_DATA: |
| pp = dis_cb.dis_value.data_string[p_db_attr->uuid - GATT_UUID_MODEL_NUMBER_STR]; |
| if (pp != NULL) |
| { |
| if (strlen ((char *)pp) > GATT_MAX_ATTR_LEN) |
| p_value->len = GATT_MAX_ATTR_LEN; |
| else |
| p_value->len = (uint16_t)strlen ((char *)pp); |
| } |
| else |
| p_value->len = 0; |
| |
| if (offset > p_value->len) |
| { |
| st = GATT_INVALID_OFFSET; |
| break; |
| } |
| else |
| { |
| p_value->len -= offset; |
| pp += offset; |
| ARRAY_TO_STREAM(p, pp, p_value->len); |
| GATT_TRACE_EVENT("GATT_UUID_MANU_NAME len=0x%04x", p_value->len); |
| } |
| break; |
| |
| case GATT_UUID_SYSTEM_ID: |
| uint64_t_TO_STREAM(p, dis_cb.dis_value.system_id); /* int_min */ |
| p_value->len = DIS_SYSTEM_ID_SIZE; |
| break; |
| |
| case GATT_UUID_PNP_ID: |
| UINT8_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id_src); |
| UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.vendor_id); |
| UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_id); |
| UINT16_TO_STREAM(p, dis_cb.dis_value.pnp_id.product_version); |
| p_value->len = DIS_PNP_ID_SIZE; |
| break; |
| |
| } |
| break; |
| } |
| } |
| *p_status = st; |
| return act; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function dis_gatt_c_read_dis_value_cmpl |
| ** |
| ** Description Client read DIS database complete callback. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void dis_gatt_c_read_dis_value_cmpl(uint16_t conn_id) |
| { |
| tSRVC_CLCB *p_clcb = srvc_eng_find_clcb_by_conn_id(conn_id); |
| |
| dis_cb.dis_read_uuid_idx = 0xff; |
| |
| srvc_eng_release_channel(conn_id); |
| |
| if (dis_cb.p_read_dis_cback && p_clcb) |
| { |
| LOG_INFO(LOG_TAG, "%s conn_id:%d attr_mask = 0x%04x", __func__, conn_id, |
| p_clcb->dis_value.attr_mask); |
| |
| (*dis_cb.p_read_dis_cback)(p_clcb->bda, &p_clcb->dis_value); |
| dis_cb.p_read_dis_cback = NULL; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function dis_gatt_c_read_dis_req |
| ** |
| ** Description Read remote device DIS attribute request. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| bool dis_gatt_c_read_dis_req(uint16_t conn_id) |
| { |
| tGATT_READ_PARAM param; |
| |
| memset(¶m, 0, sizeof(tGATT_READ_PARAM)); |
| |
| param.service.uuid.len = LEN_UUID_16; |
| param.service.s_handle = 1; |
| param.service.e_handle = 0xFFFF; |
| param.service.auth_req = 0; |
| |
| while (dis_cb.dis_read_uuid_idx < DIS_MAX_CHAR_NUM) |
| { |
| if (dis_uuid_to_attr(dis_attr_uuid[dis_cb.dis_read_uuid_idx]) & |
| dis_cb.request_mask) |
| { |
| param.service.uuid.uu.uuid16 = dis_attr_uuid[dis_cb.dis_read_uuid_idx]; |
| |
| if (GATTC_Read(conn_id, GATT_READ_BY_TYPE, ¶m) == GATT_SUCCESS) |
| return true; |
| |
| GATT_TRACE_ERROR ("Read DISInfo: 0x%04x GATT_Read Failed", param.service.uuid.uu.uuid16); |
| } |
| |
| dis_cb.dis_read_uuid_idx++; |
| } |
| |
| dis_gatt_c_read_dis_value_cmpl(conn_id); |
| |
| return(false); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function dis_c_cmpl_cback |
| ** |
| ** Description Client operation complete callback. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void dis_c_cmpl_cback (tSRVC_CLCB *p_clcb, tGATTC_OPTYPE op, |
| tGATT_STATUS status, tGATT_CL_COMPLETE *p_data) |
| { |
| uint16_t read_type = dis_attr_uuid[dis_cb.dis_read_uuid_idx]; |
| uint8_t *pp = NULL, *p_str; |
| uint16_t conn_id = p_clcb->conn_id; |
| |
| GATT_TRACE_EVENT ("dis_c_cmpl_cback() - op_code: 0x%02x status: 0x%02x \ |
| read_type: 0x%04x", op, status, read_type); |
| |
| if (op != GATTC_OPTYPE_READ) |
| return; |
| |
| if (p_data != NULL && status == GATT_SUCCESS) |
| { |
| pp = p_data->att_value.value; |
| |
| switch (read_type) |
| { |
| case GATT_UUID_SYSTEM_ID: |
| GATT_TRACE_EVENT ("DIS_ATTR_SYS_ID_BIT"); |
| if (p_data->att_value.len == DIS_SYSTEM_ID_SIZE) |
| { |
| p_clcb->dis_value.attr_mask |= DIS_ATTR_SYS_ID_BIT; |
| /* save system ID*/ |
| STREAM_TO_UINT64 (p_clcb->dis_value.system_id, pp); |
| } |
| break; |
| |
| case GATT_UUID_PNP_ID: |
| if (p_data->att_value.len == DIS_PNP_ID_SIZE) |
| { |
| p_clcb->dis_value.attr_mask |= DIS_ATTR_PNP_ID_BIT; |
| STREAM_TO_UINT8 (p_clcb->dis_value.pnp_id.vendor_id_src, pp); |
| STREAM_TO_UINT16 (p_clcb->dis_value.pnp_id.vendor_id, pp); |
| STREAM_TO_UINT16 (p_clcb->dis_value.pnp_id.product_id, pp); |
| STREAM_TO_UINT16 (p_clcb->dis_value.pnp_id.product_version, pp); |
| } |
| break; |
| |
| case GATT_UUID_MODEL_NUMBER_STR: |
| case GATT_UUID_SERIAL_NUMBER_STR: |
| case GATT_UUID_FW_VERSION_STR: |
| case GATT_UUID_HW_VERSION_STR: |
| case GATT_UUID_SW_VERSION_STR: |
| case GATT_UUID_MANU_NAME: |
| case GATT_UUID_IEEE_DATA: |
| p_str = p_clcb->dis_value.data_string[read_type - GATT_UUID_MODEL_NUMBER_STR]; |
| osi_free(p_str); |
| p_str = (uint8_t *)osi_malloc(p_data->att_value.len + 1); |
| p_clcb->dis_value.attr_mask |= dis_uuid_to_attr(read_type); |
| memcpy(p_str, p_data->att_value.value, p_data->att_value.len); |
| p_str[p_data->att_value.len] = 0; |
| p_clcb->dis_value.data_string[read_type - GATT_UUID_MODEL_NUMBER_STR] = p_str; |
| break; |
| |
| default: |
| break; |
| |
| break; |
| }/* end switch */ |
| }/* end if */ |
| |
| dis_cb.dis_read_uuid_idx ++; |
| |
| dis_gatt_c_read_dis_req(conn_id); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function DIS_SrInit |
| ** |
| ** Description Initialize the Device Information Service Server. |
| ** |
| *******************************************************************************/ |
| tDIS_STATUS DIS_SrInit (tDIS_ATTR_MASK dis_attr_mask) |
| { |
| tGATT_STATUS status; |
| |
| if (dis_cb.enabled) { |
| GATT_TRACE_ERROR("DIS already initalized"); |
| return DIS_SUCCESS; |
| } |
| |
| memset(&dis_cb, 0, sizeof(tDIS_CB)); |
| |
| btgatt_db_element_t service[DIS_MAX_ATTR_NUM] = { }; |
| |
| bt_uuid_t svc_uuid; |
| uuid_128_from_16(&svc_uuid, UUID_SERVCLASS_DEVICE_INFO); |
| service[0].type = BTGATT_DB_PRIMARY_SERVICE; |
| service[0].uuid = svc_uuid; |
| |
| for(int i=0; dis_attr_mask != 0 && i < DIS_MAX_CHAR_NUM; i++) { |
| dis_cb.dis_attr[i].uuid = dis_attr_uuid[i]; |
| |
| bt_uuid_t char_uuid; |
| uuid_128_from_16(&char_uuid, dis_cb.dis_attr[i].uuid); |
| /* index 0 is service, so characteristics start from 1 */ |
| service[i+1].type = BTGATT_DB_CHARACTERISTIC; |
| service[i+1].uuid = char_uuid; |
| service[i+1].properties = GATT_CHAR_PROP_BIT_READ; |
| service[i+1].permissions = GATT_PERM_READ; |
| |
| dis_attr_mask >>= 1; |
| } |
| |
| /* Add a GAP service */ |
| status = GATTS_AddService(srvc_eng_cb.gatt_if, service, sizeof(service)/sizeof(btgatt_db_element_t)); |
| if (status != GATT_SERVICE_STARTED) { |
| GATT_TRACE_ERROR("Can not create service, DIS_Init failed!"); |
| return GATT_ERROR; |
| } |
| |
| dis_cb.service_handle = service[0].attribute_handle; |
| dis_cb.max_handle = dis_cb.service_handle + DIS_MAX_ATTR_NUM; |
| |
| for (int i = 0; i < DIS_MAX_CHAR_NUM; i++) { |
| dis_cb.dis_attr[i].handle = service[i+1].attribute_handle; |
| |
| GATT_TRACE_DEBUG ("%s: handle of new attribute 0x%04 = x%d", __func__, |
| dis_cb.dis_attr[i].uuid, dis_cb.dis_attr[i].handle); |
| } |
| |
| dis_cb.enabled = true; |
| return (tDIS_STATUS) status; |
| } |
| /******************************************************************************* |
| ** |
| ** Function DIS_SrUpdate |
| ** |
| ** Description Update the DIS server attribute values |
| ** |
| *******************************************************************************/ |
| tDIS_STATUS DIS_SrUpdate(tDIS_ATTR_BIT dis_attr_bit, tDIS_ATTR *p_info) |
| { |
| uint8_t i = 1; |
| tDIS_STATUS st = DIS_SUCCESS; |
| |
| if (dis_attr_bit & DIS_ATTR_SYS_ID_BIT) |
| { |
| dis_cb.dis_value.system_id = p_info->system_id; |
| } |
| else if (dis_attr_bit & DIS_ATTR_PNP_ID_BIT) |
| { |
| dis_cb.dis_value.pnp_id.vendor_id = p_info->pnp_id.vendor_id; |
| dis_cb.dis_value.pnp_id.vendor_id_src = p_info->pnp_id.vendor_id_src; |
| dis_cb.dis_value.pnp_id.product_id = p_info->pnp_id.product_id; |
| dis_cb.dis_value.pnp_id.product_version = p_info->pnp_id.product_version; |
| } |
| else |
| { |
| st = DIS_ILLEGAL_PARAM; |
| |
| while (dis_attr_bit && i < (DIS_MAX_CHAR_NUM -1 )) |
| { |
| if (dis_attr_bit & (uint16_t)(1 << i)) |
| { |
| osi_free(dis_cb.dis_value.data_string[i - 1]); |
| /* coverity[OVERRUN-STATIC] False-positive : when i = 8, (1 << i) == DIS_ATTR_PNP_ID_BIT, and it will never come down here |
| CID 49902: Out-of-bounds read (OVERRUN_STATIC) |
| Overrunning static array "dis_cb.dis_value.data_string", with 7 elements, at position 7 with index variable "i". |
| */ |
| dis_cb.dis_value.data_string[i - 1] = (uint8_t *)osi_malloc(p_info->data_str.len + 1); |
| memcpy(dis_cb.dis_value.data_string[i - 1], p_info->data_str.p_data, p_info->data_str.len); |
| dis_cb.dis_value.data_string[i - 1][p_info->data_str.len] = 0; /* make sure null terminate */ |
| st = DIS_SUCCESS; |
| |
| break; |
| } |
| i ++; |
| } |
| } |
| return st; |
| } |
| /******************************************************************************* |
| ** |
| ** Function DIS_ReadDISInfo |
| ** |
| ** Description Read remote device DIS information. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| bool DIS_ReadDISInfo(BD_ADDR peer_bda, tDIS_READ_CBACK *p_cback, tDIS_ATTR_MASK mask) |
| { |
| uint16_t conn_id; |
| |
| /* Initialize the DIS client if it hasn't been initialized already. */ |
| srvc_eng_init(); |
| |
| /* For now we only handle one at a time */ |
| if (dis_cb.dis_read_uuid_idx != 0xff) |
| return(false); |
| |
| if (p_cback == NULL) |
| return(false); |
| |
| dis_cb.p_read_dis_cback = p_cback; |
| /* Mark currently active operation */ |
| dis_cb.dis_read_uuid_idx = 0; |
| |
| dis_cb.request_mask = mask; |
| |
| GATT_TRACE_EVENT ("DIS_ReadDISInfo() - BDA: %08x%04x cl_read_uuid: 0x%04x", |
| (peer_bda[0]<<24)+(peer_bda[1]<<16)+(peer_bda[2]<<8)+peer_bda[3], |
| (peer_bda[4]<<8)+peer_bda[5], dis_attr_uuid[dis_cb.dis_read_uuid_idx]); |
| |
| GATT_GetConnIdIfConnected(srvc_eng_cb.gatt_if, peer_bda, &conn_id, BT_TRANSPORT_LE); |
| |
| /* need to enhance it as multiple service is needed */ |
| srvc_eng_request_channel(peer_bda, SRVC_ID_DIS); |
| |
| if (conn_id == GATT_INVALID_CONN_ID) |
| { |
| return GATT_Connect(srvc_eng_cb.gatt_if, peer_bda, true, BT_TRANSPORT_LE, false); |
| } |
| |
| return dis_gatt_c_read_dis_req(conn_id); |
| |
| } |
| #endif /* BLE_INCLUDED */ |
| |