cmppserver.c

用c/c++实现的一个CMPP API

#include "../os.h"
#include "../cmppapi.h"
#include "../datatype.h"
#include "TcpSock.h"
#include "cmpppack.h"

#define MacPort          6668

/**************************************************************************
   Print to binary Memory info 
   打印成 0000: 00 00 00 00 00 00 00 00 00 00 | .....12334.
   bufferlen 和 LINELEN 的关系可以从上面的大小得到
**************************************************************************/
#define LINELEN     16
#define MAXBUFSIZE  4096

void    vFormatPrintBin( FILE* fp,  void* pvMem, size_t sizeMem )
{
    
    int i = 0, j = 0, k = 0, tail = 0;
    
    //char buf[1024*10];
    char    bufstack[ MAXBUFSIZE ] ;
    char *p, c;
    char* buf;

    char* content;
    int   len;
    int   bufferlen;
    
        
    if( (fp == NULL) || (pvMem == NULL) || (sizeMem <= 0 ))
    {
        return ;
    }
    

    content = ( char* ) pvMem;
    
    len = sizeMem;
    
    //打印成 0000: 00 00 00 00 00 00 00 00 00 00 | .....12334.
    // bufferlen 和 LINELEN 的关系可以从上面的大小得到
    bufferlen = (len/LINELEN+1)*( LINELEN*5 + 4 + 8 ) ;
    
    
    if( bufferlen > MAXBUFSIZE )
    {
        buf = (char*)malloc( bufferlen );
        
        if ( buf == NULL )
        {
            return ;
        }
        memset( buf, 0, bufferlen );
    }
    else    /* use bufstack */
    {   
        buf = ( char* )bufstack;
    }   
            
    //打印成 0000: 00 00 00 00 00 00 00 00 00 00 | .....12334.
    //类似的格式
    p = buf;
    for (i = 1, j = 0; i <= len; i++, j++)
    {
        if (j % LINELEN == 0)
        {
            //打印行号
            sprintf(p, "%04d: ", j / LINELEN);
            p += 5;
        }

        sprintf(p, " %02x", (unsigned char)*content++);
        p += 3;
        if (i % LINELEN == 0)
        {
            //打印ASC字符
            sprintf(p, " | ");
            p +=3;
            for (k = 0; k < LINELEN; k++)
            {
                c = *(content - LINELEN + k);
                if ( c > 32 && c < 127) 
                    sprintf(p++, "%c", c);
                else
                    sprintf(p++, ".");
            }
            sprintf(p++, "\n");
        }
    }

    //最后不足LINELEN的部分也要打印ASC字符
    tail = len % LINELEN;
    if (tail > 0)
    {
        for (k = 0; k < LINELEN-tail; k++)
        {
            //补足空格
            sprintf(p, "   ");
            p += 3;
        }
        
        sprintf(p, " | ");
        p += 3;
        for (k = 0; k < tail; k++)
        {
            c = *(content - tail + k);
            if ( c > 32 && c < 127)
            {
                sprintf(p++, "%c", c);
            }
            else
            {
                sprintf(p++, ".");
            }
        }
        sprintf(p++, "\n");     
    }
    else
    {
        sprintf(p, "\n");
    }
        
    fprintf( fp, "%s\n", buf  );
    fflush ( fp );
    
    if( bufferlen > MAXBUFSIZE )
    {
        free( buf );
    }
    return ;
}

void vPrintConnect(recCmppConnect rCmppConnect)
{
	printf("\tCMPP CONNECT CONTENT:\n"
		   "\t\tSourceAddr          =%s\n"
		   "\t\tAuthSource          =%s\n"
		   "\t\tVersion             =0x%2x\n"
		   "\t\tTimeStamp           =%d\n",
		   rCmppConnect.chSourceAddr,
		   rCmppConnect.chAuthSource,
		   rCmppConnect.ucVersion,
		   rCmppConnect.unTimestamp);
}

void  vPrintConnectResp(recCmppConnectResp rCmppConnectResp)
{
	printf("\tCMPP CONNECT RESP CONTENT:\n"
		   "\t\tStatus          =0x%2x\n"
		   "\t\tAuthIsmg        =%s\n"
		   "\t\tVersion         =0x%2x\n",
		   rCmppConnectResp.unStatus,
		   rCmppConnectResp.chAuthIsmg,
		   rCmppConnectResp.ucVersion);
	
}

