#include <switch.h>
#include <switch_event.h>
#include "tpl.h"
#include "private/switch_core_pvt.h"

Include dependency graph for switch_event.c:

Data Structures
struct	switch_event_node
	A node to store binded events. More...

struct	switch_event_subclass
	A registered custom event subclass. More...

struct	switch_event_channel_sub_node_s

struct	switch_event_channel_sub_node_head_s

struct	event_channel_data_t

struct	alias_node_s

struct	la_node_s

struct	switch_live_array_s

Macros
#define	DISPATCH_QUEUE_LEN 10000

#define	MAX_DISPATCH_VAL 64

#define	ALLOC(size) malloc(size)

#define	DUP(str) my_dup(str)

#define	FREE(ptr) switch_safe_free(ptr)

#define	SWITCH_SERIALIZED_EVENT_MAP "S(iiisss)A(S(ss))"

#define	resize(l)

Typedefs
typedef struct switch_event_channel_sub_node_s	switch_event_channel_sub_node_t

typedef struct switch_event_channel_sub_node_head_s	switch_event_channel_sub_node_head_t

typedef struct alias_node_s	alias_node_t

typedef struct la_node_s	la_node_t

Functions
static void	unsub_all_switch_event_channel (void)

static char *	my_dup (const char *s)

static int	switch_events_match (switch_event_t event, switch_event_node_t node)

static void *SWITCH_THREAD_FUNC	switch_event_deliver_thread (switch_thread_t thread, void obj)

static void	switch_event_deliver_thread_pool (switch_event_t **event)

static void *SWITCH_THREAD_FUNC	switch_event_dispatch_thread (switch_thread_t thread, void obj)

static switch_status_t	switch_event_queue_dispatch_event (switch_event_t **eventp)

void	switch_event_deliver (switch_event_t **event)
	Deliver an event to all of the registered event listeners. More...

switch_status_t	switch_event_running (void)
	Determine if the event system has been initialized. More...

const char *	switch_event_name (switch_event_types_t event)
	Render the name of an event id enumeration. More...

switch_status_t	switch_name_event (const char name, switch_event_types_t type)
	return the event id that matches a given event name More...

switch_status_t	switch_event_free_subclass_detailed (const char owner, const char subclass_name)

switch_status_t	switch_event_reserve_subclass_detailed (const char owner, const char subclass_name)
	Reserve a subclass name for private use with a custom event. More...

void	switch_core_memory_reclaim_events (void)

switch_status_t	switch_event_shutdown (void)
	Stop the eventing system. More...

static void	check_dispatch (void)

void	switch_event_launch_dispatch_threads (uint32_t max)

switch_status_t	switch_event_init (switch_memory_pool_t *pool)
	Start the eventing system. More...

switch_status_t	switch_event_create_subclass_detailed (const char file, const char func, int line, switch_event_t *event, switch_event_types_t event_id, const char subclass_name)
	Create an event. More...

switch_status_t	switch_event_set_priority (switch_event_t *event, switch_priority_t priority)
	Set the priority of an event. More...

switch_status_t	switch_event_rename_header (switch_event_t event, const char header_name, const char *new_header_name)

switch_event_header_t *	switch_event_get_header_ptr (switch_event_t event, const char header_name)
	Retrieve a header value from an event. More...

char *	switch_event_get_header_idx (switch_event_t event, const char header_name, int idx)

char *	switch_event_get_body (switch_event_t *event)
	Retrieve the body value from an event. More...

switch_status_t	switch_event_del_header_val (switch_event_t event, const char header_name, const char *val)

static switch_event_header_t *	new_header (const char *header_name)

int	switch_event_add_array (switch_event_t event, const char var, const char *val)

static switch_status_t	switch_event_base_add_header (switch_event_t event, switch_stack_t stack, const char header_name, char *data)

switch_status_t	switch_event_add_header (switch_event_t event, switch_stack_t stack, const char header_name, const char *fmt,...)

switch_status_t	switch_event_set_subclass_name (switch_event_t event, const char subclass_name)

switch_status_t	switch_event_add_header_string (switch_event_t event, switch_stack_t stack, const char header_name, const char *data)
	Add a string header to an event. More...

switch_status_t	switch_event_set_body (switch_event_t event, const char body)

switch_status_t	switch_event_add_body (switch_event_t event, const char fmt,...)

void	switch_event_destroy (switch_event_t **event)
	Destroy an event. More...

void	switch_event_merge (switch_event_t event, switch_event_t tomerge)

switch_status_t	switch_event_dup (switch_event_t *event, switch_event_t todup)
	Duplicate an event. More...

switch_status_t	switch_event_dup_reply (switch_event_t *event, switch_event_t todup)

switch_status_t	switch_event_binary_deserialize (switch_event_t eventp, void data, switch_size_t len, switch_bool_t destroy)
	Render a string representation of an event suitable for printing or network transport. More...

switch_status_t	switch_event_binary_serialize (switch_event_t event, void data, switch_size_t len)

switch_status_t	switch_event_serialize (switch_event_t event, char *str, switch_bool_t encode)

switch_status_t	switch_event_create_array_pair (switch_event_t event, char names, char **vals, int len)

switch_status_t	switch_event_create_brackets (char data, char a, char b, char c, switch_event_t event, char *new_data, switch_bool_t dup)

switch_status_t	switch_event_create_json (switch_event_t *event, const char json)

switch_status_t	switch_event_serialize_json_obj (switch_event_t event, cJSON *json)

switch_status_t	switch_event_serialize_json (switch_event_t event, char *str)

static switch_xml_t	add_xml_header (switch_xml_t xml, char name, char value, int offset)

switch_xml_t	switch_event_xmlize (switch_event_t event, const char fmt,...)

void	switch_event_prep_for_delivery_detailed (const char file, const char func, int line, switch_event_t *event)

switch_status_t	switch_event_fire_detailed (const char file, const char func, int line, switch_event_t *event, void user_data)
	Fire an event with full arguement list. More...

switch_status_t	switch_event_get_custom_events (switch_console_callback_match_t **matches)

