void
late_ack_tracker_free(AckTracker *s)
{
LateAckTracker *self = (LateAckTracker *)s;
guint32 count = ring_buffer_count(&self->ack_record_storage);
_drop_range(self, count);
ring_buffer_free(&self->ack_record_storage);
g_free(self);
}
gboolean
ring_buffer_drop(RingBuffer *self, guint32 n)
{
g_assert(self->buffer != NULL);
if (ring_buffer_count(self) < n)
return FALSE;
self->count -= n;
self->head = (self->head + n) % self->capacity;
return TRUE;
}
static void
test_init_buffer_state()
{
RingBuffer rb;
_ringbuffer_init(&rb);
assert_false(ring_buffer_is_full(&rb), "buffer should not be full");
assert_true(ring_buffer_is_empty(&rb), "buffer should be empty");
assert_true(ring_buffer_count(&rb) == 0, "buffer should be empty");
assert_true(ring_buffer_capacity(&rb) == capacity, "invalid buffer capacity");
ring_buffer_free(&rb);
}
static void
assert_test_data_idx_range_in(RingBuffer *rb, int start, int end)
{
TestData *td;
int i;
assert_true(ring_buffer_count(rb) == end-start+1, "invalid ringbuffer size; actual:%d, expected: %d", ring_buffer_count(rb), end-start);
for (i = start; i <= end; i++)
{
td = ring_buffer_element_at(rb, i - start);
assert_true(td->idx == i, "wrong order: idx:(%d) <-> td->idx(%d)", i, td->idx);
}
}
static void
test_drop_elements()
{
RingBuffer rb;
const int rb_capacity = 103;
const int drop = 31;
ring_buffer_alloc(&rb, sizeof(TestData), rb_capacity);
_ringbuffer_fill(&rb, rb_capacity, 1, TRUE);
ring_buffer_drop(&rb, drop);
assert_true(ring_buffer_count(&rb) == (rb_capacity - drop), "drop failed");
ring_buffer_free(&rb);
}
guint32
ring_buffer_get_continual_range_length(RingBuffer *self, RingBufferIsContinuousPredicate pred)
{
guint32 r = 0, i;
g_assert(self->buffer != NULL);
for (i = 0; i < ring_buffer_count(self); i++)
{
if (!pred(ring_buffer_element_at(self, i)))
{
break;
}
++r;
}
return r;
}
static void
test_element_at()
{
RingBuffer rb;
size_t i;
TestData *td;
_ringbuffer_init(&rb);
_ringbuffer_fill(&rb, capacity, 0, TRUE);
for ( i = 0; i < ring_buffer_count(&rb); i++ )
{
td = ring_buffer_element_at(&rb, i);
assert_true(td != NULL, "invalid element, i=%d", i);
assert_true(td->idx == i, "invalid order, actual=%d, expected=%d", td->idx, i);
}
ring_buffer_free(&rb);
}
static void
late_ack_tracker_free(AckTracker *s)
{
LateAckTracker *self = (LateAckTracker *)s;
AckTrackerOnAllAcked *handler = &self->on_all_acked;
if (handler->user_data_free_fn && handler->user_data)
{
handler->user_data_free_fn(handler->user_data);
}
guint32 count = ring_buffer_count(&self->ack_record_storage);
g_static_mutex_free(&self->storage_mutex);
_drop_range(self, count);
ring_buffer_free(&self->ack_record_storage);
g_free(self);
}
static void
test_ring_buffer_is_full()
{
RingBuffer rb;
int i;
TestData *last = NULL;
_ringbuffer_init(&rb);
for (i = 1; !ring_buffer_is_full(&rb); i++)
{
TestData *td = ring_buffer_push(&rb);
assert_true(td != NULL, "ring_buffer_push failed");
td->idx = i;
last = td;
}
assert_true(ring_buffer_count(&rb) == capacity, "buffer count(%d) is not equal to capacity(%d)", ring_buffer_count(&rb), capacity);
assert_true(last->idx == capacity, "buffer is not full, number of inserted items: %d, capacity: %d", last->idx, capacity);
ring_buffer_free(&rb);
}
u16 __mip_interface_parse_input_buffer(mip_interface *device_interface)
{
u16 i, ret;
mip_header *header_ptr = (mip_header*)device_interface->mip_packet;
parser_callback_ptr callback_function = NULL;
void *callback_user_ptr = NULL;
//Check that the parser is initialized
if(device_interface->state != MIP_INTERFACE_INITIALIZED)
return MIP_INTERFACE_ERROR;
///
//Are we searching for a start condition? Requires: SYNC byte 1 & 2, and a valid header
///
if(device_interface->mip_packet_byte_count < sizeof(mip_header))
{
///
//Get a start byte
///
while((device_interface->mip_packet_byte_count == 0) && ring_buffer_count(&device_interface->input_buffer))
{
ret = ring_buffer_read(&device_interface->input_buffer, &device_interface->mip_packet[0], 1);
//Found a potential start byte
if((ret == RING_BUFFER_OK) && (device_interface->mip_packet[0] == MIP_SYNC_BYTE1))
{
device_interface->mip_packet_byte_count = 1;
device_interface->parser_start_time = mip_sdk_get_time_ms();
}
}
///
//Get the rest of the header
///
if(device_interface->mip_packet_byte_count > 0)
{
//Need at least the size of (header - start_byte) in the buffer to start processing
if(ring_buffer_count(&device_interface->input_buffer) >= sizeof(mip_header) - 1)
{
//Try to get a header
for(i=0; i < sizeof(mip_header) - 1; i++)
{
ring_buffer_lookahead_read(&device_interface->input_buffer, i, &device_interface->mip_packet[i+1], 1);
}
//If the header is valid, then continue to the next step
if((header_ptr->sync2 == MIP_SYNC_BYTE2) &&
(header_ptr->payload_size + MIP_HEADER_SIZE + MIP_CHECKSUM_SIZE <= MIP_MAX_PACKET_SIZE))
{
device_interface->mip_packet_byte_count = sizeof(mip_header);
}
else
{
//Header not found
device_interface->parser_in_sync = 0;
device_interface->mip_packet_byte_count = 0;
device_interface->parser_headers_skipped++;
}
}
//Check for timeout on incoming packet
else
{
//If a timeout happens, we probably had a badly-formed packet, start over
if(__mip_interface_time_timeout(device_interface->parser_start_time, device_interface->packet_timeout) == MIP_INTERFACE_TIMEOUT)
{
device_interface->parser_timeouts++;
//Reset the parser
device_interface->mip_packet_byte_count = 0;
device_interface->parser_in_sync = 0;
}
}
}
}
///
//Header located, get the rest of the potential MIP packet
///
if(device_interface->mip_packet_byte_count >= sizeof(mip_header))
{
//Wait for the rest of the packet to be available in the buffer
if(ring_buffer_count(&device_interface->input_buffer) >= (sizeof(mip_header) - 1 + header_ptr->payload_size + MIP_CHECKSUM_SIZE))
{
//Get the remaining packet bytes
for(i=0; i < header_ptr->payload_size + MIP_CHECKSUM_SIZE; i++)
{
ring_buffer_lookahead_read(&device_interface->input_buffer, sizeof(mip_header) - 1 + i, &device_interface->mip_packet[MIP_HEADER_SIZE + i], 1);
}
///
//Valid MIP Packet Found
///
if(mip_is_checksum_valid(device_interface->mip_packet) == MIP_OK)
{
device_interface->mip_packet_byte_count += header_ptr->payload_size + MIP_CHECKSUM_SIZE;
//Trigger the callback with the valid packet
if(__mip_interface_find_callback(device_interface, header_ptr->descriptor_set, &callback_user_ptr, &callback_function) == MIP_INTERFACE_OK)
{
(*callback_function)(callback_user_ptr, device_interface->mip_packet, device_interface->mip_packet_byte_count, MIP_INTERFACE_CALLBACK_VALID_PACKET);
}
ring_buffer_consume_entries(&device_interface->input_buffer, device_interface->mip_packet_byte_count - 1);
device_interface->parser_in_sync = 1;
//Reset the parser
device_interface->mip_packet_byte_count = 0;
}
///
//Inalid MIP Packet: Bad checksum
///
else
{
//Trigger the callback with a bad checksum
if(__mip_interface_find_callback(device_interface, header_ptr->descriptor_set, &callback_user_ptr, &callback_function) == MIP_INTERFACE_OK)
{
(*callback_function)(callback_user_ptr, device_interface->mip_packet, device_interface->mip_packet_byte_count, MIP_INTERFACE_CALLBACK_CHECKSUM_ERROR);
}
if(device_interface->parser_in_sync)
{
device_interface->parser_num_bad_checksums++;
}
device_interface->parser_in_sync = 0;
}
//Reset the parser
device_interface->mip_packet_byte_count = 0;
}
//Check for timeout on incoming packet
else
{
//If a timeout happens, we probably had a bad-form packet, start over
if(__mip_interface_time_timeout(device_interface->parser_start_time, device_interface->packet_timeout) == MIP_INTERFACE_TIMEOUT)
{
//Trigger the callback with a timeout
if(__mip_interface_find_callback(device_interface, header_ptr->descriptor_set, &callback_user_ptr, &callback_function) == MIP_INTERFACE_OK)
{
(*callback_function)(callback_user_ptr, device_interface->mip_packet, device_interface->mip_packet_byte_count, MIP_INTERFACE_CALLBACK_TIMEOUT);
}
device_interface->parser_timeouts++;
device_interface->parser_in_sync = 0;
//Reset the parser
device_interface->mip_packet_byte_count = 0;
}
}
}
return MIP_INTERFACE_OK;
}
