# Système d'Exploitation : Cours 5 : IPC

- [Système d'Exploitation : Cours 5 : IPC](#système-dexploitation--cours-5--ipc)
  - [Différents types de communication](#différents-types-de-communication)
  - [Tubes](#tubes)
    - [Tubes anonymes](#tubes-anonymes)
      - [Principe & API](#principe--api)
      - [Implémentation en C](#implémentation-en-c)
    - [Les tubes nommés](#les-tubes-nommés)
      - [Pincipes](#pincipes)
      - [Implémentation en C](#implémentation-en-c-1)

## Différents types de communication

- Machines distantes reliées par un réseau
  -  Socket
- Sur la même machine : 
  - Tubes et tubes nommés
  - Files de messages
  - Sémaphores
  - Mémoires partagée

## Tubes

### Tubes anonymes

#### Principe & API

Communication unidirectionnelle entre processus.
Appel système : 
```c
int pipe(int *fileDesc);
```
- `fileDesc` → descripteur de fichier
- `fileDesc[0]` → descripteur de lecture
- `fileDesc[1]` → descripteur d'écriture

Caractéristiques : 
- Capacité limitée
- Fichier : possède un numéro d'inode mais pas de nom dans le système
- Disparait avec le processus
- Les processus qui utilisent un tube doivent avoir un lien de parenté

Concept : 

Processus père (writes fd) → Kernel (Pipe) → Processus fils (read fd)

Il est possible de mettre à la chaine entre plein de processus.
Pour une communication bidirectionnelle, il faut un tube supplémentaire.

#### Implémentation en C

```c
// Déclaration
int tube1[2] = {-1,-1};
int tube2[2] = {-1,-1};
// Ouverture
pipe(tube1);
pipe(tube2);
...
// Chaque processus ferme les descripteurs inutilisés
close(tube1[0]);
close(tube2[1]);

// Ecrire dans le tube
write(tueb1[1], &outboundMessage, sizeof(char));

// Lire dans le tube
read(tube[2], &inboundMessage, sizeof(char));

// Fermer les descripteurs à la fin du processus
close(tube1[1]);
close(tube2[0]);

```

### Les tubes nommés

#### Pincipes

Différence avec les tubes anonymes :
- Possède un nom dans le système de fichiers
- Pas de lien de parenté obligatoire entre les différents processus
- Persistant tant qu'il n'est pas détruit (même après disparition du processus qui l'a créé)
- Donnée en FIFO (taille limitée + on se déplace pas à l'intérieur)

<br>
<br>
<br>
<br>
<br>

<br>
<br>
<br>
<br>
<br>

#### Implémentation en C

```c
int tube;
mode_t droits_tubes = S_IRWXU | S_IRWXG; // Droits en lecture, écriture et exécution pour User et Group

// Création du tube
mkfifo("TUBE", droits_tube);
...

/* Ouverture du tube (fichier) en écriture seule
* Appel bloquant jusqu'à ouverture du tube par le lecteur
*/
tube = open("TUBE", O_WRONLY);

// Lecture dans le tube
read(tube, &lettre, sizeof(unsigned char));

// Ecriture dans le tube
write(tube, &lettre, sizeof(unsigned char));
```

On voit bien la création d'un fichier dans le repertoir courant de l'exécutable qui porte le nom du tube.
Il faut gérer la suppression du tube sinon il reste dans le système de fichier.