| /****************************************************************************** |
| * |
| * Copyright (C) 2008-2012 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. |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * this file contains the GATT server functions |
| * |
| ******************************************************************************/ |
| |
| #include "bt_target.h" |
| #include "bt_utils.h" |
| #include "osi/include/osi.h" |
| |
| #if (BLE_INCLUDED == TRUE) |
| #include <string.h> |
| #include "gatt_int.h" |
| #include "l2c_api.h" |
| #include "l2c_int.h" |
| #define GATT_MTU_REQ_MIN_LEN 2 |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_sr_enqueue_cmd |
| ** |
| ** Description This function enqueue the request from client which needs a |
| ** application response, and update the transaction ID. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| uint32_t gatt_sr_enqueue_cmd (tGATT_TCB *p_tcb, uint8_t op_code, uint16_t handle) |
| { |
| tGATT_SR_CMD *p_cmd = &p_tcb->sr_cmd; |
| uint32_t trans_id = 0; |
| |
| if ( (p_cmd->op_code == 0) || |
| (op_code == GATT_HANDLE_VALUE_CONF)) /* no pending request */ |
| { |
| if (op_code == GATT_CMD_WRITE || |
| op_code == GATT_SIGN_CMD_WRITE || |
| op_code == GATT_REQ_MTU || |
| op_code == GATT_HANDLE_VALUE_CONF) |
| { |
| trans_id = ++p_tcb->trans_id; |
| } |
| else |
| { |
| p_cmd->trans_id = ++p_tcb->trans_id; |
| p_cmd->op_code = op_code; |
| p_cmd->handle = handle; |
| p_cmd->status = GATT_NOT_FOUND; |
| p_tcb->trans_id %= GATT_TRANS_ID_MAX; |
| trans_id = p_cmd->trans_id; |
| } |
| } |
| |
| return trans_id; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_sr_cmd_empty |
| ** |
| ** Description This function check the server command queue is empty or not. |
| ** |
| ** Returns true if empty, false if there is pending command. |
| ** |
| *******************************************************************************/ |
| bool gatt_sr_cmd_empty (tGATT_TCB *p_tcb) |
| { |
| return(p_tcb->sr_cmd.op_code == 0); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_dequeue_sr_cmd |
| ** |
| ** Description This function dequeue the request from command queue. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatt_dequeue_sr_cmd (tGATT_TCB *p_tcb) |
| { |
| /* Double check in case any buffers are queued */ |
| GATT_TRACE_DEBUG("gatt_dequeue_sr_cmd" ); |
| if (p_tcb->sr_cmd.p_rsp_msg) |
| GATT_TRACE_ERROR("free p_tcb->sr_cmd.p_rsp_msg = %d", p_tcb->sr_cmd.p_rsp_msg); |
| osi_free_and_reset((void **)&p_tcb->sr_cmd.p_rsp_msg); |
| |
| while (!fixed_queue_is_empty(p_tcb->sr_cmd.multi_rsp_q)) |
| osi_free(fixed_queue_try_dequeue(p_tcb->sr_cmd.multi_rsp_q)); |
| fixed_queue_free(p_tcb->sr_cmd.multi_rsp_q, NULL); |
| memset( &p_tcb->sr_cmd, 0, sizeof(tGATT_SR_CMD)); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function process_read_multi_rsp |
| ** |
| ** Description This function check the read multiple response. |
| ** |
| ** Returns bool if all replies have been received |
| ** |
| *******************************************************************************/ |
| static bool process_read_multi_rsp (tGATT_SR_CMD *p_cmd, tGATT_STATUS status, |
| tGATTS_RSP *p_msg, uint16_t mtu) |
| { |
| uint16_t ii, total_len, len; |
| uint8_t *p; |
| bool is_overflow = false; |
| |
| GATT_TRACE_DEBUG ("%s status=%d mtu=%d", __func__, status, mtu); |
| |
| if (p_cmd->multi_rsp_q == NULL) |
| p_cmd->multi_rsp_q = fixed_queue_new(SIZE_MAX); |
| |
| /* Enqueue the response */ |
| BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(tGATTS_RSP)); |
| memcpy((void *)p_buf, (const void *)p_msg, sizeof(tGATTS_RSP)); |
| fixed_queue_enqueue(p_cmd->multi_rsp_q, p_buf); |
| |
| p_cmd->status = status; |
| if (status == GATT_SUCCESS) |
| { |
| GATT_TRACE_DEBUG("Multi read count=%d num_hdls=%d", |
| fixed_queue_length(p_cmd->multi_rsp_q), |
| p_cmd->multi_req.num_handles); |
| /* Wait till we get all the responses */ |
| if (fixed_queue_length(p_cmd->multi_rsp_q) == p_cmd->multi_req.num_handles) |
| { |
| len = sizeof(BT_HDR) + L2CAP_MIN_OFFSET + mtu; |
| p_buf = (BT_HDR *)osi_calloc(len); |
| p_buf->offset = L2CAP_MIN_OFFSET; |
| p = (uint8_t *)(p_buf + 1) + p_buf->offset; |
| |
| /* First byte in the response is the opcode */ |
| *p++ = GATT_RSP_READ_MULTI; |
| p_buf->len = 1; |
| |
| /* Now walk through the buffers puting the data into the response in order */ |
| list_t *list = NULL; |
| const list_node_t *node = NULL; |
| if (! fixed_queue_is_empty(p_cmd->multi_rsp_q)) |
| list = fixed_queue_get_list(p_cmd->multi_rsp_q); |
| for (ii = 0; ii < p_cmd->multi_req.num_handles; ii++) |
| { |
| tGATTS_RSP *p_rsp = NULL; |
| |
| if (list != NULL) { |
| if (ii == 0) |
| node = list_begin(list); |
| else |
| node = list_next(node); |
| if (node != list_end(list)) |
| p_rsp = (tGATTS_RSP *)list_node(node); |
| } |
| |
| if (p_rsp != NULL) |
| { |
| |
| total_len = (p_buf->len + p_rsp->attr_value.len); |
| |
| if (total_len > mtu) |
| { |
| /* just send the partial response for the overflow case */ |
| len = p_rsp->attr_value.len - (total_len - mtu); |
| is_overflow = true; |
| GATT_TRACE_DEBUG ("multi read overflow available len=%d val_len=%d", len, p_rsp->attr_value.len ); |
| } |
| else |
| { |
| len = p_rsp->attr_value.len; |
| } |
| |
| if (p_rsp->attr_value.handle == p_cmd->multi_req.handles[ii]) |
| { |
| memcpy (p, p_rsp->attr_value.value, len); |
| if (!is_overflow) |
| p += len; |
| p_buf->len += len; |
| } |
| else |
| { |
| p_cmd->status = GATT_NOT_FOUND; |
| break; |
| } |
| |
| if (is_overflow) |
| break; |
| |
| } |
| else |
| { |
| p_cmd->status = GATT_NOT_FOUND; |
| break; |
| } |
| |
| } /* loop through all handles*/ |
| |
| |
| /* Sanity check on the buffer length */ |
| if (p_buf->len == 0) |
| { |
| GATT_TRACE_ERROR("process_read_multi_rsp - nothing found!!"); |
| p_cmd->status = GATT_NOT_FOUND; |
| osi_free(p_buf); |
| GATT_TRACE_DEBUG("osi_free(p_buf)"); |
| } |
| else if (p_cmd->p_rsp_msg != NULL) |
| { |
| osi_free(p_buf); |
| } |
| else |
| { |
| p_cmd->p_rsp_msg = p_buf; |
| } |
| |
| return(true); |
| } |
| } |
| else /* any handle read exception occurs, return error */ |
| { |
| return(true); |
| } |
| |
| /* If here, still waiting */ |
| return(false); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_sr_process_app_rsp |
| ** |
| ** Description This function checks whether the response message from application |
| ** match any pending request or not. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| tGATT_STATUS gatt_sr_process_app_rsp (tGATT_TCB *p_tcb, tGATT_IF gatt_if, |
| UNUSED_ATTR uint32_t trans_id, uint8_t op_code, |
| tGATT_STATUS status, tGATTS_RSP *p_msg) |
| { |
| tGATT_STATUS ret_code = GATT_SUCCESS; |
| |
| GATT_TRACE_DEBUG("gatt_sr_process_app_rsp gatt_if=%d", gatt_if); |
| |
| gatt_sr_update_cback_cnt(p_tcb, gatt_if, false, false); |
| |
| if (op_code == GATT_REQ_READ_MULTI) |
| { |
| /* If no error and still waiting, just return */ |
| if (!process_read_multi_rsp (&p_tcb->sr_cmd, status, p_msg, p_tcb->payload_size)) |
| return(GATT_SUCCESS); |
| } |
| else |
| { |
| if (op_code == GATT_REQ_PREPARE_WRITE && status == GATT_SUCCESS) |
| gatt_sr_update_prep_cnt(p_tcb, gatt_if, true, false); |
| |
| if (op_code == GATT_REQ_EXEC_WRITE && status != GATT_SUCCESS) |
| gatt_sr_reset_cback_cnt(p_tcb); |
| |
| p_tcb->sr_cmd.status = status; |
| |
| if (gatt_sr_is_cback_cnt_zero(p_tcb) |
| && status == GATT_SUCCESS) |
| { |
| if (p_tcb->sr_cmd.p_rsp_msg == NULL) |
| { |
| p_tcb->sr_cmd.p_rsp_msg = attp_build_sr_msg (p_tcb, (uint8_t)(op_code + 1), (tGATT_SR_MSG *)p_msg); |
| } |
| else |
| { |
| GATT_TRACE_ERROR("Exception!!! already has respond message"); |
| } |
| } |
| } |
| if (gatt_sr_is_cback_cnt_zero(p_tcb)) |
| { |
| if ( (p_tcb->sr_cmd.status == GATT_SUCCESS) && (p_tcb->sr_cmd.p_rsp_msg) ) |
| { |
| ret_code = attp_send_sr_msg (p_tcb, p_tcb->sr_cmd.p_rsp_msg); |
| p_tcb->sr_cmd.p_rsp_msg = NULL; |
| } |
| else |
| { |
| ret_code = gatt_send_error_rsp (p_tcb, status, op_code, p_tcb->sr_cmd.handle, false); |
| } |
| |
| gatt_dequeue_sr_cmd(p_tcb); |
| } |
| |
| GATT_TRACE_DEBUG("gatt_sr_process_app_rsp ret_code=%d", ret_code); |
| |
| return ret_code; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_process_exec_write_req |
| ** |
| ** Description This function is called to process the execute write request |
| ** from client. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatt_process_exec_write_req (tGATT_TCB *p_tcb, uint8_t op_code, |
| UNUSED_ATTR uint16_t len, uint8_t *p_data) |
| { |
| uint8_t *p = p_data, flag, i = 0; |
| uint32_t trans_id = 0; |
| tGATT_IF gatt_if; |
| uint16_t conn_id; |
| |
| #if (GATT_CONFORMANCE_TESTING == TRUE) |
| if (gatt_cb.enable_err_rsp && gatt_cb.req_op_code == op_code) |
| { |
| GATT_TRACE_DEBUG("Conformance tst: forced err rspv for Execute Write: error status=%d", |
| gatt_cb.err_status); |
| |
| gatt_send_error_rsp (p_tcb, gatt_cb.err_status, gatt_cb.req_op_code, gatt_cb.handle, false); |
| |
| return; |
| } |
| #endif |
| |
| STREAM_TO_UINT8(flag, p); |
| |
| /* mask the flag */ |
| flag &= GATT_PREP_WRITE_EXEC; |
| |
| |
| /* no prep write is queued */ |
| if (!gatt_sr_is_prep_cnt_zero(p_tcb)) |
| { |
| trans_id = gatt_sr_enqueue_cmd(p_tcb, op_code, 0); |
| gatt_sr_copy_prep_cnt_to_cback_cnt(p_tcb); |
| |
| for (i=0; i<GATT_MAX_APPS; i++) |
| { |
| if (p_tcb->prep_cnt[i]) |
| { |
| gatt_if = (tGATT_IF) (i+1); |
| conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, gatt_if); |
| gatt_sr_send_req_callback(conn_id, |
| trans_id, |
| GATTS_REQ_TYPE_WRITE_EXEC, |
| (tGATTS_DATA *)&flag); |
| p_tcb->prep_cnt[i]= 0; |
| } |
| } |
| } |
| else /* nothing needs to be executed , send response now */ |
| { |
| GATT_TRACE_ERROR("gatt_process_exec_write_req: no prepare write pending"); |
| gatt_send_error_rsp(p_tcb, GATT_ERROR, GATT_REQ_EXEC_WRITE, 0, false); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_process_read_multi_req |
| ** |
| ** Description This function is called to process the read multiple request |
| ** from client. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatt_process_read_multi_req (tGATT_TCB *p_tcb, uint8_t op_code, uint16_t len, uint8_t *p_data) |
| { |
| uint32_t trans_id; |
| uint16_t handle = 0, ll = len; |
| uint8_t *p = p_data, i_rcb; |
| tGATT_STATUS err = GATT_SUCCESS; |
| uint8_t sec_flag, key_size; |
| |
| GATT_TRACE_DEBUG("gatt_process_read_multi_req" ); |
| p_tcb->sr_cmd.multi_req.num_handles = 0; |
| |
| gatt_sr_get_sec_info(p_tcb->peer_bda, |
| p_tcb->transport, |
| &sec_flag, |
| &key_size); |
| |
| #if (GATT_CONFORMANCE_TESTING == TRUE) |
| if (gatt_cb.enable_err_rsp && gatt_cb.req_op_code == op_code) |
| { |
| GATT_TRACE_DEBUG("Conformance tst: forced err rspvofr ReadMultiple: error status=%d", gatt_cb.err_status); |
| |
| STREAM_TO_UINT16(handle, p); |
| |
| gatt_send_error_rsp (p_tcb, gatt_cb.err_status, gatt_cb.req_op_code, handle, false); |
| |
| return; |
| } |
| #endif |
| |
| while (ll >= 2 && p_tcb->sr_cmd.multi_req.num_handles < GATT_MAX_READ_MULTI_HANDLES) |
| { |
| STREAM_TO_UINT16(handle, p); |
| |
| if ((i_rcb = gatt_sr_find_i_rcb_by_handle(handle)) < GATT_MAX_SR_PROFILES) |
| { |
| p_tcb->sr_cmd.multi_req.handles[p_tcb->sr_cmd.multi_req.num_handles++] = handle; |
| |
| /* check read permission */ |
| if ((err = gatts_read_attr_perm_check( gatt_cb.sr_reg[i_rcb].p_db, |
| false, |
| handle, |
| sec_flag, |
| key_size)) |
| != GATT_SUCCESS) |
| { |
| GATT_TRACE_DEBUG("read permission denied : 0x%02x", err); |
| break; |
| } |
| } |
| else |
| { |
| /* invalid handle */ |
| err = GATT_INVALID_HANDLE; |
| break; |
| } |
| ll -= 2; |
| } |
| |
| if (ll != 0) |
| { |
| GATT_TRACE_ERROR("max attribute handle reached in ReadMultiple Request."); |
| } |
| |
| if (p_tcb->sr_cmd.multi_req.num_handles == 0) |
| err = GATT_INVALID_HANDLE; |
| |
| if (err == GATT_SUCCESS) |
| { |
| if ((trans_id = gatt_sr_enqueue_cmd (p_tcb, op_code, p_tcb->sr_cmd.multi_req.handles[0])) != 0) |
| { |
| gatt_sr_reset_cback_cnt(p_tcb); /* read multiple use multi_rsp_q's count*/ |
| |
| for (ll = 0; ll < p_tcb->sr_cmd.multi_req.num_handles; ll ++) { |
| tGATTS_RSP *p_msg = (tGATTS_RSP *)osi_calloc(sizeof(tGATTS_RSP)); |
| handle = p_tcb->sr_cmd.multi_req.handles[ll]; |
| i_rcb = gatt_sr_find_i_rcb_by_handle(handle); |
| |
| p_msg->attr_value.handle = handle; |
| err = gatts_read_attr_value_by_handle(p_tcb, |
| gatt_cb.sr_reg[i_rcb].p_db, |
| op_code, |
| handle, |
| 0, |
| p_msg->attr_value.value, |
| &p_msg->attr_value.len, |
| GATT_MAX_ATTR_LEN, |
| sec_flag, |
| key_size, |
| trans_id); |
| |
| if (err == GATT_SUCCESS) { |
| gatt_sr_process_app_rsp(p_tcb, gatt_cb.sr_reg[i_rcb].gatt_if ,trans_id, op_code, GATT_SUCCESS, p_msg); |
| } |
| /* either not using or done using the buffer, release it now */ |
| osi_free(p_msg); |
| } |
| } |
| else |
| err = GATT_NO_RESOURCES; |
| } |
| |
| /* in theroy BUSY is not possible(should already been checked), protected check */ |
| if (err != GATT_SUCCESS && err != GATT_PENDING && err != GATT_BUSY) |
| gatt_send_error_rsp(p_tcb, err, op_code, handle, false); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_build_primary_service_rsp |
| ** |
| ** Description Primamry service request processed internally. Theretically |
| ** only deal with ReadByTypeVAlue and ReadByGroupType. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static tGATT_STATUS gatt_build_primary_service_rsp (BT_HDR *p_msg, tGATT_TCB *p_tcb, |
| uint8_t op_code, uint16_t s_hdl, |
| uint16_t e_hdl, |
| UNUSED_ATTR uint8_t *p_data, tBT_UUID value) |
| { |
| tGATT_STATUS status = GATT_NOT_FOUND; |
| uint8_t handle_len =4, *p ; |
| tGATT_SR_REG *p_rcb; |
| tGATT_SRV_LIST_INFO *p_list= &gatt_cb.srv_list_info; |
| tGATT_SRV_LIST_ELEM *p_srv=NULL; |
| tBT_UUID *p_uuid; |
| |
| p = (uint8_t *)(p_msg + 1) + L2CAP_MIN_OFFSET; |
| |
| p_srv = p_list->p_first; |
| |
| while (p_srv) |
| { |
| p_rcb = GATT_GET_SR_REG_PTR(p_srv->i_sreg); |
| |
| if (p_rcb->in_use && |
| p_rcb->s_hdl >= s_hdl && |
| p_rcb->s_hdl <= e_hdl && |
| p_rcb->type == GATT_UUID_PRI_SERVICE) |
| { |
| if ((p_uuid = gatts_get_service_uuid (p_rcb->p_db)) != NULL) |
| { |
| if (op_code == GATT_REQ_READ_BY_GRP_TYPE) |
| handle_len = 4 + p_uuid->len; |
| |
| /* get the length byte in the repsonse */ |
| if (p_msg->offset ==0) |
| { |
| *p ++ = op_code + 1; |
| p_msg->len ++; |
| p_msg->offset = handle_len; |
| |
| if (op_code == GATT_REQ_READ_BY_GRP_TYPE) |
| { |
| *p ++ = (uint8_t)p_msg->offset; /* length byte */ |
| p_msg->len ++; |
| } |
| } |
| |
| if (p_msg->len + p_msg->offset <= p_tcb->payload_size && |
| handle_len == p_msg->offset) |
| { |
| if (op_code != GATT_REQ_FIND_TYPE_VALUE || |
| gatt_uuid_compare(value, *p_uuid)) |
| { |
| UINT16_TO_STREAM(p, p_rcb->s_hdl); |
| |
| if (p_list->p_last_primary == p_srv && |
| p_list->p_last_primary == p_list->p_last) |
| { |
| GATT_TRACE_DEBUG("Use 0xFFFF for the last primary attribute"); |
| UINT16_TO_STREAM(p, 0xFFFF); /* see GATT ERRATA 4065, 4063, ATT ERRATA 4062 */ |
| } |
| else |
| { |
| UINT16_TO_STREAM(p, p_rcb->e_hdl); |
| } |
| |
| if (op_code == GATT_REQ_READ_BY_GRP_TYPE) |
| gatt_build_uuid_to_stream(&p, *p_uuid); |
| |
| status = GATT_SUCCESS; |
| p_msg->len += p_msg->offset; |
| } |
| } |
| else |
| break; |
| } |
| } |
| p_srv = p_srv->p_next; |
| } |
| p_msg->offset = L2CAP_MIN_OFFSET; |
| |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_build_find_info_rsp |
| ** |
| ** Description fill the find information response information in the given |
| ** buffer. |
| ** |
| ** Returns true: if data filled sucessfully. |
| ** false: packet full, or format mismatch. |
| ** |
| *******************************************************************************/ |
| static tGATT_STATUS gatt_build_find_info_rsp(tGATT_SR_REG *p_rcb, BT_HDR *p_msg, uint16_t *p_len, |
| uint16_t s_hdl, uint16_t e_hdl) |
| { |
| tGATT_STATUS status = GATT_NOT_FOUND; |
| uint8_t *p; |
| uint16_t len = *p_len; |
| tGATT_ATTR *p_attr = NULL; |
| uint8_t info_pair_len[2] = {4, 18}; |
| |
| if (!p_rcb->p_db || !p_rcb->p_db->p_attr_list) |
| return status; |
| |
| /* check the attribute database */ |
| p_attr = (tGATT_ATTR *) p_rcb->p_db->p_attr_list; |
| |
| p = (uint8_t *)(p_msg + 1) + L2CAP_MIN_OFFSET + p_msg->len; |
| |
| while (p_attr) |
| { |
| if (p_attr->handle > e_hdl) |
| { |
| break; |
| } |
| |
| if (p_attr->handle >= s_hdl) |
| { |
| if (p_msg->offset == 0) |
| p_msg->offset = (p_attr->uuid.len == LEN_UUID_16) ? GATT_INFO_TYPE_PAIR_16 : GATT_INFO_TYPE_PAIR_128; |
| |
| if (len >= info_pair_len[p_msg->offset - 1]) |
| { |
| if (p_msg->offset == GATT_INFO_TYPE_PAIR_16 && p_attr->uuid.len == LEN_UUID_16) |
| { |
| UINT16_TO_STREAM(p, p_attr->handle); |
| UINT16_TO_STREAM(p, p_attr->uuid.uu.uuid16); |
| } |
| else if (p_msg->offset == GATT_INFO_TYPE_PAIR_128 && p_attr->uuid.len == LEN_UUID_128 ) |
| { |
| UINT16_TO_STREAM(p, p_attr->handle); |
| ARRAY_TO_STREAM (p, p_attr->uuid.uu.uuid128, LEN_UUID_128); |
| } |
| else if (p_msg->offset == GATT_INFO_TYPE_PAIR_128 && p_attr->uuid.len == LEN_UUID_32) |
| { |
| UINT16_TO_STREAM(p, p_attr->handle); |
| gatt_convert_uuid32_to_uuid128(p, p_attr->uuid.uu.uuid32); |
| p += LEN_UUID_128; |
| } |
| else |
| { |
| GATT_TRACE_ERROR("format mismatch"); |
| status = GATT_NO_RESOURCES; |
| break; |
| /* format mismatch */ |
| } |
| p_msg->len += info_pair_len[p_msg->offset - 1]; |
| len -= info_pair_len[p_msg->offset - 1]; |
| status = GATT_SUCCESS; |
| |
| } |
| else |
| { |
| status = GATT_NO_RESOURCES; |
| break; |
| } |
| } |
| p_attr = (tGATT_ATTR *)p_attr->p_next; |
| } |
| |
| *p_len = len; |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_internal_read_by_type_req |
| ** |
| ** Description check to see if the ReadByType request can be handled internally. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static tGATT_STATUS gatts_validate_packet_format(uint8_t op_code, uint16_t *p_len, |
| uint8_t **p_data, tBT_UUID *p_uuid_filter, |
| uint16_t *p_s_hdl, uint16_t *p_e_hdl) |
| { |
| tGATT_STATUS reason = GATT_SUCCESS; |
| uint16_t uuid_len, s_hdl = 0, e_hdl = 0; |
| uint16_t len = *p_len; |
| uint8_t *p = *p_data; |
| |
| if (len >= 4) |
| { |
| /* obtain starting handle, and ending handle */ |
| STREAM_TO_UINT16(s_hdl, p); |
| STREAM_TO_UINT16(e_hdl, p); |
| len -= 4; |
| |
| if (s_hdl > e_hdl || !GATT_HANDLE_IS_VALID(s_hdl) || !GATT_HANDLE_IS_VALID(e_hdl)) |
| { |
| reason = GATT_INVALID_HANDLE; |
| } |
| /* for these PDUs, uuid filter must present */ |
| else if (op_code == GATT_REQ_READ_BY_GRP_TYPE || |
| op_code == GATT_REQ_FIND_TYPE_VALUE || |
| op_code == GATT_REQ_READ_BY_TYPE) |
| { |
| if (len >= 2 && p_uuid_filter != NULL) |
| { |
| uuid_len = (op_code == GATT_REQ_FIND_TYPE_VALUE) ? 2 : len; |
| |
| /* parse uuid now */ |
| if (gatt_parse_uuid_from_cmd (p_uuid_filter, uuid_len, &p) == false || |
| p_uuid_filter->len == 0) |
| { |
| GATT_TRACE_DEBUG("UUID filter does not exsit"); |
| reason = GATT_INVALID_PDU; |
| } |
| else |
| len -= p_uuid_filter->len; |
| } |
| else |
| reason = GATT_INVALID_PDU; |
| } |
| } |
| else |
| reason = GATT_INVALID_PDU; |
| |
| *p_data = p; |
| *p_len = len; |
| *p_s_hdl = s_hdl; |
| *p_e_hdl = e_hdl; |
| |
| return reason; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_primary_service_req |
| ** |
| ** Description process ReadByGroupType/ReadByTypeValue request, for discover |
| ** all primary services or discover primary service by UUID request. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatts_process_primary_service_req(tGATT_TCB *p_tcb, uint8_t op_code, uint16_t len, uint8_t *p_data) |
| { |
| uint8_t reason = GATT_INVALID_PDU; |
| uint16_t s_hdl = 0, e_hdl = 0; |
| tBT_UUID uuid, value, primary_service = {LEN_UUID_16, {GATT_UUID_PRI_SERVICE}}; |
| BT_HDR *p_msg = NULL; |
| uint16_t msg_len = (uint16_t)(sizeof(BT_HDR) + p_tcb->payload_size + L2CAP_MIN_OFFSET); |
| |
| memset (&value, 0, sizeof(tBT_UUID)); |
| reason = gatts_validate_packet_format(op_code, &len, &p_data, &uuid, &s_hdl, &e_hdl); |
| |
| if (reason == GATT_SUCCESS) |
| { |
| if (gatt_uuid_compare(uuid, primary_service)) |
| { |
| if (op_code == GATT_REQ_FIND_TYPE_VALUE) |
| { |
| if (gatt_parse_uuid_from_cmd(&value, len, &p_data) == false) |
| reason = GATT_INVALID_PDU; |
| } |
| |
| if (reason == GATT_SUCCESS) { |
| p_msg = (BT_HDR *)osi_calloc(msg_len); |
| reason = gatt_build_primary_service_rsp (p_msg, p_tcb, op_code, |
| s_hdl, e_hdl, p_data, |
| value); |
| } |
| } |
| else |
| { |
| if (op_code == GATT_REQ_READ_BY_GRP_TYPE) |
| { |
| reason = GATT_UNSUPPORT_GRP_TYPE; |
| GATT_TRACE_DEBUG("unexpected ReadByGrpType Group: 0x%04x", uuid.uu.uuid16); |
| } |
| else |
| { |
| /* we do not support ReadByTypeValue with any non-primamry_service type */ |
| reason = GATT_NOT_FOUND; |
| GATT_TRACE_DEBUG("unexpected ReadByTypeValue type: 0x%04x", uuid.uu.uuid16); |
| } |
| } |
| } |
| |
| if (reason != GATT_SUCCESS) |
| { |
| osi_free(p_msg); |
| gatt_send_error_rsp (p_tcb, reason, op_code, s_hdl, false); |
| } |
| else |
| attp_send_sr_msg(p_tcb, p_msg); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_find_info |
| ** |
| ** Description process find information request, for discover character |
| ** descriptors. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void gatts_process_find_info(tGATT_TCB *p_tcb, uint8_t op_code, uint16_t len, uint8_t *p_data) |
| { |
| uint8_t reason = GATT_INVALID_PDU, *p; |
| uint16_t s_hdl = 0, e_hdl = 0, buf_len; |
| BT_HDR *p_msg = NULL; |
| tGATT_SR_REG *p_rcb; |
| tGATT_SRV_LIST_INFO *p_list= &gatt_cb.srv_list_info; |
| tGATT_SRV_LIST_ELEM *p_srv=NULL; |
| |
| reason = gatts_validate_packet_format(op_code, &len, &p_data, NULL, &s_hdl, &e_hdl); |
| |
| if (reason == GATT_SUCCESS) |
| { |
| buf_len = (uint16_t)(sizeof(BT_HDR) + p_tcb->payload_size + L2CAP_MIN_OFFSET); |
| |
| p_msg = (BT_HDR *)osi_calloc(buf_len); |
| reason = GATT_NOT_FOUND; |
| |
| p = (uint8_t *)(p_msg + 1) + L2CAP_MIN_OFFSET; |
| *p ++ = op_code + 1; |
| p_msg->len = 2; |
| |
| buf_len = p_tcb->payload_size - 2; |
| |
| p_srv = p_list->p_first; |
| |
| while (p_srv) { |
| p_rcb = GATT_GET_SR_REG_PTR(p_srv->i_sreg); |
| |
| if (p_rcb->in_use && !(p_rcb->s_hdl > e_hdl || |
| p_rcb->e_hdl < s_hdl)) { |
| reason = gatt_build_find_info_rsp(p_rcb, p_msg, &buf_len, |
| s_hdl, e_hdl); |
| if (reason == GATT_NO_RESOURCES) { |
| reason = GATT_SUCCESS; |
| break; |
| } |
| } |
| p_srv = p_srv->p_next; |
| } |
| *p = (uint8_t)p_msg->offset; |
| |
| p_msg->offset = L2CAP_MIN_OFFSET; |
| } |
| |
| if (reason != GATT_SUCCESS) |
| { |
| osi_free(p_msg); |
| gatt_send_error_rsp (p_tcb, reason, op_code, s_hdl, false); |
| } |
| else |
| attp_send_sr_msg(p_tcb, p_msg); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_mtu_req |
| ** |
| ** Description This function is called to process excahnge MTU request. |
| ** Only used on LE. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void gatts_process_mtu_req (tGATT_TCB *p_tcb, uint16_t len, uint8_t *p_data) |
| { |
| uint16_t mtu = 0; |
| uint8_t *p = p_data, i; |
| BT_HDR *p_buf; |
| uint16_t conn_id; |
| |
| /* BR/EDR conenction, send error response */ |
| if (p_tcb->att_lcid != L2CAP_ATT_CID) |
| { |
| gatt_send_error_rsp (p_tcb, GATT_REQ_NOT_SUPPORTED, GATT_REQ_MTU, 0, false); |
| } |
| else if (len < GATT_MTU_REQ_MIN_LEN) |
| { |
| GATT_TRACE_ERROR("invalid MTU request PDU received."); |
| gatt_send_error_rsp (p_tcb, GATT_INVALID_PDU, GATT_REQ_MTU, 0, false); |
| } |
| else |
| { |
| STREAM_TO_UINT16 (mtu, p); |
| /* mtu must be greater than default MTU which is 23/48 */ |
| if (mtu < GATT_DEF_BLE_MTU_SIZE) |
| p_tcb->payload_size = GATT_DEF_BLE_MTU_SIZE; |
| else if (mtu > GATT_MAX_MTU_SIZE) |
| p_tcb->payload_size = GATT_MAX_MTU_SIZE; |
| else |
| p_tcb->payload_size = mtu; |
| |
| GATT_TRACE_ERROR("MTU request PDU with MTU size %d", p_tcb->payload_size); |
| |
| l2cble_set_fixed_channel_tx_data_length(p_tcb->peer_bda, L2CAP_ATT_CID, p_tcb->payload_size); |
| |
| if ((p_buf = attp_build_sr_msg(p_tcb, GATT_RSP_MTU, (tGATT_SR_MSG *) &p_tcb->payload_size)) != NULL) |
| { |
| attp_send_sr_msg (p_tcb, p_buf); |
| |
| /* Notify all registered applicaiton with new MTU size. Us a transaction ID */ |
| /* of 0, as no response is allowed from applcations */ |
| |
| for (i = 0; i < GATT_MAX_APPS; i ++) |
| { |
| if (gatt_cb.cl_rcb[i].in_use ) |
| { |
| conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, gatt_cb.cl_rcb[i].gatt_if); |
| gatt_sr_send_req_callback(conn_id, 0, GATTS_REQ_TYPE_MTU, |
| (tGATTS_DATA *)&p_tcb->payload_size); |
| } |
| } |
| |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_read_by_type_req |
| ** |
| ** Description process Read By type request. |
| ** This PDU can be used to perform: |
| ** - read characteristic value |
| ** - read characteristic descriptor value |
| ** - discover characteristic |
| ** - discover characteristic by UUID |
| ** - relationship discovery |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatts_process_read_by_type_req(tGATT_TCB *p_tcb, uint8_t op_code, uint16_t len, uint8_t *p_data) |
| { |
| tBT_UUID uuid; |
| tGATT_SR_REG *p_rcb; |
| size_t msg_len = sizeof(BT_HDR) + p_tcb->payload_size + L2CAP_MIN_OFFSET; |
| uint16_t buf_len, s_hdl, e_hdl, err_hdl = 0; |
| BT_HDR *p_msg = NULL; |
| tGATT_STATUS reason, ret; |
| uint8_t *p; |
| uint8_t sec_flag, key_size; |
| tGATT_SRV_LIST_INFO *p_list= &gatt_cb.srv_list_info; |
| tGATT_SRV_LIST_ELEM *p_srv=NULL; |
| |
| reason = gatts_validate_packet_format(op_code, &len, &p_data, &uuid, &s_hdl, &e_hdl); |
| |
| #if (GATT_CONFORMANCE_TESTING == TRUE) |
| if (gatt_cb.enable_err_rsp && gatt_cb.req_op_code == op_code) |
| { |
| GATT_TRACE_DEBUG("Conformance tst: forced err rsp for ReadByType: error status=%d", gatt_cb.err_status); |
| |
| gatt_send_error_rsp (p_tcb, gatt_cb.err_status, gatt_cb.req_op_code, s_hdl, false); |
| |
| return; |
| } |
| #endif |
| |
| if (reason == GATT_SUCCESS) |
| { |
| p_msg = (BT_HDR *)osi_calloc(msg_len); |
| p = (uint8_t *)(p_msg + 1) + L2CAP_MIN_OFFSET; |
| |
| *p ++ = op_code + 1; |
| /* reserve length byte */ |
| p_msg->len = 2; |
| buf_len = p_tcb->payload_size - 2; |
| |
| reason = GATT_NOT_FOUND; |
| |
| p_srv = p_list->p_first; |
| |
| while (p_srv) { |
| p_rcb = GATT_GET_SR_REG_PTR(p_srv->i_sreg); |
| |
| if (p_rcb->in_use && !(p_rcb->s_hdl > e_hdl || |
| p_rcb->e_hdl < s_hdl)) { |
| gatt_sr_get_sec_info(p_tcb->peer_bda, p_tcb->transport, |
| &sec_flag, &key_size); |
| |
| ret = gatts_db_read_attr_value_by_type(p_tcb, |
| p_rcb->p_db, |
| op_code, |
| p_msg, |
| s_hdl, |
| e_hdl, |
| uuid, |
| &buf_len, |
| sec_flag, |
| key_size, |
| 0, |
| &err_hdl); |
| if (ret != GATT_NOT_FOUND) { |
| reason = ret; |
| |
| if (ret == GATT_NO_RESOURCES) |
| reason = GATT_SUCCESS; |
| } |
| if (ret != GATT_SUCCESS && ret != GATT_NOT_FOUND) { |
| s_hdl = err_hdl; |
| break; |
| } |
| } |
| p_srv = p_srv->p_next; |
| } |
| *p = (uint8_t)p_msg->offset; |
| p_msg->offset = L2CAP_MIN_OFFSET; |
| } |
| if (reason != GATT_SUCCESS) |
| { |
| osi_free(p_msg); |
| |
| /* in theroy BUSY is not possible(should already been checked), protected check */ |
| if (reason != GATT_PENDING && reason != GATT_BUSY) |
| gatt_send_error_rsp (p_tcb, reason, op_code, s_hdl, false); |
| } |
| else |
| attp_send_sr_msg(p_tcb, p_msg); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_write_req |
| ** |
| ** Description This function is called to process the write request |
| ** from client. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatts_process_write_req (tGATT_TCB *p_tcb, uint8_t i_rcb, uint16_t handle, |
| uint8_t op_code, uint16_t len, uint8_t *p_data, |
| bt_gatt_db_attribute_type_t gatt_type) |
| { |
| tGATTS_DATA sr_data; |
| uint32_t trans_id; |
| tGATT_STATUS status; |
| uint8_t sec_flag, key_size, *p = p_data; |
| tGATT_SR_REG *p_sreg; |
| uint16_t conn_id; |
| |
| memset(&sr_data, 0, sizeof(tGATTS_DATA)); |
| |
| switch (op_code) |
| { |
| case GATT_REQ_PREPARE_WRITE: |
| if (len < 2) { |
| GATT_TRACE_ERROR("%s: Prepare write request was invalid - missing offset, sending error response", __func__); |
| gatt_send_error_rsp(p_tcb, GATT_INVALID_PDU, op_code, handle, false); |
| return; |
| } |
| sr_data.write_req.is_prep = true; |
| STREAM_TO_UINT16(sr_data.write_req.offset, p); |
| len -= 2; |
| /* fall through */ |
| case GATT_SIGN_CMD_WRITE: |
| if (op_code == GATT_SIGN_CMD_WRITE) |
| { |
| GATT_TRACE_DEBUG("Write CMD with data sigining" ); |
| len -= GATT_AUTH_SIGN_LEN; |
| } |
| /* fall through */ |
| case GATT_CMD_WRITE: |
| case GATT_REQ_WRITE: |
| if (op_code == GATT_REQ_WRITE || op_code == GATT_REQ_PREPARE_WRITE) |
| sr_data.write_req.need_rsp = true; |
| sr_data.write_req.handle = handle; |
| sr_data.write_req.len = len; |
| if (len != 0 && p != NULL) |
| { |
| memcpy (sr_data.write_req.value, p, len); |
| } |
| break; |
| } |
| |
| gatt_sr_get_sec_info(p_tcb->peer_bda, |
| p_tcb->transport, |
| &sec_flag, |
| &key_size); |
| |
| status = gatts_write_attr_perm_check (gatt_cb.sr_reg[i_rcb].p_db, |
| op_code, |
| handle, |
| sr_data.write_req.offset, |
| p, |
| len, |
| sec_flag, |
| key_size); |
| |
| if (status == GATT_SUCCESS) |
| { |
| if ((trans_id = gatt_sr_enqueue_cmd(p_tcb, op_code, handle)) != 0) |
| { |
| p_sreg = &gatt_cb.sr_reg[i_rcb]; |
| conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_sreg->gatt_if); |
| |
| uint8_t opcode = 0; |
| if (gatt_type == BTGATT_DB_DESCRIPTOR) { |
| opcode = GATTS_REQ_TYPE_WRITE_DESCRIPTOR; |
| } else if (gatt_type == BTGATT_DB_CHARACTERISTIC) { |
| opcode = GATTS_REQ_TYPE_WRITE_CHARACTERISTIC; |
| } else { |
| GATT_TRACE_ERROR("%s: Attempt to write attribute that's not tied with" |
| " characteristic or descriptor value.", __func__); |
| status = GATT_ERROR; |
| } |
| |
| if (opcode) { |
| gatt_sr_send_req_callback(conn_id, trans_id, opcode, &sr_data); |
| status = GATT_PENDING; |
| } |
| } |
| else |
| { |
| GATT_TRACE_ERROR("max pending command, send error"); |
| status = GATT_BUSY; /* max pending command, application error */ |
| } |
| } |
| |
| /* in theroy BUSY is not possible(should already been checked), protected check */ |
| if (status != GATT_PENDING && status != GATT_BUSY && |
| (op_code == GATT_REQ_PREPARE_WRITE || op_code == GATT_REQ_WRITE)) |
| { |
| gatt_send_error_rsp (p_tcb, status, op_code, handle, false); |
| } |
| return; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_read_req |
| ** |
| ** Description This function is called to process the read request |
| ** from client. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void gatts_process_read_req(tGATT_TCB *p_tcb, tGATT_SR_REG *p_rcb, uint8_t op_code, |
| uint16_t handle, |
| UNUSED_ATTR uint16_t len, uint8_t *p_data) |
| { |
| size_t buf_len = sizeof(BT_HDR) + p_tcb->payload_size + L2CAP_MIN_OFFSET; |
| tGATT_STATUS reason; |
| uint8_t sec_flag, key_size, *p; |
| uint16_t offset = 0, value_len = 0; |
| BT_HDR *p_msg = (BT_HDR *)osi_calloc(buf_len); |
| |
| if (op_code == GATT_REQ_READ_BLOB) |
| STREAM_TO_UINT16(offset, p_data); |
| |
| p = (uint8_t *)(p_msg + 1) + L2CAP_MIN_OFFSET; |
| *p ++ = op_code + 1; |
| p_msg->len = 1; |
| buf_len = p_tcb->payload_size - 1; |
| |
| gatt_sr_get_sec_info(p_tcb->peer_bda, p_tcb->transport, &sec_flag, |
| &key_size); |
| |
| reason = gatts_read_attr_value_by_handle(p_tcb, |
| p_rcb->p_db, |
| op_code, |
| handle, |
| offset, |
| p, |
| &value_len, |
| (uint16_t)buf_len, |
| sec_flag, |
| key_size, |
| 0); |
| |
| p_msg->len += value_len; |
| |
| if (reason != GATT_SUCCESS) |
| { |
| osi_free(p_msg); |
| |
| /* in theroy BUSY is not possible(should already been checked), protected check */ |
| if (reason != GATT_PENDING && reason != GATT_BUSY) |
| gatt_send_error_rsp (p_tcb, reason, op_code, handle, false); |
| } |
| else |
| attp_send_sr_msg(p_tcb, p_msg); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_attribute_req |
| ** |
| ** Description This function is called to process the per attribute handle request |
| ** from client. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatts_process_attribute_req (tGATT_TCB *p_tcb, uint8_t op_code, |
| uint16_t len, uint8_t *p_data) |
| { |
| uint16_t handle = 0; |
| uint8_t *p = p_data, i; |
| tGATT_SR_REG *p_rcb = gatt_cb.sr_reg; |
| tGATT_STATUS status = GATT_INVALID_HANDLE; |
| tGATT_ATTR *p_attr; |
| |
| if (len < 2) |
| { |
| GATT_TRACE_ERROR("Illegal PDU length, discard request"); |
| status = GATT_INVALID_PDU; |
| } |
| else |
| { |
| STREAM_TO_UINT16(handle, p); |
| len -= 2; |
| } |
| |
| #if (GATT_CONFORMANCE_TESTING == TRUE) |
| gatt_cb.handle = handle; |
| if (gatt_cb.enable_err_rsp && gatt_cb.req_op_code == op_code) |
| { |
| GATT_TRACE_DEBUG("Conformance tst: forced err rsp: error status=%d", gatt_cb.err_status); |
| |
| gatt_send_error_rsp (p_tcb, gatt_cb.err_status, gatt_cb.req_op_code, handle, false); |
| |
| return; |
| } |
| #endif |
| |
| if (GATT_HANDLE_IS_VALID(handle)) |
| { |
| for (i = 0; i < GATT_MAX_SR_PROFILES; i ++, p_rcb ++) |
| { |
| if (p_rcb->in_use && p_rcb->s_hdl <= handle && p_rcb->e_hdl >= handle) |
| { |
| p_attr = (tGATT_ATTR *)p_rcb->p_db->p_attr_list; |
| |
| while (p_attr) |
| { |
| if (p_attr->handle == handle) |
| { |
| switch (op_code) |
| { |
| case GATT_REQ_READ: /* read char/char descriptor value */ |
| case GATT_REQ_READ_BLOB: |
| gatts_process_read_req(p_tcb, p_rcb, op_code, handle, len, p); |
| break; |
| |
| case GATT_REQ_WRITE: /* write char/char descriptor value */ |
| case GATT_CMD_WRITE: |
| case GATT_SIGN_CMD_WRITE: |
| case GATT_REQ_PREPARE_WRITE: |
| gatts_process_write_req(p_tcb, i, handle, op_code, len, p, |
| p_attr->gatt_type); |
| break; |
| default: |
| break; |
| } |
| status = GATT_SUCCESS; |
| break; |
| } |
| p_attr = (tGATT_ATTR *)p_attr->p_next; |
| } |
| break; |
| } |
| } |
| } |
| |
| if (status != GATT_SUCCESS && op_code != GATT_CMD_WRITE && op_code != GATT_SIGN_CMD_WRITE) |
| gatt_send_error_rsp (p_tcb, status, op_code, handle, false); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_proc_srv_chg_ind_ack |
| ** |
| ** Description This function process the service changed indicaiton ACK |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void gatts_proc_srv_chg_ind_ack(tGATT_TCB *p_tcb ) |
| { |
| tGATTS_SRV_CHG_REQ req; |
| tGATTS_SRV_CHG *p_buf = NULL; |
| |
| GATT_TRACE_DEBUG("gatts_proc_srv_chg_ind_ack"); |
| |
| if ((p_buf = gatt_is_bda_in_the_srv_chg_clt_list(p_tcb->peer_bda)) != NULL) |
| { |
| GATT_TRACE_DEBUG("NV update set srv chg = false"); |
| p_buf->srv_changed = false; |
| memcpy(&req.srv_chg, p_buf, sizeof(tGATTS_SRV_CHG)); |
| if (gatt_cb.cb_info.p_srv_chg_callback) |
| (*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_UPDATE_CLIENT,&req, NULL); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_chk_pending_ind |
| ** |
| ** Description This function check any pending indication needs to be sent if |
| ** there is a pending indication then sent the indication |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void gatts_chk_pending_ind(tGATT_TCB *p_tcb ) |
| { |
| GATT_TRACE_DEBUG("%s", __func__); |
| |
| tGATT_VALUE *p_buf = (tGATT_VALUE *)fixed_queue_try_peek_first(p_tcb->pending_ind_q); |
| if (p_buf != NULL) |
| { |
| GATTS_HandleValueIndication(p_buf->conn_id, |
| p_buf->handle, |
| p_buf->len, |
| p_buf->value); |
| osi_free(fixed_queue_try_remove_from_queue(p_tcb->pending_ind_q, |
| p_buf)); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_proc_ind_ack |
| ** |
| ** Description This function process the Indication ack |
| ** |
| ** Returns true continue to process the indication ack by the aaplication |
| ** if the ACk is not a Service Changed Indication Ack |
| ** |
| *******************************************************************************/ |
| static bool gatts_proc_ind_ack(tGATT_TCB *p_tcb, uint16_t ack_handle) |
| { |
| bool continue_processing = true; |
| |
| GATT_TRACE_DEBUG ("gatts_proc_ind_ack ack handle=%d", ack_handle); |
| |
| if (ack_handle == gatt_cb.handle_of_h_r) |
| { |
| gatts_proc_srv_chg_ind_ack(p_tcb); |
| /* there is no need to inform the application since srv chg is handled internally by GATT */ |
| continue_processing = false; |
| } |
| |
| gatts_chk_pending_ind(p_tcb); |
| return continue_processing; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatts_process_value_conf |
| ** |
| ** Description This function is called to process the handle value confirmation. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatts_process_value_conf(tGATT_TCB *p_tcb, uint8_t op_code) |
| { |
| uint16_t handle = p_tcb->indicate_handle; |
| uint32_t trans_id; |
| uint8_t i; |
| tGATT_SR_REG *p_rcb = gatt_cb.sr_reg; |
| bool continue_processing; |
| uint16_t conn_id; |
| |
| alarm_cancel(p_tcb->conf_timer); |
| if (GATT_HANDLE_IS_VALID(handle)) |
| { |
| p_tcb->indicate_handle = 0; |
| continue_processing = gatts_proc_ind_ack(p_tcb, handle); |
| |
| if (continue_processing) |
| { |
| for (i = 0; i < GATT_MAX_SR_PROFILES; i ++, p_rcb ++) |
| { |
| if (p_rcb->in_use && p_rcb->s_hdl <= handle && p_rcb->e_hdl >= handle) |
| { |
| trans_id = gatt_sr_enqueue_cmd(p_tcb, op_code, handle); |
| conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_rcb->gatt_if); |
| gatt_sr_send_req_callback(conn_id, |
| trans_id, GATTS_REQ_TYPE_CONF, (tGATTS_DATA *)&handle); |
| } |
| } |
| } |
| } |
| else |
| { |
| GATT_TRACE_ERROR("unexpected handle value confirmation"); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gatt_server_handle_client_req |
| ** |
| ** Description This function is called to handle the client requests to |
| ** server. |
| ** |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gatt_server_handle_client_req (tGATT_TCB *p_tcb, uint8_t op_code, |
| uint16_t len, uint8_t *p_data) |
| { |
| /* there is pending command, discard this one */ |
| if (!gatt_sr_cmd_empty(p_tcb) && op_code != GATT_HANDLE_VALUE_CONF) |
| return; |
| |
| /* the size of the message may not be bigger than the local max PDU size*/ |
| /* The message has to be smaller than the agreed MTU, len does not include op code */ |
| if (len >= p_tcb->payload_size) |
| { |
| GATT_TRACE_ERROR("server receive invalid PDU size:%d pdu size:%d", len + 1, p_tcb->payload_size ); |
| /* for invalid request expecting response, send it now */ |
| if (op_code != GATT_CMD_WRITE && |
| op_code != GATT_SIGN_CMD_WRITE && |
| op_code != GATT_HANDLE_VALUE_CONF) |
| { |
| gatt_send_error_rsp (p_tcb, GATT_INVALID_PDU, op_code, 0, false); |
| } |
| /* otherwise, ignore the pkt */ |
| } |
| else |
| { |
| switch (op_code) |
| { |
| case GATT_REQ_READ_BY_GRP_TYPE: /* discover primary services */ |
| case GATT_REQ_FIND_TYPE_VALUE: /* discover service by UUID */ |
| gatts_process_primary_service_req (p_tcb, op_code, len, p_data); |
| break; |
| |
| case GATT_REQ_FIND_INFO:/* discover char descrptor */ |
| gatts_process_find_info(p_tcb, op_code, len, p_data); |
| break; |
| |
| case GATT_REQ_READ_BY_TYPE: /* read characteristic value, char descriptor value */ |
| /* discover characteristic, discover char by UUID */ |
| gatts_process_read_by_type_req(p_tcb, op_code, len, p_data); |
| break; |
| |
| |
| case GATT_REQ_READ: /* read char/char descriptor value */ |
| case GATT_REQ_READ_BLOB: |
| case GATT_REQ_WRITE: /* write char/char descriptor value */ |
| case GATT_CMD_WRITE: |
| case GATT_SIGN_CMD_WRITE: |
| case GATT_REQ_PREPARE_WRITE: |
| gatts_process_attribute_req (p_tcb, op_code, len, p_data); |
| break; |
| |
| case GATT_HANDLE_VALUE_CONF: |
| gatts_process_value_conf (p_tcb, op_code); |
| break; |
| |
| case GATT_REQ_MTU: |
| gatts_process_mtu_req (p_tcb, len, p_data); |
| break; |
| |
| case GATT_REQ_EXEC_WRITE: |
| gatt_process_exec_write_req (p_tcb, op_code, len, p_data); |
| break; |
| |
| case GATT_REQ_READ_MULTI: |
| gatt_process_read_multi_req (p_tcb, op_code, len, p_data); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| |
| #endif /* BLE_INCLUDED */ |
