switch_event.c File Reference

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

Include dependency graph for switch_event.c:

Go to the source code of this file.

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)
#define	SWITCH_CHANNEL_DISPATCH_MAX_KEY_PARTS   10

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 void	free_header (switch_event_header_t **header)
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_nodup (switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
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, void *user_data)
static uint32_t	switch_event_channel_unsub_channel (switch_event_channel_func_t func, const char *event_channel, void *user_data)
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, void *user_data)
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)
switch_status_t	switch_event_channel_deliver (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, void *user_data)
switch_status_t	switch_event_channel_bind (const char *event_channel, switch_event_channel_func_t func, switch_event_channel_id_t *id, void *user_data)
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_mutex_t *	CUSTOM_HASH_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

ALLOC

#define ALLOC

(

size

)

malloc(size)

Definition at line 123 of file switch_event.c.

Referenced by new_header(), and switch_event_create_subclass_detailed().

DISPATCH_QUEUE_LEN

#define DISPATCH_QUEUE_LEN   10000

Definition at line 44 of file switch_event.c.

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

DUP

#define DUP

(

str

)

my_dup(str)

Definition at line 126 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().

FREE

#define FREE

(

ptr

)

switch_safe_free(ptr)

Definition at line 129 of file switch_event.c.

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

MAX_DISPATCH_VAL

#define MAX_DISPATCH_VAL   64

Definition at line 82 of file switch_event.c.

Referenced by switch_event_dispatch_thread().

resize

#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 2241 of file switch_event.c.

Referenced by switch_event_expand_headers_check().

SWITCH_CHANNEL_DISPATCH_MAX_KEY_PARTS

#define SWITCH_CHANNEL_DISPATCH_MAX_KEY_PARTS   10

Definition at line 2942 of file switch_event.c.

Referenced by ecd_deliver().

SWITCH_SERIALIZED_EVENT_MAP

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

Definition at line 1428 of file switch_event.c.

Referenced by switch_event_binary_deserialize(), and switch_event_binary_serialize().

Typedef Documentation

alias_node_t

typedef struct alias_node_s alias_node_t

la_node_t

typedef struct la_node_s la_node_t

switch_event_channel_sub_node_head_t

typedef struct switch_event_channel_sub_node_head_s switch_event_channel_sub_node_head_t

switch_event_channel_sub_node_t

typedef struct switch_event_channel_sub_node_s switch_event_channel_sub_node_t

Function Documentation

_switch_event_channel_broadcast()

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 2903 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(), switch_thread_rwlock_unlock(), and switch_event_channel_sub_node_s::user_data.

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, np->user_data);
                        x++;
                }
        }
        switch_thread_rwlock_unlock(event_channel_manager.rwlock);

        return x;
}

add_xml_header()

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

static

Definition at line 1872 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;
}

check_dispatch()

static void check_dispatch ( void  )

static

Definition at line 634 of file switch_event.c.

References BLOCK, DISPATCH_QUEUE_LEN, 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);
        }
}

destroy_ecd()

static void destroy_ecd ( event_channel_data_t **  ecdP )

static

Definition at line 2926 of file switch_event.c.

References 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);
}

ecd_deliver()

static void ecd_deliver ( event_channel_data_t **  ecdP )

static

Definition at line 2945 of file switch_event.c.

References _switch_event_channel_broadcast(), buf, destroy_ecd(), event_channel_data_t::event_channel, event_channel_data_t::id, event_channel_data_t::json, key, event_channel_data_t::key, memset(), SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY, SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE, SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON, SWITCH_CHANNEL_DISPATCH_MAX_KEY_PARTS, SWITCH_CHANNEL_LOG, switch_core_get_event_channel_key_separator(), switch_core_test_flag(), SWITCH_EVENT_CHANNEL_GLOBAL, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_LOG_WARNING, switch_safe_free, switch_separate_string_string(), and switch_snprintf().

Referenced by switch_event_channel_deliver(), and switch_event_channel_deliver_thread().

