cmpppack.c

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

    
    return 0;
}

/************************************************************************
  Function ID:  nVerifyQuery
  Description:  CMPP协议中Query pack 合法性校验
  Input Param:  recCmppQuery*   prCmppQuery
  Output Param: 
  Return:       int             0     success
                                -1    failed
                                
*************************************************************************/
int nVerifyQuery(recCmppQuery* prCmppQuery)
{
	int nQueryType;
	
	if( NULL == prCmppQuery)
	{
		return -1;
	}
	/* Check Query Type */
	nQueryType = (int)prCmppQuery->ucQueryType;
	if((nQueryType < 0) || (nQueryType > 1))
	{
		return -2;
	}
	
	return 0;
}

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

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

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

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

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

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

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

/************************************************************************
  Function ID:  nVerifyQueryResp
  Description:  CMPP协议中Query pack 合法性校验
  Input Param:  recCmppQueryResp* prCmppQueryResp
  Output Param: 
  Return:       int             0     success
                                -1    failed
                                
*************************************************************************/
int nVerifyQueryResp(recCmppQueryResp* prCmppQueryResp)
{
	int nQueryType;
	
	if( NULL == prCmppQueryResp)
	{
		return -1;
	}
	/* Check Query Type */
	nQueryType = (int)prCmppQueryResp->ucQueryType;
	if((nQueryType < 0) || (nQueryType > 1))
	{
		return -2;
	}
	return 0;
}

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

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

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

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

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

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

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

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

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

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

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

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

    /* 11 Name: Mo_Fl   length: sizeof(int) */
    memcpy(&nNetSequence, psHead, sizeof(int));
    prCmppQueryResp->unMoFl = ntohl(nNetSequence);
    
    nRet = nVerifyQueryResp(prCmppQueryResp);
    if(nRet != 0)
    {
    	return -2;
    }
    
    return 0;
}

/************************************************************************
  Function ID:  nVerifyCancel
  Description:  CMPP协议中Cancel pack 合法性校验
  Input Param:  recCmppCancel* prCmppCancel
  Output Param: 
  Return:       int             0     success
                                -1    failed
                                
*************************************************************************/
int nVerifyCancel(recCmppCancel* prCmppCancel)
{
	return 0;
}

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

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

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

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

/************************************************************************
  Function ID:  nVerifyCancelResp
  Description:  CMPP协议中CancelResp pack 合法性校验
  Input Param:  recCmppCancelResp* prCmppCancelResp
  Output Param: 
  Return:       int             0     success
                                -1    failed
                                
*************************************************************************/
int nVerifyCancelResp(recCmppCancelResp* prCmppCancelResp)
{
	int nResult;

	if(NULL == prCmppCancelResp)
	{
		return -1;
	}
	
	/* Check Result */
	nResult = prCmppCancelResp->unSuccessId;
	if((nResult < 0) || ( nResult > 1))
	{
		return -2;
	}
	
	return 0;
}

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

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

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

/************************************************************************
  Function ID:  nVerifyActive
  Description:  CMPP协议中Active pack 合法性校验
  Input Param:  recCmppActiveTest* prCmppActiveTest
  Output Param: 
  Return:       int             0     success
                                -1    failed
                                
*************************************************************************/
int nVerifyActive(recCmppActiveTest* prCmppActiveTest)
{
	if( NULL == prCmppActiveTest)
	{
		return -1;
	}
	
	return 0;
}


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

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

/************************************************************************
  Function ID:  nVerifyActiveResp
  Description:  CMPP协议中ActiveResp pack 合法性校验
  Input Param:  recCmppActiveTestResp* prCmppActiveTestResp
  Output Param: 
  Return:       int             0     success
                                -1    failed
                                
*************************************************************************/
int nVerifyActiveResp(recCmppActiveTestResp* prCmppActiveTestResp)
{
	if( NULL == prCmppActiveTestResp)
	{
		return -1;
	}
	
	return 0;
}

/************************************************************************
  Function ID:  nActiveRespDecode
  Description:  CMPP协议的ActiveResp pack 解析函数
  Input Param:  unsigned char*      psDecodeStr
  Output Param: recCmppActiveTestResp* prCmppActiveTestResp
  Return:       int                 0   success
                                    -1  failed
                                
*************************************************************************/
int nActiveRespDecode(unsigned char* psDecodeStr, recCmppActiveTestResp* prCmppActiveTestResp)
{
	int nRet;
    unsigned char* psHead;

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

    /* 1 Name: Reserver length: 1*/
    prCmppActiveTestResp->ucReserver = *psHead;

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

/************************************************************************
  Function ID:  nCmppDecode
  Description:  CMPP协议的解析函数
  Input Param:  unsigned char* DecodeStr
                int            nLen
  Output Param: recCmppPck* prCmppPck
  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 nCmppDecode(unsigned char* DecodeStr, int nLen, recCmppPck* prCmppPck)
{
    int nRet;
    unsigned char* psHead;
    unsigned int nTmp;
    unsigned int nMsgLen;
    unsigned int nMsgCmd;
    unsigned int nSeq;
    
    psHead = DecodeStr;

    if(NULL == DecodeStr)
    {
        return -1;
    }
    if(NULL == prCmppPck)
    {
        return -1;
    }

    memset(prCmppPck, 0, sizeof(recCmppPck));
    
    /* get pack len from input str */
    memcpy(&nTmp, psHead, sizeof(int));
    nMsgLen = ntohl(nTmp);
    
    /* verify input nLen para */
    if((int)nMsgLen != nLen)
    {
        return -2;
    }
    
    /* put len in recCmppPck struct head*/
    prCmppPck->rHead.unTotalLength = nMsgLen;
    psHead = psHead + sizeof(int);

    /* get pack CmdId from input str*/
    memcpy(&nTmp, psHead, sizeof(int));
    nMsgCmd = ntohl(nTmp);
    /* put CmdId  in recCmppPck struct head */
    prCmppPck->rHead.unCommandId = nMsgCmd;
    psHead = psHead + sizeof(int);

    /* get pack sequence num from input str */
    memcpy(&nTmp, psHead, sizeof(int));
    nSeq = ntohl(nTmp);
    /* put Sequence number in recCmppPck struct head */
    prCmppPck->rHead.unSequenceId = nSeq;