dpciso.cpp

ISO 8583 with c++ for financial transaction standard

                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 con mensaje ISO actual
                NotifyEvent( );
            }

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

            iLen = 0;

    }; /* while */
    /* RETURN */
    return iRc;
}
///////////////////////////////////////////////////////////////////////////////////////
// Desconectar
int DPCISO::Disconnect()
{

   /* stop ECHO-LOGON timer */
   DeallocateEvent();
    
   /****************************************************************/
   /* Verificar mensajes pendientes, PRIMERO QUE NADA */
   iRc = CheckForMsgs( iTimeout ); /* if data avail, X sec time out */
   /****************************************************************/

   if(bConnect)
   {
     /* close socket */
     if(mySock)
        TcpClose (&mySock);
     /* close socket */
     if(mySockListen)
        TcpClose (&mySockListen);
     /* no more COMMUNICATION events */
     hostStatus = _NO_COMM_EVENTS_;
     /**************************************************/
     /* Verificar mensajes pendientes, LUEGO DEL CLOSE */
     iRc = CheckForMsgs( iTimeout ); 
     /**************************************************/
     /* clean up library */
     Tcp4uCleanup();    
     /* connect flag to FALSE */
     bConnect = false ;
   }
   /* host unavailable */
   hostStatus = _HOST_UNAVAILABLE_;
   /* return OK */
   return (iRc = TCP4U_SUCCESS);
}
///////////////////////////////////////////////////////////////////////////////////////
// Conectarse
int DPCISO::Connect(char *szHost, unsigned short usPort, unsigned short usLiPort, 
                    bool xbPP_Protocol, int iXTimeout, cobisdb *prpcXDB) 
{

   /* PRECONDITION */
   if(bConnect)
       return (iRc=TCP4U_SUCCESS);

   /***********************************/
   /* enable log                      */
   Tcp4uEnableLog( LOG4U_PROC | LOG4U_ERROR | LOG4U_DUMP );
   /* get info on this library */   
   Tcp4uVer (szVer, sizeof szVer);   
   /* init library */
   iRc = Tcp4uInit();
   if (TCP4U_SUCCESS!=iRc)     
   {
      /* host unavailable */
      hostStatus = _HOST_UNAVAILABLE_;
      return iRc; /* error */   
   }
   /***********************************/

   /* copy external timeout */
   iTimeout = iXTimeout ;

   /* connet to server and wait its reply */
   /* listen on socket */
   if(usLiPort == 0)
   {
     iRc = TcpConnect (&mySock, szHost, "dpciso", &usPort );
     if (TCP4U_SUCCESS!=iRc)
     {
          /* host unavailable */
          hostStatus = _HOST_UNAVAILABLE_;
          /* cleanup library */
          Tcp4uCleanup();
          return iRc; /* error */   
     }
     /* connect to server : ok */
     bConnect = true;
     /* host ready */
     hostStatus = _HOST_READY_;

   }


   /* listen on socket */
   if(usLiPort != 0)
   {
      unsigned short usTemp = usLiPort ;
      SOCKET         LSock  = 0;
     
      iRc = TcpGetListenSocket (& LSock, "dpciso", & usTemp, 1); /* 1 pending connection */
      if (iRc!=TCP4U_SUCCESS)
      {
        /* host unavailable */
        hostStatus = _HOST_UNAVAILABLE_;
        /* cleanup library */
        Tcp4uCleanup();
        return iRc; /* error */
      }
      iRc = TcpAccept( &mySockListen, LSock, iTimeout ); /* N secs. for timeout, 0 = for ever*/
      if (TCP4U_SUCCESS!=iRc)
      {
        /* host unavailable */
        hostStatus = _HOST_UNAVAILABLE_;
        /* cleanup library */
        Tcp4uCleanup();
        return iRc; /* error */   
      }
      /* connect from server : ok */
      bConnect = true;
      /* host ready */
      hostStatus = _HOST_READY_;
   }

   /* backup */
   strcpy(szISOHost, szHost);
   usISOPort   = usPort;
   usISOLiPort = usLiPort;
   
   /* start timer */
   AllocateEvent();

   /* TCP PP protocol ? */
   bTCPIP_PP_PROTOCOL    = xbPP_Protocol;

   /***************************************************************/
    if(INVALID_SOCKET == myActiveSock)
        myActiveSock = mySock;
    if(INVALID_SOCKET == myActiveSock)
        myActiveSock = mySockListen;
    if(INVALID_SOCKET == myActiveSock)
    {
        /* host unavailable */
        hostStatus = _HOST_UNAVAILABLE_;
        return (iRc = TCP4U_ERROR);
    }
    /***************************************************************/

   /* db connectivity point */
   if(prpcXDB != NULL)
     prpcDB = prpcXDB;

   /* return exit code */
   return iRc; /* ok */   
}
///////////////////////////////////////////////////////////////////////////////////////
// Reconectarse
int DPCISO::Reconnect( ) 
{
   if(bConnect)
        return (iRc=TCP4U_SUCCESS);
   else
        return Connect( szISOHost, usISOPort, usISOLiPort, bTCPIP_PP_PROTOCOL, iTimeout) ;
}    
///////////////////////////////////////////////////////////////////////////////////////
// Enviar req. esperando Rta.
int DPCISO::SendReqAndWaitResp(short xbPP_Protocol,  unsigned uTimeOut)
{       
   char    szStrLoc[256]={0x00};
   /*******************************************************/
   /* variable de retorno de la longitud es SHORT 16 bits */
   unsigned short shLen = 0;
   /*******************************************************/

   /* OK */
   iRc  = TCP4U_SUCCESS;              

   /* get ISO8583 msg */
   shLen = iLen = sizeof(szStr);
   isoMsg.Export( (unsigned char *)szStr, &shLen );
   iLen = shLen;
   if( iLen <= 0)
       return (iRc=TCP4U_ERROR);

   /* PP protocol (2 first bytes contain length of data) */
   if(xbPP_Protocol)
     iRc = TcpPPSend (myActiveSock, szStr, iLen, hDumpFile);
   else
     iRc = TcpSend (myActiveSock, szStr, iLen, FALSE, hDumpFile);

   do {

       /* uTimeOut > 0 : wait for response */
       if (TCP4U_SUCCESS==iRc && uTimeOut > 0) 
       {
            /* esperar rta. */
            memset( szStr, 0x00, sizeof szStr );
            if(xbPP_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;
            }
            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 );
                    // NO NOTIFICAR EVENTO CUANDO ESTAMOS ENVIANDO UN REQUERIMIENTO,
                    // SINO PODEMOS ENTRAR EN UN LOOP INFINITO
                };
            }
            else
           {
               strcpy(szStr, _ISO_MSG_HEADER_);
               iLen = strlen(szStr);
               /* update ISO8583 msg */   
               isoMsg.Import( (unsigned char *)szStr, (unsigned short)iLen );
           };
       } 
       else

       {
           strcpy(szStr, _ISO_MSG_HEADER_);
           iLen = strlen(szStr);
           /* update ISO8583 msg */   
           isoMsg.Import( (unsigned char *)szStr, (unsigned short)iLen );
       };
        
   }
   while ( TCP4U_SUCCESS==iRc && 
       (isoMsg.IsNetworkMgmtResponse() || 
        isoMsg.IsNetworkMgmtRequest()  ||
        isoMsg.IsControlCenterCommand() ) 
        );

   /* return */
   return (iRc) ;
}

