fix conflict

libs/freetdm/mod_freetdm/mod_freetdm.c

@@ -5069,7 +5069,8 @@ static ftdm_cli_entry_t ftdm_cli_options[] =
 	/* Fake handlers as they are handled within freetdm library,
 	 * we should provide a way inside freetdm to query for completions from signaling modules */
 	{ "core state", "[!]<state_name>", "", NULL },
-	{ "core flag", "[!]<flag_value>", "", NULL },
+	{ "core flag", "[!]<flag-int-value|flag-name> [<span_id|span_name>] [<chan_id>]", "", NULL },
+	{ "core spanflag", "[!]<flag-int-value|flag-name> [<span_id|span_name>]", "", NULL },
 	{ "core calls", "", "", NULL },
 };
 

libs/freetdm/src/ftdm_io.c

@@ -63,12 +63,78 @@ struct tm *localtime_r(const time_t *clock, struct tm *result);
 ftdm_time_t time_last_throttle_log = 0;
 ftdm_time_t time_current_throttle_log = 0;
 
+typedef struct val_str {
+	const char *str;
+	unsigned long long val;
+} val_str_t;
+
+static val_str_t channel_flag_strs[] =  {
+	{ "configured" ,  FTDM_CHANNEL_CONFIGURED},
+	{ "ready",  FTDM_CHANNEL_READY},
+	{ "open",  FTDM_CHANNEL_OPEN},
+	{ "dtmf-detect",  FTDM_CHANNEL_DTMF_DETECT},
+	{ "suppress-dtmf",  FTDM_CHANNEL_SUPRESS_DTMF},
+	{ "transcode",  FTDM_CHANNEL_TRANSCODE},
+	{ "buffer",  FTDM_CHANNEL_BUFFER},
+	{ "in-thread",  FTDM_CHANNEL_INTHREAD},
+	{ "wink",  FTDM_CHANNEL_WINK},
+	{ "flash",  FTDM_CHANNEL_FLASH},
+	{ "state-change",  FTDM_CHANNEL_STATE_CHANGE},
+	{ "hold",  FTDM_CHANNEL_HOLD},
+	{ "in-use",  FTDM_CHANNEL_INUSE},
+	{ "off-hook",  FTDM_CHANNEL_OFFHOOK},
+	{ "ringing",  FTDM_CHANNEL_RINGING},
+	{ "progress-detect",  FTDM_CHANNEL_PROGRESS_DETECT},
+	{ "callerid-detect",  FTDM_CHANNEL_CALLERID_DETECT},
+	{ "outbound",  FTDM_CHANNEL_OUTBOUND},
+	{ "suspended",  FTDM_CHANNEL_SUSPENDED},
+	{ "3-way",  FTDM_CHANNEL_3WAY},
+	{ "progress",  FTDM_CHANNEL_PROGRESS},
+	{ "media",  FTDM_CHANNEL_MEDIA},
+	{ "answered",  FTDM_CHANNEL_ANSWERED},
+	{ "mute",  FTDM_CHANNEL_MUTE},
+	{ "use-rx-gain",  FTDM_CHANNEL_USE_RX_GAIN},
+	{ "use-tx-gain",  FTDM_CHANNEL_USE_TX_GAIN},
+	{ "in-alarm",  FTDM_CHANNEL_IN_ALARM},
+	{ "sig-up",  FTDM_CHANNEL_SIG_UP},
+	{ "user-hangup",  FTDM_CHANNEL_USER_HANGUP},
+	{ "rx-disabled",  FTDM_CHANNEL_RX_DISABLED},
+	{ "tx-disabled",  FTDM_CHANNEL_TX_DISABLED},
+	{ "call-started",  FTDM_CHANNEL_CALL_STARTED},
+	{ "non-block",  FTDM_CHANNEL_NONBLOCK},
+	{ "ind-ack-pending",  FTDM_CHANNEL_IND_ACK_PENDING},
+	{ "blocking",  FTDM_CHANNEL_BLOCKING},
+	{ "media",  FTDM_CHANNEL_DIGITAL_MEDIA},
+	{ "native-sigbridge",  FTDM_CHANNEL_NATIVE_SIGBRIDGE},
+	{ "invalid",  FTDM_CHANNEL_MAX_FLAG},
+};
+
+static val_str_t span_flag_strs[] =  {
+	{ "configured", FTDM_SPAN_CONFIGURED},
+	{ "started", FTDM_SPAN_STARTED},
+	{ "state-change", FTDM_SPAN_STATE_CHANGE},
+	{ "suspended", FTDM_SPAN_SUSPENDED},
+	{ "in-thread", FTDM_SPAN_IN_THREAD},
+	{ "stop-thread", FTDM_SPAN_STOP_THREAD},
+	{ "use-chan-queue", FTDM_SPAN_USE_CHAN_QUEUE},
+	{ "suggest-chan-id", FTDM_SPAN_SUGGEST_CHAN_ID},
+	{ "use-av-rate", FTDM_SPAN_USE_AV_RATE},
+	{ "power-saving", FTDM_SPAN_PWR_SAVING},
+	{ "signals-queue", FTDM_SPAN_USE_SIGNALS_QUEUE},
+	{ "proceed-state", FTDM_SPAN_USE_PROCEED_STATE},
+	{ "skip-state", FTDM_SPAN_USE_SKIP_STATES},
+	{ "non-stoppable", FTDM_SPAN_NON_STOPPABLE},
+	{ "use-transfer", FTDM_SPAN_USE_TRANSFER},
+};
+
 static ftdm_status_t ftdm_call_set_call_id(ftdm_channel_t *fchan, ftdm_caller_data_t *caller_data);
 static ftdm_status_t ftdm_call_clear_call_id(ftdm_caller_data_t *caller_data);
 static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan);
 static ftdm_status_t ftdm_channel_sig_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_usrmsg_t *usrmsg);
