diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c
index edb15604e5..c0ce84b2ed 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c
@@ -48,8 +48,6 @@ static ftdm_status_t handle_print_usuage(ftdm_stream_handle_t *stream);
 
 static ftdm_status_t handle_set_function_trace(ftdm_stream_handle_t *stream, int on, int level);
 static ftdm_status_t handle_set_message_trace(ftdm_stream_handle_t *stream, int on, int level);
-static ftdm_status_t handle_set_blocks(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
-static ftdm_status_t handle_set_unblks(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
 static ftdm_status_t handle_set_inhibit(ftdm_stream_handle_t *stream, char *name);
 static ftdm_status_t handle_set_uninhibit(ftdm_stream_handle_t *stream, char *name);
 
@@ -63,6 +61,13 @@ static ftdm_status_t handle_show_status(ftdm_stream_handle_t *stream, int span,
 static ftdm_status_t handle_tx_rsc(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
 static ftdm_status_t handle_tx_grs(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose);
 
+static ftdm_status_t handle_tx_blo(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
+static ftdm_status_t handle_tx_ubl(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
+
+static ftdm_status_t handle_tx_cgb(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose);
+static ftdm_status_t handle_tx_cgu(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose);
+
+
 static ftdm_status_t handle_status_link(ftdm_stream_handle_t *stream, char *name);
 static ftdm_status_t handle_status_linkset(ftdm_stream_handle_t *stream, char *name);
 
@@ -282,20 +287,12 @@ ftdm_status_t ftdm_sngss7_handle_cli_cmd(ftdm_stream_handle_t *stream, const cha
 		/**********************************************************************/
 		}  
 	/**************************************************************************/
-	} else if (!strcasecmp(argv[c], "block")) {
+	} else if (!strcasecmp(argv[c], "inhibit")) {
 	/**************************************************************************/
 		if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
 		c++;
 
-		if (!strcasecmp(argv[c], "span")) {
-		/**********************************************************************/
-			if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
-
-			if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
-
-			handle_set_blocks(stream, span, chan, verbose);
-		/**********************************************************************/
-		} else if (!strcasecmp(argv[c], "link")) {
+		if (!strcasecmp(argv[c], "link")) {
 		/**********************************************************************/
 			if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
 			c++;
@@ -309,7 +306,26 @@ ftdm_status_t ftdm_sngss7_handle_cli_cmd(ftdm_stream_handle_t *stream, const cha
 		/**********************************************************************/
 		}   
 	/**************************************************************************/
-	} else if (!strcasecmp(argv[c], "unblock")) {
+	} else if (!strcasecmp(argv[c], "uninhibit")) {
+	/**************************************************************************/
+		if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+		c++;
+
+		if (!strcasecmp(argv[c], "link")) {
+		/**********************************************************************/
+			if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
+			c++;
+			
+			handle_set_uninhibit(stream, argv[c]);
+		/**********************************************************************/
+		} else {
+		/**********************************************************************/
+			stream->write_function(stream, "Unknown \"unblock\" command\n");
+			goto handle_cli_error;
+		/**********************************************************************/
+		} 
+	/**************************************************************************/
+	} else if (!strcasecmp(argv[c], "blo")) {
 	/**************************************************************************/
 		if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
 		c++;
@@ -320,18 +336,101 @@ ftdm_status_t ftdm_sngss7_handle_cli_cmd(ftdm_stream_handle_t *stream, const cha
 
 			if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
 
-			handle_set_unblks(stream, span, chan, verbose);
-		/**********************************************************************/
-		} else if (!strcasecmp(argv[c], "link")) {
-		/**********************************************************************/
-			if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
-			c++;
-			
-			handle_set_uninhibit(stream, argv[c]);
+			handle_tx_blo(stream, span, chan, verbose);
 		/**********************************************************************/
 		} else {
 		/**********************************************************************/
-			stream->write_function(stream, "Unknown \"unblock\" command\n");
+			stream->write_function(stream, "Unknown \"block\" command\n");
+			goto handle_cli_error;
+		/**********************************************************************/
+		}
+	/**************************************************************************/
+	} else if (!strcasecmp(argv[c], "ubl")) {
+	/**************************************************************************/
+		if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+		c++;
+
+		if (!strcasecmp(argv[c], "span")) {
+		/**********************************************************************/
+			if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
+
+			if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
+
+			handle_tx_ubl(stream, span, chan, verbose);
+		/**********************************************************************/
+		} else {
+		/**********************************************************************/
+			stream->write_function(stream, "Unknown \"ubl\" command\n");
+			goto handle_cli_error;
+		/**********************************************************************/
+		} 
+	/**************************************************************************/
+	} else if (!strcasecmp(argv[c], "cgb")) {
+	/**************************************************************************/
+		if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+		c++;
+
+		if (!strcasecmp(argv[c], "span")) {
+		/**********************************************************************/
+			if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
+
+			if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
+			c = c + 4;
+
+			if (check_arg_count(argc, 7)) goto handle_cli_error_argc;
+
+			if (!strcasecmp(argv[c], "range")) {
+			/******************************************************************/
+				c++;
+				range =  atoi(argv[c]);
+			/******************************************************************/
+			} else {
+			/******************************************************************/
+				stream->write_function(stream, "Unknown \"cgb range\" command\n");
+				goto handle_cli_error;
+			/******************************************************************/
+			}
+
+			handle_tx_cgb(stream, span, chan, range, verbose);
+		/**********************************************************************/
+		} else {
+		/**********************************************************************/
+			stream->write_function(stream, "Unknown \"cgb\" command\n");
+			goto handle_cli_error;
+		/**********************************************************************/
+		} 
+	/**************************************************************************/
+	} else if (!strcasecmp(argv[c], "cgu")) {
+	/**************************************************************************/
+		if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+		c++;
+
+		if (!strcasecmp(argv[c], "span")) {
+		/**********************************************************************/
+			if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
+
+			if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
+			c = c + 4;
+
+			if (check_arg_count(argc, 7)) goto handle_cli_error_argc;
+
+			if (!strcasecmp(argv[c], "range")) {
+			/******************************************************************/
+				c++;
+				range =  atoi(argv[c]);
+			/******************************************************************/
+			} else {
+			/******************************************************************/
+				stream->write_function(stream, "Unknown \"cgu range\" command\n");
+				goto handle_cli_error;
+			/******************************************************************/
+			}
+
+			handle_tx_cgu(stream, span, chan, range, verbose);
+		/**********************************************************************/
+		} else {
+		/**********************************************************************/
+			stream->write_function(stream, "Unknown \"cgu\" command\n");
 			goto handle_cli_error;
 		/**********************************************************************/
 		} 
@@ -433,10 +532,15 @@ static ftdm_status_t handle_print_usuage(ftdm_stream_handle_t *stream)
 	stream->write_function(stream, "ftdm ss7 show inreset span X chan Y\n");
 	stream->write_function(stream, "\n");
 	stream->write_function(stream, "Ftmod_sangoma_ss7 circuit control:\n");
-	stream->write_function(stream, "ftdm ss7 block span X chan Y\n");
-	stream->write_function(stream, "ftdm ss7 unblk span X chan Y\n");
+	stream->write_function(stream, "ftdm ss7 blo span X chan Y\n");
+	stream->write_function(stream, "ftdm ss7 ubl span X chan Y\n");
 	stream->write_function(stream, "ftdm ss7 rsc span X chan Y\n");
 	stream->write_function(stream, "ftdm ss7 grs span X chan Y range Z\n");
+	stream->write_function(stream, "\n");
+	stream->write_function(stream, "Ftmod_sangoma_ss7 link control:\n");
+	stream->write_function(stream, "ftdm ss7 inhibit link X\n");
+	stream->write_function(stream, "ftdm ss7 uninhibit link X\n");
+
 	stream->write_function(stream, "\n");
 
 	return FTDM_SUCCESS;
@@ -899,7 +1003,7 @@ static ftdm_status_t handle_show_status(ftdm_stream_handle_t *stream, int span,
 	return FTDM_SUCCESS;
 }
 /******************************************************************************/
-static ftdm_status_t handle_set_blocks(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
+static ftdm_status_t handle_tx_blo(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
 {
 	int				 x;
 	sngss7_chan_data_t  *ss7_info;
@@ -960,7 +1064,7 @@ static ftdm_status_t handle_set_blocks(ftdm_stream_handle_t *stream, int span, i
 }
 
 /******************************************************************************/
-static ftdm_status_t handle_set_unblks(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
+static ftdm_status_t handle_tx_ubl(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
 {
 	int				 x;
 	sngss7_chan_data_t  *ss7_info;
@@ -1154,17 +1258,17 @@ static ftdm_status_t handle_set_uninhibit(ftdm_stream_handle_t *stream, char *na
 /******************************************************************************/
 static ftdm_status_t handle_tx_rsc(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
 {
-	int				 x;
-	sngss7_chan_data_t  *ss7_info;
-	ftdm_channel_t	  *ftdmchan;
-	int				 lspan;
-	int				 lchan;
+	int				 	x;
+	sngss7_chan_data_t  *sngss7_info;
+	ftdm_channel_t	  	*ftdmchan;
+	int				 	lspan;
+	int				 	lchan;
 
 	x=1;
 	while (g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) {
 		if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == VOICE) {
-			ss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
-			ftdmchan = ss7_info->ftdmchan;
+			sngss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
+			ftdmchan = sngss7_info->ftdmchan;
 
 			/* if span == 0 then all spans should be printed */
 			if (span == 0) {
@@ -1181,27 +1285,31 @@ static ftdm_status_t handle_tx_rsc(ftdm_stream_handle_t *stream, int span, int c
 			}
 
 			if ((ftdmchan->physical_span_id == lspan) && (ftdmchan->physical_chan_id == lchan)) {
-				/* now that we have the right channel...put a lock on it so no-one else can use it */
+				/* lock the channel */
 				ftdm_mutex_lock(ftdmchan->mutex);
 
-				/* check if there is a pending state change|give it a bit to clear */
-				if (check_for_state_change(ftdmchan)) {
-					SS7_ERROR("Failed to wait for pending state change on CIC = %d\n", ss7_info->circuit->cic);
-					SS7_ASSERT;
-				} else {
-					/* throw the ckt block flag */
-					sngss7_set_flag(ss7_info, FLAG_RESET_TX);
+				/* throw the reset flag */
+				sngss7_set_flag(sngss7_info, FLAG_RESET_TX);
 
-					/* set the channel to suspended state */
+				switch (ftdmchan->state) {
+				/**************************************************************************/
+				case FTDM_CHANNEL_STATE_RESTART:
+					/* go to idle so that we can redo the restart state*/
+					ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE);
+					break;
+				/**************************************************************************/
+				default:
+					/* set the state of the channel to restart...the rest is done by the chan monitor */
 					ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
+					break;
+				/**************************************************************************/
 				}
-
+			
 				/* unlock the channel again before we exit */
 				ftdm_mutex_unlock(ftdmchan->mutex);
-
 			} /* if ( span and chan) */
 
-		} /* if ( cic != 0) */
+		} /* if ( cic == voice) */
 
 		/* go the next circuit */
 		x++;
@@ -1270,6 +1378,144 @@ static ftdm_status_t handle_tx_grs(ftdm_stream_handle_t *stream, int span, int c
 	return FTDM_SUCCESS;
 }
 
+/******************************************************************************/
+static ftdm_status_t handle_tx_cgb(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose)
+{
+	int					x;
+	sngss7_chan_data_t	*sngss7_info;
+	ftdm_channel_t		*ftdmchan;
+	ftdm_channel_t		*main_chan = NULL;
+	sngss7_span_data_t	*sngss7_span;
+	int					byte = 0;
+	int					bit = 0;
+
+	if (range > 31) {
+		stream->write_function(stream, "Invalid range value %d", range);
+		return FTDM_SUCCESS;
+	}
+
+	x=1;
+	while (g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) {
+		if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == VOICE) {
+
+			/* extract the channel and span info for this circuit */
+			sngss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
+			ftdmchan = sngss7_info->ftdmchan;
+			sngss7_span = ftdmchan->span->mod_data;
+
+			/* check if this circuit is part of the block */
+			if ((ftdmchan->physical_span_id == span) && 
+				((ftdmchan->physical_chan_id >= chan) && (ftdmchan->physical_chan_id < (chan+range)))) {
+
+				/* now that we have the right channel...put a lock on it so no-one else can use it */
+				ftdm_mutex_lock(ftdmchan->mutex);
+
+				/* throw the grp maint. block flag */
+				sngss7_set_flag(sngss7_info, FLAG_GRP_MN_BLOCK_TX);
+
+				/* if this is the first channel in the range */
+				if (ftdmchan->physical_chan_id == chan) {
+					/* attach the cgb information */
+					main_chan = ftdmchan;
+					sngss7_span->tx_cgb.circuit = sngss7_info->circuit->id;
+					sngss7_span->tx_cgb.range = range-1;
+					sngss7_span->tx_cgb.type = 0; /* maintenace block */
+				} /* if (ftdmchan->physical_chan_id == chan) */
+				
+				/* update the status field */
+				sngss7_span->tx_cgb.status[byte] = (sngss7_span->tx_cgb.status[byte] | (1 << bit));
+
+				/* update the bit and byte counter*/
+				bit ++;
+				if (bit == 8) {
+					byte++;
+					bit = 0;
+				}
+
+				/* unlock the channel again before we exit */
+				ftdm_mutex_unlock(ftdmchan->mutex);
+			} /* if ( span and chan) */
+		} /* if ( cic == voice) */
+		/* go the next circuit */
+		x++;
+	} /* while (g_ftdm_sngss7_data.cfg.isupCkt[x]id != 0) */
+
+	/* send the circuit group block */
+	ft_to_sngss7_cgb(main_chan);
+	
+
+	return FTDM_SUCCESS;
+}
+
+/******************************************************************************/
+static ftdm_status_t handle_tx_cgu(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose)
+{
+	int					x;
+	sngss7_chan_data_t	*sngss7_info;
+	ftdm_channel_t		*ftdmchan;
+	ftdm_channel_t		*main_chan = NULL;
+	sngss7_span_data_t	*sngss7_span;
+	int					byte = 0;
+	int					bit = 0;
+
+	if (range > 31) {
+		stream->write_function(stream, "Invalid range value %d", range);
+		return FTDM_SUCCESS;
+	}
+
+	x=1;
+	while (g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) {
+		if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == VOICE) {
+
+			/* extract the channel and span info for this circuit */
+			sngss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
+			ftdmchan = sngss7_info->ftdmchan;
+			sngss7_span = ftdmchan->span->mod_data;
+
+			/* check if this circuit is part of the block */
+			if ((ftdmchan->physical_span_id == span) && 
+				((ftdmchan->physical_chan_id >= chan) && (ftdmchan->physical_chan_id < (chan+range)))) {
+
+				/* now that we have the right channel...put a lock on it so no-one else can use it */
+				ftdm_mutex_lock(ftdmchan->mutex);
+
+				/* throw the grp maint. block flag */
+				sngss7_clear_flag(sngss7_info, FLAG_GRP_MN_BLOCK_TX);
+
+				/* if this is the first channel in the range */
+				if (ftdmchan->physical_chan_id == chan) {
+					/* attach the cgb information */
+					main_chan = ftdmchan;
+					sngss7_span->tx_cgu.circuit = sngss7_info->circuit->id;
+					sngss7_span->tx_cgu.range = range-1;
+					sngss7_span->tx_cgu.type = 0; /* maintenace block */
+				} /* if (ftdmchan->physical_chan_id == chan) */
+				
+				/* update the status field */
+				sngss7_span->tx_cgu.status[byte] = (sngss7_span->tx_cgu.status[byte] | (1 << bit));
+
+				/* update the bit and byte counter*/
+				bit ++;
+				if (bit == 8) {
+					byte++;
+					bit = 0;
+				}
+
+				/* unlock the channel again before we exit */
+				ftdm_mutex_unlock(ftdmchan->mutex);
+			} /* if ( span and chan) */
+		} /* if ( cic == voice) */
+		/* go the next circuit */
+		x++;
+	} /* while (g_ftdm_sngss7_data.cfg.isupCkt[x]id != 0) */
+
+	/* send the circuit group block */
+	ft_to_sngss7_cgu(main_chan);
+	
+
+	return FTDM_SUCCESS;
+}
+
 /******************************************************************************/
 static ftdm_status_t extract_span_chan(char *argv[10], int pos, int *span, int *chan)
 {
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_handle.c b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_handle.c
index 0c3dcffec0..0286563f29 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_handle.c
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_handle.c
@@ -915,12 +915,12 @@ ftdm_status_t handle_sta_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circ
 	/**************************************************************************/
 	case SIT_STA_CGBRSP:			/* mntc. oriented CGB response */
 		SS7_MSG_TRACE(ftdmchan, sngss7_info, "Rx mntc CGB\n");
-		handle_cgb_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
+		/*handle_cgb_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);*/
 		break;
 	/**************************************************************************/
 	case SIT_STA_CGURSP:			/* mntc. oriented CGU response */
 		SS7_MSG_TRACE(ftdmchan, sngss7_info, "Rx mntc CGU\n");
-		SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
+		/*SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));*/
 		break;
 	/**************************************************************************/
 	case SIT_STA_GRSREQ:			/* circuit group reset request */
@@ -1020,7 +1020,7 @@ ftdm_status_t handle_sta_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circ
 	/**************************************************************************/
 	case SIT_STA_LMCQMINFOREQ:	  /* when LM requests ckt grp query */
 		SS7_MSG_TRACE(ftdmchan, sngss7_info, "Rx LM CQM\n");
-		SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
+// 		SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
 		break;
 	/**************************************************************************/
 	case SIT_STA_CIRLOCGRS:		 /* group reset initiated locally by the software */
@@ -2073,7 +2073,7 @@ ftdm_status_t handle_cgb_req(uint32_t suInstId, uint32_t spInstId, uint32_t circ
 			SS7_ASSERT;
 		};
 
-#if 1
+#if 0
 		SS7_ERROR("KONRAD -> circuit=%d, byte=%d, bit=%d, status[byte]=%d, math=%d\n",
 					x,
 					byte,
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.h b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.h
index c9dbfb3ac8..bab1c8be6a 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.h
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.h
@@ -471,6 +471,8 @@ void ft_to_sngss7_gra(ftdm_channel_t *ftdmchan);
 void ft_to_sngss7_grs(ftdm_channel_t *ftdmchan);
 void ft_to_sngss7_cgba(ftdm_channel_t * ftdmchan);
 void ft_to_sngss7_cgua(ftdm_channel_t * ftdmchan);
+void ft_to_sngss7_cgb(ftdm_channel_t * ftdmchan);
+void ft_to_sngss7_cgu(ftdm_channel_t * ftdmchan);
 
 void sngss7_sta_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
 void sngss7_con_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiConEvnt *siConEvnt);
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_out.c b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_out.c
index 079f5e3e22..46bd39f7fb 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_out.c
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_out.c
@@ -61,6 +61,9 @@ void ft_to_sngss7_lpa(ftdm_channel_t * ftdmchan);
 void ft_to_sngss7_gra(ftdm_channel_t * ftdmchan);
 void ft_to_sngss7_grs(ftdm_channel_t * ftdmchan);
 
+void ft_to_sngss7_cgb(ftdm_channel_t * ftdmchan);
+void ft_to_sngss7_cgu(ftdm_channel_t * ftdmchan);
+
 void ft_to_sngss7_cgba(ftdm_channel_t * ftdmchan);
 void ft_to_sngss7_cgua(ftdm_channel_t * ftdmchan);
 /******************************************************************************/
@@ -121,6 +124,10 @@ void ft_to_sngss7_iam (ftdm_channel_t * ftdmchan)
 		(g_ftdm_sngss7_data.cfg.isupIntf[sngss7_info->circuit->infId].switchType == LSI_SW_ANS92) ||
 		(g_ftdm_sngss7_data.cfg.isupIntf[sngss7_info->circuit->infId].switchType == LSI_SW_ANS95)) {
 
+		/* include only if we're running ANSI */
+		iam.fwdCallInd.transCallNInd.pres   = PRSNT_NODEF;
+		iam.fwdCallInd.transCallNInd.val    = 0x0;
+
 		iam.usrServInfoA.eh.pres				= PRSNT_NODEF;
 
 		iam.usrServInfoA.infoTranCap.pres		= PRSNT_NODEF;
@@ -633,6 +640,106 @@ void ft_to_sngss7_cgua(ftdm_channel_t * ftdmchan)
 	SS7_FUNC_TRACE_EXIT (__FUNCTION__);
 	return;
 }
+
+/******************************************************************************/
+void ft_to_sngss7_cgb(ftdm_channel_t * ftdmchan)
+{
+	SS7_FUNC_TRACE_ENTER (__FUNCTION__);
+
+	sngss7_span_data_t 	*sngss7_span = ftdmchan->span->mod_data;
+	sngss7_chan_data_t	*sngss7_info = ftdmchan->call_data;
+	SiStaEvnt 			cgb;
+	int					x = 0;
+
+
+	memset (&cgb, 0x0, sizeof(cgb));
+
+	/* fill in the circuit group supervisory message */
+	cgb.cgsmti.eh.pres			= PRSNT_NODEF;
+	cgb.cgsmti.typeInd.pres		= PRSNT_NODEF;
+	cgb.cgsmti.typeInd.val		= sngss7_span->tx_cgb.type;
+
+	/* fill in the range */	
+	cgb.rangStat.eh.pres 		= PRSNT_NODEF;
+	cgb.rangStat.range.pres		= PRSNT_NODEF;
+	cgb.rangStat.range.val 		= sngss7_span->tx_cgb.range;
+
+	/* fill in the status */
+	cgb.rangStat.status.pres	= PRSNT_NODEF;
+	cgb.rangStat.status.len 	= ((sngss7_span->tx_cgb.range + 1) >> 3) + (((sngss7_span->tx_cgb.range + 1) & 0x07) ? 1 : 0);
+	for(x = 0; x < cgb.rangStat.status.len; x++){
+		cgb.rangStat.status.val[x] = sngss7_span->tx_cgb.status[x];
+	}
+
+	sng_cc_sta_request (1,
+						0,
+						0,
+						sngss7_span->tx_cgb.circuit,
+						0,
+						SIT_STA_CGBREQ,
+						&cgb);
+	
+	SS7_INFO_CHAN(ftdmchan, "Tx CGB (%d:%d)\n",
+							sngss7_info->circuit->cic,
+							(sngss7_info->circuit->cic + sngss7_span->tx_cgb.range));
+
+	/* clean out the saved data */
+	memset(&sngss7_span->tx_cgb, 0x0, sizeof(sngss7_group_data_t));
+
+	SS7_FUNC_TRACE_EXIT (__FUNCTION__);
+	return;
+}
+
+/******************************************************************************/
+void ft_to_sngss7_cgu(ftdm_channel_t * ftdmchan)
+{
+	SS7_FUNC_TRACE_ENTER (__FUNCTION__);
+
+	sngss7_span_data_t 	*sngss7_span = ftdmchan->span->mod_data;
+	sngss7_chan_data_t	*sngss7_info = ftdmchan->call_data;
+	SiStaEvnt 			cgu;
+	int					x = 0;
+
+
+	memset (&cgu, 0x0, sizeof(cgu));
+
+	/* fill in the circuit group supervisory message */
+	cgu.cgsmti.eh.pres			= PRSNT_NODEF;
+	cgu.cgsmti.typeInd.pres		= PRSNT_NODEF;
+	cgu.cgsmti.typeInd.val		= sngss7_span->tx_cgu.type;
+
+	/* fill in the range */	
+	cgu.rangStat.eh.pres 		= PRSNT_NODEF;
+	cgu.rangStat.range.pres		= PRSNT_NODEF;
+	cgu.rangStat.range.val 		= sngss7_span->tx_cgu.range;
+
+	/* fill in the status */
+	cgu.rangStat.status.pres	= PRSNT_NODEF;
+	cgu.rangStat.status.len 	= ((sngss7_span->tx_cgu.range + 1) >> 3) + (((sngss7_span->tx_cgu.range + 1) & 0x07) ? 1 : 0);
+	for(x = 0; x < cgu.rangStat.status.len; x++){
+		cgu.rangStat.status.val[x] = sngss7_span->tx_cgu.status[x];
+	}
+
+	sng_cc_sta_request (1,
+						0,
+						0,
+						sngss7_span->tx_cgu.circuit,
+						0,
+						SIT_STA_CGUREQ,
+						&cgu);
+	
+	SS7_INFO_CHAN(ftdmchan, "Tx CGU (%d:%d)\n",
+							sngss7_info->circuit->cic,
+							(sngss7_info->circuit->cic + sngss7_span->tx_cgu.range));
+
+	/* clean out the saved data */
+	memset(&sngss7_span->tx_cgu, 0x0, sizeof(sngss7_group_data_t));
+
+	SS7_FUNC_TRACE_EXIT (__FUNCTION__);
+	return;
+}
+
+
 /******************************************************************************/
 /* For Emacs:
  * Local Variables:
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_support.c b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_support.c
index 4ec57fe049..161a70d3ed 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_support.c
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_support.c
@@ -458,6 +458,9 @@ ftdm_status_t check_if_rx_grs_processed(ftdm_span_t *ftdmspan)
 	sngss7_chan_data_t  *sngss7_info = NULL;
 	sngss7_span_data_t	*sngss7_span = (sngss7_span_data_t *)ftdmspan->mod_data;
 	int 				i;
+	int					byte = 0;
+	int					bit = 0;
+
 
 	ftdm_log(FTDM_LOG_DEBUG, "Found Rx GRS on span %d...checking circuits\n", ftdmspan->span_id);
 
@@ -505,6 +508,21 @@ ftdm_status_t check_if_rx_grs_processed(ftdm_span_t *ftdmspan)
 			/* move the channel to the down state */
 			ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
 
+			/* update the status map if the ckt is in blocked state */
+			if ((sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX)) ||
+				(sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_TX)) ||
+				(sngss7_test_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX)) ||
+				(sngss7_test_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX))) {
+			
+				sngss7_span->rx_grs.status[byte] = (sngss7_span->rx_grs.status[byte] | (1 << bit));
+			} /* if blocked */
+			
+			/* update the bit and byte counter*/
+			bit ++;
+			if (bit == 8) {
+				byte++;
+				bit = 0;
+			}
 		} /* for ( i = circuit; i < (circuit + range + 1); i++) */
 
 GRS_UNLOCK_ALL:
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_xml.c b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_xml.c
index 4ebf3b95fd..f6d04ed2e8 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_xml.c
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_xml.c
@@ -1472,7 +1472,7 @@ static int ftmod_ss7_fill_in_isap(sng_isap_t *sng_isap)
 	if (sng_isap->tex != 0) {
 		g_ftdm_sngss7_data.cfg.isap[i].tex		= sng_isap->tex;
 	} else {
-		g_ftdm_sngss7_data.cfg.isap[i].tex		= 10;
+		g_ftdm_sngss7_data.cfg.isap[i].tex		= 1000;
 	}
 	if (sng_isap->tcrm != 0) {
 		g_ftdm_sngss7_data.cfg.isap[i].tcrm		= sng_isap->tcrm;