Bonjour,

je suis débutant en programmation systeme, je sollicite votre aide pour m'aider à écrire le main de mon programme.
Pour l'écriture du programme, il faut uniquement que j'utilise des fork, pipe... car je n'ai pas vu les threads...

J'explique ce qu'il faut faire :
-avoir plusieurs traceroute s'effectuant simultanément, afin de rassembler des informations le plus vite possible
-pouvoir choisir à la volée combien de traceroute on souhaite exécuter en parallèle)
-ajouter de nouvelles « cibles » pour traceroute pendant que l'ensemble fonctionne.
Les résultats des traceroute (avec l'option -n) lancés doivent être écrits dans un fichier pour pouvoir analyser les lignes et ainsi créer un graphe.

Le parsing et la création du graphe ont été faits, c'est le lancement des traceroutes et l'écriture dans le fichier qui pose problème.

Voici ce que j'ai écrit. Il n'est pas complet et aimerait que vous m'aidez pour faire en sorte qu'il le soit.

Merci par avance

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
// structure pour gérer une info fils => père
typedef struct {
  info1;
  info2;
  info3;
  info4;
  //...les infos qu'il faut
} t_info;
 
// structure pour gérer un fils et son pipe
typedef struct {
  int cote[2];               // Cotés du pipe
  int pid;                  // PID du fils
} t_fils;
 
int main(void)
{
  t_fils tabFils[n];           // Tableau des fils
  int i;                           // Boucle
  int nbFils;                   // Nb fils vivants
  t_info info;                  // Info transmise
 
  // Création des processus
  for (i=0; i < n; i++)
    {
      // Ouverture du pipe pour le fils vers son père
      pipe(tabFils[i].cote);
 
      // Création du processus fils
      if ((tabFils[i].pid=fork()) == 0)
    {
      // Ici on est dans le fils "i"
 
      // On commence par fermer le coté de lecture inutile
      close(tabFils[i].cote[0]);
 
      // Traceroute vers ip X
      //...
 
      // Récupération de toutes les IP situées entre moi et "x" => tableau d'IP
      //..
 
      //  Transmission de ce tableau vers le père par le pipe
      for (//...)
      {
        // Remplissage infos (une des info pourrait être le n° du fils)
        info.info1=i;
        info.info2=//...
          //... (on remplit toutes les infos)
 
          // On envoie l'info au père
          write(tabFils[i].cote[1], &info, sizeof(info);
 
         // on envoie une info particulière signifiant "fini"
         write(tabFils[i].cote[1], "EOT", 4);
 
        // Toutes les Ip sont transmises - Fin du fils (mais fermeture pipe avant)
        close(tabFils[i].cote[1]);
        exit(0);
      }
 
      // Ici on est dans le père - On n'a rien à faire sauf à fermer le coté d'écriture inutile
    close(tabFils[i].cote[1]);
    }
 
        // Ici, tous les fils sont lancés - On scrute maintenant les pipes tant qu'il y a des fils
        nbFils=n;
      while (nbFils > 0)
      {
        // On lit tous les pipes des fils
        for (i=0; i < n; i++)
          {
        // Si le fils "i" n'existe plus on le saute
        if (tabFils[i].pid == 0)
          continue;
 
        // Lecture du pipe venant du fils "i"
        if (read(tabFils[i].cote[0], &info,  sizeof(info)) > 0)
          {
            // Si on a reçu l'info particulière "EOT"
            if (//... == "EOT")
            {
              // On ferme le pipe de ce fils
              close(tabFils[i].cote[0]);
 
              // Le fils a terminé => pid mis à 0 (permettra de ne plus le traiter)
              tabFils[i].pid=0;
 
              // Un fils en moins
              nbFils--;
 
              // Inutile d'en faire plus pour ce crevard
              continue;
            }
 
            // Ici, on a reçu les infos sur les IP pour le fils "i"
            //... => on les analyse et on construit le graphe
         }
 
        // ici, soit on n'a rien reçu, soit on a fini de traiter les infos => on reboucle sur le fils suivant
            sleep(1);
   }
}
// Ici, il n'y a plus de fils
 
}