7 Nível de Enlace



Baixar 343,78 Kb.
Página1/5
Encontro26.03.2020
Tamanho343,78 Kb.
  1   2   3   4   5


7 - Nível de Enlace
A função do nível de enlace consiste em detectar e, opcionalmente, corrigir os eventuais erros do nível físico
Na montagem dos quadros, o nível de enlace acrescenta uma seqüência de bits adicionais denominados Frame Check Sequence (FCS). Uma vez detectado o erro, o quadro é descartado e opcionalmente é enviado um aviso ao sistema que o transmitiu.
7.1 - Principais Funções do Nível de Enlace
7.1.1 - Delimitação de Quadros
São usados quatro métodos na criação e reconhecimento dos limites dos quadros:

  • Contagem de caracteres: um campo no cabeçalho informa o número de caracteres do quadro.

  • Caracteres delimitadores e transparência de caracteres: utiliza caracteres especiais para indicar o início e o final do quadro. Toda vez que um delimitador aparece nos dados, é inserido (stuffed) antes dele um outro caractere especial. Quando o destinatário recebe um delimitador precedido do caractere especial ele conclui que nesse caso o caractere delimitador faz parte dos dados do quadro.

  • Flags para delimitar os quadros e transparência de bits (bit stuffing): O protocolo HDLC utiliza essa técnica e usa o padrão 01111110 como delimitador. Sempre que o transmissor encontra cinco bits consecutivos iguais a 1 nos dados que vai transmitir, ele insere (stuffs) um bit 0 na cadeia de bits. Quando o receptor encontra cinco bits 1 consecutivos, seguidos de um bit 0, ele automaticamente retira (destuffs) o bit 0.

  • Violação de códigos: utiliza codificação que possui alguma forma de redundância.


7.1.2 - Controle de Erros no Enlace
O destinatário de um quadro envia ao remetente quadros especiais carregando avisos de reconhecimento positivo ou negativo dos quadros recebidos para que se obtenham transmissões confiáveis.

Um temporizador é usado para medir um intervalo de tempo (timeout) suficiente para que o quadro chegue ao seu destino, seja processado, o reconhecimento seja enviado e chegue ao transmissor. Se o reconhecimento não chegar dentro desse intervalo de tempo o quadro é retransmitido, evitando que o transmissor fique parado indefinidamente à espera do reconhecimento. Nessa técnica, como os quadros podem ser transmitidos mais de uma vez, eles são numerados.

O controle de erro pode ser realizado a contento apenas com o reconhecimento positivo e o temporizador. O reconhecimento negativo, no entanto, acelera o processo de envio de informação. O reconhecimento pode ser um quadro de controle do nível 2, ou pode ser transportado de carona em um campo de controle de um quadro de informação (piggybacking).

São três os procedimentos mais empregados:



  • bit alternado (stop-and-wait)

  • janela n com retransmissão integral (go-back-n)

  • janela n com retransmissão seletiva (selective repeat).

No algoritmo de bit alternado o transmissor só envia um novo quadro quando recebe o reconhecimento do quadro enviado anteriormente. O primeiro quadro é numerado com o bit 0, o segundo com o bit 1, o terceiro com o bit 0, e assim sucessivamente.

Fig. 7.1 , pg 158 Diagrama de estados do algoritmo de bit alternado

Fig. 7.2 , pg 159 Controle de erro por timeout do protocolo de bit alternado


Aumenta-se a eficiência do processamento utilizando protocolos que permitem que o transmissor envie diversos quadros mesmo sem ter recebido reconhecimentos dos quadros anteriormente enviados. O número máximo de quadros, devidamente numerados, que podem ser enviados sem que tenha chegado um reconhecimento define a largura da janela de transmissão. Dois procedimentos podem ser implementados para recuperar o erro:



  • janela n com retransmissão integral (go-back-n)

  • janela n com retransmissão seletiva (selective repeat).

O receptor não precisa enviar um reconhecimento para cada quadro que recebe. O transmissor ao receber o reconhecimento do quadro n conclui que ele, e os quadros enviados antes dele, foram recebidos corretamente.


3.4 (da 3a ediçãodo Tanembaum) - Protocolos de Janela deslizante
Nos protocolos de janela deslizante cada quadro de saída contém um número de seqüência variando de 0 até um máximo. Para que o número de seqüência fique contido em um campo de n bits é usual que o máximo seja igual a 2n - 1.

