Redes

O panorama geral e as palavras de que precisamos

Antes das camadas, vamos combinar algumas palavras. Elas voltam em todas as seções, então vale conhecê-las uma vez, com calma.

As redes têm tamanhos. Uma LAN (rede local) cobre uma sala, uma casa ou uma escola. Uma WAN (rede de longa distância) cobre cidades ou países. A Internet não é uma rede só: são milhões de redes ligadas por roteadores, todas falando a mesma família de protocolos, chamada TCP/IP.

Camadas: os modelos de referência OSI e TCP/IP

Imagine que você quer mandar um cartão de aniversário para um amigo em outro país. Você escreve, um atendente coloca num envelope com endereço, um caminhão leva ao aeroporto, um avião voa e outro carteiro entrega. Ninguém faz o trabalho todo, e cada ajudante só precisa conhecer a sua parte. As redes funcionam assim, e cada ajudante se chama camada.

Uma camada oferece um serviço à camada de cima: uma promessa do que ela sabe fazer, como 'eu levo o seu pacote até a próxima máquina'. Para cumprir a promessa, a camada conversa com a mesma camada da outra máquina usando um protocolo: as regras e os formatos de mensagem que os dois combinaram. O serviço diz o que é oferecido. O protocolo diz como os dois lados fazem. Como são coisas separadas, dá para trocar o protocolo de uma camada (por exemplo, usar outro cabo) sem mexer nas camadas vizinhas.

O modelo OSI tem sete camadas. O modelo TCP/IP tem quatro: enlace, internet, transporte e aplicação. As duas camadas do meio do OSI, sessão e apresentação, tiveram pouca utilidade prática, então no TCP/IP o trabalho delas fica a cargo de cada aplicação. Um resumo clássico: o OSI é um bom modelo cujos protocolos nunca pegaram, enquanto o TCP/IP tem protocolos que conquistaram o mundo, mas um modelo que só descreve bem a si mesmo (ele não separa com clareza serviço, interface e protocolo).

Encapsulamento: envelopes dentro de envelopes

Quando uma mensagem desce pela pilha, cada camada coloca o que recebeu dentro do seu próprio envelope, chamado cabeçalho (header), e às vezes também um final (trailer). No destino acontece o contrário: cada camada abre o seu envelope, lê e entrega o que está dentro para a camada de cima. Isso é o encapsulamento. Uma camada nunca precisa entender o que há dentro do envelope que ela carrega.

Origem                              Destino

[ Mensagem ]                        [ Mensagem ]
   |  + cabeçalho de aplicação         ^  - removido
[CA|Mensagem]  (aplicação)
   |  + cabeçalho de transporte        ^
[CT|CA|Mensagem]  (segmento)
   |  + cabeçalho de rede (pacote)     ^
[CR|CT|CA|Mensagem]
   |  + cabeçalho/final de enlace      ^
[CE|CR|CT|CA|Mensagem|FE] --bits--> fio

Cabeçalhos custam espaço. A sobrecarga (overhead) é a parte dos bytes enviados que são cabeçalhos: total de cabeçalhos dividido pelo total enviado. Se a aplicação escreve 400 bytes e quatro camadas acrescentam 50 bytes de cabeçalho cada uma, a sobrecarga é 200 / 600, ou seja, um terço. Quanto menor a mensagem, mais pesam os cabeçalhos.

Comutação de circuitos e comutação de pacotes

• Comutação de circuitos (telefone antigo): antes de falar, reserva-se um caminho de ponta a ponta. Ninguém mais usa essa capacidade, mesmo quando você está em silêncio. Boa qualidade, mas desperdício para tráfego em rajadas.
• Comutação de pacotes (a Internet): a mensagem é cortada em pacotes que dividem os enlaces. Cada roteador recebe o pacote inteiro, guarda e só depois o envia adiante (store-and-forward). É eficiente quando o tráfego vem em rajadas. O preço é o atraso variável, porque pacotes podem esperar numa fila, e a perda de pacotes quando a fila enche.

Quanto tempo um pacote leva?

O atraso em um enlace tem duas partes separadas. O tempo de transmissão é quanto se leva para colocar todos os bits no fio: tamanho do pacote em bits dividido pela taxa do enlace. O atraso de propagação é quanto um bit leva para percorrer o fio: distância dividida pela velocidade do sinal (cerca de 200.000 km/s em cabo ou fibra). O último bit chega depois da soma dos dois. Convenção do quiz: ambos são contados a partir do instante em que o primeiro bit começa a sair do remetente.

pacote = 500 bytes = 4000 bits, enlace = 2 Mbps, distância = 3000 km
transmissão = 4000 bits / 2.000.000 bps = 0,002 s = 2 ms
propagação  = 3000 km / 200.000 km/s    = 0,015 s = 15 ms
o último bit chega após 2 + 15 = 17 ms

A camada física: transformar bits em sinais

O andar de baixo tem um trabalho simples: pegar bits e fazer algo viajar por um meio, para que o outro lado consiga lê-los de novo. Ele não sabe o que os bits significam. Só se importa com tensões elétricas, luz e ondas de rádio.

O cobre carrega eletricidade, então raios, motores e cabos próximos acrescentam ruído, e o sinal fica mais fraco (atenuação), principalmente em frequências altas. A fibra carrega luz, e o ruído elétrico não a perturba. Por isso os enlaces longos e rápidos usam fibra.

Baud e taxa de bits

A taxa de símbolos, medida em baud, é quantas vezes por segundo o sinal muda. Se cada símbolo pode ter V estados diferentes, um símbolo carrega log₂ V bits. Então taxa de bits = baud × log₂ V. Um sinal com 8 estados e 1.000 mudanças por segundo carrega 3 bits por símbolo, ou seja, 3.000 bits por segundo. Baud e bits por segundo só são iguais quando há dois estados.

