update

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@151 d0543943-73ff-0310-b7d9-9358b9ac24b2

diff --git a/src/include/switch_event.h b/src/include/switch_event.h
index 29ea30588c2117fb25784078390c78fc1f2f4a94..8603ca044e5b874b47dbad82597a72e3396c2c63 100644 (file)
--- a/src/include/switch_event.h
+++ b/src/include/switch_event.h
@@ -38,6 +38,13 @@ extern "C" {
 
 #include <switch.h>
 
+struct switch_event {
+       switch_event_t event;
+       int subclass;
+       char *data;
+       struct switch_event *next;
+};
+
 struct switch_event_node {
        char *id;
        switch_event_t event;
@@ -46,6 +53,7 @@ struct switch_event_node {
        struct switch_event_node *next;
 };
 
+SWITCH_DECLARE(switch_status) switch_event_shutdown(void);
 SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool);
 SWITCH_DECLARE(switch_status) switch_event_fire_subclass(switch_event_t event, int subclass, char *data);
 SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, int subclass, switch_event_callback_t callback);

diff --git a/src/include/switch_types.h b/src/include/switch_types.h
index 211cb9b7abf5fb5c61615924d9847aba5d7fdf56..27d29db49160d3996e6f090a3d74edf6ca1d8943 100644 (file)
--- a/src/include/switch_types.h
+++ b/src/include/switch_types.h
@@ -135,8 +135,10 @@ typedef enum {
        SWITCH_EVENT_ALL
 } switch_event_t;
 
+typedef struct switch_event switch_event;
 typedef struct switch_event_node switch_event_node;
-typedef void (*switch_event_callback_t)(switch_event_t, int, char *);
+typedef void (*switch_event_callback_t)(switch_event *);
+typedef apr_threadattr_t switch_threadattr_t;
 typedef struct switch_loadable_module switch_loadable_module;
 typedef struct switch_frame switch_frame;
 typedef struct switch_channel switch_channel;
@@ -275,6 +277,8 @@ typedef apr_hash_index_t switch_hash_index_t;
 #define switch_hash_first apr_hash_first
 #define switch_hash_next apr_hash_next
 #define switch_hash_this apr_hash_this
+#define switch_threadattr_create apr_threadattr_create
+#define switch_threadattr_detach_set apr_threadattr_detach_set
 
 #define SWITCH_FOPEN_READ APR_FOPEN_READ
 #define SWITCH_FOPEN_WRITE APR_FOPEN_WRITE

diff --git a/src/mod/mod_event_test/mod_event_test.c b/src/mod/mod_event_test/mod_event_test.c
index 5f1f82e49235271bd0fb9522ebe33495fe3c6ba8..2e21c771ea1d10ba433e3021d8fce4510e8f94ab 100644 (file)
--- a/src/mod/mod_event_test/mod_event_test.c
+++ b/src/mod/mod_event_test/mod_event_test.c
@@ -33,9 +33,9 @@
 
 static const char modname[] = "mod_event_test";
 
