src/switch_channel.c

Bug Summary

File:	switch_channel.c
Warning:	line 1535, column 12 Potential leak of memory pointed to by 'r'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name switch_channel.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fno-trapping-math -ffp-contract=fast -ffast-math -ffinite-math-only -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -resource-dir /usr/lib/llvm-7/lib/clang/7.0.1 -D HAVE_CONFIG_H -I . -I ./src/include -I ./libs/esl/src/include -I ./libs/xmlrpc-c -I /drone/src/libs/libvpx -I /drone/src/src/include -I /drone/src/src/include -I /drone/src/libs/libteletone/src -D SWITCH_API_VISIBILITY=1 -D CJSON_API_VISIBILITY=1 -D HAVE_VISIBILITY=1 -D _REENTRANT -D _GNU_SOURCE -I /drone/src/libs/apr/include -I /drone/src/libs/apr-util/include -I /drone/src/libs/apr-util/xml/expat/lib -I /drone/src/libs/srtp/include -I /drone/src/libs/libyuv/include -D SWITCH_HAVE_YUV -I /drone/src/libs/srtp/crypto/include -I libs/srtp/crypto/include -D SWITCH_HAVE_VPX -D ENABLE_SRTP -D SWITCH_HAVE_ODBC -I /usr/include -D SWITCH_HAVE_PNG -I /usr/include/libpng16 -D SWITCH_HAVE_FREETYPE -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/x86_64-linux-gnu -I /usr/include/editline -D HAVE_OPENSSL -I /usr/include/sofia-sip-1.13 -I /usr/include/uuid -I /drone/src/src/include -I /drone/src/src/include -I /drone/src/libs/libteletone/src -D SWITCH_API_VISIBILITY=1 -D CJSON_API_VISIBILITY=1 -D HAVE_VISIBILITY=1 -D HAVE_OPENSSL -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.1/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wno-misleading-indentation -std=c99 -fdebug-compilation-dir /drone/src -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -o /drone/src/scan-build/2021-10-18-233245-401-1 -x c src/switch_channel.c -faddrsig
1/*
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
*
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
*
* The Initial Developer of the Original Code is
* Anthony Minessale II <anthm@freeswitch.org>
* Portions created by the Initial Developer are Copyright (C)
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Anthony Minessale II <anthm@freeswitch.org>
* Michael Jerris <mike@jerris.com>
*
*
* switch_channel.c -- Media Channel Interface
*
*/

34#include <switch.h>
35#include <switch_channel.h>
36#include <pcre.h>

38struct switch_cause_table {
const char *name;
switch_call_cause_t cause;
41};

43typedef struct switch_device_state_binding_s {
switch_device_state_function_t function;
void *user_data;
struct switch_device_state_binding_s *next;
47} switch_device_state_binding_t;

49static struct {
switch_memory_pool_t *pool;
switch_hash_t *device_hash;
switch_mutex_t *device_mutex;
switch_device_state_binding_t *device_bindings;
54} globals;

56static struct switch_cause_table CAUSE_CHART[] = {
{"NONE", SWITCH_CAUSE_NONE},
{"UNALLOCATED_NUMBER", SWITCH_CAUSE_UNALLOCATED_NUMBER},
{"NO_ROUTE_TRANSIT_NET", SWITCH_CAUSE_NO_ROUTE_TRANSIT_NET},
{"NO_ROUTE_DESTINATION", SWITCH_CAUSE_NO_ROUTE_DESTINATION},
{"CHANNEL_UNACCEPTABLE", SWITCH_CAUSE_CHANNEL_UNACCEPTABLE},
{"CALL_AWARDED_DELIVERED", SWITCH_CAUSE_CALL_AWARDED_DELIVERED},
{"NORMAL_CLEARING", SWITCH_CAUSE_NORMAL_CLEARING},
{"USER_BUSY", SWITCH_CAUSE_USER_BUSY},
{"NO_USER_RESPONSE", SWITCH_CAUSE_NO_USER_RESPONSE},
{"NO_ANSWER", SWITCH_CAUSE_NO_ANSWER},
{"SUBSCRIBER_ABSENT", SWITCH_CAUSE_SUBSCRIBER_ABSENT},
{"CALL_REJECTED", SWITCH_CAUSE_CALL_REJECTED},
{"NUMBER_CHANGED", SWITCH_CAUSE_NUMBER_CHANGED},
{"REDIRECTION_TO_NEW_DESTINATION", SWITCH_CAUSE_REDIRECTION_TO_NEW_DESTINATION},
{"EXCHANGE_ROUTING_ERROR", SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR},
{"DESTINATION_OUT_OF_ORDER", SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER},
{"INVALID_NUMBER_FORMAT", SWITCH_CAUSE_INVALID_NUMBER_FORMAT},
{"FACILITY_REJECTED", SWITCH_CAUSE_FACILITY_REJECTED},
{"RESPONSE_TO_STATUS_ENQUIRY", SWITCH_CAUSE_RESPONSE_TO_STATUS_ENQUIRY},
{"NORMAL_UNSPECIFIED", SWITCH_CAUSE_NORMAL_UNSPECIFIED},
{"NORMAL_CIRCUIT_CONGESTION", SWITCH_CAUSE_NORMAL_CIRCUIT_CONGESTION},
{"NETWORK_OUT_OF_ORDER", SWITCH_CAUSE_NETWORK_OUT_OF_ORDER},
{"NORMAL_TEMPORARY_FAILURE", SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE},
{"SWITCH_CONGESTION", SWITCH_CAUSE_SWITCH_CONGESTION},
{"ACCESS_INFO_DISCARDED", SWITCH_CAUSE_ACCESS_INFO_DISCARDED},
{"REQUESTED_CHAN_UNAVAIL", SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL},
{"PRE_EMPTED", SWITCH_CAUSE_PRE_EMPTED},
{"FACILITY_NOT_SUBSCRIBED", SWITCH_CAUSE_FACILITY_NOT_SUBSCRIBED},
{"OUTGOING_CALL_BARRED", SWITCH_CAUSE_OUTGOING_CALL_BARRED},
{"INCOMING_CALL_BARRED", SWITCH_CAUSE_INCOMING_CALL_BARRED},
{"BEARERCAPABILITY_NOTAUTH", SWITCH_CAUSE_BEARERCAPABILITY_NOTAUTH},
{"BEARERCAPABILITY_NOTAVAIL", SWITCH_CAUSE_BEARERCAPABILITY_NOTAVAIL},
{"SERVICE_UNAVAILABLE", SWITCH_CAUSE_SERVICE_UNAVAILABLE},
{"BEARERCAPABILITY_NOTIMPL", SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL},
{"CHAN_NOT_IMPLEMENTED", SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED},
{"FACILITY_NOT_IMPLEMENTED", SWITCH_CAUSE_FACILITY_NOT_IMPLEMENTED},
{"SERVICE_NOT_IMPLEMENTED", SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED},
{"INVALID_CALL_REFERENCE", SWITCH_CAUSE_INVALID_CALL_REFERENCE},
{"INCOMPATIBLE_DESTINATION", SWITCH_CAUSE_INCOMPATIBLE_DESTINATION},
{"INVALID_MSG_UNSPECIFIED", SWITCH_CAUSE_INVALID_MSG_UNSPECIFIED},
{"MANDATORY_IE_MISSING", SWITCH_CAUSE_MANDATORY_IE_MISSING},
{"MESSAGE_TYPE_NONEXIST", SWITCH_CAUSE_MESSAGE_TYPE_NONEXIST},
{"WRONG_MESSAGE", SWITCH_CAUSE_WRONG_MESSAGE},
{"IE_NONEXIST", SWITCH_CAUSE_IE_NONEXIST},
{"INVALID_IE_CONTENTS", SWITCH_CAUSE_INVALID_IE_CONTENTS},
{"WRONG_CALL_STATE", SWITCH_CAUSE_WRONG_CALL_STATE},
{"RECOVERY_ON_TIMER_EXPIRE", SWITCH_CAUSE_RECOVERY_ON_TIMER_EXPIRE},
{"MANDATORY_IE_LENGTH_ERROR", SWITCH_CAUSE_MANDATORY_IE_LENGTH_ERROR},
{"PROTOCOL_ERROR", SWITCH_CAUSE_PROTOCOL_ERROR},
{"INTERWORKING", SWITCH_CAUSE_INTERWORKING},
{"SUCCESS", SWITCH_CAUSE_SUCCESS},
{"ORIGINATOR_CANCEL", SWITCH_CAUSE_ORIGINATOR_CANCEL},
{"CRASH", SWITCH_CAUSE_CRASH},
{"SYSTEM_SHUTDOWN", SWITCH_CAUSE_SYSTEM_SHUTDOWN},
{"LOSE_RACE", SWITCH_CAUSE_LOSE_RACE},
{"MANAGER_REQUEST", SWITCH_CAUSE_MANAGER_REQUEST},
{"BLIND_TRANSFER", SWITCH_CAUSE_BLIND_TRANSFER},
{"ATTENDED_TRANSFER", SWITCH_CAUSE_ATTENDED_TRANSFER},
{"ALLOTTED_TIMEOUT", SWITCH_CAUSE_ALLOTTED_TIMEOUT},
{"USER_CHALLENGE", SWITCH_CAUSE_USER_CHALLENGE},
{"MEDIA_TIMEOUT", SWITCH_CAUSE_MEDIA_TIMEOUT},
{"PICKED_OFF", SWITCH_CAUSE_PICKED_OFF},
{"USER_NOT_REGISTERED", SWITCH_CAUSE_USER_NOT_REGISTERED},
{"PROGRESS_TIMEOUT", SWITCH_CAUSE_PROGRESS_TIMEOUT},
{"INVALID_GATEWAY", SWITCH_CAUSE_INVALID_GATEWAY},
{"GATEWAY_DOWN", SWITCH_CAUSE_GATEWAY_DOWN},
{"INVALID_URL", SWITCH_CAUSE_INVALID_URL},
{"INVALID_PROFILE", SWITCH_CAUSE_INVALID_PROFILE},
{"NO_PICKUP", SWITCH_CAUSE_NO_PICKUP},
{"SRTP_READ_ERROR", SWITCH_CAUSE_SRTP_READ_ERROR},
{"BOWOUT", SWITCH_CAUSE_BOWOUT},
{"BUSY_EVERYWHERE", SWITCH_CAUSE_BUSY_EVERYWHERE},
{"DECLINE", SWITCH_CAUSE_DECLINE},
{"DOES_NOT_EXIST_ANYWHERE", SWITCH_CAUSE_DOES_NOT_EXIST_ANYWHERE},
{"NOT_ACCEPTABLE", SWITCH_CAUSE_NOT_ACCEPTABLE},
{"UNWANTED", SWITCH_CAUSE_UNWANTED},
{"NO_IDENTITY", SWITCH_CAUSE_NO_IDENTITY},
{"BAD_IDENTITY_INFO", SWITCH_CAUSE_BAD_IDENTITY_INFO},
{"UNSUPPORTED_CERTIFICATE", SWITCH_CAUSE_UNSUPPORTED_CERTIFICATE},
{"INVALID_IDENTITY", SWITCH_CAUSE_INVALID_IDENTITY},
{"STALE_DATE", SWITCH_CAUSE_STALE_DATE},
{NULL((void*)0), 0}
139};

141typedef enum {
OCF_HANGUP = (1 << 0)
143} opaque_channel_flag_t;

145typedef enum {
LP_NEITHER,
LP_ORIGINATOR,
LP_ORIGINATEE
149} switch_originator_type_t;

151struct switch_channel {
char *name;
switch_call_direction_t direction;
switch_call_direction_t logical_direction;
switch_queue_t *dtmf_queue;
switch_queue_t *dtmf_log_queue;
switch_mutex_t*dtmf_mutex;
switch_mutex_t *flag_mutex;
switch_mutex_t *state_mutex;
switch_mutex_t *thread_mutex;
switch_mutex_t *profile_mutex;
switch_core_session_t *session;
switch_channel_state_t state;
switch_channel_state_t running_state;
switch_channel_callstate_t callstate;
uint32_t flags[CF_FLAG_MAX];
uint32_t caps[CC_FLAG_MAX];
uint8_t state_flags[CF_FLAG_MAX];
uint32_t private_flags;
switch_caller_profile_t *caller_profile;
const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS30];
int state_handler_index;
switch_event_t *variables;
switch_event_t *scope_variables;
switch_hash_t *private_hash;
switch_hash_t *app_flag_hash;
switch_call_cause_t hangup_cause;
int vi;
int event_count;
int profile_index;
opaque_channel_flag_t opaque_flags;
switch_originator_type_t last_profile_type;
switch_caller_extension_t *queued_extension;
switch_event_t *app_list;
switch_event_t *api_list;
switch_event_t *var_list;
switch_hold_record_t *hold_record;
switch_device_node_t *device_node;
char *device_id;
switch_event_t *log_tags;
191};

193static void process_device_hup(switch_channel_t *channel);
194static void switch_channel_check_device_state(switch_channel_t *channel, switch_channel_callstate_t callstate);

196SWITCH_DECLARE(switch_hold_record_t *)__attribute__((visibility("default"))) switch_hold_record_t * switch_channel_get_hold_record(switch_channel_t *channel)
197{
return channel->hold_record;
199}

201SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_cause2str(switch_call_cause_t cause)
202{
uint8_t x;
const char *str = "UNKNOWN";

for (x = 0; x < (sizeof(CAUSE_CHART) / sizeof(struct switch_cause_table)) - 1; x++) {
if (CAUSE_CHART[x].cause == cause) {
	str = CAUSE_CHART[x].name;
	break;
}
}

return str;
214}

216SWITCH_DECLARE(switch_call_cause_t)__attribute__((visibility("default"))) switch_call_cause_t switch_channel_str2cause(const char *str)
217{
uint8_t x;
switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;

if (!zstr(str)_zstr(str)) {
if (*str > 47 && *str < 58) {
	cause = atoi(str);
} else {
	for (x = 0; x < (sizeof(CAUSE_CHART) / sizeof(struct switch_cause_table)) - 1 && CAUSE_CHART[x].name; x++) {
		if (!strcasecmp(CAUSE_CHART[x].name, str)) {
			cause = CAUSE_CHART[x].cause;
			break;
		}
	}
}
}

return cause;
235}

237SWITCH_DECLARE(switch_call_cause_t)__attribute__((visibility("default"))) switch_call_cause_t switch_channel_get_cause(switch_channel_t *channel)
238{
return channel->hangup_cause;
240}


243SWITCH_DECLARE(switch_call_cause_t *)__attribute__((visibility("default"))) switch_call_cause_t * switch_channel_get_cause_ptr(switch_channel_t *channel)
244{
return &channel->hangup_cause;
246}


249struct switch_callstate_table {
const char *name;
switch_channel_callstate_t callstate;
252};
253static struct switch_callstate_table CALLSTATE_CHART[] = {
{"DOWN", CCS_DOWN},
{"DIALING", CCS_DIALING},
{"RINGING", CCS_RINGING},
{"EARLY", CCS_EARLY},
{"ACTIVE", CCS_ACTIVE},
{"HELD", CCS_HELD},
{"RING_WAIT", CCS_RING_WAIT},
{"HANGUP", CCS_HANGUP},
{"UNHELD", CCS_UNHELD},
{NULL((void*)0), 0}
264};

266struct switch_device_state_table {
const char *name;
switch_device_state_t device_state;
269};
270static struct switch_device_state_table DEVICE_STATE_CHART[] = {
{"DOWN", SDS_DOWN},
{"RINGING", SDS_RINGING},
{"ACTIVE", SDS_ACTIVE},
{"ACTIVE_MULTI", SDS_ACTIVE_MULTI},
{"HELD", SDS_HELD},
{"UNHELD", SDS_UNHELD},
{"HANGUP", SDS_HANGUP},
{NULL((void*)0), 0}
279};


282SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_perform_set_callstate(switch_channel_t *channel, switch_channel_callstate_t callstate,
												  const char *file, const char *func, int line)
284{
switch_event_t *event;
switch_channel_callstate_t o_callstate = channel->callstate;

if (o_callstate == callstate || o_callstate == CCS_HANGUP) return;

channel->callstate = callstate;
if (channel->device_node) {
channel->device_node->callstate = callstate;
}
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_DEBUG,
			  "(%s) Callstate Change %s -> %s\n", channel->name,
			  switch_channel_callstate2str(o_callstate), switch_channel_callstate2str(callstate));

switch_channel_check_device_state(channel, channel->callstate);

if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_CALLSTATE)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 300, &event, SWITCH_EVENT_CHANNEL_CALLSTATE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Original-Channel-Call-State", switch_channel_callstate2str(o_callstate));
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Call-State-Number", "%d", callstate);
switch_channel_event_set_data(channel, event);
switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 304, &event, ((void*)0));
}
306}

308SWITCH_DECLARE(switch_channel_callstate_t)__attribute__((visibility("default"))) switch_channel_callstate_t switch_channel_get_callstate(switch_channel_t *channel)
309{
return channel->callstate;
311}


314SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_callstate2str(switch_channel_callstate_t callstate)
315{
uint8_t x;
const char *str = "UNKNOWN";

for (x = 0; x < (sizeof(CALLSTATE_CHART) / sizeof(struct switch_cause_table)) - 1; x++) {
if (CALLSTATE_CHART[x].callstate == callstate) {
	str = CALLSTATE_CHART[x].name;
	break;
}
}

return str;
327}

329SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_device_state2str(switch_device_state_t device_state)
330{
uint8_t x;
const char *str = "UNKNOWN";

for (x = 0; x < (sizeof(DEVICE_STATE_CHART) / sizeof(struct switch_cause_table)) - 1; x++) {
if (DEVICE_STATE_CHART[x].device_state == device_state) {
	str = DEVICE_STATE_CHART[x].name;
	break;
}
}

return str;
342}


345SWITCH_DECLARE(switch_channel_callstate_t)__attribute__((visibility("default"))) switch_channel_callstate_t switch_channel_str2callstate(const char *str)
346{
uint8_t x;
switch_channel_callstate_t callstate = (switch_channel_callstate_t) SWITCH_CAUSE_NONE;

if (*str > 47 && *str < 58) {
callstate = atoi(str);
} else {
for (x = 0; x < (sizeof(CALLSTATE_CHART) / sizeof(struct switch_callstate_table)) - 1 && CALLSTATE_CHART[x].name; x++) {
	if (!strcasecmp(CALLSTATE_CHART[x].name, str)) {
		callstate = CALLSTATE_CHART[x].callstate;
		break;
	}
}
}
return callstate;
361}



365SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_perform_audio_sync(switch_channel_t *channel, const char *file, const char *func, int line)
366{
if (switch_channel_media_up(channel)(switch_channel_test_flag(channel, CF_ANSWERED) || switch_channel_test_flag
(channel, CF_EARLY_MEDIA))) {
switch_core_session_message_t *msg = NULL((void*)0);

msg = switch_core_session_alloc(channel->session, sizeof(*msg))switch_core_perform_session_alloc(channel->session, sizeof
(*msg), "src/switch_channel.c", (const char *)__func__, 370);
MESSAGE_STAMP_FFL(msg)msg->_file = "src/switch_channel.c"; msg->_func = (const
 char *)__func__; msg->_line = 371;
msg->message_id = SWITCH_MESSAGE_INDICATE_AUDIO_SYNC;
msg->from = channel->name;
msg->_file = file;
msg->_func = func;
msg->_line = line;

switch_core_session_queue_message(channel->session, msg);
}
380}


383SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_perform_video_sync(switch_channel_t *channel, const char *file, const char *func, int line)
384{

if (switch_channel_media_up(channel)(switch_channel_test_flag(channel, CF_ANSWERED) || switch_channel_test_flag
(channel, CF_EARLY_MEDIA))) {
switch_core_session_message_t *msg = NULL((void*)0);

msg = switch_core_session_alloc(channel->session, sizeof(*msg))switch_core_perform_session_alloc(channel->session, sizeof
(*msg), "src/switch_channel.c", (const char *)__func__, 389);
MESSAGE_STAMP_FFL(msg)msg->_file = "src/switch_channel.c"; msg->_func = (const
 char *)__func__; msg->_line = 390;
msg->message_id = SWITCH_MESSAGE_INDICATE_VIDEO_SYNC;
msg->from = channel->name;
msg->_file = file;
msg->_func = func;
msg->_line = line;

switch_core_session_request_video_refresh(channel->session)_switch_core_session_request_video_refresh(channel->session
, 0, "src/switch_channel.c", (const char *)__func__, 397);
switch_core_session_queue_message(channel->session, msg);
}
400}



404SWITCH_DECLARE(switch_call_cause_t)__attribute__((visibility("default"))) switch_call_cause_t switch_channel_cause_q850(switch_call_cause_t cause)
405{
if (cause <= SWITCH_CAUSE_INTERWORKING) {
return cause;
} else {
return SWITCH_CAUSE_NORMAL_CLEARING;
}
411}

413SWITCH_DECLARE(switch_call_cause_t)__attribute__((visibility("default"))) switch_call_cause_t switch_channel_get_cause_q850(switch_channel_t *channel)
414{
return switch_channel_cause_q850(channel->hangup_cause);
416}

418SWITCH_DECLARE(switch_channel_timetable_t *)__attribute__((visibility("default"))) switch_channel_timetable_t
 * switch_channel_get_timetable(switch_channel_t *channel)
419{
switch_channel_timetable_t *times = NULL((void*)0);

if (channel->caller_profile) {
switch_mutex_lock(channel->profile_mutex);
times = channel->caller_profile->times;
switch_mutex_unlock(channel->profile_mutex);
}

return times;
429}

431SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_direction(switch_channel_t *channel, switch_call_direction_t direction)
432{
if (!switch_core_session_in_thread(channel->session)) {
channel->direction = channel->logical_direction = direction;
switch_channel_set_variable(channel, "direction", switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound")switch_channel_set_variable_var_check(channel, "direction", switch_channel_direction
(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound"
, SWITCH_TRUE);
}
437}

439SWITCH_DECLARE(switch_call_direction_t)__attribute__((visibility("default"))) switch_call_direction_t switch_channel_direction(switch_channel_t *channel)
440{
return channel->direction;
442}

444SWITCH_DECLARE(switch_call_direction_t)__attribute__((visibility("default"))) switch_call_direction_t switch_channel_logical_direction(switch_channel_t *channel)
445{
return channel->logical_direction;
447}

449SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_alloc(switch_channel_t **channel, switch_call_direction_t direction, switch_memory_pool_t *pool)
450{
switch_assert(pool != NULL)((pool != ((void*)0)) ? (void) (0) : __assert_fail ("pool != ((void*)0)"
, "src/switch_channel.c", 451, __extension__ __PRETTY_FUNCTION__
));

if (((*channel) = switch_core_alloc(pool, sizeof(switch_channel_t))switch_core_perform_alloc(pool, sizeof(switch_channel_t), "src/switch_channel.c"
, (const char *)__func__, 453)) == 0) {
return SWITCH_STATUS_MEMERR;
}

switch_event_create_plain(&(*channel)->variables, SWITCH_EVENT_CHANNEL_DATA);

switch_core_hash_init(&(*channel)->private_hash)switch_core_hash_init_case(&(*channel)->private_hash, SWITCH_TRUE
);
switch_queue_create(&(*channel)->dtmf_queue, SWITCH_DTMF_LOG_LEN1000, pool);
switch_queue_create(&(*channel)->dtmf_log_queue, SWITCH_DTMF_LOG_LEN1000, pool);

switch_mutex_init(&(*channel)->dtmf_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&(*channel)->flag_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&(*channel)->state_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&(*channel)->thread_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&(*channel)->profile_mutex, SWITCH_MUTEX_NESTED0x1, pool);
(*channel)->hangup_cause = SWITCH_CAUSE_NONE;
(*channel)->name = "";
(*channel)->direction = (*channel)->logical_direction = direction;
switch_channel_set_variable(*channel, "direction", switch_channel_direction(*channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound")switch_channel_set_variable_var_check(*channel, "direction", switch_channel_direction
(*channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound"
, SWITCH_TRUE);

return SWITCH_STATUS_SUCCESS;
474}

476SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_dtmf_lock(switch_channel_t *channel)
477{
return switch_mutex_lock(channel->dtmf_mutex);
479}

481SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_try_dtmf_lock(switch_channel_t *channel)
482{
return switch_mutex_trylock(channel->dtmf_mutex);
484}

486SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_dtmf_unlock(switch_channel_t *channel)
487{
return switch_mutex_unlock(channel->dtmf_mutex);
489}

491SWITCH_DECLARE(switch_size_t)__attribute__((visibility("default"))) switch_size_t switch_channel_has_dtmf(switch_channel_t *channel)
492{
switch_size_t has;

switch_mutex_lock(channel->dtmf_mutex);
has = switch_queue_size(channel->dtmf_queue);
switch_mutex_unlock(channel->dtmf_mutex);

return has;
500}

502SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_queue_dtmf(switch_channel_t *channel, const switch_dtmf_t *dtmf)
503{
switch_status_t status;
void *pop;
switch_dtmf_t new_dtmf = { 0 };
switch_bool_t sensitive = switch_true(switch_channel_get_variable_dup(channel, SWITCH_SENSITIVE_DTMF_VARIABLE"sensitive_dtmf", SWITCH_FALSE, -1));

switch_assert(dtmf)((dtmf) ? (void) (0) : __assert_fail ("dtmf", "src/switch_channel.c"
, 509, __extension__ __PRETTY_FUNCTION__));

switch_mutex_lock(channel->dtmf_mutex);
new_dtmf = *dtmf;

if (sensitive) {
switch_set_flag((&new_dtmf), DTMF_FLAG_SENSITIVE)((&new_dtmf))->flags |= (DTMF_FLAG_SENSITIVE);
}

if ((status = switch_core_session_recv_dtmf(channel->session, dtmf) != SWITCH_STATUS_SUCCESS)) {
goto done;
}

if (is_dtmf(new_dtmf.digit)((new_dtmf.digit > 47 && new_dtmf.digit < 58) ||
 (new_dtmf.digit > 64 && new_dtmf.digit < 69) ||
 (new_dtmf.digit > 96 && new_dtmf.digit < 101) ||
 new_dtmf.digit == 35 || new_dtmf.digit == 42 || new_dtmf.digit
 == 87 || new_dtmf.digit == 119 || new_dtmf.digit == 70 || new_dtmf
.digit == 102)) {
switch_dtmf_t *dt;
int x = 0;

if (!sensitive) {
	switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 527, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_INFO, "RECV DTMF %c:%d\n", new_dtmf.digit, new_dtmf.duration);
}

if (new_dtmf.digit != 'w' && new_dtmf.digit != 'W') {
	if (new_dtmf.duration > switch_core_max_dtmf_duration(0)) {
		switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 532, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "%s EXCESSIVE DTMF DIGIT LEN [%d]\n",
						  switch_channel_get_name(channel), new_dtmf.duration);
		new_dtmf.duration = switch_core_max_dtmf_duration(0);
	} else if (new_dtmf.duration < switch_core_min_dtmf_duration(0)) {
		switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 536, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "%s SHORT DTMF DIGIT LEN [%d]\n",
						  switch_channel_get_name(channel), new_dtmf.duration);
		new_dtmf.duration = switch_core_min_dtmf_duration(0);
	}
}

if (!new_dtmf.duration) {
	new_dtmf.duration = switch_core_default_dtmf_duration(0);
}


switch_zmalloc(dt, sizeof(*dt))(void)((((dt = switch_calloc(1, (sizeof(*dt))))) ? (void) (0)
 : __assert_fail ("(dt = switch_calloc(1, (sizeof(*dt))))", "src/switch_channel.c"
, 547, __extension__ __PRETTY_FUNCTION__)),dt);
*dt = new_dtmf;


while (switch_queue_trypush(channel->dtmf_queue, dt) != SWITCH_STATUS_SUCCESS) {
	if (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
		free(pop);
	}
	if (++x > 100) {
		status = SWITCH_STATUS_FALSE;
		free(dt);
		goto done;
	}
}
}

status = SWITCH_STATUS_SUCCESS;

done:

switch_mutex_unlock(channel->dtmf_mutex);

switch_core_media_break(channel->session, SWITCH_MEDIA_TYPE_AUDIO);

return status;
572}

574SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_queue_dtmf_string(switch_channel_t *channel, const char *dtmf_string)
575{
char *p;
switch_dtmf_t dtmf = { 0, switch_core_default_dtmf_duration(0), 0, SWITCH_DTMF_APP };
int sent = 0, dur, bad_input = 0;
char *string;
int i, argc;
char *argv[256];

if (zstr(dtmf_string)_zstr(dtmf_string)) {
return SWITCH_STATUS_GENERR;
}


dtmf.flags = DTMF_FLAG_SKIP_PROCESS;

if (*dtmf_string == '~') {
dtmf_string++;
dtmf.flags = 0;
}

string = switch_core_session_strdup(channel->session, dtmf_string)switch_core_perform_session_strdup(channel->session, dtmf_string
, "src/switch_channel.c", (const char *)__func__, 595);
argc = switch_separate_string(string, '+', argv, (sizeof(argv) / sizeof(argv[0])));

for (i = 0; i < argc; i++) {
dtmf.duration = switch_core_default_dtmf_duration(0);
dur = switch_core_default_dtmf_duration(0) / 8;
if ((p = strchr(argv[i], '@'))) {
	*p++ = '\0';
	if ((dur = atoi(p)) > (int)switch_core_min_dtmf_duration(0) / 8) {
		dtmf.duration = dur * 8;
	}
}

for (p = argv[i]; p && *p; p++) {
	if (is_dtmf(*p)((*p > 47 && *p < 58) || (*p > 64 &&
 *p < 69) || (*p > 96 && *p < 101) || *p == 35
 || *p == 42 || *p == 87 || *p == 119 || *p == 70 || *p == 102
)) {
		dtmf.digit = *p;

		if (dtmf.duration > switch_core_max_dtmf_duration(0)) {
			switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 613, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_WARNING, "EXCESSIVE DTMF DIGIT LEN %c %d\n", dtmf.digit, dtmf.duration);
			dtmf.duration = switch_core_max_dtmf_duration(0);
		} else if (dtmf.duration < switch_core_min_dtmf_duration(0)) {
			switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 616, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_WARNING, "SHORT DTMF DIGIT LEN %c %d\n", dtmf.digit, dtmf.duration);
			dtmf.duration = switch_core_min_dtmf_duration(0);
		} else if (!dtmf.duration) {
			dtmf.duration = switch_core_default_dtmf_duration(0);
		}

		if (switch_channel_queue_dtmf(channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
			switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 623, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "%s Queue dtmf\ndigit=%c ms=%u samples=%u\n",
							  switch_channel_get_name(channel), dtmf.digit, dur, dtmf.duration);
			sent++;
		}
	} else {
		bad_input++;
	}
}

}
if (sent) {
return SWITCH_STATUS_SUCCESS;
}
return bad_input ? SWITCH_STATUS_GENERR : SWITCH_STATUS_FALSE;
637}

639SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_dequeue_dtmf(switch_channel_t *channel, switch_dtmf_t *dtmf)
640{
switch_event_t *event;
void *pop;
switch_dtmf_t *dt;
switch_status_t status = SWITCH_STATUS_FALSE;
int sensitive = 0;

switch_mutex_lock(channel->dtmf_mutex);

if (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
dt = (switch_dtmf_t *) pop;
*dtmf = *dt;
sensitive = switch_test_flag(dtmf, DTMF_FLAG_SENSITIVE)((dtmf)->flags & DTMF_FLAG_SENSITIVE);

if (!sensitive && switch_queue_trypush(channel->dtmf_log_queue, dt) != SWITCH_STATUS_SUCCESS) {
	free(dt);
}

dt = NULL((void*)0);

if (dtmf->duration > switch_core_max_dtmf_duration(0)) {
	switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 661, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_WARNING, "%s EXCESSIVE DTMF DIGIT [%c] LEN [%d]\n",
					  switch_channel_get_name(channel), sensitive ? 'S' : dtmf->digit, dtmf->duration);
	dtmf->duration = switch_core_max_dtmf_duration(0);
} else if (dtmf->duration < switch_core_min_dtmf_duration(0)) {
	switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 665, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_WARNING, "%s SHORT DTMF DIGIT [%c] LEN [%d]\n",
					  switch_channel_get_name(channel), sensitive ? 'S' : dtmf->digit, dtmf->duration);
	dtmf->duration = switch_core_min_dtmf_duration(0);
} else if (!dtmf->duration) {
	dtmf->duration = switch_core_default_dtmf_duration(0);
}

status = SWITCH_STATUS_SUCCESS;
}
switch_mutex_unlock(channel->dtmf_mutex);

if (!sensitive && status == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_DTMF)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 676, &event, SWITCH_EVENT_DTMF
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
const char *dtmf_source_str = NULL((void*)0);
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-Duration", "%u", dtmf->duration);
switch(dtmf->source) {
	case SWITCH_DTMF_INBAND_AUDIO:	/* From audio */
		dtmf_source_str = "INBAND_AUDIO";
		break;
	case SWITCH_DTMF_RTP:			/* From RTP as a telephone event */
		dtmf_source_str = "RTP";
		break;
	case SWITCH_DTMF_ENDPOINT:		/* From endpoint signaling */
		dtmf_source_str = "ENDPOINT";
		break;
	case SWITCH_DTMF_APP:			/* Injected by application */
		dtmf_source_str = "APP";
		break;
	case SWITCH_DTMF_UNKNOWN:		/* Unknown source */
	default:
		dtmf_source_str = "UNKNOWN";
		break;
}
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Source", "%s", dtmf_source_str);
if (switch_channel_test_flag(channel, CF_DIVERT_EVENTS)) {
	switch_core_session_queue_event(channel->session, &event);
} else {
	switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 703, &event, ((void*)0));
}
}

return status;
708}

710SWITCH_DECLARE(switch_size_t)__attribute__((visibility("default"))) switch_size_t switch_channel_dequeue_dtmf_string(switch_channel_t *channel, char *dtmf_str, switch_size_t len)
711{
switch_size_t x = 0;
switch_dtmf_t dtmf = { 0 };

memset(dtmf_str, 0, len);

while (x < len - 1 && switch_channel_dequeue_dtmf(channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
dtmf_str[x++] = dtmf.digit;
}

return x;

723}

725SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_flush_dtmf(switch_channel_t *channel)
726{
void *pop;

switch_mutex_lock(channel->dtmf_mutex);
while (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
switch_dtmf_t *dt = (switch_dtmf_t *) pop;
if (channel->state >= CS_HANGUP || switch_queue_trypush(channel->dtmf_log_queue, dt) != SWITCH_STATUS_SUCCESS) {
	free(dt);
}
}
switch_mutex_unlock(channel->dtmf_mutex);
737}

739SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_uninit(switch_channel_t *channel)
740{
void *pop;
switch_channel_flush_dtmf(channel);
while (switch_queue_trypop(channel->dtmf_log_queue, &pop) == SWITCH_STATUS_SUCCESS) {
switch_safe_free(pop)if (pop) {free(pop);pop=((void*)0);};
}

if (channel->private_hash) {
switch_core_hash_destroy(&channel->private_hash);
}

if (channel->app_flag_hash) {
switch_core_hash_destroy(&channel->app_flag_hash);
}

switch_mutex_lock(channel->profile_mutex);
switch_event_destroy(&channel->variables);
switch_event_destroy(&channel->api_list);
switch_event_destroy(&channel->var_list);
switch_event_destroy(&channel->app_list);
if (channel->log_tags) {
switch_event_destroy(&channel->log_tags);
}
switch_mutex_unlock(channel->profile_mutex);
764}

766SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_init(switch_channel_t *channel, switch_core_session_t *session, switch_channel_state_t state,
											switch_channel_flag_t flag)
768{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 769, __extension__ __PRETTY_FUNCTION__
));
channel->state = state;
switch_channel_set_flag(channel, flag)switch_channel_set_flag_value(channel, flag, 1);
channel->session = session;
channel->running_state = CS_NONE;
return SWITCH_STATUS_SUCCESS;
775}

777SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_perform_presence(switch_channel_t *channel, const char *rpid, const char *status, const char *id,
											 const char *file, const char *func, int line)
779{
switch_event_t *event;
switch_event_types_t type = SWITCH_EVENT_PRESENCE_IN;
const char *call_info = NULL((void*)0);
char *call_info_state = "active";

if (switch_channel_test_flag(channel, CF_NO_PRESENCE)) {
return;
}

if (!status) {
type = SWITCH_EVENT_PRESENCE_OUT;
status = "idle";
}

if (!id) {
id = switch_channel_get_variable(channel, "presence_id")switch_channel_get_variable_dup(channel, "presence_id", SWITCH_TRUE
, -1);
}

if (!id) {
return;
}

call_info = switch_channel_get_variable(channel, "presence_call_info")switch_channel_get_variable_dup(channel, "presence_call_info"
, SWITCH_TRUE, -1);

if (switch_event_create(&event, type)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 804, &event, type
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", "any");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", __FILE__"src/switch_channel.c");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from", id);
if (type == SWITCH_EVENT_PRESENCE_IN) {
	if (!rpid) {
		rpid = "unknown";
	}
	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", rpid);
	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", status);
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");


if (!strcasecmp(status, "idle") || !switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
	call_info_state = "idle";
} else if (!strcasecmp(status, "hold-private")) {
	call_info_state = "held-private";
} else if (!strcasecmp(status, "hold")) {
	call_info_state = "held";
} else if (!switch_channel_test_flag(channel, CF_ANSWERED)) {
	if (channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND) {
		call_info_state = "progressing";
	} else {
		if (switch_channel_test_flag(channel, CF_SLA_INTERCEPT)) {
			call_info_state = "idle";
		} else {
			call_info_state = "alerting";
		}
	}
}

switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-info-state", call_info_state);

if (call_info) {
	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-info", call_info);
}

switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-direction",
							   channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");

switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", channel->event_count++);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Calling-File", file);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Calling-Function", func);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Presence-Calling-Line", "%d", line);

if (switch_true(switch_channel_get_variable(channel, "presence_privacy")switch_channel_get_variable_dup(channel, "presence_privacy", SWITCH_TRUE
, -1))) {
	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Privacy", "true");
}

switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 856, &event, ((void*)0));
}
858}

860SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_mark_hold(switch_channel_t *channel, switch_bool_t on)
861{
switch_event_t *event;

if (!!on == !!switch_channel_test_flag(channel, CF_LEG_HOLDING)) {
goto end;
}

if (on) {
switch_channel_set_flag(channel, CF_LEG_HOLDING)switch_channel_set_flag_value(channel, CF_LEG_HOLDING, 1);
} else {
switch_channel_clear_flag(channel, CF_LEG_HOLDING);
}

if (switch_event_create(&event, on ? SWITCH_EVENT_CHANNEL_HOLD : SWITCH_EVENT_CHANNEL_UNHOLD)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 874, &event, on ?
 SWITCH_EVENT_CHANNEL_HOLD : SWITCH_EVENT_CHANNEL_UNHOLD, ((void
*)0)) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event);
switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 876, &event, ((void*)0));
}

end:

if (on) {
if (switch_true(switch_channel_get_variable(channel, "flip_record_on_hold")switch_channel_get_variable_dup(channel, "flip_record_on_hold"
, SWITCH_TRUE, -1))) {
	switch_core_session_t *other_session;
	if (switch_core_session_get_partner(channel->session, &other_session)switch_core_session_perform_get_partner(channel->session, &
other_session, "src/switch_channel.c", (const char *)__func__
, 884) == SWITCH_STATUS_SUCCESS) {
		switch_ivr_transfer_recordings(channel->session, other_session);
		switch_core_session_rwunlock(other_session);
	}
}
}

891}

893SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_get_hold_music(switch_channel_t *channel)
894{
const char *var;

if (!(var = switch_channel_get_variable(channel, SWITCH_TEMP_HOLD_MUSIC_VARIABLE)switch_channel_get_variable_dup(channel, "temp_hold_music", SWITCH_TRUE
, -1))) {
var = switch_channel_get_variable(channel, SWITCH_HOLD_MUSIC_VARIABLE)switch_channel_get_variable_dup(channel, "hold_music", SWITCH_TRUE
, -1);
}

if (!zstr(var)_zstr(var)) {
char *expanded = switch_channel_expand_variables(channel, var)switch_channel_expand_variables_check(channel, var, ((void*)0
), ((void*)0), 0);

if (expanded != var) {
	var = switch_core_session_strdup(channel->session, expanded)switch_core_perform_session_strdup(channel->session, expanded
, "src/switch_channel.c", (const char *)__func__, 905);
	free(expanded);
}
}


return var;
912}

914SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_get_hold_music_partner(switch_channel_t *channel)
915{
switch_core_session_t *session;
const char *r = NULL((void*)0);

if (switch_core_session_get_partner(channel->session, &session)switch_core_session_perform_get_partner(channel->session, &
session, "src/switch_channel.c", (const char *)__func__, 919) == SWITCH_STATUS_SUCCESS) {
r = switch_channel_get_hold_music(switch_core_session_get_channel(session));
switch_core_session_rwunlock(session);
}

return r;
925}

927SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_scope_variables(switch_channel_t *channel, switch_event_t **event)
928{
switch_mutex_lock(channel->profile_mutex);

if (event && *event) { /* push */
(*event)->next = channel->scope_variables;
channel->scope_variables = *event;
*event = NULL((void*)0);
} else if (channel->scope_variables) { /* pop */
switch_event_t *top_event = channel->scope_variables;
channel->scope_variables = channel->scope_variables->next;
switch_event_destroy(&top_event);
}

switch_mutex_unlock(channel->profile_mutex);

943}

945SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_get_scope_variables(switch_channel_t *channel, switch_event_t **event)
946{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_event_t *new_event;

switch_mutex_lock(channel->profile_mutex);
if (channel->scope_variables) {
switch_event_t *ep;
switch_event_header_t *hp;

switch_event_create_plain(&new_event, SWITCH_EVENT_CHANNEL_DATA);
status = SWITCH_STATUS_SUCCESS;
*event = new_event;

for (ep = channel->scope_variables; ep; ep = ep->next) {
	for (hp = ep->headers; hp; hp = hp->next) {
		if (!switch_event_get_header(new_event, hp->value)switch_event_get_header_idx(new_event, hp->value, -1)) {
			switch_event_add_header_string(new_event, SWITCH_STACK_BOTTOM, hp->name, hp->value);
		}
	}
}
}
switch_mutex_unlock(channel->profile_mutex);

return status;
970}

972SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_get_variable_dup(switch_channel_t *channel, const char *varname, switch_bool_t dup, int idx)
973{
const char *v = NULL((void*)0), *r = NULL((void*)0), *vdup = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 975, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);

if (!zstr(varname)_zstr(varname)) {
if (channel->scope_variables) {
	switch_event_t *ep;

	for (ep = channel->scope_variables; ep; ep = ep->next) {
		if ((v = switch_event_get_header_idx(ep, varname, idx))) {
			break;
		}
	}
}

if (!v && (!channel->variables || !(v = switch_event_get_header_idx(channel->variables, varname, idx)))) {
	switch_caller_profile_t *cp = switch_channel_get_caller_profile(channel);

	if (cp) {
		if (!strncmp(varname, "aleg_", 5)) {
			cp = cp->originator_caller_profile;
			varname += 5;
		} else if (!strncmp(varname, "bleg_", 5)) {
			cp = cp->originatee_caller_profile;
			varname += 5;
		}
	}

	if (!cp || !(v = switch_caller_get_field_by_name(cp, varname))) {
		if ((vdup = switch_core_get_variable_pdup(varname, switch_core_session_get_pool(channel->session)))) {
			v = vdup;
		}
	}
}
}

if (dup && v != vdup) {
if (v) {
	r = switch_core_session_strdup(channel->session, v)switch_core_perform_session_strdup(channel->session, v, "src/switch_channel.c"
, (const char *)__func__, 1013);
}
} else {
r = v;
}

switch_mutex_unlock(channel->profile_mutex);

return r;
1022}

1024SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_get_variable_partner(switch_channel_t *channel, const char *varname)
1025{
const char *uuid;
const char *val = NULL((void*)0), *r = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1028, __extension__ __PRETTY_FUNCTION__
));

if (!zstr(varname)_zstr(varname)) {
if ((uuid = switch_channel_get_partner_uuid(channel))) {
	switch_core_session_t *session;
	if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1033))) {
		switch_channel_t *tchannel = switch_core_session_get_channel(session);
		val = switch_channel_get_variable(tchannel, varname)switch_channel_get_variable_dup(tchannel, varname, SWITCH_TRUE
, -1);
		switch_core_session_rwunlock(session);
	}
}
}

if (val)
r = switch_core_session_strdup(channel->session, val)switch_core_perform_session_strdup(channel->session, val, "src/switch_channel.c"
, (const char *)__func__, 1042);

return r;
1045}


1048SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_variable_last(switch_channel_t *channel)
1049{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1050, __extension__ __PRETTY_FUNCTION__
));
if (!channel->vi) {
return;
}
channel->vi = 0;
switch_mutex_unlock(channel->profile_mutex);

1057}

1059SWITCH_DECLARE(switch_event_header_t *)__attribute__((visibility("default"))) switch_event_header_t * switch_channel_variable_first(switch_channel_t *channel)
1060{
switch_event_header_t *hi = NULL((void*)0);

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1063, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->profile_mutex);
if (channel->variables && (hi = channel->variables->headers)) {
channel->vi = 1;
} else {
switch_mutex_unlock(channel->profile_mutex);
}

return hi;
1072}

1074SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_private(switch_channel_t *channel, const char *key, const void *private_info)
1075{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1076, __extension__ __PRETTY_FUNCTION__
));
switch_core_hash_insert_locked(channel->private_hash, key, private_info, channel->profile_mutex);
return SWITCH_STATUS_SUCCESS;
1079}

1081SWITCH_DECLARE(void *)__attribute__((visibility("default"))) void * switch_channel_get_private(switch_channel_t *channel, const char *key)
1082{
void *val;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1084, __extension__ __PRETTY_FUNCTION__
));
val = switch_core_hash_find_locked(channel->private_hash, key, channel->profile_mutex);
return val;
1087}

1089SWITCH_DECLARE(void *)__attribute__((visibility("default"))) void * switch_channel_get_private_partner(switch_channel_t *channel, const char *key)
1090{
const char *uuid;
void *val = NULL((void*)0);

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1094, __extension__ __PRETTY_FUNCTION__
));

if ((uuid = switch_channel_get_partner_uuid(channel))) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1098))) {
	val = switch_core_hash_find_locked(channel->private_hash, key, channel->profile_mutex);
	switch_core_session_rwunlock(session);
}
}

return val;
1105}

1107SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_name(switch_channel_t *channel, const char *name)
1108{
const char *old = NULL((void*)0);

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1111, __extension__ __PRETTY_FUNCTION__
));
if (!zstr(channel->name)_zstr(channel->name)) {
old = channel->name;
}
channel->name = NULL((void*)0);
if (name) {
char *uuid = switch_core_session_get_uuid(channel->session);
channel->name = switch_core_session_strdup(channel->session, name)switch_core_perform_session_strdup(channel->session, name,
 "src/switch_channel.c", (const char *)__func__, 1118);
switch_channel_set_variable(channel, SWITCH_CHANNEL_NAME_VARIABLE, name)switch_channel_set_variable_var_check(channel, "channel_name"
, name, SWITCH_TRUE);
if (old) {
	switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1121, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_NOTICE, "Rename Channel %s->%s [%s]\n", old, name, uuid);
} else {
	switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1123, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_NOTICE, "New Channel %s [%s]\n", name, uuid);
}
}
return SWITCH_STATUS_SUCCESS;
1127}

1129SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_channel_get_name(switch_channel_t *channel)
1130{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1131, __extension__ __PRETTY_FUNCTION__
));
return (!zstr(channel->name)_zstr(channel->name)) ? channel->name : "N/A";
1133}

1135SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_profile_var(switch_channel_t *channel, const char *name, const char *val)
1136{
char *v;
switch_status_t status = SWITCH_STATUS_SUCCESS;

switch_mutex_lock(channel->profile_mutex);


if (!strcasecmp(name, "device_id") && !zstr(val)_zstr(val)) {
const char *device_id;
if (!(device_id = switch_channel_set_device_id(channel, val))) {
	/* one time setting */
	switch_mutex_unlock(channel->profile_mutex);
	return status;
}

val = device_id;
}

if (!zstr(val)_zstr(val)) {
v = switch_core_strdup(channel->caller_profile->pool, val)switch_core_perform_strdup(channel->caller_profile->pool
, val, "src/switch_channel.c", (const char *)__func__, 1155);
} else {
v = SWITCH_BLANK_STRING"";
}

if (!strcasecmp(name, "dialplan")) {
channel->caller_profile->dialplan = v;
} else if (!strcasecmp(name, "username")) {
channel->caller_profile->username = v;
} else if (!strcasecmp(name, "caller_id_name")) {
channel->caller_profile->caller_id_name = v;
} else if (!strcasecmp(name, "caller_id_number")) {
channel->caller_profile->caller_id_number = v;
} else if (!strcasecmp(name, "callee_id_name")) {
channel->caller_profile->callee_id_name = v;
} else if (!strcasecmp(name, "callee_id_number")) {
channel->caller_profile->callee_id_number = v;
} else if (val && !strcasecmp(name, "caller_ton")) {
channel->caller_profile->caller_ton = (uint8_t) atoi(v);
} else if (val && !strcasecmp(name, "caller_numplan")) {
channel->caller_profile->caller_numplan = (uint8_t) atoi(v);
} else if (val && !strcasecmp(name, "destination_number_ton")) {
channel->caller_profile->destination_number_ton = (uint8_t) atoi(v);
} else if (val && !strcasecmp(name, "destination_number_numplan")) {
channel->caller_profile->destination_number_numplan = (uint8_t) atoi(v);
} else if (!strcasecmp(name, "ani")) {
channel->caller_profile->ani = v;
} else if (!strcasecmp(name, "aniii")) {
channel->caller_profile->aniii = v;
} else if (!strcasecmp(name, "network_addr")) {
channel->caller_profile->network_addr = v;
} else if (!strcasecmp(name, "rdnis")) {
channel->caller_profile->rdnis = v;
} else if (!strcasecmp(name, "destination_number")) {
channel->caller_profile->destination_number = v;
} else if (!strcasecmp(name, "uuid")) {
channel->caller_profile->uuid = v;
} else if (!strcasecmp(name, "source")) {
channel->caller_profile->source = v;
} else if (!strcasecmp(name, "context")) {
channel->caller_profile->context = v;
} else if (!strcasecmp(name, "chan_name")) {
channel->caller_profile->chan_name = v;
} else {
profile_node_t *pn, *n = switch_core_alloc(channel->caller_profile->pool, sizeof(*n))switch_core_perform_alloc(channel->caller_profile->pool
, sizeof(*n), "src/switch_channel.c", (const char *)__func__,
 1199);
int var_found;

n->var = switch_core_strdup(channel->caller_profile->pool, name)switch_core_perform_strdup(channel->caller_profile->pool
, name, "src/switch_channel.c", (const char *)__func__, 1202);
n->val = v;

if (!channel->caller_profile->soft) {
	channel->caller_profile->soft = n;
} else {
	var_found = 0;

	for(pn = channel->caller_profile->soft; pn ; pn = pn->next) {
		if (!strcasecmp(pn->var,n->var)) {
			pn->val = n->val;
			var_found = 1;
			break;
		}

		if(!pn->next) {
			break;
		}
	}

	if (pn && !pn->next && !var_found) {
		pn->next = n;
	}
}
}
switch_mutex_unlock(channel->profile_mutex);

return status;
1230}


1233SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_process_export(switch_channel_t *channel, switch_channel_t *peer_channel,
										   switch_event_t *var_event, const char *export_varname)
1235{

const char *export_vars = switch_channel_get_variable(channel, export_varname)switch_channel_get_variable_dup(channel, export_varname, SWITCH_TRUE
, -1);
char *cptmp = switch_core_session_strdup(channel->session, export_vars)switch_core_perform_session_strdup(channel->session, export_vars
, "src/switch_channel.c", (const char *)__func__, 1238);
int argc;
char *argv[256];

if (zstr(export_vars)_zstr(export_vars)) return;


if (var_event) {
switch_event_del_header(var_event, export_varname)switch_event_del_header_val(var_event, export_varname, ((void
*)0));
switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, export_varname, export_vars);
}

if (peer_channel) {
switch_channel_set_variable(peer_channel, export_varname, export_vars)switch_channel_set_variable_var_check(peer_channel, export_varname
, export_vars, SWITCH_TRUE);
}

if ((argc = switch_separate_string(cptmp, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
int x;

for (x = 0; x < argc; x++) {
	const char *vval;
	if ((vval = switch_channel_get_variable(channel, argv[x])switch_channel_get_variable_dup(channel, argv[x], SWITCH_TRUE
, -1))) {
		char *vvar = argv[x];
		if (!strncasecmp(vvar, "nolocal:", 8)) { /* remove this later ? */
			vvar += 8;
		} else if (!strncasecmp(vvar, "_nolocal_", 9)) {
			vvar += 9;
		}
		if (var_event) {
			switch_event_del_header(var_event, vvar)switch_event_del_header_val(var_event, vvar, ((void*)0));
			switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, vvar, vval);
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1269, (const char*)(channel->session), SWITCH_LOG_DEBUG,
							  "%s EXPORTING[%s] [%s]=[%s] to event\n",
							  switch_channel_get_name(channel),
							  export_varname,
							  vvar, vval);
		}
		if (peer_channel) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1276, (const char*)(channel->session), SWITCH_LOG_DEBUG,
							  "%s EXPORTING[%s] [%s]=[%s] to %s\n",
							  switch_channel_get_name(channel),
							  export_varname,
							  vvar, vval, switch_channel_get_name(peer_channel));
			switch_channel_set_variable(peer_channel, vvar, vval)switch_channel_set_variable_var_check(peer_channel, vvar, vval
, SWITCH_TRUE);
		}
	}
}
}


1288}

1290SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_export_variable_var_check(switch_channel_t *channel,
																 const char *varname, const char *val,
																 const char *export_varname, switch_bool_t var_check)
