RCO2-2010-2

Redes de Computadores II: Diário de Aula 2010-2

Professor: Marcelo Maia Sobral (msobral@gmail.com)
Lista de email (forum): rco2@googlegroups.com
Atendimento paralelo: 2a e 3a de 10h às 11 h, 3a e 5a de 16h às 17h.

• Ementa

Bibliografia

• Livros sobre Redes de Computadores (por ordem de preferência):
  • FOROUZAN, Behrouz. Comunicação de Dados e Redes de Computadores, 3a/4a edicão. Editora Bookman, 2004.
  • KUROSE, James F. e ROSS, Keith W. Redes de computadores e a Internet, Uma abordagem Top-Down. 5a edição. Editora Addison wesley SP, 2010..
  • TANENBAUM, Andrew S. Redes de Computadores, tradução da quarta edição. Editora Campus RJ, 2003
  • GALLO, Michael A. E HANCOCK Wiliam M. Comunicação entre computadores e tecnologia de rede. Ed. Pioneira Thomson Learning SP, 2003.
  • COMMER, Douglas E. Redes de Computadores e Internet – 2a edição. Editora Bookman, Porto Alegre, 2001

• Antiga página da disciplina (2009-1 e 2009-2)
• Links para outros materiais, normas, artigos, e apostilas do prof. Jorge Casagrande
• Programação com sockets:
  • Uma introdução na Wikipedia (inglês)
  • Um Guia básico (português)
  • Livro Unix Network Programming, 2nd edition, de Richard Stevens (há na biblioteca)

Curiosidades

• Telex: um serviço já extinto (?!)
• História da Internet-BR (dissertação de Mestrado)
• O Ciberespaço e as Redes de Computadores na Construção de Novo Conhecimento
• Uma história das Redes de Computadores
• Uso do HDLC em missões espaciais (artigo da Nasa)
• MetroEthernet Forum
• Metro Ethernet - A Technical Overview

Listas de exercícios

• 1a lista de exercícios
• 2a lista de exercícios
• 3a lista de exercícios
• 4a lista de exercícios
• 5a lista de exercícios
• 6a lista de exercícios
• 7a lista de exercícios
• 8a lista de exercícios
• 9a lista de exercícios
• 10a lista de exercícios

Softwares

• Tutorial para instalação do Omnet++ 4.0p1

27/07: Apresentação

Apresentação da disciplina: conteúdo, bibliografia e avaliação, laboratório.

29/07: Introdução e camada de enlace

Apresentou-se uma visão geral dos conceitos sobre comunicação de dados, amparada em transparências. Nesta aula se planta a base para iniciar o estudo com maior profundidade da camada de enlace e da camada física.

Os serviços identificados na figura acima estão descritos abaixo. A eles foram acrescentados outros dois:

• Encapsulamento (ou enquadramento): identificação das PDUs (quadros) de enlace dentro de sequências de bits enviadas e recebidas da camada física
• Controle de erros: garantir que quadros sejam entregues no destino
  • Detecção de erros: verificação da integridade do conteúdo de quadros (se foram recebidos sem erros de bits)
• Controle de fluxo: ajuste da quantidade de quadros transmitidos, de acordo com a capacidade do meio de transmissão (incluindo o atraso de transmissão) e do receptor
• Endereçamento: necessário quando o enlace for do tipo multi-ponto, em que vários equipamentos compartilham o meio de transmissão (ex: redes locais e redes sem-fio)
• Controle de acesso ao meio (MAC): também necessário para meios compartilhados, para disciplinar as transmissões dos diversos equipamentos de forma a evitar ou reduzir a chance de haver colisões (transmissões sobrepostas)
• Gerenciamento de enlace: funções para ativar, desativar e manter enlaces

03/08: Enquadramento

Enlaces ponto-a-ponto:

Nesta aula se criarão enlaces ponto-a-ponto entre computadores, usando o protocolo PPP. A partir de alguns experimentos se discutem os serviços da camada de enlace, em particular o enquadramento e detecção de erros.

Roteiro do primeiro laboratório

Foi apresentado como funciona o enquadramento (ou sincronização de quadro) do tipo sentinela (usado pelo PPP e HDLC). Nesse caso, usa-se uma flag delimitadora para informar o início e fim de quadro. Há uma segunda flag, chamada de escape (ESC), para evitar que um byte com o valor de flag delimitadora, o qual apareça em algum campo do quadro (ex: dados ou campos de controle) seja erroneamente interpretado como fim de quadro.

Exercício pedido no laboratório

Foi pedida a conversão de um quadro mostrado pelo pppdump. O pppdump lê o arquivo /tmp/ppp.log (onde o pppd grava uma cópia de todos os quadros recebidos e enviados, junto com o instante em que isso ocorreu), e mostra esses quadros num formato legível. Quer dizer, ele mostra os bytes dos quadros em representação hexadecimal. O que aparece na tela, portanto, é uma string com as representações hexadecimais desses bytes. No entanto, a atividade a ser feita na próxima aula precisa de um quadro em seu formato original, tal como foi transmitido pela interface serial. Por isso deve-se escrever um programa que converta a representação em string para os valores numéricos dos bytes, e os guarde em um arquivo.

Por exemplo, a seguinte sequência de bytes conforme mostrada pelo pppdump:

7e 21 45 00 00 54

... sendo uma string, na verdade é composta por uma sequência de códigos ASCII (17 bytes no total):

 37 65 20 32 31 20 34 35 21 30 30 21 30 30 21 35 34

O que se deseja é converter a sequência de códigos ASCII acima para uma sequência de bytes com esses valores (5 bytes no total):

7e 21 45 00 00 54

Abaixo segue um programa exemplo, que mostra uma forma de fazer isso. Note que ele apenas converte o conteúdo da string s para os bytes correspondentes, colocando-os no vetor res:

#include <stdio.h>

int main() {
  char * s = "7e 21 45 00 00 54";
  unsigned char res[6];
  int c;
  int i = 0, n = 0;

  while (s[i] != 0) {
    if (sscanf(s + i, "%x", &c) < 1) break;
    res[n] = c;
    i+= 3;
    n++;
  }

  for (i=0; i < n; i++) {
    printf("res[%d] = %d (ou %x em hexa)\n", i, res[i], res[i]);
  }

}

Ao executar esse programa, ele mostrará os bytes convertidos (que estão em res):

res[0] = 126 (ou 7e em hexa)
res[1] = 33 (ou 21 em hexa)
res[2] = 69 (ou 45 em hexa)
res[3] = 0 (ou 0 em hexa)
res[4] = 0 (ou 0 em hexa)
res[5] = 84 (ou 54 em hexa)

Para trabalhar com arquivos em linguagem C, veja esta introdução.

05/08: Detecção de erros

Finalização do laboratório da aula passada:

• Injetar um quadro no enlace PPP (ver roteiro do laboratório da aula passada):
  • Arquivo com o quadro
• O exercício proposto, para conversão dos bytes de um quadro PPP mostrados pelo pppdump, foi resolvido de forma muito simples pelo Sant Clear e Bruna. Segue abaixo a solução deles:

/** Desenvolvido por Sant Clear **/

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
 
  FILE *quadroDes;
  FILE *novo_quadroDes;
  
  unsigned char res[1500];
  int c = 0, i = 0, n = 0;

//*********************************************
  quadroDes = fopen("./quadro","r");

  while (fscanf(quadroDes, " %x", &c) == 1){ // Para quando não conseguir mais 
                                             // ler números hexadecimais do arquivo
    res[n] = c;
    n++;
  }

  fclose(quadroDes);
//*********************************************

//*********************************************
  novo_quadroDes = fopen("./novo_quadro","wb");
 
  fwrite(res, n, 1, novo_quadroDes);
 
  fclose(novo_quadroDes);
//*********************************************

}

... que é bem mais simples do que aquelas apresentadas por mim.

Probabilidade de erros de transmissão (BER - Bit Error Rate), códigos de detecção de erro e CRC.

Há um resumo nas transparências.

O experimento com o gerador de CRC-16 do PPP pode ser repetido em casa. Ele é capaz de verificar um quadro PPP, que pode ser conseguido usando-se a opção record do pppd. Essa opção grava em um arquivo de log os conteúdos dos quadros PPP enviados e recebidos, que podem depois serem visualizados (ou terem seu bytes extraídos) com o utilitário pppdump. Porém o gerador de CRC-16 fornecido inclui dois arquivos contendo quadros PPP previamente coletados: quadro_correto.raw e quadro_errado.raw. Eles podem ser verificados com o programa fcs (o verificador de CRC-16):

# descompacta o arquivo do gerador de CRC-16
tar czf fcs-rfc.tgz
cd fcs

# Testa o quadro correto
./fcs quadro_correto.raw

# Testa o quadro_errado
./fcs quadro_errado.raw

Há um testador que modifica aleatoriamente uma certa quantidade de bits do quadro_correto.raw, até que encontre um caso em que o erro não seja detectado. Para usá-lo deve-se executar o programa testa.py:

# executa testa.py com 4 erros de bit por quadro gerados aleatoriamente
./testa.py 4

O código fonte do gerador de CRC-16 está no arquivo fcs-rfc.c, o qual foi obtido diretamente da RFC 1662.

10/08: Controle de erros: stop-and-wait

Ver capítulo 11 do livro "Comunicação de Dados e Redes de Computadores", de Behrouz Forouzan (há uma cópia no xerox).

Resolver a 1a lista de exercícios.

Controle de erros implica garantir a entrega de quadros no destino. Assim, quadros recebidos com erros (i.e., quadros identificados pela detecção de erros como corrompidos) ou quadros extraviados (não recebidos) devem ser retransmitidos. Serviço implementado com protocolos do tipo ARQ (Automatic Repeat Request), tais como:

• Stop-and-Wait: só transmite o próximo quadro quando receber uma confirmação (ACK) do último quadro enviado. Retransmite o último quadro enviado se um tempo máximo de espera pelo ACK (ou timeout) for excedido.
• Go-Back-N: transmite até N quadros sem receber confirmação, quando então espera os ACK antes de enviar mais quadros. Caso exceda o timeout de um dos quadros enviados, retransmite todos os quadros a partir desse quadro.
• Selective Repeat: transmite até N quadros sem receber confirmação, quando então espera os ACK antes de enviar mais quadros. Caso exceda o timeout de um dos quadros enviados, retransmite somente esse quadro.

A rigor Stop-and-Wait ARQ já provê controle de erros, porém tem o potencial de causar uma baixa utilização do meio de transmissão. Os outros mecanismos, Go-Back-N e Selective Repeat, buscam melhorar o aproveitamento do meio, e assim estão também relacionados com o controle de fluxo. Esse serviço tem duas motivações principais:

1. Evitar que um transmissor mais rápido sobrecarregue um receptor
2. Melhorar o aproveitamento do meio de transmissão, quando há necessidade de confirmação de quadros e o meio apresentar um atraso de propagação significativo.

Desempenho do Stop-and-wait

O mecanismo Stop-and-wait apresenta desempenho que depende de seus parâmetros e de características físicas do enlace. Para avaliar seu desmepenho, deve-se determinar qual a taxa efetiva de transmissão que pode ser obtida. A taxa efetiva é definida com a razão entre quantidade de bits transmitidos (contidos em um ou mais quadros) e o tempo que foi necessário para que sejam entregues no destino. Quadros são considerados entregues somente quando o transmissor obtém uma confirmação do receptor. Isto não é a mesma coisa que a taxa de bits nominal do enlace, pois essa taxa informa o tempo que o transmissor leva para transmitir cada bit pelo meio de transmissão (ou melhor, o inverso de quanto tempo dura cada bit no meio). A taxa efetiva pode ser calculada descobrindo-se qual é a utilização do meio de transmissão. A utilização é um valor entre 0 e 1 que informa quanto tempo o meio foi de fato utilizado (i.e. quanto tempo o transmissor de fato precisou para transmitir um ou mais quadros), comparado com o tempo total necessário para fazer a entrega desses quadros. Por exemplo, se o transmissor levou 1 segundo para transmitir um quadro, e depois ficou 1 segundo esperando até receber a confirmação do receptor, a utilização será de 0.5 (o transmissor usou o meio durante 1 segundo, mas o tempo total para entregar o quadro foi de 2 segundos). Assim, as informações necessárias para calcular o desempenho do Stop-and-wait são:

• Taxa nominal de transmissão, ou taxa de bits ($B$): razão entre quantidade de bits que saem do transmissor e o tempo que leva para que saiam.
• Tempo de transmissão ($A_{t}$): tempo gasto pelo transmissor para transmitir um quadro. É o tempo gasto desde quando o primeiro bit do quadro começa a sair do transmissor, até quando o último bit termina de sair. Esse tempo depende da quantidade de bits transmitidos (F) e da taxa de bits nominal do meio (B): $A_{t}=F/B$
• Atraso de propagação ($A_{p}$): tempo gasto pelo sinal para se propagar desde o transmissor até o receptor. Independe da quantidade de bits transmitidos, pois é uma característica física do meio.
• Outros atrasos ($A_{o}$): outros atrasos envolvidos durante a entrega do quadro
• Tempo de envio ($A_{e}$): tempo necessário para que um quadro seja totalmente transmitido do transmissor até o receptor: $A_{e}=A_{t}+A_{p}$
• Tempo de entrega (A): tempo necessário para que um quadro seja entregue no receptor, i.e. desde o instante em que o quadro começa a ser transmitido até quando o reconhecimento chega ao transmissor:
  $A=A_{t}+2A_{p}+A_{t_{ACK}}+A_{o}$