Sentidos de um enlace

• Simplex: um sentido só (como a transmissão de TV).
• Half-duplex: os dois sentidos, mas um de cada vez (como um walkie-talkie: diz-se 'câmbio').
• Full-duplex: os dois sentidos ao mesmo tempo (como uma ligação telefônica). O Ethernet comutado de hoje é full-duplex; o antigo cabo compartilhado era half-duplex.

Qual a velocidade máxima de um canal?

Dois limites famosos respondem a isso. Largura de banda aqui significa a largura da faixa de frequências que o canal deixa passar, medida em hertz (Hz). Nyquist vale para um canal perfeito, sem ruído: dá para enviar no máximo 2B símbolos por segundo, então, com V níveis, o máximo é 2B log₂ V bits por segundo. Shannon vale para um canal real, com ruído: o máximo é B log₂(1 + S/N), qualquer que seja o número de níveis. S/N é a potência do sinal dividida pela potência do ruído. Costuma ser dada em decibéis: dB = 10 log₁₀(S/N), então 10 dB é 10 vezes, 20 dB é 100 vezes e 30 dB é 1.000 vezes.

Nyquist: B = 4 kHz, V = 4 níveis
  máx = 2 * 4000 * log2(4) = 2 * 4000 * 2 = 16.000 bps

Shannon: B = 2 kHz, 20 dB -> S/N = 100
  máx = 2000 * log2(1 + 100) = 2000 * 6,66 = cerca de 13.300 bps

Canal real com os dois limites: vale o menor (13.300)

Enviando bits: codificação e relógios

O receptor precisa saber onde um bit termina e o próximo começa, mas não existe um fio separado com o relógio do remetente. A codificação Manchester põe o relógio dentro dos dados: todo bit tem uma transição no meio do seu intervalo, e a direção dessa transição (para cima ou para baixo) diz se o bit é 0 ou 1. Qual direção significa o quê depende do padrão. O preço é que o sinal muda duas vezes mais, então precisa de cerca de o dobro da largura de banda. O Ethernet clássico a usava. A forma simples, o NRZ, usa uma tensão para 1 e outra para 0, então uma longa sequência de bits iguais vira uma linha reta e o relógio se perde.

bits:        1 1 1 1 1 0
NRZ:         ---------\_   (um nível parado por 5 bits:
                           onde começa cada bit?)
Manchester:  uma mudança no meio de TODO bit

Dividindo um canal: multiplexação

• FDM (divisão de frequência): cada sinal ganha sua própria faixa de frequências, como estações de rádio em pontos diferentes do dial.
• TDM (divisão de tempo): os sinais se revezam, cada um no seu intervalo de tempo.
• CDM / CDMA (divisão de código): todos falam ao mesmo tempo na mesma faixa, mas cada estação multiplica seus bits por um código próprio (uma sequência de chips). Os códigos são ortogonais: o produto interno entre eles é zero.

O CDMA é como uma festa em que as pessoas falam línguas diferentes: você sintoniza o ouvido na sua língua e as outras viram barulho de fundo. Em números: tome os chips A = (+1 +1 −1 −1) e B = (+1 −1 +1 −1). O produto elemento a elemento é +1 −1 −1 +1, que soma 0, então são ortogonais. A envia o bit 1 (envia A) enquanto B envia o bit 0 (envia −B). O canal soma: (0, +2, −2, 0). Para ouvir A, multiplique por A e divida por 4: (0 + 2 + 2 + 0)/4 = +1, bit 1. Para ouvir B: (0 − 2 − 2 + 0)/4 = −1, bit 0. Resultado +1 significa bit 1, −1 significa bit 0, e 0 significa que a estação ficou em silêncio.

A PCM (modulação por código de pulso) transforma voz em bits. A voz no telefone ocupa cerca de 4 kHz, então é amostrada o dobro disso, 8.000 vezes por segundo (uma a cada 125 µs). Com 8 bits por amostra, a taxa é 8.000 × 8 = 64.000 bps, o clássico canal de voz de 64 kbps.

A camada de enlace: enquadramento, erros e janela deslizante

A camada física envia um fluxo de bits. A camada de enlace transforma o fluxo em quadros (frames, pacotinhos de bits) que viajam entre duas máquinas ligadas diretamente por um enlace. Ela tem três tarefas: marcar onde cada quadro começa e termina, descobrir (ou consertar) bits danificados e evitar afogar um receptor lento.

Enquadramento: onde termina um quadro?

• Contagem de bytes: o cabeçalho diz quantos bytes vêm a seguir. Simples, mas uma contagem errada estraga tudo o que vem depois.
• Byte de flag com byte stuffing: um byte especial (a flag) marca o início e o fim. Se o mesmo valor aparecer dentro dos dados, o remetente coloca um byte de escape antes dele (e antes de qualquer byte de escape nos dados). O receptor remove os bytes de escape, e os dados chegam sem alteração.
• Flag de bits com bit stuffing: a flag é o padrão 01111110. Sempre que o remetente vê cinco 1s seguidos nos dados, insere um 0. O receptor faz o inverso: depois de cinco 1s, um 0 é removido. Assim, seis 1s seguidos só podem ser a flag.

dados a enviar:   0 1 1 1 1 1 1 0 1
após cinco 1s insere-se um 0:
dados com stuffing: 0 1 1 1 1 1 [0] 1 0 1
quadro: 01111110 0111110101 01111110   (flag, dados, flag)

Descobrindo erros

