Linux - pipes

Hola,

tengo una duda sobre el uso del mecanismo Ipc PIPES, en concreto mi problema es que me estoy basando en unos apuntes que dicen: "Para que un proceso del pipe detecte el fin de fichero (EOF) todos los flujos de escritura(los dos, el del padre y el del hijo) en el pipe han de estar cerrados", y he consultado alguna pagina y dice que si que tienen que esetar cerrados los descriptores de escritura.

Pero lo he probado y con cerrar el flujo de escritura del padre me es suficiente.
Por ejemplo tengo este programa:

#include <unistd.h>
void main(void)
{
int fds[2];
pipe(fds);

if (fork() == 0) {
dup2(fds[0], 0);
close(fds[1]);
execlp("sort", "sort", 0);
}
else if ( fork() == 0) {
dup2(fds[1], 1);
close(fds[0]);
execlp("who", "who", 0);
}

else {
close(fds[0]);
close(fds[1]);
wait(0);
wait(0);
}
}

En este caso solo se me queda bloqueado si no hago close(fds[1]), porque vale no le llega el EOF al proceso que esta leyendo, pero si cierro el fds[1] en el padre y en el primer hijo no hago close(fds[1]) da lo mismo, el programa se ejecuta correctamente y supuestamente si no cierro el fds[1] del primer hijo el segundo hijo ya no deberia detectar el fin de fichero.

¿Alguien me puede explicar esto?

Muchas gracias,
Saludos

Mírate la documentación de fork()

Los descriptores de fichero que heredan los procesos hijo son exactamente los mismos que tuviera el padre.

O sea, si cierras un fd en el padre, lo estás cerrando para los hijos.

"
* The child inherits copies of the parent’s set of open message queue descriptors (see mq_overview(7)). Each
descriptor in the child refers to the same open message queue description as the corresponding descriptor in
the parent. This means that the two descriptors share the same flags (mq_flags).
"

hola,

gracias por tu respuesta.

Si estoy deacuerdo en que heredan los descriptores de fichero pero en caso del pipe, luego los tratan independientemente. Ya que en ocasiones se cierra primero el descriptor de entrada del padre y el hijo continua leyendo del pipe, porque el proceso hijo del que esta leyendo continua enviando datos.
Con lo que si se cerrara cuando se cierra el padre, no enviaría más datos. ¿o si?

Muchas gracias,

saludos

Vaya, te puse una cita que no era. Esto es lo que quise copiar:

" * The child inherits copies of the parent’s set of open file descriptors. Each file descriptor in the child
refers to the same open file description (see open(2)) as the corresponding file descriptor in the parent.
This means that the two descriptors share open file status flags, current file offset, and signal-driven I/O
attributes (see the description of F_SETOWN and F_SETSIG in fcntl(2)).

"

Esto viene a decir lo mismo. Que si cierras el descriptor en el proceso padre, lo cierras también en el hijo. Otra cosa sería que tú crearas nuevos descriptores, o los crees con dup (o similar); en este caso, podrías mantener uno abierto y otro cerrado.

De todos modos, tendría que probarlo. Quizás lo que el proceso hijo lee incluso después de haber cerrado el fd en el padre ya estuviera previamente en el buffer ...

Y, me parece que en tu código utilizas dup2(). Esto podría explicar que se mantengan "flags" distintos para el fd del padre y del hijo.

Muchas gracias Tom,

Si, en mi programa utilizo dup2. Y quizá sea a eso a lo que se refiere en mis apuntes, a pesar de que en mi programa de ejemplo si cierro el descritor de escritura del proceso sort, el programa siga funcionando correctamente, en otros casos puede darse que se quede colgado supongo.

Gracias de nuevo,

saludos