Merge branch 'master' into smgmaster

src/mod/endpoints/mod_dingaling/Makefile

@@ -10,8 +10,10 @@ DING_DIR=$(BASE)/libs/libdingaling
 LOCAL_CFLAGS += -I$(DING_DIR)/src -I$(BASE)/libs/iksemel/include
 LOCAL_OBJS=$(DING_DIR)/src/libdingaling.o $(DING_DIR)/src/sha1.o $(IKS_LA)
 LOCAL_SOURCES=$(DING_DIR)/src/libdingaling.c $(DING_DIR)/src/sha1.c
+LOCAL_LDFLAGS=$(LIBGNUTLS_LIBS)
 include $(BASE)/build/modmake.rules
 
+
 $(IKS_LA): $(IKS_DIR) $(IKS_DIR)/.update
 	@cd $(IKS_DIR) && $(MAKE)
 	@$(TOUCH_TARGET)

src/mod/endpoints/mod_dingaling/mod_dingaling.c

@@ -65,19 +65,20 @@ typedef enum {
 	TFLAG_CODEC_READY = (1 << 8),
 	TFLAG_TRANSPORT = (1 << 9),
 	TFLAG_ANSWER = (1 << 10),
-	TFLAG_VAD_IN = (1 << 11),
-	TFLAG_VAD_OUT = (1 << 12),
-	TFLAG_VAD = (1 << 13),
-	TFLAG_DO_CAND = (1 << 14),
-	TFLAG_DO_DESC = (1 << 15),
-	TFLAG_LANADDR = (1 << 16),
-	TFLAG_AUTO = (1 << 17),
-	TFLAG_DTMF = (1 << 18),
-	TFLAG_TIMER = (1 << 19),
-	TFLAG_TERM = (1 << 20),
-	TFLAG_TRANSPORT_ACCEPT = (1 << 21),
-	TFLAG_READY = (1 << 22),
-	TFLAG_NAT_MAP = (1 << 22)
+	TFLAG_VAD_NONE = (1 << 11),
+	TFLAG_VAD_IN = (1 << 12),
+	TFLAG_VAD_OUT = (1 << 13),
+	TFLAG_VAD = (1 << 14),
+	TFLAG_DO_CAND = (1 << 15),
+	TFLAG_DO_DESC = (1 << 16),
+	TFLAG_LANADDR = (1 << 17),
+	TFLAG_AUTO = (1 << 18),
+	TFLAG_DTMF = (1 << 19),
+	TFLAG_TIMER = (1 << 20),
+	TFLAG_TERM = (1 << 21),
+	TFLAG_TRANSPORT_ACCEPT = (1 << 22),
+	TFLAG_READY = (1 << 23),
+	TFLAG_NAT_MAP = (1 << 24)
 } TFLAGS;
 
 typedef enum {
@@ -966,7 +967,7 @@ static int do_candidates(struct private_object *tech_pvt, int force)
 	if (force || !switch_test_flag(tech_pvt, TFLAG_RTP_READY)) {
 		ldl_candidate_t cand[1];
 		char *advip = tech_pvt->profile->extip ? tech_pvt->profile->extip : tech_pvt->profile->ip;
-		char *err = NULL;
+		char *err = NULL, *address = NULL;
 
 		memset(cand, 0, sizeof(cand));
 		switch_stun_random_string(tech_pvt->local_user, 16, NULL);
@@ -975,10 +976,14 @@ static int do_candidates(struct private_object *tech_pvt, int force)
 		if (switch_test_flag(tech_pvt, TFLAG_LANADDR)) {
 			advip = tech_pvt->profile->ip;
 		}
+		address = advip;
 
+		if(address && !strncasecmp(address, "host:", 5)) {
+			address = address + 5;
+		}
 
 		cand[0].port = tech_pvt->adv_local_port;
-		cand[0].address = advip;
+		cand[0].address = address;
 
 		if (!strncasecmp(advip, "stun:", 5)) {
 			char *stun_ip = advip + 5;
@@ -1568,22 +1573,8 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s
 		channel_answer_channel(session);
 		break;
 	case SWITCH_MESSAGE_INDICATE_BRIDGE:
-		/*
-		   if (tech_pvt->rtp_session && switch_test_flag(tech_pvt->profile, TFLAG_TIMER)) {
-		   switch_rtp_clear_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
-		   switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "De-activate timed RTP!\n");
-		   //switch_rtp_set_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_TIMER_RECLOCK);
-		   }
-		 */
 		break;
 	case SWITCH_MESSAGE_INDICATE_UNBRIDGE:
-		/*
-		   if (tech_pvt->rtp_session && switch_test_flag(tech_pvt->profile, TFLAG_TIMER)) {
-		   switch_rtp_set_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
-		   switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Re-activate timed RTP!\n");
-		   //switch_rtp_clear_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_TIMER_RECLOCK);
-		   }
-		 */
 		break;
 	default:
 		break;
@@ -2110,8 +2101,10 @@ static void set_profile_val(mdl_profile_t *profile, char *var, char *val)
 		} else if (!strcasecmp(val, "both")) {
 			switch_set_flag(profile, TFLAG_VAD_IN);
 			switch_set_flag(profile, TFLAG_VAD_OUT);
+		} else if (!strcasecmp(val, "none")) {
+			switch_set_flag(profile, TFLAG_VAD_NONE);
 		} else {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invald option %s for VAD\n", val);
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid option %s for VAD\n", val);
 		}
 	}
 }

