A.

TP N°4 : La communication inter-

processus sous Linux
Objectifs
A l'issue du TP l'étudiant devra être capable de :
 Comprendre et implanter une communication entre les processus en utilisant les tubes anonymes en
langage C
 Comprendre et implanter une communication entre les processus en utilisant les tubes nommés en
langage C

Exercice 1
Écrire un programme C qui crée un processus fils.
• Le processus père lit des caractères sur l'entrée standard et l’envoie à son fils.
• Le processus fils compte les lettres et les chiffres et affiche les résultats.
• Le processus père attend la terminaison du fils pour s'arrêter.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include<string.h>

void main()
{
int T[2] ;
pipe (T) ;
int pid,i,x,nbl=0,nbc=0 ;
char ch[20] ;
pid=fork() ;
if (pid==0)
{

close (T[1]);
read(T[0],ch,20);
for(i=0;ch[i]!='\0';i++){
if((ch[i]>=65 && ch[i]<=91)||(ch[i]>=97 && ch[i]<=123))
nbl++;
if(ch[i]>'0' && ch[i]<'9')
nbc++; }
close (T[0]);
printf("La chaine : %s nombre de chiffres est %d le nombre de lettres est
%d\n",ch,nbc,nbl);
}
else
{ printf("Donner une chaine : ");

1/4
 scanf("%s",ch);
close(T[0]);
write(T[1],ch,strlen(ch));
close(T[1]) ;

}
}

Exercice 2
Écrire un programme C qui permet de :
• Créer deux fils.
• Fils1 envoie à son frère « Bonjour ».
• Fils2 reçoit le message de son frère et l’affiche sur l’écran.
• Fils2 envoie à son frère «Quelle Belle journée !».
• Fils1 reçoit le message de son frère et l’affiche sur l’écran.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main ()
{
int p1[2],p2[2],p3[2],p4[2];
char chaine[7];
pipe(p1); // création de tube1
pipe(p2); // création de tube2
pipe(p3); // création de tube3
pipe(p4); // création de tube4
if (fork())// création du premier processus
{
// le père lit à partir du tube1
close (p1[1]); /* pas d’écriture sur le tube1 */
read(p1[0], chaine, 7);
close (p1[0]); /* fermeture du descripteur de lecture */

if(fork()) // création du deuxième processus

{
/* le père écrit dans le tube 2 */
close (p2[0]); /* pas de lecture sur le tube 2 */
write (p2[1],chaine, 7 );
close (p2[1]); /* fermeture du descripteur d'écriture */

// le père lit à partir du tube3

sleep(7);
close (p3[1]); /* pas d’écriture sur le tube2 */
read(p3[0], chaine, 22);
close (p3[0]); /* fermeture du descripteur de lecture */

2/4
 /* le père écrit dans le tube 4 */
close (p4[0]); /* pas de lecture sur le tube 4 */
write (p4[1], chaine, 22);
close (p4[1]); /* fermeture du descripteur d'écriture */

}
else
{
sleep(5);
printf("processus fils2 %d recoit le message du fils1 et l'affiche\n",getpid());
// le fils2 lit à partir du tube2
close (p2[1]); /* pas d’écriture sur le tube2 */
read(p2[0], chaine, 7);
printf("Message recu :<<%s>>\n",chaine);
close (p2[0]); /* fermeture du descripteur de lecture */
printf("processus fils2 %d envoie <<Quelle Belle Journee !>> au processus fils1
\n",getpid());
/* le fils2 écrit dans le tube 3 */
close (p3[0]); /* pas de lecture sur le tube 23*/
write (p3[1], "Quelle Belle Journee !", 22);
close (p3[1]); /* fermeture du descripteur d'écriture */

}
}
else
{
printf("processus P1 %d envoie <<bonjour>> au processus fils2 \n",getpid());
close (p1[0]); /* pas de lecture sur le tube1 */
write (p1[1], "bonjour", 7);
close (p1[1]); /* fermeture du descripteur d'écriture */
sleep(20);
printf("processus fils1 %d recoit le message du fils2\n",getpid());
// le fils1 lit à partir du tube4
close (p4[1]); /* pas d’écriture sur le tube4 */
read(p4[0], chaine, 22);
close (p4[0]); /* fermeture du descripteur de lecture */
printf("Message recu :<<%s>>\n",chaine);
}

3/4
Exercice 3
Écrire un programme C qui permet de créer 2 programmes p1.c et p2.c :

• le programme p1 permet de saisir une chaîne de caractères et de l’envoyer à p2 via un

tube nommé.
• Le programme p2 permet de lire cette chaîne qu’il a reçue à travers le tube et l’affiche
sur l’écran.
//p1.c

/* Processus écrivain sur le tube nommé */

#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int main ()
{
mode_t mode;
char ch[20];
int t;
mode = S_IRUSR | S_IWUSR;
printf("Donner une chaine : ");
scanf("%s",ch);
mkfifo ("tub",mode); /*création du tube nommé */
t = open ("tub", O_WRONLY); /* ouverture du tube en mode d’écriture seulement*/
write (t, ch, 20); /* écriture dans le tube */
close(t); /* fermeture du tube */
}

//p2.c
/* Processus lecteur sur le tube nommé */
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int main ()
{
char ch[20];
int T;
T = open ("tub", O_RDONLY); /* ouverture du tube en lecture seule */
read (T, ch, 20); /* lecture dans le tube */
printf ("code recu : %s\n", ch);
close(T); /* fermeture du tube */
}

4/4