Discussion :

[Guillaume1701]

Bonjour à tous,

J'ai un comportement des "named pipe" que je ne comprends pas.
Pour cela j'ai fait un petit bout de code sans gestion des erreurs qui est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int main()
{
	readNamedFifo("myFifo");
	return 0;
}
 
int32_t readNamedFifo(const std::string &path)
{
	int32_t fdFifo = open(path.c_str(), O_RDONLY | O_NONBLOCK);
 
	if (fdFifo >=0)
	{
		char buff[1024]
		int32_t buf_count = read(fdFifo, buff, 4096);
		if (buf_count < 0 && errno != EAGAIN)
		{
			// Une erreur
		}
		else if (buf_count == 0)
		{
			// La fifo est vide
		}
		else
		{
			// Lecture OK
		}
	}
}

Test :

• Dans terminal1 : mkfifo myFifo
• Dans terminal2 : je lance mon bout de code et j'ai une fifo vide
• Dans terminal1 : echo "Test" > myFifo (je n'ai plus la main)
• Dans terminal2 : je lance mon bout de code et buf_count vaut -1 et errno vaut EAGAIN
• Dans terminal1 : j'ai de nouveau la main

Mon problème vient du "O_NONBLOCK" je pense.

Dans mon cas je veux au final que mon programme surveille une fifo. Lors du démarrage, si cette dernière n'est pas vide, il la lit et puis la surveille.

Je ne sais pas si je suis clair.

Merci d'avance pour vos réponses.

[Bousk]

- tu espères lire jusque 4096o dans un buffer qui en compte 1024
- si tu es non bloquant il faudrait aussi vérifier EWOULDBLOCK imo, la valeur est pas forcément identique
- ton cas lecture ok recouvre aussi si tu n'as rien à lire et retourne EAGAIN
- pour surveiller il faudrait au moins avoir une boucle pour ça

[Sve@r]

Bonjour

Moi j'ai un petit doute (mes années C-système sont super loin) sur le mode "O_NONBLOCK" appliqué sur un fifo qui est, par essence, bloquant.

Personnellement, j'utiliserais justement le fait qu'un fifo soit bloquant pour bloquer mon programme et ne pas me prendre la tête avec les EAGAIN et consort.
Ainsi dès que le programme rend la main c'est que le fifo a eu un truc...

Et euh ici on est en C, pas en C++

[Guillaume1701]

- tu espères lire jusque 4096o dans un buffer qui en compte 1024

Effectivement, je me suis trompé en recopiant le code. C'est bien une taille de 1024.

- si tu es non bloquant il faudrait aussi vérifier EWOULDBLOCK imo, la valeur est pas forcément identique

Je n'avais pas connaissance de cela, merci de la remarque

- pour surveiller il faudrait au moins avoir une boucle pour ça

Le bout de code que j'ai posté ne sert que d'exemple au problème et n'est pas à l'image du code finale qui lui possède bien une boucle pour scruter.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
int main()
{
	readNamedFifo("myFifo");
	return 0;
}
 
int32_t readNamedFifo(const std::string &path)
{
	int32_t fdFifo = open(path.c_str(), O_RDONLY | O_NONBLOCK);
 
	if (fdFifo >=0)
	{
		char buff[1024]
		int32_t buf_count = read(fdFifo, buff, 4096);
		if (buf_count < 0 && errno != EAGAIN && errno != EWOULDBLOCK)
		{
			// Une erreur
		}
		else if (buf_count == 0)
		{
			// La fifo est vide
		}
                else if (buf_count > 0)
                {
                        // Lecture OK
                }
		else
		{
			// Une autre erreur
		}
	}
}