void vPrintSubmit(recCmppSubmit rCmppSubmit)
{
		printf("\tCMPP SUBMIT CONTENT:\n"
		   "\t\tMsgId         =[%02x %02x %02x %02x %02x %02x %02x %02x]\n"
		   "\t\tPk_total      =0x%2x\n"
		   "\t\tPk_number     =0x%2x\n"
		   "\t\tRegister_Del  =0x%2x\n"
		   "\t\tMsg_level     =0x%2x\n"
		   "\t\tServId        =%s\n"
		   "\t\tFeeUserType   =0x%2x\n"
		   "\t\tFeeTermId     =%s\n"
		   "\t\tFeeTermIdType=0x%2x\n"
		   "\t\tTp_pId        =0x%2x\n"
		   "\t\tTp_udhi       =0x%2x\n"
		   "\t\tMsgFmt        =0x%2x\n"
		   "\t\tMsgSrc        =%s\n"
		   "\t\tFeeType       =%s\n"
		   "\t\tFeeCode       =%s\n"
		   "\t\tValidTime     =%s\n"
		   "\t\tAtTime        =%s\n"
		   "\t\tSrcId         =%s\n"
		   "\t\tDestUsr_tl    =0x%2x\n"
		   "\t\tDestTermId    =%s\n"
		   "\t\tDestTermIdType =0x%2x\n"
		   "\t\tMsgLen        =0x%2x\n"
		   "\t\tMsgContent    =%s\n"
		   "\t\tLinkId      =%s\n",
		   rCmppSubmit.uchMsgId[0],
		   rCmppSubmit.uchMsgId[1],
		   rCmppSubmit.uchMsgId[2],
		   rCmppSubmit.uchMsgId[3],
		   rCmppSubmit.uchMsgId[4],
   		   rCmppSubmit.uchMsgId[5],
   		   rCmppSubmit.uchMsgId[6],
   		   rCmppSubmit.uchMsgId[7],
		   rCmppSubmit.ucPkTotal,
		   rCmppSubmit.ucPkNumber,
		   rCmppSubmit.ucRegisterDelivery,
		   rCmppSubmit.ucMsgLevel,
		   rCmppSubmit.chServiceId,
		   rCmppSubmit.ucFeeUserType,
		   rCmppSubmit.chFeeTerminateId,
		   rCmppSubmit.ucFeeTerminalType,
		   rCmppSubmit.ucTpPid,
		   rCmppSubmit.ucTpUdhi,
		   rCmppSubmit.ucMsgFmt,
		   rCmppSubmit.chMsgSrc,
		   rCmppSubmit.chFeeType,
		   rCmppSubmit.chFeeCode,
		   rCmppSubmit.chValidTime,
		   rCmppSubmit.chAtTime,
		   rCmppSubmit.chSrcId,
		   rCmppSubmit.ucDestUsrTl,
		   rCmppSubmit.chDstTerminalId,
		   rCmppSubmit.ucDstTerminalType,
		   rCmppSubmit.ucMsgLength,
		   rCmppSubmit.chMsgContent,
		   rCmppSubmit.chLinkId);
}

void vPrintSubmitResp(recCmppSubmitResp rCmppSubmitResp)
{	
	printf("\tCMPP SUBMIT CONTENT:\n"
	       "\t\tMsgId         =[%02x %02x %02x %02x %02x %02x %02x %02x]\n"
	       "\t\tResult        =0x%2x\n",
	       rCmppSubmitResp.uchMsgId[0],
       	rCmppSubmitResp.uchMsgId[1],
       	rCmppSubmitResp.uchMsgId[2],
       	rCmppSubmitResp.uchMsgId[3],
       	rCmppSubmitResp.uchMsgId[4],
    	       rCmppSubmitResp.uchMsgId[5],
    	       rCmppSubmitResp.uchMsgId[6],
  	       rCmppSubmitResp.uchMsgId[7],
	       rCmppSubmitResp.unResult);
}

void vPrintDeliver(recCmppDeliver rCmppDeliver)
{
	printf("\tCMPP Deliver CONTENT:\n"
	       "\t\tMsgId         =%s\n"
	       "\t\tDestId        =%s\n"
	       "\t\tServid        =%s\n"
	       "\t\tTpPid         =0x%2x\n"
	       "\t\tTpUdhi        =0x%2x\n"
	       "\t\tMsgFmt        =0x%2x\n"
	       "\t\tSrcTermId     =%s\n"
	       "\t\tSrcTermIdType =0x%2x\n"
	       "\t\tRegisterDel   =0x%2x\n"
	       "\t\tMsg_Len       =0x%2x\n"
	       "\t\tMsgContent    =%s\n"
	       "\t\tLinkId       =%s\n",
	       rCmppDeliver.uchMsgId,
	       rCmppDeliver.chDestId,
	       rCmppDeliver.chServiceId,
	       rCmppDeliver.ucTpPid,
	       rCmppDeliver.ucTpUdhi,
	       rCmppDeliver.ucMsgFmt,
	       rCmppDeliver.chSrcTerminalId,
	       rCmppDeliver.ucSrcTerminalType,
	       rCmppDeliver.ucRegisterDelivery,
	       rCmppDeliver.ucMsgLength,
	       rCmppDeliver.chMsgContent,
	       rCmppDeliver.chLinkId);
	
}
void vPrintDeliverResp(recCmppDeliverResp rCmppDeliverResp)
{
	printf("\tCMPP DeliverResp CONTENT:\n"
	       "\t\tMsgId         =%16x\n"
	       "\t\tResult        =%c\n",
	       (int)rCmppDeliverResp.uchMsgId,
	       rCmppDeliverResp.unResult);
	
}
void vPrintQuery(recCmppQuery rCmppQuery)
{
}
void vPrintQueryResp(recCmppQueryResp rCmppQueryResp)
{
}
void vPrintCancel(recCmppCancel rCmppCancel)
{
}
void vPrintCancelResp(recCmppCancelResp rCmppCancelResp)
{
}
void vPrintActive(recCmppActiveTest rCmppActiveTest)
{
	printf("\tCMPP Active CONTENT:\n");
}
void vPrintActiveResp(recCmppActiveTestResp rCmppActiveTestResp)
{
	printf("\tCMPP ActiveResp CONTENT:\n"
		   "\t\tReserve        =0x%2x\n",
		   rCmppActiveTestResp.ucReserver);
}