src/mod/endpoints/mod_portaudio/mod_portaudio.c

@@ -1198,14 +1198,14 @@ static switch_status_t load_config(void)
 		if (globals.outdev > -1) {
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Switching to default output device\n");
 		} else {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find an input device\n");
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find an output device\n");
 			status = SWITCH_STATUS_GENERR;
 		}
 	}
 
 	if (globals.ringdev < 0) {
 		if (globals.outdev > -1) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid ring device configured using output device\n");
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid or no ring device configured, using output device as ring device\n");
 			globals.ringdev = globals.outdev;
 		}
 	}

src/mod/endpoints/mod_sofia/mod_sofia.c

@@ -1655,6 +1655,9 @@ static switch_status_t sofia_receive_message(switch_core_session_t *session, swi
 			const char *ip = NULL, *port = NULL;
 
 			switch_channel_set_flag(channel, CF_PROXY_MODE);
+			if (tech_pvt->rm_encoding) {
+				tech_pvt->rm_encoding = NULL;
+			}
 			sofia_glue_tech_set_local_sdp(tech_pvt, NULL, SWITCH_FALSE);
 
 			if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))
@@ -3480,6 +3483,96 @@ SWITCH_STANDARD_API(sofia_count_reg_function)
 	return SWITCH_STATUS_SUCCESS;
 }
 
