← Comunicación entre ProcesosBloque 8 · Sockets de dominio Unix · Tema 32 de 52

Tema 32

Servidor local con bind, listen y accept

Vas a publicar un servicio Unix mediante una ruta, preparar su cola de conexiones y obtener un descriptor distinto para cada cliente aceptado. El servidor enviará un saludo y cerrará esa conexión. Aprenderás a construir sockaddr_un, limitar las rutas, controlar permisos y retirar únicamente la entrada que pertenece a la ejecución del servicio.

1. Contrato del servidor y alcance

El tema 31 comparó tipos usando extremos ya conectados. Ahora construiremos el punto de encuentro que un cliente independiente puede localizar. Utilizaremos AF_UNIX con SOCK_STREAM y una dirección de ruta del sistema de archivos.

El servidor acepta entre uno y veinte clientes, tres por defecto. A cada conexión le envía el texto Hola desde AF_UNIX\n, cierra su descriptor y vuelve a aceptar hasta alcanzar el límite.

La ruta permite encontrar el servicio; el socket de escucha recibe solicitudes de conexión; cada socket aceptado transporta datos de un cliente concreto.

DecisiónContrato del ejemploAmpliación posterior
Tipo.STREAM local.Otros tipos requieren revisar el protocolo.
Datos.Saludo fijo y cierre del envío al cerrar la conexión.El tema 33 desarrollará peticiones, respuestas y enmarcado.
Atención.Una conexión por vez.La multiplexación se estudiará en otro bloque.
Ruta.Absoluta, en un directorio privado del mismo usuario.Un despliegue compartido necesita otra política de acceso.
Terminación.Límite de aceptaciones o cancelación mediante SIGINT/SIGTERM.No hay presupuesto global de inactividad.

El cliente de prueba solo conecta y recibe. No envía una petición ni necesita identificarse por una ruta propia para este intercambio. El objetivo es observar el ciclo de publicación y aceptación sin introducir todavía un protocolo completo de aplicación.

2. De un extremo a una conexión aceptada

secuencia · los papeles de servidor y cliente
SERVIDOR                              CLIENTE
socket(AF_UNIX, SOCK_STREAM, 0)        socket(AF_UNIX, SOCK_STREAM, 0)
bind(ruta)
listen(backlog)
accept(...) <------------------------ connect(ruta)
    devuelve un descriptor conectado
send(saludo) -----------------------> recv hasta el cierre
close(conectado)                       close(cliente)
aceptar otro cliente
close(escucha)
unlink(ruta propia)

bind asigna una dirección local al extremo. listen lo convierte en un socket pasivo de escucha. accept retira una conexión pendiente y crea otro descriptor, conservando el de escucha para las siguientes.

connect del cliente se dirige al extremo publicado. No devuelve el descriptor de escucha del servidor ni un número que ambos procesos deban compartir. Cada proceso maneja sus propios descriptores locales.

La entrada de ruta puede existir después de bind y antes de listen. Ver un archivo de tipo socket no demuestra que el servicio esté listo para aceptar. El servidor imprimirá un mensaje de disponibilidad solo después de preparar su escucha.

3. Construir sockaddr_un y su longitud

patrón · ruta con terminación NUL y longitud explícita
struct sockaddr_un a;
memset(&a, 0, sizeof a);
a.sun_family = AF_UNIX;

size_t n = strlen(ruta);
/* Exigir n < sizeof a.sun_path antes de copiar n + 1 bytes. */
memcpy(a.sun_path, ruta, n + 1);
socklen_t longitud = (socklen_t)(offsetof(struct sockaddr_un, sun_path) + n + 1);

sun_family y sun_path pertenecen a la estructura declarada en sys/un.h. offsetof, declarada en stddef.h, evita suponer que el comienzo de sun_path se obtiene sumando tamaños a mano.

La ruta debe caber junto con su terminador. No se trunca silenciosamente: dos nombres largos que compartieran prefijo podrían terminar apuntando al mismo texto recortado. El código informa ENAMETOOLONG.

En Linux sun_path tiene habitualmente 108 bytes. La comprobación utiliza sizeof del miembro y no una constante copiada de la documentación. Las formas de dirección y la longitud para rutas se describen en unix(7).

bind y connect reciben un puntero a sockaddr por la interfaz genérica, pero el objeto real sigue siendo sockaddr_un. El cast del puntero no convierte sus bytes ni elimina la obligación de pasar la longitud apropiada.

4. Elegir una ruta dentro de un directorio propio

Las prácticas usarán un directorio nuevo creado mediante mktemp -d, por ejemplo /tmp/soipc32.ABC123, y dentro una entrada servicio.sock. El directorio identifica una sesión propia y reduce colisiones con otros ensayos.

Bash · el directorio permanece bajo administración de esta sesión
$ directorio=$(mktemp -d /tmp/soipc32.XXXXXX)
$ chmod 700 "$directorio"
$ ruta="$directorio/servicio.sock"
$ printf '%s\n' "$ruta"

