switch_core_state_machine.c File Reference

Defines
#define	STATE_MACRO(__STATE, __STATE_STR)
Functions
void	switch_core_state_machine_init (switch_memory_pool_t *pool)
void	switch_core_session_run (switch_core_session_t *session)

---

Define Documentation

#define STATE_MACRO (  __STATE, __STATE_STR   )

---

Function Documentation

void switch_core_session_run (  switch_core_session_t *  session  )

{ switch_channel_state_t state = CS_NEW, midstate = CS_DONE, 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; switch_thread_id_t thread_id; jmp_buf env; int sig, silly = 0; if (switch_test_flag((&runtime), SCF_CRASH_PROT)) { thread_id = switch_thread_self(); signal(SIGSEGV, handle_fatality); signal(SIGFPE, handle_fatality); #ifndef WIN32 signal(SIGBUS, handle_fatality); #endif if ((sig = setjmp(env)) != 0) { switch_event_t *event; if (switch_event_create(&event, SWITCH_EVENT_SESSION_CRASH) == SWITCH_STATUS_SUCCESS) { switch_channel_event_set_data(session->channel, event); switch_event_fire(&event); } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread has crashed for channel %s\n", switch_channel_get_name(session->channel)); switch_channel_hangup(session->channel, SWITCH_CAUSE_CRASH); } else { sqlite3HashInsert(&stack_table, &thread_id, sizeof(thread_id), (void *)&env); //apr_hash_set(stack_table, &thread_id, sizeof(thread_id), &env); } } /* 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 enpoint module gets the first crack at implementing the state if it wants to, it can cancel the default behaviour 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 behaviour in line by returning SWITCH_STATUS_FALSE Finally the default state behaviour is called. */ switch_assert(session != NULL); session->thread_running = 1; 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_DONE) { uint8_t exception = 0; midstate = state; if (switch_channel_test_flag(session->channel, CF_REPEAT_STATE)) { switch_channel_clear_flag(session->channel, CF_REPEAT_STATE); exception = 1; } if (state != switch_channel_get_running_state(session->channel) || state == CS_HANGUP || exception) { int index = 0; int proceed = 1; int do_extra_handlers = 1; switch_channel_set_running_state(session->channel, state); switch (state) { case CS_NEW: /* Just created, Waiting for first instructions */ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "(%s) State NEW\n", switch_channel_get_name(session->channel)); break; case CS_DONE: goto done; /* HANGUP INIT ROUTING and RESET are all short term so we signal lock during their callbacks */ case CS_HANGUP: /* Deactivate and end the thread */ { const char *var = switch_channel_get_variable(session->channel, SWITCH_PROCESS_CDR_VARIABLE); const char *hook_var; if (!switch_strlen_zero(var)) { if (!strcasecmp(var, "a_only")) { if (switch_channel_get_originator_caller_profile(session->channel)) { do_extra_handlers = 0; } } else if (!strcasecmp(var, "b_only")) { if (switch_channel_get_originatee_caller_profile(session->channel)) { do_extra_handlers = 0; } } else if (!switch_true(var)) { do_extra_handlers = 0; } } switch_core_session_signal_lock(session); STATE_MACRO(hangup, "HANGUP"); switch_core_session_signal_unlock(session); hook_var = switch_channel_get_variable(session->channel, SWITCH_API_HANGUP_HOOK_VARIABLE); if (!switch_strlen_zero(hook_var)) { switch_stream_handle_t stream = { 0 }; char *cmd = switch_core_session_strdup(session, hook_var); char *arg = NULL; if ((arg = strchr(cmd, ' '))) { *arg++ = '\0'; } SWITCH_STANDARD_STREAM(stream); switch_api_execute(cmd, arg, NULL, &stream); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Hangup Command %s(%s):\n%s\n", cmd, arg, switch_str_nil((char *) stream.data)); switch_safe_free(stream.data); } } goto done; case CS_INIT: /* Basic setup tasks */ switch_core_session_signal_lock(session); STATE_MACRO(init, "INIT"); switch_core_session_signal_unlock(session); break; case CS_ROUTING: /* Look for a dialplan and find something to do */ switch_core_session_signal_lock(session); STATE_MACRO(routing, "ROUTING"); switch_core_session_signal_unlock(session); break; case CS_RESET: /* Reset */ switch_core_session_signal_lock(session); STATE_MACRO(reset, "RESET"); switch_core_session_signal_unlock(session); 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; } if (midstate == CS_DONE) { break; } } endstate = switch_channel_get_state(session->channel); if (endstate == switch_channel_get_running_state(session->channel)) { if (endstate == CS_NEW) { switch_yield(1000); } else { switch_thread_cond_wait(session->cond, session->mutex); } } } done: switch_mutex_unlock(session->mutex); if (switch_test_flag((&runtime), SCF_CRASH_PROT)) { sqlite3HashInsert(&stack_table, &thread_id, sizeof(thread_id), NULL); //apr_hash_set(stack_table, &thread_id, sizeof(thread_id), NULL); } session->thread_running = 0; }

Here is the call graph for this function:

void switch_core_state_machine_init (  switch_memory_pool_t *  pool  )

{ if (switch_test_flag((&runtime), SCF_CRASH_PROT)) { sqlite3HashInit(&stack_table, SQLITE_HASH_BINARY, 0); } }

---