TCP/IP: qué es, pila de protocolos y transmisión de datos

¿Qué es TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) es una pila de protocolos desarrollada en la década de 1970 para ARPANET y se ha convertido en el estándar de facto para Internet global. Define cómo los datos se dividen en paquetes, se direccionan, se transmiten y se reensamblan en el lado del receptor.

La arquitectura TCP/IP se basa en un principio multicapa, donde cada capa abstrae funciones específicas. La capa de aplicación trabaja con datos de la aplicación, la capa de transporte garantiza la confiabilidad, la capa de red maneja el enrutamiento y la capa de enlace gestiona la transmisión física. La modularidad permite reemplazar protocolos dentro de una capa sin afectar a las vecinas.

En el desarrollo móvil, TCP/IP es utilizado por cada aplicación que realiza solicitudes de red. Bibliotecas como URLSession, OkHttp, AFNetworking y Alamofire funcionan sobre esta pila, ocultando al desarrollador los detalles del empaquetado y enrutamiento de paquetes. Sin embargo, comprender TCP/IP es necesario para optimizar el rendimiento: configurar parámetros TCP a través de URLSessionConfiguration permite gestionar tiempos de espera, mantener conexiones HTTP Persistentes y configurar proxies para entornos empresariales.

Comprender TCP/IP es esencial para diagnosticar problemas de red: si una aplicación no puede conectarse a un servidor, el problema puede estar en cualquier capa de la pila, desde el canal físico hasta el protocolo de aplicación. Herramientas como tcpdump, Wireshark y Charles Proxy permiten analizar el tráfico en cada capa y encontrar cuellos de botella. Para desarrolladores móviles, Xcode proporciona un Network Debug Dashboard y Android Studio ofrece un Network Inspector para analizar conexiones TCP en tiempo real.

Niveles del modelo TCP/IP

El modelo TCP/IP incluye cuatro niveles, cada uno realizando funciones estrictamente definidas durante la transmisión de datos. Comprender esta jerarquía es necesario para diagnosticar problemas de red y optimizar aplicaciones.

Capa de aplicación

En la capa de aplicación operan protocolos con los que las aplicaciones interactúan directamente: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Esta capa formatea los datos de una manera que la aplicación entiende y los pasa a la capa de transporte. Los desarrolladores de aplicaciones móviles trabajan en esta capa a través de bibliotecas de red.

Capa de transporte

La capa de transporte garantiza la transmisión de datos entre aplicaciones en diferentes dispositivos. Los protocolos principales son TCP (transmisión confiable con confirmación) y UDP (transmisión rápida sin garantías). TCP agrega puertos de origen y destino a los datos, gestiona el orden de los paquetes y controla la congestión de la red.

Capas de red y enlace

La capa de red se implementa mediante el protocolo IP, que define el direccionamiento (IPv4, IPv6) y el enrutamiento de paquetes. Cada paquete contiene las direcciones IP del remitente y el destinatario, y los enrutadores a lo largo de la ruta toman decisiones sobre el siguiente nodo basándose en tablas de enrutamiento. IPv4 utiliza direcciones de 32 bits (aproximadamente 4.3 mil millones), mientras que IPv6 usa direcciones de 128 bits, resolviendo el problema de agotamiento de direcciones.

La capa de enlace trabaja con el medio físico de transmisión: Ethernet, Wi-Fi, Bluetooth. Esta capa convierte los paquetes en señales y viceversa, gestiona el acceso al medio de transmisión mediante direcciones MAC y detecta errores de la capa física usando secuencias de verificación de trama (FCS).

En la capa de enlace operan protocolos como ARP (Address Resolution Protocol), que convierte direcciones IP en direcciones MAC de dispositivos en la red local, y PPP (Point-to-Point Protocol), utilizado en conexiones VPN y redes móviles de datos.

Cómo funciona el protocolo TCP

TCP (Transmission Control Protocol) es uno de los principales protocolos de la capa de transporte. Garantiza una entrega confiable, ordenada y verificada de errores de un flujo de bytes entre aplicaciones. Antes de transmitir datos, TCP establece una conexión mediante un triple saludo.

El triple saludo (three-way handshake) comienza con el envío de un paquete SYN por parte del cliente. El servidor responde con un paquete SYN-ACK, confirmando la recepción. El cliente completa el saludo con un paquete ACK, después de lo cual comienza la transmisión de datos. Este proceso garantiza que ambas partes están listas para el intercambio y sincronizadas en los números de secuencia.

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

En el ejemplo, se crea un socket TCP con el tipo SOCK_STREAM, que realiza automáticamente el triple saludo al llamar a connect. El método send transmite una solicitud HTTP y recv recibe la respuesta. Al finalizar, close envía un paquete FIN para cerrar correctamente la conexión.

Servidor TCP con manejo de clientes

Veamos un ejemplo de un servidor TCP en Python que acepta múltiples clientes mediante hilos. Cada conexión se maneja en un hilo separado, lo que permite atender a múltiples clientes simultáneamente sin bloquear el bucle 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 en el puerto 9090')

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

El servidor TCP maneja cada conexión en un hilo separado, llamando a accept en un bucle infinito. La función handle_client recibe datos, los convierte a mayúsculas y los envía de vuelta mediante sendall. Cuando el bucle de recv termina (cuando el cliente cierra la conexión), el hilo finaliza y el socket se cierra automáticamente. En aplicaciones móviles, este trabajo de bajo nivel con sockets no se usa directamente — las bibliotecas HTTP móviles gestionan las conexiones mediante grupos de hilos y reutilizan automáticamente las conexiones TCP.

Diferencias entre TCP y UDP

La elección entre TCP y UDP es una de las decisiones clave al diseñar la comunicación en red. TCP garantiza la entrega, el orden y la integridad de los datos a costa de latencia adicional. UDP sacrifica la confiabilidad por una latencia mínima y una menor carga en el canal.

Para aplicaciones móviles, la elección del protocolo depende del escenario: las API REST y la carga de datos requieren TCP, mientras que las videollamadas y los juegos en línea se benefician de la velocidad de UDP. Algunas aplicaciones combinan ambos protocolos — TCP para el control y UDP para el flujo de medios. El moderno protocolo QUIC, que funciona sobre UDP y se usa en HTTP/3, combina las ventajas de ambos enfoques y ya es compatible con iOS y Android a través de URLSession automáticamente.

Ejemplos de código TCP/IP

Veamos un ejemplo de un cliente TCP en Python con manejo de errores y tiempo de espera. Este enfoque se utiliza en aplicaciones móviles para una conexión confiable al 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'Error de conexión: {err}')
        sys.exit(1)

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

La función tcp_client recibe un host y un puerto, crea un socket con un tiempo de espera de 10 segundos e intenta conectarse. En caso de error de conexión — por ejemplo, servidor no disponible o bloqueo de firewall — se lanza una excepción con una descripción del problema. En aplicaciones móviles, el tiempo de espera de conexión es crítico: demasiado corto provoca errores falsos en redes lentas, demasiado largo provoca congelación de la interfaz. El valor recomendado para redes móviles es de 10 a 15 segundos para timeoutIntervalForRequest y de 30 a 60 segundos para timeoutIntervalForResource en la configuración de URLSession.