El servidor exige que el directorio inmediato sea real, pertenezca al usuario efectivo, no conceda permisos a grupo ni otros y permita al propietario escribir y atravesarlo. Rechaza una ruta relativa y un último componente vacío, punto o punto-punto.

La política del laboratorio presupone que no hay otro administrador renombrando directorios o sustituyendo entradas mientras funciona. No se presenta como un resolvedor de rutas resistente a toda modificación concurrente del espacio de nombres.

El servidor no crea ni borra el directorio. Solo crea su entrada de socket tras un bind correcto y la retira al finalizar si conserva su identidad. La shell podrá eliminar después el directorio vacío con rmdir.

5. Permisos, umask y acceso local

Para alcanzar una ruta, el cliente debe poder atravesar sus directorios. En Linux, conectar a un socket Unix de ruta también comprueba permiso de escritura sobre la entrada. Estas reglas no se sustituyen por conocer el nombre.

El directorio privado es la primera frontera de esta práctica. El servidor busca crear la entrada con modo 0600 y comprueba su modo efectivo. Antes de bind establece temporalmente umask 0177 y restaura la máscara anterior inmediatamente después.

idea · umask quita permisos de creación, no los agrega
mode_t anterior = umask(0177);
int r = bind(escucha, (struct sockaddr *)&direccion, longitud);
int motivo = errno;
umask(anterior);
errno = motivo;
/* Interpretar r; errno solo importa si r indica error. */

La máscara es una propiedad del proceso. El ejemplo es de un solo hilo y no realiza otras creaciones en ese intervalo. Un programa multihilo debe analizar esa modificación global con cuidado. El comportamiento de la máscara se documenta en umask(2).

La configuración efectiva puede verse influida por reglas del directorio como ACL. Por eso el ejemplo verifica el modo observado y falla si no coincide con su contrato, en lugar de asumir que el único dato relevante es el número pasado a umask.

Estos controles limitan el acceso del laboratorio; no autentican por sí solos qué programa del mismo usuario se conectó. Las credenciales del interlocutor se estudiarán en el tema 35.

6. bind y las colisiones de nombre

bind devuelve cero cuando asigna la dirección o −1 al fallar. Si ya existe una entrada que ocupa la ruta, no se debe borrar automáticamente y repetir: podría pertenecer a otro servicio o incluso ser un archivo que no es un socket.

El programa intentará bind directamente. Solo registra propiedad de creación si la llamada tuvo éxito. Después observa con lstat el tipo, propietario, dispositivo e inode de la entrada para controlar su retirada posterior.

Estado de la rutaQué puede ocurrirRespuesta del ejemplo
No existe y el directorio permite crear.bind crea la entrada.Registrar la propiedad y continuar.
Otro servidor la utiliza.Colisión, habitualmente EADDRINUSE.Fallar sin retirar el nombre ajeno.
Hay un socket residual.La entrada sigue ocupada aunque no escuche nadie.Fallar y dejar la decisión al responsable del recurso.
Hay un archivo o enlace.La dirección no está libre.Conservar la entrada existente.

La función asigna una dirección, no inicia por sí sola una cola de conexiones. Su retorno y condiciones se describen en bind(2).

Una comprobación previa de existencia no sustituye el resultado de bind, porque el espacio de nombres puede cambiar. Tampoco el fallo de connect demuestra por sí solo que sea correcto borrar esa ruta.

7. listen y la cola de pendientes

listen marca el socket como pasivo y configura una cola de conexiones pendientes de aceptar. En este ejemplo se solicita backlog igual a ocho.

fragmento · preparar la escucha después de bind
if (listen(escucha, 8) == -1) {
    perror("listen");
    /* Cerrar y retirar solo la ruta creada por esta ejecucion. */
}

backlog no es la cantidad total de clientes que el servidor atenderá en su vida. Tampoco crea ocho trabajadores ni ocho llamadas accept simultáneas. El programa sigue teniendo un único bucle secuencial.

La cola y sus límites efectivos dependen del sistema. Si se satura, una conexión puede esperar o fallar según el entorno y el modo del socket. No uses un valor exacto de backlog como una garantía universal sobre cuántos clientes se conectarán a la vez.

listen se aplica a tipos orientados a conexión como STREAM y SEQPACKET, no a un servicio de datagramas que intercambia unidades mediante sendto y recvfrom. Su contrato está en listen(2).

8. accept y los dos papeles del descriptor

interfaz · un nuevo descriptor por conexión aceptada
int conectado = accept(escucha, NULL, NULL);
if (conectado == -1) {
    /* Interpretar errno: interrupcion, espera temporal u otro fallo. */
} else {
    /* Enviar el saludo por conectado, nunca por escucha. */
}

accept devuelve un descriptor conectado no negativo. El de escucha permanece abierto y conserva su función. Cerrar la conexión de un cliente no cierra la escucha ni la prepara de nuevo.

