1. Un extremo de comunicación local
En los bloques anteriores utilizaste tuberías, colas y memoria compartida. Ahora incorporaremos una interfaz que también se usa en redes, pero aplicada a procesos de una misma máquina: los sockets de dominio Unix.
Un socket es un extremo de comunicación. La aplicación lo utiliza mediante un descriptor de archivo para enviar o recibir datos, conectar con otro extremo o aceptar conexiones, según el tipo y el estado de ese socket.
AF_UNIX selecciona una familia de comunicación local. El tipo, como SOCK_STREAM o SOCK_DGRAM, define qué contrato ofrece el transporte de datos.
No hay una región de datos que los dos programas deban mapear y proteger directamente. El núcleo mantiene los búferes del transporte. La aplicación sigue siendo responsable del formato, los límites de trabajo pendiente y el significado de las respuestas.
El uso local no exige que los procesos sean padre e hijo. Un servidor puede publicar una dirección que otros ejecutables utilicen para conectarse. Esa construcción comenzará en el tema 32.
2. Familia, tipo y protocolo
int socket(int familia, int tipo, int protocolo);
int fd = socket(AF_UNIX, SOCK_STREAM, 0);| Argumento | Elección del ejemplo | Pregunta que responde |
|---|---|---|
| Familia. | AF_UNIX. | ¿En qué dominio se localizan los extremos? |
| Tipo. | SOCK_STREAM. | ¿Se transporta un flujo o se conservan unidades? |
| Protocolo. | 0. | ¿Qué protocolo compatible por defecto se selecciona para esa combinación? |
AF_LOCAL es un nombre alternativo de AF_UNIX en los sistemas que lo proporcionan. Utilizaremos AF_UNIX para mantener una denominación uniforme durante el bloque.
Los tipos no identifican por sí solos TCP o UDP. AF_INET con SOCK_STREAM suele utilizar TCP, pero AF_UNIX con SOCK_STREAM ofrece un flujo local sin convertirlo en una conexión TCP.
Del mismo modo, SOCK_DGRAM en AF_UNIX no significa «UDP por una ruta». La familia determina las reglas de direccionamiento y transporte que deben consultarse. La creación y selección se describen en socket(2).
En estas prácticas el tercer argumento será cero. No se pasa un número de puerto ni un identificador de tarea en ese parámetro.
3. Crear un socket no lo conecta
socket retorna un descriptor no negativo al crear el extremo, o −1 al fallar, con el motivo en errno. El descriptor cero también es válido; no se rechaza con una condición como fd <= 0.
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) {
perror("socket");
} else {
/* Aun no hay una conexion preparada para intercambiar datos. */
if (close(fd) == -1) perror("close");
}La llamada no crea por sí sola un servidor, una ruta pública ni un segundo extremo. En un servicio de conexión habrá que asignar una dirección, escuchar, conectar y aceptar. No se puede asumir que send funcionará inmediatamente después de socket.
El descriptor de escucha y el descriptor de una conexión aceptada tendrán funciones distintas. El tema 32 desarrollará esa separación con bind, listen y accept; aquí nos centraremos en el contrato de los tipos.
Para observar datos sin preparar todavía un servidor, utilizaremos socketpair como herramienta de laboratorio: crea dos extremos ya conectados. Su uso con fork y los cierres direccionales se estudiará en profundidad en el tema 34.
4. Comparar los tres tipos
| Propiedad en AF_UNIX de Linux | SOCK_STREAM | SOCK_DGRAM | SOCK_SEQPACKET |
|---|---|---|---|
| Unidad visible. | Secuencia de bytes. | Datagrama. | Registro o paquete de una conexión. |
| Conserva límites de envío. | No. | Sí. | Sí. |
| Conexión. | Orientado a conexión. | Puede elegir destino por envío o fijar un interlocutor. | Orientado a conexión. |
| Orden y entrega local. | Flujo fiable y ordenado mientras la comunicación progresa correctamente. | Datagramas locales fiables y sin reordenación bajo las garantías de esta familia. | Registros fiables, ordenados y con límites preservados. |
| Recepción con poco espacio. | Retira un prefijo; quedan bytes para después. | Puede truncar y descartar el resto de esa unidad. | Puede truncar y descartar el resto del registro. |
| Formato de aplicación. | Necesita enmarcar mensajes dentro del flujo. | Debe definir tamaño y contenido de cada unidad. | Debe definir tamaño y contenido de cada registro. |
Las garantías anteriores corresponden a AF_UNIX en el entorno Linux del curso. No se trasladan automáticamente a otra familia. En particular, un datagrama Unix no hereda el modelo de pérdidas de UDP solo por utilizar la constante SOCK_DGRAM.
La comparación de tipos y las formas de direccionamiento están en unix(7). Fiabilidad del transporte no significa confirmación de que una tarea de aplicación terminó: el destinatario puede recibir datos y fallar antes de procesarlos.
Los búferes son finitos. Ningún tipo permite enviar un volumen arbitrario sin límites, bloqueos o errores. «Conserva mensajes» tampoco significa que acepte mensajes de cualquier tamaño.
5. SOCK_STREAM: un flujo de bytes
Si el emisor hace dos envíos con ABCDE y xyz, el receptor observa la secuencia ABCDExyz. No recibe una garantía de que habrá exactamente dos llamadas con longitudes cinco y tres.
Envios de aplicacion: "ABCDE" "xyz"
Recepciones posibles: "ABCDExyz"
"ABC" "DEx" "yz"
"A" "BCDE" "xy" "z"
Contrato estable: los bytes conservan su secuencia.Una recepción no tiene por qué llenar su búfer. Una escritura o envío también puede aceptar solo una parte del contenido, especialmente si crece el tamaño o cambia el modo de operación. El programa debe conservar cuánto falta y continuar según su protocolo.
La aplicación puede definir mensajes de longitud fija, un prefijo de longitud o delimitadores con reglas de escape. Esa decisión no la toma el transporte. El tema 33 desarrollará un protocolo de petición y respuesta con lecturas parciales.
Un búfer corto no pierde el sufijo del flujo por ese motivo: los bytes que no se retiraron siguen pendientes. El problema es reconstruir unidades de aplicación, no esperar que los límites originales de send reaparezcan en recv.
6. SOCK_DGRAM: unidades de mensaje locales
Con datagramas, los envíos ABCDE y xyz forman dos unidades. Una recepción retira una unidad, no una mezcla del final de una con el comienzo de la siguiente.
En AF_UNIX de Linux se conserva la entrega ordenada y fiable de datagramas dentro de las condiciones del transporte. Eso no elimina la posibilidad de fallos de envío, receptores ausentes o colas llenas; cada retorno debe comprobarse.
El programa puede enviar a una dirección con sendto, o fijar un interlocutor con connect y después usar send. Ese connect de un datagrama no establece un flujo de bytes ni obliga a usar listen y accept.
Una aplicación que deba responder necesita un mecanismo para identificar al emisor y localizar su dirección o canal de respuesta. No basta con elegir DGRAM y suponer que cada mensaje trae una sesión de servidor aceptada.
Si el búfer tiene tres bytes y llega ABCDE, puede obtenerse ABC y descartarse DE. La recepción siguiente retira xyz, no el sufijo del primer datagrama. Por eso hay que fijar un máximo y detectar truncamientos.
7. SOCK_SEQPACKET: conexión y registros
SOCK_SEQPACKET combina comunicación orientada a conexión con límites de registro. Los envíos normales del ejemplo forman dos unidades ordenadas, sin que el receptor deba buscar un delimitador entre ellas.
Puede resultar apropiado cuando el protocolo local quiere una sesión y unidades explícitas. Sigue siendo necesario acordar el tamaño máximo, validar el contenido y decidir qué hacer ante un registro truncado.
No es un flujo al que se haya añadido automáticamente un prefijo de longitud legible por la aplicación. El núcleo conserva registros, pero una recepción corta puede descartar parte de uno; repetir recv no lo reconstruye.
No cambies de STREAM a SEQPACKET de forma silenciosa si una plataforma no lo soporta, ni al revés. Cambiar el tipo altera el contrato. Los ejemplos informan un fallo de creación en lugar de simular compatibilidad con otro transporte.
La disponibilidad se comprueba en el sistema de destino. Las prácticas usan Linux, donde AF_UNIX admite los tres tipos estudiados.
8. Direcciones, rutas y sockets sin nombre
Una dirección Unix se expresa con sockaddr_un, declarada en sys/un.h. sun_family identifica AF_UNIX y sun_path contiene el nombre en los casos que lo utilizan.
struct sockaddr_un direccion;
memset(&direccion, 0, sizeof direccion);
direccion.sun_family = AF_UNIX;
/* Antes de copiar una ruta:
comprobar que su representacion cabe en sizeof direccion.sun_path. */| Forma | Cómo se localiza | Responsabilidad |
|---|---|---|
| Ruta del sistema de archivos. | Un nombre como /ruta/privada/servicio.sock. | Gestionar directorio, permisos y retirada de la entrada propia. |
| Espacio abstracto de Linux. | Nombre binario cuyo primer byte de sun_path es cero. | Usar longitud explícita; no tratarlo como ruta ni aplicar unlink. |
| Extremos sin nombre público. | Descriptores ya conectados o compartidos por un mecanismo válido. | Conservar y cerrar las referencias necesarias. |
socket no crea un archivo por sí solo. En el caso de ruta, bind asigna el nombre al extremo, según bind(2). El nombre representa un punto de comunicación; no es un archivo regular donde se guarde el historial de mensajes.
En Linux sun_path suele tener 108 bytes, pero el código debe consultar sizeof y considerar la terminación y longitud de dirección acordadas. El siguiente tema desarrollará la construcción correcta y la limpieza de rutas.
El espacio abstracto es específico de Linux y no tiene la misma administración de permisos de una entrada de directorio. No se presenta como una sustitución automáticamente equivalente de una ruta protegida.
Una ruta existente no se borra automáticamente al cerrar el descriptor. Tampoco se debe ejecutar unlink sobre cualquier ruta encontrada «para que bind funcione»: primero hay que establecer la propiedad del nombre y el estado del servicio.
9. Elegir un contrato para la aplicación
| Necesidad | Aspecto que conviene evaluar | Trabajo de aplicación que permanece |
|---|---|---|
| Enviar una secuencia extensa. | STREAM y procesamiento incremental. | Enmarcado, escrituras pendientes y límites del flujo. |
| Unidades independientes dirigidas a un servicio local. | DGRAM y su direccionamiento. | Máximo de unidad, dirección de respuesta e identificación de solicitudes. |
| Una sesión con registros. | SEQPACKET y soporte del entorno. | Máximo de registro, validación y tratamiento de truncamiento. |
| Compartir datos de gran volumen. | Combinar mensajes de control con memoria compartida, si el diseño lo requiere. | Propiedad, sincronización y vida útil de ambas clases de recurso. |
No se necesita un semáforo externo para convertir cada send o recv en una operación de transporte válida. Eso no significa que varios procesos puedan intercalar fragmentos de un protocolo sin coordinación: la serialización de mensajes de aplicación sigue dependiendo del diseño.
Un éxito de send indica contenido aceptado por esa operación del transporte, no una tarea terminada. Si necesitas confirmaciones, el protocolo debe asociarlas con identificadores y definir qué ocurre si el interlocutor falla.
Los sockets Unix permiten además transferir descriptores y recibir información de credenciales mediante mecanismos específicos. No basta con enviar un entero que contiene un fd; ese tema se desarrollará en el 35.
El resto de esta lección utiliza dos extremos conectados en un solo proceso para aislar los límites de datos. El transporte ofrece esas mismas reglas cuando los extremos pertenecen a procesos distintos; todavía no construiremos el servidor de rutas del tema 32.
10. Código de apoyo para los ejemplos
Guarda apoyo31.h. La cabecera reconoce los tipos del laboratorio y comprueba el cierre de los descriptores. No depende de los archivos C de temas anteriores.
#ifndef APOYO31_H
#define APOYO31_H
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <unistd.h>
static inline int elegir_tipo(const char *s)
{
if (strcmp(s, "stream") == 0) return SOCK_STREAM;
if (strcmp(s, "dgram") == 0) return SOCK_DGRAM;
if (strcmp(s, "seqpacket") == 0) return SOCK_SEQPACKET;
return -1;
}
static inline const char *nombre_tipo(int t)
{
if (t == SOCK_STREAM) return "SOCK_STREAM";
if (t == SOCK_DGRAM) return "SOCK_DGRAM";
if (t == SOCK_SEQPACKET) return "SOCK_SEQPACKET";
return "desconocido";
}
static inline int cerrar(int *fd)
{
if (*fd == -1) return 0;
int r = close(*fd);
*fd = -1;
if (r == -1) perror("close");
return r;
}
static inline int mostrar(const unsigned char *p, size_t n)
{
if (n == 0) {
if (fputs("(vacio)", stdout) == EOF) return -1;
} else if (fwrite(p, 1, n, stdout) != n) return -1;
return putchar('\n') == EOF ? -1 : 0;
}
#endifmostrar utiliza la longitud recibida y no supone que el búfer termina en NUL. La etiqueta «(vacio)» es una representación para la terminal; no forma parte del contenido transportado.
Después de intentar close se invalida el entero para que la limpieza no repita el cierre de un número que Linux podría haber liberado. Cerrar el descriptor no es lo mismo que retirar una ruta.
11. Programa: crear e identificar tipos
Guarda tipos31.c. El programa crea por separado los tres tipos y consulta SO_TYPE. No asigna rutas ni transfiere datos: comprueba la creación de extremos y su tipo real.
#include "apoyo31.h"
int main(void)
{
const int tipos[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET};
int fallo = 0;
for (size_t i = 0; i < sizeof tipos / sizeof tipos[0]; ++i) {
int fd = socket(AF_UNIX, tipos[i], 0);
if (fd == -1) {
fprintf(stderr, "%s: ", nombre_tipo(tipos[i]));
perror("socket");
fallo = 1;
continue;
}
int real = 0;
socklen_t longitud = sizeof real;
if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &real, &longitud) == -1) {
perror("getsockopt"); fallo = 1;
} else if (longitud != sizeof real || real != tipos[i]) {
fprintf(stderr, "Tipo incompatible\n"); fallo = 1;
} else {
printf("%s: descriptor %d, SO_TYPE coincide\n", nombre_tipo(real), fd);
}
if (cerrar(&fd) == -1) fallo = 1;
}
if (fflush(stdout) == EOF || ferror(stdout)) fallo = 1;
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}La longitud de getsockopt es de entrada y salida: se inicializa con la capacidad disponible y se comprueba al retornar. La interfaz se describe en getsockopt(2).
Es normal que se reutilice el mismo número de descriptor en las tres iteraciones: cada extremo anterior se cerró. El número no identifica de forma permanente al tipo ni al objeto.
Si un tipo no puede crearse, se informa el fallo y se continúa inspeccionando los demás. El retorno final será de error; no se cambia de tipo ocultando el desacuerdo.
12. Programa: comparar límites de recepción
Guarda limites31.c. El programa crea dos extremos ya conectados mediante socketpair. Un solo proceso envía dos unidades diminutas desde un extremo y recibe desde el otro; no necesita rutas, procesos hijos ni una sincronización basada en demoras.
Usamos socketpair como preparación del laboratorio, según socketpair(2). El tema 34 retomará esta interfaz para comunicar procesos y estudiar shutdown. Aquí observaremos únicamente las reglas de contenido de los tipos.
| Modo | Envíos de prueba | Capacidad de recepción |
|---|---|---|
| completo. | ABCDE y xyz. | Hasta 8 bytes por llamada. |
| corto. | ABCDE y xyz. | Hasta 3 bytes por llamada. |
| vacio. | Una unidad de cero bytes y después Z. | Hasta 8 bytes por llamada. |
Los dos envíos caben holgadamente en este par recién creado con sus opciones predeterminadas de Linux. Esta secuencia no debe generalizarse a «enviar toda una carga grande y después recibir»: un búfer finito podría bloquear al emisor antes de que empiece la recepción.
#include "apoyo31.h"
static int enviar_flujo(int fd, const unsigned char *p, size_t n)
{
if (n == 0) {
ssize_t r;
do { r = send(fd, p, 0, MSG_NOSIGNAL); } while (r == -1 && errno == EINTR);
return r == 0 ? 0 : -1;
}
size_t enviados = 0;
while (enviados < n) {
ssize_t r = send(fd, p + enviados, n - enviados, MSG_NOSIGNAL);
if (r == -1 && errno == EINTR) continue;
if (r <= 0) {
if (r == 0) errno = EIO;
return -1;
}
enviados += (size_t)r;
}
return 0;
}
static int enviar(int fd, int tipo, const char *p, size_t n)
{
if (tipo == SOCK_STREAM)
return enviar_flujo(fd, (const unsigned char *)p, n);
ssize_t r;
do { r = send(fd, p, n, MSG_NOSIGNAL); } while (r == -1 && errno == EINTR);
if (r == -1) return -1;
if ((size_t)r != n) { errno = EIO; return -1; }
return 0; /* No enviar un supuesto sufijo como otro registro. */
}
static int leer_flujo(int fd, size_t capacidad, const unsigned char *esperado,
size_t total)
{
unsigned char reconstruido[8];
size_t usados = 0;
unsigned llamadas = 0;
while (usados < total) {
size_t pedir = total - usados;
if (pedir > capacidad) pedir = capacidad;
ssize_t n;
do { n = recv(fd, reconstruido + usados, pedir, 0); }
while (n == -1 && errno == EINTR);
if (n == -1) { perror("recv flujo"); return -1; }
if (n == 0) {
fprintf(stderr, "Fin del flujo antes del contenido esperado\n");
return -1;
}
printf("Lectura %u: %zd bytes: ", ++llamadas, n);
if (mostrar(reconstruido + usados, (size_t)n) == -1) return -1;
usados += (size_t)n;
}
if (memcmp(reconstruido, esperado, total) != 0) return -1;
printf("Contenido reconstruido: ");
return mostrar(reconstruido, total);
}
static ssize_t recibir_registro(int fd, unsigned char *b, size_t capacidad,
int *truncado)
{
struct iovec v = {.iov_base = b, .iov_len = capacidad};
struct msghdr m;
ssize_t n;
do {
memset(&m, 0, sizeof m);
m.msg_iov = &v;
m.msg_iovlen = 1;
n = recvmsg(fd, &m, 0);
} while (n == -1 && errno == EINTR);
if (n >= 0) *truncado = (m.msg_flags & MSG_TRUNC) != 0;
return n;
}
static int leer_registros(int fd, size_t capacidad, const char *a, const char *b)
{
const char *esperados[2] = {a, b};
for (unsigned i = 0; i < 2; ++i) {
unsigned char datos[8];
int truncado = 0;
ssize_t n = recibir_registro(fd, datos, capacidad, &truncado);
if (n == -1) { perror("recvmsg"); return -1; }
size_t original = strlen(esperados[i]);
size_t copiados = original < capacidad ? original : capacidad;
int truncado_esperado = original > capacidad;
if ((size_t)n != copiados || truncado != truncado_esperado ||
memcmp(datos, esperados[i], copiados) != 0) {
fprintf(stderr, "Registro incompatible con la prueba\n");
return -1;
}
printf("Registro %u: %zd bytes; MSG_TRUNC=%s; contenido=",
i + 1, n, truncado ? "si" : "no");
if (mostrar(datos, copiados) == -1) return -1;
}
return 0;
}
int main(int argc, char **argv)
{
if (argc != 3) goto uso;
int tipo = elegir_tipo(argv[1]);
int corto = strcmp(argv[2], "corto") == 0;
int vacio = strcmp(argv[2], "vacio") == 0;
if (tipo == -1 || (!corto && !vacio && strcmp(argv[2], "completo") != 0))
goto uso;
int par[2] = {-1, -1};
if (socketpair(AF_UNIX, tipo, 0, par) == -1) {
perror("socketpair"); return EXIT_FAILURE;
}
int fallo = 0;
const char *a = vacio ? "" : "ABCDE";
const char *b = vacio ? "Z" : "xyz";
size_t capacidad = corto ? 3 : 8;
if (enviar(par[0], tipo, a, strlen(a)) == -1 ||
enviar(par[0], tipo, b, strlen(b)) == -1) {
perror("send"); fallo = 1; goto fin;
}
printf("Tipo: %s; modo: %s\n", nombre_tipo(tipo), argv[2]);
if (tipo == SOCK_STREAM) {
const unsigned char *esperado = (const unsigned char *)(vacio ? "Z" : "ABCDExyz");
size_t total = vacio ? 1 : 8;
if (vacio) puts("El envio vacio no agrega un registro al flujo.");
if (leer_flujo(par[1], capacidad, esperado, total) == -1) fallo = 1;
} else {
if (leer_registros(par[1], capacidad, a, b) == -1) fallo = 1;
}
fin:
if (cerrar(&par[0]) == -1) fallo = 1;
if (cerrar(&par[1]) == -1) fallo = 1;
if (fflush(stdout) == EOF || ferror(stdout)) fallo = 1;
return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
uso:
fprintf(stderr, "Uso: %s stream|dgram|seqpacket completo|corto|vacio\n", argv[0]);
return EXIT_FAILURE;
}El envío de flujo conserva un desplazamiento y continúa si hubo una aceptación parcial. En tipos de mensaje se comprueba el envío de la unidad completa y no se transforma un sufijo en otra unidad diferente. El significado del retorno de envío está en send(2).
recvmsg utiliza una estructura msghdr y un iovec para indicar el búfer. En este laboratorio solo nos interesa msg_flags para detectar MSG_TRUNC. No enviamos ni recibimos datos auxiliares de credenciales o descriptores.
Los flags de entrada de recvmsg son cero. MSG_TRUNC se observa en la salida; no se solicita la variante de Linux que puede informar el tamaño original completo en ciertos transportes. Aquí n representa los bytes copiados, y nunca se imprime más de la capacidad.
MSG_NOSIGNAL evita generar SIGPIPE en estos envíos de Linux, pero no elimina errores como EPIPE. La aplicación sigue comprobando el retorno. Ningún extremo se cierra antes de terminar la prueba de contenido.
13. Compilar y recibir contenido completo
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic tipos31.c -o tipos31
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic limites31.c -o limites31
$ ./tipos31
SOCK_STREAM: descriptor ..., SO_TYPE coincide
SOCK_DGRAM: descriptor ..., SO_TYPE coincide
SOCK_SEQPACKET: descriptor ..., SO_TYPE coincideLos puntos suspensivos representan números locales de descriptor, no valores que el programa deba exigir. Las prácticas se realizan con el compilador dirigido a Linux, por ejemplo dentro de WSL.
$ ./limites31 stream completo
Tipo: SOCK_STREAM; modo: completo
Lectura 1: 8 bytes: ABCDExyz
Contenido reconstruido: ABCDExyzLa lectura única de ocho bytes es una salida ilustrativa del laboratorio con ambos envíos ya encolados. El programa no la exige: si recv retorna un prefijo menor, continúa y verifica el contenido final reconstruido.
$ ./limites31 dgram completo
Tipo: SOCK_DGRAM; modo: completo
Registro 1: 5 bytes; MSG_TRUNC=no; contenido=ABCDE
Registro 2: 3 bytes; MSG_TRUNC=no; contenido=xyz
$ ./limites31 seqpacket completo
Tipo: SOCK_SEQPACKET; modo: completo
Registro 1: 5 bytes; MSG_TRUNC=no; contenido=ABCDE
Registro 2: 3 bytes; MSG_TRUNC=no; contenido=xyzEl programa verifica dos unidades en los tipos que preservan registros. Ese resultado no depende de intentar provocar una pausa entre envíos para que «no se junten».
El retorno cero significa que se observaron las reglas esperadas del experimento. No es una confirmación de trabajo remoto: ambos extremos están en el mismo programa y el contenido de prueba está definido de antemano.
14. Búfer corto: continuación o truncamiento
$ ./limites31 stream corto
Tipo: SOCK_STREAM; modo: corto
Lectura 1: 3 bytes: ABC
Lectura 2: 3 bytes: DEx
Lectura 3: 2 bytes: yz
Contenido reconstruido: ABCDExyzLos cortes concretos pueden ser más pequeños: lo que se exige es reconstruir ABCDExyz. Observa que DEx cruza el límite entre los envíos originales; el receptor no tiene por qué conocer ese límite.
$ ./limites31 dgram corto
Tipo: SOCK_DGRAM; modo: corto
Registro 1: 3 bytes; MSG_TRUNC=si; contenido=ABC
Registro 2: 3 bytes; MSG_TRUNC=no; contenido=xyz
$ ./limites31 seqpacket corto
Tipo: SOCK_SEQPACKET; modo: corto
Registro 1: 3 bytes; MSG_TRUNC=si; contenido=ABC
Registro 2: 3 bytes; MSG_TRUNC=no; contenido=xyzLos bytes DE del primer registro se perdieron para ese receptor al retirar la unidad con un búfer insuficiente. El segundo recibo empieza en xyz. No es válido acumular ambas lecturas y asumir que se reconstruirá ABCDExyz.
El programa acepta el truncamiento solo porque su objetivo es comprobarlo. Un protocolo de aplicación que requiera el registro completo debe rechazar la unidad truncada, aplicar su límite o pedir una retransmisión definida por el protocolo.
No basta comparar n con la capacidad: un retorno de tres en un búfer de tres puede corresponder tanto a un registro exacto como a uno truncado. El experimento distingue ambas situaciones mediante msg_flags.
Las reglas de recepción, longitudes y flags se describen en recv(2). Cambiar de tipo obliga a revisar los bucles de lectura, no solo la constante pasada al crear.
15. Unidades vacías, errores y vida útil
El valor cero depende del contrato
$ ./limites31 stream vacio
Tipo: SOCK_STREAM; modo: vacio
El envio vacio no agrega un registro al flujo.
Lectura 1: 1 bytes: Z
Contenido reconstruido: Z
$ ./limites31 dgram vacio
Tipo: SOCK_DGRAM; modo: vacio
Registro 1: 0 bytes; MSG_TRUNC=no; contenido=(vacio)
Registro 2: 1 bytes; MSG_TRUNC=no; contenido=ZUn envío de longitud cero en STREAM no crea un mensaje vacío visible. En un flujo, un retorno cero de recv con una solicitud de capacidad positiva suele indicar el cierre ordenado de la dirección de envío del interlocutor después de consumir lo pendiente. No debe confundirse con una recepción solicitada de tamaño cero.
Un datagrama de cero bytes sí es una unidad. En la prueba se retira con recvmsg y la recepción siguiente obtiene Z. No se interpreta el cero como «ya no puede llegar ningún dato».
En SOCK_SEQPACKET de Linux, este laboratorio también puede transportar un registro vacío y después otro con Z. El programa conoce que el emisor mantiene el extremo abierto y espera dos unidades. En un protocolo real que use registros vacíos hay que distinguir su significado de la terminación de la conexión; un tamaño cero aislado no aporta toda esa información.
Para mantener sencillo un servicio inicial, puedes prohibir registros vacíos en su contrato y reservar la gestión del cierre para el estado de la conexión. Esa decisión debe estar documentada, no inferirse de un printf.
Errores y cierre
| Situación | Interpretación | Respuesta de aplicación |
|---|---|---|
| socket o socketpair falla. | No se obtuvo el recurso solicitado. | Informar errno y limpiar solo descriptores válidos. |
| EINTR en envío o recepción. | La llamada fue interrumpida antes de informar un éxito. | Reintentar según la política del programa. |
| MSG_TRUNC en un registro. | Se descartó contenido que no cabía. | No aceptar el prefijo como unidad completa. |
| EAGAIN o EWOULDBLOCK en modo no bloqueante. | No hay progreso inmediato disponible. | Esperar preparación o conservar trabajo pendiente. |
| EMSGSIZE al enviar una unidad. | La unidad no cabe según los límites del transporte. | Aplicar el máximo acordado; no partirla sin rediseñar el protocolo. |
| EPIPE u otro fallo de conexión. | El envío no completó su contrato. | Gestionar el fallo y el estado de la solicitud. |
Los laboratorios usan sockets bloqueantes y un volumen fijo conocido. No implementan plazos, múltiples clientes ni un bucle de eventos. Un servicio real no puede suponer que el interlocutor siempre enviará la cantidad esperada y seguirá vivo.
Cada descriptor debe cerrarse al dejar de utilizarlo. Si un descriptor se duplica o se hereda con fork, las referencias sobrantes pueden afectar a cuándo se observa el cierre. El tema 34 tratará close, shutdown y la finalización de conexiones con detalle.
16. Explorar envíos y recepciones
Elige el tipo y carga los envíos ABCDE y xyz. Cambia la capacidad antes de recibir. En el flujo quedarán bytes pendientes; en los tipos de mensaje, cada recepción retirará una unidad completa y podrá descartar su sufijo.
Pendiente en el transporteSin bytes
Última recepciónTodavía no se recibió
Contenido retirado—
Contenido descartado—
Carga los dos envíos para comparar sus límites.
El modelo de flujo elige retirar el máximo disponible hasta la capacidad. Un recv real puede retornar menos. Esa elección ilustra una fragmentación válida sin prometer que sea la única.
Los extremos permanecen abiertos: recibir sin contenido pendiente representa que no hay progreso y no simula EOF. El modelo de mensajes acepta unidades vacías para enseñar su diferencia con la ausencia de contenido.
El límite de cola del simulador es didáctico: 32 bytes de flujo u ocho registros. No representa los tamaños de búfer del núcleo. Tampoco reproduce conexión, direccionamiento ni fallos de proceso.
17. Pruebas y diagnóstico
Comprobar los nueve casos
$ for tipo in stream dgram seqpacket; do
for modo in completo corto vacio; do
./limites31 "$tipo" "$modo" || exit 1
done
donePara STREAM verifica el contenido reconstruido y que ninguna recepción exceda su capacidad, sin exigir una cantidad exacta de llamadas. Para DGRAM y SEQPACKET comprueba las unidades esperadas, su longitud y el flag de truncamiento.
El modo corto de mensajes debe confirmar que la segunda unidad es xyz: esa comprobación distingue descarte de sufijo de una continuación de flujo. En vacio debe verse una unidad de cero bytes seguida por Z en los tipos de mensaje.
Inyectar retornos parciales y errores
- Envío parcial de flujo. En una prueba controlada, limita cada send a uno o dos bytes. El bucle debe avanzar y completar el contenido sin repetir prefijos.
- Recepción corta de flujo. Limita cada recv a un byte. La reconstrucción debe seguir siendo correcta.
- EINTR. Inyecta una interrupción antes del envío o recepción y comprueba el reintento sin duplicar contenido.
- Fallo de creación. Simula un error de socketpair. No debe cerrarse un descriptor arbitrario ni intentarse recibir desde uno inválido.
- Truncamiento. No elimines MSG_TRUNC de la comprobación para hacer pasar una recepción incompatible.
- Argumentos inválidos. Un tipo o modo desconocido se rechaza antes de crear extremos.
Los ejemplos solo envían bytes de prueba conocidos. Para datos binarios adicionales usa longitudes explícitas en todas las etapas; strlen no es una forma general de medir contenido que pueda incluir NUL.
Relacionar la API con el sistema
$ strace -e trace=socket,getsockopt,close ./tipos31
$ strace -e trace=socketpair,sendto,sendmsg,recvfrom,recvmsg,close ./limites31 dgram cortosend y recv de la biblioteca pueden verse como sendto y recvfrom con direcciones nulas en Linux. La forma concreta no cambia el contrato del programa. En recvmsg puede observarse MSG_TRUNC como flag de salida.
Para inspeccionar sockets Unix de un sistema puede utilizarse ss -x -a. Los del laboratorio duran muy poco y no tienen una ruta pública, por lo que no debes exigir encontrarlos en una captura tomada después de terminar.
| Síntoma | Error de razonamiento probable | Corrección |
|---|---|---|
| Se espera una respuesta tras socket. | Se confundió creación con conexión. | Preparar interlocutor o usar el par conectado del laboratorio. |
| Dos send no producen dos recv. | Se esperaban registros en STREAM. | Definir enmarcado y acumular por el protocolo. |
| Un mensaje pierde su sufijo. | Se trató DGRAM o SEQPACKET como un flujo. | Fijar máximo y detectar truncamiento al retirar la unidad. |
| Un cero termina el bucle de datagramas. | Se confundió unidad vacía con EOF de flujo. | Interpretar el resultado según tipo y protocolo. |
| Se busca un archivo después de socketpair. | Se supuso una ruta pública automática. | Distinguir extremos sin nombre de una dirección asignada por bind. |
| Se envía un fd como entero y no funciona. | Se confundió un número local con una referencia transferida. | Usar el mecanismo específico que se estudiará en el tema 35. |
18. Resumen
- AF_UNIX comunica extremos dentro del mismo equipo, sin direcciones IP ni puertos TCP.
- Familia, tipo y protocolo son decisiones distintas de socket.
- socket crea un extremo, pero no asigna por sí solo una ruta ni una conexión.
- SOCK_STREAM conserva la secuencia de bytes y no los límites de envío.
- SOCK_DGRAM conserva datagramas; en AF_UNIX de Linux no equivale al modelo de UDP.
- SOCK_SEQPACKET conserva registros dentro de una comunicación orientada a conexión.
- Un búfer corto deja bytes pendientes en STREAM y puede descartar el sufijo de un registro.
- recvmsg permite comprobar MSG_TRUNC, además de la longitud copiada.
- Una unidad vacía debe interpretarse según el tipo y el protocolo.
- Los sockets pueden tener ruta, usar el espacio abstracto de Linux o carecer de nombre público.
- Cerrar un descriptor no es lo mismo que retirar una entrada de ruta.
- El transporte no confirma por sí solo la terminación de una tarea de aplicación.
19. Preguntas de repaso y práctica
Responde antes de desplegar cada explicación.
1. ¿AF_UNIX identifica un flujo de bytes?
No. Es una familia de comunicación local. El tipo, como STREAM, DGRAM o SEQPACKET, selecciona el contrato de datos.
2. ¿SOCK_STREAM significa siempre TCP?
No. En AF_UNIX selecciona un flujo local; TCP pertenece a otras combinaciones de familia y protocolo.
3. ¿Qué se obtiene al llamar a socket?
Un descriptor local de un extremo, o −1 al fallar. La llamada no crea automáticamente un segundo extremo conectado ni una ruta de servicio.
4. ¿El descriptor cero es un error?
No. Todo descriptor no negativo puede ser válido. El error de socket se indica con −1.
5. ¿Por qué dos envíos pueden aparecer en una sola lectura?
Porque STREAM ofrece una secuencia de bytes sin límites de envío visibles como registros. La aplicación debe reconstruir sus propias unidades.
6. ¿Se pierde el sufijo cuando un recv de STREAM usa poco espacio?
No por esa razón. Los bytes no retirados permanecen pendientes para recepciones posteriores, mientras el flujo siga disponible.
7. ¿Un datagrama Unix tiene las mismas garantías que UDP?
No se pueden trasladar garantías por el nombre del tipo. En AF_UNIX de Linux los datagramas son fiables y no se reordenan bajo el contrato de esa familia.
8. ¿Qué añade SEQPACKET respecto de STREAM?
Conserva límites de registro y su orden dentro de una comunicación orientada a conexión. No elimina la validación ni los límites de tamaño.
9. ¿Cómo se detecta que un registro no cabía?
En el laboratorio se consulta MSG_TRUNC en msg_flags de recvmsg. Una longitud igual a la capacidad no basta para distinguir un registro exacto de uno truncado.
10. ¿La siguiente recepción recupera DE tras truncar ABCDE a ABC?
No en los tipos de mensaje estudiados. El sufijo de esa unidad se descarta; la siguiente recepción obtiene la siguiente unidad pendiente.
11. ¿Un datagrama de cero bytes equivale a no recibir nada?
No. Puede ser una unidad válida retirada del transporte. Su longitud cero no significa que la llamada haya encontrado ausencia de mensajes.
12. ¿socketpair crea una ruta de archivo?
No en el laboratorio. Devuelve dos descriptores de extremos ya conectados sin un nombre público de ruta.
13. ¿Una ruta .sock almacena los mensajes enviados?
No. Representa una dirección del extremo cuando se asigna mediante bind. El contenido se intercambia mediante el transporte, no como lectura de un archivo de historial.
14. ¿Un send exitoso confirma que el receptor terminó la tarea?
No. El protocolo de aplicación necesita una confirmación y reglas de fallo si ese significado es importante.
15. ¿Por qué no se cambia de tipo automáticamente si uno no existe?
Porque el tipo define límites y reglas de recepción. Una sustitución silenciosa puede romper el protocolo aunque las mismas funciones de creación acepten la nueva constante.
Para practicar y ampliar
- Ejecuta tipos31 y explica por qué puede repetirse el número de descriptor.
- Compara los nueve casos de limites31 sin exigir cortes concretos para el flujo.
- Predice qué registros quedan después de recibir dos bytes de ABCDE en DGRAM y en SEQPACKET.
- Inyecta envíos parciales y recepciones de un byte en STREAM y comprueba la reconstrucción.
- Explica qué cambia en un protocolo si se prohíben mensajes vacíos.
- Usa el explorador para encontrar una lectura de flujo que cruce el límite entre ambos envíos.
- Diseña un prefijo de longitud para STREAM e identifica el máximo permitido antes de reservar un búfer.
- Diseña una petición DGRAM con identificador y datos suficientes para asociar una respuesta.
- Compara las responsabilidades de una dirección de ruta y una abstracta de Linux.
- Dibuja las fases que faltan entre socket y una conexión aceptada por un servidor local.
El tema 32 construirá un servidor local con bind, listen y accept: sockaddr_un, rutas, permisos, conexiones y retirada del archivo de socket creado por el servicio.