Eventing Engine

Collaboration diagram for Eventing Engine:

Data Structures
struct	switch_event_header
	An event Header. More...
struct	switch_event
	Representation of an event. More...
struct	switch_serial_event_s
struct	switch_serial_event_header_s

Macros
#define	SWITCH_EVENT_SUBCLASS_ANY   NULL
#define	switch_event_create_subclass(_e, _eid, _sn)   switch_event_create_subclass_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, _e, _eid, _sn)
#define	switch_event_get_header(_e, _h)   switch_event_get_header_idx(_e, _h, -1)
#define	switch_event_get_header_nil(e, h)   switch_str_nil(switch_event_get_header(e,h))
#define	switch_event_del_header(_e, _h)   switch_event_del_header_val(_e, _h, NULL)
#define	switch_event_safe_destroy(_event)   if (_event) switch_event_destroy(&_event)
#define	switch_event_prep_for_delivery(_event)   switch_event_prep_for_delivery_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, _event)
#define	switch_event_expand_headers(_event, _in)   switch_event_expand_headers_check(_event, _in, NULL, NULL, 0)
#define	switch_event_create_pres_in(event)
#define	switch_event_reserve_subclass(subclass_name)   switch_event_reserve_subclass_detailed(__FILE__, subclass_name)
	Reserve a subclass assuming the owner string is the current filename. More...
#define	switch_event_free_subclass(subclass_name)   switch_event_free_subclass_detailed(__FILE__, subclass_name)
#define	switch_event_create(event, id)   switch_event_create_subclass(event, id, SWITCH_EVENT_SUBCLASS_ANY)
	Create a new event assuming it will not be custom event and therefore hiding the unused parameters. More...
#define	switch_event_fire(event)   switch_event_fire_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, event, NULL)
	Fire an event filling in most of the arguements with obvious values. More...
#define	switch_event_fire_data(event, data)   switch_event_fire_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, event, data)
	Fire an event filling in most of the arguements with obvious values and allowing user_data to be sent. More...
#define	NO_EVENT_CHANNEL_ID   0
#define	SWITCH_EVENT_CHANNEL_GLOBAL   "__global__"

Typedefs
typedef struct switch_serial_event_s	switch_serial_event_t
typedef struct switch_serial_event_header_s	switch_serial_event_header_t
typedef void(*	switch_live_array_command_handler_t) (switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data)

Enumerations
enum	switch_event_flag_t { EF_UNIQ_HEADERS = (1 << 0), EF_NO_CHAT_EXEC = (1 << 1), EF_DEFAULT_ALLOW = (1 << 2) }

Functions
switch_status_t	switch_event_init (switch_memory_pool_t *pool)
	Start the eventing system. More...
switch_status_t	switch_event_shutdown (void)
	Stop 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_event_header_t *	switch_event_get_header_ptr (switch_event_t *event, const char *header_name)
	Retrieve a header value from an event. More...
_Ret_opt_z_ char *	switch_event_get_header_idx (switch_event_t *event, const char *header_name, int idx)
switch_status_t	switch_event_rename_header (switch_event_t *event, const char *header_name, const char *new_header_name)
char *	switch_event_get_body (switch_event_t *event)
	Retrieve the body value from an event. More...
switch_status_t	switch_event_add_header (switch_event_t *event, switch_stack_t stack, const char *header_name, const char *fmt,...) PRINTF_FUNCTION(4
	Add a header to an event. More...
switch_status_t 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_add_header_string_nodup (switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
switch_status_t	switch_event_del_header_val (switch_event_t *event, const char *header_name, const char *val)
int	switch_event_add_array (switch_event_t *event, const char *var, const char *val)
void	switch_event_destroy (switch_event_t **event)
	Destroy an event. More...
switch_status_t	switch_event_dup (switch_event_t **event, switch_event_t *todup)
	Duplicate an event. More...
void	switch_event_merge (switch_event_t *event, switch_event_t *tomerge)
switch_status_t	switch_event_dup_reply (switch_event_t **event, switch_event_t *todup)
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...
void	switch_event_prep_for_delivery_detailed (const char *file, const char *func, int line, switch_event_t *event)
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_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_unbind (switch_event_node_t **node)
	Unbind a bound event consumer. More...
switch_status_t	switch_event_unbind_callback (switch_event_callback_t callback)
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_reserve_subclass_detailed (const char *owner, const char *subclass_name)
	Reserve a subclass name for private use with a custom event. More...
switch_status_t	switch_event_free_subclass_detailed (const char *owner, const char *subclass_name)
switch_status_t	switch_event_binary_deserialize (switch_event_t **eventp, void **data, switch_size_t len, switch_bool_t duplicate)
	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_serialize_json (switch_event_t *event, char **str)
switch_status_t	switch_event_serialize_json_obj (switch_event_t *event, cJSON **json)
switch_status_t	switch_event_create_json (switch_event_t **event, const char *json)
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_array_pair (switch_event_t **event, char **names, char **vals, int len)
switch_xml_t	switch_event_xmlize (switch_event_t *event, const char *fmt,...) PRINTF_FUNCTION(2
	Render a XML representation of an event suitable for printing or network transport. More...
switch_xml_t switch_status_t	switch_event_running (void)
	Determine if the event system has been initialized. More...
switch_status_t	switch_event_add_body (switch_event_t *event, const char *fmt,...) PRINTF_FUNCTION(2
	Add a body to an event. More...
switch_status_t switch_status_t	switch_event_set_body (switch_event_t *event, const char *body)
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)
switch_status_t	switch_event_create_pres_in_detailed (_In_z_ char *file, _In_z_ char *func, _In_ int line, _In_z_ const char *proto, _In_z_ const char *login, _In_z_ const char *from, _In_z_ const char *from_domain, _In_z_ const char *status, _In_z_ const char *event_type, _In_z_ const char *alt_event_type, _In_ int event_count, _In_z_ const char *unique_id, _In_z_ const char *channel_state, _In_z_ const char *answer_state, _In_z_ const char *call_direction)
static switch_status_t	switch_event_create_plain (switch_event_t **event, switch_event_types_t event_id)
void	switch_event_deliver (switch_event_t **event)
	Deliver an event to all of the registered event listeners. More...
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_event_add_presence_data_cols (switch_channel_t *channel, switch_event_t *event, const char *prefix)
void	switch_json_add_presence_data_cols (switch_event_t *event, cJSON *json, const char *prefix)
void	switch_event_launch_dispatch_threads (uint32_t max)
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_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_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)
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 destroy)
switch_status_t	switch_live_array_visible (switch_live_array_t *la, switch_bool_t visible, switch_bool_t force)
switch_bool_t	switch_live_array_isnew (switch_live_array_t *la)
void	switch_live_array_lock (switch_live_array_t *la)
void	switch_live_array_unlock (switch_live_array_t *la)
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)
switch_bool_t	switch_live_array_add_alias (switch_live_array_t *la, const char *event_channel, const char *name)
switch_bool_t	switch_live_array_clear_alias (switch_live_array_t *la, const char *event_channel, const char *name)
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)

Detailed Description

Macro Definition Documentation

NO_EVENT_CHANNEL_ID

#define NO_EVENT_CHANNEL_ID   0

Definition at line 439 of file switch_event.h.

SWITCH_EVENT_CHANNEL_GLOBAL

#define SWITCH_EVENT_CHANNEL_GLOBAL   "__global__"

Definition at line 440 of file switch_event.h.

Referenced by ecd_deliver().

switch_event_create

#define switch_event_create	(		event,
			id
	)		switch_event_create_subclass(event, id, SWITCH_EVENT_SUBCLASS_ANY)

Create a new event assuming it will not be custom event and therefore hiding the unused parameters.

Parameters

event	a NULL pointer on which to create the event
id	the event id enumeration of the desired event

Returns

SWITCH_STATUS_SUCCESS on success

Definition at line 384 of file switch_event.h.

Referenced by check_ip(), generate_on_dtmf(), handle_SIGHUP(), hanguphook(), process_device_hup(), record_callback(), rtp_common_write(), send_heartbeat(), send_record_stop_event(), signal_bridge_on_hangup(), signal_bridge_on_hibernate(), speech_thread(), switch_api_execute(), switch_channel_check_device_state(), switch_channel_clear_device_record(), switch_channel_dequeue_dtmf(), switch_channel_flip_cid(), switch_channel_get_variables(), switch_channel_get_variables_prefix(), switch_channel_mark_hold(), switch_channel_perform_hangup(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_channel_perform_presence(), switch_channel_perform_set_callstate(), switch_channel_perform_set_running_state(), switch_console_printf(), switch_core_chat_send_args(), switch_core_destroy(), switch_core_init_and_modload(), switch_core_media_bug_add(), switch_core_media_bug_destroy(), switch_core_media_read_frame(), switch_core_media_sdp_map(), switch_core_session_ctl(), switch_core_session_exec(), switch_core_session_execute_application_async(), switch_core_session_hupall_matching_var_ans(), switch_core_session_outgoing_channel(), switch_core_session_perform_destroy(), switch_core_session_read_frame(), switch_core_session_read_text_frame(), switch_core_session_reporting_state(), switch_core_session_run(), switch_core_session_set_read_codec(), switch_core_session_set_real_read_codec(), switch_core_session_set_uuid(), switch_core_session_set_video_read_codec(), switch_core_session_set_video_write_codec(), switch_core_session_set_write_codec(), switch_core_session_thread(), switch_event_binary_deserialize(), switch_event_create_array_pair(), switch_event_create_json(), switch_event_create_plain(), switch_event_import_xml(), switch_http_parse_header(), switch_ivr_broadcast(), switch_ivr_check_presence_mapping(), switch_ivr_hold(), switch_ivr_multi_threaded_bridge(), switch_ivr_park(), switch_ivr_phrase_macro_event(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_say(), switch_ivr_say_string(), switch_ivr_signal_bridge(), switch_ivr_unhold(), switch_load_network_lists(), switch_loadable_module_process(), switch_loadable_module_unprocess(), switch_log_meta_vprintf(), switch_msrp_msg_create(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_nat_multicast_runtime(), switch_odbc_handle_disconnect(), switch_rtp_add_crypto_key(), switch_scheduler_add_task_ex(), switch_scheduler_execute(), switch_send_rtcp_event(), SWITCH_STANDARD_SCHED_FUNC(), switch_xml_locate_domain(), switch_xml_locate_group(), switch_xml_locate_user(), switch_xml_open_root(), task_thread_loop(), text_callback(), tone_detect_callback(), and uuid_bridge_on_soft_execute().

switch_event_create_pres_in

#define switch_event_create_pres_in

(

event

)

Value:

switch_event_create_pres_in_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, \
                                                                                        proto, login, from, from_domain, status, event_type, alt_event_type, event_count, \
                                                                                        unique_id, channel_state, answer_state, call_direction)

Definition at line 364 of file switch_event.h.

switch_event_create_subclass

#define switch_event_create_subclass	(		_e,
			_eid,
			_sn
	)		switch_event_create_subclass_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, _e, _eid, _sn)

Definition at line 153 of file switch_event.h.

Referenced by Event::Event(), ivr_send_event(), switch_core_hash_delete_multi(), switch_event_create_pres_in_detailed(), switch_event_dup(), switch_event_dup_reply(), and switch_limit_fire_event().

switch_event_del_header

#define switch_event_del_header	(		_e,
			_h
	)		switch_event_del_header_val(_e, _h, NULL)

Definition at line 212 of file switch_event.h.

Referenced by Event::delHeader(), switch_channel_add_variable_var_check(), switch_channel_process_export(), switch_channel_set_log_tag(), switch_channel_set_variable_printf(), switch_channel_set_variable_strip_quotes_var_check(), switch_channel_set_variable_var_check(), switch_core_session_outgoing_channel(), switch_core_set_var_conditional(), switch_core_set_variable(), switch_event_base_add_header(), switch_event_channel_permission_modify(), switch_event_create_json(), switch_event_set_subclass_name(), and switch_ivr_originate().

switch_event_expand_headers

#define switch_event_expand_headers	(		_event,
			_in
	)		switch_event_expand_headers_check(_event, _in, NULL, NULL, 0)

Definition at line 355 of file switch_event.h.

Referenced by api_hook(), switch_core_execute_chat_app(), and switch_ivr_phrase_macro_event().

switch_event_fire

#define switch_event_fire

(

event

)

switch_event_fire_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, event, NULL)

Fire an event filling in most of the arguements with obvious values.

Parameters

event

the event to send (will be nulled on success)

Returns

SWITCH_STATUS_SUCCESS if the operation was successful

Note

the body supplied by this function will supersede an existing body the event may have

Definition at line 413 of file switch_event.h.

Referenced by check_ip(), do_chat_send(), Event::fire(), generate_on_dtmf(), handle_SIGHUP(), hanguphook(), ivr_send_event(), record_callback(), rtp_common_write(), send_heartbeat(), send_record_stop_event(), signal_bridge_on_hangup(), signal_bridge_on_hibernate(), speech_thread(), switch_api_execute(), switch_channel_check_device_state(), switch_channel_clear_device_record(), switch_channel_dequeue_dtmf(), switch_channel_flip_cid(), switch_channel_mark_hold(), switch_channel_perform_hangup(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_channel_perform_presence(), switch_channel_perform_set_callstate(), switch_channel_perform_set_running_state(), switch_console_printf(), switch_core_destroy(), switch_core_init_and_modload(), switch_core_media_bug_add(), switch_core_media_bug_destroy(), switch_core_media_read_frame(), switch_core_session_ctl(), switch_core_session_exec(), switch_core_session_outgoing_channel(), switch_core_session_perform_destroy(), switch_core_session_read_frame(), switch_core_session_read_text_frame(), switch_core_session_reporting_state(), switch_core_session_run(), switch_core_session_set_read_codec(), switch_core_session_set_real_read_codec(), switch_core_session_set_uuid(), switch_core_session_set_video_read_codec(), switch_core_session_set_video_write_codec(), switch_core_session_set_write_codec(), switch_ivr_hold(), switch_ivr_multi_threaded_bridge(), switch_ivr_park(), switch_ivr_parse_next_event(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_signal_bridge(), switch_ivr_unhold(), switch_limit_fire_event(), switch_loadable_module_init(), switch_loadable_module_process(), switch_loadable_module_unprocess(), switch_log_meta_vprintf(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_nat_multicast_runtime(), switch_odbc_handle_disconnect(), switch_rtp_add_crypto_key(), switch_scheduler_task_thread(), switch_send_rtcp_event(), SWITCH_STANDARD_SCHED_FUNC(), switch_xml_open_root(), text_callback(), tone_detect_callback(), and uuid_bridge_on_soft_execute().

switch_event_fire_data

#define switch_event_fire_data	(		event,
			data
	)		switch_event_fire_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, event, data)

Fire an event filling in most of the arguements with obvious values and allowing user_data to be sent.

Parameters

event	the event to send (will be nulled on success)
data	user data to send to the event handlers

Returns

SWITCH_STATUS_SUCCESS if the operation was successful

Note

the body supplied by this function will supersede an existing body the event may have

Definition at line 422 of file switch_event.h.

switch_event_free_subclass

#define switch_event_free_subclass

(

subclass_name

)

switch_event_free_subclass_detailed(__FILE__, subclass_name)

Definition at line 376 of file switch_event.h.

switch_event_get_header

#define switch_event_get_header	(		_e,
			_h
	)		switch_event_get_header_idx(_e, _h, -1)

