diff --git a/libs/freetdm/mod_freetdm/mod_freetdm.c b/libs/freetdm/mod_freetdm/mod_freetdm.c
index 16bdacdad7..34fb3f469a 100755
--- a/libs/freetdm/mod_freetdm/mod_freetdm.c
+++ b/libs/freetdm/mod_freetdm/mod_freetdm.c
@@ -178,6 +178,7 @@ static const char* channel_get_variable(switch_core_session_t *session, switch_e
 ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session_t **sp);
 void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream);
 void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream);
+void ctdm_init(switch_loadable_module_interface_t *module_interface);
 
 static switch_core_session_t *ftdm_channel_get_session(ftdm_channel_t *channel, int32_t id)
 {
@@ -5359,6 +5360,8 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_freetdm_load)
 	SWITCH_ADD_APP(app_interface, "disable_dtmf", "Disable DTMF Detection", "Disable DTMF Detection", disable_dtmf_function, "", SAF_NONE);
 	SWITCH_ADD_APP(app_interface, "enable_dtmf", "Enable DTMF Detection", "Enable DTMF Detection", enable_dtmf_function, "", SAF_NONE);
 
+	ctdm_init(*module_interface);
+
 	/* indicate that the module should continue to be loaded */
 	return SWITCH_STATUS_SUCCESS;
 }
diff --git a/libs/freetdm/mod_freetdm/tdm.c b/libs/freetdm/mod_freetdm/tdm.c
index a3369f1f7b..c66fdbebd1 100644
--- a/libs/freetdm/mod_freetdm/tdm.c
+++ b/libs/freetdm/mod_freetdm/tdm.c
@@ -38,6 +38,7 @@ void ctdm_init(switch_loadable_module_interface_t *module_interface);
 
 #define kSPAN_ID "span"
 #define kCHAN_ID "chan"
+#define kSPAN_NAME "span_name"
 
 static struct {
     switch_memory_pool_t *pool;
@@ -51,6 +52,8 @@ typedef struct {
     switch_core_session_t *session;
     switch_codec_t read_codec, write_codec;
     switch_frame_t read_frame;
+    
+	unsigned char databuf[SWITCH_RECOMMENDED_BUFFER_SIZE];
 } ctdm_private_t;
 
 static switch_status_t channel_on_init(switch_core_session_t *session);
@@ -96,11 +99,11 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
 													switch_memory_pool_t **pool,
 													switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
 {
-    const char  *szspanid = switch_event_get_header(var_event, kSPAN_ID),
-                *szchanid = switch_event_get_header(var_event, kCHAN_ID);
+    const char  *szchanid = switch_event_get_header(var_event, kCHAN_ID),
+                *span_name = switch_event_get_header(var_event, kSPAN_NAME);
     int chan_id;
     int span_id;
-    
+    switch_caller_profile_t *caller_profile;
     ftdm_span_t *span;
     ftdm_channel_t *chan;
     switch_channel_t *channel;
@@ -111,14 +114,20 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
     
     ctdm_private_t *tech_pvt = NULL;
     
-    if (zstr(szchanid) || zstr(szspanid)) {
+    if (zstr(szchanid) || zstr(span_name)) {
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Both ["kSPAN_ID"] and ["kCHAN_ID"] have to be set.\n");
         goto fail;
     }
     
     chan_id = atoi(szchanid);
-    span_id = atoi(szspanid);
     
+    if (ftdm_span_find_by_name(span_name, &span) == FTDM_SUCCESS) {
+         span_id = ftdm_span_get_id(span);   
+    } else {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find span [%s]\n", span_name);
+        goto fail;
+    }
+
     
     if (!(*new_session = switch_core_session_request(ctdm.endpoint_interface, SWITCH_CALL_DIRECTION_OUTBOUND, 0, pool))) {
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't request session.\n");
@@ -139,8 +148,14 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
     tech_pvt->span_id = span_id;
     tech_pvt->ftdm_channel = chan;
     tech_pvt->session = *new_session;
+    tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf);
+    tech_pvt->read_frame.data = tech_pvt->databuf;
     switch_core_session_set_private(*new_session, tech_pvt);
     
+    
+    caller_profile = switch_caller_profile_clone(*new_session, outbound_profile);
+    switch_channel_set_caller_profile(channel, caller_profile);
+    
     snprintf(name, sizeof(name), "tdm/%d:%d", span_id, chan_id);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Connect outbound channel %s\n", name);
 	switch_channel_set_name(channel, name);
@@ -220,6 +235,8 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
         goto fail;
     }
     
+    switch_channel_mark_answered(channel);
+    
     return SWITCH_CAUSE_SUCCESS;
 
 fail:
@@ -246,6 +263,9 @@ fail:
 
 static switch_status_t channel_on_init(switch_core_session_t *session)
 {
+    switch_channel_t *channel = switch_core_session_get_channel(session);
+    
+    switch_channel_set_state(channel, CS_CONSUME_MEDIA);   
     return SWITCH_STATUS_SUCCESS;   
 }
 
@@ -262,9 +282,9 @@ static switch_status_t channel_on_destroy(switch_core_session_t *session)
 		if (tech_pvt->write_codec.implementation) {
 			switch_core_codec_destroy(&tech_pvt->write_codec);
 		}
+        
+        ftdm_channel_close(&tech_pvt->ftdm_channel);
 	}
-    
-    ftdm_channel_close(&tech_pvt->ftdm_channel);
 
     return SWITCH_STATUS_SUCCESS;
 }
@@ -320,6 +340,7 @@ top:
     *frame = &tech_pvt->read_frame;
     tech_pvt->read_frame.datalen = (uint32_t)len;
     tech_pvt->read_frame.samples = tech_pvt->read_frame.datalen;
+    tech_pvt->read_frame.codec = &tech_pvt->read_codec;
 
     if (ftdm_channel_get_codec(tech_pvt->ftdm_channel) == FTDM_CODEC_SLIN) {
         tech_pvt->read_frame.samples /= 2;
diff --git a/libs/freetdm/src/ftdm_io.c b/libs/freetdm/src/ftdm_io.c
index ec623ad6e6..758827c9ed 100644
--- a/libs/freetdm/src/ftdm_io.c
+++ b/libs/freetdm/src/ftdm_io.c
@@ -1470,13 +1470,23 @@ FT_DECLARE(ftdm_status_t) ftdm_group_channel_use_count(ftdm_group_t *group, uint
 
 static __inline__ int chan_is_avail(ftdm_channel_t *check)
 {
-	if (!ftdm_test_flag(check, FTDM_CHANNEL_READY) ||
-		!ftdm_test_flag(check, FTDM_CHANNEL_SIG_UP) ||
-		ftdm_test_flag(check, FTDM_CHANNEL_INUSE) ||
-		ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) ||
-		ftdm_test_flag(check, FTDM_CHANNEL_IN_ALARM) ||
-		check->state != FTDM_CHANNEL_STATE_DOWN) {
-		return 0;
+	if (check->span->signal_type == FTDM_SIGTYPE_NONE) {
+		if (!ftdm_test_flag(check, FTDM_CHANNEL_READY) ||
+			ftdm_test_flag(check, FTDM_CHANNEL_INUSE) ||
+			ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) ||
+			ftdm_test_flag(check, FTDM_CHANNEL_IN_ALARM) ||
+			check->state != FTDM_CHANNEL_STATE_DOWN) {
+			return 0;
+		}
+	} else {
+		if (!ftdm_test_flag(check, FTDM_CHANNEL_READY) ||
+			!ftdm_test_flag(check, FTDM_CHANNEL_SIG_UP) ||
+			ftdm_test_flag(check, FTDM_CHANNEL_INUSE) ||
+			ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) ||
+			ftdm_test_flag(check, FTDM_CHANNEL_IN_ALARM) ||
+			check->state != FTDM_CHANNEL_STATE_DOWN) {
+			return 0;
+		}
 	}
 	return 1;
 }
@@ -5608,16 +5618,61 @@ FT_DECLARE(ftdm_status_t) ftdm_configure_span_signaling(ftdm_span_t *span, const
 	return status;
 }
 
+static void *ftdm_span_service_events(ftdm_thread_t *me, void *obj)
+{
+	int i;
+	unsigned waitms;
+	ftdm_event_t *event;
+	ftdm_status_t status = FTDM_SUCCESS;
+	ftdm_span_t *span = (ftdm_span_t*) obj;
+	short *poll_events = ftdm_malloc(sizeof(short) * span->chan_count);
+
+	memset(poll_events, 0, sizeof(short) * span->chan_count);
+
+	for(i = 1; i <= span->chan_count; i++) {
+		poll_events[i] |= FTDM_EVENTS;
+	}
+
+	while (ftdm_running() && !(ftdm_test_flag(span, FTDM_SPAN_STOP_THREAD))) {
+		waitms = 1000;
+		status = ftdm_span_poll_event(span, waitms, poll_events);
+		switch (status) {
+			case FTDM_FAIL:
+				ftdm_log(FTDM_LOG_CRIT, "%s:Failed to poll span for events\n", span->name);
+				break;
+			case FTDM_TIMEOUT:
+				break;
+			case FTDM_SUCCESS:
+				/* Check if there are any channels that have events available */
+				while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS);
+				break;
+			default:
+				ftdm_log(FTDM_LOG_CRIT, "%s:Unhandled IO event\n", span->name);
+		}
+	}
+	return NULL;
+}
+
 FT_DECLARE(ftdm_status_t) ftdm_span_start(ftdm_span_t *span)
 {
 	ftdm_status_t status = FTDM_FAIL;
-
 	ftdm_mutex_lock(span->mutex);
 
 	if (ftdm_test_flag(span, FTDM_SPAN_STARTED)) {
 		status = FTDM_EINVAL;
 		goto done;
 	}
+	if (span->signal_type == FTDM_SIGTYPE_NONE) {
+		/* If there is no signalling component, start a thread to poll events */
+		status = ftdm_thread_create_detached(ftdm_span_service_events, span);
+		if (status != FTDM_SUCCESS) {
+			ftdm_log(FTDM_LOG_CRIT,"Failed to start span event monitor thread!\n");
+			goto done;
+		}
+
+		status = ftdm_report_initial_channels_alarms(span);
+		goto done;
+	}
 
 	if (!span->start) {
 		status = FTDM_ENOSYS;
@@ -5633,7 +5688,6 @@ FT_DECLARE(ftdm_status_t) ftdm_span_start(ftdm_span_t *span)
 	if (status == FTDM_SUCCESS) {
 		ftdm_set_flag_locked(span, FTDM_SPAN_STARTED);
 	}
-
 done:
 	ftdm_mutex_unlock(span->mutex);
 	return status;
diff --git a/src/mod/endpoints/mod_media_gateway/media_gateway.c b/src/mod/endpoints/mod_media_gateway/media_gateway.c
index 8580844172..e47055236a 100644
--- a/src/mod/endpoints/mod_media_gateway/media_gateway.c
+++ b/src/mod/endpoints/mod_media_gateway/media_gateway.c
@@ -88,19 +88,6 @@ switch_status_t megaco_activate_termination(mg_termination_t *term)
     switch_status_t status = SWITCH_STATUS_SUCCESS;
     char dialstring[100];
     switch_call_cause_t cause;
-    
-    if (!zstr(term->uuid)) {
-        /* A UUID is present, check if the channel still exists */
-        switch_core_session_t *session;
-        if ((session = switch_core_session_locate(term->uuid))) {
-            switch_core_session_rwunlock(session);
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Channel [%s] already exists for termination [%s]\n", term->uuid, term->name);
-            return SWITCH_STATUS_SUCCESS;
-        }
-        
-        /* The referenced channel doesn't exist anymore, clear it */
-        term->uuid = NULL;
-    }
 
     switch_event_create(&var_event, SWITCH_EVENT_CLONE);
     
@@ -120,20 +107,44 @@ switch_status_t megaco_activate_termination(mg_termination_t *term)
     } else if (term->type == MG_TERM_TDM) {
         switch_snprintf(dialstring, sizeof dialstring, "tdm/%s", term->name);
         
-        switch_event_add_header(var_event, SWITCH_STACK_BOTTOM, kSPAN_ID, "%d", term->u.tdm.span);
+        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, kSPAN_NAME,  term->u.tdm.span_name);
         switch_event_add_header(var_event, SWITCH_STACK_BOTTOM, kCHAN_ID, "%d", term->u.tdm.channel);
     }
     
     /* Set common variables on the channel */
     switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, "true");