Socket de escucha y sockets de conexiones diferentesEl descriptor de escucha mantiene pendientes. Cada accept produce otro descriptor que comunica con un cliente concreto. El servidor puede cerrar una conexión y seguir aceptando desde la escucha. Descriptor de escuchaacepta conexionesDescriptor conectado Atransporta datosDescriptor conectado Btransporta datosCliente ACliente B
El dibujo distingue objetos; nuestro servidor atiende una conexión a la vez, sin conservar ambas activas deliberadamente.

Con argumentos NULL no se solicita la dirección del interlocutor. Si se proporciona un búfer, addrlen es de entrada y salida: debe inicializarse antes de cada llamada y validarse al volver.

Un cliente Unix puede conectar sin asignarse una ruta pública. Por eso no se puede asumir que accept devolverá una cadena sun_path útil para identificarlo. La interfaz y sus reglas se describen en accept(2).

El ejemplo establece FD_CLOEXEC explícitamente en cada descriptor. No supone que un socket aceptado herede todos los flags u opciones de la escucha. accept4 permite configurar ciertos flags al crear el descriptor en sistemas que lo ofrecen; aquí mantenemos la llamada accept que queremos estudiar.

9. Cierre, retirada de ruta y cancelación

La finalización normal cierra el cliente activo, cierra el socket de escucha y retira la entrada propia. El directorio de la sesión queda vacío para que la shell lo elimine.

La limpieza solo llama a unlink si bind tuvo éxito y se pudo registrar la identidad de un socket propio. Antes de retirar compara dispositivo e inode con la entrada actual. Si detecta una sustitución, informa el problema y conserva lo que hay en esa ruta.

La comprobación no hace atómica la secuencia lstat-unlink frente a modificaciones concurrentes. Por eso el contrato exige administración exclusiva del directorio privado mientras funciona el servicio. No se promete resolver una carrera adversaria del espacio de nombres.

Para terminar mientras accept espera, SIGINT y SIGTERM activan una bandera local. En Linux se configura SO_RCVTIMEO de 250 ms en la escucha: accept puede retornar EAGAIN o EWOULDBLOCK para revisar la bandera aunque una señal haya llegado justo antes de entrar a la llamada.

El saludo usa una espera de envío de un segundo por llamada y MSG_NOSIGNAL. No hay un presupuesto global ni una salida con latencia exacta: son controles locales del laboratorio. El comportamiento de las opciones temporales se describe en socket(7).

El manejador no cierra descriptores, no imprime ni elimina rutas. La limpieza ocurre en el flujo principal. SIGKILL no ejecuta ese flujo y puede dejar una entrada residual aunque el núcleo cierre las referencias del proceso.

10. Código de apoyo para direcciones y recursos

Guarda apoyo32.h. La construcción de direcciones se comparte entre servidor y cliente. La validación del directorio privado y la retirada de identidad se utilizan solo donde corresponde al servidor.

apoyo32.h · longitud exacta, permisos y propiedad de la entrada
#ifndef APOYO32_H
#define APOYO32_H
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <stddef.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/un.h>
#include <unistd.h>

#define SALUDO32 "Hola desde AF_UNIX\n"

static inline int direccion(const char *ruta, struct sockaddr_un *a, socklen_t *n)
{
    size_t len = strlen(ruta);
    if (len == 0 || ruta[0] != '/') { errno = EINVAL; return -1; }
    if (len >= sizeof a->sun_path) { errno = ENAMETOOLONG; return -1; }
    const char *base = strrchr(ruta, '/') + 1;
    if (!*base || strcmp(base, ".") == 0 || strcmp(base, "..") == 0) {
        errno = EINVAL; return -1;
    }
    memset(a, 0, sizeof *a);
    a->sun_family = AF_UNIX;
    memcpy(a->sun_path, ruta, len + 1);
    *n = (socklen_t)(offsetof(struct sockaddr_un, sun_path) + len + 1);
    return 0;
}

static inline int directorio_privado(const char *ruta)
{
    char padre[sizeof(((struct sockaddr_un *)0)->sun_path)];
    const char *barra = strrchr(ruta, '/');
    size_t len = (size_t)(barra - ruta);
    if (len == 0 || len >= sizeof padre) { errno = EACCES; return -1; }
    memcpy(padre, ruta, len);
    padre[len] = '\0';
    struct stat st;
    if (lstat(padre, &st) == -1) return -1;
    if (!S_ISDIR(st.st_mode) || st.st_uid != geteuid() ||
        (st.st_mode & 0077) != 0 || (st.st_mode & 0300) != 0300) {
        errno = EACCES; return -1;
    }
    return 0;
}

static inline int cloexec(int fd)
{
    int flags = fcntl(fd, F_GETFD);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
}