Definition at line 172 of file switch_event.h.

Referenced by Event::chat_send(), core_event_handler(), do_chat_send(), find_user_in_tag(), generate_m(), get_recording_var(), Event::getHeader(), parse_presence_data_cols(), play_and_detect_input_callback(), record_callback(), record_helper_post_process(), send_record_stop_event(), switch_channel_event_set_extended_data(), switch_channel_get_scope_variables(), switch_collect_input_callback(), switch_core_get_variable(), switch_core_get_variable_dup(), switch_core_get_variable_pdup(), switch_core_media_gen_local_sdp(), switch_core_perform_file_open(), switch_core_session_outgoing_channel(), switch_core_set_var_conditional(), switch_core_set_variable(), switch_dial_leg_get_var(), switch_event_channel_permission_verify(), switch_event_check_permission_list(), switch_events_match(), switch_ivr_eavesdrop_session(), switch_ivr_originate(), switch_ivr_parse_event(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_json_add_presence_data_cols(), switch_msrp_msg_get_header(), switch_say_file_handle_get_variable(), and switch_xml_config_parse_event().

switch_event_get_header_nil

#define switch_event_get_header_nil	(		e,
			h
	)		switch_str_nil(switch_event_get_header(e,h))

Definition at line 174 of file switch_event.h.

Referenced by core_event_handler(), and parse_presence_data_cols().

switch_event_prep_for_delivery

#define switch_event_prep_for_delivery

(

_event

)

switch_event_prep_for_delivery_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, _event)

Definition at line 243 of file switch_event.h.

Referenced by switch_ivr_parse_next_event().

switch_event_reserve_subclass

#define switch_event_reserve_subclass

(

subclass_name

)

switch_event_reserve_subclass_detailed(__FILE__, subclass_name)

Reserve a subclass assuming the owner string is the current filename.

Parameters

subclass_name

the subclass name to reserve

Returns

SWITCH_STATUS_SUCCESS if the operation was successful

Note

the body supplied by this function will supersede an existing body the event may have

Definition at line 375 of file switch_event.h.

Referenced by switch_limit_init().

switch_event_safe_destroy

#define switch_event_safe_destroy

(

_event

)

if (_event) switch_event_destroy(&_event)

Definition at line 219 of file switch_event.h.

Referenced by record_helper_destroy().

SWITCH_EVENT_SUBCLASS_ANY

#define SWITCH_EVENT_SUBCLASS_ANY   NULL

Definition at line 128 of file switch_event.h.

Referenced by switch_core_sqldb_start(), and switch_event_create_pres_in_detailed().

Typedef Documentation

switch_live_array_command_handler_t

typedef void(* switch_live_array_command_handler_t) (switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data)

Definition at line 437 of file switch_event.h.

switch_serial_event_header_t

typedef struct switch_serial_event_header_s switch_serial_event_header_t

switch_serial_event_t

typedef struct switch_serial_event_s switch_serial_event_t

Enumeration Type Documentation

switch_event_flag_t

enum switch_event_flag_t

Enumerator
EF_UNIQ_HEADERS
EF_NO_CHAT_EXEC
EF_DEFAULT_ALLOW

Definition at line 119 of file switch_event.h.

             {
        EF_UNIQ_HEADERS = (1 << 0),
        EF_NO_CHAT_EXEC = (1 << 1),
        EF_DEFAULT_ALLOW = (1 << 2)
} switch_event_flag_t;

Function Documentation

switch_event_add_array()

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

Definition at line 962 of file switch_event.c.

References memset(), switch_assert, switch_event_add_header_string(), switch_separate_string_string(), and SWITCH_STACK_PUSH.

Referenced by switch_event_base_add_header().

{
        char *data;
        char **array;
        int max = 0;
        int len;
        const char *p;
        int i;

        if (strlen(val) < 8) {
                return -1;
        }

        p = val + 7;

        max = 1;

        while((p = strstr(p, "|:"))) {
                max++;
                p += 2;
        }

        data = strdup(val + 7);

        len = (sizeof(char *) * max) + 1;
        switch_assert(len);

        array = malloc(len);
        switch_assert(array);
        memset(array, 0, len);

        switch_separate_string_string(data, "|:", array, max);

        for(i = 0; i < max; i++) {
                switch_event_add_header_string(event, SWITCH_STACK_PUSH, var, array[i]);
        }

        free(array);
        free(data);

        return 0;
}

switch_event_add_body()

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

Add a body to an event.

Parameters

event	the event to add to body to
fmt	optional body of the event (varargs see standard sprintf family)

Returns

SWITCH_STATUS_SUCCESS if the body was added to the event

Note

the body parameter can be shadowed by the switch_event_reserve_subclass_detailed function

Referenced by Event::addBody(), speech_thread(), switch_core_chat_send_args(), switch_core_session_read_text_frame(), switch_core_session_reporting_state(), and text_callback().

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,
			...
	)

Add a header to an event.

Parameters

event	the event to add the header to
stack	the stack sense (stack it on the top or on the bottom)
header_name	the name of the header to add
fmt	the value of the header (varargs see standard sprintf family)

Returns

SWITCH_STATUS_SUCCESS if the header was added

Referenced by check_ip(), generate_on_dtmf(), handle_SIGHUP(), send_heartbeat(), switch_caller_profile_event_set_data(), switch_channel_check_device_state(), switch_channel_dequeue_dtmf(), switch_channel_event_set_basic_data(), switch_channel_perform_presence(), switch_channel_perform_set_callstate(), switch_console_printf(), switch_core_destroy(), switch_core_init_and_modload(), switch_core_media_bug_add(), switch_core_media_bug_destroy(), switch_core_session_ctl(), switch_core_session_set_read_codec(), switch_core_session_set_real_read_codec(), switch_core_session_set_video_read_codec(), switch_core_session_set_video_write_codec(), switch_core_session_set_write_codec(), switch_ivr_broadcast(), switch_limit_fire_event(), switch_log_meta_vprintf(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_odbc_handle_disconnect(), switch_rtp_add_crypto_key(), switch_scheduler_add_task_ex(), switch_scheduler_execute(), and task_thread_loop().

switch_event_add_header_string()

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.

Parameters

event	the event to add the header to
stack	the stack sense (stack it on the top or on the bottom)
header_name	the name of the header to add
data	the value of the header

Returns

SWITCH_STATUS_SUCCESS if the header was added

Definition at line 1247 of file switch_event.c.

References DUP, switch_event_base_add_header(), and SWITCH_STATUS_GENERR.

Referenced by Event::addHeader(), check_ip(), do_chat_send(), generate_on_dtmf(), ivr_send_event(), merge_recording_variables(), record_callback(), send_record_stop_event(), signal_bridge_on_hangup(), signal_bridge_on_hibernate(), speech_thread(), switch_api_execute(), switch_caller_profile_event_set_data(), switch_channel_add_variable_var_check(), switch_channel_check_device_state(), switch_channel_clear_device_record(), switch_channel_event_set_basic_data(), switch_channel_event_set_extended_data(), switch_channel_flip_cid(), switch_channel_get_scope_variables(), switch_channel_get_variables_prefix(), switch_channel_perform_presence(), switch_channel_perform_set_callstate(), switch_channel_process_export(), switch_channel_set_log_tag(), switch_channel_set_variable_strip_quotes_var_check(), switch_channel_set_variable_var_check(), switch_console_printf(), switch_core_chat_deliver(), switch_core_chat_send(), switch_core_chat_send_args(), switch_core_hash_delete_multi(), switch_core_media_read_frame(), switch_core_media_sdp_map(), switch_core_session_exec(), switch_core_session_execute_application_async(), switch_core_session_hupall_matching_var_ans(), switch_core_session_reporting_state(), switch_core_session_set_read_codec(), switch_core_session_set_real_read_codec(), switch_core_session_set_uuid(), switch_core_session_set_video_read_codec(), switch_core_session_set_video_write_codec(), switch_core_session_set_write_codec(), switch_core_set_variable(), switch_dial_handle_add_global_var(), switch_dial_handle_add_leg_var(), switch_dial_handle_list_add_global_var(), switch_event_add_array(), switch_event_add_presence_data_cols(), switch_event_binary_deserialize(), switch_event_channel_permission_modify(), switch_event_create_array_pair(), switch_event_create_brackets(), switch_event_create_json(), switch_event_create_pres_in_detailed(), switch_event_create_subclass_detailed(), switch_event_dup(), switch_event_dup_reply(), switch_event_import_xml(), switch_event_merge(), switch_event_prep_for_delivery_detailed(), switch_event_set_priority(), switch_event_set_subclass_name(), switch_http_parse_header(), switch_http_parse_qs(), switch_ivr_broadcast(), switch_ivr_check_presence_mapping(), switch_ivr_create_message_reply(), switch_ivr_enterprise_originate(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_phrase_macro_event(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_say(), switch_ivr_say_string(), switch_ivr_signal_bridge(), switch_limit_fire_event(), switch_load_network_lists(), switch_loadable_module_process(), switch_loadable_module_unprocess(), switch_log_meta_vprintf(), switch_log_node_to_json(), switch_msrp_msg_add_header(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_nat_multicast_runtime(), switch_regex_set_event_header_callback(), switch_rtp_add_crypto_key(), switch_scheduler_add_task_ex(), switch_scheduler_execute(), switch_send_rtcp_event(), switch_xml_locate_domain(), switch_xml_locate_group(), switch_xml_locate_language(), switch_xml_locate_user(), task_thread_loop(), tone_detect_callback(), and uuid_bridge_on_soft_execute().

{
        if (data) {
                return switch_event_base_add_header(event, stack, header_name, DUP(data));
        }
        return SWITCH_STATUS_GENERR;
}

switch_event_add_header_string_nodup()

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

Definition at line 1239 of file switch_event.c.

References switch_event_base_add_header(), and SWITCH_STATUS_GENERR.

Referenced by switch_core_set_var_conditional().

{
        if (data) {
                return switch_event_base_add_header(event, stack, header_name, (char *)data);
        }
        return SWITCH_STATUS_GENERR;
}

switch_event_add_presence_data_cols()

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

Definition at line 2694 of file switch_event.c.

References switch_channel_get_variable, switch_event_add_header_string(), switch_safe_free, switch_snprintf(), switch_split, and SWITCH_STACK_BOTTOM.

Referenced by signal_bridge_on_hangup(), signal_bridge_on_hibernate(), switch_channel_event_set_basic_data(), and switch_ivr_multi_threaded_bridge().

{
        const char *data;

        if (!prefix) prefix = "";

        if ((data = switch_channel_get_variable(channel, "presence_data_cols"))) {
                char *cols[128] = { 0 };
                char header_name[128] = "";
                int col_count = 0, i = 0;
                char *data_copy = NULL;

                data_copy = strdup(data);

                col_count = switch_split(data_copy, ':', cols);

                for (i = 0; i < col_count; i++) {
                        const char *val = NULL;
                        switch_snprintf(header_name, sizeof(header_name), "%s%s", prefix, cols[i]);

                        val = switch_channel_get_variable(channel, cols[i]);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, val);
                }

                switch_safe_free(data_copy);
        }

}

switch_event_binary_deserialize()

switch_status_t switch_event_binary_deserialize	(	switch_event_t **	eventp,
		void **	data,
		switch_size_t	len,
		switch_bool_t	duplicate
	)

Render a string representation of an event suitable for printing or network transport.

Parameters

event	the event to render
str	a string pointer to point at the allocated data
encode	url encode the headers

Returns

SWITCH_STATUS_SUCCESS if the operation was successful

Note

you must free the resulting string when you are finished with it

Definition at line 1430 of file switch_event.c.

References switch_serial_event_s::body, switch_serial_event_s::event_id, switch_serial_event_s::flags, switch_serial_event_header_s::name, switch_serial_event_s::owner, switch_serial_event_s::priority, switch_serial_event_s::subclass_name, switch_assert, switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create, SWITCH_SERIALIZED_EVENT_MAP, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_serial_event_header_s::value.

{
#ifdef HAVE_LIBTPL
        switch_event_t *event;
        tpl_node *tn;
        switch_serial_event_t e;
        switch_serial_event_header_t sh;
        int how = TPL_MEM;

        switch_event_create(&event, SWITCH_EVENT_CLONE);
        switch_assert(event);

        tn = tpl_map(SWITCH_SERIALIZED_EVENT_MAP, &e, &sh);

        if (!destroy) {
                how |= TPL_EXCESS_OK;
        }

        tpl_load(tn, how, data, len);

        tpl_unpack(tn, 0);

        event->event_id = e.event_id;
        event->priority = e.priority;
        event->flags = e.flags;

        event->owner = e.owner;
        event->subclass_name = e.subclass_name;
        event->body = e.body;


        while (tpl_unpack(tn, 1)) {
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, sh.name, sh.value);
        }

        *eventp = event;

        tpl_free(tn);

        if (destroy) {
                free(*data);
        }

        *data = NULL;

        return SWITCH_STATUS_SUCCESS;
#else
        return SWITCH_STATUS_FALSE;
#endif

}

switch_event_binary_serialize()

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

Definition at line 1482 of file switch_event.c.

References switch_serial_event_s::body, switch_serial_event_s::event_id, switch_serial_event_s::flags, switch_event::headers, switch_event_header::idx, switch_event_header::name, switch_serial_event_header_s::name, switch_event_header::next, switch_serial_event_s::owner, switch_serial_event_s::priority, switch_serial_event_s::subclass_name, SWITCH_SERIALIZED_EVENT_MAP, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_event_header::value, and switch_serial_event_header_s::value.

{
#ifdef HAVE_LIBTPL
        tpl_node *tn;
        switch_serial_event_t e;
        switch_serial_event_header_t sh;
        switch_event_header_t *eh;
        int how = TPL_MEM;

        e.event_id = event->event_id;
        e.priority = event->priority;
        e.flags = event->flags;

        e.owner = event->owner;
        e.subclass_name = event->subclass_name;
        e.body = event->body;

        tn = tpl_map(SWITCH_SERIALIZED_EVENT_MAP, &e, &sh);

        tpl_pack(tn, 0);

        for (eh = event->headers; eh; eh = eh->next) {
                if (eh->idx) continue;  // no arrays yet

                sh.name = eh->name;
                sh.value = eh->value;

                tpl_pack(tn, 1);
        }

        if (*len > 0) {
                how |= TPL_PREALLOCD;
        }

        tpl_dump(tn, how, data, len);

        tpl_free(tn);

        return SWITCH_STATUS_SUCCESS;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_event_bind()

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.

Parameters

id	an identifier token of the binder
event	the event enumeration to bind to
subclass_name	the event subclass to bind to in the case if SWITCH_EVENT_CUSTOM
callback	the callback functon to bind
user_data	optional user specific data to pass whenever the callback is invoked

Returns

SWITCH_STATUS_SUCCESS if the event was binded

Definition at line 2127 of file switch_event.c.

References switch_event_bind_removable().

Referenced by switch_core_sqldb_start().

{
        return switch_event_bind_removable(id, event, subclass_name, callback, user_data, NULL);
}

switch_event_bind_removable()

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.

Parameters

id	an identifier token of the binder
event	the event enumeration to bind to
subclass_name	the event subclass to bind to in the case if SWITCH_EVENT_CUSTOM
callback	the callback functon to bind
user_data	optional user specific data to pass whenever the callback is invoked
node	bind handle to later remove the binding.

Returns

SWITCH_STATUS_SUCCESS if the event was binded

Definition at line 2060 of file switch_event.c.

References switch_event_subclass::bind, BLOCK, switch_event_node::callback, CUSTOM_HASH_MUTEX, DUP, switch_event_node::event_id, switch_event_node::id, switch_event_node::next, RUNTIME_POOL, RWLOCK, switch_event_node::subclass_name, switch_assert, SWITCH_CHANNEL_LOG, switch_core_hash_find(), SWITCH_EVENT_ALL, switch_event_reserve_subclass_detailed(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), switch_zmalloc, and switch_event_node::user_data.

Referenced by EventConsumer::bind(), switch_event_bind(), and SWITCH_MODULE_LOAD_FUNCTION().

{
        switch_event_node_t *event_node;
        switch_event_subclass_t *subclass = NULL;

        switch_assert(BLOCK != NULL);
        switch_assert(RUNTIME_POOL != NULL);

        if (node) {
                *node = NULL;
        }

        if (subclass_name) {
                switch_mutex_lock(CUSTOM_HASH_MUTEX);

                if (!(subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name))) {
                        if (switch_event_reserve_subclass_detailed(id, subclass_name) == SWITCH_STATUS_SUCCESS) {
                                if ((subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name))) {
                                        subclass->bind = 1;
                                }
                        }
                }

                switch_mutex_unlock(CUSTOM_HASH_MUTEX);

                if (!subclass) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not reserve subclass. '%s'\n", subclass_name);

                        return SWITCH_STATUS_FALSE;
                }
        }

        if (event <= SWITCH_EVENT_ALL) {
                switch_zmalloc(event_node, sizeof(*event_node));
                switch_thread_rwlock_wrlock(RWLOCK);
                switch_mutex_lock(BLOCK);
                /* <LOCKED> ----------------------------------------------- */
                event_node->id = DUP(id);
                event_node->event_id = event;
                if (subclass_name) {
                        event_node->subclass_name = DUP(subclass_name);
                }

                event_node->callback = callback;
                event_node->user_data = user_data;

                if (EVENT_NODES[event]) {
                        event_node->next = EVENT_NODES[event];
                }

                EVENT_NODES[event] = event_node;
                switch_mutex_unlock(BLOCK);
                switch_thread_rwlock_unlock(RWLOCK);
                /* </LOCKED> ----------------------------------------------- */

                if (node) {
                        *node = event_node;
                }

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_MEMERR;
}

switch_event_build_param_string()

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

Definition at line 2550 of file switch_event.c.

References switch_stream_handle::data, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_assert, switch_core_hash_find(), switch_safe_free, SWITCH_STANDARD_STREAM, switch_url_encode(), switch_event_header::value, switch_stream_handle::write_function, and zstr.

{
        switch_stream_handle_t stream = { 0 };
        switch_size_t encode_len = 1024, new_len = 0;
        char *encode_buf = NULL;
        const char *prof[12] = { 0 }, *prof_names[12] = {
        0};
        char *e = NULL;
        switch_event_header_t *hi;
        uint32_t x = 0;
        void *data = NULL;

        SWITCH_STANDARD_STREAM(stream);

        if (prefix) {
                stream.write_function(&stream, "%s&", prefix);
        }

        encode_buf = malloc(encode_len);
        switch_assert(encode_buf);



        for (x = 0; prof[x]; x++) {
                if (zstr(prof[x])) {
                        continue;
                }
                new_len = (strlen(prof[x]) * 3) + 1;
                if (encode_len < new_len) {
                        char *tmp;

                        encode_len = new_len;

                        if (!(tmp = realloc(encode_buf, encode_len))) {
                                abort();
                        }

                        encode_buf = tmp;
                }
                switch_url_encode(prof[x], encode_buf, encode_len);
                stream.write_function(&stream, "%s=%s&", prof_names[x], encode_buf);
        }

        if (event) {
                if ((hi = event->headers)) {

                        for (; hi; hi = hi->next) {
                                char *var = hi->name;
                                char *val = hi->value;

                                if (vars_map != NULL) {
                                        if ((data = switch_core_hash_find(vars_map, var)) == NULL || strcasecmp(((char *) data), "enabled"))
                                                continue;

                                }

                                new_len = (strlen((char *) val) * 3) + 1;
                                if (encode_len < new_len) {
                                        char *tmp;

                                        encode_len = new_len;

                                        tmp = realloc(encode_buf, encode_len);
                                        switch_assert(tmp);
                                        encode_buf = tmp;
                                }

                                switch_url_encode((char *) val, encode_buf, encode_len);
                                stream.write_function(&stream, "%s=%s&", (char *) var, encode_buf);

                        }
                }
        }

        e = (char *) stream.data + (strlen((char *) stream.data) - 1);

        if (e && *e == '&') {
                *e = '\0';
        }

        switch_safe_free(encode_buf);

        return stream.data;
}

switch_event_channel_bind()

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
	)