Em qualquer instante o emissor mantém um conjunto de números de seqüência correspondentes aos quadros que tenha permissão para transmitir. Estes quadros estão dentro da janela do emissor. O receptor mantém uma janela de recepção correspondente ao conjunto de quadros que possa receber. As janelas do emissor e do receptor não precisam ter os mesmos limites superior e inferior nem sequer ter mesmo tamanho.

Os números de seqüência na janela do emissor representam quadros transmitidos mas ainda não confirmados. Sempre que um pacote chega da camada de rede ele recebe o próximo maior número de seqüência e a borda superior da janela é acrescida de uma unidade . Quando chega uma confirmação a janela do emissor tem sua borda inferior acrescida de uma unidade, diminuindo a janela.

A janela do receptor corresponde aos quadros ainda não aceitos. Qualquer quadro que chegue fora da janela é sumariamente descartado. Quando chega um quadro cujo número de seqüência é igual ao bordo inferior gera-se uma confirmação e a janela gira de uma unidade. A janela do receptor sempre permanece com o tamanho original.


Fig. 3.12, da pg. 204 do Tanembaum.
3.4.2 (da 3a ediçãodo Tanembaum) - Um Protocolo usando Go Back n
Na técnica de pipelining se a capacidade do canal é b bits/seg, o tamanho de quadro é l bits, o tempo total de propagação é R segundos, o tempo de transmissão de um quadro é l/b seg. Depois que o último bit de um quadro de dados foi enviado, existe um atraso de R/2 antes que o quadro chegue ao destino e outro atraso de aproximadamente R/2 para o retorno da confirmação. No algoritmo de “para e espera” a linha está ocupada por l/b segundos e ociosa por R segundos dando uma utilização de l/(l + bR). Se l < bR a eficiência será inferior a 50%.

Quando há erros no pipelining, há duas abordagens de tratamento.

Na primeira abordagem a janela de receptor é de tamanho 1, ou seja, a camada de enlace recusa-se a aceitar qualquer quadro que não seja aquele que ela deva apresentar à camada de rede.

Outra estratégia é a de repetição seletiva na qual a camada de enlace armazena todos os quadros corretos recebidos após o quadro com defeito. Quando o emissor descobre que há algo errado ele retransmite apenas o quadro mal recebido e não necessariamente todos os seus sucessores. Se esta segunda transmissão for bem sucedida, a camada de enlace passa a ter muitos quadros corretos em seqüência e pode fornece-los à camada de rede rapidamente e confirmar o número de seqüência maior entre eles.

A janela de recepção é maior do que 1. Qualquer quadro dentro da janela pode ser aceito e armazenado até que todos os seus predecessores tenham sido passados à camada de rede.

As duas alternativas representam compromissos entre a banda passante e espaço em memória para a camada de enlace. A escolha da estratégia a adotar depende de qual seja o recurso mais valioso em cada caso.

Fig. 7.3 , pg 160 Protocolos de janela n com retransmissão integral ou seletiva
O livro Redes de Computadores de Tanembaum apresenta, de maneira extremamente didática a construção de protocolos para a camada de enlace, de maneira evolutiva, começando com um protocolo bastante simples e evoluindo paulatinamente. São apresentados seis protocolos, a seguir exibidos sob a forma de programas na linguagem Pascal, com as seguintes características:


Protocolo

Características

protocol1

Transmissão unidirecional sem erros

protocol2

Stop-and-wait unidirecional sem erros

protocol3

Stop-and-wait unidirecional em canal ruidoso

protocol4

Janelas deslizantes bidirecionais de tamanho 1

protocol5

Janelas deslizantes bidirecionais com múltiplos quadros pendentes

protocol6

Janelas deslizantes bidirecionais com recepção não seqüencial

{Tipos de dados e procedimentos comuns a diversos protocolos }

const LastBit = .....; {tamanho de pacote}

doomsday = false; {limitador de repeticao infinita}

Maxseq = .......; {maior numero de sequencia }
type bit = 0..1;

SequenceNr = 0..MaxSeq; {usado na numeracao dos quadros}

packet = packed array[0..LastBib]of bit;

{pacote das camadas superiores}

FrameKind = (data,ack,nak); {tipo de quadro}

frame = packed record

kind : Framekind;

seq : SequenceNr;

ack : SequenceNr;

info : packet

end;
procedure wait(var event : EvType)

begin {Espera pela ocorrencia de um evento e retorna seu tipo em event}end;


procedure FromNetworkLayer(var p : packet)

