Ubuntu Manpage: execl, execlp, execle, execv, execvp, execvpe

NOM

       execl, execlp, execle, execv, execvp, execvpe - Exécuter un fichier

SYNOPSIS

       #include <unistd.h>

       extern char **environ;

       int execl(const char *chemin, const char *arg, ...
       /* (char  *) NULL */);
       int execlp(const char *fichier, const char *arg, ...
       /* (char  *) NULL */);
       int execle(const char *chemin, const char *arg, ...
                       /*, (char *) NULL, char *const envp[] */);
       int execv(const char *chemin, char *const argv[]);
       int execvp(const char *fichier, char *const argv[]);
       int execvpe(const char *fichier, char *const argv[],
                       char *const envp[]);

   Exigences de macros de test de fonctionnalités pour la glibc (consulter feature_test_macros(7)) :

       execvpe() : _GNU_SOURCE

DESCRIPTION

La famille des fonctions exec() remplace l'image du processus en cours par l'image d'un nouveau
processus. Les fonctions décrites dans cette page de manuel sont en réalité des frontaux pour execve(2)
(consultez la page de manuel de execve(2) pour plus de détails sur le remplacement de l'image du
processus en cours).

Le premier argument de toutes ces fonctions est le nom du fichier à exécuter.

Les fonctions peuvent être regroupées en se basant sur les lettres qui suivent le préfixe "exec".

l - execl(), execlp(), execle()
Les arguments const char *arg et les points de suspension qui suivent peuvent être vus comme arg0, arg1,
..., argn. Ensemble, ils décrivent une liste d'un ou plusieurs pointeurs sur des chaînes de caractères
terminées par des caractères de code 0 qui représentent la liste des arguments disponibles pour le
programme à exécuter. Par convention, le premier argument doit pointer sur le nom du fichier associé au
programme à exécuter. La liste des arguments doit se terminer par un pointeur NULL, et puisque ce sont
des fonctions variadiques, ce pointeur doit être transtypé avec (char *) NULL.

A la différence des fonctions 'l', les fonctions 'v' (voir ci-dessous) spécifient les arguments de ligne
de commande du programme à exécuter sous la forme d'un tableau de pointeurs.

v - execv(), execvp(), execvpe()
L'argument char *const argv[] est un tableau de pointeurs sur des chaînes de caractères terminées par un
caractère de code 0 et représente la liste des arguments disponibles pour le nouveau programme . Par
convention, le premier argument doit pointer sur le nom du fichier associé au programme à exécuter. Le
tableau de pointeurs doit se terminer par un pointeur NULL.

e - execle(), execvpe()
L'environnement de l'appelant est spécifié à l'aide de l'argument envp. L'argument envp est un tableau de
pointeurs sur des chaînes de caractères terminées par des caractères de code 0, et qui doit se terminer
par un pointeur NULL.

Toutes les autres fonctions exec() (qui ne possèdent pas le suffixe 'e') extraient l'environnement pour
l'image du nouveau processus depuis la variable externe environ dans le processus appelant.

p - execlp(), execvp(), execvpe()
Ces fonctions dupliqueront les actions de l'interpréteur de commandes dans la recherche du fichier
exécutable si le nom fourni ne contient pas de barre oblique « / ». Le fichier est recherché dans la
liste de répertoires séparés par des deux-points indiquée dans la variable d'environnement PATH. Si cette
variable n'est pas définie, la liste de chemins par défaut correspondra à une liste contenant les
répertoires renvoyés par confstr(_CS_PATH) (qui renvoie en général la valeur "/bin:/usr/bin"), et
éventuellement le répertoire courant ; voir NOTES pour plus de détails.

Si le nom du fichier spécifié inclut une barre oblique, alors PATH est ignoré et le fichier dont le
chemin est fourni est exécuté.

De plus, certaines erreurs sont traitées de manière spécifique.

Si l'accès au fichier est refusé (execve(2) renvoie alors une erreur EACCES), ces fonctions continueront
à parcourir le reste du chemin de recherche. Si aucun fichier n'est trouvé, elles se termineront en
renvoyant errno défini à EACCES.

Si l'en-tête d'un fichier n'est pas reconnu (execve(2) renvoie alors une erreur ENOEXEC), ces fonctions
exécuteront l'interpréteur de commandes (/bin/sh) avec le chemin d'accès au fichier en tant que premier
argument. Si cette tentative échoue, aucune recherche supplémentaire ne sera effectuée.

Toutes les autres fonctions exec() (qui ne comportent pas le suffixe 'p') ont pour premier argument un
chemin (relatif ou absolu) qui spécifie le programme à exécuter.

