IVR Library

Collaboration diagram for IVR Library:

Modules
	IVR Menu Library

Typedefs
typedef struct switch_ivr_digit_stream_parser	switch_ivr_digit_stream_parser_t
typedef struct switch_ivr_digit_stream	switch_ivr_digit_stream_t

Functions
switch_status_t	switch_ivr_deactivate_unicast (switch_core_session_t *session)
switch_status_t	switch_ivr_activate_unicast (switch_core_session_t *session, char *local_ip, switch_port_t local_port, char *remote_ip, switch_port_t remote_port, char *transport, char *flags)
switch_status_t	switch_ivr_generate_json_cdr (switch_core_session_t *session, cJSON **json_cdr, switch_bool_t urlencode)
	Generate an JSON CDR report. More...
switch_status_t	switch_ivr_generate_xml_cdr (switch_core_session_t *session, switch_xml_t *xml_cdr)
	Generate an XML CDR report. More...
int	switch_ivr_set_xml_profile_data (switch_xml_t xml, switch_caller_profile_t *caller_profile, int off)
int	switch_ivr_set_xml_chan_vars (switch_xml_t xml, switch_channel_t *channel, int off)
switch_status_t	switch_ivr_parse_event (_In_ switch_core_session_t *session, _In_ switch_event_t *event)
	Parse command from an event. More...
switch_status_t	switch_ivr_parse_all_events (switch_core_session_t *session)
	Parse all commands from an event. More...
switch_status_t	switch_ivr_parse_next_event (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_all_messages (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_all_signal_data (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_signal_data (switch_core_session_t *session, switch_bool_t all, switch_bool_t only_session_thread)
switch_status_t	switch_ivr_parse_next_signal_data (switch_core_session_t *session)
switch_status_t	switch_ivr_process_indications (switch_core_session_t *session, switch_core_session_message_t *message)
switch_status_t	switch_ivr_sleep (switch_core_session_t *session, uint32_t ms, switch_bool_t sync, switch_input_args_t *args)
	Wait for time to pass for a specified number of milliseconds. More...
switch_status_t	switch_ivr_park (switch_core_session_t *session, switch_input_args_t *args)
switch_status_t	switch_ivr_collect_digits_callback (switch_core_session_t *session, switch_input_args_t *args, uint32_t digit_timeout, uint32_t abs_timeout)
	Wait for DTMF digits calling a pluggable callback function when digits are collected. More...
switch_status_t	switch_ivr_collect_digits_count (switch_core_session_t *session, char *buf, switch_size_t buflen, switch_size_t maxdigits, const char *terminators, char *terminator, uint32_t first_timeout, uint32_t digit_timeout, uint32_t abs_timeout)
	Wait for specified number of DTMF digits, untile terminator is received or until the channel hangs up. More...
switch_status_t	switch_ivr_play_and_detect_speech (switch_core_session_t *session, const char *file, const char *mod_name, const char *grammar, char **result, uint32_t input_timeout, switch_input_args_t *args)
	play a file to the session while doing speech recognition. More...
switch_status_t	switch_ivr_detect_speech_init (switch_core_session_t *session, const char *mod_name, const char *dest, switch_asr_handle_t *ah)
	Initialize background Speech detection on a session, so that parameters can be set, and grammars loaded. After calling this function, it is possible to call switch_ivr_set_param_detect_speech() to set recognition parameters. Calling switch_ivr_detect_speech_load_grammar() starts the speech recognition. More...
switch_status_t	switch_ivr_detect_speech (switch_core_session_t *session, const char *mod_name, const char *grammar, const char *name, const char *dest, switch_asr_handle_t *ah)
	Engage background Speech detection on a session. More...
switch_status_t	switch_ivr_stop_detect_speech (switch_core_session_t *session)
	Stop background Speech detection on a session. More...
switch_status_t	switch_ivr_pause_detect_speech (switch_core_session_t *session)
	Pause background Speech detection on a session. More...
switch_status_t	switch_ivr_resume_detect_speech (switch_core_session_t *session)
	Resume background Speech detection on a session. More...
switch_status_t	switch_ivr_detect_speech_load_grammar (switch_core_session_t *session, const char *grammar, const char *name)
	Load a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_unload_grammar (switch_core_session_t *session, const char *name)
	Unload a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_enable_grammar (switch_core_session_t *session, const char *name)
	Enable a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_disable_grammar (switch_core_session_t *session, const char *name)
	Disable a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_disable_all_grammars (switch_core_session_t *session)
	Disable all grammars on a background speech detection handle. More...
switch_status_t	switch_ivr_set_param_detect_speech (switch_core_session_t *session, const char *name, const char *val)
switch_status_t	switch_ivr_detect_speech_start_input_timers (switch_core_session_t *session)
	Start input timers on a background speech detection handle. More...
switch_status_t	switch_ivr_record_session (switch_core_session_t *session, char *file, uint32_t limit, switch_file_handle_t *fh)
	Record a session to disk. More...
switch_status_t	switch_ivr_transfer_recordings (switch_core_session_t *orig_session, switch_core_session_t *new_session)
switch_status_t	switch_ivr_eavesdrop_pop_eavesdropper (switch_core_session_t *session, switch_core_session_t **sessionp)
switch_status_t	switch_ivr_eavesdrop_exec_all (switch_core_session_t *session, const char *app, const char *arg)
switch_status_t	switch_ivr_eavesdrop_update_display (switch_core_session_t *session, const char *name, const char *number)
switch_status_t	switch_ivr_eavesdrop_session (switch_core_session_t *session, const char *uuid, const char *require_group, switch_eavesdrop_flag_t flags)
	Eavesdrop on a another session. More...
switch_status_t	switch_ivr_displace_session (switch_core_session_t *session, const char *file, uint32_t limit, const char *flags)
	displace the media for a session with the audio from a file More...
switch_status_t	switch_ivr_stop_displace_session (switch_core_session_t *session, const char *file)
	Stop displacing a session. More...
switch_status_t	switch_ivr_stop_record_session (switch_core_session_t *session, const char *file)
	Stop Recording a session. More...
switch_status_t	switch_ivr_session_audio (switch_core_session_t *session, const char *cmd, const char *direction, int level)
switch_status_t	switch_ivr_stop_session_audio (switch_core_session_t *session)
switch_status_t	switch_ivr_inband_dtmf_session (switch_core_session_t *session)
	Start looking for DTMF inband. More...
switch_status_t	switch_ivr_stop_inband_dtmf_session (switch_core_session_t *session)
	Stop looking for DTMF inband. More...
switch_status_t	switch_ivr_inband_dtmf_generate_session (switch_core_session_t *session, switch_bool_t read_stream)
	Start generating DTMF inband. More...
switch_status_t	switch_ivr_stop_inband_dtmf_generate_session (switch_core_session_t *session)
	Stop generating DTMF inband. More...
switch_status_t	switch_ivr_session_echo (switch_core_session_t *session, switch_input_args_t *args)
	NEEDDESC - More...
switch_status_t	switch_ivr_stop_tone_detect_session (switch_core_session_t *session)
	Stop looking for TONES. More...
switch_status_t	switch_ivr_tone_detect_session (switch_core_session_t *session, const char *key, const char *tone_spec, const char *flags, time_t timeout, int hits, const char *app, const char *data, switch_tone_detect_callback_t callback)
	Start looking for TONES. More...
switch_status_t	switch_ivr_play_file (switch_core_session_t *session, switch_file_handle_t *fh, const char *file, switch_input_args_t *args)
	play a file from the disk to the session More...
switch_status_t	switch_ivr_wait_for_silence (switch_core_session_t *session, uint32_t thresh, uint32_t silence_hits, uint32_t listen_hits, uint32_t timeout_ms, const char *file)
switch_status_t	switch_ivr_gentones (switch_core_session_t *session, const char *script, int32_t loops, switch_input_args_t *args)
switch_status_t	switch_ivr_record_file (_In_ switch_core_session_t *session, _In_ switch_file_handle_t *fh, _In_z_ const char *file, _In_opt_ switch_input_args_t *args, _In_ uint32_t limit)
	record a file from the session to a file More...
switch_status_t	switch_play_and_get_digits (switch_core_session_t *session, uint32_t min_digits, uint32_t max_digits, uint32_t max_tries, uint32_t timeout, const char *valid_terminators, const char *audio_file, const char *bad_input_audio_file, const char *var_name, char *digit_buffer, uint32_t digit_buffer_length, const char *digits_regex, uint32_t digit_timeout, const char *transfer_on_failure)
	Play a sound and gather digits with the number of retries specified if the user doesn't give digits in the set time. More...
switch_status_t	switch_ivr_speak_text_handle (switch_core_session_t *session, switch_speech_handle_t *sh, switch_codec_t *codec, switch_timer_t *timer, char *text, switch_input_args_t *args)
void	switch_ivr_clear_speech_cache (switch_core_session_t *session)
switch_status_t	switch_ivr_speak_text (switch_core_session_t *session, const char *tts_name, const char *voice_name, char *text, switch_input_args_t *args)
	Speak given text with given tts engine. More...
switch_status_t	switch_ivr_originate (switch_core_session_t *session, switch_core_session_t **bleg, switch_call_cause_t *cause, const char *bridgeto, uint32_t timelimit_sec, const switch_state_handler_table_t *table, const char *cid_name_override, const char *cid_num_override, switch_caller_profile_t *caller_profile_override, switch_event_t *ovars, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
	Make an outgoing call. More...
switch_status_t	switch_ivr_enterprise_originate (switch_core_session_t *session, switch_core_session_t **bleg, switch_call_cause_t *cause, const char *bridgeto, uint32_t timelimit_sec, const switch_state_handler_table_t *table, const char *cid_name_override, const char *cid_num_override, switch_caller_profile_t *caller_profile_override, switch_event_t *ovars, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
void	switch_ivr_bridge_display (switch_core_session_t *session, switch_core_session_t *peer_session)
switch_status_t	switch_ivr_multi_threaded_bridge (_In_ switch_core_session_t *session, _In_ switch_core_session_t *peer_session, switch_input_callback_function_t dtmf_callback, void *session_data, void *peer_session_data)
	Bridge Audio from one session to another. More...
switch_status_t	switch_ivr_signal_bridge (switch_core_session_t *session, switch_core_session_t *peer_session)
	Bridge Signalling from one session to another. More...
switch_status_t	switch_ivr_session_transfer (_In_ switch_core_session_t *session, const char *extension, const char *dialplan, const char *context)
	Transfer an existing session to another location. More...
uint32_t	switch_ivr_schedule_transfer (time_t runtime, const char *uuid, char *extension, char *dialplan, char *context)
	Transfer an existing session to another location in the future. More...
uint32_t	switch_ivr_schedule_hangup (time_t runtime, const char *uuid, switch_call_cause_t cause, switch_bool_t bleg)
	Hangup an existing session in the future. More...
switch_status_t	switch_ivr_uuid_bridge (const char *originator_uuid, const char *originatee_uuid)
	Bridge two existing sessions. More...
switch_status_t	switch_ivr_media (const char *uuid, switch_media_flag_t flags)
	Signal a session to request direct media access to it's remote end. More...
switch_status_t	switch_ivr_3p_media (const char *uuid, switch_media_flag_t flags)
switch_status_t	switch_ivr_nomedia (const char *uuid, switch_media_flag_t flags)
	Signal a session to request indirect media allowing it to exchange media directly with another device. More...
switch_status_t	switch_ivr_3p_nomedia (const char *uuid, switch_media_flag_t flags)
void	switch_ivr_bg_media (const char *uuid, switch_media_flag_t flags, switch_bool_t on, switch_bool_t is3p, uint32_t delay)
switch_status_t	switch_ivr_hold_uuid (const char *uuid, const char *message, switch_bool_t moh)
	Signal the session with a protocol specific hold message. More...
switch_status_t	switch_ivr_hold_toggle_uuid (const char *uuid, const char *message, switch_bool_t moh)
	Toggles channel hold state of session. More...
switch_status_t	switch_ivr_unhold_uuid (const char *uuid)
	Signal the session with a protocol specific unhold message. More...
switch_status_t	switch_ivr_hold (switch_core_session_t *session, const char *message, switch_bool_t moh)
	Signal the session with a protocol specific hold message. More...
switch_status_t	switch_ivr_unhold (switch_core_session_t *session)
	Signal the session with a protocol specific unhold message. More...
uint32_t	switch_ivr_schedule_broadcast (time_t runtime, const char *uuid, const char *path, switch_media_flag_t flags)
	Signal the session to broadcast audio in the future. More...
switch_status_t	switch_ivr_broadcast (const char *uuid, const char *path, switch_media_flag_t flags)
	Signal the session to broadcast audio. More...
void	switch_ivr_broadcast_in_thread (switch_core_session_t *session, const char *app, int flags)
switch_status_t	switch_ivr_transfer_variable (switch_core_session_t *sessa, switch_core_session_t *sessb, char *var)
	Transfer variables from one session to another. More...
switch_status_t	switch_ivr_digit_stream_parser_new (switch_memory_pool_t *pool, switch_ivr_digit_stream_parser_t **parser)
	Create a digit stream parser object. More...
switch_status_t	switch_ivr_digit_stream_parser_destroy (switch_ivr_digit_stream_parser_t *parser)
	Destroy a digit stream parser object. More...
switch_status_t	switch_ivr_digit_stream_new (switch_ivr_digit_stream_parser_t *parser, switch_ivr_digit_stream_t **stream)
	Create a new digit stream object. More...
switch_status_t	switch_ivr_digit_stream_destroy (switch_ivr_digit_stream_t **stream)
	Destroys a digit stream object. More...
switch_status_t	switch_ivr_digit_stream_parser_set_event (switch_ivr_digit_stream_parser_t *parser, char *digits, void *data)
	Set a digit string to action mapping. More...
switch_status_t	switch_ivr_digit_stream_parser_del_event (switch_ivr_digit_stream_parser_t *parser, char *digits)
	Delete a string to action mapping. More...
void *	switch_ivr_digit_stream_parser_feed (switch_ivr_digit_stream_parser_t *parser, switch_ivr_digit_stream_t *stream, char digit)
	Feed digits collected into the stream for event match testing. More...
switch_status_t	switch_ivr_digit_stream_reset (switch_ivr_digit_stream_t *stream)
	Reset the collected digit stream to nothing. More...
switch_status_t	switch_ivr_digit_stream_parser_set_terminator (switch_ivr_digit_stream_parser_t *parser, char digit)
	Set a digit string terminator. More...

Detailed Description

A group of core functions to do IVR related functions designed to be building blocks for a higher level IVR interface.

Typedef Documentation

typedef struct switch_ivr_digit_stream_parser switch_ivr_digit_stream_parser_t

Definition at line 679 of file switch_ivr.h.

typedef struct switch_ivr_digit_stream switch_ivr_digit_stream_t

Definition at line 681 of file switch_ivr.h.

Function Documentation

switch_status_t switch_ivr_3p_media	(	const char *	uuid,
		switch_media_flag_t	flags
	)

Definition at line 1564 of file switch_ivr.c.

References CF_3P_MEDIA_REQUESTED, CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_EARLY_MEDIA, CF_MEDIA_ACK, CF_MEDIA_SET, CF_MEDIA_TRANS, CF_PROXY_MODE, CF_REQ_MEDIA, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, SMF_IMMEDIATE, SMF_REBRIDGE, SMF_REPLYONLY_A, SMF_REPLYONLY_B, switch_assert, switch_channel_clear_flag(), switch_channel_clear_state_handler(), switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_FALSE, switch_ivr_uuid_bridge(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MESSAGE_INDICATE_3P_MEDIA, SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS, SWITCH_SIGNAL_BRIDGE_VARIABLE, SWITCH_STATUS_GENERR, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by media_thread_run().

{
        const char *other_uuid = NULL;
        switch_channel_t *channel, *other_channel = NULL;
        switch_core_session_t *session, *other_session;
        switch_core_session_message_t msg = { 0 };
        switch_status_t status = SWITCH_STATUS_GENERR;
        uint8_t swap = 0;
        //switch_frame_t *read_frame = NULL;

        msg.message_id = SWITCH_MESSAGE_INDICATE_3P_MEDIA;
        msg.from = __FILE__;

        if ((session = switch_core_session_locate(uuid))) {
                channel = switch_core_session_get_channel(session);
                
                if (switch_channel_test_flag(channel, CF_MEDIA_TRANS) || !switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,  "Operation is invalid\n");
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_INUSE;
                }

                switch_channel_set_flag(channel, CF_MEDIA_TRANS);

                if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                        swap = 1;
                }


                status = SWITCH_STATUS_SUCCESS;

                /* If we had early media in bypass mode before, it is no longer relevant */
                if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                        switch_core_session_message_t msg2 = { 0 };
                                
                        msg2.message_id = SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS;
                        msg2.from = __FILE__;
                        switch_core_session_receive_message(session, &msg2);
                }
                        
                if ((flags & SMF_REPLYONLY_A)) {
                        msg.numeric_arg = 1;
                }
                        
                switch_channel_set_flag(channel, CF_3P_MEDIA_REQUESTED);

                if (switch_core_session_receive_message(session, &msg) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't re-establsh media on %s\n", switch_channel_get_name(channel));
                        switch_channel_clear_flag(channel, CF_3P_MEDIA_REQUESTED);
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_GENERR;
                }

                if ((flags & SMF_REPLYONLY_B)) {
                        msg.numeric_arg = 1;
                } else {
                        msg.numeric_arg = 0;
                }

                if ((flags & SMF_IMMEDIATE)) {
                        switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 250, NULL);
                        switch_yield(250000);
                } else {
                        switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                        switch_channel_wait_for_flag(channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(channel, CF_3P_MEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);
                        //switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                }

                if ((flags & SMF_REBRIDGE)
                        && (other_uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
                        && (other_session = switch_core_session_locate(other_uuid))) {

                        other_channel = switch_core_session_get_channel(other_session);
                        switch_assert(other_channel != NULL);
                                
                        switch_channel_set_flag(other_channel, CF_3P_MEDIA_REQUESTED);
                        switch_channel_set_variable(other_channel, "rtp_secure_media", "optional");
                                
                        switch_core_session_receive_message(other_session, &msg);
                        switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_3P_MEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);
                        //switch_core_session_read_frame(other_session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        switch_channel_clear_state_handler(other_channel, NULL);
                        switch_core_session_rwunlock(other_session);
                }
                if (other_channel) {
                        switch_channel_clear_state_handler(channel, NULL);
                }
        
                switch_channel_clear_flag(channel, CF_MEDIA_TRANS);
                switch_core_session_rwunlock(session);

                if (other_channel) {
                        if (swap) {
                                switch_ivr_uuid_bridge(other_uuid, uuid);
                        } else {
                                switch_ivr_uuid_bridge(uuid, other_uuid);
                        }
                        switch_channel_wait_for_flag(channel, CF_BRIDGED, SWITCH_TRUE, 1000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_BRIDGED, SWITCH_TRUE, 1000, NULL);
                }
        }

        return status;
}

switch_status_t switch_ivr_3p_nomedia	(	const char *	uuid,
		switch_media_flag_t	flags
	)

Definition at line 1774 of file switch_ivr.c.

References CF_3P_NOMEDIA_REQUESTED, CF_3P_NOMEDIA_REQUESTED_BLEG, CF_BRIDGE_ORIGINATOR, CF_MEDIA_ACK, CF_MEDIA_TRANS, CF_PROXY_MODE, CF_REDIRECT, CF_REQ_MEDIA, CF_RESET, CS_HIBERNATE, CS_PARK, switch_core_session_message::from, switch_core_session_message::message_id, SMF_FORCE, SMF_REBRIDGE, switch_core_session_message::string_arg, SWITCH_BRIDGE_VARIABLE, switch_channel_clear_flag(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_state, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_channel_wait_for_state(), switch_core_session_get_channel(), switch_core_session_in_thread(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_FALSE, switch_ivr_signal_bridge(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MESSAGE_INDICATE_3P_NOMEDIA, SWITCH_R_SDP_VARIABLE, SWITCH_STATUS_GENERR, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by audio_bridge_thread(), and media_thread_run().

{
        const char *other_uuid;
        switch_channel_t *channel, *other_channel = NULL;
        switch_core_session_t *session, *other_session = NULL;
        switch_core_session_message_t msg = { 0 };
        switch_status_t status = SWITCH_STATUS_GENERR;
        uint8_t swap = 0;

        msg.message_id = SWITCH_MESSAGE_INDICATE_3P_NOMEDIA;
        msg.from = __FILE__;

        if ((session = switch_core_session_locate(uuid))) {
                status = SWITCH_STATUS_SUCCESS;
                channel = switch_core_session_get_channel(session);
                
                if (switch_channel_test_flag(channel, CF_MEDIA_TRANS) || (!(flags & SMF_FORCE) && switch_channel_test_flag(channel, CF_PROXY_MODE))) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,  "Operation is invalid\n");
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_INUSE;
                }

                switch_channel_set_flag(channel, CF_MEDIA_TRANS);

                if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                        swap = 1;
                }

                if ((flags & SMF_FORCE) || !switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                        if ((flags & SMF_REBRIDGE) && (other_uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE)) &&
                                (other_session = switch_core_session_locate(other_uuid))) {
                                other_channel = switch_core_session_get_channel(other_session);
                
                                switch_channel_set_flag(channel, CF_REDIRECT);
                                switch_channel_set_flag(channel, CF_RESET);
                                
                                switch_channel_set_flag(other_channel, CF_RESET);
                                switch_channel_set_flag(other_channel, CF_REDIRECT);

                                switch_channel_set_variable(channel, SWITCH_R_SDP_VARIABLE, NULL);
                                switch_channel_set_flag(channel, CF_3P_NOMEDIA_REQUESTED);
                                switch_core_session_receive_message(session, &msg);

                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_set_state(channel, CS_PARK);
                                }

                                switch_channel_set_state(other_channel, CS_PARK);
                                
                                if (switch_core_session_in_thread(session)) {
                                        switch_yield(100000);
                                } else {
                                        switch_channel_wait_for_state(other_channel, channel, CS_PARK);
                                }
                                
                                        
                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_wait_for_state(channel, NULL, CS_PARK);
                                }

                                switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                switch_channel_wait_for_flag(channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(channel, CF_3P_NOMEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);

                                msg.string_arg = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE);
                                switch_channel_set_flag(other_channel, CF_3P_NOMEDIA_REQUESTED);
                                switch_channel_set_flag(other_channel, CF_3P_NOMEDIA_REQUESTED_BLEG);


                                switch_core_session_receive_message(other_session, &msg);
                                switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_3P_NOMEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);
                        }

                        if (other_channel) {
                                if (swap) {
                                        switch_ivr_signal_bridge(other_session, session);
                                } else {
                                        switch_ivr_signal_bridge(session, other_session);
                                }

                                if (switch_core_session_in_thread(session)) {
                                        switch_yield(100000);
                                } else {
                                        switch_channel_wait_for_state(other_channel, channel, CS_HIBERNATE);
                                }

                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_wait_for_state(channel, other_channel, CS_HIBERNATE);
                                }
                                switch_core_session_rwunlock(other_session);
                        }
                }

                switch_channel_clear_flag(channel, CF_MEDIA_TRANS);
                switch_core_session_rwunlock(session);
        }

        

        return status;
}

