switch_core_state_machine.c File Reference

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

Include dependency graph for switch_core_state_machine.c:

Go to the source code of this file.

Macros
#define	STATE_MACRO(__STATE, __STATE_STR)

Functions
static void	switch_core_standard_on_init (switch_core_session_t *session)
static void	switch_core_standard_on_hangup (switch_core_session_t *session)
static void	switch_core_standard_on_reporting (switch_core_session_t *session)
static void	switch_core_standard_on_destroy (switch_core_session_t *session)
static void	switch_core_standard_on_reset (switch_core_session_t *session)
static void	switch_core_standard_on_routing (switch_core_session_t *session)
static void	switch_core_standard_on_execute (switch_core_session_t *session)
static void	switch_core_standard_on_exchange_media (switch_core_session_t *session)
static void	switch_core_standard_on_soft_execute (switch_core_session_t *session)
static void	switch_core_standard_on_park (switch_core_session_t *session)
static void	switch_core_standard_on_consume_media (switch_core_session_t *session)
static void	switch_core_standard_on_hibernate (switch_core_session_t *session)
void	switch_core_state_machine_init (switch_memory_pool_t *pool)
static void	check_presence (switch_core_session_t *session)
void	switch_core_session_run (switch_core_session_t *session)
void	switch_core_session_destroy_state (switch_core_session_t *session)
static void	api_hook (switch_core_session_t *session, const char *hook_var, int use_session)
void	switch_core_session_hangup_state (switch_core_session_t *session, switch_bool_t force)
void	switch_core_session_reporting_state (switch_core_session_t *session)

Macro Definition Documentation

#define STATE_MACRO	(		__STATE,
			__STATE_STR
	)

Definition at line 428 of file switch_core_state_machine.c.

Referenced by switch_core_session_destroy_state(), switch_core_session_hangup_state(), switch_core_session_reporting_state(), and switch_core_session_run().

Function Documentation

static void api_hook ( switch_core_session_t *  session, const char *  hook_var, int  use_session  )

static

Definition at line 717 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_stream_handle::data, switch_stream_handle::param_event, switch_api_execute(), switch_channel_event_set_data(), switch_channel_get_variables(), SWITCH_CHANNEL_SESSION_LOG, switch_event_expand_headers, SWITCH_LOG_DEBUG, switch_log_printf(), switch_safe_free, SWITCH_STANDARD_STREAM, switch_str_nil, and zstr.

Referenced by switch_core_session_hangup_state(), and switch_core_session_reporting_state().

{
        if (!zstr(hook_var)) {
                switch_stream_handle_t stream = { 0 };
                char *cmd = strdup(hook_var);
                char *arg = NULL;
                char *expanded = NULL;

                if ((arg = strchr(cmd, ':')) && *(arg + 1) == ':') {
                        *arg++ = '\0';
                        *arg++ = '\0';
                } else {
                        if ((arg = strchr(cmd, ' '))) {
                                *arg++ = '\0';
                        }
                }

                SWITCH_STANDARD_STREAM(stream);

                switch_channel_get_variables(session->channel, &stream.param_event);
                switch_channel_event_set_data(session->channel, stream.param_event);
                expanded = switch_event_expand_headers(stream.param_event, arg);

                switch_api_execute(cmd, expanded, use_session ? session : NULL, &stream);

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Hangup Command %s %s(%s):\n%s\n",
                                                  use_session ? "with Session" : "with no Session", cmd, switch_str_nil(expanded),
                                                  switch_str_nil((char *) stream.data) );

                if (expanded != arg) {
                        switch_safe_free(expanded);
                }

                switch_safe_free(cmd);
                
                switch_safe_free(stream.data);
        }
}

static void check_presence ( switch_core_session_t *  session )

static

Definition at line 474 of file switch_core_state_machine.c.

References switch_core_session::channel, CS_HANGUP, CS_ROUTING, SWITCH_CAUSE_LOSE_RACE, switch_channel_get_cause(), switch_channel_get_running_state(), switch_channel_presence, switch_channel_set_variable, and switch_channel_state_name().

Referenced by switch_core_session_run().