-static const char *channel_val2str(unsigned long long flag);
+
-static unsigned long long channel_str2val(const char *flag_name);
+static const char *ftdm_val2str(unsigned long long val, val_str_t *val_str_table, ftdm_size_t array_size, const char *default_str);
+static unsigned long long ftdm_str2val(const char *str, val_str_t *val_str_table, ftdm_size_t array_size, unsigned long long default_val);
+
 
 static int time_is_init = 0;
 
@@ -4370,28 +4436,28 @@ static void print_channels_by_flag(ftdm_stream_handle_t *stream, ftdm_span_t *in
 						stream->write_function(stream, "[s%dc%d][%d:%d] flag !%d(!%s) ON \n",
 												fchan->span_id, fchan->chan_id,
 												fchan->physical_span_id, fchan->physical_chan_id,
-												flagval, channel_val2str(flagval));
+												flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
 
 						mycount++;
 					} else {
 						stream->write_function(stream, "[s%dc%d][%d:%d] flag !%d(!%s) OFF \n",
 												fchan->span_id, fchan->chan_id,
 												fchan->physical_span_id, fchan->physical_chan_id,
-												flagval, channel_val2str(flagval));
+												flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
 					}
-				} else if (!not) {
+				} else {
 					if (ftdm_test_flag(fchan, flag)) {
 						stream->write_function(stream, "[s%dc%d][%d:%d] flag %d(%s) ON\n",
 												fchan->span_id, fchan->chan_id,
 												fchan->physical_span_id, fchan->physical_chan_id,
-												flagval, channel_val2str(flagval));
+												flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
 
 						mycount++;
 					} else {
 						stream->write_function(stream, "[s%dc%d][%d:%d] flag %d(%s) OFF \n",
 												fchan->span_id, fchan->chan_id,
 												fchan->physical_span_id, fchan->physical_chan_id,
-												flagval, channel_val2str(flagval));
+												flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
 					}
 				}
 			}
