uint32_t cond_len16_cond_data_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
uint8_t * * const pp_data,
uint16_t * * const pp_len)
{
SER_ASSERT_NOT_NULL(pp_len);
SER_ASSERT_NOT_NULL(*pp_len);
SER_ASSERT_NOT_NULL(pp_data);
SER_ASSERT_NOT_NULL(*pp_data);
SER_ASSERT_LENGTH_LEQ(2, ((int32_t)buf_len - (*p_index)));
uint8_t is_present = 0;
uint8_dec(p_buf, buf_len, p_index, &is_present);
if (!is_present)
{
*pp_len = NULL; //if length field is not present
(*p_index)++; //then data can not be present
*pp_data = NULL;
return NRF_SUCCESS;
}
else
{
return len16data_dec(p_buf, buf_len, p_index, pp_data, *pp_len);
}
}
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_gap_device_name_set_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_gap_conn_sec_mode_t * * const pp_write_perm,
uint8_t * * const pp_dev_name,
uint16_t * const p_dev_name_len)
{
SER_ASSERT_NOT_NULL(p_buf); //check if *p_buf is allocated
SER_ASSERT_NOT_NULL(pp_write_perm); //check if *pp_write_perm exist
SER_ASSERT_NOT_NULL(pp_dev_name); //check if *pp_dev_name exist
SER_ASSERT_NOT_NULL(p_dev_name_len); //check if *p_dev_name_len exist
uint32_t index = SER_CMD_DATA_POS;
uint32_t status_code;
SER_ASSERT_LENGTH_LEQ(4, packet_len - index); //make sure that payload is at least 4 bytes
//decode optional write permissions field
status_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_write_perm,
ble_gap_conn_sec_mode_dec);
SER_ASSERT(status_code == NRF_SUCCESS, status_code);
//decode optional device name field
status_code = len16data_dec(p_buf, packet_len, &index, pp_dev_name, p_dev_name_len);
SER_ASSERT(status_code == NRF_SUCCESS, status_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return status_code;
}
uint32_t ble_gattc_write_params_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_write)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_index);
SER_ASSERT_NOT_NULL(p_void_write);
uint32_t err_code = NRF_SUCCESS;
ble_gattc_write_params_t * p_write = (ble_gattc_write_params_t *)p_void_write;
err_code = uint8_t_dec(p_buf, buf_len, p_index, &(p_write->write_op));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_dec(p_buf, buf_len, p_index, &(p_write->flags));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_dec(p_buf, buf_len, p_index, &(p_write->handle));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_dec(p_buf, buf_len, p_index, &(p_write->offset));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = len16data_dec(p_buf, buf_len, p_index, &(p_write->p_value), &(p_write->len));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gatts_evt_rw_authorize_request_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_evt_t * const p_event,
uint32_t * const p_event_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
uint32_t index = 0;
uint32_t err_code = NRF_SUCCESS;
uint32_t in_event_len = *p_event_len;
*p_event_len = offsetof(ble_evt_t, evt.gatts_evt.params) - sizeof (ble_evt_hdr_t);
uint16_t conn_handle;
err_code = uint16_t_dec(p_buf, packet_len, &index, &conn_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
void * p_void_authorize_request = NULL;
if (p_event != NULL)
{
SER_ASSERT_LENGTH_LEQ(*p_event_len, in_event_len);
p_event->header.evt_id = BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST;
p_event->evt.gatts_evt.conn_handle = conn_handle;
p_void_authorize_request = &(p_event->evt.gatts_evt.params.authorize_request);
}
uint32_t tmp_event_len = in_event_len - *p_event_len;
err_code = ble_gatts_evt_rw_authorize_request_t_dec(p_buf,
packet_len,
&index,
&tmp_event_len,
p_void_authorize_request);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_event_len += tmp_event_len;
if(p_event != NULL)
{
if((p_event->evt.gatts_evt.params.authorize_request.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) && (p_event->evt.gatts_evt.params.authorize_request.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW))
{
uint32_t conn_index;
if(app_ble_user_mem_context_find(p_event->evt.gatts_evt.conn_handle, &conn_index) != NRF_ERROR_NOT_FOUND)
{
err_code = len16data_dec(p_buf, packet_len, &index, &m_app_user_mem_table[conn_index].mem_block.p_mem, &m_app_user_mem_table[conn_index].mem_block.len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
}
}
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
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_gatts_char_md_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_char_md)
{
uint32_t err_code = NRF_SUCCESS;
ble_gatts_char_md_t * p_char_md = (ble_gatts_char_md_t *)p_void_char_md;
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint8_t temp8 = p_buf[*p_index];
p_char_md->char_props.broadcast = temp8 >> 0;
p_char_md->char_props.read = temp8 >> 1;
p_char_md->char_props.write_wo_resp = temp8 >> 2;
p_char_md->char_props.write = temp8 >> 3;
p_char_md->char_props.notify = temp8 >> 4;
p_char_md->char_props.indicate = temp8 >> 5;
p_char_md->char_props.auth_signed_wr = temp8 >> 6;
temp8 = p_buf[*p_index + 1];
p_char_md->char_ext_props.reliable_wr = temp8 >> 0;
p_char_md->char_ext_props.wr_aux = temp8 >> 1;
*p_index += 2;
SER_ASSERT_LENGTH_LEQ(2, buf_len - *p_index);
uint16_dec(p_buf, buf_len, p_index, &p_char_md->char_user_desc_max_size);
err_code = len16data_dec(p_buf,
buf_len,
p_index,
&p_char_md->p_char_user_desc,
&p_char_md->char_user_desc_size);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
buf_len,
p_index,
(void * *)&p_char_md->p_char_pf,
ser_ble_gatts_char_pf_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
buf_len,
p_index,
(void * *)&p_char_md->p_user_desc_md,
ble_gatts_attr_md_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
buf_len,
p_index,
(void * *)&p_char_md->p_cccd_md,
ble_gatts_attr_md_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
buf_len,
p_index,
(void * *)&p_char_md->p_sccd_md,
ble_gatts_attr_md_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}