Crear una cola FIFO en lenguaje C

Las colas (queue) son estructuras de datos abstractas en informática que siguen el principio FIFO (First In, First Out), es decir, el primer elemento en entrar es el primero en salir. Se pueden comparar con una fila en la vida real, donde las personas se atienden en el orden en que llegaron. Vamos al grano a crear una cola FIFO en lenguaje C en LInux.

Esta actividad es meramente conceptual, didáctica, en la que mostramos el funcionamiento de una cola FIFO. Se trata de cuatro archivos: dos programas escritos en C, un archivo de texto llamado estado.txt y un archivo especial llamado “mi_fifo”.

Cola FIFO en lenguaje C en Linux

El primer programa lee el contenido de “estado.txt” y transfiere lo que lee al segundo programa por medio del archivo especial mi_fifo. Finalmente el programa 2 nos muestra en pantalla lo que recibe del FIFO.

programa_1.c (Programa 1)

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/stat.h>
#include <signal.h>

#define ARCHIVO "estado.txt"
#define FIFO "mi_fifo"

void handle_sigpipe(int sig) {
    fprintf(stderr, "Señal SIGPIPE recibida. La tubería puede haber sido cerrada.\n");
    // No exit aquí para que el proceso pueda seguir intentando o reiniciar
}

int main() {
    char estado;
    int archivo_fd, fifo_fd;

    // Establecer el manejador de la señal SIGPIPE
    signal(SIGPIPE, handle_sigpipe);

    // Crear la tubería de nombre (FIFO) si no existe
    if (mkfifo(FIFO, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo");
        exit(EXIT_FAILURE);
    }

    // Abrir el archivo para lectura
    archivo_fd = open(ARCHIVO, O_RDONLY);
    if (archivo_fd < 0) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // Abrir el FIFO para lectura y escritura
    fifo_fd = open(FIFO, O_RDWR);
    if (fifo_fd < 0) {
        perror("open FIFO");
        close(archivo_fd);
        exit(EXIT_FAILURE);
    }

    while (1) {
    // Leer el estado del archivo
        ssize_t bytes_read = read(archivo_fd, &estado, 1);
        if (bytes_read != 1) {
            if (bytes_read < 0) {
                perror("read");
            }
        close(archivo_fd);
        close(fifo_fd);
        exit(EXIT_FAILURE);
    }

    // Intentar escribir el estado en la tubería de nombre
    ssize_t bytes_written = write(fifo_fd, &estado, 1);
    if (bytes_written != 1) {
        if (errno == EAGAIN) {
        // FIFO está lleno o el lector no está disponible, puedes manejarlo aquí
            fprintf(stderr, "FIFO está lleno o el lector no está disponible\n");
            sleep(1); // Esperar un momento antes de intentar de nuevo
        } else {
            perror("write FIFO");
            close(archivo_fd);
            close(fifo_fd);
            exit(EXIT_FAILURE);
        }
    }

    // Posicionar el puntero del archivo al inicio (si es necesario)
    lseek(archivo_fd, 0, SEEK_SET);

    // Esperar un poco antes de volver a leer (opcional)
    sleep(1); // Ajusta el tiempo de espera según tus necesidades
}

// Cerrar los descriptores
close(archivo_fd);
close(fifo_fd);

return 0;
}

programa_2.c (Programa 2)

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

int main() {

    charestado;
    // Leer del pipe (que ahora es la entrada estándar)
    while (1) {
        ssize_tbytes_read=read(STDIN_FILENO, &estado, 1);
        if (bytes_read!=1) {
            if (bytes_read<0) {
                perror("read");
            }

            exit(EXIT_FAILURE);
        }

    // Mostrar el estado recibido
        printf("El estado recibido es: %c\n", estado);
    }

return0;

}

mkfifo mi_fifo