Enlace de Dados

Quadro Ethernet:

+-----------+----------+------+---------+---------+-----+
| Preambulo | SFD      | Dest | Source  | Type    | ... |
| 7 bytes   | 1 byte   | MAC  | MAC     | 2 bytes |     |
|           |          |6 bytes|6 bytes |         |     |
+-----------+----------+------+---------+---------+-----+
                                                    |
+---------------------------------------------------+---+----+
|              Payload (46-1500 bytes)                   | FCS|
|              (pacote IP encapsulado)                   |4 B |
+--------------------------------------------------------+----+

MAC address: 48 bits, notacao hexadecimal
  Exemplo: AA:BB:CC:DD:EE:FF
  Primeiros 3 octetos: OUI (fabricante)
  Ultimos 3 octetos: ID unico do dispositivo

FCS (Frame Check Sequence): CRC-32 para detecção de erros

Tamanho total do quadro Ethernet:
  Mínimo: 64 bytes (46 payload + 18 overhead)
  Máximo: 1518 bytes (1500 payload + 18 overhead)
  Jumbo frames: até 9000 bytes de payload (datacenters)

import binascii

# Simulação de CRC-32 na camada de enlace
def compute_fcs(frame_bytes):
    """Calcula o FCS (CRC-32) de um quadro Ethernet."""
    crc = binascii.crc32(frame_bytes) & 0xFFFFFFFF
    return crc

def verify_frame(frame_bytes, expected_fcs):
    """Verifica integridade do quadro."""
    computed = compute_fcs(frame_bytes)
    if computed == expected_fcs:
        print("Quadro íntegro — CRC OK")
        return True
    else:
        print(f"ERRO: CRC esperado {expected_fcs:#x}, calculado {computed:#x}")
        print("Quadro descartado (bit flip durante transmissão)")
        return False

# Simulando envio e recebimento
dados = b"Hello Ethernet"
fcs = compute_fcs(dados)
print(f"FCS calculado: {fcs:#010x}")
verify_frame(dados, fcs)             # OK
verify_frame(dados + b"X", fcs)      # ERRO — dados corrompidos

import uuid
import subprocess

# Obter MAC address do host
mac = ':'.join([f'{(uuid.getnode() >> i) & 0xff:02x}'
               for i in range(0, 48, 8)][::-1])
print(f"MAC address: {mac}")

# Ver tabela ARP (mapeamento IP -> MAC)
result = subprocess.run(["arp", "-a"], capture_output=True, text=True)
print(result.stdout)

Protocolos de acesso ao meio:

1. CSMA/CD (Carrier Sense Multiple Access / Collision Detection)
   Usado pelo Ethernet clássico (half-duplex)

   Algoritmo:
     1. Escuta o meio (carrier sense)
     2. Se livre → transmite
     3. Se ocupado → espera
     4. Se colisão detectada durante transmissão:
        a. Para de transmitir
        b. Envia jam signal (32 bits)
        c. Espera tempo aleatório (exponential backoff)
        d. Tenta novamente

   Exponential backoff:
     Após n colisões, espera K × 512 bit-times
     onde K é aleatório em [0, 2^n - 1]
     Máximo: n = 10 → K em [0, 1023]
     Após 16 colisões: desiste (frame descartado)

2. CSMA/CA (Collision Avoidance)
   Usado pelo Wi-Fi (802.11) — não detecta colisões no ar

   Algoritmo:
     1. Escuta o meio
     2. Se livre por DIFS → transmite
     3. Receptor envia ACK
     4. Se ACK não recebido → colisão, retransmite

   RTS/CTS (opcional): resolve "hidden terminal problem"
     A ---RTS---> AP ---CTS---> todos
     (todos sabem que A vai transmitir → esperam)

Hub (camada 1 - fisica):
  Recebe quadro em uma porta -> replica para TODAS as outras portas
  Nao olha MAC addresses. Colisoes frequentes. Obsoleto.

  A --[frame]--> [HUB] --[frame]--> B
                   |---[frame]--> C  (C recebe mesmo sem ser destino)
                   |---[frame]--> D  (D tambem recebe)

Switch (camada 2 - enlace):
  Mantém tabela MAC (MAC -> porta). Encaminha apenas para a porta correta.
  Sem colisoes. Performance muito melhor.

  A --[frame]--> [SWITCH] --[frame]--> B  (apenas B recebe)
                   |
              Tabela MAC:
              AA:BB:CC:11 -> porta 1 (A)
              AA:BB:CC:22 -> porta 2 (B)
              AA:BB:CC:33 -> porta 3 (C)

