cmppapi.c

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

    }
    nRet  = nTcpWriten_Api(    nSocket,
                   (const char*)sSendBuffer,
                   nLen );
    if( nRet < 0)
    {
        Trace("TcpWrite nRet = %d", nRet);
        return API_ERR_NETWORK;
    }       
    
    Trace( "Success to Send [%x] package to outside,"
            "sequence = %d\n", 
            prCmppPck->rHead.unCommandId,
            prCmppPck->rHead.unSequenceId );    
    return API_OK;
}


/*
 *描述：(1)登陆MTBS（发送Connect请求，接收Connect响应）
 *输入：CONNFD connDesc 连接句柄
        recCmppConnect *prCmppConnect,
 *输出：recCmppConnectResp *prCmppConnectResp
 *返回值：API_OK 成功
 *        其它 失败 
*/
static  int nLogin(
                    CONNFD connDesc,
                    recCmppConnect *prCmppConnect,
                    recCmppConnectResp *prCmppConnectResp,
                    EBool   bSocket
                )
{
    int nRet;
    int nSeq;
    recCmppPck  rCmppPck;
    recCmppPck  rRespCmppPck;
    
    if( prCmppConnect == NULL ||
        prCmppConnectResp == NULL )
    {
        vSetErrorDetail( "Error: invalid input parameter\n" );  
        return API_ERR_INVALID;
    }
    /*
    *发送前的检查工作 检查连接合法性
    */    
    nRet = nValidConnFD( connDesc );
    if( nRet != API_OK )
    {
        return nRet;
    }
        
    /*
    *判断连接状态
    */
    if( g_HConnDesc[ connDesc ].eSocketStatus != ConnectOpen )
    {
        vSetErrorDetail( "Error: socket is closed\n" );
        return    API_ERR_NETWORK;   
    }
        
    /*
    *sequence++
    */
    nSeq = nAddSequence( connDesc );
        
    //nSeq =  g_HConnDesc[ connDesc ].nSequence;
    
    rCmppPck.rHead.unSequenceId = nSeq;
    rCmppPck.rHead.unCommandId = MacC_ConnectRqst;
    rCmppPck.rHead.unTotalLength =  MacHeadLen + MacConnectLen;
    memcpy( &rCmppPck.body.rCmppConnect, prCmppConnect, sizeof( recCmppConnect ) );

    Trace( "before send nLogin, Sequence = %d", rCmppPck.rHead.unSequenceId );
    

    nRet = nSendCmppAndGetResp( connDesc, &rCmppPck, &rRespCmppPck, bSocket, MAC_TIMEOUT );
    
    if( nRet != API_OK )
    return nRet;

    memcpy( prCmppConnectResp, &rRespCmppPck.body.rCmppConnectResp, sizeof( recCmppConnectResp ) );

    return API_OK;
}          

static  int nSendActive( CONNFD connDesc, EBool bSocket )
{
    int nRet;
    int nSeq;
    recCmppPck  rCmppPck;
    recCmppPck  rRespCmppPck;

    /*
    *发送前的检查工作 检查连接合法性
    */    
    nRet = nValidConnFD( connDesc );
    if( nRet != API_OK )
    {
        return nRet;
    }
        
    /*
    *sequence++
    */
    nSeq = nAddSequence( connDesc );
        
    //nSeq =  g_HConnDesc[ connDesc ].nSequence;
    
    rCmppPck.rHead.unSequenceId = nSeq;
    rCmppPck.rHead.unCommandId = MacC_ActiveRqst;
    rCmppPck.rHead.unTotalLength =  MacHeadLen + MacActiveTestLen;
    
    nRet = nSendCmppAndGetResp( connDesc, &rCmppPck, &rRespCmppPck, bSocket, MAC_TIMEOUT );

    if( nRet != API_OK )
    return nRet;
    
    return API_OK;
}
   