1293{
char *var_name = NULL((void*)0);
const char *exports;
char *var, *new_exports, *new_exports_d = NULL((void*)0);
int local = 1;

exports = switch_channel_get_variable(channel, export_varname)switch_channel_get_variable_dup(channel, export_varname, SWITCH_TRUE
, -1);

var = switch_core_session_strdup(channel->session, varname)switch_core_perform_session_strdup(channel->session, varname
, "src/switch_channel.c", (const char *)__func__, 1301);

if (var) {
if (!strncasecmp(var, "nolocal:", 8)) { /* remove this later ? */
	var_name = var + 8;
	local = 0;
} else if (!strncasecmp(var, "_nolocal_", 9)) {
	var_name = var + 9;
	local = 0;
} else {
	var_name = var;
}
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1315, (const char*)(channel->session), SWITCH_LOG_DEBUG, "EXPORT (%s) %s[%s]=[%s]\n",
			  export_varname, local ? "" : "(REMOTE ONLY) ",
			  var_name ? var_name : "", val ? val : "UNDEF");


switch_channel_set_variable_var_check(channel, var, val, var_check);

if (var && val) {
if (exports) {
	new_exports_d = switch_mprintf("%s,%s", exports, var);
	new_exports = new_exports_d;
} else {
	new_exports = var;
}

switch_channel_set_variable(channel, export_varname, new_exports)switch_channel_set_variable_var_check(channel, export_varname
, new_exports, SWITCH_TRUE);

switch_safe_free(new_exports_d)if (new_exports_d) {free(new_exports_d);new_exports_d=((void*
)0);};
}

return SWITCH_STATUS_SUCCESS;
1336}

1338SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_export_variable_printf(switch_channel_t *channel, const char *varname,
															  const char *export_varname, const char *fmt, ...)
1340{
switch_status_t status = SWITCH_STATUS_FALSE;
char *data = NULL((void*)0);
va_list ap;
int ret;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1346, __extension__ __PRETTY_FUNCTION__
));

va_start(ap, fmt)__builtin_va_start(ap, fmt);
ret = switch_vasprintf(&data, fmt, ap);
va_end(ap)__builtin_va_end(ap);

if (ret == -1) {
return SWITCH_STATUS_FALSE;
}

status = switch_channel_export_variable(channel, varname, data, export_varname)switch_channel_export_variable_var_check(channel, varname, data
, export_varname, SWITCH_TRUE);

free(data);

return status;
1361}


1364SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_channel_del_variable_prefix(switch_channel_t *channel, const char *prefix)
1365{
switch_event_t *event;
switch_event_header_t *hp;
uint32_t r = 0;

switch_channel_get_variables(channel, &event);

if (event) {
for (hp = event->headers; hp; hp = hp->next) {
	if (zstr(prefix)_zstr(prefix) || !strncasecmp(hp->name, prefix, strlen(prefix))) {
		switch_channel_set_variable(channel, hp->name, NULL)switch_channel_set_variable_var_check(channel, hp->name, (
(void*)0), SWITCH_TRUE);
	}
}
}

switch_event_destroy(&event);

return r;
1383}

1385SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_transfer_variable_prefix(switch_channel_t *orig_channel, switch_channel_t *new_channel, const char *prefix)
1386{
switch_event_header_t *hi = NULL((void*)0);
int x = 0;

if ((hi = switch_channel_variable_first(orig_channel))) {
for (; hi; hi = hi->next) {
	char *var = hi->name;
	char *val = hi->value;

	if (zstr(prefix)_zstr(prefix) || !strncasecmp(var, prefix, strlen(prefix))) {
		x++;
		switch_channel_set_variable(new_channel, var, val)switch_channel_set_variable_var_check(new_channel, var, val, SWITCH_TRUE
);
	}
}
switch_channel_variable_last(orig_channel);
}

return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
1404}

1406SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_presence_data_vals(switch_channel_t *channel, const char *presence_data_cols)
1407{
char *cols[128] = { 0 };
char header_name[128] = "";
int col_count = 0, i = 0;
char *data_copy = NULL((void*)0);

if (zstr(presence_data_cols)_zstr(presence_data_cols)) {
presence_data_cols = switch_channel_get_variable_dup(channel, "presence_data_cols", SWITCH_FALSE, -1);
if (zstr(presence_data_cols)_zstr(presence_data_cols)) {
	return;
}
}

data_copy = strdup(presence_data_cols);

col_count = switch_split(data_copy, ':', cols)switch_separate_string(data_copy, ':', cols, (sizeof(cols) / sizeof
(cols[0])));

for (i = 0; i < col_count; i++) {
const char *val = NULL((void*)0);
switch_snprintf(header_name, sizeof(header_name), "PD-%s", cols[i]);
val = switch_channel_get_variable(channel, cols[i])switch_channel_get_variable_dup(channel, cols[i], SWITCH_TRUE
, -1);
switch_channel_set_profile_var(channel, header_name, val);
}

switch_safe_free(data_copy)if (data_copy) {free(data_copy);data_copy=((void*)0);};
1432}

1434SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_log_tag(switch_channel_t *channel, const char *tagname, const char *tagvalue)
1435{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1437, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->profile_mutex);
if (!zstr(tagname)_zstr(tagname)) {
if (!channel->log_tags) {
	switch_event_create_plain(&channel->log_tags, SWITCH_EVENT_CHANNEL_DATA);
}
if (zstr(tagvalue)_zstr(tagvalue)) {
	switch_event_del_header(channel->log_tags, tagname)switch_event_del_header_val(channel->log_tags, tagname, ((
void*)0));
} else {
	switch_event_add_header_string(channel->log_tags, SWITCH_STACK_BOTTOM, tagname, tagvalue);
}
status = SWITCH_STATUS_SUCCESS;
}
switch_mutex_unlock(channel->profile_mutex);
return status;
1452}

1454SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_get_log_tags(switch_channel_t *channel, switch_event_t **log_tags)
1455{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1457, __extension__ __PRETTY_FUNCTION__
));
if (!channel->log_tags) {
return status;
}
switch_mutex_lock(channel->profile_mutex);
if (channel->log_tags && log_tags) {
status = switch_event_dup(log_tags, channel->log_tags);
}
switch_mutex_unlock(channel->profile_mutex);
return status;
1467}

1469SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_variable_var_check(switch_channel_t *channel,
															  const char *varname, const char *value, switch_bool_t var_check)
1471{
switch_status_t status = SWITCH_STATUS_FALSE;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1474, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
if (channel->variables && !zstr(varname)_zstr(varname)) {
if (zstr(value)_zstr(value)) {
	switch_event_del_header(channel->variables, varname)switch_event_del_header_val(channel->variables, varname, (
(void*)0));
} else {
	int ok = 1;

	if (var_check) {
		ok = !switch_string_var_check_const(value);
	}
	if (ok) {
		switch_event_add_header_string(channel->variables, SWITCH_STACK_BOTTOM, varname, value);
	} else {
		switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1489, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_CRIT, "Invalid data (${%s} contains a variable)\n", varname);
	}
}
status = SWITCH_STATUS_SUCCESS;
}
switch_mutex_unlock(channel->profile_mutex);

return status;
1497}

1499SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_variable_strip_quotes_var_check(switch_channel_t *channel,
const char *varname, const char *value, switch_bool_t var_check)
1501{
switch_status_t status = SWITCH_STATUS_FALSE;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1504, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
if (channel->variables && !zstr(varname)_zstr(varname)) {
1
Assuming the condition is true→
2
←
Taking true branch→
if (zstr(value)_zstr(value)) {
3
←
Taking false branch→
	switch_event_del_header(channel->variables, varname)switch_event_del_header_val(channel->variables, varname, (
(void*)0));
} else {
	int ok = 1;
	char *t = (char *)value;
	char *r = (char *)value;

	if (t && *t == '"') {
4
←
Assuming the condition is true→
5
←
Taking true branch→
		t++;
		if (end_of(t)*(*t == '\0' ? t : t + strlen(t) - 1) == '"') {
6
←
Taking true branch→
			r = strdup(t);
7
←
Memory is allocated→
			switch_assert(r)((r) ? (void) (0) : __assert_fail ("r", "src/switch_channel.c"
, 1519, __extension__ __PRETTY_FUNCTION__));
8
←
Within the expansion of the macro 'switch_assert':
→
a
Assuming 'r' is non-null
			end_of(r)*(*r == '\0' ? r : r + strlen(r) - 1) = '\0';
		}
	}

	if (var_check) {
9
←
Assuming 'var_check' is 0→
10
←
Taking false branch→
		ok = !switch_string_var_check_const(r);
	}
	if (ok) {
11
←
Taking true branch→
		switch_event_add_header_string(channel->variables, SWITCH_STACK_BOTTOM, varname, r);
	} else {
		switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1530, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_CRIT, "Invalid data (${%s} contains a variable)\n", varname);
	}

	if (r != value) free(r);
12
←
Assuming 'r' is equal to 'value'→
13
←
Taking false branch→
}
status = SWITCH_STATUS_SUCCESS;
14
←
Potential leak of memory pointed to by 'r'
}
switch_mutex_unlock(channel->profile_mutex);

return status;
1540}

1542SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_add_variable_var_check(switch_channel_t *channel,
															  const char *varname, const char *value, switch_bool_t var_check, switch_stack_t stack)
1544{
switch_status_t status = SWITCH_STATUS_FALSE;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1547, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
if (channel->variables && !zstr(varname)_zstr(varname)) {
if (zstr(value)_zstr(value)) {
	switch_event_del_header(channel->variables, varname)switch_event_del_header_val(channel->variables, varname, (
(void*)0));
} else {
	int ok = 1;

	if (var_check) {
		ok = !switch_string_var_check_const(value);
	}
	if (ok) {
		switch_event_add_header_string(channel->variables, stack, varname, value);
	} else {
		switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 1562, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_CRIT, "Invalid data (${%s} contains a variable)\n", varname);
	}
}
status = SWITCH_STATUS_SUCCESS;
}
switch_mutex_unlock(channel->profile_mutex);

return status;
1570}


1573switch_status_t switch_event_base_add_header(switch_event_t *event, switch_stack_t stack, const char *header_name, char *data);

1575SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_variable_printf(switch_channel_t *channel, const char *varname, const char *fmt, ...)
1576{
int ret = 0;
char *data;
va_list ap;
switch_status_t status = SWITCH_STATUS_FALSE;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1582, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
if (channel->variables && !zstr(varname)_zstr(varname)) {
switch_event_del_header(channel->variables, varname)switch_event_del_header_val(channel->variables, varname, (
(void*)0));

va_start(ap, fmt)__builtin_va_start(ap, fmt);
ret = switch_vasprintf(&data, fmt, ap);
va_end(ap)__builtin_va_end(ap);

if (ret == -1) {
	switch_mutex_unlock(channel->profile_mutex);
	return SWITCH_STATUS_MEMERR;
}

status = switch_channel_set_variable(channel, varname, data)switch_channel_set_variable_var_check(channel, varname, data,
 SWITCH_TRUE);
free(data);
}
switch_mutex_unlock(channel->profile_mutex);

return status;
1603}


1606SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_variable_name_printf(switch_channel_t *channel, const char *val, const char *fmt, ...)
1607{
int ret = 0;
char *varname;
va_list ap;
switch_status_t status = SWITCH_STATUS_FALSE;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1613, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);

va_start(ap, fmt)__builtin_va_start(ap, fmt);
ret = switch_vasprintf(&varname, fmt, ap);
va_end(ap)__builtin_va_end(ap);

if (ret == -1) {
switch_mutex_unlock(channel->profile_mutex);
return SWITCH_STATUS_MEMERR;
}

status = switch_channel_set_variable(channel, varname, val)switch_channel_set_variable_var_check(channel, varname, val, SWITCH_TRUE
);

free(varname);

switch_mutex_unlock(channel->profile_mutex);

return status;
1633}


1636SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_variable_partner_var_check(switch_channel_t *channel,
																	  const char *varname, const char *value, switch_bool_t var_check)
1638{
const char *uuid;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1640, __extension__ __PRETTY_FUNCTION__
));

if (!zstr(varname)_zstr(varname)) {
if ((uuid = switch_channel_get_partner_uuid(channel))) {
	switch_core_session_t *session;
	if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1645))) {
		switch_channel_t *tchannel = switch_core_session_get_channel(session);
		switch_channel_set_variable_var_check(tchannel, varname, value, var_check);
		switch_core_session_rwunlock(session);
	}
	return SWITCH_STATUS_SUCCESS;
}
}

return SWITCH_STATUS_FALSE;
1655}

1657SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_channel_test_flag(switch_channel_t *channel, switch_channel_flag_t flag)
1658{
uint32_t r = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1661, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
r = channel->flags[flag];
switch_mutex_unlock(channel->flag_mutex);

return r;
1668}

1670SWITCH_DECLARE(switch_bool_t)__attribute__((visibility("default"))) switch_bool_t switch_channel_set_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag)
1671{
const char *uuid;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1674, __extension__ __PRETTY_FUNCTION__
));

if ((uuid = switch_channel_get_partner_uuid(channel))) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1678))) {
	switch_channel_set_flag(switch_core_session_get_channel(session), flag)switch_channel_set_flag_value(switch_core_session_get_channel
(session), flag, 1);
	switch_core_session_rwunlock(session);
	return SWITCH_TRUE;
}
}

return SWITCH_FALSE;
1686}

1688SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_channel_test_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag)
1689{
const char *uuid;
int r = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1693, __extension__ __PRETTY_FUNCTION__
));

if ((uuid = switch_channel_get_partner_uuid(channel))) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1697))) {
	r = switch_channel_test_flag(switch_core_session_get_channel(session), flag);
	switch_core_session_rwunlock(session);
}
}

return r;
1704}

1706SWITCH_DECLARE(switch_bool_t)__attribute__((visibility("default"))) switch_bool_t switch_channel_clear_flag_partner(switch_channel_t *channel, switch_channel_flag_t flag)
1707{
const char *uuid;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1710, __extension__ __PRETTY_FUNCTION__
));

if ((uuid = switch_channel_get_partner_uuid(channel))) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1714))) {
	switch_channel_clear_flag(switch_core_session_get_channel(session), flag);
	switch_core_session_rwunlock(session);
	return SWITCH_TRUE;
}
}

return SWITCH_FALSE;
1722}

1724SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_wait_for_state(switch_channel_t *channel, switch_channel_t *other_channel, switch_channel_state_t want_state)
1725{

switch_assert(channel)((channel) ? (void) (0) : __assert_fail ("channel", "src/switch_channel.c"
, 1727, __extension__ __PRETTY_FUNCTION__));

for (;;) {
if ((channel->state < CS_HANGUP && channel->state == channel->running_state && channel->running_state == want_state) ||
	(other_channel && switch_channel_down_nosig(other_channel)(switch_channel_get_state(other_channel) >= CS_HANGUP)) || switch_channel_down(channel)(switch_channel_check_signal(channel, SWITCH_TRUE) || switch_channel_get_state
(channel) >= CS_HANGUP)) {
	break;
}
switch_cond_next();
}
1736}


1739SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_wait_for_state_timeout(switch_channel_t *channel, switch_channel_state_t want_state, uint32_t timeout)
1740{

uint32_t count = 0;

for (;;) {

if ((channel->state == channel->running_state && channel->running_state == want_state) || channel->state >= CS_HANGUP) {
	break;
}

switch_channel_check_signal(channel, SWITCH_TRUE);

switch_cond_next();

if (++count >= timeout) {
	break;
}
}
1758}

1760SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_wait_for_flag(switch_channel_t *channel,
													 switch_channel_flag_t want_flag,
													 switch_bool_t pres, uint32_t to, switch_channel_t *super_channel)
1763{

if (to) {
to++;
}

for (;;) {
if (pres) {
	if (switch_channel_test_flag(channel, want_flag)) {
		break;
	}
} else {
	if (!switch_channel_test_flag(channel, want_flag)) {
		break;
	}
}

switch_cond_next();

if (super_channel && !switch_channel_ready(super_channel)switch_channel_test_ready(super_channel, SWITCH_TRUE, SWITCH_FALSE
)) {
	return SWITCH_STATUS_FALSE;
}

if (switch_channel_down(channel)(switch_channel_check_signal(channel, SWITCH_TRUE) || switch_channel_get_state
(channel) >= CS_HANGUP)) {
	return SWITCH_STATUS_FALSE;
}

if (to && !--to) {
	return SWITCH_STATUS_TIMEOUT;
}
}

return SWITCH_STATUS_SUCCESS;
1796}

1798SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_wait_for_app_flag(switch_channel_t *channel,
														 uint32_t app_flag,
														 const char *key, switch_bool_t pres, uint32_t to)
1801{
int r = 0;

if (to) {
to++;
}

for (;;) {
if (pres) {
	if ((r = switch_channel_test_app_flag_key(key, channel, app_flag))) {
		break;
	}
} else {
	if (!(r = switch_channel_test_app_flag_key(key, channel, app_flag))) {
		break;
	}
}

switch_cond_next();

if (switch_channel_down(channel)(switch_channel_check_signal(channel, SWITCH_TRUE) || switch_channel_get_state
(channel) >= CS_HANGUP)) {
	return r;
}

if (to && !--to) {
	return r;
}
}

return r;
1831}


1834SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_cap_value(switch_channel_t *channel, switch_channel_cap_t cap, uint32_t value)
1835{
switch_assert(channel)((channel) ? (void) (0) : __assert_fail ("channel", "src/switch_channel.c"
, 1836, __extension__ __PRETTY_FUNCTION__));
switch_assert(channel->flag_mutex)((channel->flag_mutex) ? (void) (0) : __assert_fail ("channel->flag_mutex"
, "src/switch_channel.c", 1837, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
channel->caps[cap] = value;
switch_mutex_unlock(channel->flag_mutex);
1842}

1844SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_cap(switch_channel_t *channel, switch_channel_cap_t cap)
1845{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1846, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->flag_mutex)((channel->flag_mutex) ? (void) (0) : __assert_fail ("channel->flag_mutex"
, "src/switch_channel.c", 1847, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
channel->caps[cap] = 0;
switch_mutex_unlock(channel->flag_mutex);
1852}

1854SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_channel_test_cap(switch_channel_t *channel, switch_channel_cap_t cap)
1855{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1856, __extension__ __PRETTY_FUNCTION__
));
return channel->caps[cap] ? 1 : 0;
1858}

1860SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_channel_test_cap_partner(switch_channel_t *channel, switch_channel_cap_t cap)
1861{
const char *uuid;
int r = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 1865, __extension__ __PRETTY_FUNCTION__
));

if ((uuid = switch_channel_get_partner_uuid(channel))) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 1869))) {
	r = switch_channel_test_cap(switch_core_session_get_channel(session), cap);
	switch_core_session_rwunlock(session);
}
}

return r;
1876}

1878SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_channel_get_flag_string(switch_channel_t *channel)
1879{
switch_stream_handle_t stream = { 0 };
char *r;
int i = 0;

SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "src/switch_channel.c", 1884, __extension__ __PRETTY_FUNCTION__
)); memset(stream.data, 0, 1024); stream.end = stream.data; stream
.data_size = 1024; stream.write_function = switch_console_stream_write
; stream.raw_write_function = switch_console_stream_raw_write
; stream.alloc_len = 1024; stream.alloc_chunk = 1024;

switch_mutex_lock(channel->flag_mutex);
for (i = 0; i < CF_FLAG_MAX; i++) {
if (channel->flags[i]) {
	stream.write_function(&stream, "%d=%d;", i, channel->flags[i]);
}
}
switch_mutex_unlock(channel->flag_mutex);

r = (char *) stream.data;

if (end_of(r)*(*r == '\0' ? r : r + strlen(r) - 1) == ';') {
end_of(r)*(*r == '\0' ? r : r + strlen(r) - 1) = '\0';
}

return r;

1902}

1904SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_channel_get_cap_string(switch_channel_t *channel)
1905{
switch_stream_handle_t stream = { 0 };
char *r;
int i = 0;

SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "src/switch_channel.c", 1910, __extension__ __PRETTY_FUNCTION__
)); memset(stream.data, 0, 1024); stream.end = stream.data; stream
.data_size = 1024; stream.write_function = switch_console_stream_write
; stream.raw_write_function = switch_console_stream_raw_write
; stream.alloc_len = 1024; stream.alloc_chunk = 1024;

switch_mutex_lock(channel->flag_mutex);
for (i = 0; i < CC_FLAG_MAX; i++) {
if (channel->caps[i]) {
	stream.write_function(&stream, "%d=%d;", i, channel->caps[i]);
}
}
switch_mutex_unlock(channel->flag_mutex);

r = (char *) stream.data;

if (end_of(r)*(*r == '\0' ? r : r + strlen(r) - 1) == ';') {
end_of(r)*(*r == '\0' ? r : r + strlen(r) - 1) = '\0';
}

return r;

1928}

1930SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_flag_value(switch_channel_t *channel, switch_channel_flag_t flag, uint32_t value)
1931{
int HELD = 0;
int just_set = 0;

switch_assert(channel)((channel) ? (void) (0) : __assert_fail ("channel", "src/switch_channel.c"
, 1935, __extension__ __PRETTY_FUNCTION__));
switch_assert(channel->flag_mutex)((channel->flag_mutex) ? (void) (0) : __assert_fail ("channel->flag_mutex"
, "src/switch_channel.c", 1936, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
if (flag == CF_LEG_HOLDING && !channel->flags[flag] && channel->flags[CF_ANSWERED]) {
HELD = 1;
}
if (channel->flags[flag] != value) {
just_set = 1;
channel->flags[flag] = value;
}
switch_mutex_unlock(channel->flag_mutex);

if (flag == CF_VIDEO_READY && just_set) {
switch_core_session_request_video_refresh(channel->session)_switch_core_session_request_video_refresh(channel->session
, 0, "src/switch_channel.c", (const char *)__func__, 1949);
}

if (flag == CF_ORIGINATOR && switch_channel_test_flag(channel, CF_ANSWERED) && switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
switch_channel_set_callstate(channel, CCS_RING_WAIT)switch_channel_perform_set_callstate(channel, CCS_RING_WAIT, "src/switch_channel.c"
, (const char *)__func__, 1953);
}

if (flag == CF_DIALPLAN) {
if (channel->direction == SWITCH_CALL_DIRECTION_INBOUND) {
	channel->logical_direction = SWITCH_CALL_DIRECTION_OUTBOUND;
	if (channel->device_node) {
		channel->device_node->direction = SWITCH_CALL_DIRECTION_INBOUND;
	}
} else {
	channel->logical_direction = SWITCH_CALL_DIRECTION_INBOUND;
	if (channel->device_node) {
		channel->device_node->direction = SWITCH_CALL_DIRECTION_OUTBOUND;
	}
}
}

if (HELD) {
switch_hold_record_t *hr;
const char *brto = switch_channel_get_partner_uuid(channel);

switch_channel_set_callstate(channel, CCS_HELD)switch_channel_perform_set_callstate(channel, CCS_HELD, "src/switch_channel.c"
, (const char *)__func__, 1974);
switch_mutex_lock(channel->profile_mutex);
channel->caller_profile->times->last_hold = switch_time_now();

hr = switch_core_session_alloc(channel->session, sizeof(*hr))switch_core_perform_session_alloc(channel->session, sizeof
(*hr), "src/switch_channel.c", (const char *)__func__, 1978);
hr->on = switch_time_now();
if (brto) {
	hr->uuid = switch_core_session_strdup(channel->session, brto)switch_core_perform_session_strdup(channel->session, brto,
 "src/switch_channel.c", (const char *)__func__, 1981);
}

if (channel->hold_record) {
	hr->next = channel->hold_record;
}
channel->hold_record = hr;

switch_mutex_unlock(channel->profile_mutex);
}

if (flag == CF_OUTBOUND) {
switch_channel_set_variable(channel, "is_outbound", "true")switch_channel_set_variable_var_check(channel, "is_outbound",
 "true", SWITCH_TRUE);
}

if (flag == CF_RECOVERED) {
switch_channel_set_variable(channel, "recovered", "true")switch_channel_set_variable_var_check(channel, "recovered", "true"
, SWITCH_TRUE);
}

if (flag == CF_VIDEO_ECHO || flag == CF_VIDEO_BLANK || flag == CF_VIDEO_DECODED_READ || flag == CF_VIDEO_PASSIVE) {
switch_core_session_start_video_thread(channel->session);
}

if (flag == CF_VIDEO_DECODED_READ && channel->flags[CF_VIDEO]) {
switch_core_session_request_video_refresh(channel->session)_switch_core_session_request_video_refresh(channel->session
, 0, "src/switch_channel.c", (const char *)__func__, 2005);
}
2007}

2009SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_flag_recursive(switch_channel_t *channel, switch_channel_flag_t flag)
2010{
switch_assert(channel)((channel) ? (void) (0) : __assert_fail ("channel", "src/switch_channel.c"
, 2011, __extension__ __PRETTY_FUNCTION__));
switch_assert(channel->flag_mutex)((channel->flag_mutex) ? (void) (0) : __assert_fail ("channel->flag_mutex"
, "src/switch_channel.c", 2012, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
channel->flags[flag]++;
switch_mutex_unlock(channel->flag_mutex);

if (flag == CF_OUTBOUND) {
switch_channel_set_variable(channel, "is_outbound", "true")switch_channel_set_variable_var_check(channel, "is_outbound",
 "true", SWITCH_TRUE);
}

if (flag == CF_RECOVERED) {
switch_channel_set_variable(channel, "recovered", "true")switch_channel_set_variable_var_check(channel, "recovered", "true"
, SWITCH_TRUE);
}
2025}


2028SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_private_flag(switch_channel_t *channel, uint32_t flags)
2029{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2030, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->flag_mutex);
channel->private_flags |= flags;
switch_mutex_unlock(channel->flag_mutex);
2034}

2036SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_private_flag(switch_channel_t *channel, uint32_t flags)
2037{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2038, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->flag_mutex);
channel->private_flags &= ~flags;
switch_mutex_unlock(channel->flag_mutex);
2042}

2044SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_channel_test_private_flag(switch_channel_t *channel, uint32_t flags)
2045{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2046, __extension__ __PRETTY_FUNCTION__
));
return (channel->private_flags & flags);
2048}

2050SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_app_flag_key(const char *key, switch_channel_t *channel, uint32_t flags)
2051{
uint32_t *flagp = NULL((void*)0);
switch_byte_t new = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2055, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->flag_mutex);

if (!channel->app_flag_hash) {
switch_core_hash_init(&channel->app_flag_hash)switch_core_hash_init_case(&channel->app_flag_hash, SWITCH_TRUE
);
new++;
}

if (new || !(flagp = switch_core_hash_find(channel->app_flag_hash, key))) {
flagp = switch_core_session_alloc(channel->session, sizeof(uint32_t))switch_core_perform_session_alloc(channel->session, sizeof
(uint32_t), "src/switch_channel.c", (const char *)__func__, 2064
);
switch_core_hash_insert(channel->app_flag_hash, key, flagp)switch_core_hash_insert_destructor(channel->app_flag_hash,
 key, flagp, ((void*)0));
}

switch_assert(flagp)((flagp) ? (void) (0) : __assert_fail ("flagp", "src/switch_channel.c"
, 2068, __extension__ __PRETTY_FUNCTION__));
*flagp |= flags;

switch_mutex_unlock(channel->flag_mutex);
2072}