switch_status_t	switch_event_bind_removable (const char id, switch_event_types_t event, const char subclass_name, switch_event_callback_t callback, void user_data, switch_event_node_t *node)
	Bind an event callback to a specific event. More...

switch_status_t	switch_event_bind (const char id, switch_event_types_t event, const char subclass_name, switch_event_callback_t callback, void *user_data)
	Bind an event callback to a specific event. More...

switch_status_t	switch_event_unbind_callback (switch_event_callback_t callback)

switch_status_t	switch_event_unbind (switch_event_node_t **node)
	Unbind a bound event consumer. More...

switch_status_t	switch_event_create_pres_in_detailed (char file, char func, int line, const char proto, const char login, const char from, const char from_domain, const char status, const char event_type, const char alt_event_type, int event_count, const char unique_id, const char channel_state, const char answer_state, const char *call_direction)

char *	switch_event_expand_headers_check (switch_event_t event, const char in, switch_event_t var_list, switch_event_t api_list, uint32_t recur)

char *	switch_event_build_param_string (switch_event_t event, const char prefix, switch_hash_t *vars_map)

int	switch_event_check_permission_list (switch_event_t list, const char name)

void	switch_json_add_presence_data_cols (switch_event_t event, cJSON json, const char *prefix)

void	switch_event_add_presence_data_cols (switch_channel_t channel, switch_event_t event, const char *prefix)

static uint32_t	switch_event_channel_unsub_head (switch_event_channel_func_t func, switch_event_channel_sub_node_head_t *head)

static uint32_t	switch_event_channel_unsub_channel (switch_event_channel_func_t func, const char *event_channel)

static switch_status_t	switch_event_channel_sub_channel (const char *event_channel, switch_event_channel_func_t func, switch_event_channel_id_t id)

static uint32_t	_switch_event_channel_broadcast (const char event_channel, const char broadcast_channel, cJSON json, const char key, switch_event_channel_id_t id)

static void	destroy_ecd (event_channel_data_t **ecdP)

static void	ecd_deliver (event_channel_data_t **ecdP)

static void *SWITCH_THREAD_FUNC	switch_event_channel_deliver_thread (switch_thread_t thread, void obj)

switch_status_t	switch_event_channel_broadcast (const char event_channel, cJSON json, const char key, switch_event_channel_id_t id)

uint32_t	switch_event_channel_unbind (const char *event_channel, switch_event_channel_func_t func)

switch_status_t	switch_event_channel_bind (const char event_channel, switch_event_channel_func_t func, switch_event_channel_id_t id)

switch_bool_t	switch_event_channel_permission_verify (const char cookie, const char event_channel)

void	switch_event_channel_permission_modify (const char cookie, const char event_channel, switch_bool_t set)

void	switch_event_channel_permission_clear (const char *cookie)

static switch_status_t	la_broadcast (switch_live_array_t la, cJSON *json)

switch_status_t	switch_live_array_visible (switch_live_array_t *la, switch_bool_t visible, switch_bool_t force)

switch_status_t	switch_live_array_clear (switch_live_array_t *la)

switch_status_t	switch_live_array_bootstrap (switch_live_array_t la, const char sessid, switch_event_channel_id_t channel_id)

switch_status_t	switch_live_array_destroy (switch_live_array_t **live_arrayP)

switch_bool_t	switch_live_array_isnew (switch_live_array_t *la)

switch_bool_t	switch_live_array_clear_alias (switch_live_array_t la, const char event_channel, const char *name)

switch_bool_t	switch_live_array_add_alias (switch_live_array_t la, const char event_channel, const char *name)

switch_status_t	switch_live_array_create (const char event_channel, const char name, switch_event_channel_id_t channel_id, switch_live_array_t **live_arrayP)

cJSON *	switch_live_array_get (switch_live_array_t la, const char name)

cJSON *	switch_live_array_get_idx (switch_live_array_t *la, int idx)

void	switch_live_array_lock (switch_live_array_t *la)

void	switch_live_array_unlock (switch_live_array_t *la)

switch_status_t	switch_live_array_del (switch_live_array_t la, const char name)

switch_status_t	switch_live_array_add (switch_live_array_t la, const char name, int index, cJSON **obj, switch_bool_t duplicate)

void	switch_live_array_set_user_data (switch_live_array_t la, void user_data)

void	switch_live_array_set_command_handler (switch_live_array_t *la, switch_live_array_command_handler_t command_handler)

void	switch_live_array_parse_json (cJSON *json, switch_event_channel_id_t channel_id)

Variables
struct {
switch_event_channel_id_t ID

switch_thread_rwlock_t * rwlock

switch_hash_t * hash

switch_hash_t * perm_hash

switch_hash_t * lahash

switch_mutex_t * lamutex

}	event_channel_manager

static unsigned int	MAX_DISPATCH = MAX_DISPATCH_VAL

static unsigned int	SOFT_MAX_DISPATCH = 0

static char	guess_ip_v4 [80] = ""

static char	guess_ip_v6 [80] = ""

static switch_event_node_t *	EVENT_NODES [SWITCH_EVENT_ALL+1] = { NULL }

static switch_thread_rwlock_t *	RWLOCK = NULL

static switch_mutex_t *	BLOCK = NULL

static switch_mutex_t *	POOL_LOCK = NULL

static switch_memory_pool_t *	RUNTIME_POOL = NULL

static switch_memory_pool_t *	THRUNTIME_POOL = NULL

static switch_thread_t *	EVENT_DISPATCH_QUEUE_THREADS [MAX_DISPATCH_VAL] = { 0 }

static uint8_t	EVENT_DISPATCH_QUEUE_RUNNING [MAX_DISPATCH_VAL] = { 0 }

static switch_queue_t *	EVENT_DISPATCH_QUEUE = NULL

static switch_queue_t *	EVENT_CHANNEL_DISPATCH_QUEUE = NULL

static switch_mutex_t *	EVENT_QUEUE_MUTEX = NULL

static switch_hash_t *	CUSTOM_HASH = NULL

static int	THREAD_COUNT = 0

static int	DISPATCH_THREAD_COUNT = 0

static int	EVENT_CHANNEL_DISPATCH_THREAD_COUNT = 0