begin {Busca informacao da camada de rede para transmitir pelo canal}end;


procedure ToNetworkLayer(var p : packet)

begin


{Entrega informacao de um quadro de entrada para a camada de rede}end;
procedure FromPhysicalLayer(var r : frame)

begin {Busca um quadro na camada fisica e o copia para r}end;


procedure ToPhysycalLayer(s : frame)

begin {Entrega o quadro s para que a camada fisica o transmita}end;


procedure StartTimer(k : SequenceNr)

begin {Dispara o relogio e habilita o evento TimeOut }end;


procedure inc(var k : SequenceNr)

begin {Incrementa circularmente k}

if k < MaxSeq then k := k + 1 else k := 0; end;

{ ****************************************************************}


{ protocol1

Transmissao de dados unidirecional do transmissor para o receptor. O canal de comunicacao eh sem erros e o receptor pode processar os dados recebidos em qualquer velocidade. O transmissor injeta dados na linha tao rapido quanto possa.

}

type EvType = (FrameArrival);


procedure sender1;

var s: frame; {buffer de um quadro de saida}

buffer : packet; {buffer de um pacote de saida}
begin

repeat


FromNetworkLayer(buffer); {busca algo para transmitir}

s.info := buffer; {copia para s para a transmissao}

ToPhysicalLayer(s); {transmite}

until doomsday; {forever}

end; {sender1}
procedure receiver1;

var r: frame; {buffer de um quadro de entrada}

event : EvType; {disparado por wait }
begin

repeat


wait(event); { o unico evento possivel eh FrameArrival}

FromPhysicalLayer(r); {busca o pacote recebido}

ToNetworkLayer(s); {passa os dados para a camada de rede}

until doomsday; {forever}

end; {receiver1}
{ ****************************************************************}
{ protocol2

Protocolo stop-and-wait fornecendo ainda comunicacao unidirecional. O canal de comunicacao eh livre de erros. O receptor possue um buffer de capacidade finita e, em consequencia eh preciso controlar o fluxo de informacoes enviado pelo transmissor.

}

type EvType = (FrameArrival);


procedure sender2;

var s: frame; {buffer de um quadro de saida}

event : EvType;
begin

repeat


FromNetworkLayer(buffer); {busca algo para transmitir}

s.info := buffer; {copia para s para a transmissao}

ToPhysicalLayer(s); {transmite}

wait(event); {nao prossegue ateh que haja recepcao}

until doomsday; {forever}

end; {sender2}


procedure receiver2;

var r,s: frame;

event : EvType;
begin

repeat


wait(event); { o unico evento possivel eh FrameArrival}

FromPhysicalLayer(r); {busca o pacote recebido}

ToNetworkLayer(r.info); {passa os dados para a camada de rede}

ToPhysicalLayer(s); {passa um quadro vazio como aceitacao}

until doomsday; {forever}

end; {receiver2}


{ ****************************************************************}
{ protocol3

Transmissao unidirecional em um canal ruidoso. Pode haver erros em quadros e ateh perda de quadros

}

cons MaxSeq = 1;


type EvType = (FrameArrival,CksumErr,TimeOut);
procedure sender3;

var NextFrameToSend : SequenceNr;

{numero de sequencia da proxima mensagem a ser transmitida }

s: frame; {area de trabalho}

buffer : packet; {buffer de um pacote de saida}

event : EvType;


begin

NextFrameToSend := 0; {inicializa sequencia de numeracao de saida}

FromNetworkLayer(buffer); {busca o primeiro pacote}

repeat


s.info := buffer; {constroi quadro para a transmissao}

s.seq := NextFrameToSend;

{insere sequencia de numeracao no quadro}

ToPhysicalLayer(s); {transmite}

StartTimer(s.seq); {se a resposta demorar muito, encerrar}

wait(event); {FrameArrival ou CCksumErr ou Timeout}

if event = FrameArrival then

begin {uma confirmacao foi recebida intacta}

FromNetworkLayer(buffer);

{busca o proximo pacote para transmitir}

inc(NextFrameToSend);

{inverte NextFrameToSend}

end

until doomsday; {forever}



end; {sender3}

procedure receiver3;

var FrameExpected : SequenceNr; {FrameExpected = 0 ou 1}

r,s: frame; {areas de trabalho}

event : EvType;
begin

FrameExpected := 0;

repeat

wait(event); { FrameArrival ou CksumErr}



if event = FrameArrival then