+    
+    if (!zstr(term->uuid)) {
+        /* A UUID is present, check if the channel still exists */
+        switch_core_session_t *session;
+        if ((session = switch_core_session_locate(term->uuid))) {
+            switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "command", "media_modify");
+            
+            switch_core_session_receive_event(session, &var_event);
 
-    if (switch_ivr_originate(NULL, &session, &cause, dialstring, 0, NULL, NULL, NULL, NULL, var_event, 0, NULL) != SWITCH_CAUSE_SUCCESS) {
-        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to instanciate termination [%s]: %s\n", term->name, switch_channel_cause2str(cause));   
-        status = SWITCH_STATUS_FALSE;
-        goto done;
+            switch_core_session_rwunlock(session);
+            
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sent refresh to channel [%s], for termination [%s]\n", term->uuid, term->name);
+            
+            return SWITCH_STATUS_SUCCESS;
+        }
+        
+        /* The referenced channel doesn't exist anymore, clear it */
+        term->uuid = NULL;
     }
     
-    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Termination [%s] successfully instanciated as [%s] [%s]\n", term->name, dialstring, switch_core_session_get_uuid(session));
+    if (zstr(term->uuid)) {    
+        if (switch_ivr_originate(NULL, &session, &cause, dialstring, 0, NULL, NULL, NULL, NULL, var_event, 0, NULL) != SWITCH_STATUS_SUCCESS) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to instanciate termination [%s]: %s\n", term->name, switch_channel_cause2str(cause));   
+            status = SWITCH_STATUS_FALSE;
+            goto done;
+        }
+        
+        term->uuid = switch_core_strdup(term->pool, switch_core_session_get_uuid(session));
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Termination [%s] successfully instanciated as [%s] [%s]\n", term->name, dialstring, switch_core_session_get_uuid(session));   
+    }
+    
+    switch_set_flag(term, MGT_ACTIVE);
     
 done:
     if (session) {
@@ -151,6 +162,7 @@ mg_termination_t *megaco_choose_termination(megaco_profile_t *profile, const cha
     mg_termination_t *term = NULL;
     char name[100];
     int term_id;
+    size_t prefixlen = strlen(prefix);
     
     /* Check the termination type by prefix */
     if (strncasecmp(prefix, profile->rtp_termination_id_prefix, strlen(profile->rtp_termination_id_prefix)) == 0) {
@@ -158,8 +170,14 @@ mg_termination_t *megaco_choose_termination(megaco_profile_t *profile, const cha
         term_id = mg_rtp_request_id(profile);
         switch_snprintf(name, sizeof name, "%s/%d", profile->rtp_termination_id_prefix, term_id);
     } else {
+        for (term = profile->physical_terminations; term; term = term->next) {
+            if (!switch_test_flag(term, MGT_ALLOCATED) && !strncasecmp(prefix, term->name, prefixlen)) {
+                switch_set_flag(term, MGT_ALLOCATED);
+                return term;
+            }
+        }
         
-        return term;
+        return NULL;
     }
     
     switch_core_new_memory_pool(&pool);
@@ -167,7 +185,9 @@ mg_termination_t *megaco_choose_termination(megaco_profile_t *profile, const cha
     term->pool = pool;
     term->type = termtype;
     term->active_events = NULL;
+    term->mg_ctxt = NULL;
     term->profile = profile;
+    switch_set_flag(term, MGT_ALLOCATED);
     
     if (termtype == MG_TERM_RTP) {
         /* Fill in local address and reserve an rtp port */
@@ -175,6 +195,7 @@ mg_termination_t *megaco_choose_termination(megaco_profile_t *profile, const cha
         term->u.rtp.local_port = switch_rtp_request_port(term->u.rtp.local_addr);
         term->u.rtp.codec = megaco_codec_str(profile->default_codec);
         term->u.rtp.term_id = term_id;
+        term->u.rtp.ptime = 20;
         term->name = switch_core_strdup(term->pool, name);
     }
     
@@ -211,6 +232,11 @@ void megaco_termination_destroy(mg_termination_t *term)
         free(term->active_events);
         term->active_events = NULL;
     }
+
+    term->mg_ctxt = NULL;
+    
+    switch_clear_flag(term, MGT_ALLOCATED);
+    switch_clear_flag(term, MGT_ACTIVE);
     
     if (term->type == MG_TERM_RTP) {
         switch_core_hash_delete_wrlock(term->profile->terminations, term->name, term->profile->terminations_rwlock);
@@ -263,6 +289,10 @@ switch_status_t megaco_context_add_termination(mg_context_t *ctx, mg_termination
             megaco_activate_termination(ctx->terminations[1]);
         }
         
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Bridging: %s (%s) <> %s (%s)\n", 
+                          ctx->terminations[0]->name, ctx->terminations[0]->uuid,
+                          ctx->terminations[1]->name, ctx->terminations[1]->uuid);
+        
         switch_ivr_uuid_bridge(ctx->terminations[0]->uuid, ctx->terminations[1]->uuid);
     }
 
diff --git a/src/mod/endpoints/mod_media_gateway/media_gateway_cmd_handler.c b/src/mod/endpoints/mod_media_gateway/media_gateway_cmd_handler.c
index 4307a8e91b..185f3fb5a9 100644
--- a/src/mod/endpoints/mod_media_gateway/media_gateway_cmd_handler.c
+++ b/src/mod/endpoints/mod_media_gateway/media_gateway_cmd_handler.c
@@ -142,8 +142,13 @@ switch_status_t mg_is_ito_pkg_req(megaco_profile_t* mg_profile, MgMgcoCommand *c
                                                 (reqEvtPar->u.other.val.u.eq.type.pres == PRSNT_NODEF) &&
                                                 (reqEvtPar->u.other.val.u.eq.type.val == MGT_VALTYPE_UINT32))
                                         {
+#ifdef BIT_64
                                             switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO," Received Inactivity timer value [%d]\n", 
-                                                    (int)reqEvtPar->u.other.val.u.eq.u.decInt.val); 
+                                                    reqEvtPar->u.other.val.u.eq.u.decInt.val); 
+#else
+                                            switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO," Received Inactivity timer value [%ld]\n", 
+                                                    reqEvtPar->u.other.val.u.eq.u.decInt.val); 
+#endif
 
                                             mg_profile->inact_tmr = reqEvtPar->u.other.val.u.eq.u.decInt.val/MG_INACTIVITY_TMR_RESOLUTION;
 
@@ -296,6 +301,8 @@ switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *
                                         }
                                     }
 
+				    mgco_handle_sdp(&local->sdp, term, MG_SDP_LOCAL);
+
                                     break;
                                 }
 
@@ -306,6 +313,7 @@ switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *
                                     remote = &mediaPar->u.remote;
                                     sdp = remote->sdp.info[0];
                                     /* for Matt - same like local descriptor */
+				    mgco_handle_sdp(&remote->sdp, term, MG_SDP_REMOTE);
                                     break;
                                 }
 
@@ -398,12 +406,12 @@ switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *
 
                                     if (mgStream->sl.remote.pres.pres) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got remote stream media description:\n");
-                                        mgco_print_sdp(&mgStream->sl.remote.sdp);
+                                        mgco_handle_sdp(&mgStream->sl.remote.sdp, term, MG_SDP_LOCAL);
                                     }
 
                                     if (mgStream->sl.local.pres.pres) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got local stream media description:\n");
-                                        mgco_print_sdp(&mgStream->sl.local.sdp);
+                                        mgco_handle_sdp(&mgStream->sl.local.sdp, term, MG_SDP_REMOTE);
                                     }
 
                                     break;
@@ -490,6 +498,10 @@ switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *i
     /*MgMgcoStreamDesc*   inc_strm_desc;*/
     MgMgcoAudRetParm *desc;
     mg_context_t* mg_ctxt;
+    int mediaId;
+    MgMgcoLocalDesc   *local = NULL;
+    CmSdpInfoSet      *psdp  = NULL;
+
 
     /* TODO - Kapil dummy line , will need to add with proper code */
     inc_med_desc = &cmd->dl.descs[0]->u.media;
@@ -535,8 +547,14 @@ switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *i
         MG_SET_VAL_PRES(new_ctxtId->val, mg_ctxt->context_id);
     }
     else {
-        /* context already present */
-        memcpy(new_ctxtId, &inc_cmd->contextId,sizeof(MgMgcoContextId));
+	    /* context already present */
+	    memcpy(new_ctxtId, &inc_cmd->contextId,sizeof(MgMgcoContextId));
+	    mg_ctxt =  megaco_get_context(mg_profile, inc_cmd->contextId.val.val);
+	    if(NULL == mg_ctxt){
+		    mg_util_set_err_string(&errTxt, " Resource Failure ");
+		    err_code = MGT_MGCO_RSP_CODE_RSRC_ERROR;
+		    goto error;
+	    }
     }
 
     /********************************************************************/
