C++ Log::Put方法代码示例

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | search_timeout                                             |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Busca un timeout en la cola                                |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
void search_timeout()
{
    int	   cont;
    int	   ret;
	char   aux_str1[100];		
    
    /* Loguea la hora */
	LogAlarm.Put(0, "search_TO(): Revisando TO...%s",  currentTimeLog());
    
    /* Busca un time out */
    cont=timeout_queue.FindTO();
    if (cont > -1)
    {
        /* Procesa un time out */ 
		process_timeout(cont);
    }
	else
	{
		/* Espera para siguiente ejecucion */
		LogAlarm.Put(0, "search_TO(): Esperando...\n");
		Cfg.GetItem("TimeOutDaemon", "SleepTime", aux_str1);
		sleep(atoi(aux_str1));
		LogAlarm.Put(0, "search_timeout(): Listo.\n");
	}
}

/*
+-----------------+------------------------------------------------------------+
| FUENTE          | Pos::SetPosBusy                                            |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Agrega una caja a la lista de ocupadas                     |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int Pos::SetPosBusy(char *ca, char *suc, char *caj)
{
    int	cont=0;

    /* Busca el siguiente disponible */
    while ((pos[cont].nro_ca[0]!='\0') && (cont<POS_MAX_MEMBERS))
	{
		cont++;
    }

	/* Si hay una posicion libre */
	if (pos[cont].nro_ca[0]=='\0')
    {
		/* Agrega el elemento */
		strcpy(pos[cont].nro_ca  , ca);
		strcpy(pos[cont].nro_caj , caj);
		strcpy(pos[cont].nro_suc , suc);
		LogAlarm.Put(5, "Objeto Pos: SetPosBusy [%s%s%s]. Posicion [%d]\n", ca, suc, caj, cont );

		/* Retorna el resultado OK */
		Errno=OK;
		return OK;
    }
	else
	{
		LogAlarm.Put(5, "Objeto Pos: SetPosBusy [%s%s%s]. NO HAY POSICIONES LIBRES\n", ca, suc, caj );
	}

	/* Retorna el resultado error */
    Errno=ENOSPC;
    return NOOK;
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | PriceOnLine::Armar_y_Enviar_Respuesta                      |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Arma un mensaje de respuesta local en funcion del mensaje  |
|                 | recibido y datos calculados y lo envia al TPV              | 
+-----------------+------------------------------------------------------------+
*/
int PriceOnLine::Armar_y_Enviar_Respuesta(char *szCodRta, struct trxRtaTPV *stRta)
{
	Price_Msg		*priceRta;
	char			szCampo13[LON_CAMPO_13 + 1];
	char			szMsgStr[2000];
	int				iLen;
	int				iRet = 0;
	char			szCpoTerVer[25+1];

	/* Arma mensaje de respuesta de rechazo hacia el TPV por configuracion erronea */
	priceRta=new Price_Msg(TYPE_PRICE_VENTA_RTA);
	
	/* Completa campos de la respuesta */
	priceRta->PutField( 1, mensaje_price->GetField( 1));
	priceRta->PutField( 2, mensaje_price->GetField(15));
	priceRta->PutField( 3, mensaje_price->GetField(16));
	priceRta->PutField( 4, mensaje_price->GetField(11));
	priceRta->PutField( 7, mensaje_price->GetField( 4));
	priceRta->PutField( 8, mensaje_price->GetField( 5));
	priceRta->PutField( 9, stRta->szCodAut);
	priceRta->PutField(10, "");
	priceRta->PutField(11, stRta->szComerc);
	priceRta->PutField(15, mensaje_price->GetCodTar());
	priceRta->PutField(16, "000000000000");
	sprintf(szCampo13, "%03d%1s%8s%s%s ", atoi(stRta->szNroLot), FLAG_OFFLINE, PINPAD_NULO, stRta->szRespCA, stRta->szPlanSF); 
	priceRta->PutField(13, szCampo13);
	priceRta->PutField( 6, szCodRta); 

	/* Devuelve nro de terminal y version */
	sprintf(szCpoTerVer, FTO_VER, stRta->szTermin, stRta->szProtoc, stRta->szPlnIso, 
								  NO_ANUL, VERSION_NRO, stRta->szTicOri, stRta->szFecOri );
	priceRta->PutField(12, szCpoTerVer);

	/* Aplana el mensaje */
	iLen = priceRta->GetMsgString(szMsgStr);

	/* Borra el mensaje price */
	delete priceRta;

	/* Envia respuesta al TPV */
	iRet = SQueue.SendMsg(orig_pid, szMsgStr, iLen);
	if (iRet != OK)
	{
		LogAlarm.Put(0, "PriceOn: ERROR (%d) al enviar respuesta\n", SQueue.GetErrno());
	}	
	else
	{
		LogAlarm.Put(0, "PriceOn: RESPUESTA LOCAL: %s\n", szCodRta);
	}
	return (iRet);
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | RtaRevAnul::ProcessIt                                      |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int RtaRevAnul::ProcessIt()
{
	int              len;
	int              ret;
	str_sel_cadata   term_data;
	trxAnulHeap	     heap_data;
	char             msgrta[300];	
	char			 idHeap[20];
	char			 aux_str1[100];
	int				 iCont;
	Queue 			 EQueue;	
	trxRevHeap		 heap_reve;

	/* Obtiene los datos de la caja en funcion de la caja del centro autorizador */
	strcpy(term_data.nro_caj_ca, IsoMsg->GetField(41)); 
	ret=ObtCaCaj(&term_data);
	if (ret!=OK)
	{
		/* Loguea el mensaje en caso de error */
		LogAlarm.Put(0, "RtaRevAnul: ERROR (%d) al obtener datos de la caja [%s]\n", ret, term_data.nro_caj_ca);
		return NOOK;
	}

	/* Obtiene los datos del heap */
	sprintf(idHeap,"%2.2s%3.3s%5.5s%8.8s", term_data.nro_ca, term_data.nro_suc, term_data.nro_caj, IsoMsg->GetField(11));
	LogAlarm.Put(0, "RtaRevAnul: Extrayendo datos del heap [%s]\n", idHeap);
	ret=Heap.GetData(idHeap,(char *)&heap_reve, sizeof(heap_reve));
	if (ret==NOOK)
	{
		LogAlarm.Put(0, "RtaRevAnul: Transaccion no existe en Heap [%s]\n", idHeap);
		return NOOK;
	}
	else
	{
		LogAlarm.Put(0, "RtaRevAnul: Reenvio a RevTrxRta\n");
		Cfg.GetItem("VisaDaemon", "QueueID", aux_str1);
		if ( EQueue.Open(atoi(aux_str1)) == OK )
		{
			Heap.PutData(idHeap,(char *)&heap_reve, sizeof(heap_reve));
			EQueue.SendMsg(EVENT_SNDREVERSO_RTA, szMsjeISO, iLMsjeISO);
		}		
	}
	LogAlarm.Put(0, "RtaRevAnul: Evento finalizado\n");	
	return OK;
}

/*
+-----------------+------------------------------------------------------------+
| FUENTE          | Pos::SetPosFree                                            |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Elimina una caja de la lista de ocupadas                   |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int Pos::SetPosFree(char *ca, char *suc, char *caj)
{
    int	cont=0;
    
	/* Busca la clave */   
    while ( ( (strcmp(pos[cont].nro_ca , ca )) || 
              (strcmp(pos[cont].nro_caj, caj)) ||
			  (strcmp(pos[cont].nro_suc, suc)) 
			) && (cont<POS_MAX_MEMBERS) )
    {
		cont++;
    }
    
	/* Si encuentra la clave */
	if ( (strcmp(pos[cont].nro_ca  , ca )==0) &&
		 (strcmp(pos[cont].nro_caj , caj)==0) &&
		 (strcmp(pos[cont].nro_suc , suc)==0) )
    {
		LogAlarm.Put(5, "Objeto Pos: SetPosFree [%s%s%s]. Posicion [%d]\n", ca, suc, caj, cont);

		/* Libera el elemento */
		pos[cont].nro_ca[0]  = '\0';
		pos[cont].nro_caj[0] = '\0';
		pos[cont].nro_suc[0] = '\0';
		
		/* Retorna el resultado OK */
		Errno=OK;
		return OK;
    }
	else
	{
		LogAlarm.Put(5, "Objeto Pos: SetPosFree [%s%s%s]. Posicion no encontrada\n", ca, suc, caj);
	}

	/* Retorna el resultado error */
    Errno=ENOENT;
    return NOOK;  
}

