uint32_t handle_storage_rx_consistent(uint16_t handle, uint32_t timestamp)
{
if (handle == RBC_MESH_INVALID_HANDLE)
{
return NRF_ERROR_INVALID_ADDR;
}
uint16_t handle_index = handle_entry_get(handle, true);
if (handle_index == HANDLE_CACHE_ENTRY_INVALID)
{
return NRF_ERROR_NOT_FOUND;
}
uint16_t data_index = m_handle_cache[handle_index].data_entry;
if (data_index == DATA_CACHE_ENTRY_INVALID)
{
return NRF_ERROR_NOT_FOUND;
}
trickle_rx_consistent(&m_data_cache[data_index].trickle, timestamp);
return NRF_SUCCESS;
}
uint32_t mesh_srv_packet_process(packet_t* packet)
{
if (!is_initialized)
{
return NRF_ERROR_INVALID_STATE;
}
uint32_t error_code;
uint8_t handle = packet->data[MESH_PACKET_HANDLE_OFFSET];
uint16_t version = (packet->data[MESH_PACKET_VERSION_OFFSET] |
(((uint16_t) packet->data[MESH_PACKET_VERSION_OFFSET + 1]) << 8));
uint8_t* data = &packet->data[MESH_PACKET_DATA_OFFSET];
uint16_t data_len = packet->length - MESH_PACKET_DATA_OFFSET;
if (data_len > MAX_VALUE_LENGTH)
{
return NRF_ERROR_INVALID_LENGTH;
}
if (handle > g_mesh_service.value_count || handle == 0)
{
return NRF_ERROR_INVALID_ADDR;
}
mesh_char_metadata_t* ch_md = &g_mesh_service.char_metadata[handle - 1];
bool uninitialized = !(ch_md->flags & (1 << MESH_MD_FLAGS_INITIALIZED_POS));
if (uninitialized)
{
trickle_init(&ch_md->trickle);
}
if (ch_md->version_number != version)
{
trickle_rx_inconsistent(&ch_md->trickle);
}
/* new version */
uint16_t separation = (version >= ch_md->version_number)?
(version - ch_md->version_number) :
(-(ch_md->version_number - MESH_VALUE_LOLLIPOP_LIMIT) + (version - MESH_VALUE_LOLLIPOP_LIMIT) - MESH_VALUE_LOLLIPOP_LIMIT);
if ((ch_md->version_number < MESH_VALUE_LOLLIPOP_LIMIT && version >= ch_md->version_number) ||
(ch_md->version_number >= MESH_VALUE_LOLLIPOP_LIMIT && separation < (UINT16_MAX - MESH_VALUE_LOLLIPOP_LIMIT)/2) ||
uninitialized)
{
/* update value */
mesh_srv_char_val_set(handle, data, data_len, false);
ch_md->flags |= (1 << MESH_MD_FLAGS_INITIALIZED_POS);
ch_md->flags &= ~(1 << MESH_MD_FLAGS_IS_ORIGIN_POS);
ch_md->version_number = version;
/* Manually set originator address */
memcpy(&ch_md->last_sender_addr, &packet->sender, sizeof(ble_gap_addr_t));
rbc_mesh_event_t update_evt;
update_evt.event_type = ((uninitialized)?
RBC_MESH_EVENT_TYPE_NEW_VAL :
RBC_MESH_EVENT_TYPE_UPDATE_VAL);
update_evt.data_len = data_len;
update_evt.value_handle = handle;
update_evt.data = data;
memcpy(&update_evt.originator_address, &packet->sender, sizeof(ble_gap_addr_t));
rbc_mesh_event_handler(&update_evt);
#ifdef RBC_MESH_SERIAL
mesh_aci_rbc_event_handler(&update_evt);
#endif
}
else if (version == ch_md->version_number)
{
/* check for conflicting data */
uint16_t old_len = MAX_VALUE_LENGTH;
error_code = mesh_srv_char_val_get(handle, NULL, &old_len, NULL);
if (error_code != NRF_SUCCESS)
{
return error_code;
}
volatile bool conflicting = false;
if (packet->rx_crc != ch_md->crc &&
!(ch_md->flags & (1 << MESH_MD_FLAGS_IS_ORIGIN_POS)))
{
conflicting = true;
}
else if (old_len != data_len)
{
conflicting = true;
}
if (conflicting)
{
TICK_PIN(7);
rbc_mesh_event_t conflicting_evt;
conflicting_evt.event_type = RBC_MESH_EVENT_TYPE_CONFLICTING_VAL;
conflicting_evt.data_len = data_len;
conflicting_evt.value_handle = handle;
conflicting_evt.data = data;
memcpy(&conflicting_evt.originator_address, &packet->sender, sizeof(ble_gap_addr_t));
trickle_rx_inconsistent(&ch_md->trickle);
rbc_mesh_event_handler(&conflicting_evt);
#ifdef RBC_MESH_SERIAL
mesh_aci_rbc_event_handler(&conflicting_evt);
#endif
}
else
{
trickle_rx_consistent(&ch_md->trickle);
}
}
ch_md->crc = packet->rx_crc;
return NRF_SUCCESS;
}