@@ -544,7 +562,7 @@ switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *i
     if ((NOTPRSNT != termId->type.pres)   &&
             (MGT_TERMID_CHOOSE == termId->type.val)){
 
-        term = megaco_choose_termination(mg_profile, "RTP"); /* TODO - RTP string has be configured one */
+        term = megaco_choose_termination(mg_profile, mg_profile->rtp_termination_id_prefix);
 
         if(NULL == term){
             mg_util_set_err_string(&errTxt, " Resource Failure ");
@@ -552,16 +570,34 @@ switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *i
             goto error;
         }
 
+	if(!term->mg_ctxt){
+		term->mg_ctxt = mg_ctxt;
+	}
+
         switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO," Allocated Termination[%p] with term name[%s]\n", (void*)term, term->name);
 
         is_rtp = 0x01;
 
-        /* TODO - Matt */
-        /* allocate rtp term and associated the same to context */
-        /********************************************************************/
+    /********************************************************************/
     }else{  /* Physical termination */
-        
-        /* get physical termination */
+	    term = megaco_find_termination(mg_profile, (char*)termId->name.lcl.val);
+
+	    if(NULL == term){
+		    mg_util_set_err_string(&errTxt, " Resource Failure ");
+		    err_code = MGT_MGCO_RSP_CODE_RSRC_ERROR;
+		    goto error;
+	    }
+
+	    if(!term->mg_ctxt){
+		    term->mg_ctxt = mg_ctxt;
+	    } else {
+		    switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO," Termination[%s] already in context..rejecting ADD \n", term->name);
+		    mg_util_set_err_string(&errTxt, " Term already is in call ");
+		    err_code = MGT_MGCP_RSP_CODE_PROT_ERROR;
+		    goto error;
+	    }
+
+	    switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_INFO," Allocated Termination[%p] with term name[%s]\n", (void*)term, term->name);
     }
     /********************************************************************/
     /* associate physical termination to context  */
@@ -654,195 +690,209 @@ switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *i
         }
 
         /* copy media descriptor */
-
         desc = rsp.u.mgCmdRsp[0]->u.add.audit.parms[rsp.u.mgCmdRsp[0]->u.add.audit.num.val-1];
         desc->type.pres = PRSNT_NODEF;
         desc->type.val = MGT_MEDIADESC;
         mgUtlCpyMgMgcoMediaDesc(&desc->u.media, inc_med_desc, &rsp.u.mgCmdRsp[0]->memCp);
+	/* see if we have received local descriptor */
+	if((NOTPRSNT != desc->u.media.num.pres) && 
+			(0 != desc->u.media.num.val))
+	{
+		for(mediaId=0; mediaId<desc->u.media.num.val; mediaId++) {
+			if(MGT_MEDIAPAR_LOCAL == desc->u.media.parms[mediaId]->type.val) {
+				local  = &desc->u.media.parms[mediaId]->u.local;
+			}
+		}
+	}
 
-        {
-            /* build local descriptors */
-            /*MgMgcoStreamDesc *stream;*/
-            MgMgcoLocalDesc   *local; 
-            CmSdpInfoSet *psdp;
-            char* ipAddress = "192.168.1.1";
-            MgMgcoMediaDesc* media = &desc->u.media;
+	/* only for RTP */
+	if(is_rtp){
+		/* build local descriptors */
+		/*MgMgcoStreamDesc *stream;*/
+		char* ipAddress[4];// = "192.168.1.1";
+		char* dup = strdup((char*)term->u.rtp.local_addr);
+		MgMgcoMediaDesc* media = &desc->u.media;
 
-            /* Most probably we need to add local descriptor */
+		switch_split(dup,'.',ipAddress);
 
-            /* allocating mem for local descriptor */
-            if (mgUtlGrowList((void ***)&media->parms, sizeof(MgMgcoMediaPar),
-                        &media->num, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
-            {
-                switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
-                return SWITCH_STATUS_FALSE;
-            }
+		/* Most probably we need to add local descriptor */
+		if(!local){
+
+			/* allocating mem for local descriptor */
+			if (mgUtlGrowList((void ***)&media->parms, sizeof(MgMgcoMediaPar),
+						&media->num, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
+			{
+				switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
+				return SWITCH_STATUS_FALSE;
+			}
 
 #if 0
-            /* Kapil - NOT REQUIRED..keeping now just for ref..will delete  asap  */
-            media->parms[media->num.val-1]->type.pres = PRSNT_NODEF;
-            /*media->parms[media->num.val-1]->type.val = MGT_MEDIAPAR_STRPAR;*/
+			/* Kapil - NOT REQUIRED..keeping now just for ref..will delete  asap  */
+			media->parms[media->num.val-1]->type.pres = PRSNT_NODEF;
+			/*media->parms[media->num.val-1]->type.val = MGT_MEDIAPAR_STRPAR;*/
 
-            printf("media->num.val[%d]\n",media->num.val);
+			printf("media->num.val[%d]\n",media->num.val);
 
-            stream = &media->parms[media->num.val-1]->u.stream;
-            stream->pres.pres = PRSNT_NODEF;
-            stream->pres.val = 0x01;
+			stream = &media->parms[media->num.val-1]->u.stream;
+			stream->pres.pres = PRSNT_NODEF;
+			stream->pres.val = 0x01;
 #if 0
-            if(inc_med_desc->num.pres && inc_med_desc->num.val){
-                /* TODO - check stream descriptor type for all medias */
-                inc_strm_desc = &inc_med_desc->parms[0]->u.stream;
-                memcpy(&stream->streamId, &inc_strm_desc->streamId, sizeof(MgMgcoStreamId));
-            }
+			if(inc_med_desc->num.pres && inc_med_desc->num.val){
+				/* TODO - check stream descriptor type for all medias */
+				inc_strm_desc = &inc_med_desc->parms[0]->u.stream;
+				memcpy(&stream->streamId, &inc_strm_desc->streamId, sizeof(MgMgcoStreamId));
+			}
 #endif
 
-            MG_INIT_TOKEN_VALUE(&(stream->streamId), 1);
+			MG_INIT_TOKEN_VALUE(&(stream->streamId), 1);
 
 
-            stream->sl.pres.pres = PRSNT_NODEF;
-            stream->sl.pres.val = 0x01;
+			stream->sl.pres.pres = PRSNT_NODEF;
+			stream->sl.pres.val = 0x01;
 
-            local  = &stream->sl.local;
+			local  = &stream->sl.local;
 #endif
-            media->parms[media->num.val-1]->type.pres = PRSNT_NODEF;
-            media->parms[media->num.val-1]->type.val = MGT_MEDIAPAR_LOCAL;
+			media->parms[media->num.val-1]->type.pres = PRSNT_NODEF;
+			media->parms[media->num.val-1]->type.val = MGT_MEDIAPAR_LOCAL;
 
-            local  = &media->parms[media->num.val-1]->u.local;
+			local  = &media->parms[media->num.val-1]->u.local;
+		}
 
-            local->pres.pres = PRSNT_NODEF;
+		local->pres.pres = PRSNT_NODEF;
 
-            psdp = &(local->sdp);
+		psdp = &(local->sdp);
 
-            if (mgUtlGrowList((void ***)&psdp->info, sizeof(CmSdpInfo),
-                        &psdp->numComp, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
-            {
-                switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
-                return SWITCH_STATUS_FALSE;
-            }
+		if (mgUtlGrowList((void ***)&psdp->info, sizeof(CmSdpInfo),
+					&psdp->numComp, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
+		{
+			switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
+			return SWITCH_STATUS_FALSE;
+		}
 
-            psdp->info[psdp->numComp.val-1]->pres.pres = PRSNT_NODEF;
+		psdp->info[psdp->numComp.val-1]->pres.pres = PRSNT_NODEF;
 
-            /* fill version */
-            /*memcpy(&psdp->info[0]->ver, &prsdp->info[0]->ver, sizeof(TknU16)); */
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->ver),1);
+		/* fill version */
+		/*memcpy(&psdp->info[0]->ver, &prsdp->info[0]->ver, sizeof(TknU16)); */
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->ver),1);
 
-            /* fill orig */
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->orig.pres), 1);
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->orig.type), CM_SDP_SPEC);
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->orig.orig.pres), 1);
+		/* fill orig */
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->orig.pres), 1);
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->orig.type), CM_SDP_SPEC);
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->orig.orig.pres), 1);
 
-            MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->orig.orig.usrName, 1, "-",
-                    &rsp.u.mgCmdRsp[0]->memCp);
-            MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->orig.orig.sessId, 1, "0",
-                    &rsp.u.mgCmdRsp[0]->memCp);
-            MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->orig.orig.sessVer, 1, "0",
-                    &rsp.u.mgCmdRsp[0]->memCp);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.netType.type),
-                    CM_SDP_NET_TYPE_IN);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.addrType), 
-                    CM_SDP_ADDR_TYPE_IPV4);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.addrType), 
-                    CM_SDP_IPV4_IP_UNI);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.addrType),
-                    CM_SDP_IPV4_IP_UNI);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[0]),
-                    ipAddress[0]);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[1]),
-                    ipAddress[1]);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[2]),
-                    ipAddress[2]);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[3]),
-                    ipAddress[3]);
+		MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->orig.orig.usrName, 1, "-",
+				&rsp.u.mgCmdRsp[0]->memCp);
+		MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->orig.orig.sessId, 1, "0",
+				&rsp.u.mgCmdRsp[0]->memCp);
+		MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->orig.orig.sessVer, 1, "0",
+				&rsp.u.mgCmdRsp[0]->memCp);
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.netType.type),
+				CM_SDP_NET_TYPE_IN);
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.addrType), 
+				CM_SDP_ADDR_TYPE_IPV4);
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.addrType), 
+				CM_SDP_IPV4_IP_UNI);
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.addrType),
+				CM_SDP_IPV4_IP_UNI);
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[0]),
+				atoi(ipAddress[0]));
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[1]),
+				atoi(ipAddress[1]));
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[2]),
+				atoi(ipAddress[2]));
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->orig.orig.sdpAddr.u.ip4.u.ip.b[3]),
+				atoi(ipAddress[3]));
 