static int	EVENT_CHANNEL_DISPATCH_THREAD_STARTING = 0

static int	SYSTEM_RUNNING = 0

static uint64_t	EVENT_SEQUENCE_NR = 0

static char *	EVENT_NAMES []

static int	PENDING = 0

Macro Definition Documentation

#define ALLOC ( size ) malloc(size)

Definition at line 120 of file switch_event.c.

Referenced by new_header(), and switch_event_create_subclass_detailed().

#define DISPATCH_QUEUE_LEN 10000

Definition at line 42 of file switch_event.c.

Referenced by check_dispatch(), switch_event_channel_broadcast(), and switch_event_queue_dispatch_event().

#define DUP ( str ) my_dup(str)

Definition at line 123 of file switch_event.c.

Referenced by new_header(), switch_event_add_header_string(), switch_event_base_add_header(), switch_event_bind_removable(), switch_event_create_subclass_detailed(), switch_event_dup(), switch_event_rename_header(), switch_event_reserve_subclass_detailed(), switch_event_set_body(), and switch_event_set_subclass_name().

#define FREE ( ptr ) switch_safe_free(ptr)

Definition at line 126 of file switch_event.c.

Referenced by switch_event_base_add_header(), switch_event_del_header_val(), switch_event_destroy(), switch_event_free_subclass_detailed(), switch_event_rename_header(), switch_event_shutdown(), switch_event_unbind(), and switch_event_unbind_callback().

#define MAX_DISPATCH_VAL 64

Definition at line 80 of file switch_event.c.

Referenced by switch_event_dispatch_thread().

#define resize ( l )

Value:

{\
char *dp;\
olen += (len + l + block);\
cpos = c - data;\
if ((dp = realloc(data, olen))) {\
        data = dp;\
        c = data + cpos;\
	memset(c, 0, olen - cpos);\
 }}                           \

Definition at line 2185 of file switch_event.c.

Referenced by switch_event_expand_headers_check().

#define SWITCH_SERIALIZED_EVENT_MAP "S(iiisss)A(S(ss))"

Definition at line 1396 of file switch_event.c.

Referenced by switch_event_binary_deserialize(), and switch_event_binary_serialize().

Typedef Documentation

typedef struct alias_node_s alias_node_t

typedef struct la_node_s la_node_t

typedef struct switch_event_channel_sub_node_head_s switch_event_channel_sub_node_head_t

typedef struct switch_event_channel_sub_node_s switch_event_channel_sub_node_t

Function Documentation

static uint32_t _switch_event_channel_broadcast	(	const char *	event_channel,
		const char *	broadcast_channel,
		cJSON *	json,
		const char *	key,
		switch_event_channel_id_t	id
	)

static

Definition at line 2841 of file switch_event.c.

References event_channel_manager, switch_event_channel_sub_node_s::func, switch_event_channel_sub_node_s::id, switch_event_channel_sub_node_s::next, switch_event_channel_sub_node_head_s::node, switch_core_hash_find(), switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

Referenced by ecd_deliver().

 {
         switch_event_channel_sub_node_t *np;
         switch_event_channel_sub_node_head_t *head;
         uint32_t x = 0;
 
         switch_thread_rwlock_rdlock(event_channel_manager.rwlock);
         if ((head = switch_core_hash_find(event_channel_manager.hash, event_channel))) {
                 for (np = head->node; np; np = np->next) {
                         if (np->id == id) {
                                 continue;
                         }
                         
                         np->func(broadcast_channel, json, key, id);
                         x++;
                 }
         }
         switch_thread_rwlock_unlock(event_channel_manager.rwlock);
 
         return x;
 }

static switch_xml_t add_xml_header	(	switch_xml_t	xml,
		char *	name,
		char *	value,
		int	offset
	)

static

Definition at line 1833 of file switch_event.c.

References memset(), switch_assert, switch_url_encode(), switch_xml_add_child_d, and switch_xml_set_txt_d.

Referenced by switch_event_xmlize().

 {
         switch_xml_t header = switch_xml_add_child_d(xml, name, offset);
 
         if (header) {
                 switch_size_t encode_len = (strlen(value) * 3) + 1;
                 char *encode_buf = malloc(encode_len);
 
                 switch_assert(encode_buf);
 
                 memset(encode_buf, 0, encode_len);
                 switch_url_encode((char *) value, encode_buf, encode_len);
                 switch_xml_set_txt_d(header, encode_buf);
                 free(encode_buf);
         }
 
         return header;
 }

static void check_dispatch ( void )

static

Definition at line 604 of file switch_event.c.