static inline int tiempo_socket(int fd, int opcion, unsigned ms)
{
    struct timeval t = {(time_t)(ms / 1000), (suseconds_t)(ms % 1000) * 1000};
    return setsockopt(fd, SOL_SOCKET, opcion, &t, sizeof t);
}

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 retirar_propia(const char *ruta, const struct stat *propia)
{
    struct stat actual;
    if (lstat(ruta, &actual) == -1) {
        if (errno == ENOENT) return 0;
        perror("lstat al retirar"); return -1;
    }
    if (!S_ISSOCK(actual.st_mode) || actual.st_dev != propia->st_dev ||
        actual.st_ino != propia->st_ino) {
        fprintf(stderr, "La ruta cambio: no se retira una entrada distinta\n");
        return -1;
    }
    if (unlink(ruta) == -1) { perror("unlink propia"); return -1; }
    return 0;
}

static inline int cantidad_clientes(const char *s, unsigned *v)
{
    if (!*s) return -1;
    for (const char *p = s; *p; ++p) if (*p < '0' || *p > '9') return -1;
    errno = 0;
    char *fin;
    unsigned long n = strtoul(s, &fin, 10);
    if (errno || *fin || n < 1 || n > 20) return -1;
    *v = (unsigned)n;
    return 0;
}
#endif

directorio_privado se llama después de direccion, por lo que ya existe una barra y la ruta cabe en sun_path. Estas precondiciones evitan cálculos sobre una dirección de ruta no validada.

La comprobación del directorio inmediato no resuelve por sí sola todos los componentes de una ruta frente a renombrados concurrentes. La sesión usa un directorio nuevo bajo su control y no modifica esa jerarquía mientras el servidor está activo.

retirar_propia usa lstat para observar la propia entrada y no seguir un enlace final. Si hubo una sustitución por otro archivo o socket con identidad diferente, no lo borra.

11. Programa completo del servidor

Guarda servidor32.c. Recibe la ruta absoluta y, opcionalmente, la cantidad de clientes que aceptará. No ejecuta unlink al arrancar ni adopta una entrada que ya existía.

servidor32.c · publicación, aceptación secuencial y retirada de la ruta propia
#include "apoyo32.h"

static volatile sig_atomic_t parar = 0;

static void solicitar(int signo) { parar = signo; }

static int saludar(int fd)
{
    const char texto[] = SALUDO32;
    size_t enviados = 0;
    while (enviados < sizeof texto - 1) {
        if (parar) { errno = ECANCELED; return -1; }
        ssize_t n = send(fd, texto + enviados, sizeof texto - 1 - enviados,
                         MSG_NOSIGNAL);
        if (n == -1 && errno == EINTR) continue;
        if (n <= 0) {
            if (n == 0) errno = EIO;
            return -1;
        }
        enviados += (size_t)n;
    }
    return 0;
}

int main(int argc, char **argv)
{
    unsigned maximo = 3;
    if ((argc != 2 && argc != 3) ||
        (argc == 3 && cantidad_clientes(argv[2], &maximo) == -1)) {
        fprintf(stderr, "Uso: %s /directorio/privado/servicio.sock [clientes(1..20)]\n",
                argv[0]);
        return EXIT_FAILURE;
    }
    struct sockaddr_un a;
    socklen_t longitud;
    if (direccion(argv[1], &a, &longitud) == -1) {
        perror("direccion"); return EXIT_FAILURE;
    }
    if (directorio_privado(argv[1]) == -1) {
        perror("directorio privado"); return EXIT_FAILURE;
    }
    struct sigaction accion;
    memset(&accion, 0, sizeof accion);
    accion.sa_handler = solicitar;
    if (sigemptyset(&accion.sa_mask) == -1 ||
        sigaction(SIGINT, &accion, NULL) == -1 ||
        sigaction(SIGTERM, &accion, NULL) == -1) {
        perror("sigaction"); return EXIT_FAILURE;
    }

    int escucha = -1, conectado = -1;
    int vinculado = 0, identificado = 0, listo = 0;
    int salida = EXIT_FAILURE;
    unsigned aceptadas = 0, enviados = 0, fallos = 0;
    struct stat propia;
    escucha = socket(AF_UNIX, SOCK_STREAM, 0);
    if (escucha == -1) { perror("socket"); goto fin; }
    if (cloexec(escucha) == -1 || tiempo_socket(escucha, SO_RCVTIMEO, 250) == -1) {
        perror("configurar escucha"); goto fin;
    }
    mode_t mascara = umask(0177);
    int r = bind(escucha, (struct sockaddr *)&a, longitud);
    int motivo = errno;
    umask(mascara);
    errno = motivo;
    if (r == -1) { perror("bind"); goto fin; }
    vinculado = 1;
    if (lstat(argv[1], &propia) == -1) { perror("lstat tras bind"); goto fin; }
    if (!S_ISSOCK(propia.st_mode) || propia.st_uid != geteuid()) {
        fprintf(stderr, "No se pudo identificar un socket propio\n"); goto fin;
    }
    identificado = 1;
    if ((propia.st_mode & 0777) != 0600) {
        fprintf(stderr, "Modo efectivo inesperado: se exige 0600\n"); goto fin;
    }
    if (listen(escucha, 8) == -1) { perror("listen"); goto fin; }
    listo = 1;
    salida = EXIT_SUCCESS;
    printf("Escuchando PID %ld en %s; limite %u; backlog solicitado 8\n",
           (long)getpid(), argv[1], maximo);
    if (fflush(stdout) == EOF) { salida = EXIT_FAILURE; goto fin; }

    while (aceptadas < maximo && !parar) {
        conectado = accept(escucha, NULL, NULL);
        if (conectado == -1) {
            if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ||
                errno == ECONNABORTED) continue;
            perror("accept"); salida = EXIT_FAILURE; break;
        }
        ++aceptadas;
        printf("Aceptada %u: descriptor conectado %d\n", aceptadas, conectado);
        if (cloexec(conectado) == -1 ||
            tiempo_socket(conectado, SO_SNDTIMEO, 1000) == -1) {
            perror("configurar conectado"); salida = EXIT_FAILURE; break;
        }
        if (saludar(conectado) == -1) {
            if (!parar) { perror("enviar saludo"); ++fallos; }
        } else {
            ++enviados;
        }
        if (cerrar(&conectado) == -1) { salida = EXIT_FAILURE; break; }
        if (fflush(stdout) == EOF) { salida = EXIT_FAILURE; break; }
    }
    if (fallos) salida = EXIT_FAILURE;

