TCP/IP: o que é, pilha de protocolos e transmissão de dados

O que é TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) é uma pilha de protocolos desenvolvida na década de 1970 para a ARPANET e tornou-se o padrão de facto para a Internet global. Ela define como os dados são divididos em pacotes, endereçados, transmitidos e remontados no lado do destinatário.

A arquitetura TCP/IP é construída em um princípio de múltiplas camadas, onde cada camada abstrai funções específicas. A camada de aplicação trabalha com dados da aplicação, a camada de transporte garante confiabilidade, a camada de rede lida com o roteamento e a camada de enlace gerencia a transmissão física. A modularidade permite substituir protocolos dentro de uma camada sem afetar as vizinhas.

No desenvolvimento mobile, o TCP/IP é usado por toda aplicação que faz requisições de rede. Bibliotecas como URLSession, OkHttp, AFNetworking e Alamofire funcionam sobre esta pilha, escondendo do desenvolvedor os detalhes de empacotamento e roteamento de pacotes. No entanto, compreender TCP/IP é necessário para otimização de desempenho: configurar parâmetros TCP através de URLSessionConfiguration permite gerenciar timeouts, manter conexões HTTP Persistentes e configurar proxies para ambientes corporativos.

Compreender TCP/IP é essencial para diagnosticar problemas de rede: se uma aplicação não consegue conectar a um servidor, o problema pode estar em qualquer camada da pilha — desde o canal físico até o protocolo de aplicação. Ferramentas como tcpdump, Wireshark e Charles Proxy permitem analisar o tráfego em cada camada e encontrar gargalos. Para desenvolvedores mobile, o Xcode fornece um Network Debug Dashboard e o Android Studio oferece um Network Inspector para analisar conexões TCP em tempo real.

Camadas do modelo TCP/IP

O modelo TCP/IP inclui quatro camadas, cada uma realizando funções estritamente definidas durante a transmissão de dados. Compreender esta hierarquia é necessário para diagnosticar problemas de rede e otimizar aplicações.

Camada de aplicação

Na camada de aplicação operam protocolos com os quais as aplicações interagem diretamente: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Esta camada formata os dados de uma forma que a aplicação entende e os passa para a camada de transporte. Desenvolvedores de aplicações mobile trabalham nesta camada através de bibliotecas de rede.

Camada de transporte

A camada de transporte garante a transmissão de dados entre aplicações em diferentes dispositivos. Os principais protocolos são TCP (transmissão confiável com confirmação) e UDP (transmissão rápida sem garantias). TCP adiciona portas de remetente e destinatário aos dados, gerencia a ordenação de pacotes e controla a congestão da rede.

Camadas de rede e enlace

A camada de rede é implementada pelo protocolo IP, que define o endereçamento (IPv4, IPv6) e o roteamento de pacotes. Cada pacote contém os endereços IP do remetente e do destinatário, e os roteadores ao longo do caminho tomam decisões sobre o próximo nó com base em tabelas de roteamento. IPv4 usa endereços de 32 bits (cerca de 4,3 bilhões), enquanto IPv6 usa endereços de 128 bits, resolvendo o problema de esgotamento de endereços.

A camada de enlace trabalha com o meio físico de transmissão: Ethernet, Wi-Fi, Bluetooth. Esta camada converte pacotes em sinais e vice-versa, gerencia o acesso ao meio de transmissão através de endereços MAC e detecta erros da camada física usando sequências de verificação de quadro (FCS).

Na camada de enlace operam protocolos como ARP (Address Resolution Protocol), que converte endereços IP em endereços MAC de dispositivos na rede local, e PPP (Point-to-Point Protocol), usado em conexões VPN e redes móveis de dados.

Como funciona o protocolo TCP

TCP (Transmission Control Protocol) é um dos principais protocolos da camada de transporte. Ele garante entrega confiável, ordenada e verificada de erros de um fluxo de bytes entre aplicações. Antes de transmitir dados, o TCP estabelece uma conexão através de um handshake triplo.

O handshake triplo (three-way handshake) começa com o envio de um pacote SYN pelo cliente. O servidor responde com um pacote SYN-ACK, confirmando o recebimento. O cliente completa o handshake com um pacote ACK, após o qual a transmissão de dados começa. Este processo garante que ambas as partes estão prontas para a troca e sincronizadas nos números de sequência.

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
response = sock.recv(4096)
print(response.decode())
sock.close()

No exemplo, um socket TCP é criado com o tipo SOCK_STREAM, que realiza automaticamente o handshake triplo quando connect é chamado. O método send transmite uma requisição HTTP e recv recebe a resposta. Após a conclusão, close envia um pacote FIN para fechar corretamente a conexão.

Servidor TCP com tratamento de clientes

Vamos ver um exemplo de um servidor TCP em Python que aceita múltiplos clientes através de threads. Cada conexão é tratada em uma thread separada, permitindo atender vários clientes simultaneamente sem bloquear o loop principal.

import socket
import threading

def handle_client(conn, addr):
    print(f'Cliente conectado: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Cliente {addr} desconectado')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('Servidor TCP iniciado na porta 9090')

while True:
    conn, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

O servidor TCP trata cada conexão em uma thread separada, chamando accept em um loop infinito. A função handle_client recebe dados, converte para maiúsculas e os envia de volta via sendall. Quando o loop recv termina (quando o cliente fecha a conexão), a thread termina e o socket é fechado automaticamente. Em aplicações mobile, esse trabalho de baixo nível com sockets não é usado diretamente — as bibliotecas HTTP móveis gerenciam conexões através de pools de threads e reutilizam automaticamente as conexões TCP.

Diferenças entre TCP e UDP

A escolha entre TCP e UDP é uma das decisões chave ao projetar a comunicação de rede. TCP garante entrega, ordem e integridade dos dados ao custo de latência adicional. UDP sacrifica a confiabilidade por latência mínima e menor carga no canal.

Para aplicações mobile, a escolha do protocolo depende do cenário: APIs REST e carregamento de dados requerem TCP, enquanto videochamadas e jogos online se beneficiam da velocidade do UDP. Algumas aplicações combinam ambos os protocolos — TCP para controle e UDP para fluxo de mídia. O moderno protocolo QUIC, que roda sobre UDP e é usado em HTTP/3, combina as vantagens de ambas as abordagens e já é suportado no iOS e Android através do URLSession automaticamente.

Exemplos de código TCP/IP

Vamos ver um exemplo de um cliente TCP em Python com tratamento de erros e timeout. Esta abordagem é usada em aplicações mobile para conexão confiável ao servidor.

import socket
import sys

def tcp_client(host, port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(10)
        sock.connect((host, port))
        print(f'Conectado a {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Erro de conexão: {err}')
        sys.exit(1)

sock = tcp_client('api.example.com', 443)
sock.close()

A função tcp_client recebe um host e porta, cria um socket com timeout de 10 segundos e tenta conectar. Em caso de erro de conexão — por exemplo, servidor indisponível ou bloqueio de firewall — uma exceção é lançada com a descrição do problema. Em aplicações mobile, o timeout de conexão é crítico: muito curto leva a erros falsos em redes lentas, muito longo leva ao congelamento da interface. O valor recomendado para redes móveis é de 10 a 15 segundos para timeoutIntervalForRequest e de 30 a 60 segundos para timeoutIntervalForResource na configuração do URLSession.