kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-05-31 10:46:27 +00:00
Code Issues Projects Releases Wiki Activity

FSCORE-379

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@13746 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Mathieu Rene 2009-06-10 06:39:08 +00:00
parent 8e1c188d40
commit 4348c7bca2
1 changed files with 117 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
src/mod/event_handlers/mod_erlang_event/mod_erlang_event.c
View File

@ -998,6 +998,7 @@ static listener_t* new_listener(struct ei_cnode_s *ec, int clientfd)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error\n");
return NULL; return NULL;
} }
memset(listener, 0, sizeof(*listener));
switch_thread_rwlock_create(&listener->rwlock, listener_pool); switch_thread_rwlock_create(&listener->rwlock, listener_pool);
switch_queue_create(&listener->event_queue, SWITCH_CORE_QUEUE_LEN, listener_pool); switch_queue_create(&listener->event_queue, SWITCH_CORE_QUEUE_LEN, listener_pool);
@ -1039,67 +1040,85 @@ static listener_t* new_outbound_listener(char* node)
return listener; return listener;
} }
static switch_status_t state_handler(switch_core_session_t *session)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_channel_state_t state = switch_channel_get_state(channel);
if (state >= CS_HANGUP) {
session_elem_t *session_element = switch_channel_get_private(channel, "_erlang_session_");
listener_t* listener = switch_channel_get_private(channel, "_erlang_listener_");
if (session_element && listener) {
remove_session_elem_from_listener(listener, session_element);
}
switch_core_event_hook_remove_state_change(session, state_handler);
}
return SWITCH_STATUS_SUCCESS;
}
session_elem_t *session_elem_create(listener_t* listener, switch_core_session_t *session)
{
/* create a session list element */
session_elem_t* session_element = switch_core_session_alloc(session, sizeof(*session_element));
switch_channel_t *channel = switch_core_session_get_channel(session);
memcpy(session_element->uuid_str, switch_core_session_get_uuid(session), SWITCH_UUID_FORMATTED_LENGTH);
switch_queue_create(&session_element->event_queue, SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
switch_mutex_init(&session_element->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
switch_channel_set_private(channel, "_erlang_session_", session_element);
switch_channel_set_private(channel, "_erlang_listener_", listener);
switch_core_event_hook_add_state_change(session, state_handler);
return session_element;
}
session_elem_t* attach_call_to_registered_process(listener_t* listener, char* reg_name, switch_core_session_t *session) session_elem_t* attach_call_to_registered_process(listener_t* listener, char* reg_name, switch_core_session_t *session)
{ {
/* create a session list element */ /* create a session list element */
session_elem_t* session_element = NULL; session_elem_t* session_element = session_elem_create(listener, session);
if (!(session_element = switch_core_session_alloc(session, sizeof(*session_element)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to allocate session element\n");
} else {
memcpy(session_element->uuid_str, switch_core_session_get_uuid(session), SWITCH_UUID_FORMATTED_LENGTH);
session_element->process.type = ERLANG_REG_PROCESS; session_element->process.type = ERLANG_REG_PROCESS;
session_element->process.reg_name = switch_core_strdup(switch_core_session_get_pool(session),reg_name); session_element->process.reg_name = switch_core_session_strdup(session, reg_name);
switch_set_flag(session_element, LFLAG_SESSION_ALIVE); switch_set_flag(session_element, LFLAG_SESSION_ALIVE);
switch_clear_flag(session_element, LFLAG_OUTBOUND_INIT);
switch_queue_create(&session_element->event_queue, SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
switch_mutex_init(&session_element->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
/* attach the session to the listener */ /* attach the session to the listener */
add_session_elem_to_listener(listener,session_element); add_session_elem_to_listener(listener,session_element);
}
return session_element; return session_element;
} }
session_elem_t* attach_call_to_pid(listener_t* listener, erlang_pid* pid, switch_core_session_t *session) session_elem_t* attach_call_to_pid(listener_t* listener, erlang_pid* pid, switch_core_session_t *session)
{ {
/* create a session list element */ /* create a session list element */
session_elem_t* session_element = NULL; session_elem_t* session_element = session_elem_create(listener, session);
if (!(session_element = switch_core_session_alloc(session, sizeof(*session_element)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to allocate session element\n");
} else {
memcpy(session_element->uuid_str, switch_core_session_get_uuid(session), SWITCH_UUID_FORMATTED_LENGTH);
session_element->process.type = ERLANG_PID; session_element->process.type = ERLANG_PID;
memcpy(&session_element->process.pid, pid, sizeof(erlang_pid)); memcpy(&session_element->process.pid, pid, sizeof(erlang_pid));
switch_set_flag(session_element, LFLAG_SESSION_ALIVE); switch_set_flag(session_element, LFLAG_SESSION_ALIVE);
switch_clear_flag(session_element, LFLAG_OUTBOUND_INIT);
switch_queue_create(&session_element->event_queue, SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
switch_mutex_init(&session_element->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
/* attach the session to the listener */ /* attach the session to the listener */
add_session_elem_to_listener(listener,session_element); add_session_elem_to_listener(listener,session_element);
ei_link(listener, ei_self(listener->ec), pid); ei_link(listener, ei_self(listener->ec), pid);
}
return session_element; return session_element;
} }
session_elem_t* attach_call_to_spawned_process(listener_t* listener, char *module, char *function, switch_core_session_t *session) session_elem_t* attach_call_to_spawned_process(listener_t* listener, char *module, char *function, switch_core_session_t *session)
{ {
/* create a session list element */ /* create a session list element */
session_elem_t* session_element=NULL; session_elem_t* session_element = session_elem_create(listener, session);
if (!(session_element = switch_core_session_alloc(session, sizeof(*session_element)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to allocate session element\n");
} else {
char hash[100]; char hash[100];
int i = 0; int i = 0;
void *p = NULL; void *p = NULL;
memcpy(session_element->uuid_str, switch_core_session_get_uuid(session), SWITCH_UUID_FORMATTED_LENGTH);
erlang_pid *pid; erlang_pid *pid;
erlang_ref ref; erlang_ref ref;
switch_set_flag(session_element, LFLAG_WAITING_FOR_PID); switch_set_flag(session_element, LFLAG_WAITING_FOR_PID);
switch_queue_create(&session_element->event_queue, SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
switch_mutex_init(&session_element->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
/* attach the session to the listener */ /* attach the session to the listener */
add_session_elem_to_listener(listener,session_element); add_session_elem_to_listener(listener,session_element);
@ -1152,13 +1171,14 @@ session_elem_t* attach_call_to_spawned_process(listener_t* listener, char *modul
session_element->process.type = ERLANG_PID; session_element->process.type = ERLANG_PID;
memcpy(&session_element->process.pid, pid, sizeof(erlang_pid)); memcpy(&session_element->process.pid, pid, sizeof(erlang_pid));
switch_set_flag(session_element, LFLAG_SESSION_ALIVE); switch_set_flag(session_element, LFLAG_SESSION_ALIVE);
switch_clear_flag(session_element, LFLAG_OUTBOUND_INIT); switch_clear_flag(session_element, LFLAG_OUTBOUND_INIT);
switch_clear_flag(session_element, LFLAG_WAITING_FOR_PID); switch_clear_flag(session_element, LFLAG_WAITING_FOR_PID);
ei_link(listener, ei_self(listener->ec), pid); ei_link(listener, ei_self(listener->ec), pid);
switch_safe_free(pid); /* malloced in handle_ref_tuple */ switch_safe_free(pid); /* malloced in handle_ref_tuple */
}
return session_element; return session_element;
} }