Definition at line 3129 of file switch_event.c.

References event_channel_manager, switch_assert, switch_event_channel_sub_channel(), SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_assert(id);

        if (!*id) {
                switch_thread_rwlock_wrlock(event_channel_manager.rwlock);
                *id = event_channel_manager.ID++;
                switch_thread_rwlock_unlock(event_channel_manager.rwlock);
        }

        status = switch_event_channel_sub_channel(event_channel, func, *id, user_data);

        return status;
}

switch_event_channel_broadcast()

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

Definition at line 3049 of file switch_event.c.

References switch_thread_data_s::alloc, destroy_ecd(), DISPATCH_QUEUE_LEN, event_channel_data_t::event_channel, EVENT_CHANNEL_DISPATCH_QUEUE, EVENT_CHANNEL_DISPATCH_THREAD_COUNT, EVENT_CHANNEL_DISPATCH_THREAD_STARTING, EVENT_QUEUE_MUTEX, switch_thread_data_s::func, switch_event_node::id, event_channel_data_t::id, event_channel_data_t::json, event_channel_data_t::key, MAX_DISPATCH, switch_thread_data_s::obj, switch_thread_data_s::pool, switch_assert, SWITCH_CHANNEL_LOG, switch_event_channel_deliver_thread(), SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_create(), switch_queue_trypush(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_pool_launch_thread(), switch_zmalloc, SYSTEM_RUNNING, and THRUNTIME_POOL.

Referenced by la_broadcast(), and switch_live_array_bootstrap().

{
        event_channel_data_t *ecd = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int launch = 0;

        if (!SYSTEM_RUNNING) {
                cJSON_Delete(*json);
                *json = NULL;
                return SWITCH_STATUS_FALSE;
        }

        switch_zmalloc(ecd, sizeof(*ecd));

        ecd->event_channel = strdup(event_channel);
        ecd->json = *json;
        ecd->key = strdup(key);
        ecd->id = id;

        *json = NULL;

        switch_mutex_lock(EVENT_QUEUE_MUTEX);
        if (!EVENT_CHANNEL_DISPATCH_THREAD_COUNT && !EVENT_CHANNEL_DISPATCH_THREAD_STARTING && SYSTEM_RUNNING) {
                EVENT_CHANNEL_DISPATCH_THREAD_STARTING = 1;
                launch = 1;
        }
        switch_mutex_unlock(EVENT_QUEUE_MUTEX);

        if (launch) {
                switch_thread_data_t *td;

                if (!EVENT_CHANNEL_DISPATCH_QUEUE) {
                        switch_queue_create(&EVENT_CHANNEL_DISPATCH_QUEUE, DISPATCH_QUEUE_LEN * MAX_DISPATCH, THRUNTIME_POOL);
                }

                td = malloc(sizeof(*td));
                switch_assert(td);

                td->alloc = 1;
                td->func = switch_event_channel_deliver_thread;
                td->obj = EVENT_CHANNEL_DISPATCH_QUEUE;
                td->pool = NULL;

                switch_thread_pool_launch_thread(&td);
        }

        if ((status = switch_queue_trypush(EVENT_CHANNEL_DISPATCH_QUEUE, ecd)) != SWITCH_STATUS_SUCCESS) {
                cJSON_Delete(ecd->json);
                ecd->json = NULL;
                destroy_ecd(&ecd);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Event Channel Queue failure for channel %s, status = %d\n", event_channel, status);
        } else {
                ecd = NULL;
        }

        return status;
}

switch_event_channel_deliver()

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

Definition at line 3107 of file switch_event.c.

References ecd_deliver(), event_channel_data_t::event_channel, switch_event_node::id, event_channel_data_t::id, event_channel_data_t::json, event_channel_data_t::key, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

{
        event_channel_data_t *ecd = NULL;
        switch_zmalloc(ecd, sizeof(*ecd));

        ecd->event_channel = strdup(event_channel);
        ecd->json = *json;
        ecd->key = strdup(key);
        ecd->id = id;

        *json = NULL;

        ecd_deliver(&ecd);

        return SWITCH_STATUS_SUCCESS;
}

switch_event_channel_permission_clear()

void switch_event_channel_permission_clear

(

const char *

cookie

)

Definition at line 3184 of file switch_event.c.

References event_channel_manager, switch_core_hash_delete(), switch_core_hash_find(), switch_event_destroy(), switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_event_t *vals;

        switch_thread_rwlock_wrlock(event_channel_manager.rwlock);
        if ((vals = switch_core_hash_find(event_channel_manager.perm_hash, cookie))) {
                switch_core_hash_delete(event_channel_manager.perm_hash, cookie);
                switch_event_destroy(&vals);
        }
        switch_thread_rwlock_unlock(event_channel_manager.rwlock);
}

switch_event_channel_permission_modify()

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

Definition at line 3160 of file switch_event.c.

References event_channel_manager, switch_core_hash_find(), switch_core_hash_insert, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_event_del_header, SWITCH_STACK_BOTTOM, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_event_t *vals;

        switch_thread_rwlock_wrlock(event_channel_manager.rwlock);
        if (!(vals = switch_core_hash_find(event_channel_manager.perm_hash, cookie))) {
                if (!set) goto end;

                switch_event_create_plain(&vals, SWITCH_EVENT_CHANNEL_DATA);
                switch_core_hash_insert(event_channel_manager.perm_hash, cookie, vals);
        }

        if (set) {
                switch_event_add_header_string(vals, SWITCH_STACK_BOTTOM, event_channel, "true");
        } else {
                switch_event_del_header(vals, event_channel);
        }


 end:

        switch_thread_rwlock_unlock(event_channel_manager.rwlock);
}

switch_event_channel_permission_verify()

switch_bool_t switch_event_channel_permission_verify	(	const char *	cookie,
		const char *	event_channel
	)

Definition at line 3146 of file switch_event.c.

References event_channel_manager, switch_core_hash_find(), switch_event_get_header, SWITCH_FALSE, switch_thread_rwlock_rdlock(), switch_thread_rwlock_unlock(), and switch_true().

{
        switch_event_t *vals;
        switch_bool_t r = SWITCH_FALSE;

        switch_thread_rwlock_rdlock(event_channel_manager.rwlock);
        if ((vals = switch_core_hash_find(event_channel_manager.perm_hash, cookie))) {
                r = switch_true(switch_event_get_header(vals, event_channel));
        }
        switch_thread_rwlock_unlock(event_channel_manager.rwlock);

        return r;
}

switch_event_channel_unbind()

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

Definition at line 3124 of file switch_event.c.

References switch_event_channel_unsub_channel().

{
        return switch_event_channel_unsub_channel(func, event_channel, user_data);
}

switch_event_check_permission_list()

int switch_event_check_permission_list	(	switch_event_t *	list,
		const char *	name
	)

Definition at line 2635 of file switch_event.c.

References EF_DEFAULT_ALLOW, switch_event::headers, switch_event_get_header, and switch_test_flag.

Referenced by switch_channel_expand_variables_check(), and switch_event_expand_headers_check().

{
        const char *v;
        int r = 0;
        int default_allow = 0;

        if (!list) {
                return 1;
        }

        default_allow = switch_test_flag(list, EF_DEFAULT_ALLOW);

        if (!list->headers) {
                return default_allow;
        }

        if ((v = switch_event_get_header(list, name))) {
                if (*v == 'd') {
                        r = 0;
                } else {
                        r = 1;
                }
        } else {
                r = default_allow;
        }

        return r;
}

switch_event_create_array_pair()

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

Definition at line 1642 of file switch_event.c.

References name, switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_str_nil, and zstr.

Referenced by helper_callback().

{
        int r;
        char *name, *val;

        switch_event_create(event, SWITCH_EVENT_CLONE);

        for (r = 0; r < len; r++) {
                val = switch_str_nil(vals[r]);
                name = names[r];

                if (zstr(name)) {
                        name = "Unknown";
                }

                switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, name, val);
        }

        return SWITCH_STATUS_SUCCESS;

}

switch_event_create_brackets()

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
	)

Definition at line 1664 of file switch_event.c.

References EF_UNIQ_HEADERS, switch_event::flags, switch_event_node::next, SWITCH_CHANNEL_LOG, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_find_end_paren(), SWITCH_LOG_DEBUG1, switch_log_printf(), switch_separate_string(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_strchr_strict().

Referenced by switch_core_perform_file_open(), switch_core_session_exec(), switch_ivr_enterprise_originate(), switch_ivr_originate(), and switch_log_node_to_json().

{
        char *vdata, *vdatap = NULL;
        char *end, *check_a, *check_b;
        switch_event_t *e = *event;
        char *var_array[1024] = { 0 };
        int var_count = 0;
        char *next = NULL, *vnext = NULL;

        if (dup) {
                vdatap = strdup(data);
                vdata = vdatap;
        } else {
                vdata = data;
        }

        end = switch_find_end_paren(vdata, a, b);

        check_a = end;

        while (check_a && (check_b = switch_strchr_strict(check_a, a, " "))) {
                if ((check_b = switch_find_end_paren(check_b, a, b))) {
                        check_a = check_b;
                }
        }

        if (check_a) end = check_a;

        if (end) {
                next = end;
                vdata++;
                *end++ = '\0';
        } else {
                if (dup) {
                        free(vdatap);
                }
                return SWITCH_STATUS_FALSE;
        }

        if (!e) {
                switch_event_create_plain(&e, SWITCH_EVENT_CHANNEL_DATA);
                e->flags |= EF_UNIQ_HEADERS;
        }


        for (;;) {
                if (next) {
                        char *pnext;

                        *next++ = '\0';

                        if ((pnext = switch_strchr_strict(next, a, " "))) {
                                next = pnext + 1;
                        }

                        vnext = switch_find_end_paren(next, a, b);
                        next = NULL;
                }


                if (vdata) {
                        if (*vdata == '^' && *(vdata + 1) == '^') {
                                vdata += 2;
                                c = *vdata++;
                        }
                }

                if ((var_count = switch_separate_string(vdata, c, var_array, (sizeof(var_array) / sizeof(var_array[0]))))) {
                        int x = 0;
                        for (x = 0; x < var_count; x++) {
                                char *inner_var_array[2] = { 0 };

                                if (switch_separate_string(var_array[x], '=', inner_var_array, (sizeof(inner_var_array) / sizeof(inner_var_array[0]))) == 2) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Parsing variable [%s]=[%s]\n", inner_var_array[0], inner_var_array[1]);
                                        switch_event_add_header_string(e, SWITCH_STACK_BOTTOM, inner_var_array[0], inner_var_array[1]);
                                }
                        }
                }

                if (vnext) {
                        vdata = vnext;
                        vnext = NULL;
                } else {
                        break;
                }

        }

        *event = e;

        if (dup) {
                *new_data = strdup(end);
                free(vdatap);
        } else {
                *new_data = end;
        }

        return SWITCH_STATUS_SUCCESS;

}

