# Camada de rede e encaminhamento

Endereçamento IP, sub-redes com máscaras e algoritmos de encaminhamento.

Página: https://resumos.rgo.pt/cadeiras/rc/camada-de-rede/

A camada de rede responde à pergunta grande: como levar um pacote de qualquer origem a qualquer destino, atravessando redes que ninguém desenhou em conjunto. As respostas são o endereçamento IP, a divisão em sub-redes e os algoritmos que preenchem as tabelas dos routers.

## Endereços IP e máscaras

Um endereço IPv4 tem 32 bits, escritos como quatro números decimais, por exemplo `192.168.1.20`. A **máscara** diz que parte identifica a rede e que parte identifica a máquina dentro dela: em `192.168.1.0/24`, os primeiros 24 bits são a rede e os últimos 8 bits são as máquinas. O `/24` é o comprimento do prefixo, e a máscara em decimal é `255.255.255.0`.

Cada sub-rede reserva dois endereços: o primeiro identifica a própria rede e o último é o **endereço de difusão** (broadcast), que fala com todas as máquinas da sub-rede. Numa `/24` há $2^8 = 256$ endereços menos estes dois, ou seja 254 máquinas utilizáveis.

## Dividir uma rede em sub-redes

Pegar na rede `192.168.1.0/24` e parti-la em 4 sub-redes iguais pede 2 bits emprestados à parte das máquinas: o prefixo passa a `/26` e a máscara a `255.255.255.192`. Cada sub-rede fica com $2^6 = 64$ endereços, 62 utilizáveis. A tabela fica assim:

| Sub-rede | Rede | Utilizáveis | Difusão |
| --- | --- | --- | --- |
| 1 | `192.168.1.0/26` | `192.168.1.1` a `192.168.1.62` | `192.168.1.63` |
| 2 | `192.168.1.64/26` | `192.168.1.65` a `192.168.1.126` | `192.168.1.127` |
| 3 | `192.168.1.128/26` | `192.168.1.129` a `192.168.1.190` | `192.168.1.191` |
| 4 | `192.168.1.192/26` | `192.168.1.193` a `192.168.1.254` | `192.168.1.255` |

Confere a segunda: começa em 64 porque cada bloco tem 64 endereços ($0$, $64$, $128$, $192$); o último utilizável é $64 + 62 = 126$ e a difusão é $127$. O método geral é sempre este: $n$ bits emprestados dão $2^n$ sub-redes, e cada bloco começa em múltiplo do seu tamanho.

Gera a tabela acima com o programa. Ele imprime rede, intervalo utilizável e difusão das 4 sub-redes:

```python
for n in range(4):
    rede = n * 64
    print(f"{n + 1}: 192.168.1.{rede}/26  utilizaveis .{rede + 1} a .{rede + 62}  difusao .{rede + 63}")
```

Empresta 2 bits: prefixo `/26`, máscara `255.255.255.192`, blocos de 64 com 62 máquinas cada. É a tabela do programa acima.

Empresta 3 bits: prefixo `/27`, máscara `255.255.255.224`, blocos de 32 com 30 máquinas cada, de `192.168.1.0/27` a `192.168.1.224/27`.