@@ -4412,16 +4478,16 @@ static void print_channels_by_flag(ftdm_stream_handle_t *stream, ftdm_span_t *in
 			for (curr = citer ; curr; curr = ftdm_iterator_next(curr)) {
 				fchan = ftdm_iterator_current(curr);
 				if (not && !ftdm_test_flag(fchan, flag)) {
-					stream->write_function(stream, "[s%dc%d][%d:%d] has not flag %d\n", 
+					stream->write_function(stream, "[s%dc%d][%d:%d] flag !%d(!%s)\n",
 							fchan->span_id, fchan->chan_id, 
 							fchan->physical_span_id, fchan->physical_chan_id, 
-							flagval);
+							flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
 					mycount++;
 				} else if (!not && ftdm_test_flag(fchan, flag)) {
-					stream->write_function(stream, "[s%dc%d][%d:%d] has flag %d\n", 
+					stream->write_function(stream, "[s%dc%d][%d:%d] flag %d(%s)\n",
 							fchan->span_id, fchan->chan_id, 
 							fchan->physical_span_id, fchan->physical_chan_id, 
-							flagval);
+							flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
 					mycount++;
 				}
 			}
@@ -4433,6 +4499,68 @@ end:
 	ftdm_mutex_unlock(globals.mutex);
 }
 
+static void print_spans_by_flag(ftdm_stream_handle_t *stream, ftdm_span_t *inspan, int32_t flagval, int not, int *count)
+{
+	ftdm_hash_iterator_t *i = NULL;
+	ftdm_span_t *span;
+	const void *key = NULL;
+	void *val = NULL;
+	uint32_t flag = (1 << flagval);
+	int mycount = 0;
+
+	*count = 0;
+
+	ftdm_mutex_lock(globals.mutex);
+
+	if (inspan) {
+		if (not) {
+			if (!ftdm_test_flag(inspan, flag)) {
+				stream->write_function(stream, "[s%d] flag !%d(!%s) ON \n",
+										inspan->span_id,
+										flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
+
+				mycount++;
+			} else {
+				stream->write_function(stream, "[s%d] flag !%d(!%s) OFF \n",
+										inspan->span_id,
+										flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
+			}
+		} else {
+			if (ftdm_test_flag(inspan, flag)) {
+				stream->write_function(stream, "[s%d] flag %d(%s) ON \n",
+										inspan->span_id,
+										flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
+				mycount++;
+			} else {
+				stream->write_function(stream, "[s%d] flag %d(%s) OFF \n",
+										inspan->span_id,
+										flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
+			}
+		}
+	} else {
+		for (i = hashtable_first(globals.span_hash); i; i = hashtable_next(i)) {
+			hashtable_this(i, &key, NULL, &val);
+			if (!key || !val) {
+				break;
+			}
+			span = val;
+			if (not && !ftdm_test_flag(span, flag)) {
+				stream->write_function(stream, "[s%d] flag !%d(!%s)\n",
+										span->span_id,
+										flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
+				mycount++;
+			} else if (!not && ftdm_test_flag(span, flag)) {
+				stream->write_function(stream, "[s%d] flag %d(%s)\n",
+									    span->span_id,
+										flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
+				mycount++;
+			}
+		}
+	}
+	*count = mycount;
+	ftdm_mutex_unlock(globals.mutex);
+}
+
 static void print_channels_by_state(ftdm_stream_handle_t *stream, ftdm_channel_state_t state, int not, int *count)
 {
 	ftdm_hash_iterator_t *i = NULL;
@@ -4483,83 +4611,47 @@ static void print_core_usage(ftdm_stream_handle_t *stream)
 	"--------------------------------------------------------------------------------\n"
 	"ftdm core state [!]<state-name> - List all channels in or not in the given state\n"
 	"ftdm core flag [!]<flag-int-value|flag-name> [<span_id|span_name>] [<chan_id>] - List all channels with the given flag value set\n"
+	"ftdm core spanflag [!]<flag-int-value|flag-name> [<span_id|span_name>] - List all spans with the given span flag value set\n"
 	"ftdm core calls - List all known calls to the FreeTDM core\n"
 	"--------------------------------------------------------------------------------\n");
 }
 
-typedef struct channel_flags_str {
-	const char *name;
-	unsigned long long channel_flag;
-} channel_flag_str_t;
 
-static channel_flag_str_t channel_flag_strs[] =  {
+static unsigned long long ftdm_str2val(const char *str, val_str_t *val_str_table, ftdm_size_t array_size, unsigned long long default_val)
- { "configured" ,  FTDM_CHANNEL_CONFIGURED},
- { "ready",  FTDM_CHANNEL_READY},
- { "open",  FTDM_CHANNEL_OPEN},
- { "dtmf-detect",  FTDM_CHANNEL_DTMF_DETECT},
- { "suppress-dtmf",  FTDM_CHANNEL_SUPRESS_DTMF},
- { "transcode",  FTDM_CHANNEL_TRANSCODE},
- { "buffer",  FTDM_CHANNEL_BUFFER},
- { "in-thread",  FTDM_CHANNEL_INTHREAD},
- { "wink",  FTDM_CHANNEL_WINK},
- { "flash",  FTDM_CHANNEL_FLASH},
- { "state-change",  FTDM_CHANNEL_STATE_CHANGE},
- { "hold",  FTDM_CHANNEL_HOLD},
- { "in-use",  FTDM_CHANNEL_INUSE},
- { "off-hook",  FTDM_CHANNEL_OFFHOOK},
- { "ringing",  FTDM_CHANNEL_RINGING},
- { "progress-detect",  FTDM_CHANNEL_PROGRESS_DETECT},
- { "callerid-detect",  FTDM_CHANNEL_CALLERID_DETECT},
- { "outbound",  FTDM_CHANNEL_OUTBOUND},
- { "suspended",  FTDM_CHANNEL_SUSPENDED},
- { "3-way",  FTDM_CHANNEL_3WAY},
- { "progress",  FTDM_CHANNEL_PROGRESS},
- { "media",  FTDM_CHANNEL_MEDIA},
- { "answered",  FTDM_CHANNEL_ANSWERED},
- { "mute",  FTDM_CHANNEL_MUTE},
- { "use-rx-gain",  FTDM_CHANNEL_USE_RX_GAIN},
- { "use-tx-gain",  FTDM_CHANNEL_USE_TX_GAIN},
- { "in-alarm",  FTDM_CHANNEL_IN_ALARM},
- { "sig-up",  FTDM_CHANNEL_SIG_UP},
- { "user-hangup",  FTDM_CHANNEL_USER_HANGUP},
- { "rx-disabled",  FTDM_CHANNEL_RX_DISABLED},
- { "tx-disabled",  FTDM_CHANNEL_TX_DISABLED},
- { "call-started",  FTDM_CHANNEL_CALL_STARTED},
- { "non-block",  FTDM_CHANNEL_NONBLOCK},
- { "ind-ack-pending",  FTDM_CHANNEL_IND_ACK_PENDING},
- { "blocking",  FTDM_CHANNEL_BLOCKING},
- { "media",  FTDM_CHANNEL_DIGITAL_MEDIA},
- { "native-sigbridge",  FTDM_CHANNEL_NATIVE_SIGBRIDGE},
- { "invalid",  FTDM_CHANNEL_MAX_FLAG},
-};
-
-static unsigned long long channel_str2val(const char *flag_name)
 {
 	int i;
-	for (i = 0; i < ftdm_array_len(channel_flag_strs); i++) {
+	for (i = 0; i < array_size; i++) {
-		if (!strcasecmp(channel_flag_strs[i].name, flag_name)) {
+		if (!strcasecmp(val_str_table[i].str, str)) {
-			return channel_flag_strs[i].channel_flag;
+			return val_str_table[i].val;
 		}
 	}
-	return FTDM_CHANNEL_MAX_FLAG;
+	return default_val;
 }
 
-static const char *channel_val2str(unsigned long long flag)
+static const char *ftdm_val2str(unsigned long long val, val_str_t *val_str_table, ftdm_size_t array_size, const char *default_str)
 {
 	int i;
-	for (i = 0; i < ftdm_array_len(channel_flag_strs); i++) {
+	for (i = 0; i < array_size; i++) {
-		if (channel_flag_strs[i].channel_flag == flag) {
+		if (val_str_table[i].val == val) {
-			return channel_flag_strs[i].name;
+			return val_str_table[i].str;
 		}
 	}
-	return "invalid";
+	return default_str;
 }
 
 static void print_channel_flag_values(ftdm_stream_handle_t *stream)
 {
 	int i;
 	for (i = 0; i < ftdm_array_len(channel_flag_strs); i++) {
-		stream->write_function(stream, "%s\n", channel_flag_strs[i].name);
+		stream->write_function(stream, "%s\n", channel_flag_strs[i].str);
+	}
+}
+
+static void print_span_flag_values(ftdm_stream_handle_t *stream)
+{
+	int i;
+	for (i = 0; i < ftdm_array_len(span_flag_strs); i++) {
+		stream->write_function(stream, "%s\n", span_flag_strs[i].str);
 	}
 }
 
@@ -4631,12 +4723,13 @@ static char *handle_core_command(const char *cmd)
 		}
 		
 		if (isalpha(flag[0])) {
-			flagval = channel_str2val(flag);
+			flagval = ftdm_str2val(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), FTDM_CHANNEL_MAX_FLAG);
 			if (flagval == FTDM_CHANNEL_MAX_FLAG) {
 				stream.write_function(&stream, "\nInvalid channel flag value. Possible channel flags\n");
 				print_channel_flag_values(&stream);
 				goto done;
 			}
+			flagval = flagval >> 1;
 		} else {
 			flagval = atoi(flag);
 		}
@@ -4661,6 +4754,44 @@ static char *handle_core_command(const char *cmd)
 
 		print_channels_by_flag(&stream, fspan, chan_id, flagval, not, &count);
 		stream.write_function(&stream, "\nTotal channels %s %d: %d\n", not ? "without flag" : "with flag", flagval, count);
+	} else if (!strcasecmp(argv[0], "spanflag")) {
+		if (argc < 2) {
+			stream.write_function(&stream, "core spanflag command requires an argument\n");
+			print_core_usage(&stream);
+			goto done;
+		}
+
+		flag = argv[1];
+		if (argv[1][0] == '!') {
+			not = 1;
+			flag++;
+		}
+
+		if (isalpha(flag[0])) {
+			flagval = ftdm_str2val(flag, span_flag_strs, ftdm_array_len(span_flag_strs), FTDM_SPAN_MAX_FLAG);
+			if (flagval == FTDM_SPAN_MAX_FLAG) {
+				stream.write_function(&stream, "\nInvalid span flag value. Possible span flags\n");
+				print_span_flag_values(&stream);
+				goto done;
+			}
+			flagval = flagval >> 1;
+		} else {
+			flagval = atoi(flag);
+		}
+
+		/* Specific span specified */
+		if (argv[2]) {
+			ftdm_span_find_by_name(argv[2], &fspan);
+			if (!fspan) {
+				stream.write_function(&stream, "-ERR span:%s not found\n", argv[2]);
+				goto done;
+			}
+		}
+
+		print_spans_by_flag(&stream, fspan, flagval, not, &count);
+		if (!fspan) {
+			stream.write_function(&stream, "\nTotal spans %s %d: %d\n", not ? "without flag" : "with flag", flagval, count);
+		}
 	} else if (!strcasecmp(argv[0], "calls")) {
 		ftdm_mutex_lock(globals.call_id_mutex);
 		current_call_id = globals.last_call_id;

libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c

@@ -1460,6 +1460,33 @@ static ftdm_status_t handle_show_status(ftdm_stream_handle_t *stream, int span,
 		x++;
 	} /* while (g_ftdm_sngss7_data.cfg.isupCkt[x]id != 0) */
 
+	/* Look spans that are being used by M2UA SG links */
+	for (x = 1; x < ftdm_array_len(g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif); x++) {
+		if (g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[x].id) {
+			if (g_ftdm_sngss7_data.cfg.mtp2Link[g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[x].mtp2LnkNmb].id) {
+				uint32_t mtp1_id = g_ftdm_sngss7_data.cfg.mtp2Link[g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[x].mtp2LnkNmb].id;
+				if (g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].id) {
+					if (g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].span == span) {
+						if (chan) {
+							if (chan == g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].chan) {
+							stream->write_function(stream, "span=%2d|chan=%2d|cic=%4d|SIGNALING LINK\n",
+													g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].span,
+													g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].chan,
+													0);
+							}
+						} else {
+							stream->write_function(stream, "span=%2d|chan=%2d|cic=%4d|SIGNALING LINK\n",
+													g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].span,
+													g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].chan,
+													0);
+						}
+					}
+				}
+
+			}
+		}
+	}
+
 	return FTDM_SUCCESS;
 }
 

libs/freetdm/src/include/private/ftdm_types.h

@@ -197,6 +197,8 @@ typedef enum {
 	FTDM_SPAN_NON_STOPPABLE = (1 << 13),
 	/* If this flag is set, then this span supports TRANSFER state */
 	FTDM_SPAN_USE_TRANSFER = (1 << 14),
+	/* This is the last flag, no more flags bigger than this */
+	FTDM_SPAN_MAX_FLAG = (1 << 15),
 } ftdm_span_flag_t;
 
 /*! \brief Channel supported features */

src/mod/endpoints/mod_media_gateway/media_gateway_cli.c

@@ -138,6 +138,7 @@ done:
 switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, megaco_profile_t* mg_cfg)
 {
 	int idx   = 0x00;
+	int peerIdx   = 0x00;
 	int len   = 0x00;
 	MgMngmt   cfm;
 	char*     xmlhdr = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
@@ -152,22 +153,23 @@ switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, me
 	memset((U8 *)&cfm, 0, sizeof(cfm));
 	memset((char *)&prntBuf, 0, sizeof(prntBuf));
 
-	 mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[0]);
-
-	if(!mg_peer){
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[0],mg_cfg->name);
-		return SWITCH_STATUS_FALSE;
-	}
-
-
 	idx = mg_cfg->idx;
 
 	len = len + sprintf(&prntBuf[0] + len,"%s\n",xmlhdr);
 