References BLOCK, DISPATCH_QUEUE_LEN, EVENT_DISPATCH_QUEUE, MAX_DISPATCH, switch_cond_next(), switch_event_launch_dispatch_threads(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_create(), THREAD_COUNT, and THRUNTIME_POOL.

Referenced by switch_event_fire_detailed(), switch_event_init(), and switch_event_launch_dispatch_threads().

 {
         if (!EVENT_DISPATCH_QUEUE) {
                 switch_mutex_lock(BLOCK);
                 
                 if (!EVENT_DISPATCH_QUEUE) {
                         switch_queue_create(&EVENT_DISPATCH_QUEUE, DISPATCH_QUEUE_LEN * MAX_DISPATCH, THRUNTIME_POOL);
                         switch_event_launch_dispatch_threads(1);
                         
                         while (!THREAD_COUNT) {
                                 switch_cond_next();
                         }
                 }
                 switch_mutex_unlock(BLOCK);
         }            
 }

static void destroy_ecd ( event_channel_data_t ** ecdP )

static

Definition at line 2864 of file switch_event.c.

References cJSON_Delete(), event_channel_data_t::event_channel, event_channel_data_t::json, event_channel_data_t::key, and switch_safe_free.

Referenced by ecd_deliver(), switch_event_channel_broadcast(), and switch_event_channel_deliver_thread().

 {
         event_channel_data_t *ecd = *ecdP;
         *ecdP = NULL;
 
         switch_safe_free(ecd->event_channel);
         switch_safe_free(ecd->key);
         if (ecd->json) {
                 cJSON_Delete(ecd->json);
                 ecd->json = NULL;
         }
 
         free(ecd);
 }

static void ecd_deliver ( event_channel_data_t ** ecdP )

static

Definition at line 2879 of file switch_event.c.

References _switch_event_channel_broadcast(), destroy_ecd(), event_channel_data_t::event_channel, event_channel_data_t::id, event_channel_data_t::json, event_channel_data_t::key, and SWITCH_EVENT_CHANNEL_GLOBAL.

Referenced by switch_event_channel_deliver_thread().

 {
         event_channel_data_t *ecd = *ecdP;
         char *p;
 
         *ecdP = NULL;
 
         _switch_event_channel_broadcast(ecd->event_channel, ecd->event_channel, ecd->json, ecd->key, ecd->id);
         
         if ((p = strchr(ecd->event_channel, '.'))) {
                 char *main_channel = strdup(ecd->event_channel);
                 p = strchr(main_channel, '.');
                 *p = '\0';
                 _switch_event_channel_broadcast(main_channel, ecd->event_channel, ecd->json, ecd->key, ecd->id);
                 free(main_channel);
         }
         _switch_event_channel_broadcast(SWITCH_EVENT_CHANNEL_GLOBAL, ecd->event_channel, ecd->json, ecd->key, ecd->id);
 
         destroy_ecd(&ecd);
 }

static switch_status_t la_broadcast	(	switch_live_array_t *	la,
		cJSON **	json
	)

static

Definition at line 3107 of file switch_event.c.

References switch_live_array_s::aliases, switch_live_array_s::channel_id, cJSON_CreateString(), cJSON_Duplicate(), cJSON_GetObjectItem(), cJSON_ReplaceItemInObject(), alias_node_s::event_channel, switch_live_array_s::event_channel, switch_live_array_s::mutex, alias_node_s::name, alias_node_s::next, switch_event_channel_broadcast(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_live_array_add(), switch_live_array_clear(), switch_live_array_del(), and switch_live_array_visible().

 {
         alias_node_t *np;
 
         if (la->aliases) {
                 switch_mutex_lock(la->mutex);
                 for (np = la->aliases; np; np = np->next) {
                         cJSON *dup = cJSON_Duplicate(*json, 1);
                         cJSON *data = cJSON_GetObjectItem(dup, "data");
 
                         cJSON_ReplaceItemInObject(dup, "eventChannel", cJSON_CreateString(np->event_channel));
                         cJSON_ReplaceItemInObject(data, "name", cJSON_CreateString(np->name));
                         
                         switch_event_channel_broadcast(np->event_channel, &dup, __FILE__, la->channel_id);
                 }
                 switch_mutex_unlock(la->mutex);
         }
 
         return switch_event_channel_broadcast(la->event_channel, json, __FILE__, la->channel_id);
 
 }

static char* my_dup ( const char * s )

static

Definition at line 110 of file switch_event.c.

References switch_assert.

 {
         size_t len = strlen(s) + 1;
         void *new = malloc(len);
         switch_assert(new);
 
         return (char *) memcpy(new, s, len);
 }

static switch_event_header_t* new_header ( const char * header_name )

static

Definition at line 899 of file switch_event.c.

References ALLOC, DUP, memset(), switch_event_header::name, switch_assert, switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_event_base_add_header().

 {
         switch_event_header_t *header;
 
 #ifdef SWITCH_EVENT_RECYCLE
                 void *pop;
                 if (EVENT_HEADER_RECYCLE_QUEUE && switch_queue_trypop(EVENT_HEADER_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) {
                         header = (switch_event_header_t *) pop;
                 } else {
 #endif
                         header = ALLOC(sizeof(*header));
                         switch_assert(header);
 #ifdef SWITCH_EVENT_RECYCLE
                 }
 #endif
 
                 memset(header, 0, sizeof(*header));
                 header->name = DUP(header_name);
 
                 return header;
 
 }

switch_status_t switch_event_add_body	(	switch_event_t *	event,
		const char *	fmt,
			...
	)

Definition at line 1208 of file switch_event.c.

References switch_safe_free, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and switch_vasprintf().

Referenced by switch_event_create_json().

 {
         int ret = 0;
         char *data;
 
         va_list ap;
         if (fmt) {
                 va_start(ap, fmt);
                 ret = switch_vasprintf(&data, fmt, ap);
                 va_end(ap);
 
                 if (ret == -1) {
                         return SWITCH_STATUS_GENERR;
                 } else {
                         switch_safe_free(event->body);
                         event->body = data;
                         return SWITCH_STATUS_SUCCESS;
                 }
         } else {
                 return SWITCH_STATUS_GENERR;
         }
 }

switch_status_t switch_event_add_header	(	switch_event_t *	event,
		switch_stack_t	stack,
		const char *	header_name,
		const char *	fmt,
			...
	)

Definition at line 1160 of file switch_event.c.

References switch_event_base_add_header(), SWITCH_STATUS_MEMERR, and switch_vasprintf().

Referenced by switch_event_create_pres_in_detailed(), and switch_event_prep_for_delivery_detailed().

 {
         int ret = 0;
         char *data;
         va_list ap;
 
         va_start(ap, fmt);
         ret = switch_vasprintf(&data, fmt, ap);
         va_end(ap);
 
         if (ret == -1) {
                 return SWITCH_STATUS_MEMERR;
         }
 
         return switch_event_base_add_header(event, stack, header_name, data);
 }

static switch_status_t switch_event_base_add_header	(	switch_event_t *	event,
		switch_stack_t	stack,
		const char *	header_name,
		char *	data
	)

static

Definition at line 968 of file switch_event.c.

References switch_event_header::array, DUP, EF_UNIQ_HEADERS, FREE, switch_event_header::hash, switch_event_header::idx, switch_event::last_header, switch_event_header::name, new_header(), switch_event_header::next, switch_assert, switch_ci_hashfunc_default(), switch_event_add_array(), switch_event_del_header, switch_event_get_header_ptr(), switch_event_set_body(), switch_safe_free, switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STACK_PUSH, SWITCH_STACK_TOP, SWITCH_STACK_UNSHIFT, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_event_header::value, and zstr.

Referenced by switch_event_add_header(), and switch_event_add_header_string().

 {
         switch_event_header_t *header = NULL;
         switch_ssize_t hlen = -1;
         int exists = 0, fly = 0;
         char *index_ptr;
         int index = 0;
         char *real_header_name = NULL;
 
 
         if (!strcmp(header_name, "_body")) {
                 switch_event_set_body(event, data);
         }
 
         if ((index_ptr = strchr(header_name, '['))) {
                 index_ptr++;
                 index = atoi(index_ptr);
                 real_header_name = DUP(header_name);
                 if ((index_ptr = strchr(real_header_name, '['))) {
                         *index_ptr++ = '\0';
                 }
                 header_name = real_header_name;
         }
 
         if (index_ptr || (stack & SWITCH_STACK_PUSH) || (stack & SWITCH_STACK_UNSHIFT)) {
 
                 if (!(header = switch_event_get_header_ptr(event, header_name)) && index_ptr) {
 
                         header = new_header(header_name);
 
                         if (switch_test_flag(event, EF_UNIQ_HEADERS)) {
                                 switch_event_del_header(event, header_name);
                         }
 
                         fly++;
                 }
 
                 if (header || (header = switch_event_get_header_ptr(event, header_name))) {
 
                         if (index_ptr) {
                                 if (index > -1 && index <= 4000) {
                                         if (index < header->idx) {
                                                 FREE(header->array[index]);
                                                 header->array[index] = DUP(data);
                                         } else {
                                                 int i;
                                                 char **m;
 
                                                 m = realloc(header->array, sizeof(char *) * (index + 1));
                                                 switch_assert(m);
                                                 header->array = m;
                                                 for (i = header->idx; i < index; i++) {
                                                         m[i] = DUP("");
                                                 }
                                                 m[index] = DUP(data);
                                                 header->idx = index + 1;
                                                 if (!fly) {
                                                         exists = 1;
                                                 }
 
                                                 goto redraw;
                                         }
                                 }
                                 goto end;
                         } else {
                                 if ((stack & SWITCH_STACK_PUSH) || (stack & SWITCH_STACK_UNSHIFT)) {
                                         exists++;
                                         stack &= ~(SWITCH_STACK_TOP | SWITCH_STACK_BOTTOM);
                                 } else {
                                         header = NULL;
                                 }
                         }
                 }
         }
 
 
         if (!header) {
 
                 if (zstr(data)) {
                         switch_event_del_header(event, header_name);
                         FREE(data);
                         goto end;
                 }
 
                 if (switch_test_flag(event, EF_UNIQ_HEADERS)) {
                         switch_event_del_header(event, header_name);
                 }
 
                 if (!strncmp(data, "ARRAY::", 7)) {
                         switch_event_add_array(event, header_name, data);
                         FREE(data);
                         goto end;
                 }
 
 
                 header = new_header(header_name);
         }
 
         if ((stack & SWITCH_STACK_PUSH) || (stack & SWITCH_STACK_UNSHIFT)) {
                 char **m = NULL;
                 switch_size_t len = 0;
                 char *hv;
                 int i = 0, j = 0;
 
                 if (header->value && !header->idx) {
                         m = malloc(sizeof(char *));
                         switch_assert(m);
                         m[0] = header->value;
                         header->value = NULL;
                         header->array = m;
                         header->idx++;
                         m = NULL;
                 }
 
                 i = header->idx + 1;
                 m = realloc(header->array, sizeof(char *) * i);
                 switch_assert(m);
 
                 if ((stack & SWITCH_STACK_PUSH)) {
                         m[header->idx] = data;
                 } else if ((stack & SWITCH_STACK_UNSHIFT)) {
                         for (j = header->idx; j > 0; j--) {
                                 m[j] = m[j-1];
                         }
                         m[0] = data;
                 }
 
                 header->idx++;
                 header->array = m;
 
         redraw:
                 len = 0;
                 for(j = 0; j < header->idx; j++) {
                         len += strlen(header->array[j]) + 2;
                 }
 
                 if (len) {
                         len += 8;
                         hv = realloc(header->value, len);
                         switch_assert(hv);
                         header->value = hv;
 
                         if (header->idx > 1) {
                                 switch_snprintf(header->value, len, "ARRAY::");
                         } else {
                                 *header->value = '\0';
                         }
 
                         hv += strlen(header->value);
                         for(j = 0; j < header->idx; j++) {
                                 if (j > 0) {
                                         memcpy(hv, "|:", 2);
                                         hv += 2;
                                 }
                                 memcpy(hv, header->array[j], strlen(header->array[j]));
                                 hv += strlen(header->array[j]);
                         }
                         *hv = '\0';
                 }
 
         } else {
                 switch_safe_free(header->value);
                 header->value = data;
         }
 
         if (!exists) {
                 header->hash = switch_ci_hashfunc_default(header->name, &hlen);
 
                 if ((stack & SWITCH_STACK_TOP)) {
                         header->next = event->headers;
                         event->headers = header;
                         if (!event->last_header) {
                                 event->last_header = header;
                         }
                 } else {
                         if (event->last_header) {
                                 event->last_header->next = header;
                         } else {
                                 event->headers = header;
                                 header->next = NULL;
                         }
                         event->last_header = header;
                 }
         }
 
  end:
 
         switch_safe_free(real_header_name);
 
         return SWITCH_STATUS_SUCCESS;
 }

static void* SWITCH_THREAD_FUNC switch_event_channel_deliver_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 2900 of file switch_event.c.

References destroy_ecd(), ecd_deliver(), EVENT_CHANNEL_DISPATCH_THREAD_COUNT, EVENT_CHANNEL_DISPATCH_THREAD_STARTING, EVENT_QUEUE_MUTEX, SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_os_yield(), switch_queue_pop(), switch_queue_trypop(), SWITCH_STATUS_SUCCESS, SYSTEM_RUNNING, and THREAD_COUNT.

Referenced by switch_event_channel_broadcast().

 {
         switch_queue_t *queue = (switch_queue_t *) obj;
         void *pop = NULL;
         event_channel_data_t *ecd = NULL;
 
         switch_mutex_lock(EVENT_QUEUE_MUTEX);
         THREAD_COUNT++;
         EVENT_CHANNEL_DISPATCH_THREAD_COUNT++;
         EVENT_CHANNEL_DISPATCH_THREAD_STARTING = 0;
         switch_mutex_unlock(EVENT_QUEUE_MUTEX);
 
         while(SYSTEM_RUNNING) {
                 
                 if (switch_queue_pop(queue, &pop) != SWITCH_STATUS_SUCCESS) {
                         continue;
                 }
 
                 if (!pop) {
                         break;
                 }
 
                 ecd = (event_channel_data_t *) pop;
                 ecd_deliver(&ecd);
                 switch_os_yield();
         }
 
         while (switch_queue_trypop(queue, &pop) == SWITCH_STATUS_SUCCESS) {
                 ecd = (event_channel_data_t *) pop;
                 destroy_ecd(&ecd);
         }
 
         switch_mutex_lock(EVENT_QUEUE_MUTEX);
         THREAD_COUNT--;
         EVENT_CHANNEL_DISPATCH_THREAD_COUNT--;
         switch_mutex_unlock(EVENT_QUEUE_MUTEX);
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Event Channel Dispatch Thread Ended.\n");
         return NULL;    
 }

static switch_status_t switch_event_channel_sub_channel	(	const char *	event_channel,
		switch_event_channel_func_t	func,
		switch_event_channel_id_t	id
	)

static

Definition at line 2776 of file switch_event.c.

References switch_event_channel_sub_node_head_s::event_channel, event_channel_manager, switch_event_channel_sub_node_s::func, switch_event_channel_sub_node_s::head, switch_event_channel_sub_node_s::id, switch_event_channel_sub_node_s::next, switch_event_channel_sub_node_head_s::node, switch_core_hash_find(), switch_core_hash_insert, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), switch_zmalloc, and switch_event_channel_sub_node_head_s::tail.

Referenced by switch_event_channel_bind().

 {
         switch_event_channel_sub_node_t *node, *np;
         switch_event_channel_sub_node_head_t *head;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_thread_rwlock_wrlock(event_channel_manager.rwlock);
 
         if (!(head = switch_core_hash_find(event_channel_manager.hash, event_channel))) {
                 switch_zmalloc(head, sizeof(*head));
                 head->event_channel = strdup(event_channel);
                 switch_core_hash_insert(event_channel_manager.hash, event_channel, head);
 
                 switch_zmalloc(node, sizeof(*node));
                 node->func = func;
                 node->id = id;
 
                 node->head = head;
                 head->node = node;
                 head->tail = node;
                 status = SWITCH_STATUS_SUCCESS;
         } else {
                 int exist = 0;
 
                 for (np = head->node; np; np = np->next) {
                         if (np->func == func) {
                                 exist = 1;
                                 break;
                         }
                 }
 
                 if (!exist) {
                         switch_zmalloc(node, sizeof(*node));
 
                         node->func = func;
                         node->id = id;
                         node->head = head;
 
 
                         if (!head->node) {
                                 head->node = node;
                                 head->tail = node;
                         } else {
                                 head->tail->next = node;
                                 head->tail = head->tail->next;
                         }
                         status = SWITCH_STATUS_SUCCESS;
                 }
         }
 
         switch_thread_rwlock_unlock(event_channel_manager.rwlock);
 
         return status;
 }

static uint32_t switch_event_channel_unsub_channel	(	switch_event_channel_func_t	func,
		const char *	event_channel
	)

static

Definition at line 2745 of file switch_event.c.

References event_channel_manager, switch_core_hash_find(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_event_channel_unsub_head(), switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_event_channel_unbind().

 {
         switch_event_channel_sub_node_head_t *head;
         uint32_t x = 0;
 
         switch_thread_rwlock_wrlock(event_channel_manager.rwlock);
 
         if (!event_channel) {
                 switch_hash_index_t *hi;
                 void *val;
 
                 for (hi = switch_core_hash_first(event_channel_manager.hash); hi; hi = switch_core_hash_next(&hi)) {
                         switch_core_hash_this(hi, NULL, NULL, &val);
 
                         if (val) {
                                 head = (switch_event_channel_sub_node_head_t *) val;
                                 x += switch_event_channel_unsub_head(func, head);
                         }
                 }
 
         } else {
                 if ((head = switch_core_hash_find(event_channel_manager.hash, event_channel))) {
                         x += switch_event_channel_unsub_head(func, head);
                 }
         }
 
         switch_thread_rwlock_unlock(event_channel_manager.rwlock);
 
         return x;
 }

static uint32_t switch_event_channel_unsub_head	(	switch_event_channel_func_t	func,
		switch_event_channel_sub_node_head_t *	head
	)

static

Definition at line 2679 of file switch_event.c.

References switch_event_channel_sub_node_head_s::event_channel, switch_event_channel_sub_node_s::func, switch_event_channel_sub_node_s::head, switch_event_channel_sub_node_s::next, switch_event_channel_sub_node_head_s::node, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, switch_log_printf(), and switch_event_channel_sub_node_head_s::tail.

Referenced by switch_event_channel_unsub_channel(), and unsub_all_switch_event_channel().

 {
         uint32_t x = 0;
 
         switch_event_channel_sub_node_t *thisnp = NULL, *np, *last = NULL;
 
         np = head->tail = head->node;
 
         while (np) {
 
                 thisnp = np;
                 np = np->next;
 
                 if (!func || thisnp->func == func) {
                         x++;
                         
                         if (last) {
                                 last->next = np;
                         } else {
                                 head->node = np;
                         }
 
 
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "UNSUBBING %p [%s]\n", (void *)(intptr_t)thisnp->func, thisnp->head->event_channel);
 
 
                         thisnp->func = NULL;
                         free(thisnp);
                 } else {
                         last = thisnp;
                         head->tail = last;
                 }
         }
 
         return x;
 }

switch_status_t switch_event_create_pres_in_detailed	(	char *	file,
		char *	func,
		int	line,
		const char *	proto,
		const char *	login,
		const char *	from,
		const char *	from_domain,
		const char *	status,
		const char *	event_type,
		const char *	alt_event_type,
		int	event_count,
		const char *	unique_id,
		const char *	channel_state,
		const char *	answer_state,
		const char *	call_direction
	)

Definition at line 2157 of file switch_event.c.

References switch_event_add_header(), switch_event_add_header_string(), switch_event_create_subclass, switch_event_fire_detailed(), SWITCH_EVENT_PRESENCE_IN, SWITCH_EVENT_SUBCLASS_ANY, SWITCH_STACK_TOP, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

 {
         switch_event_t *pres_event;
 
         if (switch_event_create_subclass(&pres_event, SWITCH_EVENT_PRESENCE_IN, SWITCH_EVENT_SUBCLASS_ANY) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "proto", proto);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "login", login);
                 switch_event_add_header(pres_event, SWITCH_STACK_TOP, "from", "%s@%s", from, from_domain);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "status", status);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "event_type", event_type);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "alt_event_type", alt_event_type);
                 switch_event_add_header(pres_event, SWITCH_STACK_TOP, "event_count", "%d", event_count);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "unique-id", alt_event_type);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "channel-state", channel_state);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "answer-state", answer_state);
                 switch_event_add_header_string(pres_event, SWITCH_STACK_TOP, "presence-call-direction", call_direction);
                 switch_event_fire_detailed(file, func, line, &pres_event, NULL);
                 return SWITCH_STATUS_SUCCESS;
         }
         return SWITCH_STATUS_MEMERR;
 }