{
        switch_channel_state_t state = switch_channel_get_running_state(session->channel);

        if (state == CS_ROUTING || state == CS_HANGUP) {
                if (switch_channel_get_cause(session->channel) == SWITCH_CAUSE_LOSE_RACE) {
                        switch_channel_presence(session->channel, "unknown", "cancelled", NULL);
                        switch_channel_set_variable(session->channel, "presence_call_info", NULL);
                } else {
                        switch_channel_presence(session->channel, "unknown", switch_channel_state_name(state), NULL);
                }
        }
}

void switch_core_session_run

(

switch_core_session_t *

session

)

Definition at line 490 of file switch_core_state_machine.c.

References CF_BLOCK_STATE, CF_NO_CDR, CF_REDIRECT, CF_THREAD_SLEEPING, CF_TRANSFER, CF_VIDEO, check_presence(), CS_CONSUME_MEDIA, CS_DESTROY, CS_EXCHANGE_MEDIA, CS_EXECUTE, CS_HANGUP, CS_HIBERNATE, CS_INIT, CS_NEW, CS_NONE, CS_PARK, CS_REPORTING, CS_RESET, CS_ROUTING, CS_SOFT_EXECUTE, db_job::event, switch_io_event_hook_state_run::next, SSF_THREAD_RUNNING, switch_endpoint_interface::state_handler, STATE_MACRO, switch_io_event_hook_state_run::state_run, switch_assert, SWITCH_CALL_DIRECTION_OUTBOUND, SWITCH_CAUSE_WRONG_CALL_STATE, switch_channel_clear_flag(), switch_channel_direction(), switch_channel_event_set_data(), switch_channel_get_name(), switch_channel_get_running_state(), switch_channel_get_state(), switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_running_state, switch_channel_set_state, switch_channel_state_name(), switch_channel_state_thread_lock(), switch_channel_state_thread_unlock(), switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_clear_flag, switch_core_session_get_name, switch_core_session_hangup_state(), switch_core_session_reporting_state(), switch_core_session_wake_video_thread(), SWITCH_EVENT_CHANNEL_CREATE, SWITCH_EVENT_CHANNEL_ORIGINATE, switch_event_create, switch_event_fire, SWITCH_FALSE, switch_ivr_parse_all_events(), switch_ivr_parse_all_messages(), SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_set_flag, SWITCH_STATUS_SUCCESS, switch_thread_cond_wait(), SWITCH_TRUE, and switch_yield.