O ruído inverte alguns bits. Para perceber, enviamos bits extras de verificação, chamados redundância. O bit de paridade é o mais simples: escolhe-se o bit para que o número de 1s no bloco seja par (ou ímpar, por combinação). Os dados 1011 têm três 1s, então o bit de paridade par é 1. Se um bit se inverte, a contagem fica ímpar e o receptor percebe. Mas se dois bits se invertem, a contagem volta a ser par e o erro passa despercebido. Um único bit de paridade detecta qualquer número ímpar de bits invertidos e deixa passar números pares.

A força de um código é medida pela sua distância de Hamming: o menor número de posições de bits em que duas palavras-código válidas diferem. Para detectar e erros é preciso distância e + 1. Para corrigir e erros é preciso distância 2e + 1 (a palavra danificada ainda deve ficar mais perto da certa do que de qualquer outra). Distância 5 detecta 4 erros ou corrige 2. A paridade tem distância 2: detecta 1, não corrige nenhum.

Um código de Hamming corrige um bit invertido. Os bits de verificação ficam nas posições 1, 2, 4, 8, ... e cada um confere as posições cujo número em binário contém aquela potência de dois. Depois de uma falha, somar os números das verificações que falharam dá a posição exata do bit ruim, e o receptor o inverte de volta. Com m bits de dados e r bits de verificação, os r bits devem dizer 'sem erro' ou apontar para um entre m + r lugares, então m + r + 1 ≤ 2ʳ.

O CRC (verificação de redundância cíclica) trata os bits de dados como um polinômio e o divide por um polinômio gerador fixo, usando aritmética sem vai-um (a subtração é XOR). O remetente acrescenta r zeros (r é o grau do gerador), divide e coloca o resto no lugar dos zeros. O quadro agora é exatamente divisível pelo gerador. O receptor divide o quadro inteiro: qualquer resto diferente de zero indica erro.

dados 1101, gerador x^2 + 1 = 101, então r = 2
acrescenta dois zeros:  110100
110 xor 101 = 011, baixa o 1 -> 111
111 xor 101 = 010, baixa o 0 -> 100
100 xor 101 = 001, baixa o 0 -> 010 (começa com 0)
resto = 10, transmite 1101 10 = 110110
o receptor divide 110110 por 101 -> resto 0 -> aceito

Stop-and-wait

A regra mais simples para um remetente: enviar um quadro, esperar uma confirmação (ACK, um quadrinho de 'recebi'), e só então enviar o próximo. Se o ACK não chegar antes de um temporizador estourar, envia-se o quadro de novo. Mas um ACK perdido cria um problema: o receptor já tem o quadro e o recebe outra vez, sem saber distinguir uma cópia de um quadro novo. Por isso cada quadro leva um número de sequência. No stop-and-wait, um bit (0, 1, 0, 1...) basta.

O stop-and-wait desperdiça o enlace. Cada ciclo dura o tempo de transmissão do quadro mais o tempo de ida e volta (RTT), e a linha fica parada enquanto espera. Utilização = t_quadro / (t_quadro + RTT). Com um enlace de 1 Mbps e quadros de 1.000 bits, t_quadro = 1 ms. Se o RTT é 20 ms, a utilização é 1/21, apenas 4,8%. Para manter o enlace ocupado seria preciso ter cerca de 21 quadros no ar, e essa é a ideia da janela deslizante.

Outro truque é o piggybacking: quando há dados indo no sentido contrário, o ACK pega carona no cabeçalho desse quadro de dados, economizando um quadro inteiro. Se não houver dados para dar carona, um temporizador curto envia o ACK sozinho.

Janela deslizante: muitos quadros em trânsito

Em um protocolo de janela deslizante, o remetente pode enviar vários quadros antes de chegar o primeiro ACK. A janela é a lista de números que ele pode ter pendentes. Conforme os ACKs chegam, a janela desliza para a frente. Com n bits para o número de sequência existem 2ⁿ números.

sequência: 0  1  2  3  4  5  6  7  0  1 ...
          [ enviados, esperando ACK ][ pode enviar ]
           ^ mais antigo sem ACK     ^ próximo a enviar
           a janela desliza p/ a direita quando chega o ACK do 0

Controle de acesso ao meio: dividir um canal

Em algumas redes muitas estações dividem um único canal, como crianças numa sala que querem falar todas. Se duas falam ao mesmo tempo, ninguém entende nada: isso é uma colisão. As regras que dizem quem fala quando pertencem a uma subcamada da camada de enlace, chamada MAC (controle de acesso ao meio).

ALOHA: fale quando quiser

No ALOHA puro a estação envia assim que tem um quadro, sem escutar. Se colidir, espera um tempo aleatório e tenta de novo. Um quadro é atingido se qualquer outro começar durante uma janela de dois tempos de quadro em volta dele (o período vulnerável). Se G é a média de tentativas por tempo de quadro, a vazão é S = G e^(−2G), no máximo 1/(2e) ≈ 18,4%, em G = 0,5. Mais de 80% do tempo se perde.

O ALOHA com fendas (slotted) divide o tempo em intervalos, e as estações só podem começar no início de um intervalo. Os quadros ou se sobrepõem por inteiro ou não se tocam, então o período vulnerável é de apenas um tempo de quadro. Aí S = G e^(−G), no máximo 1/e ≈ 36,8%, em G = 1, o dobro da versão pura. Acima da melhor carga, mais tentativas significam mais colisões, que causam mais retransmissões e ainda mais carga. Esse comportamento instável é o motivo de existir o backoff.

CSMA: escute primeiro

