ss7trace.cpp

基于NMS的ss7 4.3写的信令跟踪程序 log到文件 用ethereal可打开

/******************************************************************
 **
 **			   PROPRIETARY NOTICE
 **
 **         Copyright (c) 1995,1996,2001
 **         By TEKnique, Inc., NSS
 **
 **
 **  The following is licensed program material and is considered
 **  proprietary and confidential.  No part of this program may be
 **  reproduced or used in any form or by any means without the
 **  express written permission of TEKnique, Inc. & NSS
 **
 *****************************************************************/
/* TXxxxx trace capturing daemon */

#ifdef UNIX
#include <stdio.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/stream.h>
#endif	                                /* UNIX */

#ifdef __OS2__
#include <stdio.h>
#include <stddef.h>
#include <ctype.h>
#include <string.h>
#endif	                                /* __OS2__ */

#ifdef WIN32
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#endif                                  /* WIN32 */

#define _TX_ISUPGT_SOURCE_

#include "ss7type.h"
#include "txcpi.h"
#include "dpruser.h"

#include "tx_core.h"
#include "ss7trace.h"
#include "savingLib.h"

#define  DEFAULTTRACECHAN 0x2f

static char *usagestr = "Usage: %s <-c chan> <-f filename> <-s>\n"
						"    -c    which channel captured only, default all channels\n"
						"    -f    save file as ethereal format\n"
						"    -s    dump HEX message in console, default not dump to console\n"
						"\n"
						"The patch will capture the MTP message only, if you want\n"
						"other levels' messages, please use ss7trace instead\n"
						"\n";
extern CPI_WAIT_TYPE stdInput;

savingLib*  binFile     = NULL;
bool		showhex		= false;

/* acros to control byte swabbing depending on whether source is host or a board */
#define CPI_HTOCP_L(board, x) ((board != 0) ? cpi_htocp_l(x) : x)
#define CPI_HTOCP_S(board, x) ((board != 0) ? cpi_htocp_s(x) : x)

void hexdump(char *in, char *out, short length)
{
    short   i;

    for (i = 0; i < length; i++)
        out += sprintf(out, "%02X ", (unsigned char)in[i]);

    for (; i < 16; i++)
        out += sprintf(out, "   ", (unsigned char)in[i]);

    for (i = 0; i < length; i++)
        if (isprint(in[i]))
            out += sprintf(out, "%c", (unsigned char)in[i]);
        else
            out += sprintf(out, ".", (unsigned char)in[i]);

    for (; i < 16; i++)
        out += sprintf(out, " ", (unsigned char)in[i]);
}

int dumpHex(char *buffer, short len, bool show)
{
	//if( (len <= 0) || (*buffer & 0x0f != 5) )
	//	return 0;

    if(binFile) {
        char tmpbuffer[1024];
        // fake TP2 header
        memcpy(tmpbuffer, "\x00\x00\x3f", 3);
        memcpy(tmpbuffer + 3, buffer, len);
        binFile->save(tmpbuffer, len + 3);
    }
	if(show) {
		char line[100];

		fflush(stdout);
		do
		{
			hexdump(buffer, line, (short)((len >= 16) ? 16 : (len % 16)));
			fprintf(stdout, "\n%s", line);
			buffer += 16;
		} while ((len -= 16) > 0);
		fprintf(stdout, "\n");

		fflush(stdout);
	}

    return(0);
}

short ExitRoutine(TX_HANDLE handle, short events)
{
	char c;

	/* check if input event really did occur */
	if (tx_core_process_events(TX_CORE_INPUT, events) == FALSE)
		return (TX_CORE_SUCCESS);

	/* make sure a key was hit */
	if (tx_core_kbhit()) {
		c = getchar();
		return (TX_CORE_EXIT_POLL_LOOP);
	}

	return (TX_CORE_SUCCESS);
}