2074SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_app_flag_key(const char *key, switch_channel_t *channel, uint32_t flags)
2075{
uint32_t *flagp = NULL((void*)0);

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2078, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->flag_mutex);
if (channel->app_flag_hash && (flagp = switch_core_hash_find(channel->app_flag_hash, key))) {
if (!flags) {
	*flagp = 0;
} else {
	*flagp &= ~flags;
}
}
switch_mutex_unlock(channel->flag_mutex);
2088}

2090SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_channel_test_app_flag_key(const char *key, switch_channel_t *channel, uint32_t flags)
2091{
int r = 0;
uint32_t *flagp = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2094, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
if (channel->app_flag_hash && (flagp = switch_core_hash_find(channel->app_flag_hash, key))) {
r = (*flagp & flags);
}
switch_mutex_unlock(channel->flag_mutex);


return r;
2104}

2106SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_state_flag(switch_channel_t *channel, switch_channel_flag_t flag)
2107{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2108, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
channel->state_flags[0] = 1;
channel->state_flags[flag] = 1;
switch_mutex_unlock(channel->flag_mutex);
2114}

2116SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_state_flag(switch_channel_t *channel, switch_channel_flag_t flag)
2117{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2118, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
channel->state_flags[flag] = 0;
switch_mutex_unlock(channel->flag_mutex);
2123}

2125SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_flag(switch_channel_t *channel, switch_channel_flag_t flag)
2126{
int ACTIVE = 0;
int CLEAR = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2130, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->flag_mutex)((channel->flag_mutex) ? (void) (0) : __assert_fail ("channel->flag_mutex"
, "src/switch_channel.c", 2131, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
if (flag == CF_LEG_HOLDING && channel->flags[flag] && channel->flags[CF_ANSWERED]) {
ACTIVE = 1;
}

if (flag == CF_VIDEO_PASSIVE && channel->flags[CF_VIDEO]) {
channel->flags[CF_VIDEO_READY] = 1;

if (channel->flags[flag]) {
	CLEAR = 1;
}
}

channel->flags[flag] = 0;
switch_mutex_unlock(channel->flag_mutex);

if (flag == CF_DIALPLAN) {
if (channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND) {
	channel->logical_direction = SWITCH_CALL_DIRECTION_OUTBOUND;
	if (channel->device_node) {
		channel->device_node->direction = SWITCH_CALL_DIRECTION_INBOUND;
	}
}
}

if (ACTIVE) {
switch_channel_set_callstate(channel, CCS_UNHELD)switch_channel_perform_set_callstate(channel, CCS_UNHELD, "src/switch_channel.c"
, (const char *)__func__, 2159);
switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile->times->last_hold) {
	channel->caller_profile->times->hold_accum += (switch_time_now() - channel->caller_profile->times->last_hold);
}

if (channel->hold_record) {
	channel->hold_record->off = switch_time_now();
}

if (switch_channel_test_flag(channel, CF_PROXY_MODE) && switch_channel_test_flag(channel, CF_BRIDGED)) {
	switch_channel_set_callstate(channel, CCS_ACTIVE)switch_channel_perform_set_callstate(channel, CCS_ACTIVE, "src/switch_channel.c"
, (const char *)__func__, 2170);
}

switch_mutex_unlock(channel->profile_mutex);
}

if (flag == CF_ORIGINATOR && switch_channel_test_flag(channel, CF_ANSWERED) && switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
switch_channel_set_callstate(channel, CCS_ACTIVE)switch_channel_perform_set_callstate(channel, CCS_ACTIVE, "src/switch_channel.c"
, (const char *)__func__, 2177);
}

if (flag == CF_OUTBOUND) {
switch_channel_set_variable(channel, "is_outbound", NULL)switch_channel_set_variable_var_check(channel, "is_outbound",
 ((void*)0), SWITCH_TRUE);
}

if (flag == CF_RECOVERED) {
switch_channel_set_variable(channel, "recovered", NULL)switch_channel_set_variable_var_check(channel, "recovered", (
(void*)0), SWITCH_TRUE);
}

if (flag == CF_VIDEO_PASSIVE && CLEAR) {
switch_core_session_wake_video_thread(channel->session);
}

if (flag == CF_RECOVERING && !channel->hangup_cause) {
switch_core_recovery_track(channel->session);
}

2196}


2199SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_flag_recursive(switch_channel_t *channel, switch_channel_flag_t flag)
2200{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2201, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->flag_mutex)((channel->flag_mutex) ? (void) (0) : __assert_fail ("channel->flag_mutex"
, "src/switch_channel.c", 2202, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->flag_mutex);
if (channel->flags[flag]) {
channel->flags[flag]--;
}
switch_mutex_unlock(channel->flag_mutex);

if (flag == CF_OUTBOUND) {
switch_channel_set_variable(channel, "is_outbound", NULL)switch_channel_set_variable_var_check(channel, "is_outbound",
 ((void*)0), SWITCH_TRUE);
}
2213}

2215SWITCH_DECLARE(switch_channel_state_t)__attribute__((visibility("default"))) switch_channel_state_t switch_channel_get_state(switch_channel_t *channel)
2216{
switch_channel_state_t state;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2218, __extension__ __PRETTY_FUNCTION__
));

state = channel->state;

return state;
2223}

2225SWITCH_DECLARE(switch_channel_state_t)__attribute__((visibility("default"))) switch_channel_state_t switch_channel_get_running_state(switch_channel_t *channel)
2226{
switch_channel_state_t state;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2228, __extension__ __PRETTY_FUNCTION__
));

state = channel->running_state;

return state;
2233}

2235SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_channel_state_change_pending(switch_channel_t *channel)
2236{
if (switch_channel_down_nosig(channel)(switch_channel_get_state(channel) >= CS_HANGUP) || !switch_core_session_in_thread(channel->session)) {
return 0;
}

return channel->running_state != channel->state;
2242}

2244SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_channel_check_signal(switch_channel_t *channel, switch_bool_t in_thread_only)
2245{
switch_ivr_parse_signal_data(channel->session, SWITCH_FALSE, in_thread_only);
return 0;
2248}

2250SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_channel_test_ready(switch_channel_t *channel, switch_bool_t check_ready, switch_bool_t check_media)
2251{
int ret = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2254, __extension__ __PRETTY_FUNCTION__
));

switch_channel_check_signal(channel, SWITCH_TRUE);

if (check_media) {
ret = ((switch_channel_test_flag(channel, CF_ANSWERED) ||
		switch_channel_test_flag(channel, CF_EARLY_MEDIA)) && !switch_channel_test_flag(channel, CF_PROXY_MODE) &&
	   switch_core_session_get_read_codec(channel->session) && switch_core_session_get_write_codec(channel->session));


if (!ret)
	return ret;
}

if (!check_ready)
return ret;

ret = 0;

if (!channel->hangup_cause && channel->state > CS_ROUTING && channel->state < CS_HANGUP && channel->state != CS_RESET &&
!switch_channel_test_flag(channel, CF_TRANSFER) && !switch_channel_test_flag(channel, CF_NOT_READY) &&
!switch_channel_state_change_pending(channel)) {
ret++;
}



return ret;
2282}

2284static const char *state_names[] = {
"CS_NEW",
"CS_INIT",
"CS_ROUTING",
"CS_SOFT_EXECUTE",
"CS_EXECUTE",
"CS_EXCHANGE_MEDIA",
"CS_PARK",
"CS_CONSUME_MEDIA",
"CS_HIBERNATE",
"CS_RESET",
"CS_HANGUP",
"CS_REPORTING",
"CS_DESTROY",
"CS_NONE",
NULL((void*)0)
2300};

2302SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_state_name(switch_channel_state_t state)
2303{
return state_names[state];
2305}


2308SWITCH_DECLARE(switch_channel_state_t)__attribute__((visibility("default"))) switch_channel_state_t switch_channel_name_state(const char *name)
2309{
uint32_t x = 0;
for (x = 0; state_names[x]; x++) {
if (!strcasecmp(state_names[x], name)) {
	return (switch_channel_state_t) x;
}
}

return CS_DESTROY;
2318}

2320static inline void careful_set(switch_channel_t *channel, switch_channel_state_t *state, switch_channel_state_t val) {

if (switch_mutex_trylock(channel->thread_mutex) == SWITCH_STATUS_SUCCESS) {
*state = val;
switch_mutex_unlock(channel->thread_mutex);
} else {
switch_mutex_t *mutex = switch_core_session_get_mutex(channel->session);
int x = 0;

for (x = 0; x < 100; x++) {
	if (switch_mutex_trylock(mutex) == SWITCH_STATUS_SUCCESS) {
		*state = val;
		switch_mutex_unlock(mutex);
		break;
	} else {
		switch_cond_next();
	}
}

if (x == 100) {
	*state = val;
}

}
2344}

2346SWITCH_DECLARE(switch_channel_state_t)__attribute__((visibility("default"))) switch_channel_state_t switch_channel_perform_set_running_state(switch_channel_t *channel, switch_channel_state_t state,
																		const char *file, const char *func, int line)
2348{
int x;

switch_mutex_lock(channel->flag_mutex);
if (channel->state_flags[0]) {
for (x = 1; x < CF_FLAG_MAX; x++) {
	if (channel->state_flags[x]) {
		channel->flags[x] = 1;
		channel->state_flags[x] = 0;
	}
}
channel->state_flags[0] = 0;
}
switch_mutex_unlock(channel->flag_mutex);

switch_channel_clear_flag(channel, CF_TAGGED);


switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_DEBUG, "(%s) Running State Change %s (Cur %d Tot %" SWITCH_SIZE_T_FMT"ld" ")\n",
			  channel->name, state_names[state], switch_core_session_count(), switch_core_session_id() - 1);

switch_mutex_lock(channel->state_mutex);

careful_set(channel, &channel->running_state, state);

if (state <= CS_DESTROY) {
switch_event_t *event;

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
	if (state < CS_HANGUP) {
		if (state == CS_ROUTING) {
			switch_channel_set_callstate(channel, CCS_RINGING)switch_channel_perform_set_callstate(channel, CCS_RINGING, "src/switch_channel.c"
, (const char *)__func__, 2379);
		} else if (switch_channel_test_flag(channel, CF_ANSWERED)) {
			switch_channel_set_callstate(channel, CCS_ACTIVE)switch_channel_perform_set_callstate(channel, CCS_ACTIVE, "src/switch_channel.c"
, (const char *)__func__, 2381);
		} else if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
			switch_channel_set_callstate(channel, CCS_EARLY)switch_channel_perform_set_callstate(channel, CCS_EARLY, "src/switch_channel.c"
, (const char *)__func__, 2383);
		}
	}
}

if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_STATE)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 2388, &event, SWITCH_EVENT_CHANNEL_STATE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
	switch_channel_event_set_data(channel, event);
	switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 2390, &event, ((void*)0));
}
}

switch_mutex_unlock(channel->state_mutex);

return (switch_channel_state_t) SWITCH_STATUS_SUCCESS;
2397}

2399SWITCH_DECLARE(switch_channel_state_t)__attribute__((visibility("default"))) switch_channel_state_t switch_channel_perform_set_state(switch_channel_t *channel,
																const char *file, const char *func, int line, switch_channel_state_t state)
2401{
switch_channel_state_t last_state;
int ok = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2405, __extension__ __PRETTY_FUNCTION__
));
switch_assert(state <= CS_DESTROY)((state <= CS_DESTROY) ? (void) (0) : __assert_fail ("state <= CS_DESTROY"
, "src/switch_channel.c", 2406, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->state_mutex);

last_state = channel->state;
switch_assert(last_state <= CS_DESTROY)((last_state <= CS_DESTROY) ? (void) (0) : __assert_fail (
"last_state <= CS_DESTROY", "src/switch_channel.c", 2410, __extension__
 __PRETTY_FUNCTION__));

if (last_state == state) {
goto done;
}

if (last_state >= CS_HANGUP && state < last_state) {
goto done;
}

/* STUB for more dev
  case CS_INIT:
  switch(state) {

  case CS_NEW:
  case CS_INIT:
  case CS_EXCHANGE_MEDIA:
  case CS_SOFT_EXECUTE:
  case CS_ROUTING:
  case CS_EXECUTE:
  case CS_HANGUP:
  case CS_DESTROY:

  default:
  break;
  }
  break;
*/

switch (last_state) {
case CS_NEW:
case CS_RESET:
switch (state) {
default:
	ok++;
	break;
}
break;

case CS_INIT:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_SOFT_EXECUTE:
case CS_ROUTING:
case CS_EXECUTE:
case CS_PARK:
case CS_CONSUME_MEDIA:
case CS_HIBERNATE:
case CS_RESET:
	ok++;
default:
	break;
}
break;

case CS_EXCHANGE_MEDIA:
switch (state) {
case CS_SOFT_EXECUTE:
case CS_ROUTING:
case CS_EXECUTE:
case CS_PARK:
case CS_CONSUME_MEDIA:
case CS_HIBERNATE:
case CS_RESET:
	ok++;
default:
	break;
}
break;

case CS_SOFT_EXECUTE:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_ROUTING:
case CS_EXECUTE:
case CS_PARK:
case CS_CONSUME_MEDIA:
case CS_HIBERNATE:
case CS_RESET:
	ok++;
default:
	break;
}
break;

case CS_PARK:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_ROUTING:
case CS_EXECUTE:
case CS_SOFT_EXECUTE:
case CS_HIBERNATE:
case CS_RESET:
case CS_CONSUME_MEDIA:
	ok++;
default:
	break;
}
break;

case CS_CONSUME_MEDIA:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_ROUTING:
case CS_EXECUTE:
case CS_SOFT_EXECUTE:
case CS_HIBERNATE:
case CS_RESET:
case CS_PARK:
	ok++;
default:
	break;
}
break;
case CS_HIBERNATE:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_INIT:
case CS_ROUTING:
case CS_EXECUTE:
case CS_SOFT_EXECUTE:
case CS_PARK:
case CS_CONSUME_MEDIA:
case CS_RESET:
	ok++;
default:
	break;
}
break;

case CS_ROUTING:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_EXECUTE:
case CS_SOFT_EXECUTE:
case CS_PARK:
case CS_CONSUME_MEDIA:
case CS_HIBERNATE:
case CS_RESET:
	ok++;
default:
	break;
}
break;

case CS_EXECUTE:
switch (state) {
case CS_EXCHANGE_MEDIA:
case CS_SOFT_EXECUTE:
case CS_ROUTING:
case CS_PARK:
case CS_CONSUME_MEDIA:
case CS_HIBERNATE:
case CS_RESET:
	ok++;
default:
	break;
}
break;

case CS_HANGUP:
switch (state) {
case CS_REPORTING:
case CS_DESTROY:
	ok++;
default:
	break;
}
break;

case CS_REPORTING:
switch (state) {
case CS_DESTROY:
	ok++;
default:
	break;
}
break;

default:
break;

}

if (ok) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_DEBUG, "(%s) State Change %s -> %s\n",
				  channel->name, state_names[last_state], state_names[state]);

careful_set(channel, &channel->state, state);

if (state == CS_HANGUP && !channel->hangup_cause) {
	channel->hangup_cause = SWITCH_CAUSE_NORMAL_CLEARING;
}

if (state <= CS_DESTROY) {
	switch_core_session_signal_state_change(channel->session);
}
} else {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_WARNING,
				  "(%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! */
/* not cool lets crash this bad boy and figure out wtf is going on */
switch_assert(channel->state >= CS_HANGUP)((channel->state >= CS_HANGUP) ? (void) (0) : __assert_fail
 ("channel->state >= CS_HANGUP", "src/switch_channel.c"
, 2612, __extension__ __PRETTY_FUNCTION__));
}
done:

switch_mutex_unlock(channel->state_mutex);
return channel->state;
2618}

2620SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_state_thread_lock(switch_channel_t *channel)
2621{
switch_mutex_lock(channel->thread_mutex);
2623}


2626SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_state_thread_trylock(switch_channel_t *channel)
2627{
return switch_mutex_trylock(channel->thread_mutex);
2629}


2632SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_state_thread_unlock(switch_channel_t *channel)
2633{
switch_mutex_unlock(channel->thread_mutex);
2635}

2637SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_event_set_basic_data(switch_channel_t *channel, switch_event_t *event)
2638{
switch_caller_profile_t *caller_profile, *originator_caller_profile = NULL((void*)0), *originatee_caller_profile = NULL((void*)0);
switch_codec_implementation_t impl = { 0 };
char state_num[25];
const char *v;

switch_mutex_lock(channel->profile_mutex);

if ((caller_profile = channel->caller_profile)) {
originator_caller_profile = caller_profile->originator_caller_profile;
originatee_caller_profile = caller_profile->originatee_caller_profile;
}

switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-State", switch_channel_state_name(channel->running_state));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Call-State", switch_channel_callstate2str(channel->callstate));
switch_snprintf(state_num, sizeof(state_num), "%d", channel->state);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-State-Number", state_num);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Name", switch_channel_get_name(channel));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(channel->session));

switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Call-Direction",
						   channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Call-Direction",
						   channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");

switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-HIT-Dialplan",
						   switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND ||
						   switch_channel_test_flag(channel, CF_DIALPLAN) ? "true" : "false");


if ((v = switch_channel_get_variable_dup(channel, "presence_id", SWITCH_FALSE, -1))) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Presence-ID", v);
}

if ((v = switch_channel_get_variable_dup(channel, "presence_data", SWITCH_FALSE, -1))) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Presence-Data", v);
}


if ((v = switch_channel_get_variable_dup(channel, "presence_data_cols", SWITCH_FALSE, -1))) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Data-Cols", v);
switch_event_add_presence_data_cols(channel, event, "PD-");
}

if ((v = switch_channel_get_variable_dup(channel, "call_uuid", SWITCH_FALSE, -1))) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Call-UUID", v);
} else {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Call-UUID", switch_core_session_get_uuid(channel->session));
}

if (switch_channel_down_nosig(channel)(switch_channel_get_state(channel) >= CS_HANGUP)) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "hangup");
} else if (switch_channel_test_flag(channel, CF_ANSWERED)) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "answered");
} else if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "early");
} else {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "ringing");
}

if (channel->hangup_cause) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Hangup-Cause", switch_channel_cause2str(channel->hangup_cause));
}


switch_core_session_get_read_impl(channel->session, &impl);

if (impl.iananame) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Read-Codec-Name", impl.iananame);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Read-Codec-Rate", "%u", impl.actual_samples_per_second);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Read-Codec-Bit-Rate", "%d", impl.bits_per_second);
}

switch_core_session_get_write_impl(channel->session, &impl);

if (impl.iananame) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Name", impl.iananame);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Rate", "%u", impl.actual_samples_per_second);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Bit-Rate", "%d", impl.bits_per_second);
}

/* Index Caller's Profile */
if (caller_profile) {
switch_caller_profile_event_set_data(caller_profile, "Caller", event);
}

/* Index Originator/ee's Profile */
if (originator_caller_profile && channel->last_profile_type == LP_ORIGINATOR) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Other-Type", "originator");
switch_caller_profile_event_set_data(originator_caller_profile, "Other-Leg", event);
} else if (originatee_caller_profile && channel->last_profile_type == LP_ORIGINATEE) {	/* Index Originatee's Profile */
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Other-Type", "originatee");
switch_caller_profile_event_set_data(originatee_caller_profile, "Other-Leg", event);
}


switch_mutex_unlock(channel->profile_mutex);
2735}

2737SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_event_set_extended_data(switch_channel_t *channel, switch_event_t *event)
2738{
switch_event_header_t *hi;
int global_verbose_events = -1;

switch_mutex_lock(channel->profile_mutex);

switch_core_session_ctl(SCSC_VERBOSE_EVENTS, &global_verbose_events);

if (global_verbose_events ||
switch_channel_test_flag(channel, CF_VERBOSE_EVENTS) ||
switch_event_get_header(event, "presence-data-cols")switch_event_get_header_idx(event, "presence-data-cols", -1) ||
event->event_id == SWITCH_EVENT_CHANNEL_CREATE ||
event->event_id == SWITCH_EVENT_CHANNEL_ORIGINATE ||
event->event_id == SWITCH_EVENT_CHANNEL_UUID ||
event->event_id == SWITCH_EVENT_CHANNEL_ANSWER ||
event->event_id == SWITCH_EVENT_CHANNEL_PARK ||
event->event_id == SWITCH_EVENT_CHANNEL_UNPARK ||
event->event_id == SWITCH_EVENT_CHANNEL_BRIDGE ||
event->event_id == SWITCH_EVENT_CHANNEL_UNBRIDGE ||
event->event_id == SWITCH_EVENT_CHANNEL_PROGRESS ||
event->event_id == SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA ||
event->event_id == SWITCH_EVENT_CHANNEL_HANGUP ||
event->event_id == SWITCH_EVENT_CHANNEL_HANGUP_COMPLETE ||
event->event_id == SWITCH_EVENT_REQUEST_PARAMS ||
event->event_id == SWITCH_EVENT_CHANNEL_DATA ||
event->event_id == SWITCH_EVENT_CHANNEL_EXECUTE ||
event->event_id == SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE ||
event->event_id == SWITCH_EVENT_CHANNEL_DESTROY ||
event->event_id == SWITCH_EVENT_SESSION_HEARTBEAT ||
event->event_id == SWITCH_EVENT_API ||
event->event_id == SWITCH_EVENT_RECORD_START ||
event->event_id == SWITCH_EVENT_RECORD_STOP ||
event->event_id == SWITCH_EVENT_PLAYBACK_START ||
event->event_id == SWITCH_EVENT_PLAYBACK_STOP ||
event->event_id == SWITCH_EVENT_CALL_UPDATE || 
event->event_id == SWITCH_EVENT_MEDIA_BUG_START || 
event->event_id == SWITCH_EVENT_MEDIA_BUG_STOP || 
event->event_id == SWITCH_EVENT_CHANNEL_HOLD || 
event->event_id == SWITCH_EVENT_CHANNEL_UNHOLD || 
event->event_id == SWITCH_EVENT_TEXT || 
event->event_id == SWITCH_EVENT_CUSTOM) {

/* Index Variables */

if (channel->scope_variables) {
	switch_event_t *ep;

	for (ep = channel->scope_variables; ep; ep = ep->next) {
		for (hi = ep->headers; hi; hi = hi->next) {
			char buf[1024];
			char *vvar = NULL((void*)0), *vval = NULL((void*)0);

			vvar = (char *) hi->name;
			vval = (char *) hi->value;

			switch_assert(vvar && vval)((vvar && vval) ? (void) (0) : __assert_fail ("vvar && vval"
, "src/switch_channel.c", 2793, __extension__ __PRETTY_FUNCTION__
));
			switch_snprintf(buf, sizeof(buf), "scope_variable_%s", vvar);

			if (!switch_event_get_header(event, buf)switch_event_get_header_idx(event, buf, -1)) {
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, buf, vval);
			}
		}
	}
}

if (channel->variables) {
	for (hi = channel->variables->headers; hi; hi = hi->next) {
		char buf[1024];
		char *vvar = NULL((void*)0), *vval = NULL((void*)0);

		vvar = (char *) hi->name;
		vval = (char *) hi->value;

		switch_assert(vvar && vval)((vvar && vval) ? (void) (0) : __assert_fail ("vvar && vval"
, "src/switch_channel.c", 2811, __extension__ __PRETTY_FUNCTION__
));
		switch_snprintf(buf, sizeof(buf), "variable_%s", vvar);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, buf, vval);
	}
}
}

switch_mutex_unlock(channel->profile_mutex);
2819}


2822SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_event_set_data(switch_channel_t *channel, switch_event_t *event)
2823{
switch_mutex_lock(channel->profile_mutex);
switch_channel_event_set_basic_data(channel, event);
switch_channel_event_set_extended_data(channel, event);
switch_mutex_unlock(channel->profile_mutex);
2828}

2830SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_step_caller_profile(switch_channel_t *channel)
2831{
switch_caller_profile_t *cp;


switch_mutex_lock(channel->profile_mutex);
cp = switch_caller_profile_clone(channel->session, channel->caller_profile);
switch_mutex_unlock(channel->profile_mutex);

switch_channel_set_caller_profile(channel, cp);
2840}

2842SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
2843{
char *uuid = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2845, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->session != NULL)((channel->session != ((void*)0)) ? (void) (0) : __assert_fail
 ("channel->session != ((void*)0)", "src/switch_channel.c"
, 2846, __extension__ __PRETTY_FUNCTION__));
switch_mutex_lock(channel->profile_mutex);
switch_assert(caller_profile != NULL)((caller_profile != ((void*)0)) ? (void) (0) : __assert_fail (
"caller_profile != ((void*)0)", "src/switch_channel.c", 2848,
 __extension__ __PRETTY_FUNCTION__));

caller_profile->direction = channel->direction;
caller_profile->logical_direction = channel->logical_direction;
uuid = switch_core_session_get_uuid(channel->session);

if (!caller_profile->uuid || strcasecmp(caller_profile->uuid, uuid)) {
caller_profile->uuid = switch_core_session_strdup(channel->session, uuid)switch_core_perform_session_strdup(channel->session, uuid,
 "src/switch_channel.c", (const char *)__func__, 2855);
}

if (!caller_profile->chan_name || strcasecmp(caller_profile->chan_name, channel->name)) {
caller_profile->chan_name = switch_core_session_strdup(channel->session, channel->name)switch_core_perform_session_strdup(channel->session, channel
->name, "src/switch_channel.c", (const char *)__func__, 2859
);
}

if (!caller_profile->context) {
caller_profile->context = switch_core_session_strdup(channel->session, "default")switch_core_perform_session_strdup(channel->session, "default"
, "src/switch_channel.c", (const char *)__func__, 2863);
}

if (!caller_profile->times) {
caller_profile->times = (switch_channel_timetable_t *) switch_core_session_alloc(channel->session, sizeof(*caller_profile->times))switch_core_perform_session_alloc(channel->session, sizeof
(*caller_profile->times), "src/switch_channel.c", (const char
 *)__func__, 2867);
caller_profile->times->profile_created = switch_micro_time_now();
}

if (channel->caller_profile && channel->caller_profile->times) {
channel->caller_profile->times->transferred = caller_profile->times->profile_created;
caller_profile->times->answered = channel->caller_profile->times->answered;
caller_profile->times->progress = channel->caller_profile->times->progress;
caller_profile->times->progress_media = channel->caller_profile->times->progress_media;
caller_profile->times->created = channel->caller_profile->times->created;
caller_profile->times->hungup = channel->caller_profile->times->hungup;
if (channel->caller_profile->caller_extension) {
	switch_caller_extension_clone(&caller_profile->caller_extension, channel->caller_profile->caller_extension, caller_profile->pool);
}
} else {
caller_profile->times->created = switch_micro_time_now();
}


caller_profile->next = channel->caller_profile;
channel->caller_profile = caller_profile;
caller_profile->profile_index = switch_core_sprintf(caller_profile->pool, "%d", ++channel->profile_index);

switch_mutex_unlock(channel->profile_mutex);
2891}

2893SWITCH_DECLARE(switch_caller_profile_t *)__attribute__((visibility("default"))) switch_caller_profile_t
 * switch_channel_get_caller_profile(switch_channel_t *channel)
2894{
switch_caller_profile_t *profile;
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2896, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->profile_mutex);
if ((profile = channel->caller_profile) && profile->hunt_caller_profile) {
profile = profile->hunt_caller_profile;
}
switch_mutex_unlock(channel->profile_mutex);
return profile;
2903}