O CSMA (acesso múltiplo com detecção de portadora) acrescenta uma regra educada: escute antes de falar e espere se outro estiver usando o canal. O CSMA/CD (com detecção de colisão) também continua escutando enquanto envia e para na hora em que percebe uma colisão. Depois da colisão, cada estação espera um tempo aleatório escolhido pelo backoff exponencial binário: depois da i-ésima colisão do mesmo quadro, sorteia-se um número de intervalos de 0 a 2ⁱ − 1 (ou seja, 0 a 1, depois 0 a 3, depois 0 a 7, e assim por diante), até o limite de 0 a 1023. Com poucas estações a espera é curta. Com muitas, a faixa cresce rápido e espalha as tentativas. Ele se adapta à carga sem que ninguém precise conhecê-la.

Há uma pegadinha. Uma estação só descobre a colisão se ainda estiver enviando quando o ruído voltar. No pior caso, o quadro quase chegou à outra ponta quando colide, e o ruído leva o mesmo tempo para voltar: duas vezes o tempo de propagação (2τ). Então o quadro precisa durar pelo menos 2τ, e o tamanho mínimo do quadro = taxa × 2τ. Redes mais rápidas precisam de quadros mínimos maiores ou cabos mais curtos.

10 Mbps, tempo de intervalo 2*tau = 51,2 microssegundos
quadro mínimo = 10.000.000 bps * 0,0000512 s = 512 bits = 64 bytes

Dez vezes mais rápido (100 Mbps) com o MESMO quadro de 64 bytes:
  o cabo teria de ser 10 vezes mais curto

Ethernet, switches e hubs

Toda interface Ethernet tem um endereço MAC de 48 bits. Os primeiros 24 bits identificam o fabricante. Ele nomeia um dispositivo dentro da rede local; não é usado para rotear entre redes (isso é trabalho do endereço IP, na camada seguinte).

Um hub apenas repete os bits em todas as outras portas, então todos dividem um canal e há colisões. Um switch lê o endereço MAC de destino de cada quadro e o envia só pela porta certa, então várias conversas podem acontecer ao mesmo tempo e não há colisões entre portas. Um switch não precisa de configuração, porque aprende sozinho: quando um quadro de A entra pela porta 1, ele anota 'A está na porta 1' na tabela. Para encaminhar, consulta o destino. Se o destino é conhecido, usa só aquela porta. Se é desconhecido (ou o quadro é de broadcast), faz flooding: envia o quadro por todas as outras portas.

      A --1[ SWITCH ]2-- B          tabela no início: vazia
                  3                 1) A -> B : aprende A=porta1,
                  |                    B desconhecido: FLOOD (B e C recebem)
                  C                 2) B -> A : aprende B=porta2,
                                       A é conhecido: só a porta 1

Enlaces redundantes entre switches são bons contra falhas, mas criam laços (loops). Com um laço, quadros de flooding e de broadcast dão voltas sem parar e se multiplicam: uma tempestade de broadcast que derruba a rede. O protocolo spanning tree elege um switch raiz e mantém ativos só os enlaces que formam uma árvore (sem ciclos, por definição). Os outros enlaces ficam de reserva.

Sem fio: CSMA/CA

Em um cabo, a estação consegue escutar enquanto fala. Um rádio não faz isso bem, então o Wi-Fi (802.11) não consegue detectar colisões. Ele usa o CSMA/CA (com prevenção de colisão): espera o meio ficar livre, espera um backoff aleatório e só então envia. Como o remetente não sabe se houve colisão, o receptor envia um ACK para cada quadro, e a falta do ACK significa retransmitir.

O rádio traz o problema do terminal oculto. O que importa é a interferência no receptor, não no remetente. Tome A e C, ambos ao alcance de B mas longe demais um do outro. A envia para B. C escuta, não ouve nada (não escuta A) e também envia: os dois sinais colidem em B. A solução é o RTS/CTS: antes de enviar, o remetente pergunta (RTS) e o receptor responde (CTS). O CTS é ouvido pelos vizinhos do receptor, que então ficam quietos.

   A ------- B ------- C       A e C não se escutam
   (alcance de A chega a B)    A -> B ...... C também -> B
                (alcance de C chega a B)
                               colisão em B, ninguém percebe

A camada de rede: roteamento, endereços IP e sub-redes

A camada de enlace é para vizinhos. A camada de rede junta muitos enlaces e muitas redes e precisa responder: por qual caminho este pacote deve ir para alcançar uma máquina distante? Existem dois serviços básicos. Uma rede de datagramas (sem conexão) trata cada pacote sozinho: cada um leva o endereço de destino completo, e cada roteador decide com sua tabela naquele momento. É simples e sobrevive a falhas; a confiabilidade fica para a camada de transporte. Uma rede de circuitos virtuais (orientada a conexão) primeiro estabelece um caminho e depois todos os pacotes o seguem. A Internet usa datagramas.

Roteamento: como os roteadores acham o caminho

Um roteador tem uma tabela de roteamento. Para cada destino ele sabe qual é o próximo roteador (ou o próximo enlace) a usar. Os algoritmos de roteamento constroem essas tabelas.

Caminho mais curto (Dijkstra). Pense na rede como cidades ligadas por estradas com custos. O Dijkstra começa na origem e repete: pega o nó ainda não fixado com a menor distância conhecida, fixa-o e atualiza as distâncias dos vizinhos. O caminho mais barato pode ter mais saltos que outro.

enlaces: A-B 1, A-C 4, B-C 2, C-D 1      origem = A
passo 1: fixa A (0).  B = 1, C = 4
passo 2: fixa B (1).  C = min(4, 1+2) = 3
passo 3: fixa C (3).  D = 3+1 = 4
passo 4: fixa D (4).  caminho até D: A-B-C-D, custo 4