/*
 *描述：单发接口函数
        (1) 发送MT请求 
        (2) 接收MT响应 
 *输入：CONNFD connDesc 连接句柄
        recCmppSubmit* prCmppSubmit
 *输出：recCmppSubmitResp* prCmppSubmitResp
 *返回值：API_OK 成功
 *        其它 失败 
*/
int nSubmitSingle( CONNFD connDesc, 
                recCmppSubmit *prCmppSubmit,
                recCmppSubmitResp* prCmppSubmitResp )
{
    int nRet;
    int nSeq;
    char    sSendBuffer[ sizeof( recCmppPck) +1 ];  // 用于校验encode是否成功
    int     nLen;                                   // 
    recCmppPck  rCmppPck;
    recCmppPck  rRespCmppPck;

    if( prCmppSubmit == NULL ||
        prCmppSubmitResp == NULL )
    {
        vSetErrorDetail( "Error: invalid input parameter\n" );  
        return API_ERR_INVALID;
    }
    
    /*
    *发送前的检查工作 检查连接合法性
    */    
    nRet = nValidConnFD( connDesc );
    if( nRet != API_OK )
    {
        return nRet;
    }
    
    /*
    *发送前的检查工作 检查连接和LOGIN
    */
    nRet = nCheckSocketAndLogin( connDesc );
    if( nRet != API_OK )
    {
        return nRet;
    }   
     
    /*
    *sequence++
    */
    nSeq = nAddSequence( connDesc );
        
    //nSeq =  g_HConnDesc[ connDesc ].nSequence;
    
    rCmppPck.rHead.unSequenceId = nSeq;
    rCmppPck.rHead.unCommandId = MacC_SubmitRqst;
    rCmppPck.rHead.unTotalLength =  MacHeadLen + MacBasSubmitLen 
                                    + (int)prCmppSubmit->ucMsgLength
                                    + MacLinkId;
    memcpy( &rCmppPck.body, prCmppSubmit, sizeof( recCmppSubmit) );
    rCmppPck.body.rCmppSubmit.ucDestUsrTl = 1;
    
    /*
    *校验是否ENCODE成功，以免发送给BUFFER后发送线程ENCODE失败后，出现超时的情况
    */
    nRet = nCmppEncode( &rCmppPck, 
                        sSendBuffer,
                        &nLen );
    if( nRet != 0 )
    {
        Trace("Encode Failed, nRet = %d", nRet);
        return API_ERR_PROTOCOL;
    }
    
    
    nRet = nSendCmppAndGetResp( connDesc, &rCmppPck, &rRespCmppPck, FALSE, 
                                g_HConnDesc[ connDesc].rCfgPara.nSubmitTimeOut );

    if( nRet != API_OK )
    return nRet;

    memcpy( prCmppSubmitResp, &rRespCmppPck.body.rCmppConnectResp, sizeof( recCmppSubmitResp ) );
    if( rRespCmppPck.body.rCmppSubmitResp.unResult != 0 )
    {
        vSetErrorDetail( "Error when submit, the result of response = [%d]", 
                        rRespCmppPck.body.rCmppSubmitResp.unResult );
        return API_ERR_RESP;
    }
    return API_OK;

}                           
                                      
/*
 * 描述：拆分包接口
 *       (1) 发送MT请求
 *       (2) 接收MT响应
 * 输入：CONNFD connDesc 连接句柄
 *       recCmppSubmit* prCmppSubmit
 * 输出：recCmppSubmitResp* prCmppSubmitResp
 * 返回值：API_OK 成功
 *         其它 失败 
 */
