La création de processus via la commande ```fork``` est intéressante mais son utilisation
est limitée. Le système fourni un compagnon à ```fork``` l'appel système ```exec```. Son rôle est
de permettre à un processus de _changer son code_ (recouvrir). On parle souvent des appels ```fork/exec```.
## La famille ```exec```
Il existe six primitives de préfixe commun ```exec``` qui se différencient :
- par la manière dont les arguments récupérés via l’argument ```argv``` sont transmis.
- soit directement sous forme d’un tableau ou vecteur (d’où le ```v```) contenant
les différents paramètres. Il s’agit des primitives ```execv```, ```execvp``` et ```execve``` qui ont un nombre fixe de paramètres ;
- soit sous forme d’une liste (d’où le ```l```) ```arg0, arg1, ..., argn, NULL``` dans
les primitives ```execl```, ```execlp``` et ```execle``` qui ont ainsi un nombre variable de paramètres ;
- par la manière dont le fichier à charger est recherché dans le système de fichiers :
- avec ```execlp``` et ```execvp``` le fichier est recherché dans les répertoires spécifiés via la variable ```PATH``` de l’environnement (et dans l’ordre d’apparition) ;
- avec les autres primitives, le fichier, s’il n’est pas désigné par une référence absolue, n’est recherché que relativement au répertoire de travail du processus appelant ;
- par l’environnement conservé par le processus au cours du recouvrement :
- avec les primitives ```execve``` et ```execle``` un nouvel environnement transmis en
paramètre se substitue à l’ancien ;
- avec les autres primitives, l’environnement reste inchangé.
Le code de retour peut-être $-1$ en cas d'erreur.
### Description
```c
int execl (const char *reference, const char *arg0, ..., NULL);
```
Le fichier de ```reference``` absolue ou relative (au répertoire de travail du processus) donnée est chargé et la fonction ```main``` correspondante est appelée avec les paramètres de la liste constituée par les autres paramètres. Le paramètre ```arg0``` est récupéré dans la fonction ```main``` dans ```argv[0]```.
#### Par exemple
```c
execl("/bin/ls", "ls", "-l", "/", NULL)
```
correspond à ```ls -l /```.
```c
int execlp (const char *reference, const char *arg0, ..., NULL);
se comporte comme la précédente sauf que si la ```reference``` est relative la recherche de la référence se fait dans les répertoires spécifiés dans la variable ```PATH``` de votre environnement.
même comportement que ```execl``` mais le dernier paramètre pointe sur un environnement à substituer à l'ancien. Un environnement est constitué d'un ensemble de pointeurs sur des chaines de la forme *nom=valeur* (la fin de la liste est marquée par le pointeur ```NULL```).
#### Exemple
```c
#include <stdio.h>
#include <stdlib.h>
extern char **environ;
int main(int argc, char *argv[]) {
int ind;
char **ptr;
for (ind = 0; ind <argc;ind++)printf("%s\n",argv[ind]);