-            /* fill session name */
-            /* TODO - need to fill proper session name or skip it..*/
-            MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->sessName, 8, "SANGOMA",&rsp.u.mgCmdRsp[0]->memCp);
+		/* fill session name */
+		/* TODO - need to fill proper session name or skip it..*/
+		MG_SET_TKNSTROSXL(psdp->info[psdp->numComp.val-1]->sessName, 8, "SANGOMA",&rsp.u.mgCmdRsp[0]->memCp);
 
 
-            /* Fill the SDP Connection Info */
-            /* "c=" line - ipaddress */
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->conn.netType.type),CM_SDP_NET_TYPE_IN);
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->conn.addrType), CM_SDP_ADDR_TYPE_IPV4);
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->conn.u.ip4.addrType), CM_SDP_IPV4_IP_UNI);
+		/* Fill the SDP Connection Info */
+		/* "c=" line - ipaddress */
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->conn.netType.type),CM_SDP_NET_TYPE_IN);
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->conn.addrType), CM_SDP_ADDR_TYPE_IPV4);
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->conn.u.ip4.addrType), CM_SDP_IPV4_IP_UNI);
 
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[0]), ipAddress[0]);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[1]), ipAddress[1]);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[2]), ipAddress[2]);
-            MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[3]), ipAddress[3]);
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[0]), atoi(ipAddress[0]));
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[1]), atoi(ipAddress[1]));
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[2]), atoi(ipAddress[2]));
+		MG_SET_VAL_PRES( (psdp->info[psdp->numComp.val-1]->conn.u.ip4.u.uniIp.b[3]), atoi(ipAddress[3]));
 
-            /* t= line */
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->sdpTime.pres),1);
+
+		/* t= line */
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->sdpTime.pres),1);
 #if 0
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->sdpTime.sdpOpTimeSet.numComp),0);
-            MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->sdpTime.zoneAdjSet.numComp),0);
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->sdpTime.sdpOpTimeSet.numComp),0);
+		MG_INIT_TOKEN_VALUE(&(psdp->info[psdp->numComp.val-1]->sdpTime.zoneAdjSet.numComp),0);
 #endif
 
-            /* fill media descriptors */
-            {
-                CmSdpMediaDescSet* med = &psdp->info[psdp->numComp.val-1]->mediaDescSet;
-                CmSdpMediaDesc*    media;
+		/* fill media descriptors */
+		{
+			CmSdpMediaDescSet* med = &psdp->info[psdp->numComp.val-1]->mediaDescSet;
+			CmSdpMediaDesc*    media;
 
-                if (mgUtlGrowList((void ***)&med->mediaDesc, sizeof(CmSdpMediaDesc),
-                            &med->numComp, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
-                {
-                    switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
-                    return SWITCH_STATUS_FALSE;
-                }
+			if (mgUtlGrowList((void ***)&med->mediaDesc, sizeof(CmSdpMediaDesc),
+						&med->numComp, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
+			{
+				switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
+				return SWITCH_STATUS_FALSE;
+			}
 
-                media = med->mediaDesc[med->numComp.val-1];
+			media = med->mediaDesc[med->numComp.val-1];
 
-                MG_INIT_TOKEN_VALUE(&(media->pres),1);
+			MG_INIT_TOKEN_VALUE(&(media->pres),1);
 
-                /* Fill CmSdpMediaField */
-                MG_INIT_TOKEN_VALUE(&(media->field.pres),1);
-                MG_INIT_TOKEN_VALUE(&(media->field.mediaType),CM_SDP_MEDIA_AUDIO);
+			/* Fill CmSdpMediaField */
+			MG_INIT_TOKEN_VALUE(&(media->field.pres),1);
+			MG_INIT_TOKEN_VALUE(&(media->field.mediaType),CM_SDP_MEDIA_AUDIO);
 
-                MG_INIT_TOKEN_VALUE(&(media->field.id.type),CM_SDP_VCID_PORT);
-                MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.type),CM_SDP_PORT_INT);
-                MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.u.portInt.pres),1);
-                MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.u.portInt.port.type), CM_SDP_SPEC);
-                MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.u.portInt.port.val), 2904);
+			MG_INIT_TOKEN_VALUE(&(media->field.id.type),CM_SDP_VCID_PORT);
+			MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.type),CM_SDP_PORT_INT);
+			MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.u.portInt.pres),1);
+			MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.u.portInt.port.type), CM_SDP_SPEC);
+			MG_INIT_TOKEN_VALUE(&(media->field.id.u.port.u.portInt.port.val), term->u.rtp.local_port);
 
-                if (mgUtlGrowList((void ***)&media->field.par.pflst, sizeof(CmSdpMedProtoFmts),
-                            &media->field.par.numProtFmts, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
-                {
-                    switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
-                    return SWITCH_STATUS_FALSE;
-                }
+			if (mgUtlGrowList((void ***)&media->field.par.pflst, sizeof(CmSdpMedProtoFmts),
+						&media->field.par.numProtFmts, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
+			{
+				switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
+				return SWITCH_STATUS_FALSE;
+			}
 
-                /* CmSdpMedProtoFmts */
-                MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->prot.type), CM_SDP_MEDIA_PROTO_RTP)
-                MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->prot.u.subtype.type), CM_SDP_PROTO_RTP_AVP);
-                MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->protType), CM_SDP_MEDIA_PROTO_RTP);
+			/* CmSdpMedProtoFmts */
+			MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->prot.type), CM_SDP_MEDIA_PROTO_RTP)
+				MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->prot.u.subtype.type), CM_SDP_PROTO_RTP_AVP);
+			MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->protType), CM_SDP_MEDIA_PROTO_RTP);
 
 
-                if (mgUtlGrowList((void ***)&media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.fmts, sizeof(CmSdpU8OrNil),
-                            &media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.num, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
-                {
-                    switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
-                    return SWITCH_STATUS_FALSE;
-                }
+			if (mgUtlGrowList((void ***)&media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.fmts, sizeof(CmSdpU8OrNil),
+						&media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.num, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
+			{
+				switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
+				return SWITCH_STATUS_FALSE;
+			}
 
-                MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.fmts[0]->type), CM_SDP_SPEC);
+			MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.fmts[0]->type), CM_SDP_SPEC);
 
-                MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.fmts[0]->val), 4);
+			MG_INIT_TOKEN_VALUE(&(media->field.par.pflst[media->field.par.numProtFmts.val-1]->u.rtp.fmts[0]->val), 4);
 
-                /* Fill attribute if reqd */
-                {
-                    if (mgUtlGrowList((void ***)&media->attrSet.attr, sizeof(CmSdpAttr),
-                                &media->attrSet.numComp, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
-                    {
-                        switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
-                        return SWITCH_STATUS_FALSE;
-                    }
+			/* Fill attribute if reqd */
+			{
+				if (mgUtlGrowList((void ***)&media->attrSet.attr, sizeof(CmSdpAttr),
+							&media->attrSet.numComp, &rsp.u.mgCmdRsp[0]->memCp) != ROK)
+				{
+					switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_ERROR,"Grow List failed\n");
+					return SWITCH_STATUS_FALSE;
+				}
 
-                    MG_INIT_TOKEN_VALUE(&(media->attrSet.attr[0]->type),CM_SDP_ATTR_PTIME);
-                    MG_INIT_TOKEN_VALUE(&(media->attrSet.attr[0]->u.ptime),30);
-                }
+				MG_INIT_TOKEN_VALUE(&(media->attrSet.attr[0]->type),CM_SDP_ATTR_PTIME);
+				MG_INIT_TOKEN_VALUE(&(media->attrSet.attr[0]->u.ptime), term->u.rtp.ptime);
+			}
+		}
 
-            }
-
-        }
+		free(dup);
+	}
 
 
         /* We will always send one command at a time..*/
@@ -889,8 +939,8 @@ switch_status_t handle_mg_modify_cmd(megaco_profile_t* mg_profile, MgMgcoCommand
 	MgMgcoInd  	  *mgErr;
 	MgMgcoTermId     *termId;
 	MgMgcoTermIdLst*  termLst;
-    mg_termination_t* term = NULL;
-    switch_status_t  ret;
+	mg_termination_t* term = NULL;
+	switch_status_t  ret;
 	int 		  err_code;
 	/*MgMgcoAmmReq 	  *cmd = &inc_cmd->u.mgCmdInd[0]->cmd.u.mod;*/
 	U32 		   txn_id = inc_cmd->transId.val;
@@ -1004,6 +1054,9 @@ switch_status_t handle_mg_modify_cmd(megaco_profile_t* mg_profile, MgMgcoCommand
 
         ret = mg_prc_descriptors(mg_profile, inc_cmd, term);
 
+	/* SDP updated to termination */
+	
+	megaco_activate_termination(term);
     }
 
 	/********************************************************************/
diff --git a/src/mod/endpoints/mod_media_gateway/media_gateway_stack.h b/src/mod/endpoints/mod_media_gateway/media_gateway_stack.h
index 8c429ef620..e5c16df9c0 100644
--- a/src/mod/endpoints/mod_media_gateway/media_gateway_stack.h
+++ b/src/mod/endpoints/mod_media_gateway/media_gateway_stack.h
@@ -15,6 +15,18 @@
 
 #define MG_INACTIVITY_TMR_RESOLUTION   100          /* mit in ito package is experessed in 10ms steps */
 
+/* rtp/avp profiles */
+#define MG_RTP_AVP_PROFILE_A_LAW 8
+#define MG_RTP_AVP_PROFILE_U_LAW 0
+
+
+typedef enum{
+	MG_SDP_NONE,
+	MG_SDP_LOCAL,
+	MG_SDP_REMOTE,
+}mgco_sdp_types_e;
+
+
 typedef enum{
         SNG_MG_TPT_NONE,
         SNG_MG_TPT_UDP,
@@ -151,7 +163,7 @@ int sng_mgco_mg_get_status(int elemId, MgMngmt* cfm, megaco_profile_t* mg_cfg, m
 
 switch_status_t mg_is_ito_pkg_req(megaco_profile_t* mg_profile, MgMgcoCommand *cmd);
 switch_status_t mg_send_end_of_axn(SuId suId, MgMgcoTransId* transId, MgMgcoContextId* ctxtId, TknU32* peerId);
-void mgco_print_sdp(CmSdpInfoSet *sdp);
+void mgco_handle_sdp(CmSdpInfoSet *sdp,mg_termination_t* term, mgco_sdp_types_e sdp_type);
 void mg_util_set_ctxt_string ( MgStr  *errTxt, MgMgcoContextId     *ctxtId);
 switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *inc_cmd, MgMgcoContextId* new_ctxtId);
 switch_status_t handle_mg_subtract_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *inc_cmd);
diff --git a/src/mod/endpoints/mod_media_gateway/media_gateway_utils.c b/src/mod/endpoints/mod_media_gateway/media_gateway_utils.c
index 4e4d34b736..e5d08c1d84 100644
--- a/src/mod/endpoints/mod_media_gateway/media_gateway_utils.c
+++ b/src/mod/endpoints/mod_media_gateway/media_gateway_utils.c
@@ -112,8 +112,6 @@ S16 mg_fill_mgco_termid ( MgMgcoTermId  *termId, char* term_str, int term_len, C
         /*MG_GETMEM(termId->name.lcl.val, termId->name.lcl.len , memCp, ret);*/
         ret = mg_stack_alloc_mem((Ptr*)&termId->name.lcl.val,term_len);
 
-        printf("termId->name.lcl.val[%p]\n",termId->name.lcl.val);
-
         if( ret != ROK)
             RETVALUE(ret);          
 
@@ -121,7 +119,7 @@ S16 mg_fill_mgco_termid ( MgMgcoTermId  *termId, char* term_str, int term_len, C
         strncpy((char*)(termId->name.lcl.val), term_str, termId->name.lcl.len);
         termId->name.lcl.val[termId->name.lcl.len] = '\0';
 
-        printf("mg_fill_mgco_termid: name.lcl.val[%s], len[%d], term_str[%s], term_len[%d]\n",termId->name.lcl.val, termId->name.lcl.len, term_str,term_len);
+       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"mg_fill_mgco_termid: name.lcl.val[%s], len[%d], term_str[%s], term_len[%d]\n",termId->name.lcl.val, termId->name.lcl.len, term_str,term_len);
     }
 	      
 
@@ -740,8 +738,11 @@ void mgco_print_sdp_attr_set(CmSdpAttrSet *s)
 
 }
 