Host A quer enviar para 192.168.1.5, mas so sabe o IP. Precisa do MAC.

1. A envia ARP Request (broadcast):
   "Quem tem o IP 192.168.1.5? Me diga seu MAC."
   Destino: FF:FF:FF:FF:FF:FF (broadcast - todos recebem)

2. Host B (192.168.1.5) responde com ARP Reply:
   "Eu sou 192.168.1.5. Meu MAC e AA:BB:CC:DD:EE:55"

3. A guarda na ARP cache: 192.168.1.5 -> AA:BB:CC:DD:EE:55

4. A encapsula o pacote IP em um frame Ethernet com:
   MAC destino: AA:BB:CC:DD:EE:55
   MAC origem:  (MAC do A)
   Tipo: 0x0800 (IPv4)
   Payload: pacote IP

import time

class EthernetSwitch:
    """Simulação de um switch Ethernet com self-learning."""

    def __init__(self, num_ports, aging_time=300):
        self.mac_table = {}     # MAC → (porta, timestamp)
        self.num_ports = num_ports
        self.aging_time = aging_time

    def receive_frame(self, src_mac, dst_mac, in_port):
        """Processa um quadro recebido."""
        # Self-learning: registra MAC de origem
        self.mac_table[src_mac] = (in_port, time.time())

        # Forwarding: decide para onde enviar
        if dst_mac == "FF:FF:FF:FF:FF:FF":
            # Broadcast: envia para todas as portas exceto origem
            out_ports = [p for p in range(self.num_ports) if p != in_port]
            print(f"  BROADCAST → portas {out_ports}")
        elif dst_mac in self.mac_table:
            # Unicast conhecido: envia para porta específica
            out_port = self.mac_table[dst_mac][0]
            print(f"  FORWARD → porta {out_port}")
        else:
            # MAC desconhecido: flooding
            out_ports = [p for p in range(self.num_ports) if p != in_port]
            print(f"  FLOOD (MAC desconhecido) → portas {out_ports}")

sw = EthernetSwitch(4)
sw.receive_frame("AA:11", "BB:22", 0)  # Flood (BB:22 desconhecido)
sw.receive_frame("BB:22", "AA:11", 1)  # Forward porta 0 (AA:11 aprendido)

Sem VLAN:                        Com VLANs:
  Todos no mesmo dominio         VLAN 10 (Eng): A, B
  de broadcast                   VLAN 20 (RH):  C, D

  A, B, C, D <-> broadcast       A <-> B (VLAN 10)
  (todos veem tudo)               C <-> D (VLAN 20)
                                  A -/-> C (bloqueado, VLANs diferentes)

  802.1Q: adiciona tag de 4 bytes ao frame Ethernet
  indicando a qual VLAN o frame pertence

Tag 802.1Q inserida no quadro Ethernet:
  ┌──────┬──────┬──────┬──────────┬──────┬─────────┬─────┐
  │ Dst  │ Src  │ TPID │ PCP│DEI│ │ VID  │  Type   │ ... │
  │ MAC  │ MAC  │0x8100│ 3b │1b │ │ 12b  │         │     │
  └──────┴──────┴──────┴──────────┴──────┴─────────┴─────┘
  TPID: Tag Protocol ID (0x8100 = 802.1Q)
  PCP:  Priority Code Point (QoS)
  VID:  VLAN ID (0-4095, 12 bits → 4096 VLANs possíveis)

Trunk port vs Access port:
  Access port: pertence a UMA VLAN, sem tag
  Trunk port: carrega múltiplas VLANs, com tag 802.1Q

Trace completo: MCP server -> Neon Postgres

Camada 7 (Aplicacao): MCP tool call (JSON-RPC)
Camada 7 (Aplicacao): PostgreSQL wire protocol (query SQL)
Camada 4 (Transporte): TCP segmento (porta 5432)
Camada 3 (Rede):       IP pacote (IP do Fly.io -> IP do Neon)
Camada 2 (Enlace):     Ethernet frame (MAC do gateway Fly.io)
Camada 1 (Fisica):     Sinais eletricos/opticos no datacenter

Quando "a conexao com o banco falha", o problema pode estar
em QUALQUER uma dessas camadas:
  - DNS nao resolve (camada 7)
  - Firewall bloqueia porta 5432 (camada 3/4)
  - Rede do datacenter com falha (camada 2/1)
  - TLS certificate expired (entre camada 4 e 7)

Entender todas as camadas = debugar qualquer problema de rede.