fin:
    if (parar && salida == EXIT_SUCCESS) salida = 128 + (int)parar;
    if (cerrar(&conectado) == -1) salida = EXIT_FAILURE;
    if (cerrar(&escucha) == -1) salida = EXIT_FAILURE;
    if (vinculado) {
        if (identificado) {
            if (retirar_propia(argv[1], &propia) == -1) salida = EXIT_FAILURE;
        } else {
            fprintf(stderr, "No se retira una ruta cuya identidad no pudo confirmarse\n");
            salida = EXIT_FAILURE;
        }
    }
    if (listo) printf("Aceptadas: %u; saludos enviados: %u; fallos: %u\n",
                      aceptadas, enviados, fallos);
    if (fflush(stdout) == EOF || ferror(stdout)) salida = EXIT_FAILURE;
    return salida;
}

aceptadas cuenta conexiones obtenidas por accept, incluso si después falla el saludo. enviados cuenta envíos completados por la aplicación; no confirma que otro programa haya procesado el texto. No hay una respuesta de confirmación en este protocolo inicial.

Si un cliente falla, el servidor cierra esa conexión y puede seguir atendiendo hasta el límite. Registra el fallo y retorna error al finalizar. Un error de configuración o un fallo grave de accept terminan la escucha.

El manejador solo modifica una bandera local sig_atomic_t. El timeout de accept evita depender de que una señal llegue exactamente durante la llamada. No se atienden clientes en el manejador ni se ejecuta allí la limpieza de rutas.

Si bind tuvo éxito pero no se logra confirmar la identidad de su entrada, el programa informa que no puede retirarla con confianza. Esa ruta de error puede requerir intervención del responsable del directorio; no se sustituye la falta de evidencia por un borrado indiscriminado.

12. Cliente mínimo para probar la aceptación

Guarda cliente32.c. Este cliente no construye todavía una petición: conecta, acumula el saludo hasta el cierre y comprueba el texto exacto. Se incluye para ejecutar el servidor sin depender de una herramienta externa.

cliente32.c · conectar por ruta y observar el saludo completo
#include "apoyo32.h"

int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "Uso: %s /directorio/privado/servicio.sock\n", argv[0]);
        return EXIT_FAILURE;
    }
    struct sockaddr_un a;
    socklen_t longitud;
    if (direccion(argv[1], &a, &longitud) == -1) {
        perror("direccion"); return EXIT_FAILURE;
    }
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (fd == -1) { perror("socket"); return EXIT_FAILURE; }
    int salida = EXIT_FAILURE;
    if (cloexec(fd) == -1 || tiempo_socket(fd, SO_RCVTIMEO, 1000) == -1) {
        perror("configurar cliente"); goto fin;
    }
    if (connect(fd, (struct sockaddr *)&a, longitud) == -1) {
        perror("connect"); goto fin;
    }
    unsigned char b[64];
    size_t usados = 0;
    while (usados < sizeof b) {
        ssize_t n = recv(fd, b + usados, sizeof b - usados, 0);
        if (n == -1 && errno == EINTR) continue;
        if (n == -1) { perror("recv"); goto fin; }
        if (n == 0) break;
        usados += (size_t)n;
    }
    if (usados != sizeof SALUDO32 - 1 ||
        memcmp(b, SALUDO32, sizeof SALUDO32 - 1) != 0) {
        fprintf(stderr, "Saludo incompleto, excesivo o incompatible\n"); goto fin;
    }
    if (fwrite(b, 1, usados, stdout) != usados || fflush(stdout) == EOF) {
        fprintf(stderr, "Error al mostrar el saludo\n"); goto fin;
    }
    salida = EXIT_SUCCESS;
fin:
    if (cerrar(&fd) == -1) salida = EXIT_FAILURE;
    return salida;
}

