Discussion :

[titou624]

Bonjour à tous ! Voici mon problème dans le cadre d'un projet pour mes études je dois faire communiquer 2 processus :
Le premier cherche des fichiers avec une extension précisée en paramètre puis l'envoi via un tube au second.
Et c'est la que je bloque .....
Je ne sais pas trop si mon écriture pour la chaine de caractère est correcte.
En fait j'ai l'impression que mon deuxième processus essaye de lire dans le tube alors que le premier n'a rien écrit.....

Voici mon code :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
 
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#define MAXNAME 100
 
int p[2];
 
// Fonction principale 
int main(int argc, char **argv){
 
    pipe(p);
 
//**** Opérations effecutées par le père ****//
 
//On teste les arguments
    if(argc!=3){
        printf("Usage: find rep_depart ext \n");
        exit(2);
    }
 
// initialisation des variables
    struct stat buf;
    struct dirent *ent;
    char nom[MAXNAME];
    char *nomRep = NULL;
    DIR *rep = NULL;
  char *ext = NULL;
  char *tmp = NULL;
  int tailleNom = 0;
 
// On stock l'extension en variable
  ext = malloc(strlen(argv[2])*sizeof(char));
    strcpy(ext,argv[2]);
 
    printf("extension cherchée : %s\n",ext);
 
    //**** Opérations effecutées par le fils ****//
 
    int f = fork();
    if(f==0){
        printf("Place au fils !\n");
 
        char *fic=NULL;
        int taille=0;
 
        close(p[1]);    
        read(p[0],&taille,sizeof(int));
        fic=malloc(taille*sizeof(char));
        read(p[0],&fic,taille);
        close(p[0]);
 
        printf("Je suis le fils, ce fichier fait une taille de : %d\n",taille);
        printf("Je suis le fils, ce fichier a été lu dans le tube : %s\n",fic);
        exit(0);
    }
 
//**** FIN des opérations effecutées par le fils ****//    
 
// On stock le nom du repertoire
  nomRep = malloc(strlen(argv[1])*sizeof(char));
  strcpy(nomRep,argv[1]);
 
    printf("recherche dans le repertoire : %s\n",nomRep);
 
//ouverture du dossier
    rep = opendir(nomRep);
 
    printf("ouverture du repertoire réussie\n");
 
//Test si le dossier s'ouvre correctement
    if(!rep){    
// On signale l'erreur
        perror("opendir");
    }
 
// Tant qu'il ya des fichiers
    while(ent=(readdir(rep)))
    {        
 
// On construit l'adresse du fichier
            strcpy(nom,nomRep);
 
// Si le fichier est différent de ./ ou ../
            if(strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")){
                strcat(nom,"/");
                strcat(nom,ent->d_name);
 
// On récupère les informations sur le fichier
 
// lstat permet d'éviter de compter les liens symbolique
                if(lstat(nom,&buf)!=-1){
 
// Si c'est un fichier
                    if(S_ISREG(buf.st_mode)){    
 
// On stock les caractères après le point                        
             tmp = strrchr(ent->d_name,(int)'.');
// On test si le pointeur n'est pas nul ( Pour les fichiers sans extension)
             if(tmp != NULL){
 
// tmp+1 pour enlever le point
               if(!strcmp(ext,tmp+1)){
                   printf("fichier correspondant : %s\n",nom);
 
// écriture de l'adresse du fichier dans le tube
                                 close(p[0]);
                 write(p[1],&nom,strlen(nom));
                                 printf("Adresse du fichier écrite dans le tube: %s\n",nom);
 
// Opération pour la taille de la chaine
                 tailleNom = strlen(nom);              
                 write(p[1],&tailleNom,sizeof(int));
                                 printf("Nb de caractères écris dans le tube: %d\n",strlen(nom));        
                 printf("Ce fichier a été copié dans le tube : %s\n",nom);    
                 // On ferme le tube    
                                 close(p[1]);
 
                  }
              }
            }
         }
    }
        }//fin du while
 
// On ferme le repertoire
    closedir(rep);
 
}

Et voici ce que j'obtient en exécutant le code :

#:~/iut/se/projet$ ./crypt . c
extension cherchée : c
Place au fils !
recherche dans le repertoire : .
ouverture du repertoire réussie
fichier correspondant : ./projet.c
Je suis le fils, ce fichier fait une taille de : 1919954734
Je suis le fils, ce fichier a été lu dans le tube : (null)
Adresse du fichier écrite dans le tube: ./projet.c

En espérant avoir été le plus clair possible.
Merci d'avance à tout ceux qui s'interesseront à mon problème .

[Melem]

Je te conseille d'utiliser popen à la place de pipe pour ne pas avoir à utiliser ensuite des fork, spawn, etc. car ces fonctions ne sont pas très portables. popen c'est plus simple à utiliser, plus portable, elle convient donc toujours dans la majorité des cas, comme celui-ci.

[titou624]

Merci beaucoup pour ta réponse je vais regarder ça .

[nicolas.sitbon]

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <stdlib.h>
#include <stdio.h>
 
#include <unistd.h>
#include <glob.h>
 
static void fork_and_write(glob_t const * const result)
{
   int fds[2];
 
   if(pipe(fds) != 0)
   {
      perror("pipe");
   }
   else
   {
      switch(fork())
      {
         case -1:
            perror("fork");
            break;
 
         case 0: /* fils */
         {
            FILE * in = fdopen(fds[0], "r");
 
            if(in != NULL)
            {
               char name[FILENAME_MAX + 1];
               while(fgets(name, sizeof name, in) != NULL)
               {
                  printf("%s",name);
                  fflush(stdout); /* paranoia */
               }
 
               fclose(in), in = NULL;
            }
            else
            {
               perror("fdopen");
            }
 
            break;
         }
 
         default: /* pere */
         {
            FILE * out = fdopen(fds[1], "w");
 
            if(out != NULL)
            {
               for(size_t i = 0; i < result->gl_pathc; i++)
               {
                  fprintf(out, "%s\n",result->gl_pathv[i]);
               }
 
               fclose(out), out = NULL;
            }
            else
            {
               perror("fdopen");
            }
         }
      }
 
      close(fds[0]), fds[0] = -1;
      close(fds[1]), fds[1] = -1;
   }
}
 
int main(int argc, char **argv)
{
   if(argc != 3)
   {
      fputs("Usage: find directory ext\n", stderr);
   }
   else if(chdir(argv[1]) == -1)
   {
      perror("chdir");
   }
   else
   {
      glob_t result = {0};
 
      switch(glob(argv[2], GLOB_MARK, NULL, &result))
      {
         case 0:
            fork_and_write(&result); 
            break;
 
         case GLOB_NOMATCH:
            fputs("The pattern does not match any existing pathname\n", stderr);
            break;
 
         case GLOB_NOSPACE:
            fputs("An attempt to allocate memory failed\n", stderr);
            break;
 
         default:
            fputs("Unknow error\n", stderr);
      }
 
      globfree(&result);  
   }
 
   return 0;
}