short GetTrace(TX_HANDLE handle, short events)
{
    CPIPKT data;
    short  ret;
    short  len = CPIBUFSIZE;
    char   dir[4];
    short  length;
    U32    dpc;
    short  event;

    /* check if input event really did occur */
	if (tx_core_process_events(TX_CORE_INPUT, events) == FALSE)
		return (TX_CORE_SUCCESS);

    if ((ret = cpi_get_data(handle, (CPIPKT *)&data, &len)) == CPI_ERROR)
    {
		printf("Receive Error (%d)\n", cpi_get_last_error());
		return (TX_CORE_ERROR);
    }
    else
    {
        switch ( ((DPRH*)&data)->srcch)
        {
            case ISUP_ENT :                /* ISUP */
            {
				/*
                IsupgmtReq *mgmt = (IsupgmtReq*)&data;

                event = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->req.trc.evnt );

                if (event == TRCSGTX)
                    strcpy(dir, "-->");
                else if (event == TRCSGRX)
                    strcpy(dir, "<--");
                else
                    strcpy(dir, "???");
                dpc = CPI_HTOCP_L( mgmt->dprh.srcbd, mgmt->req.trc.dpc );
                printf("\n%d:%02d:%02d.%d ISUP.%d %s %d.%d.%d:\n",
                                    mgmt->req.trc.dt.hour,
                                    mgmt->req.trc.dt.min,
                                    mgmt->req.trc.dt.sec,
                                    mgmt->req.trc.dt.tenths,
                                    mgmt->dprh.srcbd,
                                    dir,
                                    ((dpc >> 16) & 0xff),
                                    ((dpc >>  8) & 0xff),
                                    ((dpc >>  0) & 0xff));


                length = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->req.trc.length );

                dumpHex((char *)mgmt->req.trc.evntParm, length);
				*/

                return (TX_CORE_SUCCESS);
            }
            case TCAP_ENT :                /* TCAP */
            {
				/*
                TcapgmtTrace *mgmt = (TcapgmtTrace*)&data;
                short sapNum;

                event = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->req.trc.evnt );

                if (event == LST_SG_TXED)
                    strcpy(dir, "-->");
                else if (event == LST_SG_RECVD)
                    strcpy(dir, "<--");
                else
                    strcpy(dir, "???");

                sapNum = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->hdr.elmId.elmntInst1 );

                printf("\n%d:%02d:%02d.%d TCAP.%d %s : sapNum = %d\n",
                                    mgmt->req.trc.dt.hour,
                                    mgmt->req.trc.dt.min,
                                    mgmt->req.trc.dt.sec,
                                    mgmt->req.trc.dt.tenths,
                                    mgmt->dprh.srcbd,
                                    dir,
                                    sapNum);

                dumpHex((char *)mgmt->req.trc.evntParm, mgmt->req.trc.len);
				*/
                return (TX_CORE_SUCCESS);
            }
            case SCCP_ENT :                /* SCCP */
            {
				/*
                SccpgmtTrace *mgmt = (SccpgmtTrace*)&data;
                short sapNum;

                event = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->req.trc.evnt );

                if (event == LSP_SG_TXED)
                    strcpy(dir, "-->");
                else if (event == LSP_SG_RECVD)
                    strcpy(dir, "<--");
                else
                    strcpy(dir, "???");

                sapNum = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->hdr.elmId.elmntInst1 );

                printf("\n%d:%02d:%02d.%d SCCP.%d %s : sapNum = %d\n",
                                    mgmt->req.trc.dt.hour,
                                    mgmt->req.trc.dt.min,
                                    mgmt->req.trc.dt.sec,
                                    mgmt->req.trc.dt.tenths,
                                    mgmt->dprh.srcbd,
                                    dir,
                                    sapNum);

                dumpHex((char *)mgmt->req.trc.evntParm, mgmt->req.trc.len);
				*/
                return (TX_CORE_SUCCESS);
            }
            case MTP3_ENT :                /* TP3 */
            {
                mtp3MgmtTrace *mgmt = (mtp3MgmtTrace*)&data;
                short sapNum;

                event = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->req.trc.evnt );

				if((int )mgmt->req.trc.evntParm[0] != 0x85)
					return TX_CORE_SUCCESS;

				if(showhex) {
					if (event == LSN_MSG_TX)
						strcpy(dir, "-->");
					else if (event == LSN_MSG_RX)
						strcpy(dir, "<--");
					else
						strcpy(dir, "???");

					sapNum = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->hdr.elmId.elmntInst1 );

					printf("\n%d:%02d:%02d.%d TP3.%d %s : Link # %d\n",
										mgmt->req.trc.dt.hour,
										mgmt->req.trc.dt.min,
										mgmt->req.trc.dt.sec,
										mgmt->req.trc.dt.tenths,
										mgmt->dprh.srcbd,
										dir,
										sapNum);
				}

 
                length = CPI_HTOCP_S( mgmt->dprh.srcbd, mgmt->req.trc.len );
                dumpHex((char *)&(mgmt->req.trc.evntParm[0]), length,showhex );

                return (TX_CORE_SUCCESS);
            }
            case TUP_ENT :                /* TUP */
            {
				/*
                TupgmtTrace *mgmt = (TupgmtTrace *)&data;

                event = CPI_HTOCP_S( mgmt->dpr.srcbd, mgmt->data.trc.evnt );

                if (event == TRCSGTX)
                    strcpy(dir, "-->");
                else if (event == TRCSGRX)
                    strcpy(dir, "<--");
                else
                    strcpy(dir, "???");

                dpc = CPI_HTOCP_L( mgmt->dpr.srcbd, mgmt->data.trc.dpc );
                printf("\n%d:%02d:%02d.%d TUP.%d %s %d.%d.%d:\n",
                                    mgmt->data.trc.dt.hour,
                                    mgmt->data.trc.dt.min,
                                    mgmt->data.trc.dt.sec,
                                    mgmt->data.trc.dt.tenths,
                                    mgmt->dpr.srcbd,
                                    dir,
                                    ((dpc >> 16) & 0xff),
                                    ((dpc >>  8) & 0xff),
                                    ((dpc >>  0) & 0xff));

                length = CPI_HTOCP_S( mgmt->dpr.srcbd, mgmt->data.trc.length );

                dumpHex((char *)mgmt->data.trc.evntParm, length);
				*/
                return (TX_CORE_SUCCESS);
            }
            case IUP_ENT :                /* IUP */
            {
//                IupgmtTrace *mgmt = (IupgmtTrace *)&data;
//
//               /* printf("event=%d\n", mgmt->trc.evnt); */
//                event = CPI_HTOCP_S( mgmt->hdr.dpr.srcbd, mgmt->trc.evnt);
//
//                /* printf("event=%d\n", event); */
//                if (event == TRCSGTX)
//                    strcpy(dir, "-->");
//                else if (event == TRCSGRX)
//                    strcpy(dir, "<--");
//                else
//                    strcpy(dir, "???");
//
//                dpc = CPI_HTOCP_L( mgmt->hdr.dpr.srcbd, mgmt->trc.dpc );
//                printf("\n%d:%02d:%02d.%d IUP.%d %s %d.%d.%d:\n",
//                                    mgmt->trc.dt.hour,
//                                    mgmt->trc.dt.min,
//                                    mgmt->trc.dt.sec,
//                                    mgmt->trc.dt.tenths,
//                                    mgmt->hdr.dpr.srcbd,
//                                    dir,
//                                    ((dpc >> 16) & 0xff),
//                                    ((dpc >>  8) & 0xff),
//                                    ((dpc >>  0) & 0xff));
//
//                length = CPI_HTOCP_S( mgmt->hdr.dpr.srcbd, mgmt->trc.length );
//
//                dumpHex((char *)mgmt->trc.evntParm, length);

                return (TX_CORE_SUCCESS);
            }
            default:
                return (TX_CORE_SUCCESS);
        }
	}
}