+SWITCH_STANDARD_API(sofia_username_of_function)
+{
+	char *data;
+	char *user = NULL;
+	char *domain = NULL;
+	char *profile_name = NULL;
+	char *p;
+	char *reply = "";
+	sofia_profile_t *profile = NULL;
+
+	if (!cmd) {
+		stream->write_function(stream, "%s", "");
+		return SWITCH_STATUS_SUCCESS;
+	}
+
+	data = strdup(cmd);
+	switch_assert(data);
+
+	if ((p = strchr(data, '/'))) {
+		profile_name = data;
+		*p++ = '\0';
+		user = p;
+	} else {
+		user = data;
+	}
+
+	if ((domain = strchr(user, '@'))) {
+		*domain++ = '\0';
+	}
+
+	if (!profile_name && domain) {
+		profile_name = domain;
+	}
+
+	if (user && profile_name) {
+		char *sql;
+
+		if (!(profile = sofia_glue_find_profile(profile_name))) {
+			profile_name = domain;
+			domain = NULL;
+		}
+
+		if (!profile && profile_name) {
+			profile = sofia_glue_find_profile(profile_name);
+		}
+
+		if (profile) {
+			struct cb_helper_sql2str cb;
+			char username[256] = "";
+
+			cb.buf = username;
+			cb.len = sizeof(username);
+
+			if (!domain || !strchr(domain, '.')) {
+				domain = profile->name;
+			}
+
+			switch_assert(!zstr(user));
+
+			sql = switch_mprintf("select sip_username "
+									"from sip_registrations where sip_user='%q' and (sip_host='%q' or presence_hosts like '%%%q%%')",
+									user, domain, domain);
+
+			switch_assert(sql);
+
+			sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sql2str_callback, &cb);
+			switch_safe_free(sql);
+			if (!zstr(username)) {
+				stream->write_function(stream, "%s", username);
+			} else {
+				stream->write_function(stream, "");
+			}
+			reply = NULL;
+
+		}
+	}
+
+	if (reply) {
+		stream->write_function(stream, "%s", reply);
+	}
+
+	switch_safe_free(data);
+
+	if (profile) {
+		sofia_glue_release_profile(profile);
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
 static void select_from_profile(sofia_profile_t *profile, 
 								const char *user,
 								const char *domain,
@@ -3987,6 +4080,7 @@ static switch_call_cause_t sofia_outgoing_channel(switch_core_session_t *session
 	const char *hval = NULL;
 	char *not_const = NULL;
 	int cid_locked = 0;
+	switch_channel_t *o_channel = NULL;
 
 	*new_session = NULL;
 
@@ -4015,6 +4109,11 @@ static switch_call_cause_t sofia_outgoing_channel(switch_core_session_t *session
 
 	nchannel = switch_core_session_get_channel(nsession);
 
+	if (session) {
+		o_channel = switch_core_session_get_channel(session);
+	}
+
+
 	if ((hval = switch_event_get_header(var_event, "sip_invite_to_uri"))) {
 		dest_to = switch_core_session_strdup(nsession, hval);
 	}
@@ -4121,7 +4220,23 @@ static switch_call_cause_t sofia_outgoing_channel(switch_core_session_t *session
 		gateway_ptr->ob_calls++;
 
 		if (!zstr(gateway_ptr->from_domain) && !switch_channel_get_variable(nchannel, "sip_invite_domain")) {
-			switch_channel_set_variable(nchannel, "sip_invite_domain", gateway_ptr->from_domain);
+			
+			if (!strcasecmp(gateway_ptr->from_domain, "auto-aleg-full")) {
+				const char *sip_full_from = switch_channel_get_variable(o_channel, "sip_full_from");
+				
+				if (!zstr(sip_full_from)) {
+					switch_channel_set_variable(nchannel, "sip_force_full_from", sip_full_from);
+				}
+
+			} else if (!strcasecmp(gateway_ptr->from_domain, "auto-aleg-domain")) {
+				const char *sip_from_host = switch_channel_get_variable(o_channel, "sip_from_host");
+
+				if (!zstr(sip_from_host)) {
+					switch_channel_set_variable(nchannel, "sip_invite_domain", sip_from_host);
+				}
+			} else {
+				switch_channel_set_variable(nchannel, "sip_invite_domain", gateway_ptr->from_domain);
+			}
 		}
 
 		if (!zstr(gateway_ptr->outbound_sticky_proxy) && !switch_channel_get_variable(nchannel, "sip_route_uri")) {
@@ -4320,7 +4435,6 @@ static switch_call_cause_t sofia_outgoing_channel(switch_core_session_t *session
 	}
 
 	if (session) {
-		switch_channel_t *o_channel = switch_core_session_get_channel(session);
 		const char *vval = NULL;
 
 		if ((vval = switch_channel_get_variable(o_channel, "sip_auto_answer")) && switch_true(vval)) {
@@ -5090,6 +5204,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_sofia_load)
 	switch_console_add_complete_func("::sofia::list_profile_gateway", list_profile_gateway);
 
 
+	SWITCH_ADD_API(api_interface, "sofia_username_of", "Sofia Username Lookup", sofia_username_of_function, "[profile/]<user>@<domain>");
 	SWITCH_ADD_API(api_interface, "sofia_contact", "Sofia Contacts", sofia_contact_function, "[profile/]<user>@<domain>");
 	SWITCH_ADD_API(api_interface, "sofia_count_reg", "Count Sofia registration", sofia_count_reg_function, "[profile/]<user>@<domain>");
 	SWITCH_ADD_API(api_interface, "sofia_dig", "SIP DIG", sip_dig_function, "<url>");

src/mod/endpoints/mod_sofia/mod_sofia.h

@@ -564,7 +564,8 @@ struct sofia_profile {
 	uint32_t reg_acl_count;
 	char *nat_acl[SOFIA_MAX_ACL];
 	uint32_t nat_acl_count;
-	int rport_level;
+	int server_rport_level;
+	int client_rport_level;
 	sofia_presence_type_t pres_type;
 	sofia_media_options_t media_options;
 	uint32_t force_subscription_expires;

src/mod/endpoints/mod_sofia/sofia.c

@@ -76,14 +76,15 @@ void sofia_handle_sip_r_notify(switch_core_session_t *session, int status,
 							   char const *phrase,
 							   nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip, tagi_t tags[])
 {
-#if 0
+
 	if (status >= 300 && sip && sip->sip_call_id) {
 		char *sql;
 		sql = switch_mprintf("delete from sip_subscriptions where call_id='%q'", sip->sip_call_id->i_id);
 		switch_assert(sql != NULL);
 		sofia_glue_execute_sql(profile, &sql, SWITCH_TRUE);
+		nua_handle_destroy(nh);
 	}
-#endif
+
 }
 
 #define url_set_chanvars(session, url, varprefix) _url_set_chanvars(session, url, #varprefix "_user", #varprefix "_host", #varprefix "_port", #varprefix "_uri", #varprefix "_params")
@@ -1275,6 +1276,11 @@ static void sofia_perform_profile_start_failure(sofia_profile_t *profile, char *
 	}
 }
 
+/* not a static function so that it's still visible on stacktraces */
+void watchdog_triggered_abort(void) {
+	abort();
+}
+
 #define sofia_profile_start_failure(p, xp) sofia_perform_profile_start_failure(p, xp, __FILE__, __LINE__)
 
 
@@ -1390,10 +1396,10 @@ void *SWITCH_THREAD_FUNC sofia_profile_worker_thread_run(switch_thread_t *thread
 				}
 
 				if (event_fail || step_fail) {
-					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Profile %s: SIP STACK FAILURE DETECTED!\n"
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Profile %s: SIP STACK FAILURE DETECTED BY WATCHDOG!\n"
 									  "GOODBYE CRUEL WORLD, I'M LEAVING YOU TODAY....GOODBYE, GOODBYE, GOOD BYE\n", profile->name);
 					switch_yield(2000000);
-					abort();
+					watchdog_triggered_abort();
 				}
 			}
 
@@ -1516,7 +1522,8 @@ void *SWITCH_THREAD_FUNC sofia_profile_thread_run(switch_thread_t *thread, void
 							  TAG_IF(sofia_test_pflag(profile, PFLAG_DISABLE_NAPTR),
 									 NTATAG_USE_NAPTR(0)),
 							  NTATAG_DEFAULT_PROXY(profile->outbound_proxy),
-							  NTATAG_SERVER_RPORT(profile->rport_level),
+							  NTATAG_SERVER_RPORT(profile->server_rport_level),
+							  NTATAG_CLIENT_RPORT(profile->client_rport_level),
 							  TPTAG_LOG(sofia_test_flag(profile, TFLAG_TPORT_LOG)),
 							  TAG_IF(sofia_test_pflag(profile, PFLAG_SIPCOMPACT),
 									 NTATAG_SIPFLAGS(MSG_DO_COMPACT)),
@@ -1579,7 +1586,7 @@ void *SWITCH_THREAD_FUNC sofia_profile_thread_run(switch_thread_t *thread, void
 		node->nua = nua_create(profile->s_root,	/* Event loop */
 							   sofia_event_callback,	/* Callback for processing events */
 							   profile,	/* Additional data to pass to callback */
-							   NTATAG_SERVER_RPORT(profile->rport_level), NUTAG_URL(node->url), TAG_END());	/* Last tag should always finish the sequence */
+							   NTATAG_SERVER_RPORT(profile->server_rport_level), NUTAG_URL(node->url), TAG_END());	/* Last tag should always finish the sequence */
 
 		nua_set_params(node->nua,
 					   NUTAG_APPL_METHOD("OPTIONS"),
@@ -2342,7 +2349,6 @@ switch_status_t reconfig_sofia(sofia_profile_t *profile)
 			}
 
 			/* you could change profile->foo here if it was a minor change like context or dialplan ... */
-			profile->rport_level = 1;	/* default setting */
 			profile->acl_count = 0;
 			profile->reg_acl_count = 0;
 			profile->proxy_acl_count = 0;
@@ -2493,12 +2499,6 @@ switch_status_t reconfig_sofia(sofia_profile_t *profile)
 						} else {
 							profile->dtmf_type = DTMF_NONE;
 						}
-					} else if (!strcasecmp(var, "NDLB-force-rport")) {
-						if (val && !strcasecmp(val, "safe")) {
-							profile->rport_level = 3;
-						} else if (switch_true(val)) {
-							profile->rport_level = 2;
-						}
 					} else if (!strcasecmp(var, "caller-id-type")) {
 						profile->cid_type = sofia_cid_name2type(val);
 					} else if (!strcasecmp(var, "record-template")) {
@@ -3064,7 +3064,8 @@ switch_status_t config_sofia(int reload, char *profile_name)
 				profile->dtmf_duration = 100;
 				profile->tls_version = 0;
 				profile->mflags = MFLAG_REFER | MFLAG_REGISTER;
-				profile->rport_level = 1;
+				profile->server_rport_level = 1;
+				profile->client_rport_level = 1;
 				sofia_set_pflag(profile, PFLAG_STUN_ENABLED);
 				sofia_set_pflag(profile, PFLAG_DISABLE_100REL);
 				profile->auto_restart = 1;
@@ -3206,9 +3207,19 @@ switch_status_t config_sofia(int reload, char *profile_name)
 						}
 					} else if (!strcasecmp(var, "NDLB-force-rport")) {
 						if (val && !strcasecmp(val, "safe")) {
-							profile->rport_level = 3;
+							profile->server_rport_level = 3;
+							profile->client_rport_level = 1;
+						} else if (val && !strcasecmp(val, "disabled")) {
+							profile->server_rport_level = 0;
+							profile->client_rport_level = 0;
+						} else if (val && !strcasecmp(val, "client-only")) {
+							profile->client_rport_level = 1;
+						} else if (val && !strcasecmp(val, "server-only")) {
+							profile->client_rport_level = 0;
+							profile->client_rport_level = 1;
 						} else if (switch_true(val)) {
-							profile->rport_level = 2;
+							profile->server_rport_level = 2;
+							profile->client_rport_level = 1;
 						}
 					} else if (!strcasecmp(var, "auto-rtp-bugs")) {
 						sofia_glue_parse_rtp_bugs(&profile->auto_rtp_bugs, val);
@@ -4404,7 +4415,7 @@ static void sofia_handle_sip_r_invite(switch_core_session_t *session, int status
 		
 		if (switch_channel_test_flag(channel, CF_PROXY_MODE) || 
 			switch_channel_test_flag(channel, CF_PROXY_MEDIA) || 
-			(sofia_test_flag(tech_pvt, TFLAG_T38_PASSTHRU) && has_t38)) {
+			(sofia_test_flag(tech_pvt, TFLAG_T38_PASSTHRU) && (has_t38 || status > 299))) {
 
 			if (sofia_test_flag(tech_pvt, TFLAG_SENT_UPDATE)) {
 				sofia_clear_flag_locked(tech_pvt, TFLAG_SENT_UPDATE);
@@ -4413,6 +4424,7 @@ static void sofia_handle_sip_r_invite(switch_core_session_t *session, int status
 					const char *r_sdp = NULL;
 					switch_core_session_message_t *msg;
 					private_object_t *other_tech_pvt = switch_core_session_get_private(other_session);
+					switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
 
 					if (sip->sip_payload && sip->sip_payload->pl_data &&
 						sip->sip_content_type && sip->sip_content_type->c_subtype && switch_stristr("sdp", sip->sip_content_type->c_subtype)) {
@@ -4423,9 +4435,14 @@ static void sofia_handle_sip_r_invite(switch_core_session_t *session, int status
 
 					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Passing %d %s to other leg\n", status, phrase);
 
-					if (status == 200 && sofia_test_flag(tech_pvt, TFLAG_T38_PASSTHRU) && has_t38 && sip->sip_payload && sip->sip_payload->pl_data) {
+					if (status > 299) {
+						switch_channel_set_private(channel, "t38_options", NULL);
+						switch_channel_set_private(other_channel, "t38_options", NULL);
+						sofia_clear_flag(tech_pvt, TFLAG_T38_PASSTHRU);
+						sofia_clear_flag(other_tech_pvt, TFLAG_T38_PASSTHRU);
+					} else if (status == 200 && sofia_test_flag(tech_pvt, TFLAG_T38_PASSTHRU) && has_t38 && sip->sip_payload && sip->sip_payload->pl_data) {
 						switch_t38_options_t *t38_options = sofia_glue_extract_t38_options(session, sip->sip_payload->pl_data);
-
+						
 						if (!t38_options) {
 							switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_WARNING, "%s Error parsing SDP:\n%s\n",
 											  switch_channel_get_name(tech_pvt->channel), sip->sip_payload->pl_data);
@@ -4912,7 +4929,11 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 						match = sofia_glue_negotiate_sdp(session, r_sdp);
 					}
 
-					if (match) {
+					if (!match) {
+						if (switch_channel_get_state(channel) != CS_NEW) {
+							nua_respond(tech_pvt->nh, SIP_488_NOT_ACCEPTABLE, TAG_END());
+						}
+					} else {
 						nua_handle_t *bnh;
 						sip_replaces_t *replaces;
 						su_home_t *home = NULL;
@@ -4920,6 +4941,8 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 						sofia_set_flag_locked(tech_pvt, TFLAG_READY);
 						if (switch_channel_get_state(channel) == CS_NEW) {
 							switch_channel_set_state(channel, CS_INIT);
+						} else {
+							nua_respond(tech_pvt->nh, SIP_200_OK, TAG_END());
 						}
 						sofia_set_flag(tech_pvt, TFLAG_SDP);
 						if (replaces_str) {
@@ -5688,6 +5711,11 @@ void sofia_handle_sip_i_refer(nua_t *nua, sofia_profile_t *profile, nua_handle_t
 								switch_core_event_hook_add_state_change(a_session, xfer_hanguphook);
 								switch_channel_set_variable(a_channel, "att_xfer_kill_uuid", switch_core_session_get_uuid(b_session));
 
+								if (profile->media_options & MEDIA_OPT_BYPASS_AFTER_ATT_XFER) {
+									switch_channel_set_flag(a_channel, CF_BYPASS_MEDIA_AFTER_BRIDGE);
+								}
+
+
 								if ((tmp = switch_channel_get_hold_music(a_channel))) {
 									moh = tmp;
 								}
@@ -5747,6 +5775,12 @@ void sofia_handle_sip_i_refer(nua_t *nua, sofia_profile_t *profile, nua_handle_t
 								switch_core_session_rwunlock(tmp);
 							}
 
+							if ((profile->media_options & MEDIA_OPT_BYPASS_AFTER_ATT_XFER) && (tmp = switch_core_session_locate(br_a))) {
+								switch_channel_t *tchannel = switch_core_session_get_channel(tmp);
+								switch_channel_set_flag(tchannel, CF_BYPASS_MEDIA_AFTER_BRIDGE);
+								switch_core_session_rwunlock(tmp);
+							}
+
 							switch_ivr_uuid_bridge(br_b, br_a);
 							switch_channel_set_variable(channel_b, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "ATTENDED_TRANSFER");
 							nua_notify(tech_pvt->nh, NUTAG_NEWSUB(1), SIPTAG_CONTENT_TYPE_STR("message/sipfrag;version=2.0"),
@@ -6129,7 +6163,7 @@ void sofia_handle_sip_i_info(nua_t *nua, sofia_profile_t *profile, nua_handle_t
 		/* Barf if we didn't get our private */
 		assert(switch_core_session_get_private(session));
 		
-		if (sip->sip_content_type && sip->sip_content_type->c_subtype && sip->sip_content_type->c_type &&
+		if (sip && sip->sip_content_type && sip->sip_content_type->c_subtype && sip->sip_content_type->c_type &&
 			!strncasecmp(sip->sip_content_type->c_type, "message", 7) &&
 			!strcasecmp(sip->sip_content_type->c_subtype, "update_display")) {
 			sofia_update_callee_id(session, profile, sip, SWITCH_TRUE);

src/mod/endpoints/mod_sofia/sofia_glue.c

@@ -505,7 +505,7 @@ void sofia_glue_set_local_sdp(private_object_t *tech_pvt, const char *ip, uint32
 			ptime = tech_pvt->read_codec.implementation->microseconds_per_packet / 1000;
 		}
 
-		
+
 		if (tech_pvt->dtmf_type == DTMF_2833 && tech_pvt->te > 95) {
 			switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "a=rtpmap:%d telephone-event/8000\na=fmtp:%d 0-16\n", tech_pvt->te, tech_pvt->te);
 		}
@@ -729,6 +729,8 @@ void sofia_glue_tech_prepare_codecs(private_object_t *tech_pvt)
 		return;
 	}
 
+	tech_pvt->payload_space = 0;
+
 	switch_assert(tech_pvt->session != NULL);
 
 	if ((abs = switch_channel_get_variable(tech_pvt->channel, "absolute_codec_string"))) {
@@ -1893,6 +1895,8 @@ switch_status_t sofia_glue_do_invite(switch_core_session_t *session)
 	const char *invite_full_to = switch_channel_get_variable(tech_pvt->channel, "sip_invite_full_to");
 	const char *handle_full_from = switch_channel_get_variable(tech_pvt->channel, "sip_handle_full_from");
 	const char *handle_full_to = switch_channel_get_variable(tech_pvt->channel, "sip_handle_full_to");
+	const char *force_full_from = switch_channel_get_variable(tech_pvt->channel, "sip_force_full_from");
+	const char *force_full_to = switch_channel_get_variable(tech_pvt->channel, "sip_force_full_to");
 	char *mp = NULL, *mp_type = NULL;
 
 	rep = switch_channel_get_variable(channel, SOFIA_REPLACES_HEADER);
@@ -2125,6 +2129,15 @@ switch_status_t sofia_glue_do_invite(switch_core_session_t *session)
 		}
 
 
+		if (force_full_from) {
+			from_str = (char *) force_full_from;
+		}
+
+		if (force_full_to) {
+			to_str = (char *) force_full_to;
+		}
+
+
 		if (invite_req_uri) {
 			url_str = (char *) invite_req_uri;
 		}
@@ -4754,6 +4767,11 @@ uint8_t sofia_glue_negotiate_sdp(switch_core_session_t *session, const char *r_s
 						switch_rtp_set_telephony_recv_event(tech_pvt->rtp_session, te);
 					}
 				}
+			} else {
+				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Disable 2833 dtmf\n");
+				switch_channel_set_variable(tech_pvt->channel, "dtmf_type", "none");
+				tech_pvt->dtmf_type = DTMF_NONE;
+				te = tech_pvt->recv_te = 0;
 			}
 
 			
@@ -5210,12 +5228,14 @@ void sofia_glue_del_profile(sofia_profile_t *profile)
 		}
 
 		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, gp->register_from);
-			switch_core_hash_delete(mod_sofia_globals.gateway_hash, gp->register_contact);
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "deleted gateway %s\n", gp->name);
-			profile->gateways = NULL;
+			switch_core_hash_delete(mod_sofia_globals.gateway_hash, pkey);
+			switch_safe_free(pkey);
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "deleted gateway %s from profile %s\n", gp->name, profile->name);
 		}
+		profile->gateways = NULL;
 	}
 	switch_mutex_unlock(mod_sofia_globals.hash_mutex);
 }

src/mod/endpoints/mod_sofia/sofia_presence.c

@@ -1506,9 +1506,9 @@ static int sofia_presence_sub_callback(void *pArg, int argc, char **argv, char *
 			stream.write_function(&stream,
 								  "<?xml version=\"1.0\"?>\n"
 								  "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" "
-								  "version=\"%s\" state=\"%s\" entity=\"%s\">\n",
-								  version,
-								  zstr(uuid) ? "partial" : "full", clean_id);
+								  "version=\"%s\" state=\"partial\" entity=\"%s\">\n", version, clean_id);
+								  
+								  
 		}
 
 		//if (strcasecmp(event_status, "Registered")) {

src/mod/endpoints/mod_sofia/sofia_reg.c

@@ -800,7 +800,7 @@ void sofia_reg_auth_challenge(nua_t *nua, sofia_profile_t *profile, nua_handle_t
 
 	sql = switch_mprintf("insert into sip_authentication (nonce,expires,profile_name,hostname, last_nc) "
 						 "values('%q', %ld, '%q', '%q', 0)", uuid_str,
-						 switch_epoch_time_now(NULL) + (profile->nonce_ttl ? profile->nonce_ttl : DEFAULT_NONCE_TTL),
+						 (long) switch_epoch_time_now(NULL) + (profile->nonce_ttl ? profile->nonce_ttl : DEFAULT_NONCE_TTL),
 						 profile->name, mod_sofia_globals.hostname);
 	switch_assert(sql != NULL);
 	sofia_glue_actually_execute_sql(profile, sql, profile->ireg_mutex);
@@ -1104,7 +1104,7 @@ uint8_t sofia_reg_handle_register(nua_t *nua, sofia_profile_t *profile, nua_hand
 				to_user = force_user;
 			}
 
-			if (profile->rport_level == 3 && sip->sip_user_agent &&
+			if (profile->server_rport_level == 3 && sip->sip_user_agent &&
 				sip->sip_user_agent->g_string && !strncasecmp(sip->sip_user_agent->g_string, "Polycom", 7)) {
 				if (sip && sip->sip_via) {
 					const char *host = sip->sip_via->v_host;