#include <sys/types.h>

#include <sys/param.h>

#include <stdio.h>

#include <netinet/in.h>

#include <sys/time.h>

#include <errno.h>

#include <time.h>

#include <sys/ddi.h>

#include <unistd.h>

#include "snmp.h"

#include "asn1.h"

#include "snmp_impl.h"

#include "snmp_api.h"

#include "snmp_client.h"

int snmp_dump_packet = 0;

/*#define MYDEBUG*/

#define ETHERFILE "/home/uel/cce/dcop/mestrado/cinthyan/work1/ether.log"

#define SERFILE "/home/uel/cce/dcop/mestrado/cinthyan/work1/serial.log"

#define HTMETHER "/home/uel/cce/dcop/mestrado/cinthyan/public_html/cint33.htm"

#define HTMSERIAL "/home/uel/cce/dcop/mestrado/cinthyan/public_html/cint34.htm"

/*tempo em segundos entre as amostragens */

#define MYTIMETOWAIT 300

main()

{

/************************************************

Estruturas utilizadas pelas funcoes do cmu-snmp.

*************************************************/

struct snmp_session session, *ss;

struct snmp_pdu *pdu, *response;

struct variable_list *vars,*headvars ;

oid name[MAX_NAME_LEN];

int name_length;

int status;

/* some of my vars*/

int counter;

int i;

int k=0;

char *mypstr;

struct tm *ptrtime;

time_t loctime;

int loopcont=0;

int samplecont=0;

unsigned parasleep;

FILE *fp, *fht;

char mystraux1[255];

char mystraux2[255];

char Xtime[288][30];

int XifInOctets1[288];

int XifOutOctets1[288];

int XifInDiscards1[288];

int XifInErrors1[288];

int XifInUnknownProtos1[288];

int XifOutDiscards1[288];

int XifOutErrors1[288];

int XifOutQLen1[288];

float TR1=0;

int totINDISC1=0;

int totINERR1=0;

int totINUNK1=0;

int totOUTDIS1=0;

int totOUTERR1=0;

float M_TR1=0;

float M_INDISC1=0;

float M_INERR1=0;

float M_INUNK1=0;

float M_OUTDIS1=0;

float M_OUTERR1=0;

int XifInOctets2[288];

int XifOutOctets2[288];

int XifInDiscards2[288];

int XifInErrors2[288];

int XifInUnknownProtos2[288];

int XifOutDiscards2[288];

int XifOutErrors2[288];

int XifOutQLen2[288];

int maiordoTR=0;

float TR2=0;

int totINDISC2=0;

int totINERR2=0;

int totINUNK2=0;

int totOUTDIS2=0;

int totOUTERR2=0;

float M_TR2=0;

float M_INDISC2=0;

float M_INERR2=0;

float M_INUNK2=0;

float M_OUTDIS2=0;

float M_OUTERR2=0;

/********* Vars and Tables to data sampling: Warning> do not touch this,

some further data types conversion are position dependents!

Snif, snif... ************/

int objs_qtd= 19;

char mybuff[128][255];

char objetos[128][128]={

/*01*/"system.sysName.0\0",

/*---------ET--------*/

/*02*/"interfaces.ifTable.ifEntry.ifType.1\0",

/*03*/"interfaces.ifTable.ifEntry.ifInOctets.1\0",

/*04*/"interfaces.ifTable.ifEntry.ifOutOctets.1\0",

/*05*/"interfaces.ifTable.ifEntry.ifInDiscards.1\0",

/*06*/"interfaces.ifTable.ifEntry.ifInErrors.1\0",

/*07*/"interfaces.ifTable.ifEntry.ifInUnknownProtos.1\0",

/*08*/"interfaces.ifTable.ifEntry.ifOutDiscards.1\0",

/*09*/"interfaces.ifTable.ifEntry.ifOutErrors.1\0",

/*10*/"interfaces.ifTable.ifEntry.ifOutQLen.1\0",

/*--------Serie------*/

/*11*/"interfaces.ifTable.ifEntry.ifType.2\0",

/*12*/"interfaces.ifTable.ifEntry.ifInOctets.2\0",

/*13*/"interfaces.ifTable.ifEntry.ifOutOctets.2\0",

/*14*/"interfaces.ifTable.ifEntry.ifInDiscards.2\0",

/*15*/"interfaces.ifTable.ifEntry.ifInErrors.2\0",

/*16*/"interfaces.ifTable.ifEntry.ifInUnknownProtos.2\0",

/*17*/"interfaces.ifTable.ifEntry.ifOutDiscards.2\0",

/*18*/"interfaces.ifTable.ifEntry.ifOutErrors.2\0",

/*19*/"interfaces.ifTable.ifEntry.ifOutQLen.2\0"

};

/*****end do not touch this session******/

/***********************************

Definicao do objeto a ser buscado

***********************************/

char *maquina="200.250.10.127"

char *comunidade = "public"

/*******MIB and structures initializing; open conection****/

init_mib();

bzero((char *)&session, sizeof(struct snmp_session));

session.peername = maquina;

session.version = SNMP_VERSION_1;

session.community = (u_char *)comunidade;

session.community_len = strlen((char *)comunidade);

session.retries = SNMP_DEFAULT_RETRIES;

session.timeout = SNMP_DEFAULT_TIMEOUT;

session.authenticator = NULL;

while (1){

snmp_synch_setup(&session);

ss = snmp_open(&session);

if (ss == NULL){

printf("Nao conseguiu abrir sessao\n");

return NULL;

}

/****END MIB and structures initializing; and conection is open!****/

/******** BEGIN SAMPLE: just sampling some data at router *********/

for (counter=0;counter<objs_qtd;counter++)

{

name_length = MAX_NAME_LEN;

pdu = snmp_pdu_create(GET_REQ_MSG);

if (!read_objid(objetos[counter], name, &name_length))

{ printf("Objeto inexistente: %s\n", objetos[counter]);

exit(1);

}

snmp_add_null_var(pdu, name, name_length);

/*------get time-----*/

loctime=time(NULL);ptrtime=localtime(&loctime);

sprintf(Xtime[loopcont],"%s",asctime(ptrtime));

/*------time done----*/

status = snmp_synch_response(ss, pdu, &response);

if(status == STAT_SUCCESS)

{ if(response->errstat == SNMP_ERR_NOERROR)

{ vars=response->variables;

sprint_variable(mybuff[counter],vars->name,vars->name_length,vars);

}

else

printf("Erro no pacote: %s\n",snmp_errstring(response->errstat));

}

else

if (status == STAT_TIMEOUT)

printf("Sem resposta - %s\n", maquina);

else /* status == STAT_ERROR */

printf("An error occurred!\n");

if (response)

snmp_free_pdu(response);

}

/*converting strīs to intīs*/

mypstr=(char *)strpbrk(mybuff[2],"=");mypstr+=2;

XifInOctets1[loopcont]=atoi(mypstr);

mypstr=(char *)strpbrk(mybuff[3],"=");mypstr+=2;

XifOutOctets1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[4],"=");mypstr+=2;

XifInDiscards1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[5],"=");mypstr+=2;

