cmpppack.c

来自「用c/c++实现的一个CMPP API」· C语言 代码 · 共 2,267 行 · 第 1/5 页

		if((nContentLen <= 0)||(nContentLen >= 160))
		{
			return -2;
		}
	}
	else
	{
		if((nContentLen <= 0)||(nContentLen > 140))
		{
			return -2;
		}
	}
	
    /* 11 Name: Msg_Content length: 160 */
    memcpy(psHead, prCmppDeliver->chMsgContent, nContentLen);
    psHead = psHead + nContentLen;

    /* 12 Name: Reserve length: 8 */
    memcpy(psHead, prCmppDeliver->chLinkId, MacLinkId);
    
    return 0;
}

/************************************************************************
  Function ID:  nDeliverRespEncode
  Description:  CMPP协议的deliverResp pack 组包函数
  Input Param:  recCmppDeliverResp*    prCmppDeliverResp
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nDeliverRespEncode(unsigned char* psEndoceStr,recCmppDeliverResp* prCmppDeliverResp)
{
	int nRet;
	int nTmp;
    unsigned char* psHead;

    if((NULL == psEndoceStr) || (NULL == prCmppDeliverResp))
    {
        return -1;
    }

    nRet = nVerifyDeliverResp(prCmppDeliverResp);
    if(nRet != 0)
    {
    	return -2;
    }
    
    psHead = psEndoceStr;

    /* 1 Name: MsgId length: 8 */
    memcpy(psHead, prCmppDeliverResp->uchMsgId, MacMsgId);
    psHead = psHead + MacMsgId;

    /* 2 Name: Result length: 4 */
    nTmp = htonl(prCmppDeliverResp->unResult);
    memcpy(psHead, &nTmp, sizeof(int));
    
    return 0;
}

/************************************************************************
  Function ID:  nQueryReqEncode
  Description:  CMPP协议的QueryReq  pack 组包函数
  Input Param:  recCmppQuery*          prCmppQuery
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nQueryReqEncode(unsigned char* psEndoceStr,recCmppQuery* prCmppQuery)
{
	int nRet;
    unsigned char* psHead;

    if((NULL == psEndoceStr) || (NULL == prCmppQuery))
    {
        return -1;
    }

    nRet = nVerifyQuery(prCmppQuery);
    if(nRet != 0)
    {
    	return -2;
    }
    
    psHead = psEndoceStr;

    /* 1 Name: Time length 8 */
    memcpy(psHead, prCmppQuery->chTime, MacQueryTime);
    psHead = psHead + MacQueryTime;

    /* 2 Name: Query Type length: 1 */
    *psHead = prCmppQuery->ucQueryType;
    psHead ++;

    /* 3 Name: Query Code length: 10 */
    memcpy(psHead, prCmppQuery->chQueryCode, MacQueryCode);
    psHead = psHead + MacQueryCode;

    /* 4 Name: Reserve length: 8 */
    memcpy(psHead, prCmppQuery->chReserve, MacReserve);
    
    return 0;
}

/************************************************************************
  Function ID:  nQueryRespEncode
  Description:  CMPP协议的QueryResp  pack 组包函数
  Input Param:  recCmppQueryResp*      prCmppQueryResp
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nQueryRespEncode(unsigned char* psEndoceStr,recCmppQueryResp* prCmppQueryResp)
{
	int nRet;
	unsigned int nNetSequence;
    unsigned char* psHead;

    if((NULL == psEndoceStr) || (NULL == prCmppQueryResp))
    {
        return -1;
    }

    nRet = nVerifyQueryResp(prCmppQueryResp);
    if(nRet != 0)
    {
    	return -2;
    }
    
    psHead = psEndoceStr;

    /* 1 Name: Time length: 8 */
    memcpy(psHead, prCmppQueryResp->chTime, MacQueryTime);
    psHead = psHead + MacQueryTime;

    /* 2 Name: Query type length: 1 */
    *psHead = prCmppQueryResp->ucQueryType;
    psHead ++;

    /* 3 Name: Query Code length: 10 */
    memcpy(psHead, prCmppQueryResp->chQueryCode, MacQueryCode);
    psHead = psHead + MacQueryCode;

    /* 4 Name: Mt_TlMsg length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMtTlMsg);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 5 Name: Mt_Tlusr length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMtTlUsr);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 6 Name: Mt_Scs   length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMtScs);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 7 Name: MT_Wt    length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMtWt);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 8 Name: Mt_Fl    length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMtFl);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 9 Name: Mo_Scs   length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMoScs);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 10 Name: Mo_Wt   length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMoWt);
    memcpy(psHead, &nNetSequence, sizeof(int));
    psHead = psHead + sizeof(int);

    /* 11 Name: Mo_Fl   length: sizeof(int) */
    nNetSequence = htonl(prCmppQueryResp->unMoFl);
    memcpy(psHead, &nNetSequence, sizeof(int));
    
    return 0;
}