El cliente no usa una lectura única ni supone que send y recv tienen los mismos cortes. Tampoco imprime el búfer con %s: usa una longitud comprobada y no requiere que el transporte haya añadido NUL.

La recepción admite hasta 64 bytes para poder detectar un saludo incompatible. El contrato real es el texto constante; llegar a esa capacidad se rechaza como contenido excesivo.

SO_RCVTIMEO limita cada recepción que necesite bloquear, no la duración global del cliente. connect es bloqueante y no tiene aquí un plazo integrado. Si la conexión falla, se cierra el descriptor; no se reintenta a ciegas sobre un socket cuyo estado puede ser indeterminado. Véase connect(2).

El saludo seguido de cierre es suficiente para esta demostración. En el tema 33 sustituiremos esa convención por un protocolo de petición y respuesta con reglas explícitas para longitudes y errores.

13. Compilar y conectar desde otra terminal

Bash en Linux o WSL · tres archivos en el mismo directorio
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic servidor32.c -o servidor32
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic cliente32.c -o cliente32

Las prácticas se ejecutan dentro de Linux. Si usas WSL, crea el directorio de prueba en /tmp de la distribución para utilizar su sistema de archivos Linux. No se requieren librt ni pthread para este ejemplo.

terminal A · preparar una sesión y arrancar el servidor
$ directorio=$(mktemp -d /tmp/soipc32.XXXXXX)
$ chmod 700 "$directorio"
$ ruta="$directorio/servicio.sock"
$ printf '%s\n' "$ruta"
/tmp/soipc32.ABC123/servicio.sock
$ ./servidor32 "$ruta" 3
Escuchando PID ... en /tmp/soipc32.ABC123/servicio.sock; limite 3; backlog solicitado 8

En B copia la ruta real impresa por A. Los caracteres ABC123 representan un ejemplo; la variable ruta no se transmite automáticamente a otra shell.

terminal B · tres conexiones independientes
$ ./cliente32 /tmp/soipc32.ABC123/servicio.sock
Hola desde AF_UNIX
$ ./cliente32 /tmp/soipc32.ABC123/servicio.sock
Hola desde AF_UNIX
$ ./cliente32 /tmp/soipc32.ABC123/servicio.sock
Hola desde AF_UNIX
terminal A · salida final ilustrativa
Aceptada 1: descriptor conectado ...
Aceptada 2: descriptor conectado ...
Aceptada 3: descriptor conectado ...
Aceptadas: 3; saludos enviados: 3; fallos: 0
$ test ! -e "$ruta" && echo "Ruta retirada"
Ruta retirada
$ rmdir "$directorio"

El número de descriptor conectado puede repetirse porque el anterior se cerró antes de aceptar otro. Lo estable es que cada conexión tiene su propio objeto durante la atención.

El servidor no ejecuta rmdir: el directorio pertenece a la sesión que lo creó. La retirada de la entrada y la eliminación del directorio se verifican por separado.

14. Varias conexiones y alcance del backlog

Puedes lanzar clientes cercanos en el tiempo. Aunque el núcleo mantenga solicitudes pendientes, el programa conserva una sola conexión de atención en cada iteración.

terminal B · después de que el servidor anuncie su escucha
$ ./cliente32 /tmp/soipc32.ABC123/servicio.sock > clienteA.txt &
$ a=$!
$ ./cliente32 /tmp/soipc32.ABC123/servicio.sock > clienteB.txt &
$ b=$!
$ ./cliente32 /tmp/soipc32.ABC123/servicio.sock > clienteC.txt &
$ c=$!
$ wait "$a"; wait "$b"; wait "$c"

Son tres procesos independientes que pueden conectar en un orden diferente al de sus letras. Los archivos deben contener el saludo si todos fueron aceptados correctamente. No se exige una asociación entre cliente A y el primer descriptor que imprime el servidor.

backlog ocho y límite tres describen cosas diferentes: capacidad solicitada para conexiones pendientes frente a cuántas aceptaciones realizará la aplicación. El servidor podría aceptar veinte a lo largo de su vida con el mismo backlog.

El mensaje de disponibilidad no reserva una plaza para cada cliente que lo leyó. Otro proceso puede conectar antes. Si termina el servidor o se llena la cola, connect puede fallar o esperar; el cliente debe comprobar su resultado.

Para atender varias sesiones lentas simultáneamente haría falta concurrencia o un bucle de eventos. Este servidor envía un texto corto y cierra, por lo que el ejemplo sigue siendo secuencial y acotado por cada operación local.

15. Probar colisiones, cancelación y rutas residuales

Un segundo servidor no adopta la ruta

Mientras A escucha, intenta ejecutar otro servidor con la misma ruta desde B. El segundo bind debe fallar, habitualmente con EADDRINUSE. Su limpieza no retira la entrada del primero, que debe seguir aceptando al cliente de prueba.

Repite sobre una ruta propia ocupada por un archivo regular con contenido conocido. El servidor debe fallar conservando ese archivo. No se usa la práctica como excusa para borrar una entrada que no creó.