switch_status_t switch_ivr_activate_unicast	(	switch_core_session_t *	session,
		char *	local_ip,
		switch_port_t	local_port,
		char *	remote_ip,
		switch_port_t	remote_port,
		char *	transport,
		char *	flags
	)

Definition at line 398 of file switch_ivr.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::buflen, CF_UNICAST, switch_frame::codec, switch_frame::data, fail, switch_unicast_conninfo::flag_mutex, switch_codec::implementation, switch_unicast_conninfo::local_addr, switch_unicast_conninfo::local_ip, switch_unicast_conninfo::local_port, switch_codec_implementation::microseconds_per_packet, switch_unicast_conninfo::read_codec, switch_unicast_conninfo::remote_addr, switch_unicast_conninfo::remote_ip, switch_unicast_conninfo::remote_port, switch_unicast_conninfo::session, switch_unicast_conninfo::socket, SUF_NATIVE, SUF_READY, switch_assert, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_private(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_init, switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_strdup, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_set_flag, switch_set_flag_locked, switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_create(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_UNSPEC, switch_unicast_conninfo::transport, switch_unicast_conninfo::type, switch_unicast_conninfo::write_frame, and switch_unicast_conninfo::write_frame_data.

Referenced by switch_ivr_parse_event().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_unicast_conninfo_t *conninfo = switch_core_session_alloc(session, sizeof(*conninfo));
        switch_codec_t *read_codec;

        switch_assert(conninfo != NULL);

        conninfo->local_ip = switch_core_session_strdup(session, local_ip);
        conninfo->local_port = local_port;

        conninfo->remote_ip = switch_core_session_strdup(session, remote_ip);
        conninfo->remote_port = remote_port;
        conninfo->session = session;

        if (!strcasecmp(transport, "udp")) {
                conninfo->type = AF_INET;
                conninfo->transport = SOCK_DGRAM;
        } else if (!strcasecmp(transport, "tcp")) {
                conninfo->type = AF_INET;
                conninfo->transport = SOCK_STREAM;
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid transport %s\n", transport);
                goto fail;
        }

        if (flags) {
                if (strstr(flags, "native")) {
                        switch_set_flag(conninfo, SUF_NATIVE);
                }
        }

        switch_mutex_init(&conninfo->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));

        read_codec = switch_core_session_get_read_codec(session);

        if (!switch_test_flag(conninfo, SUF_NATIVE)) {
                if (switch_core_codec_init(&conninfo->read_codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   read_codec->implementation->actual_samples_per_second,
                                                                   read_codec->implementation->microseconds_per_packet / 1000,
                                                                   1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
                                                                   NULL, switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                          "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
                                                          read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_packet / 1000);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n",
                                                          read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_packet / 1000);
                        goto fail;
                }
        }

        conninfo->write_frame.data = conninfo->write_frame_data;
        conninfo->write_frame.buflen = sizeof(conninfo->write_frame_data);
        conninfo->write_frame.codec = switch_test_flag(conninfo, SUF_NATIVE) ? read_codec : &conninfo->read_codec;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connect %s:%d->%s:%d\n",
                                          conninfo->local_ip, conninfo->local_port, conninfo->remote_ip, conninfo->remote_port);

        if (switch_sockaddr_info_get(&conninfo->local_addr,
                                                                 conninfo->local_ip, SWITCH_UNSPEC, conninfo->local_port, 0,
                                                                 switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                goto fail;
        }

        if (switch_sockaddr_info_get(&conninfo->remote_addr,
                                                                 conninfo->remote_ip, SWITCH_UNSPEC, conninfo->remote_port, 0,
                                                                 switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                goto fail;
        }

        if (switch_socket_create(&conninfo->socket, AF_INET, SOCK_DGRAM, 0, switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                if (switch_socket_bind(conninfo->socket, conninfo->local_addr) != SWITCH_STATUS_SUCCESS) {
                        goto fail;
                }
        } else {
                goto fail;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Created unicast connection %s:%d->%s:%d\n",
                                          conninfo->local_ip, conninfo->local_port, conninfo->remote_ip, conninfo->remote_port);
        switch_channel_set_private(channel, "unicast", conninfo);
        switch_channel_set_flag(channel, CF_UNICAST);
        switch_set_flag_locked(conninfo, SUF_READY);
        return SWITCH_STATUS_SUCCESS;

  fail:

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Failure creating unicast connection %s:%d->%s:%d\n",
                                          conninfo->local_ip, conninfo->local_port, conninfo->remote_ip, conninfo->remote_port);
        return SWITCH_STATUS_FALSE;
}

void switch_ivr_bg_media	(	const char *	uuid,
		switch_media_flag_t	flags,
		switch_bool_t	on,
		switch_bool_t	is3p,
		uint32_t	delay
	)

Definition at line 2014 of file switch_ivr.c.

References media_job_t::delay, media_job_t::flags, switch_thread_data_s::func, media_job_t::is3p, media_thread_run(), switch_thread_data_s::obj, media_job_t::on, pool, switch_thread_data_s::pool, media_job_t::pool, switch_core_alloc, switch_core_new_memory_pool, switch_core_strdup, switch_thread_pool_launch_thread(), and media_job_t::uuid.

Referenced by switch_core_media_toggle_hold().

{
        switch_thread_data_t *td;
        switch_memory_pool_t *pool;
        media_job_t *job;

        switch_core_new_memory_pool(&pool);
        td = switch_core_alloc(pool, sizeof(*td));
        job = switch_core_alloc(pool, sizeof(*job));
        td->func = media_thread_run;
        job->pool = pool;
        job->uuid = switch_core_strdup(pool, uuid);
        job->flags = flags;
        job->on = on;
        job->is3p = is3p;
        job->delay = delay;
        td->obj = job;
        td->pool = pool;
        switch_thread_pool_launch_thread(&td);
        
}

void switch_ivr_bridge_display	(	switch_core_session_t *	session,
		switch_core_session_t *	peer_session
	)

Definition at line 293 of file switch_ivr_bridge.c.

References send_display().

Referenced by audio_bridge_thread(), and switch_ivr_signal_bridge().

{

        send_display(session, peer_session);
        send_display(peer_session, session);

}

switch_status_t switch_ivr_broadcast	(	const char *	uuid,
		const char *	path,
		switch_media_flag_t	flags
	)

Signal the session to broadcast audio.

Parameters

uuid	the uuid of the session to broadcast on
path	the path data of the broadcast "/path/to/file.wav [<timer name>]" or "speak:<engine>|<voice>|<Text to say>"
flags	flags to send to the request (SMF_ECHO_BRIDGED to send the broadcast to both sides of the call)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4963 of file switch_ivr_async.c.

References CF_BROADCAST_DROP_MEDIA, CF_PROXY_MODE, SAF_MEDIA_TAP, SMF_ECHO_ALEG, SMF_ECHO_BLEG, SMF_EXEC_INLINE, SMF_HOLD_BLEG, SMF_LOOP, SMF_PRIORITY, SMF_REBRIDGE, switch_assert, switch_channel_get_partner_uuid(), switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_execute_application, switch_core_session_execute_application_get_flags(), switch_core_session_get_app_flags(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_queue_private_event(), switch_core_session_rwunlock(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_COMMAND, switch_event_create, switch_ivr_media(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by bcast_thread(), meta_on_dtmf(), switch_core_media_toggle_hold(), switch_core_session_send_dtmf(), switch_ivr_hold(), switch_ivr_parse_event(), switch_ivr_soft_hold(), and SWITCH_STANDARD_SCHED_FUNC().

{
        switch_channel_t *channel;
        switch_core_session_t *session, *master;
        switch_event_t *event;
        switch_core_session_t *other_session = NULL;
        const char *other_uuid = NULL;
        char *app = "playback";
        char *cause = NULL;
        char *mypath;
        char *p;
        int app_flags = 0, nomedia = 0;

        switch_assert(path);

        if (!(master = session = switch_core_session_locate(uuid))) {
                return SWITCH_STATUS_FALSE;
        }

        channel = switch_core_session_get_channel(session);

        mypath = strdup(path);
        assert(mypath);

        if ((p = strchr(mypath, ':')) && *(p + 1) == ':') {
                app = mypath;
                *p++ = '\0';
                *p++ = '\0';
                path = p;
        }

        if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                nomedia = 1;
                switch_ivr_media(uuid, SMF_REBRIDGE);
        }

        if ((cause = strchr(app, '!'))) {
                *cause++ = '\0';
                if (!cause) {
                        cause = "normal_clearing";
                }
        }

        if ((flags & SMF_ECHO_BLEG) && (other_uuid = switch_channel_get_partner_uuid(channel))
                && (other_session = switch_core_session_locate(other_uuid))) {
                if ((flags & SMF_EXEC_INLINE)) {
                        switch_core_session_execute_application_get_flags(other_session, app, path, &app_flags);
                        nomedia = 0;
                } else {
                        switch_core_session_get_app_flags(app, &app_flags);
                        if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-name", app);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-arg", path);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, (flags & SMF_PRIORITY) ? "event-lock-pri" : "event-lock", "true");

                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "lead-frames", "%d", 5);

                                if ((flags & SMF_LOOP)) {
                                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "loops", "%d", -1);
                                }

                                if ((flags & SMF_HOLD_BLEG)) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "hold-bleg", "true");
                                }

                                switch_core_session_queue_private_event(other_session, &event, (flags & SMF_PRIORITY));
                        }
                }

                switch_core_session_rwunlock(other_session);
                master = other_session;
                other_session = NULL;
        }

        if ((app_flags & SAF_MEDIA_TAP)) {
                nomedia = 0;
        }

        if ((flags & SMF_ECHO_ALEG)) {
                if ((flags & SMF_EXEC_INLINE)) {
                        nomedia = 0;
                        switch_core_session_execute_application(session, app, path);
                } else {
                        if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-name", app);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-arg", path);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, (flags & SMF_PRIORITY) ? "event-lock-pri" : "event-lock", "true");
                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "lead-frames", "%d", 5);

                                if ((flags & SMF_LOOP)) {
                                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "loops", "%d", -1);
                                }
                                if ((flags & SMF_HOLD_BLEG)) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "hold-bleg", "true");
                                }

                                switch_core_session_queue_private_event(session, &event, (flags & SMF_PRIORITY));

                                if (nomedia)
                                        switch_channel_set_flag(channel, CF_BROADCAST_DROP_MEDIA);
                        }
                }
                master = session;
        }

        if (cause) {
                if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-name", "hangup");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-arg", cause);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, (flags & SMF_PRIORITY) ? "event-lock-pri" : "event-lock", "true");
                        switch_core_session_queue_private_event(session, &event, (flags & SMF_PRIORITY));
                }
        }

        switch_core_session_rwunlock(session);
        switch_safe_free(mypath);

        return SWITCH_STATUS_SUCCESS;
}