-void mgco_print_sdp_c_line(CmSdpConn *s)
+void mgco_handle_sdp_c_line(CmSdpConn *s, mg_termination_t* term, mgco_sdp_types_e sdp_type)
 {
+    char ipadd[32];
+    memset(ipadd, 0, sizeof(ipadd));
+
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "********** SDP connection line ****** \n");
 
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Net Type = %d \n", 
@@ -760,7 +761,20 @@ void mgco_print_sdp_c_line(CmSdpConn *s)
                     s->u.ip4.u.uniIp.b[1].val,
                     s->u.ip4.u.uniIp.b[2].val,
                     s->u.ip4.u.uniIp.b[3].val);
-        }
+
+	    if(MG_SDP_REMOTE == sdp_type) {
+		    sprintf(ipadd,"%d.%d.%d.%d",
+				    s->u.ip4.u.uniIp.b[0].val,
+				    s->u.ip4.u.uniIp.b[1].val,
+				    s->u.ip4.u.uniIp.b[2].val,
+				    s->u.ip4.u.uniIp.b[3].val);
+		    /* update remote ip */
+		    if(MG_TERM_RTP == term->type){
+			    term->u.rtp.remote_addr = switch_core_strdup(term->pool,ipadd); 
+			    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Update remote ip to [%s]\n", term->u.rtp.remote_addr);
+		    }
+	    }
+	}
     }
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "**************** \n");
 }
@@ -772,7 +786,7 @@ void mgco_print_CmSdpU8OrNil(CmSdpU8OrNil* p)
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"CmSdpU8OrNil: Value = %d \n", (NOTPRSNT != p->val.pres)?p->val.val:-1); 
 }
 
-void mgco_print_sdp_media_param(CmSdpMedPar *s)
+void mgco_print_sdp_media_param(CmSdpMedPar *s, mg_termination_t* term, mgco_sdp_types_e sdp_type)
 {
     int i=0x00;
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "***** Media Parameter *********** \n");
@@ -815,6 +829,12 @@ void mgco_print_sdp_media_param(CmSdpMedPar *s)
 
                             for(i=0;i<r->num.val;i++){
                                 mgco_print_CmSdpU8OrNil(r->fmts[i]);
+
+				if(MG_RTP_AVP_PROFILE_A_LAW == r->fmts[i]->val.val){
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, " MG_RTP_AVP_PROFILE_A_LAW: \n"); 
+				}else if(MG_RTP_AVP_PROFILE_U_LAW == r->fmts[i]->val.val){
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, " MG_RTP_AVP_PROFILE_U_LAW: \n"); 
+				}
                             }
                         }
                         break;
@@ -834,255 +854,263 @@ void mgco_print_sdp_media_param(CmSdpMedPar *s)
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "**************** \n");
 }
 
-void mgco_print_sdp(CmSdpInfoSet *sdp)
+void mgco_handle_sdp(CmSdpInfoSet *sdp, mg_termination_t* term, mgco_sdp_types_e sdp_type)
 {
-    int i;
+	int i;
+
+	if (sdp->numComp.pres == NOTPRSNT) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, " No %s SDP present \n", (MG_SDP_LOCAL== sdp_type)?"MG_SDP_LOCAL":"MG_SDP_REMOTE");
+		return;
+	}
+
+	for (i = 0; i < sdp->numComp.val; i++) {
+		CmSdpInfo *s = sdp->info[i];
+		int mediaId;
+
+		/************************************************************************************************************************/
+		/* info presence check */
+		if(NOTPRSNT == s->pres.pres) continue;
+
+		/************************************************************************************************************************/
+		/* Version */
+		if(NOTPRSNT != s->ver.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, " SDP Version = %d \n", s->ver.val);
+		}
+
+		/************************************************************************************************************************/
+		/* Orig */
+		if(NOTPRSNT != s->orig.pres.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "********** SDP orig line ****** \n \t Type = %d \n", s->orig.type.val);
+
+			if(NOTPRSNT != s->orig.orig.pres.pres) {
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t User Name = %s \n", 
+						(NOTPRSNT != s->orig.orig.usrName.pres)?(char*)s->orig.orig.usrName.val:"Not Present");
+
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Id = %s \n", 
+						(NOTPRSNT != s->orig.orig.sessId.pres)?(char*)s->orig.orig.sessId.val:"Not Present");
+
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Version = %s \n", 
+						(NOTPRSNT != s->orig.orig.sessVer.pres)?(char*)s->orig.orig.sessVer.val:"Not Present");
+
+				/* sdpAddr */
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Net Type = %d \n", 
+						(NOTPRSNT != s->orig.orig.sdpAddr.netType.type.pres)?s->orig.orig.sdpAddr.netType.type.val:-1);
+
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Address Type = %d \n", 
+						(NOTPRSNT != s->orig.orig.sdpAddr.addrType.pres)?s->orig.orig.sdpAddr.addrType.val:-1);
+
+				/* print IPV4 address */
+				if (s->orig.orig.sdpAddr.addrType.pres && s->orig.orig.sdpAddr.addrType.val == CM_SDP_ADDR_TYPE_IPV4 &&
+						s->orig.orig.sdpAddr.netType.type.val == CM_SDP_NET_TYPE_IN &&
+						s->orig.orig.sdpAddr.u.ip4.addrType.val == CM_SDP_IPV4_IP_UNI) {
+
+					if (s->orig.orig.sdpAddr.u.ip4.addrType.pres) {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Address: %d.%d.%d.%d\n",
+								s->orig.orig.sdpAddr.u.ip4.u.ip.b[0].val,
+								s->orig.orig.sdpAddr.u.ip4.u.ip.b[1].val,
+								s->orig.orig.sdpAddr.u.ip4.u.ip.b[2].val,
+								s->orig.orig.sdpAddr.u.ip4.u.ip.b[3].val);
+					}
+
+				}else{
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t O-line not present \n"); 
+				}
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "********** ****** \n");
+			}
+		} else{
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t O-line not present \n"); 
+		}
+		/************************************************************************************************************************/
+		/* Session Name (s = line) */
+
+		if(NOTPRSNT != s->sessName.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Name = %s \n", s->sessName.val); 
+		} else{
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t s-line not present \n"); 
+		}
+
+		/************************************************************************************************************************/
+		/* Session Info(i= line) */
+
+		if(NOTPRSNT != s->info.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Info = %s \n", s->info.val); 
+		} else{
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t i-line not present \n"); 
+		}
+
+		/************************************************************************************************************************/
+		/* Session Uri */
+
+		if(NOTPRSNT != s->uri.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Uri = %s \n", s->uri.val); 
+		} else{
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t uri not present \n"); 
+		}
+
+		/************************************************************************************************************************/
+		/* E-Mail */
+		/* TODO */
 
 
-    if (sdp->numComp.pres == NOTPRSNT) {
-        return;
-    }
-
-    for (i = 0; i < sdp->numComp.val; i++) {
-        CmSdpInfo *s = sdp->info[i];
-        int mediaId;
-
-        /************************************************************************************************************************/
-        /* info presence check */
-        if(NOTPRSNT == s->pres.pres) continue;
-
-        /************************************************************************************************************************/
-        /* Version */
-        if(NOTPRSNT != s->ver.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, " SDP Version = %d \n", s->ver.val);
-        }
-
-        /************************************************************************************************************************/
-        /* Orig */
-        if(NOTPRSNT != s->orig.pres.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "********** SDP orig line ****** \n \t Type = %d \n", s->orig.type.val);
-
-            if(NOTPRSNT != s->orig.orig.pres.pres) {
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t User Name = %s \n", 
-                        (NOTPRSNT != s->orig.orig.usrName.pres)?(char*)s->orig.orig.usrName.val:"Not Present");
-
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Id = %s \n", 
-                        (NOTPRSNT != s->orig.orig.sessId.pres)?(char*)s->orig.orig.sessId.val:"Not Present");
-
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Version = %s \n", 
-                        (NOTPRSNT != s->orig.orig.sessVer.pres)?(char*)s->orig.orig.sessVer.val:"Not Present");
-
-                /* sdpAddr */
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Net Type = %d \n", 
-                        (NOTPRSNT != s->orig.orig.sdpAddr.netType.type.pres)?s->orig.orig.sdpAddr.netType.type.val:-1);
-
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Address Type = %d \n", 
-                        (NOTPRSNT != s->orig.orig.sdpAddr.addrType.pres)?s->orig.orig.sdpAddr.addrType.val:-1);
-
-                /* print IPV4 address */
-                if (s->orig.orig.sdpAddr.addrType.pres && s->orig.orig.sdpAddr.addrType.val == CM_SDP_ADDR_TYPE_IPV4 &&
-                        s->orig.orig.sdpAddr.netType.type.val == CM_SDP_NET_TYPE_IN &&
-                        s->orig.orig.sdpAddr.u.ip4.addrType.val == CM_SDP_IPV4_IP_UNI) {
-
-                    if (s->orig.orig.sdpAddr.u.ip4.addrType.pres) {
-                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Address: %d.%d.%d.%d\n",
-                                s->orig.orig.sdpAddr.u.ip4.u.ip.b[0].val,
-                                s->orig.orig.sdpAddr.u.ip4.u.ip.b[1].val,
-                                s->orig.orig.sdpAddr.u.ip4.u.ip.b[2].val,
-                                s->orig.orig.sdpAddr.u.ip4.u.ip.b[3].val);
-                    }
-
-                }else{
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t O-line not present \n"); 
-                }
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "********** ****** \n");
-            }
-        } else{
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t O-line not present \n"); 
-        }
-        /************************************************************************************************************************/
-        /* Session Name (s = line) */
-
-        if(NOTPRSNT != s->sessName.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Name = %s \n", s->sessName.val); 
-        } else{
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t s-line not present \n"); 
-        }
-
-        /************************************************************************************************************************/
-        /* Session Info(i= line) */
-
-        if(NOTPRSNT != s->info.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Info = %s \n", s->info.val); 
-        } else{
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t i-line not present \n"); 
-        }
-
-        /************************************************************************************************************************/
-        /* Session Uri */
-
-        if(NOTPRSNT != s->uri.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Session Uri = %s \n", s->uri.val); 
-        } else{
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t uri not present \n"); 
-        }
-
-        /************************************************************************************************************************/
-        /* E-Mail */
-        /* TODO */
+		/************************************************************************************************************************/
+		/* Phone */
+		/* TODO */
 
 
-        /************************************************************************************************************************/
-        /* Phone */
-        /* TODO */
+		/************************************************************************************************************************/
+		/* connection line */
+
+		mgco_handle_sdp_c_line(&s->conn, term, sdp_type);
+		/************************************************************************************************************************/
+		/* Bandwidth */
+		/* TODO */
+
+		/************************************************************************************************************************/
+		/* SDP Time (t= line)*/
+
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "*** t-line **************** \n");
+		if(NOTPRSNT != s->sdpTime.pres.pres) {
+			if(NOTPRSNT != s->sdpTime.sdpOpTimeSet.numComp.pres) {
+				int i = 0x00;
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP op time present with total component[%d]\n", s->sdpTime.sdpOpTimeSet.numComp.val);
+				for (i = 0;i<s->sdpTime.sdpOpTimeSet.numComp.val;i++){
+					CmSdpOpTime* t = s->sdpTime.sdpOpTimeSet.sdpOpTime[i];
+					if(NOTPRSNT == t->pres.pres) continue;
+
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Start Time = %s \n", 
+							(NOTPRSNT != t->startTime.pres)?(char*)t->startTime.val:"Not Present");
+
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Stop Time = %s \n", 
+							(NOTPRSNT != t->stopTime.pres)?(char*)t->stopTime.val:"Not Present");
+
+					/*repeat time repFieldSet */
+
+					if(NOTPRSNT != t->repFieldSet.numComp.pres) {
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP repeat time present with total component[%d]\n", 
+								t->repFieldSet.numComp.val);
+
+						/*TODO - print repeat fields */
+					}else{
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP repeat time not present \n");
+					}
+				} /* sdpOpTimeSet.numComp for loop -- end */
+			}else{/*sdpOpTimeSet.numComp.pres if -- end */
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP op time not present \n");
+			}
+
+			/*TODO - zoneAdjSet */
+		}else{
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "t-line not present \n");
+		}
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "**************** \n");
 
 
-        /************************************************************************************************************************/
-        /* connection line */
+		/************************************************************************************************************************/
+		/* key type (k= line)*/
 
