kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

update 

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@151 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Anthony Minessale 2005-12-14 20:22:19 +00:00
parent 645e48cb82
commit e16f28d529
6 changed files with 152 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/include/switch_event.h
View File

@ -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);

6
src/include/switch_types.h
View File

@ -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

4
src/mod/mod_event_test/mod_event_test.c
View File

@ -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 = {

2
src/switch_config.c
View File

@ -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';

22
src/switch_core.c
View File

@ -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();

134
src/switch_event.c
View File

@ -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"
};
SWITCH_DECLARE(char *) switch_event_name(switch_event_t event)
{
return EVENT_NAMES[event];
}
SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool)
{
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_DECLARE(switch_status) switch_event_fire_subclass(switch_event_t event, int subclass, char *data)
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);
for(e = event;; e = SWITCH_EVENT_ALL) {
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 == event || enp->event == SWITCH_EVENT_ALL) && (enp->subclass == subclass || enp->subclass < 0)) {
enp->callback(event, subclass, data);
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");
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 *new_event;
assert(ELOCK != NULL);
assert(EPOOL != NULL);
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;
}