begin {um quadro valido foi recebido}

FromPhysicalLayer(r); {busca o pacote recebido}

if r.seq = FrameExpected then

begin { eh por isto que se esperava}

ToNetworkLayer(r.info);

{passa os dados para a camada de rede}

inc(FrameExpected);

{da proxima vez se espera numero de sequencia circularmente incrementado}

end;


ToPhysicalLayer(s);

{passa um quadro vazio como aceitacao}

end { fim do codigo de FrameArrival }

until doomsday; {forever}

end; {receiver3}
{ ****************************************************************}
{ protocol4

Protocolo bidirecional de janelas deslizantes. Eh mais robusto que os anteriores, podendo enfrentar qualquer combinacao de erros e timeouts sem perder ou duplicar os pacotes da camada de rede.

}

cons MaxSeq = 1;


type EvType = (FrameArrival,CksumErr,TimeOut);
procedure protocol4;

var NextFrameToSend : SequenceNr; {0 ou 1}

FrameExpected : SequenceNr; {0 ou 1}

r,s: frame; {areas de trabalho}

buffer : packet; {pacote corrente de saida}

event : EvType;


begin

NextFrameToSend := 0; {inicializa sequencia de numeracao de saida}

FrameExpected := 0; {inicializa sequencia de numeracao de entrada}

FromNetworkLayer(buffer); {busca pacote da camada de rede}

s.info := buffer; {prepara quadro inicial para a transmissao}

s.seq := NextFrameToSend; {sequencia de numeracao de quadros}

s.ack = 1 - FrameExpected; {aceitacao via piggyback}

ToPhysicalLayer(s); {transmite o quadro}

StartTimer(s.seq); {dispara o relogio}
repeat

wait(event); {FrameArrival ou CksumErr ou Timeout}

{ Se o evento ocorrido for CksumErr ou TimeOut nada se faz.

Se o evento for FrameArrival entao testa-se r.seq e r.ack.

Se r.seq = FrameExpected aceita-se o quadro e inverte-se FrameExpected.

Se r.ack = NexrFrameToSend busca-se novo pacote e inverte-se NextFrameToSend.

Em qualquer caso prepara-se e transmite-se um quadro.}

if event = FrameArrival then

begin {um quadro valido foi recebido}

FromPhysicalLayer(r); {busca o quadro recebido}

if r.seq = FrameExpected then

begin { trata quadro de entrada}

ToNetworkLayer(r.info);

{passa o pacote para a camada de rede}

inc(FrameExpected);

{ da proxima vez se espera numero de

sequencia incrementado}

end;
if r.ack = NextframeToSend then

begin {trata quadro de saida}

FromNetworkLayer(buffer);

{busca pacote da camada de rede}

inc(NextFrameToSend);

{inverter NextFrameToSend}

end


end
s.info := buffer: {constroi quadro de saida}

s.seq := NextFrameToSend; {insere sequencia de numeracao}

s.ack = 1 - FrameExpected; {numeracao do ultimo quadro recebido}

ToPhysicalLayer(s); {transmite o quadro}

StartTimer(s.seq); {dispara o relogio}
until doomsday; {forever}

end; {protocol4}

{ ****************************************************************}

{ protocolo5 (pipelining)

Este protocolo permite multiplos quadros pendentes. O emissor pode transmitir ateh MaxSeq quadros sem receber uma confirmação. Alem disso, ao contrario dos protocolos anteriores, nao se supoe que a camada de rede seja uma fonte inesgotavel de pacotes a transmitir. Quando a camada de rede tiver um pacote para transmitir ela provocarah um evento NetworkLayerReady.

}
type EvType = (FrameArrival, CksumErr, TimeOut, NetworkLayerReady);


procedure protocol5;

var NextFrameToSend : SequenceNr;

{MaxSeq > 1; usado para fluxo de quadros de saida}

AckExpected : SequenceNr;

{quadro mais antigo ainda nao confirmado}

FrameExpected : SequenceNr;

{proximo quadro esperado no fluxo de entrada}

r,s : frame; {variaveis de trabalho}

buffer : array[SequenceNr] of packet; {buffers para o fluxo de saida}

nbuffered : SequenceNr;

{numero de posicoes de buffer atualmente em uso}

i : SequenceNr; {ponteiro para buffer}

event : EvType;
function between(a,b,c : SequenceNr):boolean;