Vetor de distâncias (Bellman-Ford; o RIP é um exemplo): cada roteador diz apenas aos vizinhos a que distância acha que está de cada destino, e cada um atualiza a tabela com o que ouve. Boas notícias viajam rápido. Más notícias viajam devagar, e esse é o problema da contagem até o infinito. Exemplo: A — B — C em linha. B chega a C em 1, A chega a C em 2. O enlace B–C quebra. B ouve de A 'chego a C em 2' (A não sabe que a rota passa por B), então B pensa 'então chego a C em 3'. A ouve o 3 de B e diz 4. Eles continuam aumentando os números, de um em um. O RIP define 16 saltos como 'infinito' para parar isso, e usa split horizon (não contar a um vizinho uma rota aprendida com ele), às vezes com poisoned reverse (contar a ele que essa rota é infinita). Isso ajuda, mas laços entre três roteadores ainda podem acontecer.

Estado de enlace (o OSPF é um exemplo): cada roteador descobre seus vizinhos, mede o custo dos enlaces e espalha essa informação, em pacotes numerados, para todos. Todos os roteadores ficam com o mesmo mapa da rede e cada um roda o Dijkstra por conta própria. Converge rápido e não tem contagem até o infinito.

Entre organizações (BGP). A Internet é dividida em sistemas autônomos (AS): redes administradas por uma organização. Dentro de um AS, um protocolo como o OSPF acha o melhor caminho. Entre ASes o objetivo não é o caminho mais curto, e sim um caminho permitido pelas regras de cada organização (por exemplo, não carregar de graça o tráfego de um concorrente). O BGP é um protocolo de vetor de caminhos: para cada destino ele anuncia a lista completa de ASes no caminho. A lista deixa o roteador ver um laço na hora (ele vê o próprio AS) e dá os dados para decisões de política.

Congestionamento e qualidade de serviço

Congestionamento é quando o tráfego de muitas origens, somado, é maior do que uma parte da rede consegue carregar. Os pacotes esperam em filas e são descartados. É um problema global. O controle de fluxo é local às duas pontas: impede que um remetente rápido afogue um receptor lento. Os dois dizem 'envie mais devagar', mas por motivos diferentes.

Um token bucket (balde de fichas) molda o tráfego. Fichas caem no balde à taxa R, até a capacidade B. Cada unidade enviada gasta uma ficha. Depois de um tempo quieto o balde está cheio, então uma rajada pode sair na taxa de pico M enquanto houver fichas. O balde esvazia a M − R (as fichas continuam chegando). A rajada dura S = B / (M − R), depois a taxa cai para R.

B = 6 Mbit, R = 1 Mbps, pico M = 7 Mbps
S = B / (M - R) = 6 / (7 - 1) = 1 s
enviado na rajada = M * S = 7 Mbit  (= B + R*S = 6 + 1)

Endereços IPv4, máscaras e sub-redes

Um endereço IPv4 tem 32 bits, escritos como quatro números de 0 a 255 (por exemplo 192.168.10.77). Tem duas partes: os primeiros bits nomeiam a rede, o resto nomeia o host dentro dela. O prefixo /n diz que os primeiros n bits são a rede. A máscara é n uns seguidos de zeros. Aplicar um AND lógico do endereço com a máscara limpa os bits de host e dá o endereço de rede. Colocar todos os bits de host em 1 dá o endereço de broadcast. Com 32 − n bits de host há 2^(32−n) endereços, mas o primeiro (rede) e o último (broadcast) são reservados, então há 2^(32−n) − 2 hosts utilizáveis. Cada bit tirado do prefixo dobra o bloco.

172.16.5.200/27   máscara 255.255.255.224   (tamanho do bloco 256-224 = 32)
200 está no bloco 192..223 do último número
rede      172.16.5.192
broadcast 172.16.5.223
hosts     172.16.5.193 .. 172.16.5.222   2^5 - 2 = 30 hosts

Para enviar, a máquina aplica a própria máscara ao destino. Se o resultado for igual à sua rede, o destino está no mesmo enlace: a máquina descobre o endereço MAC com o ARP e envia direto. Se não, o quadro vai para o MAC do roteador padrão (default gateway), mas o pacote IP mantém o endereço do destino final.

O ARP (protocolo de resolução de endereços) liga os dois tipos de endereço. A máquina pergunta a todos, por broadcast, 'quem tem este endereço IP?', o dono responde com o seu MAC, e a resposta fica guardada por alguns minutos em um cache.

Com o CIDR, as tabelas de roteamento guardam prefixos de qualquer tamanho. Um destino pode casar com vários; o roteador escolhe o prefixo mais longo que casa, o mais específico. Blocos contíguos podem ser unidos (agregação) em um prefixo mais curto que cobre exatamente os mesmos endereços, o que mantém pequenas as tabelas da Internet. Quatro blocos /24 formam um /22 só se forem consecutivos e o primeiro começar em um múltiplo de 4 no terceiro número.

rotas: 172.16.0.0/12 -> A,  172.16.8.0/21 -> B,  0.0.0.0/0 -> C
pacote para 172.16.9.1 : casa /12 e /21  -> o mais longo = /21 -> B
pacote para 172.20.1.1 : casa só /12     -> A
pacote para 8.8.8.8    : casa só /0      -> C (padrão)

agregação: 10.1.0.0/24 + 10.1.1.0/24 + 10.1.2.0/24 + 10.1.3.0/24 = 10.1.0.0/22

O pacote IPv4: TTL, fragmentos e ICMP

As tabelas de roteamento podem estar erradas por um instante e mandar pacotes em círculos. O campo TTL (tempo de vida) protege contra isso: a origem define um número, cada roteador subtrai um e, quando chega a zero, o pacote é jogado fora e a origem é avisada. O ICMP é o protocolo que os roteadores usam para mandar esses avisos ('destino inalcançável', 'tempo excedido'). O comando ping é construído sobre ele. O traceroute envia pacotes com TTL 1, 2, 3, ... e lê as respostas de 'tempo excedido' para descobrir cada roteador do caminho.

