kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-07-12 02:03:39 +00:00
Code Issues Projects Releases Wiki Activity

code analysis, clean up asserts related to switch_core_session_get_channel.

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@7402 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris 2008-01-28 07:26:10 +00:00
parent c8dd27cdd1
commit 482badffca
44 changed files with 506 additions and 1661 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/include/switch_channel.h
View File

@ -97,28 +97,28 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_running_state(
\param str the string to check \param str the string to check
\return the code \return the code
*/ */
SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(const char *str); SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(_In_ const char *str);
/*! /*!
\brief return the cause code for a given channel \brief return the cause code for a given channel
\param channel the channel \param channel the channel
\return the code \return the code
*/ */
SWITCH_DECLARE(switch_call_cause_t) switch_channel_get_cause(switch_channel_t *channel); SWITCH_DECLARE(switch_call_cause_t) switch_channel_get_cause(_In_ switch_channel_t *channel);
/*! /*!
\brief return a cause string for a given cause \brief return a cause string for a given cause
\param cause the code to check \param cause the code to check
\return the string \return the string
*/ */
SWITCH_DECLARE(const char *) switch_channel_cause2str(switch_call_cause_t cause); SWITCH_DECLARE(const char *) switch_channel_cause2str(_In_ switch_call_cause_t cause);
/*! /*!
\brief View the timetable of a channel \brief View the timetable of a channel
\param channel channel to retrieve timetable from \param channel channel to retrieve timetable from
\return a pointer to the channel's timetable (created, answered, etc..) \return a pointer to the channel's timetable (created, answered, etc..)
*/ */
SWITCH_DECLARE(switch_channel_timetable_t *) switch_channel_get_timetable(switch_channel_t *channel); SWITCH_DECLARE(switch_channel_timetable_t *) switch_channel_get_timetable(_In_ switch_channel_t *channel);
/*! /*!
\brief Allocate a new channel \brief Allocate a new channel
@ -126,7 +126,7 @@ SWITCH_DECLARE(switch_channel_timetable_t *) switch_channel_get_timetable(switch
\param pool memory_pool to use for allocation \param pool memory_pool to use for allocation
\return SWITCH_STATUS_SUCCESS if successful \return SWITCH_STATUS_SUCCESS if successful
*/ */
SWITCH_DECLARE(switch_status_t) switch_channel_alloc(switch_channel_t **channel, switch_memory_pool_t *pool); SWITCH_DECLARE(switch_status_t) switch_channel_alloc(_In_ switch_channel_t **channel, _In_ switch_memory_pool_t *pool);
/*! /*!
\brief Connect a newly allocated channel to a session object and setup it's initial state \brief Connect a newly allocated channel to a session object and setup it's initial state
@ -418,7 +418,7 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_hangup(switch_chan
\param channel channel to test \param channel channel to test
\return number of digits in the queue \return number of digits in the queue
*/ */
SWITCH_DECLARE(switch_size_t) switch_channel_has_dtmf(switch_channel_t *channel); SWITCH_DECLARE(switch_size_t) switch_channel_has_dtmf(_In_ switch_channel_t *channel);
/*! /*!
\brief Queue DTMF on a given channel \brief Queue DTMF on a given channel
@ -426,8 +426,8 @@ SWITCH_DECLARE(switch_size_t) switch_channel_has_dtmf(switch_channel_t *channel)
\param dtmf digit \param dtmf digit
\return SWITCH_STATUS_SUCCESS if successful \return SWITCH_STATUS_SUCCESS if successful
*/ */
SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *channel, const switch_dtmf_t *dtmf); SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(_In_ switch_channel_t *channel, _In_ const switch_dtmf_t *dtmf);
SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(switch_channel_t *channel, const char *dtmf_string); SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(_In_ switch_channel_t *channel, _In_ const char *dtmf_string);
/*! /*!
\brief Retrieve DTMF digits from a given channel \brief Retrieve DTMF digits from a given channel
@ -435,30 +435,30 @@ SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(switch_channel_
\param dtmf digit \param dtmf digit
\return number of bytes read into the buffer \return number of bytes read into the buffer
*/ */
SWITCH_DECLARE(switch_status_t) switch_channel_dequeue_dtmf(switch_channel_t *channel, switch_dtmf_t *dtmf); SWITCH_DECLARE(switch_status_t) switch_channel_dequeue_dtmf(_In_ switch_channel_t *channel, _In_ switch_dtmf_t *dtmf);
SWITCH_DECLARE(void) switch_channel_flush_dtmf(switch_channel_t *channel); SWITCH_DECLARE(void) switch_channel_flush_dtmf(_In_ switch_channel_t *channel);
SWITCH_DECLARE(switch_size_t) switch_channel_dequeue_dtmf_string(switch_channel_t *channel, char *dtmf_str, switch_size_t len); SWITCH_DECLARE(switch_size_t) switch_channel_dequeue_dtmf_string(_In_ switch_channel_t *channel, _Out_opt_bytecapcount_(len) char *dtmf_str, _In_ switch_size_t len);
/*! /*!
\brief Render the name of the provided state enum \brief Render the name of the provided state enum
\param state state to get name of \param state state to get name of
\return the string representation of the state \return the string representation of the state
*/ */
SWITCH_DECLARE(const char *) switch_channel_state_name(switch_channel_state_t state); SWITCH_DECLARE(const char *) switch_channel_state_name(_In_ switch_channel_state_t state);
/*! /*!
\brief Render the enum of the provided state name \brief Render the enum of the provided state name
\param name the name of the state \param name the name of the state
\return the enum value (numeric) \return the enum value (numeric)
*/ */
SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(const char *name); SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(_In_ const char *name);
/*! /*!
\brief Add information about a given channel to an event object \brief Add information about a given channel to an event object
\param channel channel to add information about \param channel channel to add information about
\param event event to add information to \param event event to add information to
*/ */
SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel_t *channel, switch_event_t *event); SWITCH_DECLARE(void) switch_channel_event_set_data(_In_ switch_channel_t *channel, _In_ switch_event_t *event);
/*! /*!
\brief Expand varaibles in a string based on the variables in a paticular channel \brief Expand varaibles in a string based on the variables in a paticular channel
@ -467,9 +467,9 @@ SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel_t *channel, sw
\return the original string if no expansion takes place otherwise a new string that must be freed \return the original string if no expansion takes place otherwise a new string that must be freed
\note it's necessary to test if the return val is the same as the input and free the string if it is not. \note it's necessary to test if the return val is the same as the input and free the string if it is not.
*/ */
SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel, const char *in); SWITCH_DECLARE(char *) switch_channel_expand_variables(_In_ switch_channel_t *channel, _In_ const char *in);
SWITCH_DECLARE(char *) switch_channel_build_param_string(switch_channel_t *channel, switch_caller_profile_t *caller_profile, const char *prefix); SWITCH_DECLARE(char *) switch_channel_build_param_string(_In_ switch_channel_t *channel, _In_opt_ switch_caller_profile_t *caller_profile, _In_opt_ const char *prefix);
SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(switch_channel_t *channel); SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(_In_ switch_channel_t *channel);
#define switch_channel_stop_broadcast(_channel) if (switch_channel_test_flag(_channel, CF_BROADCAST)) switch_channel_set_flag(_channel, CF_BREAK | CF_STOP_BROADCAST) #define switch_channel_stop_broadcast(_channel) if (switch_channel_test_flag(_channel, CF_BROADCAST)) switch_channel_set_flag(_channel, CF_BREAK | CF_STOP_BROADCAST)

4
src/include/switch_core.h
View File