static void* SWITCH_THREAD_FUNC switch_event_deliver_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 264 of file switch_event.c.

References switch_event_deliver().

Referenced by switch_event_deliver_thread_pool().

 {
         switch_event_t *event = (switch_event_t *) obj;
 
         switch_event_deliver(&event);
 
         return NULL;
 }

static void switch_event_deliver_thread_pool ( switch_event_t ** event )

static

Definition at line 273 of file switch_event.c.

References switch_thread_data_s::alloc, switch_thread_data_s::func, switch_thread_data_s::obj, switch_thread_data_s::pool, switch_assert, switch_event_deliver_thread(), and switch_thread_pool_launch_thread().

Referenced by switch_event_fire_detailed().

 {
         switch_thread_data_t *td;
         
         td = malloc(sizeof(*td));
         switch_assert(td);
 
         td->alloc = 1;
         td->func = switch_event_deliver_thread;
         td->obj = *event;
         td->pool = NULL;
 
         *event = NULL;
 
         switch_thread_pool_launch_thread(&td);
 
 }

static void* SWITCH_THREAD_FUNC switch_event_dispatch_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 291 of file switch_event.c.

References DISPATCH_THREAD_COUNT, EVENT_DISPATCH_QUEUE_RUNNING, EVENT_DISPATCH_QUEUE_THREADS, EVENT_QUEUE_MUTEX, MAX_DISPATCH_VAL, SWITCH_CHANNEL_LOG, switch_event_deliver(), SWITCH_LOG_CONSOLE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_os_yield(), switch_queue_pop(), SWITCH_STATUS_SUCCESS, SYSTEM_RUNNING, and THREAD_COUNT.