void vPrintfCmppHead(recCmppPck* prCmppPck)
{
	printf("\tCMPP HEAD:\n"
		   "\t\tTotalLength       =%d\n"
		   "\t\tCommandId         =%4x\n"
		   "\t\tSequence          =%d\n",
		   prCmppPck->rHead.unTotalLength,
		   prCmppPck->rHead.unCommandId,
		   prCmppPck->rHead.unSequenceId);
	
}
void vPrintCmppPack(recCmppPck rCmppPck)
{
	vPrintfCmppHead(&rCmppPck);
	switch(rCmppPck.rHead.unCommandId)
	{
		 case MacC_ConnectRqst:
        {
     	    vPrintConnect(rCmppPck.body.rCmppConnect);
            break;
        }
        case MacC_ConnectRep:
        {
			vPrintConnectResp(rCmppPck.body.rCmppConnectResp); 
			break;
        }
        case MacC_SubmitRqst:
        {
            vPrintSubmit(rCmppPck.body.rCmppSubmit);
            break;
        }
        case MacC_SubmitRep:
        {
            vPrintSubmitResp(rCmppPck.body.rCmppSubmitResp);
            break;
        }
        case MacC_DeliverRqst:
        {
            vPrintDeliver(rCmppPck.body.rCmppDeliver);
            break;
        }
        case MacC_DeliverRep:
        {
            vPrintDeliverResp(rCmppPck.body.rCmppDeliverResp);
            break;
        }
        case MacC_QueryRqst:
        {
            vPrintQuery(rCmppPck.body.rCmppQuery);
            break;
        }
        case MacC_QueryRep:
        {
           vPrintQueryResp(rCmppPck.body.rCmppQueryResp);
            break;
        }
        case MacC_CancelRqst:
        {
            vPrintCancel(rCmppPck.body.rCmppCancel);
            break;
        }
        case MacC_CancelRep:
        {
            vPrintCancelResp(rCmppPck.body.rCmppCancelResp);
            break;
        }
        case MacC_ActiveRqst:
        {
            vPrintActive(rCmppPck.body.rCmppActiveTest);
            break;
        }
        case MacC_ActiveRep:
        {
            vPrintActiveResp(rCmppPck.body.rCmppActiveTestResp);
            break;
        }	
	}	
}

int nConnectMakeResponse(int nResult, recCmppPck* prCmppPckResp,  recCmppPck* prCmppPck)
{
	prCmppPckResp->rHead.unTotalLength = MacHeadLen + MacConnectResLen;
	prCmppPckResp->rHead.unCommandId = MacC_ConnectRep;
	prCmppPckResp->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;

	memcpy(prCmppPckResp->body.rCmppConnectResp.chAuthIsmg, 
		   prCmppPck->body.rCmppConnect.chAuthSource, MacAuthIsmg);
	prCmppPckResp->body.rCmppConnectResp.ucVersion = prCmppPck->body.rCmppConnect.ucVersion;
	prCmppPckResp->body.rCmppConnectResp.unStatus =  nResult;

	return 0;
}

int nSubmitMakeResponse(int nResult, recCmppPck* prCmppPckResp,  recCmppPck* prCmppPck)
{
	prCmppPckResp->rHead.unTotalLength = MacHeadLen + MacSubmitResLen;
	prCmppPckResp->rHead.unCommandId = MacC_SubmitRep;
	prCmppPckResp->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;

	memcpy(prCmppPckResp->body.rCmppSubmitResp.uchMsgId, 
		   prCmppPck->body.rCmppSubmit.uchMsgId, MacMsgId);
	prCmppPckResp->body.rCmppSubmitResp.unResult =  nResult;
	
	return 0;
}
int nDeliverMakeResponse(int nResult, recCmppPck* prCmppPckResp,  recCmppPck* prCmppPck)
{
	prCmppPckResp->rHead.unTotalLength = MacHeadLen + MacDeliverResLen;
	prCmppPckResp->rHead.unCommandId = MacC_DeliverRep;
	prCmppPckResp->rHead.unSequenceId = prCmppPck->rHead.unSequenceId;