Discussion :

[lea.soineca]

Bonjour,

J'ai une très longue chaîne de caractère qui a plus de 200 000 caractères, appelée char * msgInChar;.

Lorsque j'écris cette chaîne dans un pipe (nommé pfdchildparent), mon code bloque au niveau de l'écriture :

Code :

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

write(pfdchildparent[1], msgInChar, sizeof(char) * (unsigned) strlen(msgInChar));

Mais, lorsque je limite la taille de l'écriture de ma chaîne dans le pipe, cela fonctionne. J'écris cela :

Code :

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

write(pfdchildparent[1], msgInChar, sizeof(char) * 65000);

Mais, malheureusement, je n'ai que les 65 000 premiers caractères, et j'aimerai pouvoir envoyer ma chaîne en entière. Je pense que le pipe peut recevoir un certain nombre de caractère au maximum.

Comment est ce que je peux faire pour que la chaine soit écrite en entière?

[schonai]

Bonjour,
Les pipes ont en effet une taille limitée à 64KB. Tu peux donc écrire 65536 caractères au maximum.
Mais tu peux heureusement augmenter cette limite grace à la foncrtion fcntl. Cette fonction sert à configurer tout et n'importe quoi en rapport avec les descripteurs de fichier et notamment les pipes. Tu devrait trouver ton bonheur avec l'option F_SETPIPE_SZ.

Tu peux aussi faire une boucle avec un buffer de taille fixe et écrire ta chaîne en plusieurs fois.

Bon courage!

[neuneutrinos]

ce que tu peux faire c'est envoyer les données par bloc en utilisant le retour de write

write retourne le nombre de caractère effectivement écrit dans le fichier et -1 en cas d'erreur.

pour connaitre l'erreur d'un appel Système par exemple
http://manpagesfr.free.fr/man/man3/errno.3.html
<errno.h> te permettra d'obtenir les réponses

exemple codé à l'arraché pour faire avec une taille "quelconque"

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
 
#define TAILLE_BLOC 255
 
//....
 
//strlen est une fonction qui CALCULE donc autant stocker le résultat pour éviter de le recalculer à chaque fois
unsigned int cpt=(unsigned) strlen(msgInChar);//ici (mettre +1 pour envoyer également le caractère '\0'
unsigned int n;//nombre de caractère écrits
do
{
 n=write(pfdchildparent[1], msgInChar, TAILLE_BLOC);
 if(n==-1)break;//erreur
 cpt-=n;//si il n'y a pas d'erreur cpt devrait valoir 0 à la fin de a boucle
 msgInChar+=n;//on décale la lecture de n dans le tableau
}
while(n==TAILLE_BLOC);//tant qu'on lit 1 bloc en entier
//ou bien aussi while(cpt);c'est mieux mais c'est moins clair à expliquer (enfin je crois)

[lea.soineca]

Merci pour vos réponses.

Alors j'ai testé la solution avec fcntl, mais à la compilation il y a une erreur :

Code :

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

error: 'F_SETPIPE_SZ' undeclared (first use in this function)

Voici mon code :

Code :

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

1
2
3
4
5
 
#include <unistd.h>
#include <fcntl.h>
int flags = fcntl(pfdchildparent[1], F_SETPIPE_SZ, sizeMsg+1);
write(pfdchildparent[1], msgInChar, sizeof(char) * (sizeMsg+1));

Mon Linux est : Kernel Linux 3.2.0-55-generic

[schonai]

Bonjour,
En fête cette constante est spécifique à linux. Tu dois le spécifier avant d'inclure le header de fcntl en ajoutant

Code :

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

#define _GNU_SOURCE

Par contre tu perds la portabilité...
Je pense que la solution de neuneutrinos est plus élégante et sécurisée que ce que tu essayes de faire même si c'est toujours intéressant de savoir le faire.

[lea.soineca]

Ok je vais essayer la technique pour écrire bloc par bloc.

Par contre, j'ai une autre question. Pour la lecture, il y a t-il aussi une limitation sur le pipe?

Car lorsque je lis comme cela :

Code :

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

1
2
3
4
5
6
7
 
char msgTurn[300000];
char buffer[300000];
while (read(pfdchildparent[0], buffer, sizeof(char) * 300000) > 0)
{
	strcat(msgTurn, buffer);
}

Seule les 65536 premiers caractères sont lu.

[schonai]

Dans ton sens oui.
Il n'y a pas vraiment de notion de limitation de taille en lecture ou en écriture. Comme tout sur linux, le pipe est un fichier au même titre que toto.txt, il a juste des propriétés supplémentaires. La limitation de taille, c'est la limitation de la taille du fichier qui représente ton pipe. Donc read lit en réalité le pipe tout entier.