main.cpp

ISO 8583 with c++ for financial transaction standard

	unsigned short nCount             = 0;
	int		         iRetval            = 0;
	char         szTrxFilename[256] = {0x00};
	char         szTrxFilename1_N[256] = {0x00};
	FILE        *hFile                 = NULL;
	char         szISOReqTrx[1024*100] = {0x00};
	size_t       shLen                 = 0;
	char szPAN[40]      = {0x00};
	char szTRANDAT[10]  = {0x00};
	char szTRANTIM[12]  = {0x00};
	char szPOSTDAT[10]  = {0x00};
	char szSEQNUM[16]   = {0x00};
	char szAMMOUNT[32]  = {0x00};
	char szAMMOUNT2[32] = {0x00};
	char szAMMOUNT3[32] = {0x00};
	char szACCOUNT1[32] = {0x00};
	char szACCOUNT2[32] = {0x00};
	char szT_CDE[4]     = {0x00};
	char szT_FROM[4]    = {0x00};
	char szT_TO[4]      = {0x00};
	char szTRANCODE[8]  = {0x00};
	char szTERM_ID[24]    = {0x00},
		   szTERM_LN[8]     = {0x00},
		   szTIP_EXCH_V[10] = {0x00},
		   szCURR_CODE[5]   = "032";
	time_t t_Wait       = 0L;
	time_t t_TranTim	= 0L;
	tm	   tm_TranTim	= {0x00};
	short  shApplyFrecuency    = 0;
	BOOL	 bError = false;
	BOOL	 bEndOfDatasource = false;
	WORD   wLen        = 12;
	CHAR   szBuf[12+1] = {0};
	long   nRandom = 0;
	short  iFiles = 0;
	bool   m_checkBinary     = FALSE;
	bool   m_checkRefNumRand = TRUE;
	bool   m_checkHARDCODED  = TRUE;
	BOOL	 bUseTCPPP = true;

	 /* Mensaje de FIN */
	 printf( "PROGRAMA SIMULADOR DE TRANSACCIONES ISO8583, FORMATO RED LINK\n\r");
	 /* iniciamos un numero random para cargar diversos tran-code */
	 srand( time( NULL ) );
	 nRandom = rand();

	/////////////////////////////////////////////////////////////////////////////////////////////////
	// Carga parametros de la REGISTRY con valores por default
	strcpy(szAddress,"localhost" );
	shPort = 9999 ;
	/////////////////////////////////////////////////////////////////////////////////////////////////


	iRetval = 0;
	szTrxFilename[0] = 0x00;
  if(argc >= 2)
	  strcpy(szTrxFilename, argv[1]);
  else
    strcpy(szTrxFilename, "NULL");

  /* Test hard-coded? */
	if ( !m_checkHARDCODED )
	{
    /* En binario o texto ? */
		if(!m_checkBinary)
			hFile = fopen(szTrxFilename, "rt");
		else
		{
			hFile = fopen(szTrxFilename, "rb");
			if(!hFile)
			{
				printf("Sin poder abrir archivo de transacciones ISO8583 %s\n\r", argv[1]);
				return -1;
			}
			////////////////////////////////////////////////////////
			fclose(hFile);
			iFiles++;
			sprintf(szTrxFilename1_N, "%s.%i.txt", szTrxFilename, iFiles );
			hFile = fopen(szTrxFilename1_N, "rb");
			////////////////////////////////////////////////////////
		}
		if(NULL == hFile)
		{
			printf("Sin poder abrir archivo de transacciones ISO8583\n\r");
			return -1;
		}
	};


  ///////////////////////////////////////////////////////////
  // Configurar direcciones IP y PORTS del Switch
  DPCSETCONFIG( szAddress,
                0,
                shPort,
                bUseTCPPP, /* PP-protocol : 2-bytes-length */
                _DPC_COMM_TIMEOUT_ ,
                NULL,
                0 );
  ///////////////////////////////////////////////////////////
  
	// Iniciar Host-ISO8583, emulando RED LINK S.A., modo SERVER (LISTENING PORT)
	iRetval = DPCCONNECT( szAddress,
				0,
				shPort,  /* listening port */
				bUseTCPPP,
				0 ,
				NULL );
	// Esperar conexiones y rutearlas.
	if(TCP4U_SUCCESS != iRetval)
  {
		printf("Sin poder iniciar sesion servidor (LISTENING SERVER) via TCP/IP\n\r");  
		return -2;
  }

	// Procesar mientras haya datos....
	while ( !bEndOfDatasource )
	{
		// Timeout default N seg
		DPCSETTIMEOUT( _DPC_COMM_TIMEOUT_);
		// Mientras haya mensajes entrantes, procesarlos
		if( TCP4U_SUCCESS == iRetval ||
			TCP4U_TIMEOUT == iRetval )
			iRetval = DPCSTARTPROCESSING( is_false, is_false, is_false );

		// Segun errores recibidos
		if( TCP4U_SOCKETCLOSED   == iRetval   ||
			TCP4U_CONNECTFAILED  == iRetval   ||
			TCP4U_ERROR          == iRetval   ||
			TCP4U_HOSTUNKNOWN    == iRetval   ||
			TCP4U_NOMORESOCKET   == iRetval   ||
			TCP4U_NOMORERESOURCE == iRetval   ||
			TCP4U_BINDERROR      == iRetval   ||
			TCP4U_CANCELLED      == iRetval   ||
			TCP4U_INSMEMORY      == iRetval   ||
			TCP4U_BADPORT        == iRetval )
		{
			iRetval = DPCDISCONNECT();
			// Conectar al Host-to-Host ISO8583, emulando RED LINK S.A.,
			// modo SERVER (LISTENING PORT)
			iRetval = DPCCONNECT( szAddress,
						0,
						shPort, /* listening port */
						bUseTCPPP,
						0 ,
						NULL );
		}

		// Se lee desde un archivo o se arman y disparan con ciertos parametros predefinidos ?????
		// Esto se discrimina con "hFile == NULL"
		if(hFile != NULL && (TCP4U_SUCCESS == iRetval ||	TCP4U_TIMEOUT == iRetval) )
		{
			// Leemos las transacciones desde un archivo externo, de a una
			// y hasta 75mil transacciones
			for (nCount++; nCount < qTrxLimit ;nCount++)
			{

        printf("ENTER para continuar....\r\n");
        getchar();
        
				memset(szISOReqTrx, 0x00, sizeof szISOReqTrx);
				if(!m_checkBinary)
				{
					if(fgets( szISOReqTrx, sizeof szISOReqTrx, hFile )==NULL)
					{
						fgetc( hFile );
						if(feof( hFile ))
						{
							bEndOfDatasource = true;
							break;
						} ;
					}
					shLen = strlen(szISOReqTrx);
				} else {
					if((shLen=fread( szISOReqTrx, 1, sizeof szISOReqTrx, hFile ))==0)
					{
						if(feof( hFile ))
						{
							iFiles++;
							sprintf(szTrxFilename1_N, "%s.%i.txt", szTrxFilename, iFiles );
							hFile = fopen(szTrxFilename1_N, "rb");
							if(!hFile)
							{
								bEndOfDatasource = true;
								break;
							}
							else
								shLen=fread( szISOReqTrx, 1, sizeof szISOReqTrx, hFile );
						};
					}
				};
				if(shLen > 0L)
				{
					char *pszSeparator = strstr(szISOReqTrx,"|");
					if( !pszSeparator )
						pszSeparator = szISOReqTrx;
					if( pszSeparator &&
						(strncmp( pszSeparator+12,"0200",4)==0 ||
						 strncmp( pszSeparator+12,"0420",4)==0 ||
						 strncmp( pszSeparator+12,"0421",4)==0 ||
						 strncmp( pszSeparator+12,"0800",4)==0 ||
						 strncmp( pszSeparator+12,"0220",4)==0 ||
						 strncmp( pszSeparator+12,"0221",4)==0 ||
						 strncmp( pszSeparator+13,"0200",4)==0 ||
						 strncmp( pszSeparator+13,"0420",4)==0 ||
						 strncmp( pszSeparator+13,"0421",4)==0 ||
						 strncmp( pszSeparator+13,"0800",4)==0 ||
						 strncmp( pszSeparator+13,"0220",4)==0 ||
						 strncmp( pszSeparator+13,"0221",4)==0 ||
						 strncmp( pszSeparator+14,"0200",4)==0 ||
						 strncmp( pszSeparator+14,"0420",4)==0 ||
						 strncmp( pszSeparator+14,"0421",4)==0 ||
						 strncmp( pszSeparator+14,"0800",4)==0 ||
						 strncmp( pszSeparator+14,"0220",4)==0 ||
						 strncmp( pszSeparator+14,"0221",4)==0))
					{
						 /* importacion de msg. ISO */
						if((*pszSeparator)=='|')
							pszSeparator++;
						 if(!m_checkBinary)
							shLen = strlen(pszSeparator);
						 DPCIMPORTMSG((PBYTE)pszSeparator, shLen);
						 /* actualizar nro de secuencia */
						 if(m_checkRefNumRand)
						 {
							wLen        = 12;
							nRandom = rand() % 999971 ;
							sprintf(szBuf,"%09i   ", nRandom );
							DPCUPDATEFIELD(37,&wLen,(PBYTE)szBuf,wLen);
							wLen = (WORD)sizeof(szISOReqTrx);
							DPCEXPORTMSG((PBYTE)pszSeparator, &wLen);
							shLen = wLen;
						 }
						 /* envio de msg ISO */
						 if(!m_checkBinary)
						 {
							//iRetval = DPCSENDREQNOWAIT( is_true, _DPC_COMM_TIMEOUT_ ) ; /*  seg. timeout */
							//iRetval = DPCSENDREQANDWAITRESP( is_true, _DPC_COMM_TIMEOUT_ ) ; /*  seg. timeout */
							iRetval = DPCSENDDRAFT( is_true, _DPC_COMM_TIMEOUT_, pszSeparator,shLen );
						 }
						 else
							iRetval = DPCSENDDRAFT( is_true, _DPC_COMM_TIMEOUT_, pszSeparator,shLen );
						 iRetval = TCP4U_SUCCESS;
					}
					else
					{
						 /* importacion de msg. ISO */
						 if((*pszSeparator)=='|')
							pszSeparator++;
						 if(!m_checkBinary)
							shLen = strlen(pszSeparator);
						 /* envio de msg ISO */
						 if(!m_checkBinary)
						 {
							//iRetval = DPCSENDREQANDWAITRESP( is_true, _DPC_COMM_TIMEOUT_ ) ; /*  seg. timeout */
							iRetval = DPCSENDDRAFT( is_true, _DPC_COMM_TIMEOUT_, pszSeparator,shLen );
						 }
						 else
							iRetval = DPCSENDDRAFT( is_true, _DPC_COMM_TIMEOUT_, pszSeparator,shLen );
						 iRetval = TCP4U_SUCCESS;
					};
				}
				else
					iRetval = TCP4U_SUCCESS;
			};
		}
		else if(NULL == hFile && (TCP4U_SUCCESS == iRetval ||	TCP4U_TIMEOUT == iRetval) )
		{
			// Armamamos un SET de transacciones pseudo-aleatorio, con datos predefinidos
			nCount++;
			iRetval = execute_trx_test( 200 , nCount );

		};/* end-if */

	};/* end-while */

	// Logoff final
	iRetval = DPCSENDLOGOFF()  ;

	// Cerrar archivos de transacciones
	if(NULL != hFile)
  {
		fclose(hFile);
    hFile = NULL;
  };

	// Mensaje de FIN
	printf( "YA TERMINO EL BOMBARDERO/SIMULADOR EN FORMATO RED LINK");
	// Terminar
	return 0;
}