2905SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_originator_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
2906{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2907, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->caller_profile != NULL)((channel->caller_profile != ((void*)0)) ? (void) (0) : __assert_fail
 ("channel->caller_profile != ((void*)0)", "src/switch_channel.c"
, 2908, __extension__ __PRETTY_FUNCTION__));
switch_mutex_lock(channel->profile_mutex);

if (!caller_profile->times) {
caller_profile->times = (switch_channel_timetable_t *) switch_core_alloc(caller_profile->pool, sizeof(*caller_profile->times))switch_core_perform_alloc(caller_profile->pool, sizeof(*caller_profile
->times), "src/switch_channel.c", (const char *)__func__, 2912
);
}

if (channel->caller_profile) {
caller_profile->next = channel->caller_profile->originator_caller_profile;
channel->caller_profile->originator_caller_profile = caller_profile;
channel->last_profile_type = LP_ORIGINATOR;
}
switch_assert(channel->caller_profile->originator_caller_profile->next != channel->caller_profile->originator_caller_profile)((channel->caller_profile->originator_caller_profile->
next != channel->caller_profile->originator_caller_profile
) ? (void) (0) : __assert_fail ("channel->caller_profile->originator_caller_profile->next != channel->caller_profile->originator_caller_profile"
, "src/switch_channel.c", 2920, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_unlock(channel->profile_mutex);
2922}

2924SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_hunt_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
2925{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2926, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->caller_profile != NULL)((channel->caller_profile != ((void*)0)) ? (void) (0) : __assert_fail
 ("channel->caller_profile != ((void*)0)", "src/switch_channel.c"
, 2927, __extension__ __PRETTY_FUNCTION__));

switch_mutex_lock(channel->profile_mutex);

channel->caller_profile->hunt_caller_profile = NULL((void*)0);
if (channel->caller_profile && caller_profile) {
caller_profile->direction = channel->direction;
caller_profile->logical_direction = channel->logical_direction;
channel->caller_profile->hunt_caller_profile = caller_profile;
}
switch_mutex_unlock(channel->profile_mutex);
2938}

2940SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_origination_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
2941{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2942, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->caller_profile != NULL)((channel->caller_profile != ((void*)0)) ? (void) (0) : __assert_fail
 ("channel->caller_profile != ((void*)0)", "src/switch_channel.c"
, 2943, __extension__ __PRETTY_FUNCTION__));

switch_mutex_lock(channel->profile_mutex);

if (channel->caller_profile) {
caller_profile->next = channel->caller_profile->origination_caller_profile;
channel->caller_profile->origination_caller_profile = caller_profile;
}
switch_assert(channel->caller_profile->origination_caller_profile->next != channel->caller_profile->origination_caller_profile)((channel->caller_profile->origination_caller_profile->
next != channel->caller_profile->origination_caller_profile
) ? (void) (0) : __assert_fail ("channel->caller_profile->origination_caller_profile->next != channel->caller_profile->origination_caller_profile"
, "src/switch_channel.c", 2951, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_unlock(channel->profile_mutex);
2953}

2955SWITCH_DECLARE(switch_caller_profile_t *)__attribute__((visibility("default"))) switch_caller_profile_t
 * switch_channel_get_origination_caller_profile(switch_channel_t *channel)
2956{
switch_caller_profile_t *profile = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2958, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile) {
profile = channel->caller_profile->origination_caller_profile;
}
switch_mutex_unlock(channel->profile_mutex);

return profile;
2967}


2970SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_originatee_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
2971{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2972, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->caller_profile != NULL)((channel->caller_profile != ((void*)0)) ? (void) (0) : __assert_fail
 ("channel->caller_profile != ((void*)0)", "src/switch_channel.c"
, 2973, __extension__ __PRETTY_FUNCTION__));

switch_mutex_lock(channel->profile_mutex);

if (channel->caller_profile) {
caller_profile->next = channel->caller_profile->originatee_caller_profile;
channel->caller_profile->originatee_caller_profile = caller_profile;
channel->last_profile_type = LP_ORIGINATEE;
}
switch_assert(channel->caller_profile->originatee_caller_profile->next != channel->caller_profile->originatee_caller_profile)((channel->caller_profile->originatee_caller_profile->
next != channel->caller_profile->originatee_caller_profile
) ? (void) (0) : __assert_fail ("channel->caller_profile->originatee_caller_profile->next != channel->caller_profile->originatee_caller_profile"
, "src/switch_channel.c", 2982, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_unlock(channel->profile_mutex);
2984}

2986SWITCH_DECLARE(switch_caller_profile_t *)__attribute__((visibility("default"))) switch_caller_profile_t
 * switch_channel_get_originator_caller_profile(switch_channel_t *channel)
2987{
switch_caller_profile_t *profile = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 2989, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);

if (channel->caller_profile) {
profile = channel->caller_profile->originator_caller_profile;
}
switch_mutex_unlock(channel->profile_mutex);

return profile;
2999}

3001SWITCH_DECLARE(switch_caller_profile_t *)__attribute__((visibility("default"))) switch_caller_profile_t
 * switch_channel_get_originatee_caller_profile(switch_channel_t *channel)
3002{
switch_caller_profile_t *profile = NULL((void*)0);
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3004, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile) {
profile = channel->caller_profile->originatee_caller_profile;
}
switch_mutex_unlock(channel->profile_mutex);

return profile;
3013}

3015SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_channel_get_uuid(switch_channel_t *channel)
3016{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3017, __extension__ __PRETTY_FUNCTION__
));
switch_assert(channel->session != NULL)((channel->session != ((void*)0)) ? (void) (0) : __assert_fail
 ("channel->session != ((void*)0)", "src/switch_channel.c"
, 3018, __extension__ __PRETTY_FUNCTION__));
return switch_core_session_get_uuid(channel->session);
3020}

3022SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_channel_add_state_handler(switch_channel_t *channel, const switch_state_handler_table_t *state_handler)
3023{
int x, index;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3026, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->state_mutex);
for (x = 0; x < SWITCH_MAX_STATE_HANDLERS30; x++) {
if (channel->state_handlers[x] == state_handler) {
	index = x;
	goto end;
}
}
index = channel->state_handler_index++;

if (channel->state_handler_index >= SWITCH_MAX_STATE_HANDLERS30) {
index = -1;
goto end;
}

channel->state_handlers[index] = state_handler;

end:
switch_mutex_unlock(channel->state_mutex);
return index;
3046}

3048SWITCH_DECLARE(const switch_state_handler_table_t *)__attribute__((visibility("default"))) const switch_state_handler_table_t
 * switch_channel_get_state_handler(switch_channel_t *channel, int index)
3049{
const switch_state_handler_table_t *h = NULL((void*)0);

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3052, __extension__ __PRETTY_FUNCTION__
));

if (index >= SWITCH_MAX_STATE_HANDLERS30 || index > channel->state_handler_index) {
return NULL((void*)0);
}

switch_mutex_lock(channel->state_mutex);
h = channel->state_handlers[index];
switch_mutex_unlock(channel->state_mutex);

return h;
3063}

3065SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_state_handler(switch_channel_t *channel, const switch_state_handler_table_t *state_handler)
3066{
int index, i = channel->state_handler_index;
const switch_state_handler_table_t *new_handlers[SWITCH_MAX_STATE_HANDLERS30] = { 0 };

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3070, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->state_mutex);
channel->state_handler_index = 0;

if (state_handler) {
for (index = 0; index < i; index++) {
	if (channel->state_handlers[index] != state_handler) {
		new_handlers[channel->state_handler_index++] = channel->state_handlers[index];
	}
}
} else {
for (index = 0; index < i; index++) {
	if (channel->state_handlers[index] && switch_test_flag(channel->state_handlers[index], SSH_FLAG_STICKY)((channel->state_handlers[index])->flags & SSH_FLAG_STICKY
)) {
		new_handlers[channel->state_handler_index++] = channel->state_handlers[index];
	}
}
}

for (index = 0; index < SWITCH_MAX_STATE_HANDLERS30; index++) {
channel->state_handlers[index] = NULL((void*)0);
}

if (channel->state_handler_index > 0) {
for (index = 0; index < channel->state_handler_index; index++) {
	channel->state_handlers[index] = new_handlers[index];
}
}

switch_mutex_unlock(channel->state_mutex);
3100}

3102SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_restart(switch_channel_t *channel)
3103{
switch_channel_set_state(channel, CS_RESET)switch_channel_perform_set_state(channel, "src/switch_channel.c"
, (const char *)__func__, 3104, CS_RESET);
switch_channel_wait_for_state_timeout(channel, CS_RESET, 5000);
switch_channel_set_state(channel, CS_EXECUTE)switch_channel_perform_set_state(channel, "src/switch_channel.c"
, (const char *)__func__, 3106, CS_EXECUTE);
3107}

3109/* XXX This is a somewhat simple operation.  Were essentially taking the extension that one channel
 was executing and generating a new extension for another channel that starts out where the
 original one left off with an optional forward offset.  Since all we are really doing is
 copying a few basic pool-allocated structures from one channel to another there really is
 not much to worry about here in terms of threading since we use read-write locks.
 While the features are nice, they only really are needed in one specific crazy attended
 transfer scenario where one channel was in the middle of calling a particular extension
 when it was rudely cut off by a transfer key press. XXX */

3118SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_caller_extension_masquerade(switch_channel_t *orig_channel, switch_channel_t *new_channel, uint32_t offset)
3119{
switch_caller_profile_t *caller_profile;
switch_caller_extension_t *extension = NULL((void*)0), *orig_extension = NULL((void*)0);
switch_caller_application_t *ap;
switch_status_t status = SWITCH_STATUS_FALSE;
switch_event_header_t *hi = NULL((void*)0);
const char *no_copy = switch_channel_get_variable(orig_channel, "attended_transfer_no_copy")switch_channel_get_variable_dup(orig_channel, "attended_transfer_no_copy"
, SWITCH_TRUE, -1);
char *dup;
int i, argc = 0;
char *argv[128];

if (no_copy) {
dup = switch_core_session_strdup(new_channel->session, no_copy)switch_core_perform_session_strdup(new_channel->session, no_copy
, "src/switch_channel.c", (const char *)__func__, 3131);
argc = switch_separate_string(dup, ',', argv, (sizeof(argv) / sizeof(argv[0])));
}


switch_mutex_lock(orig_channel->profile_mutex);
switch_mutex_lock(new_channel->profile_mutex);


caller_profile = switch_caller_profile_clone(new_channel->session, new_channel->caller_profile);
switch_assert(caller_profile)((caller_profile) ? (void) (0) : __assert_fail ("caller_profile"
, "src/switch_channel.c", 3141, __extension__ __PRETTY_FUNCTION__
));
extension = switch_caller_extension_new(new_channel->session, caller_profile->destination_number, caller_profile->destination_number);
orig_extension = switch_channel_get_caller_extension(orig_channel);


if (extension && orig_extension) {
for (ap = orig_extension->current_application; ap && offset > 0; offset--) {
	ap = ap->next;
}

for (; ap; ap = ap->next) {
	switch_caller_extension_add_application(new_channel->session, extension, ap->application_name, ap->application_data);
}

caller_profile->destination_number = switch_core_strdup(caller_profile->pool, orig_channel->caller_profile->destination_number)switch_core_perform_strdup(caller_profile->pool, orig_channel
->caller_profile->destination_number, "src/switch_channel.c"
, (const char *)__func__, 3155);
switch_channel_set_caller_profile(new_channel, caller_profile);
switch_channel_set_caller_extension(new_channel, extension);

for (hi = orig_channel->variables->headers; hi; hi = hi->next) {
	int ok = 1;
	for (i = 0; i < argc; i++) {
		if (!strcasecmp(argv[i], hi->name)) {
			ok = 0;
			break;
		}
	}

	if (!ok)
		continue;

	switch_channel_set_variable(new_channel, hi->name, hi->value)switch_channel_set_variable_var_check(new_channel, hi->name
, hi->value, SWITCH_TRUE);
}

status = SWITCH_STATUS_SUCCESS;
}


switch_mutex_unlock(new_channel->profile_mutex);
switch_mutex_unlock(orig_channel->profile_mutex);


return status;
3183}

3185SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_invert_cid(switch_channel_t *channel)
3186{
const char *tname, *tnum;
switch_caller_profile_t *cp;

cp = switch_channel_get_caller_profile(channel);

tname = cp->caller_id_name;
tnum = cp->caller_id_number;

3195#ifdef DEEP_DEBUG_CID
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_channel.c", (const char *)
__func__, 3196, ((void*)0), SWITCH_LOG_CRIT, "SWAP [%s][%s] [%s][%s]\n", cp->caller_id_name, cp->caller_id_number, cp->callee_id_name, cp->callee_id_number);
3197#endif

cp->caller_id_name = cp->callee_id_name;
cp->caller_id_number = cp->callee_id_number;

cp->callee_id_name = tname;
cp->callee_id_number = tnum;

if (zstr(cp->caller_id_name)_zstr(cp->caller_id_name)) {
cp->caller_id_name = "Unknown";
}

if (zstr(cp->caller_id_number)_zstr(cp->caller_id_number)) {
cp->caller_id_number = "Unknown";
}
3212}


3215SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_flip_cid(switch_channel_t *channel)
3216{
switch_event_t *event;
const char *tmp = NULL((void*)0);

switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile->callee_id_name) {
tmp = channel->caller_profile->caller_id_name;
switch_channel_set_variable(channel, "pre_transfer_caller_id_name", channel->caller_profile->caller_id_name)switch_channel_set_variable_var_check(channel, "pre_transfer_caller_id_name"
, channel->caller_profile->caller_id_name, SWITCH_TRUE);
channel->caller_profile->caller_id_name = switch_core_strdup(channel->caller_profile->pool, channel->caller_profile->callee_id_name)switch_core_perform_strdup(channel->caller_profile->pool
, channel->caller_profile->callee_id_name, "src/switch_channel.c"
, (const char *)__func__, 3224);
}

if (switch_channel_test_flag(channel, CF_BRIDGED)) {
channel->caller_profile->callee_id_name = SWITCH_BLANK_STRING"";
} else if (tmp) {
channel->caller_profile->callee_id_name = tmp;
}

if (channel->caller_profile->callee_id_number) {
tmp = channel->caller_profile->caller_id_number;
switch_channel_set_variable(channel, "pre_transfer_caller_id_number", channel->caller_profile->caller_id_number)switch_channel_set_variable_var_check(channel, "pre_transfer_caller_id_number"
, channel->caller_profile->caller_id_number, SWITCH_TRUE
);
channel->caller_profile->caller_id_number = switch_core_strdup(channel->caller_profile->pool, channel->caller_profile->callee_id_number)switch_core_perform_strdup(channel->caller_profile->pool
, channel->caller_profile->callee_id_number, "src/switch_channel.c"
, (const char *)__func__, 3236);
}

if (switch_channel_test_flag(channel, CF_BRIDGED)) {
channel->caller_profile->callee_id_number = SWITCH_BLANK_STRING"";
} else if (tmp) {
channel->caller_profile->callee_id_number = tmp;
}

switch_mutex_unlock(channel->profile_mutex);


if (switch_event_create(&event, SWITCH_EVENT_CALL_UPDATE)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 3248, &event, SWITCH_EVENT_CALL_UPDATE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
const char *uuid = switch_channel_get_partner_uuid(channel);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Direction", "RECV");

if (uuid) {
	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Bridged-To", uuid);
}
switch_channel_event_set_data(channel, event);
switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 3256, &event, ((void*)0));
}


switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 3260, (const char*)(channel->session), SWITCH_LOG_INFO, "%s Flipping CID from \"%s\" <%s> to \"%s\" <%s>\n",
			  switch_channel_get_name(channel),
			  switch_str_nil(switch_channel_get_variable(channel, "pre_transfer_caller_id_name"))(switch_channel_get_variable_dup(channel, "pre_transfer_caller_id_name"
, SWITCH_TRUE, -1) ? switch_channel_get_variable_dup(channel,
 "pre_transfer_caller_id_name", SWITCH_TRUE, -1) : ""),
			  switch_str_nil(switch_channel_get_variable(channel, "pre_transfer_caller_id_number"))(switch_channel_get_variable_dup(channel, "pre_transfer_caller_id_number"
, SWITCH_TRUE, -1) ? switch_channel_get_variable_dup(channel,
 "pre_transfer_caller_id_number", SWITCH_TRUE, -1) : ""),
			  channel->caller_profile->caller_id_name,
			  channel->caller_profile->caller_id_number
			  );

3268}

3270SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_sort_cid(switch_channel_t *channel)
3271{

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND && switch_channel_test_flag(channel, CF_BLEG)) {
switch_channel_flip_cid(channel);
switch_channel_clear_flag(channel, CF_BLEG);
} else if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_channel_test_flag(channel, CF_DIALPLAN)) {
switch_channel_set_flag(channel, CF_DIALPLAN)switch_channel_set_flag_value(channel, CF_DIALPLAN, 1);
switch_channel_flip_cid(channel);
}
3280}

3282SWITCH_DECLARE(switch_caller_extension_t *)__attribute__((visibility("default"))) switch_caller_extension_t
 * switch_channel_get_queued_extension(switch_channel_t *channel)
3283{
switch_caller_extension_t *caller_extension;

switch_mutex_lock(channel->profile_mutex);
caller_extension = channel->queued_extension;
channel->queued_extension = NULL((void*)0);
switch_mutex_unlock(channel->profile_mutex);

return caller_extension;
3292}

3294SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_transfer_to_extension(switch_channel_t *channel, switch_caller_extension_t *caller_extension)
3295{
switch_mutex_lock(channel->profile_mutex);
channel->queued_extension = caller_extension;
switch_mutex_unlock(channel->profile_mutex);

switch_channel_set_flag(channel, CF_TRANSFER)switch_channel_set_flag_value(channel, CF_TRANSFER, 1);
switch_channel_set_state(channel, CS_ROUTING)switch_channel_perform_set_state(channel, "src/switch_channel.c"
, (const char *)__func__, 3301, CS_ROUTING);
3302}

3304SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_caller_extension(switch_channel_t *channel, switch_caller_extension_t *caller_extension)
3305{
switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3306, __extension__ __PRETTY_FUNCTION__
));

switch_channel_sort_cid(channel);

switch_mutex_lock(channel->profile_mutex);
caller_extension->next = channel->caller_profile->caller_extension;
channel->caller_profile->caller_extension = caller_extension;
switch_mutex_unlock(channel->profile_mutex);
3314}


3317SWITCH_DECLARE(switch_caller_extension_t *)__attribute__((visibility("default"))) switch_caller_extension_t
 * switch_channel_get_caller_extension(switch_channel_t *channel)
3318{
switch_caller_extension_t *extension = NULL((void*)0);

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3321, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile) {
extension = channel->caller_profile->caller_extension;
}
switch_mutex_unlock(channel->profile_mutex);
return extension;
3328}


3331SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_bridge_time(switch_channel_t *channel)
3332{
switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile && channel->caller_profile->times) {
channel->caller_profile->times->bridged = switch_micro_time_now();
}
switch_mutex_unlock(channel->profile_mutex);
3338}


3341SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_set_hangup_time(switch_channel_t *channel)
3342{
if (channel->caller_profile && channel->caller_profile->times && !channel->caller_profile->times->hungup) {
switch_mutex_lock(channel->profile_mutex);
channel->caller_profile->times->hungup = switch_micro_time_now();
switch_mutex_unlock(channel->profile_mutex);
}
3348}


3351SWITCH_DECLARE(switch_channel_state_t)__attribute__((visibility("default"))) switch_channel_state_t switch_channel_perform_hangup(switch_channel_t *channel,
															 const char *file, const char *func, int line, switch_call_cause_t hangup_cause)
3353{
int ok = 0;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3356, __extension__ __PRETTY_FUNCTION__
));

/* one per customer */
switch_mutex_lock(channel->state_mutex);
if (!(channel->opaque_flags & OCF_HANGUP)) {
channel->opaque_flags |= OCF_HANGUP;
ok = 1;
}
switch_mutex_unlock(channel->state_mutex);

if (switch_channel_test_flag(channel, CF_LEG_HOLDING)) {
switch_channel_mark_hold(channel, SWITCH_FALSE);
switch_channel_set_flag(channel, CF_HANGUP_HELD)switch_channel_set_flag_value(channel, CF_HANGUP_HELD, 1);
}

if (!ok) {
return channel->state;
}

switch_channel_clear_flag(channel, CF_BLOCK_STATE);

if (channel->state < CS_HANGUP) {
switch_channel_state_t last_state;
switch_event_t *event;
const char *var;


switch_mutex_lock(channel->profile_mutex);
if (channel->hold_record && !channel->hold_record->off) {
	channel->hold_record->off = switch_time_now();
}
switch_mutex_unlock(channel->profile_mutex);

switch_mutex_lock(channel->state_mutex);
last_state = channel->state;
channel->state = CS_HANGUP;
switch_mutex_unlock(channel->state_mutex);

channel->hangup_cause = hangup_cause;
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Hangup %s [%s] [%s]\n",
				  channel->name, state_names[last_state], switch_channel_cause2str(channel->hangup_cause));


switch_channel_set_variable_partner(channel, "last_bridge_hangup_cause", switch_channel_cause2str(hangup_cause))switch_channel_set_variable_partner_var_check(channel, "last_bridge_hangup_cause"
, switch_channel_cause2str(hangup_cause), SWITCH_TRUE);

if ((var = switch_channel_get_variable(channel, SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE)switch_channel_get_variable_dup(channel, "proto_specific_hangup_cause"
, SWITCH_TRUE, -1))) {
	switch_channel_set_variable_partner(channel, "last_bridge_" SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE, var)switch_channel_set_variable_partner_var_check(channel, "last_bridge_"
 "proto_specific_hangup_cause", var, SWITCH_TRUE);
}

if (switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
	switch_channel_set_variable(channel, "last_bridge_role", "originator")switch_channel_set_variable_var_check(channel, "last_bridge_role"
, "originator", SWITCH_TRUE);
} else if (switch_channel_test_flag(channel, CF_BRIDGED)) {
	switch_channel_set_variable(channel, "last_bridge_role", "originatee")switch_channel_set_variable_var_check(channel, "last_bridge_role"
, "originatee", SWITCH_TRUE);
}


if (!switch_core_session_running(channel->session) && !switch_core_session_started(channel->session)) {
	switch_core_session_thread_launch(channel->session);
}

if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_HANGUP)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 3416, &event, SWITCH_EVENT_CHANNEL_HANGUP
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
	switch_channel_event_set_data(channel, event);
	switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 3418, &event, ((void*)0));
}

switch_core_session_kill_channel(channel->session, SWITCH_SIG_KILL)switch_core_session_perform_kill_channel(channel->session,
 "src/switch_channel.c", (const char *)__func__, 3421, SWITCH_SIG_KILL
);
switch_core_session_signal_state_change(channel->session);
switch_core_session_hangup_state(channel->session, SWITCH_FALSE);
}

return channel->state;
3427}

3429static switch_status_t send_ind(switch_channel_t *channel, switch_core_session_message_types_t msg_id, const char *file, const char *func, int line)
3430{
switch_core_session_message_t msg = { 0 };

msg.message_id = msg_id;
msg.from = channel->name;
return switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
3436}

3438SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_acknowledge_call(switch_channel_t *channel,
																const char *file, const char *func, int line)
3440{
send_ind(channel, SWITCH_MESSAGE_INDICATE_ACKNOWLEDGE_CALL, file, func, line);

return SWITCH_STATUS_SUCCESS;
3444}

3446SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_mark_ring_ready_value(switch_channel_t *channel,
																	 switch_ring_ready_t rv,
																	 const char *file, const char *func, int line)
3449{
switch_event_t *event;

if (!switch_channel_test_flag(channel, CF_RING_READY) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Ring-Ready %s!\n", channel->name);
switch_channel_set_flag_value(channel, CF_RING_READY, rv);

switch_mutex_lock(channel->profile_mutex);
if (channel->caller_profile && channel->caller_profile->times && !channel->caller_profile->times->progress) {
	channel->caller_profile->times->progress = switch_micro_time_now();
	if (channel->caller_profile->originator_caller_profile) {
		switch_core_session_t *other_session;
		if ((other_session = switch_core_session_locate(channel->caller_profile->originator_caller_profile->uuid)switch_core_session_perform_locate(channel->caller_profile
->originator_caller_profile->uuid, "src/switch_channel.c"
, (const char *)__func__, 3461))) {
			switch_channel_t *other_channel;
			other_channel = switch_core_session_get_channel(other_session);
			switch_mutex_lock(other_channel->profile_mutex);
			if (other_channel->caller_profile && !other_channel->caller_profile->times->progress) {
				other_channel->caller_profile->times->progress = channel->caller_profile->times->progress;
			}
			switch_mutex_unlock(other_channel->profile_mutex);
			switch_core_session_rwunlock(other_session);
		}
		channel->caller_profile->originator_caller_profile->times->progress = channel->caller_profile->times->progress;
	}
}
switch_mutex_unlock(channel->profile_mutex);

if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_PROGRESS)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 3476, &event, SWITCH_EVENT_CHANNEL_PROGRESS
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
	switch_channel_event_set_data(channel, event);
	switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 3478, &event, ((void*)0));
}

switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE"execute_on_ring");
switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_RING_VARIABLE"api_on_ring");

switch_channel_set_callstate(channel, CCS_RINGING)switch_channel_perform_set_callstate(channel, CCS_RINGING, "src/switch_channel.c"
, (const char *)__func__, 3484);

send_ind(channel, SWITCH_MESSAGE_RING_EVENT, file, func, line);

return SWITCH_STATUS_SUCCESS;
}

return SWITCH_STATUS_FALSE;
3492}