void switch_ivr_broadcast_in_thread	(	switch_core_session_t *	session,
		const char *	app,
		int	flags
	)

Definition at line 3919 of file switch_ivr_async.c.

References bch_t::app, bcast_thread(), bch_t::flags, pool, bch_t::session, switch_assert, switch_core_session_alloc, switch_core_session_get_pool(), switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), and thread.

Referenced by meta_on_dtmf().

{
        switch_thread_t *thread;
        switch_threadattr_t *thd_attr = NULL;
        switch_memory_pool_t *pool;
        bch_t *bch;

        switch_assert(session);

        pool = switch_core_session_get_pool(session);

        bch = switch_core_session_alloc(session, sizeof(*bch));
        bch->session = session;
        bch->app = app;
        bch->flags = flags;


        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_detach_set(thd_attr, 1);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
        switch_thread_create(&thread, thd_attr, bcast_thread, bch, pool);
}

void switch_ivr_clear_speech_cache

(

switch_core_session_t *

session

)

Definition at line 2629 of file switch_ivr_play_say.c.

References cached_speech_handle::codec, switch_timer::interval, cached_speech_handle::sh, switch_speech_handle::speech_interface, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, switch_channel_get_private(), switch_channel_set_private(), switch_core_codec_destroy(), switch_core_session_get_channel(), switch_core_speech_close(), switch_core_timer_destroy(), SWITCH_SPEECH_FLAG_NONE, and cached_speech_handle::timer.

Referenced by switch_core_session_perform_destroy(), and switch_ivr_speak_text().

{
        cached_speech_handle_t *cache_obj = NULL;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if ((cache_obj = switch_channel_get_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME))) {
                switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
                if (cache_obj->timer.interval) {
                        switch_core_timer_destroy(&cache_obj->timer);
                }
                if (cache_obj->sh.speech_interface) {
                        switch_core_speech_close(&cache_obj->sh, &flags);
                }
                switch_core_codec_destroy(&cache_obj->codec);
                switch_channel_set_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, NULL);
        }
}

switch_status_t switch_ivr_collect_digits_callback	(	switch_core_session_t *	session,
		switch_input_args_t *	args,
		uint32_t	digit_timeout,
		uint32_t	abs_timeout
	)

Wait for DTMF digits calling a pluggable callback function when digits are collected.

Parameters

session	the session to read.
args	arguements to pass for callbacks etc
timeout	a timeout in milliseconds

Returns

SWITCH_STATUS_SUCCESS to keep the collection moving.

Definition at line 1173 of file switch_ivr.c.

References arg_recursion_check_start, arg_recursion_check_stop, CF_BREAK, CF_SERVICE, switch_dtmf_t::digit, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_has_dtmf(), switch_channel_ready, switch_channel_test_flag(), switch_cond_next(), switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_read_frame(), switch_event_destroy(), SWITCH_FALSE, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), switch_micro_time_now(), SWITCH_READ_ACCEPTABLE, SWITCH_STATUS_BREAK, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, and switch_frame::user_data.

