[C] Lancement de plusieurs processus

~traceroute -n 192.48.96.9
traceroute to 192.48.96.9 (192.48.96.9), 30 hops max, 40 byte packets
 1  192.168.0.1  9.754 ms  9.461 ms  8.046 ms
 2  195.6.244.14  60.885 ms  48.924 ms  90.517 ms
 3  194.206.126.244  50.503 ms  48.97 ms  120.122 ms
 4  194.206.126.2  55.655 ms  52.213 ms  58.908 ms
 5  208.213.229.130  588.303 ms  589.843 ms  589.611 ms
 6  208.213.229.129  599.564 ms  599.763 ms  600.749 ms
 7  208.213.229.226  629.167 ms  599.284 ms  599.383 ms
 8  195.10.40.34  599.152 ms  599.289 ms  631.011 ms
 9  157.130.34.217  642.326 ms  715.072 ms  653.724 ms
10  146.188.160.62  595.143 ms  590.433 ms  659.247 ms
11  146.188.160.181  649.863 ms  700.901 ms  617.067 ms
12  137.39.253.86  600.835 ms  599.379 ms  590.867 ms
13  192.48.96.9  607.071 ms  589.221 ms  603.156 ms

void traite_fils(t_info* info, t_fils* tuyau) {
    for (i=0; i < n; i++) {
         // 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(tuyau->cote[1], info, sizeof(*info);
            
         // on envoie une info particulière signifiant "fini"
         write(tuyau->cote[1], "EOT", 4);
            
        // Toutes les Ip sont transmises - Fin du fils (mais fermeture pipe avant)
        close(tuyau->cote[1]);
        exit(0);
    }
}

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
      if (pipe(tabFils[i].cote) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
      }
      
      // Création du processus fils
      tabFils[i].pid = fork();
      switch (tabFils[i].pid)
    {
        case -1:
            perror("fork");
            exit(EXIT_FAILURE);
        case 0:  // Ici on est dans le fils "i"  
            // On commence par fermer le coté de lecture inutile
            close(tabFils[i].cote[0]);
            traite_fils(&info,&tabFils[i]);
            break;
        default:
            // Ici on est dans le père - On n'a rien à faire sauf à fermer le coté d'écriture inutile    
            close(tabFils[i].cote[1]);
            break;
    }
 

  // on est sur d'etre dans le pere...
 
 
        // 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

}