Todo enlace tem uma MTU, o maior pacote que aceita. Se um pacote IPv4 é maior, o roteador o quebra em fragmentos, cada um com seu cabeçalho. O campo offset diz onde os dados se encaixam, contado em unidades de 8 bytes, e o bit MF (more fragments) diz se vêm mais. Só o destino junta as peças de volta.

pacote = 20 de cabeçalho + 2000 de dados, MTU = 1000
máx de dados por fragmento = 1000 - 20 = 980 -> usa 976 (múltiplo de 8)
fragmento 1: dados 976, offset 0,   MF = 1
fragmento 2: dados 976, offset 122, MF = 1   (976 / 8 = 122)
fragmento 3: dados  48, offset 244, MF = 0   (1952 / 8 = 244)

NAT e IPv6

Não há endereços IPv4 suficientes (cerca de 4,3 bilhões). O NAT (tradução de endereços de rede) deixa uma casa ou empresa inteira usar endereços privados (10.0.0.0/8, 172.16.0.0/12 e 192.168.0.0/16) e mostrar um único endereço público para a Internet. A caixa de NAT usa números de porta para distinguir as conversas, como uma recepcionista que dá um ramal a cada ligação. O custo é que quem está fora não consegue iniciar uma conexão com uma máquina de dentro, o que quebra a antiga ideia de que toda máquina pode ser alcançada de qualquer lugar.

O IPv6 é a solução de verdade: os endereços têm 128 bits, praticamente infinitos. O cabeçalho foi simplificado: tamanho fixo (40 bytes), sem checksum, e os roteadores não fragmentam. Um roteador que recebe um pacote grande demais para o próximo enlace o descarta e avisa a origem com uma mensagem ICMPv6; a origem descobre a menor MTU do caminho e ajusta o tamanho dos seus pacotes.

A camada de transporte: portas, UDP e TCP

O IP leva um pacote à máquina certa, mas uma máquina executa muitos programas ao mesmo tempo: um navegador, um jogo, um tocador de música. A camada de transporte entrega os dados ao programa certo e, quando preciso, torna a entrega confiável. Ela atua só nas duas pontas; os roteadores do meio não olham para ela.

Os programas são distinguidos por números de porta, números de 16 bits (0 a 65.535). O par (endereço IP, porta) é um ponto de comunicação, um socket. Algumas portas são bem conhecidas: 80 para HTTP, 443 para HTTPS, 53 para DNS, 25 para SMTP. É como um prédio de apartamentos: o endereço IP é o prédio e a porta é o apartamento.

UDP: o leve

O UDP não acrescenta quase nada ao IP: portas para chegar ao programa certo e um checksum para detectar dados danificados. Não tem conexão, nem confirmação, nem retransmissão, nem controle de fluxo. O cabeçalho tem só 8 bytes. É a ferramenta certa quando dado atrasado não serve, como numa chamada de voz ou num jogo: é melhor pular um pedaço perdido e seguir do que parar e esperar uma retransmissão. Aplicações que precisam de confiabilidade sobre o UDP têm de construí-la sozinhas.

TCP: o confiável

O TCP dá à aplicação um fluxo confiável de bytes, na ordem certa. Ele numera os bytes, confirma o que chega, reenvia o que se perde e reduz a velocidade quando o receptor ou a rede está sobrecarregado.

Abrindo uma conexão: o handshake de três vias. Cada lado escolhe um número de sequência inicial e precisa que o outro lado o confirme. Primeiro o cliente envia SYN com o seu número. Depois o servidor responde SYN+ACK: confirma o número do cliente e envia o seu, em um só segmento. Por fim o cliente envia um ACK. Três segmentos bastam. O terceiro tem um propósito mais profundo: as redes podem atrasar e duplicar pacotes, então um SYN antigo pode chegar muito tempo depois. O servidor sozinho não sabe se é novo. O ACK final, que confirma um número que o servidor escolheu agora há pouco, prova que o cliente está mesmo participando.

Cliente                       Servidor
  |---- SYN, seq=x ---------->|
  |<--- SYN+ACK, seq=y, ack=x+1|
  |---- ACK, ack=y+1 -------->|
  |        (dados fluem)       |
  |---- FIN ----------------->|   fechando:
  |<--- ACK ------------------|   cada sentido
  |<--- FIN ------------------|   é fechado
  |---- ACK ----------------->|   separadamente

Números e confirmações. O TCP numera cada byte. O número de sequência de um segmento é o número do seu primeiro byte. O número de confirmação é o número do próximo byte esperado, e é cumulativo: confirma tudo o que vem antes. Então, se um segmento tem número de sequência s e n bytes de dados, ele cobre os bytes s a s + n − 1 e o ACK é s + n. Exemplo: s = 4000, n = 300 dá ACK 4300. Um ACK perdido costuma ser reparado pelo ACK seguinte, maior.

O controle de fluxo protege o receptor. Em cada segmento ele anuncia o espaço livre do seu buffer, a janela de recepção. Se a aplicação lê devagar, a janela encolhe, até chegar a zero, e o remetente precisa reduzir o ritmo. O controle de congestionamento protege a rede, e o remetente o estima, em uma segunda janela chamada janela de congestionamento (cwnd). O remetente pode ter em trânsito, no máximo, min(cwnd, janela de recepção) bytes sem confirmação.

O controle de congestionamento tem estas ideias (a unidade é o MSS, o tamanho máximo de segmento):