• Utilização do meio (U): razão entre o tempo em que o meio foi de fato usado pelo transmissor para transmitir o quadro, e o tempo total necessário para que o quadro seja considerado entregue:
  $U={\frac {A_{t}}{A}}={\frac {A_{t}}{A_{t}+2A_{p}+A_{t_{ACK}}+A_{o}}}$
• Taxa efetiva de transmissão (E): a taxa de bits percebida pelo transmissor para fazer a entrega de quadros: $E=B\cdot U$
• Timeout ($T_{o}$): tempo máximo de espera por um reconhecimento.

Simulações com Omnet++

Na aula foi mostrada uma simulação de protocolo de enlace que usa Stop-and-Wait. Essas simulações foram criadas usando-se o simulador de redes Omnet++. Abaixo segue um tutorial para instalar esse simulador em seu computador (assume-se que nele haja o Ubuntu Linux 9.04 ou superior):

• Tutorial para instalação do Omnet++ 4.0p1

12/08: Controle de erros e de fluxo: Go-back-N e Selective Repeat

Ver capítulo 11 do livro "Comunicação de Dados e Redes de Computadores", de Berhouz Forouzan.

• Análise dos mecanismos ARQ Go-Back-N e Selective Repeat.
• Demonstração da melhoria da utilização do meio usando esse mecanismo, comparado ao Stop-and-Wait.
• Uso do simulador Omnet++ 4.01 para avaliar esses os mecanismos ARQ.

Na aula anterior foi visto que o mecanismo ARQ Stop-and-wait é eficaz no controle de erros. Isto significa que ele garante que um quadro seja entregue no destino. Além disto, o Stop-and-wait não se atrapalha se ocorrerem os seguintes erros de transmissão:

• Perda de quadro de dados (inclui quadro de dados recebido com erros e assim descartado).
• Perda de quadro ACK
• Quadro ACK atrasado, fazendo com que ocorra um timeout de espera por confirmação e consequente retransmissão

Ser eficaz no controle de erros não significa ser eficiente. Foi visto que se o atraso de propagação for da ordem de grandeza do atraso de transmissão, a utilização do meio se reduz significativamente. Por exemplo, se o atraso de propagação for metade do de transmissão:

$U={\frac {A_{t}}{A_{t}+2A_{p}+A_{t_{ACK}}}}={\frac {A_{t}}{A_{t}+2A_{t}/2+A_{t_{ACK}}}}={\frac {A_{t}}{2A_{t}+A_{t_{ACK}}}}<{\frac {1}{2}}$

Já se esses dois atrasos forem iguais:

$U={\frac {A_{t}}{A_{t}+2A_{p}+A_{t_{ACK}}}}={\frac {A_{t}}{A_{t}+2A_{t}+A_{t_{ACK}}}}={\frac {A_{t}}{3A_{t}+A_{t_{ACK}}}}<{\frac {1}{3}}$

E assim, quanto maior for o atraso de propagação, pior será a utilização do meio de transmissão. A raiz do problema está no tempo em que o meio deixa de ser usado por causa do atraso de propagação. Isto também quer dizer que uma certa quantidade de quadros poderia ser transmitida enquanto não chega a confirmação do primeiro quadro. Essa melhoria no ARQ se chama controle de fluxo, pois visa regular a quantidade de quadros que podem ser enviados de acordo com a capacidade do meio de transmissão e do sistema destino. O ARQ mais simples que implementa uma forma de controle de fluxo se chama Go-back-N.

Go-back-N transmite até uma certa quantidade de quadros, sem ainda ter recebido uma confirmação do primeiro quadro enviado. À medida que as confirmações forem recebidas, novos quadros podem ser enviados. Esse mecanismo está ilustrado na figura abaixo:

Figura 1: uma possível sequência de transmissão com Go-back-N

Para controlar a quantidade de quadros enviados usa-se a técnica de janela deslizante. A janela é o conjunto de quadros transmitidos e ainda não confirmados, e que precisam ser lembrados para caso seja necessário retransmiti-los. Assim, sempre que um novo quadro é transmitido aumenta-se o tamanho da janela em uma unidade, e quando um quadro é confirmado diminui-se o tamanho da janela em ao menos uma unidade. Há um tamanho máximo para a janela, que corresponde à quantidade máxima de quadros que podem ser transmitidos sem ter ainda uma confirmação de entrega. Esse tamanho máximo de janela é de grande importância para a eficiência do Go-back-N, pois tem influência direta na utilização máxima que pode ser obtida do meio de transmissão.

Um controle com janela deslizante precisa que se numerem os quadros sequencialmente, de forma a representar a ordem em que foram enviados. Assim, quadros fora de ordem não são aceitos no destino (ao menos no caso do Go-back-N). Por razões de praticidade, a quantidade de números de sequência necessária para o Go-back-N é igual ao tamanho máximo da janela + 1. Por exemplo, se o tamanho máximo da janela for 3, são necessários no mínimo 4 números de sequência (ex: 0 a 3). Se a quantidade de números de sequência for igual ao tamanho da janela, pode ocorrer um erro no controle de erros do mecanismo (tente descobrir que erro seria esse ...). A figura abaixo ilustra um exemplo em que se fazem transmissões de quadros com janela de tamanho máximo 3 (a janela a cada instante é destacada em amarelo, e os números correspondem aos números de sequência dos quadros):

Note que, assim como no Stop-and-wait, os quadros de reconhecimentos indicam qual o próximo quadro a ser aceito pelo destino. Além disso, o Go-back-N aceita reconhecimentos cumulativos. Quer dizer, se houver três quadros na janela de transmissão, e for recebido um reconhecimento relativo ao segundo quadro, o transmissor considera que tanto o primeiro quanto o segundo quadro foram recebidos com sucesso. Isto é possível pois nesse ARQ o receptor aceita apenas quadros em ordem.

Desempenho do Go-back-N

Mas qual deve ser a utilização do meio de transmissão com o Go-back-N ? Para responder a essa questão devem-se considerar duas situações:

1. O atraso para receber o primeiro ACK é maior ou igual ao tempo de transmissão para enviar todos os quadros permitidos pelo tamanho máximo de janela: essa situação está mostrada na figura 1, que mostra uma sequência de transmissão. A utilização nesse caso será:
   $U={\frac {N\cdot A_{t}}{A_{t}+2A_{p}+A_{t_{ACK}}}}$
2. O atraso para receber o primeiro ACK é menor que o tempo de transmissão de uma janela de tamanho máximo: nesse caso, a utilização é máxima (= 1), pois todo o atraso de propagação é aproveitado para enviar quadros.

Falta ainda ver o que acontece em situações de erro ...

Análise do mecanismo ARQ Selective Repeat. Análise de seu desempenho, comparado ao Stop-and-wait e Go-Back-N. Análise do desempenho dos mecanismos ARQ na ocorrência de erros. Experiências com um simulador de um enlace ponto-a-ponto.

Selective Repeat

O ARQ Selective Repeat aceita receber quadros fora de ordem, pois o receptor mantém uma janela de recepção com o mesmo tamanho que a janela de transmissão. Assim, o receptor aceita um quadro se seu número de sequência estiver contido na janela de recepção atual. O limite inferior da janela de recepção avança quando chega um quadro com o primeiro número de sequência da janela. Quando o limite inferior da janela avança, os quadros correspondentes são passados para a camada superior.

O desempenho do Selective Repeat, na ausência de erros, é o mesmo do Go-Back-N.

Utilização do meio com Go-Back-N sujeito a erros

Quando ocorrem erros, o Go-Back-N rpecisa reenviar todos os quadros da janela de transmissão. Interessa aqui analisar o desempenho resultante no pior caso, quando a janela de transmissão está cheia. Note que o timeout sempre vai se referir ao quadro mais antigo da janela. Assim, pode-se fazer a análise dividindo o problema em duas partes:

1. A utilização na ausência de erros: é a utilização já calculada anteriormente, que será chamada de $U_{ok}$
2. A utilização no caso da ocorrência de um erro: é a utilização resultante de uma sequência de transmissão (uma janela completa) em que ocorre um erro, e será chamada de $U_{E}$.

A utilização total depende da probabilidade de acontecerem ambas as situações acima. Denominando-se $P_{F}$ a probabilidade da situação 1 acontecer, e $1-P_{F}$ a probabilidade de ocorrer a situação 2, a utilização total pode ser calculada assim:

$U=P_{F}\cdot U_{ok}+(1-P_{F})\cdot U_{E}$

O cálculo exato dessas probabilidades pode ser complicado. Desta forma, será adotada a seguinte simplificação: assume-se que ocorra apenas um erro por janela. Isto é razoável se a taxa de erro de bit (BER) for baixa. Por exemplo, se $BER=10^{-6}$, a probabilidade de 1 ou nenhum erro para uma janela de tamanho 7 é aproximadamente 0.9971, como se pode ver pela tabela abaixo:

Erros	Probabilidades
0	0.919431217477
1	0.0776975138337
2	0.00281396190905
3	$5.66182968546\cdot 10^{-5}$
4	$6.83512778565\cdot 10^{-7}$
5	$4.95094071439\cdot 10^{-9}$
6	$1.99230721763\cdot 10^{-11}$
7	$3.43596004858\cdot 10^{-14}$

Já se $BER=10^{-10}$, a probabilidade de 1 ou nenhum erro é aproximadamente 0.99999999997, como se pode ver nesta tabela:

Erros	Probabilidades
0	0.999991600035
1	$8.39993517541\cdot 10^{-6}$
2	$3.02397872779\cdot 10^{-11}$
3	$6.04796158487\cdot 10^{-17}$
4	$7.25755885699\cdot 10^{-23}$
5	$5.22544594474\cdot 10^{-29}$
6	$2.09017980498\cdot 10^{-35}$
7	$3.5831678264\cdot 10^{-42}$

Isto mostra que, para BER suficientemente baixo, podem-se desprezar as ocorrências de dois ou mais erros por janela.

As probabilidades envolvidas na análise de utilização são:

$P_{F_{DATA}}=(1-BER)^{n_{DATA}}$

$P_{F_{ACK}}=(1-BER)^{n_{ACK}}$

$P_{F}(N)=(P_{F_{DATA}}\cdot P_{F_{ACK}})^{N}$

• $BER$: taxa de erro de bit (Bit Error Rate), ou probabilidade de que um bit sofra erro
• $P_{F_{DATA}}$: probabilidade de um quadro de dados ser enviado sem erros
• $n_{DATA}$: quantidade de bits em um quadro de dados
• $P_{F_{ACK}}$: probabilidade de um quadro de reconhecimento ser enviado sem erros
• $n_{ACK}$: quantidade de bits em um quadro de reconhecimento
• $P_{F}(N)$: probabilidade de uma janela de N quadros ser transmitida sem erros

Nos cálculos de utilização a seguir, está implícito que $P_{F}=P_{F}(N)$.

Quando a utilização na ausência de erros for < 1

Isto acontece quando $N\cdot A_{t}<A_{t}+2\cdot A_{p}+A_{t_{ACK}}$.

$U=N\cdot A_{t}\cdot ({\frac {P_{F}}{A_{t}+2A_{p}+A_{t_{ACK}}}}+{\frac {1-P_{F}}{T_{o}+A_{t}+2A_{p}+A_{t_{ACK}}}})$

$T_{o}:$ timeout de espera por ACK

Lembrar que a fórmula acima somente pode ser usada quando a utilização sem erros for < 1 !

Quando a utilização na ausência de erros for 1

Isto acontece quando $N\cdot A_{t}\geq A_{t}+2\cdot A_{p}+A_{t_{ACK}}$, e a análise muda um pouco. Essa situação ocorre quando o tempo para receber o primeiro ACK é menor ou igual ao tempo para transmitir todos os quadros de uma janela. O cálculo da utilização com erros deve ainda considerar dois casos:

1. Timeout menor que o tempo para envio de uma janela completa ($T_{o}\leq N\cdot A_{t}$):
   $U=P_{F}+{\frac {N\cdot (1-P_{F})}{(N+\lceil {\frac {T_{o}}{A_{t}}}\rceil )}}$
   
   Obs: o operador teto (ceiling), representado por $\lceil x\rceil$, resulta no menor número inteiro que é maior ou igual que seu argumento. Quer dizer, ele arredonda o número para cima.
   
   
2. Timeout maior que o tempo de envio de uma janela completa:
   $U=P_{F}+{\frac {N\cdot A_{t}\cdot (1-P_{F})}{T_{o}+N\cdot A_{t}}}$
   

Utilização do meio com Selective Repeat sujeito a erros

Na presença de erros, o ARQ Selective Repeat proporciona uma utilização melhor que Go-Back-N. Abaixo segue a utilização obtida com Selective Repeat para os possíveis cenários de erros:

Quando a utilização na ausência de erros for < 1

Quer dizer, $N\cdot A_{t}<A_{t}+2\cdot A_{p}+A_{t_{ACK}}$. Nesse caso a utilização é a mesma do Go-Back-N:

$U=N\cdot A_{t}\cdot ({\frac {P_{F}}{A_{t}+2\cdot A_{p}+A_{t_{ACK}}}}+{\frac {1-P_{F}}{T_{o}+A_{t}+2\cdot A_{p}+A_{t_{ACK}}}})$

Quando a utilização na ausência de erros for = 1