-	len = len + sprintf(&prntBuf[0] + len,"<mg_peer>\n");
+	len = len + sprintf(&prntBuf[0] + len,"<mg_peers>\n");
-	len = len + sprintf(&prntBuf[0] + len,"<name>%s</name>\n",mg_cfg->peer_list[0]);
 
-	/* TODO - as of now supporting only one peer .. need to add logic to iterate through all the peers associated with this profile..*/
+	for(peerIdx =0; peerIdx < mg_cfg->total_peers; peerIdx++){
+
+		mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[peerIdx]);
+
+		if(!mg_peer){
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[peerIdx],mg_cfg->name);
+			return SWITCH_STATUS_FALSE;
+		}
+
+		len = len + sprintf(&prntBuf[0] + len,"<mg_peer>\n");
+		len = len + sprintf(&prntBuf[0] + len,"<name>%s</name>\n",mg_peer->name);
 
 		/* send request to MEGACO Trillium stack to get peer information*/
 		sng_mgco_mg_get_status(STGCPENT, &cfm, mg_cfg, mg_peer);
@@ -179,6 +181,9 @@ switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, me
 		len = len + sprintf(prntBuf+len, "<peer_state>%s</peer_state>\n",PRNT_MG_PEER_STATE(cfm.t.ssta.s.mgPeerSta.peerState)); 
 
 		len = len + sprintf(&prntBuf[0] + len,"</mg_peer>\n");