{
        switch_channel_state_t state = CS_NEW, midstate = CS_DESTROY, endstate;
        const switch_endpoint_interface_t *endpoint_interface;
        const switch_state_handler_table_t *driver_state_handler = NULL;
        const switch_state_handler_table_t *application_state_handler = NULL;
        int silly = 0;
        uint32_t new_loops = 500;

        /*
           Life of the channel. you have channel and pool in your session
           everywhere you go you use the session to malloc with
           switch_core_session_alloc(session, <size>)

           The endpoint module gets the first crack at implementing the state
           if it wants to, it can cancel the default behavior by returning SWITCH_STATUS_FALSE

           Next comes the channel's event handler table that can be set by an application
           which also can veto the next behavior in line by returning SWITCH_STATUS_FALSE

           Finally the default state behavior is called.


         */
        switch_assert(session != NULL);

        switch_set_flag(session, SSF_THREAD_RUNNING);
        endpoint_interface = session->endpoint_interface;
        switch_assert(endpoint_interface != NULL);

        driver_state_handler = endpoint_interface->state_handler;
        switch_assert(driver_state_handler != NULL);

        switch_mutex_lock(session->mutex);

        while ((state = switch_channel_get_state(session->channel)) != CS_DESTROY) {

                if (switch_channel_test_flag(session->channel, CF_BLOCK_STATE)) {
                        switch_channel_wait_for_flag(session->channel, CF_BLOCK_STATE, SWITCH_FALSE, 0, NULL);
                        if ((state = switch_channel_get_state(session->channel)) == CS_DESTROY) {
                                break;
                        }
                }

                midstate = state;
                if (state != switch_channel_get_running_state(session->channel) || state >= CS_HANGUP) {
                        int index = 0;
                        int proceed = 1;
                        int global_proceed = 1;
                        int do_extra_handlers = 1;
                        switch_io_event_hook_state_run_t *ptr;
                        switch_status_t rstatus = SWITCH_STATUS_SUCCESS;

                        switch_channel_set_running_state(session->channel, state);
                        switch_channel_clear_flag(session->channel, CF_TRANSFER);
                        switch_channel_clear_flag(session->channel, CF_REDIRECT);
                        switch_ivr_parse_all_messages(session);

                        if (session->endpoint_interface->io_routines->state_run) {
                                rstatus = session->endpoint_interface->io_routines->state_run(session);
                        }
                        
                        if (rstatus == SWITCH_STATUS_SUCCESS) {
                                for (ptr = session->event_hooks.state_run; ptr; ptr = ptr->next) {
                                        if ((rstatus = ptr->state_run(session)) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                }
                        }

                        switch (state) {
                        case CS_NEW:            /* Just created, Waiting for first instructions */
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) State NEW\n", switch_channel_get_name(session->channel));
                                break;
                        case CS_DESTROY:
                                goto done;
                        case CS_REPORTING:      /* Call Detail */
                                {
                                        switch_core_session_reporting_state(session);
                                        switch_channel_set_state(session->channel, CS_DESTROY);
                                }
                                goto done;
                        case CS_HANGUP: /* Deactivate and end the thread */
                                {
                                        switch_core_session_hangup_state(session, SWITCH_TRUE);
                                        if (switch_channel_test_flag(session->channel, CF_VIDEO)) {
                                                switch_core_session_wake_video_thread(session);
                                        }
                                        switch_channel_set_state(session->channel, CS_REPORTING);
                                }

                                break;
                        case CS_INIT:           /* Basic setup tasks */
                                {
                                        switch_event_t *event;

                                        STATE_MACRO(init, "INIT");
                                        
                                        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_CREATE) == SWITCH_STATUS_SUCCESS) {
                                                switch_channel_event_set_data(session->channel, event);
                                                switch_event_fire(&event);
                                        }

                                        if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                                                if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_ORIGINATE) == SWITCH_STATUS_SUCCESS) {
                                                        switch_channel_event_set_data(session->channel, event);
                                                        switch_event_fire(&event);
                                                }
                                        }
                                }
                                break;
                        case CS_ROUTING:        /* Look for a dialplan and find something to do */
                                STATE_MACRO(routing, "ROUTING");
                                break;
                        case CS_RESET:          /* Reset */
                                STATE_MACRO(reset, "RESET");
                                break;
                                /* These other states are intended for prolonged durations so we do not signal lock for them */
                        case CS_EXECUTE:        /* Execute an Operation */
                                STATE_MACRO(execute, "EXECUTE");
                                break;
                        case CS_EXCHANGE_MEDIA: /* loop all data back to source */
                                STATE_MACRO(exchange_media, "EXCHANGE_MEDIA");
                                break;
                        case CS_SOFT_EXECUTE:   /* send/recieve data to/from another channel */
                                STATE_MACRO(soft_execute, "SOFT_EXECUTE");
                                break;
                        case CS_PARK:           /* wait in limbo */
                                STATE_MACRO(park, "PARK");
                                break;
                        case CS_CONSUME_MEDIA:  /* wait in limbo */
                                STATE_MACRO(consume_media, "CONSUME_MEDIA");
                                break;
                        case CS_HIBERNATE:      /* sleep */
                                STATE_MACRO(hibernate, "HIBERNATE");
                                break;
                        case CS_NONE:
                                abort();
                                break;
                        }

                        check_presence(session);

                        if (midstate == CS_DESTROY) {
                                break;
                        }

                }

                endstate = switch_channel_get_state(session->channel);

                if (endstate == switch_channel_get_running_state(session->channel)) {
                        if (endstate == CS_NEW) {
                                switch_yield(20000);
                                switch_ivr_parse_all_events(session);
                                if (!--new_loops) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s %s Abandoned\n",
                                                                          session->uuid_str, switch_core_session_get_name(session));
                                        switch_channel_set_flag(session->channel, CF_NO_CDR);
                                        switch_channel_hangup(session->channel, SWITCH_CAUSE_WRONG_CALL_STATE);
                                }
                        } else {
                                switch_ivr_parse_all_events(session);
                                switch_ivr_parse_all_events(session);

                                if (switch_channel_get_state(session->channel) == switch_channel_get_running_state(session->channel)) {
                                        switch_channel_state_thread_lock(session->channel);
                                        switch_channel_set_flag(session->channel, CF_THREAD_SLEEPING);
                                        if (switch_channel_get_state(session->channel) == switch_channel_get_running_state(session->channel)) {
                                                switch_ivr_parse_all_events(session);
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s session thread sleep state: %s!\n", 
                                                                                  switch_channel_get_name(session->channel),
                                                                                  switch_channel_state_name(switch_channel_get_running_state(session->channel)));
                                                switch_thread_cond_wait(session->cond, session->mutex);
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s session thread wake state: %s!\n", 
                                                                                  switch_channel_get_name(session->channel),
                                                                                  switch_channel_state_name(switch_channel_get_running_state(session->channel)));


                                        }
                                        switch_channel_clear_flag(session->channel, CF_THREAD_SLEEPING);
                                        switch_channel_state_thread_unlock(session->channel);
                                }

                                switch_ivr_parse_all_events(session);
                                switch_ivr_parse_all_events(session);
                        }
                }
        }
  done:
        switch_mutex_unlock(session->mutex);

        switch_clear_flag(session, SSF_THREAD_RUNNING);
}