{Retorna verdadeiro se a<=b

begin

if ((a<=b) and (b

then between := true

else between := false

end: {between}
procedure SendData(FrameNr: SequenceNr);

{Constroi e envia um quadro de dados}

begin

s.info := buffer[FrameNr]; {inclui pacote no quadro}



s.seq := FrameNr; {inclui numeracao sequencial no quadro}

s.ack := (FrameExpected + MaxSeq) mod (MaxSeq + 1)

{confirmacao via piggybacking}

ToPhysicalLayer(s); {transmite o quadro}

StartTimer(FrameNr) {inicia o temporizador}

end; {SendData}


begin

EnablenetworkLayer; {habilita os eventos NetworkLayerReady}

NextFrameToSend := 0; {inicializa}

AckExpected := 0; {proxima confirmacao esperada no fluxo de entrada}

FrameExpected := 0;

{proximo quadro de dados esperado no fluxo de entrada}

nbuffered := 0; {inicialmente nao existem pacotes em buffer}
repeat

wait(event); { FrameArrival, CksumErr, TimeOut, NetworkLayerReady}

case event of

NetworkLayerReady : { a camada de rede tem pacote a transmitir}

begin {aceita, armazena e trasmite o novo quadro}

FromNetworkLayer(buffer[NextFrameToSend]);

{aceita pacote da camada de rede}

nbuffered := nbuffered + 1;

{incremento do numero de quadros em buffer}

SendData(NextFrameToSend); {transmite o quadro}

inc(NextFrameToSend); {expande a janela do emissor}

end;
FrameArrival : {chegada de quadro de dados ou de controle}

begin

FromPhysicalLayer(r); {recebe quadro da camada fisica}



if r.seq = FrameExpected

then


begin {os quadros nao sao aceitos fora da ordem apropriada}

ToNetworkLayer(r.info); {passa o pacote para a camada de rede}

inc(FrameExpected) {avanca a janela do receptor}

end;


{como a confirmacao de n implica na confirmacao de n-1, n-2, etc eh necessario este teste}

while between(AckExpected,r,ack,NextFrameToSend) do

begin

nbuffered := nbuffered - 1; {menos um quadro em buffer}



StopTimer(AckExpected);

{pode-se parar o temporizador pois o quadro nao se perdeu}

inc(AckExpected); {reduz a janela do emissor}

end


end;
CksumErr :; {apenas se ignora os quadros danificados}
TimeOut :

{problemas na transmissao ; retransmite os quadros pendentes}

begin

NextFrameTosend := AckExpected;



{reinicia deste ponto a transmissao}

for i := 1 to nbuffered do

begin

SendData(NextFrameToSend);



inc(NextFrameToSend)

end


end

end; {fim do codigo de FrameArrival}

if nbuffered < MaxSeq

then {existe espaco na janela do emissor}

EnableNetworkLayer {habilita a recepcao de pacotes}

else


DisableNetworkLayer {desabilita a recepcao de pacotes}

until doomsday {forever}

end: {protocol5}
{ ****************************************************************}

{ protocolo6 (recepcao nao sequencial)

O protocolo aceita quadros fora de ordem e repassa os pacotes a camada de rede em ordem. Associado a cada quadro pendente existe um temporizador. Quando um temporizador dispara apenas o quadro correspondente eh retransmitido e nao todos os quadros pendentes, como era feito no caso do protocolo5.

}
const NrBufs = . ..; {NrBufs = (MaxSeq + 1) div2}

MaxBuf =..; {MaxBuf = NrBufs}
type bufnr = 0..MaxBuf;

EvType = (FrameArrival, CksumErr, TimeOut,

NetworkLayerReady,NetworkLayerIdle);
procedure protocol6;
var AckExpected : SequenceNr; {borda inferior da janela do emissor}

NextFrameToSend : SequenceNr;{borda superior da janela do emissor +1}

FrameExpected : SequenceNr; { borda inferior da janela do receptor }

TooFar : SequenceNr; {borda superior da janela do receptor + 1}

OldestFrame : SequenceNr; {quadro que atingiu o time-out}

r,s : frame; {variaveis de trabalho}

OutBuf : array[bufnr] of packet; {buffers para o fluxo de saida}

InBuf : array[bufnr] of packet; {buffers para o fluxo de entrada}

arrived : array[bufnr] of boolean; {mapa de bits do fluxo de entrada}

nbuffered : SequenceNr;

{numero de posicoes de buffer atualmente em uso}

NoNak : boolean; {indicador tornado falso quando se envia um nak}

event : EvType;
function between(a,b,c : SequenceNr):boolean;

{Retorna verdadeiro se a<=b

begin

if ((a<=b) and (b

then between := true

else between := false

end: {between}
procedure SendFrame(fk: framekind; FrameNr: SequenceNr);

{Constroi e envia um quadro de dados, ack ou nak}

begin

s.kind := fk; {kind = (data, ack, nak)}



if fk = data

then


s.info := Outbuf[FrameNr mod NrBufs]; {inclui pacote no quadro}

s.seq := FrameNr; {para dados numeracao sequencial no quadro}

s.ack := (FrameExpected + MaxSeq) mod (MaxSeq + 1);

{confirmacao via piggybacking}

if fk = nak

then {apenas um nak por quadro}

NoNak := false;

ToPhysicalLayer(s); {transmite o quadro}

if fk = data

then


StartTimer(FrameNr mod NrBufs) {inicia o temporizador}

StopAckTimer {nada de quadro separado para ack}

end; {SendFrame}
begin

EnablenetworkLayer; {habilita os eventos NetworkLayerReady}

NextFrameToSend := 0; {inicializa}

AckExpected := 0; {proxima confirmacao esperada no fluxo de entrada}

FrameExpected := 0;

{proximo quadro de dados esperado no fluxo de entrada}

TooFar := 0;

nbuffered := 0; {inicilamente nao existem pacotes em buffer}

NoNak := true;
for i:= 0 to MaxBuf do

arrived[i] := false;


repeat

wait(event); {cinco possibilidades}

case event of

NetworkLayerReady : { a camada de rede tem pacote a transmitir}

begin {aceita, armazena e trasmite o novo quadro}

nbuffered := nbuffered + 1; {expande janela}

FromNetworkLayer(OutBuf[NextFrameToSend mod NrBufs]);

{aceita novo pacote}

SendFrame(data,NextFrameToSend); {transmite o quadro}

inc(NextFrameToSend);

{expande limite superior da janela do emissor}

end;


FrameArrival : {chegada de quadro de dados ou de controle}

begin


FromPhysicalLayer(r); {recebe quadro da camada fisica}

if r.kind = data

then {chegou um quadro nao danificado}

begin


if (r.seq <> FrameExpected) and NoNak

then


SendFrame(nak,0);

if between(FrameExpected, r.seq, TooFar) and

(arrived[r.seq mod NrBufs] = false)

then


begin {os quadros podem ser aceitos em qualquer ordem}

arrived[r.seq mod NrBufs] = true; {marcacao de buffer cheio}

InBuf[r.seq mod NrBufs] :=r.info; {inclui dados no buffer}

while arrived[FrameExpected mod NrBufs] do

begin {passa os pacotes e avanca a janela}

ToNetworkLayer(InBuf[FrameExpected mod NrBufs]); {passa o pacote p/ rede}

arrived[FrameExpected mod NrBufs] := false;

inc(FrameExpected);

{avanca a borda inferior da janela do receptor}

inc(TooFar);

{avanca a borda superior + 1 da janela do receptor}

StartAckTimer

{para verificar se hah necessidade de ack separado}

end


end

end; {fim do codigo para quadro de dados}


if (r.kind = nak) and

between(AckExpected, (r.ack + 1) mod (MaxSeq + 1),

NextFrameToSend)

then


SendFrame(ack, (r.ack + 1) mod (MaxSeq + 1));

while between(AckExpected,r,ack,NextFrameToSend) do

begin

nbuffered := nbuffered - 1;



{tratamento de ack via piggybacking}

StopTimer(AckExpected mod NrBifs);

{ o quadro nao chegou intacto}

inc(AckExpected); {avanca a borda inferior da janela do emissor}

end

end; {fim do codigo de FrameArrival}


CksumErr :

if NoNak


then

SendFrame(nak,0); {quadro recedido danificado}


TimeOut :

SendFrame(data,OldestFrame);

{retransmissao provocada por temporizacao}
NetworkIdle :

SendFrame(ack,0);

{a camada de rede ficou muito tempo ociosa e envia-se um ack}
end; {fim do case}
if nbuffered < NsBufs

then {existe espaco na janela do emissor}

EnableNetworkLayer {habilita a recepcao de pacotes}

else


DisableNetworkLayer {desabilita a recepcao de pacotes}

until doomsday {forever}

end: {protocol6}




  1   2   3   4   5


©livred.info 2019
enviar mensagem

    Página principal