@ -405,7 +405,7 @@ SWITCH_DECLARE(void *) switch_core_alloc(_In_ switch_memory_pool_t *pool, _In_ s
\return a void pointer to the newly allocated memory \return a void pointer to the newly allocated memory
\note the memory will be in scope as long as the session exists \note the memory will be in scope as long as the session exists
*/ */
SWITCH_DECLARE(void *) switch_core_session_alloc(_In_ switch_core_session_t *session, _In_ switch_size_t memory); _Ret_ SWITCH_DECLARE(void *) switch_core_session_alloc(_In_ switch_core_session_t *session, _In_ switch_size_t memory);
/*! /*!
\brief Copy a string using permanent memory allocation \brief Copy a string using permanent memory allocation
@ -512,7 +512,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_thread_launch(_In_ switch_co
\param session the session to retrieve from \param session the session to retrieve from
\return a pointer to the channel object \return a pointer to the channel object
*/ */
SWITCH_DECLARE(switch_channel_t *) switch_core_session_get_channel(_In_ switch_core_session_t *session); _Ret_ SWITCH_DECLARE(switch_channel_t *) switch_core_session_get_channel(_In_ switch_core_session_t *session);
/*! /*!
\brief Signal a session's state machine thread that a state change has occured \brief Signal a session's state machine thread that a state change has occured

8
src/include/switch_ivr.h
View File

@ -98,7 +98,7 @@ SWITCH_DECLARE(int) switch_ivr_set_xml_chan_vars(switch_xml_t xml, switch_channe
\param event the event to parse \param event the event to parse
\return SWITCH_STATUS_SUCCESS if successful \return SWITCH_STATUS_SUCCESS if successful
*/ */
SWITCH_DECLARE(switch_status_t) switch_ivr_parse_event(switch_core_session_t *session, switch_event_t *event); SWITCH_DECLARE(switch_status_t) switch_ivr_parse_event(_In_ switch_core_session_t *session, _In_ switch_event_t *event);
/*! /*!
\brief Parse all commands from an event \brief Parse all commands from an event
@ -388,8 +388,8 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
\param peer_session_data data to pass to the DTMF callback for peer_session \param peer_session_data data to pass to the DTMF callback for peer_session
\return SWITCH_STATUS_SUCCESS if all is well \return SWITCH_STATUS_SUCCESS if all is well
*/ */
SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(switch_core_session_t *session, SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(_In_ switch_core_session_t *session,
switch_core_session_t *peer_session, _In_ switch_core_session_t *peer_session,
switch_input_callback_function_t dtmf_callback, void *session_data, switch_input_callback_function_t dtmf_callback, void *session_data,
void *peer_session_data); void *peer_session_data);
@ -408,7 +408,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_signal_bridge(switch_core_session_t *
\param dialplan the new dialplan (OPTIONAL, may be NULL) \param dialplan the new dialplan (OPTIONAL, may be NULL)
\param context the new context (OPTIONAL, may be NULL) \param context the new context (OPTIONAL, may be NULL)
*/ */
SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_t *session, const char *extension, const char *dialplan, const char *context); SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(_In_ switch_core_session_t *session, const char *extension, const char *dialplan, const char *context);
/*! /*!
\brief Transfer an existing session to another location in the future \brief Transfer an existing session to another location in the future

2
src/include/switch_platform.h
View File

@ -313,6 +313,8 @@ SWITCH_END_EXTERN_C
#define _Inout_ #define _Inout_
#define _Inout_opt_ #define _Inout_opt_
#define _In_bytecount_(x) #define _In_bytecount_(x)
#define _Out_opt_bytecapcount_(x)
#define _Ret_
#endif #endif

6
src/mod/applications/mod_commands/mod_commands.c
View File

@ -1465,7 +1465,6 @@ SWITCH_STANDARD_API(originate_function)
} }
caller_channel = switch_core_session_get_channel(caller_session); caller_channel = switch_core_session_get_channel(caller_session);
switch_assert(caller_channel != NULL);
switch_channel_clear_state_handler(caller_channel, NULL); switch_channel_clear_state_handler(caller_channel, NULL);
if (*exten == '&' && *(exten + 1)) { if (*exten == '&' && *(exten + 1)) {
@ -2016,8 +2015,6 @@ SWITCH_STANDARD_API(uuid_setvar_function)
switch_channel_t *channel; switch_channel_t *channel;
channel = switch_core_session_get_channel(psession); channel = switch_core_session_get_channel(psession);
switch_assert(channel != NULL);
if (switch_strlen_zero(var_name)) { if (switch_strlen_zero(var_name)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n");
stream->write_function(stream, "-ERR No variable specified\n"); stream->write_function(stream, "-ERR No variable specified\n");
@ -2063,8 +2060,6 @@ SWITCH_STANDARD_API(uuid_getvar_function)
if ((psession = switch_core_session_locate(uuid))) { if ((psession = switch_core_session_locate(uuid))) {
switch_channel_t *channel; switch_channel_t *channel;
channel = switch_core_session_get_channel(psession); channel = switch_core_session_get_channel(psession);
switch_assert(channel != NULL);
if (switch_strlen_zero(var_name)) { if (switch_strlen_zero(var_name)) {
stream->write_function(stream, "-ERR No variable name specified!\n"); stream->write_function(stream, "-ERR No variable name specified!\n");
@ -2119,7 +2114,6 @@ SWITCH_STANDARD_API(uuid_dump_function)
char *buf; char *buf;
channel = switch_core_session_get_channel(psession); channel = switch_core_session_get_channel(psession);
switch_assert(channel != NULL);
if (switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
switch_xml_t xml; switch_xml_t xml;

15
src/mod/applications/mod_conference/mod_conference.c
View File

@ -1366,7 +1366,6 @@ static void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t * thread,
switch_assert(member != NULL); switch_assert(member != NULL);
channel = switch_core_session_get_channel(member->session); channel = switch_core_session_get_channel(member->session);
switch_assert(channel != NULL);
read_codec = switch_core_session_get_read_codec(member->session); read_codec = switch_core_session_get_read_codec(member->session);
switch_assert(read_codec != NULL); switch_assert(read_codec != NULL);
@ -1550,7 +1549,6 @@ static void conference_loop_output(conference_member_t * member)
uint32_t low_count = 0, bytes = samples * 2; uint32_t low_count = 0, bytes = samples * 2;
call_list_t *call_list = NULL, *cp = NULL; call_list_t *call_list = NULL, *cp = NULL;
switch_assert(channel != NULL);
switch_assert(member->conference != NULL); switch_assert(member->conference != NULL);
if (switch_core_timer_init(&timer, member->conference->timer_name, interval, tsamples, NULL) == SWITCH_STATUS_SUCCESS) { if (switch_core_timer_init(&timer, member->conference->timer_name, interval, tsamples, NULL) == SWITCH_STATUS_SUCCESS) {
@ -2450,13 +2448,10 @@ static void conference_list_pretty(conference_obj_t * conference, switch_stream_
channel = switch_core_session_get_channel(member->session); channel = switch_core_session_get_channel(member->session);
profile = switch_channel_get_caller_profile(channel); profile = switch_channel_get_caller_profile(channel);
stream->write_function(stream, "%u) %s (%s)\n", member->id, profile->caller_id_name, profile->caller_id_number); stream->write_function(stream, "%u) %s (%s)\n", member->id, profile->caller_id_name, profile->caller_id_number);
} }
switch_mutex_unlock(conference->member_mutex); switch_mutex_unlock(conference->member_mutex);
} }
static void conference_list(conference_obj_t * conference, switch_stream_handle_t *stream, char *delim) static void conference_list(conference_obj_t * conference, switch_stream_handle_t *stream, char *delim)
@ -2486,7 +2481,6 @@ static void conference_list(conference_obj_t * conference, switch_stream_handle_
profile = switch_channel_get_caller_profile(channel); profile = switch_channel_get_caller_profile(channel);
name = switch_channel_get_name(channel); name = switch_channel_get_name(channel);
stream->write_function(stream, "%u%s%s%s%s%s%s%s%s%s", stream->write_function(stream, "%u%s%s%s%s%s%s%s%s%s",
member->id, delim, name, delim, uuid, delim, profile->caller_id_name, delim, profile->caller_id_number, delim); member->id, delim, name, delim, uuid, delim, profile->caller_id_name, delim, profile->caller_id_number, delim);
@ -3637,7 +3631,6 @@ static switch_status_t audio_bridge_on_ring(switch_core_session_t *session)
switch_channel_t *channel = NULL; switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CUSTOM RING\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CUSTOM RING\n");
@ -3684,12 +3677,10 @@ static switch_status_t conference_outcall(conference_obj_t * conference,
} }
peer_channel = switch_core_session_get_channel(peer_session); peer_channel = switch_core_session_get_channel(peer_session);
switch_assert(peer_channel != NULL);
rdlock = 1; rdlock = 1;
goto callup; goto callup;
} }
conference_name = conference->name; conference_name = conference->name;
if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) { if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
@ -3699,7 +3690,6 @@ static switch_status_t conference_outcall(conference_obj_t * conference,
if (session != NULL) { if (session != NULL) {
caller_channel = switch_core_session_get_channel(session); caller_channel = switch_core_session_get_channel(session);
} }
if (switch_strlen_zero(cid_name)) { if (switch_strlen_zero(cid_name)) {
@ -3723,7 +3713,6 @@ static switch_status_t conference_outcall(conference_obj_t * conference,
rdlock = 1; rdlock = 1;
peer_channel = switch_core_session_get_channel(peer_session); peer_channel = switch_core_session_get_channel(peer_session);
switch_assert(peer_channel != NULL);
/* make sure the conference still exists */ /* make sure the conference still exists */
if (!switch_test_flag(conference, CFLAG_RUNNING)) { if (!switch_test_flag(conference, CFLAG_RUNNING)) {
@ -3942,8 +3931,6 @@ SWITCH_STANDARD_APP(conference_auto_function)
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
call_list_t *call_list, *np; call_list_t *call_list, *np;
switch_assert(channel != NULL);
call_list = switch_channel_get_private(channel, "_conference_autocall_list_"); call_list = switch_channel_get_private(channel, "_conference_autocall_list_");
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
@ -3987,8 +3974,6 @@ SWITCH_STANDARD_APP(conference_function)
conf_xml_cfg_t xml_cfg = { 0 }; conf_xml_cfg_t xml_cfg = { 0 };
switch_event_t *params = NULL; switch_event_t *params = NULL;
switch_assert(channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Invalid arguments\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Invalid arguments\n");
return; return;

120
src/mod/applications/mod_dptools/mod_dptools.c
View File

@ -111,10 +111,7 @@ SWITCH_STANDARD_APP(set_user_function)
{ {
switch_xml_t x_domain, xml = NULL, x_user, x_param, x_params; switch_xml_t x_domain, xml = NULL, x_user, x_param, x_params;
char *user, *mailbox, *domain; char *user, *mailbox, *domain;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
goto error; goto error;
@ -164,29 +161,19 @@ SWITCH_STANDARD_APP(set_user_function)
SWITCH_STANDARD_APP(ring_ready_function) SWITCH_STANDARD_APP(ring_ready_function)
{ {
switch_channel_t *channel; switch_channel_ring_ready(switch_core_session_get_channel(session));
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_ring_ready(channel);
} }
SWITCH_STANDARD_APP(break_function) SWITCH_STANDARD_APP(break_function)
{ {
switch_channel_t *channel; switch_channel_set_flag(switch_core_session_get_channel(session), CF_BREAK);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_set_flag(channel, CF_BREAK);
} }
SWITCH_STANDARD_APP(queue_dtmf_function) SWITCH_STANDARD_APP(queue_dtmf_function)
{ {
switch_channel_t *channel; switch_channel_queue_dtmf_string(switch_core_session_get_channel(session), (const char *) data);
channel = switch_core_session_get_channel(session);
switch_channel_queue_dtmf_string(channel, (const char *) data);
} }
SWITCH_STANDARD_APP(send_dtmf_function) SWITCH_STANDARD_APP(send_dtmf_function)
{ {
switch_core_session_send_dtmf_string(session, (const char *) data); switch_core_session_send_dtmf_string(session, (const char *) data);
@ -329,12 +316,8 @@ SWITCH_STANDARD_APP(eval_function)
SWITCH_STANDARD_APP(phrase_function) SWITCH_STANDARD_APP(phrase_function)
{ {
switch_channel_t *channel;
char *mydata = NULL; char *mydata = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!switch_strlen_zero(data) && (mydata = switch_core_session_strdup(session, data))) { if (!switch_strlen_zero(data) && (mydata = switch_core_session_strdup(session, data))) {
const char *lang; const char *lang;
char *macro = mydata; char *macro = mydata;
@ -344,7 +327,7 @@ SWITCH_STANDARD_APP(phrase_function)
*mdata++ = '\0'; *mdata++ = '\0';
} }
lang = switch_channel_get_variable(channel, "language"); lang = switch_channel_get_variable(switch_core_session_get_channel(session), "language");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Execute %s(%s) lang %s\n", macro, switch_str_nil(mdata), switch_str_nil(lang)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Execute %s(%s) lang %s\n", macro, switch_str_nil(mdata), switch_str_nil(lang));
switch_ivr_phrase_macro(session, macro, mdata, lang, NULL); switch_ivr_phrase_macro(session, macro, mdata, lang, NULL);
@ -353,35 +336,23 @@ SWITCH_STANDARD_APP(phrase_function)
SWITCH_STANDARD_APP(hangup_function) SWITCH_STANDARD_APP(hangup_function)
{ {
switch_channel_t *channel;
switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING; switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!switch_strlen_zero(data)) { if (!switch_strlen_zero(data)) {
cause = switch_channel_str2cause(data); cause = switch_channel_str2cause(data);
} }
switch_channel_hangup(channel, cause); switch_channel_hangup(switch_core_session_get_channel(session), cause);
} }
SWITCH_STANDARD_APP(answer_function) SWITCH_STANDARD_APP(answer_function)
{ {
switch_channel_t *channel; switch_channel_answer(switch_core_session_get_channel(session));
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_answer(channel);
} }
SWITCH_STANDARD_APP(pre_answer_function) SWITCH_STANDARD_APP(pre_answer_function)
{ {
switch_channel_t *channel; switch_channel_pre_answer(switch_core_session_get_channel(session));
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_pre_answer(channel);
} }
SWITCH_STANDARD_APP(redirect_function) SWITCH_STANDARD_APP(redirect_function)
@ -420,12 +391,8 @@ SWITCH_STANDARD_APP(deflect_function)
SWITCH_STANDARD_APP(set_function) SWITCH_STANDARD_APP(set_function)
{ {
switch_channel_t *channel;
char *var, *val = NULL; char *var, *val = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n");
} else { } else {
@ -440,7 +407,7 @@ SWITCH_STANDARD_APP(set_function)
} }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", var, val ? val : "UNDEF"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", var, val ? val : "UNDEF");
switch_channel_set_variable(channel, var, val); switch_channel_set_variable(switch_core_session_get_channel(session), var, val);
} }
} }
@ -470,14 +437,10 @@ SWITCH_STANDARD_APP(set_global_function)
SWITCH_STANDARD_APP(set_profile_var_function) SWITCH_STANDARD_APP(set_profile_var_function)
{ {
switch_channel_t *channel;
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile;
char *name, *val = NULL; char *name, *val = NULL;
channel = switch_core_session_get_channel(session); caller_profile = switch_channel_get_caller_profile(switch_core_session_get_channel(session));
switch_assert(channel != NULL);
caller_profile = switch_channel_get_caller_profile(channel);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n");
@ -550,14 +513,11 @@ SWITCH_STANDARD_APP(set_profile_var_function)
SWITCH_STANDARD_APP(export_function) SWITCH_STANDARD_APP(export_function)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
const char *exports; const char *exports;
char *new_exports = NULL, *new_exports_d = NULL, *var, *val = NULL, *var_name = NULL; char *new_exports = NULL, *new_exports_d = NULL, *var, *val = NULL, *var_name = NULL;
int local = 1; int local = 1;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n");
} else { } else {
@ -599,27 +559,18 @@ SWITCH_STANDARD_APP(export_function)
SWITCH_STANDARD_APP(unset_function) SWITCH_STANDARD_APP(unset_function)
{ {
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n");
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "UNSET [%s]\n", (char *) data); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "UNSET [%s]\n", (char *) data);
switch_channel_set_variable(channel, data, NULL); switch_channel_set_variable(switch_core_session_get_channel(session), data, NULL);
} }
} }
SWITCH_STANDARD_APP(log_function) SWITCH_STANDARD_APP(log_function)
{ {
switch_channel_t *channel;
char *level, *log_str; char *level, *log_str;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (data && (level = strdup(data))) { if (data && (level = strdup(data))) {
switch_log_level_t ltype = SWITCH_LOG_DEBUG; switch_log_level_t ltype = SWITCH_LOG_DEBUG;
@ -640,15 +591,11 @@ SWITCH_STANDARD_APP(log_function)
SWITCH_STANDARD_APP(info_function) SWITCH_STANDARD_APP(info_function)
{ {
switch_channel_t *channel;
switch_event_t *event; switch_event_t *event;
char *buf; char *buf;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event); switch_channel_event_set_data(switch_core_session_get_channel(session), event);
switch_event_serialize(event, &buf, SWITCH_FALSE); switch_event_serialize(event, &buf, SWITCH_FALSE);
switch_assert(buf); switch_assert(buf);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:\n%s\n", buf); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:\n%s\n", buf);
@ -659,17 +606,13 @@ SWITCH_STANDARD_APP(info_function)
SWITCH_STANDARD_APP(event_function) SWITCH_STANDARD_APP(event_function)
{ {
switch_channel_t *channel;
switch_event_t *event; switch_event_t *event;
char *argv[25] = { 0 }; char *argv[25] = { 0 };
int argc = 0; int argc = 0;
char *lbuf; char *lbuf;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_APPLICATION) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_APPLICATION) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event); switch_channel_event_set_data(switch_core_session_get_channel(session), event);
if (!switch_strlen_zero(data) && (lbuf = switch_core_session_strdup(session, data)) if (!switch_strlen_zero(data) && (lbuf = switch_core_session_strdup(session, data))
&& (argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) { && (argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
int x = 0; int x = 0;
@ -700,13 +643,7 @@ SWITCH_STANDARD_APP(event_function)
SWITCH_STANDARD_APP(privacy_function) SWITCH_STANDARD_APP(privacy_function)
{ {
switch_channel_t *channel; switch_caller_profile_t *caller_profile = switch_channel_get_caller_profile(switch_core_session_get_channel(session));
switch_caller_profile_t *caller_profile;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
caller_profile = switch_channel_get_caller_profile(channel);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No privacy mode specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No privacy mode specified.\n");
@ -742,15 +679,11 @@ SWITCH_STANDARD_APP(strftime_function)
switch_size_t retsize; switch_size_t retsize;
switch_time_exp_t tm; switch_time_exp_t tm;
char date[80] = ""; char date[80] = "";
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
switch_time_exp_lt(&tm, switch_timestamp_now()); switch_time_exp_lt(&tm, switch_timestamp_now());
switch_strftime(date, &retsize, sizeof(date), argv[1], &tm); switch_strftime(date, &retsize, sizeof(date), argv[1], &tm);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", argv[0], date); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", argv[0], date);
switch_channel_set_variable(channel, argv[0], date); switch_channel_set_variable(switch_core_session_get_channel(session), argv[0], date);
} }
} }
@ -1025,8 +958,6 @@ static switch_status_t on_dtmf(switch_core_session_t *session, void *input, swit
const char *terminators; const char *terminators;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
const char *p; const char *p;
switch_assert(channel);
if (!(terminators = switch_channel_get_variable(channel, SWITCH_PLAYBACK_TERMINATORS_VARIABLE))) { if (!(terminators = switch_channel_get_variable(channel, SWITCH_PLAYBACK_TERMINATORS_VARIABLE))) {
terminators = "*"; terminators = "*";
@ -1067,8 +998,6 @@ SWITCH_STANDARD_APP(speak_function)
char *mydata = NULL; char *mydata = NULL;
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
switch_assert(channel != NULL);
if (switch_strlen_zero(data) || !(mydata = switch_core_session_strdup(session, data))) { if (switch_strlen_zero(data) || !(mydata = switch_core_session_strdup(session, data))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Params!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Params!\n");
return; return;
@ -1122,12 +1051,9 @@ SWITCH_STANDARD_APP(speak_function)
SWITCH_STANDARD_APP(playback_function) SWITCH_STANDARD_APP(playback_function)
{ {
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
switch_assert(channel != NULL); switch_channel_pre_answer(switch_core_session_get_channel(session));
switch_channel_pre_answer(channel);
args.input_callback = on_dtmf; args.input_callback = on_dtmf;
switch_ivr_play_file(session, NULL, data, &args); switch_ivr_play_file(session, NULL, data, &args);
@ -1135,7 +1061,6 @@ SWITCH_STANDARD_APP(playback_function)
SWITCH_STANDARD_APP(gentones_function) SWITCH_STANDARD_APP(gentones_function)
{ {
switch_channel_t *channel;
char *tone_script = NULL; char *tone_script = NULL;
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
char *l; char *l;
@ -1146,12 +1071,7 @@ SWITCH_STANDARD_APP(gentones_function)
return; return;
} }
tone_script = switch_core_session_strdup(session, data); switch_channel_pre_answer(switch_core_session_get_channel(session));
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_pre_answer(channel);
if ((l = strchr(tone_script, '|'))) { if ((l = strchr(tone_script, '|'))) {
*l++ = '\0'; *l++ = '\0';
@ -1208,8 +1128,6 @@ SWITCH_STANDARD_APP(record_function)
const char *tmp; const char *tmp;
int rate; int rate;
switch_assert(channel != NULL);
if (!switch_strlen_zero(data) && (mydata = switch_core_session_strdup(session, data))) { if (!switch_strlen_zero(data) && (mydata = switch_core_session_strdup(session, data))) {
argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
} else { } else {
@ -1301,8 +1219,6 @@ SWITCH_STANDARD_APP(audio_bridge_function)
uint8_t no_media_bridge = 0; uint8_t no_media_bridge = 0;
switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING; switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
assert(caller_channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
return; return;
} }

4
src/mod/applications/mod_enum/mod_enum.c
View File

@ -547,8 +547,6 @@ SWITCH_STANDARD_DIALPLAN(enum_dialplan_hunt)
enum_route_t *rtp; enum_route_t *rtp;
char *dp = (char *) arg; char *dp = (char *) arg;
assert(channel != NULL);
if (!caller_profile) { if (!caller_profile) {
caller_profile = switch_channel_get_caller_profile(channel); caller_profile = switch_channel_get_caller_profile(channel);
} }
@ -597,8 +595,6 @@ SWITCH_STANDARD_APP(enum_app_function)
uint32_t cnt = 1; uint32_t cnt = 1;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (!(mydata = switch_core_session_strdup(session, data))) { if (!(mydata = switch_core_session_strdup(session, data))) {
return; return;
} }

7
src/mod/applications/mod_esf/mod_esf.c
View File

@ -56,7 +56,7 @@ typedef enum {
SWITCH_STANDARD_APP(bcast_function) SWITCH_STANDARD_APP(bcast_function)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_socket_t *socket; switch_socket_t *socket;
switch_sockaddr_t *audio_addr = NULL, *control_packet_addr; switch_sockaddr_t *audio_addr = NULL, *control_packet_addr;
switch_frame_t *read_frame; switch_frame_t *read_frame;
@ -77,11 +77,6 @@ SWITCH_STANDARD_APP(bcast_function)
switch_port_t mcast_control_port = 6061; switch_port_t mcast_control_port = 6061;
char *mcast_port_str = "34567"; char *mcast_port_str = "34567";
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (!switch_strlen_zero((char *) data)) { if (!switch_strlen_zero((char *) data)) {
mydata = switch_core_session_strdup(session, data); mydata = switch_core_session_strdup(session, data);
assert(mydata != NULL); assert(mydata != NULL);

51
src/mod/applications/mod_fifo/mod_fifo.c
View File

@ -40,10 +40,7 @@ SWITCH_MODULE_DEFINITION(mod_fifo, mod_fifo_load, mod_fifo_shutdown, NULL);
static switch_status_t on_dtmf(switch_core_session_t *session, void *input, switch_input_type_t itype, void *buf, unsigned int buflen) static switch_status_t on_dtmf(switch_core_session_t *session, void *input, switch_input_type_t itype, void *buf, unsigned int buflen)
{ {
switch_core_session_t *bleg; switch_core_session_t *bleg = (switch_core_session_t *) buf;
switch_channel_t *channel;
bleg = (switch_core_session_t *) buf;
switch (itype) { switch (itype) {
case SWITCH_INPUT_TYPE_DTMF: case SWITCH_INPUT_TYPE_DTMF:
@ -51,10 +48,8 @@ static switch_status_t on_dtmf(switch_core_session_t *session, void *input, swit
switch_dtmf_t *dtmf = (switch_dtmf_t *) input; switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
if (dtmf->digit == '*') { if (dtmf->digit == '*') {
channel = switch_core_session_get_channel(session); if (switch_channel_test_flag(switch_core_session_get_channel(session), CF_ORIGINATOR)) {
if (switch_channel_test_flag(channel, CF_ORIGINATOR)) { switch_channel_hangup(switch_core_session_get_channel(bleg), SWITCH_CAUSE_NORMAL_CLEARING);
channel = switch_core_session_get_channel(bleg);
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
return SWITCH_STATUS_BREAK; return SWITCH_STATUS_BREAK;
} }
} }
@ -67,10 +62,8 @@ static switch_status_t on_dtmf(switch_core_session_t *session, void *input, swit
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
#define check_string(s) if (!switch_strlen_zero(s) && !strcasecmp(s, "undef")) { s = NULL; } #define check_string(s) if (!switch_strlen_zero(s) && !strcasecmp(s, "undef")) { s = NULL; }
static switch_status_t read_frame_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data) static switch_status_t read_frame_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data)
{ {
switch_queue_t *fifo = (switch_queue_t *) user_data; switch_queue_t *fifo = (switch_queue_t *) user_data;
@ -194,7 +187,7 @@ SWITCH_STANDARD_APP(fifo_function)
int argc; int argc;
char *mydata = NULL, *argv[5] = { 0 }; char *mydata = NULL, *argv[5] = { 0 };
fifo_node_t *node; fifo_node_t *node;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
int nowait = 0; int nowait = 0;
const char *moh = NULL; const char *moh = NULL;
const char *announce = NULL; const char *announce = NULL;
@ -208,8 +201,7 @@ SWITCH_STANDARD_APP(fifo_function)
return; return;
} }
if (switch_strlen_zero(data)) {
if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No Args\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No Args\n");
return; return;
} }
@ -221,17 +213,13 @@ SWITCH_STANDARD_APP(fifo_function)
return; return;
} }
channel = switch_core_session_get_channel(session); switch_mutex_lock(globals.mutex);
switch_mutex_lock(globals.mutex);
if (!(node = switch_core_hash_find(globals.fifo_hash, argv[0]))) { if (!(node = switch_core_hash_find(globals.fifo_hash, argv[0]))) {
node = create_node(argv[0]); node = create_node(argv[0]);
} }
switch_mutex_unlock(globals.mutex); switch_mutex_unlock(globals.mutex);
moh = switch_channel_get_variable(channel, "fifo_music");
moh = switch_channel_get_variable(channel, "fifo_music");
announce = switch_channel_get_variable(channel, "fifo_announce"); announce = switch_channel_get_variable(channel, "fifo_announce");
if (argc > 2) { if (argc > 2) {
@ -254,8 +242,7 @@ SWITCH_STANDARD_APP(fifo_function)
check_string(announce); check_string(announce);
check_string(moh); check_string(moh);
if (moh) {
if (moh) {
switch_ivr_broadcast(uuid, moh, SMF_LOOP | SMF_ECHO_ALEG); switch_ivr_broadcast(uuid, moh, SMF_LOOP | SMF_ECHO_ALEG);
} }
@ -284,9 +271,7 @@ SWITCH_STANDARD_APP(fifo_function)
switch_ivr_park(session, NULL); switch_ivr_park(session, NULL);
if (switch_channel_ready(channel)) {
if (switch_channel_ready(channel)) {
if (announce) { if (announce) {
switch_ivr_play_file(session, NULL, announce, NULL); switch_ivr_play_file(session, NULL, announce, NULL);
} }
@ -345,9 +330,8 @@ SWITCH_STANDARD_APP(fifo_function)
switch_mutex_unlock(node->mutex); switch_mutex_unlock(node->mutex);
switch_channel_answer(channel); switch_channel_answer(channel);
} }
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event); switch_channel_event_set_data(channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_start"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_start");
@ -360,9 +344,7 @@ SWITCH_STANDARD_APP(fifo_function)
switch_channel_set_variable(channel, "fifo_status", "WAITING"); switch_channel_set_variable(channel, "fifo_status", "WAITING");
switch_channel_set_variable(channel, "fifo_timestamp", date); switch_channel_set_variable(channel, "fifo_timestamp", date);
while(switch_channel_ready(channel)) {
while(switch_channel_ready(channel)) {
if (moh) { if (moh) {
args.read_frame_callback = read_frame_callback; args.read_frame_callback = read_frame_callback;
args.user_data = node->fifo; args.user_data = node->fifo;
@ -389,8 +371,7 @@ SWITCH_STANDARD_APP(fifo_function)
switch_channel_t *other_channel = switch_core_session_get_channel(other_session); switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
switch_caller_profile_t *cloned_profile; switch_caller_profile_t *cloned_profile;
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) {
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(other_channel, event); switch_channel_event_set_data(other_channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "caller_pop"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "caller_pop");
@ -404,9 +385,7 @@ SWITCH_STANDARD_APP(fifo_function)
switch_event_fire(&event); switch_event_fire(&event);
} }
if (announce) {
if (announce) {
switch_ivr_play_file(session, NULL, announce, NULL); switch_ivr_play_file(session, NULL, announce, NULL);
} else { } else {
switch_ivr_sleep(session, 500); switch_ivr_sleep(session, 500);
@ -477,8 +456,7 @@ SWITCH_STANDARD_APP(fifo_function)
} }
} }
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) {
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event); switch_channel_event_set_data(channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_stop"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_stop");
@ -495,7 +473,6 @@ SWITCH_STANDARD_APP(fifo_function)
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "USAGE %s\n", FIFO_USAGE); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "USAGE %s\n", FIFO_USAGE);
} }
} }
static int xml_hash(switch_xml_t xml, switch_hash_t *hash, char *container, char *tag, int cc_off, int verbose) static int xml_hash(switch_xml_t xml, switch_hash_t *hash, char *container, char *tag, int cc_off, int verbose)

51
src/mod/applications/mod_limit/mod_limit.c
View File

@ -284,18 +284,13 @@ static switch_status_t do_config()
static switch_status_t hanguphook(switch_core_session_t *session) static switch_status_t hanguphook(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_channel_state_t state; switch_channel_state_t state = switch_channel_get_state(channel);
const char *realm = NULL; const char *realm = NULL;
const char *id = NULL; const char *id = NULL;
char *sql = NULL; char *sql = NULL;
channel = switch_core_session_get_channel(session); if (state == CS_HANGUP || state == CS_RING) {
assert(channel != NULL);
state = switch_channel_get_state(channel);
if (state == CS_HANGUP || state == CS_RING) {
id = switch_channel_get_variable(channel, "limit_id"); id = switch_channel_get_variable(channel, "limit_id");
realm = switch_channel_get_variable(channel, "limit_realm"); realm = switch_channel_get_variable(channel, "limit_realm");
sql = switch_mprintf("delete from limit_data where uuid='%q' and hostname='%q' and realm='%q'and id='%q';", sql = switch_mprintf("delete from limit_data where uuid='%q' and hostname='%q' and realm='%q'and id='%q';",
@ -406,16 +401,12 @@ SWITCH_STANDARD_API(db_api_function)
SWITCH_STANDARD_APP(db_function) SWITCH_STANDARD_APP(db_function)
{ {
switch_channel_t *channel;
int argc = 0; int argc = 0;
char *argv[4] = { 0 }; char *argv[4] = { 0 };
char *mydata = NULL; char *mydata = NULL;
char *sql = NULL; char *sql = NULL;
channel = switch_core_session_get_channel(session); if (!switch_strlen_zero(data)) {
assert(channel != NULL);
if (!switch_strlen_zero(data)) {
mydata = switch_core_session_strdup(session, data); mydata = switch_core_session_strdup(session, data);
argc = switch_separate_string(mydata, '/', argv, (sizeof(argv) / sizeof(argv[0]))); argc = switch_separate_string(mydata, '/', argv, (sizeof(argv) / sizeof(argv[0])));
} }
@ -423,9 +414,8 @@ SWITCH_STANDARD_APP(db_function)
if (argc < 4 || !argv[0]) { if (argc < 4 || !argv[0]) {
goto error; goto error;
} }
if (!strcasecmp(argv[0], "insert")) {
if (!strcasecmp(argv[0], "insert")) {
sql = switch_mprintf("delete from db_data where realm='%q' and data_key='%q'", argv[1], argv[2]); sql = switch_mprintf("delete from db_data where realm='%q' and data_key='%q'", argv[1], argv[2]);
switch_assert(sql); switch_assert(sql);
limit_execute_sql(sql, globals.mutex); limit_execute_sql(sql, globals.mutex);
@ -441,12 +431,8 @@ SWITCH_STANDARD_APP(db_function)
switch_safe_free(sql); switch_safe_free(sql);
return; return;
error:
error:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "USAGE: db %s\n", DB_USAGE); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "USAGE: db %s\n", DB_USAGE);
} }
@ -536,16 +522,12 @@ SWITCH_STANDARD_API(group_api_function)
SWITCH_STANDARD_APP(group_function) SWITCH_STANDARD_APP(group_function)
{ {
switch_channel_t *channel;
int argc = 0; int argc = 0;
char *argv[3] = { 0 }; char *argv[3] = { 0 };
char *mydata = NULL; char *mydata = NULL;
char *sql; char *sql;
channel = switch_core_session_get_channel(session); if (!switch_strlen_zero(data)) {
assert(channel != NULL);
if (!switch_strlen_zero(data)) {
mydata = switch_core_session_strdup(session, data); mydata = switch_core_session_strdup(session, data);
argc = switch_separate_string(mydata, ':', argv, (sizeof(argv) / sizeof(argv[0]))); argc = switch_separate_string(mydata, ':', argv, (sizeof(argv) / sizeof(argv[0])));
} }
@ -585,10 +567,7 @@ SWITCH_STANDARD_APP(limit_function)
int max = 0, got = 0; int max = 0, got = 0;
char buf[80] = ""; char buf[80] = "";
callback_t cbt = { 0 }; callback_t cbt = { 0 };
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (!switch_strlen_zero(data)) { if (!switch_strlen_zero(data)) {
mydata = switch_core_session_strdup(session, data); mydata = switch_core_session_strdup(session, data);
@ -600,12 +579,9 @@ SWITCH_STANDARD_APP(limit_function)
return; return;
} }
switch_mutex_lock(globals.mutex);
switch_mutex_lock(globals.mutex); realm = argv[0];
realm = argv[0];
id = argv[1]; id = argv[1];
max = atoi(argv[2]); max = atoi(argv[2]);
@ -639,11 +615,8 @@ SWITCH_STANDARD_APP(limit_function)
limit_execute_sql(sql, NULL); limit_execute_sql(sql, NULL);
switch_safe_free(sql); switch_safe_free(sql);
done:
done:
switch_mutex_unlock(globals.mutex); switch_mutex_unlock(globals.mutex);
} }

8
src/mod/applications/mod_rss/mod_rss.c
View File

@ -155,7 +155,7 @@ static switch_status_t on_dtmf(switch_core_session_t *session, void *input, swit
SWITCH_STANDARD_APP(rss_function) SWITCH_STANDARD_APP(rss_function)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status; switch_status_t status;
const char *err = NULL; const char *err = NULL;
struct dtmf_buffer dtb = { 0 }; struct dtmf_buffer dtb = { 0 };
@ -185,16 +185,12 @@ SWITCH_STANDARD_APP(rss_function)
uint32_t matches = 0; uint32_t matches = 0;
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
const char *vcf = NULL; const char *vcf = NULL;
char *chanvars = NULL; char *chanvars = switch_channel_build_param_string(channel, NULL, NULL);
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if ((vcf = switch_channel_get_variable(channel, "rss_alt_config"))) { if ((vcf = switch_channel_get_variable(channel, "rss_alt_config"))) {
cf = vcf; cf = vcf;
} }
chanvars = switch_channel_build_param_string(channel, NULL, NULL);
if (!(cxml = switch_xml_open_cfg(cf, &cfg, NULL))) { if (!(cxml = switch_xml_open_cfg(cf, &cfg, NULL))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf);
return; return;

34
src/mod/applications/mod_voicemail/mod_voicemail.c
View File

@ -792,13 +792,9 @@ static switch_status_t vm_macro_get(switch_core_session_t *session,
uint32_t timeout) uint32_t timeout)
{ {
switch_input_args_t args = { 0 }, *ap = NULL; switch_input_args_t args = { 0 }, *ap = NULL;
switch_channel_t *channel;
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_size_t bslen; switch_size_t bslen;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (buf && buflen) { if (buf && buflen) {
memset(buf, 0, buflen); memset(buf, 0, buflen);
args.input_callback = cancel_on_dtmf; args.input_callback = cancel_on_dtmf;
@ -870,7 +866,7 @@ typedef enum {
static switch_status_t create_file(switch_core_session_t *session, vm_profile_t *profile, static switch_status_t create_file(switch_core_session_t *session, vm_profile_t *profile,
char *macro_name, char *file_path, switch_size_t *message_len, switch_bool_t limit) char *macro_name, char *file_path, switch_size_t *message_len, switch_bool_t limit)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_file_handle_t fh = { 0 }; switch_file_handle_t fh = { 0 };
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
@ -878,8 +874,6 @@ static switch_status_t create_file(switch_core_session_t *session, vm_profile_t
char input[10] = "" , key_buf[80] = ""; char input[10] = "" , key_buf[80] = "";
cc_t cc = { 0 }; cc_t cc = { 0 };
switch_codec_t *read_codec; switch_codec_t *read_codec;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
read_codec = switch_core_session_get_read_codec(session); read_codec = switch_core_session_get_read_codec(session);
@ -1040,15 +1034,13 @@ static void message_count(vm_profile_t *profile, const char *myid, const char *d
static switch_status_t listen_file(switch_core_session_t *session, vm_profile_t *profile, listen_callback_t *cbt) static switch_status_t listen_file(switch_core_session_t *session, vm_profile_t *profile, listen_callback_t *cbt)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
char term; char term;
char input[10] = "" , key_buf[80] = ""; char input[10] = "" , key_buf[80] = "";
switch_file_handle_t fh = { 0 }; switch_file_handle_t fh = { 0 };
cc_t cc = { 0 }; cc_t cc = { 0 };
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if(switch_channel_ready(channel)) { if(switch_channel_ready(channel)) {
@ -1227,10 +1219,10 @@ end:
static void voicemail_check_main(switch_core_session_t *session, const char *profile_name, const char *domain_name, const char *id, int auth) static void voicemail_check_main(switch_core_session_t *session, const char *profile_name, const char *domain_name, const char *id, int auth)
{ {
vm_check_state_t vm_check_state = VM_CHECK_START; vm_check_state_t vm_check_state = VM_CHECK_START;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile;
vm_profile_t *profile; vm_profile_t *profile;
switch_xml_t x_domain, x_domain_root, x_user, x_params, x_param; switch_xml_t x_domain = NULL, x_domain_root = NULL, x_user = NULL, x_params, x_param;
switch_status_t status; switch_status_t status;
char pass_buf[80] = "", *mypass = NULL, id_buf[80] = "", *myfolder = NULL; char pass_buf[80] = "", *mypass = NULL, id_buf[80] = "", *myfolder = NULL;
const char *thepass = NULL, *myid = id; const char *thepass = NULL, *myid = id;
@ -1246,16 +1238,11 @@ static void voicemail_check_main(switch_core_session_t *session, const char *pro
int heard_auto_saved = 0, heard_auto_new = 0; int heard_auto_saved = 0, heard_auto_new = 0;
char *email_vm = NULL; char *email_vm = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(profile = switch_core_hash_find(globals.profile_hash, profile_name))) { if (!(profile = switch_core_hash_find(globals.profile_hash, profile_name))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error invalid profile %s\n", profile_name); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error invalid profile %s\n", profile_name);
return; return;
} }
x_user = x_domain = x_domain_root = NULL;
timeout = profile->digit_timeout; timeout = profile->digit_timeout;
attempts = profile->max_login_attempts; attempts = profile->max_login_attempts;
@ -1684,7 +1671,7 @@ end:
static switch_status_t voicemail_leave_main(switch_core_session_t *session, const char *profile_name, const char *domain_name, const char *id) static switch_status_t voicemail_leave_main(switch_core_session_t *session, const char *profile_name, const char *domain_name, const char *id)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
char *myfolder = "inbox"; char *myfolder = "inbox";
char sql[256]; char sql[256];
prefs_callback_t cbt; prefs_callback_t cbt;
@ -1693,7 +1680,7 @@ static switch_status_t voicemail_leave_main(switch_core_session_t *session, cons
char *file_path = NULL; char *file_path = NULL;
char *dir_path = NULL; char *dir_path = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile = switch_channel_get_caller_profile(channel);
switch_file_handle_t fh = { 0 }; switch_file_handle_t fh = { 0 };
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
char *email_vm = NULL; char *email_vm = NULL;
@ -1719,10 +1706,6 @@ static switch_status_t voicemail_leave_main(switch_core_session_t *session, cons
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
caller_profile = switch_channel_get_caller_profile(channel);
if(switch_strlen_zero(profile->storage_dir)) { if(switch_strlen_zero(profile->storage_dir)) {
dir_path = switch_core_session_sprintf(session, "%s%svoicemail%s%s%s%s%s%s", SWITCH_GLOBAL_dirs.storage_dir, dir_path = switch_core_session_sprintf(session, "%s%svoicemail%s%s%s%s%s%s", SWITCH_GLOBAL_dirs.storage_dir,
SWITCH_PATH_SEPARATOR, SWITCH_PATH_SEPARATOR,
@ -2059,10 +2042,7 @@ SWITCH_STANDARD_APP(voicemail_function)
const char *id = NULL; const char *id = NULL;
const char *auth_var = NULL; const char *auth_var = NULL;
int x = 0, check = 0, auth = 0; int x = 0, check = 0, auth = 0;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_dir_make_recursive(SWITCH_GLOBAL_dirs.storage_dir, SWITCH_DEFAULT_DIR_PERMS, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) { if (switch_dir_make_recursive(SWITCH_GLOBAL_dirs.storage_dir, SWITCH_DEFAULT_DIR_PERMS, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating %s\n", SWITCH_GLOBAL_dirs.storage_dir); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating %s\n", SWITCH_GLOBAL_dirs.storage_dir);

24
src/mod/dialplans/mod_dialplan_asterisk/mod_dialplan_asterisk.c
View File

@ -52,13 +52,8 @@ SWITCH_STANDARD_APP(dial_function)
int argc; int argc;
char *argv[4] = { 0 }; char *argv[4] = { 0 };
char *mydata; char *mydata;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (data && (mydata = switch_core_session_strdup(session, data))) { if (data && (mydata = switch_core_session_strdup(session, data))) {
if ((argc = switch_separate_string(mydata, '|', argv, (sizeof(argv) / sizeof(argv[0])))) < 2) { if ((argc = switch_separate_string(mydata, '|', argv, (sizeof(argv) / sizeof(argv[0])))) < 2) {
goto error; goto error;
@ -89,11 +84,7 @@ SWITCH_STANDARD_APP(avoid_function)
{ {
void *y = NULL; void *y = NULL;
int x = 0; int x = 0;
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
for (x = 0; x < 5; x++) { for (x = 0; x < 5; x++) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Avoiding initial deadlock on channel %s.\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Avoiding initial deadlock on channel %s.\n", switch_channel_get_name(channel));
@ -109,11 +100,7 @@ SWITCH_STANDARD_APP(goto_function)
int argc; int argc;
char *argv[3] = { 0 }; char *argv[3] = { 0 };
char *mydata; char *mydata;
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (data && (mydata = switch_core_session_strdup(session, data))) { if (data && (mydata = switch_core_session_strdup(session, data))) {
if ((argc = switch_separate_string(mydata, '|', argv, (sizeof(argv) / sizeof(argv[0])))) < 1) { if ((argc = switch_separate_string(mydata, '|', argv, (sizeof(argv) / sizeof(argv[0])))) < 1) {
goto error; goto error;
@ -134,7 +121,7 @@ SWITCH_STANDARD_APP(goto_function)
SWITCH_STANDARD_DIALPLAN(asterisk_dialplan_hunt) SWITCH_STANDARD_DIALPLAN(asterisk_dialplan_hunt)
{ {
switch_caller_extension_t *extension = NULL; switch_caller_extension_t *extension = NULL;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
char *cf = "extensions.conf"; char *cf = "extensions.conf";
switch_config_t cfg; switch_config_t cfg;
char *var, *val; char *var, *val;
@ -144,9 +131,6 @@ SWITCH_STANDARD_DIALPLAN(asterisk_dialplan_hunt)
cf = arg; cf = arg;
} }
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!caller_profile) { if (!caller_profile) {
caller_profile = switch_channel_get_caller_profile(channel); caller_profile = switch_channel_get_caller_profile(channel);
} }

6
src/mod/dialplans/mod_dialplan_directory/mod_dialplan_directory.c
View File

@ -86,16 +86,13 @@ static void load_config(void)
SWITCH_STANDARD_DIALPLAN(directory_dialplan_hunt) SWITCH_STANDARD_DIALPLAN(directory_dialplan_hunt)
{ {
switch_caller_extension_t *extension = NULL; switch_caller_extension_t *extension = NULL;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
char *var, *val; char *var, *val;
char filter[256]; char filter[256];
switch_directory_handle_t dh; switch_directory_handle_t dh;
char app[512]; char app[512];
char *data; char *data;
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (!caller_profile) { if (!caller_profile) {
caller_profile = switch_channel_get_caller_profile(channel); caller_profile = switch_channel_get_caller_profile(channel);
} }
@ -103,7 +100,6 @@ SWITCH_STANDARD_DIALPLAN(directory_dialplan_hunt)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Hello %s You Dialed %s!\n", caller_profile->caller_id_name, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Hello %s You Dialed %s!\n", caller_profile->caller_id_name,
caller_profile->destination_number); caller_profile->destination_number);
if (!(globals.directory_name && globals.host && globals.dn && globals.base && globals.pass)) { if (!(globals.directory_name && globals.host && globals.dn && globals.base && globals.pass)) {
return NULL; return NULL;
} }

12
src/mod/dialplans/mod_dialplan_xml/mod_dialplan_xml.c
View File

@ -47,14 +47,11 @@ typedef enum {
static int parse_exten(switch_core_session_t *session, switch_caller_profile_t *caller_profile, switch_xml_t xexten, switch_caller_extension_t **extension) static int parse_exten(switch_core_session_t *session, switch_caller_profile_t *caller_profile, switch_xml_t xexten, switch_caller_extension_t **extension)
{ {
switch_xml_t xcond, xaction; switch_xml_t xcond, xaction;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
char *exten_name = (char *) switch_xml_attr_soft(xexten, "name"); char *exten_name = (char *) switch_xml_attr_soft(xexten, "name");
int proceed = 0; int proceed = 0;
char *expression_expanded = NULL, *field_expanded = NULL; char *expression_expanded = NULL, *field_expanded = NULL;
channel = switch_core_session_get_channel(session);
for (xcond = switch_xml_child(xexten, "condition"); xcond; xcond = xcond->next) { for (xcond = switch_xml_child(xexten, "condition"); xcond; xcond = xcond->next) {
char *field = NULL; char *field = NULL;
char *do_break_a = NULL; char *do_break_a = NULL;
@ -186,11 +183,10 @@ static int parse_exten(switch_core_session_t *session, switch_caller_profile_t *
static switch_status_t dialplan_xml_locate(switch_core_session_t *session, switch_caller_profile_t *caller_profile, switch_xml_t * root, static switch_status_t dialplan_xml_locate(switch_core_session_t *session, switch_caller_profile_t *caller_profile, switch_xml_t * root,
switch_xml_t * node) switch_xml_t * node)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_GENERR; switch_status_t status = SWITCH_STATUS_GENERR;
switch_event_t *params = NULL; switch_event_t *params = NULL;
channel = switch_core_session_get_channel(session);
switch_event_create(&params, SWITCH_EVENT_MESSAGE); switch_event_create(&params, SWITCH_EVENT_MESSAGE);
switch_assert(params); switch_assert(params);
@ -204,11 +200,9 @@ static switch_status_t dialplan_xml_locate(switch_core_session_t *session, switc
SWITCH_STANDARD_DIALPLAN(dialplan_hunt) SWITCH_STANDARD_DIALPLAN(dialplan_hunt)
{ {
switch_caller_extension_t *extension = NULL; switch_caller_extension_t *extension = NULL;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_xml_t alt_root = NULL, cfg, xml = NULL, xcontext, xexten; switch_xml_t alt_root = NULL, cfg, xml = NULL, xcontext, xexten;
char *alt_path = (char *) arg; char *alt_path = (char *) arg;
channel = switch_core_session_get_channel(session);
if (!caller_profile) { if (!caller_profile) {
if (!(caller_profile = switch_channel_get_caller_profile(channel))) { if (!(caller_profile = switch_channel_get_caller_profile(channel))) {

51
src/mod/endpoints/mod_dingaling/mod_dingaling.c
View File

@ -906,7 +906,6 @@ static int activate_rtp(struct private_object *tech_pvt)
static int do_candidates(struct private_object *tech_pvt, int force) static int do_candidates(struct private_object *tech_pvt, int force)
{ {
switch_channel_t *channel = switch_core_session_get_channel(tech_pvt->session); switch_channel_t *channel = switch_core_session_get_channel(tech_pvt->session);
switch_assert(channel != NULL);
if (switch_test_flag(tech_pvt, TFLAG_DO_CAND)) { if (switch_test_flag(tech_pvt, TFLAG_DO_CAND)) {
return 1; return 1;
@ -1052,7 +1051,7 @@ static int do_describe(struct private_object *tech_pvt, int force)
static switch_status_t negotiate_media(switch_core_session_t *session) static switch_status_t negotiate_media(switch_core_session_t *session)
{ {
switch_status_t ret = SWITCH_STATUS_FALSE; switch_status_t ret = SWITCH_STATUS_FALSE;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = NULL;
switch_time_t started; switch_time_t started;
switch_time_t now; switch_time_t now;
@ -1061,9 +1060,6 @@ static switch_status_t negotiate_media(switch_core_session_t *session)
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_set_flag_locked(tech_pvt, TFLAG_IO); switch_set_flag_locked(tech_pvt, TFLAG_IO);
started = switch_timestamp_now(); started = switch_timestamp_now();
@ -1148,15 +1144,12 @@ static switch_status_t negotiate_media(switch_core_session_t *session)
*/ */
static switch_status_t channel_on_init(switch_core_session_t *session) static switch_status_t channel_on_init(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = NULL;
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt->read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN; tech_pvt->read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN;
switch_set_flag(tech_pvt, TFLAG_READY); switch_set_flag(tech_pvt, TFLAG_READY);
@ -1171,12 +1164,9 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
static switch_status_t channel_on_ring(switch_core_session_t *session) static switch_status_t channel_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -1205,12 +1195,9 @@ static switch_status_t channel_on_execute(switch_core_session_t *session)
static switch_status_t channel_on_hangup(switch_core_session_t *session) static switch_status_t channel_on_hangup(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -1258,18 +1245,13 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session)
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig) static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = NULL;
if (!(channel = switch_core_session_get_channel(session))) {
return SWITCH_STATUS_SUCCESS;
}
if (!(tech_pvt = switch_core_session_get_private(session))) { if (!(tech_pvt = switch_core_session_get_private(session))) {
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
switch (sig) { switch (sig) {
case SWITCH_SIG_KILL: case SWITCH_SIG_KILL:
switch_clear_flag_locked(tech_pvt, TFLAG_IO); switch_clear_flag_locked(tech_pvt, TFLAG_IO);
@ -1351,12 +1333,9 @@ static switch_status_t channel_send_dtmf(switch_core_session_t *session, const s
static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = NULL;
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
int payload = 0; int payload = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (struct private_object *) switch_core_session_get_private(session); tech_pvt = (struct private_object *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -1452,13 +1431,10 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
struct private_object *tech_pvt; struct private_object *tech_pvt;
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
int bytes = 0, samples = 0, frames = 0; int bytes = 0, samples = 0, frames = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (struct private_object *) switch_core_session_get_private(session); tech_pvt = (struct private_object *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -1506,10 +1482,6 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc
static switch_status_t channel_answer_channel(switch_core_session_t *session) static switch_status_t channel_answer_channel(switch_core_session_t *session)
{ {
struct private_object *tech_pvt; struct private_object *tech_pvt;
switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -1524,12 +1496,8 @@ static switch_status_t channel_answer_channel(switch_core_session_t *session)
static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg) static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{ {
switch_channel_t *channel;
struct private_object *tech_pvt; struct private_object *tech_pvt;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -1564,13 +1532,9 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s
static switch_status_t channel_receive_event(switch_core_session_t *session, switch_event_t *event) static switch_status_t channel_receive_event(switch_core_session_t *session, switch_event_t *event)
{ {
switch_channel_t *channel;
struct private_object *tech_pvt; struct private_object *tech_pvt;
char *subject, *body; char *subject, *body;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -2572,7 +2536,6 @@ static ldl_status handle_signalling(ldl_handle_t * handle, ldl_session_t * dlses
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "using Existing session for %s\n", ldl_session_get_id(dlsession)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "using Existing session for %s\n", ldl_session_get_id(dlsession));

139
src/mod/endpoints/mod_iax/mod_iax.c
View File

@ -339,8 +339,6 @@ static switch_status_t iax_set_codec(private_t * tech_pvt, struct iax_session *i
} }
channel = switch_core_session_get_channel(tech_pvt->session); channel = switch_core_session_get_channel(tech_pvt->session);
switch_assert(channel != NULL);
if (tech_pvt->samprate || *samprate) { if (tech_pvt->samprate || *samprate) {
unsigned short samples = iax_build_codec_rates(); unsigned short samples = iax_build_codec_rates();
@ -456,26 +454,15 @@ static void tech_init(private_t * tech_pvt, switch_core_session_t *session)
*/ */
static switch_status_t channel_on_init(switch_core_session_t *session) static switch_status_t channel_on_init(switch_core_session_t *session)
{ {
switch_channel_t *channel; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
iax_set_private(tech_pvt->iax_session, tech_pvt); iax_set_private(tech_pvt->iax_session, tech_pvt);
switch_set_flag_locked(tech_pvt, TFLAG_IO); switch_set_flag_locked(tech_pvt, TFLAG_IO);
//switch_thread_cond_create(&tech_pvt->cond, switch_core_session_get_pool(session));
//switch_mutex_lock(tech_pvt->mutex);
/* Move Channel's State Machine to RING */ /* Move Channel's State Machine to RING */
switch_channel_set_state(channel, CS_RING); switch_channel_set_state(switch_core_session_get_channel(session), CS_RING);
switch_mutex_lock(globals.mutex); switch_mutex_lock(globals.mutex);
globals.calls++; globals.calls++;
switch_mutex_unlock(globals.mutex); switch_mutex_unlock(globals.mutex);
@ -485,52 +472,24 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
static switch_status_t channel_on_ring(switch_core_session_t *session) static switch_status_t channel_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL RING\n", switch_channel_get_name(switch_core_session_get_channel(session)));
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL RING\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_on_execute(switch_core_session_t *session) static switch_status_t channel_on_execute(switch_core_session_t *session)
{ {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL EXECUTE\n", switch_channel_get_name(switch_core_session_get_channel(session)));
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL EXECUTE\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_on_hangup(switch_core_session_t *session) static switch_status_t channel_on_hangup(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_clear_flag_locked(tech_pvt, TFLAG_IO); switch_clear_flag_locked(tech_pvt, TFLAG_IO);
switch_clear_flag_locked(tech_pvt, TFLAG_VOICE); switch_clear_flag_locked(tech_pvt, TFLAG_VOICE);
//switch_thread_cond_signal(tech_pvt->cond);
if (tech_pvt->read_codec.implementation) { if (tech_pvt->read_codec.implementation) {
switch_core_codec_destroy(&tech_pvt->read_codec); switch_core_codec_destroy(&tech_pvt->read_codec);
@ -548,7 +507,7 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session)
iax_session_destroy(&tech_pvt->iax_session); iax_session_destroy(&tech_pvt->iax_session);
} }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL HANGUP\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL HANGUP\n", switch_channel_get_name(switch_core_session_get_channel(session)));
switch_mutex_lock(globals.mutex); switch_mutex_lock(globals.mutex);
globals.calls--; globals.calls--;
if (globals.calls < 0) { if (globals.calls < 0) {
@ -561,21 +520,14 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session)
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig) static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig)
{ {
switch_channel_t *channel = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch (sig) { switch (sig) {
case SWITCH_SIG_KILL: case SWITCH_SIG_KILL:
switch_clear_flag_locked(tech_pvt, TFLAG_IO); switch_clear_flag_locked(tech_pvt, TFLAG_IO);
switch_clear_flag_locked(tech_pvt, TFLAG_VOICE); switch_clear_flag_locked(tech_pvt, TFLAG_VOICE);
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING); switch_channel_hangup(switch_core_session_get_channel(session), SWITCH_CAUSE_NORMAL_CLEARING);
//switch_thread_cond_signal(tech_pvt->cond);
break; break;
case SWITCH_SIG_BREAK: case SWITCH_SIG_BREAK:
switch_set_flag_locked(tech_pvt, TFLAG_BREAK); switch_set_flag_locked(tech_pvt, TFLAG_BREAK);
@ -601,9 +553,7 @@ static switch_status_t channel_on_transmit(switch_core_session_t *session)
static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id) static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
{ {
private_t *tech_pvt = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
@ -611,20 +561,15 @@ static switch_status_t channel_waitfor_read(switch_core_session_t *session, int
static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id) static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
{ {
private_t *tech_pvt = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf) static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{ {
private_t *tech_pvt = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (tech_pvt->iax_session) { if (tech_pvt->iax_session) {
iax_send_dtmf(tech_pvt->iax_session, dtmf->digit); iax_send_dtmf(tech_pvt->iax_session, dtmf->digit);
@ -635,16 +580,11 @@ static switch_status_t channel_send_dtmf(switch_core_session_t *session, const s
static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
switch_channel_t *channel = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
switch_time_t started = switch_timestamp_now(); switch_time_t started = switch_timestamp_now();
unsigned int elapsed; unsigned int elapsed;
switch_byte_t *data; switch_byte_t *data;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
tech_pvt->read_frame.flags = SFF_NONE; tech_pvt->read_frame.flags = SFF_NONE;
*frame = NULL; *frame = NULL;
@ -655,7 +595,6 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
switch_yield(1000); switch_yield(1000);
continue; continue;
} }
//switch_thread_cond_wait(tech_pvt->cond, tech_pvt->mutex);
if (switch_test_flag(tech_pvt, TFLAG_BREAK)) { if (switch_test_flag(tech_pvt, TFLAG_BREAK)) {
switch_clear_flag(tech_pvt, TFLAG_BREAK); switch_clear_flag(tech_pvt, TFLAG_BREAK);
goto cng; goto cng;
@ -685,12 +624,9 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
} }
switch_yield(1000); switch_yield(1000);
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
cng: cng:
@ -701,19 +637,11 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
tech_pvt->read_frame.flags = SFF_CNG; tech_pvt->read_frame.flags = SFF_CNG;
*frame = &tech_pvt->read_frame; *frame = &tech_pvt->read_frame;
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
switch_channel_t *channel = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
//switch_frame_t *pframe;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!switch_test_flag(tech_pvt, TFLAG_IO)) { if (!switch_test_flag(tech_pvt, TFLAG_IO)) {
@ -732,13 +660,7 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc
static switch_status_t channel_answer_channel(switch_core_session_t *session) static switch_status_t channel_answer_channel(switch_core_session_t *session)
{ {
private_t *tech_pvt; private_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) { if (!switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) {
@ -750,13 +672,7 @@ static switch_status_t channel_answer_channel(switch_core_session_t *session)
static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg) static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{ {
switch_channel_t *channel; private_t *tech_pvt = (private_t *) switch_core_session_get_private(session);
private_t *tech_pvt;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch (msg->message_id) { switch (msg->message_id) {
@ -824,7 +740,6 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
} }
if (iax_set_codec(tech_pvt, tech_pvt->iax_session, &req, &cap, &samprate, IAX_QUERY) != SWITCH_STATUS_SUCCESS) { if (iax_set_codec(tech_pvt, tech_pvt->iax_session, &req, &cap, &samprate, IAX_QUERY) != SWITCH_STATUS_SUCCESS) {
switch_core_session_destroy(new_session); switch_core_session_destroy(new_session);
return SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL; return SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL;
@ -844,23 +759,16 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
} }
return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
} }
static switch_status_t channel_receive_event(switch_core_session_t *session, switch_event_t *event) static switch_status_t channel_receive_event(switch_core_session_t *session, switch_event_t *event)
{ {
switch_channel_t *channel; struct private_object *tech_pvt = switch_core_session_get_private(session);
struct private_object *tech_pvt; char *body = switch_event_get_body(event);
char *body;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!body) {
if (!(body = switch_event_get_body(event))) {
body = ""; body = "";
} }
@ -893,7 +801,6 @@ switch_io_routines_t iax_io_routines = {
SWITCH_MODULE_LOAD_FUNCTION(mod_iax_load) SWITCH_MODULE_LOAD_FUNCTION(mod_iax_load)
{ {
module_pool = pool; module_pool = pool;
*module_interface = switch_loadable_module_create_module_interface(pool, modname); *module_interface = switch_loadable_module_create_module_interface(pool, modname);
@ -980,7 +887,6 @@ static switch_status_t tech_media(private_t * tech_pvt, struct iax_event *iaxeve
SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime) SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
{ {
//int refresh;
struct iax_event *iaxevent = NULL; struct iax_event *iaxevent = NULL;
switch_event_t *s_event; switch_event_t *s_event;
if (load_config() != SWITCH_STATUS_SUCCESS) { if (load_config() != SWITCH_STATUS_SUCCESS) {
@ -1111,7 +1017,6 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
break; break;
} }
if ((tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session), if ((tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
iaxevent->ies.username, iaxevent->ies.username,
globals.dialplan, globals.dialplan,
@ -1128,7 +1033,6 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
switch_snprintf(name, sizeof(name), "IAX/%s-%04x", tech_pvt->caller_profile->destination_number, rand() & 0xffff); switch_snprintf(name, sizeof(name), "IAX/%s-%04x", tech_pvt->caller_profile->destination_number, rand() & 0xffff);
switch_channel_set_name(channel, name); switch_channel_set_name(channel, name);
switch_channel_set_caller_profile(channel, tech_pvt->caller_profile); switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
} }
if (iax_set_codec(tech_pvt, iaxevent->session, if (iax_set_codec(tech_pvt, iaxevent->session,
@ -1163,7 +1067,6 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Hangup %s\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Hangup %s\n", switch_channel_get_name(channel));
switch_set_flag_locked(tech_pvt, TFLAG_HANGUP); switch_set_flag_locked(tech_pvt, TFLAG_HANGUP);
switch_channel_hangup(channel, iaxevent->etype == IAX_EVENT_HANGUP ? SWITCH_CAUSE_NORMAL_CLEARING : SWITCH_CAUSE_FACILITY_REJECTED); switch_channel_hangup(channel, iaxevent->etype == IAX_EVENT_HANGUP ? SWITCH_CAUSE_NORMAL_CLEARING : SWITCH_CAUSE_FACILITY_REJECTED);
//switch_thread_cond_signal(tech_pvt->cond);
iaxevent->session = NULL; iaxevent->session = NULL;
} }
break; break;
@ -1177,7 +1080,6 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
int bytes, frames; int bytes, frames;
if (!switch_test_flag(tech_pvt, TFLAG_CODEC)) { if (!switch_test_flag(tech_pvt, TFLAG_CODEC)) {
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "audio with no codec yet!\n");
break; break;
} }
@ -1192,13 +1094,11 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
memcpy(tech_pvt->read_frame.data, iaxevent->data, iaxevent->datalen); memcpy(tech_pvt->read_frame.data, iaxevent->data, iaxevent->datalen);
/* wake up the i/o thread */ /* wake up the i/o thread */
switch_set_flag_locked(tech_pvt, TFLAG_VOICE); switch_set_flag_locked(tech_pvt, TFLAG_VOICE);
//switch_thread_cond_signal(tech_pvt->cond);
} }
} }
break; break;
case IAX_EVENT_TRANSFER: case IAX_EVENT_TRANSFER:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Call transfer occurred.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Call transfer occurred.\n");
//session[0] = iaxevent->session;
break; break;
case IAX_EVENT_DTMF: case IAX_EVENT_DTMF:
if (channel) { if (channel) {
@ -1206,7 +1106,6 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
if (globals.debug) { if (globals.debug) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%c DTMF %s\n", dtmf.digit, switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%c DTMF %s\n", dtmf.digit, switch_channel_get_name(channel));
} }
switch_channel_queue_dtmf(channel, &dtmf); switch_channel_queue_dtmf(channel, &dtmf);
} }
@ -1215,10 +1114,8 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Don't know what to do with IAX event %d.\n", iaxevent->etype); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Don't know what to do with IAX event %d.\n", iaxevent->etype);
break; break;
} }
iax_event_free(iaxevent); iax_event_free(iaxevent);
} }
} }
running = 0; running = 0;

166
src/mod/endpoints/mod_portaudio/mod_portaudio.c
View File

@ -165,25 +165,18 @@ static switch_status_t pa_cmd(const char *dest, switch_core_session_t *session,
*/ */
static switch_status_t channel_on_init(switch_core_session_t *session) static switch_status_t channel_on_init(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
private_t *tech_pvt = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
switch_time_t last; switch_time_t last;
int waitsec = globals.ring_interval * 1000000; int waitsec = globals.ring_interval * 1000000;
switch_file_handle_t fh = { 0 }; switch_file_handle_t fh = { 0 };
const char *val, *ring_file = NULL, *hold_file = NULL; const char *val, *ring_file = NULL, *hold_file = NULL;
int16_t abuf[2048]; int16_t abuf[2048];
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
last = switch_timestamp_now() - waitsec; last = switch_timestamp_now() - waitsec;
if ((val = switch_channel_get_variable(channel, "pa_hold_file"))) { if ((val = switch_channel_get_variable(channel, "pa_hold_file"))) {
hold_file = val; hold_file = val;
} else { } else {
@ -196,12 +189,9 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
if (switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) { if (switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL INIT %d %d\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL INIT %d %d\n",
switch_channel_get_name(channel), switch_channel_get_state(channel), switch_test_flag(tech_pvt, TFLAG_ANSWER)); switch_channel_get_name(channel), switch_channel_get_state(channel), switch_test_flag(tech_pvt, TFLAG_ANSWER));
if (engage_device(tech_pvt->sample_rate, tech_pvt->codec_ms) != SWITCH_STATUS_SUCCESS) { if (engage_device(tech_pvt->sample_rate, tech_pvt->codec_ms) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER); switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -297,40 +287,17 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
switch_channel_set_state(channel, CS_RING); switch_channel_set_state(channel, CS_RING);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_on_ring(switch_core_session_t *session) static switch_status_t channel_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL RING\n", switch_channel_get_name(switch_core_session_get_channel(session)));
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL RING\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_on_execute(switch_core_session_t *session) static switch_status_t channel_on_execute(switch_core_session_t *session)
{ {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL EXECUTE\n", switch_channel_get_name(switch_core_session_get_channel(session)));
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL EXECUTE\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -429,13 +396,7 @@ static void remove_pvt(private_t * tech_pvt)
static switch_status_t channel_on_hangup(switch_core_session_t *session) static switch_status_t channel_on_hangup(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
remove_pvt(tech_pvt); remove_pvt(tech_pvt);
@ -450,20 +411,15 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session)
switch_core_file_close(&tech_pvt->fh); switch_core_file_close(&tech_pvt->fh);
} }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL HANGUP\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL HANGUP\n", switch_channel_get_name(switch_core_session_get_channel(session)));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig) static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
private_t *tech_pvt = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch (sig) { switch (sig) {
@ -476,7 +432,6 @@ static switch_status_t channel_kill_channel(switch_core_session_t *session, int
} }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL KILL\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CHANNEL KILL\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -488,47 +443,24 @@ static switch_status_t channel_on_transmit(switch_core_session_t *session)
static switch_status_t channel_on_loopback(switch_core_session_t *session) static switch_status_t channel_on_loopback(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CHANNEL LOOPBACK\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CHANNEL LOOPBACK\n");
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id) static switch_status_t channel_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
{ {
private_t *tech_pvt = NULL;
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id) static switch_status_t channel_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
{ {
private_t *tech_pvt = NULL;
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf) static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{ {
private_t *tech_pvt = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "DTMF ON CALL %s [%c]\n", tech_pvt->call_id, dtmf->digit); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "DTMF ON CALL %s [%c]\n", tech_pvt->call_id, dtmf->digit);
@ -538,15 +470,9 @@ static switch_status_t channel_send_dtmf(switch_core_session_t *session, const s
static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
switch_channel_t *channel = NULL; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt = NULL;
int samples = 0; int samples = 0;
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!globals.audio_stream) { if (!globals.audio_stream) {
@ -590,7 +516,6 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
hold: hold:
{ {
switch_size_t olen = globals.read_codec.implementation->samples_per_frame; switch_size_t olen = globals.read_codec.implementation->samples_per_frame;
if (switch_core_timer_next(&globals.timer) != SWITCH_STATUS_SUCCESS) { if (switch_core_timer_next(&globals.timer) != SWITCH_STATUS_SUCCESS) {
@ -605,7 +530,6 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
goto cng; goto cng;
} }
tech_pvt->hold_frame.datalen = (uint32_t) (olen * sizeof(int16_t)); tech_pvt->hold_frame.datalen = (uint32_t) (olen * sizeof(int16_t));
tech_pvt->hold_frame.samples = (uint32_t) olen; tech_pvt->hold_frame.samples = (uint32_t) olen;
*frame = &tech_pvt->hold_frame; *frame = &tech_pvt->hold_frame;
@ -642,13 +566,8 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
switch_channel_t *channel = NULL;
private_t *tech_pvt = NULL;
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
channel = switch_core_session_get_channel(session); private_t *tech_pvt = switch_core_session_get_private(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!globals.audio_stream) { if (!globals.audio_stream) {
@ -672,35 +591,18 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc
} }
return status; return status;
} }
static switch_status_t channel_answer_channel(switch_core_session_t *session) static switch_status_t channel_answer_channel(switch_core_session_t *session)
{ {
private_t *tech_pvt;
switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg) static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{ {
switch_channel_t *channel; private_t *tech_pvt = switch_core_session_get_private(session);
private_t *tech_pvt;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch (msg->message_id) { switch (msg->message_id) {
case SWITCH_MESSAGE_INDICATE_ANSWER: case SWITCH_MESSAGE_INDICATE_ANSWER:
channel_answer_channel(session); channel_answer_channel(session);
@ -743,7 +645,6 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
switch_caller_profile_t *outbound_profile, switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags) switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags)
{ {
if ((*new_session = switch_core_session_request(portaudio_endpoint_interface, pool)) != 0) { if ((*new_session = switch_core_session_request(portaudio_endpoint_interface, pool)) != 0) {
private_t *tech_pvt; private_t *tech_pvt;
switch_channel_t *channel; switch_channel_t *channel;
@ -790,7 +691,6 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
} }
return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
} }
@ -817,14 +717,11 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_portaudio_load)
"Input Device: %d, Output Device: %d, Ring Device: %d Sample Rate: %d MS: %d\n", globals.indev, "Input Device: %d, Output Device: %d, Ring Device: %d Sample Rate: %d MS: %d\n", globals.indev,
globals.outdev, globals.ringdev, globals.sample_rate, globals.codec_ms); globals.outdev, globals.ringdev, globals.sample_rate, globals.codec_ms);
switch_core_hash_init(&globals.call_hash, module_pool); switch_core_hash_init(&globals.call_hash, module_pool);
switch_mutex_init(&globals.device_lock, SWITCH_MUTEX_NESTED, module_pool); switch_mutex_init(&globals.device_lock, SWITCH_MUTEX_NESTED, module_pool);
switch_mutex_init(&globals.pvt_lock, SWITCH_MUTEX_NESTED, module_pool); switch_mutex_init(&globals.pvt_lock, SWITCH_MUTEX_NESTED, module_pool);
switch_mutex_init(&globals.flag_mutex, SWITCH_MUTEX_NESTED, module_pool); switch_mutex_init(&globals.flag_mutex, SWITCH_MUTEX_NESTED, module_pool);
if (switch_event_reserve_subclass(MY_EVENT_RINGING) != SWITCH_STATUS_SUCCESS) { if (switch_event_reserve_subclass(MY_EVENT_RINGING) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't register subclass!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't register subclass!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -1043,8 +940,7 @@ static void PrintSupportedStandardSampleRates(const PaStreamParameters * inputPa
int i, printCount, cr = 7; int i, printCount, cr = 7;
PaError err; PaError err;
static double standardSampleRates[] = { 8000.0, 9600.0, 11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0, static double standardSampleRates[] = { 8000.0, 9600.0, 11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0,
44100.0, 48000.0, 88200.0, 96000.0, 192000.0, -1 44100.0, 48000.0, 88200.0, 96000.0, 192000.0, -1};
};
printCount = cr; printCount = cr;
for (i = 0; standardSampleRates[i] > 0; i++) { for (i = 0; standardSampleRates[i] > 0; i++) {
@ -1093,8 +989,6 @@ static int dump_info(void)
PaError err; PaError err;
const char *line = "--------------------------------------------------------------------------------\n"; const char *line = "--------------------------------------------------------------------------------\n";
switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO, switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO,
"PortAudio version number = %d\nPortAudio version text = '%s'\n", Pa_GetVersion(), Pa_GetVersionText()); "PortAudio version number = %d\nPortAudio version text = '%s'\n", Pa_GetVersion(), Pa_GetVersionText());
if (globals.audio_stream) { if (globals.audio_stream) {
@ -1194,8 +1088,6 @@ static int dump_info(void)
return err; return err;
} }
static switch_status_t engage_device(int sample_rate, int codec_ms) static switch_status_t engage_device(int sample_rate, int codec_ms)
{ {
PaStreamParameters inputParameters, outputParameters; PaStreamParameters inputParameters, outputParameters;
@ -1236,13 +1128,9 @@ static switch_status_t engage_device(int sample_rate, int codec_ms)
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
globals.read_frame.rate = sample_rate; globals.read_frame.rate = sample_rate;
globals.read_frame.codec = &globals.read_codec; globals.read_frame.codec = &globals.read_codec;
switch_mutex_lock(globals.device_lock); switch_mutex_lock(globals.device_lock);
/* LOCKED ************************************************************************************************** */ /* LOCKED ************************************************************************************************** */
inputParameters.device = globals.indev; inputParameters.device = globals.indev;
@ -1261,7 +1149,6 @@ static switch_status_t engage_device(int sample_rate, int codec_ms)
/* UNLOCKED ************************************************************************************************* */ /* UNLOCKED ************************************************************************************************* */
switch_mutex_unlock(globals.device_lock); switch_mutex_unlock(globals.device_lock);
if (err != paNoError) { if (err != paNoError) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open audio device!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open audio device!\n");
switch_core_codec_destroy(&globals.read_codec); switch_core_codec_destroy(&globals.read_codec);
@ -1271,14 +1158,9 @@ static switch_status_t engage_device(int sample_rate, int codec_ms)
} }
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t engage_ring_device(int sample_rate, int channels) static switch_status_t engage_ring_device(int sample_rate, int channels)
{ {
PaStreamParameters outputParameters; PaStreamParameters outputParameters;
@ -1301,7 +1183,6 @@ static switch_status_t engage_ring_device(int sample_rate, int channels)
/* UNLOCKED ************************************************************************************************* */ /* UNLOCKED ************************************************************************************************* */
switch_mutex_unlock(globals.device_lock); switch_mutex_unlock(globals.device_lock);
if (err != paNoError) { if (err != paNoError) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open ring device!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open ring device!\n");
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -1312,8 +1193,6 @@ static switch_status_t engage_ring_device(int sample_rate, int channels)
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t dtmf_call(char **argv, int argc, switch_stream_handle_t *stream) static switch_status_t dtmf_call(char **argv, int argc, switch_stream_handle_t *stream)
{ {
char *dtmf_str = argv[0]; char *dtmf_str = argv[0];
@ -1382,7 +1261,6 @@ static switch_status_t switch_call(char **argv, int argc, switch_stream_handle_t
switch_mutex_unlock(globals.pvt_lock); switch_mutex_unlock(globals.pvt_lock);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t hangup_call(char **argv, int argc, switch_stream_handle_t *stream) static switch_status_t hangup_call(char **argv, int argc, switch_stream_handle_t *stream)
@ -1406,7 +1284,6 @@ static switch_status_t hangup_call(char **argv, int argc, switch_stream_handle_t
switch_mutex_unlock(globals.pvt_lock); switch_mutex_unlock(globals.pvt_lock);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t answer_call(char **argv, int argc, switch_stream_handle_t *stream) static switch_status_t answer_call(char **argv, int argc, switch_stream_handle_t *stream)
@ -1446,12 +1323,9 @@ static switch_status_t answer_call(char **argv, int argc, switch_stream_handle_t
} }
done: done:
switch_mutex_unlock(globals.pvt_lock); switch_mutex_unlock(globals.pvt_lock);
stream->write_function(stream, "Answered %d channels.\n", x); stream->write_function(stream, "Answered %d channels.\n", x);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t do_flags(char **argv, int argc, switch_stream_handle_t *stream) static switch_status_t do_flags(char **argv, int argc, switch_stream_handle_t *stream)
@ -1676,19 +1550,9 @@ SWITCH_STANDARD_API(pa_cmd)
http = switch_event_get_header(stream->event, "http-host"); http = switch_event_get_header(stream->event, "http-host");
} }
if (http) { if (http) {
stream->write_function(stream, "Content-type: text/html\n\n"); stream->write_function(stream, "Content-type: text/html\n\n");
#if 0
switch_event_header_t *hp;
stream->write_function(stream, "<pre>");
for (hp = stream->event->headers; hp; hp = hp->next) {
stream->write_function(stream, "[%s]=[%s]\n", hp->name, hp->value);
}
stream->write_function(stream, "</pre>");
#endif
wcmd = switch_str_nil(switch_event_get_header(stream->event, "wcmd")); wcmd = switch_str_nil(switch_event_get_header(stream->event, "wcmd"));
action = switch_event_get_header(stream->event, "action"); action = switch_event_get_header(stream->event, "action");
@ -1815,13 +1679,10 @@ SWITCH_STANDARD_API(pa_cmd)
} }
done: done:
if (http) { if (http) {
stream->write_function(stream, stream->write_function(stream,
"<br><br><table align=center><tr><td><center><form method=post>\n" "<br><br><table align=center><tr><td><center><form method=post>\n"
"<input type=text name=wcmd size=40><br><br>\n" "<input type=text name=wcmd size=40><br><br>\n"
"<input name=action type=submit value=\"call\"> " "<input name=action type=submit value=\"call\"> "
"<input name=action type=submit value=\"hangup\"> " "<input name=action type=submit value=\"hangup\"> "
"<input name=action type=submit value=\"list\"> " "<input name=action type=submit value=\"list\"> "
@ -1856,7 +1717,6 @@ SWITCH_STANDARD_API(pa_cmd)
} }
switch_safe_free(mycmd); switch_safe_free(mycmd);
return status; return status;
} }

145
src/mod/endpoints/mod_sofia/mod_sofia.c
View File

@ -73,13 +73,8 @@ static switch_status_t sofia_kill_channel(switch_core_session_t *session, int si
*/ */
static switch_status_t sofia_on_init(switch_core_session_t *session) static switch_status_t sofia_on_init(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
private_object_t *tech_pvt; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
tech_pvt->read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN; tech_pvt->read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN;
@ -116,18 +111,12 @@ static switch_status_t sofia_on_init(switch_core_session_t *session)
static switch_status_t sofia_on_ring(switch_core_session_t *session) static switch_status_t sofia_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
private_object_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD); switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA RING\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA RING\n", switch_channel_get_name(switch_core_session_get_channel(session)));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -135,18 +124,12 @@ static switch_status_t sofia_on_ring(switch_core_session_t *session)
static switch_status_t sofia_on_reset(switch_core_session_t *session) static switch_status_t sofia_on_reset(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
private_object_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD); switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA RESET\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA RESET\n", switch_channel_get_name(switch_core_session_get_channel(session)));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -154,35 +137,23 @@ static switch_status_t sofia_on_reset(switch_core_session_t *session)
static switch_status_t sofia_on_hibernate(switch_core_session_t *session) static switch_status_t sofia_on_hibernate(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; private_object_t *tech_pvt = switch_core_session_get_private(session);
private_object_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD); switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA HIBERNATE\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA HIBERNATE\n", switch_channel_get_name(switch_core_session_get_channel(session)));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t sofia_on_execute(switch_core_session_t *session) static switch_status_t sofia_on_execute(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
private_object_t *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD); switch_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA EXECUTE\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s SOFIA EXECUTE\n", switch_channel_get_name(switch_core_session_get_channel(session)));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -247,16 +218,10 @@ static int hangup_cause_to_sip(switch_call_cause_t cause)
switch_status_t sofia_on_hangup(switch_core_session_t *session) switch_status_t sofia_on_hangup(switch_core_session_t *session)
{ {
switch_core_session_t *a_session; switch_core_session_t *a_session;
private_object_t *tech_pvt; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_call_cause_t cause; switch_call_cause_t cause;
int sip_cause; int sip_cause;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
if (tech_pvt->profile->rtpip && tech_pvt->local_sdp_audio_port) { if (tech_pvt->profile->rtpip && tech_pvt->local_sdp_audio_port) {
switch_rtp_release_port(tech_pvt->profile->rtpip, tech_pvt->local_sdp_audio_port); switch_rtp_release_port(tech_pvt->profile->rtpip, tech_pvt->local_sdp_audio_port);
@ -364,19 +329,12 @@ static switch_status_t sofia_on_transmit(switch_core_session_t *session)
static switch_status_t sofia_answer_channel(switch_core_session_t *session) static switch_status_t sofia_answer_channel(switch_core_session_t *session)
{ {
private_object_t *tech_pvt; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status; switch_status_t status;
uint32_t session_timeout = 0; uint32_t session_timeout = 0;
const char *val; const char *val;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
if (switch_test_flag(tech_pvt, TFLAG_ANS) || switch_channel_test_flag(channel, CF_OUTBOUND)) { if (switch_test_flag(tech_pvt, TFLAG_ANS) || switch_channel_test_flag(channel, CF_OUTBOUND)) {
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -445,14 +403,10 @@ static switch_status_t sofia_answer_channel(switch_core_session_t *session)
static switch_status_t sofia_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t sofia_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
private_object_t *tech_pvt = NULL; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
int payload = 0; int payload = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (switch_test_flag(tech_pvt, TFLAG_HUP)) { if (switch_test_flag(tech_pvt, TFLAG_HUP)) {
@ -467,10 +421,8 @@ static switch_status_t sofia_read_video_frame(switch_core_session_t *session, sw
} }
} }
tech_pvt->video_read_frame.datalen = 0; tech_pvt->video_read_frame.datalen = 0;
if (switch_test_flag(tech_pvt, TFLAG_IO)) { if (switch_test_flag(tech_pvt, TFLAG_IO)) {
switch_status_t status; switch_status_t status;
@ -512,14 +464,10 @@ static switch_status_t sofia_read_video_frame(switch_core_session_t *session, sw
static switch_status_t sofia_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t sofia_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
private_object_t *tech_pvt; private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
while (!(tech_pvt->video_read_codec.implementation && switch_rtp_ready(tech_pvt->video_rtp_session))) { while (!(tech_pvt->video_read_codec.implementation && switch_rtp_ready(tech_pvt->video_rtp_session))) {
@ -552,14 +500,10 @@ static switch_status_t sofia_write_video_frame(switch_core_session_t *session, s
static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
private_object_t *tech_pvt = NULL; private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
int payload = 0; int payload = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!(tech_pvt->profile->pflags & PFLAG_RUNNING)) { if (!(tech_pvt->profile->pflags & PFLAG_RUNNING)) {
@ -642,15 +586,11 @@ static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_f
static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
private_object_t *tech_pvt; private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
int bytes = 0, samples = 0, frames = 0; int bytes = 0, samples = 0, frames = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
while (!(tech_pvt->read_codec.implementation && switch_rtp_ready(tech_pvt->rtp_session))) { while (!(tech_pvt->read_codec.implementation && switch_rtp_ready(tech_pvt->rtp_session))) {
@ -700,16 +640,10 @@ static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_
static switch_status_t sofia_kill_channel(switch_core_session_t *session, int sig) static switch_status_t sofia_kill_channel(switch_core_session_t *session, int sig)
{ {
private_object_t *tech_pvt; private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch (sig) { switch (sig) {
case SWITCH_SIG_BREAK: case SWITCH_SIG_BREAK:
if (switch_rtp_ready(tech_pvt->rtp_session)) { if (switch_rtp_ready(tech_pvt->rtp_session)) {
@ -737,29 +671,11 @@ static switch_status_t sofia_kill_channel(switch_core_session_t *session, int si
static switch_status_t sofia_waitfor_read(switch_core_session_t *session, int ms, int stream_id) static switch_status_t sofia_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
{ {
private_object_t *tech_pvt;
switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t sofia_waitfor_write(switch_core_session_t *session, int ms, int stream_id) static switch_status_t sofia_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
{ {
private_object_t *tech_pvt;
switch_channel_t *channel = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -792,14 +708,10 @@ static switch_status_t sofia_send_dtmf(switch_core_session_t *session, const swi
static switch_status_t sofia_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg) static switch_status_t sofia_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
private_object_t *tech_pvt; private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_status_t status; switch_status_t status;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (msg->message_id == SWITCH_MESSAGE_INDICATE_ANSWER || msg->message_id == SWITCH_MESSAGE_INDICATE_PROGRESS) { if (msg->message_id == SWITCH_MESSAGE_INDICATE_ANSWER || msg->message_id == SWITCH_MESSAGE_INDICATE_PROGRESS) {
@ -1109,15 +1021,10 @@ static switch_status_t sofia_receive_message(switch_core_session_t *session, swi
static switch_status_t sofia_receive_event(switch_core_session_t *session, switch_event_t *event) static switch_status_t sofia_receive_event(switch_core_session_t *session, switch_event_t *event)
{ {
switch_channel_t *channel; struct private_object *tech_pvt = switch_core_session_get_private(session);
struct private_object *tech_pvt;
char *body; char *body;
nua_handle_t *msg_nh; nua_handle_t *msg_nh;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!(body = switch_event_get_body(event))) { if (!(body = switch_event_get_body(event))) {

35
src/mod/endpoints/mod_sofia/sofia.c
View File

@ -119,12 +119,9 @@ void sofia_handle_sip_i_bye(switch_core_session_t *session, int status,
sip_t const *sip, sip_t const *sip,
tagi_t tags[]) tagi_t tags[])
{ {
switch_channel_t *channel = NULL;
if (session) { if (session) {
const char *tmp; const char *tmp;
switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
if (sip->sip_user_agent && !switch_strlen_zero(sip->sip_user_agent->g_string)){ if (sip->sip_user_agent && !switch_strlen_zero(sip->sip_user_agent->g_string)){
switch_channel_set_variable(channel, "sip_user_agent", sip->sip_user_agent->g_string); switch_channel_set_variable(channel, "sip_user_agent", sip->sip_user_agent->g_string);
} }
@ -1302,8 +1299,6 @@ static void sofia_handle_sip_r_invite(switch_core_session_t *session, int status
char const *phrase, char const *phrase,
nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip, tagi_t tags[]) nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip, tagi_t tags[])
{ {
if (sip && session) { if (sip && session) {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
const char *uuid; const char *uuid;
@ -1437,8 +1432,6 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
if (session) { if (session) {
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_assert(tech_pvt->nh != NULL); switch_assert(tech_pvt->nh != NULL);
@ -1821,22 +1814,19 @@ void sofia_handle_sip_i_refer(nua_t *nua, sofia_profile_t *profile, nua_handle_t
sip_from_t const *from; sip_from_t const *from;
sip_to_t const *to; sip_to_t const *to;
sip_refer_to_t const *refer_to; sip_refer_to_t const *refer_to;
private_object_t *tech_pvt = NULL; private_object_t *tech_pvt = switch_core_session_get_private(session);
char *etmp = NULL, *exten = NULL; char *etmp = NULL, *exten = NULL;
switch_channel_t *channel_a = NULL, *channel_b = NULL; switch_channel_t *channel_a = switch_core_session_get_channel(session);
switch_channel_t *channel_b = NULL;
su_home_t *home = NULL; su_home_t *home = NULL;
char *full_ref_by = NULL; char *full_ref_by = NULL;
char *full_ref_to = NULL; char *full_ref_to = NULL;
tech_pvt = switch_core_session_get_private(session);
channel_a = switch_core_session_get_channel(session);
if (!sip->sip_cseq || !(etmp = switch_mprintf("refer;id=%u", sip->sip_cseq->cs_seq))) { if (!sip->sip_cseq || !(etmp = switch_mprintf("refer;id=%u", sip->sip_cseq->cs_seq))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
goto done; goto done;
} }
if (switch_channel_test_flag(channel_a, CF_BYPASS_MEDIA)) { if (switch_channel_test_flag(channel_a, CF_BYPASS_MEDIA)) {
nua_notify(tech_pvt->nh, NUTAG_NEWSUB(1), SIPTAG_CONTENT_TYPE_STR("message/sipfrag"), nua_notify(tech_pvt->nh, NUTAG_NEWSUB(1), SIPTAG_CONTENT_TYPE_STR("message/sipfrag"),
NUTAG_SUBSTATE(nua_substate_terminated), SIPTAG_PAYLOAD_STR("SIP/2.0 403 Forbidden"), SIPTAG_EVENT_STR(etmp), TAG_END()); NUTAG_SUBSTATE(nua_substate_terminated), SIPTAG_PAYLOAD_STR("SIP/2.0 403 Forbidden"), SIPTAG_EVENT_STR(etmp), TAG_END());
@ -2115,8 +2105,6 @@ void sofia_handle_sip_i_refer(nua_t *nua, sofia_profile_t *profile, nua_handle_t
void sofia_handle_sip_i_info(nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, switch_core_session_t *session, sip_t const *sip, tagi_t tags[]) void sofia_handle_sip_i_info(nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, switch_core_session_t *session, sip_t const *sip, tagi_t tags[])
{ {
struct private_object *tech_pvt = NULL;
switch_channel_t *channel = NULL;
/* placeholder for string searching */ /* placeholder for string searching */
const char *signal_ptr; const char *signal_ptr;
const char *rec_header; const char *rec_header;
@ -2125,14 +2113,10 @@ void sofia_handle_sip_i_info(nua_t *nua, sofia_profile_t *profile, nua_handle_t
if (session) { if (session) {
/* Get the channel */ /* Get the channel */
channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
/* Barf if we didn't get it */
switch_assert(channel != NULL);
/* make sure we have our privates */ /* make sure we have our privates */
tech_pvt = switch_core_session_get_private(session); struct private_object *tech_pvt = switch_core_session_get_private(session);
/* Barf if we didn't get it */ /* Barf if we didn't get it */
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
@ -2219,18 +2203,13 @@ void sofia_handle_sip_i_info(nua_t *nua, sofia_profile_t *profile, nua_handle_t
} }
} }
} }
return; return;
} }
} }
return; return;
fail: fail:
nua_respond(nh, 488, "Unsupported Request", NUTAG_WITH_THIS(nua), TAG_END()); nua_respond(nh, 488, "Unsupported Request", NUTAG_WITH_THIS(nua), TAG_END());
} }

28
src/mod/endpoints/mod_sofia/sofia_glue.c
View File

@ -385,10 +385,8 @@ void sofia_glue_attach_private(switch_core_session_t *session, sofia_profile_t *
tech_pvt->te = profile->te; tech_pvt->te = profile->te;
} }
tech_pvt->dtmf_type = profile->dtmf_type; tech_pvt->dtmf_type = profile->dtmf_type;
if (tech_pvt->bcng_pt) { if (tech_pvt->bcng_pt) {
tech_pvt->cng_pt = tech_pvt->bcng_pt; tech_pvt->cng_pt = tech_pvt->bcng_pt;
} else if (!tech_pvt->cng_pt) { } else if (!tech_pvt->cng_pt) {
@ -399,7 +397,6 @@ void sofia_glue_attach_private(switch_core_session_t *session, sofia_profile_t *
tech_pvt->channel = switch_core_session_get_channel(session); tech_pvt->channel = switch_core_session_get_channel(session);
switch_core_session_set_private(session, tech_pvt); switch_core_session_set_private(session, tech_pvt);
switch_snprintf(name, sizeof(name), "sofia/%s/%s", profile->name, channame); switch_snprintf(name, sizeof(name), "sofia/%s/%s", profile->name, channame);
switch_channel_set_name(tech_pvt->channel, name); switch_channel_set_name(tech_pvt->channel, name);
} }
@ -651,8 +648,8 @@ switch_status_t sofia_glue_do_invite(switch_core_session_t *session)
char *alert_info = NULL; char *alert_info = NULL;
const char *max_forwards = NULL; const char *max_forwards = NULL;
const char *alertbuf; const char *alertbuf;
private_object_t *tech_pvt; private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile;
const char *cid_name, *cid_num; const char *cid_name, *cid_num;
char *e_dest = NULL; char *e_dest = NULL;
@ -665,12 +662,8 @@ switch_status_t sofia_glue_do_invite(switch_core_session_t *session)
const char *val; const char *val;
const char *rep; const char *rep;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
rep = switch_channel_get_variable(channel, SOFIA_REPLACES_HEADER); rep = switch_channel_get_variable(channel, SOFIA_REPLACES_HEADER);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_clear_flag_locked(tech_pvt, TFLAG_SDP); switch_clear_flag_locked(tech_pvt, TFLAG_SDP);
@ -897,14 +890,10 @@ switch_status_t sofia_glue_do_invite(switch_core_session_t *session)
void sofia_glue_do_xfer_invite(switch_core_session_t *session) void sofia_glue_do_xfer_invite(switch_core_session_t *session)
{ {
private_object_t *tech_pvt; private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
caller_profile = switch_channel_get_caller_profile(channel); caller_profile = switch_channel_get_caller_profile(channel);
@ -1497,24 +1486,20 @@ uint8_t sofia_glue_negotiate_sdp(switch_core_session_t *session, sdp_session_t *
{ {
uint8_t match = 0; uint8_t match = 0;
switch_payload_t te = 0, cng_pt = 0; switch_payload_t te = 0, cng_pt = 0;
private_object_t *tech_pvt; private_object_t *tech_pvt = switch_core_session_get_private(session);
sdp_media_t *m; sdp_media_t *m;
sdp_attribute_t *attr; sdp_attribute_t *attr;
int first = 0, last = 0; int first = 0, last = 0;
int ptime = 0, dptime = 0; int ptime = 0, dptime = 0;
int sendonly = 0; int sendonly = 0;
int greedy = 0, x = 0, skip = 0, mine = 0; int greedy = 0, x = 0, skip = 0, mine = 0;
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
const char *val; const char *val;
const char *crypto = NULL; const char *crypto = NULL;
int got_crypto = 0; int got_crypto = 0;
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
greedy = !!(tech_pvt->profile->pflags & PFLAG_GREEDY); greedy = !!(tech_pvt->profile->pflags & PFLAG_GREEDY);
if (!greedy) { if (!greedy) {
@ -1962,7 +1947,6 @@ void sofia_glue_pass_sdp(private_object_t *tech_pvt, char *sdp)
if ((val = switch_channel_get_variable(tech_pvt->channel, SWITCH_SIGNAL_BOND_VARIABLE)) if ((val = switch_channel_get_variable(tech_pvt->channel, SWITCH_SIGNAL_BOND_VARIABLE))
&& (other_session = switch_core_session_locate(val))) { && (other_session = switch_core_session_locate(val))) {
other_channel = switch_core_session_get_channel(other_session); other_channel = switch_core_session_get_channel(other_session);
switch_assert(other_channel != NULL);
switch_channel_set_variable(other_channel, SWITCH_B_SDP_VARIABLE, sdp); switch_channel_set_variable(other_channel, SWITCH_B_SDP_VARIABLE, sdp);
if (!switch_test_flag(tech_pvt, TFLAG_CHANGE_MEDIA) && (switch_channel_test_flag(other_channel, CF_OUTBOUND) && if (!switch_test_flag(tech_pvt, TFLAG_CHANGE_MEDIA) && (switch_channel_test_flag(other_channel, CF_OUTBOUND) &&

3
src/mod/endpoints/mod_sofia/sofia_reg.c
View File

@ -750,8 +750,7 @@ void sofia_reg_handle_sip_r_challenge(int status,
cancel: cancel:
if (session) { if (session) {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_hangup(switch_core_session_get_channel(session), SWITCH_CAUSE_MANDATORY_IE_MISSING);
switch_channel_hangup(channel, SWITCH_CAUSE_MANDATORY_IE_MISSING);
} else { } else {
nua_cancel(nh, TAG_END()); nua_cancel(nh, TAG_END());
} }

138
src/mod/endpoints/mod_woomera/mod_woomera.c
View File

@ -200,16 +200,12 @@ static int tech_activate(private_object * tech_pvt);
*/ */
static switch_status_t woomera_on_init(switch_core_session_t *session) static switch_status_t woomera_on_init(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = switch_core_session_get_private(session);
int rate = 8000; int rate = 8000;
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt->frame.data = tech_pvt->databuf; tech_pvt->frame.data = tech_pvt->databuf;
if (switch_core_codec_init if (switch_core_codec_init
@ -244,53 +240,25 @@ static switch_status_t woomera_on_init(switch_core_session_t *session)
static switch_status_t woomera_on_ring(switch_core_session_t *session) static switch_status_t woomera_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA RING\n", switch_channel_get_name(switch_core_session_get_channel(session)));
struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA RING\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t woomera_on_execute(switch_core_session_t *session) static switch_status_t woomera_on_execute(switch_core_session_t *session)
{ {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA EXECUTE\n", switch_channel_get_name(switch_core_session_get_channel(session)));
switch_channel_t *channel = NULL;
struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA EXECUTE\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
static switch_status_t woomera_on_hangup(switch_core_session_t *session) static switch_status_t woomera_on_hangup(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; struct private_object *tech_pvt = switch_core_session_get_private(session);
struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_core_codec_destroy(&tech_pvt->read_codec); switch_core_codec_destroy(&tech_pvt->read_codec);
switch_core_codec_destroy(&tech_pvt->write_codec); switch_core_codec_destroy(&tech_pvt->write_codec);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA HANGUP\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA HANGUP\n", switch_channel_get_name(switch_core_session_get_channel(session)));
tech_destroy(tech_pvt); tech_destroy(tech_pvt);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
@ -316,13 +284,7 @@ static void udp_socket_close(struct private_object *tech_pvt)
static switch_status_t woomera_kill_channel(switch_core_session_t *session, int sig) static switch_status_t woomera_kill_channel(switch_core_session_t *session, int sig)
{ {
switch_channel_t *channel = NULL; struct private_object *tech_pvt = switch_core_session_get_private(session);
struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!tech_pvt->udp_socket) { if (!tech_pvt->udp_socket) {
@ -332,7 +294,7 @@ static switch_status_t woomera_kill_channel(switch_core_session_t *session, int
switch (sig) { switch (sig) {
case SWITCH_SIG_KILL: case SWITCH_SIG_KILL:
udp_socket_close(tech_pvt); udp_socket_close(tech_pvt);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA KILL\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s WOOMERA KILL\n", switch_channel_get_name(switch_core_session_get_channel(session)));
break; break;
case SWITCH_SIG_BREAK: case SWITCH_SIG_BREAK:
{ {
@ -345,7 +307,6 @@ static switch_status_t woomera_kill_channel(switch_core_session_t *session, int
break; break;
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -384,15 +345,10 @@ static switch_status_t woomera_waitfor_write(switch_core_session_t *session, int
static switch_status_t woomera_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t woomera_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
switch_channel_t *channel = NULL; struct private_object *tech_pvt = switch_core_session_get_private(session);
struct private_object *tech_pvt = NULL;
switch_frame_t *pframe; switch_frame_t *pframe;
switch_size_t len; switch_size_t len;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
for(;;) { for(;;) {
@ -406,15 +362,10 @@ static switch_status_t woomera_read_frame(switch_core_session_t *session, switch
switch_yield(1000); switch_yield(1000);
} }
if (!tech_pvt->udp_socket) { if (!tech_pvt->udp_socket) {
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
} }
/*
if ((status = woomera_waitfor_read(session, -1)) != SWITCH_STATUS_SUCCESS) {
return status;
}1<
*/
pframe = &tech_pvt->frame; pframe = &tech_pvt->frame;
*frame = pframe; *frame = pframe;
@ -430,15 +381,9 @@ static switch_status_t woomera_read_frame(switch_core_session_t *session, switch
static switch_status_t woomera_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id) static switch_status_t woomera_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{ {
switch_channel_t *channel = NULL; struct private_object *tech_pvt = switch_core_session_get_private(session);
struct private_object *tech_pvt = NULL;
switch_size_t len; switch_size_t len;
//switch_frame_t *pframe;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (switch_test_flag(tech_pvt, TFLAG_ABORT) || !tech_pvt->udp_socket) { if (switch_test_flag(tech_pvt, TFLAG_ABORT) || !tech_pvt->udp_socket) {
@ -449,7 +394,6 @@ static switch_status_t woomera_write_frame(switch_core_session_t *session, switc
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
//pframe = &tech_pvt->frame;
len = frame->datalen; len = frame->datalen;
if (switch_socket_sendto(tech_pvt->udp_socket, tech_pvt->udpwrite, 0, frame->data, &len) == SWITCH_STATUS_SUCCESS) { if (switch_socket_sendto(tech_pvt->udp_socket, tech_pvt->udpwrite, 0, frame->data, &len) == SWITCH_STATUS_SUCCESS) {
frame->datalen = (uint32_t) len; frame->datalen = (uint32_t) len;
@ -953,24 +897,17 @@ static int tech_activate(private_object * tech_pvt)
static void *woomera_channel_thread_run(switch_thread_t * thread, void *obj) static void *woomera_channel_thread_run(switch_thread_t * thread, void *obj)
{ {
switch_core_session_t *session = obj; switch_core_session_t *session = obj;
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
struct private_object *tech_pvt = NULL; struct private_object *tech_pvt = switch_core_session_get_private(session);
woomera_message wmsg; woomera_message wmsg;
int res = 0; int res = 0;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
if (!tech_pvt->udp_socket) { if (!tech_pvt->udp_socket) {
tech_create_read_socket(tech_pvt); tech_create_read_socket(tech_pvt);
} }
for (;;) { for (;;) {
if (globals.panic) { if (globals.panic) {
switch_set_flag_locked(tech_pvt, TFLAG_ABORT); switch_set_flag_locked(tech_pvt, TFLAG_ABORT);
@ -1014,18 +951,6 @@ static void *woomera_channel_thread_run(switch_thread_t * thread, void *obj)
memset(tech_pvt->dtmfbuf, 0, sizeof(tech_pvt->dtmfbuf)); memset(tech_pvt->dtmfbuf, 0, sizeof(tech_pvt->dtmfbuf));
switch_mutex_unlock(tech_pvt->iolock); switch_mutex_unlock(tech_pvt->iolock);
} }
#if 1==0 /*convert to use switch_time_now */
if (tech_pvt->timeout) {
struct timeval now;
int elapsed;
gettimeofday(&now, NULL);
elapsed = (((now.tv_sec * 1000) + now.tv_usec / 1000) - ((tech_pvt->started.tv_sec * 1000) + tech_pvt->started.tv_usec / 1000));
if (elapsed > tech_pvt->timeout) {
/* call timed out! */
switch_set_flag_locked(tech_pvt, TFLAG_ABORT);
}
}
#endif
if (!tech_pvt->command_channel) { if (!tech_pvt->command_channel) {
break; break;
@ -1038,17 +963,6 @@ static void *woomera_channel_thread_run(switch_thread_t * thread, void *obj)
switch_set_flag_locked(tech_pvt, TFLAG_ABORT); switch_set_flag_locked(tech_pvt, TFLAG_ABORT);
continue; continue;
} else if (!strcasecmp(wmsg.command, "DTMF")) { } else if (!strcasecmp(wmsg.command, "DTMF")) {
/*
struct ast_frame dtmf_frame = {AST_FRAME_DTMF};
int x = 0;
for (x = 0; x < strlen(wmsg.command_args); x++) {
dtmf_frame.subclass = wmsg.command_args[x];
ast_queue_frame(tech_pvt->owner, ast_frdup(&dtmf_frame));
if (globals.debug > 1) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, WOOMERA_DEBUG_PREFIX "SEND DTMF [%c] to %s\n", dtmf_frame.subclass, tech_pvt->owner->name);
}
}
*/
} else if (!strcasecmp(wmsg.command, "PROCEED")) { } else if (!strcasecmp(wmsg.command, "PROCEED")) {
/* This packet has lots of info so well keep it */ /* This packet has lots of info so well keep it */
tech_pvt->call_info = wmsg; tech_pvt->call_info = wmsg;
@ -1154,12 +1068,8 @@ static void *woomera_channel_thread_run(switch_thread_t * thread, void *obj)
return NULL; return NULL;
} }
static void *woomera_thread_run(void *obj) static void *woomera_thread_run(void *obj)
{ {
int res = 0; int res = 0;
woomera_message wmsg; woomera_message wmsg;
woomera_profile *profile; woomera_profile *profile;
@ -1209,28 +1119,8 @@ static void *woomera_thread_run(void *obj)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ALERT, "{%s} HELP! I lost my connection to woomera!\n", profile->name); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ALERT, "{%s} HELP! I lost my connection to woomera!\n", profile->name);
woomera_socket_close(&profile->woomera_socket); woomera_socket_close(&profile->woomera_socket);
//global_set_flag(TFLAG_ABORT);
globals.panic = 1; globals.panic = 1;
continue; continue;
/* Can't get to the following code --Commented out for now. */
/* if (profile->woomera_socket)
if (switch_test_flag(profile, PFLAG_INBOUND)) {
woomera_printf(profile, profile->woomera_socket, "LISTEN%s", WOOMERA_RECORD_SEPERATOR);
if (woomera_message_parse(profile->woomera_socket,
&wmsg, WOOMERA_HARD_TIMEOUT, profile, &profile->event_queue) < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "{%s} HELP! Woomera is broken!\n",
profile->name);
globals.panic = 1;
woomera_socket_close(&profile->woomera_socket);
}
}
if (profile->woomera_socket) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Woomera Thread Up {%s} %s/%d\n", profile->name,
profile->woomera_host, profile->woomera_port);
}
}*/
//continue;
} }
if (!strcasecmp(wmsg.command, "INCOMING")) { if (!strcasecmp(wmsg.command, "INCOMING")) {
@ -1277,7 +1167,6 @@ static void *woomera_thread_run(void *obj)
switch_yield(100); switch_yield(100);
} }
if (profile->woomera_socket) { if (profile->woomera_socket) {
woomera_printf(profile, profile->woomera_socket, "BYE%s", WOOMERA_RECORD_SEPERATOR); woomera_printf(profile, profile->woomera_socket, "BYE%s", WOOMERA_RECORD_SEPERATOR);
woomera_socket_close(&profile->woomera_socket); woomera_socket_close(&profile->woomera_socket);
@ -1290,7 +1179,6 @@ static void *woomera_thread_run(void *obj)
SWITCH_MODULE_RUNTIME_FUNCTION(mod_woomera_runtime) SWITCH_MODULE_RUNTIME_FUNCTION(mod_woomera_runtime)
{ {
woomera_thread_run(&default_profile); woomera_thread_run(&default_profile);
return SWITCH_STATUS_TERM; return SWITCH_STATUS_TERM;

4
src/mod/event_handlers/mod_event_socket/mod_event_socket.c
View File

@ -653,7 +653,6 @@ static switch_status_t parse_command(listener_t * listener, switch_event_t *even
if (listener->session) { if (listener->session) {
switch_channel_t *channel = switch_core_session_get_channel(listener->session); switch_channel_t *channel = switch_core_session_get_channel(listener->session);
switch_assert(channel != NULL);
if (!strncasecmp(cmd, "connect", 7)) { if (!strncasecmp(cmd, "connect", 7)) {
switch_snprintf(reply, reply_len, "+OK"); switch_snprintf(reply, reply_len, "+OK");
@ -763,8 +762,7 @@ static switch_status_t parse_command(listener_t * listener, switch_event_t *even
} }
if ((session = switch_core_session_locate(uuid))) { if ((session = switch_core_session_locate(uuid))) {
switch_channel_t *channel = switch_core_session_get_channel(session); if (!switch_channel_test_flag(switch_core_session_get_channel(session), CF_CONTROLLED)) {
if (!switch_channel_test_flag(channel, CF_CONTROLLED)) {
switch_core_session_rwunlock(session); switch_core_session_rwunlock(session);
session = NULL; session = NULL;
} }

65
src/mod/languages/mod_spidermonkey/mod_spidermonkey.c
View File

@ -1317,14 +1317,9 @@ static switch_status_t js_collect_input_callback(switch_core_session_t *session,
static JSBool session_flush_digits(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval) static JSBool session_flush_digits(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{ {
struct js_session *jss = JS_GetPrivate(cx, obj); struct js_session *jss = JS_GetPrivate(cx, obj);
switch_channel_t *channel;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); switch_channel_flush_dtmf(switch_core_session_get_channel(jss->session));
switch_assert(channel != NULL);
switch_channel_flush_dtmf(channel);
*rval = BOOLEAN_TO_JSVAL(JS_TRUE); *rval = BOOLEAN_TO_JSVAL(JS_TRUE);
return JS_TRUE; return JS_TRUE;
@ -1334,16 +1329,12 @@ static JSBool session_flush_events(JSContext * cx, JSObject * obj, uintN argc, j
{ {
struct js_session *jss = JS_GetPrivate(cx, obj); struct js_session *jss = JS_GetPrivate(cx, obj);
switch_event_t *event; switch_event_t *event;
switch_channel_t *channel;
if (!jss || !jss->session) { if (!jss || !jss->session) {
*rval = BOOLEAN_TO_JSVAL(JS_FALSE); *rval = BOOLEAN_TO_JSVAL(JS_FALSE);
return JS_TRUE; return JS_TRUE;
} }
channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
while (switch_core_session_dequeue_event(jss->session, &event) == SWITCH_STATUS_SUCCESS) { while (switch_core_session_dequeue_event(jss->session, &event) == SWITCH_STATUS_SUCCESS) {
switch_event_destroy(&event); switch_event_destroy(&event);
} }
@ -1368,10 +1359,7 @@ static JSBool session_recordfile(JSContext * cx, JSObject * obj, uintN argc, jsv
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc > 0) { if (argc > 0) {
@ -1439,10 +1427,7 @@ static JSBool session_collect_input(JSContext * cx, JSObject * obj, uintN argc,
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc > 0) { if (argc > 0) {
@ -1498,10 +1483,7 @@ static JSBool session_sayphrase(JSContext * cx, JSObject * obj, uintN argc, jsva
switch_input_args_t args = { 0 }; switch_input_args_t args = { 0 };
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc > 0) { if (argc > 0) {
@ -1575,16 +1557,11 @@ static void check_hangup_hook(struct js_session *jss)
static switch_status_t hanguphook(switch_core_session_t *session) static switch_status_t hanguphook(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
struct js_session *jss = NULL; struct js_session *jss = NULL;
switch_channel_state_t state;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
state = switch_channel_get_state(channel);
if ((jss = switch_channel_get_private(channel, "jss"))) { if ((jss = switch_channel_get_private(channel, "jss"))) {
switch_channel_state_t state = switch_channel_get_state(channel);
if (jss->hook_state != state) { if (jss->hook_state != state) {
jss->hook_state = state; jss->hook_state = state;
check_hangup_hook(jss); check_hangup_hook(jss);
@ -1604,7 +1581,6 @@ static JSBool session_hanguphook(JSContext * cx, JSObject * obj, uintN argc, jsv
if (argc > 0) { if (argc > 0) {
if ((function = JS_ValueToFunction(cx, argv[0]))) { if ((function = JS_ValueToFunction(cx, argv[0]))) {
switch_channel_t *channel = switch_core_session_get_channel(jss->session); switch_channel_t *channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
jss->on_hangup = function; jss->on_hangup = function;
jss->hook_state = switch_channel_get_state(channel); jss->hook_state = switch_channel_get_state(channel);
switch_channel_set_private(channel, "jss", jss); switch_channel_set_private(channel, "jss", jss);
@ -1634,10 +1610,7 @@ static JSBool session_streamfile(JSContext * cx, JSObject * obj, uintN argc, jsv
char posbuf[35] = ""; char posbuf[35] = "";
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc > 0) { if (argc > 0) {
@ -1700,9 +1673,7 @@ static JSBool session_set_variable(JSContext * cx, JSObject * obj, uintN argc, j
switch_channel_t *channel; switch_channel_t *channel;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
if (argc > 1) { if (argc > 1) {
char *var, *val; char *var, *val;
@ -1729,7 +1700,6 @@ static JSBool session_get_variable(JSContext * cx, JSObject * obj, uintN argc, j
} }
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
if (argc > 0) { if (argc > 0) {
const char *var, *val; const char *var, *val;
@ -1813,8 +1783,6 @@ static JSBool session_speak(JSContext * cx, JSObject * obj, uintN argc, jsval *
*rval = BOOLEAN_TO_JSVAL(JS_FALSE); *rval = BOOLEAN_TO_JSVAL(JS_FALSE);
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc < 3) { if (argc < 3) {
@ -1892,10 +1860,7 @@ static JSBool session_get_digits(JSContext * cx, JSObject * obj, uintN argc, jsv
switch_channel_t *channel; switch_channel_t *channel;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc > 0) { if (argc > 0) {
@ -1958,10 +1923,7 @@ static JSBool session_answer(JSContext * cx, JSObject * obj, uintN argc, jsval *
switch_channel_t *channel; switch_channel_t *channel;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK_ANSWER(); CHANNEL_SANITY_CHECK_ANSWER();
switch_channel_answer(channel); switch_channel_answer(channel);
@ -1974,10 +1936,7 @@ static JSBool session_pre_answer(JSContext * cx, JSObject * obj, uintN argc, jsv
switch_channel_t *channel; switch_channel_t *channel;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK_ANSWER(); CHANNEL_SANITY_CHECK_ANSWER();
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);
@ -2009,14 +1968,10 @@ static JSBool session_cdr(JSContext * cx, JSObject * obj, uintN argc, jsval * ar
static JSBool session_ready(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval) static JSBool session_ready(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{ {
struct js_session *jss = JS_GetPrivate(cx, obj); struct js_session *jss = JS_GetPrivate(cx, obj);
switch_channel_t *channel;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); *rval = BOOLEAN_TO_JSVAL(switch_channel_ready(switch_core_session_get_channel(jss->session)) ? JS_TRUE : JS_FALSE);
switch_assert(channel != NULL);
*rval = BOOLEAN_TO_JSVAL(switch_channel_ready(channel) ? JS_TRUE : JS_FALSE);
return JS_TRUE; return JS_TRUE;
} }
@ -2033,7 +1988,6 @@ static JSBool session_wait_for_media(JSContext * cx, JSObject * obj, uintN argc,
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
started = switch_timestamp_now(); started = switch_timestamp_now();
@ -2072,9 +2026,7 @@ static JSBool session_wait_for_answer(JSContext * cx, JSObject * obj, uintN argc
jsrefcount saveDepth; jsrefcount saveDepth;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
started = switch_timestamp_now(); started = switch_timestamp_now();
@ -2111,10 +2063,7 @@ static JSBool session_execute(JSContext * cx, JSObject * obj, uintN argc, jsval
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL); /* you can execute some apps before you answer CHANNEL_SANITY_CHECK(); */
/* you can execute some apps before you answer */
/* CHANNEL_SANITY_CHECK(); */
if (argc > 0) { if (argc > 0) {
const switch_application_interface_t *application_interface; const switch_application_interface_t *application_interface;
@ -2203,10 +2152,7 @@ static JSBool session_hangup(JSContext * cx, JSObject * obj, uintN argc, jsval *
switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING; switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
METHOD_SANITY_CHECK(); METHOD_SANITY_CHECK();
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
CHANNEL_SANITY_CHECK(); CHANNEL_SANITY_CHECK();
if (argc > 1) { if (argc > 1) {
@ -2542,7 +2488,6 @@ static JSBool session_getProperty(JSContext * cx, JSObject * obj, jsval id, jsva
if (jss && jss->session) { if (jss && jss->session) {
channel = switch_core_session_get_channel(jss->session); channel = switch_core_session_get_channel(jss->session);
switch_assert(channel != NULL);
caller_profile = switch_channel_get_caller_profile(channel); caller_profile = switch_channel_get_caller_profile(channel);
} }

11
src/mod/say/mod_say_de/mod_say_de.c
View File

@ -169,17 +169,12 @@ static char *strip_nonnumerics(char *in, char *out, switch_size_t len)
static switch_status_t de_say_general_count(switch_core_session_t *session, static switch_status_t de_say_general_count(switch_core_session_t *session,
char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args) char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args)
{ {
switch_channel_t *channel;
int in; int in;
int x = 0; int x = 0;
int places[9] = { 0 }; int places[9] = { 0 };
char sbuf[13] = ""; char sbuf[13] = "";
switch_status_t status; switch_status_t status;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) { if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -420,16 +415,10 @@ static switch_status_t de_say_time(switch_core_session_t *session, char *tosay,
static switch_status_t de_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method, static switch_status_t de_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method,
switch_input_args_t *args) switch_input_args_t *args)
{ {
switch_channel_t *channel;
char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */ char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */
char *dollars = NULL; char *dollars = NULL;
char *cents = NULL; char *cents = NULL;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) { if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;

11
src/mod/say/mod_say_en/mod_say_en.c
View File

@ -169,17 +169,12 @@ static char *strip_nonnumerics(char *in, char *out, switch_size_t len)
static switch_status_t en_say_general_count(switch_core_session_t *session, static switch_status_t en_say_general_count(switch_core_session_t *session,
char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args) char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args)
{ {
switch_channel_t *channel;
int in; int in;
int x = 0; int x = 0;
int places[9] = { 0 }; int places[9] = { 0 };
char sbuf[13] = ""; char sbuf[13] = "";
switch_status_t status; switch_status_t status;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) { if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -420,16 +415,10 @@ static switch_status_t en_say_time(switch_core_session_t *session, char *tosay,
static switch_status_t en_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method, static switch_status_t en_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method,
switch_input_args_t *args) switch_input_args_t *args)
{ {
switch_channel_t *channel;
char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */ char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */
char *dollars = NULL; char *dollars = NULL;
char *cents = NULL; char *cents = NULL;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) { if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;

11
src/mod/say/mod_say_es/mod_say_es.c
View File

@ -169,17 +169,12 @@ static char *strip_nonnumerics(char *in, char *out, switch_size_t len)
static switch_status_t es_say_general_count(switch_core_session_t *session, static switch_status_t es_say_general_count(switch_core_session_t *session,
char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args) char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args)
{ {
switch_channel_t *channel;
int in; int in;
int x = 0; int x = 0;
int places[9] = { 0 }; int places[9] = { 0 };
char sbuf[13] = ""; char sbuf[13] = "";
switch_status_t status; switch_status_t status;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) { if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -420,16 +415,10 @@ static switch_status_t es_say_time(switch_core_session_t *session, char *tosay,
static switch_status_t es_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method, static switch_status_t es_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method,
switch_input_args_t *args) switch_input_args_t *args)
{ {
switch_channel_t *channel;
char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */ char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */
char *dollars = NULL; char *dollars = NULL;
char *cents = NULL; char *cents = NULL;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) { if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;

11
src/mod/say/mod_say_fr/mod_say_fr.c
View File

@ -169,17 +169,12 @@ static char *strip_nonnumerics(char *in, char *out, switch_size_t len)
static switch_status_t fr_say_general_count(switch_core_session_t *session, static switch_status_t fr_say_general_count(switch_core_session_t *session,
char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args) char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args)
{ {
switch_channel_t *channel;
int in; int in;
int x = 0; int x = 0;
int places[9] = { 0 }; int places[9] = { 0 };
char sbuf[13] = ""; char sbuf[13] = "";
switch_status_t status; switch_status_t status;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) { if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -420,16 +415,10 @@ static switch_status_t fr_say_time(switch_core_session_t *session, char *tosay,
static switch_status_t fr_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method, static switch_status_t fr_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method,
switch_input_args_t *args) switch_input_args_t *args)
{ {
switch_channel_t *channel;
char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */ char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */
char *dollars = NULL; char *dollars = NULL;
char *cents = NULL; char *cents = NULL;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) { if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;

11
src/mod/say/mod_say_it/mod_say_it.c
View File

@ -169,17 +169,12 @@ static char *strip_nonnumerics(char *in, char *out, switch_size_t len)
static switch_status_t it_say_general_count(switch_core_session_t *session, static switch_status_t it_say_general_count(switch_core_session_t *session,
char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args) char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args)
{ {
switch_channel_t *channel;
int in; int in;
int x = 0; int x = 0;
int places[9] = { 0 }; int places[9] = { 0 };
char sbuf[13] = ""; char sbuf[13] = "";
switch_status_t status; switch_status_t status;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) { if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -420,16 +415,10 @@ static switch_status_t it_say_time(switch_core_session_t *session, char *tosay,
static switch_status_t it_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method, static switch_status_t it_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method,
switch_input_args_t *args) switch_input_args_t *args)
{ {
switch_channel_t *channel;
char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */ char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */
char *dollars = NULL; char *dollars = NULL;
char *cents = NULL; char *cents = NULL;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) { if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;

11
src/mod/say/mod_say_nl/mod_say_nl.c
View File

@ -169,17 +169,12 @@ static char *strip_nonnumerics(char *in, char *out, switch_size_t len)
static switch_status_t nl_say_general_count(switch_core_session_t *session, static switch_status_t nl_say_general_count(switch_core_session_t *session,
char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args) char *tosay, switch_say_type_t type, switch_say_method_t method, switch_input_args_t *args)
{ {
switch_channel_t *channel;
int in; int in;
int x = 0; int x = 0;
int places[9] = { 0 }; int places[9] = { 0 };
char sbuf[13] = ""; char sbuf[13] = "";
switch_status_t status; switch_status_t status;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) { if (!(tosay = strip_commas(tosay, sbuf, sizeof(sbuf))) || strlen(tosay) > 9) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
@ -420,16 +415,10 @@ static switch_status_t nl_say_time(switch_core_session_t *session, char *tosay,
static switch_status_t nl_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method, static switch_status_t nl_say_money(switch_core_session_t *session, char *tosay, switch_say_type_t type, switch_say_method_t method,
switch_input_args_t *args) switch_input_args_t *args)
{ {
switch_channel_t *channel;
char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */ char sbuf[16] = ""; /* enough for 999,999,999,999.99 (w/o the commas or leading $) */
char *dollars = NULL; char *dollars = NULL;
char *cents = NULL; char *cents = NULL;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) { if (strlen(tosay) > 15 || !(tosay = strip_nonnumerics(tosay, sbuf, sizeof(sbuf)))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse Error!\n");
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;

455
src/switch_channel.c
View File

@ -157,7 +157,6 @@ SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(const char *str)
SWITCH_DECLARE(switch_call_cause_t) switch_channel_get_cause(switch_channel_t *channel) SWITCH_DECLARE(switch_call_cause_t) switch_channel_get_cause(switch_channel_t *channel)
{ {
switch_assert(channel != NULL);
return channel->hangup_cause; return channel->hangup_cause;
} }
@ -165,7 +164,6 @@ SWITCH_DECLARE(switch_channel_timetable_t *) switch_channel_get_timetable(switch
{ {
switch_channel_timetable_t *times = NULL; switch_channel_timetable_t *times = NULL;
switch_assert(channel != NULL);
if (channel->caller_profile) { if (channel->caller_profile) {
switch_mutex_lock(channel->profile_mutex); switch_mutex_lock(channel->profile_mutex);
times = channel->caller_profile->times; times = channel->caller_profile->times;
@ -182,9 +180,9 @@ SWITCH_DECLARE(switch_status_t) switch_channel_alloc(switch_channel_t **channel,
if (((*channel) = switch_core_alloc(pool, sizeof(switch_channel_t))) == 0) { if (((*channel) = switch_core_alloc(pool, sizeof(switch_channel_t))) == 0) {
return SWITCH_STATUS_MEMERR; return SWITCH_STATUS_MEMERR;
} }
switch_event_create(&(*channel)->variables, SWITCH_EVENT_MESSAGE); switch_event_create(&(*channel)->variables, SWITCH_EVENT_MESSAGE);
switch_core_hash_init(&(*channel)->private_hash, pool); switch_core_hash_init(&(*channel)->private_hash, pool);
switch_queue_create(&(*channel)->dtmf_queue, 128, pool); switch_queue_create(&(*channel)->dtmf_queue, 128, pool);
@ -201,7 +199,6 @@ SWITCH_DECLARE(switch_size_t) switch_channel_has_dtmf(switch_channel_t *channel)
{ {
switch_size_t has; switch_size_t has;
switch_assert(channel != NULL);
switch_mutex_lock(channel->dtmf_mutex); switch_mutex_lock(channel->dtmf_mutex);
has = switch_queue_size(channel->dtmf_queue); has = switch_queue_size(channel->dtmf_queue);
switch_mutex_unlock(channel->dtmf_mutex); switch_mutex_unlock(channel->dtmf_mutex);
@ -214,8 +211,6 @@ SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *chan
switch_status_t status; switch_status_t status;
void *pop; void *pop;
switch_assert(channel != NULL);
switch_mutex_lock(channel->dtmf_mutex); switch_mutex_lock(channel->dtmf_mutex);
if ((status = switch_core_session_recv_dtmf(channel->session, dtmf) != SWITCH_STATUS_SUCCESS)) { if ((status = switch_core_session_recv_dtmf(channel->session, dtmf) != SWITCH_STATUS_SUCCESS)) {
@ -233,14 +228,14 @@ SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *chan
if (++x > 100) { if (++x > 100) {
status = SWITCH_STATUS_FALSE; status = SWITCH_STATUS_FALSE;
free(dt); free(dt);
goto done; goto done;
} }
} }
} }
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
done: done:
switch_mutex_unlock(channel->dtmf_mutex); switch_mutex_unlock(channel->dtmf_mutex);
@ -255,9 +250,6 @@ SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(switch_channel_
char *string; char *string;
int i, argc; int i, argc;
char *argv[256]; char *argv[256];
switch_assert(channel != NULL);
if (switch_strlen_zero(dtmf_string)) { if (switch_strlen_zero(dtmf_string)) {
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -265,7 +257,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(switch_channel_
string = switch_core_session_strdup(channel->session, dtmf_string); string = switch_core_session_strdup(channel->session, dtmf_string);
argc = switch_separate_string(string, '+', argv, (sizeof(argv) / sizeof(argv[0]))); argc = switch_separate_string(string, '+', argv, (sizeof(argv) / sizeof(argv[0])));
for(i = 0; i < argc; i++) { for(i = 0; i < argc; i++) {
dtmf.duration = SWITCH_DEFAULT_DTMF_DURATION; dtmf.duration = SWITCH_DEFAULT_DTMF_DURATION;
dur = SWITCH_DEFAULT_DTMF_DURATION / 8; dur = SWITCH_DEFAULT_DTMF_DURATION / 8;
@ -281,12 +273,12 @@ SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(switch_channel_
dtmf.digit = *p; dtmf.digit = *p;
if (switch_channel_queue_dtmf(channel, &dtmf) == SWITCH_STATUS_SUCCESS) { if (switch_channel_queue_dtmf(channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Queue dtmf\ndigit=%c ms=%u samples=%u\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Queue dtmf\ndigit=%c ms=%u samples=%u\n",
switch_channel_get_name(channel), dtmf.digit, dur, dtmf.duration); switch_channel_get_name(channel), dtmf.digit, dur, dtmf.duration);
sent++; sent++;
} }
} }
} }
} }
return sent ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE; return sent ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
@ -299,18 +291,17 @@ SWITCH_DECLARE(switch_status_t) switch_channel_dequeue_dtmf(switch_channel_t *ch
switch_dtmf_t *dt; switch_dtmf_t *dt;
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_assert(channel != NULL);
switch_mutex_lock(channel->dtmf_mutex); switch_mutex_lock(channel->dtmf_mutex);
if (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) { if (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
dt = (switch_dtmf_t *) pop; dt = (switch_dtmf_t *) pop;
/* TODO: Shouldn't we be doing a memcpy here? */
*dtmf = *dt; *dtmf = *dt;
free(dt); free(dt);
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
} }
switch_mutex_unlock(channel->dtmf_mutex); switch_mutex_unlock(channel->dtmf_mutex);
if (status == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_DTMF) == SWITCH_STATUS_SUCCESS) { if (status == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_DTMF) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event); switch_channel_event_set_data(channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Digit", "%c", dtmf->digit); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Digit", "%c", dtmf->digit);
@ -405,7 +396,7 @@ SWITCH_DECLARE(const char *) switch_channel_get_variable(switch_channel_t *chann
switch_mutex_lock(channel->profile_mutex); switch_mutex_lock(channel->profile_mutex);
if (!(v = switch_event_get_header(channel->variables, (char*)varname))) { if (!(v = switch_event_get_header(channel->variables, (char*)varname))) {
switch_caller_profile_t *cp = channel->caller_profile; switch_caller_profile_t *cp = channel->caller_profile;
if (cp) { if (cp) {
if (!strncmp(varname, "aleg_", 5)) { if (!strncmp(varname, "aleg_", 5)) {
cp = cp->originator_caller_profile; cp = cp->originator_caller_profile;
@ -433,7 +424,7 @@ SWITCH_DECLARE(void) switch_channel_variable_last(switch_channel_t *channel)
} }
channel->vi = 0; channel->vi = 0;
switch_mutex_unlock(channel->profile_mutex); switch_mutex_unlock(channel->profile_mutex);
} }
SWITCH_DECLARE(switch_event_header_t *) switch_channel_variable_first(switch_channel_t *channel) SWITCH_DECLARE(switch_event_header_t *) switch_channel_variable_first(switch_channel_t *channel)
@ -488,7 +479,7 @@ SWITCH_DECLARE(char *) switch_channel_get_name(switch_channel_t *channel)
SWITCH_DECLARE(switch_status_t) switch_channel_set_variable(switch_channel_t *channel, const char *varname, const char *value) SWITCH_DECLARE(switch_status_t) switch_channel_set_variable(switch_channel_t *channel, const char *varname, const char *value)
{ {
switch_assert(channel != NULL); switch_assert(channel != NULL);
if (!switch_strlen_zero(varname)) { if (!switch_strlen_zero(varname)) {
switch_mutex_lock(channel->profile_mutex); switch_mutex_lock(channel->profile_mutex);
switch_event_del_header(channel->variables, varname); switch_event_del_header(channel->variables, varname);
@ -507,7 +498,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_variable_partner(switch_chann
{ {
const char *uuid; const char *uuid;
switch_assert(channel != NULL); switch_assert(channel != NULL);
if (!switch_strlen_zero(varname)) { if (!switch_strlen_zero(varname)) {
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) { if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) {
switch_core_session_t *session; switch_core_session_t *session;
@ -576,11 +567,11 @@ SWITCH_DECLARE(void) switch_channel_wait_for_state(switch_channel_t *channel, sw
{ {
switch_channel_state_t state, mystate, ostate; switch_channel_state_t state, mystate, ostate;
ostate = switch_channel_get_state(channel); ostate = switch_channel_get_state(channel);
for(;;) { for(;;) {
state = switch_channel_get_running_state(other_channel); state = switch_channel_get_running_state(other_channel);
mystate = switch_channel_get_running_state(channel); mystate = switch_channel_get_running_state(channel);
if (mystate != ostate || state >= CS_HANGUP || state == want_state) { if (mystate != ostate || state >= CS_HANGUP || state == want_state) {
break; break;
} }
@ -611,7 +602,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_wait_for_flag(switch_channel_t *c
return SWITCH_STATUS_TIMEOUT; return SWITCH_STATUS_TIMEOUT;
} }
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -665,10 +656,10 @@ SWITCH_DECLARE(uint8_t) switch_channel_ready(switch_channel_t *channel)
uint8_t ret = 0; uint8_t ret = 0;
switch_assert(channel != NULL); switch_assert(channel != NULL);
if (!channel->hangup_cause && channel->state > CS_RING && channel->state < CS_HANGUP && channel->state != CS_RESET && if (!channel->hangup_cause && channel->state > CS_RING && channel->state < CS_HANGUP && channel->state != CS_RESET &&
!switch_test_flag(channel, CF_TRANSFER)) { !switch_test_flag(channel, CF_TRANSFER)) {
ret++; ret++;
} }
return ret; return ret;
@ -713,19 +704,19 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_running_state(
{ {
switch_mutex_lock(channel->flag_mutex); switch_mutex_lock(channel->flag_mutex);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "%s Running State Change %s\n", switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "%s Running State Change %s\n",
channel->name, state_names[channel->state]); channel->name, state_names[channel->state]);
channel->running_state = channel->state; channel->running_state = channel->state;
if (channel->state_flags) { if (channel->state_flags) {
channel->flags |= channel->state_flags; channel->flags |= channel->state_flags;
channel->state_flags = 0; channel->state_flags = 0;
} }
if (channel->state >= CS_RING) { if (channel->state >= CS_RING) {
switch_clear_flag(channel, CF_TRANSFER); switch_clear_flag(channel, CF_TRANSFER);
switch_channel_presence(channel, "unknown", (char *) state_names[channel->state]); switch_channel_presence(channel, "unknown", (char *) state_names[channel->state]);
} }
if (channel->state < CS_HANGUP) { if (channel->state < CS_HANGUP) {
switch_event_t *event; switch_event_t *event;
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_STATE) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_STATE) == SWITCH_STATUS_SUCCESS) {
@ -778,172 +769,172 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_c
} }
/* STUB for more dev /* STUB for more dev
case CS_INIT:
switch(state) {
case CS_NEW:
case CS_INIT:
case CS_LOOPBACK:
case CS_TRANSMIT:
case CS_RING:
case CS_EXECUTE:
case CS_HANGUP:
case CS_DONE:
default:
break;
}
break;
*/
switch (last_state) {
case CS_NEW:
case CS_RESET:
switch (state) {
default:
ok++;
break;
}
break;
case CS_INIT: case CS_INIT:
switch (state) { switch(state) {
case CS_LOOPBACK:
case CS_TRANSMIT:
case CS_RING:
case CS_EXECUTE:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_NEW:
case CS_INIT:
case CS_LOOPBACK: case CS_LOOPBACK:
switch (state) {
case CS_TRANSMIT:
case CS_RING:
case CS_EXECUTE:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_TRANSMIT: case CS_TRANSMIT:
switch (state) {
case CS_LOOPBACK:
case CS_RING:
case CS_EXECUTE:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_PARK:
switch (state) {
case CS_LOOPBACK:
case CS_RING:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_HIBERNATE:
case CS_RESET:
case CS_HOLD:
ok++;
default:
break;
}
break;
case CS_HOLD:
switch (state) {
case CS_LOOPBACK:
case CS_RING:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_HIBERNATE:
case CS_RESET:
case CS_PARK:
ok++;
default:
break;
}
break;
case CS_HIBERNATE:
switch (state) {
case CS_LOOPBACK:
case CS_INIT:
case CS_RING:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_PARK:
case CS_HOLD:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_RING: case CS_RING:
switch (state) {
case CS_LOOPBACK:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_EXECUTE: case CS_EXECUTE:
switch (state) {
case CS_LOOPBACK:
case CS_TRANSMIT:
case CS_RING:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_HANGUP: case CS_HANGUP:
switch (state) { case CS_DONE:
case CS_DONE:
ok++;
default:
break;
}
break;
default: default:
break; break;
}
break;
*/
switch (last_state) {
case CS_NEW:
case CS_RESET:
switch (state) {
default:
ok++;
break;
}
break;
case CS_INIT:
switch (state) {
case CS_LOOPBACK:
case CS_TRANSMIT:
case CS_RING:
case CS_EXECUTE:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_LOOPBACK:
switch (state) {
case CS_TRANSMIT:
case CS_RING:
case CS_EXECUTE:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_TRANSMIT:
switch (state) {
case CS_LOOPBACK:
case CS_RING:
case CS_EXECUTE:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_PARK:
switch (state) {
case CS_LOOPBACK:
case CS_RING:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_HIBERNATE:
case CS_RESET:
case CS_HOLD:
ok++;
default:
break;
}
break;
case CS_HOLD:
switch (state) {
case CS_LOOPBACK:
case CS_RING:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_HIBERNATE:
case CS_RESET:
case CS_PARK:
ok++;
default:
break;
}
break;
case CS_HIBERNATE:
switch (state) {
case CS_LOOPBACK:
case CS_INIT:
case CS_RING:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_PARK:
case CS_HOLD:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_RING:
switch (state) {
case CS_LOOPBACK:
case CS_EXECUTE:
case CS_TRANSMIT:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_EXECUTE:
switch (state) {
case CS_LOOPBACK:
case CS_TRANSMIT:
case CS_RING:
case CS_PARK:
case CS_HOLD:
case CS_HIBERNATE:
case CS_RESET:
ok++;
default:
break;
}
break;
case CS_HANGUP:
switch (state) {
case CS_DONE:
ok++;
default:
break;
}
break;
default:
break;
} }
if (ok) { if (ok) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "%s State Change %s -> %s\n", switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "%s State Change %s -> %s\n",
channel->name, state_names[last_state], state_names[state]); channel->name, state_names[last_state], state_names[state]);
switch_mutex_lock(channel->flag_mutex); switch_mutex_lock(channel->flag_mutex);
channel->state = state; channel->state = state;
switch_mutex_unlock(channel->flag_mutex); switch_mutex_unlock(channel->flag_mutex);
@ -957,7 +948,7 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_c
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_WARNING, switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_WARNING,
"%s Invalid State Change %s -> %s\n", channel->name, state_names[last_state], state_names[state]); "%s Invalid State Change %s -> %s\n", channel->name, state_names[last_state], state_names[state]);
/* we won't tolerate an invalid state change so we can make sure we are as robust as a nice cup of dark coffee! */ /* we won't tolerate an invalid state change so we can make sure we are as robust as a nice cup of dark coffee! */
if (channel->state < CS_HANGUP) { if (channel->state < CS_HANGUP) {
@ -965,7 +956,7 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_set_state(switch_c
switch_assert(0); switch_assert(0);
} }
} }
done: done:
switch_mutex_unlock(channel->flag_mutex); switch_mutex_unlock(channel->flag_mutex);
return channel->state; return channel->state;
@ -1014,7 +1005,7 @@ SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel_t *channel, sw
if (caller_profile) { if (caller_profile) {
switch_caller_profile_event_set_data(caller_profile, "Caller", event); switch_caller_profile_event_set_data(caller_profile, "Caller", event);
} }
if (originator_caller_profile && originatee_caller_profile) { if (originator_caller_profile && originatee_caller_profile) {
/* Index Originator's Profile */ /* Index Originator's Profile */
switch_caller_profile_event_set_data(originator_caller_profile, "Originator", event); switch_caller_profile_event_set_data(originator_caller_profile, "Originator", event);
@ -1038,7 +1029,7 @@ SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel_t *channel, sw
vvar = (char *) hi->name; vvar = (char *) hi->name;
vval = (char *) hi->value; vval = (char *) hi->value;
x++; x++;
switch_assert(vvar && vval); switch_assert(vvar && vval);
switch_snprintf(buf, sizeof(buf), "variable_%s", vvar); switch_snprintf(buf, sizeof(buf), "variable_%s", vvar);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, buf, "%s", vval); switch_event_add_header(event, SWITCH_STACK_BOTTOM, buf, "%s", vval);
@ -1055,9 +1046,9 @@ SWITCH_DECLARE(void) switch_channel_set_caller_profile(switch_channel_t *channel
switch_assert(channel->session != NULL); switch_assert(channel->session != NULL);
switch_mutex_lock(channel->profile_mutex); switch_mutex_lock(channel->profile_mutex);
switch_assert(caller_profile != NULL); switch_assert(caller_profile != NULL);
uuid = switch_core_session_get_uuid(channel->session); uuid = switch_core_session_get_uuid(channel->session);
if (!caller_profile->uuid || strcasecmp(caller_profile->uuid, uuid)) { if (!caller_profile->uuid || strcasecmp(caller_profile->uuid, uuid)) {
caller_profile->uuid = switch_core_session_strdup(channel->session, uuid); caller_profile->uuid = switch_core_session_strdup(channel->session, uuid);
} }
@ -1144,7 +1135,7 @@ SWITCH_DECLARE(switch_caller_profile_t *) switch_channel_get_originator_caller_p
profile = channel->caller_profile->originator_caller_profile; profile = channel->caller_profile->originator_caller_profile;
} }
switch_mutex_unlock(channel->profile_mutex); switch_mutex_unlock(channel->profile_mutex);
return profile; return profile;
} }
@ -1158,7 +1149,7 @@ SWITCH_DECLARE(switch_caller_profile_t *) switch_channel_get_originatee_caller_p
profile = channel->caller_profile->originatee_caller_profile; profile = channel->caller_profile->originatee_caller_profile;
} }
switch_mutex_unlock(channel->profile_mutex); switch_mutex_unlock(channel->profile_mutex);
return profile; return profile;
} }
@ -1190,7 +1181,7 @@ SWITCH_DECLARE(int) switch_channel_add_state_handler(switch_channel_t *channel,
channel->state_handlers[index] = state_handler; channel->state_handlers[index] = state_handler;
end: end:
switch_mutex_unlock(channel->flag_mutex); switch_mutex_unlock(channel->flag_mutex);
return index; return index;
} }
@ -1281,15 +1272,15 @@ SWITCH_DECLARE(switch_channel_state_t) switch_channel_perform_hangup(switch_chan
} }
switch_channel_stop_broadcast(channel); switch_channel_stop_broadcast(channel);
if (channel->state < CS_HANGUP) { if (channel->state < CS_HANGUP) {
switch_event_t *event; switch_event_t *event;
switch_channel_state_t last_state = channel->state; switch_channel_state_t last_state = channel->state;
channel->state = CS_HANGUP; channel->state = CS_HANGUP;
channel->hangup_cause = hangup_cause; channel->hangup_cause = hangup_cause;
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_NOTICE, "Hangup %s [%s] [%s]\n", switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_NOTICE, "Hangup %s [%s] [%s]\n",
channel->name, state_names[last_state], switch_channel_cause2str(channel->hangup_cause)); channel->name, state_names[last_state], switch_channel_cause2str(channel->hangup_cause));
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_HANGUP) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_HANGUP) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Hangup-Cause", "%s", switch_channel_cause2str(channel->hangup_cause)); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Hangup-Cause", "%s", switch_channel_cause2str(channel->hangup_cause));
switch_channel_event_set_data(channel, event); switch_channel_event_set_data(channel, event);
@ -1339,12 +1330,12 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_pre_answered(switch_
} }
/* if we're the child of another channel and the other channel is in a blocking read they will never realize we have answered so send /* if we're the child of another channel and the other channel is in a blocking read they will never realize we have answered so send
a SWITCH_SIG_BREAK to interrupt any blocking reads on that channel a SWITCH_SIG_BREAK to interrupt any blocking reads on that channel
*/ */
if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE)) if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE))
&& (other_session = switch_core_session_locate(uuid))) { && (other_session = switch_core_session_locate(uuid))) {
switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK); switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK);
switch_core_session_rwunlock(other_session); switch_core_session_rwunlock(other_session);
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -1442,12 +1433,12 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_answered(switch_chan
} }
/* if we're the child of another channel and the other channel is in a blocking read they will never realize we have answered so send /* if we're the child of another channel and the other channel is in a blocking read they will never realize we have answered so send
a SWITCH_SIG_BREAK to interrupt any blocking reads on that channel a SWITCH_SIG_BREAK to interrupt any blocking reads on that channel
*/ */
if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE)) if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE))
&& (other_session = switch_core_session_locate(uuid))) { && (other_session = switch_core_session_locate(uuid))) {
switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK); switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK);
switch_core_session_rwunlock(other_session); switch_core_session_rwunlock(other_session);
} }
switch_channel_set_variable(channel, "endpoint_disposition", "ANSWER"); switch_channel_set_variable(channel, "endpoint_disposition", "ANSWER");
@ -1485,14 +1476,14 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_answer(switch_channel_t *
} }
#define resize(l) {\ #define resize(l) {\
char *dp;\ char *dp;\
olen += (len + l + block);\ olen += (len + l + block);\
cpos = c - data;\ cpos = c - data;\
if ((dp = realloc(data, olen))) {\ if ((dp = realloc(data, olen))) {\
data = dp;\ data = dp;\
c = data + cpos;\ c = data + cpos;\
memset(c, 0, olen - cpos);\ memset(c, 0, olen - cpos);\
}} \ }} \
SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel, const char *in) SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel, const char *in)
{ {
@ -1509,7 +1500,7 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
if (!(p = strchr(q, '$'))) { if (!(p = strchr(q, '$'))) {
break; break;
} }
if (*(p-1) == '\\') { if (*(p-1) == '\\') {
q = p + 1; q = p + 1;
continue; continue;
@ -1519,11 +1510,11 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
q = p + 1; q = p + 1;
continue; continue;
} }
nv = 1; nv = 1;
break; break;
} }
if (!nv) { if (!nv) {
return (char *)in; return (char *)in;
} }
@ -1537,7 +1528,7 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
c = data; c = data;
for (p = indup; p && *p; p++) { for (p = indup; p && *p; p++) {
vtype = 0; vtype = 0;
if (*p == '\\') { if (*p == '\\') {
if (*(p + 1) == '$') { if (*(p + 1) == '$') {
nv = 1; nv = 1;
@ -1595,11 +1586,11 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
br--; br--;
} }
} }
e++; e++;
} }
p = e; p = e;
if ((vval = strchr(vname, '('))) { if ((vval = strchr(vname, '('))) {
e = vval - 1; e = vval - 1;
*vval++ = '\0'; *vval++ = '\0';
@ -1642,11 +1633,11 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
ooffset = atoi(ptr); ooffset = atoi(ptr);
} }
} }
sub_val = switch_channel_get_variable(channel, vname); sub_val = switch_channel_get_variable(channel, vname);
if (offset || ooffset) { if (offset || ooffset) {
cloned_sub_val = strdup(sub_val); cloned_sub_val = strdup(sub_val);
switch_assert(cloned_sub_val); switch_assert(cloned_sub_val);
sub_val = cloned_sub_val; sub_val = cloned_sub_val;
} }
@ -1690,10 +1681,10 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
} else { } else {
free(stream.data); free(stream.data);
} }
switch_safe_free(expanded); switch_safe_free(expanded);
switch_safe_free(expanded_vname); switch_safe_free(expanded_vname);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
free(data); free(data);
@ -1737,7 +1728,7 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
} }
} }
free(indup); free(indup);
return data; return data;
} }
@ -1765,7 +1756,7 @@ SWITCH_DECLARE(char *) switch_channel_build_param_string(switch_channel_t *chann
} }
switch_assert(caller_profile != NULL); switch_assert(caller_profile != NULL);
prof[0] = caller_profile->context; prof[0] = caller_profile->context;
prof[1] = caller_profile->destination_number; prof[1] = caller_profile->destination_number;
prof[2] = caller_profile->caller_id_name; prof[2] = caller_profile->caller_id_name;
@ -1777,7 +1768,7 @@ SWITCH_DECLARE(char *) switch_channel_build_param_string(switch_channel_t *chann
prof[8] = caller_profile->source; prof[8] = caller_profile->source;
prof[9] = caller_profile->chan_name; prof[9] = caller_profile->chan_name;
prof[10] = caller_profile->uuid; prof[10] = caller_profile->uuid;
prof_names[0] = "context"; prof_names[0] = "context";
prof_names[1] = "destination_number"; prof_names[1] = "destination_number";
prof_names[2] = "caller_id_name"; prof_names[2] = "caller_id_name";
@ -1814,13 +1805,13 @@ SWITCH_DECLARE(char *) switch_channel_build_param_string(switch_channel_t *chann
for (; hi; hi = hi->next) { for (; hi; hi = hi->next) {
char *var = hi->name; char *var = hi->name;
char *val = hi->value; char *val = hi->value;
new_len = (strlen((char *) var) * 3) + 1; new_len = (strlen((char *) var) * 3) + 1;
if (encode_len < new_len) { if (encode_len < new_len) {
char *tmp; char *tmp;
encode_len = new_len; encode_len = new_len;
tmp = realloc(encode_buf, encode_len); tmp = realloc(encode_buf, encode_len);
switch_assert(tmp); switch_assert(tmp);
encode_buf = tmp; encode_buf = tmp;
@ -1864,7 +1855,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(switch_channel_t *
if (!switch_strlen_zero(caller_profile->caller_id_name)) { if (!switch_strlen_zero(caller_profile->caller_id_name)) {
cid_buf = switch_core_session_sprintf(channel->session, "\"%s\" <%s>", caller_profile->caller_id_name, cid_buf = switch_core_session_sprintf(channel->session, "\"%s\" <%s>", caller_profile->caller_id_name,
switch_str_nil(caller_profile->caller_id_number)); switch_str_nil(caller_profile->caller_id_number));
} else { } else {
cid_buf = caller_profile->caller_id_number; cid_buf = caller_profile->caller_id_number;
} }
@ -1874,7 +1865,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(switch_channel_t *
last_app = ap->app; last_app = ap->app;
last_arg = ap->arg; last_arg = ap->arg;
} }
if (caller_profile->times) { if (caller_profile->times) {
switch_time_exp_t tm; switch_time_exp_t tm;
switch_size_t retsize; switch_size_t retsize;
@ -1909,7 +1900,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(switch_channel_t *
switch_channel_set_variable(channel, "profile_start_epoch", tmp); switch_channel_set_variable(channel, "profile_start_epoch", tmp);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->profile_created); switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->profile_created);
switch_channel_set_variable(channel, "profile_start_uepoch", tmp); switch_channel_set_variable(channel, "profile_start_uepoch", tmp);
tt_answered = (time_t) (caller_profile->times->answered / 1000000); tt_answered = (time_t) (caller_profile->times->answered / 1000000);
mtt_answered = (time_t) (caller_profile->times->answered / 1000); mtt_answered = (time_t) (caller_profile->times->answered / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_answered); switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_answered);
@ -1928,7 +1919,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(switch_channel_t *
uduration = caller_profile->times->hungup - caller_profile->times->created; uduration = caller_profile->times->hungup - caller_profile->times->created;
duration = (int32_t)(tt_hungup - tt_created); duration = (int32_t)(tt_hungup - tt_created);
mduration = (int32_t)(mtt_hungup - mtt_created); mduration = (int32_t)(mtt_hungup - mtt_created);
if (caller_profile->times->answered) { if (caller_profile->times->answered) {
billsec = (int32_t)(tt_hungup - tt_answered); billsec = (int32_t)(tt_hungup - tt_answered);
billmsec = (int32_t)(mtt_hungup - mtt_answered); billmsec = (int32_t)(mtt_hungup - mtt_answered);
@ -1952,7 +1943,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_set_timestamps(switch_channel_t *
switch_snprintf(tmp, sizeof(tmp), "%d", legbillsec); switch_snprintf(tmp, sizeof(tmp), "%d", legbillsec);
switch_channel_set_variable(channel, "flow_billsec", tmp); switch_channel_set_variable(channel, "flow_billsec", tmp);
switch_snprintf(tmp, sizeof(tmp), "%d", mduration); switch_snprintf(tmp, sizeof(tmp), "%d", mduration);
switch_channel_set_variable(channel, "mduration", tmp); switch_channel_set_variable(channel, "mduration", tmp);

1
src/switch_core.c
View File

@ -184,7 +184,6 @@ static void *switch_core_service_thread(switch_thread_t * thread, void *obj)
switch_assert(thread != NULL); switch_assert(thread != NULL);
switch_assert(session != NULL); switch_assert(session != NULL);
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_set_flag(channel, CF_SERVICE); switch_channel_set_flag(channel, CF_SERVICE);
while (data->running > 0) { while (data->running > 0) {

10
src/switch_core_codec.c
View File

@ -38,12 +38,9 @@
SWITCH_DECLARE(switch_status_t) switch_core_session_set_read_codec(switch_core_session_t *session, switch_codec_t *codec) SWITCH_DECLARE(switch_status_t) switch_core_session_set_read_codec(switch_core_session_t *session, switch_codec_t *codec)
{ {
switch_event_t *event; switch_event_t *event;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
char tmp[30]; char tmp[30];
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(session->channel, event); switch_channel_event_set_data(session->channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-name", "%s", codec->implementation->iananame); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-read-codec-name", "%s", codec->implementation->iananame);
@ -75,12 +72,9 @@ SWITCH_DECLARE(switch_codec_t *) switch_core_session_get_read_codec(switch_core_
SWITCH_DECLARE(switch_status_t) switch_core_session_set_write_codec(switch_core_session_t *session, switch_codec_t *codec) SWITCH_DECLARE(switch_status_t) switch_core_session_set_write_codec(switch_core_session_t *session, switch_codec_t *codec)
{ {
switch_event_t *event; switch_event_t *event;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
char tmp[30]; char tmp[30];
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(session->channel, event); switch_channel_event_set_data(session->channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-write-codec-name", "%s", codec->implementation->iananame); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-write-codec-name", "%s", codec->implementation->iananame);

40
src/switch_core_session.c
View File

@ -77,7 +77,6 @@ SWITCH_DECLARE(void) switch_core_session_hupall(switch_call_cause_t cause)
switch_hash_index_t *hi; switch_hash_index_t *hi;
void *val; void *val;
switch_core_session_t *session; switch_core_session_t *session;
switch_channel_t *channel;
uint32_t loops = 0; uint32_t loops = 0;
switch_mutex_lock(runtime.throttle_mutex); switch_mutex_lock(runtime.throttle_mutex);
@ -86,10 +85,7 @@ SWITCH_DECLARE(void) switch_core_session_hupall(switch_call_cause_t cause)
if (val) { if (val) {
session = (switch_core_session_t *) val; session = (switch_core_session_t *) val;
switch_core_session_read_lock(session); switch_core_session_read_lock(session);
switch_channel_hangup(switch_core_session_get_channel(session), cause);
channel = switch_core_session_get_channel(session);
switch_channel_hangup(channel, cause);
switch_core_session_rwunlock(session); switch_core_session_rwunlock(session);
} }
} }
@ -255,7 +251,6 @@ SWITCH_DECLARE(switch_call_cause_t) switch_core_session_outgoing_channel(switch_
switch_event_t *event; switch_event_t *event;
switch_channel_t *peer_channel = switch_core_session_get_channel(*new_session); switch_channel_t *peer_channel = switch_core_session_get_channel(*new_session);
if (session && channel) { if (session && channel) {
profile = switch_channel_get_caller_profile(channel); profile = switch_channel_get_caller_profile(channel);
} }
@ -363,14 +358,9 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_pass_indication(switch_core_
switch_core_session_message_t msg = {0}; switch_core_session_message_t msg = {0};
switch_core_session_t *other_session; switch_core_session_t *other_session;
const char *uuid; const char *uuid;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE)) && (other_session = switch_core_session_locate(uuid))) { if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE)) && (other_session = switch_core_session_locate(uuid))) {
msg.message_id = indication; msg.message_id = indication;
msg.from = __FILE__; msg.from = __FILE__;
@ -556,14 +546,8 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_private_event(switch
{ {
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
void *pop; void *pop;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_channel_test_flag(channel, CF_EVENT_LOCK)) { if (switch_channel_test_flag(channel, CF_EVENT_LOCK)) {
return status; return status;
} }
@ -579,12 +563,9 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_private_event(switch
SWITCH_DECLARE(void) switch_core_session_reset(switch_core_session_t *session, switch_bool_t flush_dtmf) SWITCH_DECLARE(void) switch_core_session_reset(switch_core_session_t *session, switch_bool_t flush_dtmf)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_size_t has; switch_size_t has;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
/* clear resamplers*/ /* clear resamplers*/
switch_resample_destroy(&session->read_resampler); switch_resample_destroy(&session->read_resampler);
switch_resample_destroy(&session->write_resampler); switch_resample_destroy(&session->write_resampler);
@ -609,6 +590,7 @@ SWITCH_DECLARE(void) switch_core_session_reset(switch_core_session_t *session, s
SWITCH_DECLARE(switch_channel_t *) switch_core_session_get_channel(switch_core_session_t *session) SWITCH_DECLARE(switch_channel_t *) switch_core_session_get_channel(switch_core_session_t *session)
{ {
switch_assert(session->channel);
return session->channel; return session->channel;
} }
@ -906,7 +888,6 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_exec(switch_core_session_t *
const switch_application_interface_t *application_interface, const char *arg) { const switch_application_interface_t *application_interface, const char *arg) {
switch_app_log_t *log, *lp; switch_app_log_t *log, *lp;
switch_event_t *event; switch_event_t *event;
switch_channel_t *channel;
if (!arg) { if (!arg) {
arg = ""; arg = "";
@ -914,8 +895,6 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_exec(switch_core_session_t *
log = switch_core_session_alloc(session, sizeof(*log)); log = switch_core_session_alloc(session, sizeof(*log));
switch_assert(log != NULL);
log->app = switch_core_session_strdup(session, application_interface->interface_name); log->app = switch_core_session_strdup(session, application_interface->interface_name);
log->arg = switch_core_session_strdup(session, arg); log->arg = switch_core_session_strdup(session, arg);
@ -934,8 +913,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_exec(switch_core_session_t *
switch_event_fire(&event); switch_event_fire(&event);
} }
channel = switch_core_session_get_channel(session); switch_channel_clear_flag(session->channel, CF_BREAK);
switch_channel_clear_flag(channel, CF_BREAK);
switch_assert(application_interface->application_function); switch_assert(application_interface->application_function);
@ -958,14 +936,12 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_execute_exten(switch_core_se
int argc, x, count = 0; int argc, x, count = 0;
char *expanded = NULL; char *expanded = NULL;
switch_caller_profile_t *profile, *new_profile, *pp; switch_caller_profile_t *profile, *new_profile, *pp;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_dialplan_interface_t *dialplan_interface = NULL; switch_dialplan_interface_t *dialplan_interface = NULL;
switch_caller_extension_t *extension = NULL; switch_caller_extension_t *extension = NULL;
const switch_application_interface_t *application_interface; const switch_application_interface_t *application_interface;
switch_event_t *event; switch_event_t *event;
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
channel = switch_core_session_get_channel(session);
if (!(profile = switch_channel_get_caller_profile(channel))) { if (!(profile = switch_channel_get_caller_profile(channel))) {
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -1085,9 +1061,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_execute_exten(switch_core_se
} }
done: done:
session->stack_count--; session->stack_count--;
return status; return status;
} }

36
src/switch_cpp.cpp
View File

@ -72,7 +72,7 @@ CoreSession::~CoreSession()
if (session) { if (session) {
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
if (channel && switch_test_flag(this, S_HUP)) { if (switch_test_flag(this, S_HUP)) {
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING); switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
} }
switch_core_session_rwunlock(session); switch_core_session_rwunlock(session);
@ -300,11 +300,8 @@ bool CoreSession::ready() {
} }
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
assert(channel != NULL);
return switch_channel_ready(channel) != 0; return switch_channel_ready(channel) != 0;
} }
int CoreSession::originate(CoreSession *a_leg_session, int CoreSession::originate(CoreSession *a_leg_session,
@ -380,7 +377,6 @@ int CoreSession::flushEvents()
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
assert(channel != NULL);
while (switch_core_session_dequeue_event(session, &event) == SWITCH_STATUS_SUCCESS) { while (switch_core_session_dequeue_event(session, &event) == SWITCH_STATUS_SUCCESS) {
switch_event_destroy(&event); switch_event_destroy(&event);
@ -390,14 +386,7 @@ int CoreSession::flushEvents()
int CoreSession::flushDigits() int CoreSession::flushDigits()
{ {
switch_channel_t *channel; switch_channel_flush_dtmf(switch_core_session_get_channel(session));
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
switch_channel_flush_dtmf(channel);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -451,12 +440,10 @@ void CoreSession::setHangupHook(void *hangup_func) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CoreSession::seHangupHook, hangup_func: %p\n", hangup_func); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CoreSession::seHangupHook, hangup_func: %p\n", hangup_func);
on_hangup = hangup_func; on_hangup = hangup_func;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
assert(channel != NULL);
hook_state = switch_channel_get_state(channel); hook_state = switch_channel_get_state(channel);
switch_channel_set_private(channel, "CoreSession", this); switch_channel_set_private(channel, "CoreSession", this);
switch_core_event_hook_add_state_change(session, hanguphook); switch_core_event_hook_add_state_change(session, hanguphook);
} }
/** \brief Store a file handle in the callback args /** \brief Store a file handle in the callback args
@ -530,19 +517,13 @@ void bridge(CoreSession &session_a, CoreSession &session_b)
switch_status_t hanguphook(switch_core_session_t *session_hungup) switch_status_t hanguphook(switch_core_session_t *session_hungup)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session_hungup);
CoreSession *coresession = NULL; CoreSession *coresession = NULL;
switch_channel_state_t state; switch_channel_state_t state = switch_channel_get_state(channel);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "hangup_hook called\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "hangup_hook called\n");
fflush(stdout); fflush(stdout);
channel = switch_core_session_get_channel(session_hungup);
assert(channel != NULL);
state = switch_channel_get_state(channel);
if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) { if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) {
if (coresession->hook_state != state) { if (coresession->hook_state != state) {
coresession->hook_state = state; coresession->hook_state = state;
@ -560,16 +541,13 @@ switch_status_t dtmf_callback(switch_core_session_t *session_cb,
void *buf, void *buf,
unsigned int buflen) { unsigned int buflen) {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session_cb);
CoreSession *coresession = NULL; CoreSession *coresession = NULL;
switch_status_t result; switch_status_t result;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "dtmf_callback called\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "dtmf_callback called\n");
fflush(stdout); fflush(stdout);
channel = switch_core_session_get_channel(session_cb);
assert(channel != NULL);
coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"); coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession");
if (!coresession) { if (!coresession) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid CoreSession\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid CoreSession\n");
@ -585,8 +563,6 @@ switch_status_t dtmf_callback(switch_core_session_t *session_cb,
} }
switch_status_t process_callback_result(char *ret, switch_status_t process_callback_result(char *ret,
struct input_callback_state *cb_state, struct input_callback_state *cb_state,
switch_core_session_t *session) switch_core_session_t *session)

75
src/switch_ivr.c
View File

@ -40,17 +40,12 @@
SWITCH_DECLARE(switch_status_t) switch_ivr_sleep(switch_core_session_t *session, uint32_t ms) SWITCH_DECLARE(switch_status_t) switch_ivr_sleep(switch_core_session_t *session, uint32_t ms)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_time_t start, now, done = switch_timestamp_now() + (ms * 1000); switch_time_t start = switch_timestamp_now(), now, done = switch_timestamp_now() + (ms * 1000);
switch_frame_t *read_frame; switch_frame_t *read_frame;
int32_t left, elapsed; int32_t left, elapsed;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
start = switch_timestamp_now();
for (;;) { for (;;) {
now = switch_timestamp_now(); now = switch_timestamp_now();
elapsed = (int32_t) ((now - start) / 1000); elapsed = (int32_t) ((now - start) / 1000);
@ -121,12 +116,9 @@ static void unicast_thread_launch(switch_unicast_conninfo_t *conninfo)
SWITCH_DECLARE(switch_status_t) switch_ivr_deactivate_unicast(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_deactivate_unicast(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_unicast_conninfo_t *conninfo; switch_unicast_conninfo_t *conninfo;
int sanity = 0; int sanity = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!switch_channel_test_flag(channel, CF_UNICAST)) { if (!switch_channel_test_flag(channel, CF_UNICAST)) {
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -159,14 +151,10 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_activate_unicast(switch_core_session_
char *transport, char *transport,
char *flags) char *flags)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_unicast_conninfo_t *conninfo; switch_unicast_conninfo_t *conninfo = switch_core_session_alloc(session, sizeof(*conninfo));
switch_codec_t *read_codec; switch_codec_t *read_codec;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
conninfo = switch_core_session_alloc(session, sizeof(*conninfo));
switch_assert(conninfo != NULL); switch_assert(conninfo != NULL);
conninfo->local_ip = switch_core_session_strdup(session, local_ip); conninfo->local_ip = switch_core_session_strdup(session, local_ip);
@ -270,9 +258,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_parse_event(switch_core_session_t *se
char *event_lock = switch_event_get_header(event, "event-lock"); char *event_lock = switch_event_get_header(event, "event-lock");
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_assert(channel != NULL);
switch_assert(event != NULL);
if (switch_strlen_zero(cmd)) { if (switch_strlen_zero(cmd)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Command!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Command!\n");
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -382,10 +367,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_parse_event(switch_core_session_t *se
SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_events(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_events(switch_core_session_t *session)
{ {
switch_event_t *event; switch_event_t *event;
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
while (switch_core_session_dequeue_private_event(session, &event) == SWITCH_STATUS_SUCCESS) { while (switch_core_session_dequeue_private_event(session, &event) == SWITCH_STATUS_SUCCESS) {
switch_ivr_parse_event(session, event); switch_ivr_parse_event(session, event);
@ -399,16 +380,13 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_events(switch_core_session_
SWITCH_DECLARE(switch_status_t) switch_ivr_park(switch_core_session_t *session, switch_input_args_t *args) SWITCH_DECLARE(switch_status_t) switch_ivr_park(switch_core_session_t *session, switch_input_args_t *args)
{ {
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_frame_t *read_frame; switch_frame_t *read_frame;
int stream_id = 0; int stream_id = 0;
switch_event_t *event; switch_event_t *event;
switch_unicast_conninfo_t *conninfo = NULL; switch_unicast_conninfo_t *conninfo = NULL;
switch_codec_t *read_codec = switch_core_session_get_read_codec(session); switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!switch_channel_test_flag(channel, CF_ANSWERED)) { if (!switch_channel_test_flag(channel, CF_ANSWERED)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Careful, Channel is unanswered. Pre-answering...\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Careful, Channel is unanswered. Pre-answering...\n");
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);
@ -536,14 +514,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_park(switch_core_session_t *session,
SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_callback(switch_core_session_t *session, switch_input_args_t *args, uint32_t timeout) SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_callback(switch_core_session_t *session, switch_input_args_t *args, uint32_t timeout)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_time_t started = 0; switch_time_t started = 0;
uint32_t elapsed; uint32_t elapsed;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!args->input_callback) { if (!args->input_callback) {
return SWITCH_STATUS_GENERR; return SWITCH_STATUS_GENERR;
} }
@ -606,15 +581,12 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_count(switch_core_sess
uint32_t abs_timeout) uint32_t abs_timeout)
{ {
switch_size_t i = 0, x = strlen(buf); switch_size_t i = 0, x = strlen(buf);
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_FALSE; switch_status_t status = SWITCH_STATUS_FALSE;
switch_time_t started = 0, digit_started = 0; switch_time_t started = 0, digit_started = 0;
uint32_t abs_elapsed = 0, digit_elapsed = 0; uint32_t abs_elapsed = 0, digit_elapsed = 0;
uint32_t eff_timeout = 0; uint32_t eff_timeout = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (terminator != NULL) if (terminator != NULL)
*terminator = '\0'; *terminator = '\0';
@ -709,14 +681,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_count(switch_core_sess
SWITCH_DECLARE(switch_status_t) switch_ivr_hold(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_hold(switch_core_session_t *session)
{ {
switch_core_session_message_t msg = { 0 }; switch_core_session_message_t msg = { 0 };
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
msg.message_id = SWITCH_MESSAGE_INDICATE_HOLD; msg.message_id = SWITCH_MESSAGE_INDICATE_HOLD;
msg.from = __FILE__; msg.from = __FILE__;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_set_flag(channel, CF_HOLD); switch_channel_set_flag(channel, CF_HOLD);
switch_channel_set_flag(channel, CF_SUSPEND); switch_channel_set_flag(channel, CF_SUSPEND);
@ -740,14 +709,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_hold_uuid(const char *uuid)
SWITCH_DECLARE(switch_status_t) switch_ivr_unhold(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_unhold(switch_core_session_t *session)
{ {
switch_core_session_message_t msg = { 0 }; switch_core_session_message_t msg = { 0 };
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
msg.message_id = SWITCH_MESSAGE_INDICATE_UNHOLD; msg.message_id = SWITCH_MESSAGE_INDICATE_UNHOLD;
msg.from = __FILE__; msg.from = __FILE__;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_clear_flag(channel, CF_HOLD); switch_channel_clear_flag(channel, CF_HOLD);
switch_channel_clear_flag(channel, CF_SUSPEND); switch_channel_clear_flag(channel, CF_SUSPEND);
@ -782,7 +748,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_media(const char *uuid, switch_media_
if ((session = switch_core_session_locate(uuid))) { if ((session = switch_core_session_locate(uuid))) {
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_ORIGINATOR)) { if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_ORIGINATOR)) {
swap = 1; swap = 1;
} }
@ -834,7 +800,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_nomedia(const char *uuid, switch_medi
if ((session = switch_core_session_locate(uuid))) { if ((session = switch_core_session_locate(uuid))) {
status = SWITCH_STATUS_SUCCESS; status = SWITCH_STATUS_SUCCESS;
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_ORIGINATOR)) { if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_ORIGINATOR)) {
swap = 1; swap = 1;
@ -846,7 +811,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_nomedia(const char *uuid, switch_medi
if ((flags & SMF_REBRIDGE) && (other_uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE)) && if ((flags & SMF_REBRIDGE) && (other_uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE)) &&
(other_session = switch_core_session_locate(other_uuid))) { (other_session = switch_core_session_locate(other_uuid))) {
other_channel = switch_core_session_get_channel(other_session); other_channel = switch_core_session_get_channel(other_session);
switch_assert(other_channel != NULL);
switch_core_session_receive_message(other_session, &msg); switch_core_session_receive_message(other_session, &msg);
switch_channel_clear_state_handler(other_channel, NULL); switch_channel_clear_state_handler(other_channel, NULL);
@ -870,19 +834,14 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_nomedia(const char *uuid, switch_medi
SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_t *session, const char *extension, const char *dialplan, const char *context) SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_t *session, const char *extension, const char *dialplan, const char *context)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *profile, *new_profile; switch_caller_profile_t *profile, *new_profile;
switch_core_session_message_t msg = { 0 }; switch_core_session_message_t msg = { 0 };
switch_core_session_t *other_session; switch_core_session_t *other_session;
switch_channel_t *other_channel = NULL; switch_channel_t *other_channel = NULL;
const char *uuid = NULL; const char *uuid = NULL;
switch_assert(session != NULL);
switch_core_session_reset(session, SWITCH_TRUE); switch_core_session_reset(session, SWITCH_TRUE);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_clear_flag(channel, CF_ORIGINATING); switch_channel_clear_flag(channel, CF_ORIGINATING);
/* clear all state handlers */ /* clear all state handlers */
@ -930,7 +889,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_
if (uuid && (other_session = switch_core_session_locate(uuid))) { if (uuid && (other_session = switch_core_session_locate(uuid))) {
other_channel = switch_core_session_get_channel(other_session); other_channel = switch_core_session_get_channel(other_session);
switch_assert(other_channel != NULL);
switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BOND_VARIABLE, NULL); switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BOND_VARIABLE, NULL);
switch_core_session_rwunlock(other_session); switch_core_session_rwunlock(other_session);
} }
@ -938,7 +896,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_session_transfer(switch_core_session_
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE)) if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
&& (other_session = switch_core_session_locate(uuid))) { && (other_session = switch_core_session_locate(uuid))) {
other_channel = switch_core_session_get_channel(other_session); other_channel = switch_core_session_get_channel(other_session);
switch_assert(other_channel != NULL);
switch_channel_set_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL); switch_channel_set_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL);
switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL); switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL);
@ -1339,7 +1296,7 @@ SWITCH_DECLARE(int) switch_ivr_set_xml_chan_vars(switch_xml_t xml, switch_channe
SWITCH_DECLARE(switch_status_t) switch_ivr_generate_xml_cdr(switch_core_session_t *session, switch_xml_t * xml_cdr) SWITCH_DECLARE(switch_status_t) switch_ivr_generate_xml_cdr(switch_core_session_t *session, switch_xml_t * xml_cdr)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *caller_profile; switch_caller_profile_t *caller_profile;
switch_xml_t variables, cdr, x_main_cp, x_caller_profile, x_caller_extension, x_times, time_tag, switch_xml_t variables, cdr, x_main_cp, x_caller_profile, x_caller_extension, x_times, time_tag,
x_application, x_callflow, x_inner_extension, x_apps, x_o; x_application, x_callflow, x_inner_extension, x_apps, x_o;
@ -1347,9 +1304,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_generate_xml_cdr(switch_core_session_
char tmp[512]; char tmp[512];
int cdr_off = 0, v_off = 0; int cdr_off = 0, v_off = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!(cdr = switch_xml_new("cdr"))) { if (!(cdr = switch_xml_new("cdr"))) {
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
@ -1553,7 +1507,7 @@ SWITCH_DECLARE(void) switch_ivr_delay_echo(switch_core_session_t *session, uint3
stfu_frame_t *jb_frame; stfu_frame_t *jb_frame;
switch_frame_t *read_frame, write_frame = { 0 }; switch_frame_t *read_frame, write_frame = { 0 };
switch_status_t status; switch_status_t status;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
uint32_t interval, samples; uint32_t interval, samples;
uint32_t ts = 0; uint32_t ts = 0;
@ -1570,7 +1524,6 @@ SWITCH_DECLARE(void) switch_ivr_delay_echo(switch_core_session_t *session, uint3
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Setting delay to %dms (%d frames)\n", delay_ms, qlen); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Setting delay to %dms (%d frames)\n", delay_ms, qlen);
jb = stfu_n_init(qlen); jb = stfu_n_init(qlen);
channel = switch_core_session_get_channel(session);
write_frame.codec = read_codec; write_frame.codec = read_codec;
while(switch_channel_ready(channel)) { while(switch_channel_ready(channel)) {

137
src/switch_ivr_async.c
View File

@ -251,7 +251,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_displace_session(switch_core_ses
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((bug = switch_channel_get_private(channel, file))) { if ((bug = switch_channel_get_private(channel, file))) {
switch_channel_set_private(channel, file, NULL); switch_channel_set_private(channel, file, NULL);
switch_core_media_bug_remove(session, &bug); switch_core_media_bug_remove(session, &bug);
@ -263,16 +262,13 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_displace_session(switch_core_ses
SWITCH_DECLARE(switch_status_t) switch_ivr_displace_session(switch_core_session_t *session, const char *file, uint32_t limit, const char *flags) SWITCH_DECLARE(switch_status_t) switch_ivr_displace_session(switch_core_session_t *session, const char *file, uint32_t limit, const char *flags)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_codec_t *read_codec; switch_codec_t *read_codec;
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_status_t status; switch_status_t status;
time_t to = 0; time_t to = 0;
displace_helper_t *dh; displace_helper_t *dh;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((bug = switch_channel_get_private(channel, file))) { if ((bug = switch_channel_get_private(channel, file))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Only 1 of the same file per channel please!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Only 1 of the same file per channel please!\n");
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -350,14 +346,9 @@ static switch_bool_t record_callback(switch_media_bug_t *bug, void *user_data, s
case SWITCH_ABC_TYPE_READ: case SWITCH_ABC_TYPE_READ:
if (fh) { if (fh) {
switch_size_t len; switch_size_t len;
switch_core_session_t *session; switch_core_session_t *session = switch_core_media_bug_get_session(bug);
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
session = switch_core_media_bug_get_session(bug);
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_core_media_bug_read(bug, &frame) == SWITCH_STATUS_SUCCESS) { if (switch_core_media_bug_read(bug, &frame) == SWITCH_STATUS_SUCCESS) {
int doit = 1; int doit = 1;
if (!switch_channel_test_flag(channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bug, SMBF_RECORD_ANSWER_REQ)) { if (!switch_channel_test_flag(channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bug, SMBF_RECORD_ANSWER_REQ)) {
@ -384,13 +375,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_record_session(switch_core_sessi
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((bug = switch_channel_get_private(channel, file))) { if ((bug = switch_channel_get_private(channel, file))) {
switch_channel_set_private(channel, file, NULL); switch_channel_set_private(channel, file, NULL);
switch_core_media_bug_remove(session, &bug); switch_core_media_bug_remove(session, &bug);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
@ -673,17 +662,15 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_eavesdrop_session(switch_core_session
SWITCH_DECLARE(switch_status_t) switch_ivr_record_session(switch_core_session_t *session, char *file, uint32_t limit, switch_file_handle_t *fh) SWITCH_DECLARE(switch_status_t) switch_ivr_record_session(switch_core_session_t *session, char *file, uint32_t limit, switch_file_handle_t *fh)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_codec_t *read_codec; switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
const char *p; const char *p;
const char *vval; const char *vval;
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_status_t status; switch_status_t status;
time_t to = 0; time_t to = 0;
switch_media_bug_flag_t flags = SMBF_READ_STREAM | SMBF_WRITE_STREAM; switch_media_bug_flag_t flags = SMBF_READ_STREAM | SMBF_WRITE_STREAM;
uint8_t channels; uint8_t channels = read_codec->implementation->number_of_channels;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((bug = switch_channel_get_private(channel, file))) { if ((bug = switch_channel_get_private(channel, file))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Only 1 of the same file per channel please!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Only 1 of the same file per channel please!\n");
@ -696,11 +683,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_record_session(switch_core_session_t
} }
} }
read_codec = switch_core_session_get_read_codec(session);
switch_assert(read_codec != NULL);
channels = read_codec->implementation->number_of_channels;
if ((p = switch_channel_get_variable(channel, "RECORD_STEREO")) && switch_true(p)) { if ((p = switch_channel_get_variable(channel, "RECORD_STEREO")) && switch_true(p)) {
flags |= SMBF_STEREO; flags |= SMBF_STEREO;
channels = 2; channels = 2;
@ -713,7 +695,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_record_session(switch_core_session_t
fh->channels = channels; fh->channels = channels;
fh->samplerate = read_codec->implementation->actual_samples_per_second; fh->samplerate = read_codec->implementation->actual_samples_per_second;
if (switch_core_file_open(fh, if (switch_core_file_open(fh,
file, file,
channels, channels,
@ -791,7 +772,6 @@ static switch_bool_t inband_dtmf_callback(switch_media_bug_t *bug, void *user_da
char digit_str[80]; char digit_str[80];
switch_channel_t *channel = switch_core_session_get_channel(pvt->session); switch_channel_t *channel = switch_core_session_get_channel(pvt->session);
switch_assert(channel != NULL);
frame.data = data; frame.data = data;
frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE; frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
@ -830,29 +810,22 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_inband_dtmf_session(switch_core_
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((bug = switch_channel_get_private(channel, "dtmf"))) { if ((bug = switch_channel_get_private(channel, "dtmf"))) {
switch_channel_set_private(channel, "dtmf", NULL); switch_channel_set_private(channel, "dtmf", NULL);
switch_core_media_bug_remove(session, &bug); switch_core_media_bug_remove(session, &bug);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
SWITCH_DECLARE(switch_status_t) switch_ivr_inband_dtmf_session(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_inband_dtmf_session(switch_core_session_t *session)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_codec_t *read_codec; switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_status_t status; switch_status_t status;
switch_inband_dtmf_t *pvt; switch_inband_dtmf_t *pvt;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
read_codec = switch_core_session_get_read_codec(session);
switch_assert(read_codec != NULL); switch_assert(read_codec != NULL);
if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) { if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) {
@ -899,11 +872,10 @@ static int teletone_dtmf_generate_handler(teletone_generation_session_t * ts, te
static switch_status_t generate_on_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf) static switch_status_t generate_on_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{ {
switch_media_bug_t *bug;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_media_bug_t *bug = switch_channel_get_private(channel, "dtmf_generate");
if ((bug = (switch_media_bug_t *) switch_channel_get_private(channel, "dtmf_generate"))) { if (bug) {
switch_inband_dtmf_generate_t *pvt = (switch_inband_dtmf_generate_t *) switch_core_media_bug_get_user_data(bug); switch_inband_dtmf_generate_t *pvt = (switch_inband_dtmf_generate_t *) switch_core_media_bug_get_user_data(bug);
if (pvt) { if (pvt) {
@ -977,11 +949,10 @@ static switch_bool_t inband_dtmf_generate_callback(switch_media_bug_t *bug, void
SWITCH_DECLARE(switch_status_t) switch_ivr_stop_inband_dtmf_generate_session(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_stop_inband_dtmf_generate_session(switch_core_session_t *session)
{ {
switch_media_bug_t *bug;
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_media_bug_t *bug = switch_channel_get_private(channel, "dtmf_generate");
switch_assert(channel != NULL); if (bug) {
if ((bug = switch_channel_get_private(channel, "dtmf_generate"))) {
switch_channel_set_private(channel, "dtmf_generate", NULL); switch_channel_set_private(channel, "dtmf_generate", NULL);
switch_core_media_bug_remove(session, &bug); switch_core_media_bug_remove(session, &bug);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
@ -993,16 +964,12 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_inband_dtmf_generate_session(swi
SWITCH_DECLARE(switch_status_t) switch_ivr_inband_dtmf_generate_session(switch_core_session_t *session, switch_bool_t read_stream) SWITCH_DECLARE(switch_status_t) switch_ivr_inband_dtmf_generate_session(switch_core_session_t *session, switch_bool_t read_stream)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_codec_t *read_codec; switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
switch_media_bug_t *bug; switch_media_bug_t *bug;
switch_status_t status; switch_status_t status;
switch_inband_dtmf_generate_t *pvt; switch_inband_dtmf_generate_t *pvt;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
read_codec = switch_core_session_get_read_codec(session);
switch_assert(read_codec != NULL); switch_assert(read_codec != NULL);
if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) { if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) {
@ -1105,17 +1072,14 @@ static switch_bool_t tone_detect_callback(switch_media_bug_t *bug, void *user_da
SWITCH_DECLARE(switch_status_t) switch_ivr_stop_tone_detect_session(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_stop_tone_detect_session(switch_core_session_t *session)
{ {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_tone_container_t *cont; switch_tone_container_t *cont = switch_channel_get_private(channel, "_tone_detect_");
switch_assert(channel != NULL); if (cont) {
if ((cont = switch_channel_get_private(channel, "_tone_detect_"))) {
switch_channel_set_private(channel, "_tone_detect_", NULL); switch_channel_set_private(channel, "_tone_detect_", NULL);
switch_core_media_bug_remove(session, &cont->bug); switch_core_media_bug_remove(session, &cont->bug);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
SWITCH_DECLARE(switch_status_t) switch_ivr_tone_detect_session(switch_core_session_t *session, SWITCH_DECLARE(switch_status_t) switch_ivr_tone_detect_session(switch_core_session_t *session,
@ -1123,19 +1087,14 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_tone_detect_session(switch_core_sessi
const char *flags, time_t timeout, const char *flags, time_t timeout,
const char *app, const char *data) const char *app, const char *data)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_codec_t *read_codec; switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
switch_status_t status; switch_status_t status;
switch_tone_container_t *cont = NULL; switch_tone_container_t *cont = switch_channel_get_private(channel, "_tone_detect_");
char *p, *next; char *p, *next;
int i = 0, ok = 0; int i = 0, ok = 0;
switch_media_bug_flag_t bflags = 0; switch_media_bug_flag_t bflags = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
read_codec = switch_core_session_get_read_codec(session);
switch_assert(read_codec != NULL); switch_assert(read_codec != NULL);
if (switch_strlen_zero(key)) { if (switch_strlen_zero(key)) {
@ -1143,7 +1102,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_tone_detect_session(switch_core_sessi
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
if ((cont = switch_channel_get_private(channel, "_tone_detect_"))) { if (cont) {
if (cont->index >= MAX_TONES) { if (cont->index >= MAX_TONES) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Max Tones Reached!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Max Tones Reached!\n");
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -1190,7 +1149,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_tone_detect_session(switch_core_sessi
if (!ok) { if (!ok) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid tone spec!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid tone spec!\n");
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
cont->list[cont->index].key = switch_core_session_strdup(session, key); cont->list[cont->index].key = switch_core_session_strdup(session, key);
@ -1220,7 +1178,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_tone_detect_session(switch_core_sessi
} }
} }
if ((status = switch_core_media_bug_add(session, tone_detect_callback, cont, timeout, bflags, &cont->bug)) != SWITCH_STATUS_SUCCESS) { if ((status = switch_core_media_bug_add(session, tone_detect_callback, cont, timeout, bflags, &cont->bug)) != SWITCH_STATUS_SUCCESS) {
return status; return status;
} }
@ -1250,7 +1207,6 @@ static void *SWITCH_THREAD_FUNC speech_thread(switch_thread_t * thread, void *ob
switch_thread_cond_create(&sth->cond, sth->pool); switch_thread_cond_create(&sth->cond, sth->pool);
switch_mutex_init(&sth->mutex, SWITCH_MUTEX_NESTED, sth->pool); switch_mutex_init(&sth->mutex, SWITCH_MUTEX_NESTED, sth->pool);
switch_core_session_read_lock(sth->session); switch_core_session_read_lock(sth->session);
switch_mutex_lock(sth->mutex); switch_mutex_lock(sth->mutex);
@ -1267,7 +1223,6 @@ static void *SWITCH_THREAD_FUNC speech_thread(switch_thread_t * thread, void *ob
goto done; goto done;
} }
if (switch_event_create(&event, SWITCH_EVENT_DETECTED_SPEECH) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_DETECTED_SPEECH) == SWITCH_STATUS_SUCCESS) {
if (status == SWITCH_STATUS_SUCCESS) { if (status == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Speech-Type", "detected-speech"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Speech-Type", "detected-speech");
@ -1372,28 +1327,24 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_detect_speech(switch_core_sessio
SWITCH_DECLARE(switch_status_t) switch_ivr_pause_detect_speech(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_pause_detect_speech(switch_core_session_t *session)
{ {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
struct speech_thread_handle *sth; struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
switch_assert(channel != NULL); if (sth) {
if ((sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
switch_core_asr_pause(sth->ah); switch_core_asr_pause(sth->ah);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
SWITCH_DECLARE(switch_status_t) switch_ivr_resume_detect_speech(switch_core_session_t *session) SWITCH_DECLARE(switch_status_t) switch_ivr_resume_detect_speech(switch_core_session_t *session)
{ {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
struct speech_thread_handle *sth; struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
switch_assert(channel != NULL); if (sth) {
if ((sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
switch_core_asr_resume(sth->ah); switch_core_asr_resume(sth->ah);
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
@ -1401,20 +1352,17 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech_load_grammar(switch_cor
{ {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE; switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
struct speech_thread_handle *sth; struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
switch_assert(channel != NULL); if (sth) {
if ((sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
if (switch_core_asr_load_grammar(sth->ah, grammar, path) != SWITCH_STATUS_SUCCESS) { if (switch_core_asr_load_grammar(sth->ah, grammar, path) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error loading Grammar\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error loading Grammar\n");
switch_core_asr_close(sth->ah, &flags); switch_core_asr_close(sth->ah, &flags);
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER); switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
@ -1422,20 +1370,17 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech_unload_grammar(switch_c
{ {
switch_channel_t *channel = switch_core_session_get_channel(session); switch_channel_t *channel = switch_core_session_get_channel(session);
switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE; switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
struct speech_thread_handle *sth; struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
switch_assert(channel != NULL); if (sth) {
if ((sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
if (switch_core_asr_unload_grammar(sth->ah, grammar) != SWITCH_STATUS_SUCCESS) { if (switch_core_asr_unload_grammar(sth->ah, grammar) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error unloading Grammar\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error unloading Grammar\n");
switch_core_asr_close(sth->ah, &flags); switch_core_asr_close(sth->ah, &flags);
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER); switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
@ -1446,12 +1391,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech(switch_core_session_t *
const char *dest, const char *dest,
switch_asr_handle_t *ah) switch_asr_handle_t *ah)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_codec_t *read_codec; switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
switch_status_t status; switch_status_t status;
switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE; switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
struct speech_thread_handle *sth; struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
const char *val;
if (!ah) { if (!ah) {
if (!(ah = switch_core_session_alloc(session, sizeof(*ah)))) { if (!(ah = switch_core_session_alloc(session, sizeof(*ah)))) {
@ -1459,18 +1403,13 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech(switch_core_session_t *
} }
} }
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
read_codec = switch_core_session_get_read_codec(session);
switch_assert(read_codec != NULL); switch_assert(read_codec != NULL);
if ((switch_channel_get_variable(channel, "fire_asr_events"))) {
if ((val = switch_channel_get_variable(channel, "fire_asr_events"))) {
switch_set_flag(ah, SWITCH_ASR_FLAG_FIRE_EVENTS); switch_set_flag(ah, SWITCH_ASR_FLAG_FIRE_EVENTS);
} }
if ((sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) { if (sth) {
if (switch_core_asr_load_grammar(sth->ah, grammar, path) != SWITCH_STATUS_SUCCESS) { if (switch_core_asr_load_grammar(sth->ah, grammar, path) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error loading Grammar\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error loading Grammar\n");
switch_core_asr_close(sth->ah, &flags); switch_core_asr_close(sth->ah, &flags);
@ -1497,7 +1436,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech(switch_core_session_t *
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
sth = switch_core_session_alloc(session, sizeof(*sth)); sth = switch_core_session_alloc(session, sizeof(*sth));
sth->pool = switch_core_session_get_pool(session); sth->pool = switch_core_session_get_pool(session);
sth->session = session; sth->session = session;
@ -1680,15 +1618,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_broadcast(const char *uuid, const cha
switch_assert(path); switch_assert(path);
if (!(session = switch_core_session_locate(uuid))) { if (!(master = session = switch_core_session_locate(uuid))) {
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "uuid [%s] does not match an existing session.\n", switch_str_nil(uuid));
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
master = session;
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((switch_channel_test_flag(channel, CF_EVENT_PARSE))) { if ((switch_channel_test_flag(channel, CF_EVENT_PARSE))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Channel [%s] already broadcasting...broadcast aborted\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Channel [%s] already broadcasting...broadcast aborted\n",
@ -1699,7 +1633,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_broadcast(const char *uuid, const cha
mypath = strdup(path); mypath = strdup(path);
if ((nomedia = switch_channel_test_flag(channel, CF_BYPASS_MEDIA))) { if ((nomedia = switch_channel_test_flag(channel, CF_BYPASS_MEDIA))) {
switch_ivr_media(uuid, SMF_REBRIDGE); switch_ivr_media(uuid, SMF_REBRIDGE);
} }

69
src/switch_ivr_bridge.c
View File

@ -231,14 +231,11 @@ static void *audio_bridge_thread(switch_thread_t * thread, void *obj)
static switch_status_t audio_bridge_on_loopback(switch_core_session_t *session) static switch_status_t audio_bridge_on_loopback(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_ivr_bridge_data_t *bd; switch_ivr_bridge_data_t *bd = switch_channel_get_private(channel, "_bridge_");
switch_channel_state_t state; switch_channel_state_t state;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((bd = (switch_ivr_bridge_data_t *) switch_channel_get_private(channel, "_bridge_"))) { if (bd) {
switch_channel_set_private(channel, "_bridge_", NULL); switch_channel_set_private(channel, "_bridge_", NULL);
if (bd->session == session && *bd->b_uuid) { if (bd->session == session && *bd->b_uuid) {
audio_bridge_thread(NULL, (void *) bd); audio_bridge_thread(NULL, (void *) bd);
@ -261,10 +258,7 @@ static switch_status_t audio_bridge_on_loopback(switch_core_session_t *session)
static switch_status_t audio_bridge_on_ring(switch_core_session_t *session) static switch_status_t audio_bridge_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM RING\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM RING\n", switch_channel_get_name(channel));
@ -275,10 +269,7 @@ static switch_status_t audio_bridge_on_ring(switch_core_session_t *session)
static switch_status_t audio_bridge_on_hold(switch_core_session_t *session) static switch_status_t audio_bridge_on_hold(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM HOLD\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM HOLD\n", switch_channel_get_name(channel));
@ -298,10 +289,7 @@ static const switch_state_handler_table_t audio_bridge_peer_state_handlers = {
static switch_status_t uuid_bridge_on_reset(switch_core_session_t *session) static switch_status_t uuid_bridge_on_reset(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM RESET\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM RESET\n", switch_channel_get_name(channel));
@ -316,12 +304,9 @@ static switch_status_t uuid_bridge_on_reset(switch_core_session_t *session)
static switch_status_t uuid_bridge_on_transmit(switch_core_session_t *session) static switch_status_t uuid_bridge_on_transmit(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_core_session_t *other_session; switch_core_session_t *other_session;
const char *other_uuid = NULL; const char *other_uuid = NULL;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM TRANSMIT\n", switch_channel_get_name(channel)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s CUSTOM TRANSMIT\n", switch_channel_get_name(channel));
switch_channel_clear_state_handler(channel, NULL); switch_channel_clear_state_handler(channel, NULL);
@ -422,13 +407,10 @@ static switch_status_t signal_bridge_on_hibernate(switch_core_session_t *session
static switch_status_t signal_bridge_on_hangup(switch_core_session_t *session) static switch_status_t signal_bridge_on_hangup(switch_core_session_t *session)
{ {
const char *uuid; const char *uuid;
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_core_session_t *other_session; switch_core_session_t *other_session;
switch_event_t *event; switch_event_t *event;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (switch_channel_test_flag(channel, CF_ORIGINATOR)) { if (switch_channel_test_flag(channel, CF_ORIGINATOR)) {
switch_channel_clear_flag(channel, CF_ORIGINATOR); switch_channel_clear_flag(channel, CF_ORIGINATOR);
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_UNBRIDGE) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_UNBRIDGE) == SWITCH_STATUS_SUCCESS) {
@ -439,10 +421,7 @@ static switch_status_t signal_bridge_on_hangup(switch_core_session_t *session)
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE)) if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
&& (other_session = switch_core_session_locate(uuid))) { && (other_session = switch_core_session_locate(uuid))) {
switch_channel_t *other_channel = NULL; switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
other_channel = switch_core_session_get_channel(other_session);
switch_assert(other_channel != NULL);
switch_channel_set_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL); switch_channel_set_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL);
switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL); switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL);
@ -480,15 +459,10 @@ static const switch_state_handler_table_t signal_bridge_state_handlers = {
SWITCH_DECLARE(switch_status_t) switch_ivr_signal_bridge(switch_core_session_t *session, switch_core_session_t *peer_session) SWITCH_DECLARE(switch_status_t) switch_ivr_signal_bridge(switch_core_session_t *session, switch_core_session_t *peer_session)
{ {
switch_channel_t *caller_channel, *peer_channel; switch_channel_t *caller_channel = switch_core_session_get_channel(session);
switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);
switch_event_t *event; switch_event_t *event;
caller_channel = switch_core_session_get_channel(session);
switch_assert(caller_channel != NULL);
peer_channel = switch_core_session_get_channel(peer_session);
switch_assert(peer_channel != NULL);
if (!switch_channel_ready(peer_channel)) { if (!switch_channel_ready(peer_channel)) {
switch_channel_hangup(caller_channel, switch_channel_get_cause(peer_channel)); switch_channel_hangup(caller_channel, switch_channel_get_cause(peer_channel));
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -545,31 +519,18 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_multi_threaded_bridge(switch_core_ses
switch_input_callback_function_t input_callback, void *session_data, switch_input_callback_function_t input_callback, void *session_data,
void *peer_session_data) void *peer_session_data)
{ {
switch_ivr_bridge_data_t *a_leg, *b_leg; switch_ivr_bridge_data_t *a_leg = switch_core_session_alloc(session, sizeof(*a_leg));
switch_channel_t *caller_channel, *peer_channel; switch_ivr_bridge_data_t *b_leg = switch_core_session_alloc(peer_session, sizeof(*b_leg));
switch_channel_t *caller_channel = switch_core_session_get_channel(session);
switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);
int stream_id = 0; int stream_id = 0;
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_channel_state_t state; switch_channel_state_t state;
switch_assert(session != NULL);
switch_assert(peer_session != NULL);
caller_channel = switch_core_session_get_channel(session);
switch_assert(caller_channel != NULL);
switch_channel_set_flag(caller_channel, CF_ORIGINATOR); switch_channel_set_flag(caller_channel, CF_ORIGINATOR);
peer_channel = switch_core_session_get_channel(peer_session);
switch_assert(peer_channel != NULL);
switch_channel_clear_flag(caller_channel, CF_TRANSFER); switch_channel_clear_flag(caller_channel, CF_TRANSFER);
switch_channel_clear_flag(peer_channel, CF_TRANSFER); switch_channel_clear_flag(peer_channel, CF_TRANSFER);
a_leg = switch_core_session_alloc(session, sizeof(*a_leg));
b_leg = switch_core_session_alloc(peer_session, sizeof(*b_leg));
switch_assert(a_leg && b_leg);
b_leg->session = peer_session; b_leg->session = peer_session;
switch_copy_string(b_leg->b_uuid, switch_core_session_get_uuid(session), sizeof(b_leg->b_uuid)); switch_copy_string(b_leg->b_uuid, switch_core_session_get_uuid(session), sizeof(b_leg->b_uuid));
b_leg->stream_id = stream_id; b_leg->stream_id = stream_id;

1
src/switch_ivr_menu.c
View File

@ -302,7 +302,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_menu_execute(switch_core_session_t *s
} }
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
assert(channel != NULL);
if (!(menu = switch_ivr_menu_find(stack, name))) { if (!(menu = switch_ivr_menu_find(stack, name))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Menu!\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Menu!\n");

36
src/switch_ivr_originate.c
View File

@ -36,18 +36,12 @@ static const switch_state_handler_table_t originate_state_handlers;
static switch_status_t originate_on_ring(switch_core_session_t *session) static switch_status_t originate_on_ring(switch_core_session_t *session)
{ {
switch_channel_t *channel = NULL; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
/* put the channel in a passive state so we can loop audio to it */ /* put the channel in a passive state so we can loop audio to it */
/* clear this handler so it only works once (next time (a.k.a. Transfer) we will do the real ring state) */ /* clear this handler so it only works once (next time (a.k.a. Transfer) we will do the real ring state) */
switch_channel_clear_state_handler(channel, &originate_state_handlers); switch_channel_clear_state_handler(channel, &originate_state_handlers);
switch_channel_set_state(channel, CS_HOLD); switch_channel_set_state(channel, CS_HOLD);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
@ -79,7 +73,6 @@ static void *SWITCH_THREAD_FUNC collect_thread_run(switch_thread_t * thread, voi
char buf[10] = SWITCH_BLANK_STRING; char buf[10] = SWITCH_BLANK_STRING;
char *p, term; char *p, term;
if (!strcasecmp(collect->key, "exec")) { if (!strcasecmp(collect->key, "exec")) {
char *data; char *data;
const switch_application_interface_t *application_interface; const switch_application_interface_t *application_interface;
@ -244,12 +237,12 @@ static int teletone_handler(teletone_generation_session_t * ts, teletone_tone_ma
SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t *session, switch_core_session_t *peer_session) SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t *session, switch_core_session_t *peer_session)
{ {
switch_channel_t *caller_channel; switch_channel_t *caller_channel = switch_core_session_get_channel(session);
switch_channel_t *peer_channel; switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);
const char *ringback_data = NULL; const char *ringback_data = NULL;
switch_frame_t write_frame = { 0 }; switch_frame_t write_frame = { 0 };
switch_codec_t write_codec = { 0 }; switch_codec_t write_codec = { 0 };
switch_codec_t *read_codec = NULL; switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
uint8_t pass = 0; uint8_t pass = 0;
ringback_t ringback = { 0 }; ringback_t ringback = { 0 };
switch_core_session_message_t *message = NULL; switch_core_session_message_t *message = NULL;
@ -257,15 +250,10 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
uint8_t abuf[1024]; uint8_t abuf[1024];
int timelimit = 60; int timelimit = 60;
const char *var; const char *var = switch_channel_get_variable(caller_channel, "call_timeout");
switch_time_t start = 0; switch_time_t start = 0;
caller_channel = switch_core_session_get_channel(session); if (var) {
peer_channel = switch_core_session_get_channel(peer_session);
switch_assert(caller_channel && peer_channel);
if ((var = switch_channel_get_variable(caller_channel, "call_timeout"))) {
timelimit = atoi(var); timelimit = atoi(var);
if (timelimit < 0) { if (timelimit < 0) {
timelimit = 60; timelimit = 60;
@ -279,8 +267,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
return SWITCH_STATUS_SUCCESS; return SWITCH_STATUS_SUCCESS;
} }
read_codec = switch_core_session_get_read_codec(session);
if (switch_channel_test_flag(caller_channel, CF_ANSWERED)) { if (switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback"); ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback");
} }
@ -290,7 +276,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
} }
if ((read_codec = switch_core_session_get_read_codec(session)) && (ringback_data || !switch_channel_test_flag(caller_channel, CF_BYPASS_MEDIA))) { if (read_codec && (ringback_data || !switch_channel_test_flag(caller_channel, CF_BYPASS_MEDIA))) {
if (!(pass = (uint8_t) switch_test_flag(read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH))) { if (!(pass = (uint8_t) switch_test_flag(read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH))) {
if (switch_core_codec_init(&write_codec, if (switch_core_codec_init(&write_codec,
"L16", "L16",
@ -346,8 +332,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
goto done; goto done;
} }
ringback.fh = &ringback.fhb; ringback.fh = &ringback.fhb;
} else { } else {
teletone_init_session(&ringback.ts, 0, teletone_handler, &ringback); teletone_init_session(&ringback.ts, 0, teletone_handler, &ringback);
ringback.ts.rate = read_codec->implementation->actual_samples_per_second; ringback.ts.rate = read_codec->implementation->actual_samples_per_second;
@ -378,8 +362,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
} }
if (switch_core_session_dequeue_message(peer_session, &message) == SWITCH_STATUS_SUCCESS) { if (switch_core_session_dequeue_message(peer_session, &message) == SWITCH_STATUS_SUCCESS) {
//switch_core_session_receive_message(session, message);
if (switch_test_flag(message, SCSMF_DYNAMIC)) { if (switch_test_flag(message, SCSMF_DYNAMIC)) {
switch_safe_free(message); switch_safe_free(message);
} else { } else {
@ -453,7 +435,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
} }
return status; return status;
} }
#define MAX_PEERS 128 #define MAX_PEERS 128
@ -555,9 +536,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
if (session) { if (session) {
switch_event_header_t *hi; switch_event_header_t *hi;
caller_channel = switch_core_session_get_channel(session); caller_channel = switch_core_session_get_channel(session);
switch_assert(caller_channel != NULL);
/* Copy all the applicable channel variables into the event */ /* Copy all the applicable channel variables into the event */
if ((hi = switch_channel_variable_first(caller_channel))) { if ((hi = switch_channel_variable_first(caller_channel))) {
@ -830,7 +809,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
caller_profiles[i] = new_profile; caller_profiles[i] = new_profile;
peer_sessions[i] = new_session; peer_sessions[i] = new_session;
peer_channels[i] = switch_core_session_get_channel(new_session); peer_channels[i] = switch_core_session_get_channel(new_session);
switch_assert(peer_channels[i] != NULL);
switch_channel_set_flag(peer_channels[i], CF_ORIGINATING); switch_channel_set_flag(peer_channels[i], CF_ORIGINATING);
if (var_event) { if (var_event) {

75
src/switch_ivr_play_say.c
View File

@ -98,13 +98,10 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_phrase_macro(switch_core_session_t *s
switch_status_t status = SWITCH_STATUS_GENERR; switch_status_t status = SWITCH_STATUS_GENERR;
const char *old_sound_prefix = NULL, *sound_path = NULL, *tts_engine = NULL, *tts_voice = NULL; const char *old_sound_prefix = NULL, *sound_path = NULL, *tts_engine = NULL, *tts_voice = NULL;
const char *module_name = NULL, *chan_lang = NULL; const char *module_name = NULL, *chan_lang = NULL;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
uint8_t done = 0; uint8_t done = 0;
int matches = 0; int matches = 0;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!macro_name) { if (!macro_name) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No phrase macro specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No phrase macro specified.\n");
return status; return status;
@ -164,7 +161,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_phrase_macro(switch_core_session_t *s
goto done; goto done;
} }
if (!(sound_path = (char *) switch_xml_attr(language, "sound-path"))) { if (!(sound_path = (char *) switch_xml_attr(language, "sound-path"))) {
sound_path = (char *) switch_xml_attr(language, "sound_path"); sound_path = (char *) switch_xml_attr(language, "sound_path");
} }
@ -345,11 +341,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_phrase_macro(switch_core_session_t *s
SWITCH_DECLARE(switch_status_t) switch_ivr_record_file(switch_core_session_t *session, SWITCH_DECLARE(switch_status_t) switch_ivr_record_file(switch_core_session_t *session,
switch_file_handle_t *fh, const char *file, switch_input_args_t *args, uint32_t limit) switch_file_handle_t *fh, const char *file, switch_input_args_t *args, uint32_t limit)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_dtmf_t dtmf = {0}; switch_dtmf_t dtmf = {0};
switch_file_handle_t lfh = { 0 }; switch_file_handle_t lfh = { 0 };
switch_frame_t *read_frame; switch_frame_t *read_frame;
switch_codec_t codec, *read_codec; switch_codec_t codec, *read_codec = switch_core_session_get_read_codec(session);
char *codec_name; char *codec_name;
switch_status_t status = SWITCH_STATUS_SUCCESS; switch_status_t status = SWITCH_STATUS_SUCCESS;
const char *p; const char *p;
@ -357,22 +353,17 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_record_file(switch_core_session_t *se
time_t start = 0; time_t start = 0;
uint32_t org_silence_hits = 0; uint32_t org_silence_hits = 0;
switch_assert(read_codec != NULL);
if (!fh) { if (!fh) {
fh = &lfh; fh = &lfh;
} }
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);
read_codec = switch_core_session_get_read_codec(session);
switch_assert(read_codec != NULL);
fh->channels = read_codec->implementation->number_of_channels; fh->channels = read_codec->implementation->number_of_channels;
fh->native_rate = read_codec->implementation->actual_samples_per_second; fh->native_rate = read_codec->implementation->actual_samples_per_second;
if (switch_core_file_open(fh, if (switch_core_file_open(fh,
file, file,
fh->channels, fh->channels,
@ -504,7 +495,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_record_file(switch_core_session_t *se
} }
} }
if (status != SWITCH_STATUS_SUCCESS) { if (status != SWITCH_STATUS_SUCCESS) {
break; break;
} }
@ -586,12 +576,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_gentones(switch_core_session_t *sessi
switch_codec_t *read_codec = NULL, write_codec = { 0 }; switch_codec_t *read_codec = NULL, write_codec = { 0 };
switch_frame_t write_frame = { 0 }; switch_frame_t write_frame = { 0 };
switch_byte_t data[1024]; switch_byte_t data[1024];
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);
read_codec = switch_core_session_get_read_codec(session); read_codec = switch_core_session_get_read_codec(session);
@ -672,7 +657,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_gentones(switch_core_session_t *sessi
SWITCH_DECLARE(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) SWITCH_DECLARE(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)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
int16_t *abuf; int16_t *abuf;
switch_dtmf_t dtmf = {0}; switch_dtmf_t dtmf = {0};
uint32_t interval = 0, samples = 0, framelen, sample_start = 0; uint32_t interval = 0, samples = 0, framelen, sample_start = 0;
@ -698,9 +683,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
switch_zmalloc(abuf, FILE_STARTSAMPLES * sizeof(*abuf)); switch_zmalloc(abuf, FILE_STARTSAMPLES * sizeof(*abuf));
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);
prefix = switch_channel_get_variable(channel, "sound_prefix"); prefix = switch_channel_get_variable(channel, "sound_prefix");
@ -730,13 +712,11 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
} }
} }
if (!fh) { if (!fh) {
fh = &lfh; fh = &lfh;
memset(fh, 0, sizeof(lfh)); memset(fh, 0, sizeof(lfh));
} }
if (fh->samples > 0) { if (fh->samples > 0) {
sample_start = fh->samples; sample_start = fh->samples;
fh->samples = 0; fh->samples = 0;
@ -748,8 +728,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
fh->prebuf = maybe; fh->prebuf = maybe;
} }
} }
if (switch_core_file_open(fh, if (switch_core_file_open(fh,
file, file,
@ -764,7 +742,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
asis = 1; asis = 1;
} }
write_frame.data = abuf; write_frame.data = abuf;
write_frame.buflen = FILE_STARTSAMPLES; write_frame.buflen = FILE_STARTSAMPLES;
@ -803,14 +780,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
date = switch_core_session_strdup(session, p); date = switch_core_session_strdup(session, p);
switch_channel_set_variable(channel, "RECORD_DATE", p); switch_channel_set_variable(channel, "RECORD_DATE", p);
} }
#if 0
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"OPEN FILE %s %uhz %u channels\n"
"TITLE=%s\n"
"COPYRIGHT=%s\n"
"SOFTWARE=%s\n"
"ARTIST=%s\n" "COMMENT=%s\n" "DATE=%s\n", file, fh->samplerate, fh->channels, title, copyright, software, artist, comment, date);
#endif
switch_assert(read_codec != NULL); switch_assert(read_codec != NULL);
interval = read_codec->implementation->microseconds_per_frame / 1000; interval = read_codec->implementation->microseconds_per_frame / 1000;
@ -856,7 +825,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
framelen = codec.implementation->bytes_per_frame; framelen = codec.implementation->bytes_per_frame;
} }
if (timer_name) { if (timer_name) {
uint32_t len; uint32_t len;
@ -984,14 +952,12 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
switch_clear_flag(fh, SWITCH_FILE_SEEK); switch_clear_flag(fh, SWITCH_FILE_SEEK);
} }
if (!asis && fh->speed && do_speed) { if (!asis && fh->speed && do_speed) {
float factor = 0.25f * abs(fh->speed); float factor = 0.25f * abs(fh->speed);
switch_size_t newlen, supplement, step; switch_size_t newlen, supplement, step;
short *bp = write_frame.data; short *bp = write_frame.data;
switch_size_t wrote = 0; switch_size_t wrote = 0;
supplement = (int) (factor * olen); supplement = (int) (factor * olen);
newlen = (fh->speed > 0) ? olen - supplement : olen + supplement; newlen = (fh->speed > 0) ? olen - supplement : olen + supplement;
step = (fh->speed > 0) ? (newlen / supplement) : (olen / supplement); step = (fh->speed > 0) ? (newlen / supplement) : (olen / supplement);
@ -1034,8 +1000,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
write_frame.datalen = write_frame.samples * 2; write_frame.datalen = write_frame.samples * 2;
} }
llen = olen; llen = olen;
if (timer_name) { if (timer_name) {
@ -1069,7 +1033,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
break; break;
} }
if (timer_name) { if (timer_name) {
if (switch_core_timer_next(&timer) != SWITCH_STATUS_SUCCESS) { if (switch_core_timer_next(&timer) != SWITCH_STATUS_SUCCESS) {
break; break;
@ -1128,7 +1091,7 @@ SWITCH_DECLARE(switch_status_t) switch_play_and_get_digits(switch_core_session_t
{ {
char terminator; //used to hold terminator recieved from char terminator; //used to hold terminator recieved from
switch_channel_t *channel; //the channel contained in session switch_channel_t *channel = switch_core_session_get_channel(session); //the channel contained in session
switch_status_t status; //used to recieve state out of called functions switch_status_t status; //used to recieve state out of called functions
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
@ -1136,12 +1099,6 @@ SWITCH_DECLARE(switch_status_t) switch_play_and_get_digits(switch_core_session_t
min_digits, max_digits, max_tries, timeout, valid_terminators, prompt_audio_file, min_digits, max_digits, max_tries, timeout, valid_terminators, prompt_audio_file,
bad_input_audio_file, digit_buffer_length, digits_regex); bad_input_audio_file, digit_buffer_length, digits_regex);
//Get the channel
channel = switch_core_session_get_channel(session);
//Make sure somebody is home
switch_assert(channel != NULL);
//Answer the channel if it hasn't already been answered //Answer the channel if it hasn't already been answered
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);
@ -1238,7 +1195,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_speak_text_handle(switch_core_session
switch_speech_handle_t *sh, switch_speech_handle_t *sh,
switch_codec_t *codec, switch_timer_t *timer, char *text, switch_input_args_t *args) switch_codec_t *codec, switch_timer_t *timer, char *text, switch_input_args_t *args)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
short abuf[960]; short abuf[960];
switch_dtmf_t dtmf = {0}; switch_dtmf_t dtmf = {0};
uint32_t len = 0; uint32_t len = 0;
@ -1255,9 +1212,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_speak_text_handle(switch_core_session
char *p, *tmp = NULL; char *p, *tmp = NULL;
const char *star, *pound; const char *star, *pound;
switch_size_t starlen, poundlen; switch_size_t starlen, poundlen;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if (!sh) { if (!sh) {
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
@ -1502,10 +1456,7 @@ typedef struct cached_speech_handle cached_speech_handle_t;
SWITCH_DECLARE(void) switch_ivr_clear_speech_cache(switch_core_session_t *session) SWITCH_DECLARE(void) switch_ivr_clear_speech_cache(switch_core_session_t *session)
{ {
cached_speech_handle_t *cache_obj = NULL; cached_speech_handle_t *cache_obj = NULL;
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
if ((cache_obj = switch_channel_get_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME))) { if ((cache_obj = switch_channel_get_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME))) {
switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE; switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
@ -1516,14 +1467,13 @@ SWITCH_DECLARE(void) switch_ivr_clear_speech_cache(switch_core_session_t *sessio
switch_core_codec_destroy(&cache_obj->codec); switch_core_codec_destroy(&cache_obj->codec);
switch_channel_set_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, NULL); switch_channel_set_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, NULL);
} }
} }
SWITCH_DECLARE(switch_status_t) switch_ivr_speak_text(switch_core_session_t *session, SWITCH_DECLARE(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) const char *tts_name, const char *voice_name, char *text, switch_input_args_t *args)
{ {
switch_channel_t *channel; switch_channel_t *channel = switch_core_session_get_channel(session);
uint32_t rate = 0; uint32_t rate = 0;
int interval = 0; int interval = 0;
switch_frame_t write_frame = { 0 }; switch_frame_t write_frame = { 0 };
@ -1540,9 +1490,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_speak_text(switch_core_session_t *ses
const char *timer_name, *var; const char *timer_name, *var;
cached_speech_handle_t *cache_obj = NULL; cached_speech_handle_t *cache_obj = NULL;
int need_create = 1, need_alloc = 1; int need_create = 1, need_alloc = 1;
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
switch_channel_pre_answer(channel); switch_channel_pre_answer(channel);

6
src/switch_rtp.c
View File

@ -1620,8 +1620,7 @@ static int rtp_common_write(switch_rtp_t *rtp_session,
if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_TALK)) { if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_TALK)) {
switch_event_t *event; switch_event_t *event;
if (switch_event_create(&event, SWITCH_EVENT_TALK) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_TALK) == SWITCH_STATUS_SUCCESS) {
switch_channel_t *channel = switch_core_session_get_channel(rtp_session->vad_data.session); switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
switch_channel_event_set_data(channel, event);
switch_event_fire(&event); switch_event_fire(&event);
} }
} }
@ -1637,8 +1636,7 @@ static int rtp_common_write(switch_rtp_t *rtp_session,
if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_NOTALK)) { if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_NOTALK)) {
switch_event_t *event; switch_event_t *event;
if (switch_event_create(&event, SWITCH_EVENT_NOTALK) == SWITCH_STATUS_SUCCESS) { if (switch_event_create(&event, SWITCH_EVENT_NOTALK) == SWITCH_STATUS_SUCCESS) {
switch_channel_t *channel = switch_core_session_get_channel(rtp_session->vad_data.session); switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
switch_channel_event_set_data(channel, event);
switch_event_fire(&event); switch_event_fire(&event);
} }
} }