Cancelar sin clientes

Bash · observar el mensaje de disponibilidad antes de terminar
$ ./servidor32 "$ruta" 20 > servidor32.log &
$ servidor=$!
$ cat servidor32.log
Escuchando PID ... en ...
$ kill -TERM "$servidor"
$ wait "$servidor"
$ echo $?
143
$ test ! -e "$ruta" && echo "Ruta retirada"

Si todavía no apareció el mensaje, vuelve a observar el archivo antes de enviar la señal. El timeout local de accept permite salir sin depender de que una interrupción coincida con su bloqueo. La planificación puede retrasar la salida; no se exige un número exacto de milisegundos.

Una caída abrupta deja otro problema

En un ensayo propio, SIGKILL termina el proceso sin ejecutar unlink. El socket de escucha deja de existir al cerrarse sus referencias, pero la entrada de ruta puede permanecer. Una nueva creación en ese mismo nombre seguirá encontrando la colisión.

Un connect fallido no es una autorización general para retirar el nombre. En la sesión privada, si conoces que el único servidor de esa prueba ya terminó y nadie usará la ruta, puedes retirar explícitamente esa entrada residual.

Bash · solo después de confirmar el fin del servidor propio
$ rm -- "$ruta"
$ rmdir "$directorio"

No es un comando de arranque automático ni una búsqueda para borrar sockets del sistema. Se aplica exclusivamente a la entrada conocida de tu directorio privado y después de cerrar la generación de prueba.

Una ruta sustituida no es la entrada original

En una prueba controlada puedes retirar la entrada propia mientras el servidor sigue vivo y colocar allí un archivo diferente. Al finalizar, el servidor debe advertir el cambio y conservar el archivo sustituto. Esa prueba viola deliberadamente la administración exclusiva para comprobar la defensa de limpieza, no para prometer ausencia de todas las carreras posibles.

16. Explorar el ciclo del servicio

Avanza desde socket hasta una aceptación. Puedes poner una ruta ajena antes de bind, solicitar varias conexiones pendientes y cerrar por separado la escucha y la conexión activa.

Descriptor del servicioNo creado

Entrada de rutaNo existe

Conexiones pendientes0

Descriptor de atenciónNinguno activo

Crea un extremo, asigna la ruta y prepara la escucha.

La cola del modelo admite tres pendientes para que se vea su función. No es una predicción del límite exacto del núcleo ni reproduce todos los resultados posibles de connect ante saturación.

Si retiras la ruta mientras una conexión ya está aceptada, el modelo conserva esa conexión: unlink afecta al nombre, no ejecuta close sobre los descriptores. El programa C usa otra secuencia de cierre deliberada para su finalización normal.

«Colocar entrada ajena» puede simular una ocupación previa o una sustitución de prueba. La limpieza no la elimina. El explorador omite permisos, envío de saludo y tiempos para centrarse en las identidades de los recursos.

17. Diagnóstico y pruebas del código

Inspeccionar mientras el servidor escucha

otra terminal Linux · reemplazar por la ruta real de tu sesión
$ ls -ld /tmp/soipc32.ABC123
$ ls -l /tmp/soipc32.ABC123/servicio.sock
srw------- ... /tmp/soipc32.ABC123/servicio.sock
$ ss -x -l -n

El primer carácter s representa una entrada de tipo socket. No se abre con cat para leer saludos: el cliente se conecta mediante la interfaz de sockets.

ss puede mostrar el extremo que escucha y su ruta. Una conexión aceptada es otro objeto y puede desaparecer tan rápido que no aparezca en una captura manual del saludo.

Bash · traza de una ejecución pequeña
$ strace -e trace=socket,bind,listen,accept,setsockopt,fcntl,umask,newfstatat,sendto,close,unlink ./servidor32 "$ruta" 1

La traza permite observar el retorno de accept y el descriptor conectado que recibe el saludo. La representación concreta de lstat o send puede aparecer con otra llamada de la biblioteca en Linux.

Comprobaciones útiles

Para probar EINTR de manera reproducible puede envolverse accept, send o recv y devolver una interrupción controlada antes de ejecutar la llamada real. La prueba no debe cerrar el descriptor ni fingir una adquisición o envío que no ocurrió.

Una prueba de bloqueo necesita su propio límite externo y limpieza. Debe esperar el mensaje «Escuchando» antes de conectar o enviar señales, en lugar de usar una pausa estimada que oculte una carrera de arranque.

