1 files changed, 335 insertions, 0 deletions

diff --git a/toxcore/event.c b/toxcore/event.c
new file mode 100755
index 00000000..17e68c87
--- /dev/null
+++ b/toxcore/event.c
@@ -0,0 +1,335 @@
+/**  event.c
+ * 
+ *   Copyright (C) 2013 Tox project All Rights Reserved.
+ *
+ *   This file is part of Tox.
+ *
+ *   Tox is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   Tox is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Tox. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * 
+ *   Report bugs/suggestions to me ( mannol ) at either #tox-dev @ freenode.net:6667 or
+ *   my email: eniz_vukovic@hotmail.com
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include "event.h"
+
+#include "util.h"
+
+#define _GNU_SOURCE
+
+#include <assert.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <inttypes.h>
+#include <pthread.h>
+
+#define RUN_IN_THREAD(func, args) {   pthread_t _tid; \
+    pthread_create(&_tid, NULL, func, args); assert( pthread_detach(_tid) == 0 ); }
+
+#define LOCK(event_handler)   pthread_mutex_lock  (&event_handler->mutex)
+#define UNLOCK(event_handler) pthread_mutex_unlock(&event_handler->mutex)
+
+#define FREQUENCY 10000
+
+#define inline__ inline __attribute__((always_inline))
+
+
+typedef struct _EventContainer {
+    void*      (*func)(void*);
+    void*      func_args;
+    unsigned   timeout;
+    long long  id;
+
+} EventContainer;
+
+typedef struct _EventHandler {
+    EventContainer* timed_events;
+    size_t          timed_events_count;
+
+    int             running;
+
+    pthread_mutex_t mutex;
+
+} EventHandler;
+
+int throw_event( void* (func)(void*), void* arg );
+int reset_timer_event ( int id, uint32_t timeout );
+int throw_timer_event ( void* (func)(void*), void* arg, unsigned timeout);
+int cancel_timer_event ( int id );
+int execute_timer_event ( int id );
+
+struct _Event event =
+{
+    throw_event,
+    /* reset_timer_event */ NULL,
+    throw_timer_event,
+    cancel_timer_event,
+    /*execute_timer_event*/ NULL
+};
+
+/*
+ * Random functions used by this file
+ */
+void clear_events (EventContainer** event_container, size_t* counter)
+{
+    free(*event_container );
+
+    *event_container = NULL;
+    *counter = 0;
+}
+
+int pop_id ( EventContainer** event_container, size_t* counter, int id )
+{
+    if ( !*event_container || !*counter || !id )
+        return -1;
+
+    EventContainer* _it = *event_container;
+    int i;
+
+    for ( i = *counter; i; -- i ){
+        if ( _it->id == id ) { /* Hit! */
+            break;
+        }
+        ++_it;
+    }
+
+    if ( i ) {
+        for ( ; i; -- i ){ *_it = *(_it + 1); ++_it; }
+        -- (*counter );
+        *event_container = realloc(*event_container, sizeof(EventContainer) * (*counter )); /* resize */
+
+        return 0;
+
+    }
+
+    /* not found here */
+
+    return -1;
+}
+
+void push_event ( EventContainer** container, size_t* counter, void* (func)(void*), void* arg )
+{
+    (*container ) = realloc((*container ), sizeof(EventContainer) * ((*counter ) + 1));
+    assert((*container ) != NULL);
+
+    (*container )[*counter].func = func;
+    (*container )[*counter].func_args = arg;
+    (*container )[*counter].timeout = 0;
+    (*container )[*counter].id = 0;
+
+    (*counter )++;
+}
+
+void reorder_events ( size_t counter, EventContainer* container, unsigned timeout )
+{
+    if ( counter > 1 ) {
+
+        int i = counter - 1;
+
+        /* start from behind excluding last added member */
+        EventContainer* _it = &container[i - 1];
+
+        EventContainer _last_added = container[i];
+
+        for ( ; i; --i ) {
+            if ( _it->timeout > timeout ){
+                *(_it + 1) = *_it;
+                *_it = _last_added; -- _it;
+            }
+        }
+
+    }
+}
+
+/* ============================================= */
+
+/* main poll for event execution */
+void* event_poll( void* arg )
+{
+    EventHandler* _event_handler = arg;
+
+    while ( _event_handler->running )
+    {
+
+    LOCK( _event_handler );
+
+        if ( _event_handler->timed_events ){
+
+            uint32_t _time = ((uint32_t)(current_time() / 1000));
+
+            if ( _event_handler->timed_events[0].timeout < _time ) {
+
+                RUN_IN_THREAD ( _event_handler->timed_events[0].func,
+                                _event_handler->timed_events[0].func_args );
+
+                pop_id(&_event_handler->timed_events,
+                       &_event_handler->timed_events_count,
+                         _event_handler->timed_events[0].id);
+
+            }
+
+        }
+
+    UNLOCK( _event_handler );
+
+        usleep(FREQUENCY);
+    }
+
+LOCK( _event_handler );
+
+    clear_events(&_event_handler->timed_events, &_event_handler->timed_events_count);
+
+UNLOCK( _event_handler );
+
+    _event_handler->running = -1;
+    pthread_exit(NULL);
+}
+
+int throw_event( void* (func)(void*), void* arg )
+{
+    pthread_t _tid;
+    int _rc =
+    pthread_create(&_tid, NULL, func, arg );
+
+    return (0 != _rc ) ? _rc : pthread_detach(_tid);
+}
+
+EventHandler event_handler;
+
+/* Place and order array of timers */
+int throw_timer_event ( void* (func)(void*), void* arg, unsigned timeout)
+{
+    static int _unique_id = 1;
+
+    push_event(&event_handler.timed_events, &(event_handler.timed_events_count), func, arg );
+
+    size_t _counter = event_handler.timed_events_count;
+
+    event_handler.timed_events[_counter - 1].timeout = timeout + ((uint32_t)(current_time() / 1000));
+    event_handler.timed_events[_counter - 1].id = _unique_id; ++_unique_id;
+
+
+    /* reorder */
+
+    reorder_events(_counter, event_handler.timed_events, timeout );
+
+    return _unique_id - 1;
+}
+
+int execute_timer_event ( int id )
+{
+    int _status;
+
+LOCK((&event_handler));
+    EventContainer* _it = event_handler.timed_events;
+
+    int _i = event_handler.timed_events_count;
+
+    /* Find it and execute */
+    for ( ; _i; _i-- ) {
+        if ( _it->id == id ) {
+            RUN_IN_THREAD ( _it->func, _it->func_args );
+            break;
+        }
+        ++_it;
+    }
+
+    /* Now remove it from the queue */
+
+    if ( _i ) {
+        for ( ; _i; -- _i ){ *_it = *(_it + 1); ++_it; }
+        -- event_handler.timed_events_count;
+
+        event_handler.timed_events = realloc
+            (event_handler.timed_events, sizeof(EventContainer) * event_handler.timed_events_count); /* resize */
+
+        _status = 0;
+
+    }
+    else _status = -1;
+
+UNLOCK((&event_handler));
+
+    return _status;
+}
+
+int reset_timer_event ( int id, uint32_t timeout )
+{
+    int _status;
+
+LOCK((&event_handler));
+
+    EventContainer* _it = event_handler.timed_events;
+
+    int _i = event_handler.timed_events_count;
+
+    /* Find it and change */
+    for ( ; _i; _i-- ) {
+        if ( _it->id == id ) {
+            _it->timeout = timeout + ((uint32_t)(current_time() / 1000));
+            break;
+        }
+        ++_it;
+    }
+
+    _status = _i ? -1 : 0;
+
+UNLOCK((&event_handler));
+
+    return _status;
+}
+
+/* Remove timer from array */
+inline__ int cancel_timer_event ( int id )
+{
+    return pop_id (&event_handler.timed_events, &event_handler.timed_events_count, id );
+}
+
+
+/* Initialization and termination of event polls
+ * This will be run at the beginning and the end of the program execution.
+ * I think that's the best way to do it.
+ */
+
+void __attribute__((constructor)) init_event_poll ()
+{
+    event_handler.timed_events = NULL;
+    event_handler.timed_events_count = 0;
+
+    event_handler.running = 1;
+
+    pthread_mutex_init(&event_handler.mutex, NULL);
+
+    RUN_IN_THREAD(event_poll, &event_handler);
+}
+
+void __attribute__((destructor)) terminate_event_poll()
+{
+    /* Exit thread */
+    event_handler.running = 0;
+    
+    /* Keep the global until thread exits */
+    while (event_handler.running > -1) { 
+        event_handler.running;
+        usleep(FREQUENCY*2);   
+    }
+        
+    pthread_mutex_destroy( &event_handler.mutex );
+}