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_gap_lesc_oob_data_get_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t * p_conn_handle,
ble_gap_lesc_p256_pk_t * * pp_pk_own,
ble_gap_lesc_oob_data_t * * pp_oobd_own)
{
uint32_t index = SER_CMD_HEADER_SIZE;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(pp_oobd_own);
SER_ASSERT_NOT_NULL(pp_pk_own);
err_code = uint16_t_dec(p_buf, packet_len, &index, p_conn_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, packet_len, &index, (void **)pp_pk_own, ble_gap_lesc_p256_pk_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, packet_len, &index, (void **)pp_oobd_own, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ble_uuid_vs_add_req_dec(uint8_t const * const p_buf,
uint16_t buf_len,
ble_uuid128_t * * const pp_uuid,
uint8_t * * const pp_uuid_type)
{
uint32_t index = SER_CMD_HEADER_SIZE;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(pp_uuid);
SER_ASSERT_NOT_NULL(pp_uuid_type);
SER_ASSERT_NOT_NULL(*pp_uuid);
SER_ASSERT_NOT_NULL(*pp_uuid_type);
uint32_t err_code;
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_uuid, ble_uuid128_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_uuid_type, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, buf_len);
return err_code;
}
uint32_t ble_gatts_service_add_req_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint8_t * const p_type,
ble_uuid_t * * const pp_uuid,
uint16_t * * const pp_handle)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_type);
SER_ASSERT_NOT_NULL(pp_uuid);
SER_ASSERT_NOT_NULL(*pp_uuid);
SER_ASSERT_NOT_NULL(pp_handle);
SER_ASSERT_NOT_NULL(*pp_handle);
uint32_t index = SER_CMD_DATA_POS;
uint32_t err_code;
SER_ASSERT_LENGTH_LEQ(3, buf_len - index);
err_code = uint8_t_dec(p_buf, buf_len, &index, p_type);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
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, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT(index == buf_len, NRF_ERROR_INVALID_LENGTH);
return err_code;
}
uint32_t ble_uuid_decode_req_dec(uint8_t const * const p_buf,
uint32_t const buf_len,
uint8_t * p_uuid_le_len,
uint8_t * * const pp_uuid_le,
ble_uuid_t * * const pp_uuid)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_uuid_le_len);
uint32_t err_code;
uint32_t index = 0;
uint8_t opcode = SD_BLE_UUID_DECODE;
SER_ASSERT_LENGTH_LEQ(1, ((int32_t)buf_len - index));
uint8_dec(p_buf, buf_len, &index, &opcode);
SER_ASSERT(opcode == SD_BLE_UUID_DECODE, NRF_ERROR_INVALID_DATA);
err_code = len8data_dec(p_buf, buf_len, &index, pp_uuid_le, p_uuid_le_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_uuid, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, buf_len);
return err_code;
}
uint32_t ble_uuid_decode_rsp_dec(uint8_t const * const p_buf,
uint32_t buf_len,
ble_uuid_t * * const pp_uuid,
uint32_t * const p_result_code)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t err_code;
uint32_t index = 0;
uint32_t decode_result = ser_ble_cmd_rsp_result_code_dec(p_buf,
&index,
buf_len,
SD_BLE_UUID_DECODE,
p_result_code);
if (decode_result != NRF_SUCCESS)
{
return decode_result;
}
if (*p_result_code != NRF_SUCCESS)
{
SER_ASSERT_LENGTH_EQ(index, buf_len);
return NRF_SUCCESS;
}
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);
SER_ASSERT_LENGTH_EQ(index, buf_len);
return err_code;
}
uint32_t ble_gatts_initial_user_handle_get_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t ** pp_handle,
uint32_t * const p_result_code)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t err_code;
uint32_t index = 0;
uint32_t decode_result = ser_ble_cmd_rsp_result_code_dec(p_buf,
&index,
packet_len,
SD_BLE_GATTS_INITIAL_USER_HANDLE_GET,
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;
}
err_code = cond_field_dec(p_buf, packet_len, &index, (void * *)pp_handle,
uint16_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint32_t ble_tx_buffer_count_get_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint8_t * * const pp_count,
uint32_t * const p_result_code)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t index = 0;
uint32_t err_code = ser_ble_cmd_rsp_result_code_dec(p_buf, &index, packet_len,
SD_BLE_TX_BUFFER_COUNT_GET, p_result_code);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
if (*p_result_code != NRF_SUCCESS)
{
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
err_code = cond_field_dec(p_buf, packet_len, &index, (void * *)pp_count, uint8_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint32_t ble_gap_authenticate_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t * const p_conn_handle,
ble_gap_sec_params_t * * const pp_sec_params)
{
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_sec_params);
SER_ASSERT_NOT_NULL(*pp_sec_params);
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_dec(p_buf, packet_len, &index, p_conn_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_sec_params,
ble_gap_sec_params_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ble_gap_sec_params_reply_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_gap_sec_keyset_t const * const p_sec_keyset,
uint32_t * const p_result_code)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t err_code = NRF_SUCCESS;
uint32_t index = 0;
err_code = ser_ble_cmd_rsp_result_code_dec(p_buf, &index, packet_len, SD_BLE_GAP_SEC_PARAMS_REPLY, p_result_code);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
if (*p_result_code != NRF_SUCCESS)
{
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
//SER_ASSERT_NOT_NULL(p_sec_keyset); // Removed after input from KC 2016-03-11
err_code = cond_field_dec(p_buf, packet_len, &index, (void **)&p_sec_keyset, ble_gap_sec_keyset_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ecb_block_encrypt_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
nrf_ecb_hal_data_t * p_ecb_data,
uint32_t * const p_result_code)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t index = 0;
uint32_t decode_result = ser_ble_cmd_rsp_result_code_dec(p_buf,
&index,
packet_len,
SD_ECB_BLOCK_ENCRYPT,
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;
}
uint32_t err_code = cond_field_dec(p_buf, packet_len, &index, (void **)&p_ecb_data, nrf_ecb_hal_data_t_out_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint32_t ble_gatts_hvx_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint32_t * const p_result_code,
uint16_t * * const pp_bytes_written)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
uint32_t err_code;
uint32_t index = 0;
uint32_t decode_result = ser_ble_cmd_rsp_result_code_dec(p_buf,
&index,
packet_len,
SD_BLE_GATTS_HVX,
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;
}
err_code = cond_field_dec(p_buf, packet_len, &index, (void * *)pp_bytes_written, uint16_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
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_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_gap_evt_lesc_dhkey_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 err_code = NRF_SUCCESS;
uint32_t conn_index;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_event_len);
// [minimal packet is: 'conn_handle' + 'p_pk_peer' SER_FIELD_NOT_PRESENT +
// 'oobd_req']
SER_ASSERT_LENGTH_LEQ(sizeof(uint16_t) + sizeof(uint8_t) + sizeof(uint8_t),
packet_len);
uint32_t event_len = offsetof (ble_gap_evt_t, params) + sizeof(uint8_t) + sizeof(uint8_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_len = event_len;
err_code = uint16_t_dec(p_buf, packet_len, &index, &p_event->evt.gap_evt.conn_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
// keyset is an extension of standard event data - used to synchronize keys at application
err_code = app_ble_gap_sec_context_find(p_event->evt.gap_evt.conn_handle, &conn_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
p_event->evt.gap_evt.params.lesc_dhkey_request.p_pk_peer = m_app_keys_table[conn_index].keyset.keys_peer.p_pk;
err_code = cond_field_dec(p_buf, packet_len, &index,
(void **)&p_event->evt.gap_evt.params.lesc_dhkey_request.p_pk_peer, ble_gap_lesc_p256_pk_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
uint8_t data;
err_code = uint8_t_dec(p_buf, packet_len, &index, &data);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
p_event->evt.gap_evt.params.lesc_dhkey_request.oobd_req = data & 0x01;
SER_ASSERT_LENGTH_EQ(index, packet_len);
*p_event_len = event_len;
return err_code;
}
uint32_t ble_gatts_descriptor_add_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t * const p_char_handle,
ble_gatts_attr_t * * const pp_attr,
uint16_t * * const pp_handle)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_char_handle);
SER_ASSERT_NOT_NULL(pp_attr);
SER_ASSERT_NOT_NULL(*pp_attr);
SER_ASSERT_NOT_NULL(pp_handle);
SER_ASSERT_NOT_NULL(*pp_handle);
uint32_t index = 0;
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 2 + 1, packet_len);
SER_ASSERT(p_buf[index] == SD_BLE_GATTS_DESCRIPTOR_ADD, NRF_ERROR_INVALID_PARAM);
index++;
uint16_dec(p_buf, packet_len, &index, p_char_handle);
uint32_t err_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_attr,
ble_gatts_attr_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf,
packet_len,
&index,
(void * *)pp_handle,
NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
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_enable_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_enable_params_t * * const pp_ble_enable_params)
{
uint32_t index = SER_CMD_DATA_POS;
uint32_t err_code;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(pp_ble_enable_params);
SER_ASSERT_NOT_NULL(*pp_ble_enable_params);
err_code = cond_field_dec(p_buf, packet_len, &index, (void * *)pp_ble_enable_params, ble_enable_params_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ble_gap_address_set_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint8_t * const p_addr_cycle_mode,
ble_gap_addr_t * * const pp_addr)
{
uint32_t index = SER_CMD_DATA_POS;
uint32_t err_code;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_addr_cycle_mode);
SER_ASSERT_NOT_NULL(pp_addr);
SER_ASSERT_NOT_NULL(*pp_addr);
uint8_dec(p_buf, packet_len, &index, (void *)p_addr_cycle_mode);
err_code = cond_field_dec(p_buf, packet_len, &index, (void * *)pp_addr, ble_gap_addr_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ble_gatts_value_get_rsp_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint8_t * * const pp_value,
uint16_t * * const pp_value_len,
uint32_t * const p_result_code)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_result_code);
SER_ASSERT_NOT_NULL(pp_value);
SER_ASSERT_NOT_NULL(pp_value_len);
uint32_t err_code;
uint32_t index = 0;
uint32_t decode_result = ser_ble_cmd_rsp_result_code_dec(p_buf, &index,
packet_len, SD_BLE_GATTS_VALUE_GET,
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;
}
uint16_t value_buffer_size = *(*pp_value_len);
err_code = cond_field_dec(p_buf, packet_len, &index, (void * *)pp_value_len, uint16_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
uint16_t value_len = (*pp_value_len) ? *(*pp_value_len) : 0;
err_code = buf_dec(p_buf, packet_len, &index, pp_value, value_buffer_size, value_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
uint32_t ble_common_enable_params_t_dec(uint8_t const * const p_buf,
uint32_t buf_len,
uint32_t * const p_index,
void * const p_void_common_enable_params)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_index);
SER_ASSERT_NOT_NULL(p_void_common_enable_params);
ble_common_enable_params_t * p_common_enable_params = (ble_common_enable_params_t *)p_void_common_enable_params;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_dec(p_buf, buf_len, p_index, &p_common_enable_params->vs_uuid_count);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, buf_len, p_index, (void **) &(p_common_enable_params->p_conn_bw_counts),
ble_conn_bw_counts_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ecb_block_encrypt_req_dec(uint8_t const * const p_buf,
uint32_t buf_len,
nrf_ecb_hal_data_t * * const pp_ecb_data)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(pp_ecb_data);
SER_ASSERT_NOT_NULL(*pp_ecb_data);
uint32_t index = 0;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(1, buf_len);
SER_ASSERT(p_buf[index] == SD_ECB_BLOCK_ENCRYPT, NRF_ERROR_INVALID_PARAM);
index++;
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_ecb_data, nrf_ecb_hal_data_t_in_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, buf_len);
return err_code;
}
uint32_t ble_gap_lesc_dhkey_reply_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
uint16_t * p_conn_handle,
ble_gap_lesc_dhkey_t * * pp_dhkey)
{
uint32_t index = SER_CMD_HEADER_SIZE;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(pp_dhkey);
err_code = uint16_t_dec(p_buf, packet_len, &index, p_conn_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, packet_len, &index, (void **)pp_dhkey, ble_gap_lesc_dhkey_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t temp_get_req_dec(uint8_t const * const p_buf,
uint32_t buf_len,
int32_t * * const pp_temp)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(pp_temp);
SER_ASSERT_NOT_NULL(*pp_temp);
uint32_t index = 0;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(1, buf_len);
SER_ASSERT(p_buf[index] == SD_TEMP_GET, NRF_ERROR_INVALID_PARAM);
index++;
err_code = cond_field_dec(p_buf, buf_len, &index, (void * *)pp_temp, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, buf_len);
return err_code;
}
uint32_t ble_gap_rssi_get_req_dec(uint8_t const * const p_buf,
uint16_t packet_len,
uint16_t * p_conn_handle,
int8_t * * const pp_rssi)
{
uint32_t index = SER_CMD_DATA_POS;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_conn_handle);
SER_ASSERT_NOT_NULL(pp_rssi);
SER_ASSERT_NOT_NULL(*pp_rssi);
SER_ASSERT_LENGTH_LEQ(3, packet_len);
err_code = uint16_t_dec(p_buf, packet_len, &index, p_conn_handle);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, packet_len, &index, (void **) pp_rssi, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_EQ(index, packet_len);
return err_code;
}
uint32_t ble_gap_adv_start_req_dec(uint8_t const * const p_buf,
uint32_t packet_len,
ble_gap_adv_params_t * * const pp_adv_params)
{
uint32_t index = 0, i = 0;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(pp_adv_params);
SER_ASSERT_NOT_NULL(*pp_adv_params);
SER_ASSERT_NOT_NULL((*pp_adv_params)->p_peer_addr);
SER_ASSERT_NOT_NULL((*pp_adv_params)->p_whitelist);
SER_ASSERT_NOT_NULL((*pp_adv_params)->p_whitelist->pp_addrs);
SER_ASSERT_NOT_NULL((*pp_adv_params)->p_whitelist->pp_irks);
for (i = 0; i < BLE_GAP_WHITELIST_ADDR_MAX_COUNT; i++)
{
SER_ASSERT_NOT_NULL((*pp_adv_params)->p_whitelist->pp_addrs[i]);
}
for (i = 0; i < BLE_GAP_WHITELIST_IRK_MAX_COUNT; i++)
{
SER_ASSERT_NOT_NULL((*pp_adv_params)->p_whitelist->pp_irks[i]);
}
/* Packet with variable length. */
/* For now check: opcode + indicator showing if ble_gap_adv_params_t struct is present. */
SER_ASSERT_LENGTH_LEQ(SER_CMD_HEADER_SIZE + 1, packet_len);
SER_ASSERT(p_buf[index] == SD_BLE_GAP_ADV_START, NRF_ERROR_INVALID_PARAM);
index++;
if (p_buf[index++] == SER_FIELD_PRESENT)
{
err_code = uint8_t_dec(p_buf, packet_len, &index, &((*pp_adv_params)->type));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, packet_len, &index, (void **) &((*pp_adv_params)->p_peer_addr), ble_gap_addr_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_dec(p_buf, packet_len, &index, &((*pp_adv_params)->fp));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_dec(p_buf, packet_len, &index, (void **) &((*pp_adv_params)->p_whitelist), ble_gap_whitelist_t_dec);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_dec(p_buf, packet_len, &index, &((*pp_adv_params)->interval));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_dec(p_buf, packet_len, &index, &((*pp_adv_params)->timeout));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_adv_ch_mask_t_dec(p_buf, packet_len, &index, &((*pp_adv_params)->channel_mask));
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
}
else
{
*pp_adv_params = NULL;
}
SER_ASSERT_LENGTH_EQ(index, packet_len);
return NRF_SUCCESS;
}
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;
}