static void switch_core_standard_on_consume_media ( switch_core_session_t *  session )

static

Definition at line 411 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_assert, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, and switch_log_printf().

{
        switch_assert(session != NULL);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard CONSUME_MEDIA\n", switch_channel_get_name(session->channel));
}

static void switch_core_standard_on_destroy ( switch_core_session_t *  session )

static

Definition at line 178 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, and switch_log_printf().

{

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard DESTROY\n", switch_channel_get_name(session->channel));
}

static void switch_core_standard_on_exchange_media ( switch_core_session_t *  session )

static

Definition at line 391 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, and switch_log_printf().

{

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard EXCHANGE_MEDIA\n", switch_channel_get_name(session->channel));
}

static void switch_core_standard_on_execute ( switch_core_session_t *  session )

static

Definition at line 323 of file switch_core_state_machine.c.

References switch_caller_application::application_data, switch_caller_application::application_name, CF_CONFIRM_BLIND_TRANSFER, CF_RECOVERED, CF_RECOVERING, CF_RESET, switch_core_session::channel, CS_EXECUTE, CS_PARK, switch_caller_extension::current_application, switch_core_session_message::from, switch_core_session_message::message_id, switch_caller_application::next, switch_core_session_message::numeric_arg, SWITCH_CAUSE_NORMAL_CLEARING, switch_channel_clear_flag(), switch_channel_get_caller_extension(), switch_channel_get_name(), switch_channel_get_state(), switch_channel_get_variable, switch_channel_hangup, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_state, switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_execute_application, switch_core_session_get_uuid(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), switch_core_session_video_reset(), SWITCH_LOG_DEBUG, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE, and SWITCH_STATUS_SUCCESS.