{
        event_channel_data_t *ecd = *ecdP;
        char *key;
        uint32_t t = 0;

        *ecdP = NULL;

        t = _switch_event_channel_broadcast(ecd->event_channel, ecd->event_channel, ecd->json, ecd->key, ecd->id);

        key = strdup(ecd->event_channel);
        if (switch_core_test_flag(SCF_EVENT_CHANNEL_ENABLE_HIERARCHY_DELIVERY)) {
                const char *sep = switch_core_get_event_channel_key_separator();
                char *x_argv[SWITCH_CHANNEL_DISPATCH_MAX_KEY_PARTS] = { 0 };
                int x_argc = switch_separate_string_string(key, (char*) sep, x_argv, SWITCH_CHANNEL_DISPATCH_MAX_KEY_PARTS);
                char buf[1024];
                int i, r;

                for(i=x_argc - 1; i > 0; i--) {
                        int z;

                        memset(buf, 0, 1024);
                        switch_snprintf(buf, sizeof(buf), "%s", x_argv[0]);
                        for(z=1; z < i; z++) {
                                strcat(buf, sep);
                                strncat(buf, x_argv[z], sizeof(buf) - strlen(buf) - 1);
                        }

                        r = _switch_event_channel_broadcast(buf, ecd->event_channel, ecd->json, ecd->key, ecd->id);
                        t += r;
                        if (r && switch_core_test_flag(SCF_EVENT_CHANNEL_HIERARCHY_DELIVERY_ONCE)) {
                                break;
                        }
                }
        } else {
                char *p = NULL;

                if ((p = strchr(key, '.'))) {
                        *p = '\0';
                        t += _switch_event_channel_broadcast(key, ecd->event_channel, ecd->json, ecd->key, ecd->id);
                }
        }

        switch_safe_free(key);

        t += _switch_event_channel_broadcast(SWITCH_EVENT_CHANNEL_GLOBAL, ecd->event_channel, ecd->json, ecd->key, ecd->id);

        if(t == 0) {
                if (switch_core_test_flag(SCF_EVENT_CHANNEL_LOG_UNDELIVERABLE_JSON)) {
                        char *json = cJSON_Print(ecd->json);

                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "no subscribers for %s , %s => %s\n", ecd->event_channel, ecd->key, json);
                        switch_safe_free(json);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "no subscribers for %s , %s\n", ecd->event_channel, ecd->key);
                }
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "delivered to %u subscribers for %s\n", t, ecd->event_channel);
        }

        destroy_ecd(&ecd);
}

free_header()

static void free_header ( switch_event_header_t **  header )

static

Definition at line 931 of file switch_event.c.

References FREE, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), switch_queue_trypush(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_event_base_add_header(), switch_event_del_header_val(), and switch_event_destroy().

{
        assert(header);

        if (*header) {
                if ((*header)->idx) {
                        if (!(*header)->array) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "INDEX WITH NO ARRAY ?? [%s][%s]\n", (*header)->name, (*header)->value);
                        } else {
                                int i = 0;

                                for (i = 0; i < (*header)->idx; i++) {
                                        FREE((*header)->array[i]);
                                }
                                FREE((*header)->array);
                        }
                }

                FREE((*header)->name);
                FREE((*header)->value);

#ifdef SWITCH_EVENT_RECYCLE
                if (switch_queue_trypush(EVENT_HEADER_RECYCLE_QUEUE, *header) != SWITCH_STATUS_SUCCESS) {
                        FREE(*header);
                }
#else
                FREE(*header);
#endif
        }
}

la_broadcast()

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

static

Definition at line 3231 of file switch_event.c.

References switch_live_array_s::aliases, switch_live_array_s::channel_id, 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);

}

my_dup()

static char* my_dup ( const char *  s )

static

Definition at line 113 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);
}

new_header()

static switch_event_header_t* new_header ( const char *  header_name )

static

Definition at line 908 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_event_add_body()

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

Definition at line 1266 of file switch_event.c.

References switch_event::body, 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_event_add_header()

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 1210 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);
}