///////////////////////////////////////////////////////////////////////////////////////
// Enviar requerimiento sin esperar rta.
int DPCISO::SendReqNoWait(short xbPP_Protocol,  unsigned uTimeOut)
{       
   char            szStrLoc[256]={0x00};
    /*******************************************************/
    /* variable de retorno de la longitud es SHORT 16 bits */
   	unsigned short  shLen = 0;
	  /*******************************************************/

   /* OK */
   iRc  = TCP4U_SUCCESS;              

   /* get ISO8583 msg */
   shLen = iLen = sizeof(szStr);
   isoMsg.Export( (unsigned char *)szStr, &shLen );
   iLen = shLen;
   if( iLen <= 0)
       return (iRc=TCP4U_ERROR);

   /* PP protocole (2 first bytes contain length of data) */
   if(xbPP_Protocol)
      iRc = TcpPPSend (myActiveSock, szStr, iLen, hDumpFile);
   else
      iRc = TcpSend (myActiveSock, szStr, iLen, FALSE, hDumpFile);   
   /* uTimeOut > 0 : wait for response */
   if (TCP4U_SUCCESS==iRc && uTimeOut > 0)   
   {
        iRc = CheckForMsgs( uTimeOut ); /* if data avail, X sec time out */
        /* 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 )     ;