TCP/IP: cos'è, pila di protocolli e trasmissione dati

Cos'è TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) è una pila di protocolli sviluppata negli anni '70 per ARPANET ed è diventata lo standard de facto per Internet globale. Definisce come i dati vengono divisi in pacchetti, indirizzati, trasmessi e riassemblati sul lato del destinatario.

L'architettura TCP/IP è costruita su un principio multistrato, dove ogni livello astrae funzioni specifiche. Il livello applicazione lavora con i dati dell'applicazione, il livello trasporto garantisce l'affidabilità, il livello rete gestisce il routing e il livello collegamento gestisce la trasmissione fisica. La modularità consente di sostituire i protocolli all'interno di un livello senza influenzare quelli vicini.

Nello sviluppo mobile, TCP/IP è utilizzato da ogni applicazione che effettua richieste di rete. Librerie come URLSession, OkHttp, AFNetworking e Alamofire funzionano sopra questa pila, nascondendo allo sviluppatore i dettagli dell'impacchettamento e del routing dei pacchetti. Tuttavia, comprendere TCP/IP è necessario per l'ottimizzazione delle prestazioni: configurare i parametri TCP tramite URLSessionConfiguration consente di gestire i timeout, mantenere connessioni HTTP Persistenti e configurare proxy per ambienti aziendali.

Comprendere TCP/IP è essenziale per diagnosticare problemi di rete: se un'applicazione non riesce a connettersi a un server, il problema può essere a qualsiasi livello della pila — dal canale fisico al protocollo applicativo. Strumenti come tcpdump, Wireshark e Charles Proxy consentono di analizzare il traffico a ogni livello e trovare i colli di bottiglia. Per gli sviluppatori mobili, Xcode fornisce un Network Debug Dashboard e Android Studio offre un Network Inspector per analizzare le connessioni TCP in tempo reale.

Livelli del modello TCP/IP

Il modello TCP/IP include quattro livelli, ciascuno dei quali esegue funzioni strettamente definite durante la trasmissione dei dati. Comprendere questa gerarchia è necessario per diagnosticare problemi di rete e ottimizzare le applicazioni.

Livello applicazione

Al livello applicazione operano i protocolli con cui le applicazioni interagiscono direttamente: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Questo livello formatta i dati in modo comprensibile all'applicazione e li passa al livello trasporto. Gli sviluppatori di applicazioni mobili lavorano a questo livello tramite librerie di rete.

Livello trasporto

Il livello trasporto garantisce la trasmissione dei dati tra applicazioni su dispositivi diversi. I principali protocolli sono TCP (trasmissione affidabile con conferma) e UDP (trasmissione veloce senza garanzie). TCP aggiunge le porte del mittente e del destinatario ai dati, gestisce l'ordine dei pacchetti e controlla la congestione della rete.

Livelli rete e collegamento

Il livello rete è implementato dal protocollo IP, che definisce l'indirizzamento (IPv4, IPv6) e il routing dei pacchetti. Ogni pacchetto contiene gli indirizzi IP del mittente e del destinatario, e i router lungo il percorso prendono decisioni sul nodo successivo in base alle tabelle di routing. IPv4 utilizza indirizzi a 32 bit (circa 4,3 miliardi), mentre IPv6 utilizza indirizzi a 128 bit, risolvendo il problema dell'esaurimento degli indirizzi.

Il livello collegamento lavora con il mezzo di trasmissione fisico: Ethernet, Wi-Fi, Bluetooth. Questo livello converte i pacchetti in segnali e viceversa, gestisce l'accesso al mezzo di trasmissione tramite indirizzi MAC e rileva gli errori del livello fisico utilizzando sequenze di controllo del frame (FCS).

Al livello collegamento operano protocolli come ARP (Address Resolution Protocol), che converte gli indirizzi IP in indirizzi MAC dei dispositivi sulla rete locale, e PPP (Point-to-Point Protocol), utilizzato nelle connessioni VPN e nelle reti dati mobili.

Come funziona il protocollo TCP

TCP (Transmission Control Protocol) è uno dei principali protocolli del livello trasporto. Garantisce una consegna affidabile, ordinata e verificata degli errori di un flusso di byte tra applicazioni. Prima di trasmettere i dati, TCP stabilisce una connessione tramite una stretta di mano a tre vie.

La stretta di mano a tre vie (three-way handshake) inizia con l'invio di un pacchetto SYN da parte del client. Il server risponde con un pacchetto SYN-ACK, confermando la ricezione. Il client completa la stretta di mano con un pacchetto ACK, dopo il quale inizia la trasmissione dei dati. Questo processo garantisce che entrambe le parti siano pronte per lo scambio e sincronizzate sui numeri di sequenza.

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()

Nell'esempio, viene creato un socket TCP con il tipo SOCK_STREAM, che esegue automaticamente la stretta di mano a tre vie quando viene chiamato connect. Il metodo send trasmette una richiesta HTTP e recv riceve la risposta. Al completamento, close invia un pacchetto FIN per chiudere correttamente la connessione.

Server TCP con gestione dei client

Consideriamo un esempio di server TCP in Python che accetta più client tramite thread. Ogni connessione viene gestita in un thread separato, consentendo di servire più client contemporaneamente senza bloccare il ciclo principale.

import socket
import threading

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

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('Server TCP avviato sulla porta 9090')

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

Il server TCP gestisce ogni connessione in un thread separato, chiamando accept in un ciclo infinito. La funzione handle_client riceve i dati, li converte in maiuscolo e li rimanda indietro tramite sendall. Quando il ciclo recv termina (quando il client chiude la connessione), il thread termina e il socket si chiude automaticamente. Nelle applicazioni mobili, questo lavoro di basso livello con i socket non viene utilizzato direttamente — le librerie HTTP mobili gestiscono le connessioni tramite pool di thread e riutilizzano automaticamente le connessioni TCP.

Differenze tra TCP e UDP

La scelta tra TCP e UDP è una delle decisioni chiave nella progettazione della comunicazione di rete. TCP garantisce consegna, ordine e integrità dei dati a costo di una latenza aggiuntiva. UDP sacrifica l'affidabilità per una latenza minima e un carico inferiore sul canale.

Per le applicazioni mobili, la scelta del protocollo dipende dallo scenario: le API REST e il caricamento dei dati richiedono TCP, mentre le videochiamate e i giochi online beneficiano della velocità di UDP. Alcune applicazioni combinano entrambi i protocolli — TCP per il controllo e UDP per il flusso multimediale. Il moderno protocollo QUIC, che funziona su UDP ed è utilizzato in HTTP/3, combina i vantaggi di entrambi gli approcci ed è già supportato su iOS e Android tramite URLSession automaticamente.

Esempi di codice TCP/IP

Consideriamo un esempio di client TCP in Python con gestione degli errori e timeout. Questo approccio viene utilizzato nelle applicazioni mobili per una connessione affidabile al server.

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'Connesso a {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Errore di connessione: {err}')
        sys.exit(1)

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

La funzione tcp_client riceve un host e una porta, crea un socket con un timeout di 10 secondi e tenta di connettersi. In caso di errore di connessione — ad esempio, server non disponibile o blocco del firewall — viene generata un'eccezione con una descrizione del problema. Nelle applicazioni mobili, il timeout di connessione è critico: troppo corto porta a falsi errori su reti lente, troppo lungo porta al congelamento dell'interfaccia. Il valore consigliato per le reti mobili è di 10–15 secondi per timeoutIntervalForRequest e di 30–60 secondi per timeoutIntervalForResource nella configurazione di URLSession.