XifInErrors1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[6],"=");mypstr+=2;

XifInUnknownProtos1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[7],"=");mypstr+=2;

XifOutDiscards1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[8],"=");mypstr+=2;

XifOutErrors1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[9],"=");mypstr+=2;

XifOutQLen1[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[11],"=");mypstr+=2;

XifInOctets2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[12],"=");mypstr+=2;

XifOutOctets2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[13],"=");mypstr+=2;

XifInDiscards2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[14],"=");mypstr+=2;

XifInErrors2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[15],"=");mypstr+=2;

XifInUnknownProtos2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[16],"=");mypstr+=2;

XifOutDiscards2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[17],"=");mypstr+=2;

XifOutErrors2[loopcont]=atol(mypstr);

mypstr=(char *)strpbrk(mybuff[18],"=");mypstr+=2;

XifOutQLen2[loopcont]=atol(mypstr);

/***** END SAMPLE *****/

snmp_close(ss);

loopcont++;

#ifdef MYDEBUG

/*ETHER*/

printf("-----------------------------\n");

for (i=0;i<loopcont;i++){

printf("ETHER %s" ,Xtime[i]);

printf(" InOct[%d]" ,XifInOctets1[i]);

printf("OutOct[%d]" ,XifOutOctets1[i]);

printf("InDisc[%d]" ,XifInDiscards1[i]);

printf("InErro[%d]" ,XifInErrors1[i]);

printf("InUPro[%d]" ,XifInUnknownProtos1[i]);

printf("OutDis[%d]" ,XifOutDiscards1[i]);

printf("OutErr[%d]\n",XifOutErrors1[i]);

}

