récupèrer stdin venant d'un pipe

Version imprimable

08/06/2007, 13h18
julien.63

récupèrer stdin venant d'un pipe
Salut,
j'ai écrit un programme qui prend comme option le nom d'un fichier.
Mais je voudrais faire en sorte que ce fichier puisse être fourni par le flux d'entrée standard de manière à pouvoir piper les programmes.

Mais à vrai dire je ne sais pas trop comment m'y prendre pour teste que stdin vient bien de la sortie d'un programme et non pas de mon clavier?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char ch[1024]; while( fgets(ch, 1000, stdin) ) { printf("%s\n", ch); } return 0; }
merci de vos conseils.
08/06/2007, 15h50
souviron34

ben ya rien à faire..

Puisque tu as mis un fgets avec stdin c'est toto-matique ;)

si ton programme s'appelle toto, quand tu feras par exemple

Code:

cat fichier | toto

toto prendra automatiquement son input de la sortie de "cat fichier".

Et de l'intérieur du programme il n'y a rien à faire pour tester. C'est l'avantage de stdin.

Par contre, si vraiment tu veux vérifier, alors il faudrait de l'intérieur du programme ouvrir ton fichier et comparer les lignes.. Mais je ne crois pas que ce soit ça que tu veux....
08/06/2007, 16h12
julien.63

En fait, voilà ce que je souhaitais faire :

tester si l'option -d a été fournie
si non regarder dans stdin si y'a quelque chose
si non message d'erreur et exit

peut être n'ai-je pas la bonne logique?
08/06/2007, 16h32
souviron34

réfléchis calmement à ton pbe.. ;)

Expose-le réellement, pas la solution que tu viens d'exposer, mais le problème..
11/06/2007, 10h06
julien.63

mon problème, comme je disais dans mon premier post, c'est que je ne vois pas comment faire de test sur stdin pour être sûr qu'il ne s'agit pas du clavier mais bien de la sortie standard d'un autre programme "pipé".

Voici plus en détails, ce que je fais et ce que je voudrais faire.
je travaille sur deux petits outils qui peuvent être utilisés independamment ou les uns à la suite des autres en pipe.
le premier génére des lignes de texte en sortie standard.
le second traite ce texte. Ce dernier a une option -d si la sortie standard du premier a été redirigé vers un fichier. Si l'option -d n'est pas renseigné, les données sont censées venir par l'entrée standard (via un pipe). C'est là que je coinçe : si mon utilisateur ne renseigne pas -d et ne fait pas de pipe.
11/06/2007, 10h45
Médinoc

Sous POSIX: isatty(), ou fstat().
Ces fonctions sont supportées par la C Run-Time Library (CRT) de Microsoft, donc elles marchent sous Windows (sous les noms _isatty() et _fstat()).
11/06/2007, 15h06
souviron34
Citation:

Envoyé par julien.63

mon problème, comme je disais dans mon premier post, c'est que je ne vois pas comment faire de test sur stdin pour être sûr qu'il ne s'agit pas du clavier mais bien de la sortie standard d'un autre programme "pipé".

Voici plus en détails, ce que je fais et ce que je voudrais faire.
je travaille sur deux petits outils qui peuvent être utilisés independamment ou les uns à la suite des autres en pipe.
le premier génére des lignes de texte en sortie standard.
le second traite ce texte. Ce dernier a une option -d si la sortie standard du premier a été redirigé vers un fichier. Si l'option -d n'est pas renseigné, les données sont censées venir par l'entrée standard (via un pipe). C'est là que je coinçe : si mon utilisateur ne renseigne pas -d et ne fait pas de pipe.

Je ne comprend pas :

ton entrée du 2ième est TOUJOURS stdin.

La seule chose que tu as à tester, c'est si tu as un fichier de commandes. Auquel cas tu ne poses pas de questions. Et l'entrée se fera toujours par stdin...

D'autre part, ce pourquoi tu te "mords la queue", c'est que ça n'est pas standard de traiter comme ça...

La manière standard sous *n*x est celle-ci :
1. Par défaut, tu mets un file descriptor comme variable dans ton programme.
2. Avant d'explorer les options, tu l'affectes à stdin. ça prendra un pipe, un "<", ou des entrées manuelles.
3. Si dans les options tu as -f, l'entrée viendra d'un fichier dont le nom suit l'option, et dans ce cas-là tu affectes le file descriptor au fichier.
mais stdin est STANDARD....