int nSubmitSplit( CONNFD connDesc, 
              const unsigned int unMsgLength,
              const char *sMsgContent,
              recCmppSubmit *prCmppSubmit,
              recCmppSubmitResp* prCmppSubmitResp )
{
    int i, nRet, nPkgLen, nPkgTotal;
    char *pcCurr, *pcEnd, *pcStart;
    recCmppSubmit      rSubmitPck;

    if ( (prCmppSubmit->ucMsgFmt == MSG_FORMAT_ASCII && unMsgLength < 160) ||
         (prCmppSubmit->ucMsgFmt != MSG_FORMAT_GB && unMsgLength <= 140) ||
         (prCmppSubmit->ucMsgFmt == MSG_FORMAT_GB && unMsgLength <= 70) )
    {
        if ( prCmppSubmit->ucPkNumber == 0 )
        {
            prCmppSubmit->ucPkNumber = 1;
        }
        if ( prCmppSubmit->ucPkTotal == 0 )   
        {
            prCmppSubmit->ucPkTotal = 1;  
        }
        prCmppSubmit->ucMsgLength = unMsgLength;
        memcpy( prCmppSubmit->chMsgContent, sMsgContent,unMsgLength );
        return nSubmitSingle( connDesc, prCmppSubmit, prCmppSubmitResp );
         
    }

    memcpy( &rSubmitPck, prCmppSubmit, sizeof(recCmppSubmit) );
    
    switch ( prCmppSubmit->ucMsgFmt )
    {
        case MSG_FORMAT_GB:
        {
             /*先计算总的包数*/
            pcCurr = (char*)sMsgContent;
            pcEnd  = (char*)sMsgContent + unMsgLength;
            
            for ( nPkgTotal=0; pcCurr<pcEnd; nPkgTotal++ )
            {
                for( i = 0; i < 70 && pcCurr < pcEnd; i++ )
                {
                    if( (  *pcCurr & 0x80 ) != 0 && pcCurr+1 < pcEnd )
                    {
                        pcCurr++; 
                        pcCurr++; 
                    }
                    else
                    {
                        pcCurr++; 
                    }
                }
            }
            
            /*拆包*/
            pcCurr = (char*)sMsgContent;
            pcEnd  = (char*)sMsgContent + unMsgLength;            
            rSubmitPck.ucPkTotal = nPkgTotal & 0xff;    /*总的包数*/        
            
            for ( nPkgTotal = 1; pcCurr < pcEnd; nPkgTotal++ )
            {
                memset(rSubmitPck.chMsgContent, 0, MacMsgLen+1);
                for( pcStart = pcCurr, i = 0; i < 70 && pcCurr < pcEnd; i++ )
                {
                    if( (  *pcCurr & 0x80 ) != 0 && pcCurr+1 < pcEnd )
                    {
                        pcCurr++; 
                        pcCurr++; 
                    }
                    else
                    {
                        pcCurr++; 
                    }
                }
                nPkgLen = pcCurr - pcStart;                

                rSubmitPck.ucPkNumber= nPkgTotal;
                rSubmitPck.ucMsgLength = nPkgLen;
                //printf("package[%d] ucMsgLength = %d\n",nPkgTotal, nPkgLen );                
                memcpy( rSubmitPck.chMsgContent, pcStart, nPkgLen);
                
                nRet = nSubmitSingle( connDesc, &rSubmitPck, prCmppSubmitResp );    
                if ( nRet != API_OK )
                {
                    return nRet;
                }
            }
            
            break;
        }
        case MSG_FORMAT_ASCII:
        case MSG_FORMAT_WRITE_CARD:
        case MSG_FORMAT_BINARY:
        case MSG_FORMAT_UCS2:
        default:
        {
            if ( prCmppSubmit->ucMsgFmt == MSG_FORMAT_ASCII )
            {
                nPkgLen = g_nMsgLenAscii;
            }
            else
            {
                nPkgLen = g_nMsgLenOther;
            }

            /* 计算总的包数 */
            nPkgTotal = unMsgLength / nPkgLen;        
            if( ( unMsgLength % nPkgLen ) > 0)
            {
                nPkgTotal++;
            }
            rSubmitPck.ucPkTotal = nPkgTotal & 0xff;

            for( i=1; i<= nPkgTotal; i++ )
            {
                memset(rSubmitPck.chMsgContent, 0, MacMsgLen+1);
                rSubmitPck.ucPkNumber= i;    
                if ( i < nPkgTotal )
                {
                    rSubmitPck.ucMsgLength = nPkgLen;
                }
               else
                {
                    rSubmitPck.ucMsgLength = unMsgLength % nPkgLen ;     
                    if (rSubmitPck.ucMsgLength == 0 )
                    	{
                    		rSubmitPck.ucMsgLength = nPkgLen;
                    	}
                   // rSubmitPck.ucMsgLength = unMsgLength - nPkgLen*(nPkgTotal-1) ;
                }
                memcpy( rSubmitPck.chMsgContent, sMsgContent+(i-1)*nPkgLen, 
                        rSubmitPck.ucMsgLength );
                nRet = nSubmitSingle( connDesc, &rSubmitPck, prCmppSubmitResp );    
                if ( nRet != API_OK )
                {
                    return nRet;
                }
            }
            break;
        }
    }
    return nRet;
}                   

