dpciso.cpp

ISO 8583 with c++ for financial transaction standard

int DPCISO::GetMsg (char *szMsg, unsigned short *piLen )
{
    if( szMsg && piLen )
        return isoMsg.Export( (unsigned char *)szMsg , piLen );       
    else
        return TCP4U_ERROR;
}
///////////////////////////////////////////////////////////////////////////////////////
// Setear msg
int DPCISO::SetMsg (char *szMsg, unsigned short iLen )
{
    if( szMsg && iLen > 0)
        return isoMsg.Import( (unsigned char *)szMsg , iLen );       
    else
        return TCP4U_ERROR;
}
///////////////////////////////////////////////////////////////////////////////////////
// callback timer
VOID CALLBACK DPCISO::TimerProc(HWND hWindow, UINT uTimer, UINT uInt, DWORD uDWord)
{
    char szStrLoc[512]={0x00};
    int  iRc=TCP4U_ERROR;
    time_t tCurrentTime = time( NULL );
    ////////////////////////////////////
    unsigned short  shLen = 0;
    ///////////////////////////////////

    /* stop ECHO-LOGON timer */
    DeallocateEvent();

    /* verificar mensajes si es TIMER EVENT CHECKING */
    iLen = 0;
    if( eventType == _TIMER_EVENT_CHECKING_ )    
    {
        /*******************************************/
        iRc = CheckForMsgs( 1 ); /* 1 sec time out */
        /*******************************************/

        /* 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 )     ;
            if( bTCPIP_PP_PROTOCOL && bNETWORK_MGMT_ENABLE )
              iRc = TcpPPSend (mySock, szStr, 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)szStr, 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)
        {        
            NotifyEvent();
        }
        else if (iRc == TCP4U_ERROR)
        {        
        }
        else

        {
            Disconnect();
            Reconnect();
        };
    }; /* fin IF */

    /* Verificar ultimos N segundos de inactividad y enviar ECHO TEST-LOGON */
    /* O si vencio el TIMER DE ECHO */
    if(time( NULL ) >= (tLastEchoLogon+_ISO8583_ECHO_TIMEOUT_) || 1 == uInt)
    {
        tLastEchoLogon = time( NULL );            
        DPCSENDLOGON( CNTL_LOGON_REQUERIMENT );
    }; /* fin IF */

    /* start ECHO-LOGON timer */
    AllocateEvent();

}


///////////////////////////////////////////////////////////////////////////////////////
// Alojar evento (timer)
long DPCISO::AllocateEvent()
{    
    if ( _INNER_LOOP_CHECKING_ == eventType) 
    {
        UINT uiRet = 0;
        uiRet = SetTimer( (NULL != hHandle)
                            ? hHandle
                            : NULL, 
                            1, _ISO8583_ECHO_TIMEOUT_MSEG_, DPCTIMERPROC ); /* TIME ECHO TEST, 15 SEG */
        /* NO LANZAR TIMER DE POLLING DE MSGS., PORQUE ES INNER-LOOP EL CHEQUEO */
        return 0;
    }
    else
    {
        UINT uiRet = 0;
        uiRet = SetTimer( (NULL != hHandle)
                            ? hHandle
                            : NULL, 
                            1, _ISO8583_ECHO_TIMEOUT_MSEG_, DPCTIMERPROC ); /* TIME ECHO TEST, 15 SEG */
        uiRet = SetTimer( (NULL != hHandle)
                            ? hHandle
                            : NULL, 
                            2, _POLLING_TIMEOUT_MSEG_, DPCTIMERPROC ); /* TIMER POLLING, 1 SEG */        
        return uiRet ;
    }
}
///////////////////////////////////////////////////////////////////////////////////////
// Desalojar evento (timer)
long DPCISO::DeallocateEvent()
{    
    if ( _INNER_LOOP_CHECKING_ == eventType) 
    {
        KillTimer( NULL, 1 ); /* TIMER DE ECHO */
        /* NO HAY TIMER DE POLLING PORQUE ES INNER-LOOP */
        return 0;
    }
    else
    {
        KillTimer( NULL, 1 ); /* TIMER DE ECHO */
        return KillTimer( NULL, 2 ); /* TIMER DE POLLING DE MENSAJES */
    }
}

/* Funcion de busqueda de un STRING en un buffer de memoria binario, generico */
void *memstr( const void *vBuffer, const char szFind[], const size_t nSize )
{
    const char *ptrAddress = (char *)vBuffer;
    char *ptrBuffer  = (char *)vBuffer;
    char *ptrFirst   = NULL;    
    size_t  nLenStr  = 0;    
    size_t  iCounter = 0;
    /* precondition */
    if( NULL == vBuffer || NULL == szFind || nSize <= 0)
        return NULL;
    while( (ptrFirst = (char *)memchr( ptrBuffer, szFind[0], nSize)) != NULL )
    {
        for(iCounter=0, nLenStr = strlen(szFind);
            iCounter < nLenStr && szFind[iCounter] == ptrFirst[iCounter];
            iCounter++ )
            ;
        /* check for string length */
        if(iCounter >= nLenStr)
            /* return PTR to first char */
            return ptrFirst;
        else
        {
            if((ptrBuffer+1) <= (ptrAddress + nSize))
                ptrBuffer++;
            else
                /* return NO PTR */
                return NULL;
        };
    };
    /* return NO PTR */
    return NULL;
}

///////////////////////////////////////////////////////////////////////////////////////
// Disparar evento de notificacion (mensaje de notificacion)
// Este procedimiento verifica la existencia o no de mensajes concatenados y desarrolla
// la logica para manejarlos individualmente. Esto se da con protocolo TCP/IP y con un
// buffer de recepcion de hasta 20k bytes. Pueden venir fragmentados tambien, y tambien
// se desarrolla la logica para manejar eso, con un buffer de backup.
///////////////////////////////////////////////////////////////////////////////////////
long DPCISO::NotifyEvent( boolean_t bFromSAFQueue )
{    
    // Verificar mensajes ISO concatenados, comenzando con ASCII-2,3,4, o 5
    char    *ptrBegin     = szStr,
            *ptrEnd       = szStr,
            *ptrISO       = szStr,
            *ptrISOBackup = NULL; /* backup de mensaje actual */
    short    nLenISO    = 0;
    bool    bAppendISO = false;
    short    nCounter        = 0;
    /* Constantes de limitacion */
    const short cnMaxValidLength = 1024; /* max trx = 1024 bytes */
    const short    cnLoopLimit      = 20480 / (cnMaxValidLength/2); /* max frame = 20k */    
        
    /* Inicio valido del mensaje ISO es "ISO" para ATM y POS */
    ptrBegin = (char *)memstr( szStr, _ISO_MSG_HEADER_ATM_POS_ , iLen );
    if(!ptrBegin)
        return ( iRc = TCP4U_ERROR );
    /* Busco el proximo mensaje concatenado si hubiere ETX o EOT o NUL */
    /* Inicio valido del mensaje ISO es "ISO" para ATM y POS */
    ptrEnd = (char *)memstr( ptrBegin + 1, _ISO_MSG_HEADER_ATM_POS_ , iLen );    
    if(ptrEnd)    
        bAppendISO = true; /* Hay concatenados */
    else
        bAppendISO = false; /* No hay concatenados */
    /* Se hallo un concatenado ? */
    if(!ptrEnd && false == bAppendISO)
    {
        ptrEnd     = ptrBegin;
        bAppendISO = false; /* No hay concatenados */
    }
    else if(!ptrEnd && true == bAppendISO)
        ptrEnd     = ptrBegin;        
    else
        bAppendISO = true; /* Hay concatenados */

    /* Continua un mensaje fragmentado? Unir las partes desde el backup... */
    if( (ptrBegin - szStr) > 1 && iLenBackup > 0)
    {
        memcpy( szStrBackup + iLenBackup, szStr, ptrBegin - szStr );
        iLenBackup += ptrBegin - szStr;
        szStrBackup[iLenBackup] = 0x00;
        /* Procesar mensaje individual ISO para ATM y POS */

        ptrISO  = (char *)memstr( szStrBackup, _ISO_MSG_HEADER_ATM_POS_, iLen );
        if(ptrISO)
        {            
            /* Enviar a SAF el mensaje individual concatenado y partido */
            nLenISO = iLenBackup;
            StoreInSAFQueue( szStrBackup, iLenBackup );
            /* backup de mensaje actual */
            ptrISOBackup = ptrISO; 
        };
        /* Limpiar backup  */
        iLenBackup = 0;
        memset( szStrBackup, 0x00, sizeof szStrBackup );


    }
    /* Mientras haya mensajes concatenados, o sino, siempre sea el  1er mensaje.  */
    for(    nCounter = 0; 
            ptrBegin != NULL && nCounter < cnLoopLimit && iLen > 0; 
            nCounter++ )         
        {
        /* Mientras haya mensajes concatenados con STX o EOT o NUL...*/
        if( true == bAppendISO )
        {                
            /* Busco un inicio valido del msg ISO para ATM y POS */ 
            ptrISO = ptrBegin;

            /* Busco el proximo mensaje concatenado si hubiere ETX o EOT */
            /* Inicio valido del mensaje ISO es "ISO" para ATM y POS */
            ptrEnd = (char *)memstr( ptrBegin + 1, _ISO_MSG_HEADER_ATM_POS_ , iLen );    
            /* si no hay proximo, pero habia un inicio.... */
            if( ptrISO && (NULL == ptrEnd || (NULL != ptrEnd && ptrEnd == ptrISO)) 
              )
            {
                /* Atencion, mensaje partido, continua en proximo frame TCP */
                nLenISO    = strlen( ptrISO );
                iLenBackup = nLenISO;
                memcpy( szStrBackup, ptrISO, iLenBackup );
                szStrBackup[iLenBackup] = 0x00;
                /* Verificar caracteres finales , si son de CONTROL */
                if( szStrBackup[iLenBackup-1] <= 31 )
                {                    
                    szStrBackup[iLenBackup-1] = 0x00;
                    iLenBackup--;
                }
                if( szStrBackup[iLenBackup-1] <= 31 )
                {                    
                    szStrBackup[iLenBackup-1] = 0x00;
                    iLenBackup--;
                }
                /* Salir */
                return iRc;                
            }
            else
            {
                /* Longitud ISO reconocido */                
                nLenISO = ptrEnd - ptrBegin;
            };            
        }
        else
        {
            /* Buscar el inicio valido del mensaje ISO para ATM y POS */
            ptrISO     = (char *)memstr( ptrBegin, _ISO_MSG_HEADER_ATM_POS_, iLen  );
            nLenISO    = iLen;            
        };

        /* Procesar mensaje individual valido , no concatenado */        
        if(ptrISO && ptrISOBackup != ptrISO && nLenISO <= cnMaxValidLength && !bAppendISO )            
        {
            iRc = NotifyIndividualEvent( ptrISO, nLenISO, bFromSAFQueue );            
            ptrISOBackup = ptrISO;
            iLenBackup   = nLenISO;
        }
        /* Enviar a SAF el mensaje individual concatenado */
        else if (ptrISO && ptrISOBackup != ptrISO && nLenISO <= cnMaxValidLength && bAppendISO)
        {
            StoreInSAFQueue( ptrISO, nLenISO );
            ptrISOBackup = ptrISO;
            iLenBackup   = nLenISO;
        }
        /* Si el mensaje ya fue procesado, descartar */
        else
            break;
        
        /* Resto longitud actual de transaccion a longitud original */
        iLen -= nLenISO;


        /* Inicio valido del mensaje ISO es "ISO" para ATM y POS */
        ptrBegin = (char *)memstr( ptrBegin + 1, _ISO_MSG_HEADER_ATM_POS_ , iLen + nLenISO );    
        /* Inicio valido del mensaje ISO es "ISO" para ATM y POS */
        if(ptrBegin)
            ptrEnd = (char *)memstr( ptrBegin + 1, _ISO_MSG_HEADER_ATM_POS_ , iLen );
        else
            ptrEnd = NULL;
        

    }; /* end while */
    /* Retorno del Cod. Rta     */
    return iRc;
}
///////////////////////////////////////////////////////////////////////////////////////
// Enviar a SAF el mensaje ISO actual
int DPCISO::StoreInSAFQueue( char *ptrISO, int nLenISO )
{    
    DWORD   dwTrace       = 0,
            dwReferral    = 0;
    CHAR    chNumber[12]  = {0x00};
    WORD    shLen         = sizeof(chNumber);
    
    // precondicion : punteros y lognitud validas !
    if( NULL == ptrISO || n