int main( int argc, char* argv[] )
{
    S32 cps[MAXBOARD + 1];
	TX_HANDLE fds[MAXBOARD + 1];
	short i;
    short chan = DEFAULTTRACECHAN;
	char *myname;
	char *str = NULL;
	char sbuf[CPSTRSIZE], *vstr = sbuf; /* dummy for old cpi_init */
	short port;
	char fileName[FILENAME_MAX];

    printf("Trace onitor SS7 V4.0 patch 1: Hit Enter to exit\n");
    printf("Copyright 2004, NS Communications Corporation\n");
    printf("modified by Wilbur Lang, Airsurprise Techonlogy Co., LTD.\n");

    /* Open the txXXXX */

	myname = argv[0];

	i = 1;
	while (i < argc) {
		str = argv[i];
		if (*str == '-') {
			switch (*++str) {
			case 'c':	/* which channel should we speak through */
				chan = atoi(++str);
				break;

			case 'f':
                if (*++str)         /* was there no space ? */
                    strcpy(fileName, str);
                else
                    strcpy(fileName, argv[++i]);

                binFile = new savingLib(fileName);
				break;

			case 's':
				showhex = true;
				break;

			default:
				printf(usagestr, myname);
				exit(1);
			}
		}
		++i;
	}

	if (chan < 1) {
		printf(usagestr, argv[0]);
		exit(2);
	}
	/* Process console data */

	if (tx_core_init() != TX_CORE_SUCCESS) {
		printf("Could not initialize core routines\n");
		exit(1);
	}

	cpi_init(0, &vstr);

	cpi_get_resources(MAXBOARD, cps);

    for (i = 0; i <= MAXBOARD; ++i) {
		if (cps[i]) {
			port = PORT(i,chan);
			if ((fds[i] = cpi_open(port, CPIM_PORT, NULL)) == CPI_INVALID_HANDLE) {
                printf("%s : could not open board %d driver %x\n", argv[0], i, cpi_get_last_error());
			} else {
                tx_core_install_handler(cpi_wait_obj(fds[i]), fds[i], GetTrace);
				tx_core_set_poll(cpi_wait_obj(fds[i]), TX_CORE_INPUT);

			}
		}
	}

	tx_core_install_handler(stdInput, CPI_INVALID_HANDLE, ExitRoutine);
	tx_core_set_poll(stdInput, TX_CORE_INPUT);

	tx_core_poll_loop(TX_CORE_INFINITE);

	/* close all the handles */
    for (i = 0; i <= MAXBOARD; ++i)
		if (fds[i])
			cpi_close(fds[i]);

    if(binFile) {
        delete binFile;
        binFile = 0;
    }

	return (0);
}