switch_event_create_json()

switch_status_t switch_event_create_json	(	switch_event_t **	event,
		const char *	json
	)

Definition at line 1767 of file switch_event.c.

References cJSON::child, cJSON_Array, cJSON_String, switch_event::event_id, item, name, cJSON::next, cJSON::string, switch_event_add_body(), switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create, switch_event_del_header, switch_name_event(), SWITCH_STACK_BOTTOM, SWITCH_STACK_PUSH, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_VA_NONE, cJSON::type, value, and cJSON::valuestring.

Referenced by Event::Event().

{
        switch_event_t *new_event;
        cJSON *cj, *cjp;


        if (!(cj = cJSON_Parse(json))) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_event_create(&new_event, SWITCH_EVENT_CLONE) != SWITCH_STATUS_SUCCESS) {
                cJSON_Delete(cj);
                return SWITCH_STATUS_FALSE;
        }

        for (cjp = cj->child; cjp; cjp = cjp->next) {
                char *name = cjp->string;
                char *value = cjp->valuestring;

                if (name && value) {
                        if (!strcasecmp(name, "_body")) {
                                switch_event_add_body(new_event, value, SWITCH_VA_NONE);
                        } else {
                                if (!strcasecmp(name, "event-name")) {
                                        switch_event_del_header(new_event, "event-name");
                                        switch_name_event(value, &new_event->event_id);
                                }

                                switch_event_add_header_string(new_event, SWITCH_STACK_BOTTOM, name, value);
                        }

                } else if (name) {
                        if (cjp->type == cJSON_Array) {
                                int i, x = cJSON_GetArraySize(cjp);

                                for (i = 0; i < x; i++) {
                                        cJSON *item = cJSON_GetArrayItem(cjp, i);

                                        if (item && item->type == cJSON_String && item->valuestring) {
                                                switch_event_add_header_string(new_event, SWITCH_STACK_PUSH, name, item->valuestring);
                                        }
                                }
                        }
                }
        }

        cJSON_Delete(cj);
        *event = new_event;
        return SWITCH_STATUS_SUCCESS;
}

switch_event_create_plain()

static switch_status_t switch_event_create_plain ( switch_event_t **  event, switch_event_types_t  event_id  )

inlinestatic

Definition at line 386 of file switch_event.h.

References EF_UNIQ_HEADERS, switch_event_node::event_id, SWITCH_DECLARE, SWITCH_EVENT_CHANNEL_DATA, SWITCH_EVENT_CLONE, switch_event_create, switch_event_deliver(), SWITCH_EVENT_REQUEST_PARAMS, and SWITCH_STATUS_SUCCESS.

Referenced by switch_channel_alloc(), switch_channel_get_scope_variables(), switch_channel_set_log_tag(), switch_core_init(), switch_core_unset_variables(), switch_dial_handle_add_global_var(), switch_dial_handle_add_leg_var(), switch_dial_handle_list_add_global_var(), switch_event_channel_permission_modify(), switch_event_create_brackets(), switch_ivr_enterprise_originate(), switch_ivr_originate(), switch_ivr_uuid_bridge(), and switch_log_node_to_json().

{
        switch_status_t status = switch_event_create(event, SWITCH_EVENT_CLONE);
        if (status == SWITCH_STATUS_SUCCESS) {
                (*event)->event_id = event_id;

                if (event_id == SWITCH_EVENT_REQUEST_PARAMS || event_id == SWITCH_EVENT_CHANNEL_DATA) {
                        (*event)->flags |= EF_UNIQ_HEADERS;
                }
        }

        return status;
}

switch_event_create_pres_in_detailed()

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

switch_event_create_subclass_detailed()

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.

Parameters

event	a NULL pointer on which to create the event
event_id	the event id enumeration of the desired event
subclass_name	the subclass name for custom event (only valid when event_id is SWITCH_EVENT_CUSTOM)

Returns

SWITCH_STATUS_SUCCESS on success

Definition at line 747 of file switch_event.c.

References ALLOC, DUP, EF_UNIQ_HEADERS, switch_event_node::event_id, memset(), switch_assert, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, SWITCH_EVENT_CLONE, SWITCH_EVENT_CUSTOM, SWITCH_EVENT_MESSAGE, switch_event_prep_for_delivery_detailed(), SWITCH_EVENT_REQUEST_PARAMS, switch_queue_trypop(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_EVENT_RECYCLE
        void *pop;
#endif

        *event = NULL;

        if ((event_id != SWITCH_EVENT_CLONE && event_id != SWITCH_EVENT_CUSTOM) && subclass_name) {
                return SWITCH_STATUS_GENERR;
        }
#ifdef SWITCH_EVENT_RECYCLE
        if (EVENT_RECYCLE_QUEUE && switch_queue_trypop(EVENT_RECYCLE_QUEUE, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                *event = (switch_event_t *) pop;
        } else {
#endif
                *event = ALLOC(sizeof(switch_event_t));
                switch_assert(*event);
#ifdef SWITCH_EVENT_RECYCLE
        }
#endif

        memset(*event, 0, sizeof(switch_event_t));

        if (event_id == SWITCH_EVENT_REQUEST_PARAMS || event_id == SWITCH_EVENT_CHANNEL_DATA || event_id == SWITCH_EVENT_MESSAGE) {
                (*event)->flags |= EF_UNIQ_HEADERS;
        }

        if (event_id != SWITCH_EVENT_CLONE) {
                (*event)->event_id = event_id;
                switch_event_prep_for_delivery_detailed(file, func, line, *event);
        }

        if (subclass_name) {
                (*event)->subclass_name = DUP(subclass_name);
                switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, "Event-Subclass", subclass_name);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_event_del_header_val()

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

Definition at line 872 of file switch_event.c.

References free_header(), switch_event_header::hash, hash, switch_event::last_header, switch_event_header::name, switch_event_header::next, switch_assert, switch_ci_hashfunc_default(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_event_header::value, and zstr.

{
        switch_event_header_t *hp, *lp = NULL, *tp;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int x = 0;
        switch_ssize_t hlen = -1;
        unsigned long hash = 0;

        tp = event->headers;
        hash = switch_ci_hashfunc_default(header_name, &hlen);
        while (tp) {
                hp = tp;
                tp = tp->next;

                x++;
                switch_assert(x < 1000000);

                if ((!hp->hash || hash == hp->hash) && !strcasecmp(header_name, hp->name) && (zstr(val) || !strcmp(hp->value, val))) {
                        if (lp) {
                                lp->next = hp->next;
                        } else {
                                event->headers = hp->next;
                        }
                        if (hp == event->last_header || !hp->next) {
                                event->last_header = lp;
                        }
                        free_header(&hp);
                        status = SWITCH_STATUS_SUCCESS;
                } else {
                        lp = hp;
                }
        }

        return status;
}

switch_event_deliver()

void switch_event_deliver

(

switch_event_t **

event

)

Deliver an event to all of the registered event listeners.

Parameters

event

the event to send (will be nulled)

Note

normaly use switch_event_fire for delivering events (only use this when you wish to deliver the event blocking on your thread)

Definition at line 400 of file switch_event.c.

References switch_event_node::callback, switch_event_node::next, RWLOCK, SWITCH_EVENT_ALL, switch_event_destroy(), switch_events_match(), switch_thread_rwlock_rdlock(), switch_thread_rwlock_unlock(), SYSTEM_RUNNING, and switch_event_node::user_data.

Referenced by switch_event_create_plain(), switch_event_deliver_thread(), and switch_event_dispatch_thread().

{
        switch_event_types_t e;
        switch_event_node_t *node;

        if (SYSTEM_RUNNING) {
                switch_thread_rwlock_rdlock(RWLOCK);
                for (e = (*event)->event_id;; e = SWITCH_EVENT_ALL) {
                        for (node = EVENT_NODES[e]; node; node = node->next) {
                                if (switch_events_match(*event, node)) {
                                        (*event)->bind_user_data = node->user_data;
                                        node->callback(*event);
                                }
                        }

                        if (e == SWITCH_EVENT_ALL) {
                                break;
                        }
                }
                switch_thread_rwlock_unlock(RWLOCK);
        }

        switch_event_destroy(event);
}

switch_event_destroy()

void switch_event_destroy

(

switch_event_t **

event

)

Destroy an event.

Parameters

event

pointer to the pointer to event to destroy

Definition at line 1289 of file switch_event.c.

References switch_event::body, FREE, free_header(), switch_event::headers, switch_event_header::next, switch_event::subclass_name, switch_queue_trypush(), and SWITCH_STATUS_SUCCESS.

Referenced by asr_set_json_text_params(), audio_bridge_thread(), chat_process_event(), EventConsumer::cleanup(), Event::Event(), event_handler(), Event::fire(), CoreSession::flushEvents(), helper_callback(), speech_thread(), switch_channel_api_on(), switch_channel_clear_device_record(), switch_channel_del_variable_prefix(), switch_channel_execute_on(), switch_channel_set_scope_variables(), switch_channel_uninit(), switch_core_destroy(), switch_core_file_close(), switch_core_hash_delete_multi(), switch_core_media_gen_local_sdp(), switch_core_perform_file_open(), switch_core_session_flush_private_events(), switch_core_session_hupall_matching_var_ans(), switch_core_session_perform_destroy(), switch_core_session_receive_event(), switch_core_session_thread(), switch_core_unset_variables(), switch_dial_handle_destroy(), switch_dial_handle_list_destroy(), switch_event_channel_permission_clear(), switch_event_deliver(), switch_event_fire_detailed(), switch_event_shutdown(), switch_http_free_request(), switch_ivr_check_presence_mapping(), switch_ivr_collect_digits_callback(), switch_ivr_eavesdrop_session(), switch_ivr_enterprise_originate(), switch_ivr_gentones(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_phrase_macro_event(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_say(), switch_ivr_say_string(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), switch_ivr_transfer_variable(), switch_ivr_uuid_bridge(), switch_load_network_lists(), switch_log_node_free(), switch_log_node_to_json(), switch_msrp_msg_destroy(), switch_say_file_handle_destroy(), switch_scheduler_task_thread(), switch_xml_config_parse(), switch_xml_locate_domain(), switch_xml_locate_group(), switch_xml_locate_user(), switch_xml_open_root(), and unsub_all_switch_event_channel().

{
        switch_event_t *ep = *event;
        switch_event_header_t *hp, *this;

        if (ep) {
                for (hp = ep->headers; hp;) {
                        this = hp;
                        hp = hp->next;
                        free_header(&this);
                }
                FREE(ep->body);
                FREE(ep->subclass_name);
#ifdef SWITCH_EVENT_RECYCLE
                if (switch_queue_trypush(EVENT_RECYCLE_QUEUE, ep) != SWITCH_STATUS_SUCCESS) {
                        FREE(ep);
                }
#else
                FREE(ep);
#endif

        }
        *event = NULL;
}

switch_event_dup()

switch_status_t switch_event_dup	(	switch_event_t **	event,
		switch_event_t *	todup
	)

Duplicate an event.

Parameters

event	a NULL pointer on which to duplicate the event
todup	an event to duplicate

Returns

SWITCH_STATUS_SUCCESS if the event was duplicated

Definition at line 1334 of file switch_event.c.

References switch_event_header::array, switch_event::bind_user_data, switch_event::body, DUP, switch_event::event_id, switch_event::event_user_data, switch_event::flags, switch_event::headers, switch_event_header::idx, switch_event::key, switch_event_header::name, switch_event_header::next, switch_event::subclass_name, switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create_subclass, SWITCH_STACK_BOTTOM, SWITCH_STACK_PUSH, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and switch_event_header::value.

Referenced by do_chat_send(), event_handler(), Event::fire(), CoreSession::sendEvent(), speech_thread(), switch_channel_get_log_tags(), switch_channel_get_variables(), switch_core_chat_send(), switch_core_get_variables(), switch_core_session_read_text_frame(), switch_dial_handle_dup(), switch_ivr_enterprise_originate(), switch_ivr_originate(), switch_ivr_record_session_event(), switch_log_node_dup(), switch_log_node_to_json(), switch_msrp_msg_dup(), text_callback(), and tone_detect_callback().

{
        switch_event_header_t *hp;

        if (switch_event_create_subclass(event, SWITCH_EVENT_CLONE, todup->subclass_name) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_STATUS_GENERR;
        }

        (*event)->event_id = todup->event_id;
        (*event)->event_user_data = todup->event_user_data;
        (*event)->bind_user_data = todup->bind_user_data;
        (*event)->flags = todup->flags;
        for (hp = todup->headers; hp; hp = hp->next) {
                if (todup->subclass_name && !strcmp(hp->name, "Event-Subclass")) {
                        continue;
                }

                if (hp->idx) {
                        int i;
                        for (i = 0; i < hp->idx; i++) {
                                switch_event_add_header_string(*event, SWITCH_STACK_PUSH, hp->name, hp->array[i]);
                        }
                } else {
                        switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, hp->name, hp->value);
                }
        }

        if (todup->body) {
                (*event)->body = DUP(todup->body);
        }

        (*event)->key = todup->key;

        return SWITCH_STATUS_SUCCESS;
}

switch_event_dup_reply()

switch_status_t switch_event_dup_reply	(	switch_event_t **	event,
		switch_event_t *	todup
	)

Definition at line 1371 of file switch_event.c.

References switch_event_header::array, switch_event::bind_user_data, switch_event::body, switch_event::event_id, switch_event::event_user_data, switch_event::flags, switch_event::headers, switch_event_header::idx, switch_event::key, switch_event_header::name, name, switch_event_header::next, switch_event::subclass_name, switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create_subclass, switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STACK_PUSH, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, value, and switch_event_header::value.

Referenced by switch_ivr_create_message_reply().

{
        switch_event_header_t *hp;
        char hname[1024] = "";
        char *p;

        if (switch_event_create_subclass(event, SWITCH_EVENT_CLONE, todup->subclass_name) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_STATUS_GENERR;
        }

        (*event)->event_id = todup->event_id;
        (*event)->event_user_data = todup->event_user_data;
        (*event)->bind_user_data = todup->bind_user_data;
        (*event)->flags = todup->flags;

        for (hp = todup->headers; hp; hp = hp->next) {
                char *name = hp->name, *value = hp->value;

                if (todup->subclass_name && !strcmp(hp->name, "Event-Subclass")) {
                        continue;
                }

                if (!strncasecmp(hp->name, "from_", 5)) {
                        p = hp->name + 5;
                        switch_snprintf(hname, sizeof(hname), "to_%s", p);
                        name = hname;
                } else if (!strncasecmp(hp->name, "to_", 3)) {
                        p = hp->name + 3;
                        switch_snprintf(hname, sizeof(hname), "from_%s", p);
                        name = hname;
                } else if (!strcasecmp(name, "to")) {
                        name = "from";
                } else if (!strcasecmp(name, "from")) {
                        name = "to";
                }

                if (hp->idx) {
                        int i;
                        for (i = 0; i < hp->idx; i++) {
                                switch_event_add_header_string(*event, SWITCH_STACK_PUSH, name, hp->array[i]);
                        }
                } else {
                        switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, name, value);
                }
        }

        switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, "replying", "true");

        if (todup->body) {
                switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, "orig_body", todup->body);
        }

        (*event)->key = todup->key;

        return SWITCH_STATUS_SUCCESS;
}

switch_event_expand_headers_check()

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
	)