/*
 * 描述：低层群发包(拆分包)接口
 *       (1) 发送MT请求
 *       (2) 接收MT响应
 *       该接口支持群发,和内容超长度的拆分
 *       群发的目的地址号码用","号分割, 返回API_OK,表明发送都
 *       成功,如果非API_OK, 输出参数sLastTerminateId
 *        说明最后一个失败的目标号码, 如果返回的是API_ERR_RESP,
 *        说明是网关返回了一个RESPONSE表明错误, prCmppSubmitResp
 *          表明结果
 * 输入：CONNFD connDesc 连接句柄
 *       const char *sDstTerminateId 目标地址号码( 以,号分割多个号码)
 *       const unsigned charucDstTerminateType 接收短信的用户的号码类型
 *       const unsigned int unMsgLength 内容长度
 *       const char *sMsgContent  内容
 *       recCmppSubmit* prCmppSubmit
 * 输出：recCmppSubmitResp* prCmppSubmitResp
 *       sLastTerminateId    最后处理的目标号码
 * 返回值：API_OK 成功
 *         其它 失败
 */
int ASPAPI nSubmit( CONNFD connDesc, 
              const char *sDstTerminateId,
              const unsigned char ucDstTerminateType,
              const unsigned int unMsgLength,
              const char *sMsgContent,
              recCmppSubmit *prCmppSubmit,
              recCmppSubmitResp* prCmppSubmitResp,
              char *sLastTerminateId )
{
    int i, nRet;
    EBool bFlag;
    char *s1, *s2;
    char sDstTermId[MacDesTermId+1];
    char sTmpTermIds[MacDesTermId*MAX_DST_TERMIN+1];

    if ( sDstTerminateId == NULL || unMsgLength <= 0 ||
         sLastTerminateId == NULL || sMsgContent == NULL || 
         prCmppSubmit == NULL || prCmppSubmitResp == NULL )
    {
        Trace( "nSubmit input para invalid\n");
        vSetErrorDetail( "invalid input parameter" );
        return  API_ERR_INVALID;
    }
    //modify by lijian 2003-12-11 防止伪码错误
    //memcpy(sTmpTermIds, sDstTerminateId, MacDesTermId*MAX_DST_TERMIN+1);
    strcpy(sTmpTermIds, sDstTerminateId);
    s1 = sTmpTermIds;
    
    for( i=0, nRet=API_OK, bFlag = True; bFlag == True && i <MAX_DST_TERMIN; i++ )
    {
        s2 = strchr( s1, cDivTag );
        if ( s2 != NULL )
        {
            *s2 = 0;
        }
        else
        {
            bFlag = False;
        }
        memset( sDstTermId, 0, sizeof(sDstTermId) );
        memcpy( sDstTermId, s1, MacDesTermId );
        sDstTermId[MacDesTermId+1] = '\0';
        memcpy( prCmppSubmit->chDs