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_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)

uint32_t	switch_event_channel_unbind (const char *event_channel, switch_event_channel_func_t func)

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

switch_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

#define NO_EVENT_CHANNEL_ID 0

Definition at line 437 of file switch_event.h.

#define SWITCH_EVENT_CHANNEL_GLOBAL "__global__"

Definition at line 438 of file switch_event.h.

Referenced by ecd_deliver().

#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 383 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_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_exec(), switch_core_session_execute_application_async(), switch_core_session_outgoing_channel(), switch_core_session_perform_destroy(), switch_core_session_read_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(), 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_vprintf(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_nat_multicast_runtime(), switch_rtp_add_crypto_key(), switch_scheduler_add_task(), switch_scheduler_execute(), SWITCH_STANDARD_SCHED_FUNC(), switch_xml_locate_domain(), switch_xml_locate_group(), switch_xml_locate_user(), switch_xml_open_root(), task_thread_loop(), tone_detect_callback(), and uuid_bridge_on_soft_execute().

#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 363 of file switch_event.h.

#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().

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

Definition at line 211 of file switch_event.h.

Referenced by Event::delHeader(), switch_channel_add_variable_var_check(), switch_channel_process_export(), switch_channel_set_variable_printf(), 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().

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

Definition at line 354 of file switch_event.h.

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

#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 412 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_exec(), switch_core_session_outgoing_channel(), switch_core_session_perform_destroy(), switch_core_session_read_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(), switch_ivr_signal_bridge(), switch_ivr_unhold(), switch_limit_fire_event(), switch_loadable_module_process(), switch_loadable_module_unprocess(), switch_log_vprintf(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_nat_multicast_runtime(), switch_rtp_add_crypto_key(), switch_scheduler_task_thread(), SWITCH_STANDARD_SCHED_FUNC(), switch_xml_open_root(), tone_detect_callback(), and uuid_bridge_on_soft_execute().

#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 421 of file switch_event.h.

#define switch_event_free_subclass ( subclass_name ) switch_event_free_subclass_detailed(__FILE__, subclass_name)

Definition at line 375 of file switch_event.h.

#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(), Event::getHeader(), parse_presence_data_cols(), play_and_detect_input_callback(), switch_channel_event_set_extended_data(), switch_channel_get_scope_variables(), 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_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(), switch_json_add_presence_data_cols(), switch_say_file_handle_get_variable(), and switch_xml_config_parse_event().

#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().

#define switch_event_prep_for_delivery ( _event ) switch_event_prep_for_delivery_detailed(__FILE__, (const char * )__SWITCH_FUNC__, __LINE__, _event)

Definition at line 242 of file switch_event.h.

Referenced by switch_ivr_parse_next_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.

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 374 of file switch_event.h.

Referenced by switch_limit_init().

#define switch_event_safe_destroy ( _event ) if (_event) switch_event_destroy(_event)

Definition at line 218 of file switch_event.h.

#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

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 435 of file switch_event.h.

typedef struct switch_serial_event_header_s switch_serial_event_header_t

typedef struct switch_serial_event_s switch_serial_event_t

Enumeration Type Documentation

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

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

Definition at line 922 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;
         }
 
         if (!max) {
                 return -2;
         }
 
         data = strdup(val + 7);
 
         len = (sizeof(char *) * max) + 1;
         switch_assert(len);
 
         array = malloc(len);
         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_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(), and switch_core_session_reporting_state().

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_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_vprintf(), switch_nat_add_mapping_internal(), switch_nat_del_mapping(), switch_rtp_add_crypto_key(), switch_scheduler_add_task(), switch_scheduler_execute(), and task_thread_loop().

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

References DUP, switch_event_base_add_header(), SWITCH_STACK_NODUP, and SWITCH_STATUS_GENERR.

 {
         if (data) {
                 return switch_event_base_add_header(event, stack, header_name, (stack & SWITCH_STACK_NODUP) ? (char *)data : DUP(data));
         }
         return SWITCH_STATUS_GENERR;
 }

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

Definition at line 2635 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_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 1398 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_SUCCESS, and switch_serial_event_header_s::value.

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

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

Definition at line 1446 of file switch_event.c.

References switch_serial_event_s::body, switch_serial_event_s::event_id, switch_serial_event_s::flags, 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_SUCCESS, switch_event_header::value, and switch_serial_event_header_s::value.

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

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 2071 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_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 2013 of file switch_event.c.

