Qu'est-ce qu'un signal UNIX et Comment les utiliser ?

Manipulation des signaux UNIX

Créer votre propre Protocole de Communication Client-Serveur

C / C++ / C#

![Description](https://i.imgur.com/H7wFUl8.png)

Maintenant que nous avons appris à quoi servent les signaux UNIX et les PID, nous allons apprendre à les manipuler avec du code afin de nous permettre de créer différents programmes les utilisants. Nous utiliserons la bibliothèque "signal" et je vous présenterais les fonctions principales afin de pouvoir manipuler les signaux. 
Nous allons dans un premier temps analyser ces fonctions, si vous ne comprenez pas bien à quoi elles servent et comment les utiliser, pas d'inquiétude, nous y reviendrons lors de la partie pratique.

Je vais dans un premier temps vous lister les fonctions que nous allons voir lors de ce cours avant de vous les détailler une à une avec leur nom, leur prototype, une courte explication de son utilité ainsi qu’un exemple afin de mieux comprendre comment les utiliser en pratique. 
Encore une fois je me répète, mais si vous ne comprenez pas réellement tout lors de l’explication de ces différentes fonctions, c’est parfaitement normal et ne vous inquiétez pas, tout sera plus clair lors de la phase pratique car nous les utiliserons directement les unes avec les autres.

#### Fonction: `getpid()`
- **Lib:** unistd
- **Prototype:**
``` C
  pid_t getpid(void);
```
- **Description:** La fonction getpid renvoie l'identifiant du processus appelant.

- **Exemple:**
``` C
#include <stdio.h>
#include <unistd.h>

int main(void) {
  pid_t pid;

  pid = getpid();
  printf("The process ID is %d\n", pid);

  return 0;
}
```
Output:
``` bash
The process ID is 54624
```

#### Fonction: `signal()`
- **Lib:** signal
- **Prototype:**
``` C
sighandler_t signal(int signum, sighandler_t handler);
```
- **Description:**
La fonction signal en C permet de designer une fonction (appelée gestionnaire de signal) à appeler lorsqu'un signal spécifique est reçu par un programme en cours d'exécution afin que vous puissiez prendre des mesures en réponse au signal.

- **Exemple:**
``` C
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

void signal_handler(int signum) 
{
  printf("Received SIGINT!\n", signum);
  exit(0);
}

int main() 
{
  // Si nous recevons le signal SIGINT, 
	// la fonction "signal_handler" 
	// est appelee.
  
  signal(SIGINT, signal_handler);

// Dans la logique on devrait avoir une
// boucle infini pour attendre le signal

  return 0;
}
```

#### Fonction: `sigemptyset()`
- **Lib:** signal
- **Prototype:**
``` C
int sigemptyset(sigset_t *set);
```
- **Description:**
La fonction sigemptyset est utilisée pour initialiser un ensemble de signaux à l'ensemble vide, ce qui signifie qu'il ne contient aucun signal.
Les ensembles de signaux sont utilisés par certaines fonctions, telles que sigaction, pour définir les signaux à traiter.
La fonction sigemptyset prend un pointeur vers un ensemble de signaux comme argument et vide cet ensemble en n'y ajoutant aucun signal.
Cette fonction est souvent utilisée conjointement avec la fonction sigaddset qui ajoute un signal spécifié à un ensemble de signaux. 
Cela est utile lorsque vous souhaitez manipuler des ensembles de signaux pour diverses opérations, comme bloquer ou débloquer certains signaux.

#### Fonction: `sigaddset()`
- **Lib:** signal
- **Prototype:**
``` C
int sigaddset(sigset_t *set, int signum);
```
- **Description:**
Cette fonction permet d'ajouter un signal à un ensemble de signaux. La fonction sigaddset prend deux arguments : un pointeur vers un ensemble de signaux et le numéro du signal à ajouter à l'ensemble.

- **Exemple: (sigemptyset et sigaddset)**
``` C
#include <signal.h>

int main(void)
{
	sigset_t signal_set;

	// Initialisation d’un ensemble de 
	// signaux vide
	sigemptyset(&signal_set);

	// On ajoute SIGINT à l'ensemble de 
	// signaux
	sigaddset(&signal_set, SIGINT);
	return 0;
}
```

#### Fonction: `sigaction()`
- **Lib:** signal
- **Prototype:**
``` C
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
```
- **Description:**
La fonction sigaction est utilisée pour spécifier l'action à entreprendre lorsqu'un signal spécifique est reçu par un processus.
L'argument signum spécifie le signal pour lequel l'action est spécifiée.
L'argument act est un pointeur vers une structure struct sigaction qui spécifie l'action à entreprendre lorsque le signal est reçu.
L'argument oldact est un pointeur vers struct sigaction qui est utilisé pour récupérer l'action précédente pour le signal spécifié (Même si très peu utilisé).

- **Exemple:**
``` C
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

void signal_handler(int signum) {
  printf("Received signal %d\n", signum);
}

int main(void) {
  struct sigaction action;
  action.sa_handler = signal_handler;
  sigemptyset(&action.sa_mask);
  action.sa_flags = 0;

  sigaction(SIGINT, &action, NULL);

	// Dans la logique on devrait avoir une
	// boucle infini pour attendre le signal

  return 0;
}
```

#### Fonction: `kill()`
- **Lib:** signal
- **Prototype:**
``` C
int kill(pid_t pid, int sig);
```
- **Description:**
En C, la fonction kill est un appel système qui envoie un signal à un processus. L'argument pid spécifie l'ID du processus avec lequel vous souhaitez communiquer. L'argument sig spécifie le signal à envoyer au processus. Différents signaux peuvent être envoyés, chacun correspondant à un objectif différent.

- **Exemple:**
``` C
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int main() {
	// Obtenir le PID du processus
  pid_t pid = getpid();
	// Envoyer le signal SIGKILL au processus
  int result = kill(pid, SIGKILL);
  if (result == 0) {
	printf("Process terminated successfully.\n");
  } else {
	perror("Error terminating process");
  }
  return 0;
}
```

#### Fonction: `usleep()`
- **Lib:** unistd
- **Prototype:**
``` C
int usleep(useconds_t usec);
```
- **Description:**
La fonction usleep provoque la mise en veille du processus appelant pendant un nombre spécifié de microsecondes.

- **Exemple:**
``` C
#include <stdio.h>
#include <unistd.h>

int main(void) {
    printf("Sleeping for 5000 microseconds...\n");
    usleep(5000);
    printf("Done sleeping.\n");
    return 0;
}
```

#### Fonction: `pause()`
- **Lib:** unistd
- **Prototype:**
``` C
int pause(void);
```
- **Description:**
pause() est une fonction qui met le processus appelant en veille jusqu'à ce qu'un signal soit reçu. Le processus reste bloqué jusqu'à ce qu'un gestionnaire de signal soit exécuté ou que le signal soit ignoré

- **Exemple:**
``` C
#include <stdio.h>
#include <unistd.h>

int main(void) {
    printf("Entering pause...\n");
    pause();
    printf("Exiting pause.\n");
    return 0;
}

```

Bien, nous venons de voir la majorité des fonctions qui vont nous être utiles pour le petit projet que nous devrons faire au chapitre suivant, j’ai essayé de détailler un maximum l'utilité et le fonctionnement de ces fonctions, si vous avez encore des doutes sur leurs usages, je vous invite à regarder leur manuel.

Si vous avez bien suivi et compris le projet que nous allons faire, vous devez commencer à comprendre comment nous allons pouvoir utiliser ses fonctions.

Bien entendu, je vous inviterais à réaliser le projet par vous même pour ceux qui le souhaite (Le sujet se trouve au chapitre suivant). Pour les autres, allons-y et commençons notre projet final dès le prochain chapitre !
<data>NE PAS SUPPRIMER CETTE LIGNE!</data>


Nous allons découvrir comment utiliser les signaux UNIX pour communiquer entre différents programmes. Par la suite, nous créerons une communication textuelle entre un client et un serveur.