VALEUR RENVOYÉE

       Les  fonctions  exec()  ne s'interrompent que si une erreur s'est produite. La valeur renvoyée est -1, et
       errno contient le code d'erreur.

ERREURS

       Toutes ces fonctions peuvent échouer et définir errno à n'importe quelle erreur décrite dans execve(2).

VERSIONS

       La fonction execvpe() a été introduite dans la glibc 2.11.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).
       ┌───────────────────────────────┬──────────────────────┬─────────────┐
       │ Interface                     │ Attribut             │ Valeur      │
       ├───────────────────────────────┼──────────────────────┼─────────────┤
       │ execl(), execle(), execv()    │ Sécurité des threads │ MT-Safe     │
       ├───────────────────────────────┼──────────────────────┼─────────────┤
       │ execlp(), execvp(), execvpe() │ Sécurité des threads │ MT-Safe env │
       └───────────────────────────────┴──────────────────────┴─────────────┘

CONFORMITÉ

       POSIX.1-2001, POSIX.1-2008.

       La fonction execvpe() est une extension GNU.

NOTES

Le chemin de recherche par défaut (utilisé lorsque l'environnement ne contient pas la variable PATH)
varie en fonction du système utilisé. Il contient en général /bin et /usr/bin (dans cet ordre) et parfois
aussi le répertoire courant. Sur certains systèmes et à titre de mesure anti-cheval de Troie, le
répertoire courant est inclus après /bin et /usr/bin. L'implémentation de la glibc quant à elle, a
longtemps conservé le chemin de recherche par défaut traditionnel où le répertoire courant se situe en
tête de liste. Cependant, suite à une réécriture du code lors du développement de la version 2.24 de la
glibc, le répertoire courant a été proprement éjecté du chemin de recherche. Ce changement de
comportement accidentel étant considéré cependant comme relativement bénéfique, il n'y aura pas de retour
en arrière.

Le comportement de execlp() et execvp() lorsqu'une erreur se produit pendant l'exécution d'un programme
est un comportement historique mais n'a traditionnellement jamais été documenté, ni spécifié dans la
norme POSIX. Lorsque ETXTBSY est rencontré, BSD (et peut-être d'autres systèmes) endorment le processus
appelant puis réitère l'opération. Sous Linux, cette situation est considérée comme une erreur grave, et
la commande se termine immédiatement.

Traditionnellement, les fonctions execlp() et execvp() ignoraient toutes les erreurs sauf celles décrites
ci-dessus, ENOMEM et E2BIG à la survenue desquelles elles se terminaient. Désormais, elles se terminent
si une autre erreur que celles-ci se produit.

BOGUES

       Dans  les  versions de la glibc antérieures à 2.24, execl() et execle() utilisaient realloc(3) en interne
       et n'étaient donc pas async-signal-safe, en violation des spécifications de POSIX.1. La version  2.24  de
       la glibc corrige ce problème.

   Détails spécifiques à l'architecture
       Sous  sparc  et  sparc64,  execv()  est  fournie en tant qu'appel système par le noyau (avec le prototype
       décrit ci-dessus) à titre de compatibilité avec SunOS. Sous ces architectures, la fonction  qui  sert  de
       frontal à execv() n'utilise pas cette fonction.

VOIR AUSSI

       sh(1), execve(2), execveat(2), fork(2), ptrace(2), fexecve(3), system(3), environ(7)

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des
       instructions  pour  signaler  des  anomalies et la dernière version de cette page peuvent être trouvées à
       l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

       La  traduction  française   de   cette   page   de   manuel   a   été   créée   par   Christophe   Blaess
       <https://www.blaess.fr/christophe/>,   Stéphan   Rafin   <stephan.rafin@laposte.net>,   Thierry   Vignaud
       <tvignaud@mandriva.com>, François Micaux, Alain Portal  <aportal@univ-montp2.fr>,  Jean-Philippe  Guérard
       <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-luc.coulon@wanadoo.fr>,   Julien   Cristau
       <jcristau@debian.org>,     Thomas     Huriaux      <thomas.huriaux@gmail.com>,      Nicolas      François
       <nicolas.francois@centraliens.net>,     Florentin     Duneau    <fduneau@gmail.com>,    Simon    Paillard
       <simon.paillard@resel.enst-bretagne.fr>,    Denis    Barbier    <barbier@debian.org>,    David     Prévot
       <david@tilapin.org> et Lucien Gentis <lucien.gentis@waika9.com>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General Public License
       version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel,  veuillez  envoyer  un  message  à
       debian-l10n-french@lists.debian.org.

GNU                                                2 août 2019                                           EXEC(3)