-        mgco_print_sdp_c_line(&s->conn);
-        /************************************************************************************************************************/
-        /* Bandwidth */
-        /* TODO */
+		if(NOTPRSNT != s->keyType.pres.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Key Type = %d \n", 
+					(NOTPRSNT != s->keyType.keyType.pres)?s->keyType.keyType.val:-1);
 
-        /************************************************************************************************************************/
-        /* SDP Time (t= line)*/
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Key Data = %s \n", 
+					(NOTPRSNT != s->keyType.key_data.pres)?(char*)s->keyType.key_data.val:"Not Present");
+		}else{
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "k-line not present \n");
+		}
 
-        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "*** t-line **************** \n");
-        if(NOTPRSNT != s->sdpTime.pres.pres) {
-            if(NOTPRSNT != s->sdpTime.sdpOpTimeSet.numComp.pres) {
-                int i = 0x00;
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP op time present with total component[%d]\n", s->sdpTime.sdpOpTimeSet.numComp.val);
-                for (i = 0;i<s->sdpTime.sdpOpTimeSet.numComp.val;i++){
-                    CmSdpOpTime* t = s->sdpTime.sdpOpTimeSet.sdpOpTime[i];
-                    if(NOTPRSNT == t->pres.pres) continue;
+		/************************************************************************************************************************/
+		/* Attribute Set */
 
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Start Time = %s \n", 
-                            (NOTPRSNT != t->startTime.pres)?(char*)t->startTime.val:"Not Present");
+		mgco_print_sdp_attr_set(&s->attrSet);
 
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Stop Time = %s \n", 
-                            (NOTPRSNT != t->stopTime.pres)?(char*)t->stopTime.val:"Not Present");
+		/************************************************************************************************************************/
+		/* Media Descriptor Set */
 
-                    /*repeat time repFieldSet */
+		if (s->mediaDescSet.numComp.pres) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "****** Media Descriptor Set present with numComp[%d]\n", s->mediaDescSet.numComp.val);
+			for (mediaId = 0; mediaId < s->mediaDescSet.numComp.val; mediaId++) {
+				CmSdpMediaDesc *desc = s->mediaDescSet.mediaDesc[mediaId];
 
-                    if(NOTPRSNT != t->repFieldSet.numComp.pres) {
-                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP repeat time present with total component[%d]\n", 
-                                t->repFieldSet.numComp.val);
+				if(NOTPRSNT == desc->pres.pres) continue;
 
-                        /*TODO - print repeat fields */
-                    }else{
-                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP repeat time not present \n");
-                    }
-                } /* sdpOpTimeSet.numComp for loop -- end */
-            }else{/*sdpOpTimeSet.numComp.pres if -- end */
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "SDP op time not present \n");
-            }
+				/* Media Field */
+				{
+					CmSdpMediaField* f = &desc->field; 
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Media Type = %d \n",(NOTPRSNT == f->mediaType.pres)?f->mediaType.val:-1);
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Media  = %s \n",(NOTPRSNT == f->media.pres)?(char*)f->media.val:"Not Present");
+					/* Channel ID */
+					if(NOTPRSNT != f->id.type.pres){
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t VcId Type = %d \n", f->id.type.val);
+						switch(f->id.type.val){
+							case CM_SDP_VCID_PORT:
+								{
+									CmSdpPort         *p = &f->id.u.port;
+									switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "CM_SDP_VCID_PORT:\n");
+									switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t SDP port type = %d \n", (NOTPRSNT == p->type.pres)?p->type.val:-1);
+									switch(p->type.val)
+									{
+										case CM_SDP_PORT_INT:
+											{
+												switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,
+														  "\t CM_SDP_PORT_INT: SDP port = %d  type = %d \n", 
+														 p->u.portInt.port.val.val, p->u.portInt.port.type.val);
+												if(MG_SDP_REMOTE == sdp_type) {
+												/* update remote information */
+													if(MG_TERM_RTP == term->type){
+														term->u.rtp.remote_port = p->u.portInt.port.val.val;
+														printf("Update remote port to [%d]\n", term->u.rtp.remote_port);
+													}
+												}
+												break;
+											}
+										case CM_SDP_PORT_VPCID:
+											{
+												switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t CM_SDP_PORT_VPCID: \n"); 
+												break;
+											}
+										default:
+											break;
+									}
+									break;
+								}
+							default:
+								break;
+						}
+					}
+					mgco_print_sdp_media_param(&f->par, term, sdp_type);
+				}
 
-            /*TODO - zoneAdjSet */
-        }else{
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "t-line not present \n");
-        }
-        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "**************** \n");
+				/*info */
+				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Info  = %s \n",(NOTPRSNT == desc->info.pres)?(char*)desc->info.val:"Not Present");
+
+				/*connection set */
+				{
+					int cnt=0x00;
+					if(NOTPRSNT != desc->connSet.numComp.pres){
+						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Number of Connection component[%d]\n",desc->connSet.numComp.val); 
+						for(cnt=0;cnt<desc->connSet.numComp.val;cnt++){
+							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "************************\n");
+							mgco_handle_sdp_c_line(desc->connSet.connSet[cnt], term, sdp_type);
+							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "************************\n");
+						}
+					}
+				}
+
+				/* attribute set */
+				mgco_print_sdp_attr_set(&desc->attrSet);
 
 
-        /************************************************************************************************************************/
-        /* key type (k= line)*/
+				if (desc->field.mediaType.val == CM_SDP_MEDIA_AUDIO &&
+						desc->field.id.type.val ==  CM_SDP_VCID_PORT &&
+						desc->field.id.u.port.type.val == CM_SDP_PORT_INT &&
+						desc->field.id.u.port.u.portInt.port.type.val == CM_SDP_SPEC) {
+					int port = desc->field.id.u.port.u.portInt.port.val.val;
 
-        if(NOTPRSNT != s->keyType.pres.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Key Type = %d \n", 
-                    (NOTPRSNT != s->keyType.keyType.pres)?s->keyType.keyType.val:-1);
-
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Key Data = %s \n", 
-                    (NOTPRSNT != s->keyType.key_data.pres)?(char*)s->keyType.key_data.val:"Not Present");
-        }else{
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "k-line not present \n");
-        }
-
-        /************************************************************************************************************************/
-        /* Attribute Set */
-
-        mgco_print_sdp_attr_set(&s->attrSet);
-        
-        /************************************************************************************************************************/
-        /* Media Descriptor Set */
-
-        if (s->mediaDescSet.numComp.pres) {
-            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "****** Media Descriptor Set present with numComp[%d]\n", s->mediaDescSet.numComp.val);
-            for (mediaId = 0; mediaId < s->mediaDescSet.numComp.val; mediaId++) {
-                CmSdpMediaDesc *desc = s->mediaDescSet.mediaDesc[mediaId];
-
-                if(NOTPRSNT == desc->pres.pres) continue;
-
-                /* Media Field */
-                {
-                    CmSdpMediaField* f = &desc->field; 
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Media Type = %d \n",(NOTPRSNT == f->mediaType.pres)?f->mediaType.val:-1);
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Media  = %s \n",(NOTPRSNT == f->media.pres)?(char*)f->media.val:"Not Present");
-                    /* Channel ID */
-                    if(NOTPRSNT != f->id.type.pres){
-                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t VcId Type = %d \n", f->id.type.val);
-                        switch(f->id.type.val){
-                            case CM_SDP_VCID_PORT:
-                                {
-                                    CmSdpPort         *p = &f->id.u.port;
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "CM_SDP_VCID_PORT:\n");
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t SDP port type = %d \n", (NOTPRSNT == p->type.pres)?p->type.val:-1);
-                                    switch(p->type.val)
-                                    {
-                                        case CM_SDP_PORT_INT:
-                                            {
-                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t CM_SDP_PORT_INT: SDP port = %d  type = %d \n", p->u.portInt.port.val.val, p->u.portInt.port.type.val);
-                                                break;
-                                            }
-                                        case CM_SDP_PORT_VPCID:
-                                            {
-                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t CM_SDP_PORT_VPCID: \n"); 
-                                                break;
-                                            }
-                                        default:
-                                            break;
-                                    }
-                                    break;
-                                }
-                            default:
-                                break;
-                        }
-                    }
-                    mgco_print_sdp_media_param(&f->par);
-                }
-
-                /*info */
-                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Info  = %s \n",(NOTPRSNT == desc->info.pres)?(char*)desc->info.val:"Not Present");
-
-                /*connection set */
-                {
-                    int cnt=0x00;
-                    if(NOTPRSNT != desc->connSet.numComp.pres){
-                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\t Number of Connection component[%d]\n",desc->connSet.numComp.val); 
-                        for(cnt=0;cnt<desc->connSet.numComp.val;cnt++){
-                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "************************\n");
-                            mgco_print_sdp_c_line(desc->connSet.connSet[cnt]);
-                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "************************\n");
-                        }
-                    }
-                }
-
-                /* attribute set */
-                mgco_print_sdp_attr_set(&desc->attrSet);
-
-
-                if (desc->field.mediaType.val == CM_SDP_MEDIA_AUDIO &&
-                        desc->field.id.type.val ==  CM_SDP_VCID_PORT &&
-                        desc->field.id.u.port.type.val == CM_SDP_PORT_INT &&
-                        desc->field.id.u.port.u.portInt.port.type.val == CM_SDP_SPEC) {
-                    int port = desc->field.id.u.port.u.portInt.port.val.val;
-
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Port: %d\n", port);
-
-                }
-            }
-        }
-    }
+					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Port: %d\n", port);
+				}
+			}
+		}
+	}
 }
 
 /*****************************************************************************************************************************/