/************************************************************************
  Function ID:  nCancelReqEncode
  Description:  CMPP协议的CancelReq  pack 组包函数
  Input Param:  recCmppCancel*         prCmppCancel
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nCancelReqEncode(unsigned char* psEndoceStr,recCmppCancel* prCmppCancel)
{
	int nRet;
    unsigned char* psHead;

    if((NULL == psEndoceStr) || (NULL == prCmppCancel))
    {
        return -1;
    }

    nRet = nVerifyCancel(prCmppCancel);
    if(nRet != 0)
    {
    	return -2;
    }
    
    psHead = psEndoceStr;

    /* 1 Name: MsgId length: 8 */
    memcpy(psHead, prCmppCancel->uchMsgId, MacMsgId);
    
    return 0;
}

/************************************************************************
  Function ID:  nCancelRespEncode
  Description:  CMPP协议的CancelResp  pack 组包函数
  Input Param:  recCmppCancelResp*     prCmppCancelResp
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nCancelRespEncode(unsigned char* psEndoceStr,recCmppCancelResp* prCmppCancelResp)
{
	int nRet;
	int nTmp;
    unsigned char* psHead;

    if((NULL == psEndoceStr) || (NULL == prCmppCancelResp))
    {
        return -1;
    }

    nRet = nVerifyCancelResp(prCmppCancelResp);
    if( nRet !=0 )
    {
    	return -2;
    }
    
    psHead = psEndoceStr;
    
    /* 1 Name: SuccessId length: 4 */
    nTmp = htonl(prCmppCancelResp->unSuccessId);
    memcpy(psHead, &nTmp, sizeof(int));
    
    
    return 0;
}