Definition at line 2251 of file switch_event.c.

References switch_stream_handle::data, end_of_p, in, memset(), resize, SCF_API_EXPANSION, switch_api_execute(), switch_assert, switch_core_get_variable_dup(), switch_core_test_flag(), switch_event_check_permission_list(), switch_event_get_header_idx(), switch_safe_free, SWITCH_STANDARD_STREAM, SWITCH_STATUS_SUCCESS, switch_string_has_escaped_data(), switch_string_var_check_const(), and zstr.

{
        char *p, *c = NULL;
        char *data, *indup, *endof_indup;
        size_t sp = 0, len = 0, olen = 0, vtype = 0, br = 0, cpos, block = 128;
        const char *sub_val = NULL;
        char *cloned_sub_val = NULL, *expanded_sub_val = NULL;
        char *func_val = NULL;
        int nv = 0;
        char *gvar = NULL, *sb = NULL;

        if (recur > 100) {
                return (char *) in;
        }

        if (zstr(in)) {
                return (char *) in;
        }

        nv = switch_string_var_check_const(in) || switch_string_has_escaped_data(in);

        if (!nv) {
                return (char *) in;
        }

        nv = 0;
        olen = strlen(in) + 1;
        indup = strdup(in);
        switch_assert(indup);
        endof_indup = end_of_p(indup) + 1;

        if ((data = malloc(olen))) {
                memset(data, 0, olen);
                c = data;
                for (p = indup; p && p < endof_indup && *p; p++) {
                        int global = 0;
                        vtype = 0;

                        if (*p == '\\') {
                                if (*(p + 1) == '$') {
                                        nv = 1;
                                        p++;
                                        if (*(p + 1) == '$') {
                                                p++;
                                        }
                                } else if (*(p + 1) == '\'') {
                                        p++;
                                        continue;
                                } else if (*(p + 1) == '\\') {
                                        if (len + 1 >= olen) {
                                                resize(1);
                                        }

                                        *c++ = *p++;
                                        len++;
                                        continue;
                                }
                        }

                        if (*p == '$' && !nv) {
                                if (*(p + 1) == '$') {
                                        p++;
                                        global++;
                                }

                                if (*(p + 1)) {
                                        if (*(p + 1) == '{') {
                                                vtype = global ? 3 : 1;
                                        } else {
                                                nv = 1;
                                        }
                                } else {
                                        nv = 1;
                                }
                        }

                        if (nv) {
                                if (len + 1 >= olen) {
                                        resize(1);
                                }

                                *c++ = *p;
                                len++;
                                nv = 0;
                                continue;
                        }

                        if (vtype) {
                                char *s = p, *e, *vname, *vval = NULL;
                                size_t nlen;

                                s++;

                                if ((vtype == 1 || vtype == 3) && *s == '{') {
                                        br = 1;
                                        s++;
                                }

                                e = s;
                                vname = s;
                                while (*e) {
                                        if (br == 1 && *e == '}') {
                                                br = 0;
                                                *e++ = '\0';
                                                break;
                                        }

                                        if (br > 0) {
                                                if (e != s && *e == '{') {
                                                        br++;
                                                } else if (br > 1 && *e == '}') {
                                                        br--;
                                                }
                                        }

                                        e++;
                                }
                                p = e > endof_indup ? endof_indup : e;

                                vval = NULL;
                                for(sb = vname; sb && *sb; sb++) {
                                        if (*sb == ' ') {
                                                vval = sb;
                                                break;
                                        } else if (*sb == '(') {
                                                vval = sb;
                                                br = 1;
                                                break;
                                        }
                                }

                                if (vval) {
                                        e = vval - 1;
                                        *vval++ = '\0';

                                        while (*e == ' ') {
                                                *e-- = '\0';
                                        }
                                        e = vval;

                                        while (e && *e) {
                                                if (*e == '(') {
                                                        br++;
                                                } else if (br > 1 && *e == ')') {
                                                        br--;
                                                } else if (br == 1 && *e == ')') {
                                                        *e = '\0';
                                                        break;
                                                }
                                                e++;
                                        }

                                        vtype = 2;
                                }

                                if (vtype == 1 || vtype == 3) {
                                        char *expanded = NULL;
                                        int offset = 0;
                                        int ooffset = 0;
                                        char *ptr;
                                        int idx = -1;

                                        if ((expanded = switch_event_expand_headers_check(event, (char *) vname, var_list, api_list, recur+1)) == vname) {
                                                expanded = NULL;
                                        } else {
                                                vname = expanded;
                                        }
                                        if ((ptr = strchr(vname, ':'))) {
                                                *ptr++ = '\0';
                                                offset = atoi(ptr);
                                                if ((ptr = strchr(ptr, ':'))) {
                                                        ptr++;
                                                        ooffset = atoi(ptr);
                                                }
                                        }

                                        if ((ptr = strchr(vname, '[')) && strchr(ptr, ']')) {
                                                *ptr++ = '\0';
                                                idx = atoi(ptr);
                                        }

                                        if (vtype == 3 || !(sub_val = switch_event_get_header_idx(event, vname, idx))) {
                                                switch_safe_free(gvar);
                                                if ((gvar = switch_core_get_variable_dup(vname))) {
                                                        sub_val = gvar;
                                                }

                                                if (var_list && !switch_event_check_permission_list(var_list, vname)) {
                                                        sub_val = "<Variable Expansion Permission Denied>";
                                                }


                                                if ((expanded_sub_val = switch_event_expand_headers_check(event, sub_val, var_list, api_list, recur+1)) == sub_val) {
                                                        expanded_sub_val = NULL;
                                                } else {
                                                        sub_val = expanded_sub_val;
                                                }
                                        }

                                        if (sub_val) {
                                                if (offset || ooffset) {
                                                        cloned_sub_val = strdup(sub_val);
                                                        switch_assert(cloned_sub_val);
                                                        sub_val = cloned_sub_val;
                                                }

                                                if (offset >= 0) {
                                                        sub_val += offset;
                                                } else if ((size_t) abs(offset) <= strlen(sub_val)) {
                                                        sub_val = cloned_sub_val + (strlen(cloned_sub_val) + offset);
                                                }

                                                if (ooffset > 0 && (size_t) ooffset < strlen(sub_val)) {
                                                        if ((ptr = (char *) sub_val + ooffset)) {
                                                                *ptr = '\0';
                                                        }
                                                }
                                        }

                                        switch_safe_free(expanded);
                                } else {
                                        switch_stream_handle_t stream = { 0 };
                                        char *expanded = NULL;
                                        char *expanded_vname = NULL;

                                        if ((expanded_vname = switch_event_expand_headers_check(event, (char *) vname, var_list, api_list, recur+1)) == vname) {
                                                expanded_vname = NULL;
                                        } else {
                                                vname = expanded_vname;
                                        }

                                        if ((expanded = switch_event_expand_headers_check(event, vval, var_list, api_list, recur+1)) == vval) {
                                                expanded = NULL;
                                        } else {
                                                vval = expanded;
                                        }

                                        if (!switch_core_test_flag(SCF_API_EXPANSION) || (api_list && !switch_event_check_permission_list(api_list, vname))) {
                                                func_val = NULL;
                                                sub_val = "<API execute Permission Denied>";
                                        } else {
                                                SWITCH_STANDARD_STREAM(stream);
                                                if (switch_api_execute(vname, vval, NULL, &stream) == SWITCH_STATUS_SUCCESS) {
                                                        func_val = stream.data;
                                                        sub_val = func_val;
                                                } else {
                                                        free(stream.data);
                                                }
                                        }

                                        switch_safe_free(expanded);
                                        switch_safe_free(expanded_vname);
                                }
                                if ((nlen = sub_val ? strlen(sub_val) : 0)) {
                                        if (len + nlen >= olen) {
                                                resize(nlen);
                                        }

                                        len += nlen;
                                        strcat(c, sub_val);
                                        c += nlen;
                                }

                                switch_safe_free(func_val);
                                switch_safe_free(cloned_sub_val);
                                switch_safe_free(expanded_sub_val);
                                sub_val = NULL;
                                vname = NULL;
                                br = 0;
                        }

                        if (sp) {
                                if (len + 1 >= olen) {
                                        resize(1);
                                }

                                *c++ = ' ';
                                sp = 0;
                                len++;
                        }

                        if (*p == '$') {
                                p--;
                        } else {
                                if (len + 1 >= olen) {
                                        resize(1);
                                }

                                *c++ = *p;
                                len++;
                        }
                }
        }
        free(indup);
        switch_safe_free(gvar);

        return data;
}

switch_event_fire_detailed()

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.

Parameters

file	the calling file
func	the calling function
line	the calling line number
event	the event to send (will be nulled on success)
user_data	optional private data to pass to the event handlers

Returns

Definition at line 2006 of file switch_event.c.

