uint32_t ble_gatts_read_authorize_params_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_struct)
{
ble_gatts_read_authorize_params_t * p_params =
(ble_gatts_read_authorize_params_t *) p_void_struct;
uint32_t error_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_params->gatt_status);
uint8_t temp_val;
SER_ASSERT_LENGTH_LEQ(1, buf_len - *p_index);
uint8_dec(p_buf, buf_len, p_index, &temp_val);
p_params->update = temp_val;
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_params->offset);
error_code = len16data_dec(p_buf, buf_len, p_index, &p_params->p_data, &p_params->len);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
return error_code;
}
uint32_t ble_version_get_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_version_t * p_version,
uint32_t * const p_result_code)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t status_code = ser_ble_cmd_rsp_result_code_dec(p_buf, &index, packet_len,
SD_BLE_VERSION_GET,
p_result_code);
if (status_code != NRF_SUCCESS)
{
return status_code;
}
if (*p_result_code != NRF_SUCCESS)
{
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint8_dec(p_buf, packet_len, &index, &(p_version->version_number));
uint16_dec(p_buf, packet_len, &index, &(p_version->company_id));
uint16_dec(p_buf, packet_len, &index, &p_version->subversion_number);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return status_code;
}
uint32_t ble_gap_sec_params_reply_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t * p_conn_handle,
uint8_t * p_sec_status,
ble_gap_sec_params_t * * const pp_sec_params)
{
uint32_t index = SER_CMD_HEADER_SIZE;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(p_sec_status);
SER_ASSERT_NOT_NULL(pp_sec_params);
SER_ASSERT_NOT_NULL(*pp_sec_params);
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 4, packet_len);
uint16_dec(p_buf, packet_len, &index, p_conn_handle);
uint8_dec(p_buf, packet_len, &index, p_sec_status);
if (p_buf[index] == SER_FIELD_PRESENT)
{
index++;
SER_ASSERT_LENGTH_LEQ(index + 5, packet_len);
uint16_dec(p_buf, packet_len, &index, &((*pp_sec_params)->timeout));
(*pp_sec_params)->bond = (p_buf[index] >> 0) & 0x01;
(*pp_sec_params)->mitm = (p_buf[index] >> 1) & 0x01;
(*pp_sec_params)->io_caps = (p_buf[index] >> 2) & 0x07;
(*pp_sec_params)->oob = (p_buf[index] >> 5) & 0x01;
index++;
uint8_dec(p_buf, packet_len, &index, &(*pp_sec_params)->min_key_size);
uint8_dec(p_buf, packet_len, &index, &(*pp_sec_params)->max_key_size);
}
uint32_t ble_gatts_value_get_req_dec(uint8_t const * const p_buf,
uint16_t packet_len,
uint16_t * const handle,
uint16_t * const offset,
uint16_t * * const pp_len,
uint8_t * * const pp_data)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 6, packet_len);
SER_ASSERT(p_buf[index] == SD_BLE_GATTS_VALUE_GET, NRF_ERROR_INVALID_PARAM);
index++;
uint16_dec(p_buf, packet_len, &index, handle);
uint16_dec(p_buf, packet_len, &index, offset);
if (p_buf[index++] == SER_FIELD_PRESENT)
{
uint16_dec(p_buf, packet_len, &index, *pp_len);
}
else
{
*pp_len = NULL;
}
if (p_buf[index++] == SER_FIELD_NOT_PRESENT)
{
*pp_data = NULL;
}
return NRF_SUCCESS;
}
uint32_t ble_gatts_evt_hvc_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(SER_EVT_CONN_HANDLE_SIZE + 1, packet_len);
uint32_t event_len = SER_EVT_CONN_HANDLE_SIZE + sizeof (ble_gatts_evt_hvc_t);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GATTS_EVT_HVC;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &p_event->evt.gatts_evt.conn_handle);
uint16_dec(p_buf, packet_len, &index, &p_event->evt.gatts_evt.params.hvc.handle);
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gattc_evt_char_val_by_uuid_read_rsp_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
uint32_t * const p_struct_size,
void * const p_void_struct)
{
ble_gattc_evt_char_val_by_uuid_read_rsp_t * p_read =
(ble_gattc_evt_char_val_by_uuid_read_rsp_t *) p_void_struct;
uint32_t err_code = NRF_SUCCESS;
uint16_t value_len;
uint16_t count;
uint32_t i;
SER_ASSERT_LENGTH_LEQ(4, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &count);
uint16_dec(p_buf, buf_len, p_index, &value_len);
uint32_t total_struct_size = *p_struct_size;
//calculate the size of the struct
*p_struct_size = offsetof(ble_gattc_evt_char_val_by_uuid_read_rsp_t, handle_value[count]);
*p_struct_size += value_len * count;
if (p_read)
{
p_read->value_len = value_len;
p_read->count = count;
ble_gattc_handle_value_t * p_handle_value;
uint8_t * p_value;
SER_ASSERT_LENGTH_LEQ(*p_struct_size, total_struct_size);
p_value = (uint8_t *)&p_read->handle_value[count];
for (i = 0; i < count; i++)
{
p_handle_value = (ble_gattc_handle_value_t *)&p_read->handle_value[i];
p_handle_value->p_value = p_value;
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &(p_handle_value->handle));
SER_ASSERT_LENGTH_LEQ(p_read->value_len, buf_len - *p_index);
memcpy(p_handle_value->p_value, &p_buf[*p_index], p_read->value_len);
*p_index += p_read->value_len;
p_value += value_len;
}
}
else
{
*p_index += count * (value_len + 2);
}
return err_code;
}
uint32_t ble_gap_evt_sec_info_request_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
uint32_t event_len;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(2 + 1 + 6 + 2 + 1, packet_len);
event_len = SER_EVT_CONN_HANDLE_SIZE + sizeof (ble_gap_evt_sec_info_request_t);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GAP_EVT_SEC_INFO_REQUEST;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &p_event->evt.gap_evt.conn_handle);
ble_gap_evt_sec_info_request_t * p_sec_info_request =
&(p_event->evt.gap_evt.params.sec_info_request);
p_sec_info_request->peer_addr.addr_type = p_buf[index++];
p_sec_info_request->peer_addr.addr[0] = p_buf[index++];
p_sec_info_request->peer_addr.addr[1] = p_buf[index++];
p_sec_info_request->peer_addr.addr[2] = p_buf[index++];
p_sec_info_request->peer_addr.addr[3] = p_buf[index++];
p_sec_info_request->peer_addr.addr[4] = p_buf[index++];
p_sec_info_request->peer_addr.addr[5] = p_buf[index++];
uint16_dec(p_buf, packet_len, &index, &p_sec_info_request->div);
p_sec_info_request->enc_info = (p_buf[index] >> 0) & 0x1;
p_sec_info_request->id_info = (p_buf[index] >> 1) & 0x1;
p_sec_info_request->sign_info = (p_buf[index] >> 2) & 0x1;
index++;
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gattc_handle_range_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_struct)
{
ble_gattc_handle_range_t * p_range = (ble_gattc_handle_range_t *) p_void_struct;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(4, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &(p_range->start_handle));
uint16_dec(p_buf, buf_len, p_index, &(p_range->end_handle));
return err_code;
}
uint32_t ble_gatts_char_handles_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_char_handles)
{
ble_gatts_char_handles_t * p_char_handles = (ble_gatts_char_handles_t *)p_void_char_handles;
SER_ASSERT_LENGTH_LEQ(8, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &(p_char_handles->value_handle));
uint16_dec(p_buf, buf_len, p_index, &p_char_handles->user_desc_handle);
uint16_dec(p_buf, buf_len, p_index, &p_char_handles->cccd_handle);
uint16_dec(p_buf, buf_len, p_index, &p_char_handles->sccd_handle);
return NRF_SUCCESS;
}
uint32_t ble_gattc_evt_hvx_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
uint16_t tmp_attr_len;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(11, packet_len);
tmp_attr_len = uint16_decode(&(p_buf[9]));
uint32_t event_len = offsetof(ble_gattc_evt_t, params.hvx) +
offsetof (ble_gattc_evt_hvx_t, data) + tmp_attr_len;
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GATTC_EVT_HVX;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.conn_handle));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.gatt_status));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.error_handle));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.hvx.handle));
uint8_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.hvx.type));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.hvx.len));
SER_ASSERT_LENGTH_LEQ(index + tmp_attr_len, packet_len);
if (tmp_attr_len > 0)
{
memcpy(&(p_event->evt.gattc_evt.params.hvx.data[0]), &(p_buf[index]), tmp_attr_len);
index += tmp_attr_len;
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gap_evt_sec_params_request_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
uint32_t event_len;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(7, packet_len);
event_len = SER_EVT_CONN_HANDLE_SIZE + sizeof (ble_gap_evt_sec_params_request_t);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GAP_EVT_SEC_PARAMS_REQUEST;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &p_event->evt.gap_evt.conn_handle);
ble_gap_evt_sec_params_request_t * p_sec_params_request =
&(p_event->evt.gap_evt.params.sec_params_request);
uint16_dec(p_buf, packet_len, &index, &p_sec_params_request->peer_params.timeout);
p_sec_params_request->peer_params.bond = (p_buf[index] >> 0) & 0x1;
p_sec_params_request->peer_params.mitm = (p_buf[index] >> 1) & 0x1;
p_sec_params_request->peer_params.io_caps = (p_buf[index] >> 2) & 0x7;
p_sec_params_request->peer_params.oob = (p_buf[index] >> 5) & 0x1;
index++;
p_sec_params_request->peer_params.min_key_size = p_buf[index++];
p_sec_params_request->peer_params.max_key_size = p_buf[index++];
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gatts_service_add_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t * const p_conn_handle,
uint32_t * const p_result_code)
{
uint32_t index = 0;
uint32_t decode_result = ser_ble_cmd_rsp_result_code_dec(p_buf, &index, packet_len,
SD_BLE_GATTS_SERVICE_ADD,
p_result_code);
if (decode_result != NRF_SUCCESS)
{
return decode_result;
}
if (*p_result_code != NRF_SUCCESS)
{
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_LENGTH_LEQ(index + 2, packet_len);
uint16_dec(p_buf, packet_len, &index, p_conn_handle);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return decode_result;
}
uint32_t ble_evt_tx_complete_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(SER_EVT_CONN_HANDLE_SIZE + 1, packet_len);
uint32_t event_len = SER_EVT_CONN_HANDLE_SIZE + sizeof (ble_evt_tx_complete_t);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_EVT_TX_COMPLETE;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &p_event->evt.common_evt.conn_handle);
uint8_dec(p_buf, packet_len, &index, &p_event->evt.common_evt.params.tx_complete.count);
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gattc_char_value_by_uuid_read_req_dec(
uint8_t const * const p_buf,
uint16_t buf_len,
uint16_t * const p_conn_handle,
ble_uuid_t * * const pp_uuid,
ble_gattc_handle_range_t * * const
pp_handle_range)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(pp_uuid);
SER_ASSERT_NOT_NULL(*pp_uuid);
SER_ASSERT_NOT_NULL(pp_handle_range);
SER_ASSERT_NOT_NULL(*pp_handle_range);
uint32_t index = 0;
uint32_t err_code;
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 2, buf_len);
SER_ASSERT(p_buf[index] == SD_BLE_GATTC_CHAR_VALUE_BY_UUID_READ, NRF_ERROR_INVALID_DATA);
index++;
uint16_dec(p_buf, buf_len, &index, p_conn_handle);
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_uuid, ble_uuid_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_handle_range,
ble_gattc_handle_range_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, buf_len);
return err_code;
}
uint32_t ble_gattc_char_values_read_req_dec(uint8_t const * const p_buf,
uint16_t packet_len,
uint16_t * const p_conn_handle,
uint16_t * * const pp_handles,
uint16_t * const p_handle_count)
{
SER_ASSERT_NOT_NULL(p_buf); //check if *p_buf is allocated
SER_ASSERT_NOT_NULL(p_conn_handle); //check if *p_conn_handle exist
SER_ASSERT_NOT_NULL(pp_handles); //check if *p_handles exist
SER_ASSERT_NOT_NULL(*pp_handles); //check if p_handles exist
SER_ASSERT_NOT_NULL(p_handle_count); //check if *p_handle_count exist
uint32_t index = SER_CMD_DATA_POS;
uint32_t status_code;
SER_ASSERT_LENGTH_LEQ(5, packet_len - index); //make sure that payload length is at least 5 bytes
uint16_dec(p_buf, packet_len, &index, p_conn_handle);
//decode handle table count with optional handle table
status_code = count16_cond_data16_dec(p_buf, packet_len, &index, pp_handles, p_handle_count);
SER_ASSERT(status_code == NRF_SUCCESS, status_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return status_code;
}
uint32_t ser_ble_gatts_char_pf_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_char_pf)
{
ble_gatts_char_pf_t * p_char_pf = (ble_gatts_char_pf_t *)p_void_char_pf;
SER_ASSERT_LENGTH_LEQ(7, buf_len - *p_index);
uint8_dec(p_buf, buf_len, p_index, &p_char_pf->format);
uint8_dec(p_buf, buf_len, p_index, (uint8_t *)&p_char_pf->exponent);
uint16_dec(p_buf, buf_len, p_index, &p_char_pf->unit);
uint8_dec(p_buf, buf_len, p_index, &p_char_pf->name_space);
uint16_dec(p_buf, buf_len, p_index, &p_char_pf->desc);
return NRF_SUCCESS;
}
uint32_t ble_gattc_evt_char_vals_read_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
uint32_t event_len = 0;
uint32_t error_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(10, packet_len);
event_len = (uint16_t) (offsetof(ble_evt_t, evt.gattc_evt.params.char_vals_read_rsp.values)) -
sizeof (ble_evt_hdr_t) +
uint16_decode(&p_buf[BLE_GATTC_EVT_CHAR_VALS_READ_RSP_LEN_POSITION]);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
else
{
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
*p_event_len = event_len;
}
p_event->header.evt_id = BLE_GATTC_EVT_CHAR_VALS_READ_RSP;
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.conn_handle));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.gatt_status));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.error_handle));
//Event structure for BLE_GATTC_EVT_CHAR_VALS_READ_RSP
error_code =
ble_gattc_evt_char_vals_read_rsp_t_dec(p_buf, packet_len, &index,
&(p_event->evt.gattc_evt.params.char_vals_read_rsp));
SER_ASSERT_LENGTH_EQ(index, packet_len);
return error_code;
}
uint32_t count16_cond_data16_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
uint16_t * * const pp_data,
uint16_t * const p_count)
{
uint16_t count = 0;
uint8_t is_present = 0;
uint16_t i;
SER_ASSERT_NOT_NULL(p_count);
SER_ASSERT_NOT_NULL(pp_data);
SER_ASSERT_NOT_NULL(*pp_data);
SER_ASSERT_LENGTH_LEQ(3, ((int32_t)buf_len - (*p_index)));
uint16_dec(p_buf, buf_len, p_index, &count);
if (count > *p_count)
{
return NRF_ERROR_DATA_SIZE;
}
SER_ASSERT_LENGTH_LEQ(count, *p_count);
uint8_dec(p_buf, buf_len, p_index, &is_present);
if (!is_present)
{
*pp_data = NULL;
return NRF_SUCCESS;
}
else
{
for (i = 0; i < count; i++ )
{
uint16_dec(p_buf, buf_len, p_index, &((&(**pp_data))[i]) );
}
*p_count = i;
}
return NRF_SUCCESS;
}
uint32_t ble_gap_evt_conn_param_update_request_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(SER_EVT_CONN_HANDLE_SIZE + 2, packet_len);
uint32_t event_len = (uint16_t) (offsetof(ble_evt_t, evt.gap_evt.params.conn_param_update_request)) +
sizeof (ble_gap_evt_conn_param_update_request_t) -
sizeof (ble_evt_hdr_t);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &p_event->evt.gap_evt.conn_handle);
uint16_dec(p_buf, packet_len, &index,
&p_event->evt.gap_evt.params.conn_param_update_request.conn_params.min_conn_interval);
uint16_dec(p_buf, packet_len, &index,
&p_event->evt.gap_evt.params.conn_param_update_request.conn_params.max_conn_interval);
uint16_dec(p_buf, packet_len, &index,
&p_event->evt.gap_evt.params.conn_param_update_request.conn_params.slave_latency);
uint16_dec(p_buf, packet_len, &index,
&p_event->evt.gap_evt.params.conn_param_update_request.conn_params.conn_sup_timeout);
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gatts_attr_context_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_attr_context)
{
uint32_t error_code = NRF_SUCCESS;
ble_gatts_attr_context_t * p_context = (ble_gatts_attr_context_t *) p_void_attr_context;
error_code = ble_uuid_t_dec(p_buf, buf_len, p_index, &(p_context->srvc_uuid));
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = ble_uuid_t_dec(p_buf, buf_len, p_index, &(p_context->char_uuid));
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = ble_uuid_t_dec(p_buf, buf_len, p_index, &(p_context->desc_uuid));
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
SER_ASSERT_LENGTH_LEQ(5, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &(p_context->srvc_handle));
uint16_dec(p_buf, buf_len, p_index, &(p_context->value_handle));
uint8_dec(p_buf, buf_len, p_index, &(p_context->type));
return error_code;
}
uint32_t ble_gattc_primary_services_discover_req_dec(uint8_t const * const p_buf,
uint16_t packet_len,
uint16_t * const p_conn_handle,
uint16_t * const p_start_handle,
ble_uuid_t * * const pp_srvc_uuid)
{
uint32_t index = SER_CMD_DATA_POS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(p_start_handle);
SER_ASSERT_NOT_NULL(pp_srvc_uuid);
SER_ASSERT_NOT_NULL(*pp_srvc_uuid);
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 2 + 2 + 1, packet_len);
uint16_dec(p_buf, packet_len, &index, p_conn_handle);
uint16_dec(p_buf, packet_len, &index, p_start_handle);
switch (p_buf[index++])
{
case SER_FIELD_NOT_PRESENT:
*pp_srvc_uuid = NULL;
break;
case SER_FIELD_PRESENT:
SER_ASSERT_LENGTH_LEQ(index + 2 + 1, packet_len);
uint16_dec(p_buf, packet_len, &index, &(*pp_srvc_uuid)->uuid);
uint8_dec(p_buf, packet_len, &index, &(*pp_srvc_uuid)->type);
break;
default:
return NRF_ERROR_INVALID_DATA;
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint32_t ble_uuid_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_uuid)
{
ble_uuid_t * p_uuid = (ble_uuid_t *)p_void_uuid;
SER_ASSERT_LENGTH_LEQ(3, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_uuid->uuid);
uint8_dec(p_buf, buf_len, p_index, &p_uuid->type);
return NRF_SUCCESS;
}
uint32_t ble_gattc_relationships_discover_req_dec(
uint8_t const * const p_buf,
uint16_t packet_len,
uint16_t * const p_conn_handle,
ble_gattc_handle_range_t * * const
pp_handle_range)
{
uint32_t index = SER_CMD_DATA_POS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(pp_handle_range);
SER_ASSERT_NOT_NULL(*pp_handle_range);
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 2 + 1, packet_len);
uint16_dec(p_buf, packet_len, &index, p_conn_handle);
switch (p_buf[index++])
{
case SER_FIELD_NOT_PRESENT:
*pp_handle_range = NULL;
break;
case SER_FIELD_PRESENT:
SER_ASSERT_LENGTH_LEQ(index + 2 + 2, packet_len);
uint16_dec(p_buf, packet_len, &index, &(*pp_handle_range)->start_handle);
uint16_dec(p_buf, packet_len, &index, &(*pp_handle_range)->end_handle);
break;
default:
return NRF_ERROR_INVALID_DATA;
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint32_t ble_gatts_write_authorize_params_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_struct)
{
ble_gatts_write_authorize_params_t * p_params =
(ble_gatts_write_authorize_params_t *) p_void_struct;
uint32_t error_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_params->gatt_status);
return error_code;
}
uint32_t ble_gattc_evt_desc_disc_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(SER_EVT_CONN_HANDLE_SIZE + 6, packet_len);
uint16_t tmp_conn_handle;
uint16_t tmp_gatt_status;
uint16_t tmp_error_handle;
uint16_t tmp_service_count;
uint16_dec(p_buf, packet_len, &index, &tmp_conn_handle);
uint16_dec(p_buf, packet_len, &index, &tmp_gatt_status);
uint16_dec(p_buf, packet_len, &index, &tmp_error_handle);
uint16_dec(p_buf, packet_len, &index, &tmp_service_count);
uint32_t event_len = offsetof(ble_evt_t, evt.gattc_evt.params.desc_disc_rsp) +
sizeof (uint16_t) + tmp_service_count * sizeof (ble_gattc_desc_t);
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GATTC_EVT_DESC_DISC_RSP;
p_event->header.evt_len = event_len;
p_event->evt.gattc_evt.conn_handle = tmp_conn_handle;
p_event->evt.gattc_evt.gatt_status = tmp_gatt_status;
p_event->evt.gattc_evt.error_handle = tmp_error_handle;
p_event->evt.gattc_evt.params.desc_disc_rsp.count = tmp_service_count;
SER_ASSERT_LENGTH_LEQ(index + (tmp_service_count * 5), packet_len);
for (uint16_t i = 0; i < tmp_service_count; i++)
{
uint16_dec(p_buf, packet_len, &index,
&p_event->evt.gattc_evt.params.desc_disc_rsp.descs[i].handle);
uint16_dec(p_buf, packet_len, &index,
&p_event->evt.gattc_evt.params.desc_disc_rsp.descs[i].uuid.uuid);
uint8_dec(p_buf, packet_len, &index,
&p_event->evt.gattc_evt.params.desc_disc_rsp.descs[i].uuid.type);
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
uint32_t ble_gatts_hvx_params_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_hvx_params)
{
ble_gatts_hvx_params_t * p_hvx_params = (ble_gatts_hvx_params_t *)p_void_hvx_params;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(2 + 1 + 2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_hvx_params->handle);
uint8_dec(p_buf, buf_len, p_index, &p_hvx_params->type);
uint16_dec(p_buf, buf_len, p_index, &p_hvx_params->offset);
SER_ASSERT_NOT_NULL(&p_hvx_params->p_len);
err_code = cond_len16_cond_data_dec(p_buf,
buf_len,
p_index,
&p_hvx_params->p_data,
&p_hvx_params->p_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gatts_attr_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_gatts_attr)
{
uint32_t err_code = NRF_SUCCESS;
ble_gatts_attr_t * p_gatts_attr = (ble_gatts_attr_t *)p_void_gatts_attr;
err_code = cond_field_dec(p_buf,
buf_len,
p_index,
(void * *)&p_gatts_attr->p_uuid,
ble_uuid_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
buf_len,
p_index,
(void * *)&p_gatts_attr->p_attr_md,
ble_gatts_attr_md_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_LEQ(4, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_gatts_attr->init_offs);
uint16_dec(p_buf, buf_len, p_index, &p_gatts_attr->max_len);
//init len move just before p_data to be able to use len16data decoder.
err_code = len16data_dec(p_buf,
buf_len,
p_index,
&p_gatts_attr->p_value,
&p_gatts_attr->init_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gap_sec_info_reply_req_dec(uint8_t const * const p_buf,
uint16_t packet_len,
uint16_t * p_conn_handle,
ble_gap_enc_info_t * * const pp_enc_info,
ble_gap_irk_t * * const pp_id_info,
ble_gap_sign_info_t * * const pp_sign_info)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(pp_enc_info);
SER_ASSERT_NOT_NULL(pp_id_info);
SER_ASSERT_NOT_NULL(pp_sign_info);
SER_ASSERT_NOT_NULL(*pp_enc_info);
SER_ASSERT_NOT_NULL(*pp_id_info);
SER_ASSERT_NOT_NULL(*pp_sign_info);
uint32_t index = SER_CMD_DATA_POS;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(2, packet_len - index);
uint16_dec(p_buf, packet_len, &index, p_conn_handle);
err_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_enc_info,
ble_gap_enc_info_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_id_info,
ble_gap_irk_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_sign_info,
ble_gap_sign_info_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ble_gattc_evt_char_vals_read_rsp_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_struct)
{
ble_gattc_evt_char_vals_read_rsp_t * p_read =
(ble_gattc_evt_char_vals_read_rsp_t *) p_void_struct;
uint32_t error_code = NRF_SUCCESS;
//Decode len
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &(p_read->len));
//Decode values
SER_ASSERT_LENGTH_LEQ(p_read->len, buf_len - *p_index);
memcpy(p_read->values, &p_buf[*p_index], p_read->len);
*p_index += p_read->len;
return error_code;
}
uint32_t ble_gattc_evt_write_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
uint32_t index = 0;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
SER_ASSERT_LENGTH_LEQ(13, packet_len);
uint16_t tmp_attr_len = uint16_decode(&(p_buf[11]));
uint32_t event_len = offsetof(ble_evt_t, evt.gattc_evt.params.write_rsp) +
sizeof (ble_gattc_evt_write_rsp_t) - 1 + tmp_attr_len;
if (p_event == NULL)
{
*p_event_len = event_len;
return NRF_SUCCESS;
}
SER_ASSERT(event_len <= *p_event_len, NRF_ERROR_DATA_SIZE);
p_event->header.evt_id = BLE_GATTC_EVT_WRITE_RSP;
p_event->header.evt_len = event_len;
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.conn_handle));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.gatt_status));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.error_handle));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.write_rsp.handle));
uint8_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.write_rsp.write_op));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.write_rsp.offset));
uint16_dec(p_buf, packet_len, &index, &(p_event->evt.gattc_evt.params.write_rsp.len));
SER_ASSERT_LENGTH_LEQ(index + tmp_attr_len, packet_len);
if (tmp_attr_len > 0)
{
memcpy(&(p_event->evt.gattc_evt.params.write_rsp.data[0]), &(p_buf[index]), tmp_attr_len);
index += tmp_attr_len;
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return NRF_SUCCESS;
}