/*
+-----------------+------------------------------------------------------------+
| FUENTE          | Pos::IsPosFree                                             |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Verifica si una caja esta libre                            |
|                 | Retorna: 1:No encontrado - 0:Encontrado                    | 
+-----------------+------------------------------------------------------------+
*/
int Pos::IsPosFree(char *ca, char *suc, char *caj)
{
    int	cont=0;
    int ret;

    /* Busca si la clave se encuentra */
    while ( ( (strcmp(pos[cont].nro_ca  , ca )) || 
              (strcmp(pos[cont].nro_caj , caj)) ||
              (strcmp(pos[cont].nro_suc , suc)) 
			) && (cont<POS_MAX_MEMBERS) )
	{
        cont++;
    }
    
	/* Retorna el resultado */
	ret = (cont==POS_MAX_MEMBERS);

	LogAlarm.Put(5, "Objeto Pos: IsPosFree  [%s%s%s]. Retorno [%d]\n", ca, suc, caj, ret);

    return ret;
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | EchoTest::EnviarMsg                                        |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Envia un mensaje por la cola administrativa                |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int EchoTest::EnviarMsg(int orig_pid, char *msg, int len)
{
	Queue AQueue;
	int iRet;
	char msgString[500];
	char auxString1[100];

	/* Abre cola de mensajes administrativos */
	Cfg.GetItem("AdminDaemon", "QueueID", auxString1);
	iRet = AQueue.Open(atol(auxString1));
	if (iRet==OK)
	{
		/* Envia mensaje */
		memset(msgString, 0, sizeof(msgString));
		memcpy(msgString, msg, len);
		iRet = AQueue.SendMsg(orig_pid, msgString, len);
	}
	if (iRet)
	{
		LogAlarm.Put(0, "EchoTest: ERROR al enviar mensaje por cola administrativa\n");
	}
	return iRet;
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | EchoTest::ProcessIt                                        |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int EchoTest::ProcessIt()
{
	char	msg_str[2000];
	int		len;
	int		ret;
	int		HeapOcup = 0;
	int		TOQueueOcup = 0;
	char	aux_str1[100];	
	char	idHeap[20];
	str_sel_cadata	term_data;
	int     iCantidad;

	/* Arma los datos de la terminal */
	memset(&term_data, 0, sizeof(term_data));
	strncpy(term_data.nro_suc, ping_data.nro_suc, sizeof(term_data.nro_suc));
	strncpy(term_data.nro_caj, ping_data.nro_caj, sizeof(term_data.nro_caj));
	strncpy(term_data.nro_ca , ping_data.nro_ca , sizeof(term_data.nro_ca ));
	LogAlarm.Put(0, "EchoTest: Suc:[%s] Caj:[%s] CA:[%s]\n", term_data.nro_suc, term_data.nro_caj, term_data.nro_ca);

	/* Obtiene datos de la terminal */
	ret=getDataByNTET(&term_data);
	if (ret!=OK)
	{
		LogAlarm.Put( 1, "EchoTest: ERROR (%d) al obtener datos de la terminal\n", ret);
		EnviarMsg(orig_pid, "ERROR", 5);
		return NOOK;
	}

	/* Se carga en el objeto TraceNmbr el centro autorizador con el que se trabaja */
	TraceNumber.SetNroSuc(term_data.nro_suc);
	TraceNumber.SetNroCaj(term_data.nro_caj);
	TraceNumber.SetNroCA (term_data.nro_ca );
	TraceNumber.SetCodConCie("0");

	/* Arma mensaje iso */
	mensaje_iso->PutField(7, currentTimestamp());
	strcpy(aux_str1, TraceNumber);
	TraceNumber.Inc();
	mensaje_iso->PutField(11, aux_str1); 
	mensaje_iso->PutField(24, term_data.cod_red);
	mensaje_iso->PutField(41, term_data.nro_caj_ca);
	mensaje_iso->PutField(42, term_data.nro_com_et);

	/* Arma clave del heap */
	sprintf(idHeap,"%02d",atoi(term_data.nro_ca));

	/* Verifica si se encuentra en el heap */
	LogAlarm.Put(0, "EchoTest: Busca clave en el heap [%s]\n", idHeap);
	ret=Heap.FindData(idHeap, (char *)&orig_pid,sizeof(orig_pid));
	if (ret!=1)
	{
		LogAlarm.Put(0, "EchoTest: Heap ocupado. Clave:[%s]\n", idHeap);
		HeapOcup = 1;
	}
	LogAlarm.Put(0, "EchoTest: Valor de HeapOcup %d\n", HeapOcup);

	/* Verifica si se encuentra en la TOQ */
	ret=timeout_queue.FindTimeOut(idHeap);
	if (ret==1)
	{
		LogAlarm.Put(0, "EchoTest: Se encontro en TOQueue. Clave:[%s]\n", idHeap);
		TOQueueOcup = 1;
	}
	LogAlarm.Put(0, "EchoTest: Valor de TOQueueOcup %d\n", TOQueueOcup);

	/* Si el ping esta activo */
	if ((HeapOcup == 1) && (TOQueueOcup == 1))
	{
		/* Envia respuesta por la cola administrativa */
		LogAlarm.Put(0, "EchoTest: Ping Activo. Esta ocupado\n");
		LogAlarm.Put(0, "EchoTest: Envia respuesta por la cola administrativa\n");
		ret= EnviarMsg(orig_pid, "ERROR", 5);
		return NOOK;
	}
	else 
	{
		/* Si el head esta ocupado */
		if (HeapOcup == 1)
		{
			LogAlarm.Put( 0, "EchoTest: Se encuentra en Heap pero no en TOQ\n");
			ret=Heap.GetData(idHeap, (char *)&orig_pid,sizeof(orig_pid));
			if (ret==NOOK)
			{
				LogAlarm.Put( 0, "EchoTest: ERROR (%d) al extraer de heap\n", Heap.GetErrno());
				EnviarMsg(orig_pid, "ERROR", 5);			
				return NOOK;
			}
		}

		/* Si la TOQ esta ocupada */ 
		if (TOQueueOcup == 1) 
		{
//.........这里部分代码省略.........

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | Batch::ProcessIt                                           |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int Batch::ProcessIt()
{
    char			aux_str[100];
    char			msg_str[2000];
    int				msg_len;
    int				ret;
    str_heap_data	heap_data;
    str_sel_ntdata	term_data;
    char			idHeap[20];

    /* Obtiene los datos del mensaje */
    LogAlarm.Put(5, "Batch: Obteniendo datos de la terminal.\n");
    strcpy(term_data.nro_caj_ca, mensaje_iso->GetField(41));
    strcpy(term_data.nro_com   , mensaje_iso->GetField(42));

    /* Obtiene datos de la terminal */
	ret=getDataByCA(&term_data);
	if (ret!=OK)
	{
		LogAlarm.Put( 0, "Batch: ERROR (%d) al obtener datos de la terminal\n", ret);
		return NOOK;
	}

    /* Se indica al objeto TraceNmbr con que centro autorizador se trabaja */
    TraceNumber.SetNroSuc(term_data.nro_suc);
    TraceNumber.SetNroCaj(term_data.nro_caj);
    TraceNumber.SetNroCA (term_data.nro_ca );
    TraceNumber.SetCodConCie(term_data.cod_con_cie);

	/* Setea centro autorizador */
	mensaje_iso->SetNroCA8583(term_data.nro_ca);
	
	/* Obtiene tarjeta y la carga para agregar 'F' final */
	switch (DBTipoProtocoloISO(term_data.nro_ca))
	{
	case PROT_ISO_AMEX:
		sprintf(aux_str, "%s", mensaje_iso->GetField(2));
		mensaje_iso->PutField(2, aux_str);
		break;
	default:
		break;
	}
	
    /* Completar el mensaje con los datos generados	*/
    strcpy(aux_str, TraceNumber);
    TraceNumber.Inc();
    mensaje_iso->PutField(11, aux_str); 

    /* Chequea consistencia del mensaje	*/
    LogAlarm.Put(5, "Batch: Checkeo de consistencia del msg.\n");
    if (!mensaje_iso->ChkReady())
	{
		LogAlarm.Put(0,"Batch: ERROR mensaje ISO incompleto\n");
		return NOOK;
	}

    /* Registra transaccion en TrxHeap	*/
    LogAlarm.Put(5, "Batch: Obteniendo datos para el Heap.\n");
    heap_data.orig_pid=orig_pid;
    LogAlarm.Put(5, "Batch: Poniendo datos en el Heap.\n");
    sprintf(idHeap,"%2.2s%3.3s%5.5s%8.8s", term_data.nro_ca, term_data.nro_suc,
                                           term_data.nro_caj, mensaje_iso->GetField(11));
    ret=Heap.PutData(idHeap,(char *)&heap_data, sizeof(heap_data));
    if (ret==NOOK)
	{
		LogAlarm.Put(5, "Batch: ERROR (%d) al agregar en el Heap\n", Heap.GetErrno());
		return NOOK;
	}

    /* Registra en la TimeoutQueue	*/
    LogAlarm.Put(5, "Batch: Agregando a la TO Queue.\n");
    Cfg.GetItem("TimeOutDaemon", "MsgTimeOut320", aux_str);
    ret=timeout_queue.SetTimeOut(idHeap, atoi(aux_str), GetType(), "");
	if (ret==NOOK)
	{
		LogAlarm.Put(0, "Batch: ERROR (%d) al agregar en TimeOutQueue\n", timeout_queue.GetErrno());
		return NOOK;
	}

	/* Aplana el mensaje */
    msg_len=mensaje_iso->GetMsgString(msg_str);

    /* Envia el mensaje por X25 */
    LogAlarm.Put(0, "Batch: Envia a X.25. CAut [%s]\n", term_data.nro_ca);
	ret=XQueue.SendMsg(atoi(term_data.nro_ca)+1, msg_str, msg_len);
    if (ret==NOOK)
	{
		LogAlarm.Put(0, "Batch: ERROR (%d) al enviar a Cola X.25\n", XQueue.GetErrno());
		return NOOK;
	}
	LogAlarm.Put(5, "Batch: Evento finalizado\n");

//.........这里部分代码省略.........

main()
{
   Log		LogAlarm;
   Config	CfgCred("credito.ini");
   char		buffer1[500];
   char		buffer2[500];
   Queue	XQueue,EQueue;
   long		QueueID,QueuePerm;
   struct	tm *newtime;
   time_t	ltime;
   int 		ret;
   int 		len;
   Iso_Msg	*IsoMsg;
   Iso_Msg	*IsoRta;

   LogAlarm.Open("../log/Em.log");
   LogAlarm.SetLevel(10);

   CfgCred.GetItem("CAVisaDaemon","QueueID",buffer1);
   QueueID=atol(buffer1);
   CfgCred.GetItem("CAVisaDaemon","QueuePerms",buffer2);
   QueuePerm=atol(buffer2);
   ret=XQueue.Create(QueueID,QueuePerm);

   if (ret!=OK)
      exit(ret); 

   CfgCred.GetItem("Daemon","QueueID",buffer1);
   QueueID=atol(buffer1);
   CfgCred.GetItem("Daemon","QueuePerms",buffer2);
   QueuePerm=atol(buffer2);
   ret=EQueue.Open(QueueID,QueuePerm);
   if (ret!=OK)
   { 
      exit(ret); 
   }
   
   time(&ltime); 
   newtime=localtime(&ltime);
   srandom(newtime->tm_sec);
   LogAlarm.Put(1,"Comenzando Operacion %s\n",asctime(newtime)); 

   while (ret==OK)
   {
	len=XQueue.GetMsg(0, buffer1, sizeof(buffer1));
	if (len==NOOK)
	{
	   break;
	}

	IsoMsg=new Iso_Msg(buffer1,len);

	switch (IsoMsg->GetMsgType())
	{
	   case TYPE_VISA_VENTA:
	       LogAlarm.Put(1,"Recibido PriceOn [%s] [%s]\n",
		      IsoMsg->GetField(41),IsoMsg->GetField(11));
	       IsoRta = new Iso_Msg(TYPE_VISA_VENTA_RTA);
	       IsoRta->PutField(2,IsoMsg->GetField(2));
	       IsoRta->PutField(11, IsoMsg->GetField(11));
	       IsoRta->PutField(24, IsoMsg->GetField(24));

	       sprintf(buffer1,"%012%d",random());
	       IsoRta->PutField(37,buffer1);

	       sprintf(buffer1,"%06d",random());
	       IsoRta->PutField(38,buffer1);

	       IsoRta->PutField(39,"00");
	       IsoRta->PutField(41, IsoMsg->GetField(41));

	       len=IsoRta->GetMsgString(buffer1);

	       ret=EQueue.SendMsg(EVENT_PRICEONLINE_RTA,buffer1,len);

               break;
        }

   }
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | init                                                       |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Inicia las estructuras y memoria compartida                |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int init()
{
    int	ret;
    int	cont;
	int	max_entries;
	char aux_str1[100];
	char aux_str2[100];

    /* Configura las señales de terminacion */
	signal(SIGINT, shut_down);
    signal(SIGTERM, shut_down);

    /* Obtiene el nombre del archivo de log */
	Cfg.GetItem("TimeOutDaemon", "LogName", aux_str1);
    LogAlarm.Open(aux_str1);

    /* Setea el nivel de log */
	Cfg.GetItem("TimeOutDaemon", "LogLevel", aux_str1);
    LogAlarm.SetLevel(atoi(aux_str1));

	/* Loguea hora de comienzo */
    LogAlarm.Put( 0,"TimeOutDaemon::init(): Comienzo [%s] - %s", NUM_VERSION, currentTimeLog()); 

    /* Obtiene la cantidad maxima de entradas en la cola */
	Cfg.GetItem("TimeOutDaemon", "MaxEntries", aux_str1);
    max_entries=atoi(aux_str1);

    /* Obtiene la cantidad maxima de entradas en la tabla de PIDs */
	Cfg.GetItem("PIDTable", "ShMemID", aux_str1);
    Cfg.GetItem("PIDTable", "MaxEntries", aux_str2);

    /* Abre tabla de PIDs */
	LogAlarm.Put(0, "TimeOutDaemon::init(): Abre tabla de PIDs [%s] [%s]\n", aux_str1, aux_str2);
    while (PTable.Open(atoi(aux_str1), atoi(aux_str2))==NOOK)
    {
		if (PTable.GetErrno()!=ENOENT)
		{
			LogAlarm.Put(0, "TimeOutDaemon::init(): Error (%d)!!\n", PTable.GetErrno());
			exit(1);
		}
    }
    
	/* Pone el pid en la tabla */
	LogAlarm.Put(0, "TimeOutDaemon::init(): Adding PID to PID table...\n");
    ret=PTable.PutPid(getpid());
    if (ret==NOOK)
    {
		LogAlarm.Put(0, "TimeOutDaemon::init(): Error (%d)!!\n", PTable.GetErrno());
		exit(1);
    }

    /* Obtiene los identificadores y permisos de la cola de timeout */
	Cfg.GetItem("TimeOutDaemon", "ShMemID", aux_str1);
    Cfg.GetItem("TimeOutDaemon", "ShMemPerms", aux_str2);

    /* Crea cola de timeout */
    LogAlarm.Put(0, "TimeOutDaemon::init(): Creando area de memoria compartida para la Timeout_Queue\n");  
    ret=timeout_queue.Create(atoi(aux_str1), max_entries, atoi(aux_str2));
    if (ret==NOOK)
    {
		LogAlarm.Put(0, "TimeOutDaemon::init(): Error (%d) al crear area para la Timeout_Queue \n", timeout_queue.GetErrno());
    }

    /* Obtiene identificador de la cola de eventos */
	Cfg.GetItem("VisaDaemon", "QueueID", aux_str1);
    
	/* Abre cola de eventos */
	LogAlarm.Put(0, "TimeOutDaemon::init(): Abriendo cola de eventos...\n");
    ret= EQueue.Open(atoi(aux_str1));
    if (ret==NOOK)
	{
		LogAlarm.Put(1, "TimeOutDaemon::init(): Error (%d) al abrir cola de eventos!!\n", EQueue.GetErrno());
		return NOOK;
	}

    return OK;
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | process_timeout                                            |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Procesa el timeout.                                        |
|                 | Parametro: cont: Posicion de la cola con el timeout        | 
+-----------------+------------------------------------------------------------+
*/
void process_timeout(int cont)
{
	int		ret;
	int		event_type;
	str_timeout     	*timeout_data;
	str_timeout_event	timeout_event_data;
	char	aux_str1[100];	
	
	/* Obtiene los datos del elemento con time out vencido */
	timeout_data=timeout_queue.GetTimeOut(cont);
	LogAlarm.Put(0, "process_timeout(): Se encontro un TO (id:%s)\n", timeout_data->id);
	
	/* Si expired==0 */
	if (timeout_data->expired==0)
	{
		/* Setea el primer timeout */
		Cfg.GetItem("TimeOutDaemon", "MsgTimeOut2", aux_str1);
		LogAlarm.Put(0, "process_timeout(): Primer timeout\n");
		timeout_queue.SetOne(cont, atoi(aux_str1)); 
		
		/* Generar evento TimeOut */
		LogAlarm.Put(0, "process_timeout(): Generando evento TimeOut...\n");
		
		/* Completa la estructura del timeout */
		strcpy(timeout_event_data.key,timeout_data->id);
		strcpy(timeout_event_data.cod_ser,timeout_data->cod_ser);
		
		/* Obtiene el tipo de evento */
		switch (timeout_data->event_type)
		{
		case EVENT_REVTRXANUL:
			LogAlarm.Put(5,"process_timeout():  generando TimeOut de Reverso Anulacion \n");
			event_type=EVENT_TIMEOUT_REV_ANUL;
			break;
		case EVENT_SNDTRXANUL:
			LogAlarm.Put(5,"process_timeout():  Generando Timeout de Anulacion \n");
			event_type=EVENT_TIMEOUT_ANULACION;
			break;
		case EVENT_CIERRE:
			LogAlarm.Put(5, "process_timeout(): Generando TimeOut de cierre...\n");
			event_type=EVENT_TIMEOUT_CIERRE;
			break;
		case EVENT_CIERRE_B:
			LogAlarm.Put(5, "process_timeout(): Generando Timeout de cierre Batch\n");
			event_type=EVENT_TIMEOUT_CIERRE_B;
			break;
		case EVENT_BATCH:
			LogAlarm.Put(5, "process_timeout(): Generando Timeout en trx de batch upload\n");
			event_type=EVENT_TIMEOUT_BATCH;
			break;
		case EVENT_SNDTRXOFFLINE:
			LogAlarm.Put(5, "process_timeout(): Generando Timeout de Transaccion offline\n");
			event_type=EVENT_TMTTRXOFFLINE;
			break;
		case EVENT_SNDREVERSO:
			LogAlarm.Put(5, "process_timeout(): Generando Timeout de reverso\n");
			event_type=EVENT_TIMEOUT_REVERSO;
			break;
		case EVENT_ECHOTEST:
			LogAlarm.Put(5, "process_timeout(): Generando Timeout de echo test\n");
			
			event_type=EVENT_TIMEOUT_ECHOTEST;
			break;
		default:
			LogAlarm.Put(5, "process_timeout(): Generando Timeout generico\n");
			event_type=EVENT_TIMEOUT;
		}
		
		/* Envia el mensaje al Daemon */
		ret=EQueue.SendMsg(event_type, (char *)&timeout_event_data, sizeof(str_timeout_event));
		if (ret==NOOK)
		{
			LogAlarm.Put(5, "process_timeout: Error (%d) en Envio de Evento Timeout!!\n", EQueue.GetErrno());
		}
	}
	else  /* expired en 1 (ya se habia cumplido el 1er. timeout) */
	{
		/* Borra el timeout de la cola */
		LogAlarm.Put(0, "process_timeout: Segundo timeout. Borrando de la tabla...\n");
		timeout_queue.SetSecond(cont);
	}
}

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | PriceOnLine::ProcessIt                                     |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int PriceOnLine::ProcessIt()
{
	str_sel_cadata	term_data;
	str_heap_data	heap_data;
	TrxData			trx_data;
	char			msg_str[2000];
	char			aux_str[64];
	char			szNroCta[64];
	int				cont;
	int				len;
	int				ret;
	int				limite=OK;
	int				channel_down;
	int				pos_ocup;
	int				TrxEnVuelo;
	str_upd_rev		StrDataRev;
	char 			CajDevol[6];
	char 			TrxDevol[5];
	char 			CajVenta[6];
	char 			TrxVenta[5];
	char			FecVenta[7];
	char			szCampo13[LON_CAMPO_13 + 1];
	char			szCuotas[32];
	/* Modificacion PINPAD */
	char			szPinPad[64];
	int				iHayPinPad;
	/* Pinpad 2*/
	long			lCodProc;
	long			lCodCuenta;
	char			szCodiProc[16];
	int				iTipoOperacion=0;
	char			NroTrxAux[9];
	char			szRowId[64];
	char			szFHtransm[32];
	char			szFHoperac[32];
	long			lImpoTran;
	long			lCashBack;
        char                    szCriptograma[1024] = {0};
        char                    szVersionEMV[20] = {0};
        char                    szEMVProductList[512] = {0};
	struct trxRtaTPV stRta;
	
	/* Blanquea estructura de respuesta */
	memset(&stRta, 0, sizeof(stRta));
	memset(stRta.szCodAut, ' ', sizeof(stRta.szCodAut)-1);
	memset(stRta.szComerc, ' ', sizeof(stRta.szComerc)-1);
	memset(stRta.szTermin, ' ', sizeof(stRta.szTermin)-1);
	memset(stRta.szNroLot, ' ', sizeof(stRta.szNroLot)-1);
	memset(stRta.szPlnIso, ' ', sizeof(stRta.szPlnIso)-1);
	memset(stRta.szProtoc, ' ', sizeof(stRta.szProtoc)-1);
	memset(stRta.szRespCA, ' ', sizeof(stRta.szRespCA)-1);
	memset(stRta.szFecOri, ' ', sizeof(stRta.szFecOri)-1);
	memset(stRta.szTicOri, ' ', sizeof(stRta.szTicOri)-1);
	memset(stRta.szPlanSF, ' ', sizeof(stRta.szPlanSF)-1);
        

	/* Track II en las IBM no viene el separador de campos '='. Se agrega */
	char TrackIIprice[40];
	char * indexTr;
	strcpy(TrackIIprice,mensaje_price->GetField(10));
	if ((indexTr=strchr(TrackIIprice,'D'))!=NULL)
	{
		*indexTr='='; 
		mensaje_price->PutField(10,TrackIIprice);
	}
	
	/* Se invierte la fecha de caducidad siempre */
	mensaje_price->InvertirFecha(); 
	
	/* Se loguean los datos de la terminal */
	LogAlarm.Put(0, "PriceOn: Emp:[%s] Suc:[%s] Ter:[%s] Trx:[%s] Tar:[%s] Plan:[%s]\n", 
						mensaje_price->GetEmpresa()     , 
						mensaje_price->GetSucursal()    ,
						mensaje_price->GetTerminal()    ,
						mensaje_price->GetTransaccion() ,
						mensaje_price->GetCodTar()      ,
						mensaje_price->ObtPlanSf());

	/* Se obtienen los datos de la terminal en base al mensaje price */
	strcpy(term_data.plan_sf, mensaje_price->ObtPlanSf());
	strcpy(term_data.cod_tar, mensaje_price->GetCodTar());
	strcpy(term_data.nro_suc, mensaje_price->GetEmpresa());
	strcpy(term_data.nro_caj, mensaje_price->GetTerminal());

	/* Obtiene el tipo de operacion ( 01:T_VENT - 02:T_DEVO - 08:T_PAGO - 09:T_DEVP ) */
	iTipoOperacion = atoi(mensaje_price->GetField(5));

	/* Se buscan los restantes datos de la terminal */
	ret=getDataByNT2(&term_data);
	if ( (ret!=OK) || (term_data.caj_bloq==1) )
	{
		/* Al dar error, loguea los datos de la terminal mal configurada */
//.........这里部分代码省略.........

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | Cierre::ProcessIt                                          |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int Cierre::ProcessIt()
{
    char			aux_str[100];
    char			msg_str[2000];
    int				msg_len;
    int				ret;
    str_heap_data	heap_data;
    BatchData		batch_data;
    str_sel_ntdata	term_data;
	char			aux_str1[100];
    char			idHeap[20];

	/* Obtiene los datos del mensaje */
    strcpy(term_data.nro_caj_ca, mensaje_iso->GetField(41));
    strcpy(term_data.nro_com   , mensaje_iso->GetField(42));
    
	/* Completa la estructura con los datos del mensaje */
	batch_data.NroCajCa(term_data.nro_caj_ca);

	/* Obtiene datos de la terminal */
	ret=getDataByCACie(&term_data);
	if (ret!=OK)
	{
		LogAlarm.Put( 0, "Cierre: ERROR (%d) al obtener datos de la terminal\n", ret);
		return NOOK;
	}

	/* Indica al objeto TraceNmbr el centro autorizador */
    TraceNumber.SetNroSuc(term_data.nro_suc);
    TraceNumber.SetNroCaj(term_data.nro_caj);
    TraceNumber.SetNroCA (term_data.nro_ca );
    TraceNumber.SetCodConCie(term_data.cod_con_cie);

    /* Completar el mensaje con los datos generados */
    mensaje_iso->PutField(7, currentTimestamp());
    strcpy(aux_str, TraceNumber);
    TraceNumber.Inc();
    mensaje_iso->PutField(11, aux_str); 
    mensaje_iso->PutField(15, currentTimestamp());

    /* Chequea consistencia del mensaje	*/
	LogAlarm.Put(95, "Cierre: Chequea consistencia del mensaje\n");
	if (!mensaje_iso->ChkReady())
	{
		LogAlarm.Put( 0, "Cierre: ERROR de consistencia en el mensaje\n");
		return NOOK;
	}

    /* Registrar transaccion en TrxHeap	*/
    LogAlarm.Put(95, "Cierre: Obtiene datos para el Heap\n");
    heap_data.orig_pid=orig_pid;

	/* Pone datos en el heap */
    LogAlarm.Put(95, "Cierre: Poniendo datos en el Heap.\n");
    sprintf(idHeap,"%2.2s%3.3s%5.5s%8.8s",term_data.nro_ca,term_data.nro_suc,term_data.nro_caj,mensaje_iso->GetField(11));
    ret=Heap.PutData(idHeap,(char *)&heap_data, sizeof(heap_data));
	if (ret==NOOK)
	{
		LogAlarm.Put(0, "Cierre: ERROR (%d) al poner los datos en el heap!!\n", Heap.GetErrno());
		return NOOK;
	}

    /* Registra en la TimeoutQueue con un timeout diferente a los otros eventos */
    LogAlarm.Put( 5, "Cierre: Agrega a la cola de timeout\n");
    Cfg.GetItem("TimeOutDaemon", "MsgTimeOut500", aux_str1);
    ret=timeout_queue.SetTimeOut(idHeap, atoi(aux_str1), GetType(), ""/*CodSer*/);
	if (ret==NOOK)
	{
		LogAlarm.Put( 0, "Cierre: ERROR (%d) al agregar en cola de timeout!!\n", timeout_queue.GetErrno());
		return NOOK;
	}

    /* Si se graba registro de cierre */
	memset(aux_str1, 0, sizeof(aux_str1));
	Cfg.GetItem("AdminDaemon", "InsertCierre", aux_str1);
	if (aux_str1[0] != 'N')
	{
		/* Completa la estructura */
		batch_data.NroCA(term_data.nro_ca);
		mensaje_iso->GetDBData(batch_data);
		batch_data.CanRet("0000");
		sprintf(aux_str, "%02d", E_ENVI);
		batch_data.CodEst(aux_str);
		batch_data.NroSuc(term_data.nro_suc);
		batch_data.NroCaj(term_data.nro_caj);
		batch_data.NroCom(term_data.nro_com);

		/* Registra en la base de datos */
		LogAlarm.Put( 5, "Cierre: Registra en base de datos\n");
		ret=DBBatch.Insert(batch_data.GetInsData());
		if (ret!=OK)
		{
//.........这里部分代码省略.........

/*
+-----------------+------------------------------------------------------------+
| FUNCION         | SndTrxOffLine::ProcessIt                                   |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int SndTrxOffLine::ProcessIt()
{
    int             len;
    int             ret;
    int				iCont;
	str_sel_cadata  term_data;
    char            msg_str[2000];
    char            aux_str[20];
    trxOffHeap      infoHeap;         
    DBInfoEnvio     InfoEnvio;        
    str_fet_bu_trx  trxOff;
    int             pos_ocup;
    str_tarjeta     data_tar;
	char			aux_str1[100];	
    DBTrxPk         trxPk;             
    char			idHeap[20];
	char			szFechaEnvio[16];
	int				iErrorBD;
	int				iNroCuotas;

	/* Carga estructura para busqueda de transaccion offline */
    strncpy(trxOff.cod_tar   , CodTarjeta, sizeof(trxOff.cod_tar));
    strncpy(trxOff.cod_est   , "00"      , sizeof(trxOff.cod_est));
    strncpy(trxOff.nro_caj_ca, NroCajCa  , sizeof(trxOff.nro_caj_ca));
    strncpy(trxOff.nro_trx   , NroTrx    , sizeof(trxOff.nro_trx));
	trxOff.nro_caj_ca[sizeof(trxOff.nro_caj_ca)-1]='\0';
    trxOff.cod_tar   [sizeof(trxOff.cod_tar)   -1]='\0';
	trxOff.cod_est   [sizeof(trxOff.cod_est)   -1]='\0';
	trxOff.nro_trx   [sizeof(trxOff.nro_trx)   -1]='\0';

    /* Busca en BD una transaccion offline */
    LogAlarm.Put(0, "TrxOff: Lee offline [%s] [%s] [%s] [%s]\n", trxOff.nro_caj_ca, trxOff.cod_tar, trxOff.cod_est, trxOff.nro_trx);
	ret=DBGetNextTrx(&trxOff, &iErrorBD);
    if (ret!=OK)
    {
		LogAlarm.Put( 0, "TrxOff: Retorno de recuperacion de offline:%d Errno:%d\n", ret, iErrorBD);
		EnviarMsg(orig_pid, "ERROR", 5);
		return OK; 
	}
    //LogAlarm.Put(0, "TrxOff: Rowid a enviar [%s]\n",trxOff.rowid);

	/* Obtiene datos del centro autorizador */
    LogAlarm.Put(5, "TrxOff: Obtiene codigo de centro\n");
	strcpy(data_tar.cod_tar, trxOff.cod_tar);
	ret = ObtCA(&data_tar);
	if (ret!=OK)
	{
		LogAlarm.Put(0, "TrxOff: ERROR al obtener CA. Tar:[%s]\n", trxOff.cod_tar);
		EnviarMsg(orig_pid, "ERROR", 5);
		return OK; 
	}       

	/* Verifica si la caja esta libre */
    strcpy(term_data.nro_caj, trxOff.nro_caj);
    pos_ocup = P.IsPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
    if (pos_ocup)
    {    
		/* Marca la caja como ocupada */
		ret = P.SetPosBusy(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		if (ret!=OK)
		{
			LogAlarm.Put(0, "TrxOff: ERROR al setear caja como ocupada\n");
		}
    }
    else
    {
        /* Retorna envio de caja bloqueada */
		LogAlarm.Put(0, "TrxOff: ERROR. Caja bloqueada\n");
		EnviarMsg(orig_pid, "BLOCK", 5);
		return NOOK;
    }

    /* Arma el mensaje base de acuerdo al codigo de transaccion */
	switch (atoi(trxOff.cod_trx))
	{
	case T_VENT:
		IsoMsg=new Iso_Msg(TYPE_VISA_VENTA_LOCAL);
		break;
	case T_DEVO:
		IsoMsg=new Iso_Msg(TYPE_VISA_DEVOL_LOCAL);
		break;
	case T_PAGO:
		IsoMsg=new Iso_Msg(TYPE_VISA_VENTA_LOCAL);
		sprintf(aux_str1, "%06d", OPCODE_VISA_PAGO_RESUMEN);
		IsoMsg->PutField(3, aux_str1);
		break;
	case T_DEVP:
		IsoMsg=new Iso_Msg(TYPE_VISA_DEVOL_LOCAL);
		sprintf(aux_str1, "%06d", OPCODE_VISA_DEVO_RESUMEN);
		IsoMsg->PutField(3, aux_str1);
		break;
	default: /* Tipo de transaccion desconocida */
//.........这里部分代码省略.........