Quer dizer, $N\cdot A_{t}\geq A_{t}+2\cdot A_{p}+A_{t_{ACK}}$

Há dois casos a analisar:

1. Timeout maior que o tempo para enviar uma janela completa:
   $U=P_{F}+{\frac {N\cdot A_{t}\cdot (1-P_{F})}{T_{o}+A_{t}+2\cdot A_{p}+A_{t_{ACK}}}}$
2. Timeout menor que o tempo para enviar uma janela completa:
   $U=P_{F}+{\frac {N\cdot (1-P_{F})}{N+1}}$

17/08: Protocolos PPP e HDLC

Detalhes sobre esses protocolos. Ver as transparências:

• PPP
• HDLC
  • Uso do HDLC em missões espaciais (artigo da Nasa)

Resolver a 2a lista de exercícios.

Curiosidade: sockets para camada de enlace

Assim como é possível escrever programas que se comuniquem usando os protocolos UDP, TCP e IP, também se podem criar programas que se comuniquem diretamente usando um protocolo de enlace. Para isso devem-se usar sockets do tipo AF_PACKET (no Linux ... em outros Unix pode ser diferente), que possibilitam enviar e receber quadros por uma interface de rede.

A criação de um socket AF_PACKET pode ser feita da seguinte forma:

  int sd;

  // criação de um socket do tipo AF_PACKET, por onde se enviam e recebe quadros pela camada
  // de enlace. O parâmetro 0x8888 é o identificador de protocolo da camada superior.
  if ((sd = socket(AF_PACKET, SOCK_DGRAM, htons(0x8888))) < 0) {
    perror("Ao criar o socket");
    return 1;
  }

