dpciso.cpp

ISO 8583 with c++ for financial transaction standard

            iLen = strlen ( szStrLoc );
            if( bTCPIP_PP_PROTOCOL && bNETWORK_MGMT_ENABLE )
                iRc = TcpPPSend (myActiveSock, szStrLoc, iLen, hDumpFile);
            else if( bNETWORK_MGMT_ENABLE )
                iRc = TcpSend (myActiveSock, szStrLoc, iLen, FALSE, hDumpFile);
            else 
                iRc = TCP4U_SUCCESS;
            // debug y tracking de mensaje ECHO
            if( bNETWORK_MGMT_ENABLE )
                trkEchoes.Write( (LPBYTE)szStrLoc, iLen );
        }
        else if( iRc == TCP4U_SUCCESS && isoMsg.IsNetworkMgmtResponse() )
        {                
            // debug y tracking de mensaje ECHO
            iLen = strlen( szStr );
            trkEchoes.Write( (LPBYTE)szStr, iLen );
        }
        else if( iRc == TCP4U_SUCCESS && isoMsg.IsControlCenterCommand() )
        {                                
        }

        else if (TCP4U_SUCCESS == iRc)
        {                
           // debug y tracking de mensaje ISO
           trkLogg.Write( (LPBYTE)szStr, iLen );
           // Notificar Evento
           NotifyEvent();
        };

   };
   /* return ok-error */
   return (iRc) ;
}
///////////////////////////////////////////////////////////////////////////////////////
// ID local TCP-IP
int DPCISO::GetLocalID (char *szStrName, int uNameSize, unsigned long *lpAddress)
{
    if(szStrName && uNameSize > 0 && lpAddress)
    {
        iRc = TCP4U_SUCCESS;
        /* init library */
        if(!bConnect)
        {
            iRc = Tcp4uInit();
            if (TCP4U_SUCCESS!=iRc)  
                return (iRc); /* error */
        }
        iRc = TcpGetLocalID ( szStrName, uNameSize, lpAddress);
        /* clean up library */
        if(!bConnect)
            Tcp4uCleanup();
        return (iRc); /* error ? ok ? */
    }
    else
        return (iRc=TCP4U_ERROR) ;
}