et ça n'est pas juste pour le pipe.... comme je disais tu pourrais faire "mon prog < fichier_réponses" et pour stdin c'est pareil, comme "cat fichier_reponses | monprog" ...

C'est pour ça que je te disais qu'il y avait un problème de conception...

Note : et si il y a des questions à poser, les poser dans tous les cas de figure SAUF si l'option -f est présente...

merci pour ces indications, voici où j'en suis. Le code ci-dessous n'est sans doute pas optimal mais il semble fonctionner.

Code:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <stdlib.h>
#include <sys/stat.h>
 
int main(int argc, char **argv)
{
	char 	ch[1024];
	FILE 	*file = NULL;
	struct 	stat buf;
	int 	file_desc = -1;
	char	*database = NULL;
 
	if (fstat(fileno(stdin),&buf) == 0){
		if ( (buf.st_dev) == 0)
		{
			file_desc = fileno(stdin);
		}
	}
 
	if (argc == 2)
	{	
		if (getopt (argc, argv, "d:") != -1){
			database = strdup(optarg);
			if ( (file = fopen(database, "r")) != NULL){
		    	      file_desc = fileno(file);
			}
		}
	}
 
	if (file_desc == -1){
		exit(0);
	}
 
	if( (file = fdopen(file_desc,"r")) == NULL)
		exit(0);
 
	while( fgets(ch, 1000, file) )  
	{  
		printf("**%s\n", ch); 
	} 
 
	return 0; 
}

mmmm faire un fopen sur stdin...

moi je ferais :

Code:

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
33
34
35
36
37
38
 
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
 
int main(int argc, char **argv)
{
   char 	ch[1024];
   FILE 	*file = stdin ;
 
    if (argc > 1)
      {
         if (getopt (argc, argv, "d:") != -1 )
          {
            if ( (file = fopen(optarg, "r")) == NULL)
              {
                  fprintf ( stderr, "\n Erreur : peux pas ouvrir le fichier\n");
                  return ( EXIT_FAILURE);
              }
          }
       else
         {
            fprintf ( stderr, "\nMauvaise option..\n");
            return EXIT_FAILURE ;
         }
     }
 
    while( fgets(ch, 1000, file) != NULL )  
      {  
          printf("**%s\n", ch); 
      } 
 
   if ( file != stdin )
      fclose(file);
 
    return 0; 
}

11/06/2007, 17h43
souviron34

et d'ailleurs je rajouterais que sous systèmes unixoide il y a des conventions d'écriture pour les options.

Un fichier peut être associé à -f filename ou -in filename

(comme -v pour verbose)

