#include "monit.h"
//#include "time.h"

#define CincoMinutos (CLK_TCK * 60 * 5)
//-------------------------------------------------------------------------
extern HSNMP_SESSION snmpSession;
//-------------------------------------------------------------------------
cMonitorInterface::cMonitorInterface(const string &nome, const string &ip) {
   Arquivo.InformarInterface(ip);

   Ip.s_addr      = inet_addr(ip.c_str());
   NomeInterface  = nome;
   UltConsulta    = 0;
   QualVar        = 0;
   UltIfInOctets  = 0;
   UltIfOutOctets = 0;
   UltIfInErrors  = 0;
   UltIfOutErrors = 0;
   Trafego        = 0;
   Erros          = 0;
   EsperarResposta= 0;
}
//-------------------------------------------------------------------------
cMonitorInterface::~cMonitorInterface() {
}
//-------------------------------------------------------------------------
string ValueToString(SMI_VALUE &value) {
	SMI_UINT32 offset;
   char strString[128];
   strString[0]= 0; // Limpa a string caso alguém não o faça
   switch (value.type) {
      case SMI_TYPE_INT:
         wsprintf(strString, "%ld", (long)value.value.sNumber);
         break;
      case SMI_TYPE_UINT32:
      case SMI_TYPE_CNTR32:
      case SMI_TYPE_GAUGE32:
      case SMI_TYPE_TIMETICKS:
         wsprintf(strString, "%lu", (unsigned long)value.value.uNumber);
         break;
      case SMI_TYPE_CNTR64:
         wsprintf(strString, "0x%08lX%08lX",
               (unsigned long)value.value.hNumber.hipart,
               (unsigned long)value.value.hNumber.lopart);
         break;
      case SMI_TYPE_OCTETS:
      case SMI_TYPE_BITS:
      case SMI_TYPE_OPAQUE: {
         int binary;
         binary = FALSE;
         for (offset=0; offset<value.value.string.len; offset++) {
            if (!isprint(value.value.string.ptr[offset])) {
               binary = TRUE;
               break;
            }
         }
         if (binary) {
            wsprintf(strString, "%02X", (int)value.value.string.ptr[0]);
            for (offset=1; offset<value.value.string.len && offset<sizeof(strString)/3; offset++) {
               wsprintf(strString+offset*3-1, ":%02X", (int)value.value.string.ptr[offset]);
            }
         } else {
            strString[0] = '"';
            if (value.value.string.len!=0) {
               memcpy(strString+1, value.value.string.ptr, value.value.string.len);
            }
            strString[1+value.value.string.len] = '"';
            strString[1+value.value.string.len+1] = 0;
         }
         break;
      }
      case SMI_TYPE_IPADDR:
         wsprintf(strString, "%d", (int)value.value.string.ptr[0]);
         for (offset=1; offset<value.value.string.len; offset++) {
            wsprintf(strString+strlen(strString), ".%d", (int)value.value.string.ptr[offset]);
         }
         break;
      case SMI_TYPE_NSAPADDR:
         wsprintf(strString, "%02X", (int)value.value.string.ptr[0]);
         for (offset=1; offset<value.value.string.len; offset++) {
            wsprintf(strString+offset*3-1, ":%02X", (int)value.value.string.ptr[offset]);
         }
         break;
      case SMI_TYPE_OID:
         SnmpOidToStr(&(value.value.oid), sizeof(strString), strString);
         break;
      case SMI_TYPE_NULL:
         wsprintf(strString, "NULL");
         break;
      default:
         wsprintf(strString, "Unknown type(%02x)", (int)value.type);
         break;
   }
   return string(strString);
}
//-------------------------------------------------------------------------
void cMonitorInterface::TratarResposta(struct in_addr &in, HSNMP_PDU &pdu) {
   int ok= 0;
   if( in.s_addr == Ip.s_addr ) {
      SMI_INT error_status;
      SMI_INT error_index;
      HSNMP_VBL vbl;

      SNMPAPI_STATUS nStatus= SnmpGetPduData(pdu, NULL, NULL,
                                             &error_status, &error_index, &vbl);
      if(error_status == SNMP_ERROR_NOERROR) {
	      SMI_UINT32 nCount;
      	SMI_UINT32 index;

      	nCount= SnmpCountVbl(vbl);
      	for(index=1; index<= nCount; index++) {	/* Snmp Vbl index is 1-based! */
      		SMI_OID name;
		      SMI_VALUE value;

		      nStatus= SnmpGetVb(vbl, index, &name, &value);
		      if(nStatus != SNMPAPI_FAILURE) {
               ok= 1;
               string resp= ValueToString(value);
               unsigned long value= strtoul(resp.c_str(),NULL,10);

               switch( QualVar ) {
                  case 0 :
                     if(UltIfInOctets != 0)
                        Trafego+= value - UltIfInOctets; // Pega a diferença
                                                         // da última leitura
                     UltIfInOctets= value;
                     break;
                  case 1 :
                     if(UltIfOutOctets != 0)
                        Trafego+= value - UltIfOutOctets;
                     UltIfOutOctets= value;
                     break;
                  case 2 :
                     if(UltIfInErrors != 0)
                        Erros+= value - UltIfInErrors;
                     UltIfInErrors= value;
                     break;
                  case 3 :
                     if(UltIfOutErrors != 0)
                        Erros+= value - UltIfOutErrors;
                     UltIfOutErrors= value;

                     Arquivo.InfDados(DataAtual.da_day, // Registra os
                                      DataAtual.da_mon, // valores obtidos
                                      DataAtual.da_year,
                                      HoraAtual.ti_hour,
                                      HoraAtual.ti_min,
                                      sOcorrencia(Trafego,Erros,0));
                     break;
               }
		      }
         }
      }
      SnmpFreeVbl(vbl);
      if(ok) {
         QualVar++;
         EsperarResposta= 0;
         if(QualVar <= 3)
            Executar();
         else
            QualVar= 0;
      }
   }
}
//-------------------------------------------------------------------------
void cMonitorInterface::Executar() {
   if( EsperarResposta == 1 ) {
   // Esperava resposta que não veio, armazenamos 0.
      EsperarResposta= 0;
      QualVar        = 0;
      Arquivo.InfDados(DataAtual.da_day,
                       DataAtual.da_mon,
                       DataAtual.da_year,
                       HoraAtual.ti_hour,
                       HoraAtual.ti_min,
                       sOcorrencia(0,0,1));
   } else {
      if( UltConsulta == 0 || // Ou entra porque é a primeira vez
          QualVar > 0      || // ou porque estamos no meio de um pedido
          (clock() - UltConsulta) >= CincoMinutos ) {
                              // ou porque ja se passaram 5 minutos do
                              // ultimo pedido
         EsperarResposta= 1;
         switch( QualVar ) {
            case 0 :
               UltConsulta= clock();
               getdate(&DataAtual);
               gettime(&HoraAtual);
               Trafego= 0;
               Erros  = 0;
               SendRequest("ifInOctets[0]");
               break;
            case 1 : SendRequest("ifOutOctets[0]"); break;
            case 2 : SendRequest("ifInErrors[0]");  break;
            case 3 : SendRequest("ifOutErrors[0]"); break;
         }
      }
   }
}
//-------------------------------------------------------------------------
HSNMP_VBL cMonitorInterface::CreateSingleVbl(const string &strMibVarname) {
	SMI_POID name;
	SMI_PVALUE value;
	HSNMP_VBL vbl;
	SNMPAPI_STATUS nStatus;

	/* TODO: this works for string only */
	/* fill varbind */
	name = SmiCreateOid(MAXOBJIDSIZE);
	value = SmiCreateNumberValue(SMI_TYPE_NULL, 0);

	/* convert strName to name OID struct */
	if (isdigit(strMibVarname[0])) {
		nStatus = SnmpStrToOid((char *) strMibVarname.c_str(), name);
		if (nStatus==SNMPAPI_FAILURE) {
			SmiDestroyValue(value);
			SmiDestroyOid(name);
			return SNMPAPI_FAILURE;
		}
		name->len = nStatus;
	} else {
		nStatus = MibStrToOid(name, (char *) strMibVarname.c_str());
		if (nStatus==MIB_FAILURE) {
			SmiDestroyValue(value);
			SmiDestroyOid(name);
			return SNMPAPI_FAILURE;
		}
		name->len = nStatus;
		SnmpOidToStr(name, 256, (char *) strMibVarname.c_str());
	}

	/* create VBL with one varbind */
	vbl = SnmpCreateVbl(snmpSession, name, value);
	nStatus = (SNMPAPI_STATUS)vbl;
	if (nStatus==SNMPAPI_FAILURE) {
		SmiDestroyValue(value);
		SmiDestroyOid(name);
		return SNMPAPI_FAILURE;
	}

	SmiDestroyValue(value);
	SmiDestroyOid(name);
	return vbl;
}
//-------------------------------------------------------------------------
SNMPAPI_STATUS  cMonitorInterface::SendRequest(const string &strMibVarname) {
	SNMPAPI_STATUS nStatus;
	HSNMP_VBL vbl;
	HSNMP_PDU pdu;
   SMI_INT pdu_type= SNMP_PDU_GET;

	dstEntity= SnmpStrToEntity(snmpSession,(char*) Arquivo.RetIp().c_str());
	Status   = (SNMPAPI_STATUS)dstEntity;
	if(Status==SNMPAPI_FAILURE)
		return SNMPAPI_FAILURE;
	context  = SnmpStrToContext(snmpSession, dstEntity, "public");
	Status   = (SNMPAPI_STATUS) context;
	if(Status==SNMPAPI_FAILURE) {
		SnmpFreeEntity(dstEntity);
		return SNMPAPI_FAILURE;
	}

	vbl= CreateSingleVbl(strMibVarname);
	nStatus= (SNMPAPI_STATUS)vbl;
	if(nStatus==SNMPAPI_FAILURE) {
	   SnmpFreeContext(context);
	   SnmpFreeEntity(dstEntity);
		return SNMPAPI_FAILURE;
   }
	pdu = SnmpCreatePdu(snmpSession,
			pdu_type,						// request type
			NULL,								// request id (NULL=generate)
			SNMP_ERROR_NOERROR,			// error status
			0,									// error_index
			vbl);								// varbindlist
	nStatus = (SNMPAPI_STATUS)pdu;
	if (nStatus==SNMPAPI_FAILURE) {
		SnmpFreeVbl(vbl);
	   SnmpFreeContext(context);
	   SnmpFreeEntity(dstEntity);
		return SNMPAPI_FAILURE;
   }
	nStatus = SnmpSendMsg(snmpSession,
			                NULL,	   // source (NULL in SNMPv1)
			                dstEntity,	// dest
			                context,	// community
			                pdu);		// pdu

	if (nStatus==SNMPAPI_FAILURE) {
		SnmpFreePdu(pdu);
		SnmpFreeVbl(vbl);
	   SnmpFreeContext(context);
	   SnmpFreeEntity(dstEntity);
		return SNMPAPI_FAILURE;
	}
	SnmpFreePdu(pdu);
	SnmpFreeVbl(vbl);
	SnmpFreeContext(context);
	SnmpFreeEntity(dstEntity);
	return SNMPAPI_SUCCESS;
}
//-------------------------------------------------------------------------