R
romarioo
Guest
por favor eu preciso o código para envio e recebimento de protocolo de transporte
Eu preciso escrever a 7 sub-rotinas e sou realmente a tentar encontrar qualquer informação sobre como fazer isso ...Por favor, sua ajuda é highlly apreciá-lo: '(# include
# include
/ * ************************************************ ******************
Alternating Bit e GO-BACK-N Network emulador: VERSÃO 1,1 JFKurose
Este código deve ser usado para PA2, unidirecional ou bidirecional
protocolos de transferência de dados (de A a transferência de dados bidirecional B.
é de crédito suplementar e não é necessário).Propriedades de rede:
- Um atraso de rede modo médias cinco unidades de tempo (já não se
são outras mensagens no canal para GBN), mas pode ser maior
- Os pacotes podem ser corrompido (cabeçalho ou a porção de dados)
ou perdidos, de acordo com o definido pelo usuário probabilidades
- Pacotes serão entregues na ordem em que foram enviados
(embora alguns podem ser perdidos).
************************************************** ********************/
# define BIDIRECTIONAL 0 / * Altere para 1 se você estiver fazendo o crédito extra * /
/ * E escrever um B_output rotina chamada * /
/ * Uma msg "é a unidade de dados passados da camada 5 (código de professores) para a camada * /
/ * 4 (código de alunos).Ele contém os dados (caracteres) para ser entregue * /
/ * Camada de 5 alunos por meio do transporte entidades protocolo de nível.* /
struct (msg
char data [20];
);
/ * Um pacote é a unidade de dados passados da camada 4 (código estudantes) para a camada * /
/ * 3 (código de professores).Observe a estrutura pré-definida de pacotes, que todos os * /
/ * Os alunos devem seguir.* /
pkt struct (
seqnum int;
acknum int;
int quantidade;
char payload [20];
);
ESTUDANTES /********* WRITE os próximos sete ROTINAS *********// * Chamada da camada 5, passou os dados a serem enviados para outro * /
A_output (mensagem)
struct message msg;
(
)
B_output (message) / * só deve ser preenchida para o crédito extra * /
struct message msg;
(
/ * do nothing * /
)
/ * Chamada de camada 3, quando chega um pacote para a camada 4 * /
A_input pacotes ()
struct packet pkt;
(
/ * Timer stop * /
stoptimer (0);
/ * Verificar se o ACK é ok * /
/ * verificar se o ACK não enviar nenhum == * /
/ * Se não se ressentir último pacote * /
/ * Se sim seq_no incremento e saída * /)
/ * Chamado quando um temporizador vai desligar * /
A_timerinterrupt ()
(
)
/ * A seguinte rotina será chamado uma vez (apenas) antes de qualquer outra * /
/ * A entidade rotinas são chamados.Você pode usá-lo para fazer qualquer inicialização * /
A_init ()
(
)/ * Observe que a simples transferência de um-para-B, não há B_output () * /
/ * Chamada de camada 3, quando chega um pacote para a camada 4 em B * /
B_input pacotes ()
struct packet pkt;
(
)
/ * Chamada quando o temporizador vai desligar B * /
B_timerinterrupt ()
(
)
/ * O rouytine seguinte será chamado uma vez (apenas) antes de qualquer outra * /
/ Rotinas B * entidade são chamados.Você pode usá-lo para fazer qualquer inicialização * /
B_init ()
(
)/************************************************* ****************
***************** REDE emulação do código inicia abaixo ***********
O código abaixo simula a camada de 3 e abaixo de ambiente de rede:
- Emula a transmissão e distribuição (possivelmente com pouco nível de corrupção
e perda de pacotes) de pacotes através da camada de 3 / 4 de interface
- Manipula o início / parada de um timer, e gera timer
interrupções (resultando em chamar os alunos manipulador temporizador).
- Gera mensagem a ser enviada (mais tarde passou de 5 a 4)
NÃO HÁ RAZÃO de que os estudantes devem ter de ler ou compreender
O código abaixo.VOCÊ NÃO shold toque, ou de referência (em seu código) QUALQUER
DAS ESTRUTURAS DE DADOS ABAIXO.Se você está interessado em saber como eu projetei
o emulador, você está livre para olhar o código - mas, novamente, você deve ter
, e você defeinitely não deve ter que modificar
************************************************** ****************/
struct evento (
float EVtime / * hora do evento * /
evType int / * código do tipo de evento * /
eventividade int / * entidade onde ocorre evento * /
struct pkt pktptr * / * ptr para pacote (se houver) w assoc / evento * /
struct evento * prev;
struct evento * next;
);
struct evento * evlist = NULL; / * lista de eventos * /
/ * Eventos possíveis: * /
# define TIMER_INTERRUPT 0
# define FROM_LAYER5 1
# define FROM_LAYER3 2
# define OFF 0
# define ON 1
# define A 0
# define B 1TRACE = 1; / * para a minha depuração * /
nsim = 0; / * número de mensagens 5-4 até agora * /
nsimmax = 0; / * número de msgs para gerar, em seguida, pare * /
float tempo = 0,000;
float lossprob / * probabilidade de que um pacote é descartado * /
float corruptprob / * probabilidade de que um bit é pacote é invertida * /
float lambda; / * taxa de chegada de mensagens da camada 5 * /
int ntolayer3; / * número enviado para a camada 3 * /
nlost int / * número perdido na mídia * /
int ncorrupt; / * número corrompido pelos meios de comunicação * /
main ()
(
struct evento * eventptr;
struct msg msg2give;
struct pkt2give pkt;
int i, j;
char c;
init ();
A_init ();
B_init ();
while (1) (
evlist eventptr = / * get próximo evento para simular * /
if (eventptr == NULL)
goto terminar;
evlist evlist => próximo; / * Remover este evento da lista de eventos * /
if (evlist! = NULL)
evlist-> prev = NULL;
if (trace> = 2) (
printf ( "time \ nEVENT:% f", eventptr-EVtime>);
printf ( "tipo:% d", eventptr-> evType);
if (eventptr-> evType == 0)
printf ( ", timerinterrupt");
else if (eventptr-> evType == 1)
printf ( ", fromlayer5");
diferente
printf ( ", fromlayer3");
printf ( "entidade:% d \ n", eventptr-> eventividade);
)
= tempo eventptr-> EVtime / * tempo de atualização para o evento da próxima vez * /
if (nsim == nsimmax)
break; / * tudo feito com simulação * /
if (eventptr-> evType == FROM_LAYER5) (
generate_next_arrival (); / * criação futura chegada * /
/ * Preencher msg a dar com a seqüência de mesma letra * /
j% nsim = 26;
for (i = 0; i <20; i )
msg2give.data = 97 j;
if (trace> 2) (
printf ( "MainLoop: dados fornecidos ao aluno:");
for (i = 0; i <20; i )
printf ( "% c", msg2give.data );
printf ( "\ n");
)
nsim ;
if (eventptr-> eventividade == A)
A_output (msg2give);
diferente
B_output (msg2give);
)
else if (eventptr-> evType == FROM_LAYER3) (
pkt2give.seqnum = eventptr-> pktptr-seqnum>;
pkt2give.acknum = eventptr-> pktptr-acknum>;
pkt2give.checksum = eventptr-> pktptr-checksum>;
for (i = 0; i <20; i )
pkt2give.payload = eventptr-> pktptr-> carga ;
if (eventptr-> eventividade == A) / * entregar pacotes chamando * /
A_input pkt2give (); / * entidade adequada * /
diferente
B_input pkt2give ();
livre (eventptr-> pktptr); / * de memória livre para o pacote * /
)
else if (eventptr-> evType == TIMER_INTERRUPT) (
if (eventptr-> eventividade == A)
A_timerinterrupt ();
diferente
B_timerinterrupt ();
)
else (
printf ( "INTERNO PANIC: tipo de evento desconhecido \ n");
)
eventptr (livre);
)
terminar:
printf ( "Simulator denunciado em tempo% f \ n% d após o envio de msgs layer5 \ n", tempo, nsim);
)init () / * inicializar o simulador * /
(
int i;
float soma, AVG;
jimsrand float ();printf ("----- Stop and Wait Network Simulator Version 1.1 -------- \ n \ n ");
printf ( "Digite o número de mensagens para simular:");
scanf ( "% d", & nsimmax);
printf ( "Enter a probabilidade de perda de pacotes [enter 0,0 por nenhuma perda ]:");
scanf ( "% f", & lossprob);
printf ( "Enter a probabilidade de corrupção de pacotes [0,0 por nenhuma corrupção ]:");
scanf ( "% f", & corruptprob);
printf ( "Digite o tempo médio entre mensagens do remetente layer5 [> 0,0 ]:");
scanf ( "% f", & lambda);
printf ( "TRACE");
scanf ( "% d", & Trace);
srand (9999) / * init gerador de números aleatórios * /
sum = 0,0; / * teste de gerador de números aleatórios para os alunos * /
for (i = 0; i <1000; i )
soma = soma jimsrand (); / * jimsrand () deve ser uniforme em [0,1] * /
avg = sum/1000.0;
if (avg <0,25 | | avg> 0,75) (
printf ( "É provável que a geração de números aleatórios em sua máquina \ n");
printf ( "é diferente do que este emulador espera. Por favor, \ n");
printf ( "Um olhar sobre a rotina jimsrand () no código do emulador. Desculpe. \ n");
exit (0);
)
ntolayer3 = 0;
nlost = 0;
ncorrupt = 0;
tempo = 0,0; / * inicializar o tempo para 0,0 * /
generate_next_arrival (); / * inicializar lista de eventos * /
)
/************************************************* ***************************/
/ * Jimsrand (): return a flutuar no intervalo [0,1].A rotina abaixo é usado para * /
/ * Isolar toda a geração de números aleatórios em um local.Assumimos que o * /
/ * Fornecidos pelo sistema rand () função retornar um int em therange [0, mmm] * /
/************************************************* ***************************/
jimsrand float ()
(
mmm dupla = (double RAND_MAX); / / 2147483647 / * maior int - dependente da máquina !!!!!!!!* /
float x; / * cada aluno pode precisar de mudar mmm * /
x = rand () mmm / / * x deve ser uniforme em [0,1] * /
return (x);
)
/********************* EVENTO handline ROTINAS *******/
/ * O próximo conjunto de rotinas de manipular a lista de eventos * /
/************************************************* ****/
generate_next_arrival ()
(
double x, log (), ceil ();
struct evento * evptr;
/ / Char * malloc ();
float ttime;
TempInt int;
if (trace> 2)
printf ( "Gerar PRÓXIMA CHEGADA: a criação de nova chegada \ n");
x = lambda jimsrand * () * 2 / * x é uniforme em [0,2 * lambda] * /
/ * Com média de lambda * /
evptr = (struct evento *) malloc (sizeof (struct evento));
evptr-> EVtime = tempo x;
evptr-> evType = FROM_LAYER5;
if (BIDIRECTIONAL & & (jimsrand ()> 0,5))
evptr-> eventividade = B;
diferente
evptr-> eventividade = A;
insertEvent (evptr);
)insertEvent (p)
struct evento * p;
(
struct evento * q, * qold;
if (trace> 2) (
printf ( "insertEvent: o tempo é% lf \ n", tempo);
printf ( "insertEvent: tempo futuro será% lf \ n", p-> EVtime);
)
evlist q = / * q aponta para cabeçalho da lista em que p struct inserido * /
if (q == NULL) (/ * lista está vazia * /
evlist = p;
p-> next = NULL;
p-> prev = NULL;
)
else (
for (qold = q; q! = NULL & & p-> EVtime> q-EVtime>; q = q-> next)
qold = q;
if (q == NULL) (/ * fim da lista * /
qold-> next = p;
p-> prev = qold;
p-> next = NULL;
)
else if (q == evlist) (/ * frente da lista * /
p-> evlist = next;
p-> prev = NULL;
p-> next-> prev = p;
evlist = p;
)
else (/ * meio da lista * /
p-> next = q;
p-> anterior = q-> prev;
q-> prev-> next = p;
q-> prev = p;
)
)
)
printevlist ()
(
struct evento * q;
int i;
printf ("-------------- \ nEvent Segue a lista: \ n ");
for (q = evlist; q! = NULL; q = q-> next) (
printf (tempo de evento ":% m, tipo: ENTITY% d:% d \ n", q-> EVtime, q-> evType, q-> eventividade);
)
printf ("-------------- \ n ");
)/********************** Student-rotinas pode ser chamado *********************** /
/ * Chamada pelos alunos de rotina para cancelar uma anteriormente iniciados timer * /
stoptimer (ÄoRb)
ÄoRb int / * A ou B está tentando parar timer * /
(
struct evento * q, * qold;
if (trace> 2)
printf ( "Stop Timer: cronômetro parando em% f \ n", time);
/ * For (q = evlist; q! = NULL & & q-> next! = NULL; q = q-> next) * /
for (q = evlist; q! = NULL; q = q-> next)
if ((q-> evType == TIMER_INTERRUPT & & q-> eventividade ÄoRb ==)) (
/ * Remover este evento * /
if (q-> next == NULL & & q-> prev == NULL)
evlist = NULL; / * remove o primeiro evento, e apenas na lista * /
else if (q-> next == NULL) / * Fim da lista - há uma em frente * /
q-> prev-> next = NULL;
else if (q == evlist) (/ * frente da lista - deve haver evento depois * /
q-> next-> prev = NULL;
evlist = q-> next;
)
else (/ * meio da lista * /
q-> next-> prev = q-> prev;
q-> prev-> next = q-> next;
)
free (q);
return;
)
printf ( "Atenção: Não é possível cancelar o timer. Ele não estava funcionando. \ n");
)startTimer (ÄoRb, incremento)
ÄoRb int / * A ou B está tentando parar timer * /
float incremento;
(
struct evento * q;
struct evento * evptr;
/ / Char * malloc ();
if (trace> 2)
printf ( "Start Timer: Timer a partir de% f \ n", time);
/ * Be nice: verificar se temporizador é iniciado, se assim for, então avisar * /
/ * For (q = evlist; q! = NULL & & q-> next! = NULL; q = q-> next) * /
for (q = evlist; q! = NULL; q = q-> next)
if ((q-> evType == TIMER_INTERRUPT & & q-> eventividade ÄoRb ==)) (
printf ( "Atenção: tentativa de iniciar um temporizador que já foi iniciado \ n");
return;
)
/ * Criar eventos futuros para quando se apaga timer * /
evptr = (struct evento *) malloc (sizeof (struct evento));
evptr-> EVtime tempo = incremento;
evptr-> evType = TIMER_INTERRUPT;
evptr-> eventividade = ÄoRb;
insertEvent (evptr);
)/************************** TOLAYER3 ***************/
tolayer3 (ÄoRb, pacotes)
ÄoRb int / * A ou B está tentando parar timer * /
struct packet pkt;
(
struct pkt * mypktptr;
evptr struct evento *, * q;
/ / Char * malloc ();
float lastime, x, jimsrand ();
int i;ntolayer3 ;
/ * Simular perdas: * /
if (jimsrand () <lossprob) (
nlost ;
if (trace> 0)
printf (TOLAYER3 ": pacote que está sendo perdido \ n");
return;
)
/ * Faça uma cópia do estudante pacote só me deu desde que ele / ela pode decidir * /
/ * Para fazer alguma coisa com o pacote depois de retornar a ele * /
mypktptr = (struct pkt *) malloc (sizeof (pkt));
mypktptr-> seqnum = packet.seqnum;
mypktptr-> acknum = packet.acknum;
mypktptr-> checksum = packet.checksum;
for (i = 0; i <20; i )
mypktptr-> carga = packet.payload ;
if (trace> 2) (
printf (TOLAYER3 ": seq:% d,% d ack, confira:% d", mypktptr-seqnum>,
mypktptr-> acknum, mypktptr-> checksum);
for (i = 0; i <20; i )
printf ( "% c", mypktptr-> carga );
printf ( "\ n");
)
/ * Criar eventos futuros para a chegada dos pacotes no outro lado * /
evptr = (struct evento *) malloc (sizeof (struct evento));
evptr-> evType = FROM_LAYER3 / * pacote vai sair de layer3 * /
evptr-> eventividade = (ÄoRb 1)% 2; / * evento ocorre em outras entidades * /
evptr-> pktptr = mypktptr / * ptr para salvar a minha cópia do pacote * /
/ * Finalmente, calcular o tempo de chegada do pacote na outra extremidade.
médio não pode reordenar, por isso, certifique pacote chega entre 1 e 10
unidades de tempo após o último horário de pacotes
No momento, o meio em seu caminho para o destino * /
tempo lastime =;
/ * For (q = evlist; q! = NULL & & q-> next! = NULL; q = q-> next) * /
for (q = evlist; q! = NULL; q = q-> next)
if ((q-> evType == FROM_LAYER3 & & q-> eventividade == evptr-> eventividade))
lastime = q-> EVtime;
evptr-> EVtime = lastime 1 9 * jimsrand ();/ * Simular a corrupção: * /
if (jimsrand () <corruptprob) (
ncorrupt ;
if ((x jimsrand = ()) <.75)
mypktptr-> payload [0] = 'Z'; / * payload corrupto * /
else if (x <.875)
mypktptr-> seqnum = 999999;
diferente
mypktptr-> acknum = 999999;
if (trace> 0)
printf (TOLAYER3 ": pacote ser corrompido \ n");
)
if (trace> 2)
printf (TOLAYER3 ": programação de chegada do outro lado \ n");
insertEvent (evptr);
)
tolayer5 (ÄoRb, datasent)
ÄoRb int;
datasent char [20];
(
int i;
if (trace> 2) (
printf ( "TOLAYER5: dados recebidos:");
for (i = 0; i <20; i )
printf ( "% c", datasent );
printf ( "\ n");
)
)
Eu preciso escrever a 7 sub-rotinas e sou realmente a tentar encontrar qualquer informação sobre como fazer isso ...Por favor, sua ajuda é highlly apreciá-lo: '(# include
# include
/ * ************************************************ ******************
Alternating Bit e GO-BACK-N Network emulador: VERSÃO 1,1 JFKurose
Este código deve ser usado para PA2, unidirecional ou bidirecional
protocolos de transferência de dados (de A a transferência de dados bidirecional B.
é de crédito suplementar e não é necessário).Propriedades de rede:
- Um atraso de rede modo médias cinco unidades de tempo (já não se
são outras mensagens no canal para GBN), mas pode ser maior
- Os pacotes podem ser corrompido (cabeçalho ou a porção de dados)
ou perdidos, de acordo com o definido pelo usuário probabilidades
- Pacotes serão entregues na ordem em que foram enviados
(embora alguns podem ser perdidos).
************************************************** ********************/
# define BIDIRECTIONAL 0 / * Altere para 1 se você estiver fazendo o crédito extra * /
/ * E escrever um B_output rotina chamada * /
/ * Uma msg "é a unidade de dados passados da camada 5 (código de professores) para a camada * /
/ * 4 (código de alunos).Ele contém os dados (caracteres) para ser entregue * /
/ * Camada de 5 alunos por meio do transporte entidades protocolo de nível.* /
struct (msg
char data [20];
);
/ * Um pacote é a unidade de dados passados da camada 4 (código estudantes) para a camada * /
/ * 3 (código de professores).Observe a estrutura pré-definida de pacotes, que todos os * /
/ * Os alunos devem seguir.* /
pkt struct (
seqnum int;
acknum int;
int quantidade;
char payload [20];
);
ESTUDANTES /********* WRITE os próximos sete ROTINAS *********// * Chamada da camada 5, passou os dados a serem enviados para outro * /
A_output (mensagem)
struct message msg;
(
)
B_output (message) / * só deve ser preenchida para o crédito extra * /
struct message msg;
(
/ * do nothing * /
)
/ * Chamada de camada 3, quando chega um pacote para a camada 4 * /
A_input pacotes ()
struct packet pkt;
(
/ * Timer stop * /
stoptimer (0);
/ * Verificar se o ACK é ok * /
/ * verificar se o ACK não enviar nenhum == * /
/ * Se não se ressentir último pacote * /
/ * Se sim seq_no incremento e saída * /)
/ * Chamado quando um temporizador vai desligar * /
A_timerinterrupt ()
(
)
/ * A seguinte rotina será chamado uma vez (apenas) antes de qualquer outra * /
/ * A entidade rotinas são chamados.Você pode usá-lo para fazer qualquer inicialização * /
A_init ()
(
)/ * Observe que a simples transferência de um-para-B, não há B_output () * /
/ * Chamada de camada 3, quando chega um pacote para a camada 4 em B * /
B_input pacotes ()
struct packet pkt;
(
)
/ * Chamada quando o temporizador vai desligar B * /
B_timerinterrupt ()
(
)
/ * O rouytine seguinte será chamado uma vez (apenas) antes de qualquer outra * /
/ Rotinas B * entidade são chamados.Você pode usá-lo para fazer qualquer inicialização * /
B_init ()
(
)/************************************************* ****************
***************** REDE emulação do código inicia abaixo ***********
O código abaixo simula a camada de 3 e abaixo de ambiente de rede:
- Emula a transmissão e distribuição (possivelmente com pouco nível de corrupção
e perda de pacotes) de pacotes através da camada de 3 / 4 de interface
- Manipula o início / parada de um timer, e gera timer
interrupções (resultando em chamar os alunos manipulador temporizador).
- Gera mensagem a ser enviada (mais tarde passou de 5 a 4)
NÃO HÁ RAZÃO de que os estudantes devem ter de ler ou compreender
O código abaixo.VOCÊ NÃO shold toque, ou de referência (em seu código) QUALQUER
DAS ESTRUTURAS DE DADOS ABAIXO.Se você está interessado em saber como eu projetei
o emulador, você está livre para olhar o código - mas, novamente, você deve ter
, e você defeinitely não deve ter que modificar
************************************************** ****************/
struct evento (
float EVtime / * hora do evento * /
evType int / * código do tipo de evento * /
eventividade int / * entidade onde ocorre evento * /
struct pkt pktptr * / * ptr para pacote (se houver) w assoc / evento * /
struct evento * prev;
struct evento * next;
);
struct evento * evlist = NULL; / * lista de eventos * /
/ * Eventos possíveis: * /
# define TIMER_INTERRUPT 0
# define FROM_LAYER5 1
# define FROM_LAYER3 2
# define OFF 0
# define ON 1
# define A 0
# define B 1TRACE = 1; / * para a minha depuração * /
nsim = 0; / * número de mensagens 5-4 até agora * /
nsimmax = 0; / * número de msgs para gerar, em seguida, pare * /
float tempo = 0,000;
float lossprob / * probabilidade de que um pacote é descartado * /
float corruptprob / * probabilidade de que um bit é pacote é invertida * /
float lambda; / * taxa de chegada de mensagens da camada 5 * /
int ntolayer3; / * número enviado para a camada 3 * /
nlost int / * número perdido na mídia * /
int ncorrupt; / * número corrompido pelos meios de comunicação * /
main ()
(
struct evento * eventptr;
struct msg msg2give;
struct pkt2give pkt;
int i, j;
char c;
init ();
A_init ();
B_init ();
while (1) (
evlist eventptr = / * get próximo evento para simular * /
if (eventptr == NULL)
goto terminar;
evlist evlist => próximo; / * Remover este evento da lista de eventos * /
if (evlist! = NULL)
evlist-> prev = NULL;
if (trace> = 2) (
printf ( "time \ nEVENT:% f", eventptr-EVtime>);
printf ( "tipo:% d", eventptr-> evType);
if (eventptr-> evType == 0)
printf ( ", timerinterrupt");
else if (eventptr-> evType == 1)
printf ( ", fromlayer5");
diferente
printf ( ", fromlayer3");
printf ( "entidade:% d \ n", eventptr-> eventividade);
)
= tempo eventptr-> EVtime / * tempo de atualização para o evento da próxima vez * /
if (nsim == nsimmax)
break; / * tudo feito com simulação * /
if (eventptr-> evType == FROM_LAYER5) (
generate_next_arrival (); / * criação futura chegada * /
/ * Preencher msg a dar com a seqüência de mesma letra * /
j% nsim = 26;
for (i = 0; i <20; i )
msg2give.data = 97 j;
if (trace> 2) (
printf ( "MainLoop: dados fornecidos ao aluno:");
for (i = 0; i <20; i )
printf ( "% c", msg2give.data );
printf ( "\ n");
)
nsim ;
if (eventptr-> eventividade == A)
A_output (msg2give);
diferente
B_output (msg2give);
)
else if (eventptr-> evType == FROM_LAYER3) (
pkt2give.seqnum = eventptr-> pktptr-seqnum>;
pkt2give.acknum = eventptr-> pktptr-acknum>;
pkt2give.checksum = eventptr-> pktptr-checksum>;
for (i = 0; i <20; i )
pkt2give.payload = eventptr-> pktptr-> carga ;
if (eventptr-> eventividade == A) / * entregar pacotes chamando * /
A_input pkt2give (); / * entidade adequada * /
diferente
B_input pkt2give ();
livre (eventptr-> pktptr); / * de memória livre para o pacote * /
)
else if (eventptr-> evType == TIMER_INTERRUPT) (
if (eventptr-> eventividade == A)
A_timerinterrupt ();
diferente
B_timerinterrupt ();
)
else (
printf ( "INTERNO PANIC: tipo de evento desconhecido \ n");
)
eventptr (livre);
)
terminar:
printf ( "Simulator denunciado em tempo% f \ n% d após o envio de msgs layer5 \ n", tempo, nsim);
)init () / * inicializar o simulador * /
(
int i;
float soma, AVG;
jimsrand float ();printf ("----- Stop and Wait Network Simulator Version 1.1 -------- \ n \ n ");
printf ( "Digite o número de mensagens para simular:");
scanf ( "% d", & nsimmax);
printf ( "Enter a probabilidade de perda de pacotes [enter 0,0 por nenhuma perda ]:");
scanf ( "% f", & lossprob);
printf ( "Enter a probabilidade de corrupção de pacotes [0,0 por nenhuma corrupção ]:");
scanf ( "% f", & corruptprob);
printf ( "Digite o tempo médio entre mensagens do remetente layer5 [> 0,0 ]:");
scanf ( "% f", & lambda);
printf ( "TRACE");
scanf ( "% d", & Trace);
srand (9999) / * init gerador de números aleatórios * /
sum = 0,0; / * teste de gerador de números aleatórios para os alunos * /
for (i = 0; i <1000; i )
soma = soma jimsrand (); / * jimsrand () deve ser uniforme em [0,1] * /
avg = sum/1000.0;
if (avg <0,25 | | avg> 0,75) (
printf ( "É provável que a geração de números aleatórios em sua máquina \ n");
printf ( "é diferente do que este emulador espera. Por favor, \ n");
printf ( "Um olhar sobre a rotina jimsrand () no código do emulador. Desculpe. \ n");
exit (0);
)
ntolayer3 = 0;
nlost = 0;
ncorrupt = 0;
tempo = 0,0; / * inicializar o tempo para 0,0 * /
generate_next_arrival (); / * inicializar lista de eventos * /
)
/************************************************* ***************************/
/ * Jimsrand (): return a flutuar no intervalo [0,1].A rotina abaixo é usado para * /
/ * Isolar toda a geração de números aleatórios em um local.Assumimos que o * /
/ * Fornecidos pelo sistema rand () função retornar um int em therange [0, mmm] * /
/************************************************* ***************************/
jimsrand float ()
(
mmm dupla = (double RAND_MAX); / / 2147483647 / * maior int - dependente da máquina !!!!!!!!* /
float x; / * cada aluno pode precisar de mudar mmm * /
x = rand () mmm / / * x deve ser uniforme em [0,1] * /
return (x);
)
/********************* EVENTO handline ROTINAS *******/
/ * O próximo conjunto de rotinas de manipular a lista de eventos * /
/************************************************* ****/
generate_next_arrival ()
(
double x, log (), ceil ();
struct evento * evptr;
/ / Char * malloc ();
float ttime;
TempInt int;
if (trace> 2)
printf ( "Gerar PRÓXIMA CHEGADA: a criação de nova chegada \ n");
x = lambda jimsrand * () * 2 / * x é uniforme em [0,2 * lambda] * /
/ * Com média de lambda * /
evptr = (struct evento *) malloc (sizeof (struct evento));
evptr-> EVtime = tempo x;
evptr-> evType = FROM_LAYER5;
if (BIDIRECTIONAL & & (jimsrand ()> 0,5))
evptr-> eventividade = B;
diferente
evptr-> eventividade = A;
insertEvent (evptr);
)insertEvent (p)
struct evento * p;
(
struct evento * q, * qold;
if (trace> 2) (
printf ( "insertEvent: o tempo é% lf \ n", tempo);
printf ( "insertEvent: tempo futuro será% lf \ n", p-> EVtime);
)
evlist q = / * q aponta para cabeçalho da lista em que p struct inserido * /
if (q == NULL) (/ * lista está vazia * /
evlist = p;
p-> next = NULL;
p-> prev = NULL;
)
else (
for (qold = q; q! = NULL & & p-> EVtime> q-EVtime>; q = q-> next)
qold = q;
if (q == NULL) (/ * fim da lista * /
qold-> next = p;
p-> prev = qold;
p-> next = NULL;
)
else if (q == evlist) (/ * frente da lista * /
p-> evlist = next;
p-> prev = NULL;
p-> next-> prev = p;
evlist = p;
)
else (/ * meio da lista * /
p-> next = q;
p-> anterior = q-> prev;
q-> prev-> next = p;
q-> prev = p;
)
)
)
printevlist ()
(
struct evento * q;
int i;
printf ("-------------- \ nEvent Segue a lista: \ n ");
for (q = evlist; q! = NULL; q = q-> next) (
printf (tempo de evento ":% m, tipo: ENTITY% d:% d \ n", q-> EVtime, q-> evType, q-> eventividade);
)
printf ("-------------- \ n ");
)/********************** Student-rotinas pode ser chamado *********************** /
/ * Chamada pelos alunos de rotina para cancelar uma anteriormente iniciados timer * /
stoptimer (ÄoRb)
ÄoRb int / * A ou B está tentando parar timer * /
(
struct evento * q, * qold;
if (trace> 2)
printf ( "Stop Timer: cronômetro parando em% f \ n", time);
/ * For (q = evlist; q! = NULL & & q-> next! = NULL; q = q-> next) * /
for (q = evlist; q! = NULL; q = q-> next)
if ((q-> evType == TIMER_INTERRUPT & & q-> eventividade ÄoRb ==)) (
/ * Remover este evento * /
if (q-> next == NULL & & q-> prev == NULL)
evlist = NULL; / * remove o primeiro evento, e apenas na lista * /
else if (q-> next == NULL) / * Fim da lista - há uma em frente * /
q-> prev-> next = NULL;
else if (q == evlist) (/ * frente da lista - deve haver evento depois * /
q-> next-> prev = NULL;
evlist = q-> next;
)
else (/ * meio da lista * /
q-> next-> prev = q-> prev;
q-> prev-> next = q-> next;
)
free (q);
return;
)
printf ( "Atenção: Não é possível cancelar o timer. Ele não estava funcionando. \ n");
)startTimer (ÄoRb, incremento)
ÄoRb int / * A ou B está tentando parar timer * /
float incremento;
(
struct evento * q;
struct evento * evptr;
/ / Char * malloc ();
if (trace> 2)
printf ( "Start Timer: Timer a partir de% f \ n", time);
/ * Be nice: verificar se temporizador é iniciado, se assim for, então avisar * /
/ * For (q = evlist; q! = NULL & & q-> next! = NULL; q = q-> next) * /
for (q = evlist; q! = NULL; q = q-> next)
if ((q-> evType == TIMER_INTERRUPT & & q-> eventividade ÄoRb ==)) (
printf ( "Atenção: tentativa de iniciar um temporizador que já foi iniciado \ n");
return;
)
/ * Criar eventos futuros para quando se apaga timer * /
evptr = (struct evento *) malloc (sizeof (struct evento));
evptr-> EVtime tempo = incremento;
evptr-> evType = TIMER_INTERRUPT;
evptr-> eventividade = ÄoRb;
insertEvent (evptr);
)/************************** TOLAYER3 ***************/
tolayer3 (ÄoRb, pacotes)
ÄoRb int / * A ou B está tentando parar timer * /
struct packet pkt;
(
struct pkt * mypktptr;
evptr struct evento *, * q;
/ / Char * malloc ();
float lastime, x, jimsrand ();
int i;ntolayer3 ;
/ * Simular perdas: * /
if (jimsrand () <lossprob) (
nlost ;
if (trace> 0)
printf (TOLAYER3 ": pacote que está sendo perdido \ n");
return;
)
/ * Faça uma cópia do estudante pacote só me deu desde que ele / ela pode decidir * /
/ * Para fazer alguma coisa com o pacote depois de retornar a ele * /
mypktptr = (struct pkt *) malloc (sizeof (pkt));
mypktptr-> seqnum = packet.seqnum;
mypktptr-> acknum = packet.acknum;
mypktptr-> checksum = packet.checksum;
for (i = 0; i <20; i )
mypktptr-> carga = packet.payload ;
if (trace> 2) (
printf (TOLAYER3 ": seq:% d,% d ack, confira:% d", mypktptr-seqnum>,
mypktptr-> acknum, mypktptr-> checksum);
for (i = 0; i <20; i )
printf ( "% c", mypktptr-> carga );
printf ( "\ n");
)
/ * Criar eventos futuros para a chegada dos pacotes no outro lado * /
evptr = (struct evento *) malloc (sizeof (struct evento));
evptr-> evType = FROM_LAYER3 / * pacote vai sair de layer3 * /
evptr-> eventividade = (ÄoRb 1)% 2; / * evento ocorre em outras entidades * /
evptr-> pktptr = mypktptr / * ptr para salvar a minha cópia do pacote * /
/ * Finalmente, calcular o tempo de chegada do pacote na outra extremidade.
médio não pode reordenar, por isso, certifique pacote chega entre 1 e 10
unidades de tempo após o último horário de pacotes
No momento, o meio em seu caminho para o destino * /
tempo lastime =;
/ * For (q = evlist; q! = NULL & & q-> next! = NULL; q = q-> next) * /
for (q = evlist; q! = NULL; q = q-> next)
if ((q-> evType == FROM_LAYER3 & & q-> eventividade == evptr-> eventividade))
lastime = q-> EVtime;
evptr-> EVtime = lastime 1 9 * jimsrand ();/ * Simular a corrupção: * /
if (jimsrand () <corruptprob) (
ncorrupt ;
if ((x jimsrand = ()) <.75)
mypktptr-> payload [0] = 'Z'; / * payload corrupto * /
else if (x <.875)
mypktptr-> seqnum = 999999;
diferente
mypktptr-> acknum = 999999;
if (trace> 0)
printf (TOLAYER3 ": pacote ser corrompido \ n");
)
if (trace> 2)
printf (TOLAYER3 ": programação de chegada do outro lado \ n");
insertEvent (evptr);
)
tolayer5 (ÄoRb, datasent)
ÄoRb int;
datasent char [20];
(
int i;
if (trace> 2) (
printf ( "TOLAYER5: dados recebidos:");
for (i = 0; i <20; i )
printf ( "% c", datasent );
printf ( "\ n");
)
)