/*serial*/

for (i=0;i<loopcont;i++){

printf("SERIAL %s" ,Xtime[i]);

printf(" InOct[%d]" ,XifInOctets2[i]);

printf("OutOct[%d]" ,XifOutOctets2[i]);

printf("InDisc[%d]" ,XifInDiscards2[i]);

printf("InErro[%d]" ,XifInErrors2[i]);

printf("InUPro[%d]" ,XifInUnknownProtos2[i]);

printf("OutDis[%d]" ,XifOutDiscards2[i]);

printf("OutErr[%d]\n",XifOutErrors2[i]);

}

#endif

if (samplecont>0){

/*gravar linhas*/

/*ETHER*/

if ((fp =fopen(ETHERFILE,"a"))==NULL)

{printf("falha abertura arquivo de log ether para amostra\n");exit(1);};

/* calcular ether*/

TR1=(((XifInOctets1[loopcont-1]-XifInOctets1[loopcont-2])+(XifOutOctets1[loopcont-1]-XifOutOctets1[loopcont-2]))*8)/MYTIMETOWAIT;

totINDISC1=totINDISC1+(XifInDiscards1[loopcont-1] - XifInDiscards1[loopcont-2]);

totINERR1 =totINERR1 +(XifInErrors1[loopcont-1] - XifInErrors1[loopcont-2]);

totINUNK1 =totINUNK1 +(XifInUnknownProtos1[loopcont-1]- XifInUnknownProtos1[loopcont-2]);

totOUTDIS1=totOUTDIS1+(XifOutDiscards1[loopcont-1] - XifOutDiscards1[loopcont-2]);

totOUTERR1=totOUTERR1+(XifOutErrors1[loopcont-1] - XifOutErrors1[loopcont-2]);/*totais obtidos*/

M_INDISC1=totINDISC1/(samplecont+1);

M_INERR1=totINERR1 / (samplecont+1);

M_INUNK1=totINUNK1 / (samplecont+1);

M_OUTDIS1=totOUTDIS1/ (samplecont+1);

M_OUTERR1=totOUTERR1/ (samplecont+1);/*medias obtidas*/

/*fim calcular ether*/

/*imprimindo dados obtidos*/

fprintf(fp,"\n%s" ,Xtime[loopcont-1]); /*data e hora da

amostra*/

fprintf(fp,"TR[%f]" ,TR1); /*througtput na

amostra*/

fprintf(fp," InDiscars[%d]" ,XifInDiscards1[loopcont-1]

-XifInDiscards1[loopcont-2]);

fprintf(fp," InErrors[%d] " ,XifInErrors1[loopcont-1]

-XifInErrors1[loopcont-2]);

fprintf(fp," InUnkProt[%d]" ,XifInUnknownProtos1[loopcont-1]

-XifInUnknownProtos1[loopcont-2]);

fprintf(fp,"\nOutDiscar[%d]" ,XifOutDiscards1[loopcont-1]

-XifOutDiscards1[loopcont-2]);

fprintf(fp," OutErrors[%d]" ,XifOutErrors1[loopcont-1]

-XifOutErrors1[loopcont-2]);

fprintf(fp,"\n");

/*fim impressao dados obtidos*/

/*msgs de analise*/

if( (XifInDiscards1[loopcont-1]

-XifInDiscards1[loopcont-2])

>(2*M_INDISC1))

{fprintf(fp,"ifInDiscards superou 2*media \n");

fprintf(fp," causas possiveis:\n");

fprintf(fp," -problemas do software do roteador (baixa)\n");

};

if( (XifInErrors1[loopcont-1]

-XifInErrors1[loopcont-2])

>(2*M_INERR1))

{fprintf(fp,"ifInErrors superou 2*media \n");

fprintf(fp,"causas possiveis:\n");

fprintf(fp," -cabeamento de rede fora de especificacao\n");

fprintf(fp," -repetidor falhando\n");

fprintf(fp," -interface do roteador falhando (baixa)\n");

};

if( (XifInUnknownProtos1[loopcont-1]

-XifInUnknownProtos1[loopcont-2])

>2*M_INUNK1)

fprintf(fp,"ifInUnknownProtos superou 2*media\n");

if( (XifOutDiscards1[loopcont-1]

-XifOutDiscards1[loopcont-2])

>2*M_OUTDIS1)

{fprintf(fp,"ifOutDiscards superou 2*media\n");

fprintf(fp,"causas possiveis: \n");

fprintf(fp," -talvez problema com o software executado pelo roteador\n");

fprintf(fp," -falha do roteador\n");

};

if( (XifOutErrors1[loopcont-1]

-XifOutErrors1[loopcont-2])

>2*M_OUTERR1)

{fprintf(fp,"ifOutErrors superou 2*media\n");

fprintf(fp,"causas possiveis: \n");

fprintf(fp," -problemas de cabeamento fisico \n");

fprintf(fp," -interface de roteadores falhando (baixa)\n");

};

/*fim msg de analise*/

fclose(fp);

/*SERIAL*/

if ((fp =fopen(SERFILE,"a"))==NULL)

{printf("falha abertura arquivo de log ser na amostra\n");exit(1);};

/* calcular serial*/

if((XifInOctets2[loopcont-1]-XifInOctets2[loopcont-2])>(XifOutOctets2[loopcont-1]-XifOutOctets2[loopcont-2]))

{maiordoTR=XifInOctets2[loopcont-1]-XifInOctets2[loopcont-2];}

else

{maiordoTR=XifOutOctets2[loopcont-1]-XifOutOctets2[loopcont-2];};

TR2=(maiordoTR*8)/MYTIMETOWAIT;

totINDISC2=totINDISC2+(XifInDiscards2[loopcont-1] - XifInDiscards2[loopcont-2]);

totINERR2 =totINERR2 +(XifInErrors2[loopcont-1] - XifInErrors2[loopcont-2]);

totINUNK2 =totINUNK2 +(XifInUnknownProtos2[loopcont-1]- XifInUnknownProtos2[loopcont-2]);

totOUTDIS2=totOUTDIS2+(XifOutDiscards2[loopcont-1] - XifOutDiscards2[loopcont-2]);

totOUTERR2=totOUTERR2+(XifOutErrors2[loopcont-1] - XifOutErrors2[loopcont-2]);

M_INDISC2=totINDISC2 / (samplecont+1);

M_INERR2 =totINERR2 / (samplecont+1);

M_INUNK2 =totINUNK2 / (samplecont+1);

M_OUTDIS2=totOUTDIS2 / (samplecont+1);

M_OUTERR2=totOUTERR2 / (samplecont+1);/*medias obtidas*/

/*fim calcular serial*/

/*imprimindo dados obtidos*/

fprintf(fp,"\n%s" ,Xtime[loopcont-1]); /*data e hora da amostra*/

fprintf(fp,"TR[%f]" ,TR2); /*througtput na

amostra*/

fprintf(fp," InDiscars[%d]" ,XifInDiscards2[loopcont-1]

-XifInDiscards2[loopcont-2] );

fprintf(fp," InErrors[%d] " ,XifInErrors2[loopcont-1]

-XifInErrors2[loopcont-2]);

fprintf(fp," InUnkProt[%d]" ,XifInUnknownProtos2[loopcont-1]

-XifInUnknownProtos2[loopcont-2]);

fprintf(fp,"\nOutDiscar[%d]" ,XifOutDiscards2[loopcont-1]

-XifOutDiscards2[loopcont-2]);

fprintf(fp," OutErrors[%d]" ,XifOutErrors2[loopcont-1]

-XifOutErrors2[loopcont-2]);

fprintf(fp,"\n");

/*fim impressao dados obtidos*/

/*msgs de analise*/

if( (XifInDiscards2[loopcont-1]

-XifInDiscards2[loopcont-2])

>(2*M_INDISC2))

fprintf(fp,"ifInDiscards superou 2*media \n");

if( (XifInErrors2[loopcont-1]

-XifInErrors2[loopcont-2])

>(2*M_INERR2))

fprintf(fp,"ifInErrors superou 2*media \n");

if( (XifInUnknownProtos2[loopcont-1]

-XifInUnknownProtos2[loopcont-2])

>(2*M_INUNK2))

fprintf(fp,"ifInUnknownProtos superou 2*media\n");

if( (XifOutDiscards2[loopcont-1]

-XifOutDiscards2[loopcont-2])

>(2*M_OUTDIS2))

fprintf(fp,"ifOutDiscards superou 2*media\n");

if( (XifOutErrors2[loopcont-1]

-XifOutErrors2[loopcont-2])

>(2*M_OUTERR2))

fprintf(fp,"ifOutErrors superou 2*media\n");

/*fim msg de analise*/

fclose(fp);

/*fim gravar linhas*/

};