References BLOCK, check_dispatch(), EVENT_QUEUE_MUTEX, switch_runtime::events_use_dispatch, runtime, RUNTIME_POOL, switch_assert, switch_event_deliver_thread_pool(), switch_event_destroy(), switch_event_queue_dispatch_event(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SYSTEM_RUNNING, and switch_event_node::user_data.

Referenced by switch_event_create_pres_in_detailed().

{

        switch_assert(BLOCK != NULL);
        switch_assert(RUNTIME_POOL != NULL);
        switch_assert(EVENT_QUEUE_MUTEX != NULL);
        switch_assert(RUNTIME_POOL != NULL);

        if (SYSTEM_RUNNING <= 0) {
                /* sorry we're closed */
                switch_event_destroy(event);
                return SWITCH_STATUS_SUCCESS;
        }

        if (user_data) {
                (*event)->event_user_data = user_data;
        }



        if (runtime.events_use_dispatch) {
                check_dispatch();

                if (switch_event_queue_dispatch_event(event) != SWITCH_STATUS_SUCCESS) {
                        switch_event_destroy(event);
                        return SWITCH_STATUS_FALSE;
                }
        } else {
                switch_event_deliver_thread_pool(event);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_event_free_subclass_detailed()

switch_status_t switch_event_free_subclass_detailed	(	const char *	owner,
		const char *	subclass_name
	)

Definition at line 454 of file switch_event.c.

References switch_event_subclass::bind, CUSTOM_HASH_MUTEX, FREE, switch_event_subclass::name, switch_event_subclass::owner, RUNTIME_POOL, RWLOCK, switch_assert, SWITCH_CHANNEL_LOG, switch_core_hash_delete(), switch_core_hash_find(), SWITCH_LOG_NOTICE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_event_subclass_t *subclass;
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_mutex_lock(CUSTOM_HASH_MUTEX);

        switch_assert(RUNTIME_POOL != NULL);
        switch_assert(CUSTOM_HASH != NULL);

        if ((subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name))) {
                if (!strcmp(owner, subclass->owner)) {
                        switch_thread_rwlock_wrlock(RWLOCK);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Subclass reservation deleted for %s:%s\n", owner, subclass_name);
                        switch_core_hash_delete(CUSTOM_HASH, subclass_name);
                        FREE(subclass->owner);
                        FREE(subclass->name);
                        FREE(subclass);
                        status = SWITCH_STATUS_SUCCESS;
                        switch_thread_rwlock_unlock(RWLOCK);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Subclass reservation %s inuse by listeners, detaching..\n", subclass_name);
                        subclass->bind = 1;
                }
        }

        switch_mutex_unlock(CUSTOM_HASH_MUTEX);

        return status;
}

switch_event_get_body()

char* switch_event_get_body

(

switch_event_t *

event

)

Retrieve the body value from an event.

Parameters

event

the event to read the body from

Returns

the value of the body or NULL

Definition at line 867 of file switch_event.c.

References switch_event::body.

Referenced by Event::getBody(), play_and_detect_input_callback(), switch_collect_input_callback(), and switch_ivr_parse_event().

{
        return (event ? event->body : NULL);
}

switch_event_get_custom_events()

switch_status_t switch_event_get_custom_events

(

switch_console_callback_match_t **

matches

)

Definition at line 2040 of file switch_event.c.

References CUSTOM_HASH_MUTEX, switch_console_push_match(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_hash_index_t *hi = NULL;
        const void *var;
        void *val;
        int x = 0;

        switch_mutex_lock(CUSTOM_HASH_MUTEX);

        for (hi = switch_core_hash_first(CUSTOM_HASH); hi; hi = switch_core_hash_next(&hi)) {
                switch_core_hash_this(hi, &var, NULL, &val);
                switch_console_push_match(matches, (const char *) var);
                x++;
        }

        switch_mutex_unlock(CUSTOM_HASH_MUTEX);

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_event_get_header_idx()

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

Definition at line 846 of file switch_event.c.

References switch_event_header::array, switch_event_get_header_ptr(), and switch_event_header::value.

Referenced by switch_channel_get_variable_dup(), and switch_event_expand_headers_check().

{
        switch_event_header_t *hp;

        if ((hp = switch_event_get_header_ptr(event, header_name))) {
                if (idx > -1) {
                        if (idx < hp->idx) {
                                return hp->array[idx];
                        } else {
                                return NULL;
                        }
                }

                return hp->value;
        } else if (!strcmp(header_name, "_body")) {
                return event->body;
        }

        return NULL;
}

switch_event_get_header_ptr()

switch_event_header_t* switch_event_get_header_ptr	(	switch_event_t *	event,
		const char *	header_name
	)

Retrieve a header value from an event.

Parameters

event	the event to read the header from
header_name	the name of the header to read

Returns

the value of the requested header

Definition at line 825 of file switch_event.c.

References switch_event_header::hash, hash, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_assert, and switch_ci_hashfunc_default().

Referenced by switch_event_base_add_header(), and switch_event_get_header_idx().

{
        switch_event_header_t *hp;
        switch_ssize_t hlen = -1;
        unsigned long hash = 0;

        switch_assert(event);

        if (!header_name)
                return NULL;

        hash = switch_ci_hashfunc_default(header_name, &hlen);

        for (hp = event->headers; hp; hp = hp->next) {
                if ((!hp->hash || hash == hp->hash) && !strcasecmp(hp->name, header_name)) {
                        return hp;
                }
        }
        return NULL;
}

switch_event_init()

switch_status_t switch_event_init

(

switch_memory_pool_t *

pool

)

Start the eventing system.

Parameters

pool	the memory pool to use for the event system (creates a new one if NULL)

Returns

SWITCH_STATUS_SUCCESS when complete

Definition at line 692 of file switch_event.c.

References BLOCK, check_dispatch(), CUSTOM_HASH_MUTEX, event_channel_manager, EVENT_QUEUE_MUTEX, guess_ip_v4, guess_ip_v6, MAX_DISPATCH, pool, POOL_LOCK, RUNTIME_POOL, RWLOCK, SCF_MINIMAL, switch_assert, SWITCH_CHANNEL_LOG, switch_core_cpu_count(), switch_core_hash_init, switch_core_test_flag(), switch_find_local_ip(), SWITCH_LOG_INFO, switch_log_printf(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), switch_queue_create(), SWITCH_STATUS_SUCCESS, switch_thread_rwlock_create(), SYSTEM_RUNNING, and THRUNTIME_POOL.

Referenced by switch_core_init().

{

        /* don't need any more dispatch threads than we have CPU's*/
        MAX_DISPATCH = (switch_core_cpu_count() / 2) + 1;
        if (MAX_DISPATCH < 2) {
                MAX_DISPATCH = 2;
        }

        switch_assert(pool != NULL);
        THRUNTIME_POOL = RUNTIME_POOL = pool;
        switch_thread_rwlock_create(&RWLOCK, RUNTIME_POOL);
        switch_mutex_init(&BLOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
        switch_mutex_init(&POOL_LOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
        switch_mutex_init(&EVENT_QUEUE_MUTEX, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
        switch_mutex_init(&CUSTOM_HASH_MUTEX, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
        switch_core_hash_init(&CUSTOM_HASH);

        if (switch_core_test_flag(SCF_MINIMAL)) {
                return SWITCH_STATUS_SUCCESS;
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Activate Eventing Engine.\n");

        switch_core_hash_init(&event_channel_manager.lahash);
        switch_mutex_init(&event_channel_manager.lamutex, SWITCH_MUTEX_NESTED, RUNTIME_POOL);

        switch_thread_rwlock_create(&event_channel_manager.rwlock, RUNTIME_POOL);
        switch_core_hash_init(&event_channel_manager.hash);
        switch_core_hash_init(&event_channel_manager.perm_hash);
        event_channel_manager.ID = 1;

        switch_mutex_lock(EVENT_QUEUE_MUTEX);
        SYSTEM_RUNNING = -1;
        switch_mutex_unlock(EVENT_QUEUE_MUTEX);

        //switch_threadattr_create(&thd_attr, pool);
        switch_find_local_ip(guess_ip_v4, sizeof(guess_ip_v4), NULL, AF_INET);
        switch_find_local_ip(guess_ip_v6, sizeof(guess_ip_v6), NULL, AF_INET6);


#ifdef SWITCH_EVENT_RECYCLE
        switch_queue_create(&EVENT_RECYCLE_QUEUE, 250000, THRUNTIME_POOL);
        switch_queue_create(&EVENT_HEADER_RECYCLE_QUEUE, 250000, THRUNTIME_POOL);
#endif

        check_dispatch();

        switch_mutex_lock(EVENT_QUEUE_MUTEX);
        SYSTEM_RUNNING = 1;
        switch_mutex_unlock(EVENT_QUEUE_MUTEX);

        return SWITCH_STATUS_SUCCESS;
}

switch_event_launch_dispatch_threads()

void switch_event_launch_dispatch_threads

(

uint32_t

max

)

Definition at line 653 of file switch_event.c.

References check_dispatch(), EVENT_DISPATCH_QUEUE_RUNNING, EVENT_DISPATCH_QUEUE_THREADS, index, MAX_DISPATCH, pool, RUNTIME_POOL, SOFT_MAX_DISPATCH, SWITCH_CHANNEL_LOG, switch_event_dispatch_thread(), switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_PRI_REALTIME, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_priority_set(), switch_threadattr_stacksize_set(), and switch_yield.

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

{
        switch_threadattr_t *thd_attr;
        uint32_t index = 0;
        uint32_t sanity = 200;

        switch_memory_pool_t *pool = RUNTIME_POOL;

        check_dispatch();

        if (max > MAX_DISPATCH) {
                return;
        }

        if (max < SOFT_MAX_DISPATCH) {
                return;
        }

        for (index = SOFT_MAX_DISPATCH; index < max && index < MAX_DISPATCH; index++) {
                if (EVENT_DISPATCH_QUEUE_THREADS[index]) {
                        continue;
                }

                switch_threadattr_create(&thd_attr, pool);
                switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
                switch_thread_create(&EVENT_DISPATCH_QUEUE_THREADS[index], thd_attr, switch_event_dispatch_thread, EVENT_DISPATCH_QUEUE, pool);
                while(--sanity && !EVENT_DISPATCH_QUEUE_RUNNING[index]) switch_yield(10000);

                if (index == 1) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Create event dispatch thread %d\n", index);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Create additional event dispatch thread %d\n", index);
                }
        }

        SOFT_MAX_DISPATCH = index;
}

switch_event_merge()

void switch_event_merge	(	switch_event_t *	event,
		switch_event_t *	tomerge
	)

Definition at line 1315 of file switch_event.c.

References switch_event_header::array, switch_event::headers, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_assert, switch_event_add_header_string(), SWITCH_STACK_BOTTOM, SWITCH_STACK_PUSH, and switch_event_header::value.

Referenced by asr_set_json_text_params(), Event::merge(), speech_thread(), switch_channel_execute_on(), switch_ivr_enterprise_originate(), switch_ivr_originate(), and switch_ivr_play_file().

{
        switch_event_header_t *hp;

        switch_assert(tomerge && event);

        for (hp = tomerge->headers; hp; hp = hp->next) {
                if (hp->idx) {
                        int i;

                        for(i = 0; i < hp->idx; i++) {
                                switch_event_add_header_string(event, SWITCH_STACK_PUSH, hp->name, hp->array[i]);
                        }
                } else {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, hp->name, hp->value);
                }
        }
}

switch_event_name()

const char* switch_event_name

(

switch_event_types_t

event

)

Render the name of an event id enumeration.

Parameters

event

the event id to render the name of

Returns

the rendered name

Definition at line 430 of file switch_event.c.

References BLOCK, EVENT_NAMES, RUNTIME_POOL, and switch_assert.

Referenced by Event::getType(), switch_event_prep_for_delivery_detailed(), switch_event_unbind(), and switch_event_unbind_callback().

{
        switch_assert(BLOCK != NULL);
        switch_assert(RUNTIME_POOL != NULL);

        return EVENT_NAMES[event];
}

switch_event_prep_for_delivery_detailed()

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

Definition at line 1972 of file switch_event.c.

References switch_event::event_id, EVENT_QUEUE_MUTEX, EVENT_SEQUENCE_NR, guess_ip_v4, guess_ip_v6, switch_core_get_hostname(), switch_core_get_switchname(), switch_core_get_uuid(), switch_cut_path(), switch_event_add_header(), switch_event_add_header_string(), switch_event_name(), switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), switch_rfc822_date(), SWITCH_STACK_BOTTOM, switch_strftime_nocheck(), switch_time_exp_lt(), and SWITCH_UINT64_T_FMT.

Referenced by switch_event_create_subclass_detailed().

{
        switch_time_exp_t tm;
        char date[80] = "";
        switch_size_t retsize;
        switch_time_t ts = switch_micro_time_now();
        uint64_t seq;

        switch_mutex_lock(EVENT_QUEUE_MUTEX);
        seq = ++EVENT_SEQUENCE_NR;
        switch_mutex_unlock(EVENT_QUEUE_MUTEX);


        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Event-Name", switch_event_name(event->event_id));
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Core-UUID", switch_core_get_uuid());
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "FreeSWITCH-Hostname", switch_core_get_hostname());
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "FreeSWITCH-Switchname", switch_core_get_switchname());
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "FreeSWITCH-IPv4", guess_ip_v4);
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "FreeSWITCH-IPv6", guess_ip_v6);

        switch_time_exp_lt(&tm, ts);
        switch_strftime_nocheck(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm);
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Event-Date-Local", date);
        switch_rfc822_date(date, ts);
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Event-Date-GMT", date);
        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Date-Timestamp", "%" SWITCH_UINT64_T_FMT, (uint64_t) ts);
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Event-Calling-File", switch_cut_path(file));
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Event-Calling-Function", func);
        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Calling-Line-Number", "%d", line);
        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Event-Sequence", "%" SWITCH_UINT64_T_FMT, seq);


}

switch_event_rename_header()

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

Definition at line 796 of file switch_event.c.

References DUP, FREE, switch_event_header::hash, hash, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_assert, switch_ci_hashfunc_default(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_event_header_t *hp;
        switch_ssize_t hlen = -1;
        unsigned long hash = 0;
        int x = 0;

        switch_assert(event);

        if (!header_name) {
                return SWITCH_STATUS_FALSE;
        }

        hash = switch_ci_hashfunc_default(header_name, &hlen);

        for (hp = event->headers; hp; hp = hp->next) {
                if ((!hp->hash || hash == hp->hash) && !strcasecmp(hp->name, header_name)) {
                        FREE(hp->name);
                        hp->name = DUP(new_header_name);
                        hlen = -1;
                        hp->hash = switch_ci_hashfunc_default(hp->name, &hlen);
                        x++;
                }
        }

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_event_reserve_subclass_detailed()

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.

Parameters

owner	the owner of the event name
subclass_name	the name to reserve

Returns

SWITCH_STATUS_SUCCESS if the name was reserved

Note

There is nothing to enforce this but I recommend using module::event_name for the subclass names

Definition at line 485 of file switch_event.c.

References switch_event_subclass::bind, CUSTOM_HASH_MUTEX, DUP, switch_event_subclass::name, switch_event_subclass::owner, RUNTIME_POOL, switch_assert, switch_core_hash_find(), switch_core_hash_insert, switch_goto_status, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

Referenced by switch_event_bind_removable().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_event_subclass_t *subclass;

        switch_mutex_lock(CUSTOM_HASH_MUTEX);

        switch_assert(RUNTIME_POOL != NULL);
        switch_assert(CUSTOM_HASH != NULL);

        if ((subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name))) {
                /* a listener reserved it for us, now we can lock it so nobody else can have it */
                if (subclass->bind) {
                        subclass->bind = 0;
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }
                switch_goto_status(SWITCH_STATUS_INUSE, end);
        }

        switch_zmalloc(subclass, sizeof(*subclass));

        subclass->owner = DUP(owner);
        subclass->name = DUP(subclass_name);

        status = switch_core_hash_insert(CUSTOM_HASH, subclass->name, subclass);

        if (status != SWITCH_STATUS_SUCCESS) {
                free(subclass->owner);
                free(subclass->name);
                free(subclass);
        }

end:

        switch_mutex_unlock(CUSTOM_HASH_MUTEX);

        return status;
}

switch_event_running()

switch_xml_t switch_status_t switch_event_running

(

void

)

Determine if the event system has been initialized.

Returns

SWITCH_STATUS_SUCCESS if the system is running

Definition at line 425 of file switch_event.c.

References SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SYSTEM_RUNNING.

Referenced by switch_console_printf(), and switch_log_meta_vprintf().