References switch_event_subclass::bind, BLOCK, switch_event_node::callback, 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) {
                 if (!(subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name))) {
                         switch_event_reserve_subclass_detailed(id, subclass_name);
                         subclass = switch_core_hash_find(CUSTOM_HASH, subclass_name);
                         subclass->bind = 1;
                 }
                 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;
 }

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

Definition at line 2491 of file switch_event.c.

References switch_stream_handle::data, 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 *) var) * 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_status_t switch_event_channel_bind	(	const char *	event_channel,
		switch_event_channel_func_t	func,
		switch_event_channel_id_t *	id
	)

Definition at line 3004 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);
 
         return status;
 }

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

References switch_thread_data_s::alloc, cJSON_Delete(), 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, 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\n", event_channel);
         } else {
                 ecd = NULL;
         }
         
         return status;
 }

void switch_event_channel_permission_clear ( const char * cookie )

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

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

Definition at line 3036 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_bool_t switch_event_channel_permission_verify	(	const char *	cookie,
		const char *	event_channel
	)

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

uint32_t switch_event_channel_unbind	(	const char *	event_channel,
		switch_event_channel_func_t	func
	)

Definition at line 2999 of file switch_event.c.

References switch_event_channel_unsub_channel().

 {
         return switch_event_channel_unsub_channel(func, event_channel);
 }

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

Definition at line 2576 of file switch_event.c.

References EF_DEFAULT_ALLOW, 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_status_t switch_event_create_array_pair	(	switch_event_t **	event,
		char **	names,
		char **	vals,
		int	len
	)

Definition at line 1602 of file switch_event.c.

References 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_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 1624 of file switch_event.c.

References SWITCH_CHANNEL_LOG, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_find_end_paren(), SWITCH_LOG_DEBUG10, 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(), and switch_ivr_originate().

 {
         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);
         }
 
 
         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 };
                                 int inner_var_count;
 
                                 if ((inner_var_count = 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_DEBUG10, "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_status_t switch_event_create_json	(	switch_event_t **	event,
		const char *	json
	)

Definition at line 1728 of file switch_event.c.

References cJSON::child, cJSON_Array, cJSON_Delete(), cJSON_GetArrayItem(), cJSON_GetArraySize(), cJSON_Parse(), cJSON_String, switch_event::event_id, 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, 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;
 }

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

inlinestatic

Definition at line 385 of file switch_event.h.

References EF_UNIQ_HEADERS, switch_event_node::event_id, SWITCH_EVENT_CHANNEL_DATA, SWITCH_EVENT_CLONE, switch_event_create, SWITCH_EVENT_REQUEST_PARAMS, and SWITCH_STATUS_SUCCESS.

Referenced by switch_channel_alloc(), switch_channel_get_scope_variables(), switch_core_init(), switch_core_unset_variables(), switch_event_channel_permission_modify(), switch_event_create_brackets(), switch_ivr_enterprise_originate(), switch_ivr_originate(), and switch_ivr_uuid_bridge().

 {
         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_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_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 718 of file switch_event.c.

References ALLOC, DUP, EF_UNIQ_HEADERS, 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_status_t switch_event_del_header_val	(	switch_event_t *	event,
		const char *	header_name,
		const char *	val
	)

Definition at line 843 of file switch_event.c.

References switch_event_header::array, FREE, hash, switch_event_header::hash, switch_event_header::idx, memset(), switch_event_header::name, switch_event_header::next, switch_assert, switch_ci_hashfunc_default(), switch_queue_trypush(), 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(hp->name);
 
                         if (hp->idx) {
                                 int i = 0;
 
                                 for (i = 0; i < hp->idx; i++) {
                                         FREE(hp->array[i]);
                                 }
                                 FREE(hp->array);
                         }
 
                         FREE(hp->value);
 
                         memset(hp, 0, sizeof(*hp));
 #ifdef SWITCH_EVENT_RECYCLE
                         if (switch_queue_trypush(EVENT_HEADER_RECYCLE_QUEUE, hp) != SWITCH_STATUS_SUCCESS) {
                                 FREE(hp);
                         }
 #else
                         FREE(hp);
 #endif
                         status = SWITCH_STATUS_SUCCESS;
                 } else {
                         lp = hp;
                 }
         }
 
         return status;
 }

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 392 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_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);
 }