+	}
+
+	len = len + sprintf(&prntBuf[0] + len,"</mg_peers>\n");
 
 	stream->write_function(stream, "\n%s\n",&prntBuf[0]);
 
@@ -190,6 +195,7 @@ switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, me
 switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_profile_t* mg_cfg)
 {
 	int idx   = 0x00;
+	int peerIdx   = 0x00;
 	int len   = 0x00;
 	MgMngmt   cfm;
 	char*     xmlhdr = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
@@ -204,12 +210,6 @@ switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_
 	memset((U8 *)&cfm, 0, sizeof(cfm));
 	memset((char *)&prntBuf, 0, sizeof(prntBuf));
 
-	 mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[0]);
-
-	if(!mg_peer){
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[0],mg_cfg->name);
-		return SWITCH_STATUS_FALSE;
-	}
 	 
 
 	idx = mg_cfg->idx;
@@ -221,9 +221,17 @@ switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_
 /****************************************************************************************************************/
 /* Print Peer Information ***************************************************************************************/
 
-	/* TODO - as of now supporting only one peer .. need to add logic to iterate through all the peers associated with this profile..*/
-
 	len = len + sprintf(&prntBuf[0] + len,"<mg_peers>\n");
+
+	for(peerIdx =0; peerIdx < mg_cfg->total_peers; peerIdx++){
+
+		mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[peerIdx]);
+
+		if(!mg_peer){
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[peerIdx],mg_cfg->name);
+			return SWITCH_STATUS_FALSE;
+		}
+
 		len = len + sprintf(&prntBuf[0] + len,"<mg_peer name=%s>\n",mg_peer->name);
 
 		/* send request to MEGACO Trillium stack to get peer information*/