{
        switch_caller_extension_t *extension;
        const char *uuid;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard EXECUTE\n", switch_channel_get_name(session->channel));

        switch_channel_clear_flag(session->channel, CF_RECOVERING);

        switch_channel_set_variable(session->channel, "call_uuid", switch_core_session_get_uuid(session));

        if (switch_channel_get_variable(session->channel, "recovered") && !switch_channel_test_flag(session->channel, CF_RECOVERED)) {
                switch_channel_set_flag(session->channel, CF_RECOVERED);
        }

  top:
        switch_channel_clear_flag(session->channel, CF_RESET);

        switch_core_session_video_reset(session);
        
        if ((extension = switch_channel_get_caller_extension(session->channel)) == 0) {
                switch_channel_hangup(session->channel, SWITCH_CAUSE_NORMAL_CLEARING);
                return;
        }

        while (switch_channel_get_state(session->channel) == CS_EXECUTE && extension->current_application) {
                switch_caller_application_t *current_application = extension->current_application;

                extension->current_application = extension->current_application->next;

                if (switch_core_session_execute_application(session,
                                                                                                        current_application->application_name,
                                                                                                        current_application->application_data) != SWITCH_STATUS_SUCCESS) {
                        return;
                }

                if (switch_channel_test_flag(session->channel, CF_RESET)) {
                        goto top;
                }

        }

        if (switch_channel_ready(session->channel) && switch_channel_get_state(session->channel) == CS_EXECUTE && 
                switch_channel_test_flag(session->channel, CF_CONFIRM_BLIND_TRANSFER) && 
                (uuid = switch_channel_get_variable(session->channel, "blind_transfer_uuid"))) {
                switch_core_session_t *other_session;

                if ((other_session = switch_core_session_locate(uuid))) {
                        switch_core_session_message_t msg = { 0 };                      
                        msg.message_id = SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE;
                        msg.from = __FILE__;
                        msg.numeric_arg = 0;
                        switch_core_session_receive_message(other_session, &msg);
                        switch_core_session_rwunlock(other_session);

                        switch_channel_set_variable(session->channel, "park_timeout", "10:blind_transfer");
                        switch_channel_set_state(session->channel, CS_PARK);
                        switch_channel_clear_flag(session->channel, CF_CONFIRM_BLIND_TRANSFER);
                }
        }
        
        if (switch_channel_ready(session->channel) && switch_channel_get_state(session->channel) == CS_EXECUTE) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "%s has executed the last dialplan instruction, hanging up.\n",
                                                  switch_channel_get_name(session->channel));
                switch_channel_hangup(session->channel, SWITCH_CAUSE_NORMAL_CLEARING);
        }
}

static void switch_core_standard_on_hangup ( switch_core_session_t *  session )

static

Definition at line 55 of file switch_core_state_machine.c.