void switch_event_destroy ( switch_event_t ** event )

Destroy an event.

Parameters

event pointer to the pointer to event to destroy

Definition at line 1231 of file switch_event.c.

References switch_event::body, ep, FREE, switch_event::headers, switch_event_header::next, switch_event::subclass_name, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), switch_queue_trypush(), and SWITCH_STATUS_SUCCESS.

Referenced by audio_bridge_thread(), chat_process_event(), EventConsumer::cleanup(), 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_receive_event(), switch_core_session_thread(), switch_core_unset_variables(), 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(), 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_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(), unsub_all_switch_event_channel(), and Event::~Event().

 {
         switch_event_t *ep = *event;
         switch_event_header_t *hp, *this;
 
         if (ep) {
                 for (hp = ep->headers; hp;) {
                         this = hp;
                         hp = hp->next;
 
                         if (this->idx) {
                                 if (!this->array) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "INDEX WITH NO ARRAY WTF?? [%s][%s]\n", this->name, this->value);
                                 } else {
                                         int i = 0;
 
                                         for (i = 0; i < this->idx; i++) {
                                                 FREE(this->array[i]);
                                         }
                                         FREE(this->array);
                                 }
                         }
 
                         FREE(this->name);
                         FREE(this->value);
 
 
 #ifdef SWITCH_EVENT_RECYCLE
                         if (switch_queue_trypush(EVENT_HEADER_RECYCLE_QUEUE, this) != SWITCH_STATUS_SUCCESS) {
                                 FREE(this);
                         }
 #else
                         FREE(this);
 #endif
 
 
                 }
                 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_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 1302 of file switch_event.c.

References switch_event_header::array, DUP, switch_event_header::idx, switch_event_header::name, switch_event_header::next, 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_variables(), switch_core_chat_send(), switch_core_get_variables(), switch_ivr_enterprise_originate(), switch_ivr_originate(), 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_status_t switch_event_dup_reply	(	switch_event_t **	event,
		switch_event_t *	todup
	)

Definition at line 1339 of file switch_event.c.

References switch_event_header::array, switch_event_header::idx, switch_event_header::name, switch_event_header::next, 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, 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;
 }

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 2195 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_CHANNEL_LOG, switch_core_get_variable_dup(), switch_core_test_flag(), switch_event_check_permission_list(), switch_event_get_header_idx(), SWITCH_LOG_CRIT, switch_log_printf(), 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);
         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) == '\\') {
                                         *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) {
                                 *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;
 
                                         SWITCH_STANDARD_STREAM(stream);
 
                                         if (stream.data) {
                                                 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 {
                                                         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);
 
                                         } else {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
                                                 free(data);
                                                 free(indup);
                                                 return (char *) in;
                                         }
                                 }
                                 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;
                                 vtype = 0;
                                 br = 0;
                         }
                         if (len + 1 >= olen) {
                                 resize(1);
                         }
 
                         if (sp) {
                                 *c++ = ' ';
                                 sp = 0;
                                 len++;
                         }
 
                         if (*p == '$') {
                                 p--;
                         } else {
                                 *c++ = *p;
                                 len++;
                         }
                 }
         }
         free(indup);
         switch_safe_free(gvar);
 
         return data;
 }

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 1963 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, and SYSTEM_RUNNING.

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_status_t switch_event_free_subclass_detailed	(	const char *	owner,
		const char *	subclass_name
	)

Definition at line 446 of file switch_event.c.

References switch_event_subclass::bind, 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_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_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;
                 }
         }
 
         return status;
 }

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

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

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

switch_status_t switch_event_get_custom_events ( switch_console_callback_match_t ** matches )

Definition at line 1997 of file switch_event.c.

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

 {
         switch_hash_index_t *hi = NULL;
         const void *var;
         void *val;
         int x = 0;
         
         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++;
         }
 
         return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

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

Definition at line 817 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_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 796 of file switch_event.c.

References hash, switch_event_header::hash, 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_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 664 of file switch_event.c.

References BLOCK, check_dispatch(), 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_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;
 }

void switch_event_launch_dispatch_threads ( uint32_t max )

Definition at line 623 of file switch_event.c.