Referenced by switch_event_launch_dispatch_threads().

 {
         switch_queue_t *queue = (switch_queue_t *) obj;
         int my_id = 0;
 
         switch_mutex_lock(EVENT_QUEUE_MUTEX);
         THREAD_COUNT++;
         DISPATCH_THREAD_COUNT++;
 
         for (my_id = 0; my_id < MAX_DISPATCH_VAL; my_id++) {
                 if (EVENT_DISPATCH_QUEUE_THREADS[my_id] == thread) {
                         break;
                 }
         }
 
         if ( my_id >= MAX_DISPATCH_VAL ) {
                 switch_mutex_unlock(EVENT_QUEUE_MUTEX);
                 return NULL;
         }
 
         EVENT_DISPATCH_QUEUE_RUNNING[my_id] = 1;
         switch_mutex_unlock(EVENT_QUEUE_MUTEX);
 
 
         for (;;) {
                 void *pop = NULL;
                 switch_event_t *event = NULL;
 
                 if (!SYSTEM_RUNNING) {
                         break;
                 }
 
                 if (switch_queue_pop(queue, &pop) != SWITCH_STATUS_SUCCESS) {
                         continue;
                 }
 
                 if (!pop) {
                         break;
                 }
 
                 event = (switch_event_t *) pop;
                 switch_event_deliver(&event);
                 switch_os_yield();
         }
 
 
         switch_mutex_lock(EVENT_QUEUE_MUTEX);
         EVENT_DISPATCH_QUEUE_RUNNING[my_id] = 0;
         THREAD_COUNT--;
         DISPATCH_THREAD_COUNT--;
         switch_mutex_unlock(EVENT_QUEUE_MUTEX);
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Dispatch Thread %d Ended.\n", my_id);
         return NULL;
 
 }