samplecont++;

if (loopcont>288) loopcont=0;

if (samplecont>1){

/*gerando htmfiles*/

if ((fp=fopen(ETHERFILE,"r"))==NULL)

{printf("falha abertura arquivo de log ether para conversao\n");exit(1);};

if ((fht=fopen(HTMETHER,"w"))==NULL)

{printf("falha abertura arquivo de htm ether\n");exit(1);};

/*faz header*/

fprintf(fht,"<HTML>\n");

fprintf(fht,"<HEAD>\n");

fprintf(fht,"<TITLE>Interface Ethernet</TITLE>\n");

fprintf(fht,"</HEAD>\n");

fprintf(fht,"<BODY>\n");

/*copia log*/

while (!feof(fp)){

fgets (mystraux1, 255, fp);

mystraux1[strlen(mystraux1)-1]=' ';

fprintf(fht,"<DD>%s<BR>\n",mystraux1);

}

/*escreve tail*/

fprintf(fht,"</BODY>\n");

fprintf(fht,"</HTML>\n");

/*fecha arquivos*/

fclose(fp);

fclose(fht);

/*------------------------*/

if ((fp =fopen(SERFILE,"r"))==NULL)

{printf("falha abertura arquivo de log serial para conversao\n");exit(1);};

if ((fht =fopen(HTMSERIAL,"w"))==NULL)

{printf("falha abertura arquivo de log htm serial\n");exit(1);};

/*faz header*/

fprintf(fht,"<HTML>\n");

fprintf(fht,"<HEAD>\n");

fprintf(fht,"<TITLE>Interface Serial</TITLE>\n");

fprintf(fht,"</HEAD>\n");

fprintf(fht,"<BODY>\n");

/*copia log*/

while (!feof(fp)){

fgets(mystraux1,255,fp);

mystraux1[strlen(mystraux1)-1]=' ';

fprintf(fht,"<DD>%s<BR>\n",mystraux1);

}

/*escreve tail*/

fprintf(fht,"</BODY>\n");

fprintf(fht,"</HTML>\n");

/*fecha arquivos*/

fclose(fp);

fclose(fht);

/*fim gerando htmfiles*/

parasleep=sleep(MYTIMETOWAIT);

};

};/*while*/

}

}