[Vídeo: What is Subnetting? - Subnetting Mastery - Part 1 of 7](https://www.youtube.com/watch?v=BWZ-MHIhqjM)

A miniatura vem do YouTube. O vídeo só carrega quando clicas. [Abrir no YouTube](https://www.youtube.com/watch?v=BWZ-MHIhqjM)

Na prática, quase ninguém configura isto à mão em cada máquina: o **DHCP** entrega endereço, máscara, gateway e DNS automaticamente quando te ligas, e o **ICMP** leva as mensagens de erro e de diagnóstico (o `ping` e o `traceroute` falam ICMP).

O DHCP em quatro mensagens, pela ordem com que viajam na rede:

![Diagrama de sequência DORA: o cliente envia Discover e Request, o servidor responde Offer e Ack.](https://resumos.rgo.pt/cadeiras/rc/camada-de-rede/figura-1.svg)

Lê a sequência como uma conversa: o cliente anuncia-se em difusão (`Discover`), o servidor oferece um endereço (`Offer`), o cliente pede-o formalmente (`Request`) e o servidor confirma (`Ack`). Só a partir do `Ack` é que o endereço é teu.

## Como os routers escolhem

Cada router tem uma **tabela de encaminhamento** com entradas do tipo “para este prefixo, envia pela interface X ao vizinho Y”. Perante um pacote, escolhe a entrada com o **prefixo mais longo** que contenha o destino: entre `192.168.0.0/16` e `192.168.1.128/26`, um pacote para `192.168.1.130` segue a segunda, porque é a mais específica.

![Duas entradas de tabela e o destino 192.168.1.130: a seta escolhe 192.168.1.128/26 por ser o prefixo mais longo.](https://resumos.rgo.pt/cadeiras/rc/camada-de-rede/figura-2.svg)

As tabelas podem ser escritas à mão (encaminhamento estático, bom para redes pequenas) ou aprendidas por protocolos: **vetor de distâncias**, onde cada router conta aos vizinhos o que sabe e todos convergem por aproximações sucessivas, e **estado de ligação**, onde cada router inunda o mapa da rede e todos calculam os caminhos mais curtos localmente. O primeiro é simples e por vezes lento a reagir a falhas; o segundo é rápido e gasta mais memória e processamento. A Internet usa as duas ideias em escalas diferentes.

Segue o vetor de distâncias em três routers em linha, A, B e C, com custo 1 por salto. Cada router começa por só se conhecer a si próprio com custo 0. Na primeira ronda de trocas, cada um aprende os vizinhos diretos: A fica com (A: 0, B: 1), B com (B: 0, A: 1, C: 1) e C com (C: 0, B: 1). Na segunda ronda, B conta a A que chega a C com custo 1, por isso A regista C com custo 2; o simétrico acontece em C, que regista A com custo 2. Ninguém muda mais nada na ronda seguinte: convergiu, e cada router sabe o caminho mais curto para todos.

## Sair para a Internet: NAT

Dentro de casa os endereços são privados (`192.168.x.x`) e repetem-se em todas as casas do mundo; na Internet cada pacote precisa de um endereço público único. O **NAT** no router de acesso traduz uns nos outros e regista a tradução numa tabela, para saber a quem entregar as respostas. Com o endereço público `203.0.113.7`:

| Dentro de casa | Para a Internet | Regresso |
| --- | --- | --- |
| `192.168.1.20:5000` | `203.0.113.7:60001` | a resposta a `:60001` volta para `192.168.1.20:5000` |
| `192.168.1.21:5000` | `203.0.113.7:60002` | a resposta a `:60002` volta para `192.168.1.21:5000` |

As duas máquinas usam a mesma porta privada `5000`, e é a porta pública traduzida que as distingue. Sem entrada na tabela, um pacote vindo de fora não entra: é por isso que servidores em casa precisam de reencaminhamento de portas configurado à mão.

## IPv6 em poucas linhas

O IPv4 tem 32 bits e os endereços esgotaram-se; o **IPv6** usa 128 bits escritos em 8 grupos hexadecimais, como `2001:db8::1`, com prefixos do tipo `/64` para cada rede. O espaço é tão grande que cada rede recebe milhões de endereços sem partilhas nem NAT. As duas versões coexistem: a transição faz-se com pilha dupla (máquinas que falam as duas) e túneis, e a tua ligação provavelmente já negoceia as duas sem dares por isso.

Ver a regra de ouro da divisão

Para partir uma rede em $k$ sub-redes, escolhe o menor $n$ com $2^n \geq k$ e empresta $n$ bits. Cada sub-rede tem $2^{32 - \text{prefixo}}$ endereços e blocos alinhados a múltiplos desse tamanho. O erro típico é esquecer os dois endereços reservados por sub-rede e contar $64$ máquinas onde só cabem $62$.