{
        return SYSTEM_RUNNING ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_event_serialize()

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

Definition at line 1527 of file switch_event.c.

References switch_event_header::array, switch_event::body, buf, switch_event::headers, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_safe_free, switch_snprintf(), SWITCH_STATUS_SUCCESS, switch_url_encode(), and switch_event_header::value.

Referenced by Event::serialize(), switch_core_session_thread(), and switch_ivr_originate().

{
        switch_size_t len = 0;
        switch_event_header_t *hp;
        switch_size_t llen = 0, dlen = 0, blocksize = 512, encode_len = 1536, new_len = 0;
        char *buf;
        char *encode_buf = NULL;        /* used for url encoding of variables to make sure unsafe things stay out of the serialized copy */

        *str = NULL;

        dlen = blocksize * 2;

        if (!(buf = malloc(dlen))) {
                abort();
        }

        /* go ahead and give ourselves some space to work with, should save a few reallocs */
        if (!(encode_buf = malloc(encode_len))) {
                abort();
        }

        /* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "hit serialized!.\n"); */
        for (hp = event->headers; hp; hp = hp->next) {
                /*
                 * grab enough memory to store 3x the string (url encode takes one char and turns it into %XX)
                 * so we could end up with a string that is 3 times the originals length, unlikely but rather
                 * be safe than destroy the string, also add one for the null.  And try to be smart about using
                 * the memory, allocate and only reallocate if we need more.  This avoids an alloc, free CPU
                 * destroying loop.
                 */

                if (hp->idx) {
                        int i;
                        new_len = 0;
                        for(i = 0; i < hp->idx; i++) {
                                new_len += (strlen(hp->array[i]) * 3) + 1;
                        }
                } else {
                        new_len = (strlen(hp->value) * 3) + 1;
                }

                if (encode_len < new_len) {
                        char *tmp;

                        /* keep track of the size of our allocation */
                        encode_len = new_len;

                        if (!(tmp = realloc(encode_buf, encode_len))) {
                                abort();
                        }

                        encode_buf = tmp;
                }

                /* handle any bad things in the string like newlines : etc that screw up the serialized format */


                if (encode) {
                        switch_url_encode(hp->value, encode_buf, encode_len);
                } else {
                        switch_snprintf(encode_buf, encode_len, "[%s]", hp->value);
                }


                llen = strlen(hp->name) + strlen(encode_buf) + 8;

                if ((len + llen) > dlen) {
                        char *m = NULL;
                        dlen += (blocksize + (len + llen));
                        if (!(m = realloc(buf, dlen))) {
                                abort();
                        }
                        buf = m;
                }

                switch_snprintf(buf + len, dlen - len, "%s: %s\n", hp->name, *encode_buf == '\0' ? "_undef_" : encode_buf);
                len = strlen(buf);
        }

        /* we are done with the memory we used for encoding, give it back */
        switch_safe_free(encode_buf);

        if (event->body) {
                int blen = (int) strlen(event->body);
                llen = blen;

                if (blen) {
                        llen += 25;
                } else {
                        llen += 5;
                }

                if ((len + llen) > dlen) {
                        char *m = NULL;
                        dlen += (blocksize + (len + llen));
                        if (!(m = realloc(buf, dlen))) {
                                abort();
                        }
                        buf = m;
                }

                if (blen) {
                        switch_snprintf(buf + len, dlen - len, "Content-Length: %d\n\n%s", blen, event->body);
                } else {
                        switch_snprintf(buf + len, dlen - len, "\n");
                }
        } else {
                switch_snprintf(buf + len, dlen - len, "\n");
        }

        *str = buf;

        return SWITCH_STATUS_SUCCESS;
}

switch_event_serialize_json()

switch_status_t switch_event_serialize_json	(	switch_event_t *	event,
		char **	str
	)

Definition at line 1856 of file switch_event.c.

References switch_event_serialize_json_obj(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by Event::serialize().

{

        cJSON *cj;
        *str = NULL;

        if (switch_event_serialize_json_obj(event, &cj) == SWITCH_STATUS_SUCCESS) {
                *str = cJSON_PrintUnformatted(cj);
                cJSON_Delete(cj);

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_event_serialize_json_obj()

switch_status_t switch_event_serialize_json_obj	(	switch_event_t *	event,
		cJSON **	json
	)

Definition at line 1818 of file switch_event.c.

References 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_STATUS_SUCCESS, and switch_event_header::value.

Referenced by switch_event_serialize_json().

{
        switch_event_header_t *hp;
        cJSON *cj;

        cj = cJSON_CreateObject();

        for (hp = event->headers; hp; hp = hp->next) {
                if (hp->idx) {
                        cJSON *a = cJSON_CreateArray();
                        int i;

                        for(i = 0; i < hp->idx; i++) {
                                cJSON_AddItemToArray(a, cJSON_CreateString(hp->array[i]));
                        }

                        cJSON_AddItemToObject(cj, hp->name, a);

                } else {
                        cJSON_AddItemToObject(cj, hp->name, cJSON_CreateString(hp->value));
                }
        }

        if (event->body) {
                int blen = (int) strlen(event->body);
                char tmp[25];

                switch_snprintf(tmp, sizeof(tmp), "%d", blen);

                cJSON_AddItemToObject(cj, "Content-Length", cJSON_CreateString(tmp));
                cJSON_AddItemToObject(cj, "_body", cJSON_CreateString(event->body));
        }

        *json = cj;

        return SWITCH_STATUS_SUCCESS;
}

switch_event_set_body()

switch_status_t switch_status_t switch_event_set_body	(	switch_event_t *	event,
		const char *	body
	)

Definition at line 1255 of file switch_event.c.

References switch_event::body, DUP, switch_safe_free, and SWITCH_STATUS_SUCCESS.

Referenced by switch_event_base_add_header().

{
        switch_safe_free(event->body);

        if (body) {
                event->body = DUP(body);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_event_set_priority()

switch_status_t switch_event_set_priority	(	switch_event_t *	event,
		switch_priority_t	priority
	)

Set the priority of an event.

Parameters

event	the event to set the priority on
priority	the event priority

Returns

SWITCH_STATUS_SUCCESS

Definition at line 789 of file switch_event.c.

References switch_event_add_header_string(), switch_priority_name(), SWITCH_STACK_TOP, and SWITCH_STATUS_SUCCESS.

Referenced by Event::setPriority().

{
        event->priority = priority;
        switch_event_add_header_string(event, SWITCH_STACK_TOP, "priority", switch_priority_name(priority));
        return SWITCH_STATUS_SUCCESS;
}

switch_event_set_subclass_name()

switch_status_t switch_status_t switch_event_set_subclass_name	(	switch_event_t *	event,
		const char *	subclass_name
	)

Definition at line 1227 of file switch_event.c.

References DUP, switch_event::subclass_name, switch_event_add_header_string(), switch_event_del_header, switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

{
        if (!event || !subclass_name)
                return SWITCH_STATUS_GENERR;

        switch_safe_free(event->subclass_name);
        event->subclass_name = DUP(subclass_name);
        switch_event_del_header(event, "Event-Subclass");
        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Event-Subclass", event->subclass_name);
        return SWITCH_STATUS_SUCCESS;
}

switch_event_shutdown()

switch_status_t switch_event_shutdown

(

void

)

Stop the eventing system.

Returns

SWITCH_STATUS_SUCCESS when complete

Definition at line 549 of file switch_event.c.

References DISPATCH_THREAD_COUNT, event_channel_manager, EVENT_DISPATCH_QUEUE_THREADS, EVENT_QUEUE_MUTEX, switch_runtime::events_use_dispatch, FREE, MAX_DISPATCH, switch_event_subclass::name, switch_event_subclass::owner, runtime, SCF_MINIMAL, SWITCH_CHANNEL_LOG, switch_core_hash_destroy(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_memory_reclaim_events(), switch_core_test_flag(), switch_event_destroy(), SWITCH_LOG_CONSOLE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_interrupt_all(), switch_queue_trypop(), switch_queue_trypush(), SWITCH_STATUS_SUCCESS, switch_thread_join(), switch_yield, SYSTEM_RUNNING, THREAD_COUNT, and unsub_all_switch_event_channel().

Referenced by switch_core_destroy().

{
        uint32_t x = 0;
        int last = 0;
        switch_hash_index_t *hi;
        const void *var;
        void *val;
        switch_status_t res;

        if (switch_core_test_flag(SCF_MINIMAL)) {
                return SWITCH_STATUS_SUCCESS;
        }

        switch_mutex_lock(EVENT_QUEUE_MUTEX);
        SYSTEM_RUNNING = 0;
        switch_mutex_unlock(EVENT_QUEUE_MUTEX);

        unsub_all_switch_event_channel();

        if (EVENT_CHANNEL_DISPATCH_QUEUE) {
                res = switch_queue_trypush(EVENT_CHANNEL_DISPATCH_QUEUE, NULL);
                (void)res;
                switch_queue_interrupt_all(EVENT_CHANNEL_DISPATCH_QUEUE);
        }

        if (runtime.events_use_dispatch) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping dispatch queues\n");

                for(x = 0; x < (uint32_t)DISPATCH_THREAD_COUNT; x++) {
                        res = switch_queue_trypush(EVENT_DISPATCH_QUEUE, NULL);
                        (void)res;
                }

                switch_queue_interrupt_all(EVENT_DISPATCH_QUEUE);

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping dispatch threads\n");

                for(x = 0; x < (uint32_t)MAX_DISPATCH; x++) {
                        if (EVENT_DISPATCH_QUEUE_THREADS[x]) {
                                switch_status_t st;
                                switch_thread_join(&st, EVENT_DISPATCH_QUEUE_THREADS[x]);
                        }
                }
        }

        x = 0;
        while (x < 100 && THREAD_COUNT) {
                switch_yield(100000);
                if (THREAD_COUNT == last) {
                        x++;
                }

                last = THREAD_COUNT;
        }

        if (runtime.events_use_dispatch) {
                void *pop = NULL;
                switch_event_t *event = NULL;

                while (switch_queue_trypop(EVENT_DISPATCH_QUEUE, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                        event = (switch_event_t *) pop;
                        switch_event_destroy(&event);
                }
        }

        for (hi = switch_core_hash_first(CUSTOM_HASH); hi; hi = switch_core_hash_next(&hi)) {
                switch_event_subclass_t *subclass;
                switch_core_hash_this(hi, &var, NULL, &val);
                if ((subclass = (switch_event_subclass_t *) val)) {
                        FREE(subclass->name);
                        FREE(subclass->owner);
                        FREE(subclass);
                }
        }

        switch_core_hash_destroy(&event_channel_manager.lahash);
        switch_core_hash_destroy(&event_channel_manager.hash);
        switch_core_hash_destroy(&event_channel_manager.perm_hash);

        switch_core_hash_destroy(&CUSTOM_HASH);
        switch_core_memory_reclaim_events();

        return SWITCH_STATUS_SUCCESS;
}

switch_event_unbind()

switch_status_t switch_event_unbind

(

switch_event_node_t **

node

)

Unbind a bound event consumer.

Parameters

node	node to unbind

Returns

SWITCH_STATUS_SUCCESS if the consumer was unbinded

Definition at line 2175 of file switch_event.c.

References BLOCK, switch_event_node::event_id, FREE, switch_event_node::id, switch_event_node::next, RWLOCK, switch_event_node::subclass_name, SWITCH_CHANNEL_LOG, switch_event_name(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by EventConsumer::cleanup(), and SWITCH_MODULE_SHUTDOWN_FUNCTION().

{
        switch_event_node_t *n, *np, *lnp = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;

        n = *node;

        if (!n) {
                return status;
        }

        switch_thread_rwlock_wrlock(RWLOCK);
        switch_mutex_lock(BLOCK);
        /* <LOCKED> ----------------------------------------------- */
        for (np = EVENT_NODES[n->event_id]; np; np = np->next) {
                if (np == n) {
                        if (lnp) {
                                lnp->next = n->next;
                        } else {
                                EVENT_NODES[n->event_id] = n->next;
                        }
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Event Binding deleted for %s:%s\n", n->id, switch_event_name(n->event_id));
                        FREE(n->subclass_name);
                        FREE(n->id);
                        FREE(n);
                        *node = NULL;
                        status = SWITCH_STATUS_SUCCESS;
                        break;
                }
                lnp = np;
        }
        switch_mutex_unlock(BLOCK);
        switch_thread_rwlock_unlock(RWLOCK);
        /* </LOCKED> ----------------------------------------------- */

        return status;
}

switch_event_unbind_callback()

switch_status_t switch_event_unbind_callback

(

switch_event_callback_t

callback

)

Definition at line 2134 of file switch_event.c.

References BLOCK, switch_event_node::callback, switch_event_node::event_id, FREE, switch_event_node::id, switch_event_node::next, RWLOCK, switch_event_node::subclass_name, SWITCH_CHANNEL_LOG, SWITCH_EVENT_ALL, switch_event_name(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_core_sqldb_stop().

{
        switch_event_node_t *n, *np, *lnp = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int id;

        switch_thread_rwlock_wrlock(RWLOCK);
        switch_mutex_lock(BLOCK);
        /* <LOCKED> ----------------------------------------------- */
        for (id = 0; id <= SWITCH_EVENT_ALL; id++) {
                lnp = NULL;

                for (np = EVENT_NODES[id]; np;) {
                        n = np;
                        np = np->next;
                        if (n->callback == callback) {
                                if (lnp) {
                                        lnp->next = n->next;
                                } else {
                                        EVENT_NODES[n->event_id] = n->next;
                                }

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Event Binding deleted for %s:%s\n", n->id, switch_event_name(n->event_id));
                                FREE(n->subclass_name);
                                FREE(n->id);
                                FREE(n);
                                status = SWITCH_STATUS_SUCCESS;
                        } else {
                                lnp = n;
                        }
                }
        }
        switch_mutex_unlock(BLOCK);
        switch_thread_rwlock_unlock(RWLOCK);
        /* </LOCKED> ----------------------------------------------- */

        return status;
}

switch_event_xmlize()

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

Render a XML representation of an event suitable for printing or network transport.

Parameters

event	the event to render
fmt	optional body of the event (varargs see standard sprintf family)

Returns

the xml object if the operation was successful

Note

the body supplied by this function will supersede an existing body the event may have

Referenced by Event::serialize().

switch_json_add_presence_data_cols()

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

Definition at line 2664 of file switch_event.c.

References json_add_child_string(), switch_event_get_header, switch_safe_free, switch_snprintf(), and switch_split.

{
        const char *data;

        if (!prefix) prefix = "";

        if ((data = switch_event_get_header(event, "presence_data_cols"))) {
                char *cols[128] = { 0 };
                char header_name[128] = "";
                int col_count = 0, i = 0;
                char *data_copy = NULL;

                data_copy = strdup(data);

                col_count = switch_split(data_copy, ':', cols);

                for (i = 0; i < col_count; i++) {
                        const char *val = NULL;
                        switch_snprintf(header_name, sizeof(header_name), "%s%s", prefix, cols[i]);

                        val = switch_event_get_header(event, cols[i]);
                        json_add_child_string(json, header_name, val);
                }

                switch_safe_free(data_copy);
        }

}

switch_live_array_add()

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

Definition at line 3629 of file switch_event.c.

References cJSON_GetObjectCstr(), switch_live_array_s::event_channel, switch_live_array_s::hash, switch_live_array_s::head, json_add_child_obj(), la_broadcast(), switch_live_array_s::mutex, la_node_s::name, switch_live_array_s::name, la_node_s::next, la_node_s::obj, la_node_s::pos, switch_live_array_s::pos, switch_live_array_s::serno, switch_core_hash_find(), switch_core_hash_insert, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, switch_zmalloc, and switch_live_array_s::tail.

{
        la_node_t *node;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        const char *action = "add";
        cJSON *msg = NULL, *data = NULL;
        const char *visibility = NULL;
        
        switch_mutex_lock(la->mutex);

        if ((node = switch_core_hash_find(la->hash, name))) {

                action = "modify";

                if (node->obj) {
                        if (duplicate) {
                                cJSON_Delete(node->obj);
                                node->obj = NULL;
                        }
                }
        } else {
                switch_zmalloc(node, sizeof(*node));

                node->name = strdup(name);
                switch_core_hash_insert(la->hash, name, node);

                if (index > -1 && index < la->pos && la->head) {
                        la_node_t *np, *last = NULL;
                        int i = 0;

                        for(np = la->head; np; np = np->next) {

                                if (i == index) {
                                        if (last) {
                                                node->next = last->next;
                                                last->next = node;
                                                np = node;
                                        } else {
                                                node->next = la->head;
                                                la->head = node;
                                                np = node;
                                        }
                                }

                                np->pos = i;
                                la->tail = np;
                                last = np;
                                i++;
                        }


                } else {

                        node->pos = la->pos++;
                        index = node->pos;

                        if (!la->head) {
                                la->head = node;
                        } else {
                                la->tail->next = node;
                        }

                        la->tail = node;
                }
        }

        if (duplicate) {
                node->obj = cJSON_Duplicate(*obj, 1);
        } else {
                node->obj = *obj;
        }

        msg = cJSON_CreateObject();
        data = json_add_child_obj(msg, "data", NULL);
        if ((visibility = cJSON_GetObjectCstr(node->obj, "contentVisibility"))) {
                cJSON_AddItemToObject(msg, "contentVisibility", cJSON_CreateString(visibility));
        }
        cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
        cJSON_AddItemToObject(data, "action", cJSON_CreateString(action));

        if (index > -1) {
                cJSON_AddItemToObject(data, "arrIndex", cJSON_CreateNumber(index));
        }

        cJSON_AddItemToObject(data, "name", cJSON_CreateString(la->name));
        cJSON_AddItemToObject(data, "hashKey", cJSON_CreateString(node->name));
        cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(la->serno++));
        cJSON_AddItemToObject(data, "data", cJSON_Duplicate(node->obj, 1));

        la_broadcast(la, &msg);

        switch_mutex_unlock(la->mutex);

        return status;
}

switch_live_array_add_alias()

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

Definition at line 3459 of file switch_event.c.

References switch_live_array_s::aliases, alias_node_s::event_channel, event_channel_manager, alias_node_s::key, switch_live_array_s::mutex, alias_node_s::name, alias_node_s::next, switch_live_array_s::pool, switch_core_alloc, switch_core_hash_insert, switch_core_sprintf(), switch_core_strdup, SWITCH_FALSE, switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_TRUE.

{
        alias_node_t *node = 0, *np;
        switch_bool_t exist = SWITCH_FALSE;

        switch_mutex_lock(la->mutex);
        for (np = la->aliases; np && np->next; np = np->next) {
                if (!strcmp(np->event_channel, event_channel) && !strcmp(np->name, name)) {
                        exist = SWITCH_TRUE;
                        break;
                }
        }

        if (!exist) {
                node = switch_core_alloc(la->pool, sizeof(*node));
                node->event_channel = switch_core_strdup(la->pool, event_channel);
                node->name = switch_core_strdup(la->pool, name);
                node->key = switch_core_sprintf(la->pool, "%s.%s", event_channel, name);

                if (np) {
                        np->next = node;
                } else {
                        la->aliases = node;
                }
        }

        switch_mutex_unlock(la->mutex);

        if (!exist) {
                switch_mutex_lock(event_channel_manager.lamutex);
                switch_core_hash_insert(event_channel_manager.lahash, node->key, la);
                switch_mutex_unlock(event_channel_manager.lamutex);
        }


        return !exist;
}

switch_live_array_bootstrap()

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

Definition at line 3312 of file switch_event.c.

References switch_live_array_s::event_channel, switch_live_array_s::head, json_add_child_array(), json_add_child_obj(), switch_live_array_s::mutex, la_node_s::name, switch_live_array_s::name, la_node_s::next, la_node_s::obj, switch_live_array_s::serno, switch_event_channel_broadcast(), SWITCH_FALSE, switch_live_array_visible(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_live_array_s::visible.

Referenced by switch_live_array_parse_json().

{
        la_node_t *np;
        cJSON *msg, *data;

        switch_mutex_lock(la->mutex);

#if OLD_WAY
        msg = cJSON_CreateObject();
        data = json_add_child_obj(msg, "data", NULL);

        cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
        cJSON_AddItemToObject(data, "action", cJSON_CreateString("clear"));
        cJSON_AddItemToObject(data, "name", cJSON_CreateString(la->name));
        cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(-1));
        cJSON_AddItemToObject(data, "data", cJSON_CreateObject());

        switch_event_channel_broadcast(la->event_channel, &msg, __FILE__, channel_id);

        for (np = la->head; np; np = np->next) {
                msg = cJSON_CreateObject();
                data = json_add_child_obj(msg, "data", NULL);

                cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
                cJSON_AddItemToObject(data, "action", cJSON_CreateString("add"));
                cJSON_AddItemToObject(data, "name", cJSON_CreateString(la->name));
                cJSON_AddItemToObject(data, "hashKey", cJSON_CreateString(np->name));
                cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(la->serno++));
                cJSON_AddItemToObject(data, "data", cJSON_Duplicate(np->obj, 1));
                if (sessid) {
                        cJSON_AddItemToObject(msg, "sessid", cJSON_CreateString(sessid));
                }
                switch_event_channel_broadcast(la->event_channel, &msg, __FILE__, channel_id);
        }
#else


        msg = cJSON_CreateObject();
        data = json_add_child_obj(msg, "data", NULL);

        cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
        cJSON_AddItemToObject(data, "action", cJSON_CreateString("bootObj"));
        cJSON_AddItemToObject(data, "name", cJSON_CreateString(la->name));
        cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(-1));

        if (sessid) {
                cJSON_AddItemToObject(msg, "sessid", cJSON_CreateString(sessid));
        }

        data = json_add_child_array(data, "data");

        for (np = la->head; np; np = np->next) {
                cJSON *row = cJSON_CreateArray();
                cJSON_AddItemToArray(row, cJSON_CreateString(np->name));
                cJSON_AddItemToArray(row, cJSON_Duplicate(np->obj, 1));
                cJSON_AddItemToArray(data, row);
        }

        switch_event_channel_broadcast(la->event_channel, &msg, __FILE__, channel_id);


#endif

        if (!la->visible) {
                switch_live_array_visible(la, SWITCH_FALSE, SWITCH_TRUE);
        }

        switch_mutex_unlock(la->mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_live_array_clear()

switch_status_t switch_live_array_clear

(

switch_live_array_t *

la

)

Definition at line 3278 of file switch_event.c.

References cur, switch_live_array_s::event_channel, switch_live_array_s::head, json_add_child_obj(), la_broadcast(), switch_live_array_s::mutex, la_node_s::name, switch_live_array_s::name, la_node_s::next, la_node_s::obj, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_live_array_s::tail.

Referenced by switch_live_array_destroy().

{
        la_node_t *cur, *np;
        cJSON *msg, *data;

        switch_mutex_lock(la->mutex);
        np = la->head;

        msg = cJSON_CreateObject();
        data = json_add_child_obj(msg, "data", NULL);

        cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
        cJSON_AddItemToObject(data, "action", cJSON_CreateString("clear"));
        cJSON_AddItemToObject(data, "name", cJSON_CreateString(la->name));
        cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(-1));
        cJSON_AddItemToObject(data, "data", cJSON_CreateObject());

        la_broadcast(la, &msg);

        while(np) {
                cur = np;
                np  = np->next;
                cJSON_Delete(cur->obj);
                free(cur->name);
                free(cur);
        }

        la->head = la->tail = NULL;

        switch_mutex_unlock(la->mutex);

        return SWITCH_STATUS_SUCCESS;
}

switch_live_array_clear_alias()

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

Definition at line 3427 of file switch_event.c.

References switch_live_array_s::aliases, alias_node_s::event_channel, event_channel_manager, switch_live_array_s::mutex, alias_node_s::name, alias_node_s::next, switch_core_hash_delete(), SWITCH_FALSE, switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_TRUE.

{
        alias_node_t *np, *last = NULL, *del = NULL;
        switch_bool_t r = SWITCH_FALSE;

        switch_mutex_lock(la->mutex);
        for (np = la->aliases; np; np = np->next) {
                if (!strcmp(np->event_channel, event_channel) && !strcmp(np->name, name)) {
                        r = SWITCH_TRUE;
                        del = np;

                        if (last) {
                                last->next = np->next;
                        } else {
                                la->aliases = np->next;
                        }
                } else {
                        last = np;
                }
        }
        switch_mutex_unlock(la->mutex);

        if (r) {
                switch_mutex_lock(event_channel_manager.lamutex);
                switch_core_hash_delete(event_channel_manager.lahash, del->key);
                switch_mutex_unlock(event_channel_manager.lamutex);
        }


        return r;
}

switch_live_array_create()

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
	)

Definition at line 3497 of file switch_event.c.

References switch_live_array_s::channel_id, switch_live_array_s::event_channel, event_channel_manager, switch_live_array_s::hash, key, switch_live_array_s::key, switch_live_array_s::mutex, switch_live_array_s::name, switch_live_array_s::new, pool, switch_live_array_s::pool, switch_live_array_s::refs, switch_live_array_s::serno, switch_core_alloc, switch_core_hash_find(), switch_core_hash_init, switch_core_hash_insert, switch_core_new_memory_pool, switch_core_sprintf(), switch_core_strdup, SWITCH_FALSE, switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_live_array_s::visible.

Referenced by switch_live_array_parse_json().

{
        switch_live_array_t *la = NULL;
        switch_memory_pool_t *pool;
        char *key = NULL;

        switch_core_new_memory_pool(&pool);
        key = switch_core_sprintf(pool, "%s.%s", event_channel, name);

        switch_mutex_lock(event_channel_manager.lamutex);
        la = switch_core_hash_find(event_channel_manager.lahash, key);
        switch_mutex_unlock(event_channel_manager.lamutex);

        if (la) {
                la->new = SWITCH_FALSE;
        } else {
                la = switch_core_alloc(pool, sizeof(*la));
                la->pool = pool;
                la->serno = 1;
                la->visible = SWITCH_TRUE;
                la->event_channel = switch_core_strdup(la->pool, event_channel);
                la->name = switch_core_strdup(la->pool, name);
                la->key = key;
                la->new = SWITCH_TRUE;
                la->channel_id = channel_id;
                switch_core_hash_init(&la->hash);
                switch_mutex_init(&la->mutex, SWITCH_MUTEX_NESTED, la->pool);

                switch_mutex_lock(event_channel_manager.lamutex);
                switch_core_hash_insert(event_channel_manager.lahash, la->key, la);
                switch_mutex_unlock(event_channel_manager.lamutex);
        }

        switch_mutex_lock(la->mutex);
        la->refs++;
        switch_mutex_unlock(la->mutex);

        *live_arrayP = la;

        return SWITCH_STATUS_SUCCESS;
}

switch_live_array_del()

switch_status_t switch_live_array_del	(	switch_live_array_t *	la,
		const char *	name
	)

Definition at line 3581 of file switch_event.c.

References cur, switch_live_array_s::event_channel, switch_live_array_s::hash, switch_live_array_s::head, json_add_child_obj(), la_broadcast(), switch_live_array_s::mutex, la_node_s::name, switch_live_array_s::name, la_node_s::next, la_node_s::obj, la_node_s::pos, switch_live_array_s::pos, switch_live_array_s::serno, switch_core_hash_delete(), switch_core_hash_find(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and switch_live_array_s::tail.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        la_node_t *node, *cur, *np, *last = NULL;
        cJSON *msg, *data = NULL;

        switch_mutex_lock(la->mutex);
        if ((node = switch_core_hash_find(la->hash, name))) {
                np = la->head;

                while(np) {
                        cur = np;
                        np = np->next;

                        if (cur == node) {
                                if (last) {
                                        last->next = cur->next;
                                } else {
                                        la->head = cur->next;
                                }
                                switch_core_hash_delete(la->hash, name);

                                msg = cJSON_CreateObject();
                                data = json_add_child_obj(msg, "data", NULL);

                                cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
                                cJSON_AddItemToObject(data, "name", cJSON_CreateString(la->name));
                                cJSON_AddItemToObject(data, "action", cJSON_CreateString("del"));
                                cJSON_AddItemToObject(data, "hashKey", cJSON_CreateString(cur->name));
                                cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(la->serno++));
                                cJSON_AddItemToObject(data, "data", cur->obj);
                                cur->obj = NULL;

                                la_broadcast(la, &msg);
                                free(cur->name);
                                free(cur);
                        } else {
                                cur->pos = la->pos++;
                                la->tail = cur;
                                last = cur;
                        }
                }
        }
        switch_mutex_unlock(la->mutex);

        return status;
}

switch_live_array_destroy()

switch_status_t switch_live_array_destroy

(

switch_live_array_t **

live_arrayP

)

Definition at line 3384 of file switch_event.c.

References switch_live_array_s::aliases, event_channel_manager, switch_live_array_s::hash, alias_node_s::key, switch_live_array_s::key, switch_live_array_s::mutex, alias_node_s::next, pool, switch_live_array_s::pool, switch_live_array_s::refs, switch_core_destroy_memory_pool, switch_core_hash_delete(), switch_core_hash_destroy(), switch_live_array_clear(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_live_array_parse_json().

{
        switch_live_array_t *la = *live_arrayP;
        switch_memory_pool_t *pool;
        alias_node_t *np;
        int done = 0;

        *live_arrayP = NULL;

        switch_mutex_lock(la->mutex);
        if (la->refs) {
                la->refs--;
        }
        if (la->refs) done = 1;
        switch_mutex_unlock(la->mutex);

        if (done) {
                return SWITCH_STATUS_SUCCESS;
        }

        pool = la->pool;

        switch_live_array_clear(la);

        switch_core_hash_destroy(&la->hash);

        switch_mutex_lock(event_channel_manager.lamutex);
        switch_core_hash_delete(event_channel_manager.lahash, la->key);
        for (np = la->aliases; np; np = np->next) {
                switch_core_hash_delete(event_channel_manager.lahash, np->key);
        }
        switch_mutex_unlock(event_channel_manager.lamutex);

        switch_core_destroy_memory_pool(&pool);

        return SWITCH_STATUS_SUCCESS;
}

switch_live_array_get()

cJSON* switch_live_array_get	(	switch_live_array_t *	la,
		const char *	name
	)

Definition at line 3540 of file switch_event.c.

References switch_live_array_s::hash, switch_live_array_s::mutex, la_node_s::obj, switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

{
        la_node_t *node;
        cJSON *dup = NULL;

        switch_mutex_lock(la->mutex);
        if ((node = switch_core_hash_find(la->hash, name))) {
                dup = cJSON_Duplicate(node->obj, 1);
        }
        switch_mutex_unlock(la->mutex);

        return dup;
}

switch_live_array_get_idx()

cJSON* switch_live_array_get_idx	(	switch_live_array_t *	la,
		int	idx
	)

Definition at line 3554 of file switch_event.c.

References switch_live_array_s::head, switch_live_array_s::mutex, la_node_s::next, la_node_s::obj, la_node_s::pos, switch_mutex_lock(), and switch_mutex_unlock().

{
        la_node_t *node;
        cJSON *dup = NULL;

        switch_mutex_lock(la->mutex);
        for (node = la->head; node; node = node->next) {
                if (node->pos == idx) {
                        dup = cJSON_Duplicate(node->obj, 1);
                        break;
                }
        }
        switch_mutex_unlock(la->mutex);

        return dup;
}

switch_live_array_isnew()

switch_bool_t switch_live_array_isnew

(

switch_live_array_t *

la

)

Definition at line 3422 of file switch_event.c.

References switch_live_array_s::new.

{
        return la->new;
}

switch_live_array_lock()

void switch_live_array_lock

(

switch_live_array_t *

la

)

Definition at line 3571 of file switch_event.c.

References switch_live_array_s::mutex, and switch_mutex_lock().

{
        switch_mutex_lock(la->mutex);
}

switch_live_array_parse_json()

void switch_live_array_parse_json	(	cJSON *	json,
		switch_event_channel_id_t	channel_id
	)

Definition at line 3738 of file switch_event.c.

References cJSON_GetObjectCstr(), switch_live_array_s::command_handler, name, switch_live_array_bootstrap(), switch_live_array_create(), switch_live_array_destroy(), SWITCH_STATUS_SUCCESS, and switch_live_array_s::user_data.

{
        const char *context = NULL, *name = NULL;
        switch_live_array_t *la = NULL;
        cJSON *jla = NULL;

        if ((jla = cJSON_GetObjectItem(json, "data")) && (jla = cJSON_GetObjectItem(jla, "liveArray"))) {

                if ((context = cJSON_GetObjectCstr(jla, "context")) && (name = cJSON_GetObjectCstr(jla, "name"))) {
                        const char *command = cJSON_GetObjectCstr(jla, "command");
                        const char *sessid = cJSON_GetObjectCstr(json, "sessid");

                        if (command) {
                                if (switch_live_array_create(context, name, channel_id, &la) == SWITCH_STATUS_SUCCESS) {

                                        if (!strcasecmp(command, "bootstrap")) {
                                                switch_live_array_bootstrap(la, sessid, channel_id);
                                        } else {
                                                if (la->command_handler) {
                                                        la->command_handler(la, command, sessid, jla, la->user_data);
                                                }
                                        }
                                        switch_live_array_destroy(&la);
                                }
                        }
                }
        }

}

switch_live_array_set_command_handler()

void switch_live_array_set_command_handler	(	switch_live_array_t *	la,
		switch_live_array_command_handler_t	command_handler
	)

Definition at line 3731 of file switch_event.c.

References switch_live_array_s::command_handler, and switch_assert.

{
        switch_assert(la);
        la->command_handler = command_handler;
}

switch_live_array_set_user_data()

void switch_live_array_set_user_data	(	switch_live_array_t *	la,
		void *	user_data
	)

Definition at line 3725 of file switch_event.c.

References switch_assert, switch_event_node::user_data, and switch_live_array_s::user_data.

{
        switch_assert(la);
        la->user_data = user_data;
}

switch_live_array_unlock()

void switch_live_array_unlock

(

switch_live_array_t *

la

)

Definition at line 3576 of file switch_event.c.

References switch_live_array_s::mutex, and switch_mutex_unlock().

{
        switch_mutex_unlock(la->mutex);
}

switch_live_array_visible()

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

Definition at line 3254 of file switch_event.c.

References switch_live_array_s::event_channel, json_add_child_obj(), la_broadcast(), switch_live_array_s::mutex, switch_live_array_s::serno, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and switch_live_array_s::visible.

Referenced by switch_live_array_bootstrap().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_mutex_lock(la->mutex);
        if (la->visible != visible || force) {
                cJSON *msg, *data;

                msg = cJSON_CreateObject();
                data = json_add_child_obj(msg, "data", NULL);

                cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(la->event_channel));
                cJSON_AddItemToObject(data, "action", cJSON_CreateString(visible ? "hide" : "show"));
                cJSON_AddItemToObject(data, "wireSerno", cJSON_CreateNumber(la->serno++));

                la_broadcast(la, &msg);

                la->visible = visible;
        }
        switch_mutex_unlock(la->mutex);

        return status;
}

switch_name_event()

switch_status_t switch_name_event	(	const char *	name,
		switch_event_types_t *	type
	)

return the event id that matches a given event name

Parameters

name	the name of the event
type	the event id to return

Returns

SWITCH_STATUS_SUCCESS if there was a match

Definition at line 438 of file switch_event.c.

References BLOCK, EVENT_NAMES, RUNTIME_POOL, switch_assert, SWITCH_EVENT_ALL, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by EventConsumer::bind(), Event::Event(), and switch_event_create_json().

{
        switch_event_types_t x;
        switch_assert(BLOCK != NULL);
        switch_assert(RUNTIME_POOL != NULL);

        for (x = 0; x <= SWITCH_EVENT_ALL; x++) {
                if ((strlen(name) > 13 && !strcasecmp(name + 13, EVENT_NAMES[x])) || !strcasecmp(name, EVENT_NAMES[x])) {
                        *type = x;
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        return SWITCH_STATUS_FALSE;
}