Las PIPE en principio solo sirven para comunicaciones padre
– hijo, por lo que para comunicarnos entre procesos independientes necesitamos
otro tipo estructura.
Esta son los FIFO, archivos que ya no se crean en el proceso
padre, sino que lo genera el sistema operativo. Es un ente que genera el SO y
que podrá ser utilizado por diversos procesos estén o no emparentados.
Es decir, los mecanismos de comunicación no tienen que estar
necesariamente emparentados.
Se llama FIFO porque es una cola (first in, first out).
Para operar con ellos en C usaremos comandos de ficheros de
bajo nivel (write, open…)
El comando que permite crear una FIFO se mknod, al igual que la función de C que
permite generarlas en ese lenguaje.
En Linux, el comando para generar un FIFO sigue esta
estructura:
mknod [opciones]
nombreFichero p
Con el parámetro mode indicamos
los permisos que tendrá nuestro FIFO.
Una vez generado podemos comprobarlos haciendo un ls-l
Hecho esto, y sabiendo que
funciona como una pila, podemos meterle información para que lo vaya leyendo
otro proceso que acceda al FIFO.
Vamos a introducirle el contenido
de visualizar los directorios, con un ls,
para luego visualizar por pantalla su contenido con un cat.
En C podemos programar nuestros procesos para que mientras
uno crea y está a la escucha para leer el FIFO, otro introduzca información en
él y sea leído por el primero.
Para ello usaremos la función mknod (tiene el mismo nombre que el comando usado para generar el
fichero).
La función mknod tiene
la siguiente estructura:
int mknod (const char
*pathname, mode_t modo, dev_t dev);
Donde:
- Pathname: Nombre del dispositivo
- Modo: Especifica tanto los permisos de uso como el tipo de nodo que se creará
- Dev: Debe ser una combinación (utilizando OR bit a bit) de uno de los tipos de fichero que se enumeran a continuación.
- S_IFREG
- S_IFCHR
- S_IFBLK
- S_IFIFO – Para crear un FIFO
El código para la creación y lectura de un FIFO es el
siguiente
#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int main(void){ int fp; int p, bytesLeidos; char saludo[] = "Un saludo!!!\n", buffer[10]; p = mknod("FIFO3", S_IFIFO|0666, 0); // Permiso de lectura y escritura if (p == -1){ printf("Ha ocurrido un error \n"); exit(0); } while(1){ fp = open("FIFO3", 0); bytesLeidos = read(fp, buffer, 1); printf("Obteniendo información... \n"); while(bytesLeidos != 0){ printf("%s", buffer); bytesLeidos = read(fp, buffer, 1); // lee otro byte } close(fp); } return 0; }
Y el programa para escribir en el FIFO:
#include <stdio.h> #include <stdlib.h> #include <string.h> int main(){ int fp; char saludo[] = "Un saludo!!!\n"; fp = open("FIFO3", 1); // Abre el fichero FIFO ya creado if(fp == -1){ printf("Error al abrir el fichero...\n"); exit(1); } printf("Mandando información al FIFO...\n"); write(fp, saludo, strlen(saludo)); // Manda al FIFO fp la cadena de texto saludo con los caracteres contados por strlen close(fp); return 0; }
Para comprobar el funcionamiento compilamos y ejecutamos
primero el programa para la lectura (es el que crea el FIFO) y se mantiene a la
espera.
Mientras, abrimos otra terminal y lanzamos el programa para
escribir en el FIFO.
Podremos ver el desarrollo en tiempo real, siendo algo tal
que así
Al mostrar el texto por pantalla
lo vemos de esta forma porque uno trabaja en ASCII y otro en UNICODE, pero para
hacernos una idea de que se comunican correctamente sirve.
0 comentarios:
Publicar un comentario