References check_dispatch(), EVENT_DISPATCH_QUEUE, EVENT_DISPATCH_QUEUE_RUNNING, EVENT_DISPATCH_QUEUE_THREADS, 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;
         int launched = 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);
                 }
                 launched++;
         }
 
         SOFT_MAX_DISPATCH = index;
 }

void switch_event_merge	(	switch_event_t *	event,
		switch_event_t *	tomerge
	)

Definition at line 1283 of file switch_event.c.

References switch_event_header::array, 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 speech_thread(), switch_channel_execute_on(), 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);
                 }
         }
 }

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

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

Definition at line 1929 of file switch_event.c.

References 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_status_t switch_event_rename_header	(	switch_event_t *	event,
		const char *	header_name,
		const char *	new_header_name
	)

Definition at line 767 of file switch_event.c.

References DUP, FREE, hash, switch_event_header::hash, 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_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 473 of file switch_event.c.

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

Referenced by switch_event_bind_removable().

 {
         switch_event_subclass_t *subclass;
 
         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;
                         return SWITCH_STATUS_SUCCESS;
                 }
                 return SWITCH_STATUS_INUSE;
         }
 
         switch_zmalloc(subclass, sizeof(*subclass));
 
         subclass->owner = DUP(owner);
         subclass->name = DUP(subclass_name);
 
         switch_core_hash_insert(CUSTOM_HASH, subclass->name, subclass);
 
         return SWITCH_STATUS_SUCCESS;
 }

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

References SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SYSTEM_RUNNING.

Referenced by switch_console_printf(), and switch_log_vprintf().

 {
         return SYSTEM_RUNNING ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

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

Definition at line 1487 of file switch_event.c.

References switch_event_header::array, buf, 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(), and switch_core_session_thread().

 {
         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 = buf;
                         dlen += (blocksize + (len + llen));
                         if (!(buf = realloc(buf, dlen))) {
                                 buf = m;
                                 abort();
                         }
                 }
 
                 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 = buf;
                         dlen += (blocksize + (len + llen));
                         if (!(buf = realloc(buf, dlen))) {
                                 buf = m;
                                 abort();
                         }
                 }
 
                 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_status_t switch_event_serialize_json	(	switch_event_t *	event,
		char **	str
	)

Definition at line 1817 of file switch_event.c.

References cJSON_Delete(), cJSON_PrintUnformatted(), 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_status_t switch_event_serialize_json_obj	(	switch_event_t *	event,
		cJSON **	json
	)

Definition at line 1779 of file switch_event.c.

References switch_event_header::array, cJSON_AddItemToArray(), cJSON_AddItemToObject(), cJSON_CreateArray(), cJSON_CreateObject(), cJSON_CreateString(), 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_status_t switch_status_t switch_event_set_body	(	switch_event_t *	event,
		const char *	body
	)

Definition at line 1197 of file switch_event.c.

References 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_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 760 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_status_t switch_status_t switch_event_set_subclass_name	(	switch_event_t *	event,
		const char *	subclass_name
	)

Definition at line 1177 of file switch_event.c.

References DUP, 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_status_t switch_event_shutdown ( void )

Stop the eventing system.

Returns: SWITCH_STATUS_SUCCESS when complete

Definition at line 524 of file switch_event.c.

References DISPATCH_THREAD_COUNT, EVENT_CHANNEL_DISPATCH_QUEUE, event_channel_manager, EVENT_DISPATCH_QUEUE, EVENT_DISPATCH_QUEUE_THREADS, EVENT_QUEUE_MUTEX, switch_runtime::events_use_dispatch, FREE, 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;
 
         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) {
                 switch_queue_trypush(EVENT_CHANNEL_DISPATCH_QUEUE, NULL);
                 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++) {
                         switch_queue_trypush(EVENT_DISPATCH_QUEUE, NULL);
                 }
                 
 
                 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)DISPATCH_THREAD_COUNT; 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_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 2119 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_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().

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_NOTICE, "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_status_t switch_event_unbind_callback ( switch_event_callback_t callback )

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

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_NOTICE, "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_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().

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

Definition at line 2605 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_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 3505 of file switch_event.c.