@@ -232,6 +240,7 @@ switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_
 		get_peer_xml_buffer(&prntBuf[0] + len, &cfm.t.ssta.s.mgPeerSta);
 
 		len = len + sprintf(&prntBuf[0] + len,"</mg_peer>\n");
+	}
 	len = len + sprintf(&prntBuf[0] + len,"</mg_peers>\n");
 
 	

src/mod/endpoints/mod_media_gateway/media_gateway_stack.c

@@ -183,7 +183,6 @@ switch_status_t sng_mgco_cfg(megaco_profile_t* profile)
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," mgco_mu_ssap_config SUCCESS \n");	
 	}
 
-
 	if(mgco_mg_tsap_config(profile)) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," mgco_mg_tsap_config FAILED \n");	
 		return SWITCH_STATUS_FALSE;
@@ -256,7 +255,6 @@ switch_status_t sng_mgco_start(megaco_profile_t* profile )
 	else {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_tsap_enable_cntrl SUCCESS \n");
 	}
-	//mgco_mg_enable_debug();
 
 	return SWITCH_STATUS_SUCCESS;
 }
@@ -784,6 +782,8 @@ int mgco_mg_gen_config(void)
 	cfg->noEDInst = 1;
 #endif /* CM_ABNF_MT_LIB */
 
+	cfg->entType  = LMG_ENT_GW; 
+
 #ifdef GCP_CH
 	cfg->numBinsPeerCmdHl = 20;
 	cfg->numBinsTransReqHl = 50;
@@ -1002,7 +1002,7 @@ int mgco_mg_tsap_config(megaco_profile_t* profile)
 	/* FILL TSAP config */
 	cfg->tSAPId 	= profile->idx;
 	cfg->spId   	= profile->idx;
-	cfg->provType 	= mg_get_tpt_type(profile);
+	cfg->provType 	= LMG_PROV_TYPE_TUCL; 
 
 	/* FILL TUCL Information */
 	cfg->memId.region = S_REG; 
@@ -1046,7 +1046,7 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
 	Pst          	pst;              /* Post for layer manager */
 	U32            peerIdx = 0;
 	CmInetIpAddr   ipAddr = 0;
-	mg_peer_profile_t*  mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[0]);
+	mg_peer_profile_t*  mg_peer =  NULL;
 
 	memset(&mgMngmt, 0, sizeof(mgMngmt));
 	cfg   = &(mgMngmt.t.cfg.c.mgGcpEntCfg);