References switch_caller_application::application_data, switch_caller_application::application_name, switch_rtp_numbers_t::burstrate, CF_RECOVERING, CF_ZOMBIE_EXEC, switch_core_session::channel, switch_rtp_numbers_t::cng_packet_count, switch_caller_extension::current_application, switch_rtp_numbers_t::dtmf_packet_count, switch_rtp_numbers_t::flaws, switch_rtp_numbers_t::flush_packet_count, switch_rtp_stats_t::inbound, switch_rtp_numbers_t::jb_packet_count, switch_rtp_numbers_t::largest_jb_size, switch_rtp_numbers_t::lossrate, switch_rtp_numbers_t::max_variance, switch_rtp_numbers_t::mean_interval, switch_rtp_numbers_t::media_bytes, switch_rtp_numbers_t::media_packet_count, switch_rtp_numbers_t::min_variance, switch_rtp_numbers_t::mos, switch_caller_application::next, switch_rtcp_numbers_t::octet_count, switch_rtp_stats_t::outbound, switch_rtp_numbers_t::packet_count, switch_rtcp_numbers_t::packet_count, switch_rtp_numbers_t::R, switch_rtp_numbers_t::raw_bytes, switch_rtp_stats_t::rtcp, switch_rtp_numbers_t::skip_packet_count, switch_channel_cause2str(), switch_channel_clear_flag(), switch_channel_get_caller_extension(), switch_channel_get_cause(), switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_media_get_stats(), switch_core_media_set_stats(), switch_core_recovery_untrack(), switch_core_session_execute_application, switch_core_session_get_pool(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_STATUS_IGNORE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_true().

{
        switch_caller_extension_t *extension;
        int rec;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard HANGUP, cause: %s\n",
                                          switch_channel_get_name(session->channel), switch_channel_cause2str(switch_channel_get_cause(session->channel)));

        if (switch_true(switch_channel_get_variable(session->channel, "log_audio_stats_on_hangup"))) {
                switch_rtp_stats_t *audio_stats = NULL;

                switch_core_media_set_stats(session);
                audio_stats = switch_core_media_get_stats(session, SWITCH_MEDIA_TYPE_AUDIO, switch_core_session_get_pool(session));
                if (audio_stats) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                        SWITCH_LOG_DEBUG,
                                        "%s Call statistics:\n"
                                        "in_raw_bytes: %d\n"
                                        "in_media_bytes: %d\n"
                                        "in_packet_count: %d\n"
                                        "in_media_packet_count: %d\n"
                                        "in_skip_packet_count: %d\n"
                                        "in_jitter_packet_count: %d\n"
                                        "in_dtmf_packet_count: %d\n"
                                        "in_cng_packet_count: %d\n"
                                        "in_flush_packet_count: %d\n"
                                        "in_largest_jb_size: %d\n\n"
                                        "in_jitter_min_variance: %lf\n"
                                        "in_jitter_max_variance: %lf\n"
                                        "in_jitter_loss_rate: %lf\n"
                                        "in_jitter_burst_rate: %lf\n"
                                        "in_mean_interval: %lf\n\n"
                                        "in_flaw_total: %d\n"
                                        "in_quality_percentage: %lf\n"
                                        "in_mos: %lf\n\n"
                                        "out_raw_bytes: %d\n"
                                        "out_media_bytes: %d\n"
                                        "out_packet_count: %d\n"
                                        "out_media_packet_count: %d\n"
                                        "out_skip_packet_count: %d\n"
                                        "out_dtmf_packet_count: %d\n"
                                        "out_cng_packet_count: %d\n\n"
                                        "rtcp_packet_count: %d\n"
                                        "rtcp_octet_count: %d\n",
                                switch_channel_get_name(session->channel),
                                (int)audio_stats->inbound.raw_bytes,
                                (int)audio_stats->inbound.media_bytes,
                                (int)audio_stats->inbound.packet_count,
                                (int)audio_stats->inbound.media_packet_count,
                                (int)audio_stats->inbound.skip_packet_count,
                                (int)audio_stats->inbound.jb_packet_count,
                                (int)audio_stats->inbound.dtmf_packet_count,
                                (int)audio_stats->inbound.cng_packet_count,
                                (int)audio_stats->inbound.flush_packet_count,
                                (int)audio_stats->inbound.largest_jb_size,
                                audio_stats->inbound.min_variance,
                                audio_stats->inbound.max_variance,
                                audio_stats->inbound.lossrate,
                                audio_stats->inbound.burstrate,
                                audio_stats->inbound.mean_interval,
                                (int)audio_stats->inbound.flaws,
                                audio_stats->inbound.R,
                                audio_stats->inbound.mos,
                                (int)audio_stats->outbound.raw_bytes,
                                (int)audio_stats->outbound.media_bytes,
                                (int)audio_stats->outbound.packet_count,
                                (int)audio_stats->outbound.media_packet_count,
                                (int)audio_stats->outbound.skip_packet_count,
                                (int)audio_stats->outbound.dtmf_packet_count,
                                (int)audio_stats->outbound.cng_packet_count,
                                (int)audio_stats->rtcp.packet_count,
                                (int)audio_stats->rtcp.octet_count
                                        );
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s Missing call statistics!\n",
                                        switch_channel_get_name(session->channel));
                }
        }

        rec = switch_channel_test_flag(session->channel, CF_RECOVERING);
        switch_channel_clear_flag(session->channel, CF_RECOVERING);

        if (!rec) {
                switch_core_recovery_untrack(session, SWITCH_TRUE);
        }

        
        if (!switch_channel_test_flag(session->channel, CF_ZOMBIE_EXEC)) {
                return;
        }

        if ((extension = switch_channel_get_caller_extension(session->channel)) == 0) {
                return;
        }

        while(extension->current_application) {
                switch_caller_application_t *current_application = extension->current_application;
                switch_status_t status;

                extension->current_application = extension->current_application->next;

                status = switch_core_session_execute_application(session,
                                                                                                                 current_application->application_name, current_application->application_data);
                                                                                                                 
                
                if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_IGNORE) {
                        return;
                }
        }





}

static void switch_core_standard_on_hibernate ( switch_core_session_t *  session )

static

Definition at line 417 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_assert, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, and switch_log_printf().

{
        switch_assert(session != NULL);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard HIBERNATE\n", switch_channel_get_name(session->channel));
}

static void switch_core_standard_on_init ( switch_core_session_t *  session )

static

Definition at line 38 of file switch_core_state_machine.c.

