1. Un punto de encuentro para procesos independientes
En el bloque anterior creamos canales con pipe y repartimos sus descriptores mediante fork. Ese mecanismo funciona cuando los procesos pueden heredar referencias de un antecesor que preparó la conexión.
Ahora imagina un receptor iniciado en una terminal y un emisor ejecutado después desde otra. Queremos que ambos encuentren el mismo canal usando un nombre acordado. Una FIFO, también llamada tubería con nombre, proporciona ese punto de encuentro.
Una FIFO es un archivo especial que permite abrir una tubería mediante una ruta. Su nombre pertenece al sistema de archivos; los bytes intercambiados se mantienen en el canal del núcleo y no se guardan como contenido de un archivo regular.
Los procesos necesitan ver la misma FIFO y tener permisos para abrirla. No basta con escribir rutas de igual texto si cada proceso ve un sistema de archivos distinto, como puede ocurrir con contenedores o espacios de nombres separados.
El nombre no identifica automáticamente a un interlocutor concreto. Cualquier proceso con acceso apropiado podría abrirlo. En este tema trabajaremos con un emisor y un receptor bajo el mismo usuario.
2. Tubería anónima, FIFO y archivo regular
| Propiedad | Tubería anónima | FIFO | Archivo regular |
|---|---|---|---|
| Creación habitual. | pipe devuelve dos descriptores. | mkfifo crea una entrada; open obtiene descriptores. | open puede crear y abrir contenido persistente. |
| Cómo se encuentra. | Por referencias heredadas o transmitidas. | Por una ruta y sus permisos. | Por una ruta y sus permisos. |
| Contenido. | Flujo temporal de bytes. | Flujo temporal de bytes. | Datos almacenados en el archivo. |
| Acceso aleatorio. | No. | No; lseek no permite retroceder en el flujo. | Habitualmente sí. |
| Encuentro de lector y escritor. | Los extremos existen al crear el canal. | La apertura bloqueante puede esperar al extremo complementario. | Abrirlo no exige otro proceso conectado. |
| Qué queda al cerrar todo. | El canal deja de estar referenciado. | El nombre puede seguir existiendo, sin conservar los bytes del intercambio. | El contenido puede seguir disponible. |
La semejanza con un archivo regular termina en la interfaz de ruta y descriptores. Una FIFO no sirve como registro durable ni como buzón que acumule datos indefinidamente cuando no hay receptor.
3. Crear el nombre con mkfifo
int mkfifo(const char *ruta, mode_t modo);
if (mkfifo(ruta, 0600) == -1) {
perror("mkfifo");
/* No suponer que se creo una FIFO nueva. */
}mkfifo devuelve cero al crear la entrada y −1 al fallar, dejando la causa en errno. No retorna un descriptor, no crea procesos y no espera a que aparezca un lector. Para usar el canal se necesita un open posterior.
El modo especifica permisos, no el tipo de archivo: la propia operación crea una FIFO. Los números de permisos se escriben con cero inicial en C porque son valores octales. La interfaz y sus errores están documentados en mkfifo(3).
| Error habitual | Qué revisar |
|---|---|
| EEXIST. | Ya hay una entrada con ese nombre; podría ser otro tipo de archivo. |
| ENOENT. | Falta algún directorio de la ruta. |
| EACCES. | Faltan permisos para recorrer la ruta o crear una entrada en el directorio. |
| ENOTDIR. | Un componente que debía ser directorio no lo es. |
| EROFS. | El sistema de archivos está montado como solo lectura. |
La orden de terminal mkfifo ruta permite crear el mismo tipo de objeto sin escribir C. Usaremos tanto la orden como la función para relacionar el estado del sistema con las llamadas del programa.
4. Permisos, umask y directorio contenedor
Los permisos de lectura permiten abrir el extremo lector; los de escritura, el escritor. El bit de ejecución de la FIFO no la convierte en un programa. En los directorios de la ruta, el permiso de búsqueda permite alcanzar la entrada.
En el caso habitual sin una ACL predeterminada en el directorio, los permisos iniciales resultan de modo & ~umask. Por ejemplo, solicitar 0660 con umask 0027 produce 0640. Las ACL predeterminadas pueden modificar esta regla de creación, como explica umask(2).
$ (umask 027; mkfifo permisos16.fifo)
$ ls -l permisos16.fifo
prw-r----- ... permisos16.fifoLa orden mkfifo sin -m solicita normalmente 0666, que con esa máscara también produce 0640. El subshell entre paréntesis limita el cambio de umask a ese ejemplo. Comprueba el resultado real con ls o stat.
El laboratorio principal solicitará 0600 y usará un directorio privado creado con mktemp -d. El emisor y el receptor deben ejecutarse bajo el mismo usuario; una máscara más restrictiva aún puede retirar permisos solicitados.
El directorio importa tanto como la FIFO: quien puede modificar sus entradas puede retirar o reemplazar el nombre. No soluciones un error de acceso concediendo permisos universales sin definir primero qué procesos deben participar.
5. Decidir qué hacer si la ruta ya existe
Ignorar cualquier EEXIST es un error: la ruta podría señalar a un archivo regular, un directorio o un enlace simbólico. Abrir después un supuesto canal podría terminar leyendo o escribiendo un recurso distinto.
struct stat estado;
if (lstat(ruta, &estado) == -1) {
perror("lstat");
} else if (!S_ISFIFO(estado.st_mode)) {
fprintf(stderr, "La entrada no es una FIFO\n");
}lstat describe la entrada final sin seguirla si es un enlace; fstat describe el recurso que ya se abrió. Sus diferencias se documentan en stat(2).
El creador de este tema rechazará toda ruta existente. El programa de transferencia exigirá una FIFO previamente creada y verificará su tipo antes y después de abrirla. No borrará una entrada ajena para resolver el conflicto.
Comprobar con lstat y abrir después son dos operaciones: otra parte podría cambiar la ruta entre ambas. El programa añade O_NOFOLLOW y compara dispositivo e inode tras abrir, pero eso no vuelve atómica toda la secuencia ni evita cualquier espera sobre un objeto reemplazado. Su entorno de uso es un directorio privado que no modifican otros participantes durante la apertura.
6. Abrir los extremos y esperar al interlocutor
/* Receptor */
int entrada = open(ruta, O_RDONLY);
/* Emisor */
int salida = open(ruta, O_WRONLY);Al abrir para lectura sin escritor disponible, open puede esperar a un escritor. Al abrir para escritura sin lector disponible, espera a un lector. El primer programa puede estar detenido dentro de open, sin haber llegado todavía a read o write. El encuentro no depende de cuál terminal se inició primero.
Cuando ambos extremos se encuentran, cada proceso obtiene su descriptor y puede comenzar la transferencia. La devolución de open no confirma que el otro vaya a seguir conectado ni que haya recibido datos. Las reglas de apertura se describen en fifo(7).
El emisor abre con O_WRONLY, sin O_CREAT ni O_TRUNC. La FIFO ya debe existir; no queremos crear accidentalmente un archivo regular si falta. O_CLOEXEC evita heredar el descriptor si más adelante el programa ejecuta otro binario. Las opciones pertenecen a open(2).
No se utiliza O_RDWR para evitar la espera. Linux permite abrir así una FIFO, pero POSIX no define ese comportamiento; además, el propio proceso sostendría ambos extremos y alteraría la detección de EOF o de ausencia de lectores. El tema 17 estudiará O_NONBLOCK y sus resultados específicos.
7. Laboratorio: preparar una FIFO privada
Este primer programa solo crea el nombre. No lo abre ni lo elimina al terminar, porque los otros programas necesitan encontrarlo después. Rechaza una ruta existente y deja que el propietario del laboratorio decida cuándo retirarla.
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "Uso: %s ruta_fifo\n", argv[0]);
return EXIT_FAILURE;
}
if (mkfifo(argv[1], 0600) == -1) {
perror("mkfifo");
return EXIT_FAILURE;
}
printf("FIFO creada: %s\n", argv[1]);
return EXIT_SUCCESS;
}$ gcc -std=c17 -Wall -Wextra -Wpedantic crear_fifo.c -o crear_fifo
$ directorio=$(mktemp -d "$HOME/fifo16.XXXXXX")
$ canal="$directorio/canal"
$ ./crear_fifo "$canal"
FIFO creada: /home/usuario/fifo16.ABC123/canal
$ ls -l "$canal"
prw------- ... /home/usuario/fifo16.ABC123/canal
$ printf '%s\n' "$canal"
/home/usuario/fifo16.ABC123/canalLa ruta mostrada es ilustrativa: conserva la que imprimió tu equipo. La letra inicial p de ls identifica el tipo FIFO. Una salida de tamaño cero no significa que un emisor no pueda tener bytes pendientes; el tamaño del archivo especial no mide la ocupación del canal.
Usa el sistema de archivos Linux de WSL, como tu directorio personal. Un sistema de archivos montado desde Windows puede no ofrecer las mismas operaciones para archivos especiales.
8. Programa: enviar y recibir desde procesos separados
El siguiente programa tiene dos modos. enviar copia stdin hacia la FIFO; recibir copia la FIFO hacia stdout. Cada invocación es un proceso independiente: no contiene fork ni comparte variables con la otra.
Se transportan bytes sin suponer cadenas ni líneas. El bucle conserva el progreso de escrituras parciales y reintenta EINTR. SIGPIPE se ignora para tratar la desaparición del lector como EPIPE y poder cerrar el descriptor.
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
static int escribir_todo(int fd, const unsigned char *datos, size_t cantidad)
{
size_t enviados = 0;
while (enviados < cantidad) {
ssize_t n = write(fd, datos + enviados, cantidad - enviados);
if (n > 0)
enviados += (size_t)n;
else if (n == -1 && errno == EINTR)
continue;
else {
if (n == 0)
errno = EIO;
return -1;
}
}
return 0;
}
static int copiar(int origen, int destino)
{
unsigned char bloque[4096];
for (;;) {
ssize_t n = read(origen, bloque, sizeof bloque);
if (n > 0) {
if (escribir_todo(destino, bloque, (size_t)n) == -1)
return -1;
} else if (n == 0)
return 0;
else if (errno != EINTR)
return -1;
}
}
static int abrir_fifo(const char *ruta, int modo)
{
struct stat antes, despues;
if (lstat(ruta, &antes) == -1)
return -1;
if (!S_ISFIFO(antes.st_mode)) {
errno = EINVAL;
return -1;
}
int fd;
do {
fd = open(ruta, modo | O_NOFOLLOW | O_CLOEXEC);
} while (fd == -1 && errno == EINTR);
if (fd == -1)
return -1;
int causa = 0;
if (fstat(fd, &despues) == -1)
causa = errno;
else if (!S_ISFIFO(despues.st_mode) || antes.st_dev != despues.st_dev ||
antes.st_ino != despues.st_ino)
causa = EINVAL;
if (causa != 0) {
close(fd);
errno = causa;
return -1;
}
return fd;
}
int main(int argc, char *argv[])
{
if (argc != 3 || (strcmp(argv[1], "enviar") != 0 &&
strcmp(argv[1], "recibir") != 0)) {
fprintf(stderr, "Uso: %s enviar|recibir ruta_fifo\n", argv[0]);
return EXIT_FAILURE;
}
for (int fd = 0; fd <= 2; ++fd) {
if (fcntl(fd, F_GETFD) == -1) {
perror("Se requieren 0, 1 y 2 abiertos");
return EXIT_FAILURE;
}
}
struct sigaction accion = {0};
accion.sa_handler = SIG_IGN;
if (sigemptyset(&accion.sa_mask) == -1 ||
sigaction(SIGPIPE, &accion, NULL) == -1) {
perror("preparar SIGPIPE");
return EXIT_FAILURE;
}
int enviar = strcmp(argv[1], "enviar") == 0;
fprintf(stderr, "%s: abriendo FIFO; puede esperar al otro extremo\n",
enviar ? "Emisor" : "Receptor");
int fd = abrir_fifo(argv[2], enviar ? O_WRONLY : O_RDONLY);
if (fd == -1) {
perror("abrir FIFO (ruta existente y tipo FIFO requeridos)");
return EXIT_FAILURE;
}
fprintf(stderr, "%s: FIFO abierta\n", enviar ? "Emisor" : "Receptor");
int resultado = EXIT_SUCCESS;
if (copiar(enviar ? STDIN_FILENO : fd,
enviar ? fd : STDOUT_FILENO) == -1) {
perror("copiar");
resultado = EXIT_FAILURE;
}
if (close(fd) == -1) {
perror("close FIFO");
resultado = EXIT_FAILURE;
}
return resultado;
}El mensaje «abriendo FIFO» aparece antes de open; «FIFO abierta» confirma que esa llamada terminó. Ambos van a stderr. El receptor devuelve solo el contenido por stdout, lo que permite redirigirlo a un archivo para verificarlo.
La validación del descriptor no cambia los permisos ni crea el nombre. Si falla el acceso, se informa el error y termina. El modo de uso supone que la FIFO permanece estable en el directorio privado durante el encuentro.
9. Ejecutar el intercambio en dos terminales
Compila fifo_transferir y usa la ruta real creada en el paso anterior. Ambos terminales deben ejecutar el binario desde su directorio o mediante una ruta absoluta.
$ gcc -std=c17 -Wall -Wextra -Wpedantic fifo_transferir.c -o fifo_transferir$ ./fifo_transferir recibir "$canal"
Receptor: abriendo FIFO; puede esperar al otro extremo
... espera al emisor ...$ canal='/home/usuario/fifo16.ABC123/canal'
$ printf 'hola desde otro proceso\n' | ./fifo_transferir enviar "$canal"
Emisor: abriendo FIFO; puede esperar al otro extremo
Emisor: FIFO abiertaEn A aparecerá «Receptor: FIFO abierta», seguido del texto recibido. Cuando printf termina, el emisor obtiene EOF de su stdin, cierra su escritor y sale. El receptor consume lo pendiente y obtiene EOF del canal, por lo que también termina.
Repite invirtiendo el orden: inicia primero B y luego A. El emisor puede esperar dentro de open; todavía no ha empezado a copiar desde stdin. Ninguno necesita conocer el PID del otro.
También puedes usar herramientas de terminal sobre la misma FIFO: cat "$canal" en A y printf 'prueba\n' > "$canal" en B. En el segundo caso, la shell realiza la apertura para la redirección antes de ejecutar printf.
10. Probar bytes cero, entrada vacía y datos grandes
Las siguientes pruebas arrancan el receptor en segundo plano desde Bash para facilitar la repetición. Ejecuta cada emisor antes de esperar al receptor: si haces wait demasiado pronto, este podría seguir esperando su apertura complementaria.
$ ./fifo_transferir recibir "$canal" > recibido16.bin &
$ receptor=$!
$ printf 'A\000B\n' | ./fifo_transferir enviar "$canal"
$ wait "$receptor"
$ od -An -t x1 recibido16.bin
41 00 42 0a$ ./fifo_transferir recibir "$canal" > vacio16.bin &
$ receptor=$!
$ ./fifo_transferir enviar "$canal" < /dev/null
$ wait "$receptor"
$ wc -c < vacio16.bin
0La apertura se encuentra con la del receptor aunque no haya contenido. Después, el cierre del único escritor permite EOF. No es lo mismo que no iniciar nunca el emisor: en ese caso el receptor bloqueante puede seguir detenido en open.
$ head -c 1048576 /dev/urandom > origen16.bin
$ ./fifo_transferir recibir "$canal" > destino16.bin &
$ receptor=$!
$ ./fifo_transferir enviar "$canal" < origen16.bin
$ wait "$receptor"
$ cmp origen16.bin destino16.bin
$ echo $?
0Los mensajes de apertura siguen visibles por stderr y no contaminan los archivos. No se exige que el MiB completo quepa en la FIFO: el lector libera espacio mientras el emisor avanza.
Prueba además una ruta inexistente y un archivo regular en lugar del canal. El programa debe rechazar ambos sin crear la ruta ausente ni modificar el archivo regular. Volver a ejecutar crear_fifo sobre la FIFO existente debe informar EEXIST y conservarla.
11. Flujo compartido y límites de mensaje
Una FIFO sigue siendo un flujo de bytes: no conserva fronteras de mensajes para read. Una lectura puede devolver parte de una escritura o agrupar contenido de varias. El orden FIFO no equivale a «una llamada, un mensaje».
Si hay varios lectores sobre el mismo canal, compiten por el contenido; no recibe cada uno una copia. Si hay varios escritores, sus bytes alimentan el mismo flujo. Para difundir mensajes o distinguir clientes se necesita diseñar un protocolo distinto.
La garantía de PIPE_BUF evita que escrituras suficientemente pequeñas se entremezclen con otras, bajo las condiciones estudiadas en el tema 12. No permite asumir que una cabecera y un cuerpo enviados en llamadas separadas forman una unidad atómica.
El programa de transferencia usa un solo escritor y un solo lector. Su bucle escribir_todo conserva progreso, pero no sirve por sí solo como protocolo de registros para varios productores. En el tema 18 se diseñarán peticiones acotadas y canales de respuesta por cliente.
12. close, unlink y vida del canal
| Operación o situación | Qué cambia | Qué no debes suponer |
|---|---|---|
| mkfifo. | Crea una entrada del sistema de archivos. | No devuelve extremos abiertos. |
| open. | Obtiene un descriptor y puede esperar el encuentro. | No crea por sí solo el nombre en nuestro programa. |
| close. | Libera una referencia del proceso. | No elimina el nombre de la FIFO. |
| unlink. | Retira un nombre de la entrada. | No cierra los descriptores que ya estaban abiertos. |
| Todos los extremos cerrados. | Termina la vida del flujo abierto sin conservar su contenido para una sesión posterior. | La entrada puede seguir existiendo y abrirse de nuevo. |
Si retiras el nombre mientras emisor y receptor ya están conectados, pueden continuar por sus descriptores abiertos. Un proceso nuevo no podrá encontrar esa entrada por la ruta retirada. La relación entre nombres y referencias se describe en unlink(2).
Si se vuelve a crear una FIFO bajo la misma ruta antes de cerrar los descriptores antiguos, será un objeto distinto. Los procesos viejos pueden seguir conectados al canal anterior y los nuevos abrir el recién creado. Una cadena de texto igual no garantiza que todos estén usando la misma generación del canal.
Por eso el propietario del laboratorio retira el nombre después de que ambos programas hayan terminado. Los programas de transferencia no ejecutan unlink: cada invocación desconoce si alguien más todavía necesita abrirlo.
$ rm -- "$canal"
$ rmdir -- "$directorio"Ejecuta estos pasos en la terminal que conserva directorio y canal del laboratorio. rmdir exige que el directorio esté vacío. Si los programas terminaron por una señal antes de la limpieza, la FIFO puede quedar presente: no hay eliminación automática por salir de un proceso.
13. Explorar creación, apertura y EOF
Elige qué extremo intenta abrir primero. Avanza por una sesión con un emisor y un receptor. Después del encuentro puedes retirar el nombre para comprobar que eso no equivale a cerrar sus descriptores. El modelo no representa reconexiones, que se estudiarán en el tema 17.
Nombre en el directorioTodavía no existe
ReceptorSin descriptor
EmisorSin descriptor
Bytes pendientes0
Crea la FIFO para comenzar.
Compara «el escritor cerró, pero quedan datos» con «no quedan datos ni escritores». El receptor primero consume lo pendiente y solo después observa EOF. Si el nombre permanece al terminar, eso no significa que los bytes sigan guardados.
14. Diagnosticar rutas, permisos y esperas
$ stat "$canal"
$ strace -o receptor16.log ./fifo_transferir recibir "$canal"
... inicia el emisor desde otra terminal para completar el encuentro ...
$ less receptor16.logBusca la inspección de tipo, la apertura, read y close. Según la biblioteca, open puede aparecer como openat, lstat como newfstatat y mkfifo como mknodat. No confundas una llamada de apertura todavía pendiente con una lectura que ya está esperando datos.
| Síntoma | Qué comprobar |
|---|---|
| El receptor muestra solo «abriendo FIFO». | Falta un escritor que abra el mismo objeto; puede estar esperando en open. |
| El emisor no llega a «FIFO abierta». | No hay apertura lectora complementaria sobre esa FIFO. |
| mkfifo informa EEXIST. | Inspecciona la entrada; no la borres suponiendo que es un residuo propio. |
| open informa EACCES. | Permisos del canal, búsqueda en directorios y usuario efectivo de cada proceso. |
| Un programa informa ENOENT. | Ruta absoluta, variable canal, directorios existentes y posibles unlink. |
| Se rechaza la ruta con EINVAL. | Tipo no FIFO o recurso distinto al inspeccionado antes de open. |
| El receptor no termina después del emisor. | Puede quedar otra referencia escritora abierta en algún proceso. |
| write informa EPIPE. | Desaparecieron todos los lectores; el programa ignora SIGPIPE para tratar el fallo. |
| La ruta existe, pero los procesos no se encuentran. | Podrían ver objetos distintos por recreación del nombre o por sistemas de archivos diferentes. |
Si el canal está abierto, la semántica de lectura y escritura coincide en lo esencial con la de las tuberías anónimas: capacidad finita, contrapresión, EOF y pérdida del lector. Las condiciones del flujo se documentan en pipe(7).
15. Resumen
- Una FIFO permite encontrar una tubería por una ruta, sin heredar sus extremos mediante fork.
- mkfifo crea el nombre; open obtiene el descriptor; read y write transfieren bytes.
- El nombre persiste, pero el contenido del canal no se convierte en un archivo durable.
- Permisos, umask y acceso al directorio determinan quién puede participar.
- EEXIST no demuestra que la entrada sea una FIFO válida ni que pertenezca al programa.
- La apertura bloqueante puede esperar al extremo complementario antes de comenzar la transferencia.
- Los límites de mensaje siguen siendo responsabilidad del protocolo.
- close libera una referencia; unlink retira un nombre y no cierra descriptores ya abiertos.
- Un responsable debe definir la creación, estabilidad y retirada de la ruta.
16. Preguntas de repaso y práctica
Responde antes de desplegar las explicaciones.
1. ¿mkfifo devuelve un descriptor?
No. Retorna cero o −1 y crea una entrada en el sistema de archivos. Para obtener un descriptor se llama a open.
2. ¿Por qué dos procesos independientes pueden usar la misma FIFO?
Porque la abren por una ruta que identifica el mismo objeto visible para ambos y cuyos permisos permiten el acceso. No necesitan heredar los extremos del canal.
3. ¿La FIFO guarda los bytes como un archivo regular?
No. Los datos circulan por el canal del núcleo; la entrada del directorio proporciona un nombre y no almacenamiento durable del contenido.
4. ¿EEXIST permite continuar sin más?
No. La entrada existente puede tener otro tipo o pertenecer a otro uso. El creador del laboratorio la rechaza y no la reemplaza.
5. ¿Qué ocurre si el lector bloqueante se inicia primero?
Puede esperar dentro de open hasta que aparezca un escritor complementario. Todavía no está necesariamente ejecutando read.
6. ¿Por qué el emisor no utiliza O_CREAT?
Porque la FIFO debe haber sido creada previamente. Si faltara y se usara O_CREAT, se podría crear un archivo regular en lugar del canal esperado.
7. ¿Qué permisos deja 0660 con umask 0027 en el caso habitual sin ACL predeterminada?
0640: la máscara retira la escritura del grupo y los permisos de otros. La fórmula es modo & ~umask.
8. ¿Un byte cero termina la recepción?
No. Es contenido y se cuenta en el retorno positivo de read. EOF es el retorno cero de una lectura de tamaño positivo bajo las condiciones del flujo.
9. ¿Dos lectores reciben una copia del mismo contenido?
No. Consumen del flujo compartido. Una FIFO no implementa difusión a cada lector.
10. ¿unlink interrumpe un intercambio ya conectado?
No por sí solo. Retira el nombre, pero las referencias abiertas pueden continuar utilizando el objeto anterior.
11. ¿Recrear el mismo nombre reconecta a los procesos antiguos?
No. Los descriptores antiguos siguen asociados a su objeto; la nueva entrada identifica otra FIFO.
12. ¿Por qué los programas no eliminan el canal automáticamente?
Porque cada transferencia desconoce si otro proceso todavía necesita abrirlo. El propietario del laboratorio realiza la retirada al finalizar el uso.
Para practicar
- Crea la FIFO en un directorio privado y observa su tipo y permisos con ls y stat. Distingue nombre, inode y descriptor.
- Ejecuta el intercambio comenzando por el lector y luego por el escritor. Identifica en qué open espera el primero.
- Transfiere un byte cero, una entrada vacía y un archivo binario grande. Verifica todo el contenido con cmp.
- Prueba crear dos veces la misma ruta y verifica que el objeto original se conserva.
- Pasa un archivo regular y un enlace simbólico al programa de transferencia. Comprueba que los rechaza sin modificar su contenido.
- Compara los permisos creados bajo dos máscaras en un directorio sin ACL predeterminada. Restaura el entorno usando subshells.
- Usa strace para distinguir una apertura pendiente de una lectura pendiente. Inicia el interlocutor desde otra terminal.
- Dibuja qué ocurre al retirar el nombre durante una conexión y recrearlo antes de cerrar los extremos antiguos.
El tema 17 estudiará el bloqueo y la E/S no bloqueante en FIFO: O_NONBLOCK, ENXIO, EAGAIN, EOF y la reconexión de lectores y escritores.