Salut,
Tu oublies une condition après la création du fork():
fork() < 0 -> erreur
fork() = 0 -> processus fils (id_pere = getppid() et id_fils = getpid())
fork() > 0 -> processus père (id_pere = getpid() et id_fils = retour de fork())
Pour la duplication du code, blabla, je pense que tu as compris.
A ta place, j'enlèverai la boucle et ferai du cas pas cas, car dans chaque processus, tu dois fermer une extrémité des tubes (avec close(descripteur);).
Pour les faire communiquer entre eux, suffit d'utiliser les fonctions read() et write().
En gros, de mémoire (car je ne prog pas énormément sous linux), voici ce que donnerait un échange entre 2 processus père et fils (le père envoie un entier au fils):
Code C/C++ :
int main() {
int descripteur[2]; //descripteur du tube anonyme
//création du tube anonyme
if (pipe(descripteur) == -1) { puts("erreur de création du tube"); exit(1); }
//duplication du processus
pid_t pid=fork();
if (pid < 0) { puts("erreur de duplication du processus") exit(1); }
//cas du processus fils
if (pid == 0) {
close(descripteur[1]); //fermeture de l'entrée du tube
//lecture du tube
size_t res;
int nbr;
res=read(descripteur[0],(int*)&nbr,sizeof(int));
//vérification des erreurs
//cas d'une erreur système
if (res < 0) { puts("erreur de lecture du tube"); exit(1); }
//cas où le processus écrivain a fermé son extrémité du tube
else if (res != sizeof(int)) { puts"erreur de lecture du tube"); exit(1); }
//sinon, tout s'est bien passé, affichage de l'entier lu
printf("entier lu: %d\n",nbr);
close(descripteur[0]; //fermeture du descripteur
}
//cas du processus père
else if (pid > 0) {
close(descripteur[0]); //fermeture de la sortie du tube
//ecriture dans le tube
size_t res;
int nbr=5; //entier écrit
res=write(descripteur[1],(int*)&nbr,sizeof(int));
//vérification des erreurs
if (res != sizeof(int)) { puts("erreur d'écriture dans le tube"); exit(1); }
close(descripteur[1]; //fermeture du descripteur
}
}
Voilà comment on communique dans le cas d'un tube anonyme (de mémoire, il y a sans doute des erreurs).
Ensuite, pour attendre, plusieurs possibilités : wait(), waitpid(), pause(), (d'autres, à oublier dans ton cas: sleep(), alarm(), ...)
Les problèmes :
- wait() attend la fin de n'importe quel processus
- waitpid() attend la fin d'un processus fils (donc à utiliser uniquement pour le processus père)
- pause() attend n'importe quel signal (ce qui permet à l'autre processus de le réveiller en lui envoyant un signal, mais si c'est le système qui, pour une raison quelconque, lui en envoie un, c'est fichu)
Et là... désolé mais j'ai plus le courage de réfléchir ce soir
Mais dis moi, ce ne serait pas un TP ton truc (tu dis "je dois faire ça") ? Si c'est un projet personnel, pourquoi ne pas utiliser les segments de mémoire partagée (+ éventuellement les sémaphores) ? Ce serait, à mon avis, plus simple que les tubes.
En fait, tu as un exempleconcret de tube anonyme
ici
Bonne chance !
Cordialement, uaip.