dpciso.cpp

ISO 8583 with c++ for financial transaction standard

   bReversalToSAF_SystemFailure = is_false;
   trxStatus                    = CISO_APPROVED_I;
   iLen    = iLenOut = iLenBackup  = 0;
   memset( szStr      , 0x00, sizeof szStr );
   memset( szStrOut   , 0x00, sizeof szStrOut );
   memset( szStrBackup, 0x00, sizeof szStrBackup );
   ////////////////////////////////////////////////
   iRc               = TCP4U_SUCCESS;
   hDumpFile         = HFILE_ERROR;    // Archivo DUMP de TCP4U Library
   mySock = mySockListen = myActiveSock = 0;
   hHandle           = NULL;
   tLastEchoLogon    = 0L;
   efFormat          = CNTL_FORMAT_ISO8583;
   iTimeout          = 0;
   hostStatus        = _HOST_READY_;
   hostBackEndStatus = _HOST_READY_;
   ulTrxCounter      = 0;   
#if defined( ___INNER_LOOP_CHECKING_ )
   eventType        = _INNER_LOOP_CHECKING_ ;
#elif defined( ___TIMER_EVENT_CHECKING_ )
   eventType        = _TIMER_EVENT_CHECKING_ ;
#else
#error "Sin definir el modo de procesamiento de eventos"
#endif
   // ISO8583 init 
   isoMsg.InitMessage();
   // open-create SAF
   safQueue.Open( SAFFILENAME );
   // open-cerate MSG track
   trkLogg.Open( MSGTRKFILENAME );
   // open-create ERROR track
   trkError.Open( ERRTRKFILENAME );
   // open-create ECHOE track
   trkEchoes.Open( ECHOTRKFILENAME );
   
   //////////////////////////////////////////////
   szISOHost[0]     = 0x00;
   usISOPort        = 0;
   usISOLiPort      = 0 ;   
   szBackEndHost[0] = 0x00;
   usBackEndPort    = 0;
   //////////////////////////////////////////////
   szBackEndUser[0]  = 0x00;    
   szBackEndPassw[0] = 0x00;
   //////////////////////////////////////////////
   

   // TCP Connect 
   Connect( szHost, usPort, usLiPort, xbPP_Protocol, iTimeout);   

   // Verify locale settings  (decimal point)
   VerifyLocaleSettings();

}
///////////////////////////////////////////////////////////////////////////////////////
// destructor
DPCISO::~DPCISO()
{
   /* shuting down.... */
   hostStatus                   = _HOST_STOPPED_;
   hostBackEndStatus            = _HOST_STOPPED_;
   tLastSAFProcessed            = 0L;
   tLastEchoLogon               = 0L;
   bReversalToSAF_SystemFailure = is_false ;
   bNETWORK_MGMT_ENABLE         = false ;
   if(bConnect)
   {
     /* close socket */
     TcpClose (&mySock);
     /**************************************************/
     /* verify pending msgs                            */
     CheckForMsgs( iTimeout ); 
     /**************************************************/
     /* clean up library */
     Tcp4uCleanup();    
     bConnect = false ;
   }
   // Archivo DUMP de TCP4U Library
   hDumpFile = HFILE_ERROR;    
   // close SAF
   safQueue.Close( );
   // close MSG tracker
   trkLogg.Close();
   // close ERR tracker
   trkError.Close();
   // close ECHO tracker
   trkEchoes.Close();
   // Sin contador
   ulTrxCounter = 0;
}
///////////////////////////////////////////////////////////////////////////////////////
// verificacion de SAF pendiente
void DPCISO::VerifyPendingSAF( void )
{
    /* numeros de auditoria y referencia para una transaccion ISO */
    unsigned long    dwTrace    = 0L, 
                     dwReferral = 0L;
    
    /* precondicion : estar habilitado el parametro de envio a SAF */
    if(!bReversalToSAF_SystemFailure)
        return ;

    /* verificar SAF : si hay registros... */
    if( safQueue.StoredRecords() > 0 )
    {
        /* ir al primer registro almacenado */
        safQueue.SetFirstStored();
        /* mientras no sea el fin del archivo... , leer */
        while ( safQueue.ReadStored( (unsigned char *)szStr, (short)sizeof szStr, &iLen, 
            &dwTrace, &dwReferral) )
        {
            /* importar mensaje ISO */
            isoMsg.Import( (unsigned char *)szStr, iLen );
            /* procesar mensaje ISO con senal de "origen es cola de SAF" */
            NotifyEvent( is_true );
            /* marcar al registro SAF como procesado */
            safQueue.SetForwarded();
        };/* end while */
        /* al final del ciclo, recalcular estadisticas */
        safQueue.InitStatistics();
    }; /* end if */
}
///////////////////////////////////////////////////////////////////////////////////////
// inicio del procesamiento general del data center
int DPCISO::StartProcessing(boolean_t bLogon,boolean_t bAuthorize, boolean_t bRevToSAF)
{    
    char            szStrLoc[256]={0x00};
    unsigned short  uTimeOut     = iTimeout;
    time_t          tCurrentTime = time( NULL );
    /*******************************************************/
    /* variable de retorno de la longitud es SHORT 16 bits */
   	unsigned short  shLen = 0;
	  /*******************************************************/

    /****************************************************************/
    /* El archivo de DUMP de TCP4ULibrary                           */
    hDumpFile = fileno( trkError.GetFileHandle() );
    /****************************************************************/

    /****************************************************************/
    /* Verificar mensajes pendientes, PRIMERO QUE NADA */
    iRc = CheckForMsgs( uTimeOut ); /* if data avail, X sec time out */
    /****************************************************************/

    /***********************************************************************/
    /* Verificar SAF Previo si es que autoriza, LUEGO DEL CHEQUEO ANTERIOR */
    if(bAuthorize)
        VerifyPendingSAF();
    /***********************************************************************/
    /* Verificar si se envian reversos a SAF  */
    if(bRevToSAF)
        bReversalToSAF_SystemFailure = is_true;
    else
        bReversalToSAF_SystemFailure = is_false;
    /***********************************************************************/

    /******************************************************************/
    /* Se envia un LOGON? Luego de haber CHEQUEADO MENSAJES ENTRANTES */
    if(bLogon && bNETWORK_MGMT_ENABLE)
    {
        iLen = FormatLineCntrlLogonReq( CNTL_LOGON_REQUERIMENT );
        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 );
    }
    else
    {
        iRc = TCP4U_SUCCESS;        
    }
    /******************************************************************/

    
    /* mientras haya mensajes pendientes enviados */
    while (TCP4U_SUCCESS == iRc)
    {
        memset( szStr, 0x00, sizeof szStr );
        if(bTCPIP_PP_PROTOCOL)
            iRc = TcpPPRecv (myActiveSock, szStr, sizeof szStr, uTimeOut, FALSE, hDumpFile); 
        else
            iRc = TcpRecv (myActiveSock, szStr, sizeof szStr, uTimeOut, hDumpFile); 
         /* verificar longitudes retornadas */
        if(iRc<=0)
        {
            iLen = 0;
            return iRc;
        }
        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() )
            {
                iLen = sizeof szStrLoc;
                isoMsg.Export( (unsigned char *)szStrLoc, (unsigned short *)&iLen );
                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 );
                /* si debe autorizarse o no */
                if(bAuthorize)
                    NotifyEvent();
            }
        }
        else
            iLen = 0;

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

        /* verificar acciones pendientes del sist.oper.*/
        VerifyPendingOSMessages();
    
        /* Verificar SAF Previo si es que autoriza,        */
        /* y si hay registros , y si la ultima transaccion */
        /* no fue enviada a SAF por rechazo SYSTEM_FAILURE */
        if( safQueue.IsActionRequired()                                  && 
            GetLastTransactionStatus() != CISO_SYSTEM_FAILURE_I          &&
            GetLastTransactionStatus() != CISO_CUTOVER_IN_PROGREESS_I    &&
            GetLastTransactionStatus() != CISO_DESTINY_NOT_AVAILABLE_I   && 




            bAuthorize    )
            /* verificar SAF */
            VerifyPendingSAF();

    }/*end while*/

    return iRc;
}
///////////////////////////////////////////////////////////////////////////////////////
// Iniciar procesamiento (verificacion inicial de INPUT) 
int DPCISO::StartProcessing( char *szHost, unsigned short usPort, 
                             unsigned short usLiPort, bool xbPP_Protocol,                             
                             boolean_t    bLogon) 
{   
   if (TCP4U_SUCCESS!=Connect( szHost, usPort, usLiPort, xbPP_Protocol, iTimeout))     
       return iRc; /* error */   
   return StartProcessing( bLogon );
}
///////////////////////////////////////////////////////////////////////////////////////
// Verificacion de mensajes de INPUT
int DPCISO::CheckForMsgs(unsigned short    uTimeOut)
{    
    char            szStrLoc[256]={0x00};
    time_t          tCurrentTime = time( NULL );


    iLen = 0;
    if(!bConnect)
    {
        return (iRc = TCP4U_ERROR);
    }
    
    /* OK */
    iRc = TCP4U_SUCCESS;
    /* Mientras sea OK....*/
    while( TCP4U_SUCCESS == iRc )
    {

        /****************************************************************/
        /* segun el socket desde donde se haya recibido                 */
        if( !TcpIsDataAvail( mySock ) )
            if( !TcpIsDataAvail( mySockListen ) )
                return (iRc = TCP4U_ERROR);
            else
                myActiveSock = mySockListen; /* input desde socket escucha */
        else
            myActiveSock = mySock;    /* input desde socket de envios */
        /****************************************************************/

        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 */
         /* 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() )
            {
                iLen = sizeof szStrLoc;
                isoMsg.Export( (unsigned char *)szStrLoc, (unsigned short *)&iLen );
                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