switch_event_base_add_header()

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 1005 of file switch_event.c.

References switch_event_header::array, DUP, EF_UNIQ_HEADERS, FREE, free_header(), switch_event_header::hash, switch_event_header::idx, index, 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(), switch_event_add_header_string(), and switch_event_add_header_string_nodup().

{
        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)) {
                switch_event_header_t *tmp_header = NULL;

                if (!(header = switch_event_get_header_ptr(event, header_name)) && index_ptr) {

                        tmp_header = 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;
                                                }

                                                FREE(data);
                                                goto redraw;
                                        }
                                } else if (tmp_header) {
                                        free_header(&tmp_header);
                                }

                                FREE(data);
                                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 += 2;
                        if (!header->array[j]) { 
                                continue;
                        }
                        len += strlen(header->array[j]);
                }

                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;
                                }
                                if (!header->array[j]) { 
                                        continue;
                                }
                                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;
}

switch_event_channel_deliver_thread()

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

static

Definition at line 3008 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;
}

switch_event_channel_sub_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, void *  user_data  )

static

Definition at line 2836 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_node::id, 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, switch_event_channel_sub_node_head_s::tail, switch_event_node::user_data, and switch_event_channel_sub_node_s::user_data.

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->user_data = user_data;
                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 && np->user_data == user_data) {
                                exist = 1;
                                break;
                        }
                }

                if (!exist) {
                        switch_zmalloc(node, sizeof(*node));

                        node->func = func;
                        node->user_data = user_data;
                        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;
}

switch_event_channel_unsub_channel()

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

static

Definition at line 2805 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, user_data);
                        }
                }

        } else {
                if ((head = switch_core_hash_find(event_channel_manager.hash, event_channel))) {
                        x += switch_event_channel_unsub_head(func, head, user_data);
                }
        }

        switch_thread_rwlock_unlock(event_channel_manager.rwlock);

        return x;
}

switch_event_channel_unsub_head()

static uint32_t switch_event_channel_unsub_head ( switch_event_channel_func_t  func, switch_event_channel_sub_node_head_t *  head, void *  user_data  )

static

Definition at line 2738 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(), switch_event_channel_sub_node_head_s::tail, and switch_event_channel_sub_node_s::user_data.

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 && (thisnp->user_data == user_data || user_data == NULL))) {
                        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_event_create_pres_in_detailed()

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 2213 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;
}

switch_event_deliver_thread()

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

static

Definition at line 272 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;
}

switch_event_deliver_thread_pool()

static void switch_event_deliver_thread_pool ( switch_event_t **  event )

static

Definition at line 281 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);

}

switch_event_dispatch_thread()

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

static

Definition at line 299 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;

}

switch_event_queue_dispatch_event()

static switch_status_t switch_event_queue_dispatch_event ( switch_event_t **  eventp )

static

Definition at line 358 of file switch_event.c.

References DISPATCH_QUEUE_LEN, DISPATCH_THREAD_COUNT, 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_event_xmlize()

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

Definition at line 1891 of file switch_event.c.

References add_xml_header(), switch_event_header::array, switch_event::body, switch_event::headers, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_snprintf(), switch_xml_add_child_d(), switch_xml_free(), 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);
                        switch_xml_free(xml);

                        return NULL;
                }
                ret = vsnprintf(data, 2048, fmt, ap);
#endif
                va_end(ap);
                if (ret == -1) {
#ifndef HAVE_VASPRINTF
                        free(data);
#endif
                        switch_xml_free(xml);

                        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;
}

switch_events_match()

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

static

Definition at line 233 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;
}

unsub_all_switch_event_channel()

static void unsub_all_switch_event_channel ( void  )

static

Definition at line 2775 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_safe_free, 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, NULL);
                switch_core_hash_delete(event_channel_manager.hash, head->event_channel);
                free(head->event_channel);
                free(head);
        }

        switch_safe_free(hi);
        switch_thread_rwlock_unlock(event_channel_manager.rwlock);
}

