ss7_decoder.c

example of SS7 file analyzer & decoder

/*---------------------------------------------------------------------*
*                                                                      *
*  SS7_decoder.C                                                       *
*                                                                      *
*                                                                      *
*----------------------------------------------------------------------*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <conio.h>


#include "HdlcRx.h"
#include "mtp.h"
#include "isup.h"


#define PACKET_SIZE	300
#define TIME_UNIT	0.000125f

#ifndef BYTE
	typedef unsigned char BYTE;
#endif


void ProcessFrameMTP( BYTE* pFrame, unsigned long nbByte, unsigned long NumByte, FILE *pfout)
{
	BYTE* pMTP2_Header = pFrame;
	BYTE* pMTP3_Header = pMTP2_Header + SS7_MTP2_HEADER_OFFSET;
	BYTE* pMTP3_USER_PART = pMTP3_Header + SS7_MTP3_HEADER_OFFSET;
	BOOL bMSU = FALSE;
	BYTE FSN, BSN;
static 	BYTE Old_FSN = 0, Old_BSN = 0; 
	int heure, minute;
	float seconde;
	int DPC, OPC;

	seconde = (float) NumByte * TIME_UNIT;
	heure = (int)seconde / 3600;
	seconde -= (float)heure * 3600.0f;
	minute = (int)seconde / 60;
	seconde -= (float)minute * 60.0f;

	/* MTP2 analysis */
	if( nbByte < 5)
	{
		fputs( "!!! NOT MTP2 FRAME !!!", pfout);
	}
	else
	{
		BSN = SS7_MTP2_BSN(pMTP2_Header);
		FSN = SS7_MTP2_FSN(pMTP2_Header);

		if( (FSN != Old_FSN) || (BSN != Old_BSN))
		{
			Old_FSN = FSN;
			Old_BSN = BSN;

			switch( SS7_MTP2_LI(pMTP2_Header))
			{
			case 0: /* FISU */
				fprintf( pfout, "%d:%d:%2.3f - ", heure, minute, seconde);
				fprintf( pfout, "FISU\r\n");
			break;

			case 1 : /* LSSU */
			case 2 :
				fprintf( pfout, "%d:%d:%2.3f - ", heure, minute, seconde);
				fprintf( pfout, "LSSU\r\n");
			break;

			case 63 : /* MSU extended */
				fprintf( pfout, "%d:%d:%2.3f - ", heure, minute, seconde);
				fprintf( pfout, "MSU extended - size %d\r\n", (int)nbByte - 5);
				bMSU = TRUE;
			break;
			default: /* MSU */
				fprintf( pfout, "%d:%d:%2.3f - ", heure, minute, seconde);
				fprintf( pfout, "MSU - LI= %d - nb byte= %d\r\n", (int)SS7_MTP2_LI(pMTP2_Header), (int)nbByte);
				bMSU = TRUE;
			break;
			}
			
			if( bMSU == TRUE)
			{
				DPC = (int)SS7_MTP3_DPC(pMTP3_Header);
				OPC = (int)SS7_MTP3_OPC(pMTP3_Header);

				fprintf( pfout, "\t SI : %d (%s)\r\n", (int)SS7_MTP3_SI(pMTP3_Header), SS7_MTP_USER[(int)SS7_MTP3_SI(pMTP3_Header)]);
				
				fprintf( pfout, "\t DPC : %d (%d-%d-%d) - %s\r\n", DPC, SS7_PC_FORMAT_3_8_3_PART1(DPC), SS7_PC_FORMAT_3_8_3_PART2(DPC), SS7_PC_FORMAT_3_8_3_PART3(DPC), SS7_PC_ZONE[SS7_PC_FORMAT_3_8_3_PART1(DPC)]);
				fprintf( pfout, "\t OPC : %d (%d-%d-%d) - %s\r\n", OPC, SS7_PC_FORMAT_3_8_3_PART1(OPC), SS7_PC_FORMAT_3_8_3_PART2(OPC), SS7_PC_FORMAT_3_8_3_PART3(OPC), SS7_PC_ZONE[SS7_PC_FORMAT_3_8_3_PART1(OPC)]);
				fprintf( pfout, "\t SLS : %d\r\n", (int)SS7_MTP3_SLS(pMTP3_Header));

				fprintf( pfout, "\t %s :\r\n", SS7_MTP_USER[(int)SS7_MTP3_SI(pMTP3_Header)]);
				switch( SS7_MTP3_SI(pMTP3_Header))
				{
				case SS7_SI_ISUP:	
					ISUP_Analysis( pMTP3_USER_PART, nbByte - SS7_MTP2_HEADER_OFFSET - SS7_MTP3_HEADER_OFFSET,pfout);
				break;
				default:
					fprintf( pfout, "\t\t USER PART not implemented\r\n");
					break;
				}
	
				fputs("\r\n", pfout);

			}

		}
	
	}
}