@@ -1064,13 +1064,16 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
 	mgMngmt.hdr.elmId.elmnt     = STGCPENT;
 
 	cfg->numPeer 			= mg_cfg->total_peers;
+	for(peerIdx =0; peerIdx < mg_cfg->total_peers; peerIdx++){
+
+		mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[peerIdx]);
+
 		cfg->peerCfg[peerIdx].sSAPId 	= mg_cfg->idx;        /* SSAP ID */;
 		cfg->peerCfg[peerIdx].port 	= atoi(mg_peer->port);
 		cfg->peerCfg[peerIdx].tsapId 	= mg_cfg->idx;
 
 		cfg->peerCfg[peerIdx].mtuSize = MG_MAX_MTU_SIZE;
 
-
 		cfg->peerCfg[peerIdx].peerAddrTbl.count = 1;
 		cfg->peerCfg[peerIdx].peerAddrTbl.netAddr[0].type =
 			CM_NETADDR_IPV4;
@@ -1088,7 +1091,7 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
 #ifdef GCP_MG
 		cfg->peerCfg[peerIdx].transportType  = mg_get_tpt_type_from_str(mg_peer->transport_type);
 		cfg->peerCfg[peerIdx].encodingScheme = mg_get_enc_type_from_str(mg_peer->encoding_type);
-	cfg->peerCfg[peerIdx].mgcPriority = 0;
+		cfg->peerCfg[peerIdx].mgcPriority = peerIdx;
 		cfg->peerCfg[peerIdx].useAHScheme = FALSE;
 		cfg->peerCfg[peerIdx].mid.pres = PRSNT_NODEF;
 		cfg->peerCfg[peerIdx].mid.len = strlen((char*)mg_peer->mid);
@@ -1097,6 +1100,7 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
 				cfg->peerCfg[peerIdx].mid.len);
 
 #endif /* GCP_MG */
+	}
 
 	return(sng_cfg_mg(&pst, &mgMngmt));
 }
@@ -1306,7 +1310,6 @@ sng_mg_transport_types_e  mg_get_tpt_type_from_str(char* tpt_type)
 	if(!strcasecmp(tpt_type, "UDP")){
 		return SNG_MG_TPT_UDP;
 	}else if(!strcasecmp(tpt_type,"TCP")){
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "TCP Transport for H.248 Protocol Not Yet Supported \n");
 		return SNG_MG_TPT_TCP;
 	}else if(!strcasecmp(tpt_type,"STCP")){
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "STCP Transport for H.248 Protocol Not Yet Supported \n");

src/mod/endpoints/mod_media_gateway/media_gateway_xml.c

@@ -78,11 +78,12 @@ switch_status_t config_profile(megaco_profile_t *profile, switch_bool_t reload)
 		goto done;
 	}
 