Variable Documentation

BLOCK

switch_mutex_t* BLOCK = NULL

static

Definition at line 89 of file switch_event.c.

Referenced by check_dispatch(), switch_event_bind_removable(), switch_event_fire_detailed(), switch_event_init(), switch_event_name(), switch_event_unbind(), switch_event_unbind_callback(), and switch_name_event().

CUSTOM_HASH

switch_hash_t* CUSTOM_HASH = NULL

static

Definition at line 99 of file switch_event.c.

CUSTOM_HASH_MUTEX

switch_mutex_t* CUSTOM_HASH_MUTEX = NULL

static

Definition at line 98 of file switch_event.c.

Referenced by switch_event_bind_removable(), switch_event_free_subclass_detailed(), switch_event_get_custom_events(), switch_event_init(), and switch_event_reserve_subclass_detailed().

DISPATCH_THREAD_COUNT

int DISPATCH_THREAD_COUNT = 0

static

Definition at line 101 of file switch_event.c.

Referenced by switch_event_dispatch_thread(), switch_event_queue_dispatch_event(), and switch_event_shutdown().

EVENT_CHANNEL_DISPATCH_QUEUE

switch_queue_t* EVENT_CHANNEL_DISPATCH_QUEUE = NULL

static

Definition at line 96 of file switch_event.c.

Referenced by switch_event_channel_broadcast().

EVENT_CHANNEL_DISPATCH_THREAD_COUNT

int EVENT_CHANNEL_DISPATCH_THREAD_COUNT = 0

static

Definition at line 102 of file switch_event.c.

Referenced by switch_event_channel_broadcast(), and switch_event_channel_deliver_thread().

EVENT_CHANNEL_DISPATCH_THREAD_STARTING

int EVENT_CHANNEL_DISPATCH_THREAD_STARTING = 0

static

Definition at line 103 of file switch_event.c.

Referenced by switch_event_channel_broadcast(), and switch_event_channel_deliver_thread().

event_channel_manager

struct { ... } event_channel_manager

Referenced by _switch_event_channel_broadcast(), switch_event_channel_bind(), switch_event_channel_permission_clear(), switch_event_channel_permission_modify(), switch_event_channel_permission_verify(), switch_event_channel_sub_channel(), switch_event_channel_unsub_channel(), switch_event_init(), switch_event_shutdown(), switch_live_array_add_alias(), switch_live_array_clear_alias(), switch_live_array_create(), switch_live_array_destroy(), and unsub_all_switch_event_channel().

EVENT_DISPATCH_QUEUE

switch_queue_t* EVENT_DISPATCH_QUEUE = NULL

static

Definition at line 95 of file switch_event.c.

EVENT_DISPATCH_QUEUE_RUNNING

uint8_t EVENT_DISPATCH_QUEUE_RUNNING[MAX_DISPATCH_VAL] = { 0 }

static

Definition at line 94 of file switch_event.c.

Referenced by switch_event_dispatch_thread(), and switch_event_launch_dispatch_threads().

EVENT_DISPATCH_QUEUE_THREADS

switch_thread_t* EVENT_DISPATCH_QUEUE_THREADS[MAX_DISPATCH_VAL] = { 0 }

static

Definition at line 93 of file switch_event.c.

Referenced by switch_event_dispatch_thread(), switch_event_launch_dispatch_threads(), and switch_event_shutdown().

EVENT_NAMES

char* EVENT_NAMES[]

static

Definition at line 137 of file switch_event.c.

Referenced by switch_event_name(), and switch_name_event().

EVENT_NODES

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

static

Definition at line 87 of file switch_event.c.

EVENT_QUEUE_MUTEX

switch_mutex_t* EVENT_QUEUE_MUTEX = NULL

static

Definition at line 97 of file switch_event.c.

Referenced by switch_event_channel_broadcast(), switch_event_channel_deliver_thread(), switch_event_dispatch_thread(), switch_event_fire_detailed(), switch_event_init(), switch_event_prep_for_delivery_detailed(), switch_event_queue_dispatch_event(), and switch_event_shutdown().

