TCP e Comunicacao Confiavel

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          Source Port          |       Destination Port        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                        Sequence Number                       |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                    Acknowledgment Number                     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Offset|  Res  |C|E|U|A|P|R|S|F|          Window Size         |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|           Checksum            |       Urgent Pointer          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                    Options (variable)                 |Padding|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Header TCP: 20 bytes (minimo) vs UDP: 8 bytes
Flags importantes:
  SYN (S) = Sincronizar sequence numbers (inicio de conexao)
  ACK (A) = Acknowledgment valido
  FIN (F) = Finalizar conexao
  RST (R) = Reset (abortar conexao)
  PSH (P) = Push (entrega imediata ao aplicativo)

Cliente                          Servidor
   |                                |
   |------- SYN (seq=x) ---------->|   1. Cliente quer conectar
   |                                |      (escolhe seq number inicial x)
   |                                |
   |<--- SYN-ACK (seq=y, ack=x+1)--|   2. Servidor aceita e envia seu seq
   |                                |      (escolhe seq number inicial y)
   |                                |
   |------- ACK (ack=y+1) -------->|   3. Cliente confirma
   |                                |
   |===== CONEXAO ESTABELECIDA =====|
   |                                |
   |------- DATA (seq=x+1) ------->|   Agora pode enviar dados
   |<------ ACK (ack=x+1+len) -----|

Dados: "HELLO" (5 bytes), seq inicial = 100

Cliente:  seq=100, data="HE" (2 bytes)  ------->
                                         <------- ACK=102 (proximo esperado)
Cliente:  seq=102, data="LL" (2 bytes)  ------->
                                         <------- ACK=104
Cliente:  seq=104, data="O"  (1 byte)  ------->
                                         <------- ACK=105

Se um segmento se perder, o receptor reenvia o ultimo ACK:
Cliente:  seq=102, data="LL" ------> [PERDIDO]
          (timeout, sem ACK)
Cliente:  seq=102, data="LL" ------->  (retransmissao)
                                <------- ACK=104

Sliding Window:

Remetente:
  [enviado+ACK] [enviado, sem ACK] [pode enviar] [nao pode enviar]
  ─────────────|──────────────────|─────────────|──────────────────
               ^                  ^              ^
          base da janela    proximo a enviar   limite da janela

Receptor anuncia: Window = 4000 bytes
  -> Remetente pode ter ate 4000 bytes "em voo" (enviados, sem ACK)

Se receptor esta lento:  Window = 0  -> Remetente para de enviar!
Quando receptor libera buffer: Window = 2000 -> Remetente retoma

Cliente                          Servidor
   |                                |
   |------- FIN ------------------>|   1. Cliente quer fechar
   |<------ ACK -------------------|   2. Servidor confirma
   |                                |      (servidor pode continuar enviando)
   |<------ FIN -------------------|   3. Servidor tambem quer fechar
   |------- ACK ------------------>|   4. Cliente confirma
   |                                |
   | [TIME_WAIT: 2*MSL]            |   Cliente espera antes de liberar porta
   |                                |
   |=== CONEXAO ENCERRADA =========|

import socket

# ── Servidor TCP (echo) ──
def tcp_server():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # STREAM = TCP
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind(("0.0.0.0", 9999))
    server.listen(5)  # Backlog de 5 conexoes pendentes
    print("TCP server ouvindo na porta 9999")

    while True:
        conn, addr = server.accept()  # Handshake TCP acontece aqui
        print(f"Conexao de {addr}")

        while True:
            data = conn.recv(1024)
            if not data:
                break
            print(f"Recebido: {data.decode()}")
            conn.sendall(data)  # Echo de volta

        conn.close()
        print(f"Conexao com {addr} encerrada")

# ── Cliente TCP ──
def tcp_client():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect(("localhost", 9999))  # Three-way handshake

    sock.sendall(b"Hello, TCP!")
    response = sock.recv(1024)
    print(f"Resposta: {response.decode()}")

    sock.close()  # FIN handshake

TCP no harness.os — esta em todo lugar:

1. Neon Postgres: usa PostgreSQL wire protocol sobre TCP
   Agente --> TCP:5432 --> Neon Proxy --> TCP --> Neon Compute
   Confiabilidade do TCP garante: queries chegam intactas,
   resultados nao se perdem, transacoes sao atomicas.

2. MCP HTTP/SSE: HTTP roda sobre TCP
   Claude CLI --> TCP:443 --> Fly.io --> MCP Server
   TCP garante que tool calls e resultados nao se perdem.

3. Session handoffs: confiabilidade critica
   Handoff = "carta" que a proxima sessao deve receber intacta.
   Perder um handoff = perder contexto de trabalho.
   TCP (via HTTP POST ao Neon) garante entrega.

Paralelo: TCP reliability = session handoff reliability
  TCP garante: dados chegam, em ordem, sem duplicatas.
  Harness garante: handoffs sao salvos, com estado, sem perda.