J'ai bien tenu compte de tes conseils. Mais j'ai apporté une petite modification quand même pour prévoir le cas où l'utilisateur ne renseigne pas l'option -f (j'ai changé ça aussi ;-) ) ne ferait pas de pipe.

Code:

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
33
34
35
36
37
38
39
 
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <stdlib.h>
#include <sys/stat.h>
 
int main(int argc, char **argv)
{
	char 	ch[1024];
	FILE 	*file = NULL;
	struct 	stat buf;	
 
	if (fstat(fileno(stdin),&buf) == 0)
		if ( (buf.st_dev) == 0)
			file = stdin;
 
	if (argc == 2)
	{	
		if (getopt (argc, argv, "f:") != -1){
			if ( (file = fopen(optarg, "r")) == NULL)
			{
			     printf("#cannot open file %s",optarg);
			     exit(0);
			}
		}
	}
 
        if(!file)
		exit(0);
 
	while( fgets(ch, 1000, file) )  
	{  
		printf("**%s\n", ch); 
	} 
 
	return 0; 
}

12/06/2007, 15h39
souviron34
je m'excuse de me répéter, mais :

TU N'AS PAS TENU COMPTE DE GRAND CHOSE.....
1. Pas de test correct dans la lecture de la ligne (ce n'est pas ton while qui marchera)
2. Ton test sur les options ne marchera pas (si tu fais -f toto ça fera 3 arguments et non pas 2... ) D'où ce que j'avais mis : > 2.
3. Ce n'est pas correct de faire des trucs comme ça sur stdin. Pourquoi encore veux-tu tester si l'utilisateur n'a pas fait de pipe ou de redirection de l'input ?? Je veux bien que tu veuilles sortir si il n'y a pas de lignes entrées, mais alors ta simple boucle de lecture suffira.... Si elle correctement codée.
  Et d'ailleurs tes tests tels quels marcheront toujours, puisque tu auras tapé la commande. Il y aura quelque chose sur stdin..

Hello,
Citation:
Envoyé par julien.63
J'ai bien tenu de tes conseils. Mais j'ai apporté une petite modification quand même pour prévoir le cas où l'utilisateur ne renseigne pas l'option -f (j'ai changé ça aussi ;-) ) ne ferait pas de pipe.
Code:

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 33 34 35 36 37 38 39 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <getopt.h> #include <stdlib.h> #include <sys/stat.h> int main(int argc, char **argv) { char ch[1024]; FILE *file = NULL; struct stat buf; if (fstat(fileno(stdin),&buf) == 0) if ( (buf.st_dev) == 0) file = stdin; if (argc == 2) { if (getopt (argc, argv, "f:") != -1){ if ( (file = fopen(optarg, "r")) == NULL) { printf("#cannot open file %s",optarg); exit(0); } } } if(!file) exit(0); while( fgets(ch, 1000, file) ) { printf("**%s\n", ch); } return 0; }
Quelques remarques sur le code :
- le stat() ne sert à rien, pareil pour le fopen() (peut etre un comportement indéfini d'ailleurs, à voir, normalement, un flux ouvert se ferme et se réouvre (freopen())). stdin est standard et est le flux d'entrée associé à tout processus. Dans le modèle Unix/Posix, tout processus peut se représenter comme une boîte noîte auquelle est connectée un flux d'entrée (stdin), un flux de sortie général (stdout) et un flux d'erreur (stderr). On retrouve ces 3 flux de façon standard dans le langage C comme étant 3 FILE* automatiquement ouverts au début d'un programme. Donc il suffit de lire stdin (déjà ouvert) dans le cas d'un tube si on récupère le stdout d'un autre programme.
- En cas d'erreur (ouverture de fichier), mieux vaut écrire sur le flux d'erreur stderr avec fprintf() et sortir du programme en utilisant la constante EXIT_FAILURE (valeur différente de 0) présente dans stdlib.h.

Pour ton pb de récupérer stdin, il suffit de regarder ne serait-ce que les premiers exemples du K&R.

Exple avec récup sortie standard de commande echo :
Citation:
[foobar1329@dreuz ~]$ cat main.c
Code:

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 33 34 #include <stdlib.h> #include <stdio.h> #include <ctype.h> #include <string.h> int main(int argc, char ** argv) { int c = EOF, sep = EOF; if (argc != 1 && argc != 2) { fprintf(stderr, "bad number of args! :-(\n"); exit(EXIT_FAILURE); } else if (argc == 2 && strlen(argv[1]) > 1u) { fprintf(stderr, "I just need a character as first arg, not a string, I take the first character! :-(\n"); sep = *argv[1]; } else if (argc == 2) { sep = *argv[1]; } while ((c = getchar()) != EOF) { if (isspace(c) && sep != EOF) { putchar(sep); } else { putchar(c); } } putchar('\n'); return 0; }
[foobar1329@dreuz ~]$ gcc -Wall -pedantic -std=c89 main.c -o gerard
[foobar1329@dreuz ~]$ echo "Bernard et Roger sont encore a la machine a café" | ./gerard
Bernard et Roger sont encore a la machine a café

[foobar1329@dreuz ~]$ echo "Bernard et Roger sont encore a la machine a café" | ./gerard \;
Bernard;et;Roger;sont;encore;a;la;machine;a;café;
A+

13/06/2007, 09h52
julien.63
souviron34 a écrit:

Citation:

je m'excuse de me répéter

et moi de te faire répéter ;)

J'ai donc rajouter un test sur la lecture. Et concernant les options, il ne s'agit que d'un code très simplifié pour régler mon souci. Mon programme comporte en fait 7 options qui sont récupérées et testées de manière plus orthodoxe.

Le code posté par souviron34 (http://developpez.net/forums/showpos...41&postcount=9) est parfait au détail prés que si l'utilisateur ne renseigne pas l'option -f et ne pipe pas alors on branche le sdtin (le clavier) sur sdtout (l'écran) et le programme ne fait qu'afficher ce que tape l'utilisateur (c'est ce qui m'arrive quand le compile en totu cas). C'est la raison pour laquelle j'essaie de faire des tests sur stdin. Je voudrais pouvoir déterminer si c'est la sortie d'un autre programme (auquel cas c'est bon) ou bien le clavier (auquel cas c'est pas bon). Ca me semble aller dans le sens d'un programme plus "propre".

Pourquoi ce test là n'est-il pas bon?
Code:

1 2 3 if (fstat(fileno(stdin),&buf) == 0) if ( (buf.st_dev) == 0) file = stdin;
Parce que quand je compile et que je teste, ça fait ce que je souhaiterais
13/06/2007, 10h33
Médinoc
Parce qu'apparemment, ce n'est pas ce que tu cherches.
Tu dois envisager les différents cas:
- L'entrée est redirigée et pas de fichier spécifié -> OK ?
- L'entrée est redirigée et un fichier est spécifié -> Erreur ?
- L'entrée est la console et pas de fichier spécifié -> Erreur ? Aide ?
- L'entrée est la console et un fichier est spécifié -> OK ?
Sachant que tu peux utiliser simplement isatty() plutôt que fstat()...
13/06/2007, 10h47
julien.63
Est ce que ceci serait alors plus approprié ?
Code:

1 2 3 if (isatty(fileno(stdin)) == 0) file = stdin;
Sinon voilà ce que je souhaite faire :
* L'entrée est redirigée et pas de fichier spécifié -> OK : lit l'entrée redirigée
* L'entrée est redirigée et un fichier est spécifié -> OK : lit le fichier
* L'entrée est la console et pas de fichier spécifié -> Aide
* L'entrée est la console et un fichier est spécifié -> OK : lit le fichier

Dans ce cas, oui, ça parait plus approprié.
Ce qui donnerait comme algorithme:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 bool close = faux fichier fich = null si fichier_specifie fich = open(nom_fichier) close = vrai sinon si isatty(stdin) Afficher l'aide sinon fich = stdin si fich != null traitement si close fclose(fich)

Voici ce que ça donnerait. Est ce que ça pose problème de se passer du booléen et de faire

Code:

if(file != stdin)

avant de clore évenutellement?

Code:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <stdlib.h>
#include <sys/stat.h>
 
int main(int argc, char **argv)
{
	char 	ch[1024];
	FILE 	*file = NULL;
 
	if (argc == 2)
	{
		if (getopt (argc, argv, "d:") != -1){
			if( (file = fopen(optarg, "r")) == NULL){
		    	printf("# CANNOT OPEN FILE : %s\n",optarg);
		    	return EXIT_FAILURE;
			}
		}
	}
 
	if(file == NULL)
	{
		if (isatty(fileno(stdin)))
		{
	 		printHelp();
	 		exit(EXIT_FAILURE);
		}
		else
		{
			file = stdin
		}
	}	
 
	while( fgets(ch, 1000, file) != NULL)  
	{  
		printf("**%s\n", ch); 
	} 
 
	if(file != stdin)
		fclose(file);
 
	return 0; 
}

13/06/2007, 11h42
Médinoc

Je pense que conceptuellement, le booléen est mieux.

Ok, donc voici la version avec booléen :
Merci beaucoup pour votre aide à tous. Non seulement j'ai ce que ce dont j'avais besoin (grâce à vous) mais en plus j'ai appris plein de truc au passage. :D :D :merci:

Code:

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <stdlib.h>
#include <sys/stat.h>
 
int main(int argc, char **argv)
{
	char 	ch[1024];
	FILE 	*file = NULL;
	int 	close = 0;
 
	if (argc == 2)
	{	
		printf("#database option\n");
		if (getopt (argc, argv, "d:") != -1){
			if( (file = fopen(optarg, "r")) == NULL){
		    	printf("# CANNOT OPEN FILE : %s\n",optarg);
		    	return EXIT_FAILURE;
			}
			else
				close = 1;
		}
	}
 
	if(file == NULL)
	{
		if (isatty(fileno(stdin))
		{
			printf("## PAS D'ENTREE !!");
			return EXIT_FAILURE;
		}
		else
		{
			printf("##stdin\n");
	 		file = stdin;
		}
	}	
 
	printf("##start\n");
	while( fgets(ch, 1000, file) != NULL)  
	{  
		printf("**%s\n", ch); 
	} 
	printf("##end\n");
 
	if(close)
		fclose(file);
 
	return 0; 
}