EVENT_SEQUENCE_NR

uint64_t EVENT_SEQUENCE_NR = 0

static

Definition at line 105 of file switch_event.c.

Referenced by switch_event_prep_for_delivery_detailed().

guess_ip_v4

char guess_ip_v4[80] = ""

static

Definition at line 85 of file switch_event.c.

Referenced by switch_event_init(), and switch_event_prep_for_delivery_detailed().

guess_ip_v6

char guess_ip_v6[80] = ""

static

Definition at line 86 of file switch_event.c.

Referenced by switch_event_init(), and switch_event_prep_for_delivery_detailed().

hash

switch_hash_t* hash

Definition at line 76 of file switch_event.c.

Referenced by switch_ci_hashfunc_default(), switch_event_del_header_val(), switch_event_get_header_ptr(), switch_event_rename_header(), switch_hash_default(), switch_hash_default_ci(), switch_hashtable_insert_destructor(), switch_hashtable_remove(), switch_hashtable_search(), and switch_scheduler_del_task_group().

ID

switch_event_channel_id_t ID

Definition at line 74 of file switch_event.c.

lahash

switch_hash_t* lahash

Definition at line 78 of file switch_event.c.

lamutex

switch_mutex_t* lamutex

Definition at line 79 of file switch_event.c.

MAX_DISPATCH

unsigned int MAX_DISPATCH = MAX_DISPATCH_VAL

static

Definition at line 83 of file switch_event.c.

Referenced by check_dispatch(), switch_event_channel_broadcast(), switch_event_init(), switch_event_launch_dispatch_threads(), switch_event_queue_dispatch_event(), and switch_event_shutdown().

PENDING

int PENDING = 0

static

Definition at line 356 of file switch_event.c.

Referenced by switch_event_queue_dispatch_event().

perm_hash

switch_hash_t* perm_hash

Definition at line 77 of file switch_event.c.

POOL_LOCK

switch_mutex_t* POOL_LOCK = NULL

static

Definition at line 90 of file switch_event.c.

Referenced by switch_event_init().

RUNTIME_POOL

switch_memory_pool_t* RUNTIME_POOL = NULL

static

Definition at line 91 of file switch_event.c.

Referenced by switch_event_bind_removable(), switch_event_fire_detailed(), switch_event_free_subclass_detailed(), switch_event_init(), switch_event_launch_dispatch_threads(), switch_event_name(), switch_event_reserve_subclass_detailed(), and switch_name_event().

rwlock

switch_thread_rwlock_t* rwlock

Definition at line 75 of file switch_event.c.

RWLOCK

switch_thread_rwlock_t* RWLOCK = NULL

static

Definition at line 88 of file switch_event.c.

Referenced by switch_event_bind_removable(), switch_event_deliver(), switch_event_free_subclass_detailed(), switch_event_init(), switch_event_unbind(), and switch_event_unbind_callback().

SOFT_MAX_DISPATCH

unsigned int SOFT_MAX_DISPATCH = 0

static

Definition at line 84 of file switch_event.c.

Referenced by switch_event_launch_dispatch_threads(), and switch_event_queue_dispatch_event().

SYSTEM_RUNNING

int SYSTEM_RUNNING = 0

static

Definition at line 104 of file switch_event.c.

Referenced by switch_event_channel_broadcast(), switch_event_channel_deliver_thread(), switch_event_deliver(), switch_event_dispatch_thread(), switch_event_fire_detailed(), switch_event_init(), switch_event_queue_dispatch_event(), switch_event_running(), and switch_event_shutdown().

THREAD_COUNT

int THREAD_COUNT = 0

static

Definition at line 100 of file switch_event.c.

Referenced by check_dispatch(), switch_event_channel_deliver_thread(), switch_event_dispatch_thread(), and switch_event_shutdown().

THRUNTIME_POOL

switch_memory_pool_t* THRUNTIME_POOL = NULL

static

Definition at line 92 of file switch_event.c.

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