Comment attendre jusqu'à ce que les données sont écrites sur l'autre extrémité de la pipe

Votre tuyau est ouvert en mode de blocage, et vous ne faites rien pour changer les choses, ce qui est probablement ce que vous souhaitiez.

Cependant, depuis la première chose à faire est de demander à la taille des données en attente sur le tuyau, puis aveuglément sauter dans la lecture de ce nombre d'octets (qui selon toute probabilité sera nul à la fois que le code est exécuté depuis le parent n'a pas écrit quoi que ce soit encore), vous n'avez pas de bloc, et, au lieu de laisser juste parce que vous avez demandé rien.

Il y a un certain nombre de façons de le faire, y compris une sélection de boucle. Si vous préférez bloc sur une lecture jusqu'à ce que les données sont disponibles, alors faites-le sur un seul octet et remplir le reste des données par la suite.

Ce n'est pas un exemple de comment faire cela droit, mais c'est un court exemple de la façon dont vous pouvez attendre sur un seul octet, demande la lecture de la taille de la pipe pour obtenir le reste des données, à le lire, et continuer jusqu'à ce que le tuyau n'a pas de données à gauche et le parent s'arrête à leur fin:

J'espère que vous le trouverez utile.

#include <stdio.h>
#include <unistd.h>
#include <sys/ioctl.h>
int main()
{
int pid = 0;
//create pipe pair
int fd[2];
pipe(fd);
pid = fork();
if (pid == 0)
{
//child side
char *buff = NULL;
char byte = 0;
int count = 0;
//close write side. don't need it.
close(fd[1]);
//read at least one byte from the pipe.
while (read(fd[0], &byte, 1) == 1)
{
if (ioctl(fd[0], FIONREAD, &count) != -1)
{
fprintf(stdout,"Child: count = %d\n",count);
//allocate space for the byte we just read + the rest
// of whatever is on the pipe.
buff = malloc(count+1);
buff[0] = byte;
if (read(fd[0], buff+1, count) == count)
fprintf(stdout,"Child: received \"%s\"\n", buff);
free(buff);
}
else
{   //could not read in-size
perror("Failed to read input size.");
}
}
//close our side
close(fd[0]);
fprintf(stdout,"Child: Shutting down.\n");
}
else
{   //close read size. don't need it.
const char msg1[] = "Message From Parent";
const char msg2[] = "Another Message From Parent";
close(fd[0]);
sleep(5); //simulate process wait
fprintf(stdout, "Parent: sending \"%s\"\n", msg1);
write(fd[1], msg1, sizeof(msg1));
sleep(5); //simulate process wait
fprintf(stdout, "Parent: sending \"%s\"\n", msg2);
write(fd[1], msg2, sizeof(msg2));
close(fd[1]);
fprintf(stdout,"Parent: Shutting down.\n");
}
return 0;
}

---

Sortie

Parent: sending "Message From Parent"
Child: count = 19
Child: received "Message From Parent"
Parent: sending "Another Message From Parent"
Parent: Shutting down.
Child: count = 27
Child: received "Another Message From Parent"
Child: Shutting down.

OriginalL'auteur WhozCraig

Le problème est avec obtenir le nombre d'octets écrits dans le tuyau. Vous obtenez juste après le fork(). Si le processus de lecture est exécutée en premier lieu, il ne contiendra pas de données (et le nombre sera égal à zéro). Si le processus d'écriture d'exécuter tout d'abord, il va contenir des données.

Comment rendre l'enfant à attendre jusqu'à ce que des données sont écrites à l'autre bout?

Depuis l'ouverture du tuyau dans le blocage de la mode, vous devriez lire autant de données que possible, et de ne pas essayer d'obtenir la taille des données écrites.

---

Ici est votre modifiés exemple qui attend un message complet :

#include <stdio.h>
#include <sys/ioctl.h>
int main()
{
int pid;
FILE *fp;
fp = fopen("test.txt","w");
char *buff = malloc(1024);
int fd[2];
int count = 0 ;
pipe(fd);
pid = fork();
if(pid == 0)
{
close(fd[1]);
int i = 0;
while ( i < 10 )
{
fprintf(fp,"\n TIME before read: %s \n",__TIME__);
read(fd[0], buff+i, 1);
++ i;
}
fprintf(fp,"Full message received!\nbuffer: %s\n TIME after read %s\n", buff, __TIME__);
}
else{
close(fd[0]);
sleep(10);    //delay caused by application specific code replaced with sleep
write(fd[1],"THIS is it",10);
}
fclose(fp);
return 0;
}

OriginalL'auteur BЈовић