poscomm.c

这是一个基于UCLinux下的一个GPRS 移动POS设备的代码

/* 
   poscomm.c
   Sunyard S520-G POS communicate routine package.
*/
#include <stdio.h>
#include <stdlib.h>
#include "pos.h"

static int  CommTrans(  );
static int  SendData(char *strBuf, short sDataSize );
static int  RecvData(char *strBuf, short sBufSize, short sTimeOut );
static void PrintPack( char *title, unsigned char *pack, int len );

// *******************************************************************
// Function  Name   : ConnectHost
// Function         : connect the pos with host
// Parameter        : 
// Return           : on success return  > 0;
// *******************************************************************
short DoConnectHost()
{
    short  sRet;
    char strHost[20], strTcpPort[10], strTel[20];
    
    // 连接
    Syd_DisplayLine( 3, "Connecting host...", 0, ALIGN_CENTER );
    
    Syd_FieldVar(gTrans.strHdtBuf, HDT_TEL, HDT_FS, strTel);
    Syd_FieldVar(gTrans.strHdtBuf, HDT_TCP,  HDT_FS, strHost);
    Syd_FieldVar(gTrans.strHdtBuf, HDT_PORT, HDT_FS, strTcpPort);
 
    sRet = Syd_ConnectHost(ngCommWay, strHost, atoi(strTcpPort), strTel);
    if ( sRet < 0 )
        return RET_FAILURE;
   
    return RET_SUCCESS;
	
}


/*
 * CommHost() -- commnuciate with host
 *   in  para --
  *   out para -- 
 *   return -- 
 *                  RET_SUCCESS: SUCCESS 
 *                  other:       FAILURE
 */
int  CommHost( )
{
    time_t tStart;
    short sRet, sOfflineMode;
    char temp[ 30 ];


    // connect
    tStart = time( NULL );
//    Syd_DisplayLine( 3, "connecting host ...", 0, ALIGN_CENTER );
    sRet = DoConnectHost();
    if ( sRet < 0 )
    {
        Syd_ErrorMessageWait( 3, "connect failure", 0, ALIGN_CENTER );
        return RET_FAILURE;
    }

    sRet = CommTrans();
    if ( RET_SUCCESS != sRet )
    {
    	Syd_ErrorMessageWait( 3, "Transaction Inprt", 0, ALIGN_CENTER );
        Syd_CloseComm(ngCommWay);
        return RET_FAILURE;
    }

    Syd_CloseComm(ngCommWay);

    return RET_SUCCESS;
}

// *******************************************************************
// Function  Name   : CommTrans
// Function         : send transaction data to the host and get response
// Parameter        : 
//               sd :  socket id  
// Return           : on success return   RET_SUCCESS;
// *******************************************************************
static int  CommTrans()
{
    unsigned char strSndBuf[ 512 ], strRcvBuf[ 512 ];
    short sTimeOut, sSndSize, sRcvSize, sRet;
    char  temp[ 30 ];

    // pack data
    Syd_DisplayLine( 3, "packing ...", 0, ALIGN_CENTER );
    memset(strSndBuf, ' ', sizeof(strSndBuf));
    sSndSize = PackData( strSndBuf, sizeof( strSndBuf ) );
    if ( sSndSize <= 0 )
        return RET_PACK_ERR;
 
    // timeout
    Syd_FieldVar( gTrans.strHdtBuf, HDT_TIMEOUT, HDT_FS, temp );
    sTimeOut = atoi( temp );

    // send
    Syd_DisplayLine( 3, "Sending ...", 0, ALIGN_CENTER );
    if ( SendData( strSndBuf, sSndSize ) < 0 )
    {
        return RET_SEND_ERR;
    }

    // receive
    Syd_DisplayLine(3, "Receiving ...", 0, ALIGN_CENTER);
    if ( ( sRcvSize = RecvData( strRcvBuf, sizeof( strRcvBuf ), sTimeOut ) ) <= 0 ) {
        if (sRcvSize == 0) 
            return RET_TIMEOUT;
        else
            return RET_RECV_ERR;
    }

    // unpack the data
    Syd_DisplayLine( 3, "Processing ...", 0, ALIGN_CENTER );
    sRet = UnPackData( strRcvBuf, sRcvSize );
    if ( sRet != RET_SUCCESS ) 
        return sRet;

    return RET_SUCCESS;
}

static int  FormPacket( unsigned char *strData, int nLen )
{
    int i;

    strData[ 0 ] = STX;
    strData[ 1 ] = ( int )( nLen / 1000 ) << 4 | ( int )( nLen % 1000 ) / 100;
    strData[ 2 ] = ( int )( ( nLen % 100 ) / 10 ) <<4 | ( ( nLen % 100 ) % 10 );
    strData[ 3 + nLen ] = ETX;
    for ( strData[ 4 + nLen ] = 0, i = 1; i < 4 + nLen; i++)
        strData[ 4 + nLen ] ^= strData[ i ];

    return ( nLen + 5 );
}