diff --git a/src/mod/endpoints/mod_media_gateway/media_gateway_xml.c b/src/mod/endpoints/mod_media_gateway/media_gateway_xml.c
index 0d6390a173..e3c3b8c3de 100644
--- a/src/mod/endpoints/mod_media_gateway/media_gateway_xml.c
+++ b/src/mod/endpoints/mod_media_gateway/media_gateway_xml.c
@@ -65,6 +65,60 @@ switch_status_t config_profile(megaco_profile_t *profile, switch_bool_t reload)
 
 
 		profile->idx = ++mg_sap_id;
+        
+        
+        if ((mg_phys_terms = switch_xml_child(mg_interface, "physical_terminations"))) {
+            for (mg_term = switch_xml_child(mg_phys_terms, "map"); mg_term; mg_term = mg_term->next) {
+                switch_memory_pool_t *pool;
+                mg_termination_t *term;
+                // <map  termination-id-prefix="Term1/" termination-id-base="1" tech="freetdm" channel-prefix="wp2" channel-map"1-15,17-31"/>
+                const char *prefix = switch_xml_attr(mg_term, "termination-id-prefix");
+                //const char *sztermination_id_base = switch_xml_attr(mg_term, "termination-id-base");
+                //const char *tech =  switch_xml_attr(mg_term, "tech");
+                const char *channel_prefix = switch_xml_attr(mg_term, "channel-prefix");
+                const char *channel_map = switch_xml_attr(mg_term, "channel-map");
+                
+                
+                if (!zstr(channel_map)) {
+                    /* Split channel-map */
+                    char *channel_map_dup = strdup(channel_map);
+                    char *chanmap[24];
+                    int chanmap_count, i;
+                    chanmap_count = switch_split(channel_map_dup, ' ', chanmap);
+                    for (i = 0; i < chanmap_count; i++) {
+                        char *p = strchr(chanmap[i], '-');
+                        if (p) {
+                            int startchan, endchan, j;
+                            *p++ = '\0';
+                            startchan = atoi(chanmap[i]);
+                            endchan = atoi(p);
+                            
+                            for (j = startchan; j < endchan; j++) {
+                                switch_core_new_memory_pool(&pool);
+                                term = switch_core_alloc(profile->pool, sizeof *term);
+                                term->pool = pool;
+                                term->type = MG_TERM_TDM;
+                                term->profile = profile;
+                                term->mg_ctxt = NULL;
+				term->active_events = NULL;
+                                term->name = switch_core_sprintf(pool, "%s%d", prefix, j);
+                                term->u.tdm.channel = j;
+                                term->u.tdm.span_name = switch_core_strdup(pool, channel_prefix);
+                                
+                                switch_core_hash_insert_wrlock(profile->terminations, term->name, term, profile->terminations_rwlock);
+                                term->next = profile->physical_terminations;
+                                profile->physical_terminations = term;
+                                
+                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Mapped termination [%s] to freetdm span: %s chan: %d\n", term->name, term->u.tdm.span_name, term->u.tdm.channel);
+                            }
+                        }
+                    }
+                    
+                    free(channel_map_dup);
+                }
+            }
+        }
+
 
 		/* we should break from here , profile name should be unique */
 		break;
@@ -113,59 +167,6 @@ switch_status_t config_profile(megaco_profile_t *profile, switch_bool_t reload)
 		}
 	}
     
-    
-    if ((mg_phys_terms = switch_xml_child(cfg, "physical_terminations"))) {
-        
-        for (mg_term = switch_xml_child(mg_phys_terms, "map"); mg_term; mg_term = mg_term->next) {
-            switch_memory_pool_t *pool;
-            mg_termination_t *term;
-            // <map  termination-id-prefix="Term1/" termination-id-base="1" tech="freetdm" channel-prefix="wp2" channel-map"1-15,17-31"/>
-            const char *prefix = switch_xml_attr(mg_term, "termination-id-prefix");
-            //const char *sztermination_id_base = switch_xml_attr(mg_term, "termination-id-base");
-            //const char *tech =  switch_xml_attr(mg_term, "tech");
-            //const char *channel_prefix = switch_xml_attr(mg_term, "channel-prefix");
-            const char *channel_map = switch_xml_attr(mg_term, "channel-map");
-            const char *szspan_id = switch_xml_attr(mg_term, "span-id");
-            const int span_id = !zstr(szspan_id) ? atoi(szspan_id) : 0;
-            
-            
-            if (!zstr(channel_map)) {
-                /* Split channel-map */
-                char *channel_map_dup = strdup(channel_map);
-                char *chanmap[24];
-                int chanmap_count, i;
-                chanmap_count = switch_split(channel_map_dup, ' ', chanmap);
-                for (i = 0; i < chanmap_count; i++) {
-                    char *p = strchr(chanmap[i], '-');
-                    if (p) {
-                        int startchan, endchan, j;
-                        *p++ = '\0';
-                        startchan = atoi(chanmap[i]);
-                        endchan = atoi(p);
-                        
-                        for (j = startchan; j < endchan; j++) {
-                            switch_core_new_memory_pool(&pool);
-                            term = switch_core_alloc(profile->pool, sizeof *term);
-                            term->pool = pool;
-                            term->type = MG_TERM_TDM;
-                            term->profile = profile;
-                            term->name = switch_core_sprintf(pool, "%s%d", prefix, j);
-                            term->u.tdm.span = span_id;
-                            term->u.tdm.channel = j;
-                            
-                            switch_core_hash_insert_wrlock(profile->terminations, term->name, term, profile->terminations_rwlock);
-                         
-                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Mapped termination [%s] to freetdm span: %d chan: %d\n", term->name, term->u.tdm.span, term->u.tdm.channel);
-                        }
-                    }
-                }
-                
-                free(channel_map_dup);
-            }
-            
-        }
-    }
-
 	/* configure the MEGACO stack */
 	status = sng_mgco_cfg(profile);
 
diff --git a/src/mod/endpoints/mod_media_gateway/mod_media_gateway.c b/src/mod/endpoints/mod_media_gateway/mod_media_gateway.c
index 1533ca7d15..de315d7ae9 100644
--- a/src/mod/endpoints/mod_media_gateway/mod_media_gateway.c
+++ b/src/mod/endpoints/mod_media_gateway/mod_media_gateway.c
@@ -639,7 +639,7 @@ void handle_mgco_cmd_ind(Pst *pst, SuId suId, MgMgcoCommand* cmd)
                             MgMgcoNtfyReply*  ntfy = &cmd->u.mgCmdCfm[0]->u.ntfy;
                             MgMgcoTermId*     term = NULL;
                             char              term_name[32]; 
-                            memset(&term_name[0], 32, 0x00);
+                            memset(&term_name[0], 0x00,32);
 
                             strcpy(&term_name[0], "Invalid");
 
@@ -685,7 +685,7 @@ void handle_mgco_cmd_ind(Pst *pst, SuId suId, MgMgcoCommand* cmd)
                             MgMgcoSvcChgReply*  svc = &cmd->u.mgCmdCfm[0]->u.svc;
                             MgMgcoTermId*     term = NULL;
                             char              term_name[32]; 
-                            memset(&term_name[0], 32, 0x00);
+                            memset(&term_name[0], 0x00, 32);
 
                             strcpy(&term_name[0], "Invalid");
 
diff --git a/src/mod/endpoints/mod_media_gateway/mod_media_gateway.h b/src/mod/endpoints/mod_media_gateway/mod_media_gateway.h
index d74fb31d1e..af53052fbb 100644
--- a/src/mod/endpoints/mod_media_gateway/mod_media_gateway.h
+++ b/src/mod/endpoints/mod_media_gateway/mod_media_gateway.h
@@ -83,10 +83,25 @@ typedef struct mg_context_s mg_context_t;
 /* TDM parameters understood by the controllable channel */
 #define kSPAN_ID "span"
 #define kCHAN_ID "chan"
+#define kSPAN_NAME "span_name"
 
 
 typedef struct mg_termination_s mg_termination_t;
 