3494SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_check_zrtp(switch_channel_t *channel)
3495{

if (!switch_channel_test_flag(channel, CF_ZRTP_PASSTHRU)
&& switch_channel_test_flag(channel, CF_ZRTP_PASSTHRU_REQ)
&& switch_channel_test_flag(channel, CF_ZRTP_HASH)) {
switch_core_session_t *other_session;
switch_channel_t *other_channel;
int doit = 1;

if (switch_core_session_get_partner(channel->session, &other_session)switch_core_session_perform_get_partner(channel->session, &
other_session, "src/switch_channel.c", (const char *)__func__
, 3504) == SWITCH_STATUS_SUCCESS) {
	other_channel = switch_core_session_get_channel(other_session);

	if (switch_channel_test_flag(other_channel, CF_ZRTP_HASH) && !switch_channel_test_flag(other_channel, CF_ZRTP_PASSTHRU)) {

		switch_channel_set_flag(channel, CF_ZRTP_PASSTHRU)switch_channel_set_flag_value(channel, CF_ZRTP_PASSTHRU, 1);
		switch_channel_set_flag(other_channel, CF_ZRTP_PASSTHRU)switch_channel_set_flag_value(other_channel, CF_ZRTP_PASSTHRU
, 1);

		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 3512, (const char*)(channel->session), SWITCH_LOG_INFO,
						  "%s Activating ZRTP passthru mode.\n", switch_channel_get_name(channel));

		switch_channel_set_variable(channel, "zrtp_passthru_active", "true")switch_channel_set_variable_var_check(channel, "zrtp_passthru_active"
, "true", SWITCH_TRUE);
		switch_channel_set_variable(other_channel, "zrtp_passthru_active", "true")switch_channel_set_variable_var_check(other_channel, "zrtp_passthru_active"
, "true", SWITCH_TRUE);
		switch_channel_set_variable(channel, "zrtp_secure_media", "false")switch_channel_set_variable_var_check(channel, "zrtp_secure_media"
, "false", SWITCH_TRUE);
		switch_channel_set_variable(other_channel, "zrtp_secure_media", "false")switch_channel_set_variable_var_check(other_channel, "zrtp_secure_media"
, "false", SWITCH_TRUE);
		doit = 0;
	}

	switch_core_session_rwunlock(other_session);
}

if (doit) {
	switch_channel_set_variable(channel, "zrtp_passthru_active", "false")switch_channel_set_variable_var_check(channel, "zrtp_passthru_active"
, "false", SWITCH_TRUE);
	switch_channel_set_variable(channel, "zrtp_secure_media", "true")switch_channel_set_variable_var_check(channel, "zrtp_secure_media"
, "true", SWITCH_TRUE);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 3528, (const char*)(channel->session), SWITCH_LOG_INFO,
					  "%s ZRTP not negotiated on both sides; disabling ZRTP passthru mode.\n", switch_channel_get_name(channel));

	switch_channel_clear_flag(channel, CF_ZRTP_PASSTHRU);
	switch_channel_clear_flag(channel, CF_ZRTP_HASH);

	if (switch_core_session_get_partner(channel->session, &other_session)switch_core_session_perform_get_partner(channel->session, &
other_session, "src/switch_channel.c", (const char *)__func__
, 3534) == SWITCH_STATUS_SUCCESS) {
		other_channel = switch_core_session_get_channel(other_session);

		switch_channel_set_variable(other_channel, "zrtp_passthru_active", "false")switch_channel_set_variable_var_check(other_channel, "zrtp_passthru_active"
, "false", SWITCH_TRUE);
		switch_channel_set_variable(other_channel, "zrtp_secure_media", "true")switch_channel_set_variable_var_check(other_channel, "zrtp_secure_media"
, "true", SWITCH_TRUE);
		switch_channel_clear_flag(other_channel, CF_ZRTP_PASSTHRU);
		switch_channel_clear_flag(other_channel, CF_ZRTP_HASH);

		switch_core_session_rwunlock(other_session);
	}

}
}
3547}

3549SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_mark_pre_answered(switch_channel_t *channel, const char *file, const char *func, int line)
3550{
switch_event_t *event;

if (!switch_channel_test_flag(channel, CF_EARLY_MEDIA) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
const char *uuid;
switch_core_session_t *other_session;

switch_core_media_check_dtls(channel->session, SWITCH_MEDIA_TYPE_AUDIO);

switch_channel_check_zrtp(channel);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Pre-Answer %s!\n", channel->name);
switch_channel_set_flag(channel, CF_EARLY_MEDIA)switch_channel_set_flag_value(channel, CF_EARLY_MEDIA, 1);

switch_channel_set_variable(channel, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "EARLY MEDIA")switch_channel_set_variable_var_check(channel, "endpoint_disposition"
, "EARLY MEDIA", SWITCH_TRUE);

if (switch_true(switch_channel_get_variable(channel, "video_mirror_input")switch_channel_get_variable_dup(channel, "video_mirror_input"
, SWITCH_TRUE, -1))) {
	switch_channel_set_flag(channel, CF_VIDEO_MIRROR_INPUT)switch_channel_set_flag_value(channel, CF_VIDEO_MIRROR_INPUT,
 1);
}

if (channel->caller_profile && channel->caller_profile->times) {
	switch_mutex_lock(channel->profile_mutex);
	channel->caller_profile->times->progress_media = switch_micro_time_now();
	if (channel->caller_profile->originator_caller_profile) {
		switch_core_session_t *osession;
		if ((osession = switch_core_session_locate(channel->caller_profile->originator_caller_profile->uuid)switch_core_session_perform_locate(channel->caller_profile
->originator_caller_profile->uuid, "src/switch_channel.c"
, (const char *)__func__, 3574))) {
			switch_channel_t *other_channel;
			other_channel = switch_core_session_get_channel(osession);
			if (other_channel->caller_profile) {
				other_channel->caller_profile->times->progress_media = channel->caller_profile->times->progress_media;
			}
			switch_core_session_rwunlock(osession);
		}
		channel->caller_profile->originator_caller_profile->times->progress_media = channel->caller_profile->times->progress_media;
	}
	switch_mutex_unlock(channel->profile_mutex);
}

if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 3587, &event, SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
	switch_channel_event_set_data(channel, event);
	switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 3589, &event, ((void*)0));
}

switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE"execute_on_pre_answer");
switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE"execute_on_media");

switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE"api_on_pre_answer");
switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE"api_on_media");

if (switch_true(switch_channel_get_variable(channel, SWITCH_PASSTHRU_PTIME_MISMATCH_VARIABLE)switch_channel_get_variable_dup(channel, "passthru_ptime_mismatch"
, SWITCH_TRUE, -1))) {
	switch_channel_set_flag(channel, CF_PASSTHRU_PTIME_MISMATCH)switch_channel_set_flag_value(channel, CF_PASSTHRU_PTIME_MISMATCH
, 1);
}


/* 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
 */
if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE)switch_channel_get_variable_dup(channel, "originator", SWITCH_TRUE
, -1))
	&& (other_session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 3607))) {
	switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK)switch_core_session_perform_kill_channel(other_session, "src/switch_channel.c"
, (const char *)__func__, 3608, SWITCH_SIG_BREAK);
	switch_core_session_rwunlock(other_session);
}

switch_channel_set_callstate(channel, CCS_EARLY)switch_channel_perform_set_callstate(channel, CCS_EARLY, "src/switch_channel.c"
, (const char *)__func__, 3612);

send_ind(channel, SWITCH_MESSAGE_PROGRESS_EVENT, file, func, line);

switch_core_media_check_autoadj(channel->session);

return SWITCH_STATUS_SUCCESS;
}

return SWITCH_STATUS_FALSE;
3622}

3624SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_pre_answer(switch_channel_t *channel, const char *file, const char *func, int line)
3625{
switch_core_session_message_t msg = { 0 };
switch_status_t status = SWITCH_STATUS_SUCCESS;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3629, __extension__ __PRETTY_FUNCTION__
));

if (channel->hangup_cause || channel->state >= CS_HANGUP) {
return SWITCH_STATUS_FALSE;
}

if (switch_channel_test_flag(channel, CF_ANSWERED)) {
return SWITCH_STATUS_SUCCESS;
}

if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
return SWITCH_STATUS_SUCCESS;
}

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
msg.message_id = SWITCH_MESSAGE_INDICATE_PROGRESS;
msg.from = channel->name;
status = switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
}

if (status == SWITCH_STATUS_SUCCESS) {
switch_channel_perform_mark_pre_answered(channel, file, func, line);
switch_channel_audio_sync(channel)switch_channel_perform_audio_sync(channel, "src/switch_channel.c"
, (const char *)__func__, 3651);
} else {
switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION)switch_channel_perform_hangup(channel, "src/switch_channel.c"
, (const char *)__func__, 3653, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION
);
}

return status;
3657}

3659SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_ring_ready_value(switch_channel_t *channel, switch_ring_ready_t rv,
																const char *file, const char *func, int line)
3661{
switch_core_session_message_t msg = { 0 };
switch_status_t status = SWITCH_STATUS_SUCCESS;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3665, __extension__ __PRETTY_FUNCTION__
));

if (channel->hangup_cause || channel->state >= CS_HANGUP) {
return SWITCH_STATUS_FALSE;
}

if (switch_channel_test_flag(channel, CF_ANSWERED)) {
return SWITCH_STATUS_SUCCESS;
}

if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
return SWITCH_STATUS_SUCCESS;
}

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
msg.message_id = SWITCH_MESSAGE_INDICATE_RINGING;
msg.from = channel->name;
msg.numeric_arg = rv;
status = switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
}

if (status == SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Ring Ready %s!\n", channel->name);
switch_channel_perform_mark_ring_ready_value(channel, rv, file, func, line);
} else {
switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION)switch_channel_perform_hangup(channel, "src/switch_channel.c"
, (const char *)__func__, 3690, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION
);
}

return status;
3694}

3696static void do_api_on(switch_channel_t *channel, const char *variable)
3697{
char *app;
char *arg = NULL((void*)0);
switch_stream_handle_t stream = { 0 };

app = switch_core_session_strdup(channel->session, variable)switch_core_perform_session_strdup(channel->session, variable
, "src/switch_channel.c", (const char *)__func__, 3702);

if ((arg = strchr(app, ' '))) {
*arg++ = '\0';
}

SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "src/switch_channel.c", 3708, __extension__ __PRETTY_FUNCTION__
)); memset(stream.data, 0, 1024); stream.end = stream.data; stream
.data_size = 1024; stream.write_function = switch_console_stream_write
; stream.raw_write_function = switch_console_stream_raw_write
; stream.alloc_len = 1024; stream.alloc_chunk = 1024;
switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 3709, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "%s process %s: %s(%s)\n%s\n",
			  channel->name, variable, app, switch_str_nil(arg)(arg ? arg : ""), (char *) stream.data);
switch_api_execute(app, arg, NULL((void*)0), &stream);
free(stream.data);
3713}


3716SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_api_on(switch_channel_t *channel, const char *variable_prefix)
3717{
switch_event_header_t *hp;
switch_event_t *event;
int x = 0;


switch_channel_get_variables(channel, &event);

for (hp = event->headers; hp; hp = hp->next) {
char *var = hp->name;
char *val = hp->value;

if (!strncasecmp(var, variable_prefix, strlen(variable_prefix))) {
	if (hp->idx) {
		int i;
		for (i = 0; i < hp->idx; i++) {
			x++;
			do_api_on(channel, hp->array[i]);
		}
	} else {
		x++;
		do_api_on(channel, val);
	}
}
}

switch_event_destroy(&event);

return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
3746}

3748static void do_execute_on(switch_channel_t *channel, const char *variable)
3749{
char *arg = NULL((void*)0);
char *p;
int bg = 0;
char *app;

app = switch_core_session_strdup(channel->session, variable)switch_core_perform_session_strdup(channel->session, variable
, "src/switch_channel.c", (const char *)__func__, 3755);

for(p = app; p && *p; p++) {
if (*p == ' ' || (*p == ':' && (*(p+1) != ':'))) {
	*p++ = '\0';
	arg = p;
	break;
} else if (*p == ':' && (*(p+1) == ':')) {
	bg++;
	break;
}
}

switch_assert(app != NULL)((app != ((void*)0)) ? (void) (0) : __assert_fail ("app != ((void*)0)"
, "src/switch_channel.c", 3768, __extension__ __PRETTY_FUNCTION__
));
if (!strncasecmp(app, "perl", 4)) {
bg++;
}

if (bg) {
switch_core_session_execute_application_async(channel->session, app, arg);
} else {
switch_core_session_execute_application(channel->session, app, arg)switch_core_session_execute_application_get_flags(channel->
session, app, arg, ((void*)0));
}
3778}

3780SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_execute_on(switch_channel_t *channel, const char *variable_prefix)
3781{
switch_event_header_t *hp;
switch_event_t *event, *cevent;
int x = 0;

switch_core_get_variables(&event);
switch_channel_get_variables(channel, &cevent);
switch_event_merge(event, cevent);

for (hp = event->headers; hp; hp = hp->next) {
char *var = hp->name;
char *val = hp->value;

if (!strncasecmp(var, variable_prefix, strlen(variable_prefix))) {
	if (hp->idx) {
		int i;
		for (i = 0; i < hp->idx; i++) {
			x++;
			do_execute_on(channel, hp->array[i]);
		}
	} else {
		x++;
		do_execute_on(channel, val);
	}
}
}

switch_event_destroy(&event);
switch_event_destroy(&cevent);

return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
3812}

3814SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_mark_answered(switch_channel_t *channel, const char *file, const char *func, int line)
3815{
switch_event_t *event;
const char *uuid;
switch_core_session_t *other_session;
const char *var;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3821, __extension__ __PRETTY_FUNCTION__
));

if (channel->hangup_cause || channel->state >= CS_HANGUP) {
return SWITCH_STATUS_FALSE;
}

if (switch_channel_test_flag(channel, CF_ANSWERED)) {
return SWITCH_STATUS_SUCCESS;
}

switch_core_media_check_dtls(channel->session, SWITCH_MEDIA_TYPE_AUDIO);

if (channel->caller_profile && channel->caller_profile->times) {
switch_mutex_lock(channel->profile_mutex);
channel->caller_profile->times->answered = switch_micro_time_now();
switch_mutex_unlock(channel->profile_mutex);
}

switch_channel_check_zrtp(channel);
switch_channel_set_flag(channel, CF_ANSWERED)switch_channel_set_flag_value(channel, CF_ANSWERED, 1);

if (switch_true(switch_channel_get_variable(channel, "video_mirror_input")switch_channel_get_variable_dup(channel, "video_mirror_input"
, SWITCH_TRUE, -1))) {
switch_channel_set_flag(channel, CF_VIDEO_MIRROR_INPUT)switch_channel_set_flag_value(channel, CF_VIDEO_MIRROR_INPUT,
 1);
//switch_channel_set_flag(channel, CF_VIDEO_DECODED_READ);
}


if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_ANSWER)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 3848, &event, SWITCH_EVENT_CHANNEL_ANSWER
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(channel, event);
switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 3850, &event, ((void*)0));
}

/* 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
*/
if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE)switch_channel_get_variable_dup(channel, "originator", SWITCH_TRUE
, -1))
&& (other_session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_channel.c"
, (const char *)__func__, 3857))) {
switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK)switch_core_session_perform_kill_channel(other_session, "src/switch_channel.c"
, (const char *)__func__, 3858, SWITCH_SIG_BREAK);
switch_core_session_rwunlock(other_session);
}

if (switch_true(switch_channel_get_variable(channel, SWITCH_PASSTHRU_PTIME_MISMATCH_VARIABLE)switch_channel_get_variable_dup(channel, "passthru_ptime_mismatch"
, SWITCH_TRUE, -1))) {
switch_channel_set_flag(channel, CF_PASSTHRU_PTIME_MISMATCH)switch_channel_set_flag_value(channel, CF_PASSTHRU_PTIME_MISMATCH
, 1);
}

if ((var = switch_channel_get_variable(channel, SWITCH_ENABLE_HEARTBEAT_EVENTS_VARIABLE)switch_channel_get_variable_dup(channel, "enable_heartbeat_events"
, SWITCH_TRUE, -1))) {
uint32_t seconds = 60;
int tmp;

if (switch_is_number(var)) {
	tmp = atoi(var);
	if (tmp > 0) {
		seconds = tmp;
	}
} else if (!switch_true(var)) {
	seconds = 0;
}

if (seconds) {
	switch_core_session_enable_heartbeat(channel->session, seconds);
}
}

switch_channel_set_variable(channel, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "ANSWER")switch_channel_set_variable_var_check(channel, "endpoint_disposition"
, "ANSWER", SWITCH_TRUE);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Channel [%s] has been answered\n",
			  channel->name);


if (switch_channel_get_variable(channel, "absolute_codec_string")switch_channel_get_variable_dup(channel, "absolute_codec_string"
, SWITCH_TRUE, -1)) {
/* inherit_codec == true will implicitly clear the absolute_codec_string
   variable if used since it was the reason it was set in the first place and is no longer needed */
if (switch_true(switch_channel_get_variable(channel, "inherit_codec")switch_channel_get_variable_dup(channel, "inherit_codec", SWITCH_TRUE
, -1))) {
	switch_channel_set_variable(channel, "absolute_codec_string", NULL)switch_channel_set_variable_var_check(channel, "absolute_codec_string"
, ((void*)0), SWITCH_TRUE);
}
}

switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE"execute_on_answer");

if (!switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE"execute_on_media");
switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE"api_on_media");
}

switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE"api_on_answer");

switch_channel_presence(channel, "unknown", "answered", NULL)switch_channel_perform_presence(channel, "unknown", "answered"
, ((void*)0), "src/switch_channel.c", (const char *)__func__,
 3906);

//switch_channel_audio_sync(channel);

switch_core_recovery_track(channel->session);

switch_channel_set_callstate(channel, CCS_ACTIVE)switch_channel_perform_set_callstate(channel, CCS_ACTIVE, "src/switch_channel.c"
, (const char *)__func__, 3912);

send_ind(channel, SWITCH_MESSAGE_ANSWER_EVENT, file, func, line);

switch_core_media_check_autoadj(channel->session);

if (switch_channel_test_flag(channel, CF_RTT)) {
switch_channel_set_flag_partner(channel, CF_RTT);
}

return SWITCH_STATUS_SUCCESS;
3923}

3925SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_perform_answer(switch_channel_t *channel, const char *file, const char *func, int line)
3926{
switch_core_session_message_t msg = { 0 };
switch_status_t status = SWITCH_STATUS_SUCCESS;

switch_assert(channel != NULL)((channel != ((void*)0)) ? (void) (0) : __assert_fail ("channel != ((void*)0)"
, "src/switch_channel.c", 3930, __extension__ __PRETTY_FUNCTION__
));

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
return SWITCH_STATUS_SUCCESS;
}

if (channel->hangup_cause || channel->state >= CS_HANGUP) {
return SWITCH_STATUS_FALSE;
}

if (switch_channel_test_flag(channel, CF_ANSWERED)) {
return SWITCH_STATUS_SUCCESS;
}

msg.message_id = SWITCH_MESSAGE_INDICATE_ANSWER;
msg.from = channel->name;
status = switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);


if (status == SWITCH_STATUS_SUCCESS) {
switch_channel_perform_mark_answered(channel, file, func, line);
if (!switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
	switch_channel_audio_sync(channel)switch_channel_perform_audio_sync(channel, "src/switch_channel.c"
, (const char *)__func__, 3952);
}
} else {
switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION)switch_channel_perform_hangup(channel, "src/switch_channel.c"
, (const char *)__func__, 3955, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION
);
}


if (switch_core_session_in_thread(channel->session) && !switch_channel_test_flag(channel, CF_PROXY_MODE) &&
!switch_channel_test_flag(channel, CF_HAS_TEXT)) {
const char *delay;

if ((delay = switch_channel_get_variable(channel, "answer_delay")switch_channel_get_variable_dup(channel, "answer_delay", SWITCH_TRUE
, -1))) {
	uint32_t msec = atoi(delay);

	if (msec) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 3967, (const char*)(channel->session), SWITCH_LOG_DEBUG, "Answer delay for %u msec\n", msec);
		switch_ivr_sleep(channel->session, msec, SWITCH_TRUE, NULL((void*)0));
	}
}
}

return status;
3974}

3976#define resize(l){ char *dp; olen += (len + l + block); cpos = c - data; if ((
dp = realloc(data, olen))) { data = dp; c = data + cpos; memset
(c, 0, olen - cpos); }} {\
char *dp;\
olen += (len + l + block);\
cpos = c - data;\
if ((dp = realloc(data, olen))) {\
data = dp;\
c = data + cpos;\
memset(c, 0, olen - cpos);\
}}                           \

3986SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_channel_expand_variables_check(switch_channel_t *channel, const char *in, switch_event_t *var_list, switch_event_t *api_list, uint32_t recur)
3987{
char *p, *c = NULL((void*)0);
char *data, *indup, *endof_indup;
size_t sp = 0, len = 0, olen = 0, vtype = 0, br = 0, cpos, block = 128;
char *cloned_sub_val = NULL((void*)0), *sub_val = NULL((void*)0), *expanded_sub_val = NULL((void*)0);
char *func_val = NULL((void*)0), *sb = NULL((void*)0);
int nv = 0;

if (recur > 100) {
return (char *) in;
}

if (zstr(in)_zstr(in)) {
return (char *) in;
}

nv = switch_string_var_check_const(in) || switch_string_has_escaped_data(in);

if (!nv) {
return (char *) in;
}


nv = 0;
olen = strlen(in) + 1;
indup = strdup(in);
endof_indup = end_of_p(indup)(*indup == '\0' ? indup : indup + strlen(indup) - 1) + 1;

if ((data = malloc(olen))) {
memset(data, 0, olen);
c = data;
for (p = indup; p && p < endof_indup && *p; p++) {
	int global = 0;
	vtype = 0;

	if (*p == '\\') {
		if (*(p + 1) == '$') {
			nv = 1;
			p++;
			if (*(p + 1) == '$') {
				p++;
			}
		} else if (*(p + 1) == '\'') {
			p++;
			continue;
		} else if (*(p + 1) == '\\') {
			if (len + 1 >= olen) {
				resize(1){ char *dp; olen += (len + 1 + block); cpos = c - data; if ((
dp = realloc(data, olen))) { data = dp; c = data + cpos; memset
(c, 0, olen - cpos); }};
			}

			*c++ = *p++;
			len++;
			continue;
		}
	}

	if (*p == '$' && !nv) {

		if (*(p + 1) == '$') {
			p++;
			global++;
		}

		if (*(p + 1)) {
			if (*(p + 1) == '{') {
				vtype = global ? 3 : 1;
			} else {
				nv = 1;
			}
		} else {
			nv = 1;
		}
	}

	if (nv) {
		if (len + 1 >= olen) {
			resize(1){ char *dp; olen += (len + 1 + block); cpos = c - data; if ((
dp = realloc(data, olen))) { data = dp; c = data + cpos; memset
(c, 0, olen - cpos); }};
		}

		*c++ = *p;
		len++;
		nv = 0;
		continue;
	}

	if (vtype) {
		char *s = p, *e, *vname, *vval = NULL((void*)0);
		size_t nlen;

		s++;

		if ((vtype == 1 || vtype == 3) && *s == '{') {
			br = 1;
			s++;
		}

		e = s;
		vname = s;
		while (*e) {
			if (br == 1 && *e == '}') {
				br = 0;
				*e++ = '\0';
				break;
			}

			if (br > 0) {
				if (e != s && *e == '{') {
					br++;
				} else if (br > 1 && *e == '}') {
					br--;
				}
			}

			e++;
		}
		p = e > endof_indup ? endof_indup : e;

		vval = NULL((void*)0);
		for(sb = vname; sb && *sb; sb++) {
			if (*sb == ' ') {
				vval = sb;
				break;
			} else if (*sb == '(') {
				vval = sb;
				br = 1;
				break;
			}
		}

		if (vval) {
			e = vval - 1;
			*vval++ = '\0';
			while (*e == ' ') {
				*e-- = '\0';
			}
			e = vval;

			while (e && *e) {
				if (*e == '(') {
					br++;
				} else if (br > 1 && *e == ')') {
					br--;
				} else if (br == 1 && *e == ')') {
					*e = '\0';
					break;
				}
				e++;
			}

			vtype = 2;
		}

		if (vtype == 1 || vtype == 3) {
			char *expanded = NULL((void*)0);
			int offset = 0;
			int ooffset = 0;
			char *ptr;
			int idx = -1;

			if ((expanded = switch_channel_expand_variables_check(channel, (char *) vname, var_list, api_list, recur+1)) == vname) {
				expanded = NULL((void*)0);
			} else {
				vname = expanded;
			}

			if ((ptr = strchr(vname, ':'))) {
				*ptr++ = '\0';
				offset = atoi(ptr);
				if ((ptr = strchr(ptr, ':'))) {
					ptr++;
					ooffset = atoi(ptr);
				}
			}

			if ((ptr = strchr(vname, '[')) && strchr(ptr, ']')) {
				*ptr++ = '\0';
				idx = atoi(ptr);
			}

			if ((sub_val = (char *) switch_channel_get_variable_dup(channel, vname, SWITCH_TRUE, idx))) {
				if (var_list && !switch_event_check_permission_list(var_list, vname)) {
					sub_val = "<Variable Expansion Permission Denied>";
				}

				if ((expanded_sub_val = switch_channel_expand_variables_check(channel, sub_val, var_list, api_list, recur+1)) == sub_val) {
					expanded_sub_val = NULL((void*)0);
				} else {
					sub_val = expanded_sub_val;
				}

				if (offset || ooffset) {
					cloned_sub_val = strdup(sub_val);
					switch_assert(cloned_sub_val)((cloned_sub_val) ? (void) (0) : __assert_fail ("cloned_sub_val"
, "src/switch_channel.c", 4179, __extension__ __PRETTY_FUNCTION__
));
					sub_val = cloned_sub_val;
				}

				if (offset >= 0) {
					if ((size_t) offset > strlen(sub_val)) {
						*sub_val = '\0';
					} else {
						sub_val += offset;
					}
				} else if ((size_t) abs(offset) <= strlen(sub_val)) {
					sub_val = cloned_sub_val + (strlen(cloned_sub_val) + offset);
				}

				if (ooffset > 0 && (size_t) ooffset < strlen(sub_val)) {
					if ((ptr = (char *) sub_val + ooffset)) {
						*ptr = '\0';
					}
				}
			}

			switch_safe_free(expanded)if (expanded) {free(expanded);expanded=((void*)0);};
		} else {
			switch_stream_handle_t stream = { 0 };
			char *expanded = NULL((void*)0);

			SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "src/switch_channel.c", 4205, __extension__ __PRETTY_FUNCTION__
)); memset(stream.data, 0, 1024); stream.end = stream.data; stream
.data_size = 1024; stream.write_function = switch_console_stream_write
; stream.raw_write_function = switch_console_stream_raw_write
; stream.alloc_len = 1024; stream.alloc_chunk = 1024;

			if (stream.data) {
				char *expanded_vname = NULL((void*)0);

				if ((expanded_vname = switch_channel_expand_variables_check(channel, (char *) vname, var_list, api_list, recur+1)) == vname) {
					expanded_vname = NULL((void*)0);
				} else {
					vname = expanded_vname;
				}

				if ((expanded = switch_channel_expand_variables_check(channel, vval, var_list, api_list, recur+1)) == vval) {
					expanded = NULL((void*)0);
				} else {
					vval = expanded;
				}

				if (!switch_core_test_flag(SCF_API_EXPANSION) || (api_list && !switch_event_check_permission_list(api_list, vname))) {
					func_val = NULL((void*)0);
					sub_val = "<API Execute Permission Denied>";
					free(stream.data);
				} else {
					if (switch_api_execute(vname, vval, channel->session, &stream) == SWITCH_STATUS_SUCCESS) {
						func_val = stream.data;
						sub_val = func_val;
					} else {
						free(stream.data);
					}
				}

				switch_safe_free(expanded)if (expanded) {free(expanded);expanded=((void*)0);};
				switch_safe_free(expanded_vname)if (expanded_vname) {free(expanded_vname);expanded_vname=((void
*)0);};

			} else {
				switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 4239, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_CRIT, "Memory Error!\n");
				free(data);
				free(indup);
				return (char *) in;
			}
		}
		if ((nlen = sub_val ? strlen(sub_val) : 0)) {
			if (len + nlen >= olen) {
				resize(nlen){ char *dp; olen += (len + nlen + block); cpos = c - data; if
 ((dp = realloc(data, olen))) { data = dp; c = data + cpos; memset
(c, 0, olen - cpos); }};
			}

			len += nlen;
			strcat(c, sub_val);
			c += nlen;
		}

		switch_safe_free(func_val)if (func_val) {free(func_val);func_val=((void*)0);};
		switch_safe_free(cloned_sub_val)if (cloned_sub_val) {free(cloned_sub_val);cloned_sub_val=((void
*)0);};
		switch_safe_free(expanded_sub_val)if (expanded_sub_val) {free(expanded_sub_val);expanded_sub_val
=((void*)0);};
		sub_val = NULL((void*)0);
		vname = NULL((void*)0);
		br = 0;
	}

	if (sp) {
		if (len + 1 >= olen) {
			resize(1){ char *dp; olen += (len + 1 + block); cpos = c - data; if ((
dp = realloc(data, olen))) { data = dp; c = data + cpos; memset
(c, 0, olen - cpos); }};
		}

		*c++ = ' ';
		sp = 0;
		len++;
	}

	if (*p == '$') {
		p--;
	} else {
		if (len + 1 >= olen) {
			resize(1){ char *dp; olen += (len + 1 + block); cpos = c - data; if ((
dp = realloc(data, olen))) { data = dp; c = data + cpos; memset
(c, 0, olen - cpos); }};
		}

		*c++ = *p;
		len++;
	}
}
}
free(indup);

return data;
4288}

4290SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_channel_build_param_string(switch_channel_t *channel, switch_caller_profile_t *caller_profile, const char *prefix)
4291{
switch_stream_handle_t stream = { 0 };
switch_size_t encode_len = 1024, new_len = 0;
char *encode_buf = NULL((void*)0);
const char *prof[13] = { 0 }, *prof_names[13] = {
0};
char *e = NULL((void*)0);
switch_event_header_t *hi;
uint32_t x = 0;

SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "src/switch_channel.c", 4301, __extension__ __PRETTY_FUNCTION__
)); memset(stream.data, 0, 1024); stream.end = stream.data; stream
.data_size = 1024; stream.write_function = switch_console_stream_write
; stream.raw_write_function = switch_console_stream_raw_write
; stream.alloc_len = 1024; stream.alloc_chunk = 1024;

if (prefix) {
stream.write_function(&stream, "%s&", prefix);
}

encode_buf = malloc(encode_len);
switch_assert(encode_buf)((encode_buf) ? (void) (0) : __assert_fail ("encode_buf", "src/switch_channel.c"
, 4308, __extension__ __PRETTY_FUNCTION__));

if (!caller_profile) {
caller_profile = switch_channel_get_caller_profile(channel);
}

switch_assert(caller_profile != NULL)((caller_profile != ((void*)0)) ? (void) (0) : __assert_fail (
"caller_profile != ((void*)0)", "src/switch_channel.c", 4314,
 __extension__ __PRETTY_FUNCTION__));

prof[0] = caller_profile->context;
prof[1] = caller_profile->destination_number;
prof[2] = caller_profile->caller_id_name;
prof[3] = caller_profile->caller_id_number;
prof[4] = caller_profile->network_addr;
prof[5] = caller_profile->ani;
prof[6] = caller_profile->aniii;
prof[7] = caller_profile->rdnis;
prof[8] = caller_profile->source;
prof[9] = caller_profile->chan_name;
prof[10] = caller_profile->uuid;
prof[11] = caller_profile->transfer_source;

prof_names[0] = "context";
prof_names[1] = "destination_number";
prof_names[2] = "caller_id_name";
prof_names[3] = "caller_id_number";
prof_names[4] = "network_addr";
prof_names[5] = "ani";
prof_names[6] = "aniii";
prof_names[7] = "rdnis";
prof_names[8] = "source";
prof_names[9] = "chan_name";
prof_names[10] = "uuid";
prof_names[11] = "transfer_source";

for (x = 0; prof[x]; x++) {
if (zstr(prof[x])_zstr(prof[x])) {
	continue;
}
new_len = (strlen(prof[x]) * 3) + 1;
if (encode_len < new_len) {
	char *tmp;

	encode_len = new_len;

	if (!(tmp = realloc(encode_buf, encode_len))) {
		abort();
	}

	encode_buf = tmp;
}
switch_url_encode(prof[x], encode_buf, encode_len);
stream.write_function(&stream, "%s=%s&", prof_names[x], encode_buf);
}

if (channel->caller_profile->soft) {
profile_node_t *pn;

for(pn = channel->caller_profile->soft; pn; pn = pn->next) {
	char *var = pn->var;
	char *val = pn->val;

	new_len = (strlen((char *) var) * 3) + 1;
	if (encode_len < new_len) {
		char *tmp;

		encode_len = new_len;

		tmp = realloc(encode_buf, encode_len);
		switch_assert(tmp)((tmp) ? (void) (0) : __assert_fail ("tmp", "src/switch_channel.c"
, 4376, __extension__ __PRETTY_FUNCTION__));
		encode_buf = tmp;
	}

	switch_url_encode((char *) val, encode_buf, encode_len);
	stream.write_function(&stream, "%s=%s&", (char *) var, encode_buf);

}
}

if ((hi = switch_channel_variable_first(channel))) {
for (; hi; hi = hi->next) {
	char *var = hi->name;
	char *val = hi->value;

	new_len = (strlen((char *) var) * 3) + 1;
	if (encode_len < new_len) {
		char *tmp;

		encode_len = new_len;

		tmp = realloc(encode_buf, encode_len);
		switch_assert(tmp)((tmp) ? (void) (0) : __assert_fail ("tmp", "src/switch_channel.c"
, 4398, __extension__ __PRETTY_FUNCTION__));
		encode_buf = tmp;
	}

	switch_url_encode((char *) val, encode_buf, encode_len);
	stream.write_function(&stream, "%s=%s&", (char *) var, encode_buf);

}
switch_channel_variable_last(channel);
}

e = (char *) stream.data + (strlen((char *) stream.data) - 1);

if (e && *e == '&') {
*e = '\0';
}

switch_safe_free(encode_buf)if (encode_buf) {free(encode_buf);encode_buf=((void*)0);};

return stream.data;
4418}

4420SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_pass_callee_id(switch_channel_t *channel, switch_channel_t *other_channel)
4421{
int x = 0;

switch_assert(channel)((channel) ? (void) (0) : __assert_fail ("channel", "src/switch_channel.c"
, 4424, __extension__ __PRETTY_FUNCTION__));
switch_assert(other_channel)((other_channel) ? (void) (0) : __assert_fail ("other_channel"
, "src/switch_channel.c", 4425, __extension__ __PRETTY_FUNCTION__
));

switch_mutex_lock(channel->profile_mutex);
switch_mutex_lock(other_channel->profile_mutex);

if (!zstr(channel->caller_profile->callee_id_name)_zstr(channel->caller_profile->callee_id_name)) {
other_channel->caller_profile->callee_id_name = switch_core_strdup(other_channel->caller_profile->pool, channel->caller_profile->callee_id_name)switch_core_perform_strdup(other_channel->caller_profile->
pool, channel->caller_profile->callee_id_name, "src/switch_channel.c"
, (const char *)__func__, 4431);
x++;
}

if (!zstr(channel->caller_profile->callee_id_number)_zstr(channel->caller_profile->callee_id_number)) {
other_channel->caller_profile->callee_id_number = switch_core_strdup(other_channel->caller_profile->pool, channel->caller_profile->callee_id_number)switch_core_perform_strdup(other_channel->caller_profile->
pool, channel->caller_profile->callee_id_number, "src/switch_channel.c"
, (const char *)__func__, 4436);
x++;
}

switch_mutex_unlock(other_channel->profile_mutex);
switch_mutex_unlock(channel->profile_mutex);

return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
4444}

4446SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_get_variables(switch_channel_t *channel, switch_event_t **event)
4447{
switch_status_t status;
switch_mutex_lock(channel->profile_mutex);
if (channel->variables) {
status = switch_event_dup(event, channel->variables);
} else {
status = switch_event_create(event, SWITCH_EVENT_CHANNEL_DATA)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 4453, event, SWITCH_EVENT_CHANNEL_DATA
, ((void*)0));
}
switch_mutex_unlock(channel->profile_mutex);
return status;
4457}

4459SWITCH_DECLARE(switch_core_session_t *)__attribute__((visibility("default"))) switch_core_session_t * switch_channel_get_session(switch_channel_t *channel)
4460{
switch_assert(channel)((channel) ? (void) (0) : __assert_fail ("channel", "src/switch_channel.c"
, 4461, __extension__ __PRETTY_FUNCTION__));
return channel->session;
4463}

4465SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_set_timestamps(switch_channel_t *channel)
4466{
switch_status_t status = SWITCH_STATUS_SUCCESS;
const char *cid_buf = NULL((void*)0);
switch_caller_profile_t *caller_profile;
switch_app_log_t *app_log, *ap;
char *last_app = NULL((void*)0), *last_arg = NULL((void*)0);
char start[80] = "", resurrect[80] = "", answer[80] = "", hold[80],
bridge[80] = "", progress[80] = "", progress_media[80] = "", end[80] = "", tmp[80] = "",
profile_start[80] =	"";
int32_t duration = 0, legbillsec = 0, billsec = 0, mduration = 0, billmsec = 0, legbillmsec = 0, progressmsec = 0, progress_mediamsec = 0;
int32_t answersec = 0, answermsec = 0, waitsec = 0, waitmsec = 0;
switch_time_t answerusec = 0;
switch_time_t uduration = 0, legbillusec = 0, billusec = 0, progresssec = 0, progressusec = 0, progress_mediasec = 0, progress_mediausec = 0, waitusec = 0;
time_t tt_created = 0, tt_answered = 0, tt_resurrected = 0, tt_bridged, tt_last_hold, tt_hold_accum,
tt_progress = 0, tt_progress_media = 0, tt_hungup = 0, mtt_created = 0, mtt_answered = 0, mtt_bridged = 0,
mtt_hungup = 0, tt_prof_created, mtt_progress = 0, mtt_progress_media = 0;
void *pop;
char dtstr[SWITCH_DTMF_LOG_LEN1000 + 1] = "";
int x = 0;

switch_mutex_lock(channel->profile_mutex);

if (switch_channel_test_flag(channel, CF_TIMESTAMP_SET)) {
switch_mutex_unlock(channel->profile_mutex);
return SWITCH_STATUS_FALSE;
}

if (!(caller_profile = channel->caller_profile) || !channel->variables) {
switch_mutex_unlock(channel->profile_mutex);
return SWITCH_STATUS_FALSE;
}

switch_channel_set_flag(channel, CF_TIMESTAMP_SET)switch_channel_set_flag_value(channel, CF_TIMESTAMP_SET, 1);

if ((app_log = switch_core_session_get_app_log(channel->session))) {
for (ap = app_log; ap && ap->next; ap = ap->next);
last_app = ap->app;
last_arg = ap->arg;
}

if (!zstr(caller_profile->caller_id_name)_zstr(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)(caller_profile->caller_id_number ? caller_profile->caller_id_number
 : ""));
} else {
cid_buf = caller_profile->caller_id_number;
}

while (x < SWITCH_DTMF_LOG_LEN1000 && switch_queue_trypop(channel->dtmf_log_queue, &pop) == SWITCH_STATUS_SUCCESS) {
switch_dtmf_t *dt = (switch_dtmf_t *) pop;

if (dt) {
	dtstr[x++] = dt->digit;
	free(dt);
	dt = NULL((void*)0);
}
}

if (x) {
const char *var = switch_channel_get_variable(channel, "digits_dialed_filter")switch_channel_get_variable_dup(channel, "digits_dialed_filter"
, SWITCH_TRUE, -1);
char *digit_string = dtstr;
char *X = NULL((void*)0);
switch_regex_t *re = NULL((void*)0);
char *substituted = NULL((void*)0);

if (!zstr(var)_zstr(var)) {
	int proceed = 0;
	int ovector[30];

	if ((proceed = switch_regex_perform(dtstr, var, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
		int len = (strlen(dtstr) + strlen(var) + 10) * proceed;
		int i = 0;
		const char *replace = NULL((void*)0);

		X = malloc(len);

		for (i = 0; i < proceed; i++) {
			if (pcre_get_substring(dtstr, ovector, proceed, i, &replace) >= 0) {
				if (replace) {
					switch_size_t plen = strlen(replace);
					memset(X, 'X', plen);
					*(X+plen) = '\0';
					
					switch_safe_free(substituted)if (substituted) {free(substituted);substituted=((void*)0);};
					substituted = switch_string_replace(substituted ? substituted : dtstr, replace, X);
					
					pcre_free_substring(replace);
				}
			}
		}

		if (!zstr(substituted)_zstr(substituted)) {
			digit_string = substituted;
		}
	}
}

switch_channel_set_variable(channel, "digits_dialed", digit_string)switch_channel_set_variable_var_check(channel, "digits_dialed"
, digit_string, SWITCH_TRUE);
switch_regex_safe_free(re)if (re) { switch_regex_free(re); re = ((void*)0); };
switch_safe_free(substituted)if (substituted) {free(substituted);substituted=((void*)0);};
switch_safe_free(X)if (X) {free(X);X=((void*)0);};
} else {
switch_channel_set_variable(channel, "digits_dialed", "none")switch_channel_set_variable_var_check(channel, "digits_dialed"
, "none", SWITCH_TRUE);
}

if (caller_profile->times) {
switch_time_exp_t tm;
switch_size_t retsize;
const char *fmt = "%Y-%m-%d %T";

switch_time_exp_lt(&tm, caller_profile->times->created);
switch_strftime_nocheck(start, &retsize, sizeof(start), fmt, &tm);
switch_channel_set_variable(channel, "start_stamp", start)switch_channel_set_variable_var_check(channel, "start_stamp",
 start, SWITCH_TRUE);

switch_time_exp_lt(&tm, caller_profile->times->profile_created);
switch_strftime_nocheck(profile_start, &retsize, sizeof(profile_start), fmt, &tm);
switch_channel_set_variable(channel, "profile_start_stamp", profile_start)switch_channel_set_variable_var_check(channel, "profile_start_stamp"
, profile_start, SWITCH_TRUE);

if (caller_profile->times->answered) {
	switch_time_exp_lt(&tm, caller_profile->times->answered);
	switch_strftime_nocheck(answer, &retsize, sizeof(answer), fmt, &tm);
	switch_channel_set_variable(channel, "answer_stamp", answer)switch_channel_set_variable_var_check(channel, "answer_stamp"
, answer, SWITCH_TRUE);
}

if (caller_profile->times->bridged) {
	switch_time_exp_lt(&tm, caller_profile->times->bridged);
	switch_strftime_nocheck(bridge, &retsize, sizeof(bridge), fmt, &tm);
	switch_channel_set_variable(channel, "bridge_stamp", bridge)switch_channel_set_variable_var_check(channel, "bridge_stamp"
, bridge, SWITCH_TRUE);
}

if (caller_profile->times->last_hold) {
	switch_time_exp_lt(&tm, caller_profile->times->last_hold);
	switch_strftime_nocheck(hold, &retsize, sizeof(hold), fmt, &tm);
	switch_channel_set_variable(channel, "hold_stamp", hold)switch_channel_set_variable_var_check(channel, "hold_stamp", hold
, SWITCH_TRUE);
}

if (caller_profile->times->resurrected) {
	switch_time_exp_lt(&tm, caller_profile->times->resurrected);
	switch_strftime_nocheck(resurrect, &retsize, sizeof(resurrect), fmt, &tm);
	switch_channel_set_variable(channel, "resurrect_stamp", resurrect)switch_channel_set_variable_var_check(channel, "resurrect_stamp"
, resurrect, SWITCH_TRUE);
}

if (caller_profile->times->progress) {
	switch_time_exp_lt(&tm, caller_profile->times->progress);
	switch_strftime_nocheck(progress, &retsize, sizeof(progress), fmt, &tm);
	switch_channel_set_variable(channel, "progress_stamp", progress)switch_channel_set_variable_var_check(channel, "progress_stamp"
, progress, SWITCH_TRUE);
}

if (caller_profile->times->progress_media) {
	switch_time_exp_lt(&tm, caller_profile->times->progress_media);
	switch_strftime_nocheck(progress_media, &retsize, sizeof(progress_media), fmt, &tm);
	switch_channel_set_variable(channel, "progress_media_stamp", progress_media)switch_channel_set_variable_var_check(channel, "progress_media_stamp"
, progress_media, SWITCH_TRUE);
}

if (channel->hold_record) {
	switch_hold_record_t *hr;
	switch_stream_handle_t stream = { 0 };

	SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "src/switch_channel.c", 4623, __extension__ __PRETTY_FUNCTION__
)); memset(stream.data, 0, 1024); stream.end = stream.data; stream
.data_size = 1024; stream.write_function = switch_console_stream_write
; stream.raw_write_function = switch_console_stream_raw_write
; stream.alloc_len = 1024; stream.alloc_chunk = 1024;

	stream.write_function(&stream, "{", SWITCH_VA_NONE"%s", "");

	for (hr = channel->hold_record; hr; hr = hr->next) {
		stream.write_function(&stream, "{%"SWITCH_TIME_T_FMT"ld"",%"SWITCH_TIME_T_FMT"ld""},", hr->on, hr->off);
	}
	end_of((char *)stream.data)*(*(char *)stream.data == '\0' ? (char *)stream.data : (char *
)stream.data + strlen((char *)stream.data) - 1) = '}';

	switch_channel_set_variable(channel, "hold_events", (char *)stream.data)switch_channel_set_variable_var_check(channel, "hold_events",
 (char *)stream.data, SWITCH_TRUE);
	free(stream.data);
}

switch_time_exp_lt(&tm, caller_profile->times->hungup);
switch_strftime_nocheck(end, &retsize, sizeof(end), fmt, &tm);
switch_channel_set_variable(channel, "end_stamp", end)switch_channel_set_variable_var_check(channel, "end_stamp", end
, SWITCH_TRUE);

tt_created = (time_t) (caller_profile->times->created / 1000000);
mtt_created = (time_t) (caller_profile->times->created / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_created);
switch_channel_set_variable(channel, "start_epoch", tmp)switch_channel_set_variable_var_check(channel, "start_epoch",
 tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->created);
switch_channel_set_variable(channel, "start_uepoch", tmp)switch_channel_set_variable_var_check(channel, "start_uepoch"
, tmp, SWITCH_TRUE);

tt_prof_created = (time_t) (caller_profile->times->profile_created / 1000000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_prof_created);
switch_channel_set_variable(channel, "profile_start_epoch", tmp)switch_channel_set_variable_var_check(channel, "profile_start_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->profile_created);
switch_channel_set_variable(channel, "profile_start_uepoch", tmp)switch_channel_set_variable_var_check(channel, "profile_start_uepoch"
, tmp, SWITCH_TRUE);

tt_answered = (time_t) (caller_profile->times->answered / 1000000);
mtt_answered = (time_t) (caller_profile->times->answered / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_answered);
switch_channel_set_variable(channel, "answer_epoch", tmp)switch_channel_set_variable_var_check(channel, "answer_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->answered);
switch_channel_set_variable(channel, "answer_uepoch", tmp)switch_channel_set_variable_var_check(channel, "answer_uepoch"
, tmp, SWITCH_TRUE);

tt_bridged = (time_t) (caller_profile->times->bridged / 1000000);
mtt_bridged = (time_t) (caller_profile->times->bridged / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_bridged);
switch_channel_set_variable(channel, "bridge_epoch", tmp)switch_channel_set_variable_var_check(channel, "bridge_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->bridged);
switch_channel_set_variable(channel, "bridge_uepoch", tmp)switch_channel_set_variable_var_check(channel, "bridge_uepoch"
, tmp, SWITCH_TRUE);

tt_last_hold = (time_t) (caller_profile->times->last_hold / 1000000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_last_hold);
switch_channel_set_variable(channel, "last_hold_epoch", tmp)switch_channel_set_variable_var_check(channel, "last_hold_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->last_hold);
switch_channel_set_variable(channel, "last_hold_uepoch", tmp)switch_channel_set_variable_var_check(channel, "last_hold_uepoch"
, tmp, SWITCH_TRUE);

tt_hold_accum = (time_t) (caller_profile->times->hold_accum / 1000000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_hold_accum);
switch_channel_set_variable(channel, "hold_accum_seconds", tmp)switch_channel_set_variable_var_check(channel, "hold_accum_seconds"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->hold_accum);
switch_channel_set_variable(channel, "hold_accum_usec", tmp)switch_channel_set_variable_var_check(channel, "hold_accum_usec"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->hold_accum / 1000);
switch_channel_set_variable(channel, "hold_accum_ms", tmp)switch_channel_set_variable_var_check(channel, "hold_accum_ms"
, tmp, SWITCH_TRUE);

tt_resurrected = (time_t) (caller_profile->times->resurrected / 1000000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_resurrected);
switch_channel_set_variable(channel, "resurrect_epoch", tmp)switch_channel_set_variable_var_check(channel, "resurrect_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->resurrected);
switch_channel_set_variable(channel, "resurrect_uepoch", tmp)switch_channel_set_variable_var_check(channel, "resurrect_uepoch"
, tmp, SWITCH_TRUE);

tt_progress = (time_t) (caller_profile->times->progress / 1000000);
mtt_progress = (time_t) (caller_profile->times->progress / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_progress);
switch_channel_set_variable(channel, "progress_epoch", tmp)switch_channel_set_variable_var_check(channel, "progress_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->progress);
switch_channel_set_variable(channel, "progress_uepoch", tmp)switch_channel_set_variable_var_check(channel, "progress_uepoch"
, tmp, SWITCH_TRUE);

tt_progress_media = (time_t) (caller_profile->times->progress_media / 1000000);
mtt_progress_media = (time_t) (caller_profile->times->progress_media / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_progress_media);
switch_channel_set_variable(channel, "progress_media_epoch", tmp)switch_channel_set_variable_var_check(channel, "progress_media_epoch"
, tmp, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->progress_media);
switch_channel_set_variable(channel, "progress_media_uepoch", tmp)switch_channel_set_variable_var_check(channel, "progress_media_uepoch"
, tmp, SWITCH_TRUE);

tt_hungup = (time_t) (caller_profile->times->hungup / 1000000);
mtt_hungup = (time_t) (caller_profile->times->hungup / 1000);
switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT"ld", tt_hungup);
switch_channel_set_variable(channel, "end_epoch", tmp)switch_channel_set_variable_var_check(channel, "end_epoch", tmp
, SWITCH_TRUE);
switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", caller_profile->times->hungup);
switch_channel_set_variable(channel, "end_uepoch", tmp)switch_channel_set_variable_var_check(channel, "end_uepoch", tmp
, SWITCH_TRUE);

duration = (int32_t) (tt_hungup - tt_created);
mduration = (int32_t) (mtt_hungup - mtt_created);
uduration = caller_profile->times->hungup - caller_profile->times->created;

if (caller_profile->times->bridged > caller_profile->times->created) {
	waitsec = (int32_t) (tt_bridged - tt_created);
	waitmsec = (int32_t) (mtt_bridged - mtt_created);
	waitusec = caller_profile->times->bridged - caller_profile->times->created;
} else {
	waitsec = 0;
	waitmsec = 0;
	waitusec = 0;
}

if (caller_profile->times->answered) {
	billsec = (int32_t) (tt_hungup - tt_answered);
	billmsec = (int32_t) (mtt_hungup - mtt_answered);
	billusec = caller_profile->times->hungup - caller_profile->times->answered;

	legbillsec = (int32_t) (tt_hungup - tt_created);
	legbillmsec = (int32_t) (mtt_hungup - mtt_created);
	legbillusec = caller_profile->times->hungup - caller_profile->times->created;

	answersec = (int32_t) (tt_answered - tt_created);
	answermsec = (int32_t) (mtt_answered - mtt_created);
	answerusec = caller_profile->times->answered - caller_profile->times->created;
}

if (caller_profile->times->progress) {
	progresssec = (int32_t) (tt_progress - tt_created);
	progressmsec = (int32_t) (mtt_progress - mtt_created);
	progressusec = caller_profile->times->progress - caller_profile->times->created;
}

if (caller_profile->times->progress_media) {
	progress_mediasec = (int32_t) (tt_progress_media - tt_created);
	progress_mediamsec = (int32_t) (mtt_progress_media - mtt_created);
	progress_mediausec = caller_profile->times->progress_media - caller_profile->times->created;
}

}

switch_channel_set_variable(channel, "last_app", last_app)switch_channel_set_variable_var_check(channel, "last_app", last_app
, SWITCH_TRUE);
switch_channel_set_variable(channel, "last_arg", last_arg)switch_channel_set_variable_var_check(channel, "last_arg", last_arg
, SWITCH_TRUE);
switch_channel_set_variable(channel, "caller_id", cid_buf)switch_channel_set_variable_var_check(channel, "caller_id", cid_buf
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", duration);
switch_channel_set_variable(channel, "duration", tmp)switch_channel_set_variable_var_check(channel, "duration", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", billsec);
switch_channel_set_variable(channel, "billsec", tmp)switch_channel_set_variable_var_check(channel, "billsec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%"SWITCH_TIME_T_FMT"ld", progresssec);
switch_channel_set_variable(channel, "progresssec", tmp)switch_channel_set_variable_var_check(channel, "progresssec",
 tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", answersec);
switch_channel_set_variable(channel, "answersec", tmp)switch_channel_set_variable_var_check(channel, "answersec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", waitsec);
switch_channel_set_variable(channel, "waitsec", tmp)switch_channel_set_variable_var_check(channel, "waitsec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%"SWITCH_TIME_T_FMT"ld", progress_mediasec);
switch_channel_set_variable(channel, "progress_mediasec", tmp)switch_channel_set_variable_var_check(channel, "progress_mediasec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", legbillsec);
switch_channel_set_variable(channel, "flow_billsec", tmp)switch_channel_set_variable_var_check(channel, "flow_billsec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", mduration);
switch_channel_set_variable(channel, "mduration", tmp)switch_channel_set_variable_var_check(channel, "mduration", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", billmsec);
switch_channel_set_variable(channel, "billmsec", tmp)switch_channel_set_variable_var_check(channel, "billmsec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", progressmsec);
switch_channel_set_variable(channel, "progressmsec", tmp)switch_channel_set_variable_var_check(channel, "progressmsec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", answermsec);
switch_channel_set_variable(channel, "answermsec", tmp)switch_channel_set_variable_var_check(channel, "answermsec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", waitmsec);
switch_channel_set_variable(channel, "waitmsec", tmp)switch_channel_set_variable_var_check(channel, "waitmsec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", progress_mediamsec);
switch_channel_set_variable(channel, "progress_mediamsec", tmp)switch_channel_set_variable_var_check(channel, "progress_mediamsec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%d", legbillmsec);
switch_channel_set_variable(channel, "flow_billmsec", tmp)switch_channel_set_variable_var_check(channel, "flow_billmsec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", uduration);
switch_channel_set_variable(channel, "uduration", tmp)switch_channel_set_variable_var_check(channel, "uduration", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", billusec);
switch_channel_set_variable(channel, "billusec", tmp)switch_channel_set_variable_var_check(channel, "billusec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", progressusec);
switch_channel_set_variable(channel, "progressusec", tmp)switch_channel_set_variable_var_check(channel, "progressusec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", answerusec);
switch_channel_set_variable(channel, "answerusec", tmp)switch_channel_set_variable_var_check(channel, "answerusec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", waitusec);
switch_channel_set_variable(channel, "waitusec", tmp)switch_channel_set_variable_var_check(channel, "waitusec", tmp
, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", progress_mediausec);
switch_channel_set_variable(channel, "progress_mediausec", tmp)switch_channel_set_variable_var_check(channel, "progress_mediausec"
, tmp, SWITCH_TRUE);

switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT"ld", legbillusec);
switch_channel_set_variable(channel, "flow_billusec", tmp)switch_channel_set_variable_var_check(channel, "flow_billusec"
, tmp, SWITCH_TRUE);

switch_mutex_unlock(channel->profile_mutex);

return status;
4820}

4822SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_get_partner_uuid_copy(switch_channel_t *channel, char *buf, switch_size_t blen)
4823{
const char *uuid = NULL((void*)0);

switch_mutex_lock(channel->profile_mutex);
if (!(uuid = switch_channel_get_variable_dup(channel, SWITCH_SIGNAL_BOND_VARIABLE"signal_bond", SWITCH_TRUE, -1))) {
uuid = switch_channel_get_variable_dup(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE"originate_signal_bond", SWITCH_TRUE, -1);
}

if (uuid) {
strncpy(buf, uuid, blen);
uuid = (const char *) buf;
}
switch_mutex_unlock(channel->profile_mutex);

return uuid;
4838}


4841SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_get_partner_uuid(switch_channel_t *channel)
4842{
const char *uuid = NULL((void*)0);

if (!(uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE)switch_channel_get_variable_dup(channel, "signal_bond", SWITCH_TRUE
, -1))) {
uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE)switch_channel_get_variable_dup(channel, "originate_signal_bond"
, SWITCH_TRUE, -1);
}

return uuid;
4850}

4852SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_handle_cause(switch_channel_t *channel, switch_call_cause_t cause)
4853{
switch_core_session_t *session = channel->session;
const char *transfer_on_fail = NULL((void*)0);
char *tof_data = NULL((void*)0);
char *tof_array[4] = { 0 };
//int tof_arrayc = 0;

if (!switch_channel_up_nosig(channel)(switch_channel_get_state(channel) < CS_HANGUP)) {
return;
}

transfer_on_fail = switch_channel_get_variable(channel, "transfer_on_fail")switch_channel_get_variable_dup(channel, "transfer_on_fail", SWITCH_TRUE
, -1);
tof_data = switch_core_session_strdup(session, transfer_on_fail)switch_core_perform_session_strdup(session, transfer_on_fail,
 "src/switch_channel.c", (const char *)__func__, 4865);
switch_split(tof_data, ' ', tof_array)switch_separate_string(tof_data, ' ', tof_array, (sizeof(tof_array
) / sizeof(tof_array[0])));
 	transfer_on_fail = tof_array[0];

/*
  if the variable continue_on_fail is set it can be:
  'true' to continue on all failures.
  'false' to not continue.
  A list of codes either names or numbers eg "user_busy,normal_temporary_failure,603"
  failure_causes acts as the opposite version
  EXCEPTION... ATTENDED_TRANSFER never is a reason to continue.......
*/
if (cause != SWITCH_CAUSE_ATTENDED_TRANSFER) {
const char *continue_on_fail = NULL((void*)0), *failure_causes = NULL((void*)0);

continue_on_fail = switch_channel_get_variable(channel, "continue_on_fail")switch_channel_get_variable_dup(channel, "continue_on_fail", SWITCH_TRUE
, -1);
failure_causes = switch_channel_get_variable(channel, "failure_causes")switch_channel_get_variable_dup(channel, "failure_causes", SWITCH_TRUE
, -1);

if (continue_on_fail || failure_causes) {
	const char *cause_str;
	char cause_num[35] = "";

	cause_str = switch_channel_cause2str(cause);
	switch_snprintf(cause_num, sizeof(cause_num), "%u", cause);

	if (failure_causes) {
		char *lbuf = switch_core_session_strdup(session, failure_causes)switch_core_perform_session_strdup(session, failure_causes, "src/switch_channel.c"
, (const char *)__func__, 4891);
		char *argv[256] = { 0 };
		int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
		int i, x = 0;

		for (i = 0; i < argc; i++) {
			if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
				x++;
				break;
			}
		}
		if (!x) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 4903, (const char*)(session), SWITCH_LOG_DEBUG,
							  "Failure causes [%s]:  Cause: %s\n", failure_causes, cause_str);
			return;
		}
	}

	if (continue_on_fail) {
		if (switch_true(continue_on_fail)) {
			return;
		} else {
			char *lbuf = switch_core_session_strdup(session, continue_on_fail)switch_core_perform_session_strdup(session, continue_on_fail,
 "src/switch_channel.c", (const char *)__func__, 4913);
			char *argv[256] = { 0 };
			int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
			int i;

			for (i = 0; i < argc; i++) {
				if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 4920, (const char*)(session), SWITCH_LOG_DEBUG,
									  "Continue on fail [%s]:  Cause: %s\n", continue_on_fail, cause_str);
					return;
				}
			}
		}
	}
} else {
	/* no answer is *always* a reason to continue */
	if (cause == SWITCH_CAUSE_NO_ANSWER || cause == SWITCH_CAUSE_NO_USER_RESPONSE || cause == SWITCH_CAUSE_ORIGINATOR_CANCEL) {
		return;
	}
}

if (transfer_on_fail || failure_causes) {
	const char *cause_str;
	char cause_num[35] = "";

	cause_str = switch_channel_cause2str(cause);
	switch_snprintf(cause_num, sizeof(cause_num), "%u", cause);

	if ((tof_array[1] == NULL((void*)0) ) || (!strcasecmp(tof_array[1], "auto_cause"))){
		tof_array[1] = (char *) cause_str;
	}

	if (failure_causes) {
		char *lbuf = switch_core_session_strdup(session, failure_causes)switch_core_perform_session_strdup(session, failure_causes, "src/switch_channel.c"
, (const char *)__func__, 4946);
		char *argv[256] = { 0 };
		int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
		int i, x = 0;

		for (i = 0; i < argc; i++) {
			if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
				x++;
				break;
			}
		}
		if (!x) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 4958, (const char*)(session), SWITCH_LOG_DEBUG,
							  "Failure causes [%s]:  Cause: %s\n", failure_causes, cause_str);

			switch_ivr_session_transfer(session, tof_array[1], tof_array[2], tof_array[3]);
		}
	}

	if (transfer_on_fail) {
		if (switch_true(transfer_on_fail)) {
			return;
		} else {
			char *lbuf = switch_core_session_strdup(session, transfer_on_fail)switch_core_perform_session_strdup(session, transfer_on_fail,
 "src/switch_channel.c", (const char *)__func__, 4969);
			char *argv[256] = { 0 };
			int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
			int i;

			for (i = 0; i < argc; i++) {
				if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 4976, (const char*)(session), SWITCH_LOG_DEBUG,
									  "Transfer on fail [%s]:  Cause: %s\n", transfer_on_fail, cause_str);
					switch_ivr_session_transfer(session, tof_array[1], tof_array[2], tof_array[3]);
				}
			}
		}
	}
}
}