SíntomaQué revisarDecisión correcta
EADDRINUSE en bind.La ruta ya está ocupada.Identificar su responsable; no borrar automáticamente.
ENOENT en connect.Ruta o directorio ausentes, o servicio ya retirado.Usar el nombre real y comprobar la fase del servidor.
ECONNREFUSED.No hay una escucha utilizable en ese extremo.Investigar servicio y generación, sin deducir propiedad del nombre.
EACCES.Permisos de directorio, entrada o política de la prueba.Verificar usuario, modo efectivo y directorio privado.
accept devuelve EAGAIN.En este ejemplo puede vencer SO_RCVTIMEO.Revisar cancelación y continuar esperando, sin tratarlo como una conexión.
El segundo cliente no progresa.La aplicación es secuencial o alcanzó el límite.Separar backlog, conexión pendiente y atención activa.
Queda una ruta tras morir.No se ejecutó la limpieza o no se pudo confirmar identidad.Intervención del responsable sobre el recurso conocido.
La ruta cambió durante la ejecución.Se incumplió la administración exclusiva.Conservar la entrada distinta e informar el fallo.

unlink elimina el nombre de una entrada, mientras referencias ya abiertas pueden seguir utilizándose, como describe unlink(2). Por eso ruta, escucha y conexiones deben inspeccionarse como recursos distintos.

18. Resumen

19. Preguntas de repaso y práctica

Responde antes de desplegar cada explicación.

1. ¿Qué hace bind en un socket Unix de ruta?

Asigna la dirección al extremo y crea su entrada de socket si la operación tiene éxito. No prepara por sí solo la escucha.

2. ¿Por qué se suma uno a strlen al calcular la longitud?

Porque el contrato de ruta incluye el terminador NUL. El miembro debe poder alojar todos esos bytes.

3. ¿Por qué se utiliza offsetof para sun_path?

Para expresar el desplazamiento real del miembro en la estructura, sin suponer manualmente padding ni tamaños de cabecera.

4. ¿Por qué el servidor no borra la ruta antes de bind?

Porque la entrada podría pertenecer a otro servicio o ser un archivo ajeno. Una colisión no concede propiedad para retirarla.

5. ¿Qué función cumple el directorio privado?

Controla quién puede atravesar y modificar el espacio de nombres de la sesión. El ejemplo exige además administración exclusiva mientras el servicio funciona.

6. ¿umask agrega permisos al socket?

No. Quita permisos de creación según las reglas del sistema. El programa restaura la máscara y verifica después el modo efectivo.

7. ¿backlog ocho significa ocho clientes atendidos simultáneamente?

No. Solicita capacidad para conexiones pendientes de aceptar. El ejemplo sigue atendiendo una conexión a la vez.

8. ¿Qué descriptor devuelve accept?

Uno nuevo conectado con un cliente. El descriptor original permanece como escucha y puede utilizarse para otra aceptación.

9. ¿Cerrar el conectado impide aceptar al siguiente?

No. La escucha es un recurso distinto y permanece abierta hasta que se cierre explícitamente.

10. ¿Puede aceptarse una conexión sin obtener una ruta del cliente?

Sí. El cliente puede no haber publicado una ruta propia. La dirección devuelta por accept no equivale por sí sola a una identidad autenticada.

11. ¿Por qué el cliente acumula varias lecturas?

Porque STREAM no conserva los cortes de send. El saludo puede llegar en partes y se valida después de reconstruirlo hasta el cierre.

12. ¿El timeout de accept convierte el socket en no bloqueante?

No. Limita una operación bloqueante en este entorno y permite revisar cancelación periódicamente. O_NONBLOCK es otra configuración y tiene otro contrato.

13. ¿Por qué un connect fallido no autoriza a retirar la ruta?

Porque puede fallar por permisos, fase de arranque, saturación u otras causas. El fallo no demuestra que el nombre sea propio ni que nadie lo utilice.

14. ¿Qué ocurre si la entrada fue sustituida antes de la limpieza?

Si la comparación detecta otra identidad o tipo, el servidor informa el problema y no elimina la nueva entrada. Esa defensa no elimina todas las carreras concurrentes.

15. ¿Por qué puede quedar un socket residual tras SIGKILL?

Porque el núcleo cierra referencias, pero no ejecuta el unlink de la aplicación. La entrada de ruta requiere administración explícita del responsable.

Para practicar y ampliar

  1. Dibuja los recursos existentes después de socket, bind, listen y dos aceptaciones sucesivas.
  2. Calcula la longitud de una dirección de ruta incluyendo su terminador y el comienzo real de sun_path.
  3. Ejecuta tres clientes y explica por qué puede repetirse el descriptor conectado.
  4. Lanza un segundo servidor sobre la ruta activa y verifica que el primero sigue funcionando.
  5. Prueba una ruta ocupada por un archivo propio y comprueba que su contenido permanece intacto.
  6. Compara cierre de conexión, cierre de escucha y retirada de nombre en el simulador.
  7. Cancela mientras no hay clientes y verifica la ruta y el directorio por separado.
  8. Simula el fallo de listen después de bind y comprueba la limpieza del recurso obtenido.
  9. Inyecta envíos y lecturas de un byte sin cambiar el contrato del saludo.
  10. Diseña la petición que agregarías al cliente y explica qué reglas de longitud, respuesta y error faltan todavía.
Próximo paso

El tema 33 desarrollará un cliente y un protocolo de petición y respuesta: connect, send, recv, enmarcado de mensajes y tratamiento de lecturas parciales.