-static void event_handler (switch_event_t event, int subclass, char *data)
+static void event_handler (switch_event *event)
 {
-       switch_console_printf(SWITCH_CHANNEL_CONSOLE,"*** OK *** I got event [%s] subclass [%d] data [%s]\n", switch_event_name(event), subclass, data);
+       switch_console_printf(SWITCH_CHANNEL_CONSOLE,"*** OK *** I got event [%s] subclass [%d] data [%s]\n", switch_event_name(event->event), event->subclass, event->data);
 }
 
 static switch_loadable_module_interface event_test_module_interface = {

diff --git a/src/switch_config.c b/src/switch_config.c
index fcbd46558bc795358a3707ce73b9d97e83ab6387..e3014be383009bc7f3e0ea0e8f70dd9164d698f6 100644 (file)
--- a/src/switch_config.c
+++ b/src/switch_config.c
@@ -108,7 +108,7 @@ SWITCH_DECLARE(int) switch_config_next_pair(switch_config *cfg, char **var, char
                        *end = '\0';
                        end--;
                } else if ((end = strchr(*var, '\n'))) {
-                       if (*end - 1 == '\r') {
+                       if (*(end - 1) == '\r') {
                                end--;
                        }
                        *end = '\0';

diff --git a/src/switch_core.c b/src/switch_core.c
index ce62813506c8f9e3b3da1661615d3d0055bfb8cf..bd5a584de93402f642dd624f48dffd40018fe881 100644 (file)
--- a/src/switch_core.c
+++ b/src/switch_core.c
@@ -1350,9 +1350,9 @@ SWITCH_DECLARE(void *) switch_core_hash_find(switch_hash *hash, char *key)
 SWITCH_DECLARE(void) switch_core_launch_module_thread(switch_thread_start_t func, void *obj)
 {
        switch_thread *thread;
-       apr_threadattr_t *thd_attr;;
-       apr_threadattr_create(&thd_attr, runtime.memory_pool);
-       apr_threadattr_detach_set(thd_attr, 1);
+       switch_threadattr_t *thd_attr;;
+       switch_threadattr_create(&thd_attr, runtime.memory_pool);
+       switch_threadattr_detach_set(thd_attr, 1);
 
        switch_thread_create(&thread,
                                          thd_attr,
@@ -1388,9 +1388,9 @@ static void * SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *threa
 SWITCH_DECLARE(void) switch_core_session_thread_launch(switch_core_session *session)
 {
        switch_thread *thread;
-       apr_threadattr_t *thd_attr;;
-       apr_threadattr_create(&thd_attr, session->pool);
-       apr_threadattr_detach_set(thd_attr, 1);
+       switch_threadattr_t *thd_attr;;
+       switch_threadattr_create(&thd_attr, session->pool);
+       switch_threadattr_detach_set(thd_attr, 1);
 
        if (switch_thread_create(&thread,
                                                  thd_attr,
@@ -1406,9 +1406,9 @@ SWITCH_DECLARE(void) switch_core_session_thread_launch(switch_core_session *sess
 SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session *session, switch_thread_start_t func, void *obj)
 {
        switch_thread *thread;
-       apr_threadattr_t *thd_attr;;
-       apr_threadattr_create(&thd_attr, session->pool);
-       apr_threadattr_detach_set(thd_attr, 1);
+       switch_threadattr_t *thd_attr;;
+       switch_threadattr_create(&thd_attr, session->pool);
+       switch_threadattr_detach_set(thd_attr, 1);
 
        switch_thread_create(&thread,
                                          thd_attr,
@@ -1548,6 +1548,10 @@ SWITCH_DECLARE(switch_status) switch_core_init(void)
 
 SWITCH_DECLARE(switch_status) switch_core_destroy(void)
 {
+
+       switch_event_shutdown();
+       switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Closing Event Engine.\n");
+
        if (runtime.memory_pool) {
                apr_pool_destroy(runtime.memory_pool);
                apr_terminate();

diff --git a/src/switch_event.c b/src/switch_event.c
index fc1eef8bd124ff6f53727ecf790ab3f738459a60..17e133ed37ae6531a9f6de130f905bcbaef30720 100644 (file)
--- a/src/switch_event.c
+++ b/src/switch_event.c
@@ -31,9 +31,15 @@
  */
 #include <switch_event.h>
 
+static switch_event *EVENT_QUEUE_HEAD;
+static switch_event *EVENT_QUEUE_WORK;
 static switch_event_node *EVENT_NODES[SWITCH_EVENT_ALL+1] = {NULL};
 static switch_mutex_t *ELOCK = NULL;
+static switch_mutex_t *MUTEX = NULL;
 static switch_memory_pool *EPOOL = NULL;
+switch_thread_cond_t *COND;
+
+static int THREAD_RUNNING = 0;
 
 /* make sure this is synced with the switch_event_t enum in switch_types.h
    also never put any new ones before EVENT_ALL
@@ -48,40 +54,130 @@ static char *EVENT_NAMES[] = {
        "ALL"
 };
 
+static void * SWITCH_THREAD_FUNC switch_event_thread(switch_thread *thread, void *obj) 
+{
+       switch_event_node *enp;
+       switch_event *event = NULL, *out_event = NULL;
+       switch_event_t e;
+
+       assert(ELOCK != NULL);
+       assert(EPOOL != NULL);
+
+       THREAD_RUNNING = 1;
+       while(THREAD_RUNNING == 1) {
+               switch_thread_cond_wait(COND, MUTEX);
+
+               if (THREAD_RUNNING == 1) {
+                       switch_mutex_lock(ELOCK);
+                       /* <LOCKED> -----------------------------------------------*/
+                       EVENT_QUEUE_WORK = EVENT_QUEUE_HEAD;
+                       EVENT_QUEUE_HEAD = NULL;
+                       switch_mutex_unlock(ELOCK);
+                       /* </LOCKED> -----------------------------------------------*/
+               }
+
+               for(event = EVENT_QUEUE_WORK; event;) {
+                       out_event = event;
+                       event = event->next;
+                       out_event->next = NULL;
+                       if (THREAD_RUNNING == 1) {
+                               for(e = out_event->event;; e = SWITCH_EVENT_ALL) {
+                                       for(enp = EVENT_NODES[e]; enp; enp = enp->next) {
+                                               if ((enp->event == out_event->event || enp->event == SWITCH_EVENT_ALL) && (enp->subclass == out_event->subclass || enp->subclass < 0)) {
+                                                       enp->callback(out_event);
+                                               }
+                                       }
+               
+                                       if (e == SWITCH_EVENT_ALL) {
+                                               break;
+                                       }
+                               }
+                       }
+                       free(out_event->data);
+                       free(out_event);
+               }
+       }
+       THREAD_RUNNING = 0;
+       return NULL;
+}
+
+
 SWITCH_DECLARE(char *) switch_event_name(switch_event_t event)
 {
+       assert(ELOCK != NULL);
+       assert(EPOOL != NULL);
+
        return EVENT_NAMES[event];
 }
 
+SWITCH_DECLARE(switch_status) switch_event_shutdown(void)
+{
+       THREAD_RUNNING = -1;
+
+       switch_thread_cond_signal(COND);
+
+       while(THREAD_RUNNING) {
+               switch_yield(100);
+       }
+       return SWITCH_STATUS_SUCCESS;
+}
+
 SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool)
 {
+    switch_thread *thread;
+    switch_threadattr_t *thd_attr;;
+    switch_threadattr_create(&thd_attr, pool);
+    switch_threadattr_detach_set(thd_attr, 1);
+
+
        assert(pool != NULL);
        EPOOL = pool;
        switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Activate Eventing Engine.\n");
-       return switch_mutex_init(&ELOCK, SWITCH_MUTEX_NESTED, EPOOL);
+       switch_mutex_init(&ELOCK, SWITCH_MUTEX_NESTED, EPOOL);
+
+       switch_mutex_init(&MUTEX, SWITCH_MUTEX_NESTED, pool);
+       switch_thread_cond_create(&COND, pool); 
+       switch_mutex_lock(MUTEX);
+       
+    switch_thread_create(&thread,
+                                                thd_attr,
+                                                switch_event_thread,
+                                                NULL,
+                                                pool
+                                                );
+
+
+       return SWITCH_STATUS_SUCCESS;
+
 }
 
 SWITCH_DECLARE(switch_status) switch_event_fire_subclass(switch_event_t event, int subclass, char *data)
 {
-       switch_event_node *enp;
-       switch_event_t e;
+
+       switch_event *new_event;
 
        assert(ELOCK != NULL);
        assert(EPOOL != NULL);
 
-       for(e = event;; e = SWITCH_EVENT_ALL) {
-               for(enp = EVENT_NODES[e]; enp; enp = enp->next) {
-                       if ((enp->event == event || enp->event == SWITCH_EVENT_ALL) && (enp->subclass == subclass || enp->subclass < 0)) {
-                               enp->callback(event, subclass, data);
-                       }
-               }
-               
-               if (e == SWITCH_EVENT_ALL) {
-                       break;
-               }
-
+       if (!(new_event = malloc(sizeof(*new_event)))) {
+               return SWITCH_STATUS_MEMERR;
        }
 
+       memset(new_event, 0, sizeof(*new_event));
+       new_event->event = event;
+       new_event->subclass = subclass;
+       new_event->data = strdup(data ? data : "");
+       
+       switch_mutex_lock(ELOCK);
+       /* <LOCKED> -----------------------------------------------*/
+       if (EVENT_QUEUE_HEAD) {
+               new_event->next = EVENT_QUEUE_HEAD;
+       }
+       EVENT_QUEUE_HEAD = new_event;
+       switch_mutex_unlock(ELOCK);
+       /* </LOCKED> -----------------------------------------------*/
+       
+       switch_thread_cond_signal(COND);
        return SWITCH_STATUS_SUCCESS;
 }
 
@@ -93,6 +189,8 @@ SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event,
        assert(EPOOL != NULL);
 
        if (event <= SWITCH_EVENT_ALL && (event_node = switch_core_alloc(EPOOL, sizeof(switch_event_node)))) {
+               switch_mutex_lock(ELOCK);
+               /* <LOCKED> -----------------------------------------------*/
                event_node->id = switch_core_strdup(EPOOL, id);
                event_node->event = event;
                event_node->subclass = subclass;
@@ -101,6 +199,8 @@ SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event,
                        event_node->next = EVENT_NODES[event];
                }
                EVENT_NODES[event] = event_node;
+               switch_mutex_unlock(ELOCK);
+               /* </LOCKED> -----------------------------------------------*/
                return SWITCH_STATUS_SUCCESS;
        }