my_device_handler/events.c

#include "events.h"
#include <stdlib.h>

events_queue *global_queue;

void global_queue_init(){
	global_queue = events_queue_new();
}


events_queue* events_queue_new(){
	events_queue* eq = malloc( sizeof( events_queue));
	eq->headptr = malloc( sizeof( struct event_list_head));
	init_events_queue( eq);
	return eq;
}

void init_events_queue( events_queue *queue){
	SLIST_INIT( queue->headptr);
	queue->events_last = NULL;
	queue->count = 0;
}

void add_to_events_queue( events_queue *queue, device_event* event){
	event_list_entry* entry = malloc( sizeof( event_list_entry));

	entry->event = event;

	if(SLIST_EMPTY( queue->headptr)){
		SLIST_INSERT_HEAD( queue->headptr, entry, entries);
	}
	else{
		SLIST_INSERT_AFTER( queue->events_last, entry, entries);
	}
	queue->events_last = entry;
	queue->count++;
}

void add_all_to_global_queue( events_queue *queue){
	while (!SLIST_EMPTY( queue->headptr)) {           /* List Deletion. */
		event_list_entry *list_entry = SLIST_FIRST( queue->headptr);
		add_to_events_queue( global_queue, list_entry->event);
		SLIST_REMOVE_HEAD( queue->headptr, entries);
		free(list_entry);
	}
	init_events_queue( queue);
}

int drain_events_into( device_event** events){

	event_list_entry *list_entry;
	device_event *current;
	int index = 0;
	int count = global_queue->count;

	if( count){
		*events = malloc( count * sizeof( device_event));

		while ( !SLIST_EMPTY( global_queue->headptr)) {
			list_entry = SLIST_FIRST( global_queue->headptr);
			current = list_entry->event;
			SLIST_REMOVE_HEAD( global_queue->headptr, entries);
			(*events)[index++] = *current;
			free(list_entry);
		}
		/*init_events_queue */
		init_events_queue( global_queue);
	}
	else{
		*events = NULL;
	}

	return count;
}