• Slow start: comece com cwnd = 1 MSS. Cada ACK soma 1 MSS, então a janela dobra a cada RTT: 1, 2, 4, 8, 16. É exponencial, apesar do nome. Continua até a cwnd chegar ao limiar ssthresh.
• Congestion avoidance (prevenção de congestionamento): acima do ssthresh, cresce só 1 MSS por RTT (aumento aditivo), com cuidado.
• Timeout (congestionamento sério, nem os ACKs voltam): ssthresh = metade da janela atual, cwnd = 1 MSS e slow start de novo.
• Três ACKs duplicados: o receptor continua repetindo o último ACK em ordem quando chegam segmentos posteriores. Um ou dois podem ser só reordenação, três indicam uma perda. O fast retransmit reenvia o segmento que falta sem esperar o temporizador. No TCP Reno, a fast recovery então põe ssthresh e cwnd na metade e continua crescendo 1 MSS por RTT.

cwnd
 20|        /|
 16|      /  |
 12|    /    |        /|
 10|  /      |      /  |    +1 MSS por RTT,
  8|/        |    /    |    metade a cada perda
  6|         |  /
  4|         |/
   +--------------------------> tempo

Quanto esperar? O timeout. Se o temporizador é curto demais, o TCP reenvia à toa. Se é longo demais, a recuperação de perdas é lenta. Por isso o TCP acompanha o atraso real com uma média móvel: SRTT = α·SRTT + (1 − α)·R, com α = 7/8, em que R é a medida mais recente. O valor antigo tem peso grande, cada nova amostra tem peso pequeno. Exemplo: SRTT = 60 ms e R = 100 ms dão 7/8 × 60 + 1/8 × 100 = 52,5 + 12,5 = 65 ms. O timeout é o SRTT mais uma margem de segurança baseada na variação.

O algoritmo de Nagle combate segmentos minúsculos. Enquanto houver dados enviados ainda não confirmados, escritas pequenas esperam em um buffer até o ACK chegar ou um segmento cheio ficar pronto. Ele se adapta sozinho à rede. Aplicações interativas que odeiam esperar, como jogos, o desligam.

Fechando. O lado que fecha primeiro envia o último ACK e depois espera no estado TIME_WAIT por duas vezes o tempo máximo de vida de um segmento. Se esse último ACK se perdeu, o outro lado vai enviar seu FIN de novo, e alguém ainda precisa estar lá para responder. Isso também deixa segmentos duplicados antigos dessa conexão morrerem na rede antes de o mesmo par de portas ser reutilizado.

A camada de aplicação: DNS, e-mail, a Web e streaming

O andar do topo é o que as pessoas realmente usam. Os programas aqui seguem protocolos que rodam sobre TCP ou UDP. Vamos ver como nomes viram endereços, como o e-mail viaja, como a Web funciona e como vídeos e sites populares chegam rápido até você.

DNS: a lista telefônica da Internet

As pessoas gostam de nomes (www.example.com). A rede entende só endereços numéricos. O DNS (sistema de nomes de domínio) traduz um no outro. Nenhuma máquina sabe tudo, então os nomes formam uma árvore: a raiz, depois os domínios de topo (.com, .org, .br), depois os nomes abaixo. Cada parte da árvore é uma zona, administrada por seu próprio responsável, com um servidor autoritativo que tem a palavra final sobre ela.

              . (raiz)
           /     |     \
        .com   .org    .br          domínios de topo
         |
    example.com                      uma zona
         |
  www.example.com                    um nome

O seu computador pergunta a um resolvedor local (em geral do seu provedor). Se o resolvedor não sabe, ele pergunta à hierarquia com consultas iterativas: cada servidor responde com o que sabe, a resposta final ou um encaminhamento para quem perguntar em seguida. Para www.example.com com o cache vazio, a ordem é: um servidor raiz (aponta para o .com), depois um servidor do .com (aponta para o servidor autoritativo de example.com) e, por fim, o servidor autoritativo (dá o endereço). Na prática, o cache evita quase todas as idas à raiz e aos servidores de topo.

Toda resposta tem um TTL (tempo de vida): por quantos segundos pode ser reutilizada sem perguntar de novo. Um TTL alto significa menos carga e respostas mais rápidas, mas as mudanças se espalham devagar. Um TTL baixo é o contrário. Se um endereço com TTL 300 está no cache no instante 0 e o administrador o muda aos 100 s, os clientes atrás desse cache continuam com o endereço antigo até os 300 s. Por isso se reduz o TTL dias antes de mudar um serviço.

E-mail

O e-mail faz dois trabalhos separados. O SMTP empurra (push) uma mensagem do remetente até o servidor do destinatário. O usuário então lê a caixa postal com um protocolo de acesso, IMAP ou POP3, que a puxa (pull). Para achar para onde enviar uma mensagem para ana@example.org, o servidor de envio pergunta ao DNS os registros MX de example.org: eles nomeiam os servidores de e-mail do domínio, em ordem de preferência. A parte depois do @ é um domínio, não o nome de uma máquina.

A Web e o HTTP

O HTTP é um protocolo de pedido e resposta. O navegador envia um pedido ('GET desta página') e o servidor responde com um código e o conteúdo. O HTTP é sem estado (stateless): cada pedido é tratado sozinho, sem memória do anterior. Um cookie acrescenta memória: o servidor pede ao navegador que guarde um pequeno texto e o envie de volta em todo pedido. Em geral o cookie guarda só um identificador de sessão, e os dados de verdade ficam no servidor.

Contando idas e voltas. Convenção: abrir uma conexão TCP custa 1 RTT (o handshake), e cada pedido com sua resposta custa 1 RTT (o tempo de enviar os dados em si é ignorado). Com HTTP não persistente, cada objeto precisa de uma conexão nova, então 2 RTT cada. Com HTTP persistente, a mesma conexão é reutilizada: 1 RTT para o handshake e depois 1 RTT por objeto. Uma página com 1 arquivo HTML e N imagens, sem conexões em paralelo: não persistente 2(N + 1) RTT, persistente 2 + N RTT. Com N = 4: 10 contra 6.