///////////////////////////////////////////////////////////////////////////////////////
// Formatear ECHO-LOGON
int DPCISO::FormatLineCntrlLogonReq( enumCntlType wCntlCode )
{
    /* Mensajes de Control de Linea  (Echo Test=301, Logon=1 u Logoff=2) */    
    char       szDateTime[16];             // String de DateTime
    char       szSeqNum[16];               // String de Sequence Number
    const char szEOT[2] = { 0x3, 0 };      // End-Of-Text (ASCII-3)



    /* Fecha y Hora actuales del Sistema Operativo (ANSI C Unix) */
    time_t tTime         = time( NULL );        // System Time
    tm     *ptmLocalTime = localtime(&tTime);    // Local System Time    
    strftime(szDateTime, sizeof szDateTime, "%m%d%H%M%S", ptmLocalTime);


    // Armado del mensaje ISO-8583, campo a campo, como esta predefinido
    // en el Manual del Sistema, en Base24-Host-Interchange, y en
    // Manual de Mensajes ISO-8583. En su defecto remitirse al codigo fuente.
    
    // ISO-Header-Indicator [0..2=3]
    strcpy(&szStr[0], _ISO_MSG_HEADER_);            
    // Header [3..11=9]
    strcpy(&szStr[3], "014000050"); // B24 Host Input (issuer HOST24)
    // Message-Type-Identifier [12..15=4]        
    strcpy(&szStr[12], "0800"); // Network Mgm Requirement
    // Primary-Bitmap [16..31=16]    
    strcpy(&szStr[16], "8220000000000000"); // B24 In 0800    
    // Optional-Secondary-Bitmap [32..47=16]    
    strcpy(&szStr[32], "0400000000000000"); // B24 In 0800    
    // Transmision-Date-Time [48..57=10]    
    strcpy(&szStr[48], szDateTime);                    
    // PseudoRandom Trace Number                 
    sprintf(szSeqNum, "%06i", rand() );
    // Trace-Number [58..63=6]    
    strcpy(&szStr[58], szSeqNum);                 
    // Req Network-Management-Information-Code [64..66=3]
    if (wCntlCode == CNTL_ECHO_REQUERIMENT)
        strcpy(&szStr[64], "301"); // Echo 
    else if(wCntlCode == CNTL_LOGON_REQUERIMENT)
        strcpy(&szStr[64], "001"); // Logon
    else
        strcpy(&szStr[64], "002"); // Logoff                
    // End-Of-Transmission [67=1]
    strcpy(&szStr[67], szEOT); 
    // Import ISO8583
    isoMsg.Import( (unsigned char *)szStr , 68 );

    // bytes?
    return iLen=68;
            
}
///////////////////////////////////////////////////////////////////////////////////////
// Formatear rta. de ECHO-LOGON
int DPCISO::FormatLineCntrlLogonResp( char *szInMsg , enumCntlType wCntlCode )
{
    /* Mensajes de Control de Linea  (Echo Test=301, Logon=1 u Logoff=2) */        
    char       szDateTime[16];             // String de DateTime
    char       szSeqNum[16];               // String de Sequence Number
    const char szEOT[2] = { 0x3, 0 };      // End-Of-Text (ASCII-3)
    unsigned short wLen = 0;



    /* Fecha y Hora actuales del Sistema Operativo (ANSI C Unix) */
    time_t tTime         = time( NULL );        // System Time
    tm     *ptmLocalTime = localtime(&tTime);    // Local System Time    
    strftime(szDateTime, sizeof szDateTime, "%m%d%H%M%S", ptmLocalTime);


    // Armado del mensaje ISO-8583, campo a campo, como esta predefinido
    // en el Manual del Sistema, en Base24-Host-Interchange, y en
    // Manual de Mensajes ISO-8583. En su defecto remitirse al codigo fuente.
    
    // Header [3..11=9]
    strcpy(&szStr[3], "014000055"); // B24 Host Input/Output (issuer-acquirer HOST24)
    // Message-Type-Identifier [12..15=4]        
    strcpy(&szStr[12], "0810"); // Network Mgm Response
    // Primary-Bitmap [16..31=16]    
    strcpy(&szStr[16], "8220000002000000"); // B24 Out 0810
    // Optional-Secondary-Bitmap [32..47=16]    
    strcpy(&szStr[32], "0400000000000000"); // B24 Out 0810    
    // Transmision-Date-Time [48..57=10]    
    if(    (szInMsg) && 
        (strncmp("0101000000", szInMsg+48, 10) <= 0) && 
        (strncmp("1231235959", szInMsg+48, 10) >= 0))
    {
        strncpy(szDateTime, szInMsg+48, 10 );    
        strcpy(&szStr[48], szDateTime);    
    }
    else
        strcpy(&szStr[48], szDateTime);    
    // InputMessage-Trace-Number ?
    if(    (szInMsg) && 
        (strncmp("000000", szInMsg+58, 6) <= 0) && 
        (strncmp("999999", szInMsg+58, 6) >= 0))
        {
        // Trace-Number [58..63=6]
        strncpy(szSeqNum, szInMsg+58, 6);
        szSeqNum[6] = 0x00;
        }
    else
        {
        // Default Trace-Number [58..63=6]
        strcpy(szSeqNum, "000000");
        };
    // Trace-Number [58..63=6]
    strcpy(&szStr[58], szSeqNum);     
    // Response-Code [64..65=2]
    strcpy(&szStr[64], "00"); // Approved
    // InputMessage-Network-Mgm-Information-Code?
    if(    (szInMsg) && 
        ((strncmp(szInMsg+64, "001", 3) == 0) ||
         (strncmp(szInMsg+64, "002", 3) == 0) ||
         (strncmp(szInMsg+64, "301", 3) == 0))
      )
        {                                        
        // In Network-Management-Information-Code [64..66=3]
        // Out Network-Management-Information-Code [66..68=3]
        strncpy(&szStr[66], szInMsg+64, 3);    
        szStr[69] = 0x00;
        }
    else
        {                
        // Default Network-Management-Information-Code [66..68=3]
        if (wCntlCode == CNTL_ECHO_RESPONSE)
            strcpy(&szStr[66], "301"); // Echo 
        else if(wCntlCode == CNTL_LOGON_RESPONSE)
            strcpy(&szStr[66], "001"); // Logon
        else
            strcpy(&szStr[66], "002"); // Logoff
        }
    // End-Of-Transmission [69=1]
    strcpy(&szStr[69], szEOT); 
    // Import ISO8583
    isoMsg.Import( (unsigned char *)szStr , 70 );
    // In Msg ?
    if(    szInMsg )
    {
        wLen = 70;
        // Export formatted msg
        isoMsg.Export( (unsigned char *)szInMsg, &wLen );
        // bytes?
        return wLen;
    }
    else
        // bytes?
        return iLen=70;

}
///////////////////////////////////////////////////////////////////////////////////////
// Enviar logon
int DPCISO::SendLogon( enumCntlType wLogon )
{
    char            szStrLoc[256]={0x00} ;
    unsigned short  uTimeOut = iTimeout;
    ////////////////////////////////////
    unsigned short  shLen = 0;
    ////////////////////////////////////

    // Precondicion : formato ISO8583
    if(CNTL_FORMAT_NONISO8583 == efFormat)
        return (iRc = TCP4U_ERROR);
    // Precondicion : conectado
    if (!bConnect)
        return (iRc = TCP4U_ERROR);
    // Precondicion : disponible
    if(hostStatus == _HOST_STOPPED_)
        return (iRc = TCP4U_ERROR);

    // Antes de enviar LOGON-LOGOFF, verificar lo PENDIENTE
    iRc = CheckForMsgs( uTimeOut )  ;
    
    // Despues, y segun lo solicitado, armar el ECHO o LOGON
    if( wLogon == CNTL_LOGOFF_REQUERIMENT )
        iLen = FormatLineCntrlLogonResp( NULL, wLogon);
    else if( wLogon == CNTL_LOGON_REQUERIMENT )
        iLen = FormatLineCntrlLogonReq( wLogon );
    else 
        iLen = FormatLineCntrlLogonReq( wLogon );

    // Segun Protocolo, enviar mensaje de ECHO LOGON
    if(bTCPIP_PP_PROTOCOL && bNETWORK_MGMT_ENABLE )
      iRc = TcpPPSend (myActiveSock, szStr, iLen, hDumpFile);
    else if ( bNETWORK_MGMT_ENABLE )
      iRc = TcpSend (myActiveSock, szStr, iLen, FALSE, hDumpFile);
    else
      iRc = TCP4U_SUCCESS;
    // debug y tracking de mensaje ECHO
    if( bNETWORK_MGMT_ENABLE )
        trkEchoes.Write( (LPBYTE)szStr, iLen );


    /* uTimeOut > 0 : wait for response */
    if (TCP4U_SUCCESS==iRc && uTimeOut > 0)     
    {
        memset( szStr, 0x00, sizeof szStr );
        if(bTCPIP_PP_PROTOCOL)
            iRc = TcpPPRecv (myActiveSock, szStr, sizeof szStr, uTimeOut, FALSE, hDumpFile); /* sectimeout */

        else
            iRc = TcpRecv (myActiveSock, szStr, sizeof szStr, uTimeOut, hDumpFile); /* sectimeout */
    }
    else
        iRc = 0;
     /* verificar longitudes retornadas */
    if(iRc<=0)
    {
         iLen = 0;
         iRc = TCP4U_ERROR;
    }
    else if(iRc>0)
    {
        iLen = iRc;
        isoMsg.Import( (unsigned char *)szStr , iLen );       
        iRc = TCP4U_SUCCESS;
        /* verificar si lo recibido es un requerimiento o echo */

        if( iRc == TCP4U_SUCCESS && isoMsg.IsNetworkMgmtRequest() )
        {
            shLen = iLen = sizeof szStrLoc;
            isoMsg.Export( (unsigned char *)szStrLoc, &shLen );
            iLen = shLen;
            FormatLineCntrlLogonResp( szStrLoc , CNTL_LOGON_RESPONSE )     ;
            iLen = strlen ( szStrLoc );
            if( bTCPIP_PP_PROTOCOL && bNETWORK_MGMT_ENABLE )
                iRc = TcpPPSend (myActiveSock, szStrLoc, iLen, hDumpFile);            
            else if ( bNETWORK_MGMT_ENABLE )
                iRc = TcpSend (myActiveSock, szStrLoc, iLen, FALSE, hDumpFile);
            else
                iRc = TCP4U_SUCCESS;
            // debug y tracking de mensaje ECHO
            if ( bNETWORK_MGMT_ENABLE )
                trkEchoes.Write( (LPBYTE)szStrLoc, iLen );
        }
        else if( iRc == TCP4U_SUCCESS && isoMsg.IsNetworkMgmtResponse() )
        {
            // debug y tracking de mensaje ECHO
            iLen = strlen( szStr );
            trkEchoes.Write( (LPBYTE)szStr, iLen );
        }
        else if( iRc == TCP4U_SUCCESS && isoMsg.IsControlCenterCommand() )
        {                            
        }
        else if (TCP4U_SUCCESS == iRc)
        {            
            // debug y tracking de mensaje ISO
            trkLogg.Write( (LPBYTE)szStr, iLen );
            // Notoficar evento
            NotifyEvent();
        }

        /* Verificar ultimos N segundos de inactividad */
        if(time( NULL ) > (tLastEchoLogon+_ISO8583_ECHO_TIMEOUT_))
        {
            tLastEchoLogon = time( NULL );            
            DPCSENDLOGON( CNTL_LOGON_REQUERIMENT );
        }

        /* verificar acciones pendientes del sist.oper.*/
        VerifyPendingOSMessages();

    }
    else
        iLen = 0;
   /* return */
   return iRc;
}

///////////////////////////////////////////////////////////////////////////////////////
// Enviar logoff
int DPCISO::SendLogoff()
{
    return SendLogon( CNTL_LOGOFF_REQUERIMENT );
}
///////////////////////////////////////////////////////////////////////////////////////
// Recuperar msg