References CF_RECOVERING, CF_RECOVERING_BRIDGE, switch_core_session::channel, CS_EXECUTE, CS_RESET, CS_ROUTING, switch_channel_clear_flag(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_state, switch_channel_test_flag(), SWITCH_LOG_DEBUG, and switch_log_printf().

{
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard INIT\n", switch_channel_get_name(session->channel));

        if (switch_channel_test_flag(session->channel, CF_RECOVERING_BRIDGE)) {
                switch_channel_set_state(session->channel, CS_RESET);
        } else {
                if (switch_channel_test_flag(session->channel, CF_RECOVERING)) {
                        switch_channel_set_state(session->channel, CS_EXECUTE);
                } else {
                        switch_channel_set_state(session->channel, CS_ROUTING);
                }
        }

        switch_channel_clear_flag(session->channel, CF_RECOVERING);
}

static void switch_core_standard_on_park ( switch_core_session_t *  session )

static

Definition at line 403 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_assert, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_core_session_reset(), switch_ivr_park(), SWITCH_LOG_DEBUG, switch_log_printf(), and SWITCH_TRUE.

{
        switch_assert(session != NULL);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard PARK\n", switch_channel_get_name(session->channel));
        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
        switch_ivr_park(session, NULL);
}

static void switch_core_standard_on_reporting ( switch_core_session_t *  session )

static

Definition at line 171 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_channel_cause2str(), switch_channel_get_cause(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, and switch_log_printf().

{

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard REPORTING, cause: %s\n",
                                          switch_channel_get_name(session->channel), switch_channel_cause2str(switch_channel_get_cause(session->channel)));
}

static void switch_core_standard_on_reset ( switch_core_session_t *  session )

static

Definition at line 184 of file switch_core_state_machine.c.

References CF_BRIDGE_ORIGINATOR, CF_MEDIA_ACK, CF_PROXY_MODE, CF_RECOVERING_BRIDGE, switch_core_session::channel, CS_RESET, switch_channel_clear_flag(), switch_channel_get_name(), switch_channel_get_partner_uuid(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_up, switch_channel_wait_for_flag(), switch_channel_wait_for_state_timeout(), switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_core_session_locate, switch_core_session_rwunlock(), switch_ivr_signal_bridge(), switch_ivr_uuid_bridge(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_TRUE, and switch_yield.

{
        switch_channel_set_variable(session->channel, "call_uuid", switch_core_session_get_uuid(session));

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard RESET\n", switch_channel_get_name(session->channel));

        if (switch_channel_test_flag(session->channel, CF_RECOVERING_BRIDGE)) {
                switch_core_session_t *other_session = NULL;
                const char *uuid = switch_core_session_get_uuid(session);

                if (switch_channel_test_flag(session->channel, CF_BRIDGE_ORIGINATOR)) {
                        const char *other_uuid = switch_channel_get_partner_uuid(session->channel);
                        int x = 0;

                        if (other_uuid) {
                                for (x = 0; other_session == NULL && x < 20; x++) {
                                        if (!switch_channel_up(session->channel)) {
                                                break;
                                        }
                                        other_session = switch_core_session_locate(other_uuid);
                                        switch_yield(100000);
                                }
                        }

                        if (other_session) {
                                switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
                                switch_channel_clear_flag(session->channel, CF_BRIDGE_ORIGINATOR);
                                switch_channel_wait_for_state_timeout(other_channel, CS_RESET, 5000);
                                switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 2000, NULL);

                                if (switch_channel_test_flag(session->channel, CF_PROXY_MODE) && switch_channel_test_flag(other_channel, CF_PROXY_MODE)) {
                                        switch_ivr_signal_bridge(session, other_session);
                                } else {
                                        switch_ivr_uuid_bridge(uuid, other_uuid);
                                }
                                switch_core_session_rwunlock(other_session);
                        }
                }

                switch_channel_clear_flag(session->channel, CF_RECOVERING_BRIDGE);
        }

}

static void switch_core_standard_on_routing ( switch_core_session_t *  session )

static

Definition at line 228 of file switch_core_state_machine.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CF_PROXY_MODE, CF_SIGNAL_BRIDGE_TTL, switch_core_session::channel, CS_CONSUME_MEDIA, CS_EXECUTE, switch_caller_profile::dialplan, switch_dialplan_interface::hunt_function, SMF_NONE, SWITCH_CALL_DIRECTION_OUTBOUND, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CAUSE_NO_ROUTE_DESTINATION, switch_channel_direction(), switch_channel_expand_variables, switch_channel_get_caller_profile(), switch_channel_get_name(), switch_channel_get_queued_extension(), switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_caller_extension(), switch_channel_set_state, switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_get_uuid(), switch_core_session_strdup, SWITCH_FALSE, switch_ivr_blind_transfer_ack(), switch_ivr_media(), switch_loadable_module_get_dialplan_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_separate_string(), SWITCH_STATUS_SUCCESS, UNPROTECT_INTERFACE, switch_core_session::uuid_str, and zstr.

{
        switch_dialplan_interface_t *dialplan_interface = NULL;
        switch_caller_profile_t *caller_profile;
        switch_caller_extension_t *extension = NULL;
        char *expanded = NULL;
        char *dpstr = NULL;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard ROUTING\n", switch_channel_get_name(session->channel));

        switch_channel_set_variable(session->channel, "call_uuid", switch_core_session_get_uuid(session));
                
        if ((switch_channel_test_flag(session->channel, CF_ANSWERED) ||
                 switch_channel_test_flag(session->channel, CF_EARLY_MEDIA) ||
                 switch_channel_test_flag(session->channel, CF_SIGNAL_BRIDGE_TTL)) && switch_channel_test_flag(session->channel, CF_PROXY_MODE)) {
                switch_ivr_media(session->uuid_str, SMF_NONE);
        }

        if ((caller_profile = switch_channel_get_caller_profile(session->channel)) == 0) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't get profile!\n");
                switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                return;
        } else {
                char *dp[25];
                int argc, x, count = 0;

                if ((extension = switch_channel_get_queued_extension(session->channel))) {
                        switch_channel_set_caller_extension(session->channel, extension);
                        switch_channel_set_state(session->channel, CS_EXECUTE);
                        goto end;
                }

                if (!zstr(caller_profile->dialplan)) {
                        if ((dpstr = switch_core_session_strdup(session, caller_profile->dialplan))) {
                                expanded = switch_channel_expand_variables(session->channel, dpstr);
                                argc = switch_separate_string(expanded, ',', dp, (sizeof(dp) / sizeof(dp[0])));
                                for (x = 0; x < argc; x++) {
                                        char *dpname = dp[x];
                                        char *dparg = NULL;

                                        if (dpname) {
                                                if ((dparg = strchr(dpname, ':'))) {
                                                        *dparg++ = '\0';
                                                }
                                        } else {
                                                continue;
                                        }
                                        if (!(dialplan_interface = switch_loadable_module_get_dialplan_interface(dpname))) {
                                                continue;
                                        }

                                        count++;

                                        extension = dialplan_interface->hunt_function(session, dparg, NULL);
                                        UNPROTECT_INTERFACE(dialplan_interface);

                                        if (extension) {
                                                switch_channel_set_caller_extension(session->channel, extension);
                                                switch_channel_set_state(session->channel, CS_EXECUTE);
                                                goto end;
                                        }
                                }
                        }
                }

                if (!count) {
                        if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                                if (switch_channel_test_flag(session->channel, CF_ANSWERED)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "No Dialplan on answered channel, changing state to HANGUP\n");
                                        switch_channel_hangup(session->channel, SWITCH_CAUSE_NO_ROUTE_DESTINATION);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No Dialplan, changing state to CONSUME_MEDIA\n");
                                        switch_channel_set_state(session->channel, CS_CONSUME_MEDIA);
                                }
                                goto end;
                        }
                }
        }

        if (!extension) {

                if (switch_ivr_blind_transfer_ack(session, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "No Route, Aborting\n");
                        switch_channel_hangup(session->channel, SWITCH_CAUSE_NO_ROUTE_DESTINATION);
                }
        }

  end:

        if (expanded && dpstr && expanded != dpstr) {
                free(expanded);
        }
}

static void switch_core_standard_on_soft_execute ( switch_core_session_t *  session )

static

Definition at line 397 of file switch_core_state_machine.c.

References switch_core_session::channel, switch_assert, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, and switch_log_printf().

{
        switch_assert(session != NULL);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard SOFT_EXECUTE\n", switch_channel_get_name(session->channel));
}

void switch_core_state_machine_init

(

switch_memory_pool_t *

pool

)

Definition at line 423 of file switch_core_state_machine.c.

Referenced by switch_core_init().

{
        return;
}