// *******************************************************************
// Function  Name   : SendData
// Function         : send data
// Parameter        : 
//            strbuf:  
//         sDataSize: 
// Return           : on success return   RET_SUCCESS;
// *******************************************************************
static int  SendData( char *strBuf, short sDataSize )
{
    char temp[ 20 ], *ptr;
    short sRet;
    unsigned char ucRef;

    sRet = RET_SUCCESS;
    
    switch ( ngCommWay )
    {
        case COMM_SMS:
	    if (sDataSize > 140) {
    		if (Syd_GetEnv("#SMREF", temp, 3) < 0) ucRef = 1;
    		else ucRef = atoi(temp);
    		sprintf(temp, "%03d", ucRef+1);
    		Syd_PutEnv("#SMREF", temp);
            }
            else ucRef = 0;
            Syd_FieldVar( gTrans.strHdtBuf, HDT_TEL, HDT_FS, temp);
            sRet = Syd_SendSMSData( strBuf, sDataSize, temp, ucRef);
            if ( sRet == 0 )
                sRet = RET_SUCCESS;
            else
                sRet = RET_SEND_ERR;
            break;

        case COMM_DATA:
            ptr = malloc( sDataSize + 5 );
            if ( ptr == NULL )
                return RET_FAILURE;
            memcpy( ptr + 3, strBuf, sDataSize );
            sDataSize = FormPacket( ptr, sDataSize );
            sRet =  Syd_SendCommData( ptr, sDataSize, 2 );
            if ( sRet == 0 )
                sRet = RET_SUCCESS;
            else
                sRet = RET_SEND_ERR;
            free( ptr );
            break;

        case COMM_TCPIP:
        case COMM_GPRS:
            sRet = Syd_TcpPutMessage2(strBuf, sDataSize);
            if ( sRet > 0 )
                sRet = RET_SUCCESS;
            else
                sRet = RET_SEND_ERR;
            break;

        case COMM_SERIAL:
//          sRet = SerialSendData( strBuf, sDataSize );
            return RET_SEND_ERR;
            break;

        default:
            return RET_SEND_ERR;
    }
    return sRet;
}

// *******************************************************************
// Function  Name   : RecvData
// Function         : receive data
// Parameter        : 
//               sd :  socket id  
//            strbuf:  
//         sDataSize: 
//          sTimeOut:  
// Return           : on success return the received data number
// *******************************************************************
static int  RecvData( char *strBuf, short sBufSize, short sTimeOut )
{
    char temp[ 20 ], *ptr;
    short sRet, i;
    time_t tStart;

    switch( ngCommWay )
    {
        case COMM_SMS: //sms
            Syd_StartStatusBar( 5, sTimeOut );
            Syd_FieldVar( gTrans.strHdtBuf, HDT_TEL, HDT_FS, temp );
            sRet = Syd_ReceiveSMSData( strBuf, sBufSize, sTimeOut, temp );
            Syd_StopStatusBar();
            break;

        case COMM_DATA: //GSM DIAL
            ptr = malloc( sBufSize + 10 );
            if ( ptr == NULL )
                return -1;
            Syd_StartStatusBar( 5, sTimeOut );
            tStart = time( NULL );
            do
            {
                sRet = Syd_ReceiveCommData( ptr, sBufSize, 1 );
            } while ( sRet <= 0 && time( NULL ) - tStart < sTimeOut );
            Syd_StopStatusBar();
            if ( sRet > 5 )
            {
                sRet -=  5;
                memcpy( strBuf, ptr + 3, sRet );
            }
            else if ( sRet > 0 )
                sRet = -1;
            free( ptr );
            break;

        case COMM_GPRS:  //gprs
        case COMM_TCPIP:  //tcpip
            Syd_StartStatusBar(5, sTimeOut);
            tStart = time(NULL);
            do {
               sRet =  Syd_TcpGetMessage2(strBuf, sBufSize);
            } while (sRet == 0 && time(NULL) - tStart < sTimeOut); 
            Syd_StopStatusBar();
            break;

        case COMM_SERIAL:
//          sRet = SerialSendData(strBuf, sDataSize);
            return RET_FAILURE;

        default:
            return RET_FAILURE;
    }
    return sRet;
}

// *******************************************************************
// Function  Name   : PackData()
// Function         : 
// Parameter        : strBuf: 
//                  : sBufSize: the buffer size
// Return           : on success return the packet size 
//                  : on error return < 0
// *******************************************************************
int PackData(unsigned char *strBuf, int sBufSize)
{
    short sDataSize = 0, sLen;

    sLen = TRACK2_LEN;
    memcpy(strBuf, gTrans.strTrack2, strlen(gTrans.strTrack2));
    sDataSize += sLen;

    sLen = TRACK3_LEN;
    memcpy(strBuf + sDataSize, gTrans.strTrack3, strlen(gTrans.strTrack3));
    sDataSize += sLen;
      
    sLen = 12;
    memset(strBuf + sDataSize, '0', 12-strlen(gTrans.strAmt));
    memcpy(strBuf + sDataSize+12-strlen(gTrans.strAmt), gTrans.strAmt, strlen(gTrans.strAmt));
    sDataSize += sLen;
    
    return sDataSize;

}

// *******************************************************************
// Function  Name   : UnpackData()
// Function         : 
// Parameter        : strBuf: 
//                  : sBufSize: the buffer size
// Return           : on success return  0
//                  : on error return < 0
// *******************************************************************
int UnPackData(unsigned char *strBuf, int sBufSize)
{
    unsigned char strRet[3];
    
    memcpy(strRet, strBuf, 2);
    strRet[2] = 0;
    if (!memcmp(strRet, "00", 2))
    {
    	strcpy(gTrans.strRejcode, "00");
        return RET_SUCCESS;
    }
    else
        return (atoi(strRet));
}