1. Contrato de la conversación
La ruta, los permisos y la aceptación de conexiones siguen las reglas del tema 32. Cambia lo que sucede después de accept: el servidor espera una petición completa, calcula una respuesta y continúa sobre la misma conexión.
El ejemplo admite dos operaciones sobre un cuerpo de hasta 256 bytes: eco devuelve los mismos bytes; mayus transforma solamente las letras ASCII de a a z. Una operación desconocida produce una respuesta de error, sin romper una conversación correctamente enmarcada.
Una respuesta válida debe coincidir con la versión, clase, operación e identificador que espera el cliente, respetar el tamaño máximo y contener un resultado compatible con el contrato.
| Decisión | Regla del ejemplo | Consecuencia |
|---|---|---|
| Transporte. | AF_UNIX, SOCK_STREAM. | Los límites se construyen en la aplicación. |
| Conversación. | Hasta 16 peticiones por conexión. | El servidor no acepta una sesión de duración ilimitada por diseño. |
| Turno del cliente. | Enviar una petición y esperar su respuesta. | No hay varias solicitudes propias en vuelo en el cliente de ejemplo. |
| Identificadores. | 1, 2, 3... dentro de la conexión. | Se detectan respuestas ajenas y secuencias de solicitud incorrectas. |
| Datos. | Longitud entre 0 y 256 bytes. | No se exige NUL ni se busca un delimitador dentro del cuerpo. |
Las operaciones son deliberadamente pequeñas y no producen efectos externos. Nos permiten estudiar recepción, validación y correlación antes de añadir tareas que deban persistir o recuperarse tras una caída.
2. Conectar no equivale a completar una petición
El cliente crea un extremo y ejecuta connect con la dirección Unix del servicio. Un retorno cero prepara la conexión; todavía no significa que una solicitud de aplicación se haya enviado, aceptado o calculado.
CLIENTE SERVIDOR
socket + connect --------------------> accept
peticion id 1 -----------------------> recibir cabecera y cuerpo
validar y calcular
respuesta id 1 <--------------------- enviar cabecera y cuerpo
peticion id 2 -----------------------> recibir otra trama
respuesta id 2 <--------------------- responder
close -------------------------------> EOF entre tramas
cerrar conectadoSi connect falla, el ejemplo cierra el descriptor y falla la invocación. No reintenta indefinidamente sobre el mismo socket: después de ciertos fallos su estado no debe darse por reutilizable. El contrato se describe en connect(2).
La dirección de ruta identifica el extremo de conexión en AF_UNIX. No es una cola persistente de solicitudes ni un archivo al que anexar tramas con operaciones ordinarias de archivo; véase unix(7).
3. Dar límites a los mensajes de un flujo
En STREAM, dos envíos pueden reunirse en una recepción y un envío puede necesitar varias recepciones. El receptor no debe interpretar «retornó recv» como «terminó una petición».
| Estrategia | Ventaja | Regla que debe añadirse |
|---|---|---|
| Longitud fija. | El tamaño de la unidad ya se conoce. | Definir relleno y validar todos los campos. |
| Delimitador. | Puede resultar cómodo para texto. | Escapar el delimitador y limitar la búsqueda. |
| Cabecera con longitud. | Admite cuerpos binarios de tamaño variable. | Validar la longitud antes de reservar o leer el cuerpo. |
| Cierre de conexión. | Marca el final de una secuencia. | No permite por sí solo varias peticiones sucesivas sin cerrar. |
Elegiremos una cabecera fija de 16 bytes que declara la longitud del cuerpo. La unidad total será 16 + longitud. El límite máximo de trama es, por tanto, 272 bytes.
El receptor pide exactamente los bytes que faltan de cada parte. Si el núcleo ya tiene dos tramas, leer la primera no retira accidentalmente el comienzo de la segunda. Los bytes de la siguiente permanecen pendientes en el flujo.
Otro diseño podría leer bloques grandes y conservar sobrantes en un acumulador. Aquí evitaremos ese almacenamiento adicional y haremos explícitas las dos fases: cabecera y cuerpo.
4. Formato de la cabecera y del cuerpo
| Bytes | Campo | Regla |
|---|---|---|
| 0–3. | Marca. | Los cuatro bytes ASCII IPC3. |
| 4. | Versión. | 1. |
| 5. | Clase. | 1 petición; 2 respuesta. |
| 6. | Operación. | 1 eco; 2 mayúsculas ASCII; otros códigos no soportados. |
| 7. | Estado. | 0 en peticiones; 0 éxito o 1 error en respuestas. |
| 8–11. | Identificador. | Entero de 32 bits, no cero, byte más significativo primero. |
| 12–15. | Longitud. | Entero de 32 bits, de 0 a 256, en el mismo orden de bytes. |
| 16 en adelante. | Cuerpo. | Exactamente longitud bytes; no se añade terminador. |
La respuesta repite operación e identificador. En éxito contiene los bytes del resultado; en error contiene una descripción acotada. La clase y el estado evitan confundir una respuesta con una nueva petición.
49 50 43 33 01 01 01 00 00 00 00 01 00 00 00 04
I P C 3 version/clase/op/estado id longitud
68 6f 6c 61
h o l aNo enviamos sizeof de una estructura C nativa. Los campos se codifican por separado para evitar padding, alineación y orden de bytes dependientes de la ABI. La estructura local del programa solo es una representación de trabajo.
La operación mayus no es una conversión Unicode: transforma únicamente bytes de a a z. Los demás bytes, incluidos los de UTF-8 y NUL, se conservan. La herramienta de terminal recibe cadenas de argumentos, pero el formato transporta bytes con longitud.
5. Enviar todo sin repetir prefijos
send retorna cuántos bytes aceptó esa llamada o −1 al fallar. En un flujo, un éxito puede cubrir solo un prefijo. La siguiente llamada debe comenzar después de ese prefijo, no desde el principio de la trama.
enviados = 0;
while (enviados < total) {
n = send(fd, datos + enviados, total - enviados, MSG_NOSIGNAL);
/* Si n > 0: enviados += n. */
/* Si n == -1 y errno == EINTR: decidir reintento. */
/* Otros errores: abandonar esta conexion segun el protocolo. */
}Un retorno positivo manda sobre el valor anterior de errno. El ejemplo conserva el progreso y reintenta EINTR sin repetir bytes ya aceptados, conforme a send(2).
La cabecera y el cuerpo pueden enviarse con dos bucles sin que eso cree dos registros del transporte. El receptor usa el formato para saber dónde termina cada parte.
Si falla un envío después de haber aceptado algunos bytes, la conexión puede contener un prefijo incompleto. El ejemplo la cierra. No comienza otra trama en ese flujo como si el error hubiera borrado el prefijo.
6. Recibir exactamente lo necesario
La recepción acumula hasta completar la parte solicitada. Un resultado corto no es un error por sí mismo. El cierre, en cambio, tiene distinto significado según dónde aparezca.
| Situación | Interpretación | Respuesta |
|---|---|---|
| EOF antes del primer byte de una cabecera nueva. | El interlocutor terminó entre tramas. | El servidor puede cerrar normalmente; un cliente que esperaba respuesta falla. |
| EOF después de algunos bytes de cabecera. | Trama truncada. | Fallar la conversación. |
| EOF antes de completar un cuerpo no vacío. | Trama truncada. | No procesar un prefijo. |
| Longitud declarada cero. | Cuerpo vacío completo. | No llamar a recv para ese cuerpo ni confundirlo con EOF. |
| EINTR. | Interrupción de una llamada. | Conservar el progreso y reintentar según la política. |
El servidor conoce que llegó una trama cuando completó cabecera validada y cuerpo, no cuando el cliente cerró. Esto permite responder sin esperar EOF y continuar con otra solicitud en la misma conexión.
MSG_WAITALL no elimina por sí solo todas las condiciones de cierre, señales y errores. Usaremos un bucle que expresa qué parte falta y qué significa cada retorno. Las reglas de recepción se describen en recv(2).
7. Validar antes de interpretar
- Completar 16 bytes de cabecera. No interpretar campos que todavía no llegaron.
- Validar marca, versión y clase esperada. Un cliente espera respuestas; el servidor espera peticiones.
- Validar estado, identificador y longitud máxima. Rechazar antes de intentar leer un cuerpo excesivo.
- Completar el cuerpo acotado. Sin reservar memoria proporcional a una longitud no comprobada.
- Validar la conversación. Secuencia de identificadores y correspondencia con la operación pendiente.
- Ejecutar o verificar la operación. El formato correcto no sustituye las reglas semánticas.
El búfer del cuerpo tiene capacidad fija para el máximo permitido. Una longitud 0xffffffff se rechaza al terminar la cabecera; el programa no intenta asignar ni esperar cuatro mil millones de bytes.
El servidor exige identificadores consecutivos desde uno. El cliente exige que la respuesta tenga su identificador y operación pendientes. Esas reglas detectan equivocaciones, pero no autentican al interlocutor.
8. Errores de aplicación y errores de conversación
Si llega una operación desconocida dentro de una trama completa y válida, el servidor puede responder con estado de error y conservar la sesión. Conoce dónde termina esa solicitud y cómo construir la respuesta.
Si la marca, versión, clase, estado de petición o longitud son inválidos, el ejemplo cierra la conexión. No intenta buscar la próxima aparición de IPC3 dentro de datos arbitrarios: podría ser contenido de un cuerpo y no una cabecera.
| Problema | Tratamiento | Continuidad |
|---|---|---|
| Operación no soportada. | Respuesta de error con mismo id y operación. | Puede continuar la siguiente petición. |
| Cabecera inválida o cuerpo truncado. | Cerrar y registrar fallo. | No hay resincronización automática. |
| Id fuera de secuencia. | Fallar la conversación. | No se ejecuta esa solicitud. |
| Timeout o error de transporte. | Cerrar según la política de esta implementación. | No se reenvía automáticamente trabajo. |
| Resultado incompatible en el cliente. | Rechazarlo aunque el transporte terminara. | La invocación no informa éxito. |
Los textos de error también llevan longitud y se muestran de manera acotada. No se supone que un cuerpo recibido termine en NUL.
9. Varias peticiones en una conexión
El cliente envía una petición, recibe su respuesta completa y solo entonces envía la siguiente. Esta disciplina evita que el emisor acumule solicitudes sin límite antes de leer resultados.
El servidor puede recibir cabeceras y cuerpos repartidos de cualquier manera en el flujo. También puede encontrar varios mensajes ya disponibles: sus lecturas exactas conservan el comienzo de la siguiente trama en el socket.
El ejemplo limita la sesión a 16 solicitudes. Tras responder la última, el servidor cierra la conexión. Si el cliente termina antes, cierra entre tramas y el servidor reconoce EOF de sesión.
El identificador se reinicia en cada conexión. No es una clave global de deduplicación ni un registro persistente de trabajo completado. Reabrir una conexión y volver a utilizar id uno no demuestra que una operación anterior nunca ocurrió.
Un cliente con varias solicitudes en vuelo necesitaría asociar respuestas y controlar su ventana de pendientes. No basta con quitar la espera del bucle y enviar todo de forma bloqueante; habría que analizar capacidad en ambas direcciones.
10. Código del protocolo compartido
Guarda protocolo33.h y copia junto a él la cabecera apoyo32.h del tema 32. Reutilizaremos sus funciones de dirección, permisos y limpieza para concentrarnos en el protocolo. No se necesitan servidor32.c ni cliente32.c.
Los retornos de recibir_trama son: 1 trama completa, 0 EOF entre tramas, −1 error de E/S, −2 truncamiento y −3 cabecera incompatible. El programa decide cómo tratar cada caso.
#ifndef PROTOCOLO33_H
#define PROTOCOLO33_H
#include "apoyo32.h"
#include <inttypes.h>
#include <stdint.h>
#define CAB33 16u
#define MAX_CUERPO 256u
#define MAX_PETICIONES 16u
#define PETICION 1u
#define RESPUESTA 2u
#define OP_ECO 1u
#define OP_MAYUS 2u
#define EST_OK 0u
#define EST_ERROR 1u
struct trama {
unsigned char tipo, operacion, estado;
uint32_t id, longitud;
unsigned char cuerpo[MAX_CUERPO];
};
static inline void poner32(unsigned char *p, uint32_t x)
{
p[0] = (unsigned char)(x >> 24); p[1] = (unsigned char)(x >> 16);
p[2] = (unsigned char)(x >> 8); p[3] = (unsigned char)x;
}
static inline uint32_t obtener32(const unsigned char *p)
{
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
((uint32_t)p[2] << 8) | (uint32_t)p[3];
}
static inline int enviar_todo(int fd, const unsigned char *b, size_t n,
const volatile sig_atomic_t *cancelar)
{
size_t usados = 0;
while (usados < n) {
if (cancelar && *cancelar) { errno = ECANCELED; return -1; }
ssize_t r = send(fd, b + usados, n - usados, MSG_NOSIGNAL);
if (r == -1 && errno == EINTR) continue;
if (r <= 0) { if (r == 0) errno = EIO; return -1; }
usados += (size_t)r;
}
return 0;
}
static inline int recibir_exacto(int fd, unsigned char *b, size_t n,
int eof_inicial,
const volatile sig_atomic_t *cancelar)
{
size_t usados = 0;
while (usados < n) {
if (cancelar && *cancelar) { errno = ECANCELED; return -1; }
ssize_t r = recv(fd, b + usados, n - usados, 0);
if (r == -1 && errno == EINTR) continue;
if (r == -1) return -1;
if (r == 0) return usados == 0 && eof_inicial ? 0 : -2;
usados += (size_t)r;
}
return 1; /* Tambien completa correctamente un cuerpo de longitud cero. */
}
static inline int enviar_trama(int fd, const struct trama *t,
const volatile sig_atomic_t *cancelar)
{
if ((t->tipo != PETICION && t->tipo != RESPUESTA) || !t->id ||
t->longitud > MAX_CUERPO || t->estado > EST_ERROR ||
(t->tipo == PETICION && t->estado != EST_OK)) {
errno = EINVAL; return -1;
}
unsigned char h[CAB33];
memcpy(h, "IPC3", 4);
h[4] = 1; h[5] = t->tipo; h[6] = t->operacion; h[7] = t->estado;
poner32(h + 8, t->id);
poner32(h + 12, t->longitud);
if (enviar_todo(fd, h, sizeof h, cancelar) == -1) return -1;
return enviar_todo(fd, t->cuerpo, t->longitud, cancelar);
}
static inline int recibir_trama(int fd, unsigned char tipo, struct trama *t,
const volatile sig_atomic_t *cancelar)
{
unsigned char h[CAB33];
int r = recibir_exacto(fd, h, sizeof h, 1, cancelar);
if (r != 1) return r;
uint32_t id = obtener32(h + 8), longitud = obtener32(h + 12);
if (memcmp(h, "IPC3", 4) != 0 || h[4] != 1 || h[5] != tipo ||
!id || longitud > MAX_CUERPO || h[7] > EST_ERROR ||
(tipo == PETICION && h[7] != EST_OK)) return -3;
t->tipo = h[5]; t->operacion = h[6]; t->estado = h[7];
t->id = id; t->longitud = longitud;
return recibir_exacto(fd, t->cuerpo, longitud, 0, cancelar);
}
static inline void convertir_ascii(unsigned char *b, size_t n)
{
for (size_t i = 0; i < n; ++i)
if (b[i] >= 'a' && b[i] <= 'z') b[i] = (unsigned char)(b[i] - 'a' + 'A');
}
static inline int repeticiones(const char *s, unsigned *n)
{
if (cantidad_clientes(s, n) == -1 || *n > MAX_PETICIONES) return -1;
return 0;
}
#endifLas funciones conservan el progreso de la parte actual. Solo consideran EOF limpio antes de comenzar una cabecera nueva; para el cuerpo, un cero prematuro es truncamiento aunque todavía no haya llegado ningún byte.
La estructura trama no sale directamente por send. enviar_trama crea una cabecera de 16 bytes y después transmite el cuerpo declarado. Los campos locales que no se utilizaron no se filtran como padding o contenido accidental.
El puntero cancelar representa una bandera local de ese proceso. El cliente pasa NULL; el servidor permite que su manejador solicite terminar. No es memoria compartida entre interlocutores.
11. Servidor de peticiones
Guarda servidor33.c. Conserva la política de rutas privadas y propiedad del tema 32. En cada conexión acepta hasta 16 tramas, exige su secuencia de identificadores y responde sin necesitar un cierre previo del cliente.
#include "protocolo33.h"
static volatile sig_atomic_t parar = 0;
static void solicitar(int signo) { parar = signo; }
static int atender(int fd, unsigned *respondidas, unsigned *errores)
{
for (uint32_t siguiente = 1; siguiente <= MAX_PETICIONES; ++siguiente) {
struct trama p;
int r = recibir_trama(fd, PETICION, &p, ¶r);
if (r == 0) return 0; /* EOF entre tramas. */
if (r != 1) {
if (!parar) {
if (r == -1) perror("recibir peticion");
else fprintf(stderr, "Peticion truncada o incompatible: %d\n", r);
}
return -1;
}
if (p.id != siguiente) {
fprintf(stderr, "Identificador fuera de secuencia\n"); return -1;
}
struct trama respuesta = {0};
respuesta.tipo = RESPUESTA;
respuesta.operacion = p.operacion;
respuesta.id = p.id;
if (p.operacion == OP_ECO || p.operacion == OP_MAYUS) {
respuesta.estado = EST_OK;
respuesta.longitud = p.longitud;
memcpy(respuesta.cuerpo, p.cuerpo, p.longitud);
if (p.operacion == OP_MAYUS)
convertir_ascii(respuesta.cuerpo, respuesta.longitud);
} else {
const char error[] = "Operacion no soportada";
respuesta.estado = EST_ERROR;
respuesta.longitud = sizeof error - 1;
memcpy(respuesta.cuerpo, error, sizeof error - 1);
}
if (enviar_trama(fd, &respuesta, ¶r) == -1) {
if (!parar) perror("enviar respuesta");
return -1;
}
++*respondidas;
if (respuesta.estado == EST_ERROR) ++*errores;
}
return 0; /* Limite de peticiones: cerrar esta conexion. */
}
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 [conexiones(1..20)]\n",
argv[0]); return 1;
}
struct sockaddr_un a;
socklen_t longitud;
if (direccion(argv[1], &a, &longitud) == -1 ||
directorio_privado(argv[1]) == -1) {
perror("ruta del servidor"); return 1;
}
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 1;
}
int escucha = -1, conectado = -1, vinculado = 0, identificado = 0;
int salida = 1, listo = 0;
unsigned conexiones = 0, respondidas = 0, errores = 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 anterior = umask(0177);
int r = bind(escucha, (struct sockaddr *)&a, longitud);
int motivo = errno;
umask(anterior);
errno = motivo;
if (r == -1) { perror("bind"); goto fin; }
vinculado = 1;
if (lstat(argv[1], &propia) == -1) { perror("lstat"); goto fin; }
if (!S_ISSOCK(propia.st_mode) || propia.st_uid != geteuid()) {
fprintf(stderr, "No se identifica un socket propio\n"); goto fin;
}
identificado = 1;
if ((propia.st_mode & 0777) != 0600) {
fprintf(stderr, "Se exige modo efectivo 0600\n"); goto fin;
}
if (listen(escucha, 8) == -1) { perror("listen"); goto fin; }
salida = 0; listo = 1;
printf("Protocolo33 listo PID %ld en %s; limite %u conexiones\n",
(long)getpid(), argv[1], maximo);
if (fflush(stdout) == EOF) { salida = 1; goto fin; }
while (conexiones < maximo && !parar) {
conectado = accept(escucha, NULL, NULL);
if (conectado == -1) {
if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ||
errno == ECONNABORTED) continue;
perror("accept"); salida = 1; break;
}
++conexiones;
if (cloexec(conectado) == -1 ||
tiempo_socket(conectado, SO_RCVTIMEO, 1000) == -1 ||
tiempo_socket(conectado, SO_SNDTIMEO, 1000) == -1) {
perror("configurar conectado"); salida = 1; break;
}
if (atender(conectado, &respondidas, &errores) == -1 && !parar) ++fallos;
if (cerrar(&conectado) == -1) { salida = 1; break; }
}
if (fallos) salida = 1;
fin:
if (parar && salida == 0) salida = 128 + (int)parar;
if (cerrar(&conectado) == -1) salida = 1;
if (cerrar(&escucha) == -1) salida = 1;
if (vinculado) {
if (identificado) {
if (retirar_propia(argv[1], &propia) == -1) salida = 1;
} else {
fprintf(stderr, "No se retira una ruta de identidad incierta\n"); salida = 1;
}
}
if (listo) printf("Conexiones: %u; respuestas enviadas: %u; "
"errores de aplicacion: %u; fallos de sesion: %u\n",
conexiones, respondidas, errores, fallos);
if (fflush(stdout) == EOF || ferror(stdout)) salida = 1;
return salida;
}Una operación no soportada incrementa errores de aplicación cuando se envió su respuesta, pero no convierte la sesión en inválida. El servidor puede terminar con retorno cero aunque haya respondido errores semánticos correctamente.
Los fallos de sesión se registran aparte y hacen retornar error al terminar la vida del servidor. Una conexión con trama inválida se cierra; las siguientes pueden seguir siendo atendidas hasta el límite configurado.
La función atender conoce el siguiente identificador esperado. El límite de 16 pertenece a esta versión del protocolo; el cliente del ejemplo lo respeta y no espera una sesión ilimitada.
12. Cliente con verificación de respuestas
Guarda cliente33.c. Acepta eco, mayus o desconocida para probar el error semántico. Repite el mismo cuerpo en una sola conexión, con identificadores distintos, entre una y dieciséis veces.
#include "protocolo33.h"
int main(int argc, char **argv)
{
unsigned veces = 1;
if ((argc != 4 && argc != 5) ||
(argc == 5 && repeticiones(argv[4], &veces) == -1)) goto uso;
unsigned char operacion;
if (strcmp(argv[2], "eco") == 0) operacion = OP_ECO;
else if (strcmp(argv[2], "mayus") == 0) operacion = OP_MAYUS;
else if (strcmp(argv[2], "desconocida") == 0) operacion = 255;
else goto uso;
size_t n = strlen(argv[3]);
if (n > MAX_CUERPO) {
fprintf(stderr, "El cuerpo supera 256 bytes\n"); return 1;
}
struct sockaddr_un a;
socklen_t longitud;
if (direccion(argv[1], &a, &longitud) == -1) {
perror("direccion"); return 1;
}
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) { perror("socket"); return 1; }
int salida = 1, hubo_error = 0;
if (cloexec(fd) == -1 || tiempo_socket(fd, SO_RCVTIMEO, 1000) == -1 ||
tiempo_socket(fd, SO_SNDTIMEO, 1000) == -1) {
perror("configurar cliente"); goto fin;
}
if (connect(fd, (struct sockaddr *)&a, longitud) == -1) {
perror("connect"); goto fin;
}
unsigned char esperado[MAX_CUERPO];
memcpy(esperado, argv[3], n);
if (operacion == OP_MAYUS) convertir_ascii(esperado, n);
for (uint32_t id = 1; id <= veces; ++id) {
struct trama p = {0};
p.tipo = PETICION; p.operacion = operacion; p.estado = EST_OK;
p.id = id; p.longitud = (uint32_t)n;
memcpy(p.cuerpo, argv[3], n);
if (enviar_trama(fd, &p, NULL) == -1) { perror("enviar peticion"); goto fin; }
struct trama r;
int recibido = recibir_trama(fd, RESPUESTA, &r, NULL);
if (recibido != 1) {
if (recibido == -1) perror("recibir respuesta");
else fprintf(stderr, "Falta una respuesta completa: %d\n", recibido);
goto fin;
}
if (r.id != id || r.operacion != operacion) {
fprintf(stderr, "Respuesta ajena a la solicitud pendiente\n"); goto fin;
}
if (r.estado == EST_ERROR) {
printf("Respuesta id %" PRIu32 ": ERROR: ", id);
if (fwrite(r.cuerpo, 1, r.longitud, stdout) != r.longitud ||
putchar('\n') == EOF) goto fin;
hubo_error = 1;
continue;
}
if ((operacion != OP_ECO && operacion != OP_MAYUS) ||
r.longitud != n || memcmp(r.cuerpo, esperado, n) != 0) {
fprintf(stderr, "Resultado incompatible\n"); goto fin;
}
printf("Respuesta id %" PRIu32 ": %" PRIu32 " bytes: ", id, r.longitud);
if (fwrite(r.cuerpo, 1, r.longitud, stdout) != r.longitud ||
putchar('\n') == EOF) goto fin;
}
salida = hubo_error ? 2 : 0;
fin:
if (cerrar(&fd) == -1) salida = 1;
if (fflush(stdout) == EOF || ferror(stdout)) salida = 1;
return salida;
uso:
fprintf(stderr, "Uso: %s /ruta/servicio.sock eco|mayus|desconocida texto "
"[repeticiones(1..16)]\n", argv[0]);
return 1;
}Los retornos del cliente son cero si todas las respuestas son correctas y exitosas, dos si recibió uno o más errores de aplicación válidos y uno ante un fallo de transporte, formato, resultado o uso.
Una respuesta de error también debe coincidir con id y operación. No se muestra un texto arbitrario recibido de una respuesta que pertenece a otra solicitud pendiente.
El programa no espera EOF para aceptar una respuesta: la cabecera y su cuerpo bastan. Después de la última respuesta cierra su descriptor, permitiendo que el servidor observe un final entre tramas si todavía esperaba otra.
13. Compilar e intercambiar solicitudes
Los cuatro archivos necesarios son apoyo32.h, protocolo33.h, servidor33.c y cliente33.c. El protocolo incluye inttypes.h para utilizar las macros de impresión de uint32_t.
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic servidor33.c -o servidor33
$ gcc -std=c17 -O2 -Wall -Wextra -Wpedantic cliente33.c -o cliente33$ directorio=$(mktemp -d /tmp/soipc33.XXXXXX)
$ chmod 700 "$directorio"
$ ruta="$directorio/servicio.sock"
$ printf '%s\n' "$ruta"
/tmp/soipc33.ABC123/servicio.sock
$ ./servidor33 "$ruta" 3
Protocolo33 listo PID ... en /tmp/soipc33.ABC123/servicio.sock; limite 3 conexionesEn B usa la ruta real que imprimió A. Cada invocación del cliente utiliza una conexión; sus repeticiones son varias solicitudes dentro de ella.
$ ./cliente33 /tmp/soipc33.ABC123/servicio.sock eco "hola" 3
Respuesta id 1: 4 bytes: hola
Respuesta id 2: 4 bytes: hola
Respuesta id 3: 4 bytes: hola
$ ./cliente33 /tmp/soipc33.ABC123/servicio.sock mayus "hola mundo" 2
Respuesta id 1: 10 bytes: HOLA MUNDO
Respuesta id 2: 10 bytes: HOLA MUNDO
$ ./cliente33 /tmp/soipc33.ABC123/servicio.sock desconocida "hola"
Respuesta id 1: ERROR: Operacion no soportada
$ echo $?
2Conexiones: 3; respuestas enviadas: 6; errores de aplicacion: 1; fallos de sesion: 0
$ test ! -e "$ruta" && rmdir "$directorio"El servidor considera correcto haber respondido un error de operación. El cliente lo informa con retorno dos porque esa solicitud no obtuvo un resultado exitoso. Son decisiones diferentes sobre una misma conversación válida.
14. Probar tamaños, vacío y contenido binario
$ ./cliente33 "$ruta" eco "" 2
Respuesta id 1: 0 bytes:
Respuesta id 2: 0 bytes:
$ ./cliente33 "$ruta" mayus "acción"
Respuesta id 1: 7 bytes: ACCIóNEl cuerpo vacío produce una trama de 16 bytes y se completa sin leer un cuerpo. No necesita cerrar la conexión. El ejemplo UTF-8 muestra la transformación ASCII: la ó permanece como sus bytes originales y no se convierte en Ó.
Prueba 256 bytes ASCII para el límite válido y 257 para el rechazo de entrada del cliente antes de crear el socket. El máximo se aplica a bytes; no a la cantidad de caracteres visibles.
Los argumentos de una shell no transportan un NUL interno. Para comprobar el protocolo binario utiliza una prueba que envíe, por ejemplo, los bytes 61 00 62 con longitud tres. Eco debe devolver los tres; mayus debe devolver 41 00 42. No hay una llamada strlen en la interpretación del cuerpo recibido.
La descripción de error es una elección de esta implementación. El formato mantiene el mismo máximo y las mismas reglas de longitud para cualquier respuesta.
15. Cierres, plazos y reintentos de trabajo
El cierre de STREAM se interpreta respecto del estado del receptor. EOF entre solicitudes permite finalizar una sesión del servidor; EOF cuando el cliente espera una respuesta completa no confirma el trabajo pendiente.
El servidor configura un segundo de espera de envío y recepción por llamada en cada conexión. Eso evita algunas esperas indefinidas de un interlocutor silencioso, pero no es un presupuesto total por trama: un emisor que entrega pequeños fragmentos puede prolongar la sesión.
El cliente tiene controles locales similares. Un servicio con un plazo global necesitaría conservar una fecha o presupuesto y coordinarlo con un bucle de E/S apropiado, en lugar de renovar implícitamente la ventana en cada recv.
Si un timeout aparece después de recibir parte de la cabecera o cuerpo, el ejemplo cierra. El helper no devuelve al llamador un estado incremental para reanudar más tarde. Sería incorrecto empezar a leer otra cabecera desde el punto actual.
La cancelación del servidor también puede cortar una trama. El manejador marca una bandera y el flujo principal cierra y retira la ruta propia. Los timeouts locales permiten revisar esa bandera si la señal llegó antes de comenzar una operación bloqueante; no garantizan una latencia exacta.
¿Se puede repetir una petición si se pierde la respuesta?
Un send completo solo confirma aceptación de bytes por esa operación del transporte. El servidor puede haber calculado una respuesta que el cliente nunca recibió. La ausencia de respuesta no demuestra que no se ejecutó la operación.
Las operaciones de este ejemplo son transformaciones sin efectos externos, pero el cliente no implementa reintento automático. Si una tarea modificara una cuenta o enviara un correo, repetirla exigiría idempotencia, deduplicación o un protocolo transaccional.
El id local de esta conversación no ofrece «exactamente una vez». No persiste después de cerrar y no enlaza automáticamente solicitudes de conexiones distintas. La correlación y la recuperación son problemas relacionados, pero diferentes.
16. Explorar un receptor por estados
El modelo prepara dos peticiones reales del formato: id uno con hola e id dos con mundo. Alimenta al receptor de un byte, de siete en siete o con todo el resto para observar cómo completa cabeceras y cuerpos.
Bytes de prueba aún por entregar41
Estado del receptorCabecera: 0 de 16 bytes
Último fragmento hexadecimal—
Tramas completasNinguna
La primera trama ocupa 20 bytes y la segunda 21.
El botón de cierre representa que el emisor deja sin transmitir los bytes de prueba que faltaban. No afirma que un cierre real descarte bytes que el núcleo ya había aceptado: esos bytes podrían seguir disponibles antes de observar EOF.
Si llegan ambas tramas juntas, el modelo procesa una, conserva el sobrante y procesa la siguiente. El programa C usa lecturas exactas que dejan ese sobrante en el búfer del socket; son dos maneras de respetar los mismos límites.
El modelo usa cuerpos ASCII conocidos para mostrar su contenido y no implementa toda la aplicación. La versión desconocida o una longitud excesiva cierran el parser didáctico sin buscar otra marca dentro del flujo.
17. Pruebas y diagnóstico
Casos correctos
- Una conexión persistente. Envía varias solicitudes y comprueba sus ids sin cerrar entre respuestas.
- Límite de sesión. Completa 16 intercambios; el servidor no debe esperar una petición diecisiete para terminar esa conexión.
- Vacío y máximo. Prueba cuerpos de cero y 256 bytes, además de rechazo de 257 en el cliente.
- Binario. Comprueba un NUL intermedio con una herramienta que trabaje por bytes.
- Error semántico recuperable. Envía una operación desconocida y después una eco válida en la misma sesión con el siguiente id.
- Tramas reunidas. Una prueba puede enviar dos peticiones juntas; el servidor debe responderlas por separado y en orden.
Fragmentación y señales sin pruebas frágiles
Envuelve send para que acepte solo uno o dos bytes y recv para que retire un byte cada vez. La conversación completa debe seguir siendo correcta. La prueba debe aplicar el límite a la llamada real, no fingir éxito sin enviar datos.
Inyecta EINTR antes de algunas llamadas reales, comprobando que los bucles conservan progreso. Un retorno positivo ya representa bytes aceptados o retirados; no se repiten por consultar un errno antiguo.
Algunas compilaciones de glibc utilizan variantes instrumentadas como __recv_chk. Un controlador que intercepte recv debe verificar qué función está envolviendo para no creer que probó lecturas parciales cuando siguió ejecutándose la lectura original.
Tramas y respuestas incompatibles
| Prueba | Comportamiento exigido | Lo que no debe ocurrir |
|---|---|---|
| Marca o versión desconocidas. | Cerrar esa sesión. | Interpretar el cuerpo como si fuera la versión 1. |
| Longitud 257 o 0xffffffff. | Rechazar al validar la cabecera. | Reservar o esperar el tamaño declarado sin control. |
| Cierre a mitad de cabecera. | Informar truncamiento. | Aceptar los campos que alcanzaron a llegar. |
| Cierre con cuerpo pendiente. | No ejecutar la operación incompleta. | Calcular sobre el prefijo recibido. |
| Id repetido o fuera de secuencia. | Fallar la conversación. | Tratarlo como trabajo nuevo legítimo. |
| Respuesta con id u operación distintos. | El cliente la rechaza. | Mostrarla como resultado de su solicitud pendiente. |
| Resultado de éxito incorrecto. | El cliente falla la validación. | Confiar solo en que se recibió la cantidad de bytes. |
Los objetos inválidos de prueba deben prepararse como bytes controlados; enviar_trama rechaza ciertos errores locales antes de transmitir. No retires esa validación del código normal para «probar» una longitud enorme.
Prueba también un cliente que conecta y cierra sin enviar ninguna cabecera. Es EOF entre tramas y el servidor puede terminar esa conexión normalmente. Contrástalo con un cliente que transmite un solo byte y luego cierra.
$ strace -xx -s 300 -e trace=connect,sendto,recvfrom,close ./cliente33 "$ruta" eco "hola" 2La traza puede mostrar cabecera y cuerpo en llamadas diferentes, o fragmentos más pequeños. El análisis debe reconstruir la secuencia completa. Un límite de llamada observado en una ejecución no se convierte en un límite de mensaje garantizado.
Rutas y finalización del servicio
Se mantienen las pruebas del tema 32: no borrar una colisión, retirar el socket propio tras el fin normal y conservar una entrada que haya cambiado de identidad. Los participantes deben utilizar un directorio privado administrado de forma exclusiva.
Un controlador de pruebas tiene su propio límite externo y termina los procesos que lanzó si algo falla. Para el arranque espera el mensaje «Protocolo33 listo» en lugar de una pausa aproximada. El retorno del servidor distingue fallos de sesión de errores de aplicación respondidos correctamente.
18. Resumen
- connect establece transporte; no confirma la ejecución de una solicitud.
- STREAM necesita enmarcado de aplicación, incluso dentro del mismo equipo.
- La cabecera de 16 bytes declara clase, operación, estado, id y longitud.
- Los enteros se codifican explícitamente, sin enviar una estructura nativa.
- Los bucles de E/S avanzan por los bytes que cada llamada realmente procesó.
- La longitud se valida antes de leer un cuerpo o reservar un tamaño externo.
- Un cuerpo vacío es una trama completa; EOF tiene otro significado.
- EOF entre tramas y EOF dentro de una trama requieren tratamientos diferentes.
- Un error de operación puede responderse sin perder sincronización.
- Una cabecera inválida o una trama truncada cierran la conversación de este ejemplo.
- Los identificadores correlacionan respuestas dentro de una sesión, sin prometer deduplicación global.
- Un fallo de respuesta no autoriza a repetir efectos externos automáticamente.
19. Preguntas de repaso y práctica
Responde antes de desplegar cada explicación. Usa los estados de cabecera, cuerpo y petición pendiente para razonar.
1. ¿Por qué recv no define el final de una petición?
Porque STREAM entrega una secuencia de bytes con cortes variables. El final se reconoce mediante el formato de aplicación.
2. ¿Qué se valida antes de leer el cuerpo?
La cabecera completa: marca, versión, clase esperada, estado, identificador y longitud máxima. Una longitud excesiva se rechaza antes de esperar esos bytes.
3. ¿Por qué no se envía sizeof(struct trama)?
Porque la estructura local puede incluir padding y representación nativa. El formato define posiciones y orden de bytes explícitos.
4. ¿Qué hace el bucle si send acepta solo tres bytes?
Avanza tres posiciones y solicita únicamente los bytes restantes. No vuelve a enviar el prefijo ya aceptado.
5. ¿EINTR obliga a empezar de cero la trama?
No. Se conserva el progreso de llamadas anteriores exitosas. El programa reintenta la parte que todavía falta según su política.
6. ¿Cómo se interpreta un cuerpo de longitud cero?
Como un cuerpo ya completo sin llamar a recv para él. No es EOF de la conexión.
7. ¿Qué diferencia hay entre EOF inicial y EOF a mitad de cabecera?
El primero termina entre tramas; el segundo deja una trama incompleta. Si el cliente esperaba una respuesta, incluso el EOF inicial significa que esa respuesta no llegó.
8. ¿Qué ocurre si una recepción ya contiene dos tramas?
El formato permite separarlas. El código C solicita solo lo que falta de la primera parte, dejando los siguientes bytes pendientes en el socket.
9. ¿Por qué una operación desconocida no rompe necesariamente la sesión?
Si la trama es válida y completa, el servidor conoce sus límites y puede responder un error con el mismo id y operación antes de seguir.
10. ¿Por qué no se busca otra marca IPC3 después de una cabecera inválida?
Porque esos bytes podrían aparecer dentro de datos y no señalar una frontera real. El ejemplo cierra en lugar de inventar una resincronización.
11. ¿Qué comprueba el cliente además del tamaño?
Clase, versión, estado permitido, identificador, operación y contenido del resultado exitoso. Un número correcto de bytes no basta.
12. ¿El id uno identifica una tarea para siempre?
No. Se reinicia en cada conexión y no hay registro persistente de deduplicación. Su función es correlacionar dentro de esa conversación.
13. ¿mayus convierte todas las letras de un texto UTF-8?
No. Solo transforma los bytes ASCII de a a z. Los otros bytes se conservan.
14. ¿El timeout de un segundo es un plazo global de trama?
No. Se aplica por llamada bloqueante. Varias llamadas con progreso parcial pueden prolongar la conversación.
15. ¿No recibir respuesta demuestra que la tarea no se ejecutó?
No. Puede haberse calculado o producido un efecto antes de perder la respuesta. Repetir trabajo con efectos externos necesita otro contrato.
Para practicar y ampliar
- Codifica a mano una petición eco de tres bytes con id cinco y su respuesta.
- Ejecuta 16 solicitudes en una conexión y compara conexiones aceptadas con respuestas enviadas.
- Prueba cuerpo vacío, 256 bytes y rechazo de 257.
- Envía un NUL intermedio mediante una prueba binaria y verifica eco y mayus.
- Inyecta avances de un byte en send y recv y confirma que no se duplican ni pierden bytes.
- Contrasta cierre sin cabecera, cabecera parcial y cuerpo parcial.
- Envía una operación desconocida seguida de una válida en la misma conexión.
- Prepara respuestas de prueba con id, operación o resultado incorrectos y comprueba su rechazo.
- Diseña una tercera operación y define primero sus longitudes y errores de aplicación.
- Propón una política de reintento para una tarea con efectos, incluyendo cómo detectar duplicados después de reconectar.
El tema 34 profundizará en socketpair y cierre de conexiones: crear un par conectado, utilizar shutdown y distinguir el cierre de una dirección del cierre completo de las referencias.