References cJSON_AddItemToObject(), cJSON_CreateNumber(), cJSON_CreateObject(), cJSON_CreateString(), cJSON_Delete(), cJSON_Duplicate(), json_add_child_obj(), la_broadcast(), la_node_s::name, la_node_s::next, la_node_s::obj, la_node_s::pos, switch_core_hash_find(), switch_core_hash_insert, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_zmalloc.

 {
         la_node_t *node;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
         const char *action = "add";
         cJSON *msg = NULL, *data = 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);
         
         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_bool_t switch_live_array_add_alias	(	switch_live_array_t *	la,
		const char *	event_channel,
		const char *	name
	)

Definition at line 3335 of file switch_event.c.

References alias_node_s::event_channel, event_channel_manager, alias_node_s::key, alias_node_s::name, 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_status_t switch_live_array_bootstrap	(	switch_live_array_t *	la,
		const char *	sessid,
		switch_event_channel_id_t	channel_id
	)

Definition at line 3188 of file switch_event.c.

References cJSON_AddItemToArray(), cJSON_AddItemToObject(), cJSON_CreateArray(), cJSON_CreateNumber(), cJSON_CreateObject(), cJSON_CreateString(), cJSON_Duplicate(), json_add_child_array(), json_add_child_obj(), la_node_s::name, la_node_s::next, la_node_s::obj, switch_event_channel_broadcast(), SWITCH_FALSE, switch_live_array_visible(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

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_status_t switch_live_array_clear ( switch_live_array_t * la )

Definition at line 3154 of file switch_event.c.

References cJSON_AddItemToObject(), cJSON_CreateNumber(), cJSON_CreateObject(), cJSON_CreateString(), cJSON_Delete(), cur, json_add_child_obj(), la_broadcast(), la_node_s::name, la_node_s::next, la_node_s::obj, switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

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_bool_t switch_live_array_clear_alias	(	switch_live_array_t *	la,
		const char *	event_channel,
		const char *	name
	)

Definition at line 3303 of file switch_event.c.

References alias_node_s::event_channel, event_channel_manager, 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_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 3373 of file switch_event.c.

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_status_t switch_live_array_del	(	switch_live_array_t *	la,
		const char *	name
	)

Definition at line 3457 of file switch_event.c.

References cJSON_AddItemToObject(), cJSON_CreateNumber(), cJSON_CreateObject(), cJSON_CreateString(), cur, json_add_child_obj(), la_broadcast(), la_node_s::name, la_node_s::next, la_node_s::obj, la_node_s::pos, switch_core_hash_delete(), switch_core_hash_find(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_FALSE.

 {
         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_status_t switch_live_array_destroy ( switch_live_array_t ** live_arrayP )

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

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

Definition at line 3416 of file switch_event.c.

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

cJSON* switch_live_array_get_idx	(	switch_live_array_t *	la,
		int	idx
	)

Definition at line 3430 of file switch_event.c.

References cJSON_Duplicate(), 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_bool_t switch_live_array_isnew ( switch_live_array_t * la )

Definition at line 3298 of file switch_event.c.

 {
         return la->new;
 }

void switch_live_array_lock ( switch_live_array_t * la )

Definition at line 3447 of file switch_event.c.

References switch_mutex_lock().

 {
         switch_mutex_lock(la->mutex);
 }

void switch_live_array_parse_json	(	cJSON *	json,
		switch_event_channel_id_t	channel_id
	)

Definition at line 3611 of file switch_event.c.

References cJSON_GetObjectCstr(), cJSON_GetObjectItem(), switch_live_array_s::command_handler, 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);
                                 }
                         }
                 }
         }
 
 }

void switch_live_array_set_command_handler	(	switch_live_array_t *	la,
		switch_live_array_command_handler_t	command_handler
	)

Definition at line 3604 of file switch_event.c.

References switch_assert.

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

void switch_live_array_set_user_data	(	switch_live_array_t *	la,
		void *	user_data
	)

Definition at line 3598 of file switch_event.c.

References switch_assert.

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

void switch_live_array_unlock ( switch_live_array_t * la )

Definition at line 3452 of file switch_event.c.

References switch_mutex_unlock().

 {
         switch_mutex_unlock(la->mutex);
 }

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

Definition at line 3130 of file switch_event.c.

References cJSON_AddItemToObject(), cJSON_CreateNumber(), cJSON_CreateObject(), cJSON_CreateString(), json_add_child_obj(), la_broadcast(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_FALSE.

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

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation