sofia_glue.c

Bug Summary

File:	mod/endpoints/mod_sofia/sofia_glue.c
Warning:	line 1394, column 11 Potential memory leak
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 sofia_glue.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/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 -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 -I . -I /usr/include/sofia-sip-1.13 -D HAVE_STIRSHAKEN -D PIC -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/src/mod/endpoints/mod_sofia -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-184555-401-1 -x c sofia_glue.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>
* Ken Rice <krice@freeswitch.org>
* Paul D. Tinsley <pdt at jackhammer.org>
* Bret McDanel <trixter AT 0xdecafbad.com>
* Eliot Gable <egable AT.AT broadvox.com>
*
*
* sofia_glue.c -- SOFIA SIP Endpoint (code to tie sofia to freeswitch)
*
*/
36#include "mod_sofia.h"
37#include <switch_stun.h>

39switch_cache_db_handle_t *_sofia_glue_get_db_handle(sofia_profile_t *profile, const char *file, const char *func, int line);
40#define sofia_glue_get_db_handle(_p)_sofia_glue_get_db_handle(_p, "sofia_glue.c", (const char *)__func__
, 40) _sofia_glue_get_db_handle(_p, __FILE__"sofia_glue.c", __SWITCH_FUNC__(const char *)__func__, __LINE__40)


43int sofia_glue_check_nat(sofia_profile_t *profile, const char *network_ip)
44{
switch_assert(network_ip)((network_ip) ? (void) (0) : __assert_fail ("network_ip", "sofia_glue.c"
, 45, __extension__ __PRETTY_FUNCTION__));

return (profile->extsipip &&
	!switch_check_network_list_ip(network_ip, "loopback.auto")switch_check_network_list_ip_token(network_ip, "loopback.auto"
, ((void*)0)) &&
	!switch_check_network_list_ip(network_ip, profile->local_network)switch_check_network_list_ip_token(network_ip, profile->local_network
, ((void*)0)));
50}

52private_object_t *sofia_glue_new_pvt(switch_core_session_t *session)
53{
private_object_t *tech_pvt = (private_object_t *) switch_core_session_alloc(session, sizeof(private_object_t))switch_core_perform_session_alloc(session, sizeof(private_object_t
), "sofia_glue.c", (const char *)__func__, 54);
switch_mutex_init(&tech_pvt->flag_mutex, SWITCH_MUTEX_NESTED0x1, switch_core_session_get_pool(session));
switch_mutex_init(&tech_pvt->sofia_mutex, SWITCH_MUTEX_NESTED0x1, switch_core_session_get_pool(session));
return tech_pvt;
58}

60void sofia_glue_set_name(private_object_t *tech_pvt, const char *channame)
61{
char name[256];
char *p;

switch_snprintf(name, sizeof(name), "sofia/%s/%s", tech_pvt->profile->name, channame);
if ((p = strchr(name, ';'))) {
*p = '\0';
}
switch_channel_set_name(tech_pvt->channel, name);
70}

72void sofia_glue_attach_private(switch_core_session_t *session, sofia_profile_t *profile, private_object_t *tech_pvt, const char *channame)
73{

unsigned int x, i;

switch_assert(session != NULL)((session != ((void*)0)) ? (void) (0) : __assert_fail ("session != ((void*)0)"
, "sofia_glue.c", 77, __extension__ __PRETTY_FUNCTION__));
switch_assert(profile != NULL)((profile != ((void*)0)) ? (void) (0) : __assert_fail ("profile != ((void*)0)"
, "sofia_glue.c", 78, __extension__ __PRETTY_FUNCTION__));
switch_assert(tech_pvt != NULL)((tech_pvt != ((void*)0)) ? (void) (0) : __assert_fail ("tech_pvt != ((void*)0)"
, "sofia_glue.c", 79, __extension__ __PRETTY_FUNCTION__));

switch_core_session_add_stream(session, NULL((void*)0));

switch_mutex_lock(tech_pvt->flag_mutex);
switch_mutex_lock(profile->flag_mutex);

/* copy flags from profile to the sofia private */
for (x = 0; x < TFLAG_MAX; x++) {
tech_pvt->flags[x] = profile->flags[x];
}

tech_pvt->x_freeswitch_support_local = FREESWITCH_SUPPORT"update_display,send_info";

tech_pvt->profile = profile;

if (!zstr(profile->rtpip[profile->rtpip_next])_zstr(profile->rtpip[profile->rtpip_next])) {
tech_pvt->mparams.rtpip4 = switch_core_session_strdup(session, profile->rtpip[profile->rtpip_next++])switch_core_perform_session_strdup(session, profile->rtpip
[profile->rtpip_next++], "sofia_glue.c", (const char *)__func__
, 96);
tech_pvt->mparams.rtpip = tech_pvt->mparams.rtpip4;

if (profile->rtpip_next >= profile->rtpip_index) {
	profile->rtpip_next = 0;
}
}

if (!zstr(profile->rtpip6[profile->rtpip_next6])_zstr(profile->rtpip6[profile->rtpip_next6])) {
tech_pvt->mparams.rtpip6 = switch_core_session_strdup(session, profile->rtpip6[profile->rtpip_next6++])switch_core_perform_session_strdup(session, profile->rtpip6
[profile->rtpip_next6++], "sofia_glue.c", (const char *)__func__
, 105);

if (zstr(tech_pvt->mparams.rtpip)_zstr(tech_pvt->mparams.rtpip)) {
	tech_pvt->mparams.rtpip = tech_pvt->mparams.rtpip6;
}

if (profile->rtpip_next6 >= profile->rtpip_index6) {
	profile->rtpip_next6 = 0;
}
}

profile->inuse++;
switch_mutex_unlock(profile->flag_mutex);
switch_mutex_unlock(tech_pvt->flag_mutex);

if (tech_pvt->bte) {
tech_pvt->recv_te = tech_pvt->te = tech_pvt->bte;
} else if (!tech_pvt->te) {
tech_pvt->mparams.recv_te = tech_pvt->mparams.te = profile->te;
}

tech_pvt->mparams.dtmf_type = tech_pvt->profile->dtmf_type;

if (!sofia_test_media_flag(tech_pvt->profile, SCMF_SUPPRESS_CNG)((tech_pvt->profile)->media_flags[SCMF_SUPPRESS_CNG] ? 1
 : 0)) {
if (tech_pvt->bcng_pt) {
	tech_pvt->cng_pt = tech_pvt->bcng_pt;
} else if (!tech_pvt->cng_pt) {
	tech_pvt->cng_pt = profile->cng_pt;
}
}

tech_pvt->session = session;
tech_pvt->channel = switch_core_session_get_channel(session);

if (sofia_test_pflag(profile, PFLAG_TRACK_CALLS)((profile)->pflags[PFLAG_TRACK_CALLS] ? 1 : 0)) {
switch_channel_set_flag(tech_pvt->channel, CF_TRACKABLE)switch_channel_set_flag_value(tech_pvt->channel, CF_TRACKABLE
, 1);
}


if (profile->flags[PFLAG_PASS_RFC2833]) {
switch_channel_set_flag(tech_pvt->channel, CF_PASS_RFC2833)switch_channel_set_flag_value(tech_pvt->channel, CF_PASS_RFC2833
, 1);
}

if (sofia_test_pflag(tech_pvt->profile, PFLAG_RTP_NOTIMER_DURING_BRIDGE)((tech_pvt->profile)->pflags[PFLAG_RTP_NOTIMER_DURING_BRIDGE
] ? 1 : 0)) {
switch_channel_set_flag(tech_pvt->channel, CF_RTP_NOTIMER_DURING_BRIDGE)switch_channel_set_flag_value(tech_pvt->channel, CF_RTP_NOTIMER_DURING_BRIDGE
, 1);
}

if (sofia_test_pflag(tech_pvt->profile, PFLAG_T38_PASSTHRU)((tech_pvt->profile)->pflags[PFLAG_T38_PASSTHRU] ? 1 : 0
)) {
switch_channel_set_flag(tech_pvt->channel, CF_T38_PASSTHRU)switch_channel_set_flag_value(tech_pvt->channel, CF_T38_PASSTHRU
, 1);
}

switch_channel_set_cap(tech_pvt->channel, CC_MEDIA_ACK)switch_channel_set_cap_value(tech_pvt->channel, CC_MEDIA_ACK
, 1);
switch_channel_set_cap(tech_pvt->channel, CC_BYPASS_MEDIA)switch_channel_set_cap_value(tech_pvt->channel, CC_BYPASS_MEDIA
, 1);
switch_channel_set_cap(tech_pvt->channel, CC_PROXY_MEDIA)switch_channel_set_cap_value(tech_pvt->channel, CC_PROXY_MEDIA
, 1);
switch_channel_set_cap(tech_pvt->channel, CC_JITTERBUFFER)switch_channel_set_cap_value(tech_pvt->channel, CC_JITTERBUFFER
, 1);
switch_channel_set_cap(tech_pvt->channel, CC_FS_RTP)switch_channel_set_cap_value(tech_pvt->channel, CC_FS_RTP,
 1);
switch_channel_set_cap(tech_pvt->channel, CC_RTP_RTT)switch_channel_set_cap_value(tech_pvt->channel, CC_RTP_RTT
, 1);
switch_channel_set_cap(tech_pvt->channel, CC_MSRP)switch_channel_set_cap_value(tech_pvt->channel, CC_MSRP, 1
);
switch_channel_set_cap(tech_pvt->channel, CC_QUEUEABLE_DTMF_DELAY)switch_channel_set_cap_value(tech_pvt->channel, CC_QUEUEABLE_DTMF_DELAY
, 1);



tech_pvt->mparams.ndlb = tech_pvt->profile->mndlb;
tech_pvt->mparams.inbound_codec_string = profile->inbound_codec_string;
tech_pvt->mparams.outbound_codec_string = profile->outbound_codec_string;
tech_pvt->mparams.auto_rtp_bugs = profile->auto_rtp_bugs;
tech_pvt->mparams.timer_name = profile->timer_name;
tech_pvt->mparams.vflags = profile->vflags;
tech_pvt->mparams.manual_rtp_bugs = profile->manual_rtp_bugs;
tech_pvt->mparams.manual_video_rtp_bugs = profile->manual_video_rtp_bugs;
tech_pvt->mparams.extsipip = profile->extsipip;
tech_pvt->mparams.extrtpip = profile->extrtpip;
tech_pvt->mparams.local_network = profile->local_network;
tech_pvt->mparams.sipip = profile->sipip;
tech_pvt->mparams.jb_msec = profile->jb_msec;
tech_pvt->mparams.rtcp_audio_interval_msec = profile->rtcp_audio_interval_msec;
tech_pvt->mparams.rtcp_video_interval_msec = profile->rtcp_video_interval_msec;
tech_pvt->mparams.sdp_username = profile->sdp_username;
tech_pvt->mparams.cng_pt = tech_pvt->cng_pt;
tech_pvt->mparams.rtp_timeout_sec = profile->rtp_timeout_sec;
tech_pvt->mparams.rtp_hold_timeout_sec = profile->rtp_hold_timeout_sec;

if (profile->rtp_digit_delay) {
tech_pvt->mparams.dtmf_delay = profile->rtp_digit_delay;
}

switch_media_handle_create(&tech_pvt->media_handle, session, &tech_pvt->mparams);
switch_media_handle_set_media_flags(tech_pvt->media_handle, tech_pvt->profile->media_flags);

switch_core_media_check_dtmf_type(session);

for(i = 0; i < profile->cand_acl_count; i++) {
switch_core_media_add_ice_acl(session, SWITCH_MEDIA_TYPE_AUDIO, profile->cand_acl[i]);
switch_core_media_add_ice_acl(session, SWITCH_MEDIA_TYPE_VIDEO, profile->cand_acl[i]);
}


switch_core_session_set_private(session, tech_pvt)switch_core_session_set_private_class(session, tech_pvt, SWITCH_PVT_PRIMARY
);

if (channame) {
sofia_glue_set_name(tech_pvt, channame);
}

208}




213switch_status_t sofia_glue_ext_address_lookup(sofia_profile_t *profile, char **ip, switch_port_t *port,
									  const char *sourceip, switch_memory_pool_t *pool)
215{
char *error = "";
switch_status_t status = SWITCH_STATUS_FALSE;
int x;
switch_port_t stun_port = SWITCH_STUN_DEFAULT_PORT3478;
char *stun_ip = NULL((void*)0);

if (!sourceip) {
return status;
}

if (!strncasecmp(sourceip, "host:", 5)) {
status = (*ip = switch_stun_host_lookup(sourceip + 5, pool)) ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
} else if (!strncasecmp(sourceip, "stun:", 5)) {
char *p;

stun_ip = strdup(sourceip + 5);

switch_assert(stun_ip)((stun_ip) ? (void) (0) : __assert_fail ("stun_ip", "sofia_glue.c"
, 233, __extension__ __PRETTY_FUNCTION__));

if ((p = strchr(stun_ip, ':'))) {
	int iport;
	*p++ = '\0';
	iport = atoi(p);
	if (iport > 0 && iport < 0xFFFF) {
		stun_port = (switch_port_t) iport;
	}
}

if (zstr(stun_ip)_zstr(stun_ip)) {
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 245, ((void*)0), SWITCH_LOG_ERROR, "STUN Failed! NO STUN SERVER\n");
	goto out;
}


      for (x = 0; x < 5; x++) {
          if ((status = switch_stun_lookup(ip, port, stun_ip, stun_port, &error, pool)) != SWITCH_STATUS_SUCCESS) {
              switch_yield(100000)switch_sleep(100000);;
          } else {
		break;
          }
      }

if (!*ip) {
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 259, ((void*)0), SWITCH_LOG_ERROR, "STUN Failed! No IP returned\n");
	goto out;
}
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 262, ((void*)0), SWITCH_LOG_DEBUG, "STUN Success [%s]:[%d]\n", *ip, *port);
status = SWITCH_STATUS_SUCCESS;
} else {
*ip = (char *) sourceip;
status = SWITCH_STATUS_SUCCESS;
}

out:

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

return status;
274}


277const char *sofia_glue_get_unknown_header(sip_t const *sip, const char *name)
278{
sip_unknown_t *un;
for (un = sip->sip_unknown; un; un = un->un_next) {
if (!strcasecmp(un->un_name, name)) {
	if (!zstr(un->un_value)_zstr(un->un_value)) {
		return un->un_value;
	}
}
}
return NULL((void*)0);
288}

290sofia_transport_t sofia_glue_str2transport(const char *str)
291{
if (!strncasecmp(str, "udp", 3)) {
return SOFIA_TRANSPORT_UDP;
} else if (!strncasecmp(str, "tcp", 3)) {
return SOFIA_TRANSPORT_TCP;
} else if (!strncasecmp(str, "sctp", 4)) {
return SOFIA_TRANSPORT_SCTP;
} else if (!strncasecmp(str, "tls", 3)) {
return SOFIA_TRANSPORT_TCP_TLS;
}

return SOFIA_TRANSPORT_UNKNOWN;
303}

305enum tport_tls_verify_policy sofia_glue_str2tls_verify_policy(const char * str){
char *ptr_next;
int len;
enum tport_tls_verify_policy ret;
char *ptr_cur = (char *) str;
ret = TPTLS_VERIFY_NONE;

while (ptr_cur) {
if ((ptr_next = strchr(ptr_cur, '|'))) {
	len = (int)(ptr_next++ - ptr_cur);
} else {
	len = (int)strlen(ptr_cur);
}
if (!strncasecmp(ptr_cur, "in",len)) {
	ret |= TPTLS_VERIFY_IN;
} else if (!strncasecmp(ptr_cur, "none",len)) {
	ret = TPTLS_VERIFY_NONE;
	break;
} else if (!strncasecmp(ptr_cur, "out",len)) {
	ret |= TPTLS_VERIFY_OUT;
} else if (!strncasecmp(ptr_cur, "all",len)) {
	ret |= TPTLS_VERIFY_ALL;
} else if (!strncasecmp(ptr_cur, "subjects_in",len)) {
	ret |= TPTLS_VERIFY_SUBJECTS_IN;
} else if (!strncasecmp(ptr_cur, "subjects_out",len)) {
	ret |= TPTLS_VERIFY_SUBJECTS_OUT;
} else if (!strncasecmp(ptr_cur, "subjects_all",len)) {
	ret |= TPTLS_VERIFY_SUBJECTS_ALL;
} else {
	char el[32] = {0};
	strncpy(el, ptr_cur, len < sizeof(el) ? len : sizeof(el) - 1);
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 336, ((void*)0), SWITCH_LOG_ERROR, "Invalid tls-verify-policy value: %s\n", el);
}
ptr_cur = ptr_next;
}
return ret;
341}

343/* create "local-uuid" */
344int sofia_glue_is_valid_session_uuid(const char *session_uuid)
345{
int i;
if (zstr(session_uuid)_zstr(session_uuid) || strlen(session_uuid) != RFC7989_SESSION_UUID_LEN32) {
return 0;
}
for (i = 0; i < RFC7989_SESSION_UUID_LEN32; i++) {
char c = session_uuid[i];
if ((c < '0' || c > '9') && (c < 'a' || c > 'f')) {
	return 0;
}
}
return 1;
357}

359/* NIL session-uuid: 00000000000000000000000000000000 */
360int sofia_glue_is_nil_session_uuid(const char *session_uuid)
361{
if (zstr(session_uuid)_zstr(session_uuid)) {
return 0;
}
if (!memcmp(session_uuid, RFC7989_SESSION_UUID_NULL"00000000000000000000000000000000", RFC7989_SESSION_UUID_LEN32)) {
return 1;
}
return 0;
369}

371const char *sofia_glue_uuid_to_session_uuid(switch_memory_pool_t *pool, const char *uuid)
372{
char *session_uuid = NULL((void*)0); /*"local-uuid", per rfc7989*/
if (zstr(uuid)_zstr(uuid) || strlen(uuid) != 36) return NULL((void*)0);

session_uuid = switch_core_alloc(pool, RFC7989_SESSION_UUID_LEN + 1)switch_core_perform_alloc(pool, 32 + 1, "sofia_glue.c", (const
 char *)__func__, 376);
memcpy(session_uuid, uuid, 8);
memcpy(session_uuid + 8, uuid + 9, 4);
memcpy(session_uuid + 12, uuid + 14, 4);
memcpy(session_uuid + 16, uuid + 19, 4);
memcpy(session_uuid + 20, uuid + 24, 12);

if (!sofia_glue_is_valid_session_uuid(session_uuid)) return NULL((void*)0);

return session_uuid;
386}

388/* rfc7989 generic params, return 0 if param is disabled from config or invalid. ALL params allowed by default. */
389/* save updated generic params list in chan var. */
390int sofia_glue_check_filter_generic_params(switch_core_session_t *session, sofia_profile_t *profile, char *param)
391{

char *tmp = NULL((void*)0);
switch_channel_t *channel = switch_core_session_get_channel(session);

if (zstr(param)_zstr(param)) {
return 0;
}
if (profile->rfc7989_filter) {
char *found = NULL((void*)0); char *end = NULL((void*)0); 
char *token_array[100] = { 0 };
int tokens = switch_separate_string(profile->rfc7989_filter, ',', token_array, (sizeof(token_array) / sizeof(token_array[0])));
tmp = switch_core_session_strdup(session, param)switch_core_perform_session_strdup(session, param, "sofia_glue.c"
, (const char *)__func__, 403);
if (tokens) {
	int i;
	for (i = 0; i < tokens && token_array[i]; i++) {
		while ((found = strstr(tmp, token_array[i]))) {
			end = strchr(found, ';');
			if (!end) end = strchr(found, '\0');
			*found = '\0';
			strcat(tmp, found + (end - found));
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 412, (const char*)(session), SWITCH_LOG_WARNING, 
				"Session-ID: Dropped generic param: %s\n", token_array[i]); 
		}
	}
}
}

if (tmp) {
switch_channel_set_variable(channel, SWITCH_RFC7989_GENERIC_PARAM_VARIABLE, tmp)switch_channel_set_variable_var_check(channel, "generic_param_session_uuid"
, tmp, SWITCH_TRUE);
} else {
switch_channel_set_variable(channel, SWITCH_RFC7989_GENERIC_PARAM_VARIABLE, param)switch_channel_set_variable_var_check(channel, "generic_param_session_uuid"
, param, SWITCH_TRUE);
}

return 1;
426}
427/* check and store Session-ID header. */
428/* retrieve "local-uuid" and "remote-uuid" of the remote party. */
429void sofia_glue_store_session_id(switch_core_session_t *session, sofia_profile_t *profile, sip_t const *sip, switch_bool_t is_reply)
430{
char *a_id, *b_id, *duped, *p, *remote_param;
const char *header = sofia_glue_get_unknown_header(sip, "Session-ID");
switch_channel_t *channel = switch_core_session_get_channel(session);

if (!sofia_test_pflag(profile, PFLAG_RFC7989_SESSION_ID)((profile)->pflags[PFLAG_RFC7989_SESSION_ID] ? 1 : 0)) return;

if (!header) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 438, (const char*)(session), SWITCH_LOG_WARNING, "Session-ID: missing header.");
return;
}

duped = switch_core_session_strdup(session, header)switch_core_perform_session_strdup(session, header, "sofia_glue.c"
, (const char *)__func__, 442);

if (zstr(duped)_zstr(duped)) return;

a_id = switch_strip_whitespace(duped);

if (zstr(a_id)_zstr(a_id)) return;

p = strchr(a_id, ';');
if (p) *p = '\0';

if (!sofia_glue_is_valid_session_uuid(a_id)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 454, (const char*)(session), SWITCH_LOG_WARNING, "Session-ID: Ignoring \"%s\" parsed as \"%s\"\n", header, a_id);
return;
}

/* RFC7329 compatibility */
if (is_reply) {
const char *temp_id = switch_channel_get_variable(channel, SWITCH_RFC7989_APP_SESSION_ID_VARIABLE)switch_channel_get_variable_dup(channel, "app_session_uuid", SWITCH_TRUE
, -1);
if (!zstr(temp_id)_zstr(temp_id) && !memcmp(a_id, temp_id, RFC7989_SESSION_UUID_LEN32) ) {
	/* 'If a SIP response only contains the "local-uuid" that was sent
	 *  originally, this comes from a pre-standard implementation and MUST
	 *  NOT be discarded for removing the nil "remote-uuid". In this
	 *  case, all future transactions within this dialog MUST contain only
	 *  the UUID received in the first SIP response" */
	switch_channel_set_flag(channel, CF_RFC7329_COMPAT)switch_channel_set_flag_value(channel, CF_RFC7329_COMPAT, 1);
	switch_channel_set_flag_partner(channel, CF_RFC7329_COMPAT);
}
}

/* "local-uuid" field retrieved from remote party will become 
* SWITCH_RFC7989_APP_SESSION_ID_VARIABLE in a b2bua role. */
if (!zstr(a_id)_zstr(a_id)) {
struct private_object *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
switch_channel_set_variable(channel, SWITCH_RFC7989_SESSION_ID_VARIABLE, a_id)switch_channel_set_variable_var_check(channel, "session_uuid"
, a_id, SWITCH_TRUE);
if (tech_pvt && tech_pvt->sofia_private && !tech_pvt->sofia_private->rfc7989_uuid) {
	tech_pvt->sofia_private->rfc7989_uuid = su_strdup(nua_handle_get_home(tech_pvt->nh), a_id);
}
}

if (!p) {
switch_channel_set_flag(channel, CF_RFC7329_COMPAT)switch_channel_set_flag_value(channel, CF_RFC7329_COMPAT, 1);
switch_channel_set_flag_partner(channel, CF_RFC7329_COMPAT);
return;
}
p++;
remote_param = strstr(p, "remote=");
if (!remote_param) {
switch_channel_set_flag(channel, CF_RFC7329_COMPAT)switch_channel_set_flag_value(channel, CF_RFC7329_COMPAT, 1);
switch_channel_set_flag_partner(channel, CF_RFC7329_COMPAT);
sofia_glue_check_filter_generic_params(session, profile, p);
return;
} 
b_id = remote_param + 7;
if (!zstr(b_id)_zstr(b_id) && strlen(b_id) == RFC7989_SESSION_UUID_LEN32 /*32*/) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 497, (const char*)(session), SWITCH_LOG_DEBUG, "Session-ID: Set remote-uuid: %s\n", b_id);
/*using chan var as placeholder only when UAS or when answer() was called in the dialplan */
switch_channel_set_variable(channel, SWITCH_RFC7989_REMOTE_SESSION_ID_VARIABLE, b_id)switch_channel_set_variable_var_check(channel, "remote_session_uuid"
, b_id, SWITCH_TRUE);
switch_channel_set_variable_partner(channel, SWITCH_RFC7989_REMOTE_SESSION_ID_VARIABLE, b_id)switch_channel_set_variable_partner_var_check(channel, "remote_session_uuid"
, b_id, SWITCH_TRUE);

} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 503, (const char*)(session), SWITCH_LOG_WARNING, "Session-ID: invalid uuid, ignored.\n");
}
505}

507/* add "Session-ID:" header */
508char *sofia_glue_session_id_header(switch_core_session_t *session, sofia_profile_t *profile)
509{
switch_channel_t *channel;
const char *b_id = NULL((void*)0);
const char *a_id = NULL((void*)0);
const char *temp_id = NULL((void*)0);
const char *generic = NULL((void*)0);

if (!session) return NULL((void*)0);

if (!profile) return NULL((void*)0);

if (!sofia_test_pflag(profile, PFLAG_RFC7989_SESSION_ID)((profile)->pflags[PFLAG_RFC7989_SESSION_ID] ? 1 : 0)) return NULL((void*)0);

channel = switch_core_session_get_channel(session);

a_id = switch_channel_get_variable_partner(channel, SWITCH_RFC7989_SESSION_ID_VARIABLE"session_uuid");

if (zstr(a_id)_zstr(a_id)) {
a_id = switch_channel_get_variable(channel, SWITCH_RFC7989_APP_SESSION_ID_VARIABLE)switch_channel_get_variable_dup(channel, "app_session_uuid", SWITCH_TRUE
, -1);
if (!zstr(a_id)_zstr(a_id) && strlen(a_id) == 36) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 529, (const char*)(session), SWITCH_LOG_INFO, "Reformatting app Session-ID: %s\n", a_id);
	a_id = sofia_glue_uuid_to_session_uuid(switch_core_session_get_pool(session), a_id);
	if (!zstr(a_id)_zstr(a_id)) {
		struct private_object *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
		switch_channel_set_variable(channel, SWITCH_RFC7989_APP_SESSION_ID_VARIABLE, a_id)switch_channel_set_variable_var_check(channel, "app_session_uuid"
, a_id, SWITCH_TRUE);
		if (tech_pvt && tech_pvt->sofia_private && !tech_pvt->sofia_private->rfc7989_uuid) {
			tech_pvt->sofia_private->rfc7989_uuid = su_strdup(nua_handle_get_home(tech_pvt->nh), a_id);
		}
	}
}
}

if (zstr(a_id)_zstr(a_id)) {
const char *partner_uuid = switch_channel_get_partner_uuid(channel);
if (!zstr(partner_uuid)_zstr(partner_uuid)) {
	const char *partner_session_id = sofia_glue_uuid_to_session_uuid(switch_core_session_get_pool(session), partner_uuid);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 545, (const char*)(session), SWITCH_LOG_INFO, "Setting \"Session-ID: %s\" from partner leg\n", partner_session_id);
	switch_channel_set_variable_partner(channel, SWITCH_RFC7989_SESSION_ID_VARIABLE, partner_session_id)switch_channel_set_variable_partner_var_check(channel, "session_uuid"
, partner_session_id, SWITCH_TRUE);
	a_id = partner_session_id;
}
}

if (((switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) && zstr(a_id)_zstr(a_id) &&
		switch_channel_get_state(channel) == CS_INIT) && switch_channel_test_flag(channel, CF_ORIGINATING)) {
/*outbound initial request*/
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH256 + 1];

switch_uuid_str(uuid_str, sizeof(uuid_str));
a_id = sofia_glue_uuid_to_session_uuid(switch_core_session_get_pool(session), uuid_str);
if (!zstr(a_id)_zstr(a_id)) {
	struct private_object *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
	switch_channel_set_variable(channel, SWITCH_RFC7989_APP_SESSION_ID_VARIABLE, a_id)switch_channel_set_variable_var_check(channel, "app_session_uuid"
, a_id, SWITCH_TRUE);
	if (tech_pvt && tech_pvt->sofia_private && !tech_pvt->sofia_private->rfc7989_uuid) {
		tech_pvt->sofia_private->rfc7989_uuid = su_strdup(nua_handle_get_home(tech_pvt->nh), a_id);
	}
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 565, (const char*)(session), SWITCH_LOG_DEBUG, 
		"Session-ID: Outbound initial request. local-uuid: %s", a_id);
if (sofia_test_pflag(profile, PFLAG_RFC7989_FORCE_OLD)((profile)->pflags[PFLAG_RFC7989_FORCE_OLD] ? 1 : 0)) {
	/*for old (and obsolete) Session-ID RFC7329 */
	return switch_core_session_sprintf(session, "Session-ID: %s", a_id);
}

b_id = RFC7989_SESSION_UUID_NULL"00000000000000000000000000000000";
return switch_core_session_sprintf(session, "Session-ID: %s;remote=%s", a_id, b_id);
}

temp_id = switch_channel_get_variable(channel, SWITCH_RFC7989_REMOTE_SESSION_ID_VARIABLE)switch_channel_get_variable_dup(channel, "remote_session_uuid"
, SWITCH_TRUE, -1);
if ((switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) && 
	((switch_channel_get_state(channel) == CS_INIT) || (switch_channel_get_state(channel) == CS_EXECUTE)) &&
	zstr(temp_id)_zstr(temp_id)) {
/* fallback to RFC7329 - "old". */
/* inbound initial request, no "remote" param. section 11 of RFC7989. */
a_id = switch_channel_get_variable(channel, SWITCH_RFC7989_SESSION_ID_VARIABLE)switch_channel_get_variable_dup(channel, "session_uuid", SWITCH_TRUE
, -1);
if (zstr(a_id)_zstr(a_id)) {
	a_id = RFC7989_SESSION_UUID_NULL"00000000000000000000000000000000";
} else {
	switch_channel_set_variable(channel, SWITCH_RFC7989_APP_SESSION_ID_VARIABLE, a_id)switch_channel_set_variable_var_check(channel, "app_session_uuid"
, a_id, SWITCH_TRUE);
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 588, (const char*)(session), SWITCH_LOG_WARNING, "Session-ID: Fallback to RFC7329");
switch_channel_set_flag(channel, CF_RFC7329_COMPAT)switch_channel_set_flag_value(channel, CF_RFC7329_COMPAT, 1);
return switch_core_session_sprintf(session, "Session-ID: %s", a_id);
}
if ((switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) &&
	((switch_channel_get_state(channel) == CS_INIT) || (switch_channel_get_state(channel) == CS_EXECUTE)) && 
	sofia_glue_is_nil_session_uuid(temp_id)) {
/*inbound initial request*/
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH256 + 1];

switch_uuid_str(uuid_str, sizeof(uuid_str));
a_id = sofia_glue_uuid_to_session_uuid(switch_core_session_get_pool(session), uuid_str);
if (!zstr(a_id)_zstr(a_id)) {
	struct private_object *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
	switch_channel_set_variable(channel, SWITCH_RFC7989_APP_SESSION_ID_VARIABLE, a_id)switch_channel_set_variable_var_check(channel, "app_session_uuid"
, a_id, SWITCH_TRUE);
	if (tech_pvt && tech_pvt->sofia_private) {
		tech_pvt->sofia_private->rfc7989_uuid = su_strdup(nua_handle_get_home(tech_pvt->nh), a_id);
	}
}
b_id = switch_channel_get_variable(channel, SWITCH_RFC7989_SESSION_ID_VARIABLE)switch_channel_get_variable_dup(channel, "session_uuid", SWITCH_TRUE
, -1);
if (zstr(b_id)_zstr(b_id)) {
	b_id = RFC7989_SESSION_UUID_NULL"00000000000000000000000000000000";
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 611, (const char*)(session), SWITCH_LOG_DEBUG, 
		"Session-ID: Inbound initial request. local-uuid: %s", a_id);
return switch_core_session_sprintf(session, "Session-ID: %s;remote=%s", a_id, b_id);
}

if (zstr(a_id)_zstr(a_id)) {
struct private_object *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
/* setting NIL local-uuid should never happen, 
 * but in case we don't get to set it properly by here, just set it to NIL */
if (tech_pvt && tech_pvt->sofia_private && tech_pvt->sofia_private->rfc7989_uuid) {
	/* handle BYE after REFER or other cases where the channel is destroyed already and we can't get the chan var */
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 622, (const char*)(session), SWITCH_LOG_DEBUG, "Session-ID: retrieved local-uuid ");
	a_id = tech_pvt->sofia_private->rfc7989_uuid;
} else {
	a_id = RFC7989_SESSION_UUID_NULL"00000000000000000000000000000000";
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 626, (const char*)(session), SWITCH_LOG_DEBUG, "Session-ID: NIL local-uuid ");
}
}

b_id = switch_channel_get_variable(channel, SWITCH_RFC7989_SESSION_ID_VARIABLE)switch_channel_get_variable_dup(channel, "session_uuid", SWITCH_TRUE
, -1);

if (zstr(b_id)_zstr(b_id) && switch_channel_test_flag(channel, CF_RFC7329_COMPAT)) {
/* fallback to RFC7329 , only one uuid*/
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 634, (const char*)(session), SWITCH_LOG_WARNING ,"Session-ID: Fallback to RFC7329, use one uuid");
return switch_core_session_sprintf(session, "Session-ID: %s", a_id);
} else if (zstr(b_id)_zstr(b_id)) {
b_id = RFC7989_SESSION_UUID_NULL"00000000000000000000000000000000";
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 638, (const char*)(session), SWITCH_LOG_DEBUG, "Session-ID: set NIL remote-uuid");
}

/* B2B: handle generic params*/
generic = switch_channel_get_variable_partner(channel, SWITCH_RFC7989_GENERIC_PARAM_VARIABLE"generic_param_session_uuid");
if (!zstr(generic)_zstr(generic)) {
/* copy generic param (name and val) */
return switch_core_session_sprintf(session, "Session-ID: %s;%s", a_id, generic);
}
if (switch_channel_test_flag(channel, CF_RFC7329_COMPAT)) {
return switch_core_session_sprintf(session, "Session-ID: %s", a_id);
}
return switch_core_session_sprintf(session, "Session-ID: %s;remote=%s", a_id, b_id);
651}

653char *sofia_glue_find_parameter_value(switch_core_session_t *session, const char *str, const char *param)
654{
const char *param_ptr;
char *param_value;
char *tmp;
switch_size_t param_len;

if (zstr(str)_zstr(str) || zstr(param)_zstr(param) || !session) return NULL((void*)0);

if (end_of(param)*(*param == '\0' ? param : param + strlen(param) - 1) != '=') {
param = switch_core_session_sprintf(session, "%s=", param);
if (zstr(param)_zstr(param)) return NULL((void*)0);
}

param_len = strlen(param);
param_ptr = sofia_glue_find_parameter(str, param);

if (zstr(param_ptr)_zstr(param_ptr)) return NULL((void*)0);

param_value = switch_core_session_strdup(session, param_ptr + param_len)switch_core_perform_session_strdup(session, param_ptr + param_len
, "sofia_glue.c", (const char *)__func__, 672);

if (zstr(param_value)_zstr(param_value)) return NULL((void*)0);

if ((tmp = strchr(param_value, ';'))) *tmp = '\0';

return param_value;
679}

681char *sofia_glue_find_parameter(const char *str, const char *param)
682{
char *ptr = NULL((void*)0);

ptr = (char *) str;
while (ptr) {
if (!strncasecmp(ptr, param, strlen(param)))
	return ptr;

if ((ptr = strchr(ptr, ';')))
	ptr++;
}

return NULL((void*)0);
695}

697sofia_transport_t sofia_glue_url2transport(const url_t *url)
698{
char *ptr = NULL((void*)0);
int tls = 0;

if (!url)
return SOFIA_TRANSPORT_UNKNOWN;

if (url->url_scheme && !strcasecmp(url->url_scheme, "sips")) {
tls++;
}

if ((ptr = sofia_glue_find_parameter(url->url_params, "transport="))) {
return sofia_glue_str2transport(ptr + 10);
}

return (tls) ? SOFIA_TRANSPORT_TCP_TLS : SOFIA_TRANSPORT_UDP;
714}

716sofia_transport_t sofia_glue_via2transport(const sip_via_t * via)
717{
char *ptr = NULL((void*)0);

if (!via || !via->v_protocol)
return SOFIA_TRANSPORT_UNKNOWN;

if ((ptr = strrchr(via->v_protocol, '/'))) {
ptr++;

if (!strncasecmp(ptr, "udp", 3)) {
	return SOFIA_TRANSPORT_UDP;
} else if (!strncasecmp(ptr, "tcp", 3)) {
	return SOFIA_TRANSPORT_TCP;
} else if (!strncasecmp(ptr, "tls", 3)) {
	return SOFIA_TRANSPORT_TCP_TLS;
} else if (!strncasecmp(ptr, "sctp", 4)) {
	return SOFIA_TRANSPORT_SCTP;
} else if (!strncasecmp(ptr, "wss", 3)) {
	return SOFIA_TRANSPORT_WSS;
} else if (!strncasecmp(ptr, "ws", 2)) {
	return SOFIA_TRANSPORT_WS;
}
}

return SOFIA_TRANSPORT_UNKNOWN;
742}

744const char *sofia_glue_transport2str(const sofia_transport_t tp)
745{
switch (tp) {
case SOFIA_TRANSPORT_TCP:
return "tcp";

case SOFIA_TRANSPORT_TCP_TLS:
return "tls";

case SOFIA_TRANSPORT_SCTP:
return "sctp";

case SOFIA_TRANSPORT_WS:
return "ws";

case SOFIA_TRANSPORT_WSS:
return "wss";

default:
return "udp";
}
765}

767char *sofia_glue_create_external_via(switch_core_session_t *session, sofia_profile_t *profile, sofia_transport_t transport)
768{
return sofia_glue_create_via(session, profile->extsipip, (sofia_glue_transport_has_tls(transport))
						 ? profile->tls_sip_port : profile->extsipport, transport);
771}

773char *sofia_glue_create_via(switch_core_session_t *session, const char *ip, switch_port_t port, sofia_transport_t transport)
774{
char *ipv6 = strchr(ip, ':');
if (port && port != 5060) {
if (session) {
	return switch_core_session_sprintf(session, "SIP/2.0/%s %s%s%s:%d;rport", sofia_glue_transport2str(transport), ipv6 ? "[" : "", ip, ipv6 ? "]" : "", port);
} else {
	return switch_mprintf("SIP/2.0/%s %s%s%s:%d;rport", sofia_glue_transport2str(transport), ipv6 ? "[" : "", ip, ipv6 ? "]" : "", port);
}
} else {
if (session) {
	return switch_core_session_sprintf(session, "SIP/2.0/%s %s%s%s;rport", sofia_glue_transport2str(transport), ipv6 ? "[" : "", ip, ipv6 ? "]" : "");
} else {
	return switch_mprintf("SIP/2.0/%s %s%s%s;rport", sofia_glue_transport2str(transport), ipv6 ? "[" : "", ip, ipv6 ? "]" : "");
}
}
789}

791char *sofia_glue_strip_uri(const char *str)
792{
char *p;
char *r;

if ((p = strchr(str, '<'))) {
p++;
r = strdup(p);
switch_assert(r)((r) ? (void) (0) : __assert_fail ("r", "sofia_glue.c", 799, __extension__
 __PRETTY_FUNCTION__));
if ((p = strchr(r, '>'))) {
	*p = '\0';
}
} else {
r = strdup(str);
switch_assert(r)((r) ? (void) (0) : __assert_fail ("r", "sofia_glue.c", 805, __extension__
 __PRETTY_FUNCTION__));
}

return r;
809}



813int sofia_glue_transport_has_tls(const sofia_transport_t tp)
814{
switch (tp) {
case SOFIA_TRANSPORT_TCP_TLS:
return 1;

default:
return 0;
}
822}

824void sofia_glue_get_addr(msg_t *msg, char *buf, size_t buflen, int *port)
825{
su_addrinfo_t *addrinfo = msg_addrinfo(msg);
if (!addrinfo) {
return;
}

if (buf) {
get_addr(buf, buflen, addrinfo->ai_addr, (socklen_t)addrinfo->ai_addrlen);
}

if (port) {
*port = get_port(addrinfo->ai_addr);
}
838}

840char *sofia_overcome_sip_uri_weakness(switch_core_session_t *session, const char *uri, const sofia_transport_t transport, switch_bool_t uri_only,
							  const char *params, const char *invite_tel_params)
842{
char *stripped = switch_core_session_strdup(session, uri)switch_core_perform_session_strdup(session, uri, "sofia_glue.c"
, (const char *)__func__, 843);
char *new_uri = NULL((void*)0);
char *p;
const char *url_params = NULL((void*)0);

if (!zstr(params)_zstr(params) && *params == '~') {
url_params = params + 1;
params = NULL((void*)0);
}

stripped = sofia_glue_get_url_from_contact(stripped, 0);

/* remove our params so we don't make any whiny moronic device piss its pants and forget who it is for a half-hour */
if ((p = (char *) switch_stristr(";fs_", stripped))) {
*p = '\0';
}

if (transport && transport != SOFIA_TRANSPORT_UDP) {

if (switch_stristr("port=", stripped)) {
	new_uri = switch_core_session_sprintf(session, "%s%s%s", uri_only ? "" : "<", stripped, uri_only ? "" : ">");
} else {
	if (params) {
		new_uri = switch_core_session_sprintf(session, "%s%s;transport=%s;%s%s",
											  uri_only ? "" : "<", stripped, sofia_glue_transport2str(transport), params, uri_only ? "" : ">");
	} else {
		new_uri = switch_core_session_sprintf(session, "%s%s;transport=%s%s",
											  uri_only ? "" : "<", stripped, sofia_glue_transport2str(transport), uri_only ? "" : ">");
	}
}
} else {
if (params) {
	new_uri = switch_core_session_sprintf(session, "%s%s;%s%s", uri_only ? "" : "<", stripped, params, uri_only ? "" : ">");
} else {
	if (uri_only) {
		new_uri = stripped;
	} else {
		new_uri = switch_core_session_sprintf(session, "<%s>", stripped);
	}
}
}

if (url_params && !uri_only) {
new_uri = switch_core_session_sprintf(session, "%s;%s", new_uri, url_params);
}

if (!zstr(invite_tel_params)_zstr(invite_tel_params)) {
char *lhs, *rhs = strchr(new_uri, '@');

if (!zstr(rhs)_zstr(rhs)) {
	*rhs++ = '\0';
	lhs = new_uri;
	new_uri = switch_core_session_sprintf(session, "%s;%s@%s", lhs, invite_tel_params, rhs);
}
}

return new_uri;
900}

902char *sofia_glue_get_extra_headers(switch_channel_t *channel, const char *prefix)
903{
char *extra_headers = NULL((void*)0);
switch_stream_handle_t stream = { 0 };
switch_event_header_t *hi = NULL((void*)0);
const char *exclude_regex = NULL((void*)0);
switch_regex_t *re = NULL((void*)0);
int ovector[30] = {0};
int proceed;

exclude_regex = switch_channel_get_variable(channel, "exclude_outgoing_extra_header")switch_channel_get_variable_dup(channel, "exclude_outgoing_extra_header"
, SWITCH_TRUE, -1);
SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "sofia_glue.c", 913, __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 ((hi = switch_channel_variable_first(channel))) {
for (; hi; hi = hi->next) {
	const char *name = (char *) hi->name;
	char *value = (char *) hi->value;

	if (!strcasecmp(name, "sip_geolocation")) {
		stream.write_function(&stream, "Geolocation: %s\r\n", value);
	}

	if (!strncasecmp(name, prefix, strlen(prefix))) {
		if ( !exclude_regex || !(proceed = switch_regex_perform(name, exclude_regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
			const char *hname = name + strlen(prefix);
			stream.write_function(&stream, "%s: %s\r\n", hname, value);
			switch_regex_safe_free(re)if (re) { switch_regex_free(re); re = ((void*)0); };
		} else {
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 929, ((void*)0), SWITCH_LOG_DEBUG, "Ignoring Extra Header [%s] , matches exclude_outgoing_extra_header [%s]\n", name, exclude_regex);
		}
	}
}
switch_channel_variable_last(channel);
}

if (!zstr((char *) stream.data)_zstr((char *) stream.data)) {
extra_headers = stream.data;
} else {
switch_safe_free(stream.data)if (stream.data) {free(stream.data);stream.data=((void*)0);};
}

return extra_headers;
943}

945void sofia_glue_set_extra_headers(switch_core_session_t *session, sip_t const *sip, const char *prefix)
946{
sip_unknown_t *un;
char name[512] = "";
switch_channel_t *channel = switch_core_session_get_channel(session);
char pstr[32];


if (!sip || !channel) {
return;
}

for (un = sip->sip_unknown; un; un = un->un_next) {
if (sofia_test_extra_headers(un->un_name)(((!strncasecmp(un->un_name, "X-", 2) && strncasecmp
(un->un_name, "X-FS-", 5)) || !strncasecmp(un->un_name,
 "P-", 2) || !strncasecmp(un->un_name, "On", 2)) ? 1 : 0)) {
	if (!zstr(un->un_value)_zstr(un->un_value)) {
		switch_snprintf(name, sizeof(name), "%s%s", prefix, un->un_name);
		switch_channel_set_variable(channel, name, un->un_value)switch_channel_set_variable_var_check(channel, name, un->un_value
, SWITCH_TRUE);
	}
}
}

switch_snprintf(pstr, sizeof(pstr), "execute_on_%sprefix", prefix);
switch_channel_execute_on(channel, pstr);
switch_channel_api_on(channel, pstr);

switch_channel_execute_on(channel, "execute_on_sip_extra_headers");
switch_channel_api_on(channel, "api_on_sip_extra_headers");
972}

974char *sofia_glue_get_extra_headers_from_event(switch_event_t *event, const char *prefix)
975{
char *extra_headers = NULL((void*)0);
switch_stream_handle_t stream = { 0 };
switch_event_header_t *hp;

SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "sofia_glue.c", 980, __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;
for (hp = event->headers; hp; hp = hp->next) {
if (!zstr(hp->name)_zstr(hp->name) && !zstr(hp->value)_zstr(hp->value) && !strncasecmp(hp->name, prefix, strlen(prefix))) {
	char *name = strdup(hp->name);
	const char *hname;
	switch_assert(name)((name) ? (void) (0) : __assert_fail ("name", "sofia_glue.c",
 985, __extension__ __PRETTY_FUNCTION__));
	hname = name + strlen(prefix);
	stream.write_function(&stream, "%s: %s\r\n", hname, (char *)hp->value);
	free(name);
}
}

if (!zstr((char *) stream.data)_zstr((char *) stream.data)) {
extra_headers = stream.data;
} else {
switch_safe_free(stream.data)if (stream.data) {free(stream.data);stream.data=((void*)0);};
}

return extra_headers;
999}

1001char *sofia_glue_get_non_extra_unknown_headers(sip_t const *sip)
1002{
char *unknown = NULL((void*)0);
switch_stream_handle_t stream = { 0 };
sip_unknown_t *un;

if (!sip) {
return NULL((void*)0);
}

SWITCH_STANDARD_STREAM(stream)memset(&stream, 0, sizeof(stream)); stream.data = malloc(
1024); ((stream.data) ? (void) (0) : __assert_fail ("stream.data"
, "sofia_glue.c", 1011, __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;
for (un = sip->sip_unknown; un; un = un->un_next) {
if (!sofia_test_extra_headers(un->un_name)(((!strncasecmp(un->un_name, "X-", 2) && strncasecmp
(un->un_name, "X-FS-", 5)) || !strncasecmp(un->un_name,
 "P-", 2) || !strncasecmp(un->un_name, "On", 2)) ? 1 : 0)) {
	if (!zstr(un->un_value)_zstr(un->un_value)) {
		stream.write_function(&stream, "%s: %s\r\n",un->un_name,un->un_value);
	}
}
}
if (!zstr((char *) stream.data)_zstr((char *) stream.data)) {
unknown = stream.data;
} else {
switch_safe_free(stream.data)if (stream.data) {free(stream.data);stream.data=((void*)0);};
}

return unknown;
1026}

1028switch_status_t sofia_glue_do_invite(switch_core_session_t *session)
1029{
char *alert_info = NULL((void*)0);
const char *max_forwards = NULL((void*)0);
const char *alertbuf;
const char *identity = NULL((void*)0);
private_object_t *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *caller_profile;
const char *cid_name, *cid_num;
char *e_dest = NULL((void*)0);
const char *holdstr = "";
char *extra_headers = NULL((void*)0);
switch_status_t status = SWITCH_STATUS_FALSE;
uint32_t session_timeout = tech_pvt->profile->session_timeout;
const char *val;
const char *rep;
const char *call_id = NULL((void*)0);
char *route = NULL((void*)0);
char *route_uri = NULL((void*)0);
sofia_destination_t *dst = NULL((void*)0);
sofia_cid_type_t cid_type = tech_pvt->profile->cid_type;
sip_cseq_t *cseq = NULL((void*)0);
const char *invite_record_route = switch_channel_get_variable(tech_pvt->channel, "sip_invite_record_route")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_record_route"
, SWITCH_TRUE, -1);
const char *invite_route_uri = switch_channel_get_variable(tech_pvt->channel, "sip_invite_route_uri")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_route_uri"
, SWITCH_TRUE, -1);
const char *invite_full_from = switch_channel_get_variable(tech_pvt->channel, "sip_invite_full_from")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_full_from"
, SWITCH_TRUE, -1);
const char *invite_full_to = switch_channel_get_variable(tech_pvt->channel, "sip_invite_full_to")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_full_to"
, SWITCH_TRUE, -1);
const char *handle_full_from = switch_channel_get_variable(tech_pvt->channel, "sip_handle_full_from")switch_channel_get_variable_dup(tech_pvt->channel, "sip_handle_full_from"
, SWITCH_TRUE, -1);
const char *handle_full_to = switch_channel_get_variable(tech_pvt->channel, "sip_handle_full_to")switch_channel_get_variable_dup(tech_pvt->channel, "sip_handle_full_to"
, SWITCH_TRUE, -1);
const char *force_full_from = switch_channel_get_variable(tech_pvt->channel, "sip_force_full_from")switch_channel_get_variable_dup(tech_pvt->channel, "sip_force_full_from"
, SWITCH_TRUE, -1);
const char *force_full_to = switch_channel_get_variable(tech_pvt->channel, "sip_force_full_to")switch_channel_get_variable_dup(tech_pvt->channel, "sip_force_full_to"
, SWITCH_TRUE, -1);
const char *content_encoding = switch_channel_get_variable(tech_pvt->channel, "sip_content_encoding")switch_channel_get_variable_dup(tech_pvt->channel, "sip_content_encoding"
, SWITCH_TRUE, -1);
char *mp = NULL((void*)0), *mp_type = NULL((void*)0);
char *record_route = NULL((void*)0);
const char *recover_via = NULL((void*)0);
int require_timer = 1;
uint8_t is_t38 = 0;
const char *hold_char = "*";
const char *session_id_header = sofia_glue_session_id_header(session, tech_pvt->profile);
const char *stir_shaken_attest = NULL((void*)0);
char *identity_to_free = NULL((void*)0);
const char *date = NULL((void*)0);


if (sofia_test_flag(tech_pvt, TFLAG_SIP_HOLD_INACTIVE)((tech_pvt)->flags[TFLAG_SIP_HOLD_INACTIVE] ? 1 : 0) ||
1
Taking false branch→
switch_true(switch_channel_get_variable_dup(tech_pvt->channel, "sofia_hold_inactive", SWITCH_FALSE, -1))) {
hold_char = "#";
}

if (switch_channel_test_flag(tech_pvt->channel, CF_RECOVERING)) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
const char *recover_contact = switch_channel_get_variable(tech_pvt->channel, "sip_recover_contact")switch_channel_get_variable_dup(tech_pvt->channel, "sip_recover_contact"
, SWITCH_TRUE, -1);
recover_via = switch_channel_get_variable(tech_pvt->channel, "sip_recover_via")switch_channel_get_variable_dup(tech_pvt->channel, "sip_recover_via"
, SWITCH_TRUE, -1);

if (!zstr(invite_record_route)_zstr(invite_record_route)) {
	record_route = switch_core_session_sprintf(session, "Record-Route: %s", invite_record_route);
}

if (recover_contact) {
	char *tmp = switch_core_session_strdup(session, recover_contact)switch_core_perform_session_strdup(session, recover_contact, "sofia_glue.c"
, (const char *)__func__, 1086);
	tech_pvt->redirected = sofia_glue_get_url_from_contact(tmp, 0);
}
}


if ((rep = switch_channel_get_variable(channel, SOFIA_REPLACES_HEADER)switch_channel_get_variable_dup(channel, "_sofia_replaces_", SWITCH_TRUE
, -1))) {
4
←
Assuming 'rep' is null→
5
←
Taking false branch→
switch_channel_set_variable(channel, SOFIA_REPLACES_HEADER, NULL)switch_channel_set_variable_var_check(channel, "_sofia_replaces_"
, ((void*)0), SWITCH_TRUE);
}

switch_assert(tech_pvt != NULL)((tech_pvt != ((void*)0)) ? (void) (0) : __assert_fail ("tech_pvt != ((void*)0)"
, "sofia_glue.c", 1096, __extension__ __PRETTY_FUNCTION__));

sofia_clear_flag_locked(tech_pvt, TFLAG_SDP)switch_mutex_lock(tech_pvt->flag_mutex); (tech_pvt)->flags
[TFLAG_SDP] = 0; switch_mutex_unlock(tech_pvt->flag_mutex)
;;

caller_profile = switch_channel_get_caller_profile(channel);

if (!caller_profile) {
6
←
Assuming 'caller_profile' is non-null→
7
←
Taking false branch→
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "sofia_glue.c", (const
 char *)__func__, 1103, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
}


if ((val = switch_channel_get_variable_dup(channel, "sip_require_timer", SWITCH_FALSE, -1)) && switch_false(val)) {
8
←
Assuming 'val' is null→
require_timer = 0;
}


cid_name = caller_profile->caller_id_name;
cid_num = caller_profile->caller_id_number;

if (!tech_pvt->sent_invites && !switch_channel_test_flag(channel, CF_ANSWERED)) {
9
←
Assuming the condition is false→
switch_core_media_prepare_codecs(tech_pvt->session, SWITCH_FALSE);
switch_core_media_check_video_codecs(tech_pvt->session);
}

check_decode(cid_name, session)do { ((session) ? (void) (0) : __assert_fail ("session", "sofia_glue.c"
, 1121, __extension__ __PRETTY_FUNCTION__)); if (!_zstr(cid_name
)) { int d = 0; char *p; if (strchr(cid_name, '%')) { char *tmp
 = switch_core_perform_session_strdup(session, cid_name, "sofia_glue.c"
, (const char *)__func__, 1121); switch_url_decode(tmp); cid_name
 = tmp; d++; } if ((p = strchr(cid_name, '"'))) { if (!d) { char
 *tmp = switch_core_perform_session_strdup(session, cid_name,
 "sofia_glue.c", (const char *)__func__, 1121); cid_name = tmp
; } if ((p = strchr(cid_name, '"'))) { cid_name = p+1; } if (
(p = strrchr(cid_name, '"'))) { *p = '\0'; } } } break; } while
 (0);
check_decode(cid_num, session)do { ((session) ? (void) (0) : __assert_fail ("session", "sofia_glue.c"
, 1122, __extension__ __PRETTY_FUNCTION__)); if (!_zstr(cid_num
)) { int d = 0; char *p; if (strchr(cid_num, '%')) { char *tmp
 = switch_core_perform_session_strdup(session, cid_num, "sofia_glue.c"
, (const char *)__func__, 1122); switch_url_decode(tmp); cid_num
 = tmp; d++; } if ((p = strchr(cid_num, '"'))) { if (!d) { char
 *tmp = switch_core_perform_session_strdup(session, cid_num, "sofia_glue.c"
, (const char *)__func__, 1122); cid_num = tmp; } if ((p = strchr
(cid_num, '"'))) { cid_num = p+1; } if ((p = strrchr(cid_num,
 '"'))) { *p = '\0'; } } } break; } while (0);


if ((alertbuf = switch_channel_get_variable(channel, "alert_info")switch_channel_get_variable_dup(channel, "alert_info", SWITCH_TRUE
, -1))) {
10
←
Assuming 'alertbuf' is null→
11
←
Taking false branch→
alert_info = switch_core_session_sprintf(tech_pvt->session, "Alert-Info: %s", alertbuf);
}

if ((stir_shaken_attest = switch_channel_get_variable(tech_pvt->channel, "sip_stir_shaken_attest")switch_channel_get_variable_dup(tech_pvt->channel, "sip_stir_shaken_attest"
, SWITCH_TRUE, -1))) {
12
←
Assuming 'stir_shaken_attest' is null→
13
←
Taking false branch→
char date_buf[80] = "";
char *dest = caller_profile->destination_number;
check_decode(dest, session)do { ((session) ? (void) (0) : __assert_fail ("session", "sofia_glue.c"
, 1132, __extension__ __PRETTY_FUNCTION__)); if (!_zstr(dest)
) { int d = 0; char *p; if (strchr(dest, '%')) { char *tmp = switch_core_perform_session_strdup
(session, dest, "sofia_glue.c", (const char *)__func__, 1132)
; switch_url_decode(tmp); dest = tmp; d++; } if ((p = strchr(
dest, '"'))) { if (!d) { char *tmp = switch_core_perform_session_strdup
(session, dest, "sofia_glue.c", (const char *)__func__, 1132)
; dest = tmp; } if ((p = strchr(dest, '"'))) { dest = p+1; } if
 ((p = strrchr(dest, '"'))) { *p = '\0'; } } } break; } while
 (0);
switch_rfc822_date(date_buf, switch_micro_time_now());
date = switch_core_session_strdup(tech_pvt->session, date_buf)switch_core_perform_session_strdup(tech_pvt->session, date_buf
, "sofia_glue.c", (const char *)__func__, 1134);
identity = identity_to_free = sofia_stir_shaken_as_create_identity_header(tech_pvt->session, stir_shaken_attest, cid_num, dest);
}
if (!identity) {
14
←
Taking true branch→
identity = switch_channel_get_variable(channel, "sip_h_identity")switch_channel_get_variable_dup(channel, "sip_h_identity", SWITCH_TRUE
, -1);
}
if (!date) {
15
←
Taking true branch→
date = switch_channel_get_variable(channel, "sip_h_date")switch_channel_get_variable_dup(channel, "sip_h_date", SWITCH_TRUE
, -1);
}

max_forwards = switch_channel_get_variable(channel, SWITCH_MAX_FORWARDS_VARIABLE)switch_channel_get_variable_dup(channel, "max_forwards", SWITCH_TRUE
, -1);

if ((status = switch_core_media_choose_port(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO, 0)) != SWITCH_STATUS_SUCCESS) {
16
←
Assuming the condition is false→
17
←
Taking false branch→
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1147, (const char*)(tech_pvt->session), SWITCH_LOG_ERROR, "Port Error!\n");
goto end;
}

if (!switch_channel_get_private(tech_pvt->channel, "t38_options") || zstr(tech_pvt->mparams.local_sdp_str)_zstr(tech_pvt->mparams.local_sdp_str)) {
18
←
Assuming the condition is false→
19
←
Taking false branch→
switch_core_media_gen_local_sdp(session, SDP_TYPE_REQUEST, NULL((void*)0), 0, NULL((void*)0), 0);
}

sofia_set_flag_locked(tech_pvt, TFLAG_READY)((tech_pvt->flag_mutex != ((void*)0)) ? (void) (0) : __assert_fail
 ("tech_pvt->flag_mutex != NULL", "sofia_glue.c", 1155, __extension__
 __PRETTY_FUNCTION__));switch_mutex_lock(tech_pvt->flag_mutex
);(tech_pvt)->flags[TFLAG_READY] = 1;switch_mutex_unlock(tech_pvt
->flag_mutex);;

if (!tech_pvt->nh) {
20
←
Assuming the condition is true→
21
←
Taking true branch→
char *d_url = NULL((void*)0), *url = NULL((void*)0), *url_str = NULL((void*)0);
sofia_private_t *sofia_private;
char *invite_contact = NULL((void*)0), *to_str, *use_from_str, *from_str;
const char *t_var;
char *rpid_domain = NULL((void*)0), *p;
const char *priv = "off";
const char *screen = "no";
const char *invite_params = switch_channel_get_variable(tech_pvt->channel, "sip_invite_params")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_params"
, SWITCH_TRUE, -1);
const char *invite_to_params = switch_channel_get_variable(tech_pvt->channel, "sip_invite_to_params")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_to_params"
, SWITCH_TRUE, -1);
const char *invite_tel_params = switch_channel_get_variable(switch_core_session_get_channel(session), "sip_invite_tel_params")switch_channel_get_variable_dup(switch_core_session_get_channel
(session), "sip_invite_tel_params", SWITCH_TRUE, -1);
const char *invite_to_uri = switch_channel_get_variable(tech_pvt->channel, "sip_invite_to_uri")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_to_uri"
, SWITCH_TRUE, -1);
const char *invite_from_uri = switch_channel_get_variable(tech_pvt->channel, "sip_invite_from_uri")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_from_uri"
, SWITCH_TRUE, -1);
const char *invite_contact_params = switch_channel_get_variable(tech_pvt->channel, "sip_invite_contact_params")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_contact_params"
, SWITCH_TRUE, -1);
const char *invite_from_params = switch_channel_get_variable(tech_pvt->channel, "sip_invite_from_params")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_from_params"
, SWITCH_TRUE, -1);
const char *invite_pid_params = switch_channel_get_variable(tech_pvt->channel, "sip_invite_pid_params")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_pid_params"
, SWITCH_TRUE, -1);
const char *from_var = switch_channel_get_variable(tech_pvt->channel, "sip_from_uri")switch_channel_get_variable_dup(tech_pvt->channel, "sip_from_uri"
, SWITCH_TRUE, -1);
const char *from_display = switch_channel_get_variable(tech_pvt->channel, "sip_from_display")switch_channel_get_variable_dup(tech_pvt->channel, "sip_from_display"
, SWITCH_TRUE, -1);
const char *invite_req_uri = switch_channel_get_variable(tech_pvt->channel, "sip_invite_req_uri")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_req_uri"
, SWITCH_TRUE, -1);
const char *invite_domain = switch_channel_get_variable(tech_pvt->channel, "sip_invite_domain")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_domain"
, SWITCH_TRUE, -1);

const char *use_name, *use_number;

if (zstr(tech_pvt->dest)_zstr(tech_pvt->dest)) {
22
←
Taking false branch→
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1181, (const char*)(tech_pvt->session), SWITCH_LOG_ERROR, "URL Error!\n");
	switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
}

if ((d_url = sofia_glue_get_url_from_contact(tech_pvt->dest, 1))) {
23
←
Assuming 'd_url' is null→
24
←
Taking false branch→
	url = d_url;
} else {
	url = tech_pvt->dest;
}

if (!tech_pvt->from_str) {
25
←
Assuming the condition is false→
26
←
Taking false branch→
	const char *sipip;
	const char *format;
	char *use_cid_num = switch_core_session_url_encode(tech_pvt->session, cid_num);

	sipip = tech_pvt->profile->sipip;

	if (!zstr(tech_pvt->mparams.remote_ip)_zstr(tech_pvt->mparams.remote_ip) && sofia_glue_check_nat(tech_pvt->profile, tech_pvt->mparams.remote_ip)) {
		sipip = tech_pvt->profile->extsipip;
	}

	if (!zstr(invite_domain)_zstr(invite_domain)) {
		sipip = invite_domain;
	}

	format = strchr(sipip, ':') ? "\"%s\" <sip:%s%s[%s]>" : "\"%s\" <sip:%s%s%s>";

	tech_pvt->from_str = switch_core_session_sprintf(tech_pvt->session, format, cid_name, use_cid_num, !zstr(cid_num)_zstr(cid_num) ? "@" : "", sipip);
}

if (from_var) {
27
←
Assuming 'from_var' is null→
28
←
Taking false branch→
	if (strncasecmp(from_var, "sip:", 4) || strncasecmp(from_var, "sips:", 5)) {
		use_from_str = switch_core_session_strdup(tech_pvt->session, from_var)switch_core_perform_session_strdup(tech_pvt->session, from_var
, "sofia_glue.c", (const char *)__func__, 1213);
	} else {
		use_from_str = switch_core_session_sprintf(tech_pvt->session, "sip:%s", from_var);
	}
} else if (!zstr(tech_pvt->gateway_from_str)_zstr(tech_pvt->gateway_from_str)) {
29
←
Taking true branch→
	use_from_str = tech_pvt->gateway_from_str;
} else {
	use_from_str = tech_pvt->from_str;
}

if (!zstr(tech_pvt->gateway_from_str)_zstr(tech_pvt->gateway_from_str)) {
30
←
Taking true branch→
	rpid_domain = switch_core_session_strdup(session, tech_pvt->gateway_from_str)switch_core_perform_session_strdup(session, tech_pvt->gateway_from_str
, "sofia_glue.c", (const char *)__func__, 1224);
} else if (!zstr(tech_pvt->from_str)_zstr(tech_pvt->from_str)) {
	rpid_domain = switch_core_session_strdup(session, use_from_str)switch_core_perform_session_strdup(session, use_from_str, "sofia_glue.c"
, (const char *)__func__, 1226);
}

sofia_glue_get_url_from_contact(rpid_domain, 0);
if (rpid_domain && (rpid_domain = strrchr(rpid_domain, '@'))) {
31
←
Assuming 'rpid_domain' is null→
	rpid_domain++;
	if ((p = strchr(rpid_domain, ';'))) {
		*p = '\0';
	}
}

if (sofia_test_pflag(tech_pvt->profile, PFLAG_AUTO_NAT)((tech_pvt->profile)->pflags[PFLAG_AUTO_NAT] ? 1 : 0)) {
32
←
Taking false branch→
	if (!zstr(tech_pvt->mparams.remote_ip)_zstr(tech_pvt->mparams.remote_ip) && !zstr(tech_pvt->profile->extsipip)_zstr(tech_pvt->profile->extsipip) && sofia_glue_check_nat(tech_pvt->profile, tech_pvt->mparams.remote_ip)) {
		rpid_domain = tech_pvt->profile->extsipip;
	} else {
		rpid_domain = tech_pvt->profile->sipip;
	}
}

if (!zstr(invite_domain)_zstr(invite_domain)) {
33
←
Taking true branch→
	rpid_domain = (char *)invite_domain;
}

if (zstr(rpid_domain)_zstr(rpid_domain)) {
34
←
Taking false branch→
	rpid_domain = "cluecon.com";
}

if (!zstr(tech_pvt->dest)_zstr(tech_pvt->dest)) {
35
←
Taking true branch→
	dst = sofia_glue_get_destination(tech_pvt->dest);
}

/*
 * Ignore transport chanvar and uri parameter for gateway connections
 * since all of them have been already taken care of in mod_sofia.c:sofia_outgoing_channel()
 */
if (tech_pvt->transport == SOFIA_TRANSPORT_UNKNOWN && zstr(tech_pvt->gateway_name)_zstr(tech_pvt->gateway_name)) {
36
←
Assuming the condition is false→
	if (dst && dst->route_uri) {
		p = dst->route_uri;
	} else {
		p = url;
	}
	if ((p = (char *) switch_stristr("port=", p))) {
		p += 5;
		tech_pvt->transport = sofia_glue_str2transport(p);
	} else {
		if ((t_var = switch_channel_get_variable(channel, "sip_transport")switch_channel_get_variable_dup(channel, "sip_transport", SWITCH_TRUE
, -1))) {
			tech_pvt->transport = sofia_glue_str2transport(t_var);
		}
	}

	if (tech_pvt->transport == SOFIA_TRANSPORT_UNKNOWN) {
		tech_pvt->transport = SOFIA_TRANSPORT_UDP;
	}
}

if (!zstr(tech_pvt->mparams.remote_ip)_zstr(tech_pvt->mparams.remote_ip) && sofia_glue_check_nat(tech_pvt->profile, tech_pvt->mparams.remote_ip)) {
37
←
Taking false branch→
	tech_pvt->user_via = sofia_glue_create_external_via(session, tech_pvt->profile, tech_pvt->transport);
}

if (!sofia_test_pflag(tech_pvt->profile, PFLAG_TLS)((tech_pvt->profile)->pflags[PFLAG_TLS] ? 1 : 0) && sofia_glue_transport_has_tls(tech_pvt->transport)) {
38
←
Taking false branch→
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1286, (const char*)(tech_pvt->session), SWITCH_LOG_ERROR, "TLS not supported by profile\n");
	switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
}

if (zstr(tech_pvt->invite_contact)_zstr(tech_pvt->invite_contact)) {
39
←
Taking false branch→
	const char *contact;
	if ((contact = switch_channel_get_variable(channel, "sip_contact_user")switch_channel_get_variable_dup(channel, "sip_contact_user", SWITCH_TRUE
, -1))) {
		char *ip_addr = tech_pvt->profile->sipip;
		char *ipv6;

		if ( !zstr(tech_pvt->mparams.remote_ip)_zstr(tech_pvt->mparams.remote_ip) && sofia_glue_check_nat(tech_pvt->profile, tech_pvt->mparams.remote_ip ) ) {
			ip_addr = tech_pvt->profile->extsipip;
		}

		ipv6 = strchr(ip_addr, ':');

		if (sofia_glue_transport_has_tls(tech_pvt->transport)) {
			tech_pvt->invite_contact = switch_core_session_sprintf(session, "sip:%s@%s%s%s:%d", contact,
																   ipv6 ? "[" : "", ip_addr, ipv6 ? "]" : "", tech_pvt->profile->tls_sip_port);
		} else {
			tech_pvt->invite_contact = switch_core_session_sprintf(session, "sip:%s@%s%s%s:%d", contact,
																   ipv6 ? "[" : "", ip_addr, ipv6 ? "]" : "", tech_pvt->profile->extsipport);
		}
	} else {
		tech_pvt->invite_contact = sofia_glue_get_profile_url(tech_pvt->profile, tech_pvt->mparams.remote_ip, tech_pvt->transport);
	}
}

url_str = sofia_overcome_sip_uri_weakness(session, url, tech_pvt->transport, SWITCH_TRUE, invite_params, invite_tel_params);
invite_contact = sofia_overcome_sip_uri_weakness(session, tech_pvt->invite_contact, tech_pvt->transport, SWITCH_FALSE, invite_contact_params, NULL((void*)0));
from_str = sofia_overcome_sip_uri_weakness(session, invite_from_uri ? invite_from_uri : use_from_str, 0, SWITCH_TRUE, invite_from_params, NULL((void*)0));
40
←
Assuming 'invite_from_uri' is null→
41
←
'?' condition is false→
to_str = sofia_overcome_sip_uri_weakness(session, invite_to_uri ? invite_to_uri : tech_pvt->dest_to, 0, SWITCH_FALSE, invite_to_params, NULL((void*)0));
42
←
Assuming 'invite_to_uri' is non-null→
43
←
'?' condition is true→

switch_channel_set_variable(channel, "sip_outgoing_contact_uri", invite_contact)switch_channel_set_variable_var_check(channel, "sip_outgoing_contact_uri"
, invite_contact, SWITCH_TRUE);

/*
  Does the "genius" who wanted SIP to be "text-based" so it was "easier to read" even use it now,
  or did he just suggest it to make our lives miserable?
*/
use_from_str = from_str;

if (!switch_stristr("sip:", use_from_str)) {
44
←
Assuming the condition is false→
45
←
Taking false branch→
	use_from_str = switch_core_session_sprintf(session, "sip:%s", use_from_str);
}

if (!from_display && (!strcasecmp(tech_pvt->caller_profile->caller_id_name, "_undef_") || zstr(tech_pvt->caller_profile->caller_id_name)_zstr(tech_pvt->caller_profile->caller_id_name))) {
46
←
Assuming 'from_display' is non-null→
	from_str = switch_core_session_sprintf(session, "<%s>", use_from_str);
} else {
	char *name = switch_core_session_strdup(session, from_display ? from_display : tech_pvt->caller_profile->caller_id_name)switch_core_perform_session_strdup(session, from_display ? from_display
 : tech_pvt->caller_profile->caller_id_name, "sofia_glue.c"
, (const char *)__func__, 1334);
	check_decode(name, session)do { ((session) ? (void) (0) : __assert_fail ("session", "sofia_glue.c"
, 1335, __extension__ __PRETTY_FUNCTION__)); if (!_zstr(name)
) { int d = 0; char *p; if (strchr(name, '%')) { char *tmp = switch_core_perform_session_strdup
(session, name, "sofia_glue.c", (const char *)__func__, 1335)
; switch_url_decode(tmp); name = tmp; d++; } if ((p = strchr(
name, '"'))) { if (!d) { char *tmp = switch_core_perform_session_strdup
(session, name, "sofia_glue.c", (const char *)__func__, 1335)
; name = tmp; } if ((p = strchr(name, '"'))) { name = p+1; } if
 ((p = strrchr(name, '"'))) { *p = '\0'; } } } break; } while
 (0);
	from_str = switch_core_session_sprintf(session, "\"%s\" <%s>", name, use_from_str);
}

if (!(call_id = switch_channel_get_variable(channel, "sip_invite_call_id")switch_channel_get_variable_dup(channel, "sip_invite_call_id"
, SWITCH_TRUE, -1))) {
47
←
Assuming 'call_id' is not null→
48
←
Taking false branch→
	if (sofia_test_pflag(tech_pvt->profile, PFLAG_UUID_AS_CALLID)((tech_pvt->profile)->pflags[PFLAG_UUID_AS_CALLID] ? 1 :
 0)) {
		call_id = switch_core_session_get_uuid(session);
	}
}

if (handle_full_from) {
49
←
Assuming 'handle_full_from' is null→
50
←
Taking false branch→
	from_str = (char *) handle_full_from;
}

if (handle_full_to) {
51
←
Assuming 'handle_full_to' is null→
52
←
Taking false branch→
	to_str = (char *) handle_full_to;
}


if (force_full_from) {
53
←
Assuming 'force_full_from' is null→
54
←
Taking false branch→
	from_str = (char *) force_full_from;
}

if (force_full_to) {
55
←
Assuming 'force_full_to' is null→
56
←
Taking false branch→
	to_str = (char *) force_full_to;
}


if (invite_req_uri) {
57
←
Assuming 'invite_req_uri' is null→
58
←
Taking false branch→
	url_str = (char *) invite_req_uri;
}

if (url_str) {
59
←
Assuming 'url_str' is null→
60
←
Taking false branch→
	char *s = NULL((void*)0);
	if (!strncasecmp(url_str, "sip:", 4)) {
		s = url_str + 4;
	}
	if (!strncasecmp(url_str, "sips:", 5)) {
		s = url_str + 5;
	}

	/* tel: patch from jaybinks, added by MC
             It compiles but I don't have a way to test it
	*/
	if (!strncasecmp(url_str, "tel:", 4)) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1380, (const char*)(tech_pvt->session),
						  SWITCH_LOG_ERROR, "URL Error! tel: uri's not supported at this time\n");
		switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
	}
	if (!s) {
		s = url_str;
	}
	switch_channel_set_variable(channel, "sip_req_uri", s)switch_channel_set_variable_var_check(channel, "sip_req_uri",
 s, SWITCH_TRUE);
}

switch_channel_set_variable(channel, "sip_to_host", sofia_glue_get_host(to_str, switch_core_session_get_pool(session)))switch_channel_set_variable_var_check(channel, "sip_to_host",
 sofia_glue_get_host(to_str, switch_core_session_get_pool(session
)), SWITCH_TRUE);
switch_channel_set_variable(channel, "sip_from_host", sofia_glue_get_host(from_str, switch_core_session_get_pool(session)))switch_channel_set_variable_var_check(channel, "sip_from_host"
, sofia_glue_get_host(from_str, switch_core_session_get_pool(
session)), SWITCH_TRUE);
61
←
Within the expansion of the macro 'switch_channel_set_variable':
→
a
Calling 'sofia_glue_get_host'
b
Returned allocated memory

if (!(tech_pvt->nh = nua_handle(tech_pvt->profile->nua, NULL((void*)0),
								NUTAG_URL(url_str)nutag_url, urltag_url_v(url_str),
69
←
Within the expansion of the macro 'NUTAG_URL':
a
Potential memory leak
								TAG_IF(call_id, SIPTAG_CALL_ID_STR(call_id))!(call_id) ? tag_skip : siptag_call_id_str, tag_str_v(call_id
),
								TAG_IF(!zstr(record_route), SIPTAG_HEADER_STR(record_route))!(!_zstr(record_route)) ? tag_skip : siptag_header_str, tag_str_v
((record_route)),
								SIPTAG_TO_STR(to_str)siptag_to_str, tag_str_v(to_str), SIPTAG_FROM_STR(from_str)siptag_from_str, tag_str_v(from_str), SIPTAG_CONTACT_STR(invite_contact)siptag_contact_str, tag_str_v(invite_contact), TAG_END()(tag_type_t)0, (tag_value_t)0))) {

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1399, (const char*)(session), SWITCH_LOG_CRIT,
					  "Error creating HANDLE!\nurl_str=[%s]\ncall_id=[%s]\nto_str=[%s]\nfrom_str=[%s]\ninvite_contact=[%s]\n",
					  url_str,
					  call_id ? call_id : "N/A",
					  to_str,
					  from_str,
					  invite_contact);

	switch_safe_free(d_url)if (d_url) {free(d_url);d_url=((void*)0);};
	switch_goto_status(SWITCH_STATUS_FALSE, end)status = SWITCH_STATUS_FALSE; goto end;
}

if (tech_pvt->dest && (strstr(tech_pvt->dest, ";fs_nat") || strstr(tech_pvt->dest, ";received")
					   || ((val = switch_channel_get_variable(channel, "sip_sticky_contact")switch_channel_get_variable_dup(channel, "sip_sticky_contact"
, SWITCH_TRUE, -1)) && switch_true(val)))) {
	sofia_set_flag(tech_pvt, TFLAG_NAT)(tech_pvt)->flags[TFLAG_NAT] = 1;
	tech_pvt->record_route = switch_core_session_strdup(tech_pvt->session, url_str)switch_core_perform_session_strdup(tech_pvt->session, url_str
, "sofia_glue.c", (const char *)__func__, 1414);
	if (!dst || !dst->route_uri) {
		route_uri = tech_pvt->record_route;
	}
	session_timeout = SOFIA_NAT_SESSION_TIMEOUT90;
	switch_channel_set_variable(channel, "sip_nat_detected", "true")switch_channel_set_variable_var_check(channel, "sip_nat_detected"
, "true", SWITCH_TRUE);
}

if ((val = switch_channel_get_variable(channel, "sip_cid_type")switch_channel_get_variable_dup(channel, "sip_cid_type", SWITCH_TRUE
, -1))) {
	cid_type = sofia_cid_name2type(val);
}

if (switch_channel_test_flag(tech_pvt->channel, CF_RECOVERING) && switch_channel_direction(tech_pvt->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
	if (zstr((use_name = switch_channel_get_variable(tech_pvt->channel, "effective_callee_id_name")))_zstr((use_name = switch_channel_get_variable_dup(tech_pvt->
channel, "effective_callee_id_name", SWITCH_TRUE, -1))) &&
		zstr((use_name = switch_channel_get_variable(tech_pvt->channel, "sip_callee_id_name")))_zstr((use_name = switch_channel_get_variable_dup(tech_pvt->
channel, "sip_callee_id_name", SWITCH_TRUE, -1)))) {
		if (!(use_name = switch_channel_get_variable(tech_pvt->channel, "sip_to_display")switch_channel_get_variable_dup(tech_pvt->channel, "sip_to_display"
, SWITCH_TRUE, -1))) {
			use_name = switch_channel_get_variable(tech_pvt->channel, "sip_to_user")switch_channel_get_variable_dup(tech_pvt->channel, "sip_to_user"
, SWITCH_TRUE, -1);
		}
	}

	if (zstr((use_number = switch_channel_get_variable(tech_pvt->channel, "effective_callee_id_number")))_zstr((use_number = switch_channel_get_variable_dup(tech_pvt->
channel, "effective_callee_id_number", SWITCH_TRUE, -1))) &&
		zstr((use_number = switch_channel_get_variable(tech_pvt->channel, "sip_callee_id_number")))_zstr((use_number = switch_channel_get_variable_dup(tech_pvt->
channel, "sip_callee_id_number", SWITCH_TRUE, -1)))) {
		use_number = switch_channel_get_variable(tech_pvt->channel, "sip_to_user")switch_channel_get_variable_dup(tech_pvt->channel, "sip_to_user"
, SWITCH_TRUE, -1);
	}

	if (zstr(use_name)_zstr(use_name) && zstr(use_name = tech_pvt->caller_profile->callee_id_name)_zstr(use_name = tech_pvt->caller_profile->callee_id_name
)) {
		use_name = tech_pvt->caller_profile->caller_id_name;
	}

	if (zstr(use_number)_zstr(use_number) && zstr(use_number = tech_pvt->caller_profile->callee_id_number)_zstr(use_number = tech_pvt->caller_profile->callee_id_number
)) {
		use_number = tech_pvt->caller_profile->caller_id_number;
	}
} else {
	use_name = tech_pvt->caller_profile->caller_id_name;
	use_number = tech_pvt->caller_profile->caller_id_number;
}

check_decode(use_name, session)do { ((session) ? (void) (0) : __assert_fail ("session", "sofia_glue.c"
, 1451, __extension__ __PRETTY_FUNCTION__)); if (!_zstr(use_name
)) { int d = 0; char *p; if (strchr(use_name, '%')) { char *tmp
 = switch_core_perform_session_strdup(session, use_name, "sofia_glue.c"
, (const char *)__func__, 1451); switch_url_decode(tmp); use_name
 = tmp; d++; } if ((p = strchr(use_name, '"'))) { if (!d) { char
 *tmp = switch_core_perform_session_strdup(session, use_name,
 "sofia_glue.c", (const char *)__func__, 1451); use_name = tmp
; } if ((p = strchr(use_name, '"'))) { use_name = p+1; } if (
(p = strrchr(use_name, '"'))) { *p = '\0'; } } } break; } while
 (0);

switch (cid_type) {
case CID_TYPE_PID:
	if (switch_test_flag(caller_profile, SWITCH_CPF_SCREEN)((caller_profile)->flags & SWITCH_CPF_SCREEN)) {
		if (zstr(tech_pvt->caller_profile->caller_id_name)_zstr(tech_pvt->caller_profile->caller_id_name) || !strcasecmp(tech_pvt->caller_profile->caller_id_name, "_undef_")) {
			tech_pvt->asserted_id = switch_core_session_sprintf(tech_pvt->session, "<sip:%s@%s%s%s>",
																use_number, rpid_domain,
																invite_pid_params ? ";" : "",
																invite_pid_params ? invite_pid_params : "");
		} else {
			tech_pvt->asserted_id = switch_core_session_sprintf(tech_pvt->session, "\"%s\" <sip:%s@%s%s%s>",
																use_name, use_number, rpid_domain,
																invite_pid_params ? ";" : "",
																invite_pid_params ? invite_pid_params : "");
		}
	} else {
		if (zstr(tech_pvt->caller_profile->caller_id_name)_zstr(tech_pvt->caller_profile->caller_id_name) || !strcasecmp(tech_pvt->caller_profile->caller_id_name, "_undef_")) {
			tech_pvt->preferred_id = switch_core_session_sprintf(tech_pvt->session, "<sip:%s@%s%s%s>",
																 tech_pvt->caller_profile->caller_id_number, rpid_domain,
																 invite_pid_params ? ";" : "",
																 invite_pid_params ? invite_pid_params : "");
		} else {
			tech_pvt->preferred_id = switch_core_session_sprintf(tech_pvt->session, "\"%s\" <sip:%s@%s%s%s>",
																 tech_pvt->caller_profile->caller_id_name,
																 tech_pvt->caller_profile->caller_id_number, rpid_domain,
																 invite_pid_params ? ";" : "",
																 invite_pid_params ? invite_pid_params : "");
		}
	}

	if (switch_test_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER)((caller_profile)->flags & SWITCH_CPF_HIDE_NUMBER)) {
		tech_pvt->privacy = "id";
	} else {
		if (!(val = switch_channel_get_variable(channel, "sip_cid_suppress_privacy_none")switch_channel_get_variable_dup(channel, "sip_cid_suppress_privacy_none"
, SWITCH_TRUE, -1)) || !switch_true(val)) {
			tech_pvt->privacy = "none";
		}
	}

	break;
case CID_TYPE_RPID:
	{
		if (switch_test_flag(caller_profile, SWITCH_CPF_HIDE_NAME)((caller_profile)->flags & SWITCH_CPF_HIDE_NAME)) {
			priv = "name";
			if (switch_test_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER)((caller_profile)->flags & SWITCH_CPF_HIDE_NUMBER)) {
				priv = "full";
			}
		} else if (switch_test_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER)((caller_profile)->flags & SWITCH_CPF_HIDE_NUMBER)) {
			priv = "full";
		}

		if (switch_test_flag(caller_profile, SWITCH_CPF_SCREEN)((caller_profile)->flags & SWITCH_CPF_SCREEN)) {
			screen = "yes";
		}

		if (zstr(tech_pvt->caller_profile->caller_id_name)_zstr(tech_pvt->caller_profile->caller_id_name) || !strcasecmp(tech_pvt->caller_profile->caller_id_name, "_undef_")) {
			tech_pvt->rpid = switch_core_session_sprintf(tech_pvt->session, "<sip:%s@%s>;party=calling;screen=%s;privacy=%s",
														 use_number, rpid_domain, screen, priv);
		} else {
			tech_pvt->rpid = switch_core_session_sprintf(tech_pvt->session, "\"%s\"<sip:%s@%s>;party=calling;screen=%s;privacy=%s",
														 use_name, use_number, rpid_domain, screen, priv);
		}
	}
	break;
default:
	break;
}


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

if (!(sofia_private = su_alloc(nua_handle_get_home(tech_pvt->nh), sizeof(*sofia_private)))) {
	abort();
}

memset(sofia_private, 0, sizeof(*sofia_private));
sofia_private->is_call = 2;
sofia_private->is_static++;

if (switch_channel_test_flag(tech_pvt->channel, CF_RECOVERING)) {
	sofia_private->is_call++;
}

tech_pvt->sofia_private = sofia_private;
switch_copy_string(tech_pvt->sofia_private->uuid_str, switch_core_session_get_uuid(session), sizeof(tech_pvt->sofia_private->uuid_str));
tech_pvt->sofia_private->uuid = tech_pvt->sofia_private->uuid_str;
nua_handle_bind(tech_pvt->nh, tech_pvt->sofia_private);
}

if (tech_pvt->e_dest && sofia_test_pflag(tech_pvt->profile, PFLAG_IN_DIALOG_CHAT)((tech_pvt->profile)->pflags[PFLAG_IN_DIALOG_CHAT] ? 1 :
 0)) {
char *user = NULL((void*)0), *host = NULL((void*)0);
char hash_key[256] = "";

e_dest = strdup(tech_pvt->e_dest);
switch_assert(e_dest != NULL)((e_dest != ((void*)0)) ? (void) (0) : __assert_fail ("e_dest != ((void*)0)"
, "sofia_glue.c", 1545, __extension__ __PRETTY_FUNCTION__));
user = e_dest;

if ((host = strchr(user, '@'))) {
	*host++ = '\0';
}
switch_snprintf(hash_key, sizeof(hash_key), "%s%s%s", user, host, cid_num);

tech_pvt->chat_from = tech_pvt->from_str;
tech_pvt->chat_to = tech_pvt->dest;
if (tech_pvt->profile->pres_type) {
	tech_pvt->hash_key = switch_core_session_strdup(tech_pvt->session, hash_key)switch_core_perform_session_strdup(tech_pvt->session, hash_key
, "sofia_glue.c", (const char *)__func__, 1556);
	switch_mutex_lock(tech_pvt->profile->flag_mutex);
	switch_core_hash_insert(tech_pvt->profile->chat_hash, tech_pvt->hash_key, tech_pvt)switch_core_hash_insert_destructor(tech_pvt->profile->chat_hash
, tech_pvt->hash_key, tech_pvt, ((void*)0));
	switch_mutex_unlock(tech_pvt->profile->flag_mutex);
}
free(e_dest);
}

holdstr = sofia_test_flag(tech_pvt, TFLAG_SIP_HOLD)((tech_pvt)->flags[TFLAG_SIP_HOLD] ? 1 : 0) ? hold_char : "";

if (!switch_channel_get_variable(channel, "sofia_profile_name")switch_channel_get_variable_dup(channel, "sofia_profile_name"
, SWITCH_TRUE, -1)) {
switch_channel_set_variable(channel, "sofia_profile_name", tech_pvt->profile->name)switch_channel_set_variable_var_check(channel, "sofia_profile_name"
, tech_pvt->profile->name, SWITCH_TRUE);
switch_channel_set_variable(channel, "recovery_profile_name", tech_pvt->profile->name)switch_channel_set_variable_var_check(channel, "recovery_profile_name"
, tech_pvt->profile->name, SWITCH_TRUE);
switch_channel_set_variable(channel, "sofia_profile_url", tech_pvt->profile->url)switch_channel_set_variable_var_check(channel, "sofia_profile_url"
, tech_pvt->profile->url, SWITCH_TRUE);
}

extra_headers = sofia_glue_get_extra_headers(channel, SOFIA_SIP_HEADER_PREFIX"sip_h_");

if ((val = switch_channel_get_variable(channel, SOFIA_SESSION_TIMEOUT)switch_channel_get_variable_dup(channel, "sofia_session_timeout"
, SWITCH_TRUE, -1))) {
int v_session_timeout = atoi(val);
if (v_session_timeout >= 0) {
	session_timeout = v_session_timeout;
}
}

if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
switch_core_media_proxy_remote_addr(session, NULL((void*)0));
switch_core_media_patch_sdp(tech_pvt->session);
}

if (!zstr(tech_pvt->dest)_zstr(tech_pvt->dest)) {
if (!dst) {
	dst = sofia_glue_get_destination(tech_pvt->dest);
}

if (dst->route_uri) {
	route_uri = sofia_overcome_sip_uri_weakness(tech_pvt->session, dst->route_uri, tech_pvt->transport, SWITCH_TRUE, NULL((void*)0), NULL((void*)0));
}

if (dst->route) {
	route = dst->route;
}
}

if ((val = switch_channel_get_variable(channel, "sip_route_uri")switch_channel_get_variable_dup(channel, "sip_route_uri", SWITCH_TRUE
, -1))) {
route_uri = switch_core_session_strdup(session, val)switch_core_perform_session_strdup(session, val, "sofia_glue.c"
, (const char *)__func__, 1601);
route = NULL((void*)0);
}

if (route_uri) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1606, (const char*)(tech_pvt->session), SWITCH_LOG_DEBUG, "%s Setting proxy route to %s\n", route_uri,
				  switch_channel_get_name(channel));
tech_pvt->route_uri = switch_core_session_strdup(tech_pvt->session, route_uri)switch_core_perform_session_strdup(tech_pvt->session, route_uri
, "sofia_glue.c", (const char *)__func__, 1608);
}


if ((val = switch_channel_get_variable(tech_pvt->channel, "sip_invite_cseq")switch_channel_get_variable_dup(tech_pvt->channel, "sip_invite_cseq"
, SWITCH_TRUE, -1))) {
uint32_t callsequence = (uint32_t) strtoul(val, NULL((void*)0), 10);
cseq = sip_cseq_create(nua_handle_get_home(tech_pvt->nh), callsequence, SIP_METHOD_INVITEsip_method_invite, "INVITE");
}


switch_channel_clear_flag(channel, CF_MEDIA_ACK);

if (handle_full_from) {
nua_handle_set_has_invite(tech_pvt->nh, 1);
}

if ((mp = sofia_media_get_multipart(session, "sip_multipart", tech_pvt->mparams.local_sdp_str, &mp_type))) {
sofia_clear_flag(tech_pvt, TFLAG_ENABLE_SOA)(tech_pvt)->flags[TFLAG_ENABLE_SOA] = 0;
}

if ((tech_pvt->session_timeout = session_timeout)) {
tech_pvt->session_refresher = switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? nua_local_refresher : nua_remote_refresher;
if (sofia_test_pflag(tech_pvt->profile, PFLAG_UPDATE_REFRESHER)((tech_pvt->profile)->pflags[PFLAG_UPDATE_REFRESHER] ? 1
 : 0) || switch_channel_var_true(tech_pvt->channel, "sip_update_refresher")) {
	tech_pvt->update_refresher = 1;
}
} else {
tech_pvt->session_refresher = nua_no_refresher;
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1637, (const char*)(tech_pvt->session), SWITCH_LOG_INFO, "%s sending invite call-id: %s\n",
			  switch_channel_get_name(tech_pvt->channel), call_id);

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1640, (const char*)(tech_pvt->session), SWITCH_LOG_DEBUG, "%s sending invite version: %s\nLocal SDP:\n%s\n",
			  switch_channel_get_name(tech_pvt->channel), switch_version_full_human(),
			  tech_pvt->mparams.local_sdp_str ? tech_pvt->mparams.local_sdp_str : "NO SDP PRESENT\n");



if ((switch_channel_get_private(tech_pvt->channel, "t38_options")) ||
((switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE) ||
  switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MEDIA) )
	&& switch_stristr("m=image", tech_pvt->mparams.local_sdp_str))) {
sofia_clear_flag(tech_pvt, TFLAG_ENABLE_SOA)(tech_pvt)->flags[TFLAG_ENABLE_SOA] = 0;
is_t38 = 1;
  }


if (sofia_use_soa(tech_pvt)((tech_pvt)->flags[TFLAG_ENABLE_SOA] ? 1 : 0)) {
nua_invite(tech_pvt->nh,
		   NUTAG_AUTOANSWER(0)nutag_autoanswer, tag_bool_v(0),
		   //TAG_IF(zstr(tech_pvt->mparams.local_sdp_str), NUTAG_AUTOACK(0)),
		   //TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), NUTAG_AUTOACK(1)),
		   // The code above is breaking things...... grrr WE need this because we handle our own acks and there are 3pcc cases in there too
		   NUTAG_AUTOACK(0)nutag_autoack, tag_bool_v(0),
		   NUTAG_SESSION_TIMER(tech_pvt->session_timeout)nutag_session_timer, tag_uint_v((tech_pvt->session_timeout
)),
		   NUTAG_SESSION_REFRESHER(tech_pvt->session_refresher)nutag_session_refresher, tag_int_v((tech_pvt->session_refresher
)),
		   NUTAG_UPDATE_REFRESH(tech_pvt->update_refresher)nutag_update_refresh, tag_bool_v((tech_pvt->update_refresher
)),
		   TAG_IF(!zstr(session_id_header), SIPTAG_HEADER_STR(session_id_header))!(!_zstr(session_id_header)) ? tag_skip : siptag_header_str, tag_str_v
((session_id_header)),
		   TAG_IF(sofia_test_flag(tech_pvt, TFLAG_RECOVERED), NUTAG_INVITE_TIMER(UINT_MAX))!(((tech_pvt)->flags[TFLAG_RECOVERED] ? 1 : 0)) ? tag_skip
 : nutag_invite_timer, tag_uint_v(((2147483647 *2U +1U))),
		   TAG_IF(invite_full_from, SIPTAG_FROM_STR(invite_full_from))!(invite_full_from) ? tag_skip : siptag_from_str, tag_str_v(invite_full_from
),
		   TAG_IF(invite_full_to, SIPTAG_TO_STR(invite_full_to))!(invite_full_to) ? tag_skip : siptag_to_str, tag_str_v(invite_full_to
),
		   TAG_IF(tech_pvt->redirected, NUTAG_URL(tech_pvt->redirected))!(tech_pvt->redirected) ? tag_skip : nutag_url, urltag_url_v
(tech_pvt->redirected),
		   TAG_IF(!zstr(recover_via), SIPTAG_VIA_STR(recover_via))!(!_zstr(recover_via)) ? tag_skip : siptag_via_str, tag_str_v
(recover_via),
		   TAG_IF(!zstr(tech_pvt->user_via), SIPTAG_VIA_STR(tech_pvt->user_via))!(!_zstr(tech_pvt->user_via)) ? tag_skip : siptag_via_str,
 tag_str_v(tech_pvt->user_via),
		   TAG_IF(!zstr(tech_pvt->rpid), SIPTAG_REMOTE_PARTY_ID_STR(tech_pvt->rpid))!(!_zstr(tech_pvt->rpid)) ? tag_skip : siptag_remote_party_id_str
, tag_str_v(tech_pvt->rpid),
		   TAG_IF(!zstr(tech_pvt->preferred_id), SIPTAG_P_PREFERRED_IDENTITY_STR(tech_pvt->preferred_id))!(!_zstr(tech_pvt->preferred_id)) ? tag_skip : siptag_p_preferred_identity_str
, tag_str_v(tech_pvt->preferred_id),
		   TAG_IF(!zstr(tech_pvt->asserted_id), SIPTAG_P_ASSERTED_IDENTITY_STR(tech_pvt->asserted_id))!(!_zstr(tech_pvt->asserted_id)) ? tag_skip : siptag_p_asserted_identity_str
, tag_str_v(tech_pvt->asserted_id),
		   TAG_IF(!zstr(tech_pvt->privacy), SIPTAG_PRIVACY_STR(tech_pvt->privacy))!(!_zstr(tech_pvt->privacy)) ? tag_skip : siptag_privacy_str
, tag_str_v(tech_pvt->privacy),
		   TAG_IF(!zstr(identity), SIPTAG_IDENTITY_STR(identity))!(!_zstr(identity)) ? tag_skip : siptag_identity_str, tag_str_v
(identity),
		   TAG_IF(!zstr(date), SIPTAG_DATE_STR(date))!(!_zstr(date)) ? tag_skip : siptag_date_str, tag_str_v(date),
		   TAG_IF(!zstr(alert_info), SIPTAG_HEADER_STR(alert_info))!(!_zstr(alert_info)) ? tag_skip : siptag_header_str, tag_str_v
((alert_info)),
		   TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers))!(!_zstr(extra_headers)) ? tag_skip : siptag_header_str, tag_str_v
((extra_headers)),
		   TAG_IF(sofia_test_pflag(tech_pvt->profile, PFLAG_PASS_CALLEE_ID), SIPTAG_HEADER_STR("X-FS-Support: " FREESWITCH_SUPPORT))!(((tech_pvt->profile)->pflags[PFLAG_PASS_CALLEE_ID] ? 1
 : 0)) ? tag_skip : siptag_header_str, tag_str_v(("X-FS-Support: "
 "update_display,send_info")),
		   TAG_IF(!zstr(max_forwards), SIPTAG_MAX_FORWARDS_STR(max_forwards))!(!_zstr(max_forwards)) ? tag_skip : siptag_max_forwards_str,
 tag_str_v(max_forwards),
		   TAG_IF(!zstr(route_uri), NUTAG_PROXY(route_uri))!(!_zstr(route_uri)) ? tag_skip : ntatag_default_proxy, urltag_url_v
((route_uri)),
		   TAG_IF(!zstr(invite_route_uri), NUTAG_INITIAL_ROUTE_STR(invite_route_uri))!(!_zstr(invite_route_uri)) ? tag_skip : nutag_initial_route_str
, tag_str_v(invite_route_uri),
		   TAG_IF(!zstr(route), SIPTAG_ROUTE_STR(route))!(!_zstr(route)) ? tag_skip : siptag_route_str, tag_str_v(route
),
		   TAG_IF(tech_pvt->profile->minimum_session_expires, NUTAG_MIN_SE(tech_pvt->profile->minimum_session_expires))!(tech_pvt->profile->minimum_session_expires) ? tag_skip
 : nutag_min_se, tag_uint_v((tech_pvt->profile->minimum_session_expires
)),
		   TAG_IF(cseq, SIPTAG_CSEQ(cseq))!(cseq) ? tag_skip : siptag_cseq, siptag_cseq_v(cseq),
		   TAG_IF(content_encoding, SIPTAG_CONTENT_ENCODING_STR(content_encoding))!(content_encoding) ? tag_skip : siptag_content_encoding_str,
 tag_str_v(content_encoding),
		   TAG_IF(zstr(tech_pvt->mparams.local_sdp_str), SIPTAG_PAYLOAD_STR(""))!(_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : siptag_payload_str
, tag_str_v(""),
		   TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), SOATAG_ADDRESS(tech_pvt->mparams.adv_sdp_audio_ip))!(!_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : soatag_address
, tag_str_v(tech_pvt->mparams.adv_sdp_audio_ip),
		   TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str))!(!_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : soatag_user_sdp_str
, tag_str_v(tech_pvt->mparams.local_sdp_str),
		   TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), SOATAG_REUSE_REJECTED(1))!(!_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : soatag_reuse_rejected
, tag_bool_v(1),
		   TAG_IF(is_t38, SOATAG_ORDERED_USER(1))!(is_t38) ? tag_skip : soatag_ordered_user, tag_bool_v(1),
		   TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), SOATAG_RTP_SORT(SOA_RTP_SORT_REMOTE))!(!_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : soatag_rtp_sort
, tag_int_v(SOA_RTP_SORT_REMOTE),
		   TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), SOATAG_RTP_SELECT(SOA_RTP_SELECT_ALL))!(!_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : soatag_rtp_select
, tag_int_v(SOA_RTP_SELECT_ALL),
		   TAG_IF(rep, SIPTAG_REPLACES_STR(rep))!(rep) ? tag_skip : siptag_replaces_str, tag_str_v(rep),
		   TAG_IF(!require_timer, NUTAG_TIMER_AUTOREQUIRE(0))!(!require_timer) ? tag_skip : nutag_timer_autorequire, tag_bool_v
(0),
		   TAG_IF(!zstr(tech_pvt->mparams.local_sdp_str), SOATAG_HOLD(holdstr))!(!_zstr(tech_pvt->mparams.local_sdp_str)) ? tag_skip : soatag_hold
, tag_str_v(holdstr), TAG_END()(tag_type_t)0, (tag_value_t)0);
} else {
nua_invite(tech_pvt->nh,
		   NUTAG_AUTOANSWER(0)nutag_autoanswer, tag_bool_v(0),
		   NUTAG_AUTOACK(0)nutag_autoack, tag_bool_v(0),
		   NUTAG_SESSION_TIMER(tech_pvt->session_timeout)nutag_session_timer, tag_uint_v((tech_pvt->session_timeout
)),
		   NUTAG_SESSION_REFRESHER(tech_pvt->session_refresher)nutag_session_refresher, tag_int_v((tech_pvt->session_refresher
)),
		   NUTAG_UPDATE_REFRESH(tech_pvt->update_refresher)nutag_update_refresh, tag_bool_v((tech_pvt->update_refresher
)),
		   TAG_IF(!zstr(session_id_header), SIPTAG_HEADER_STR(session_id_header))!(!_zstr(session_id_header)) ? tag_skip : siptag_header_str, tag_str_v
((session_id_header)),
		   TAG_IF(sofia_test_flag(tech_pvt, TFLAG_RECOVERED), NUTAG_INVITE_TIMER(UINT_MAX))!(((tech_pvt)->flags[TFLAG_RECOVERED] ? 1 : 0)) ? tag_skip
 : nutag_invite_timer, tag_uint_v(((2147483647 *2U +1U))),
		   TAG_IF(invite_full_from, SIPTAG_FROM_STR(invite_full_from))!(invite_full_from) ? tag_skip : siptag_from_str, tag_str_v(invite_full_from
),
		   TAG_IF(invite_full_to, SIPTAG_TO_STR(invite_full_to))!(invite_full_to) ? tag_skip : siptag_to_str, tag_str_v(invite_full_to
),
		   TAG_IF(tech_pvt->redirected, NUTAG_URL(tech_pvt->redirected))!(tech_pvt->redirected) ? tag_skip : nutag_url, urltag_url_v
(tech_pvt->redirected),
		   TAG_IF(!zstr(recover_via), SIPTAG_VIA_STR(recover_via))!(!_zstr(recover_via)) ? tag_skip : siptag_via_str, tag_str_v
(recover_via),
		   TAG_IF(!zstr(tech_pvt->user_via), SIPTAG_VIA_STR(tech_pvt->user_via))!(!_zstr(tech_pvt->user_via)) ? tag_skip : siptag_via_str,
 tag_str_v(tech_pvt->user_via),
		   TAG_IF(!zstr(tech_pvt->rpid), SIPTAG_REMOTE_PARTY_ID_STR(tech_pvt->rpid))!(!_zstr(tech_pvt->rpid)) ? tag_skip : siptag_remote_party_id_str
, tag_str_v(tech_pvt->rpid),
		   TAG_IF(!zstr(tech_pvt->preferred_id), SIPTAG_P_PREFERRED_IDENTITY_STR(tech_pvt->preferred_id))!(!_zstr(tech_pvt->preferred_id)) ? tag_skip : siptag_p_preferred_identity_str
, tag_str_v(tech_pvt->preferred_id),
		   TAG_IF(!zstr(tech_pvt->asserted_id), SIPTAG_P_ASSERTED_IDENTITY_STR(tech_pvt->asserted_id))!(!_zstr(tech_pvt->asserted_id)) ? tag_skip : siptag_p_asserted_identity_str
, tag_str_v(tech_pvt->asserted_id),
		   TAG_IF(!zstr(tech_pvt->privacy), SIPTAG_PRIVACY_STR(tech_pvt->privacy))!(!_zstr(tech_pvt->privacy)) ? tag_skip : siptag_privacy_str
, tag_str_v(tech_pvt->privacy),
		   TAG_IF(!zstr(alert_info), SIPTAG_HEADER_STR(alert_info))!(!_zstr(alert_info)) ? tag_skip : siptag_header_str, tag_str_v
((alert_info)),
		   TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers))!(!_zstr(extra_headers)) ? tag_skip : siptag_header_str, tag_str_v
((extra_headers)),
		   TAG_IF(sofia_test_pflag(tech_pvt->profile, PFLAG_PASS_CALLEE_ID), SIPTAG_HEADER_STR("X-FS-Support: " FREESWITCH_SUPPORT))!(((tech_pvt->profile)->pflags[PFLAG_PASS_CALLEE_ID] ? 1
 : 0)) ? tag_skip : siptag_header_str, tag_str_v(("X-FS-Support: "
 "update_display,send_info")),
		   TAG_IF(!zstr(max_forwards), SIPTAG_MAX_FORWARDS_STR(max_forwards))!(!_zstr(max_forwards)) ? tag_skip : siptag_max_forwards_str,
 tag_str_v(max_forwards),
		   TAG_IF(!zstr(identity), SIPTAG_IDENTITY_STR(identity))!(!_zstr(identity)) ? tag_skip : siptag_identity_str, tag_str_v
(identity),
		   TAG_IF(!zstr(route_uri), NUTAG_PROXY(route_uri))!(!_zstr(route_uri)) ? tag_skip : ntatag_default_proxy, urltag_url_v
((route_uri)),
		   TAG_IF(!zstr(route), SIPTAG_ROUTE_STR(route))!(!_zstr(route)) ? tag_skip : siptag_route_str, tag_str_v(route
),
		   TAG_IF(!zstr(invite_route_uri), NUTAG_INITIAL_ROUTE_STR(invite_route_uri))!(!_zstr(invite_route_uri)) ? tag_skip : nutag_initial_route_str
, tag_str_v(invite_route_uri),
		   TAG_IF(tech_pvt->profile->minimum_session_expires, NUTAG_MIN_SE(tech_pvt->profile->minimum_session_expires))!(tech_pvt->profile->minimum_session_expires) ? tag_skip
 : nutag_min_se, tag_uint_v((tech_pvt->profile->minimum_session_expires
)),
		   TAG_IF(!require_timer, NUTAG_TIMER_AUTOREQUIRE(0))!(!require_timer) ? tag_skip : nutag_timer_autorequire, tag_bool_v
(0),
		   TAG_IF(cseq, SIPTAG_CSEQ(cseq))!(cseq) ? tag_skip : siptag_cseq, siptag_cseq_v(cseq),
		   TAG_IF(content_encoding, SIPTAG_CONTENT_ENCODING_STR(content_encoding))!(content_encoding) ? tag_skip : siptag_content_encoding_str,
 tag_str_v(content_encoding),
		   NUTAG_MEDIA_ENABLE(0)nutag_media_enable, tag_bool_v(0),
		   SIPTAG_CONTENT_TYPE_STR(mp_type ? mp_type : "application/sdp")siptag_content_type_str, tag_str_v(mp_type ? mp_type : "application/sdp"
),
		   SIPTAG_PAYLOAD_STR(mp ? mp : tech_pvt->mparams.local_sdp_str)siptag_payload_str, tag_str_v(mp ? mp : tech_pvt->mparams.
local_sdp_str), TAG_IF(rep, SIPTAG_REPLACES_STR(rep))!(rep) ? tag_skip : siptag_replaces_str, tag_str_v(rep), SOATAG_HOLD(holdstr)soatag_hold, tag_str_v(holdstr), TAG_END()(tag_type_t)0, (tag_value_t)0);
}

switch_safe_free(extra_headers)if (extra_headers) {free(extra_headers);extra_headers=((void*
)0);};
switch_safe_free(mp)if (mp) {free(mp);mp=((void*)0);};
tech_pvt->redirected = NULL((void*)0);

status = SWITCH_STATUS_SUCCESS;

1739end:

if (dst) {
sofia_glue_free_destination(dst);
}

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

return status;
1748}

1750void sofia_glue_do_xfer_invite(switch_core_session_t *session)
1751{
private_object_t *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_caller_profile_t *caller_profile;
const char *sipip, *format, *contact_url;

switch_assert(tech_pvt != NULL)((tech_pvt != ((void*)0)) ? (void) (0) : __assert_fail ("tech_pvt != ((void*)0)"
, "sofia_glue.c", 1757, __extension__ __PRETTY_FUNCTION__));
switch_mutex_lock(tech_pvt->sofia_mutex);
caller_profile = switch_channel_get_caller_profile(channel);

if (!zstr(tech_pvt->mparams.remote_ip)_zstr(tech_pvt->mparams.remote_ip) && sofia_glue_check_nat(tech_pvt->profile, tech_pvt->mparams.remote_ip)) {
sipip = tech_pvt->profile->extsipip;
contact_url = tech_pvt->profile->public_url;
} else {
sipip = tech_pvt->profile->extsipip ? tech_pvt->profile->extsipip : tech_pvt->profile->sipip;
contact_url = tech_pvt->profile->url;
}

format = strchr(sipip, ':') ? "\"%s\" <sip:%s@[%s]>" : "\"%s\" <sip:%s@%s>";

if ((tech_pvt->from_str = switch_core_session_sprintf(session, format, caller_profile->caller_id_name, caller_profile->caller_id_number, sipip))) {

const char *rep = switch_channel_get_variable(channel, SOFIA_REPLACES_HEADER)switch_channel_get_variable_dup(channel, "_sofia_replaces_", SWITCH_TRUE
, -1);

tech_pvt->nh2 = nua_handle(tech_pvt->profile->nua, NULL((void*)0),
						   SIPTAG_TO_STR(tech_pvt->dest)siptag_to_str, tag_str_v(tech_pvt->dest), SIPTAG_FROM_STR(tech_pvt->from_str)siptag_from_str, tag_str_v(tech_pvt->from_str), SIPTAG_CONTACT_STR(contact_url)siptag_contact_str, tag_str_v(contact_url), TAG_END()(tag_type_t)0, (tag_value_t)0);

nua_handle_bind(tech_pvt->nh2, tech_pvt->sofia_private);

nua_invite(tech_pvt->nh2,
		   SIPTAG_CONTACT_STR(contact_url)siptag_contact_str, tag_str_v(contact_url),
		   TAG_IF(!zstr(tech_pvt->user_via), SIPTAG_VIA_STR(tech_pvt->user_via))!(!_zstr(tech_pvt->user_via)) ? tag_skip : siptag_via_str,
 tag_str_v(tech_pvt->user_via),
		   SOATAG_ADDRESS(tech_pvt->mparams.adv_sdp_audio_ip)soatag_address, tag_str_v(tech_pvt->mparams.adv_sdp_audio_ip
),
		   SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str)soatag_user_sdp_str, tag_str_v(tech_pvt->mparams.local_sdp_str
),
		   SOATAG_REUSE_REJECTED(1)soatag_reuse_rejected, tag_bool_v(1),
		   SOATAG_RTP_SORT(SOA_RTP_SORT_REMOTE)soatag_rtp_sort, tag_int_v(SOA_RTP_SORT_REMOTE), SOATAG_RTP_SELECT(SOA_RTP_SELECT_ALL)soatag_rtp_select, tag_int_v(SOA_RTP_SELECT_ALL), TAG_IF(rep, SIPTAG_REPLACES_STR(rep))!(rep) ? tag_skip : siptag_replaces_str, tag_str_v(rep), TAG_END()(tag_type_t)0, (tag_value_t)0);
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 1788, (const char*)(tech_pvt->session), SWITCH_LOG_ERROR, "Memory Error!\n");
}
switch_mutex_unlock(tech_pvt->sofia_mutex);
1791}


1794/* map sip responses to QSIG cause codes ala RFC4497 section 8.4.4 */
1795switch_call_cause_t sofia_glue_sip_cause_to_freeswitch(int status)
1796{
switch (status) {
case 200:
return SWITCH_CAUSE_NORMAL_CLEARING;
case 401:
case 402:
case 403:
case 407:
case 603:
case 607:
return SWITCH_CAUSE_CALL_REJECTED;
case 404:
return SWITCH_CAUSE_UNALLOCATED_NUMBER;
case 485:
case 604:
return SWITCH_CAUSE_NO_ROUTE_DESTINATION;
case 408:
case 504:
return SWITCH_CAUSE_RECOVERY_ON_TIMER_EXPIRE;
case 410:
return SWITCH_CAUSE_NUMBER_CHANGED;
case 413:
case 414:
case 416:
case 420:
case 421:
case 423:
case 505:
case 513:
return SWITCH_CAUSE_INTERWORKING;
case 480:
return SWITCH_CAUSE_NO_USER_RESPONSE;
case 400:
case 481:
case 500:
case 503:
return SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE;
case 486:
case 600:
return SWITCH_CAUSE_USER_BUSY;
case 484:
return SWITCH_CAUSE_INVALID_NUMBER_FORMAT;
case 488:
case 606:
return SWITCH_CAUSE_INCOMPATIBLE_DESTINATION;
case 502:
return SWITCH_CAUSE_NETWORK_OUT_OF_ORDER;
case 405:
return SWITCH_CAUSE_SERVICE_UNAVAILABLE;
case 406:
case 415:
case 501:
return SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED;
case 482:
case 483:
return SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR;
case 487:
return SWITCH_CAUSE_ORIGINATOR_CANCEL;
case 428:
return SWITCH_CAUSE_NO_IDENTITY;
case 429:
return SWITCH_CAUSE_BAD_IDENTITY_INFO;
case 437:
return SWITCH_CAUSE_UNSUPPORTED_CERTIFICATE;
case 438:
return SWITCH_CAUSE_INVALID_IDENTITY;
default:
return SWITCH_CAUSE_NORMAL_UNSPECIFIED;
}
1865}

1867void sofia_glue_pass_sdp(private_object_t *tech_pvt, char *sdp)
1868{
const char *val;
switch_core_session_t *other_session;
switch_channel_t *other_channel;

if ((val = switch_channel_get_partner_uuid(tech_pvt->channel))
&& (other_session = switch_core_session_locate(val)switch_core_session_perform_locate(val, "sofia_glue.c", (const
 char *)__func__, 1874))) {
other_channel = switch_core_session_get_channel(other_session);
switch_channel_set_variable(other_channel, SWITCH_B_SDP_VARIABLE, sdp)switch_channel_set_variable_var_check(other_channel, "switch_m_sdp"
, sdp, SWITCH_TRUE);

1878#if 0
if (!sofia_test_flag(tech_pvt, TFLAG_CHANGE_MEDIA)((tech_pvt)->flags[TFLAG_CHANGE_MEDIA] ? 1 : 0) && !switch_channel_test_flag(tech_pvt->channel, CF_RECOVERING) &&
	(switch_channel_direction(other_channel) == SWITCH_CALL_DIRECTION_OUTBOUND &&
	 switch_channel_direction(tech_pvt->channel) == SWITCH_CALL_DIRECTION_OUTBOUND && switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE))) {
	switch_ivr_nomedia(val, SMF_FORCE);
	sofia_set_flag_locked(tech_pvt, TFLAG_CHANGE_MEDIA)((tech_pvt->flag_mutex != ((void*)0)) ? (void) (0) : __assert_fail
 ("tech_pvt->flag_mutex != NULL", "sofia_glue.c", 1883, __extension__
 __PRETTY_FUNCTION__));switch_mutex_lock(tech_pvt->flag_mutex
);(tech_pvt)->flags[TFLAG_CHANGE_MEDIA] = 1;switch_mutex_unlock
(tech_pvt->flag_mutex);;
}
1885#endif

switch_core_session_rwunlock(other_session);
}
1889}

1891char *sofia_glue_get_path_from_contact(char *buf)
1892{
char *p, *e, *path = NULL((void*)0), *contact = NULL((void*)0);

if (!buf) return NULL((void*)0);

contact = sofia_glue_get_url_from_contact(buf, SWITCH_TRUE);

if (!contact) return NULL((void*)0);

if ((p = strstr(contact, "fs_path="))) {
p += 8;

if (!zstr(p)_zstr(p)) {
	path = strdup(p);
}
}

if (!path) {
free(contact);
return NULL((void*)0);
}

if ((e = strrchr(path, ';'))) {
*e = '\0';
}

switch_url_decode(path);

free(contact);

return path;
1923}

1925char *sofia_glue_get_url_from_contact(char *buf, uint8_t to_dup)
1926{
char *url = NULL((void*)0), *e;

switch_assert(buf)((buf) ? (void) (0) : __assert_fail ("buf", "sofia_glue.c", 1929
, __extension__ __PRETTY_FUNCTION__));

while(*buf == ' ') {
buf++;
}

if (*buf == '"') {
buf++;
if((e = strchr(buf, '"'))) {
	buf = e+1;
}
}

while(*buf == ' ') {
buf++;
}

url = strchr(buf, '<');

if (url && (e = switch_find_end_paren(url, '<', '>'))) {
url++;
if (to_dup) {
	url = strdup(url);
	switch_assert(url)((url) ? (void) (0) : __assert_fail ("url", "sofia_glue.c", 1952
, __extension__ __PRETTY_FUNCTION__));
	e = strchr(url, '>');
}

*e = '\0';
} else {
if (url) buf++;

if (to_dup) {
	url = strdup(buf);
} else {
	url = buf;
}
}
return url;
1967}

1969switch_status_t sofia_glue_profile_rdlock__(const char *file, const char *func, int line, sofia_profile_t *profile)
1970{
switch_status_t status = switch_thread_rwlock_tryrdlock(profile->rwlock);
if (status != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL((void*)0), SWITCH_LOG_ERROR, "Profile %s is locked\n", profile->name);
return status;
}
1976#ifdef SOFIA_DEBUG_RWLOCKS
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL((void*)0), SWITCH_LOG_ERROR, "XXXXXXXXXXXXXX LOCK %s\n", profile->name);
1978#endif
return status;
1980}

1982switch_bool_t sofia_glue_profile_exists(const char *key)
1983{
switch_bool_t tf = SWITCH_FALSE;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (switch_core_hash_find(mod_sofia_globals.profile_hash, key)) {
tf = SWITCH_TRUE;
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

return tf;
1993}

1995sofia_profile_t *sofia_glue_find_profile__(const char *file, const char *func, int line, const char *key)
1996{
sofia_profile_t *profile;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if ((profile = (sofia_profile_t *) switch_core_hash_find(mod_sofia_globals.profile_hash, key))) {
if (!sofia_test_pflag(profile, PFLAG_RUNNING)((profile)->pflags[PFLAG_RUNNING] ? 1 : 0)) {
2002#ifdef SOFIA_DEBUG_RWLOCKS
	switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL((void*)0), SWITCH_LOG_ERROR, "Profile %s is not running\n", profile->name);
2004#endif
	profile = NULL((void*)0);
	goto done;
}
if (sofia_glue_profile_rdlock__(file, func, line, profile) != SWITCH_STATUS_SUCCESS) {
	profile = NULL((void*)0);
}
} else {
2012#ifdef SOFIA_DEBUG_RWLOCKS
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL((void*)0), SWITCH_LOG_ERROR, "Profile %s is not in the hash\n", key);
2014#endif
}

done:
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

return profile;
2021}

2023void sofia_glue_release_profile__(const char *file, const char *func, int line, sofia_profile_t *profile)
2024{
if (profile) {
2026#ifdef SOFIA_DEBUG_RWLOCKS
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL((void*)0), SWITCH_LOG_ERROR, "XXXXXXXXXXXXXX UNLOCK %s\n", profile->name);
2028#endif
switch_thread_rwlock_unlock(profile->rwlock);
}
2031}

2033switch_status_t sofia_glue_add_profile(char *key, sofia_profile_t *profile)
2034{
switch_status_t status = SWITCH_STATUS_FALSE;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (!switch_core_hash_find(mod_sofia_globals.profile_hash, key)) {
status = switch_core_hash_insert(mod_sofia_globals.profile_hash, key, profile)switch_core_hash_insert_destructor(mod_sofia_globals.profile_hash
, key, profile, ((void*)0));
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

return status;
2044}


2047void sofia_glue_del_every_gateway(sofia_profile_t *profile)
2048{
sofia_gateway_t *gp = NULL((void*)0);

switch_mutex_lock(mod_sofia_globals.hash_mutex);
for (gp = profile->gateways; gp; gp = gp->next) {
sofia_glue_del_gateway(gp);
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);
2056}


2059void sofia_glue_gateway_list(sofia_profile_t *profile, switch_stream_handle_t *stream, int up)
2060{
sofia_gateway_t *gp = NULL((void*)0);

switch_mutex_lock(mod_sofia_globals.hash_mutex);
for (gp = profile->gateways; gp; gp = gp->next) {
int reged = (gp->status == SOFIA_GATEWAY_UP);

if (up ? reged : !reged) {
	stream->write_function(stream, "%s ", gp->name);
}
}

switch_mutex_unlock(mod_sofia_globals.hash_mutex);
2073}


2076void sofia_glue_del_gateway(sofia_gateway_t *gp)
2077{
if (!gp->deleted) {
if (gp->state != REG_STATE_NOREG) {
	gp->retry = 0;
	gp->state = REG_STATE_UNREGISTER;
}

gp->deleted = 1;
}
2086}

2088void sofia_glue_restart_all_profiles(void)
2089{
switch_hash_index_t *hi;
const void *var;
void *val;
sofia_profile_t *pptr;
switch_xml_t xml_root;
const char *err;

if ((xml_root = switch_xml_open_root(1, &err))) {
switch_xml_free(xml_root);
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2099, ((void*)0), SWITCH_LOG_NOTICE, "Reload XML [%s]\n", err);
}

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (mod_sofia_globals.profile_hash) {
for (hi = switch_core_hash_first(mod_sofia_globals.profile_hash)switch_core_hash_first_iter(mod_sofia_globals.profile_hash, (
(void*)0)); hi; hi = switch_core_hash_next(&hi)) {
	switch_core_hash_this(hi, &var, NULL((void*)0), &val);
	if ((pptr = (sofia_profile_t *) val)) {
		int rsec = 10;
		int diff = (int) (switch_epoch_time_now(NULL((void*)0)) - pptr->started);
		int remain = rsec - diff;
		if (sofia_test_pflag(pptr, PFLAG_RESPAWN)((pptr)->pflags[PFLAG_RESPAWN] ? 1 : 0) || !sofia_test_pflag(pptr, PFLAG_RUNNING)((pptr)->pflags[PFLAG_RUNNING] ? 1 : 0)) {
			continue;
		}

		if (diff < rsec) {
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2115, ((void*)0), SWITCH_LOG_ERROR,
							  "Profile %s must be up for at least %d seconds to stop/restart.\nPlease wait %d second%s\n",
							  pptr->name, rsec, remain, remain == 1 ? "" : "s");
			continue;
		}
		sofia_set_pflag_locked(pptr, PFLAG_RESPAWN)((pptr->flag_mutex != ((void*)0)) ? (void) (0) : __assert_fail
 ("pptr->flag_mutex != NULL", "sofia_glue.c", 2120, __extension__
 __PRETTY_FUNCTION__));switch_mutex_lock(pptr->flag_mutex)
;(pptr)->pflags[PFLAG_RESPAWN] = 1;switch_mutex_unlock(pptr
->flag_mutex);;
		sofia_clear_pflag_locked(pptr, PFLAG_RUNNING)switch_mutex_lock(pptr->flag_mutex); (pptr)->pflags[PFLAG_RUNNING
] = 0; switch_mutex_unlock(pptr->flag_mutex);;
	}
}
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

2127}


2130void sofia_glue_global_siptrace(switch_bool_t on)
2131{
switch_hash_index_t *hi;
const void *var;
void *val;
sofia_profile_t *pptr;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (mod_sofia_globals.profile_hash) {
for (hi = switch_core_hash_first(mod_sofia_globals.profile_hash)switch_core_hash_first_iter(mod_sofia_globals.profile_hash, (
(void*)0)); hi; hi = switch_core_hash_next(&hi)) {
	switch_core_hash_this(hi, &var, NULL((void*)0), &val);
	if ((pptr = (sofia_profile_t *) val)) {
		nua_set_params(pptr->nua, TPTAG_LOG(on)tptag_log, tag_bool_v((on)), TAG_END()(tag_type_t)0, (tag_value_t)0);
	}
}
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

2148}

2150void sofia_glue_global_standby(switch_bool_t on)
2151{
switch_hash_index_t *hi;
const void *var;
void *val;
sofia_profile_t *pptr;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (mod_sofia_globals.profile_hash) {
for (hi = switch_core_hash_first(mod_sofia_globals.profile_hash)switch_core_hash_first_iter(mod_sofia_globals.profile_hash, (
(void*)0)); hi; hi = switch_core_hash_next(&hi)) {
	switch_core_hash_this(hi, &var, NULL((void*)0), &val);
	if ((pptr = (sofia_profile_t *) val)) {
		if (on) {
			sofia_set_pflag_locked(pptr, PFLAG_STANDBY)((pptr->flag_mutex != ((void*)0)) ? (void) (0) : __assert_fail
 ("pptr->flag_mutex != NULL", "sofia_glue.c", 2163, __extension__
 __PRETTY_FUNCTION__));switch_mutex_lock(pptr->flag_mutex)
;(pptr)->pflags[PFLAG_STANDBY] = 1;switch_mutex_unlock(pptr
->flag_mutex);;
		} else {
			sofia_clear_pflag_locked(pptr, PFLAG_STANDBY)switch_mutex_lock(pptr->flag_mutex); (pptr)->pflags[PFLAG_STANDBY
] = 0; switch_mutex_unlock(pptr->flag_mutex);;
		}
	}
}
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

2172}

2174void sofia_glue_global_capture(switch_bool_t on)
2175{
     switch_hash_index_t *hi;
     const void *var;
     void *val;
     sofia_profile_t *pptr;

     switch_mutex_lock(mod_sofia_globals.hash_mutex);
     if (mod_sofia_globals.profile_hash) {
             for (hi = switch_core_hash_first(mod_sofia_globals.profile_hash)switch_core_hash_first_iter(mod_sofia_globals.profile_hash, (
(void*)0)); hi; hi = switch_core_hash_next(&hi)) {
                     switch_core_hash_this(hi, &var, NULL((void*)0), &val);
                     if ((pptr = (sofia_profile_t *) val)) {
                             nua_set_params(pptr->nua, TPTAG_CAPT(on ? mod_sofia_globals.capture_server : NULL)tptag_capt, tag_str_v((on ? mod_sofia_globals.capture_server :
 ((void*)0))), TAG_END()(tag_type_t)0, (tag_value_t)0);
                     }
             }
     }
     switch_mutex_unlock(mod_sofia_globals.hash_mutex);

2192}


2195void sofia_glue_global_watchdog(switch_bool_t on)
2196{
switch_hash_index_t *hi;
const void *var;
void *val;
sofia_profile_t *pptr;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (mod_sofia_globals.profile_hash) {
for (hi = switch_core_hash_first(mod_sofia_globals.profile_hash)switch_core_hash_first_iter(mod_sofia_globals.profile_hash, (
(void*)0)); hi; hi = switch_core_hash_next(&hi)) {
	switch_core_hash_this(hi, &var, NULL((void*)0), &val);
	if ((pptr = (sofia_profile_t *) val)) {
		pptr->watchdog_enabled = (on ? 1 : 0);
	}
}
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);

2213}

2215void sofia_glue_del_profile(sofia_profile_t *profile)
2216{
sofia_gateway_t *gp;
char *aliases[512];
int i = 0, j = 0;
switch_hash_index_t *hi;
const void *var;
void *val;
sofia_profile_t *pptr;

switch_mutex_lock(mod_sofia_globals.hash_mutex);
if (mod_sofia_globals.profile_hash) {
for (hi = switch_core_hash_first(mod_sofia_globals.profile_hash)switch_core_hash_first_iter(mod_sofia_globals.profile_hash, (
(void*)0)); hi; hi = switch_core_hash_next(&hi)) {
	switch_core_hash_this(hi, &var, NULL((void*)0), &val);
	if ((pptr = (sofia_profile_t *) val) && pptr == profile) {
		aliases[i++] = strdup((char *) var);
		if (i == 512) {
			abort();
		}
	}
}

for (j = 0; j < i && j < 512; j++) {
	switch_core_hash_delete(mod_sofia_globals.profile_hash, aliases[j]);
	free(aliases[j]);
}

for (gp = profile->gateways; gp; gp = gp->next) {
	char *pkey = switch_mprintf("%s::%s", profile->name, gp->name);

	switch_core_hash_delete(mod_sofia_globals.gateway_hash, gp->name);
	switch_core_hash_delete(mod_sofia_globals.gateway_hash, pkey);
	switch_safe_free(pkey)if (pkey) {free(pkey);pkey=((void*)0);};
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2248, ((void*)0), SWITCH_LOG_NOTICE, "deleted gateway %s from profile %s\n", gp->name, profile->name);
}
profile->gateways = NULL((void*)0);
}
switch_mutex_unlock(mod_sofia_globals.hash_mutex);
2253}

2255int sofia_recover_callback(switch_core_session_t *session)
2256{

switch_channel_t *channel = switch_core_session_get_channel(session);
private_object_t *tech_pvt = NULL((void*)0);
sofia_profile_t *profile = NULL((void*)0);
const char *tmp;
const char *rr;
int r = 0;
const char *profile_name = switch_channel_get_variable_dup(channel, "recovery_profile_name", SWITCH_FALSE, -1);
int swap = switch_channel_var_true(channel, "dlg_req_swap_direction");

if (zstr(profile_name)_zstr(profile_name)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 2268, (const char*)(session), SWITCH_LOG_CRIT, "Missing profile\n");
return 0;
}

if (!(profile = sofia_glue_find_profile(profile_name)sofia_glue_find_profile__("sofia_glue.c", (const char *)__func__
, 2272, profile_name))) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 2273, (const char*)(session), SWITCH_LOG_CRIT, "Invalid profile %s\n", profile_name);
return 0;
}


tech_pvt = (private_object_t *) switch_core_session_alloc(session, sizeof(private_object_t))switch_core_perform_session_alloc(session, sizeof(private_object_t
), "sofia_glue.c", (const char *)__func__, 2278);
tech_pvt->channel = channel;

switch_mutex_init(&tech_pvt->flag_mutex, SWITCH_MUTEX_NESTED0x1, switch_core_session_get_pool(session));
switch_mutex_init(&tech_pvt->sofia_mutex, SWITCH_MUTEX_NESTED0x1, switch_core_session_get_pool(session));

tech_pvt->mparams.remote_ip = (char *) switch_channel_get_variable(channel, "sip_network_ip")switch_channel_get_variable_dup(channel, "sip_network_ip", SWITCH_TRUE
, -1);
tech_pvt->mparams.remote_port = atoi(switch_str_nil(switch_channel_get_variable(channel, "sip_network_port"))(switch_channel_get_variable_dup(channel, "sip_network_port",
 SWITCH_TRUE, -1) ? switch_channel_get_variable_dup(channel, "sip_network_port"
, SWITCH_TRUE, -1) : ""));
tech_pvt->caller_profile = switch_channel_get_caller_profile(channel);

if ((tmp = switch_channel_get_variable(tech_pvt->channel, "rtp_2833_send_payload")switch_channel_get_variable_dup(tech_pvt->channel, "rtp_2833_send_payload"
, SWITCH_TRUE, -1))) {
int te = atoi(tmp);
if (te > 64) {
	tech_pvt->te = (switch_payload_t)te;
}
}

if ((tmp = switch_channel_get_variable(tech_pvt->channel, "rtp_2833_recv_payload")switch_channel_get_variable_dup(tech_pvt->channel, "rtp_2833_recv_payload"
, SWITCH_TRUE, -1))) {
int te = atoi(tmp);
if (te > 64) {
	tech_pvt->recv_te = (switch_payload_t)te;
}
}

rr = switch_channel_get_variable(channel, "sip_invite_record_route")switch_channel_get_variable_dup(channel, "sip_invite_record_route"
, SWITCH_TRUE, -1);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
tech_pvt->dest = switch_core_session_sprintf(session, "sip:%s", switch_channel_get_variable(channel, "sip_req_uri")switch_channel_get_variable_dup(channel, "sip_req_uri", SWITCH_TRUE
, -1));
switch_channel_set_variable(channel, "sip_handle_full_from", switch_channel_get_variable(channel, swap ? "sip_full_to" : "sip_full_from"))switch_channel_set_variable_var_check(channel, "sip_handle_full_from"
, switch_channel_get_variable_dup(channel, swap ? "sip_full_to"
 : "sip_full_from", SWITCH_TRUE, -1), SWITCH_TRUE);
switch_channel_set_variable(channel, "sip_handle_full_to", switch_channel_get_variable(channel, swap ? "sip_full_from" : "sip_full_to"))switch_channel_set_variable_var_check(channel, "sip_handle_full_to"
, switch_channel_get_variable_dup(channel, swap ? "sip_full_from"
 : "sip_full_to", SWITCH_TRUE, -1), SWITCH_TRUE);
} else {
const char *contact_params = switch_channel_get_variable(channel, "sip_contact_params")switch_channel_get_variable_dup(channel, "sip_contact_params"
, SWITCH_TRUE, -1);
const char *contact_uri = switch_channel_get_variable(channel, "sip_contact_uri")switch_channel_get_variable_dup(channel, "sip_contact_uri", SWITCH_TRUE
, -1);
tech_pvt->redirected = switch_core_session_sprintf(session, "sip:%s%s%s", contact_uri, contact_params ? ";" : "", switch_str_nil(contact_params)(contact_params ? contact_params : ""));

if (zstr(rr)_zstr(rr)) {
	switch_channel_set_variable_printf(channel, "sip_invite_route_uri", "<sip:%s@%s:%s;transport=%s>",
									   switch_channel_get_variable(channel, "sip_from_user")switch_channel_get_variable_dup(channel, "sip_from_user", SWITCH_TRUE
, -1),
									   switch_channel_get_variable(channel, "sip_network_ip")switch_channel_get_variable_dup(channel, "sip_network_ip", SWITCH_TRUE
, -1),
									   switch_channel_get_variable(channel, "sip_network_port")switch_channel_get_variable_dup(channel, "sip_network_port", SWITCH_TRUE
, -1),
									   switch_channel_get_variable(channel,"sip_via_protocol")switch_channel_get_variable_dup(channel, "sip_via_protocol", SWITCH_TRUE
, -1)
									   );

}

tech_pvt->dest = switch_core_session_sprintf(session, "sip:%s", switch_channel_get_variable(channel, "sip_from_uri")switch_channel_get_variable_dup(channel, "sip_from_uri", SWITCH_TRUE
, -1));

if (!switch_channel_get_variable_dup(channel, "sip_handle_full_from", SWITCH_FALSE, -1)) {
	switch_channel_set_variable(channel, "sip_handle_full_from", switch_channel_get_variable(channel, swap ? "sip_full_from" :"sip_full_to"))switch_channel_set_variable_var_check(channel, "sip_handle_full_from"
, switch_channel_get_variable_dup(channel, swap ? "sip_full_from"
 :"sip_full_to", SWITCH_TRUE, -1), SWITCH_TRUE);
}

if (!switch_channel_get_variable_dup(channel, "sip_handle_full_to", SWITCH_FALSE, -1)) {
	switch_channel_set_variable(channel, "sip_handle_full_to", switch_channel_get_variable(channel, swap ? "sip_full_to" : "sip_full_from"))switch_channel_set_variable_var_check(channel, "sip_handle_full_to"
, switch_channel_get_variable_dup(channel, swap ? "sip_full_to"
 : "sip_full_from", SWITCH_TRUE, -1), SWITCH_TRUE);
}
}

if (rr && !switch_channel_get_variable(channel, "sip_invite_route_uri")switch_channel_get_variable_dup(channel, "sip_invite_route_uri"
, SWITCH_TRUE, -1)) {
switch_channel_set_variable(channel, "sip_invite_route_uri", rr)switch_channel_set_variable_var_check(channel, "sip_invite_route_uri"
, rr, SWITCH_TRUE);
}

tech_pvt->dest_to = tech_pvt->dest;

sofia_glue_attach_private(session, profile, tech_pvt, NULL((void*)0));
switch_channel_set_name(tech_pvt->channel, switch_channel_get_variable(channel, "channel_name")switch_channel_get_variable_dup(channel, "channel_name", SWITCH_TRUE
, -1));


switch_channel_set_variable(channel, "sip_invite_call_id", switch_channel_get_variable(channel, "sip_call_id"))switch_channel_set_variable_var_check(channel, "sip_invite_call_id"
, switch_channel_get_variable_dup(channel, "sip_call_id", SWITCH_TRUE
, -1), SWITCH_TRUE);

if (switch_true(switch_channel_get_variable(channel, "sip_nat_detected")switch_channel_get_variable_dup(channel, "sip_nat_detected", SWITCH_TRUE
, -1))) {
switch_channel_set_variable_printf(channel, "sip_route_uri", "sip:%s@%s:%s",
								   switch_channel_get_variable(channel, "sip_req_user")switch_channel_get_variable_dup(channel, "sip_req_user", SWITCH_TRUE
, -1),
								   switch_channel_get_variable(channel, "sip_network_ip")switch_channel_get_variable_dup(channel, "sip_network_ip", SWITCH_TRUE
, -1), switch_channel_get_variable(channel, "sip_network_port")switch_channel_get_variable_dup(channel, "sip_network_port", SWITCH_TRUE
, -1)
								   );
}

if (session) {
const char *use_uuid;

if ((use_uuid = switch_channel_get_variable(channel, "origination_uuid")switch_channel_get_variable_dup(channel, "origination_uuid", SWITCH_TRUE
, -1))) {
	if (switch_core_session_set_uuid(session, use_uuid) == SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 2358, (const char*)(session), SWITCH_LOG_DEBUG, "%s set UUID=%s\n", switch_channel_get_name(channel),
						  use_uuid);
	} else {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "sofia_glue.c", (const char *)__func__
, 2361, (const char*)(session), SWITCH_LOG_CRIT, "%s set UUID=%s FAILED\n",
						  switch_channel_get_name(channel), use_uuid);
	}
}
}

r++;

sofia_glue_release_profile(profile)sofia_glue_release_profile__("sofia_glue.c", (const char *)__func__
, 2369, profile);


return r;

2374}



2378int sofia_glue_recover(switch_bool_t flush)
2379{
sofia_profile_t *profile;
int r = 0;
switch_console_callback_match_t *matches;


if (list_profiles_full(NULL((void*)0), NULL((void*)0), &matches, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
switch_console_callback_match_node_t *m;
for (m = matches->head; m; m = m->next) {
	if ((profile = sofia_glue_find_profile(m->val)sofia_glue_find_profile__("sofia_glue.c", (const char *)__func__
, 2388, m->val))) {
		r += sofia_glue_profile_recover(profile, flush);
		sofia_glue_release_profile(profile)sofia_glue_release_profile__("sofia_glue.c", (const char *)__func__
, 2390, profile);
	}
}
switch_console_free_matches(&matches);
}
return r;
2396}

2398int sofia_glue_profile_recover(sofia_profile_t *profile, switch_bool_t flush)
2399{
int r = 0;

if (profile) {
sofia_clear_pflag_locked(profile, PFLAG_STANDBY)switch_mutex_lock(profile->flag_mutex); (profile)->pflags
[PFLAG_STANDBY] = 0; switch_mutex_unlock(profile->flag_mutex
);;

if (flush) {
	switch_core_recovery_flush(SOFIA_RECOVER"sofia", profile->name);
} else {
	r = switch_core_recovery_recover(SOFIA_RECOVER"sofia", profile->name);
}
}

return r;
2413}


2416int sofia_glue_init_sql(sofia_profile_t *profile)
2417{
char *test_sql = NULL((void*)0);

char reg_sql[] =
"CREATE TABLE sip_registrations (\n"
"   call_id          VARCHAR(255),\n"
"   sip_user         VARCHAR(255),\n"
"   sip_host         VARCHAR(255),\n"
"   presence_hosts   VARCHAR(255),\n"
"   contact          VARCHAR(1024),\n"
"   status           VARCHAR(255),\n"
"   ping_status      VARCHAR(255),\n"
"   ping_count       INTEGER,\n"
"   ping_time        BIGINT,\n"
"   force_ping       INTEGER,\n"
"   rpid             VARCHAR(255),\n"
"   expires          BIGINT,\n"
"   ping_expires     INTEGER not null default 0,\n"
"   user_agent       VARCHAR(255),\n"
"   server_user      VARCHAR(255),\n"
"   server_host      VARCHAR(255),\n"
"   profile_name     VARCHAR(255),\n"
"   hostname         VARCHAR(255),\n"
"   network_ip       VARCHAR(255),\n"
"   network_port     VARCHAR(6),\n"
"   sip_username     VARCHAR(255),\n"
"   sip_realm        VARCHAR(255),\n"
"   mwi_user         VARCHAR(255),\n"
"   mwi_host         VARCHAR(255),\n"
"   orig_server_host VARCHAR(255),\n"
"   orig_hostname    VARCHAR(255),\n"
"   sub_host         VARCHAR(255)\n"
");\n";

char pres_sql[] =
"CREATE TABLE sip_presence (\n"
"   sip_user        VARCHAR(255),\n"
"   sip_host        VARCHAR(255),\n"
"   status          VARCHAR(255),\n"
"   rpid            VARCHAR(255),\n"
"   expires         BIGINT,\n"
"   user_agent      VARCHAR(255),\n"
"   profile_name    VARCHAR(255),\n"
"   hostname        VARCHAR(255),\n"
"   network_ip      VARCHAR(255),\n"
"   network_port    VARCHAR(6),\n"
"   open_closed     VARCHAR(255)\n"
");\n";

char dialog_sql[] =
"CREATE TABLE sip_dialogs (\n"
"   call_id         VARCHAR(255),\n"
"   uuid            VARCHAR(255),\n"
"   sip_to_user     VARCHAR(255),\n"
"   sip_to_host     VARCHAR(255),\n"
"   sip_from_user   VARCHAR(255),\n"
"   sip_from_host   VARCHAR(255),\n"
"   contact_user    VARCHAR(255),\n"
"   contact_host    VARCHAR(255),\n"
"   state           VARCHAR(255),\n"
"   direction       VARCHAR(255),\n"
"   user_agent      VARCHAR(255),\n"
"   profile_name    VARCHAR(255),\n"
"   hostname        VARCHAR(255),\n"
"   contact         VARCHAR(255),\n"
"   presence_id     VARCHAR(255),\n"
"   presence_data   VARCHAR(255),\n"
"   call_info       VARCHAR(255),\n"
"   call_info_state VARCHAR(255) default '',\n"
"   expires         BIGINT default 0,\n"
"   status          VARCHAR(255),\n"
"   rpid            VARCHAR(255),\n"
"   sip_to_tag      VARCHAR(255),\n"
"   sip_from_tag    VARCHAR(255),\n"
"   rcd             INTEGER not null default 0\n"
");\n";

char sub_sql[] =
"CREATE TABLE sip_subscriptions (\n"
"   proto           VARCHAR(255),\n"
"   sip_user        VARCHAR(255),\n"
"   sip_host        VARCHAR(255),\n"
"   sub_to_user     VARCHAR(255),\n"
"   sub_to_host     VARCHAR(255),\n"
"   presence_hosts  VARCHAR(255),\n"
"   event           VARCHAR(255),\n"
"   contact         VARCHAR(1024),\n"
"   call_id         VARCHAR(255),\n"
"   full_from       VARCHAR(255),\n"
"   full_via        VARCHAR(255),\n"
"   expires         BIGINT,\n"
"   user_agent      VARCHAR(255),\n"
"   accept          VARCHAR(255),\n"
"   profile_name    VARCHAR(255),\n"
"   hostname        VARCHAR(255),\n"
"   network_port    VARCHAR(6),\n"
"   network_ip      VARCHAR(255),\n"
"   version         INTEGER DEFAULT 0 NOT NULL,\n"
"   orig_proto      VARCHAR(255),\n"
"   full_to         VARCHAR(255)\n"
");\n";

char auth_sql[] =
"CREATE TABLE sip_authentication (\n"
"   nonce           VARCHAR(255),\n"
"   expires         BIGINT,"
"   profile_name    VARCHAR(255),\n"
"   hostname        VARCHAR(255),\n"
"   last_nc         INTEGER\n"
");\n";

/* should we move this glue to sofia_sla or keep it here where all db init happens? XXX MTK */
char shared_appearance_sql[] =
"CREATE TABLE sip_shared_appearance_subscriptions (\n"
"   subscriber        VARCHAR(255),\n"
"   call_id           VARCHAR(255),\n"
"   aor               VARCHAR(255),\n"
"   profile_name      VARCHAR(255),\n"
"   hostname          VARCHAR(255),\n"
"   contact_str       VARCHAR(255),\n"
"   network_ip        VARCHAR(255)\n"
");\n";

char shared_appearance_dialogs_sql[] =
"CREATE TABLE sip_shared_appearance_dialogs (\n"
"   profile_name      VARCHAR(255),\n"
"   hostname          VARCHAR(255),\n"
"   contact_str       VARCHAR(255),\n"
"   call_id           VARCHAR(255),\n"
"   network_ip        VARCHAR(255),\n"
"   expires           BIGINT\n"
");\n";


int x;
char *indexes[] = {
"create index sr_call_id on sip_registrations (call_id)",
"create index sr_sip_user on sip_registrations (sip_user)",
"create index sr_sip_host on sip_registrations (sip_host)",
"create index sr_sub_host on sip_registrations (sub_host)",
"create index sr_mwi_user on sip_registrations (mwi_user)",
"create index sr_mwi_host on sip_registrations (mwi_host)",
"create index sr_profile_name on sip_registrations (profile_name)",
"create index sr_presence_hosts on sip_registrations (presence_hosts)",
"create index sr_contact on sip_registrations (contact)",
"create index sr_expires on sip_registrations (expires)",
"create index sr_ping_expires on sip_registrations (ping_expires)",
"create index sr_hostname on sip_registrations (hostname)",
"create index sr_status on sip_registrations (status)",
"create index sr_ping_status on sip_registrations (ping_status)",
"create index sr_network_ip on sip_registrations (network_ip)",
"create index sr_network_port on sip_registrations (network_port)",
"create index sr_sip_username on sip_registrations (sip_username)",
"create index sr_sip_realm on sip_registrations (sip_realm)",
"create index sr_orig_server_host on sip_registrations (orig_server_host)",
"create index sr_orig_hostname on sip_registrations (orig_hostname)",
"create index ss_call_id on sip_subscriptions (call_id)",
"create index ss_multi on sip_subscriptions (call_id, profile_name, hostname)",
"create index ss_hostname on sip_subscriptions (hostname)",
"create index ss_network_ip on sip_subscriptions (network_ip)",
"create index ss_sip_user on sip_subscriptions (sip_user)",
"create index ss_sip_host on sip_subscriptions (sip_host)",
"create index ss_presence_hosts on sip_subscriptions (presence_hosts)",
"create index ss_event on sip_subscriptions (event)",
"create index ss_proto on sip_subscriptions (proto)",
"create index ss_sub_to_user on sip_subscriptions (sub_to_user)",
"create index ss_sub_to_host on sip_subscriptions (sub_to_host)",
"create index ss_expires on sip_subscriptions (expires)",
"create index ss_orig_proto on sip_subscriptions (orig_proto)",
"create index ss_network_port on sip_subscriptions (network_port)",
"create index ss_profile_name on sip_subscriptions (profile_name)",
"create index ss_version on sip_subscriptions (version)",
"create index ss_full_from on sip_subscriptions (full_from)",
"create index ss_contact on sip_subscriptions (contact)",
"create index sd_uuid on sip_dialogs (uuid)",
"create index sd_hostname on sip_dialogs (hostname)",
"create index sd_presence_data on sip_dialogs (presence_data)",
"create index sd_call_info on sip_dialogs (call_info)",
"create index sd_call_info_state on sip_dialogs (call_info_state)",
"create index sd_expires on sip_dialogs (expires)",
"create index sd_rcd on sip_dialogs (rcd)",
"create index sd_sip_to_tag on sip_dialogs (sip_to_tag)",
"create index sd_sip_from_user on sip_dialogs (sip_from_user)",
"create index sd_sip_from_host on sip_dialogs (sip_from_host)",
"create index sd_sip_to_host on sip_dialogs (sip_to_host)",
"create index sd_presence_id on sip_dialogs (presence_id)",
"create index sd_call_id on sip_dialogs (call_id)",
"create index sd_sip_from_tag on sip_dialogs (sip_from_tag)",
"create index sp_hostname on sip_presence (hostname)",
"create index sp_open_closed on sip_presence (open_closed)",
"create index sp_sip_user on sip_presence (sip_user)",
"create index sp_sip_host on sip_presence (sip_host)",
"create index sp_profile_name on sip_presence (profile_name)",
"create index sp_expires on sip_presence (expires)",
"create index sa_nonce on sip_authentication (nonce)",
"create index sa_hostname on sip_authentication (hostname)",
"create index sa_expires on sip_authentication (expires)",
"create index sa_last_nc on sip_authentication (last_nc)",
"create index ssa_hostname on sip_shared_appearance_subscriptions (hostname)",
"create index ssa_network_ip on sip_shared_appearance_subscriptions (network_ip)",
"create index ssa_subscriber on sip_shared_appearance_subscriptions (subscriber)",
"create index ssa_profile_name on sip_shared_appearance_subscriptions (profile_name)",
"create index ssa_aor on sip_shared_appearance_subscriptions (aor)",
"create index ssd_profile_name on sip_shared_appearance_dialogs (profile_name)",
"create index ssd_hostname on sip_shared_appearance_dialogs (hostname)",
"create index ssd_contact_str on sip_shared_appearance_dialogs (contact_str)",
"create index ssd_call_id on sip_shared_appearance_dialogs (call_id)",
"create index ssd_expires on sip_shared_appearance_dialogs (expires)",
NULL((void*)0)
};

switch_cache_db_handle_t *dbh = sofia_glue_get_db_handle(profile)_sofia_glue_get_db_handle(profile, "sofia_glue.c", (const char
 *)__func__, 2628);
char *test2;
char *err;

if (!dbh) {
return 0;
}


test_sql = switch_mprintf("delete from sip_registrations where sub_host is null "
					  "and hostname='%q' "
					  "and network_ip like '%%' and network_port like '%%' and sip_username "
					  "like '%%' and mwi_user  like '%%' and mwi_host like '%%' "
					  "and orig_server_host like '%%' and orig_hostname like '%%'", mod_sofia_globals.hostname);


switch_cache_db_test_reactive(dbh, test_sql, "drop table sip_registrations", reg_sql);

switch_cache_db_test_reactive(dbh, "select ping_count from sip_registrations", NULL((void*)0), "alter table sip_registrations add column ping_count INTEGER default 0");
switch_cache_db_test_reactive(dbh, "select ping_status from sip_registrations", NULL((void*)0), "alter table sip_registrations add column ping_status VARCHAR(255) default 'Reachable'");
switch_cache_db_test_reactive(dbh, "select ping_expires from sip_registrations", NULL((void*)0), "alter table sip_registrations add column ping_expires INTEGER not null default 0");
switch_cache_db_test_reactive(dbh, "select ping_time from sip_registrations", NULL((void*)0), "alter table sip_registrations add column ping_time BIGINT not null default 0");
switch_cache_db_test_reactive(dbh, "select force_ping from sip_registrations", NULL((void*)0), "alter table sip_registrations add column force_ping INTEGER not null default 0");

test2 = switch_mprintf("%s;%s", test_sql, test_sql);

if (switch_cache_db_execute_sql(dbh, test2, &err) != SWITCH_STATUS_SUCCESS) {

if (switch_stristr("read-only", err)) {
	free(err);
} else {
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2659, ((void*)0), SWITCH_LOG_CRIT, "GREAT SCOTT!!! Cannot execute batched statements! [%s]\n"
					  "If you are using mysql, make sure you are using MYODBC 3.51.18 or higher and enable FLAG_MULTI_STATEMENTS\n", err);

	switch_cache_db_release_db_handle(&dbh);
	free(test2);
	free(test_sql);
	free(err);
	return 0;
}
}

free(test2);


free(test_sql);

test_sql = switch_mprintf("delete from sip_subscriptions where hostname='%q' and full_to='XXX'", mod_sofia_globals.hostname);

switch_cache_db_test_reactive(dbh, test_sql, "DROP TABLE sip_subscriptions", sub_sql);

free(test_sql);
test_sql = switch_mprintf("delete from sip_dialogs where hostname='%q' and (expires <> -9999 or rpid='' or sip_from_tag='' or rcd > 0)",
					  mod_sofia_globals.hostname);


switch_cache_db_test_reactive(dbh, test_sql, "DROP TABLE sip_dialogs", dialog_sql);

free(test_sql);
test_sql = switch_mprintf("delete from sip_presence where hostname='%q' or open_closed=''", mod_sofia_globals.hostname);

switch_cache_db_test_reactive(dbh, test_sql, "DROP TABLE sip_presence", pres_sql);

free(test_sql);
test_sql = switch_mprintf("delete from sip_authentication where hostname='%q' or last_nc >= 0", mod_sofia_globals.hostname);

switch_cache_db_test_reactive(dbh, test_sql, "DROP TABLE sip_authentication", auth_sql);

free(test_sql);
test_sql = switch_mprintf("delete from sip_shared_appearance_subscriptions where contact_str='' or hostname='%q' and network_ip like '%%'",
					  mod_sofia_globals.hostname);

switch_cache_db_test_reactive(dbh, test_sql, "DROP TABLE sip_shared_appearance_subscriptions", shared_appearance_sql);

free(test_sql);
test_sql = switch_mprintf("delete from sip_shared_appearance_dialogs where contact_str='' or hostname='%q' and network_ip like '%%'",
					  mod_sofia_globals.hostname);

switch_cache_db_test_reactive(dbh, test_sql, "DROP TABLE sip_shared_appearance_dialogs", shared_appearance_dialogs_sql);

free(test_sql);

for (x = 0; indexes[x]; x++) {
switch_cache_db_create_schema(dbh, indexes[x], NULL((void*)0));
}

switch_cache_db_release_db_handle(&dbh);

return 1;

2718}

2720void sofia_glue_execute_sql(sofia_profile_t *profile, char **sqlp, switch_bool_t sql_already_dynamic)
2721{
char *sql;

switch_assert(sqlp && *sqlp)((sqlp && *sqlp) ? (void) (0) : __assert_fail ("sqlp && *sqlp"
, "sofia_glue.c", 2724, __extension__ __PRETTY_FUNCTION__));
sql = *sqlp;

switch_sql_queue_manager_push(profile->qm, sql, 1, !sql_already_dynamic);

if (sql_already_dynamic) {
*sqlp = NULL((void*)0);
}
2732}


2735void sofia_glue_execute_sql_now(sofia_profile_t *profile, char **sqlp, switch_bool_t sql_already_dynamic)
2736{
char *sql;

switch_assert(sqlp && *sqlp)((sqlp && *sqlp) ? (void) (0) : __assert_fail ("sqlp && *sqlp"
, "sofia_glue.c", 2739, __extension__ __PRETTY_FUNCTION__));
sql = *sqlp;

switch_mutex_lock(profile->dbh_mutex);
switch_sql_queue_manager_push_confirm(profile->qm, sql, 0, !sql_already_dynamic);
switch_mutex_unlock(profile->dbh_mutex);

if (sql_already_dynamic) {
*sqlp = NULL((void*)0);
}
2749}

2751void sofia_glue_execute_sql_soon(sofia_profile_t *profile, char **sqlp, switch_bool_t sql_already_dynamic)
2752{
char *sql;

switch_assert(sqlp && *sqlp)((sqlp && *sqlp) ? (void) (0) : __assert_fail ("sqlp && *sqlp"
, "sofia_glue.c", 2755, __extension__ __PRETTY_FUNCTION__));
sql = *sqlp;

switch_sql_queue_manager_push(profile->qm, sql, 0, !sql_already_dynamic);

if (sql_already_dynamic) {
*sqlp = NULL((void*)0);
}
2763}


2766switch_cache_db_handle_t *_sofia_glue_get_db_handle(sofia_profile_t *profile, const char *file, const char *func, int line)
2767{
switch_cache_db_handle_t *dbh = NULL((void*)0);
char *dsn;

if (!zstr(profile->odbc_dsn)_zstr(profile->odbc_dsn)) {
dsn = profile->odbc_dsn;
} else {
dsn = profile->dbname;
}

if (_switch_cache_db_get_db_handle_dsn(&dbh, dsn, file, func, line) != SWITCH_STATUS_SUCCESS) {
dbh = NULL((void*)0);
}

return dbh;
2782}

2784void sofia_glue_actually_execute_sql_trans(sofia_profile_t *profile, char *sql, switch_mutex_t *mutex)
2785{
switch_cache_db_handle_t *dbh = NULL((void*)0);

if (mutex) {
switch_mutex_lock(mutex);
}


if (!(dbh = sofia_glue_get_db_handle(profile)_sofia_glue_get_db_handle(profile, "sofia_glue.c", (const char
 *)__func__, 2793))) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2794, ((void*)0), SWITCH_LOG_ERROR, "Error Opening DB\n");

goto end;
}

switch_cache_db_persistant_execute_trans_full(dbh, sql, 1,
										  profile->pre_trans_execute,
										  profile->post_trans_execute,
										  profile->inner_pre_trans_execute,
										  profile->inner_post_trans_execute
										  );

switch_cache_db_release_db_handle(&dbh);

end:

if (mutex) {
switch_mutex_unlock(mutex);
}
2813}

2815void sofia_glue_actually_execute_sql(sofia_profile_t *profile, char *sql, switch_mutex_t *mutex)
2816{
switch_cache_db_handle_t *dbh = NULL((void*)0);
char *err = NULL((void*)0);

if (mutex) {
switch_mutex_lock(mutex);
}

if (!(dbh = sofia_glue_get_db_handle(profile)_sofia_glue_get_db_handle(profile, "sofia_glue.c", (const char
 *)__func__, 2824))) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2825, ((void*)0), SWITCH_LOG_ERROR, "Error Opening DB\n");

if (mutex) {
	switch_mutex_unlock(mutex);
}

return;
}

switch_cache_db_execute_sql(dbh, sql, &err);

if (mutex) {
switch_mutex_unlock(mutex);
}

if (err) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2841, ((void*)0), SWITCH_LOG_ERROR, "SQL ERR: [%s]\n%s\n", err, sql);
free(err);
}

switch_cache_db_release_db_handle(&dbh);
2846}

2848switch_bool_t sofia_glue_execute_sql_callback(sofia_profile_t *profile,
									  switch_mutex_t *mutex, char *sql, switch_core_db_callback_func_t callback, void *pdata)
2850{
switch_bool_t ret = SWITCH_FALSE;
char *errmsg = NULL((void*)0);
switch_cache_db_handle_t *dbh = NULL((void*)0);

if (mutex) {
switch_mutex_lock(mutex);
}

if (!(dbh = sofia_glue_get_db_handle(profile)_sofia_glue_get_db_handle(profile, "sofia_glue.c", (const char
 *)__func__, 2859))) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2860, ((void*)0), SWITCH_LOG_ERROR, "Error Opening DB\n");

if (mutex) {
	switch_mutex_unlock(mutex);
}

return ret;
}

switch_cache_db_execute_sql_callback(dbh, sql, callback, pdata, &errmsg);

if (mutex) {
switch_mutex_unlock(mutex);
}

if (errmsg) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2876, ((void*)0), SWITCH_LOG_ERROR, "SQL ERR: [%s] %s\n", sql, errmsg);
free(errmsg);
}

switch_cache_db_release_db_handle(&dbh);

return ret;
2883}

2885char *sofia_glue_execute_sql2str(sofia_profile_t *profile, switch_mutex_t *mutex, char *sql, char *resbuf, size_t len)
2886{
char *ret = NULL((void*)0);
char *err = NULL((void*)0);
switch_cache_db_handle_t *dbh = NULL((void*)0);

if (mutex) {
switch_mutex_lock(mutex);
}

if (!(dbh = sofia_glue_get_db_handle(profile)_sofia_glue_get_db_handle(profile, "sofia_glue.c", (const char
 *)__func__, 2895))) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2896, ((void*)0), SWITCH_LOG_ERROR, "Error Opening DB\n");

if (mutex) {
	switch_mutex_unlock(mutex);
}

return NULL((void*)0);
}

ret = switch_cache_db_execute_sql2str(dbh, sql, resbuf, len, &err);

if (mutex) {
switch_mutex_unlock(mutex);
}

if (err) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 2912, ((void*)0), SWITCH_LOG_ERROR, "SQL ERR: [%s]\n%s\n", err, sql);
free(err);
}

switch_cache_db_release_db_handle(&dbh);

return ret;
2919}

2921char *sofia_glue_get_register_host(const char *uri)
2922{
char *register_host = NULL((void*)0);
const char *s;
char *p = NULL((void*)0);

if (zstr(uri)_zstr(uri)) {
return NULL((void*)0);
}

if ((s = switch_stristr("sip:", uri))) {
s += 4;
} else if ((s = switch_stristr("sips:", uri))) {
s += 5;
}

if (!s) {
return NULL((void*)0);
}

register_host = strdup(s);

switch_assert(register_host)((register_host) ? (void) (0) : __assert_fail ("register_host"
, "sofia_glue.c", 2943, __extension__ __PRETTY_FUNCTION__));

/* remove port for register_host for testing nat acl take into account
  ipv6 addresses which are required to have brackets around the addr
*/

if ((p = strchr(register_host, ']'))) {
if (*(p + 1) == ':') {
	*(p + 1) = '\0';
}
} else {
if ((p = strrchr(register_host, ':'))) {
	*p = '\0';
}
}

/* register_proxy should always start with "sip:" or "sips:" */
assert(register_host)((register_host) ? (void) (0) : __assert_fail ("register_host"
, "sofia_glue.c", 2960, __extension__ __PRETTY_FUNCTION__));

return register_host;
2963}

2965const char *sofia_glue_strip_proto(const char *uri)
2966{
char *p;

if ((p = strchr(uri, ':'))) {
return p + 1;
}

return uri;
2974}

2976sofia_cid_type_t sofia_cid_name2type(const char *name)
2977{
if (!strcasecmp(name, "rpid")) {
return CID_TYPE_RPID;
}

if (!strcasecmp(name, "pid")) {
return CID_TYPE_PID;
}

return CID_TYPE_NONE;

2988}

2990/* all the values of the structure are initialized to NULL  */
2991/* in case of failure the function returns NULL */
2992/* sofia_destination->route can be NULL */
2993sofia_destination_t *sofia_glue_get_destination(char *data)
2994{
sofia_destination_t *dst = NULL((void*)0);
char *to = NULL((void*)0);
char *contact = NULL((void*)0);
char *route = NULL((void*)0);
char *route_uri = NULL((void*)0);
char *eoc = NULL((void*)0);
char *p = NULL((void*)0);

if (zstr(data)_zstr(data)) {
return NULL((void*)0);
}

if (!(dst = (sofia_destination_t *) malloc(sizeof(sofia_destination_t)))) {
return NULL((void*)0);
}

/* return a copy of what is in the buffer between the first < and > */
if (!(contact = sofia_glue_get_url_from_contact(data, 1))) {
goto mem_fail;
}

if ((eoc = strstr(contact, ";fs_path="))) {
*eoc = '\0';

if (!(route = strdup(eoc + 9))) {
	goto mem_fail;
}

for (p = route; p && *p; p++) {
	if (*p == '>' || *p == ';') {
		*p = '\0';
		break;
	}
}

switch_url_decode(route);

if (!(route_uri = strdup(route))) {
	goto mem_fail;
}
if ((p = strchr(route_uri, ','))) {
	do {
		*p = '\0';
	} while ((--p > route_uri) && *p == ' ');
}
}

if (!(to = strdup(data))) {
goto mem_fail;
}

if ((eoc = strstr(to, ";fs_path="))) {
*eoc++ = '>';
*eoc = '\0';
}

if ((p = strstr(contact, ";fs_"))) {
*p = '\0';
}

dst->contact = contact;
dst->to = to;
dst->route = route;
dst->route_uri = route_uri;
return dst;

mem_fail:
switch_safe_free(contact)if (contact) {free(contact);contact=((void*)0);};
switch_safe_free(to)if (to) {free(to);to=((void*)0);};
switch_safe_free(route)if (route) {free(route);route=((void*)0);};
switch_safe_free(route_uri)if (route_uri) {free(route_uri);route_uri=((void*)0);};
switch_safe_free(dst)if (dst) {free(dst);dst=((void*)0);};
return NULL((void*)0);
3068}

3070void sofia_glue_free_destination(sofia_destination_t *dst)
3071{
if (dst) {
switch_safe_free(dst->contact)if (dst->contact) {free(dst->contact);dst->contact=(
(void*)0);};
switch_safe_free(dst->route)if (dst->route) {free(dst->route);dst->route=((void*
)0);};
switch_safe_free(dst->route_uri)if (dst->route_uri) {free(dst->route_uri);dst->route_uri
=((void*)0);};
switch_safe_free(dst->to)if (dst->to) {free(dst->to);dst->to=((void*)0);};
switch_safe_free(dst)if (dst) {free(dst);dst=((void*)0);};
}
3079}

3081switch_status_t sofia_glue_send_notify(sofia_profile_t *profile, const char *user, const char *host, const char *event, const char *contenttype,
							   const char *body, const char *o_contact, const char *network_ip, const char *call_id)
3083{
char *id = NULL((void*)0);
nua_handle_t *nh;
sofia_destination_t *dst = NULL((void*)0);
char *contact_str, *contact, *user_via = NULL((void*)0);
char *route_uri = NULL((void*)0), *p;
char *ptr;

contact = sofia_glue_get_url_from_contact((char *) o_contact, 1);

if ((p = strstr(contact, ";fs_"))) {
*p = '\0';
}

if (!zstr(network_ip)_zstr(network_ip) && sofia_glue_check_nat(profile, network_ip)) {
id = switch_mprintf("sip:%s@%s", user, profile->extsipip);
switch_assert(id)((id) ? (void) (0) : __assert_fail ("id", "sofia_glue.c", 3099
, __extension__ __PRETTY_FUNCTION__));

if ((ptr = sofia_glue_find_parameter(o_contact, "transport="))) {
	sofia_transport_t transport = sofia_glue_str2transport( ptr + 10 );

	switch (transport) {
	case SOFIA_TRANSPORT_TCP:
		contact_str = profile->tcp_public_contact;
		break;
	case SOFIA_TRANSPORT_TCP_TLS:
		contact_str = sofia_test_pflag(profile, PFLAG_TLS)((profile)->pflags[PFLAG_TLS] ? 1 : 0) ?
			profile->tls_public_contact : profile->tcp_public_contact;
		break;
	default:
		contact_str = profile->public_url;
		break;
	}
	user_via = sofia_glue_create_external_via(NULL((void*)0), profile, transport);
} else {
	user_via = sofia_glue_create_external_via(NULL((void*)0), profile, SOFIA_TRANSPORT_UDP);
	contact_str = profile->public_url;
}
} else {
id = switch_mprintf("sip:%s@%s", user, host);
switch_assert(id)((id) ? (void) (0) : __assert_fail ("id", "sofia_glue.c", 3123
, __extension__ __PRETTY_FUNCTION__));

if ((ptr = sofia_glue_find_parameter(o_contact, "transport="))) {
	sofia_transport_t transport = sofia_glue_str2transport( ptr + 10 );

	switch (transport) {
	case SOFIA_TRANSPORT_TCP:
		contact_str = profile->tcp_contact;
		break;
	case SOFIA_TRANSPORT_TCP_TLS:
		contact_str = sofia_test_pflag(profile, PFLAG_TLS)((profile)->pflags[PFLAG_TLS] ? 1 : 0) ?
			profile->tls_contact : profile->tcp_contact;
		break;
	default:
		contact_str = profile->url;
		break;
	}
} else {
	contact_str = profile->url;
}
}

dst = sofia_glue_get_destination((char *) o_contact);
switch_assert(dst)((dst) ? (void) (0) : __assert_fail ("dst", "sofia_glue.c", 3146
, __extension__ __PRETTY_FUNCTION__));

if (dst->route_uri) {
route_uri = sofia_glue_strip_uri(dst->route_uri);
}

nh = nua_handle(profile->nua, NULL((void*)0), NUTAG_URL(contact)nutag_url, urltag_url_v(contact), SIPTAG_FROM_STR(id)siptag_from_str, tag_str_v(id), SIPTAG_TO_STR(id)siptag_to_str, tag_str_v(id), SIPTAG_CONTACT_STR(contact_str)siptag_contact_str, tag_str_v(contact_str), TAG_END()(tag_type_t)0, (tag_value_t)0);
nua_handle_bind(nh, &mod_sofia_globals.destroy_private);

nua_notify(nh,
	   NUTAG_NEWSUB(1)nutag_newsub, tag_bool_v(1),
	   TAG_IF(dst->route_uri, NUTAG_PROXY(route_uri))!(dst->route_uri) ? tag_skip : ntatag_default_proxy, urltag_url_v
((route_uri)), TAG_IF(dst->route, SIPTAG_ROUTE_STR(dst->route))!(dst->route) ? tag_skip : siptag_route_str, tag_str_v(dst
->route),
	   TAG_IF(user_via, SIPTAG_VIA_STR(user_via))!(user_via) ? tag_skip : siptag_via_str, tag_str_v(user_via),
	   SIPTAG_SUBSCRIPTION_STATE_STR("terminated;reason=noresource")siptag_subscription_state_str, tag_str_v("terminated;reason=noresource"
),
	   TAG_IF(event, SIPTAG_EVENT_STR(event))!(event) ? tag_skip : siptag_event_str, tag_str_v(event),
	   TAG_IF(call_id, SIPTAG_CALL_ID_STR(call_id))!(call_id) ? tag_skip : siptag_call_id_str, tag_str_v(call_id
),
	   TAG_IF(contenttype, SIPTAG_CONTENT_TYPE_STR(contenttype))!(contenttype) ? tag_skip : siptag_content_type_str, tag_str_v
(contenttype), TAG_IF(body, SIPTAG_PAYLOAD_STR(body))!(body) ? tag_skip : siptag_payload_str, tag_str_v(body), TAG_END()(tag_type_t)0, (tag_value_t)0);

switch_safe_free(contact)if (contact) {free(contact);contact=((void*)0);};
switch_safe_free(route_uri)if (route_uri) {free(route_uri);route_uri=((void*)0);};
switch_safe_free(id)if (id) {free(id);id=((void*)0);};
sofia_glue_free_destination(dst);
switch_safe_free(user_via)if (user_via) {free(user_via);user_via=((void*)0);};

return SWITCH_STATUS_SUCCESS;
3171}


3174int sofia_glue_tech_simplify(private_object_t *tech_pvt)
3175{
const char *uuid, *network_addr_a = NULL((void*)0), *network_addr_b = NULL((void*)0), *simplify, *simplify_other_channel;
switch_channel_t *other_channel = NULL((void*)0), *inbound_channel = NULL((void*)0);
switch_core_session_t *other_session = NULL((void*)0), *inbound_session = NULL((void*)0);
uint8_t did_simplify = 0;
int r = 0;

if (!switch_channel_test_flag(tech_pvt->channel, CF_ANSWERED) || switch_channel_test_flag(tech_pvt->channel, CF_SIMPLIFY)) {
goto end;
}

if (switch_channel_test_flag(tech_pvt->channel, CF_BRIDGED) &&
(uuid = switch_channel_get_partner_uuid(tech_pvt->channel)) && (other_session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "sofia_glue.c", (const
 char *)__func__, 3187))) {

other_channel = switch_core_session_get_channel(other_session);

if (switch_channel_test_flag(other_channel, CF_ANSWERED)) {	/* Check if the other channel is answered */
	simplify = switch_channel_get_variable(tech_pvt->channel, "sip_auto_simplify")switch_channel_get_variable_dup(tech_pvt->channel, "sip_auto_simplify"
, SWITCH_TRUE, -1);
	simplify_other_channel = switch_channel_get_variable(other_channel, "sip_auto_simplify")switch_channel_get_variable_dup(other_channel, "sip_auto_simplify"
, SWITCH_TRUE, -1);

	r = 1;

	if (switch_true(simplify) && !switch_channel_test_flag(tech_pvt->channel, CF_BRIDGE_ORIGINATOR)) {
		network_addr_a = switch_channel_get_variable(tech_pvt->channel, "network_addr")switch_channel_get_variable_dup(tech_pvt->channel, "network_addr"
, SWITCH_TRUE, -1);
		network_addr_b = switch_channel_get_variable(other_channel, "network_addr")switch_channel_get_variable_dup(other_channel, "network_addr"
, SWITCH_TRUE, -1);
		inbound_session = other_session;
		inbound_channel = other_channel;
	} else if (switch_true(simplify_other_channel) && !switch_channel_test_flag(other_channel, CF_BRIDGE_ORIGINATOR)) {
		network_addr_a = switch_channel_get_variable(other_channel, "network_addr")switch_channel_get_variable_dup(other_channel, "network_addr"
, SWITCH_TRUE, -1);
		network_addr_b = switch_channel_get_variable(tech_pvt->channel, "network_addr")switch_channel_get_variable_dup(tech_pvt->channel, "network_addr"
, SWITCH_TRUE, -1);
		inbound_session = tech_pvt->session;
		inbound_channel = tech_pvt->channel;
	}

	if (inbound_channel && inbound_session && !zstr(network_addr_a)_zstr(network_addr_a) && !zstr(network_addr_b)_zstr(network_addr_b) && !strcmp(network_addr_a, network_addr_b)) {
		if (strcmp(network_addr_a, switch_str_nil(tech_pvt->profile->sipip)(tech_pvt->profile->sipip ? tech_pvt->profile->sipip
 : ""))
			&& strcmp(network_addr_a, switch_str_nil(tech_pvt->profile->extsipip)(tech_pvt->profile->extsipip ? tech_pvt->profile->
extsipip : ""))) {

			switch_core_session_message_t *msg;

			switch_log_printf(SWITCH_CHANNEL_ID_LOG, __FILE__"sofia_glue.c", __SWITCH_FUNC__(const char *)__func__, __LINE__3215, switch_channel_get_uuid(inbound_channel),
							  SWITCH_LOG_NOTICE, "Will simplify channel [%s]\n", switch_channel_get_name(inbound_channel));

			msg = switch_core_session_alloc(inbound_session, sizeof(*msg))switch_core_perform_session_alloc(inbound_session, sizeof(*msg
), "sofia_glue.c", (const char *)__func__, 3218);
			MESSAGE_STAMP_FFL(msg)msg->_file = "sofia_glue.c"; msg->_func = (const char *
)__func__; msg->_line = 3219;
			msg->message_id = SWITCH_MESSAGE_INDICATE_SIMPLIFY;
			msg->from = __FILE__"sofia_glue.c";
			switch_core_session_receive_message(inbound_session, msg)switch_core_session_perform_receive_message(inbound_session, msg
, "sofia_glue.c", (const char *)__func__, 3222);

			did_simplify = 1;

			switch_core_recovery_track(inbound_session);

			switch_channel_set_flag(inbound_channel, CF_SIMPLIFY)switch_channel_set_flag_value(inbound_channel, CF_SIMPLIFY, 1
);

		}
	}

	if (!did_simplify && inbound_channel) {
		switch_log_printf(SWITCH_CHANNEL_ID_LOG, __FILE__"sofia_glue.c", __SWITCH_FUNC__(const char *)__func__, __LINE__3234, switch_channel_get_uuid(inbound_channel), SWITCH_LOG_NOTICE,
						  "Could not simplify channel [%s]\n", switch_channel_get_name(inbound_channel));
	}
}

switch_core_session_rwunlock(other_session);
}


end:

return r;
3246}

3248void sofia_glue_pause_jitterbuffer(switch_core_session_t *session, switch_bool_t on)
3249{
switch_core_session_message_t *msg;
msg = switch_core_session_alloc(session, sizeof(*msg))switch_core_perform_session_alloc(session, sizeof(*msg), "sofia_glue.c"
, (const char *)__func__, 3251);
MESSAGE_STAMP_FFL(msg)msg->_file = "sofia_glue.c"; msg->_func = (const char *
)__func__; msg->_line = 3252;
msg->message_id = SWITCH_MESSAGE_INDICATE_JITTER_BUFFER;
msg->string_arg = switch_core_session_strdup(session, on ? "pause" : "resume")switch_core_perform_session_strdup(session, on ? "pause" : "resume"
, "sofia_glue.c", (const char *)__func__, 3254);
msg->from = __FILE__"sofia_glue.c";

switch_core_session_queue_message(session, msg);
3258}


3261void sofia_glue_build_vid_refresh_message(switch_core_session_t *session, const char *pl)
3262{
switch_core_session_message_t *msg;
msg = switch_core_session_alloc(session, sizeof(*msg))switch_core_perform_session_alloc(session, sizeof(*msg), "sofia_glue.c"
, (const char *)__func__, 3264);
MESSAGE_STAMP_FFL(msg)msg->_file = "sofia_glue.c"; msg->_func = (const char *
)__func__; msg->_line = 3265;
msg->message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;
if (pl) {
msg->string_arg = switch_core_session_strdup(session, pl)switch_core_perform_session_strdup(session, pl, "sofia_glue.c"
, (const char *)__func__, 3268);
}
msg->from = __FILE__"sofia_glue.c";

switch_core_session_queue_message(session, msg);
3273}


3276char *sofia_glue_gen_contact_str(sofia_profile_t *profile, sip_t const *sip, nua_handle_t *nh, sofia_dispatch_event_t *de, sofia_nat_parse_t *np)
3277{
char *contact_str = NULL((void*)0);
const char *contact_host;//, *contact_user;
sip_contact_t const *contact;
char *port;
const char *display = "\"user\"";
char new_port[25] = "";
sofia_nat_parse_t lnp = { { 0 } };
const char *ipv6;
sip_from_t const *from;

if (!sip || !sip->sip_contact) {
return NULL((void*)0);
}

from = sip->sip_from;
contact = sip->sip_contact;

if (!np) {
np = &lnp;
}

sofia_glue_get_addr(de->data->e_msg, np->network_ip, sizeof(np->network_ip), &np->network_port);

if (sofia_glue_check_nat(profile, np->network_ip)) {
np->is_auto_nat = 1;
}

port = (char *) contact->m_url->url_port;
contact_host = sip->sip_contact->m_url->url_host;
//contact_user = sip->sip_contact->m_url->url_user;

display = contact->m_display;


if (zstr(display)_zstr(display)) {
if (from) {
	display = from->a_display;
	if (zstr(display)_zstr(display)) {
		display = "\"user\"";
	}
}
} else {
display = "\"user\"";
}

if (sofia_test_pflag(profile, PFLAG_AGGRESSIVE_NAT_DETECTION)((profile)->pflags[PFLAG_AGGRESSIVE_NAT_DETECTION] ? 1 : 0
)) {
if (sip->sip_via) {
	const char *v_port = sip->sip_via->v_port;
	const char *v_host = sip->sip_via->v_host;

	if (v_host && sip->sip_via->v_received) {
		np->is_nat = "via received";
	} else if (v_host && strcmp(np->network_ip, v_host)) {
		np->is_nat = "via host";
	} else if (v_port && atoi(v_port) != np->network_port) {
		np->is_nat = "via port";
	}
}
}

if (!np->is_nat && sip->sip_via && sip->sip_via->v_port &&
atoi(sip->sip_via->v_port) == 5060 && np->network_port != 5060 ) {
np->is_nat = "via port";
}

if (!np->is_nat && profile->nat_acl_count) {
uint32_t x = 0;
int ok = 1;
char *last_acl = NULL((void*)0);

if (!zstr(contact_host)_zstr(contact_host)) {
	for (x = 0; x < profile->nat_acl_count; x++) {
		last_acl = profile->nat_acl[x];
		if (!(ok = switch_check_network_list_ip(contact_host, last_acl)switch_check_network_list_ip_token(contact_host, last_acl, ((
void*)0)))) {
			break;
		}
	}

	if (ok) {
		np->is_nat = last_acl;
	}
}
}

if (np->is_nat && profile->local_network && switch_check_network_list_ip(np->network_ip, profile->local_network)switch_check_network_list_ip_token(np->network_ip, profile
->local_network, ((void*)0))) {
if (profile->debug) {
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "sofia_glue.c", (const char *)__func__
, 3364, ((void*)0), SWITCH_LOG_DEBUG, "IP %s is on local network, not seting NAT mode.\n", np->network_ip);
}
np->is_nat = NULL((void*)0);
}

if (sip->sip_record_route) {
char *full_contact = sip_header_as_string(nua_handle_get_home(nh), (void *) contact);
char *route = sofia_glue_strip_uri(sip_header_as_string(nua_handle_get_home(nh), (void *) sip->sip_record_route));
char *full_contact_dup;
char *route_encoded;
int route_encoded_len;
full_contact_dup = sofia_glue_get_url_from_contact(full_contact, 1);
route_encoded_len = (int)(strlen(route) * 3) + 1;
switch_zmalloc(route_encoded, route_encoded_len)(void)((((route_encoded = switch_calloc(1, (route_encoded_len
)))) ? (void) (0) : __assert_fail ("(route_encoded = switch_calloc(1, (route_encoded_len)))"
, "sofia_glue.c", 3377, __extension__ __PRETTY_FUNCTION__)),route_encoded
);
switch_url_encode(route, route_encoded, route_encoded_len);
contact_str = switch_mprintf("%s <%s;fs_path=%s>", display, full_contact_dup, route_encoded);
free(route);
free(full_contact_dup);
free(route_encoded);
}
else if (np->is_nat && np->fs_path) {
char *full_contact = sip_header_as_string(nua_handle_get_home(nh), (void *) contact);
char *full_contact_dup;
char *path_encoded;
int path_encoded_len;
char *path_val;
const char *tp;

full_contact_dup = sofia_glue_get_url_from_contact(full_contact, 1);

if ((tp = switch_stristr("transport=", full_contact_dup))) {
	tp += 10;
}

if (zstr(tp)_zstr(tp)) {
	tp = "udp";
}

path_val = switch_mprintf("sip:%s:%d;transport=%s", np->network_ip, np->network_port, tp);
path_encoded_len = (int)(strlen(path_val) * 3) + 1;

switch_zmalloc(path_encoded, path_encoded_len)(void)((((path_encoded = switch_calloc(1, (path_encoded_len))
)) ? (void) (0) : __assert_fail ("(path_encoded = switch_calloc(1, (path_encoded_len)))"
, "sofia_glue.c", 3405, __extension__ __PRETTY_FUNCTION__)),path_encoded
);
switch_copy_string(path_encoded, ";fs_path=", 10);
switch_url_encode(path_val, path_encoded + 9, path_encoded_len - 9);

contact_str = switch_mprintf("%s <%s;fs_nat=yes%s>", display, full_contact_dup, path_encoded);

free(full_contact_dup);
free(path_encoded);
free(path_val);

} else {

if (zstr(contact_host)_zstr(contact_host)) {
	np->is_nat = "No contact host";
}

if (np->is_nat) {
	contact_host = np->network_ip;
	switch_snprintf(new_port, sizeof(new_port), ":%d", np->network_port);
	port = NULL((void*)0);
}


if (port) {
	switch_snprintf(new_port, sizeof(new_port), ":%s", port);
}

ipv6 = strchr(contact_host, ':');


if (contact->m_url->url_params) {
	contact_str = switch_mprintf("%s <sip:%s%s%s%s%s%s;%s>%s",
								 display, contact->m_url->url_user,
								 contact->m_url->url_user ? "@" : "",
								 ipv6 ? "[" : "",
								 contact_host, ipv6 ? "]" : "", new_port, contact->m_url->url_params, np->is_nat ? ";fs_nat=yes" : "");
} else {
	contact_str = switch_mprintf("%s <sip:%s%s%s%s%s%s>%s",
								 display,
								 contact->m_url->url_user,
								 contact->m_url->url_user ? "@" : "",
								 ipv6 ? "[" : "", contact_host, ipv6 ? "]" : "", new_port, np->is_nat ? ";fs_nat=yes" : "");
}
}

return contact_str;
3451}

3453char *sofia_glue_get_host(const char *str, switch_memory_pool_t *pool)
3454{
char *s, *p;

if ((p = strchr(str, '@'))) {
62
←
Assuming 'p' is not null→
63
←
Taking true branch→
p++;
} else {
return NULL((void*)0);
}

if (pool) {
64
←
Assuming 'pool' is null→
65
←
Taking false branch→
s = switch_core_strdup(pool, p)switch_core_perform_strdup(pool, p, "sofia_glue.c", (const char
 *)__func__, 3464);
} else {
s = strdup(p);
66
←
Memory is allocated→
}

for (p = s; p && *p; p++) {
67
←
Assuming 'p' is non-null→
68
←
Loop condition is false. Execution continues on line 3476→
if ((*p == ';') || (*p == '>')) {
	*p = '\0';
	break;
}
}

return s;
3477}

3479void sofia_glue_fire_events(sofia_profile_t *profile)
3480{
void *pop = NULL((void*)0);

while (profile->event_queue && switch_queue_trypop(profile->event_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {
switch_event_t *event = (switch_event_t *) pop;
switch_event_fire(&event)switch_event_fire_detailed("sofia_glue.c", (const char * )(const
 char *)__func__, 3485, &event, ((void*)0));
}

3488}

3490void sofia_event_fire(sofia_profile_t *profile, switch_event_t **event)
3491{
switch_queue_push(profile->event_queue, *event);
*event = NULL((void*)0);
3494}

3496void sofia_glue_clear_soa(switch_core_session_t *session, switch_bool_t partner)
3497{
switch_core_session_t *other_session;
struct private_object *tech_pvt = switch_core_session_get_private(session)switch_core_session_get_private_class(session, SWITCH_PVT_PRIMARY
);

sofia_clear_flag(tech_pvt, TFLAG_ENABLE_SOA)(tech_pvt)->flags[TFLAG_ENABLE_SOA] = 0;

if (partner && switch_core_session_get_partner(session, &other_session)switch_core_session_perform_get_partner(session, &other_session
, "sofia_glue.c", (const char *)__func__, 3503) == SWITCH_STATUS_SUCCESS) {
if (switch_core_session_compare(session, other_session)) {
	struct private_object *other_tech_pvt = switch_core_session_get_private(other_session)switch_core_session_get_private_class(other_session, SWITCH_PVT_PRIMARY
);

	sofia_clear_flag(other_tech_pvt, TFLAG_ENABLE_SOA)(other_tech_pvt)->flags[TFLAG_ENABLE_SOA] = 0;
}
switch_core_session_rwunlock(other_session);
}

3512}

3514char *sofia_glue_get_profile_url(sofia_profile_t *profile, char *remote_ip, const sofia_transport_t transport)
3515{
char *url = NULL((void*)0);
int check_nat = 0;

if (!zstr(remote_ip)_zstr(remote_ip) && sofia_glue_check_nat(profile, remote_ip)) {
check_nat = 1;
}

if (sofia_glue_transport_has_tls(transport)) {
if (check_nat && profile->tls_public_url) {
	url = profile->tls_public_url;
} else {
	url = profile->tls_url;
}
} else {
if (check_nat && profile->public_url) {
	url = profile->public_url;
} else {
	url = profile->url;
}
}

if (!url) url = profile->url;

return url;
3540}

3542/* gets the IP or HOST from a sip uri or from x.x.x.x:port format */
3543char *sofia_glue_get_host_from_cfg(const char *uri, switch_memory_pool_t *pool)
3544{
char *host = NULL((void*)0);
const char *s;
char *p = NULL((void*)0);

if (zstr(uri)_zstr(uri)) {
return NULL((void*)0);
}

if ((s = switch_stristr("sip:", uri)) && s == uri) {
s += 4;
} else if ((s = switch_stristr("sips:", uri)) && s == uri) {
s += 5;
}

if (!s) {
s = uri;
}

host = switch_core_strdup(pool, s)switch_core_perform_strdup(pool, s, "sofia_glue.c", (const char
 *)__func__, 3563);

if ((p = strchr(host, ']'))) {
if (*(p + 1) == ':') {
	*(p + 1) = '\0';
}
} else {
if ((p = strrchr(host, ':'))) {
	*p = '\0';
}
}

return host;
3576}

3578/* 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:
*/