int main(int argc, char* argv[])
{
	static 	char szName[2048];
	static 	char szFileIn[2048];
	static 	char szFileOut[2048];
	static char	szTemp[256], * psz1, * psz2;
	FILE *pfin, *pfout;
	BYTE byteIn, bytePrev1, bytePrev2;
	PHDLC_RX pHdlc;
	int n;
	unsigned long nbByte;
	BOOL bopen = FALSE;
	unsigned int  fcs16;
	BYTE *pHdlcFrame;
	BYTE *pTmpFrame;
	static BYTE HdlcFrame[PACKET_SIZE];
	static BYTE TmpFrame[PACKET_SIZE];
	unsigned long NumByte = 0;
	char *p, *q;

	
	puts( "*----------------------------------------------------------------------*");
	puts( "*                                                                      *");
	puts( "*   SS7 DECODER - V0.0                                                 *");
	puts( "*                                                                      *");
	puts( "*----------------------------------------------------------------------*\n");

 	if( argc >= 2)
	{
		p = szName;
		q = argv[1];
		do
		{
			*p++ = *q++;
		}
		while( *q);
	}
	else
	{
		printf( "SS7 file Name = ");
		scanf( "%s", szName);

		if( strlen(szName) == 0)
		{
			strcpy( szName, "SS7");
		}
	}

	sprintf( szFileIn, "%s", szName);
	printf( "Input file : %s\n\n", szFileIn);

	pfin = fopen( szFileIn, "rb");
	if( pfin == NULL)
	{
		puts( "Erreur ouverture fichier");
		exit(0);
	}
	
	sprintf( szFileOut, "%s_SS7.txt", szName);
	printf( "Output file for SS7 analysis : %s\n\n", szFileOut);

	pfout = fopen( szFileOut, "wb");
	if( pfout == NULL)
	{
		puts( "Erreur creation fichier");
		exit(0);
	}

	pHdlc = HdlcRxCreate();

	n = 1;
	byteIn = 0;
	bytePrev1 = 0;
	while(n==1)
	{
		bytePrev2 = bytePrev1;
		bytePrev1 = byteIn;
		n = fread( &byteIn, sizeof(BYTE), 1, pfin);
		NumByte++;
		if( n == 1)
		{
			HdlcRxPushByte( pHdlc, byteIn);

			if( HdlcRxIsFrameAbort(pHdlc) == TRUE)
			{
				bopen = FALSE;
				
				ProcessFrameMTP( TmpFrame, nbByte, NumByte, pfout);

				HdlcRxPushByte( pHdlc, bytePrev1);
				HdlcRxPushByte( pHdlc, byteIn);
			}

			if( HdlcRxIsDataReady(pHdlc) == TRUE)
			{

				if( bopen == FALSE)
				{
					if( HdlcRxIsFrameOpen(pHdlc) == TRUE)
					{
						bopen = TRUE;

						pHdlcFrame = HdlcFrame;
						*pHdlcFrame++ = byteIn;
						
						pTmpFrame = TmpFrame;
						*pTmpFrame = HdlcRxGetData(pHdlc);

						nbByte = 1;
						
						fcs16 = InitializeFCS16();
						fcs16 = ComputeFCS16( fcs16, *pTmpFrame);

						*pTmpFrame++;

					}
				}
				else
				{
					if( HdlcRxIsFrameClose(pHdlc) == TRUE)
					{

						bopen = FALSE;

						ProcessFrameMTP( TmpFrame, nbByte, NumByte, pfout);
	
					}
					else
					{
						*pHdlcFrame++ = byteIn;

						*pTmpFrame = HdlcRxGetData(pHdlc);
						
						nbByte++;
			
						if( nbByte >= PACKET_SIZE)
						{
							puts( "overflow.....");
							HdlcDestroy(pHdlc);
							pHdlc = HdlcRxCreate();
							nbByte = 0;
							bopen = FALSE;
						}

						fcs16 = ComputeFCS16( fcs16, *pTmpFrame);

						*pTmpFrame++;

					}
				}
			}

		}
		else
		{
		}
	}

	HdlcDestroy(pHdlc);

	fclose(pfout);

	fclose(pfin);

	puts( "That's all folks !");
#ifdef _DEBUG
	_getch();
#endif

	return 0;
}