O cache HTTP funciona em duas fases. Enquanto a cópia guardada está dentro do seu prazo (o max-age do cabeçalho Cache-Control), o navegador a usa sem perguntar ao servidor. Depois disso, faz um pedido condicional, enviando o validador que recebeu (ETag ou Last-Modified). Se nada mudou, o servidor responde 304 Not Modified sem corpo, economizando a transferência. Exemplo: max-age=60 e ETag, e a página é necessária de novo após 90 s: faz-se um pedido condicional.

Entrega de conteúdo e streaming

Uma CDN (rede de entrega de conteúdo) mantém cópias do conteúdo em muitos lugares do mundo. O truque mais comum para levar você à cópia mais próxima está no DNS: o servidor DNS da CDN devolve um endereço diferente conforme o lugar de onde vem a pergunta. O conteúdo viaja menos, o atraso cai e a carga se espalha.

Vídeo e áudio são tocados em ritmo fixo, mas chegam com atraso variável. O player guarda alguns segundos em um buffer de reprodução (playout buffer): ele enche quando a rede está rápida e esvazia quando está lenta. O preço é um pequeno atraso no início, aceitável para um vídeo gravado, mas ruim para uma chamada ao vivo, que precisa de um buffer bem pequeno.

Segurança de redes

As mensagens atravessam máquinas de estranhos. A segurança pergunta: alguém pode ler? Alguém pode alterar? Estou mesmo falando com quem penso? Três propriedades diferentes respondem a essas perguntas, e cada uma precisa do seu próprio mecanismo.

Chaves simétricas e assimétricas

Na criptografia simétrica, os dois lados compartilham a mesma chave secreta. É rápida, mas como combinar a chave sem que um espião ouça? A criptografia assimétrica (de chave pública) resolve isso: cada pessoa tem um par de chaves, uma chave pública que todos podem conhecer e uma chave privada que fica em segredo. O que uma chave tranca, só a outra abre. Para mandar um segredo ao Bob, você tranca com a chave pública do Bob, e só a chave privada do Bob abre.

Hashes e assinaturas

Uma função de hash criptográfica (o SHA-256 é uma) transforma uma mensagem de qualquer tamanho em um resumo (digest) curto, de tamanho fixo, como uma impressão digital. Precisa ser fácil de calcular, praticamente impossível de inverter e resistente a colisões (muito difícil achar duas mensagens com o mesmo resumo). Mudar uma letra muda o resumo por completo.

Uma assinatura digital usa o par de chaves ao contrário: você assina com a sua chave privada e todos verificam com a sua chave pública. Dá autoria, integridade e não repúdio (você não pode negar). Na prática, assina-se o resumo da mensagem, não a mensagem inteira, porque ele é muito mais curto.

Um MAC (código de autenticação de mensagem) é como uma assinatura feita com uma chave secreta compartilhada: prova que a mensagem não foi alterada e que veio de quem tem a chave.

Certificados e confiança

Os truques de chave pública só funcionam se a chave pública que você recebeu realmente pertence a quem diz ser o dono. Senão, um homem no meio poderia lhe dar a chave dele. Um certificado resolve isso: um terceiro de confiança, a autoridade certificadora (CA), assina uma declaração 'esta chave pertence a este nome'. O seu navegador verifica a assinatura seguindo uma cadeia de certificados até uma CA raiz em que ele já confia. O certificado atesta a ligação entre uma identidade e uma chave pública, nada além disso.

Provando quem você é: desafio e resposta

Como provar que você conhece um segredo sem enviá-lo? No desafio-resposta, o verificador envia um valor e o outro lado devolve esse valor transformado com o segredo. Se o desafio fosse sempre o mesmo, um atacante poderia gravar uma resposta boa e tocá-la de novo (um replay). Por isso o verificador envia um número aleatório novo, um nonce (número usado uma vez), a cada vez. Uma resposta antiga não serve para um desafio novo.

Protocolos como o TLS (o cadeado do navegador) e o IPsec combinam essas peças. Chaves públicas e certificados deixam os dois lados combinarem uma chave e saberem quem é o outro. Depois, a criptografia simétrica rápida protege os dados, e um MAC em cada mensagem detecta qualquer alteração antes de os dados serem usados.

Juntando tudo

Vamos seguir um clique: você digita www.example.com no navegador. Cada camada faz seu pequeno trabalho, em ordem.

1. Aplicação (DNS): o navegador pergunta ao resolvedor o endereço de www.example.com. O cache ou a árvore DNS responde com um endereço IP.
2. Rede (ARP): o endereço está fora da sua sub-rede, então a sua máquina descobre o endereço MAC do roteador padrão com o ARP.
3. Transporte (TCP): um handshake de três vias abre uma conexão na porta 443 ou 80.
4. Aplicação (HTTP): o pedido sai e a resposta volta, com um código de status.
5. Rede, enlace e física: cada pacote atravessa roteadores (prefixo mais longo, TTL caindo), cada salto é um quadro com novos endereços MAC, e os bits são sinais em cabos, fibra ou rádio.

Alguns erros se repetem em provas e na vida real. Confira esta lista antes de responder.

• Misturar largura de banda (quanto por segundo) com latência (quanto tempo leva).
• Esquecer que os hosts utilizáveis de uma sub-rede são 2^(32−n) − 2.
• Misturar o endereço MAC (só um enlace) com o endereço IP (fim a fim).
• Achar que a janela de recepção e a janela de congestionamento são a mesma coisa.
• Achar que o slow start é lento: ele dobra a cada RTT.
• Usar todo o espaço de sequência como janela no selective repeat: o limite é a metade.
• Acreditar que só criptografar protege contra alterações na mensagem.