Após criado, o socket deve ser vinculado a uma interface de rede. Dessa forma, os quadros enviados sairão por essa interface, e quadros por ela recebidos serão passados para o socket. A vinculação à interface é feita com a função bind, porém usando-se uma struct sockaddr_ll para especificar a interface e o identificador do protocolo da camada superior. No exemplo abaixo, vincula-se o socket à interface eth0. Além disso, o protocolo de camada superior foi definido pelo número 8888 (esse valor irá aparecer no campo ethertype dos quadros Ethernet).

  // Precisa vincular o socket a uma interface de rede, usando uma "struct sockaddr_ll"
  addr.sll_family = AF_PACKET;
  addr.sll_protocol = htons(0x8888); // apenas um exemplo: protocolo de número 8888
  addr.sll_ifindex = getif(sd, "eth0"); // descobre o numero da interface de rede

  if (addr.sll_ifindex < 0) {
    perror("Interface desconhecida !");
    return 1;
  }

  // vincula o socket a interface de rede
  if (bind(sd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
    perror("Ao fazer bind");
    return 1;
  }

Obs: a função getif, usada acima para obter o número da interface de rede conforme registrado no sistema operacional, foi implementada da seguinte forma:

// Obtém o número de uma interface de rede, conforme registrada no sistema operacional
int getif(int sd, char * ifname) {
  struct ifreq ifr;

  strcpy(ifr.ifr_name, ifname);
  if (ioctl(sd, SIOCGIFINDEX, &ifr) < 0) {
    perror("interface ???");
    return -1;
  }
  return ifr.ifr_ifindex;
}

Tendo o socket criado e vinculado a uma interface, pode-se usá-lo então para enviar e receber quadros.

  // endreço de destino: broadcast Ethernet
  unsigned char dest[6] = {0xff, 0xff,0xff,0xff,0xff,0xff};

  // Envia 100 quadros
  for (i=0; i < 100; i++) {
    int bytes;
    unsigned char msg[SIZE];

    // o conteúdo do quadro (payload) está dentro de msg
    bzero(msg, SIZE);
    strcpy(msg, "12345678910");

    // endereço físico do destinatário, e identificador de protocolo (ethertype)
    addr.sll_protocol = htons(0x8888);
    addr.sll_halen = 6;
    memcpy(addr.sll_addr, dest, 6); // variável "dest" é um vetor que contém o endereço de destino

    // envia um quadro
    if ((bytes=sendto(sd, msg, 100, 0, (struct sockaddr*)&addr, sizeof(addr))) > 0) {
      printf("enviados %d bytes ...\n", bytes);
    }

    // espera 1 segundo
    sleep(1);
  }
  close(sd);

Juntando esses pedaços de programa acima, podem-se criar programas de demonstração do uso de sockets de enlace:

• Programa de envio
• Programa de recepção

Para compilá-los:

gcc -o envio l2-envio.c
gcc -o recepcao l2-recepcao.c

Teste-os rodando o programa de envio em um computador e o de recepção em outro. Eles precisam ser executados com privilégio de administrador, portanto rode-os dentro de máquinas virtuais desta forma:

sudo ./envio eth0

... e ...

sudo ./recepcao eth0

Curiosidade: captura de quadros para análise

Para analisar um protocolo em ação, é necessário capturar suas PDUs e interpretá-las. Programas como tcpdump e wireshark fazem exatamente isso, oferecendo grande riqueza de detalhes e opções de filtragem de PDUs a serem analisadas. Mas como nada é perfeito, esses programas não possibilitam capturar plenamente quadros de protocolos de enlace que não sejam Ethernet (IEEE 802.3) ou WiFi (IEEE 802.11), devido ao mecanismo de captura que eles usam. Quer dizer, algumas informações dos cabeçalhos dos quadros podem ser descartados. Assim, caso se deseje analisar um protocolo como PPP, deve-se escrever um programa de captura.

Os quadros capturados precisam ser gravados em um arquivo para posterior análise pelo wireshark. Segundo a documentação do projeto do wireshark, arquivos de captura devem seguir o formato descrito na libpcap, a biblioteca de captura usada por esse programa. De acordo com a libpcap, esse arquivo tem o seguinte formato:

Como se vê, o arquivo inicia com um cabeçalho global. Em seguida há uma sequência de pares formados pelo cabeçalho de um pacote e seu conteúdo capturado. O formato do cabeçalho global é:

typedef struct pcap_hdr_s {
        guint32 magic_number;   /* magic number */
        guint16 version_major;  /* major version number */
        guint16 version_minor;  /* minor version number */
        gint32  thiszone;       /* GMT to local correction */
        guint32 sigfigs;        /* accuracy of timestamps */
        guint32 snaplen;        /* max length of captured packets, in octets */
        guint32 network;        /* data link type */
} pcap_hdr_t;

Os cabeçalhos de pacotes são definidos por outra struct:

typedef struct pcaprec_hdr_s {
        guint32 ts_sec;         /* timestamp seconds */
        guint32 ts_usec;        /* timestamp microseconds */
        guint32 incl_len;       /* number of octets of packet saved in file */
        guint32 orig_len;       /* actual length of packet */
} pcaprec_hdr_t;

Os detalhes de como usar essas estruturas de dados pode ser visto na descrição do arquivo de captura, no site do wireshark. Um exemplo de como usá-las segue abaixo:

// Cria um arquivo de captura.
//
// char * nome: o nome do arquivo a ser criado
// int snaplen: a quantidade de bytes capturadas em cada pacote
// int link: o tipo de enlace onde foram capturados os pacotes
//
// valor de retorno: o descritor do arquivo aberto (ou NULL em caso de erro)

FILE * create_pcap_file(char * nome, int snaplen, int link) {
  pcap_hdr_t header;
  FILE * f;
  
  header.magic_number = 0xa1b2c3d4;
  header.version_major = 2;
  header.version_minor = 4;
  header.thiszone = 0;
  header.sigfigs = 0;
  header.snaplen = snaplen;
  header.network = link;

  if ((f = fopen(nome, "w")) != NULL) {
    fwrite(&header, sizeof(header), 1, f);
  }

  return f;
}

// Grava um pacote no arquivo de captura.
//
// FILE * f: o descritor do arquivo de captura, criado previamente por create_pacp_file
// unsigned char * msg: o buffer que contém os bytes do pacote capturado
// int bytes: a quantidade de bytes capturados
// int snaplen: a quantidade máxima de bytes capturados

void save_pcap(FILE * f, unsigned char * msg, int bytes, int snaplen) {
  pcaprec_hdr_t header;
  struct timeval tv;
  int maxbytes;

  if (snaplen < bytes) maxbytes = snaplen;
  else maxbytes = bytes;

  gettimeofday(&tv, NULL);
  header.ts_sec = tv.tv_sec;
  header.ts_usec = tv.tv_usec;
  header.incl_len = maxbytes;
  header.orig_len = bytes;
  
  fwrite(&header, sizeof(header), 1, f);
  fwrite(msg, maxbytes, 1, f);
  fflush(f);
}

Os valores para link (tipo de enlace) onde foi realizada a captura são estes:

// Estas definições foram copiadas da biblioteca libpcap
// Coloquei-as aqui para não precisar instalar a biblioteca para
// compilar esse programa, já que ele não a utiliza.

#define DLT_NULL        0       /* no link-layer encapsulation */
#define DLT_EN10MB      1       /* Ethernet (10Mb) */
#define DLT_EN3MB       2       /* Experimental Ethernet (3Mb) */
#define DLT_AX25        3       /* Amateur Radio AX.25 */
#define DLT_PRONET      4       /* Proteon ProNET Token Ring */
#define DLT_CHAOS       5       /* Chaos */
#define DLT_IEEE802     6       /* IEEE 802 Networks */
#define DLT_ARCNET      7       /* ARCNET, with BSD-style header */
#define DLT_SLIP        8       /* Serial Line IP */
#define DLT_PPP         9       /* Point-to-point Protocol */
#define DLT_FDDI        10      /* FDDI */

Atividade

1. Escreva um programa para copiar um arquivo entre dois computadores usando sockets de enlace.
   • Uma introdução sobre arquivos
   • Uma solução para o envio do arquivo (falta a recepção)
2. Faça um programa que captura quadros em uma interface e os grave no formato libpcap, de forma que possam ser posteriormente interpretados e visualizados com wireshark ou tcpdump.

19/08: Enlaces ponto-a-ponto entre roteadores

Nesta aula serão configurados enlaces entre dois roteadores Cisco usando os protocolos PPP e HDLC. O objetivo é ter um contato com esse tipo de equipamento, e ver os protocolos em ação. Além disto, será feita uma medição de vazão (throughput) com cada um dos protocolos.

• Roteiro da experiência
• Tutorial da interface de linha de comando Cisco (CLI)
• Resolução de problemas com PPP em roteadores Cisco

24/08: Introdução à camada física

Ver capítulos 3, 4 e 5 do livro "Comunicação de dados e Redes de Computadores", de Berhouz Forouzan (cópia no xerox).

Ver transparências.

Serviços da camada física:

(Adaptado do livro "Comunicação de Dados e Redes de Computadores, 3a ed.", de Berhouz Forouzan)

Transmissão digital:

• Transmissão serial x paralela
• Transmissão serial síncrona x assíncrona
  • Experiência para comparar esses dois tipos de transmissão serial

Dúvidas nas listas de exercícios

• Prova do semestre 2010-1

Foram corrigidas algumas questões das listas 1 e 2.

A questão 3 da lista 2 despertou uma dúvida sobre como a utilização e a taxa efetiva variam em função tanto do tamanho da janela quanto da taxa nominal, para um mecanismo ARQ Go-Back-N. Foram plotados dois gráficos para ilustrar a dependência entre elas, mostrados abaixo. Eles foram gerados usando estes valores: quadros de 1500 bytes, atraso de propagação de 5 ms, quadros ACK de 8 bytes.

Taxa efetiva em função do tamanho da janela (N) e da taxa nominal

---

Utilização em função do tamanho da janela (N) e da taxa nominal

26/08: 1a avaliação

Engloba as listas de exercícios 1 e 2.

31/08: Modems

Ver transparências sobre modems.

Resolver a 3a lista.

Hoje foi realizada a experiência com modems síncronos, em que se configuram modems SDSL.

• Manual modem DT2048 SHDSL

02/09: Enlaces de teste em modems

Ver transparências.

Roteiro do experimento

09/09: Códigos de linha

Resolver a 4a lista de exercícios.

Ver capítulos 3 e 4 do livro "Comunicação de dados e Redes de Computadores", de Berhouz Forouzan (cópia no xerox).

Ver transparências sobre códigos de linha.

Bom texto sobre modulação digital

Curiosidade: resumo de Redes CAN comentado em aula.

Tarefa individual

A tarefa individual a seguir faz parte da avaliação do segundo módulo da disciplina.

Fazer uma pesquisa sobre a codificação de linha/modulação usadas em aDSL. O texto deve explicar as características elétricas do sinal gerado na linha, a codificação ou modulação adotadas, e quaisquer outras estruturações que porventura existam no sinal; explore o uso de diagramas para ilustrar as informações apresentadas. Por fim, deve descrever também os protocolos de enlace usados e a sequência de encapsulamentos realizada desde o computador do usuário (o cliente aDSL) até o roteador na operadora.

Sua pesquisa deve conter:

• Um resumo (ou abstract), com no máximo 10 linhas, informando o que está contido no texto.
• Uma introdução, contendo a contextualização do serviço aDSL (quando foi criado, a quem se destina, e qual o princípio tecnológico) e indicando que informações serão apresentadas no texto.
• Uma seção sobre a codificação ou modulação usada no aDSL
• Uma seção sobre os protocolos de enlace utilizados, incluindo os encapsulamentos efetuados desde o cliente aDSL e o roteador na operadora.
• Uma conclusão
• A bibliografia utilizada (com referências no texto).

Entrega: 23/09/2010

Conceitos da 1a avaliação

Aluno	Conceito
Anderson	C
Bruna	D
Bruno	D
Diogo	D
Felipe	C
Gustavo	D
Luan	D
Michel	D
Murilo	D
Sant'Clear	C
Vitor	B

14/09: Modems analógicos e Interfaces digitais

• Listas para a avaliação de recuperação:
  • Lista 1 com algumas novas questões
  • Lista 2

Sugestão para a data da recuperação: entre 27/09 e 01/10.

---

Ver capítulo 5 e 6 do livro "Comunicação de dados e Redes de Computadores", de Berhouz Forouzan (cópia no xerox).

Ver transparências sobre modems analógicos.

Ver transparências sobre interfaces digitais.

Durante a aula serão feitas experiências sobre interfaces digitais V.35 e RS-232c.

Trabalho coletivo

Após ver um conjunto de tecnologias de enlace e de camada física, devem existir questões como "afinal, quais tecnologias são usadas de fato atualmente, e quais as apostas para o futuro próximo ?". Para responder a essa pergunta propõe-se um trabalho coletivo de pesquisa para criar uma tabela dessas tecnologias junto com algumas outras informações:

• Que protocolos de enlace estão envolvidos ?
• Qual a codificação ou modulação usada ?
• Em que tipo de circuito é usada (incluindo o tipo de meio de transmissão) ?
• Que equipamentos são necessários (incluindo os modelos) ?
• Quais as taxas de bits nominais e BER que proporcionam ?
• Qual o custo do enlace ?
• Empresa de onde obteve a informação ?

Os resultados da pesquisa devem ser colocados aqui mesmo na Wiki.

16/09: Redes locais

Sobre a avaliação de 23/09: vejam a avaliação de 2009-2 e de 2010-1.

Introdução a redes locais

• Transparências:
  • Introdução
  • LANs e acesso ao meio
• Capítulo 13 do livro "Comunicação de Dados e Redes de Computadores", de Berhouz Forouzan (tem no xerox)
• Capítulo 4 do livro "Redes de Computadores", de Andrew Tanenbaum (tem na biblioteca)

Distinção entre WAN, MAN e LAN

• Aplicações de cada um desses tipos de rede
• Tecnologias envolvidas
• "Backbones" da Internet Brasileira:

Brasil em 1996

RNP 1991,1992,1996,1998,2000,2001,2005,2006, 2007.

Embratel Mapa 1,Mapa 2

Eletronet Mapa Eletronet

Utilização do meio de transmissão em uma rede local, com MAC do tipo CSMA/CD

• Roteiro da experiência
  • Programa emissor: faça o download e compile com o comando:

    gcc -o emissor emissor.c
    

Resultados:

1: 140254390 214015690
2: 214015690 276800590
3: 276800590 336225070
4: 336225070 398761510
5: 398761510 460950490
6: 479962630 544977970
7: 544977970 610117870
8: 690263890 755876470

Plotar um gráfico da quantidade de bytes recebidos X quantidade de estações transmissoras. Na tabela acima, as estações transmissoras estão na 1a coluna, e a quantidade de bytes recebidos deve ser calculada pela subtração da 3a coluna pela 2a coluna.

• • A experiência pode ser feita também com o simulador Omnet++:
    • Intale o Omnet++ 4
    • Instale o modelo INET:

      # Faz o download do INET Framework (aprox. 23 MB)
      wget http://github.com/downloads/inet-framework/inet/inet-20100323-src.tgz
      
      # Descompacta o arquivo
      tar xzf inet-20100323-src.tgz
      
      # Compila o INET
      cd inet
      make makefiles
      make
      

    • Copie esses arquivos para dentro de inet/examples/ethernet/lans:
      mu.ini
      mu2.ini
      Networks.ned
    • Para executar uma simulação interativa, com animação, faça assim:

      cd inet/examples/ethernet/lans
      ./run mu.ini
      

      ... e escolha um dos modelos para executar.
    • Para executar uma simulação não-interativa, com uma bateria de experimentos que variam a quantidade de estações (2 a 16) e tamanhos de quadros (256, 512 e 1480 bytes), faça assim:

      cd inet/examples/ethernet/lans
      ./run -u Cmdenv -c Hub1 mu2.ini
      

    • Os resultados das simulações estarão em arquivos dentro do subdiretório inet/examples/ethernet/lans/results. Por exemplo, o arquivo Hub1-0.sca contém o resultado da primeira simulação, e parte de seu conteúdo é mostrada abaixo (cada linha contém algum resultado ou estatística da simulação, e o título é auto-explicativo):

      version 2
      run Hub1-1-20100423-09:38:33-7627
      attr bytes 256
      attr configname Hub1
      attr datetime 20100423-09:38:33
      attr experiment Hub1
      attr inifile mu2.ini
      attr iterationvars "$bytes=256, $stations=3"
      attr iterationvars2 "$bytes=256, $stations=3, $repetition=0"
      attr measurement "$bytes=256, $stations=3"
      attr network HubLAN2
      attr processid 7627
      attr repetition 0
      attr replication #0
      attr resultdir results
      attr runnumber 1
      attr seedset 1
      attr stations 3
      
      scalar .        bytes   256
      scalar .        stations        3
      scalar HubLAN2.sta[0].cli       "packets sent"  0
      scalar HubLAN2.sta[0].cli       "packets rcvd"  0
      scalar HubLAN2.sta[0].cli       "end-to-end delay mean"         0
      scalar HubLAN2.sta[0].cli       "end-to-end delay stddev"       nan
      scalar HubLAN2.sta[0].cli       "end-to-end delay min"  0
      scalar HubLAN2.sta[0].cli       "end-to-end delay max"  0
      scalar HubLAN2.sta[0].srv       "packets sent"  0
      scalar HubLAN2.sta[0].srv       "packets rcvd"  247453
      scalar HubLAN2.sta[0].srv       "end-to-end delay mean"         1.6121223100944
      scalar HubLAN2.sta[0].srv       "end-to-end delay stddev"       1.0596723502417
      scalar HubLAN2.sta[0].srv       "end-to-end delay min"  0.0002378
      scalar HubLAN2.sta[0].srv       "end-to-end delay max"  5.18103003756
      scalar HubLAN2.sta[0].llc       "dsaps registered"      1
      scalar HubLAN2.sta[0].llc       "packets from higher layer"     0
      scalar HubLAN2.sta[0].llc       "frames from MAC"       247453
      scalar HubLAN2.sta[0].llc       "packets passed up"     247453
      scalar HubLAN2.sta[0].llc       "packets dropped - unknown DSAP"        0
      scalar HubLAN2.sta[0].mac       "simulated time"        60.0001141233
      scalar HubLAN2.sta[0].mac       "txrate (Mb)"   10
      scalar HubLAN2.sta[0].mac       "full duplex"   0
      scalar HubLAN2.sta[0].mac       "frames sent"   0
      scalar HubLAN2.sta[0].mac       "frames rcvd"   247453
      scalar HubLAN2.sta[0].mac       "bytes sent"    0
      scalar HubLAN2.sta[0].mac       "bytes rcvd"    68544481
      scalar HubLAN2.sta[0].mac       "frames from higher layer"      0
      scalar HubLAN2.sta[0].mac       "frames from higher layer dropped (iface down)"         0
      scalar HubLAN2.sta[0].mac       "frames dropped (bit error)"    0
      scalar HubLAN2.sta[0].mac       "frames dropped (not for us)"   0
      scalar HubLAN2.sta[0].mac       "frames passed up to HL"        247453
      scalar HubLAN2.sta[0].mac       "PAUSE frames sent"     0
      scalar HubLAN2.sta[0].mac       "PAUSE frames rcvd"     0
      scalar HubLAN2.sta[0].mac       "frames/sec sent"       0
      scalar HubLAN2.sta[0].mac       "frames/sec rcvd"       4124.2088221947
      scalar HubLAN2.sta[0].mac       "bits/sec sent"         0
      scalar HubLAN2.sta[0].mac       "bits/sec rcvd"         9139246.7499834
      scalar HubLAN2.sta[0].mac       "rx channel idle (%)"   5.937858457565
      scalar HubLAN2.sta[0].mac       "rx channel utilization (%)"    94.031961146038
      scalar HubLAN2.sta[0].mac       "rx channel collision (%)"      0.030180396396893
      scalar HubLAN2.sta[0].mac       collisions      4825
      scalar HubLAN2.sta[0].mac       backoffs        0
      

21/09: Redes locais: desempenho do CSMA/CD/ arquitetura IEEE 802

• Correção de exercícios das listas 3 e 4.

Roteiro do experimento

Desempenho de um MAC CSMA/CD

• Para fins de comparação com o experimento da aula passada, conectar os computadores da bancada no switch (tomadas verdes), e repetir parte das medições (apenas aquelas que envolvem todos os computadores da bancada).

Uma análise feita no capítulo 4 do livro "Redes de Computadores, 4a ed." de Andrew Tanenbaum fornece a seguinte previsão de desempenho para o CSMA/CD em uma rede Ethernet a 10 Mbps.

• Utilização do meio:

$U={\frac {1}{1+{\frac {2BLe}{cF}}}}$

• B: taxa de bits nominal
• L: comprimento do meio de transmissão
• c: velocidade de propagação do sinal
• F: comprimento do quadro

Essa figura mostra curvas para a utilização do meio em função da quantidade de estações prontas para transmitir, e para diferentes tamanhos de quadro. A conclusão é que quadros menores proporcionam desempenho inferior, assim como uma quantidade maior de estações resulta em uma provável menor utilização do meio. No entanto essa análise considera a rede numa situação de carga muito alta, o que não acontece normalmente. Há também algumas simplificações no desenvolvimento da análise, tal como considerar que a probabilidade de retransmissão constante em cada slot, ao invés de analisar o algoritmo de recuo exponencial binário (backoff). Finalmente, esse resultado tem sentido para um meio de transmissão compartilhado, mas a atualmente as redes locais ethernet trabalham com meios de transmissão exclusivos (ethernet comutada e full-duplex, em que não há risco de colisão).

Para fins de comparação, um experimento de simulação foi realizado (conforme descrito na aula anterior), e foram obtidos os resultados mostrados na figura abaixo.

Para esse experimento foram realizadas simulações com os seguintes parâmetros:

• Quadros de 256, 512 e 1480 bytes
• 2 a 45 estações
• Geração de tráfego por estação com intervalos entre quadros dados por uma distribuição exponencial com média 15*tamanho_quadro_em_bits*0.11us (0.11us é o tempo aproximado de um bit)

23/09: 2a avaliação

Envolve o conteúdo sobre Camada Física, e se baseará nas listas de exercícios 3 e 4.

Conceitos

Aluno	Conceito
Anderson	B
Bruna	C
Bruno	C
Diogo	A
Felipe	B
Gustavo	A
Luan	C
Michel	C
Murilo	A
Sant'Clear	D
Vitor	A

28/09: Redes locais: arquitetura IEEE 802

• Arquitetura IEEE 802 e Redes locais IEEE 802.3 (Ethernet)
  • Ver transparências.
  • Capítulo 4 do livro "Redes de Computadores", de Andrew Tanenbaum.
  • Capítulo 14 do livro "Comunicação de Dados e Redes de Computadores", de Behrouz Forouzan.

Desenho usado por Bob Metcalfe, um dos criadores da Ethernet, para apresentação em uma conferência em 1976.

• Detalhamento da norma IEEE 802.3 (Ethernet)

• Experimento:
  • Domínios de colisão e domínios de broadcast
    • Animacões que mostram o tratamento de colisões
  • Visualização de contadores e estatísticas no switch
  • Há colisões em ethernet comutada ?
  • emissor.c e receptor.c

Ver também:

• Ethernet 40 Gbps e 100 Gbps

30/09: Redes locais: arquitetura IEEE 802 e interligação de LANs

Ver 5a lista de exercícios.

• Ver transparências.
• Capítulo 16 do livro "Comunicação de Dados e Redes de Computadores, 3a ed.", de Behrouz Forouzan.
• Capítulo 4 do livro "Redes de Computadores, 4a ed.", de Andrew Tanenbaum.

• Interligação de LANs (norma IEEE802.1D):
  • Operação de pontes e switches (roteiro)
    • Visualizar o aprendizado de endereços em um switch ou ponte (usando o switch D-Link).
    • Visualizar como um switch ou ponte propaga quadros em broadcast.

Emulação de redes locais

Um computador com Linux pode ser transformado em uma ponte ou switch, usando bridge-utils. O utilitário brctl possibilita configurar interfaces do tipo bridge:

• Para criar uma bridge:

  # Cria uma interface de rede do tipo bridge, chamada br0. O nome da interface 
  # pode ser qualquer coisa (ex: br0, ponte1, ...)
  brctl addbr br0
  

• Para adicionar interfaces de rede à bridge br0:

  brctl addif br0 eth0
  brctl addif br0 eth1
  

• Para ver as bridges existentes:

  brctl show
  

• Para ver os endereços MAC reconhecidos atualmente na bridge br0:

  brctl showmacs br0
  

Essas funcionalidades podem ser exploradas no Netkit. Esse conjunto de softwares possibilita a configuração, execução e uso de redes emuladas. Assim, consegue-se criar uma rede de tamanho razoável totalmente por software, e que rode em um único computador. Cada equipamento dessas redes emuladas funciona como um computador Linux, que pode ser configurado para operar como servidor, roteador, switch, uma simples ponte (bridge) ou um firewall. Esses computadores Linux emulados são máquinas virtuais, portanto funcionam como computadores reais.

Netkit

Um sistema para fazer experimentos com redes interligadas por pontes, switches ou roteadores.

• Guia rápido de instalação
• Download
• Para os experimentos abaixo:
  • Fazer experimentos para visualizar como os quadros se propagam entre os segmentos através da ponte.
  • Visualizar como a ponte aprende os endereços das estações de cada segmento.
  • Testar o envio de quadros em broadcast, e observar como a ponte os propaga.
• Exemplos de experimentos: faça o download e descompacte-os; em seguida entre no diretório do experimento, e execute lstart. Para terminar o experimento execute lhalt -q.
  • LAN simples: uma LAN com quatro computadores (pc1, pc2, pc3, pc4). Os computadores virtuais têm IPs 192.168.1.X, sendo X o número computador (ex: pc1 tem IP 192.168.1.1). Use ping para fazer testes de comunicação. Veja o arquivo lab.conf (configuração da rede) e pc1.startup, pc2.startup, pc3.startup e pc4.startup (scripts que configuram cada máquina virtual após o boot).
  • LAN com switch: uma LAN com quatro computadores (pc1, pc2, pc3, pc4) interligados por um switch. O switch é implementado por um computador com Linux com 4 portas ethernet. Ver o arquivo lab.conf e switch.startup.

Tema extra: tecnologias de LAN switches

• Bom texto sobre switches
  • Animação sobre o funcionamento de switches (Cisco)
• Texto sobre tecnologias de switches (store-and-forward e cut-through)
  • Animacão sobre switches cut-through
  • Animacão sobre switches store-and-forward
  • Animacão sobre switches simétricos (todas portas com mesma taxa de bits)
  • Animacão sobre switches assimétricos (portas com diferentes taxas de bits)

• Quais são as características dos switches do laboratório ?
  • D-Link DES-526 (manual)
  • Micronet SP 1658B (manual)
  • 3Com 3224 (especificações)

05/10: Redes locais: interligação de LANs e VLANs IEEE 802.1q

• Ver transparências.
• Capítulo 16 do livro "Comunicação de Dados e Redes de Computadores, 3a ed.", de Behrouz Forouzan.
• Capítulo 4 do livro "Redes de Computadores, 4a ed.", de Andrew Tanenbaum.
• Capítulo 5 do livro "Redes de computadores e a Internet, Uma abordagem Top-Down. 5a edição, de James Kurose.

• VLANs
  • Norma IEEE 802.1q
  • Roteiro da experiência
    • manual do switch D-Link DES-3526
  • Definição de VLANs
  • Criação de VLANs no switch D-Link
  • Visualização do tráfego de VLANs

Quadro ethernet com a TAG IEEE 802.1q

Atividades

• Como visto em 30/09, um computador com Linux pode ser transformado em uma ponte ou switch, usando bridge-utils.

• No Linux também é possível usar VLANs, configuradas com o utilitário vconfig (contido no pacote vlan, que pode ser instalado com sudo apt-get install vlan). Cada VLAN configurada irá criar uma interface virtual correspondente. Ex: para configurar as VLANs 5 e 10 na interface eth0:

  vconfig add eth0 5
  vconfig add eth0 10
  

  Com isto serão criadas as interfaces eth0.5 (interface virtual associada à VLAN 5) e eth0.10 (interface virtual da VLAN 10). Essas interfaces podem ser configuradas com o utilitário ifconfig, como qualquer outra interface de rede. Note que as interfaces eth0.5 e eth0.10 funcionam em modo tagged.
  • Unindo-se o suporte a VLANs com as interfaces do tipo bridge, pode-se transformar um computador Linux em um switch com VLANs. Lembre-se que cada interface bridge define um switch, pois ela interliga duas ou mais interfaces ethernet em nível de enlace. A interface bridge opera assim como uma ponte transparente, com funcionamento conforme descrito na aula de 30/09. Por exemplo, os comandos abaixo transformam um computador com 4 interfaces de rede em um switch, e cria duas VLANs:

    # Os comandos abaixo vão criar um switch de 4 portas, com três delas em modo untagged (eth0, eth1, eth2)
    # e uma em modo tagged (eth3). As interfaces eth0 e eth1 serão postas na VLAN 5 em modo untagged.
    # A interface eth2 será posta na VLAN 10 em modo untagged. A interface eth3 será posta nas VLANs 5 e 10 em modo
    # tagged.
    
    # Cria a interface virtual eth3.5, pertencente a VLAN 5
    vconfig add eth3 5
    
    # Cria a interface virtual eth3.10, pertencente a VLAN 5
    vconfig add eth3 10
    
    # Cria as inerfaces bridge
    brctl addbr vlan5
    brctl addbr vlan10
    
    # Adiciona as interfaces eth0, eth1 e eth3.5 à bridge vlan5
    brctl addif vlan5 eth0
    brctl addif vlan5 eth1
    brctl addif vlan5 eth3.5
    
    # Adiciona as interfaces eth2 e eth3.10 à bridge vlan10
    brctl addif vlan10 eth2
    brctl addif vlan10 eth3.10
    

Netkit

Netkit foi apresentado na aula de 30/09.

• Experimentos com VLAN: observar os quadros com tag nas interfaces que operam em modo tagged. Teste também o isolamento entre VLANs.
• Exemplos de experimentos: faça o download e descompacte-os; em seguida entre no diretório do experimento, e execute lstart. Para terminar o experimento execute lhalt -q.
  • Switch e duas LANs: duas LANs com quatro computadores cada (LAN1 tem IPs 192.168.1.0/24 e contém pc1, pc2, pc3, pc4; LAN2 tem IPs 192.168.2.0/24 e contém pc5, pc6, pc7, pc8). Um switch implementado por um computador com Linux com 9 portas ethernet interliga todos os computadores. No entanto, esse switch separa as duas LANs, como se fossem duas VLANs. O computador pc4 opera como gateway entre as LANs.
  • Switch e duas VLANs: duas VLANs com quatro computadores cada. VLAN 5 tem IPs 192.168.1.0/24 e contém pc1, pc2, pc3, pc4; VLAN 10 tem IPs 192.168.2.0/24 e contém pc4, pc5, pc6, pc7. O switch Linux foi configurado para que a interface eth3 esteja nas VLANs 5 e 10 (i.e. em modo tagged), as interfaces eth0, eth1, eth2 estejam na VLAN 5 em modo untagged, e as interfaces eth4, eth5 e eth6 estejam na VLAN 10 em modo untagged. O computador pc4 opera como gateway entre as VLANs, usando duas interfaces virtuais (i.e. a interface eth0 foi posta nas VLANs 5 e 10 em modo tagged).
  • Dois switches e duas VLANs: duas VLANs com quatro computadores cada. VLAN 5 tem IPs 192.168.1.0/24 e contém pc1, pc2, pc3, pc4; VLAN 10 tem IPs 192.168.2.0/24 e contém pc5, pc6, pc7, pc8. O switch Linux foi configurado para que a interface eth3 esteja nas VLANs 5 e 10 (i.e. em modo tagged), as interfaces eth0, eth1, eth2 estejam na VLAN 5 em modo untagged, e as interfaces eth4, eth5 e eth6 estejam na VLAN 10 em modo untagged. O computador pc4 opera como gateway entre as VLANs, usando duas interfaces virtuais (i.e. a interface eth0 foi posta nas VLANs 5 e 10 em modo tagged). O diagrama abaixo ilustra essa rede:

Leia os arquivos de inicialização switch1.startup, switch2.startup e pc4.startup para entender como foram configuradas as VLANs.

07/10: Redes locais: VLANs IEEE 802.1q; interligação de LANs e protocolo Spanning Tree (STP)

Fazer a 6a lista de exercícios.

• Capítulo 16 do livro "Comunicação de Dados e Redes de Computadores, 3a ed.", de Behrouz Forouzan.
• Capítulo 4 do livro "Redes de Computadores, 4a ed.", de Andrew Tanenbaum.
• Capítulo 5 do livro "Redes de computadores e a Internet, Uma abordagem Top-Down. 5a edição, de James Kurose.

• Continuação da aula de 05/10 sobre VLANs
• Introdução a STP (ver transparências)
• Uma animação sobre STP.
• Um texto explicativo sobre STP
• STP na Wikipedia

• 7a Lista de exercícios

Atividades

1. Experimento com Spanning Tree:
   • Usando os switches do laboratório
   • Usando o Netkit.
     
     Esse segundo experimento implementa esta rede:
     
     
     
     
     1. Iniciar o laboratório do Netkit, com comando lstart
     2. Rodar o tcpdump nas interfaces dos switches:

        tcpdump -i any -ln
        

     3. Em qualquer um dos PC faça um ping para qualquer outro PC. Observe as respostas do ping, e o tráfego mostrado pelo tcpdump.
     4. Em cada um dos switches ative o protocolo STP:

        brctl stp br0 on
        

     5. Observe as respostas do ping, e o tráfego revelado pelo tcpdump.
     6. Veja como ficou a topologia lógica após a ativação do STP. Quer dizer, veja os estados das portas dos switches:

        brctl showstp br0
        

     7. Modifique a prioridade STP dos switches (um número entre 0 e 65535), e veja o resultado na topologia lógica criada pelo STP:

        brctl setbridgeprio br0 PRIORIDADE
        

     8. Pare o ping e tcpdump. Em seguida desative o STP nos switches:

        brctl stp br0 off
        

     9. Execute novamente o tcpdump em todos os switches:

        # N é o número  do switch
        tcpdump -i any -ln -w switchN.cap
        

     10. Reative o STP nos switches:

         brctl stp br0 on
         

     11. Pare o tcpdump, e copie cada arquivo switchN.cap para o diretório /lab de cada switch. Esse diretório corresponde ao diretório do laboratório no sistema Linux real.
     12. Execute o wireshark, e use-o para interpretar os arquivos switchN.cap. Veja as PDUs STP trocadas entre os switches.

14/10: Redes locais: controle de acesso com IEEE 802.1x e VLANs dinâmicas

• Ver transparências
• Capítulo de um livro sobre IEEE 802.1x
• Roteiro da experiência
  • Arquivo de configuração do wpa_supplicant (rco2.conf)

Norma IEEE 802.1x

A norma IEEE 802.1x define um framework para controle de acesso a redes locais IEEE 802, sendo usado tanto em redes cabeadas quanto sem-fio. O propósito dessa norma é criar mecanismos para identificar e autorizar ou não o acesso de um usuário à infraestrutura da rede. Esses mecanismos são implementados em três componentes que forma a estrutura de controle de acesso IEEE 802.1x, mostrada na figura abaixo:

• Supplicant: o cliente que deseja se autenticar. Implementado com um software (ex: wpa_supplicant, xsupplicant).
• Autenticador: o equipamento que dá acesso à rede para o cliente, e onde é feito o bloqueio ou liberação do uso da rede. Implementado em switches e Access Points (no caso de redes sem-fio).
• Servidor de Autenticação: o equipamento que verifica as credenciais fornecidas pelo supplicant, e informa ao autenticador se ele pode ou não acessar a rede. Implementado comumente em um servidor Radius.

A autenticação se faz com protocolos específicos definidos na norma IEEE 802.1x:

• EAP (Extensible Authentication Protocol): protocolo para intercâmbio de informações de autenticação entre supplicant e servidor de autenticação.
• EAPOL (EAP over LAN): protocolo para transportar as PDUs EAP entre supplicant e autenticador.

Existem vários métodos EAP, que correspondem a diferentes mecanismos de autenticação. Assim, o método de autenticação pode ser escolhido de acordo com as necessidades de uma rede.

• EAP-MD5: baseado em login e senha, usa um desafio MD5 para autenticar o usuário.
• EAP-TLS: baseado em certificados digitais X.509, usados para autenticar a rede para o supplicant, e o supplicant para a rede.
• EAP-TTLS: também baseado em certificados digitais, mas somente para autenticar a rede pro supplicant. O supplicant se autentica com algum outro método EAP mais simples, como EAP-MD5.
• ... e muitos outros !

Conceitos da recuperação da 1a avaliação

Aluno	Conceito
Bruna	D
Bruno	B
Diogo	B
Gustavo	A
Luan	D
Michel	D
Murilo	B

2a avaliação: Sant'Clear = C

19/10: IEEE 802.1x e VLANs dinâmicas

• Avaliação do semestre 2009-2

• Finalização do experimento sobre IEEE 802.1x:
  • Roteiro da experiência sobre VLANs dinâmicas

• RCF 3580

Tarefa

Redes Ethernet se tornaram o padrão de fato para redes locais, e estão sendo estendendo a outros domínios. Um caso é o uso dessa tecnologia para redes metropolitanas, conhecido como MetroEthernet. Faça uma pesquisa sobre MetroEthernet, de forma a contemplar o seguinte:

1. Para que cenários ela foi criada ?
2. Que normas a definem ?
3. Como se relaciona com outras tecnologias MAN e WAN, tais como MPLS, TDM (SDH) e ATM ?
4. Que diferenças possui comparada com Ethernet para LANs ?
5. Que abstrações para enlaces foram definidas (ex: E-Line e outras), e em que situações podem ser usadas ?
6. Quais as aplicações de Q-in-Q e M-in-M nessas redes ?
7. Que equipamentos são utilizados (pesquise tipos de equipamentos, com exemplos de fabricantes e modelos) ?

Não esqueça de incluir as fontes bibliográficas em sua pesquisa ! E não se limite a copiar os textos dessas fontes ... interprete as informações sempre que possível e explique com suas palavras.

Dica: ver o MetroEthernet Forum.

Prazo de entrega: 04/11/2010

21/10: WAN: Introdução; Frame-Relay

• Introdução a WAN: conceitos básicos (ver transparências)

• Experimento sobre Frame-Relay
  • Guia da Cisco sobre Frame Relay

Ver também:

• Capítulo 18 do livro Comunicação de Dados e Redes de Computadores, 3a ed., de Behrouz Forouzan.
• Capítulos 12 a 15 do livro Comunicação entre Computadores e Tecnologias de Rede, de Michael Gallo e William Hancock.

26/10: Revisão

Revisão, com correção das listas de exercícios.

• Avaliação de 2010-1

28/10: 3a avaliação

Na sala de aula ...

Conceitos

Aluno	Conceito
Anderson	B
Bruna	D
Bruno	C
Diogo	B
Felipe	C
Gustavo	C
Luan	D
Michel	C
Murilo	B
Sant'Clear	D
Vitor	B

04/11: WAN: Frame-Relay e MPLS

• 8a lista de exercícios

• Referências sobre MPLS:
  • Capítulo 5 (seção 5.4.5) do livro Redes de Computadores, 4a ed., de Andrew Tanenbaum.
  • MPLS Related Notes
  • MPLS Tutorial
  • MPLS na Wikipedia
  • RFC 3031: MPLS Architecture
  • MPLS Label Stack Encoding
• Documentação sobre os experimentos com MPLS (tirados do projeto MPLS-Linux)

• 1o Experimento com MPLS
  • Lab do netkit com o experimento[

Obs: o guia de instalação do Netkit foi visto em aula anterior.

MPLS: Multi Protocol Label Switching

MPLS é um mecanismo para redes de telecomunicações de alto desempenho que encaminha e transporta dados de um nó da rede a outro. Isso se faz por meio de links virtuais entre nós distantes um do outro, semelhante ao conceito de circuitos virtuais. Diversos protocolos podem ser transportados por MPLS, tais como IP e Ethernet (note que o primeiro é um protocolo de rede, mas o segundo é um "protocolo" de enlace). Assim, MPLS se apresenta como uma tecnologia de transporte de dados em redes de longa distância, como ilustrado na figura abaixo.

Simplificadamente, um cabeçalho (shim header) é adicionado a cada PDU a ser transportada pela rede MPLS. O rótulo contém um número identificador chamado de rótulo (label, e similar ao VCI visto em circuitos virtuais), junto com alguns bits de controle. Os roteadores dentro da rede MPLS encaminham essas PDUs com base somente no conteúdo desse cabeçalho, comutando-os de acordo com os valores de rótulo (label switching). Note que MPLS não faz roteamento, e sim comutação de circuitos virtuais: os circuitos devem ser previamente estabelecidos para que o encaminhamento de PDUs entre origem e destino possa ser realizada. Desta forma, MPLS parece ser um protocolo que fica entre as camadas de rede e de enlace, como mostrado na figura a seguir.

---->

O cabeçalho MPLS possui apenas 32 bits, como mostrado abaixo. O valor de rótulo ocupa 20 bits, o que possibilita pouco mais de 1 milhão de diferentes rótulos ($2^{20}$). Há um campo Time To Live (ou simplesmente TTL) com 8 bits, com mesma finalidade que o campo homônimo existente em PDUS IPv4: evitar que um erro de configuração em um roteador faça com que PDUs fiquem circulando eternamente em um loop na rede. O valor desse campo TTL é decrementado por cada roteador que encaminhe a PDU e, se o valor chegar a 0, a PDU é descartada. O campo Exp com 3 bits foi pensado para codificar a classe de serviço da PDU, a qual pode ser usada por mecanismos de qualidade de serviço (QoS) existentes na rede. Por exemplo, o valor de Exp pode ser usado como prioridade da PDU em um determinado roteador dentro da rede MPLS. Por fim, o bit S (bottom of stack) informa se esse é o último cabeçalho MPLS na PDU, uma vez que podem-se empilhar dois ou mais desses cabeçalhos.

A terminologia MPLS possui nomes próprios para diversos componentes da arquitetura. Como ocorre em outras tecnologias, existem conceitos conhecidos apresentados porém com nomes diferentes. A tabela abaixo descreve alguns termos importantes existentes no MPLS:

Termo	Descrição
LSP	Label Switching Path, o análogo a circuito virtual.
LSR	Label Switching Router, ou roteador capaz de comutar PDUs MPLS.
LER	Label Edge Router, ou roteador que faz a interface entre a rede MPLS (onde se encaminham PDUs exclusivamente com base nos rótulos), e a rede externa (onde não se usa MPLS). A rede externa pode ser qualquer outra rede, como IPv4, IPv6 ou mesmo LAN Ethernet. Note que LER é um tipo especial de LSR, e podem ser denominados também como LSR ingress (LSR de entrada na rede MPLS) e LSR egress (LSR de saída da rede MPLS).
LFIB	Label Forwarding Information Base, ou o conjunto de informações existentes nos LSR usadas para fazer o encaminhamento das PDUS MPLS. Pode ser entendida como uma estrutura análoga à tabela de comutação de circuitos virtuais.

Usando os termos acima, podem-se descrever redes MPLS demonstrativas como mostrado a seguir. Na primeira rede há dois LSP: um vai do Host X ao Host Z e está identificado com PDUS em amarelo, e outro vai de Host X ao Host Y e tem PDUs em azul. O número dentro de cada PDU informa os valores de rótulo usados ao longo dos LSP. Assim como em circuitos virtuais em geral (e como em Frame Relay e ATM), os valores de rótulo podem ser modificados por cada roteador que os comute.

Conceitos básicos sobre comutação de rótulos

A comutação de rótulos feita nos LSR é muito parecida com comutação de circuitos virtuais. Ao receber uma PDU MPLS, um LSR decide o que fazer com ela com base no número do rótulo e na interface de rede de onde ela foi recebida. Porém há um detalhe específico do MPLS: uma ou mais interfaces podem ser associadas em um labelspace MPLS, sendo esse labelspace usado para identificar de onde foi recebida uma PDU. Desta forma, um LSR na verdade decide o que fazer com uma PDU com base em seu rótulo e no seu labelspace. Dentro do LSR essa operação se chama ILM (Input Label Mapping).

ILM é a função que identifica uma PDU recebida e mapeia seu rótulo para um labelspace

Um caso especial trata de PDUs que entram na rede MPLS. Por exemplo, uma PDU IPv4, originada de uma rede externa, deve ser transportada pela rede MPLS. Nesse caso, o LER (roteador de borda) deve associar essa PDU a um rótulo MPLS e encaminhá-lo pela rede MPLS. A identificação de uma PDU externa à rede MPLS, com base nas informações dessa PDU, se chama FEC (Forwarding Equivalence Class).

Uma vez identificada uma PDU recebida, o LSR deve encaminhá-la de acordo com instruções predefinidas em sua LFIB. Dentro de sua LFIB essas instruções são chamadas de NHLFE (Next-Hop Label Forwarding Entry), e contêm a operação MPLS a ser realizada e a interface de saída por onde encaminhar a PDU. As operações MPLS possíveis estão descritas na tabela abaixo:

Operação	Descrição
SWAP	Troca o valor de rótulo. Essa operação deve ser usada para comutação dentro da rede MPLS. Mesmo quando o novo valor de rótulo for idêntico ao anterior essa operação deve ser realizada.
PUSH	Adiciona um cabeçalho MPLS com um determinado valor de rótulo. Essa operação deve ser usada principalmente nos LER, quando uma PDU entra na rede MPLS.
POP	Remove o cabeçalho MPLS. Essa operação deve ser usada principalmente nos LER, quando uma PDU sai da rede MPLS.

A comutação fica completa ao se juntarem o mapeamento de entrada (ILM) com as NHLFE, no caso de comutação dentro da rede MPLS. No caso de entrada de PDUs na rede MPLS, a operação se chama FTN (Fec-To-Nhlfe), que nada mais é que regras para associar os rótulos MPLS a essas PDUS. No exemplo da PDU IPv4, pode-se usar o endereço IPv4 de destino dessa PDU para escolher que rótulo MPLS deve ser usado. Isso está sumarizado na figura abaixo.

09/11: WAN: MPLS

• Concluir a atividade da aula anterior.
  • Obs: será necessário reinstalar o netkit ...
    • Se você estiver no laboratório de Redes: (arquivos)
    • Se você estiver em outro lugar: Site do netkit

O exercício proposto em aula - fazer o LSP entre A2 e A1 passar por E5 ao invés de E3 - implica modificar a configuração dos roteadores E2, E3, E4 e E5:

• E4: mudar a NHLFE para que o LSP A2->A1 vá para E5.

  echo 'A2->A1'
  #add label 2000 and forward the packets to E5, for destination A1
  var=`mpls nhlfe add key 0 instructions push gen 2000 nexthop eth0 ipv4 10.0.4.5 |grep key | cut -c 17-26`
  echo key=$var
  
  ip route add 172.16.10.0/24 via 10.0.4.5 mpls $var
  

• E5: fazer a comutação A2->A1 que antes ficava em E3.

  echo 'A2->A1'
  #switching incoming label 2000 to 2001 and then forwarding the packet to E2.
  mpls labelspace set dev eth0 labelspace 0
  mpls ilm add label gen 2000 labelspace 0 
  var=`mpls nhlfe add key 0 instructions push gen 2001 nexthop eth1 ipv4 10.0.1.2 | grep key |cut -c 17-26`
  mpls xc add ilm_label gen 2000 ilm_labelspace 0 nhlfe_key $var
  

• E2: modificar o labelspace 0 para que contenha a interface eth3.

  echo 'A2->A1'
  #expect and pop label 2001
  mpls labelspace set dev eth3 labelspace 0
  mpls ilm add label gen 2001 labelspace 0
  

• E3: removida a configuração da comutação A2->A1

Exemplos de serviços baseados em MPLS em operadoras:

• GVT
• Embratel
• Oi

Para casa

• Ler texto sobre MPLS
• Ler este outro texto sobre MPLS, da Alcatel-Lucent.

11/11: WAN: MPLS

Atividade de hoje: Labelspaces e túneis

• Roteiro sobre labelspaces e túneis MPLS
  • Laboratório do netkit sobre labelspaces
  • Laboratório do netkit sobre túneis

Questão: para que serviria um túnel MPLS ?

Atenção: 4a avaliação

• Trabalho sobre WAN
  • Laboratório do Netkit necessário para o trabalho

OBS (para professor): adicionar aqui referência para comandos de rede do Linux (ifconfig, route, ...)

Conceitos

Aluno	Conceito
Anderson	A
Bruna	D
Bruno	A
Diogo	A
Felipe	D
Gustavo	A
Luan	B
Michel	C
Murilo	A
Sant'Clear	D
Vitor	A

Operações MPLS no Linux

CUIDADO: Não use rótulos entre 0 e 15, pois são reservados (ver detalhes).

As operações MPLS no Linux são definidas por sequências de comandos não muito claros à primeira vista. Assim segue abaixo um rápido guia sobre como realizá-las:

• PUSH: da rede IP para a rede MPLS

  # Cria primeiro um NHLFE que adiciona o rótulo 100, e encaminha a PDU MPLS pela interface eth3. O endereço IP 10.0.1.5 corresponde
  # ao próximo roteador.
  var=`mpls nhlfe add key 0 instructions push gen 100 nexthop eth3 ipv4 10.0.1.5 |grep key | cut -c 17-26`
  
  # Mapeia FEC (Forward Equivalence Class) e NHLFE. FEC é a classificação do tráfego que está entrando na rede MPLS (note 
  # que nesse exemplo trata-se somente de um conceito).
  ip route add 172.16.30.0/24 via 10.0.1.5 mpls $var
  

• POP: da rede MPLS para a rede IP

  # Adiciona a interface eth3 ao labelspace 0
  mpls labelspace set dev eth3 labelspace 0
  
  # Cria um mapeamento de rótulo de entrada (ILM), para receber PDUs com determinado rótulo vindas do labelspace 0
  # Esse comando sozinho faz o POP do rótulo
  mpls ilm add label gen 300 labelspace 0
  

• SWAP: comutando rótulos dentro da rede MPLS

  # Adiciona a interface eth0 ao labelspace 0
  mpls labelspace set dev eth0 labelspace 0
  
  # Cria um mapeamento de rótulo de entrada (ILM), para receber PDUs com determinado rótulo vindas do labelspace 0
  # Esse comando sozinho faz o POP do rótulo
  mpls ilm add label gen 2000 labelspace 0
  
  # Cria NHLFE que adiciona o rótulo 3000, e encaminha a PDU MPLS pela interface eth1. O endereço IP 10.0.6.3 corresponde
  # ao próximo roteador.
  var1=`mpls nhlfe add key 0 instructions push gen 3000 nexthop eth1  ipv4 10.0.6.3 |grep key | cut -c 17-26`
  
  # Faz a comutação de fato: a PDU MPLS identificada pela ILM com rótulo 2000 e vinda pelo labelspace 0 deve ser encaminhada 
  # de acordo com o que estiver determinado na NHLFE acima
  mpls xc add ilm_label gen 2000 ilm_labelspace 0 nhlfe_key $var1
  

• Caso especial: entrada em túnel, que se faz com SWAP e em seguida PUSH:

  # Adiciona a interface eth1 ao labelspace 0
  mpls labelspace set dev eth1 labelspace 0
  
  # Cria um mapeamento de rótulo de entrada (ILM), para receber PDUs com determinado rótulo vindas do labelspace 0
  # Esse comando sozinho faz o POP do rótulo
  mpls ilm add label gen 100 labelspace 0
  
  # Cria NHLFE que adiciona o rótulo 2000, e encaminha a PDU MPLS pela interface eth0.
  var1=`mpls nhlfe add key 0 instructions push gen 2000  nexthop eth0 ipv4 10.0.4.4 |grep key | cut -c 17-26`
  
  # Cria NHLFE que adiciona o rótulo 200, e encaminha a PDU MPLS de acordo com as instruções da NHLFE acima
  # Isto terá o efeito de empilhar o rótulo 2000 sobre o rótulo 200.
  var2=`mpls nhlfe add key 0 instructions push gen 200 forward $var1 |grep key| cut -c 17-26`
  
  # Faz a comutação de fato: a PDU MPLS identificada pela ILM com rótulo 100 e vinda pelo labelspace 0 deve ser encaminhada 
  # de acordo com o que estiver determinado na NHLFE acima
  mpls xc add ilm_label gen 100 ilm_labelspace 0 nhlfe_key $var2
  

• Caso especial: saída do túnel MPLS, quando deve ser feito um POP e em seguida SWAP (obs: se aplica somente ao caso em que a mensagem que sai do túnel deve ir a outro LSR. Se ao sair do túnel também for sair do LSP interno, então deve ser feito outro POP ao invés de SWAP).

  # Adiciona a interface eth1 ao labelspace 0
  mpls labelspace set dev eth1 labelspace 0
  
  # Cria um mapeamento de rótulo de entrada (ILM), para receber PDUs com determinado rótulo vindas do labelspace 0
  # Esse comando sozinho faz o POP do rótulo 3000
  mpls ilm add label gen 3000 labelspace 0
  
  # Cria um mapeamento de rótulo de entrada (ILM), para receber PDUs com determinado rótulo vindas do labelspace 0
  # Esse comando sozinho faz o POP do rótulo 200
  mpls ilm add label gen 200 labelspace 0
  
  # Cria NHLFE que adiciona o rótulo 300, e encaminha a PDU MPLS pela interface eth2
  key=`mpls nhlfe add key 0 instructions push gen 300 nexthop eth2 ipv4 10.0.5.1 |grep key |cut -c 17-26`
  
  # Faz a comutação de fato: a PDU MPLS identificada pela ILM com rótulo 200 e vinda pelo labelspace 0 deve ser encaminhada 
  # de acordo com o que estiver determinado na NHLFE acima.
  # Repare que o comando abaixo irá atuar somente depois que a PDU tiver saído do túnel (i.e. depois que tiver feito o POP 3000)
  mpls xc add ilm_label gen 200 ilm_labelspace 0 nhlfe_key $key
  

Obs: cada interface precisa ser adicionada a um labelspace apenas uma vez

16/11: WAN: MPLS

• Label merging: roteiro do experimento
  • Arquivos do netkit

Label merging ("fusão de rótulos") significa a união de dois ou mais LSP a partir de um roteador. Isso pode ser feito quando os LSP em questão seguem o mesmo caminho a partir desse roteador e possuem o mesmo destino (e são tratados da mesma forma do ponto de vista de engenharia de tráfego).

No exemplo acima, os LSP A1 -> A3 e A2 -> A3 seguem o mesmo caminho a partir do roteador E3. Assim, a partir desse ponto eles podem ser fundidos. Porém os LSP A3 -> A1 e A3 -> A2 não podem ser fundidos, já que os caminhos que eles seguem terminam em destinos diferentes.

18/11: Redes sem-fio: introdução

• Ver transparências
• Ver capítulo 15 do livro Comunicação de Dados e Redes de Computadores, 3a ed., de Behrouz Forouzan.
• Ver capítulo 6 do livro Redes de Computadores e a Internet, 3a ed., de James Kurose.
• Ver capítulo 4 (seção 4.4) do livro Redes de Computadores, 4a ed., de Andrew Tanenbaum.
• Ver este livro on-line sobre redes IEEE 802.11. (precisa do gnochm ou chmsee para ser lido)

Será feito um experimento para configurar, usar e verificar a vazão de uma rede local sem-fio IEEE 802.11. Também será investigado o tráfego nessa rede, usando o analisador de protocolo wireshark.

• Roteiro do experimento

Alguns usos de redes sem-fio

Redes locais sem-fio

Enlaces ponto-a-ponto de média/longa distância

Prover conectividade em ferrovias

Redes de dispositivos acoplados ao corpo de uma pessoa

Redes de sensores

Redes entre veículos (experimental)

23/11: Redes sem-fio: padrão IEEE 802.11

• Ver transparências
• Ver capítulo 15 do livro Comunicação de Dados e Redes de Computadores, 3a ed., de Behrouz Forouzan.
• Ver capítulo 6 do livro Redes de Computadores e a Internet, 3a ed., de James Kurose.
• Ver capítulo 4 (seção 4.4) do livro Redes de Computadores, 4a ed., de Andrew Tanenbaum.
• Ver este livro on-line sobre redes IEEE 802.11. (precisa do gnochm ou chmsee para ser lido)

• Continuaremos o experimento iniciado aula passada:
  • Roteiro do experimento

Resultados do experimento:

• Downstream: 7 fluxos unidirecionais simultâneos de 144 MB enviados do computador do professor (rede cabeada) para os dos alunos (rede sem-fio).
• Upstream: 7 fluxos unidirecionais simultâneos de 144 MB enviados do computador dos alunos para o do professor.
• Comandos usados (usaram-se dd e nc):
  • No computador que recebe o fluxo (X é o número do computador): nc -d -l 150X
  • No computador que inicia o fluxo: dd if=/dev/zero bs=1440 count=100000 | nc 192.168.1.X 150X

Downstream (kB/s)	Upstream (kB/s)
913	624
850	591
832	591
671	475
582	474
???	426
???	180

Por que downstream apresentou melhores resultados ?

25/11: Redes sem-fio: redes ad hoc

• Ver transparências
• Ver capítulo 15 do livro Comunicação de Dados e Redes de Computadores, 3a ed., de Behrouz Forouzan.
• Ver capítulo 6 do livro Redes de Computadores e a Internet, 3a ed., de James Kurose.
• Ver capítulo 4 (seção 4.4) do livro Redes de Computadores, 4a ed., de Andrew Tanenbaum.
• Ver este livro on-line sobre redes IEEE 802.11. (precisa do gnochm ou chmsee para ser lido)

Resolver a 9a lista de exercicios.

Discussão sobre experimento da aula passada.

MAC CSMA/CA (Carrier Sense Multiple Access/Collision Avoidance)

O CSMA/CA definido na norma IEEE 802.11 implementa um acesso ao meio visando reduzir a chance de colisões. Numa rede sem-fio como essa, não é possível detectar colisões, portanto uma vez iniciada uma transmissão não pode ser interrompida. A detecção de colisões, e de outros erros que impeçam um quadro de ser recebido pelo destinatário, se faz indiretamente com quadros de reconhecimento (ACK). Cada quadro transmitido deve ser reconhecido pelo destinatário, como mostrado abaixo, para que a transmissão seja considerada com sucesso.

Envio de um quadro de dados, com subsequente reconhecimento (ACK)

O não recebimento de um ACK desencadeia uma retransmissão, de forma parecida com o procedimento de retransmissão do CSMA/CD ao detectar colisão. Antes de efetuar uma retransmissão, o MAC espera um tempo aleatório denominado backoff (recuo). Esse tempo é sorteado dentre um conjunto de possíveis valores que compõem a Janela de Contenção (Cw - Contention Window), representados no intervalo [0, Cw]. O valor de Cw varia de $Cw_{min}$ (15 para IEEE 802.11g e 31 para 802.11b) a $Cw_{max}$ (1023), e praticamente dobra a cada retransmissão de um mesmo quadro. A figura abaixo ilustra as janelas de contenção para retransmissões sucessivas.

Backoff para retransmissões sucessivas

Uma diferença importante com relação ao CSMA/CD se refere ao caso em que uma estação tem um quadro para transmitir, mas encontra o meio ocupado. No CSMA/CD essa estação iria aguardar até que o meio se tornasse ocioso, e então transmitiria imediatamente o quadro. No CSMA/CA, porém, a estação faz obrigatoriamente um backoff assim que o meio se torna livre (usando $Cw_{min}$ como valor de Cw). Além disso, se durante a espera do backoff o meio voltar a ficar ocupado, o decremento do backoff é pausado até que o meio fique ocioso novamente. Esses procedimentos têm por objetivo reduzir a chance de colisão nessa situação. Se uma estação estiver aguardando o meio ficar ocioso, há uma boa chance de outra estação estar fazendo a mesma coisa. Se essas estações transmitissem assim que o meio se tornasse ocioso, fatalmente ocorreria uma colisão. Assim, com o CSMA/CA o acesso ao meio por um conjunto de estações ocorreria como mostrado na figura abaixo.

Juntando tudo, pode-se descrever em alto-nível o algoritmo do CSMA/CA (simplificando alguns detalhes) com o fluxograma abaixo:

Fluxograma para MAC CSMA/CA em modo contenção (função DCF). Esse fluxograma não mostra as esperas de intervalos entre quadros (IFS). Cw significa Janela de Contenção (Contention Window), e Cwmin é seu valor mínimo definido na norma (15 no caso do IEEE 802.11g, e 31 para IEEE 802.11b).

Um último detalhe sobre o CSMA/CA trata dos intervalos entre quadros (IFS - Inter Frame Space), que são tempos mínimos que um nodo deve esperar antes de transmitir um quadro, após o meio se tornar ocioso. Sua finalidade é priorizar o acesso ao meio para certos tipos de quadros, que têm urgência para serem enviados. Esse é o caso de quadros de confirmação (ACK) e CTS (Clear To Send). Um IFS menor corresponde a uma maior prioridade de transmissão de quadro. A figura abaixo ilustra os tipos de IFS:

Intervalos entre quadros

• SIFS (Short Interframe Space): intervalo mais curto, usado antes do envio de quadros ACK e CTS.
• PIFS (PCF Interframe Space): intervalo intermediário, usado quando em modo PCF (Point Coordination Function). O modo PCF implementa um tipo de acesso ao meio mestre-escravo. Raramente encontrado em equipamentos.
• DIFS (Distributed Interframe Space): intervalo usual, aplicado no início de transmissões em geral (quadros de dados, associação, autenticação, RTS).

• Simulações (animações) sobre CSMA/CA:
  • Algumas animações sobre CSMA/CA (University of Teeside - UK)
  • CSMA/CA sem nodos escondidos (Kurose)
  • CSMA/CA com nodos escondidos (Kurose)

Desempenho estimado do MAC CSMA/CA

• Temporização: tempos envolvidos na operação do MAC
  

Parâmetros usados pelo MAC CSMA/CA

Deve-se usar a análise do desempenho do stop-and-wait para estimar qual a melhor utilização possível com CSMA/CA num cenário ideal. Tal cenário seria descrito assim:

• apenas uma estação transmite quadros (fluxo unidirecional)
• não ocorrem erros
• os quadros de dados têm sempre tamanho máximo = 1534 bytes, com payload de 1500 bytes.
• os quadros ACK têm 14 bytes
• assume-se taxa nominal de 54 Mbps, com SIFS = 13 us, DIFS = 31 us, slot = 9 us e $Cw_{min}=15$
• há um tempo adicional de 26 us usado para preâmbulo e outros detalhes da camada física (PHY):
  • preâmbulo: 20 us
  • signal extension (trailer PHY): 6 us

Redes Ad Hoc

• Roteiro do experimento

• Ausência de uma estação base (ou Access Point)
• Cada estação pode se comunicar diretamente com qualquer outra estação em seu alcance
• Problemas dos nodos escondidos e expostos se manifestam intensamente
• Demandam roteamento especializado (ex: AODV, OLSR)

Podem possibilitar a criação de uma rede local temporária em um ambiente previamente sem infraestrutura (AP)

Podem formar redes temporárias entre equipamentos móveis

Podem ser usadas como base para aplicações inovadoras, como redes veiculares

Problemas sobre nodos escondidos e expostos

1. De acordo com a rede sem-fio em modo ad hoc mostrada na figura abaixo, identifique (assuma que o MAC seja o CSMA/CA):
   • Que estações não conseguem transmitir simultaneamente, devido ao problema dos nodos expostos
   • Para cada estação, identifique todas as estações que podem transmitir simultaneamente (independente da estação destino)
     
     
     
2. Faça a mesma análise para a rede mostrada abaixo:
   
   

30/11: Redes sem-fio: Segurança em redes IEEE 802.11

• Transparências
  • Capítulo de um livro sobre IEEE 802.1x
  • Uma análise sobre a segurança WEP
  • Ver capítulos 5, 6 e 7 do livro sobre IEEE 802.11
  • Ver capítulo 8 (seção 8.6.4) do livro Redes de Computadores, 4a ed. de Anndrew Tanenbaum.
  • Bom artigo sobre segurança em redes sem-fio
  • The Unofficial 802.11 Security Web Page

• Roteiro do experimento
  • Arquivos para o wpa_supplicant
  • Aircrack-ng (software para quebrar chaves WEP e WPA-PSK)
    • Um guia rápido para quebra de chaves WEP
    • Um tutorial sobre como quebrar WPA/WPA2

Redes sem-fio oferecem muitos atrativos, como acesso ubíquo, ausência de cabeamento e suporte a usuários móveis. Mas também se sujeitam a uso indevido, uma vez que pessoas não-autorizadas no alcance do sinal do ponto de acesso podem tentar usá-la para se comunicarem. Em geral três questões fundamentais aparecem no que diz respeito à segurança em redes sem-fio:

1. Acesso indevido: uso indevido da infraestrutura por pessoas não-autorizadas.
2. Monitoramento do tráfego da rede: os quadros na rede sem-fio podem ser coletados e interpretados, com possível roubo ou revelação de informação sensível.
3. Infiltração de equipamentos na rede: um ou mais pontos de acesso podem ser infiltrados na rede sem-fio (chamados de Rogue AP), fazendo com que pessoas os utilizem para se comunicarem. Assim, o tráfego dessas pessoas pode passar por outra rede, sendo passível de monitoramento.

Por exemplo, redes em locais densamente ocupados (como edifícios) podem ser investigadas por alguém em busca de uma rede aberta ou fácil de ser invadida. Essa pessoa pode simplesmente querer usar o acesso à Internet disponível em alguma rede sem-fio, ou mesmo invadir os equipamentos existentes em tal rede. A figura abaixo mostra a técnica de WarDriving, em que uma pessoa investiga a existência de redes sem-fio a partir de um carro que trafega pelas ruas.

Existem inclusive símbolos (warchalking) usados para indicar em ruas e edifícios a existência de redes sem-fio abertas. Esta rápida explicação sobre warchalking foi obtida em um artigo sobre WarChalking:

 O warchalking foi criado pelo web designer Matt Jones que, enquanto almoçava com dois amigos, viu alguns estudantes
utilizando conexões wireless para trabalhar a partir de uma praça pública, como se fosse um escritório. Um dos amigos de 
Matt lembrou-se de uma “linguagem” de sinais utilizada por mendigos e viajantes com o objetivo de informar onde poderiam 
achar comida grátis, uma cama confortável ou até mesmo encrenca, e surgiu a idéia de demarcar a presença de redes wireless 
com sinais parecidos.

Os símbolos do warchalking são:

Assim, uma rede sem-fio minimamente bem configurada deve usar mecanismos de segurança que impeçam ou dificultem seu uso indevido. Em um cenário usual, tal rede sem-fio poderia se apresentar como mostrado abaixo:

Para tratar essas questões, deve haver mecanismos de segurança que contemplem os seguintes requisitos:

1. Autenticação de usuários: usuários da rede sem-fio devem se identificar (ou autenticar) na infra-estrutura dessa rede, de forma a se autorizarem ou não seus acessos.
2. Sigilo das comunicações: o tráfego na rede sem-fio deve ser encriptado, para que não seja inteligível caso sejam capturados por usuários mal-intencionados que estejam monitorando a rede sem-fio.
3. Autenticação dos pontos de acesso: pontos de acesso devem se identificar para os usuários, para evitar a infiltração de pontos de acesso indevidos na rede.

Há mecanismos de segurança usados em redes IEEE 802.11 que contemplam todos os requisitos acima (WPA-EAP, WPA Enterprise), ou parcialmente (WPA-PSK ou WPA Personal). WPA-EAP aproveita a infraestrutura IEEE 802.1x, junto com técnicas de encriptação entre estações sem-fio, para atender esses requisitos. Já WPA-PSK usa apenas as técnicas de encriptação, não havendo um controle de acesso baseado em usuário. Na figura abaixo se mostra uma pequena rede sem-fio que usa WPA-EAP.

Além dos mecanismos WPA, definidos na norma IEEE 802.11i, outra forma de implantar controle de acesso em redes sem-fio se vale de um portal de captura. Quando um usuário não identificado acessa a rede, o acesso ao ponto de acesso é concedido mas ao tentar navegar na Web seu acesso é desviado para uma página predefinida. Nessa página o usuário deve se identificar (ex: com login e senha), e em caso de sucesso seu acesso à Internet é liberado. Essa técnica se vale de uma combinação de mecanismos (firewall com filtro IP, serviço Web, uso de programas para autenticação) para controlar o acesso dos usuários. No entanto, não provê sigilo das comunicações nem autenticação de pontos de acesso ao usuário. Sua atratividade reside na simplicidade de implantação e uso (não necessita de supplicant), sendo uma escolha comum em hot spots como aeroportos e cyber cafes. No Projeto Integrador 2009.2 as equipes implantaram uma infra-estrutura que usava essa técnica.

02/12: Redes sem-fio: Segurança em redes IEEE 802.11

• Transparências
  • Capítulo de um livro sobre IEEE 802.1x
  • Uma análise sobre a segurança WEP
  • Ver capítulos 5, 6 e 7 do livro sobre IEEE 802.11
  • Ver capítulo 8 (seção 8.6.4) do livro Redes de Computadores, 4a ed. de Anndrew Tanenbaum.

• Roteiro do experimento
  • Arquivos para o wpa_supplicant
  • Aircrack-ng (software para quebrar chaves WEP e WPA-PSK)
    • Um guia rápido para quebra de chaves WEP
    • Um tutorial sobre como quebrar WPA/WPA2
    • Bom texto sobre IEEE 802.1X em redes sem-fio

Continuação do experimento da aula anterior (faltou WPA-EAP e portal de captura - Captive Portal), e avaliação do projeto sobre WAN.

• Exemplo de portal de captura implantado no Projeto Integrador 2009.2 do Curos Técnico em Redes

07/12: Redes sem-fio: transição entre BSS em rede infra-estruturada (handover)

• Ver capítulos 8, 20, 21, 23 e 25 do livro sobre IEEE 802.11
• Ver capítulo 8 (seção 8.6.4) do livro Redes de Computadores, 4a ed. de Anndrew Tanenbaum.
• Resolver a 10a lista de exercícios

• Roteiro do experimento

Autenticação e associação

Originalmente foi definido na norma IEEE 802.11 que uma estação precisa se autenticar e associar a um BSS para poder transmitir dados. Em sua forma mais simples, esses procedimentos demandam apenas quatro quadros de controle no total, sendo dois para cada operação. A sequência de autenticação em sua forma mais simples é denominada Autenticação aberta, mostrada abaixo:

Autenticação aberta

Como se pode ver, chamar essa operação de autenticação é forçar o uso desse termo porque o AP (que controla o BSS) não confere a identidade informada pela estação. Assim, outra forma de autenticação foi criada para conferir a informação passada pela estação, além de negociar chave de encriptação para ter o sigilo das comunicações. Esse novo método se chama Autenticação com chave compartilhada, sendo implementado pelo WEP (e lembre que isso é inseguro e não deve ser usado em redes reais ;-):

Autenticação com chave compartilhada

Note que no caso de se usar WPA ou WPA2, a autenticação é transferida para depois da associação. Porém, por compatibilidade com o que foi definido originalmente na norma, deve-se efetuar a autenticação aberta antes da associação.

Uma vez estando a estação em estado autenticado, deve ocorrer a associação com o AP. Na associação o AP registra a existência da estação de forma que o sistema de distribuição (DS, que interliga os AP) saiba em que AP se encontra essa estação e possa assim lhe encaminhar quadros. A norma IEEE 802.11 proíbe explicitamente a associação a mais de um AP simultaneamente.

Associação com AP

Transição de BSS

Em redes IEEE 802.11 com mais de um AP, para ampliar a área de cobertura, estações que se movimentam podem precisar migrar de um AP para outro. Essa operação se chama transição de BSS (também conhecida como handover ou roaming).

A transição se desencadeia quando o sinal do enlace com o AP atual tem sua qualidade abaixo de um determinado limiar. Isso faz com que um novo AP seja procurado (varredura, ou scanning). Ao escolher um novo AP, a estação precisa nele se autenticar e associar. A autenticação depende do método usado (aberto, WPA-PSK à esquerda, ou WPA-EAP à direita)

Como se pode deduzir, a transição feita dessa forma não é imediata. Na verdade, ela pode demorar muitos segundos ! Esse atraso de transição pode influenciar negativamente nas comunicações em andamento, uma vez que a transição costuma ocorrer quando o sinal está com baixa qualidade (causando perdas de quadros), além da demora para se completar. Esforços vêm sendo feitos atualmente para reduzir o atraso de transição, e dentre eles a norma IEEE 802.11r propõe um mecanismo para acelerar a autenticação. Porém o atraso de varredura ainda está por melhorar ...

A qualidade do sinal depende da modulação usada (e da taxa de dados), assim o limiar entre um BSS e outro depende de como as estações medem a qualidade de sinal e quais as taxas mínimas aceitáveis. A figura abaixo ilustra possíveis alcances para diferentes taxas de dados.

Taxas em função da distância do AP (exemplo, pois depende das condições do ambiente e dos equipamentos)

Esta outra figura ilustra as taxas em função da distância para um cenário sem obstáculos, e assumindo alguns parâmetros típicos de equipamentos (ver o capítulo 23 do livro "802.11 Wireless Networks The Definitive Guide").

Assim, a cobertura de uma área envolve um planejamento que leve em conta as taxas mínimas desejáveis e as características dos equipamentos (potências de transmissão e ganhos de antenas) e do ambiente (existência de obstáculos, reflexões, e fontes de ruído). Além disso, deve-se minimzar a interferência entre BSS vizinhos, o que pode ser feito escolhendo-se canais que não se sobreponham. A figura abaixo mostra conceitualmente como se podem escolher os canais dos AP para atingir esse objetivo.

Desta forma, podem-se criar BSS para cobrir uma área e aproveitar melhor a capacidade do meio de transmissão.

Medição da qualidade de enlace

Em um forum encontrou-se o seguinte questionamento:

Hello,


the 802.11 standard specifies that link quality should be (for DSSS modulation) calculated from the correlation value obtained 
when code lock is achieved between the local PN code and the incoming PN codes.

In practice however I am convinced that Wi-Fi cards' producers do not calculate it in this way but rather by the percentage of 
correctly recieved bits or as the difference between signal strength and noise level.

I am currently doing some research on the possibility of using a 802.11 signal in a Wi-Fi LAN for locational purposes and I 
would like to consider all the information available to estimate a terminal's position. That includes, signal strength, noise 
level and link quality. However I cannot use link quality if I am not sure of how it is calculated.

Does anyone know how I can find a Wi-Fi card whose vendors specify their method of determining the link quality? Or a card from 
which I can extract a link quality according to the definition of the standard?

Há também um outro bom texto, com explicações sobre muitos termos usados quando se trata da qualidade do link (tais como RSSI e SNR). Um tanto comprido, por isso não o copiei aqui.

O texto acima questiona como se faz a medição de qualidade de enlace em uma rede sem-fio IEEE 802.11. Nele se observa que a norma define como se deve fazer isso, mas os fabricantes provavelmente não seguem isso à risca. Partindo desse texto, pesquise como um determinado fabricante ou modelo de interface de rede faz essa medição (ex: Atheros, D-Link, Ralink, Intel, Broadcom, ...).

09/12: Outras tecnologias sem-fio

Ficam como sugestão de pesquisa essas tecnologias para WPAN (Wireless Personal Area Network). Procurem comparar as definições dessas tecnologias (em particular MAC e PHY) com o que estudamos sobre IEEE 802.11.

• Bluetooth (IEEE 802.15.1)
• UWB (IEEE 802.15.3)
• Zigbee (IEEE 802.15.4)

Hoje faremos uma revisão, com resolução das listas de exercícios.

• 9a lista
• 10a lista

14/12: 5a avaliação

• Provas de recuperação de semestres anteriores

Conceitos

Aluno	Conceito
Anderson	B
Bruna	D
Bruno	D
Diogo	C
Felipe	D
Gustavo	B
Luan	D
Michel	D
Murilo	C
Sant'Clear	D
Vitor	B

Conceitos do semestre

Aluno	1a avaliação	2a avaliação	3a avaliação	4a avaliação	5a avaliação	Conceito parcial
Anderson	C	B (A)	B	A	B	B
Bruna	D	C (B)	D	D	D	D!
Bruno	B	C (B)	C	A	D	D?
Diogo	B	A	B	A	C	B
Felipe	C	B	C	B	D	D?
Gustavo	A	A	C	A	B	B
Luan	D	C	D	B	D	D?
Michel	D	C	C	C	D	D?
Murilo	B	A	B	A	C	B
Sant'Clear	C	D	D	D	D	D!
Vitor	B	A	B	A	B	B

Obs: no caso de conceito parcial D:

• D! significa reprovação em definitivo, por frequência insuficiente
• D? significa que pode ser revertido na recuperação

Obs 2: entre parênteses o conceito da avaliação somado a de trabalhos que foram pedidos:

• aDSL na 2a avaliação
• Metroethernet na 3a avaliação

Recuperação da 4a avaliação

ATENÇÃO: prazo final é 20/12 (2a feira) às 11:00 h, quando deve ser apresentado pessoalmente.

Deve-se fazer o trabalho sobre WAN, porém considerando a seguinte rede:

• arquivos do Netkit necessários.