/************************************************************************
  Function ID:  nActiveReqEncode
  Description:  CMPP协议的ActiveReq    pack 组包函数
  Input Param:  recCmppActiveTest*     prCmppActiveTest
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nActiveReqEncode(unsigned char* psEndoceStr,recCmppActiveTest* prCmppActiveTest)
{
	int nRet;
	
    if((NULL == psEndoceStr) || (NULL == prCmppActiveTest))
    {
        return -1;
    }

    nRet = nVerifyActive(prCmppActiveTest);
    if(nRet !=  0)
    {
    	return -2;
    }
    
    return 0;
}

/************************************************************************
  Function ID:  nActiveRespEncode
  Description:  CMPP协议的ActiveResp    pack 组包函数
  Input Param:  recCmppActiveTest*     prCmppActiveTest
  Output Param: unsigned char*         psEndoceStr
  Return:       int                    0   success
                                       -1  failed
                                
*************************************************************************/
int nActiveRespEncode(unsigned char* psEndoceStr,recCmppActiveTestResp* prCmppActiveTestResp)
{
	int nRet;
    unsigned char* psHead;

    if((NULL == psEndoceStr) || (NULL == prCmppActiveTestResp))
    {
        return -1;
    }

    nRet = nVerifyActiveResp(prCmppActiveTestResp);
    if(nRet != 0)
    {
    	return -2;
    }
    
    psHead = psEndoceStr;

    /* 1 Name: Reserver length: 1*/
    *psHead = prCmppActiveTestResp->ucReserver;
    
    return 0;
}
/************************************************************************
  Function ID:  nCmppDecode
  Description:  CMPP协议的组包函数
  Input Param:  recCmppPck* prCmppPck
  Output Param: unsigned char* DecodeStr
                int*           pnLen
  Return:       int             0     success
                                -1    input para error
                                -2    input nLen  not equal DeCodestr len
                                -3    CmdId error
                                -4    verify content of struct recCmppPck fail
                                
*************************************************************************/
int nCmppEncode(recCmppPck* prCmppPck, unsigned char* DecodeStr, int* pnLen)
{
    int nRet;
    unsigned char* psHead;
    unsigned int nMsgLen;
    unsigned int nMsgCmd;
    unsigned int nSeq;
    
    if(NULL == prCmppPck)
    {
        return -1;
    }
    if(NULL == DecodeStr)
    {
        return -1;
    }

    psHead = DecodeStr;

    /* put Cmpp Pack Len into out str */
    nMsgLen = htonl(prCmppPck->rHead.unTotalLength);
    memcpy(psHead, &nMsgLen, sizeof(int));
    psHead = psHead + sizeof(int);

    /* put Cmpp Pack CmdId into out str */
    nMsgCmd = htonl(prCmppPck->rHead.unCommandId);
    memcpy(psHead, &nMsgCmd, sizeof(int));
    psHead = psHead + sizeof(int);

    /* put Cmpp Pack sequence into out str */
    nSeq = htonl(prCmppPck->rHead.unSequenceId);
    memcpy(psHead, &nSeq, sizeof(int));
    psHead = psHead + sizeof(int);

	nRet = nIsCorrectLen(prCmppPck->rHead.unCommandId,
						 prCmppPck->rHead.unTotalLength);
	if(nRet != 0)
	{
    	vSetErrorDetail("Message Length is invalid");
	    Trace("Len is not Correct");
		return -2;
	}

	*pnLen = prCmppPck->rHead.unTotalLength;
	
    switch(prCmppPck->rHead.unCommandId)
    {
        case MacC_ConnectRqst:
        {
            nRet = nConnectReqEncode(psHead, &prCmppPck->body.rCmppConnect);
            break;
        }
        case MacC_ConnectRep:
        {
            nRet = nConnectRespEncode(psHead, &prCmppPck->body.rCmppConnectResp);
            break;
        }
        case MacC_SubmitRqst:
        {
            nRet = nSubmitReqEncode(psHead, &prCmppPck->body.rCmppSubmit);
            break;
        }
        case MacC_SubmitRep:
        {
            nRet = nSubmitRespEncode(psHead, &prCmppPck->body.rCmppSubmitResp);
            break;
        }
        case MacC_DeliverRqst:
        {
            nRet = nDeliverReqEncode(psHead, &prCmppPck->body.rCmppDeliver);
            break;
        }
        case MacC_DeliverRep:
        {
            nRet = nDeliverRespEncode(psHead, &prCmppPck->body.rCmppDeliverResp);
            break;
        }
        case MacC_QueryRqst:
        {
            nRet = nQueryReqEncode(psHead, &prCmppPck->body.rCmppQuery);
            break;
        }
        case MacC_QueryRep:
        {
            nRet = nQueryRespEncode(psHead, &prCmppPck->body.rCmppQueryResp);
            break;
        }
        case MacC_CancelRqst:
        {
            nRet = nCancelReqEncode(psHead, &prCmppPck->body.rCmppCancel);
            break;
        }
        case MacC_CancelRep:
        {
            nRet = nCancelRespEncode(psHead, &prCmppPck->body.rCmppCancelResp);
            break;
        }
        case MacC_ActiveRqst:
        {
            nRet = nActiveReqEncode(psHead, &prCmppPck->body.rCmppActiveTest);
            break;
        }
        case MacC_ActiveRep:
        {
            nRet = nActiveRespEncode(psHead, &prCmppPck->body.rCmppActiveTestResp);
            break;
        }
        default:
        {
            return -3;
            break;
        }
    }
    if(nRet == -2)
    {
    	return -4;
    }
    return nRet;
}