+enum {
+    MGT_ALLOCATED = (1 << 0),
+    MGT_ACTIVE = (1 << 1),
+    
+} mg_termination_flags;
+
+struct mg_context_s {
+    uint32_t context_id;
+    mg_termination_t *terminations[MG_CONTEXT_MAX_TERMS];
+    megaco_profile_t *profile;
+    mg_context_t *next;
+    switch_memory_pool_t *pool;
+};
+
 struct mg_termination_s {
     switch_memory_pool_t *pool;
     mg_termination_type_t type;
@@ -96,6 +111,8 @@ struct mg_termination_s {
     megaco_profile_t *profile; /*!< Parent MG profile */
     MgMgcoReqEvtDesc  *active_events;     /* !< active megaco events */
     mg_termination_t *next; /*!< List for physical terminations */
+    mg_context_t* mg_ctxt;
+    uint32_t flags;
     
     union {
         struct {
@@ -116,20 +133,14 @@ struct mg_termination_s {
         } rtp;
         
         struct {
-            int span;
             int channel;
+            const char *span_name;
         } tdm;
     } u;
 };
 
 
-struct mg_context_s {
-    uint32_t context_id;
-    mg_termination_t *terminations[MG_CONTEXT_MAX_TERMS];
-    megaco_profile_t *profile;
-    mg_context_t *next;
-    switch_memory_pool_t *pool;
-};
+
 
 #define MG_CONTEXT_MODULO 16
 #define MG_MAX_CONTEXTS 32768
@@ -165,6 +176,9 @@ struct megaco_profile_s {
     
     uint8_t rtpid_bitmap[MG_MAX_CONTEXTS/8];
     uint32_t rtpid_next;
+    
+    mg_termination_t *physical_terminations;
+    
     switch_hash_t *terminations;
     switch_thread_rwlock_t *terminations_rwlock;
 };
@@ -220,6 +234,7 @@ mg_context_t *megaco_choose_context(megaco_profile_t *profile);
 void megaco_release_context(mg_context_t *ctx);
 switch_status_t megaco_context_sub_termination(mg_context_t *ctx, mg_termination_t *term);
 switch_status_t megaco_context_sub_all_termination(mg_context_t *ctx);
+switch_status_t megaco_activate_termination(mg_termination_t *term);
 
 mg_termination_t *megaco_choose_termination(megaco_profile_t *profile, const char *prefix);
 mg_termination_t *megaco_find_termination(megaco_profile_t *profile, const char *name);
diff --git a/src/mod/endpoints/mod_sofia/rtp.c b/src/mod/endpoints/mod_sofia/rtp.c
index a464beb1be..04feb55a8a 100644
--- a/src/mod/endpoints/mod_sofia/rtp.c
+++ b/src/mod/endpoints/mod_sofia/rtp.c
@@ -93,6 +93,7 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
 static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);
 static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg);
 static switch_status_t channel_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf);
+static switch_status_t channel_receive_event(switch_core_session_t *session, switch_event_t *event);
 
 switch_state_handler_table_t crtp_state_handlers = {
 	.on_init = channel_on_init,
@@ -104,6 +105,7 @@ switch_io_routines_t crtp_io_routines = {
 	.read_frame = channel_read_frame,
 	.write_frame = channel_write_frame,
 	.receive_message = channel_receive_message,
+    .receive_event = channel_receive_event,
     .send_dtmf = channel_send_dtmf
 };
 
@@ -186,11 +188,12 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
     tech_pvt->dtmf_type = DTMF_2833; /* XXX */
     
     if (zstr(local_addr) || local_port == 0) {
-        tech_pvt->mode = RTP_SENDONLY;
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "The local address and port must be set\n");
+        goto fail;
     } else if (zstr(remote_addr) || remote_port == 0) {
-        tech_pvt->mode = RTP_SENDRECV;
+        tech_pvt->mode = RTP_RECVONLY;
     } else {
-        
+        tech_pvt->mode = RTP_SENDRECV;
     }
     
     switch_core_session_set_private(*new_session, tech_pvt);
@@ -312,7 +315,8 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
 	tech_pvt = switch_core_session_get_private(session);
 	assert(tech_pvt != NULL);
     
-    if (!tech_pvt->rtp_session) {
+    if (!tech_pvt->rtp_session || tech_pvt->mode == RTP_SENDONLY) {
+	switch_yield(20000); /* replace by local timer XXX */
         goto cng;
     }
         
@@ -323,6 +327,7 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
     }
     
     tech_pvt->read_frame.flags = SFF_NONE;
+    tech_pvt->read_frame.codec = &tech_pvt->read_codec;
     status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame, flags);
 
     if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
@@ -334,6 +339,7 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
     
 cng:
     *frame = &tech_pvt->read_frame;
+    tech_pvt->read_frame.codec = &tech_pvt->read_codec;
     tech_pvt->read_frame.flags |= SFF_CNG;
     tech_pvt->read_frame.datalen = 0;
     
@@ -366,8 +372,11 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc
     
     tech_pvt->timestamp_send += samples;
 #endif
-    
-	switch_rtp_write_frame(tech_pvt->rtp_session, frame);
+    if (tech_pvt->mode == RTP_RECVONLY) {
+	return SWITCH_STATUS_SUCCESS;
+    }
+
+    switch_rtp_write_frame(tech_pvt->rtp_session, frame);
 
     return SWITCH_STATUS_SUCCESS;
 }
@@ -395,6 +404,68 @@ static switch_status_t channel_send_dtmf(switch_core_session_t *session, const s
     return SWITCH_STATUS_SUCCESS;
 }
 
+static switch_bool_t compare_var(switch_event_t *event, switch_channel_t *channel, const char *varname)
+{
+    const char *chan_val = switch_channel_get_variable_dup(channel, varname, SWITCH_FALSE, -1);
+    const char *event_val = switch_event_get_header(event, varname);
+
+    if (zstr(chan_val) || zstr(event_val)) {
+	return 1;
+    }    
+
+    return strcasecmp(chan_val, event_val);
+}
+
+static switch_status_t channel_receive_event(switch_core_session_t *session, switch_event_t *event)
+{
+    const char *command = switch_event_get_header(event, "command");
+    switch_channel_t *channel = switch_core_session_get_channel(session);
+    crtp_private_t *tech_pvt = switch_core_session_get_private(session);
+    
+    if (!zstr(command) && !strcasecmp(command, "media_modify")) {
+        /* Compare parameters */
+        if (compare_var(event, channel, kREMOTEADDR) ||
+            compare_var(event, channel, kREMOTEPORT)) {
+            char *remote_addr = switch_event_get_header(event, kREMOTEADDR);
+            char *szremote_port = switch_event_get_header(event, kREMOTEPORT);
+            switch_port_t remote_port = !zstr(szremote_port) ? atoi(szremote_port) : 0;
+            const char *err;
+
+            
+            switch_channel_set_variable(channel, kREMOTEADDR, remote_addr);
+            switch_channel_set_variable(channel, kREMOTEPORT, szremote_port);
+            
+            if (switch_rtp_set_remote_address(tech_pvt->rtp_session, remote_addr, remote_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
+                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error setting RTP remote address: %s\n", err);
+            } else {
+                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set RTP remote: %s:%d\n", remote_addr, (int)remote_port);
+                tech_pvt->mode = RTP_SENDRECV;
+            }
+        }
+        
+        if (compare_var(event, channel, kCODEC) ||
+            compare_var(event, channel, kPTIME) ||
+            compare_var(event, channel, kPT) ||
+            compare_var(event, channel, kRATE)) {
+            /* Reset codec */
+            switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Switching codec not yet implemented\n");
+        }
+        
+        if (compare_var(event, channel, kRFC2833PT)) {
+            const char *szpt = switch_channel_get_variable(channel, kRFC2833PT);
+            int pt = !zstr(szpt) ? atoi(szpt) : 0;
+            
+            switch_channel_set_variable(channel, kRFC2833PT, szpt);
+            switch_rtp_set_telephony_event(tech_pvt->rtp_session, pt);
+        }
+    
+    } else {
+        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Received unknown command [%s] in event.\n", !command ? "null" : command);
+    }
+
+    return SWITCH_STATUS_SUCCESS;
+}
+
 static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
 {
     crtp_private_t *tech_pvt = NULL;
diff --git a/src/switch_channel.c b/src/switch_channel.c
index 138123f3eb..a563a67b1a 100644
--- a/src/switch_channel.c
+++ b/src/switch_channel.c
@@ -4154,8 +4154,8 @@ SWITCH_DECLARE(const char *) switch_channel_get_partner_uuid(switch_channel_t *c
 {
 	const char *uuid = NULL;
 
-	if (!(uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) {
-		uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE);
+	if (!(uuid = switch_channel_get_variable_dup(channel, SWITCH_SIGNAL_BOND_VARIABLE, SWITCH_FALSE, -1))) {
+		uuid = switch_channel_get_variable_dup(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, SWITCH_FALSE, -1);
 	}
 
 	return uuid;
diff --git a/src/switch_rtp.c b/src/switch_rtp.c
index 3bad17ce17..341b005473 100644
--- a/src/switch_rtp.c
+++ b/src/switch_rtp.c
@@ -1451,7 +1451,7 @@ SWITCH_DECLARE(switch_status_t) switch_rtp_add_crypto_key(switch_rtp_t *rtp_sess
 														  uint32_t index, switch_rtp_crypto_key_type_t type, unsigned char *key, switch_size_t keylen)
 {
 #ifndef ENABLE_SRTP
-	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "SRTP NOT SUPPORTED IN THIS BUILD!\n");
+	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SRTP NOT SUPPORTED IN THIS BUILD!\n");
 	return SWITCH_STATUS_FALSE;
 #else
 	switch_rtp_crypto_key_t *crypto_key;
@@ -1832,6 +1832,7 @@ SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
 		goto end;
 	}
 
+#if 0
 	if (zstr(tx_host)) {
 		*err = "Missing remote host";
 		goto end;
@@ -1841,6 +1842,7 @@ SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
 		*err = "Missing remote port";
 		goto end;
 	}
+#endif
 
 	if (switch_rtp_create(&rtp_session, payload, samples_per_interval, ms_per_packet, flags, timer_name, err, pool) != SWITCH_STATUS_SUCCESS) {
 		goto end;
@@ -1854,7 +1856,7 @@ SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
 		goto end;
 	}
 
-	if (switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, 0, SWITCH_TRUE, err) != SWITCH_STATUS_SUCCESS) {
+	if (!zstr(tx_host) && switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, 0, SWITCH_TRUE, err) != SWITCH_STATUS_SUCCESS) {
 		switch_mutex_unlock(rtp_session->flag_mutex);
 		rtp_session = NULL;
 		goto end;
@@ -2161,7 +2163,7 @@ SWITCH_DECLARE(uint8_t) switch_rtp_ready(switch_rtp_t *rtp_session)
 	}
 
 	switch_mutex_lock(rtp_session->flag_mutex);
-	ret = (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO) && rtp_session->sock_input && rtp_session->sock_output && rtp_session->remote_addr
+	ret = (switch_test_flag(rtp_session, SWITCH_RTP_FLAG_IO) && rtp_session->sock_input /* && rtp_session->sock_output && rtp_session->remote_addr */
 		   && rtp_session->ready == 2) ? 1 : 0;
 	switch_mutex_unlock(rtp_session->flag_mutex);