if (!switch_channel_test_flag(channel, CF_TRANSFER) && !switch_channel_test_flag(channel, CF_CONFIRM_BLIND_TRANSFER) &&
switch_channel_get_state(channel) != CS_ROUTING) {
switch_channel_hangup(channel, cause)switch_channel_perform_hangup(channel, "src/switch_channel.c"
, (const char *)__func__, 4989, cause);
}
4991}

4993SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_global_init(switch_memory_pool_t *pool)
4994{
memset(&globals, 0, sizeof(globals));
globals.pool = pool;

switch_mutex_init(&globals.device_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_core_hash_init(&globals.device_hash)switch_core_hash_init_case(&globals.device_hash, SWITCH_TRUE
);
5000}

5002SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_global_uninit(void)
5003{
switch_core_hash_destroy(&globals.device_hash);
5005}


5008static void fetch_device_stats(switch_device_record_t *drec)
5009{
switch_device_node_t *np;


memset(&drec->stats, 0, sizeof(switch_device_stats_t));

switch_mutex_lock(drec->mutex);
for(np = drec->uuid_list; np; np = np->next) {
drec->stats.total++;
if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
	drec->stats.total_in++;
} else {
	drec->stats.total_out++;
}

if (!np->hup_profile) {
	drec->stats.offhook++;
	if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
		drec->stats.offhook_in++;
	} else {
		drec->stats.offhook_out++;
	}

	if (np->callstate == CCS_HELD) {
		drec->stats.held++;
		if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
			drec->stats.held_in++;
		} else {
			drec->stats.held_out++;
		}
	} else if (np->callstate == CCS_UNHELD) {
		drec->stats.unheld++;
		if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
			drec->stats.unheld_in++;
		} else {
			drec->stats.unheld_out++;
		}
	} else {
		if (np->callstate == CCS_EARLY) {
			drec->stats.early++;
			if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
				drec->stats.early_in++;
			} else {
				drec->stats.early_out++;
			}
		} else if (np->callstate == CCS_RINGING) {
			drec->stats.ringing++;
			if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
				drec->stats.ringing_in++;
			} else {
				drec->stats.ringing_out++;
			}
		} else if (np->callstate == CCS_RING_WAIT) {
			drec->stats.ring_wait++;
		} else if (np->callstate == CCS_HANGUP) {
			drec->stats.hup++;
			if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
				drec->stats.hup_in++;
			} else {
				drec->stats.hup_out++;
			}
		} else if (np->callstate != CCS_DOWN) {
			drec->stats.active++;
			if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
				drec->stats.active_in++;
			} else {
				drec->stats.active_out++;
			}
		}
	}
} else {
	drec->stats.hup++;
	if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
		drec->stats.hup_in++;
	} else {
		drec->stats.hup_out++;
	}
}
}
switch_mutex_unlock(drec->mutex);

5090}

5092SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_clear_device_record(switch_channel_t *channel)
5093{
switch_memory_pool_t *pool;
int sanity = 100;
switch_device_node_t *np;
switch_event_t *event;

if (!channel->device_node || !switch_channel_test_flag(channel, CF_FINAL_DEVICE_LEG)) {
return;
}

while(--sanity && channel->device_node->parent->refs) {
switch_yield(100000)switch_sleep(100000);;
}

switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 5107, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "Destroying device cdr %s on device [%s]\n",
			  channel->device_node->parent->uuid,
			  channel->device_node->parent->device_id);

if (switch_event_create(&event, SWITCH_EVENT_CALL_DETAIL)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 5111, &event, SWITCH_EVENT_CALL_DETAIL
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
int x = 0;
char prefix[80] = "";

switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Type", "device");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-ID", channel->device_node->parent->device_id);

switch_mutex_lock(channel->device_node->parent->mutex);
for(np = channel->device_node->parent->uuid_list; np; np = np->next) {
	switch_snprintf(prefix, sizeof(prefix), "Call-%d", ++x);
	switch_caller_profile_event_set_data(np->hup_profile, prefix, event);
}
switch_mutex_unlock(channel->device_node->parent->mutex);

switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 5125, &event, ((void*)0));
}

switch_mutex_lock(channel->device_node->parent->mutex);
for(np = channel->device_node->parent->uuid_list; np; np = np->next) {
if (np->xml_cdr) {
	switch_xml_free(np->xml_cdr);
}
if (np->event) {
	switch_event_destroy(&np->event);
}
}
switch_mutex_unlock(channel->device_node->parent->mutex);

pool = channel->device_node->parent->pool;

switch_mutex_lock(globals.device_mutex);
switch_core_destroy_memory_pool(&pool)switch_core_perform_destroy_memory_pool(&pool, "src/switch_channel.c"
, (const char *)__func__, 5142);

switch_mutex_unlock(globals.device_mutex);


5147}

5149SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_process_device_hangup(switch_channel_t *channel)
5150{

switch_channel_check_device_state(channel, channel->callstate);
process_device_hup(channel);

5155}

5157static void process_device_hup(switch_channel_t *channel)
5158{
switch_hold_record_t *hr, *newhr, *last = NULL((void*)0);
switch_device_record_t *drec = NULL((void*)0);
switch_device_node_t *node;

if (!channel->device_node) {
return;
}

switch_mutex_lock(globals.device_mutex);
node = channel->device_node;
drec = channel->device_node->parent;

node->hup_profile = switch_caller_profile_dup(drec->pool, channel->caller_profile);
fetch_device_stats(drec);

switch_ivr_generate_xml_cdr(channel->session, &node->xml_cdr);
if (switch_event_create(&node->event, SWITCH_EVENT_CALL_DETAIL)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 5175, &node->event
, SWITCH_EVENT_CALL_DETAIL, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_extended_data(channel, node->event);
}

for (hr = channel->hold_record; hr; hr = hr->next) {
newhr = switch_core_alloc(drec->pool, sizeof(*newhr))switch_core_perform_alloc(drec->pool, sizeof(*newhr), "src/switch_channel.c"
, (const char *)__func__, 5180);
newhr->on = hr->on;
newhr->off = hr->off;

if (hr->uuid) {
	newhr->uuid = switch_core_strdup(drec->pool, hr->uuid)switch_core_perform_strdup(drec->pool, hr->uuid, "src/switch_channel.c"
, (const char *)__func__, 5185);
}

if (!node->hold_record) {
	node->hold_record = newhr;
} else if (last) {
	last->next = newhr;
}

last = newhr;
}

if (!drec->stats.offhook) { /* this is final call */

switch_core_hash_delete(globals.device_hash, drec->device_id);
switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 5200, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "Processing last call from device [%s]\n",
				  drec->device_id);
switch_channel_set_flag(channel, CF_FINAL_DEVICE_LEG)switch_channel_set_flag_value(channel, CF_FINAL_DEVICE_LEG, 1
);
} else {
channel->device_node = NULL((void*)0);
}

drec->refs--;

switch_mutex_unlock(globals.device_mutex);

5211}

5213static void switch_channel_check_device_state(switch_channel_t *channel, switch_channel_callstate_t callstate)
5214{
switch_device_record_t *drec = NULL((void*)0);
switch_device_state_binding_t *ptr = NULL((void*)0);
switch_event_t *event = NULL((void*)0);

if (!channel->device_node) {
return;
}

drec = channel->device_node->parent;

switch_mutex_lock(globals.device_mutex);
switch_mutex_lock(drec->mutex);

fetch_device_stats(drec);

if (drec->state != SDS_HANGUP) {
if (drec->stats.offhook == 0 || drec->stats.hup == drec->stats.total) {
	drec->state = SDS_HANGUP;
} else {
	if (drec->stats.active == 0) {
		if ((drec->stats.ringing_out + drec->stats.early_out) > 0 || drec->stats.ring_wait > 0) {
			drec->state = SDS_RINGING;
		} else {
			if (drec->stats.held > 0) {
				drec->state = SDS_HELD;
			} else if (drec->stats.unheld > 0) {
				drec->state = SDS_UNHELD;
			} else {
				drec->state = SDS_DOWN;
			}
		}
	} else if (drec->stats.active == 1) {
		drec->state = SDS_ACTIVE;
	} else {
		drec->state = SDS_ACTIVE_MULTI;
	}
}
}

if ((drec->state == SDS_DOWN && drec->last_state == SDS_DOWN) || (drec->state == SDS_HANGUP && drec->last_state == SDS_HANGUP)) {
switch_mutex_unlock(drec->mutex);
switch_mutex_unlock(globals.device_mutex);
return;
}

if (!drec->call_start) {
drec->call_start = switch_micro_time_now();
}

switch(drec->state) {
case SDS_RINGING:
if (!drec->ring_start) {
	drec->ring_start = switch_micro_time_now();
	drec->ring_stop = 0;
}
break;
case SDS_ACTIVE:
case SDS_ACTIVE_MULTI:
if (!drec->active_start) {
	drec->active_start = switch_micro_time_now();
	drec->active_stop = 0;
}
break;
case SDS_HELD:
if (!drec->hold_start) {
	drec->hold_start = switch_micro_time_now();
	drec->hold_stop = 0;
}
break;
default:
break;
}

if (callstate != CCS_UNHELD && drec->active_start && drec->state != SDS_ACTIVE && drec->state != SDS_ACTIVE_MULTI) {
drec->active_stop = switch_micro_time_now();
}

if (drec->ring_start && !drec->ring_stop && drec->state != SDS_RINGING) {
drec->ring_stop = switch_micro_time_now();
}

if (drec->hold_start && !drec->hold_stop && drec->state != SDS_HELD) {
drec->hold_stop = switch_micro_time_now();
}


if (switch_event_create(&event, SWITCH_EVENT_DEVICE_STATE)switch_event_create_subclass_detailed("src/switch_channel.c",
 (const char * )(const char *)__func__, 5301, &event, SWITCH_EVENT_DEVICE_STATE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-ID", drec->device_id);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Last-Device-State", switch_channel_device_state2str(drec->last_state));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-State", switch_channel_device_state2str(drec->state));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-Call-State", switch_channel_callstate2str(callstate));
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Total-Legs", "%u", drec->stats.total);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Offhook", "%u", drec->stats.offhook);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Ringing", "%u", drec->stats.ringing);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Early", "%u", drec->stats.early);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Active", "%u", drec->stats.active);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Held", "%u", drec->stats.held);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-UnHeld", "%u", drec->stats.unheld);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Hup", "%u", drec->stats.hup);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Talk-Time-Start-Uepoch", "%"SWITCH_TIME_T_FMT"ld", drec->active_start);
if (drec->active_stop) {
	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Talk-Time-Stop-Uepoch", "%"SWITCH_TIME_T_FMT"ld", drec->active_stop);
	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Talk-Time-Milliseconds", "%u", (uint32_t)(drec->active_stop - drec->active_start) / 1000);
}
}

switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 5321, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG1,
			  "%s device: %s\nState: %s Dev State: %s/%s Total:%u Offhook:%u "
			  "Ringing:%u Early:%u Active:%u Held:%u Unheld:%u Hungup:%u Dur: %u Ringtime: %u Holdtime: %u %s\n",
			  switch_channel_get_name(channel),
			  drec->device_id,
			  switch_channel_callstate2str(callstate),
			  switch_channel_device_state2str(drec->last_state),
			  switch_channel_device_state2str(drec->state),
			  drec->stats.total,
			  drec->stats.offhook,
			  drec->stats.ringing,
			  drec->stats.early,
			  drec->stats.active,
			  drec->stats.held,
			  drec->stats.unheld,
			  drec->stats.hup,
			  drec->active_stop ? (uint32_t)(drec->active_stop - drec->active_start) / 1000 : 0,
			  drec->ring_stop ? (uint32_t)(drec->ring_stop - drec->ring_start) / 1000 : 0,
			  drec->hold_stop ? (uint32_t)(drec->hold_stop - drec->hold_start) / 1000 : 0,
			  switch_channel_test_flag(channel, CF_FINAL_DEVICE_LEG) ? "FINAL LEG" : "");

for (ptr = globals.device_bindings; ptr; ptr = ptr->next) {
ptr->function(channel->session, callstate, drec);
}

drec->last_stats = drec->stats;

if (drec->active_stop) {
drec->active_start = drec->active_stop = 0;
if (drec->state == SDS_ACTIVE || drec->state == SDS_ACTIVE_MULTI) {
	drec->active_start = switch_micro_time_now();
}
}

if (drec->hold_stop) {
drec->hold_start = drec->hold_stop = 0;
if (drec->state == SDS_HELD) {
	drec->hold_start = switch_micro_time_now();
}
}

if (drec->ring_stop) {
drec->ring_start = drec->ring_stop = 0;
if (drec->state == SDS_RINGING) {
	drec->ring_start = switch_micro_time_now();
}
}

drec->last_call_time = switch_micro_time_now();

drec->last_state = drec->state;

switch_mutex_unlock(drec->mutex);
switch_mutex_unlock(globals.device_mutex);


if (event) {
switch_event_fire(&event)switch_event_fire_detailed("src/switch_channel.c", (const char
 * )(const char *)__func__, 5378, &event, ((void*)0));
}

5381}

5383/* assumed to be called under a lock */
5384static void add_uuid(switch_device_record_t *drec, switch_channel_t *channel)
5385{
switch_device_node_t *node;

switch_assert(drec)((drec) ? (void) (0) : __assert_fail ("drec", "src/switch_channel.c"
, 5388, __extension__ __PRETTY_FUNCTION__));

switch_channel_set_flag(channel, CF_DEVICE_LEG)switch_channel_set_flag_value(channel, CF_DEVICE_LEG, 1);
node = switch_core_alloc(drec->pool, sizeof(*node))switch_core_perform_alloc(drec->pool, sizeof(*node), "src/switch_channel.c"
, (const char *)__func__, 5391);

node->uuid = switch_core_strdup(drec->pool, switch_core_session_get_uuid(channel->session))switch_core_perform_strdup(drec->pool, switch_core_session_get_uuid
(channel->session), "src/switch_channel.c", (const char *)
__func__, 5393);
node->parent = drec;
node->callstate = channel->callstate;
node->direction = channel->logical_direction == SWITCH_CALL_DIRECTION_INBOUND ? SWITCH_CALL_DIRECTION_OUTBOUND : SWITCH_CALL_DIRECTION_INBOUND;

channel->device_node = node;

if (!drec->uuid_list) {
drec->uuid_list = node;
drec->uuid = node->uuid;
} else {
drec->uuid_tail->next = node;
}

drec->uuid_tail = node;
drec->refs++;
5409}

5411static switch_status_t create_device_record(switch_device_record_t **drecp, const char *device_id)
5412{
switch_device_record_t *drec;
switch_memory_pool_t *pool;

switch_assert(drecp)((drecp) ? (void) (0) : __assert_fail ("drecp", "src/switch_channel.c"
, 5416, __extension__ __PRETTY_FUNCTION__));

switch_core_new_memory_pool(&pool)switch_core_perform_new_memory_pool(&pool, "src/switch_channel.c"
, (const char *)__func__, 5418);
drec = switch_core_alloc(pool, sizeof(*drec))switch_core_perform_alloc(pool, sizeof(*drec), "src/switch_channel.c"
, (const char *)__func__, 5419);
drec->pool = pool;
drec->device_id = switch_core_strdup(drec->pool, device_id)switch_core_perform_strdup(drec->pool, device_id, "src/switch_channel.c"
, (const char *)__func__, 5421);
switch_mutex_init(&drec->mutex, SWITCH_MUTEX_NESTED0x1, drec->pool);

*drecp = drec;

return SWITCH_STATUS_SUCCESS;
5427}


5430SWITCH_DECLARE(const char *)__attribute__((visibility("default"))) const char * switch_channel_set_device_id(switch_channel_t *channel, const char *device_id)
5431{
switch_device_record_t *drec;

if (channel->device_node) {
return NULL((void*)0);
}

channel->device_id = switch_core_session_strdup(channel->session, device_id)switch_core_perform_session_strdup(channel->session, device_id
, "src/switch_channel.c", (const char *)__func__, 5438);

switch_mutex_lock(globals.device_mutex);

if (!(drec = switch_core_hash_find(globals.device_hash, channel->device_id))) {
create_device_record(&drec, channel->device_id);
switch_core_hash_insert(globals.device_hash, drec->device_id, drec)switch_core_hash_insert_destructor(globals.device_hash, drec->
device_id, drec, ((void*)0));
}

add_uuid(drec, channel);

switch_mutex_unlock(globals.device_mutex);

switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel)SWITCH_CHANNEL_ID_SESSION, "src/switch_channel.c", (const char
 *)__func__, 5451, (const char*)switch_channel_get_session(channel
), SWITCH_LOG_DEBUG, "Setting DEVICE ID to [%s]\n", device_id);

switch_channel_check_device_state(channel, channel->callstate);

return device_id;
5456}

5458SWITCH_DECLARE(switch_device_record_t *)__attribute__((visibility("default"))) switch_device_record_t
 * switch_channel_get_device_record(switch_channel_t *channel)
5459{
if (channel->device_node) {
switch_mutex_lock(channel->device_node->parent->mutex);
return channel->device_node->parent;
}

return NULL((void*)0);
5466}

5468SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_channel_release_device_record(switch_device_record_t **drecp)
5469{
if (drecp && *drecp) {
switch_mutex_unlock((*drecp)->mutex);
*drecp = NULL((void*)0);
}
5474}

5476SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_bind_device_state_handler(switch_device_state_function_t function, void *user_data)
5477{
switch_device_state_binding_t *binding = NULL((void*)0), *ptr = NULL((void*)0);
assert(function != NULL)((function != ((void*)0)) ? (void) (0) : __assert_fail ("function != NULL"
, "src/switch_channel.c", 5479, __extension__ __PRETTY_FUNCTION__
));

if (!(binding = (switch_device_state_binding_t *) switch_core_alloc(globals.pool, sizeof(*binding))switch_core_perform_alloc(globals.pool, sizeof(*binding), "src/switch_channel.c"
, (const char *)__func__, 5481))) {
return SWITCH_STATUS_MEMERR;
}

binding->function = function;
binding->user_data = user_data;

switch_mutex_lock(globals.device_mutex);
for (ptr = globals.device_bindings; ptr && ptr->next; ptr = ptr->next);

if (ptr) {
ptr->next = binding;
} else {
globals.device_bindings = binding;
}

switch_mutex_unlock(globals.device_mutex);

return SWITCH_STATUS_SUCCESS;
5500}

5502SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_unbind_device_state_handler(switch_device_state_function_t function)
5503{
switch_device_state_binding_t *ptr, *last = NULL((void*)0);
switch_status_t status = SWITCH_STATUS_FALSE;

switch_mutex_lock(globals.device_mutex);
for (ptr = globals.device_bindings; ptr; ptr = ptr->next) {
if (ptr->function == function) {
	status = SWITCH_STATUS_SUCCESS;

	if (last) {
		last->next = ptr->next;
	} else {
		globals.device_bindings = ptr->next;
		last = NULL((void*)0);
		continue;
	}
}
last = ptr;
}
switch_mutex_unlock(globals.device_mutex);

return status;
5525}

5527SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_channel_pass_sdp(switch_channel_t *from_channel, switch_channel_t *to_channel, const char *sdp)
5528{
switch_status_t status = SWITCH_STATUS_FALSE;
char *use_sdp = (char *) sdp;
char *patched_sdp = NULL((void*)0);

if (!switch_channel_get_variable(to_channel, SWITCH_B_SDP_VARIABLE)switch_channel_get_variable_dup(to_channel, "switch_m_sdp", SWITCH_TRUE
, -1)) {
const char *var;

if ((var = switch_channel_get_variable(from_channel, "bypass_media_sdp_filter")switch_channel_get_variable_dup(from_channel, "bypass_media_sdp_filter"
, SWITCH_TRUE, -1))) {
	if ((patched_sdp = switch_core_media_process_sdp_filter(use_sdp, var, from_channel->session))) {
		use_sdp = patched_sdp;
	}
}

switch_channel_set_variable(to_channel, SWITCH_B_SDP_VARIABLE, use_sdp)switch_channel_set_variable_var_check(to_channel, "switch_m_sdp"
, use_sdp, SWITCH_TRUE);
}

switch_safe_free(patched_sdp)if (patched_sdp) {free(patched_sdp);patched_sdp=((void*)0);};

return status;
5548}

5550/* For Emacs:
* Local Variables:
* mode:c
* indent-tabs-mode:t
* tab-width:4
* c-basic-offset:4
* End:
* For VIM:
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
*/