/*
*------------------------------------------------------------------------
* clkinit - initialize the clock and sleep queue (called at startup)
*------------------------------------------------------------------------
*/
int
clkinit(void)
{
int clkint();
set_evec(IRQBASE, clkint);
clkruns = 1;
clockq = newqueue();
preempt = QUANTUM; /* initial time quantum */
compute_delay();
/* set to: timer 0, 16-bit counter, rate generator mode,
counter is binary */
outb(CLKCNTL, 0x34);
/* must write LSB first, then MSB */
outb(CLOCK0, (char)DIVIDER);
outb(CLOCK0, DIVIDER>>8);
return OK;
}
/**
* @brief Gestisce la lettura dei pacchetti UDP provenienti dal Monitor.
* @return void.
*/
void lettura_pkt_monitor(void)
{
uint32_t buf[ (65536/sizeof(uint32_t)) ];
struct sockaddr_in From;
unsigned int Fromlen;
int ris;
memset(&From,0,sizeof(From));
Fromlen=sizeof(struct sockaddr_in);
ris = recvfrom ( monitordatafd, (char*)buf, (int)65536, 0, (struct sockaddr*)&From, &Fromlen);
if (ris<0)
{
if(errno!=EINTR)
{
fprintf(stderr,"recvfrom() failed, Error: %d \"%s\"\n", errno,strerror(errno));
fprintf(stderr,"ma non ho chiuso il socket");
}
}
else
{
int ris2;
long int msecdelay;
uint32_t idletto;
uint16_t portfromfixed;
/* Salva la porta da cui arrivano i pacchetti del Fixed */
portfromfixed = ntohs(From.sin_port);
/* Se legge un ping calcola il suo delay e lo imposta 0 come id */
if(ris == SIZE_PING)
{
idletto=0;
msecdelay=compute_delay_ping(buf);
}
/* Altrimenti lo gestisce come un normale pacchetto */
else
{
idletto=buf[0];
msecdelay=compute_delay(buf);
}
/* Se sono pacchetti normali e non ping, li inoltra all'applicazione */
if(ris != SIZE_PING)
{
ris2=Sendn(appmobilefd,(char*)buf,ris);
if(ris2!=ris) { fprintf(stderr,"recv from appmobile failed, received %d: ", ris); exit(9); }
}
/* Se arriva un pacchetto in ritardo e la porta da cui arriva è la stessa da cui invia, la cambia perché LENTA */
if((msecdelay > PKT_IN_TIME) && (portfromfixed == cfgPorte[index]))
{
index=(index+1)%numporte;
}
/* Altrimenti se arriva un pacchetto in orario su una porta differente, si sincronizza su quella porta */
else if((msecdelay <= PKT_IN_TIME) && (portfromfixed != cfgPorte[index]))
{
index=trova_porta(portfromfixed, cfgPorte, index, numporte);
}
}
}
int main(int argc, char *argv[])
{
uint16_t portLBfixed;
int ris, LBfixedfd;
pthread_t th;
int primoricevuto=0;
int tipogenerazionepkt;
if(argc==1) {
printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
portLBfixed = 11001;
tipogenerazionepkt=2;
}
else if(argc!=3) { printf ("necessari 2 parametri\n"); usage(); exit(1); }
else { /* leggo parametri da linea di comando */
portLBfixed = atoi(argv[1]);
tipogenerazionepkt=atoi(argv[2]);
}
if ((signal (SIGHUP, sig_close)) == SIG_ERR) { perror("signal (SIGHUP) failed: "); EExit(2); }
if ((signal (SIGINT, sig_close)) == SIG_ERR) { perror("signal (SIGINT) failed: "); EExit(2); }
if ((signal (SIGTERM, sig_close)) == SIG_ERR) { perror("signal (SIGTERM) failed: "); EExit(2); }
init_random();
ris=socketpair(AF_UNIX,SOCK_STREAM,0,fds);
if (ris < 0) { perror("socketpair fds0 failed: "); EExit(1); }
/*
ris=SetsockoptTCPNODELAY(fds[0],1); if (!ris) EExit(5);
ris=SetsockoptTCPNODELAY(fds[1],1); if (!ris) EExit(5);
*/
/* mi connetto al LBfixed */
ris=TCP_setup_connection(&LBfixedfd, "127.0.0.1", portLBfixed, 300000, 300000, 1);
if(!ris) { printf ("TCP_setup_connection() failed\n"); EExit(1); }
f=fopen("delayfixed.txt","wt");
if(f==NULL) { perror("fopen failed"); EExit(1); }
/* inizializzo il sistema di controllo dei pkt ricevuti e/o duplicati */
init_checkrecvFixed();
init_checkrecvFixedDelay();
FD_ZERO(&all);
FD_SET(LBfixedfd,&all);
maxfd=LBfixedfd;
FD_SET(fds[0],&all);
if(maxfd<fds[0]) maxfd=fds[0];
for(;;)
{
struct timeval timeout;
long int msecdelay;
do {
rdset=all;
timeout.tv_sec=10;
timeout.tv_usec=0;
ris=select(maxfd+1,&rdset,NULL,NULL,&timeout);
/* ris=select(maxfd+1,&rdset,NULL,NULL,&timeout); */
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
EExit(1);
}
/* se arriva qualcosa dalla connessione TCP con LBfixed, leggo!!!! */
if( FD_ISSET(LBfixedfd,&rdset) )
{
uint32_t buf[PKTSIZE], idletto; int ris;
#ifdef VICDEBUG
fprintf(stderr,"in arrivo qualcosa dalla connessione TCP del LBfixed:\n");
#endif
/* ris=recv(LBfixedfd,(char*)buf,PKTSIZE,MSG_DONTWAIT); */
/* ris=Readn(LBfixedfd,(char*)buf,PKTSIZE); */
ris=Readn(LBfixedfd,(char*)buf,sizeof(buf));
/*if(ris!=PKTSIZE) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }*/
if(ris!=sizeof(buf)) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }
idletto=buf[0];
/* printf("ricevuto pkt id %u\n",idletto); */
msecdelay=compute_delay(buf);
if( check_pkt_recv_at_Fixed(idletto) == 1 ) /* pacchetto duplicato */
{
printf("ricevuto pkt duplicato id %d delay %ld msec \n",idletto, msecdelay);
numduplicati++;
}
else
{
/* memorizzo di avere ricevuto il pkt */
set_pkt_recv_at_Fixed(idletto);
SetpktrecvFixedDelay(idletto,msecdelay);
#ifdef OUTPUT_MEDIO
printf("ricevuto pkt id %lu delay %ld msec \n",idletto, msecdelay);
#endif
if(primoricevuto==0) {
pkt_generator_parameters params;
primoricevuto=1;
idlastrecv=idletto;
/* faccio partire il pthread pkt_generator per attivare la generazione di pacchetti */
params.tipogenerazionepkt=tipogenerazionepkt;
params.fd=fds[1];
ris = pthread_create (&th, NULL, pkt_generator, (void*)¶ms );
if (ris){
printf("ERROR; return code from pthread_create() is %d\n",ris);
EExit(-1);
}
}
else if(idletto>idlastrecv) {
idlastrecv=idletto;
}
if(msecdelay>150) {
numritardi++;
printf("%d : delay msec %ld TEMPO SUPERATO\n", idletto, msecdelay);
}
else {
numok++;
printf("%d : delay msec %ld\n", idletto, msecdelay);
}
/* save_delay(f,buf); */
}
}
else
{
if( FD_ISSET(fds[0],&rdset) )
{
char ch;
/* IL BUG E' QUI: E' STATO USATO UN VETTORE DI UINT32 PER CREARE IL PACCHETTO QUANDO SI SAREBBE DOVUTO USARE UN */
/* VETTORE DI CARATTERI (char buf[PKTSIZE]) DATO CHE : */
/* sizeof(buf) = 400 , con uint32_t buf[PKTSIZE] */
/* sizeof(buf) = 100 , con char buf[PKTSIZE] */
/* ERGO LA RICEZIONE E L'INVIO DEI PACCHETTI VA FATTA CON 400 DI DIMENSIONE E NON PKTSIZE, CIOÈ 100 */
uint32_t buf[PKTSIZE];
struct timeval sent;
do {
ris=recv(fds[0],&ch,1,0);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("Appfixed - recv from scheduler failed: ");
sleep(1);
EExit(1);
}
/* spedisco i pkt */
/*memset((char*)buf,0,PKTSIZE);*/
memset((char*)buf,0,sizeof(buf));
buf[0]=idmsg;
gettimeofday(&sent,NULL);
memcpy( (char*)&(buf[1]), (char*)&sent, sizeof(struct timeval) );
/*
fprintf(stderr,"pkt %u sent %ld sec %ld usec\n", idmsg, sent.tv_sec, sent.tv_usec );
*/
/*ris=Sendn(LBfixedfd, (char*)buf, PKTSIZE );*/
ris=Sendn(LBfixedfd, (char*)buf, sizeof(buf) );
/*if(ris!=PKTSIZE) {*/
if(ris!=sizeof(buf)) {
fprintf(stderr,"Appfixed - Sendn failed ris %d TERMINO\n", ris);
sleep(1);
EExit(1);
}
#ifdef OUTPUT_MEDIO
fprintf(stderr,"pkt %u sent %dB\n", idmsg, ris);
#endif
idmsg++;
}
}
} /* fine for ;; */
return(0);
}
void compute_estimation(aodv_neigh *tmp_neigh) {
int recv_delay;
//Nominal rate computation
//Add last own transmission delay measured by our neighbour
tmp_neigh->ett.count_rcv++;
if (tmp_neigh->ett.count_rcv == tmp_neigh->ett.ett_window) { //Let's compute the estimation!
recv_delay = compute_delay(tmp_neigh);
if (recv_delay == 0 && tmp_neigh->ett.ett_window == ETT_PROBES_MAX) {
if (tmp_neigh->ett.reset) { //Second consectutive round without an estimation!
#ifdef DEBUG
printk(
"Capacity Estimation with %s is not possible - Second: Resetting\n",
inet_ntoa(tmp_neigh->ip));
#endif
reset_ett(tmp_neigh);
} else { //First round without an estimation!
#ifdef DEBUG
printk(
"Capacity Estimation with %s is not possible - First: Using last measured values\n",
inet_ntoa(tmp_neigh->ip));
#endif
//lets start a new measurements round
delay_vector_init(&(tmp_neigh->ett.recv_delays[0]));
tmp_neigh->ett.count_rcv = 0;
tmp_neigh->ett.ett_window = ETT_PROBES_MIN;
tmp_neigh->ett.reset = 1;
}
send_ett_info(tmp_neigh, tmp_neigh->send_rate, FALSE);
return;
}
if (recv_delay == 0) {
//Increase the size of the estimation window
tmp_neigh->ett.ett_window += 2; //lets do two more measurements
if (tmp_neigh->ett.ett_window > ETT_PROBES_MAX)
tmp_neigh->ett.ett_window=ETT_PROBES_MAX;
return;
}
if (recv_delay == DEFAULT_ETT_METRIC) {
#ifdef DEBUG
printk(
"%s does not receive my ETT_PROBES: Capacity Estimation is not possible - Resetting ETT...\n",
inet_ntoa(tmp_neigh->ip));
#endif
reset_ett(tmp_neigh);
return;
}
//lets start a new measurement round
delay_vector_init(&(tmp_neigh->ett.recv_delays[0]));
tmp_neigh->ett.count_rcv = 0;
tmp_neigh->ett.ett_window = ETT_PROBES_MIN;
tmp_neigh->ett.reset = 0;
tmp_neigh->send_rate = compute_rate(recv_delay);
send_ett_info(tmp_neigh, tmp_neigh->send_rate, FALSE);
}
}
