En programmation système, les tubes et les descripteurs sont des mécanismes de

communication entre processus. Nous distinguons deux types de tubes :

➢ Les tubes anonymes

➢ Les tubes nommés

1. Les tubes anonymes

1.1. Définition

➢ Les tubes anonymes sont un moyen simple de communication entre deux processus
apparentés, c'est-à-dire ayant un processus parent commun.
➢ Ils sont créés par l'appel système pipe(), qui renvoie deux descripteurs de fichier,
l'un pour la lecture, l'autre pour l'écriture.

Descripteur de fichier

Un descripteur de fichier (fd) est un petit nombre entier non négatif utilisé par le noyau
pour référencer un fichier utilisé par un programme en cours d'exécution. C’est est un
entier qui représente un fichier ouvert dans le système d'exploitation. Il est utilisé
pour accéder au fichier, par exemple pour lire ou écrire des données.

Les descripteurs de tubes sont des descripteurs de fichier spéciaux qui représentent
un tube :

- 0 représente un descripteur de lecture

- 1 représente un descripteur d’écriture

➢ Les tubes sont unidirectionnels, c'est-à-dire qu'un processus ne peut écrire que
dans un tube et lire que dans un autre.

1.2. Utilisation des tubes

Pour utiliser un tube, un processus doit ouvrir les deux descripteurs de fichier renvoyés
par l'appel système pipe(). Le processus qui écrit dans le tube utilise le descripteur
d'écriture pour écrire les données dans le tube. Le processus qui lit dans le tube utilise
le descripteur de lecture pour lire les données du tube.
Exemple d'utilisation d'un tube

Le code suivant illustre l'utilisation d'un tube pour communiquer entre deux processus
:

C
#include <stdio.h>
#include <unistd.h>
int main() {
int fd[2]; tableau de 2 fd
char buf[1024]; // tableau de 1024 char

// Création du tube
pipe(fd);
// Processus producteur
if (fork() == 0) {
// Écriture dans le tube
write(fd[1], "Bonjour, mon fils !", strlen("Bonjour, mon fils !"));
exit(0);
}

// Processus consommateur
// Lecture dans le tube
read(fd[0], buf, 1024);
printf("Lecture : %s\n", buf);

// Fermeture des descripteurs

close(fd[0]);
close(fd[1]);
return 0;
}

Ce code crée un tube et le partage entre deux processus. Le processus producteur écrit
" Bonjour, mon fils !" dans le tube. Le processus consommateur lit " Bonjour, mon fils
!" du tube.
 2. Les tubes nommés

2.1. Définition

➢ Les tubes nommés sont un type de tube qui est accessible à tous les processus
ayant les droits d'accès adéquats.
➢ Ils sont créés par l'appel système mkfifo().
➢ Les tubes nommés sont bidirectionnels, c'est-à-dire qu'un processus peut écrire
et lire dans le même tube.

2.2. Utilisation des tubes nommés

Pour utiliser un tube nommé, un processus doit ouvrir le tube en lecture ou en écriture.

Exemple d'utilisation d'un tube nommé

Le code suivant illustre l'utilisation d'un tube nommé pour communiquer entre deux
processus :

C
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>

int main() {
int fd;
char buf[1024];

// Création du tube nommé

mkfifo("my_pipe", 0666); // crée un nouveau tube nommé my_pipe avec les permissions 0666

// Processus producteur
if (fork() == 0) {
// Écriture dans le tube nommé
fd = open("my_pipe", O_WRONLY); // O_WRONLY: flag d’ouverture
write(fd, " Bonjour, bon cours !", strlen("Bonjour, bon cours !"));
close(fd);
exit(0);
}

// Processus consommateur
 // Lecture dans le tube nommé
fd = open("my_pipe", O_RDONLY);
read(fd, buf, 1024);
printf("Lecture : %s\n", buf);
close(fd);

return 0;
}

Ce code crée un tube nommé et le partage entre deux processus. Le processus

producteur écrit "Hello, world !" dans le tube nommé. Le processus consommateur lit
"Hello, world !" du tube nommé.

3. Conclusion
Les tubes et les descripteurs sont des mécanismes de communication puissants qui
peuvent être utilisés pour connecter différents processus.

Les valeurs possibles pour les flags d'ouverture sont les suivantes :
• O_RDONLY : Ouvre le fichier en mode lecture uniquement.
• O_WRONLY : Ouvre le fichier en mode écriture uniquement.
• O_RDWR : Ouvre le fichier en mode lecture et écriture.
• O_APPEND : Ajoute les données écrites au fichier à la fin du fichier.
• O_CREAT : Crée le fichier s'il n'existe pas.
• O_TRUNC : Supprime le contenu du fichier s'il existe.
• O_EXCL : Renvoie une erreur si le fichier existe déjà.
 4. EXERCICES

Exercice 1
Écrivez un programme C qui crée deux processus, un processus émetteur et un processus récepteur.
Le processus émetteur écrit la chaîne "Hello, world!" dans le tube et le processus récepteur lit la
chaîne du tube et l'affiche sur la console.

Solution exo1
C
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
// Créer un tube
int pipefd[2];
pipe(pipefd);

// Créer un processus émetteur

pid_t pid = fork();

// Si le processus est un processus émetteur

if (pid == 0) {
// Écrire une chaîne dans le tube
char *message = "Hello, world!";
write(pipefd[1], message, strlen(message));
// Terminer le processus
exit(0);
}

// Si le processus est un processus récepteur

else {
// Lire une chaîne du tube
char buffer[1024];
int bytes_read = read(pipefd[0], buffer, sizeof(buffer));
// Afficher la chaîne sur la console
printf("La chaîne reçue est : %s\n", buffer);
// Terminer le processus
return 0;
}
}
Exercice 2
Écrivez un programme C qui crée deux processus, un processus émetteur et un processus récepteur.
Le processus émetteur écrit des nombres entiers dans le tube et le processus récepteur lit les nombres
du tube et les affiche sur la console.

Exercice 3
Écrivez un programme C qui crée deux processus, un processus émetteur et un processus
récepteur. Le processus émetteur écrit des chaînes dans le tube et le processus récepteur lit les
chaînes du tube et les affiche sur la console. Le processus récepteur doit afficher les chaînes
dans l'ordre inverse de celui dans lequel elles ont été écrites.