Referenced by CoreSession::collectDigits(), enterprise_originate_ringback_thread(), fs_switch_ivr_collect_digits_callback(), and switch_ivr_soft_hold().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_time_t abs_started = 0, digit_started = 0;
        uint32_t abs_elapsed = 0, digit_elapsed = 0;

        if (!args) {
                return SWITCH_STATUS_GENERR;
        }

        arg_recursion_check_start(args);

        if (abs_timeout) {
                abs_started = switch_micro_time_now();
        }
        if (digit_timeout) {
                digit_started = switch_micro_time_now();
        }

        while (switch_channel_ready(channel)) {
                switch_frame_t *read_frame = NULL;
                switch_event_t *event;
                switch_dtmf_t dtmf = { 0 };

                if (switch_channel_test_flag(channel, CF_BREAK)) {
                        switch_channel_clear_flag(channel, CF_BREAK);
                        status = SWITCH_STATUS_BREAK;
                        break;
                }

                if (abs_timeout) {
                        abs_elapsed = (uint32_t) ((switch_micro_time_now() - abs_started) / 1000);
                        if (abs_elapsed >= abs_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }
                if (digit_timeout) {
                        digit_elapsed = (uint32_t) ((switch_micro_time_now() - digit_started) / 1000);
                        if (digit_elapsed >= digit_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }


                switch_ivr_parse_all_events(session);


                if (switch_channel_has_dtmf(channel)) {
                        if (!args->input_callback && !args->buf && !args->dmachine) {
                                status = SWITCH_STATUS_BREAK;
                                break;
                        }
                        switch_channel_dequeue_dtmf(channel, &dtmf);

                        if (args->dmachine) {
                                char ds[2] = {dtmf.digit, '\0'};
                                if ((status = switch_ivr_dmachine_feed(args->dmachine, ds, NULL)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        } 

                        if (args->input_callback) {
                                status = args->input_callback(session, (void *) &dtmf, SWITCH_INPUT_TYPE_DTMF, args->buf, args->buflen);
                        }

                        if (digit_timeout) {
                                digit_started = switch_micro_time_now();
                        }
                }

                if (switch_core_session_dequeue_event(session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                        switch_status_t ostatus = args->input_callback(session, event, SWITCH_INPUT_TYPE_EVENT, args->buf, args->buflen);
                        if (ostatus != SWITCH_STATUS_SUCCESS) {
                                status = ostatus;
                        }
                        switch_event_destroy(&event);
                }

                if (status != SWITCH_STATUS_SUCCESS) {
                        break;
                }

                if (switch_channel_test_flag(channel, CF_SERVICE)) {
                        switch_cond_next();
                } else {
                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                }

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        break;
                }

                if (args && args->dmachine) {
                        if ((status = switch_ivr_dmachine_ping(args->dmachine, NULL)) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }

                if (read_frame && args && (args->read_frame_callback)) {
                        if ((status = args->read_frame_callback(session, read_frame, args->user_data)) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }
        }

        arg_recursion_check_stop(args);

        return status;
}

switch_status_t switch_ivr_collect_digits_count	(	switch_core_session_t *	session,
		char *	buf,
		switch_size_t	buflen,
		switch_size_t	maxdigits,
		const char *	terminators,
		char *	terminator,
		uint32_t	first_timeout,
		uint32_t	digit_timeout,
		uint32_t	abs_timeout
	)

Wait for specified number of DTMF digits, untile terminator is received or until the channel hangs up.

Parameters

session	the session to read.
buf	strig to write to
buflen	max size of buf
maxdigits	max number of digits to read
terminators	digits to end the collection
terminator	actual digit that caused the collection to end (if any)
first_timeout	timeout in ms
digit_timeout	digit timeout in ms
abs_timeout	abs timeout in ms

Returns

SWITCH_STATUS_SUCCESS to keep the collection moving.

Definition at line 1287 of file switch_ivr.c.

References switch_frame::buflen, CF_SERVICE, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_second, switch_channel_dequeue_dtmf(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_cond_next(), switch_core_codec_destroy(), switch_core_codec_init, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_read_frame(), switch_core_session_write_frame(), switch_generate_sln_silence(), SWITCH_IO_FLAG_NONE, switch_ivr_parse_all_events(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_zmalloc, and zstr.

Referenced by fs_switch_ivr_collect_digits_count(), CoreSession::getDigits(), play_and_collect(), and switch_ivr_read().

{
        switch_size_t i = 0, x = strlen(buf);
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_time_t started = 0, digit_started = 0;
        uint32_t abs_elapsed = 0, digit_elapsed = 0;
        uint32_t eff_timeout = 0;
        switch_frame_t write_frame = { 0 };
        unsigned char *abuf = NULL;
        switch_codec_implementation_t imp = { 0 };
        switch_codec_t codec = { 0 };
        int sval = 0;
        const char *var;

        if ((var = switch_channel_get_variable(channel, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE)) && (sval = atoi(var))) {
                switch_core_session_get_read_impl(session, &imp);

                if (switch_core_codec_init(&codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   imp.samples_per_second,
                                                                   imp.microseconds_per_packet / 1000,
                                                                   imp.number_of_channels,
                                                                   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
                                                                   switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec Error L16@%uhz %u channels %dms\n",
                                                          imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);
                        return SWITCH_STATUS_FALSE;
                }


                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Codec Activated L16@%uhz %u channels %dms\n",
                                                  imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);

                write_frame.codec = &codec;
                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                write_frame.data = abuf;
                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
                write_frame.datalen = imp.decoded_bytes_per_packet;
                write_frame.samples = write_frame.datalen / sizeof(int16_t);
        }

        if (terminator != NULL) {
                *terminator = '\0';
        }

        if (!zstr(terminators)) {
                for (i = 0; i < x; i++) {
                        if (strchr(terminators, buf[i]) && terminator != NULL) {
                                *terminator = buf[i];
                                buf[i] = '\0';
                                switch_safe_free(abuf);
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        if (abs_timeout) {
                started = switch_micro_time_now();
        }

        if (digit_timeout && first_timeout) {
                eff_timeout = first_timeout;
        } else if (digit_timeout && !first_timeout) {
                first_timeout = eff_timeout = digit_timeout;
        } else if (first_timeout) {
                digit_timeout = eff_timeout = first_timeout;
        }


        if (eff_timeout) {
                digit_started = switch_micro_time_now();
        }

        while (switch_channel_ready(channel)) {
                switch_frame_t *read_frame;

                if (abs_timeout) {
                        abs_elapsed = (uint32_t) ((switch_micro_time_now() - started) / 1000);
                        if (abs_elapsed >= abs_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }


                switch_ivr_parse_all_events(session);



                if (eff_timeout) {
                        digit_elapsed = (uint32_t) ((switch_micro_time_now() - digit_started) / 1000);

                        if (digit_elapsed >= eff_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }

                if (switch_channel_has_dtmf(channel)) {
                        switch_dtmf_t dtmf = { 0 };
                        switch_size_t y;

                        if (eff_timeout) {
                                eff_timeout = digit_timeout;
                                digit_started = switch_micro_time_now();
                        }

                        for (y = 0; y <= maxdigits; y++) {
                                if (switch_channel_dequeue_dtmf(channel, &dtmf) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }

                                if (!zstr(terminators) && strchr(terminators, dtmf.digit) && terminator != NULL) {
                                        *terminator = dtmf.digit;
                                        switch_safe_free(abuf);
                                        return SWITCH_STATUS_SUCCESS;
                                }


                                buf[x++] = dtmf.digit;
                                buf[x] = '\0';

                                if (x >= buflen || x >= maxdigits) {
                                        switch_safe_free(abuf);
                                        return SWITCH_STATUS_SUCCESS;
                                }
                        }
                }

                if (switch_channel_test_flag(channel, CF_SERVICE)) {
                        switch_cond_next();
                } else {
                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                break;
                        }

                        if (write_frame.data) {
                                switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, imp.number_of_channels, sval);
                                switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
                        }

                }
        }

        if (write_frame.codec) {
                switch_core_codec_destroy(&codec);
        }

        switch_safe_free(abuf);

        return status;
}

switch_status_t switch_ivr_deactivate_unicast

(

switch_core_session_t *

session

)

Definition at line 365 of file switch_ivr.c.

References CF_UNICAST, switch_unicast_conninfo::read_codec, switch_unicast_conninfo::socket, SUF_READY, SUF_THREAD_RUNNING, switch_channel_clear_flag(), switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_clear_flag_locked, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_session_get_channel(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SHUTDOWN_READWRITE, switch_socket_close(), switch_socket_shutdown(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_thread_join(), switch_yield, and switch_unicast_conninfo::thread.

Referenced by switch_core_session_perform_destroy(), switch_core_session_reset(), and switch_ivr_park().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_unicast_conninfo_t *conninfo;
        int sanity = 0;

        if (!switch_channel_test_flag(channel, CF_UNICAST)) {
                return SWITCH_STATUS_FALSE;
        }

        if ((conninfo = switch_channel_get_private(channel, "unicast"))) {
                switch_status_t st;

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Shutting down unicast connection\n");
                switch_clear_flag_locked(conninfo, SUF_READY);
                switch_socket_shutdown(conninfo->socket, SWITCH_SHUTDOWN_READWRITE);
                switch_thread_join(&st, conninfo->thread);
                
                while (switch_test_flag(conninfo, SUF_THREAD_RUNNING)) {
                        switch_yield(10000);
                        if (++sanity >= 10000) {
                                break;
                        }
                }
                if (switch_core_codec_ready(&conninfo->read_codec)) {
                        switch_core_codec_destroy(&conninfo->read_codec);
                }
                switch_socket_close(conninfo->socket);
        }
        switch_channel_clear_flag(channel, CF_UNICAST);
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_detect_speech	(	switch_core_session_t *	session,
		const char *	mod_name,
		const char *	grammar,
		const char *	name,
		const char *	dest,
		switch_asr_handle_t *	ah
	)

Engage background Speech detection on a session.

Parameters

session	the session to attach
mod_name	the module name of the ASR library
grammar	the grammar text, URI, or local file name
name	the grammar name
dest	the destination address
ah	an ASR handle to use (NULL to create one)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4778 of file switch_ivr_async.c.

References speech_thread_handle::ah, SWITCH_ASR_FLAG_FIRE_EVENTS, switch_channel_get_private(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_load_grammar(), switch_core_session_get_channel(), switch_ivr_detect_speech_init(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_set_flag, SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOT_INITALIZED, SWITCH_STATUS_SUCCESS, and switch_true().

Referenced by switch_ivr_play_and_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status;
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        const char *p;

        if (!sth) {
                /* No speech thread handle available yet, init speech detection first. */
                if ((status = switch_ivr_detect_speech_init(session, mod_name, dest, ah)) != SWITCH_STATUS_SUCCESS) {
                        return SWITCH_STATUS_NOT_INITALIZED;
                }

                /* Fetch the new speech thread handle */
                if (!(sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
                        return SWITCH_STATUS_NOT_INITALIZED;
                }
        }

        if (switch_core_asr_load_grammar(sth->ah, grammar, name) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error loading Grammar\n");
                switch_ivr_stop_detect_speech(session);
                return SWITCH_STATUS_FALSE;
        }

        if ((p = switch_channel_get_variable(channel, "fire_asr_events")) && switch_true(p)) {
                switch_set_flag(sth->ah, SWITCH_ASR_FLAG_FIRE_EVENTS);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_detect_speech_disable_all_grammars

(

switch_core_session_t *

session

)

Disable all grammars on a background speech detection handle.

Parameters

session

The session to change the grammar on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4703 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_disable_all_grammars(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_disable_all_grammars(sth->ah)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error disabling all Grammars\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_detect_speech_disable_grammar	(	switch_core_session_t *	session,
		const char *	name
	)

Disable a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4687 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_disable_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_disable_grammar(sth->ah, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error disabling Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_detect_speech_enable_grammar	(	switch_core_session_t *	session,
		const char *	name
	)

Enable a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4671 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_enable_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_enable_grammar(sth->ah, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error enabling Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_detect_speech_init	(	switch_core_session_t *	session,
		const char *	mod_name,
		const char *	dest,
		switch_asr_handle_t *	ah
	)

Initialize background Speech detection on a session, so that parameters can be set, and grammars loaded. After calling this function, it is possible to call switch_ivr_set_param_detect_speech() to set recognition parameters. Calling switch_ivr_detect_speech_load_grammar() starts the speech recognition.

Parameters

session	the session to attach
mod_name	the module name of the ASR library
dest	the destination address
ah	an ASR handle to use (NULL to create one)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4719 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, speech_thread_handle::ah, speech_thread_handle::bug, speech_thread_handle::pool, speech_thread_handle::session, SMBF_NO_PAUSE, SMBF_READ_STREAM, speech_callback(), speech_on_dtmf(), SWITCH_ASR_FLAG_FIRE_EVENTS, SWITCH_ASR_FLAG_NONE, switch_channel_get_private(), switch_channel_get_variable, switch_channel_set_private(), switch_core_asr_close(), switch_core_asr_open(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_ivr_stop_detect_speech(), switch_set_flag, switch_snprintf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, and switch_true().

Referenced by switch_ivr_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status;
        switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_codec_implementation_t read_impl = { 0 };
        const char *p;
        char key[512] = "";

        if (sth) {
                /* Already initialized */
                return SWITCH_STATUS_SUCCESS;
        }

        if (!ah) {
                if (!(ah = switch_core_session_alloc(session, sizeof(*ah)))) {
                        return SWITCH_STATUS_MEMERR;
                }
        }

        switch_core_session_get_read_impl(session, &read_impl);

        if ((status = switch_core_asr_open(ah,
                                                                           mod_name,
                                                                           "L16",
                                                                           read_impl.actual_samples_per_second, dest, &flags,
                                                                           switch_core_session_get_pool(session))) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        sth = switch_core_session_alloc(session, sizeof(*sth));
        sth->pool = switch_core_session_get_pool(session);
        sth->session = session;
        sth->ah = ah;

        if ((p = switch_channel_get_variable(channel, "fire_asr_events")) && switch_true(p)) {
                switch_set_flag(ah, SWITCH_ASR_FLAG_FIRE_EVENTS);
        }

        switch_snprintf(key, sizeof(key), "%s/%s/%s/%s", mod_name, NULL, NULL, dest);

        if ((status = switch_core_media_bug_add(session, "detect_speech", key,
                                                                                        speech_callback, sth, 0, SMBF_READ_STREAM | SMBF_NO_PAUSE, &sth->bug)) != SWITCH_STATUS_SUCCESS) {
                switch_core_asr_close(ah, &flags);
                return status;
        }

        if ((status = switch_core_event_hook_add_recv_dtmf(session, speech_on_dtmf)) != SWITCH_STATUS_SUCCESS) {
                switch_ivr_stop_detect_speech(session);
                return status;
        }

        switch_channel_set_private(channel, SWITCH_SPEECH_KEY, sth);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_detect_speech_load_grammar	(	switch_core_session_t *	session,
		const char *	grammar,
		const char *	name
	)

Load a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
grammar	the grammar text, URI, or local file name
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4614 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_load_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_load_grammar(sth->ah, grammar, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error loading Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_detect_speech_start_input_timers

(

switch_core_session_t *

session

)

Start input timers on a background speech detection handle.

Parameters

session

The session to start the timers on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4643 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), switch_core_asr_start_input_timers(), switch_core_session_get_channel(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_play_and_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);

        if (sth) {
                switch_core_asr_start_input_timers(sth->ah);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_detect_speech_unload_grammar	(	switch_core_session_t *	session,
		const char *	name
	)

Unload a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4655 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_unload_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_unload_grammar(sth->ah, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error unloading Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_digit_stream_destroy

(

switch_ivr_digit_stream_t **

stream

)

Destroys a digit stream object.

Parameters

stream

a pointer to the stream object

Returns

NULL if no match found or consumer data that was associated with a given digit string when matched

Definition at line 2311 of file switch_ivr.c.

References switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (*stream) {
                switch_safe_free((*stream)->digits);
                free(*stream);
                *stream = NULL;
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_status_t switch_ivr_digit_stream_new	(	switch_ivr_digit_stream_parser_t *	parser,
		switch_ivr_digit_stream_t **	stream
	)

Create a new digit stream object.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
stream	a pointer to the stream object pointer

Returns

NULL if no match found or consumer data that was associated with a given digit string when matched

Definition at line 2295 of file switch_ivr.c.

References memset(), switch_assert, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        /* if we have a parser object memory pool and a stream object pointer that is null */
        if (parser && stream && *stream == NULL) {
                *stream = (switch_ivr_digit_stream_t *) malloc(sizeof(**stream));
                switch_assert(*stream);
                memset(*stream, 0, sizeof(**stream));
                switch_zmalloc((*stream)->digits, parser->buflen + 1);
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_status_t switch_ivr_digit_stream_parser_del_event	(	switch_ivr_digit_stream_parser_t *	parser,
		char *	digits
	)

Delete a string to action mapping.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
digits	the digit string to be removed from the map

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2367 of file switch_ivr.c.

References SWITCH_CHANNEL_LOG, switch_core_hash_delete(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL && digits != NULL && *digits) {
                status = switch_core_hash_delete(parser->hash, digits) ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unable to del hash for '%s'\n", digits);
        }

        return status;
}

switch_status_t switch_ivr_digit_stream_parser_destroy

(

switch_ivr_digit_stream_parser_t *

parser

)

Destroy a digit stream parser object.

Parameters

parser

a pointer to the parser object

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2277 of file switch_ivr.c.

References switch_core_destroy_memory_pool, switch_core_hash_destroy(), and SWITCH_STATUS_FALSE.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL) {
                if (parser->hash != NULL) {
                        switch_core_hash_destroy(&parser->hash);
                        parser->hash = NULL;
                }
                /* free the memory pool if we created it */
                if (parser->pool_auto_created && parser->pool != NULL) {
                        status = switch_core_destroy_memory_pool(&parser->pool);
                }
        }

        return status;
}

void* switch_ivr_digit_stream_parser_feed	(	switch_ivr_digit_stream_parser_t *	parser,
		switch_ivr_digit_stream_t *	stream,
		char	digit
	)

Feed digits collected into the stream for event match testing.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
stream	a stream to write data to
digit	a digit to collect and test against the map of digit strings

Returns

NULL if no match found or consumer data that was associated with a given digit string when matched

Definition at line 2382 of file switch_ivr.c.

References switch_assert, switch_core_hash_find(), and switch_micro_time_now().

{
        void *result = NULL;
        switch_size_t len;

        switch_assert(parser);
        switch_assert(stream);
        switch_assert(stream->digits);

        len = strlen(stream->digits);

        /* handle new digit arrivals */
        if (digit) {
                /* if it's not a terminator digit, add it to the collected digits */
                if (digit != parser->terminator) {
                        /* if collected digits length >= the max length of the keys
                         * in the hash table, then left shift the digit string
                         */
                        if (len > 0 && parser->maxlen != 0 && len >= parser->maxlen) {
                                char *src = stream->digits + 1;
                                char *dst = stream->digits;

                                while (*src) {
                                        *(dst++) = *(src++);
                                }
                                *dst = digit;
                        } else {
                                *(stream->digits + (len++)) = digit;
                                *(stream->digits + len) = '\0';
                                stream->last_digit_time = switch_micro_time_now() / 1000;
                        }
                }
        }

        /* don't allow collected digit string testing if there are varying sized keys until timeout */
        if (parser->maxlen - parser->minlen > 0 && (switch_micro_time_now() / 1000) - stream->last_digit_time < parser->digit_timeout_ms) {
                len = 0;
        }
        /* if we have digits to test */
        if (len) {
                result = switch_core_hash_find(parser->hash, stream->digits);
                /* if we matched the digit string, or this digit is the terminator
                 * reset the collected digits for next digit string
                 */
                if (result != NULL || parser->terminator == digit) {
                        *stream->digits = '\0';
                }
        }


        return result;
}

switch_status_t switch_ivr_digit_stream_parser_new	(	switch_memory_pool_t *	pool,
		switch_ivr_digit_stream_parser_t **	parser
	)

Create a digit stream parser object.

Parameters

pool	the pool to use for the new hash
parser	a pointer to the object pointer

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2237 of file switch_ivr.c.

References memset(), pool, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_hash_init, switch_core_new_memory_pool, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL) {
                int pool_auto_created = 0;

                /* if the caller didn't provide a pool, make one */
                if (pool == NULL) {
                        switch_core_new_memory_pool(&pool);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "created a memory pool\n");
                        if (pool != NULL) {
                                pool_auto_created = 1;
                        }
                }
                /* if we have a pool, make a parser object */
                if (pool != NULL) {
                        *parser = (switch_ivr_digit_stream_parser_t *) switch_core_alloc(pool, sizeof(switch_ivr_digit_stream_parser_t));
                }
                /* if we have parser object, initialize it for the caller */
                if (pool && *parser != NULL) {
                        memset(*parser, 0, sizeof(switch_ivr_digit_stream_parser_t));
                        (*parser)->pool_auto_created = pool_auto_created;
                        (*parser)->pool = pool;
                        (*parser)->digit_timeout_ms = 1000;
                        switch_core_hash_init(&(*parser)->hash);

                        status = SWITCH_STATUS_SUCCESS;
                } else {
                        status = SWITCH_STATUS_MEMERR;
                        /* if we can't create a parser object,clean up the pool if we created it */
                        if (pool != NULL && pool_auto_created) {
                                switch_core_destroy_memory_pool(&pool);
                        }
                }
        }

        return status;
}

switch_status_t switch_ivr_digit_stream_parser_set_event	(	switch_ivr_digit_stream_parser_t *	parser,
		char *	digits,
		void *	data
	)

Set a digit string to action mapping.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
digits	a string of digits to associate with an action
data	consumer data attached to this digit string

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2325 of file switch_ivr.c.

References SWITCH_CHANNEL_LOG, switch_core_hash_insert, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL && digits != NULL && *digits && parser->hash != NULL) {

                status = switch_core_hash_insert(parser->hash, digits, data);
                if (status == SWITCH_STATUS_SUCCESS) {
                        switch_size_t len = strlen(digits);

                        /* if we don't have a terminator, then we have to try and
                         * figure out when a digit set is completed, therefore we
                         * keep track of the min and max digit lengths
                         */

                        if (len > parser->buflen) {
                                parser->buflen = len;
                        }

                        if (parser->terminator == '\0') {
                                if (len > parser->maxlen) {
                                        parser->maxlen = len;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "max len %u\n", (uint32_t) parser->maxlen);
                                }
                                if (parser->minlen == 0 || len < parser->minlen) {
                                        parser->minlen = len;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "min len %u\n", (uint32_t) parser->minlen);
                                }
                        } else {
                                /* since we have a terminator, reset min and max */
                                parser->minlen = 0;
                                parser->maxlen = 0;
                        }
                }
        }
        if (status != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unable to add hash for '%s'\n", digits);
        }

        return status;
}

switch_status_t switch_ivr_digit_stream_parser_set_terminator	(	switch_ivr_digit_stream_parser_t *	parser,
		char	digit
	)

Set a digit string terminator.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
digit	the terminator digit

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2448 of file switch_ivr.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL) {
                parser->terminator = digit;
                /* since we have a terminator, reset min and max */
                parser->minlen = 0;
                parser->maxlen = 0;
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_status_t switch_ivr_digit_stream_reset

(

switch_ivr_digit_stream_t *

stream

)

Reset the collected digit stream to nothing.

Parameters

stream

a pointer to the parser stream object created by switch_ivr_digit_stream_new

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2435 of file switch_ivr.c.

References switch_assert, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_assert(stream);
        switch_assert(stream->digits);

        *stream->digits = '\0';
        stream->last_digit_time = 0;
        status = SWITCH_STATUS_SUCCESS;

        return status;
}

switch_status_t switch_ivr_displace_session	(	switch_core_session_t *	session,
		const char *	file,
		uint32_t	limit,
		const char *	flags
	)

displace the media for a session with the audio from a file

Parameters

session	the session to displace
file	filename
limit	time limit in ms
flags	m (mux) l (loop) or r(read session instead of write session)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 912 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, switch_directories::base_dir, switch_file_handle::channels, displace_helper_t::fh, displace_helper_t::file, switch_codec_implementation::iananame, displace_helper_t::loop, displace_helper_t::mux, switch_codec_implementation::number_of_channels, read_displace_callback(), switch_file_handle::samplerate, SMBF_NO_PAUSE, SMBF_READ_REPLACE, SMBF_WRITE_REPLACE, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_get_private(), switch_channel_get_variable, switch_channel_hangup, switch_channel_media_up, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_file_close(), switch_core_file_open, switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_codec(), switch_core_session_get_read_impl(), switch_core_session_reset(), switch_core_session_sprintf(), switch_core_session_strdup, switch_epoch_time_now(), SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, switch_find_end_paren(), SWITCH_GLOBAL_dirs, switch_is_file_path(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PATH_SEPARATOR, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_str_nil, SWITCH_TRUE, switch_true(), SWITCH_URL_SEPARATOR, write_displace_callback(), and zstr.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug;
        switch_status_t status;
        time_t to = 0;
        char *ext;
        const char *prefix;
        displace_helper_t *dh;
        const char *p;
        switch_bool_t hangup_on_error = SWITCH_FALSE;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);

        if ((p = switch_channel_get_variable(channel, "DISPLACE_HANGUP_ON_ERROR"))) {
                hangup_on_error = switch_true(p);
        }

        if (zstr(file)) {
                return SWITCH_STATUS_FALSE;
        }

        if ((status = switch_channel_pre_answer(channel)) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_STATUS_FALSE;
        }

        if (!switch_channel_media_up(channel) || !switch_core_session_get_read_codec(session)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can not displace session.  Media not enabled on channel\n");
                return SWITCH_STATUS_FALSE;
        }

        if ((bug = switch_channel_get_private(channel, file))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Only 1 of the same file per channel please!\n");
                return SWITCH_STATUS_FALSE;
        }

        if (!(dh = switch_core_session_alloc(session, sizeof(*dh)))) {
                return SWITCH_STATUS_MEMERR;
        }

        if (!(prefix = switch_channel_get_variable(channel, "sound_prefix"))) {
                prefix = SWITCH_GLOBAL_dirs.base_dir;
        }

        if (!strstr(file, SWITCH_URL_SEPARATOR)) {
                if (!switch_is_file_path(file)) {
                        char *tfile = NULL;
                        char *e;

                        if (*file == '[') {
                                tfile = switch_core_session_strdup(session, file);
                                if ((e = switch_find_end_paren(tfile, '[', ']'))) {
                                        *e = '\0';
                                        file = e + 1;
                                } else {
                                        tfile = NULL;
                                }
                        }

                        file = switch_core_session_sprintf(session, "%s%s%s%s%s", switch_str_nil(tfile), tfile ? "]" : "", prefix, SWITCH_PATH_SEPARATOR, file);
                }
                if ((ext = strrchr(file, '.'))) {
                        ext++;
                } else {
                        ext = read_impl.iananame;
                        file = switch_core_session_sprintf(session, "%s.%s", file, ext);
                }
        }

        dh->fh.channels = read_impl.number_of_channels;
        dh->fh.samplerate = read_impl.actual_samples_per_second;
        dh->file = switch_core_session_strdup(session, file);

        if (switch_core_file_open(&dh->fh,
                                                          file,
                                                          read_impl.number_of_channels,
                                                          read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                if (hangup_on_error) {
                        switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                }
                return SWITCH_STATUS_GENERR;
        }

        if (limit) {
                to = switch_epoch_time_now(NULL) + limit;
        }

        if (flags && strchr(flags, 'm')) {
                dh->mux++;
        }

        if (flags && strchr(flags, 'l')) {
                dh->loop++;
        }

        if (flags && strchr(flags, 'r')) {
                status = switch_core_media_bug_add(session, "displace", file,
                                                                                   read_displace_callback, dh, to, SMBF_WRITE_REPLACE | SMBF_READ_REPLACE | SMBF_NO_PAUSE, &bug);
        } else {
                status = switch_core_media_bug_add(session, "displace", file,
                                                                                   write_displace_callback, dh, to, SMBF_WRITE_REPLACE | SMBF_READ_REPLACE | SMBF_NO_PAUSE, &bug);
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                switch_core_file_close(&dh->fh);
                return status;
        }

        switch_channel_set_private(channel, file, bug);

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_eavesdrop_exec_all	(	switch_core_session_t *	session,
		const char *	app,
		const char *	arg
	)

Definition at line 1832 of file switch_ivr_async.c.

References exec_cb_data::caller, exec_cb(), switch_core_media_bug_exec_all(), switch_core_session_alloc, switch_core_session_strdup, exec_cb_data::val, and exec_cb_data::var.

{
        struct exec_cb_data *data = NULL;

        data = switch_core_session_alloc(session, sizeof(*data));
        data->var = switch_core_session_strdup(session, app);
        data->val = switch_core_session_strdup(session, arg);
        data->caller = session;

        return switch_core_media_bug_exec_all(session, "eavesdrop", exec_cb, data);
}

switch_status_t switch_ivr_eavesdrop_pop_eavesdropper	(	switch_core_session_t *	session,
		switch_core_session_t **	sessionp
	)

Definition at line 1773 of file switch_ivr_async.c.

References eavesdrop_pvt::eavesdropper, ep, SMBF_PRUNE, switch_core_media_bug_get_user_data(), switch_core_media_bug_pop(), switch_core_media_bug_set_flag(), switch_core_session_read_lock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_media_bug_t *bug;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (switch_core_media_bug_pop(session, "eavesdrop", &bug) == SWITCH_STATUS_SUCCESS) {
                struct eavesdrop_pvt *ep = (struct eavesdrop_pvt *) switch_core_media_bug_get_user_data(bug);

                if (ep && ep->eavesdropper && ep->eavesdropper != session) {
                        switch_core_session_read_lock(ep->eavesdropper);
                        *sessionp = ep->eavesdropper;
                        switch_core_media_bug_set_flag(bug, SMBF_PRUNE);
                        status = SWITCH_STATUS_SUCCESS;
                }
        }


        return status;
}

switch_status_t switch_ivr_eavesdrop_session	(	switch_core_session_t *	session,
		const char *	uuid,
		const char *	require_group,
		switch_eavesdrop_flag_t	flags
	)

Eavesdrop on a another session.

Parameters

session	our session
uuid	the uuid of the session to spy on
require_group	group name to use to limit by group
flags	tweak read-mux, write-mux and dtmf

Returns

SWITCH_STATUS_SUCESS if all is well

Definition at line 1866 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, buf, eavesdrop_pvt::buffer, switch_frame::buflen, switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_VIDEO, switch_core_session::channel, switch_frame::codec, switch_frame::data, eavesdrop_pvt::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, eavesdrop_callback(), eavesdrop_pvt::eavesdropper, ED_BRIDGE_READ, ED_BRIDGE_WRITE, ED_COPY_DISPLAY, ED_DTMF, ED_MUX_READ, ED_MUX_WRITE, ep, eavesdrop_pvt::flags, switch_core_session_message::from, switch_codec::implementation, switch_core_session_message::message_id, switch_codec_implementation::microseconds_per_packet, eavesdrop_pvt::mutex, switch_codec_implementation::number_of_channels, eavesdrop_pvt::r_buffer, eavesdrop_pvt::r_mutex, switch_frame::rate, eavesdrop_pvt::read_impl, switch_frame::samples, SFF_CNG, SMBF_NO_PAUSE, SMBF_READ_PING, SMBF_READ_REPLACE, SMBF_READ_STREAM, SMBF_READ_VIDEO_PING, SMBF_READ_VIDEO_STREAM, SMBF_SPY_VIDEO_STREAM, SMBF_SPY_VIDEO_STREAM_BLEG, SMBF_THREAD_LOCK, SMBF_WRITE_REPLACE, SMBF_WRITE_STREAM, SMBF_WRITE_VIDEO_STREAM, switch_core_session_message::string_arg, switch_buffer_add_mutex(), switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_inuse(), switch_buffer_lock(), switch_buffer_read(), switch_buffer_unlock(), switch_buffer_zero(), switch_buffer_zwrite(), switch_channel_dequeue_dtmf(), switch_channel_get_caller_profile(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_media_ack, switch_channel_media_up, switch_channel_pre_answer, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_state_change_pending(), switch_channel_test_flag(), switch_channel_up, switch_channel_up_nosig, switch_clear_flag, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, switch_core_media_bug_add(), switch_core_media_bug_clear_flag(), switch_core_media_bug_remove(), switch_core_media_bug_set_flag(), switch_core_media_bug_test_flag(), switch_core_session_alloc, switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_locate, switch_core_session_read_frame(), switch_core_session_receive_message, switch_core_session_request_video_refresh(), switch_core_session_reset(), switch_core_session_rwunlock(), switch_core_session_set_read_codec(), switch_core_session_strdup, switch_core_session_write_frame(), switch_event_destroy(), switch_event_get_header, SWITCH_FALSE, SWITCH_IO_FLAG_NONE, switch_ivr_phrase_macro, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_media_bug_parse_spy_fmt(), switch_media_bug_set_spy_fmt(), SWITCH_MESSAGE_INDICATE_BRIDGE, SWITCH_MESSAGE_INDICATE_DISPLAY, SWITCH_MESSAGE_INDICATE_UNBRIDGE, SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_mux_channels(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, switch_separate_string(), switch_set_flag, switch_snprintf(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_true(), switch_yield, eavesdrop_pvt::tread_impl, eavesdrop_pvt::w_buffer, eavesdrop_pvt::w_mutex, and zstr.

{
        switch_core_session_t *tsession;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        int codec_initialized = 0;
        const char *name, *num;

        if ((tsession = switch_core_session_locate(uuid))) {
                struct eavesdrop_pvt *ep = NULL;
                switch_media_bug_t *bug = NULL;
                switch_channel_t *tchannel = switch_core_session_get_channel(tsession);
                switch_frame_t *read_frame, write_frame = { 0 };
                switch_codec_t codec = { 0 };
                int16_t buf[SWITCH_RECOMMENDED_BUFFER_SIZE / 2];
                uint32_t tlen;
                const char *macro_name = "eavesdrop_announce";
                const char *id_name = NULL;
                switch_codec_implementation_t tread_impl = { 0 }, read_impl = { 0 };
                switch_core_session_message_t msg = { 0 };
                char cid_buf[1024] = "";
                switch_caller_profile_t *cp = NULL;
                uint32_t sanity = 600;
                switch_media_bug_flag_t read_flags = 0, write_flags = 0;
                const char *vval;
                int buf_size = 0;

                if (!switch_channel_media_up(channel)) {
                        goto end;
                }

                while(switch_channel_state_change_pending(tchannel) || !switch_channel_media_up(tchannel)) {
                        switch_yield(10000);
                        if (!--sanity) break;
                }

                if (!switch_channel_media_up(tchannel)) {
                        goto end;
                }

                switch_core_session_get_read_impl(tsession, &tread_impl);
                switch_core_session_get_read_impl(session, &read_impl);

                if ((id_name = switch_channel_get_variable(tchannel, "eavesdrop_announce_id"))) {
                        const char *tmp = switch_channel_get_variable(tchannel, "eavesdrop_announce_macro");
                        if (tmp) {
                                macro_name = tmp;
                        }

                        switch_ivr_phrase_macro(session, macro_name, id_name, NULL, NULL);
                }


                if (!zstr(require_group)) {
                        int argc, i;
                        int ok = 0;
                        char *argv[10] = { 0 };
                        char *data;

                        const char *group_name = switch_channel_get_variable(tchannel, "eavesdrop_group");
                        /* If we don't have a group, then return */
                        if (!group_name) {
                                status = SWITCH_STATUS_BREAK;
                                goto end;
                        }
                        /* Separate the group */
                        data = strdup(group_name);
                        if ((argc = switch_separate_string(data, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                                for (i = 0; i < argc; i++) {
                                        /* If one of the group matches, then ok */
                                        if (argv[i] && !strcmp(argv[i], require_group)) {
                                                ok = 1;
                                        }
                                }
                        }
                        switch_safe_free(data);
                        /* If we didn't find any match, then end */
                        if (!ok) {
                                status = SWITCH_STATUS_BREAK;
                                goto end;
                        }
                }


                ep = switch_core_session_alloc(session, sizeof(*ep));

                tlen = tread_impl.decoded_bytes_per_packet;


                if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                        goto end;
                }


                if (switch_core_codec_init(&codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   tread_impl.actual_samples_per_second,
                                                                   tread_impl.microseconds_per_packet / 1000,
                                                                   tread_impl.number_of_channels,
                                                                   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
                                                                   NULL, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot init codec\n");
                        switch_core_session_rwunlock(tsession);
                        goto end;
                }

                switch_core_session_get_read_impl(session, &read_impl);

                ep->read_impl = read_impl;
                ep->tread_impl = tread_impl;

                codec_initialized = 1;

                switch_core_session_set_read_codec(session, &codec);
                write_frame.codec = &codec;
                write_frame.data = buf;
                write_frame.buflen = sizeof(buf);
                write_frame.rate = codec.implementation->actual_samples_per_second;
                
                /* Make sure that at least one leg is bridged, default to both */
                if (! (flags & (ED_BRIDGE_READ | ED_BRIDGE_WRITE))) {
                        flags |= ED_BRIDGE_READ | ED_BRIDGE_WRITE;
                }

                buf_size = codec.implementation->decoded_bytes_per_packet * 10;

                ep->eavesdropper = session;
                ep->flags = flags;
                switch_mutex_init(&ep->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
                switch_buffer_create_dynamic(&ep->buffer, buf_size, buf_size, buf_size);
                switch_buffer_add_mutex(ep->buffer, ep->mutex);

                switch_mutex_init(&ep->w_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
                switch_buffer_create_dynamic(&ep->w_buffer, buf_size, buf_size, buf_size);
                switch_buffer_add_mutex(ep->w_buffer, ep->w_mutex);

                switch_mutex_init(&ep->r_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
                switch_buffer_create_dynamic(&ep->r_buffer, buf_size, buf_size, buf_size);
                switch_buffer_add_mutex(ep->r_buffer, ep->r_mutex);

                if (flags & ED_BRIDGE_READ) {
                        read_flags = SMBF_READ_STREAM | SMBF_READ_REPLACE;
                }

                if (flags & ED_BRIDGE_WRITE) {
                        write_flags = SMBF_WRITE_STREAM | SMBF_WRITE_REPLACE;
                }

                if (switch_channel_test_flag(session->channel, CF_VIDEO) && switch_channel_test_flag(tsession->channel, CF_VIDEO)) {                    
                        if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_show_listener_video"))) { 
                                if (switch_true(vval) || !strcasecmp(vval, "aleg") || !strcasecmp(vval, "bleg") || !strcasecmp(vval, "both")) {
                                        read_flags |= SMBF_SPY_VIDEO_STREAM;
                                }
                                if (switch_true(vval) || !strcasecmp(vval, "bleg") || !strcasecmp(vval, "both")) {
                                        read_flags |= SMBF_SPY_VIDEO_STREAM_BLEG;
                                }
                        }
                        
                        if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_concat_video")) && switch_true(vval)) { 
                                read_flags |= SMBF_READ_VIDEO_STREAM;
                                read_flags |= SMBF_WRITE_VIDEO_STREAM;
                        } else {
                                read_flags |= SMBF_READ_VIDEO_PING;
                        }
                } else {
                        read_flags &= ~SMBF_READ_VIDEO_PING;
                        read_flags &= ~SMBF_READ_VIDEO_STREAM;
                        read_flags &= ~SMBF_WRITE_VIDEO_STREAM;
                        read_flags &= ~SMBF_SPY_VIDEO_STREAM;
                        read_flags &= ~SMBF_SPY_VIDEO_STREAM_BLEG;
                }

                
                if (switch_core_media_bug_add(tsession, "eavesdrop", uuid,
                                                                          eavesdrop_callback, ep, 0,
                                                                          read_flags | write_flags | SMBF_READ_PING | SMBF_THREAD_LOCK | SMBF_NO_PAUSE,
                                                                          &bug) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot attach bug\n");
                        goto end;
                }

                if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_video_spy_fmt"))) { 
                        switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt(vval));
                }

                msg.from = __FILE__;

                /* Tell the channel we are going to be in a bridge */
                msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE;
                switch_core_session_receive_message(session, &msg);
                cp = switch_channel_get_caller_profile(tchannel);

                name = cp->caller_id_name;
                num = cp->caller_id_number;

                if (flags & ED_COPY_DISPLAY) {
                        if (switch_channel_test_flag(tchannel, CF_BRIDGE_ORIGINATOR) || !switch_channel_test_flag(tchannel, CF_BRIDGED)) {
                                name = cp->callee_id_name;
                                num = cp->callee_id_number;
                        } else {
                                name = cp->caller_id_name;
                                num = cp->caller_id_number;
                        }
                }

                sanity = 300;
                while(switch_channel_up(channel) && !switch_channel_media_ack(channel) && --sanity) {
                        switch_yield(10000);
                }


                switch_snprintf(cid_buf, sizeof(cid_buf), "%s|%s", name, num);
                msg.string_arg = cid_buf;
                msg.message_id = SWITCH_MESSAGE_INDICATE_DISPLAY;
                switch_core_session_receive_message(session, &msg);

                if (switch_channel_test_flag(tchannel, CF_VIDEO)) {

                        msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;

                        switch_core_session_receive_message(tsession, &msg);
                }

                while (switch_channel_up_nosig(tchannel) && switch_channel_ready(channel)) {
                        uint32_t len = sizeof(buf);
                        switch_event_t *event = NULL;
                        char *fcommand = NULL;
                        char db[2] = "";
                        int vid_bug = 0, vid_dual = 0;

                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                goto end_loop;
                        }

                        if (switch_core_session_dequeue_event(session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                                char *command = switch_event_get_header(event, "eavesdrop-command");
                                if (command) {
                                        fcommand = switch_core_session_strdup(session, command);
                                }
                                switch_event_destroy(&event);
                        }

                        if ((flags & ED_DTMF) && switch_channel_has_dtmf(channel)) {
                                switch_dtmf_t dtmf = { 0 };
                                switch_channel_dequeue_dtmf(channel, &dtmf);
                                db[0] = dtmf.digit;
                                fcommand = db;
                        }

                        if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) || 
                                switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM)) {
                                vid_dual = 1;
                        }

                        if (vid_dual || switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
                                vid_bug = 1;
                        }
                        
                        if (fcommand) {
                                char *d;
                                for (d = fcommand; *d; d++) {
                                        int z = 1;

                                        switch (*d) {
                                        case '1':
                                                switch_set_flag(ep, ED_MUX_READ);
                                                switch_clear_flag(ep, ED_MUX_WRITE);
                                                if (vid_bug) {
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;
                                        case '2':
                                                switch_set_flag(ep, ED_MUX_WRITE);
                                                switch_clear_flag(ep, ED_MUX_READ);
                                                if (vid_bug) {
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;
                                        case '3':
                                                switch_set_flag(ep, ED_MUX_READ);
                                                switch_set_flag(ep, ED_MUX_WRITE);
                                                if (vid_bug) {
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;

                                        case '4':
                                                switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("dual-crop"));
                                                break;
                                        case '5':
                                                switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("lower-right-small"));
                                                break;
                                        case '6':
                                                switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("lower-right-large"));
                                                break;
                                        case '0':
                                                switch_clear_flag(ep, ED_MUX_READ);
                                                switch_clear_flag(ep, ED_MUX_WRITE);
                                                if (vid_bug) {
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;
                                        case '*':
                                                goto end_loop;
                                        default:
                                                z = 0;
                                                break;

                                        }

                                        if (z) {
                                                if (ep->r_buffer) {
                                                        switch_buffer_lock(ep->r_buffer);
                                                        switch_buffer_zero(ep->r_buffer);
                                                        switch_buffer_unlock(ep->r_buffer);
                                                }

                                                if (ep->w_buffer) {
                                                        switch_buffer_lock(ep->w_buffer);
                                                        switch_buffer_zero(ep->w_buffer);
                                                        switch_buffer_unlock(ep->w_buffer);
                                                }
                                        }
                                }
                        }

                        if (!switch_test_flag(read_frame, SFF_CNG)) {
                                switch_buffer_lock(ep->r_buffer);
                                switch_buffer_zwrite(ep->r_buffer, read_frame->data, read_frame->datalen);
                                switch_buffer_unlock(ep->r_buffer);

                                switch_buffer_lock(ep->w_buffer);
                                switch_buffer_zwrite(ep->w_buffer, read_frame->data, read_frame->datalen);
                                switch_buffer_unlock(ep->w_buffer);
                        }

                        if (len > tlen) {
                                len = tlen;
                        }

                        if (switch_buffer_inuse(ep->buffer) >= len) {
                                switch_buffer_lock(ep->buffer);
                                while (switch_buffer_inuse(ep->buffer) >= len) {
                                        int tchanged = 0, changed = 0;

                                        write_frame.datalen = (uint32_t) switch_buffer_read(ep->buffer, buf, len);
                                        write_frame.samples = write_frame.datalen / 2;


                                        switch_core_session_get_read_impl(tsession, &tread_impl);
                                        switch_core_session_get_read_impl(session, &read_impl);
                                                
                                        if (tread_impl.number_of_channels != ep->tread_impl.number_of_channels || 
                                                tread_impl.actual_samples_per_second != ep->tread_impl.actual_samples_per_second) {
                                                tchanged = 1;
                                        }

                                        if (read_impl.number_of_channels != ep->tread_impl.number_of_channels ||
                                                read_impl.actual_samples_per_second != ep->read_impl.actual_samples_per_second) {
                                                changed = 1;
                                        }
                                        
                                        if (changed || tchanged) {

                                                if (changed) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, 
                                                                                          "SPYING CHANNEL CODEC CHANGE FROM %dhz@%dc to %dhz@%dc\n", 
                                                                                          ep->read_impl.actual_samples_per_second,
                                                                                          ep->read_impl.number_of_channels,
                                                                                          read_impl.actual_samples_per_second,
                                                                                          read_impl.number_of_channels);
                                                }

                                                if (tchanged) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, 
                                                                                          "SPYED CHANNEL CODEC CHANGE FROM %dhz@%dc to %dhz@%dc\n", 
                                                                                          ep->tread_impl.actual_samples_per_second,
                                                                                          ep->tread_impl.number_of_channels,
                                                                                          tread_impl.actual_samples_per_second,
                                                                                          tread_impl.number_of_channels);

                                                        tlen = tread_impl.decoded_bytes_per_packet;
                                                        
                                                        if (len > tlen) {
                                                                len = tlen;
                                                        }
                                                        
                                                        switch_core_codec_destroy(&codec);
                                                        
                                                        if (switch_core_codec_init(&codec,
                                                                                                           "L16",
                                                                                                           NULL,
                                                                                                           NULL,
                                                                                                           tread_impl.actual_samples_per_second,
                                                                                                           tread_impl.microseconds_per_packet / 1000,
                                                                                                           tread_impl.number_of_channels,
                                                                                                           SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
                                                                                                           NULL, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot init codec\n");
                                                                switch_core_session_rwunlock(tsession);
                                                                goto end;
                                                        }
                                                }
                                                
                                                ep->read_impl = read_impl;
                                                ep->tread_impl = tread_impl;
                                        }
                                        

                                        if (ep->tread_impl.number_of_channels != ep->read_impl.number_of_channels) {
                                                uint32_t rlen = write_frame.datalen / 2 / ep->tread_impl.number_of_channels;
                                                
                                                switch_mux_channels((int16_t *) write_frame.data, rlen, ep->tread_impl.number_of_channels, ep->read_impl.number_of_channels);
                                                write_frame.datalen = rlen * 2 * ep->read_impl.number_of_channels;
                                                write_frame.samples = write_frame.datalen / 2;
                                        }
                                        
                                        if ((status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0)) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                }
                                switch_buffer_unlock(ep->buffer);
                        }

                }

          end_loop:

                /* Tell the channel we are no longer going to be in a bridge */
                msg.message_id = SWITCH_MESSAGE_INDICATE_UNBRIDGE;
                switch_core_session_receive_message(session, &msg);



          end:

                if (codec_initialized)
                        switch_core_codec_destroy(&codec);

                if (bug) {
                        switch_core_media_bug_remove(tsession, &bug);
                }

                if (ep) {
                        if (ep->buffer) {
                                switch_buffer_destroy(&ep->buffer);
                        }

                        if (ep->r_buffer) {
                                switch_buffer_destroy(&ep->r_buffer);
                        }

                        if (ep->w_buffer) {
                                switch_buffer_destroy(&ep->w_buffer);
                        }
                }

                switch_core_session_rwunlock(tsession);
                status = SWITCH_STATUS_SUCCESS;

                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
        }

        return status;
}

switch_status_t switch_ivr_eavesdrop_update_display	(	switch_core_session_t *	session,
		const char *	name,
		const char *	number
	)

Definition at line 1845 of file switch_ivr_async.c.

References exec_cb_data::caller, display_exec_cb(), switch_channel_clear_app_flag_key(), switch_channel_set_app_flag_key(), switch_channel_test_app_flag_key(), switch_core_media_bug_exec_all(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_strdup, SWITCH_STATUS_FALSE, exec_cb_data::val, and exec_cb_data::var.

{
        struct exec_cb_data *data = NULL;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_FALSE;

        data = switch_core_session_alloc(session, sizeof(*data));
        data->var = switch_core_session_strdup(session, name);
        data->val = switch_core_session_strdup(session, number);
        data->caller = session;

        if (!switch_channel_test_app_flag_key("EAVESDROP", channel, 1)) {
                switch_channel_set_app_flag_key("EAVESDROP", channel, 1);
                status = switch_core_media_bug_exec_all(session, "eavesdrop", display_exec_cb, data);
                switch_channel_clear_app_flag_key("EAVESDROP", channel, 1);
        }

        return status;
}

switch_status_t switch_ivr_enterprise_originate	(	switch_core_session_t *	session,
		switch_core_session_t **	bleg,
		switch_call_cause_t *	cause,
		const char *	bridgeto,
		uint32_t	timelimit_sec,
		const switch_state_handler_table_t *	table,
		const char *	cid_name_override,
		const char *	cid_num_override,
		switch_caller_profile_t *	caller_profile_override,
		switch_event_t *	ovars,
		switch_originate_flag_t	flags,
		switch_call_cause_t *	cancel_cause
	)

Definition at line 1454 of file switch_ivr_originate.c.

References enterprise_originate_handle_t::bleg, enterprise_originate_handle_t::cause, CF_ANSWERED, CF_NOT_READY, CF_PROXY_MEDIA, CF_PROXY_MODE, enterprise_originate_handle_t::done, enterprise_originate_ringback_thread(), enterprise_originate_thread(), MAX_PEERS, mutex, enterprise_originate_handle_t::mutex, switch_event_header::name, switch_event_header::next, enterprise_originate_handle_t::ovars, pool, ent_originate_ringback::ringback_data, running, ent_originate_ringback::running, ent_originate_ringback::session, enterprise_originate_handle_t::status, switch_caller_profile_dup(), SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CAUSE_LOSE_RACE, SWITCH_CAUSE_NO_ANSWER, SWITCH_CAUSE_NO_PICKUP, SWITCH_CAUSE_SUCCESS, switch_channel_cause2str(), switch_channel_clear_flag(), switch_channel_get_caller_profile(), switch_channel_get_variable, switch_channel_handle_cause(), switch_channel_media_ready, switch_channel_pre_answer, switch_channel_process_export(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_core_strdup, SWITCH_ENT_ORIGINATE_DELIM, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_brackets(), switch_event_create_plain(), switch_event_destroy(), switch_event_dup(), SWITCH_EXPORT_VARS_VARIABLE, SWITCH_FALSE, switch_goto_status, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), switch_separate_string_string(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_thread_create(), switch_thread_join(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), switch_yield, thread, enterprise_originate_handle_t::thread, ent_originate_ringback::thread, switch_event_header::value, and zstr.

Referenced by switch_ivr_originate().

{
        int x_argc = 0;
        char *x_argv[MAX_PEERS] = { 0 };
        enterprise_originate_handle_t *hp = NULL, handles[MAX_PEERS] = { {0} };
        int i;
        switch_caller_profile_t *cp = NULL;
        switch_channel_t *channel = NULL;
        char *data;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_threadattr_t *thd_attr = NULL;
        int running = 0, over = 0;
        switch_status_t tstatus = SWITCH_STATUS_FALSE;
        switch_memory_pool_t *pool;
        switch_event_header_t *hi = NULL;
        struct ent_originate_ringback rb_data = { 0 };
        const char *ringback_data = NULL;
        switch_event_t *var_event = NULL;
        int getcause = 1;

        *cause = SWITCH_CAUSE_SUCCESS;

        switch_core_new_memory_pool(&pool);

        if (zstr(bridgeto)) {
                *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
                getcause = 0;
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        data = switch_core_strdup(pool, bridgeto);

        if (session) {
                switch_caller_profile_t *cpp = NULL;
                channel = switch_core_session_get_channel(session);
                if ((cpp = switch_channel_get_caller_profile(channel))) {
                        cp = switch_caller_profile_dup(pool, cpp);
                }
        }

        if (ovars) {
                var_event = ovars;
        } else {
                if (switch_event_create_plain(&var_event, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
                        abort();
                }
        }

        if (session) {
                switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "ent_originate_aleg_uuid", switch_core_session_get_uuid(session));
        }
        
        if (channel) {
                const char *tmp_var = NULL;

                switch_channel_process_export(channel, NULL, var_event, SWITCH_EXPORT_VARS_VARIABLE);

                if ((tmp_var = switch_channel_get_variable(channel, "effective_ani"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_ani", tmp_var);
                }

                if ((tmp_var = switch_channel_get_variable(channel, "effective_aniii"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_aniii", tmp_var);
                }

                if ((tmp_var = switch_channel_get_variable(channel, "effective_caller_id_name"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_name", tmp_var);
                }

                if ((tmp_var = switch_channel_get_variable(channel, "effective_caller_id_number"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_number", tmp_var);
                }
        }

        /* strip leading spaces */
        while (data && *data && *data == ' ') {
                data++;
        }

        /* extract channel variables, allowing multiple sets of braces */
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Parsing ultra-global variables\n");
        while (*data == '<') {
                char *parsed = NULL;

                if (switch_event_create_brackets(data, '<', '>', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Parse Error!\n");
                        switch_goto_status(SWITCH_STATUS_GENERR, done);
                }

                data = parsed;
        }

        /* strip leading spaces (again) */
        while (data && *data && *data == ' ') {
                data++;
        }

        if (ovars && ovars != var_event) {
                for (hi = ovars->headers; hi; hi = hi->next) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, hi->name, hi->value);
                }
        }

        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "ignore_early_media", "true");

        if (!(x_argc = switch_separate_string_string(data, SWITCH_ENT_ORIGINATE_DELIM, x_argv, MAX_PEERS))) {
                *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
                getcause = 0;
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);

        for (i = 0; i < x_argc; i++) {
                handles[i].session = session;
                handles[i].bleg = NULL;
                handles[i].cause = 0;
                handles[i].cancel_cause = 0;
                handles[i].bridgeto = x_argv[i];
                handles[i].timelimit_sec = timelimit_sec;
                handles[i].table = table;
                handles[i].cid_name_override = cid_name_override;
                handles[i].cid_num_override = cid_num_override;
                handles[i].caller_profile_override = cp;
                switch_event_dup(&handles[i].ovars, var_event);
                handles[i].flags = flags;
                switch_mutex_init(&handles[i].mutex, SWITCH_MUTEX_NESTED, pool);
                switch_mutex_lock(handles[i].mutex);
                switch_thread_create(&handles[i].thread, thd_attr, enterprise_originate_thread, &handles[i], pool);
        }

        if (channel && !switch_channel_test_flag(channel, CF_PROXY_MODE) && !switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
                if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                        ringback_data = switch_channel_get_variable(channel, "transfer_ringback");
                }

                if (!ringback_data) {
                        ringback_data = switch_channel_get_variable(channel, "ringback");
                }

                if (ringback_data || switch_channel_media_ready(channel)) {
                        rb_data.ringback_data = ringback_data;
                        rb_data.session = session;
                        rb_data.running = 1;
                        if (!switch_channel_media_ready(channel)) {
                                if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                                        goto done;
                                }
                        }
                        switch_thread_create(&rb_data.thread, thd_attr, enterprise_originate_ringback_thread, &rb_data, pool);
                }
        }


        for (;;) {
                running = 0;
                over = 0;

                if (channel && !switch_channel_ready(channel)) {
                        break;
                }

                if (cancel_cause && *cancel_cause > 0) {
                        break;
                }

                for (i = 0; i < x_argc; i++) {


                        if (handles[i].done == 0) {
                                running++;
                        } else if (handles[i].done == 1) {
                                if (handles[i].status == SWITCH_STATUS_SUCCESS) {
                                        handles[i].done = 2;
                                        hp = &handles[i];
                                        goto done;
                                } else {
                                        handles[i].done = -1;
                                }
                        } else {
                                over++;
                        }

                        switch_yield(10000);
                }

                if (!running || over == x_argc) {
                        break;
                }
        }


  done:

        if (hp) {
                *cause = hp->cause;
                getcause = 0;
                status = hp->status;
                *bleg = hp->bleg;
                switch_mutex_unlock(hp->mutex);
                switch_thread_join(&tstatus, hp->thread);
                switch_event_destroy(&hp->ovars);
        }

        for (i = 0; i < x_argc; i++) {
                if (hp == &handles[i]) {
                        continue;
                }

                if (cancel_cause && *cancel_cause > 0) {
                        handles[i].cancel_cause = *cancel_cause;
                } else {
                        handles[i].cancel_cause = SWITCH_CAUSE_LOSE_RACE;
                }
        }

        for (i = 0; i < x_argc; i++) {

                if (hp == &handles[i]) {
                        continue;
                }

                if (channel && handles[i].cause && handles[i].cause != SWITCH_CAUSE_SUCCESS) {
                        switch_channel_handle_cause(channel, handles[i].cause);
                }

                switch_mutex_unlock(handles[i].mutex);

                if (getcause && *cause != handles[i].cause && handles[i].cause != SWITCH_CAUSE_LOSE_RACE && handles[i].cause != SWITCH_CAUSE_NO_PICKUP) {
                        *cause = handles[i].cause;
                        getcause++;
                }

                switch_thread_join(&tstatus, handles[i].thread);
                switch_event_destroy(&handles[i].ovars);
        }

        if (channel && rb_data.thread) {
                switch_channel_set_flag(channel, CF_NOT_READY);
                switch_thread_join(&tstatus, rb_data.thread);
                switch_channel_clear_flag(channel, CF_NOT_READY);
        }


  end:

        if (getcause == 1 && *cause == SWITCH_CAUSE_SUCCESS) {
                *cause = SWITCH_CAUSE_NO_ANSWER;
        }

        if (channel) {
                if (*cause == SWITCH_CAUSE_SUCCESS) {
                        switch_channel_set_variable(channel, "originate_disposition", "success");
                } else {
                        switch_channel_set_variable(channel, "originate_disposition", "failure");
                        switch_channel_set_variable(channel, "hangup_cause", switch_channel_cause2str(*cause));
                }
        }


        if (var_event && var_event != ovars) {
                switch_event_destroy(&var_event);
        }

        switch_core_destroy_memory_pool(&pool);

        return status;

}

switch_status_t switch_ivr_generate_json_cdr	(	switch_core_session_t *	session,
		cJSON **	json_cdr,
		switch_bool_t	urlencode
	)

Generate an JSON CDR report.

Parameters

session	the session to get the data from.
json_cdr	pointer to the json object

Returns

SWITCH_STATUS_SUCCESS if successful

Note

on success the json object must be freed

Definition at line 3177 of file switch_ivr.c.

References switch_channel_timetable::answered, switch_app_log::app, switch_caller_application::application_data, switch_caller_application::application_name, switch_caller_extension::applications, switch_app_log::arg, switch_channel_timetable::bridged, switch_caller_profile::caller_extension, switch_caller_extension::children, cJSON_AddItemToArray(), cJSON_AddItemToObject(), cJSON_CreateArray(), cJSON_CreateObject(), cJSON_CreateString(), switch_channel_timetable::created, switch_caller_extension::current_application, switch_caller_profile::dialplan, switch_caller_extension::extension_name, switch_caller_extension::extension_number, switch_channel_timetable::hold_accum, switch_channel_timetable::hungup, switch_channel_timetable::last_hold, switch_app_log::next, switch_caller_profile::next, switch_caller_application::next, switch_caller_profile::originatee_caller_profile, switch_caller_profile::originator_caller_profile, switch_channel_timetable::profile_created, switch_caller_profile::profile_index, switch_channel_timetable::progress, switch_channel_timetable::progress_media, switch_channel_timetable::resurrected, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_get_caller_profile(), switch_channel_get_cap_string(), switch_channel_get_flag_string(), switch_channel_get_state(), switch_channel_state_name(), switch_core_get_switchname(), switch_core_get_uuid(), switch_core_session_get_app_log(), switch_core_session_get_channel(), switch_ivr_set_json_call_stats(), switch_ivr_set_json_chan_vars(), switch_ivr_set_json_profile_data(), SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_TYPE_VIDEO, switch_snprintf(), SWITCH_STATUS_SUCCESS, switch_str_nil, SWITCH_TIME_T_FMT, switch_caller_profile::times, switch_channel_timetable::transferred, and zstr.

Referenced by switch_ivr_multi_threaded_bridge(), and switch_ivr_originate().

{
        cJSON *cdr = cJSON_CreateObject();
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_caller_profile_t *caller_profile;
        cJSON *variables, *j_main_cp, *j_caller_profile, *j_caller_extension, *j_caller_extension_apps, *j_times, *j_application,
                *j_callflow, *j_profile, *j_inner_extension, *j_app_log, *j_apps, *j_o, *j_o_profiles, *j_channel_data, *callStats;
        switch_app_log_t *app_log;
        char tmp[512], *f;

        cJSON_AddItemToObject(cdr, "core-uuid", cJSON_CreateString(switch_core_get_uuid()));
        cJSON_AddItemToObject(cdr, "switchname", cJSON_CreateString(switch_core_get_switchname()));
        j_channel_data = cJSON_CreateObject();

        cJSON_AddItemToObject(cdr, "channel_data", j_channel_data);

        cJSON_AddItemToObject(j_channel_data, "state", cJSON_CreateString((char *) switch_channel_state_name(switch_channel_get_state(channel))));
        cJSON_AddItemToObject(j_channel_data, "direction", cJSON_CreateString(switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound"));

        switch_snprintf(tmp, sizeof(tmp), "%d", switch_channel_get_state(channel));
        cJSON_AddItemToObject(j_channel_data, "state_number", cJSON_CreateString((char *) tmp));
        
        if ((f = switch_channel_get_flag_string(channel))) {
                cJSON_AddItemToObject(j_channel_data, "flags", cJSON_CreateString((char *) f));
                free(f);
        }

        if ((f = switch_channel_get_cap_string(channel))) {
                cJSON_AddItemToObject(j_channel_data, "caps", cJSON_CreateString((char *) f));
                free(f);
        }

        callStats = cJSON_CreateObject();
        cJSON_AddItemToObject(cdr, "callStats", callStats);
        switch_ivr_set_json_call_stats(callStats, session, SWITCH_MEDIA_TYPE_AUDIO);
        switch_ivr_set_json_call_stats(callStats, session, SWITCH_MEDIA_TYPE_VIDEO);

        variables = cJSON_CreateObject();
        cJSON_AddItemToObject(cdr, "variables", variables);
        switch_ivr_set_json_chan_vars(variables, channel, urlencode);


        if ((app_log = switch_core_session_get_app_log(session))) {
                switch_app_log_t *ap;

                j_app_log = cJSON_CreateObject();
                j_apps = cJSON_CreateArray();

                cJSON_AddItemToObject(cdr, "app_log", j_app_log);
                cJSON_AddItemToObject(j_app_log, "applications", j_apps);

                for (ap = app_log; ap; ap = ap->next) {
                        j_application = cJSON_CreateObject();

                        cJSON_AddItemToObject(j_application, "app_name", cJSON_CreateString(ap->app));
                        cJSON_AddItemToObject(j_application, "app_data", cJSON_CreateString(ap->arg));

                        cJSON_AddItemToArray(j_apps, j_application);
                }
        }


        caller_profile = switch_channel_get_caller_profile(channel);

        j_callflow = cJSON_CreateArray();
        cJSON_AddItemToObject(cdr, "callflow", j_callflow);

        while (caller_profile) {

                j_profile = cJSON_CreateObject();

                if (!zstr(caller_profile->dialplan)) {
                        cJSON_AddItemToObject(j_profile, "dialplan", cJSON_CreateString((char *)caller_profile->dialplan));
                }

                if (!zstr(caller_profile->profile_index)) {
                        cJSON_AddItemToObject(j_profile, "profile_index", cJSON_CreateString((char *)caller_profile->profile_index));
                }

                if (caller_profile->caller_extension) {
                        switch_caller_application_t *ap;

                        j_caller_extension = cJSON_CreateObject();
                        j_caller_extension_apps = cJSON_CreateArray();

                        cJSON_AddItemToObject(j_profile, "extension", j_caller_extension);

                        cJSON_AddItemToObject(j_caller_extension, "name", cJSON_CreateString(caller_profile->caller_extension->extension_name));
                        cJSON_AddItemToObject(j_caller_extension, "number", cJSON_CreateString(caller_profile->caller_extension->extension_number));
                        cJSON_AddItemToObject(j_caller_extension, "applications", j_caller_extension_apps);

                        if (caller_profile->caller_extension->current_application) {
                                cJSON_AddItemToObject(j_caller_extension, "current_app", cJSON_CreateString(caller_profile->caller_extension->current_application->application_name));
                        }

                        for (ap = caller_profile->caller_extension->applications; ap; ap = ap->next) {
                                j_application = cJSON_CreateObject();

                                cJSON_AddItemToArray(j_caller_extension_apps, j_application);

                                if (ap == caller_profile->caller_extension->current_application) {
                                        cJSON_AddItemToObject(j_application, "last_executed", cJSON_CreateString("true"));
                                }
                                cJSON_AddItemToObject(j_application, "app_name", cJSON_CreateString(ap->application_name));
                                cJSON_AddItemToObject(j_application, "app_data", cJSON_CreateString(switch_str_nil(ap->application_data)));