-	count = 0x00;
-	event = NULL;
 	for (mg_peer = switch_xml_child(mg_peers, "mg_peer"); mg_peer; mg_peer = mg_peer->next) {
 		const char *name = switch_xml_attr_soft(mg_peer, "name");
 		for(idx=0; idx<profile->total_peers; idx++){
+			count = 0x00;
+			event = NULL;
+			peer_profile = NULL;
 			if (!strcmp(name, profile->peer_list[idx])) {
 				/* peer profile */
 				peer_profile = switch_core_alloc(profile->pool, sizeof(*peer_profile));
@@ -136,6 +137,7 @@ switch_status_t mg_config_cleanup(megaco_profile_t* profile)
 static switch_xml_config_item_t *get_peer_instructions(mg_peer_profile_t *profile) {
 	switch_xml_config_item_t *dup;
 
+
 	switch_xml_config_item_t instructions[] = {
 		/* parameter name        type                 reloadable   pointer                         default value     options structure */
 		SWITCH_CONFIG_ITEM("ip", SWITCH_CONFIG_STRING, CONFIG_RELOADABLE, &profile->ipaddr, "", &switch_config_string_strdup, "", "Peer IP"),

src/mod/endpoints/mod_media_gateway/mod_media_gateway.c

@@ -118,7 +118,7 @@ void handle_sng_log(uint8_t level, char *fmt, ...)
 		case SNG_LOGLEVEL_DEBUG:    log_level = SWITCH_LOG_DEBUG;       break;
 		case SNG_LOGLEVEL_INFO:     log_level = SWITCH_LOG_INFO;        break;
 		case SNG_LOGLEVEL_WARN:     log_level = SWITCH_LOG_WARNING;     break;
-		case SNG_LOGLEVEL_ERROR:    log_level = SWITCH_LOG_DEBUG;       break;
+		case SNG_LOGLEVEL_ERROR:    log_level = SWITCH_LOG_ERROR;       break;
 		case SNG_LOGLEVEL_CRIT:     log_level = SWITCH_LOG_CRIT;        break;
 		default:                    log_level = SWITCH_LOG_DEBUG;       break;
 	};

src/mod/endpoints/mod_sofia/rtp.c

@@ -88,15 +88,19 @@ switch_io_routines_t crtp_io_routines = {
     .send_dtmf = channel_send_dtmf
 };
 
+#if 0
 SWITCH_STANDARD_API(test_function)
 {
     return SWITCH_STATUS_SUCCESS;
 }
+#endif
 
 void crtp_init(switch_loadable_module_interface_t *module_interface)
 {
     switch_endpoint_interface_t *endpoint_interface;
+#if 0 /* DAVIDY */
     switch_api_interface_t *api_interface;
+#endif
     crtp.pool = module_interface->pool;
     endpoint_interface = switch_loadable_module_create_interface(module_interface, SWITCH_ENDPOINT_INTERFACE);
     endpoint_interface->interface_name = "rtp";
@@ -128,12 +132,18 @@ typedef struct parsed_sdp_s {
 
 static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_sdp, const char *codec_string)
 {
-    switch_core_session_t const * session = tech_pvt->session;    
-    int num_codecs;
-    const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS] = { 0 };
-    
-    char *codec_order[SWITCH_MAX_CODECS] = { 0 };
     int codec_order_last;
+    int num_codecs;
+#if 0 /* DAVIDY */
+    switch_core_session_t const * session = tech_pvt->session;    
+#endif
+    const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS] = { 0 };
+    char *codec_order[SWITCH_MAX_CODECS] = { 0 };
+#if 1 /* DAVIDY */
+    char *sdpbuf = NULL;
+    sdp_connection_t *connection = NULL;
+    sdp_printer_t *printer = NULL;
+#endif
 
     
     /* Load in the list of codecs we support. If we have a codec string we use our priorities first */
@@ -151,24 +161,30 @@ static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_s
     
     if (zstr(l_sdp)) {
         /* Generate a local SDP here */
+#if 0 /* DAVIDY */
         const char *sdpbuf = switch_core_session_sprintf(session, "v=0\nIN IP4 %s\nm=audio %d RTP/AVP %d");
+#endif
         
     } else {
         /* Parse the SDP and remove anything we cannot support, then validate it to make sure it contains at least one codec 
          * so that we reject invalid ones. */
-#if 1
+#if 0
         uint8_t match = 0;
         int first = 0, last = 0;
         int ptime = 0, dptime = 0, maxptime = 0, dmaxptime = 0;
         int sendonly = 0, recvonly = 0;
-        int greedy = 0, x = 0, skip = 0, mine = 0;
+        int greedy = 0, x = 0, skip = 0;
-        int got_crypto = 0, got_audio = 0, got_avp = 0, got_savp = 0, got_udptl = 0;
 #endif
+	int ptime = 0, maxptime = 0;	
         int sdp_modified = 0;
         int cur_codec = 0;
         
         sdp_parser_t *parser = NULL;
+#if 1 /* DAVIDY */
+        sdp_session_t *sdp;
+#else
         sdp_session_t *sdp, *lsdp;
+#endif
         sdp_media_t *m;
         sdp_attribute_t *attr;
         su_home_t *sdp_home;
@@ -196,7 +212,6 @@ static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_s
                     }
                 }
             
-                sdp_connection_t *connection;
                 connection = sdp->sdp_connection;
                 if (m->m_connections) {
                     connection = m->m_connections;
@@ -250,8 +265,10 @@ static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_s
                 
             }
         }
+#if 0 /* DAVIDY */
         char sdpbuf[2048] = "";
-        sdp_printer_t *printer = sdp_print(sdp_home, sdp, sdpbuf, sizeof(sdpbuf), 0);
+#endif
+        printer = sdp_print(sdp_home, sdp, sdpbuf, sizeof(sdpbuf), 0);
         switch_channel_set_variable(tech_pvt->channel, kLSDP, sdpbuf);
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Setting local SDP: [%s]\n", sdpbuf);
         sdp_printer_free(printer);
@@ -485,8 +502,10 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
     char name[128];
     const char *dname = "PCMU";
     uint32_t interval = 20;
-    crtp_private_t *tech_pvt;
+    crtp_private_t *tech_pvt = NULL;
+#if 0
     const char *r_sdp = switch_event_get_header(var_event, kRSDP);
+#endif
     const char *l_sdp = switch_event_get_header(var_event, kLSDP);
     const char *codec_string = switch_event_get_header_nil(var_event, kCODECSTRING);