static switch_status_t switch_event_queue_dispatch_event ( switch_event_t ** eventp )

static

Definition at line 350 of file switch_event.c.

References DISPATCH_QUEUE_LEN, DISPATCH_THREAD_COUNT, EVENT_DISPATCH_QUEUE, EVENT_QUEUE_MUTEX, MAX_DISPATCH, PENDING, SOFT_MAX_DISPATCH, switch_event_launch_dispatch_threads(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_push(), switch_queue_size(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SYSTEM_RUNNING.

Referenced by switch_event_fire_detailed().

 {
 
         switch_event_t *event = *eventp;
 
         if (!SYSTEM_RUNNING) {
                 return SWITCH_STATUS_FALSE;
         }
 
         while (event) {
                 int launch = 0;
 
                 switch_mutex_lock(EVENT_QUEUE_MUTEX);
 
                 if (!PENDING && switch_queue_size(EVENT_DISPATCH_QUEUE) > (unsigned int)(DISPATCH_QUEUE_LEN * DISPATCH_THREAD_COUNT)) {
                         if (SOFT_MAX_DISPATCH + 1 > MAX_DISPATCH) {
                                 launch++;
                                 PENDING++;
                         }
                 }
 
                 switch_mutex_unlock(EVENT_QUEUE_MUTEX);
 
                 if (launch) {
                         if (SOFT_MAX_DISPATCH + 1 < MAX_DISPATCH) {
                                 switch_event_launch_dispatch_threads(SOFT_MAX_DISPATCH + 1);
                         }
 
                         switch_mutex_lock(EVENT_QUEUE_MUTEX);
                         PENDING--;
                         switch_mutex_unlock(EVENT_QUEUE_MUTEX);
                 }
 
                 *eventp = NULL;
                 switch_queue_push(EVENT_DISPATCH_QUEUE, event);
                 event = NULL;
 
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_xml_t switch_event_xmlize	(	switch_event_t *	event,
		const char *	fmt,
			...
	)

Definition at line 1852 of file switch_event.c.

References add_xml_header(), switch_event_header::array, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_snprintf(), switch_xml_add_child_d, switch_xml_new(), switch_xml_set_txt_d, switch_event_header::value, and zstr.

 {
         switch_event_header_t *hp;
         char *data = NULL, *body = NULL;
         int ret = 0;
         switch_xml_t xml = NULL;
         uint32_t off = 0;
         va_list ap;
         switch_xml_t xheaders = NULL;
 
         if (!(xml = switch_xml_new("event"))) {
                 return xml;
         }
 
         if (!zstr(fmt)) {
                 va_start(ap, fmt);
 #ifdef HAVE_VASPRINTF
                 ret = vasprintf(&data, fmt, ap);
 #else
                 data = (char *) malloc(2048);
                 if (!data) {
                         va_end(ap);
                         return NULL;
                 }
                 ret = vsnprintf(data, 2048, fmt, ap);
 #endif
                 va_end(ap);
                 if (ret == -1) {
 #ifndef HAVE_VASPRINTF
                         free(data);
 #endif
                         return NULL;
                 }
         }
 
         if ((xheaders = switch_xml_add_child_d(xml, "headers", off++))) {
                 int hoff = 0;
                 for (hp = event->headers; hp; hp = hp->next) {
 
                         if (hp->idx) {
                                 int i;
                                 for (i = 0; i < hp->idx; i++) {
                                         add_xml_header(xheaders, hp->name, hp->array[i], hoff++);
                                 }
                         } else {
                                 add_xml_header(xheaders, hp->name, hp->value, hoff++);
                         }
                 }
         }
 
         if (!zstr(data)) {
                 body = data;
         } else if (event->body) {
                 body = event->body;
         }
 
         if (body) {
                 int blen = (int) strlen(body);
                 char blena[25];
                 switch_snprintf(blena, sizeof(blena), "%d", blen);
                 if (blen) {
                         switch_xml_t xbody = NULL;
 
                         add_xml_header(xml, "Content-Length", blena, off++);
                         if ((xbody = switch_xml_add_child_d(xml, "body", off++))) {
                                 switch_xml_set_txt_d(xbody, body);
                         }
                 }
         }
 
         if (data) {
                 free(data);
         }
 
         return xml;
 }

static int switch_events_match	(	switch_event_t *	event,
		switch_event_node_t *	node
	)

static

Definition at line 225 of file switch_event.c.

References switch_event_node::event_id, switch_event::event_id, switch_event_node::subclass_name, switch_event::subclass_name, SWITCH_EVENT_ALL, and switch_event_get_header.

Referenced by switch_event_deliver().

 {
         int match = 0;
 
         if (node->event_id == SWITCH_EVENT_ALL) {
                 match++;
 
                 if (!node->subclass_name) {
                         return match;
                 }
         }
 
         if (match || event->event_id == node->event_id) {
 
                 if (event->subclass_name && node->subclass_name) {
                         if (!strncasecmp(node->subclass_name, "file:", 5)) {
                                 char *file_header;
                                 if ((file_header = switch_event_get_header(event, "file")) != 0) {
                                         match = !strcmp(node->subclass_name + 5, file_header) ? 1 : 0;
                                 }
                         } else if (!strncasecmp(node->subclass_name, "func:", 5)) {
                                 char *func_header;
                                 if ((func_header = switch_event_get_header(event, "function")) != 0) {
                                         match = !strcmp(node->subclass_name + 5, func_header) ? 1 : 0;
                                 }
                         } else if (event->subclass_name && node->subclass_name) {
                                 match = !strcmp(event->subclass_name, node->subclass_name) ? 1 : 0;
                         }
                 } else if ((event->subclass_name && !node->subclass_name) || (!event->subclass_name && !node->subclass_name)) {
                         match = 1;
                 } else {
                         match = 0;
                 }
         }
 
         return match;
 }

static void unsub_all_switch_event_channel ( void )

static

Definition at line 2716 of file switch_event.c.

References switch_event_channel_sub_node_head_s::event_channel, event_channel_manager, switch_core_hash_delete(), switch_core_hash_first_iter(), switch_core_hash_this(), switch_event_channel_unsub_head(), switch_event_destroy(), switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_event_shutdown().

 {
         switch_hash_index_t *hi = NULL;
         const void *var;
         void *val;
         switch_event_channel_sub_node_head_t *head;
 
         switch_thread_rwlock_wrlock(event_channel_manager.rwlock);
 
         while ((hi = switch_core_hash_first_iter( event_channel_manager.perm_hash, hi))) {
                 switch_event_t *vals = NULL;
                 switch_core_hash_this(hi, &var, NULL, &val);
                 vals = (switch_event_t *) val;
                 switch_core_hash_delete(event_channel_manager.perm_hash, var);
                 switch_event_destroy(&vals);
         }
 
         while ((hi = switch_core_hash_first_iter( event_channel_manager.hash, hi))) {
                 switch_core_hash_this(hi, NULL, NULL, &val);
                 head = (switch_event_channel_sub_node_head_t *) val;
                 switch_event_channel_unsub_head(NULL, head);
                 switch_core_hash_delete(event_channel_manager.hash, head->event_channel);
                 free(head->event_channel);
                 free(head);
         }
 
         switch_thread_rwlock_unlock(event_channel_manager.rwlock);
 }