Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       execve - Executer un programme

SYNOPSIS

       #include <unistd.h>

       int execve(const char *filename, char *const argv[],
        char *const envp[]);

DESCRIPTION

       execve() execute le programme correspondant au fichier filename. Celui-
       ci doit etre un executable binaire ou bien un script commencant par une
       ligne du type :

           #! interpr'eteur [argument-optionnel]

       Pour  des  details  sur  ce  dernier  cas,  consultez << Scripts >> ci-
       dessous.

       argv  est  un  tableau  de  chaines  d'arguments  passees  au   nouveau
       programme.  envp  est  un  tableau  de chaines, ayant par convention la
       forme  cl'e=valeur,  qui  sont  passees  au  nouveau   programme   comme
       environnement.  argv ainsi que envp doivent se terminer par un pointeur
       NULL. Les arguments et l'environnement sont accessibles par le  nouveau
       programme dans sa fonction principale, lorsqu'elle est definie comme :

           int main(int argc, char *argv[], char *envp[])

       En  cas  de  reussite,  execve()  ne  revient  pas a l'appelant, et les
       segments de texte, de donnees (<< data >> et << bss >>), ainsi  que  la
       pile du processus appelant sont remplaces par ceux du programme charge.

       Si  l'on  effectuait  un ptrace(2) sur le programme appelant, un signal
       SIGTRAP est envoye apres la reussite de execve().

       Si le bit Set-UID est positionne sur le fichier filename, si le systeme
       de fichiers sous-jacent n'est pas monte nosuid (l'attribut MS_NOSUID de
       mount(2)), et si le  programme  n'est  pas  trace,  l'UID  effectif  du
       processus  appelant  est  modifie pour prendre celui du proprietaire du
       fichier. De meme,  lorsque  le  bit  Set-GID  est  positionne,  le  GID
       effectif est modifie pour correspondre a celui du groupe du fichier.

       L'UID  effectif  du  processus  est copie dans le Set-UID sauve ; de la
       meme maniere, le GID effectif est copie  dans  le  Set-GID  sauve.  Ces
       copies ont lieu apres toute modification d'ID effectif a cause des bits
       de permission Set-UID et Set-GID.

       Si l'executable est un fichier  binaire  a.out  lie  dynamiquement,  et
       contenant  des  appels aux bibliotheques partagees, le linker dynamique
       de Linux ld.so(8) est appele avant l'execution,  afin  de  charger  les
       bibliotheques partagees necessaires en memoire et d'effectuer l'edition
       des liens de l'executable.

       Si l'executable est au format  ELF  lie  dynamiquement,  l'interpreteur
       indique  dans  le  segment  PT_INTERP  sera  invoque  pour  charger les
       bibliotheques   partagees.   Cet    interpreteur    est    generalement
       /lib/ld-linux.so.1  pour  les fichiers binaires lies avec la libc Linux
       5, ou /lib/ld-linux.so.2 pour ceux lies avec la glibc 2.

       Tous les attributs du processus sont preserves lors  d'un  execve(),  a
       l'exception des suivants :

       *      Les   signaux   pour   lesquels  le  processus  avait  place  un
              gestionnaire  sont  reinitialises  a  leur  valeur  par   defaut
              (consultez signal(7)).

       *      L'eventuelle  pile  specifique pour les gestionnaires de signaux
              n'est pas conservee (sigaltstack(2)).

       *      Les projections en memoire ne sont pas conservees (mmap(2)).

       *      Les  segments  de  memoire  partagee  System  V  sont   detaches
              (shmat(2)).

       *      Les   objets   de   memoire   partagee   POSIX   sont  supprimes
              (shm_open(3)).

       *      Les descripteurs de files de messages POSIX ouverts sont  fermes
              (mq_overview(7)).

       *      Les    semaphores    nommes    POSIX    ouverts    sont   fermes
              (sem_overview(7)).

       *      Les   temporisations    POSIX    ne    sont    pas    conservees
              (timer_create(2)).

       *      Les flux de repertoires ouverts sont fermes (opendir(3)).

       *      Les  verrouillages  de  memoire ne sont pas preserves (mlock(2),
              mlockall(2)).

       *      Les  gestionnaires  de  terminaison  ne   sont   pas   preserves
              (atexit(3), on_exit(3)).

       *      L'environnement de travail en virgule flottante est remis a zero
              (consultez fenv(3)).

       Les  attributs  de  processus  listes  ci-dessus  sont  specifies  dans
       POSIX.1-2001.  Les  attributs de processus specifiques a Linux suivants
       sont egalement reinitialises lors d'un execve() :

       *  L'attribut PR_SET_DUMPABLE  de  prctl(2)  est  active,  sauf  si  un
          programme setuid ou setgid est execute, auquel cas il est desactive.

       *  L'attribut PR_SET_KEEPCAPS de prctl(2) est efface.

       *  Le nom du processus, positionne par prctl(2) PR_SET_NAME (et affiche
          avec ps -o comm), est reinitialise avec le nom du nouvel executable.

       *  Le signal de  terminaison  est  reinitialise  a  SIGCHLD  (consultez
          clone(2)).

       Notez egalement les points suivants :

       *  Tous  les  threads  autre  que  l'appelant  sont  detruits lors d'un
          execve(). Les mutex, les  variables  de  condition,  et  les  autres
          objets de pthreads sont detruits.

       *  L'equivalent  de  setlocale(LC_ALL, "C") est execute au demarrage du
          programme.

       *  POSIX.1-2001 indique que les actions pour  les  signaux  ignores  ou
          places  a  la valeur par defaut ne sont pas modifiees. Une exception
          est neanmoins specifiee dans POSIX.1-2001 : si SIGCHLD  est  ignore,
          l'implementation peut laisser l'action inchangee ou la replacer a la
          valeur par defaut ; Linux ne modifie pas l'action.

       *  Toutes les operations  d'E/S  asynchrones  en  cours  sont  annulees
          (aio_read(3), aio_write(3)).

       *  Pour  le  traitement  des  capacites  lors  d'un execve(), consultez
          capabilities(7).

       *  Par defaut, les descripteurs de fichier restent ouverts  au  travers
          d'un  execve(). Les descripteurs marques close-on-exec sont fermes ;
          consultez  la  description  de  FD_CLOEXEC  dans  fcntl(2).  (Si  un
          descripteur  de  fichier est ferme, cela cause la liberation de tous
          les verrous d'enregistrement obtenus sur  le  fichier  correspondant
          par ce processus. Consultez fcntl(2) pour les details.) POSIX.1-2001
          indique que si les descripteurs de fichiers 0, 1 et 2 devaient  etre
          fermes  apres un execve() reussi, et le processus devient privilegie
          en raison d'un  bit  set-user-ID  ou  set-group-ID  sur  le  fichier
          execute,  le systeme peut ouvrir un fichier non specifie pour chacun
          de ces descripteurs. En general, un programme  portable,  privilegie
          ou  pas, peut considerer que ces trois descripteurs resteront fermes
          apres un execve().

   Scripts
       Un script est un fichier dont le bit d'execution est active et dont  la
       premiere ligne est de la forme :

           #! interpr'eteur [argument-optionnel]

       L'interpr'eteur  doit  etre  un nom de fichier valide pour un executable
       qui n'est pas un script lui-meme. Si l'argument  filename  de  execve()
       indique  un  script,  l'interpr'eteur  sera  appele  avec  les arguments
       suivants :

           interpr'eteur [argument-optionnel] filename arg...

       ou arg... est la liste de mots pointee par l'argument argv de execve().

       Pour etre portable, argument-optionnel doit soit etre absent, soit etre
       un  seul  mot  (c'est-a-dire  ne pas contenir d'espace) ; consultez les
       NOTES ci-dessous.

   Limites sur la taille des param`etres et environnement
       La plupart des implementations Unix imposent des limites sur la  taille
       totale  des  chaines des parametres des lignes de commande (argv) et de
       l'environnement (envp) qui peuvent etre passees a un nouveau programme.
       POSIX.1   permet  a  une  implementation  d'annoncer  cette  limite  en
       utilisant la constante ARG_MAX  (soit  definie  dans  <limits.h>,  soit
       disponible a l'execution en utilisant l'appel sysconf(_SC_ARG_MAX)).

       Sur  les  noyaux  Linux  anterieurs  a 2.6.23, la memoire utilisee pour
       stocker les chaines d'environnement et d'arguments etait limitee  a  32
       pages   (defini   par   la  constante  noyau  MAX_ARG_PAGES).  Sur  les
       architectures dont la taille de page est 4 Ko, cela donne un maximum de
       128 Ko.

       Sur  les  noyaux 2.6.23 et ulterieurs, la plupart des architectures ont
       une limite  de  taille  derivee  de  la  limite  de  ressources  souple
       RLIMIT_STACK  (consultez  getrlimit(2)) qui est en vigueur au moment de
       l'appel a execve() (ce n'est pas le cas  pour  les  architectures  sans
       unite  de  gestion  memoire :  elles  conservent  la  limite des noyaux
       anterieurs a 2.6.23). Ce changement permet aux programmes  d'avoir  une
       liste  de  parametre  ou un environnement beaucoup plus grand. Pour ces
       architectures, la taille totale est limitees a 1/4 de la taille de pile
       permise  (imposer  une  limite  de  1/4 permet d'assurer que le nouveau
       programme garde de l'espace pour la  pile).  Depuis  Linux  2.6.25,  le
       noyau place une limite inferieure de 32 pages a cette limite de taille,
       de telle sorte que  meme  si  RLIMIT_STACK  est  tres  faible,  il  est
       garantit aux applications qu'elles auront au moins autant de place pour
       les parametres et leur environnement que ce qui etait fournit par Linux
       2.6.23  et les precedents (cette garantie n'etait pas presente dans les
       noyaux 2.6.23 et 2.6.24). De plus, la limite par chaine est de 32 pages
       (la  constante  noyau  MAX_ARG_STRLEN), et le nombre maximal de chaines
       est de 0x7FFFFFFF.

VALEUR RENVOY'EE

       En cas de reussite, execve() ne revient pas, en cas d'echec il  renvoie
       -1 et errno contient le code d'erreur.

ERREURS

       E2BIG  Le nombre total d'octets dans l'environnement (envp) et la liste
              d'arguments (argv) est trop grand.

       EACCES La permission de parcours est refusee pour un des composants  du
              chemin   filename   ou  du  nom  d'un  interpreteur  de  script.
              (Consultez aussi path_resolution(7).)

       EACCES Le fichier ou l'interpreteur de  script  n'est  pas  un  fichier
              regulier.

       EACCES L'autorisation  d'execution  est  refusee pour le fichier, ou un
              interpreteur de script, ou un interpreteur ELF.

       EACCES Le systeme de fichiers est monte avec l'option noexec.

       EFAULT L'argument filename pointe en  dehors  de  l'espace  d'adressage
              accessible.

       EINVAL Un  executable  ELF  a  plusieurs  segments  PT_INTERP  (indique
              plusieurs interpreteurs).

       EIO    Une erreur d'entree-sortie s'est produite.

       EISDIR L'interpreteur ELF cite est un repertoire.

       ELIBBAD
              L'interpreteur ELF mentionne n'est pas dans un format connu.

       ELOOP  Le chemin d'acces au fichier filename, ou a un  interpreteur  de
              script,  ou  a  un  interpreteur  ELF,  contient  une  reference
              circulaire (a travers un lien symbolique)

       EMFILE Le nombre maximal de fichiers ouverts par processus est atteint.

       ENAMETOOLONG
              La chaine de caracteres filename est trop longue.

       ENFILE La limite du nombre total de fichiers ouverts sur le  systeme  a
              ete atteinte.

       ENOENT Le fichier filename ou un script ou un interpreteur ELF n'existe
              pas, ou une bibliotheque partagee necessaire pour le fichier  ou
              l'interpreteur n'est pas disponible.

       ENOEXEC
              Le  fichier  executable  n'est  pas  dans  le bon format, ou est
              destine a une autre architecture.

       ENOMEM Pas assez de memoire pour le noyau.

       ENOTDIR
              Un element du chemin d'acces au fichier filename, a un script ou
              a un interpreteur ELF, n'est pas un repertoire.

       EPERM  Le  systeme  de  fichiers est monte avec l'attribut nosuid et le
              fichier a un bit Set-UID ou Set-GID positionne.

       EPERM  Le processus est suivi avec ptrace(2), l'utilisateur  n'est  pas
              le  superutilisateur,  et le fichier a un bit Set-UID ou Set-GID
              positionne.

       ETXTBSY
              Un executable a ete ouvert  en  ecriture  par  un  ou  plusieurs
              processus.

CONFORMIT'E

       SVr4,   BSD 4.3,   POSIX.1-2001.   POSIX.1-2001  ne  documente  pas  le
       comportement avec << #! >> mais est neanmoins compatible.

NOTES

       Les processus Set-UID  et  Set-GID  ne  peuvent  pas  etre  suivis  par
       ptrace(2).

       Linux ignore les bits Set-UID et Set-GID sur les scripts.

       Le  resultat d'un montage de systeme de fichiers avec l'attribut nosuid
       peut varier suivant les versions du noyau Linux : certaines  refuseront
       l'execution  des  fichiers  Set-UID et Set-GID lorsque cela donnerait a
       l'appelant des privileges qu'il n'a pas (et renverront l'erreur EPERM),
       d'autres  ignoreront  simplement  les  bits  Set-UID  et  Set-GID  mais
       accepteront d'effectuer l'appel exec().

       La premiere ligne d'un shell script  executable  (#!)  a  une  longueur
       maximale de 127 caracteres.

       La  semantique  de  l'argument-optionnel  d'un script differe selon les
       implementations.  Sous  Linux,  la  chaine   qui   suit   le   nom   de
       l'interpr'eteur  est passee a l'interpreteur comme un seul mot, et cette
       chaine peut  contenir  des  espaces.  Cependant,  le  comportement  est
       different  sur d'autres systemes. Certains utilisent la premiere espace
       comme fin de l'argument-optionnel. Sur  certains  systemes,  un  script
       peut   avoir  plusieurs  arguments,  delimites  par  des  espaces  dans
       argument-optionnel.

       Sous Linux, argv peut etre  NULL,  ce  qui  a  le  meme  effet  que  de
       specifier  que cet argument est un pointeur vers une liste contenant un
       pointeur NULL unique. Ne vous servez  pas  de  cette  caract'eristique !
       Elle  n'est ni standard ni portable : sur la plupart des systemes Unix,
       faire cela causera une erreur.

       POSIX.1-2001 indique  que  les  valeurs  renvoyees  par  sysconf(3)  ne
       doivent  pas  changer  pendant la vie d'un processus. Cependant, depuis
       Linux 2.6.23, si la limite de ressources RLIMIT_STACK change, alors  la
       valeur  renvoyee  par  _SC_ARG_MAX changera egalement, pour refleter le
       fait que la limite de l'espace qui recoit les parametres de la ligne de
       commande et les variables d'environnement a change.

   Historique
       Avec Unix V6, la liste des arguments d'un appel exec() se terminait par
       0, alors que la liste des arguments de main se terminait par -1. Aussi,
       cette  liste  d'arguments  n'etait  pas  utilisable directement dans un
       appel exec() supplementaire. Depuis Unix V7, les deux terminateurs sont
       NULL.

EXEMPLE

       Le  programme  suivant  est  concu  pour  etre  execute  par  le second
       programme ci-dessous. Il se contente d'afficher sa ligne  de  commande,
       un argument par ligne.

           /* myecho.c */

           #include <stdio.h>
           #include <stdlib.h>

           int
           main(int argc, char *argv[])
           {
               int j;

               for (j = 0; j < argc; j++)
                   printf("argv[%d]: %s\n", j, argv[j]);

               exit(EXIT_SUCCESS);
           }

       Ce  programme  peut etre utilise pour executer le programme donne comme
       argument de ligne de commande :

           /* execve.c */

           #include <stdio.h>
           #include <stdlib.h>
           #include <unistd.h>

           int
           main(int argc, char *argv[])
           {
               char *newargv[] = { NULL, "hello", "world", NULL };
               char *newenviron[] = { NULL };

               if (argc != 2) {
                fprintf(stderr, "Usage: %s <file-to-exec>\n", argv[0]);
                exit(EXIT_FAILURE);
               }

               newargv[0] = argv[1];

               execve(argv[1], newargv, newenviron);
               perror("execve");   /* execve() ne retourne qu'en cas d'erreur */
               exit(EXIT_FAILURE);
           }

       On peut utiliser le second programme pour executer  le  premier  de  la
       facon suivante :

           $ cc myecho.c -o myecho
           $ cc execve.c -o execve
           $ ./execve ./myecho
           argv[0]: ./myecho
           argv[1]: hello
           argv[2]: world

       On  peut  aussi utiliser ces programmes pour montrer l'utilisation d'un
       interpreteur de  scripts.  Pour  ce  faire,  on  cree  un  script  dont
       l'<< interpreteur >> est notre programme myecho :

           $ cat > script.sh
           #! ./myecho script-arg
           ^D
           $ chmod +x script.sh

       On peut alors utiliser notre programme pour executer le script :

           $ ./execve ./script.sh
           argv[0]: ./myecho
           argv[1]: script-arg
           argv[2]: ./script.sh
           argv[3]: hello
           argv[4]: world

VOIR AUSSI

       chmod(2),   fork(2),   ptrace(2),   execl(3),   fexecve(3),  getopt(3),
       credentials(7), environ(7), path_resolution(7), ld.so(8)

COLOPHON

       Cette page fait partie de  la  publication  3.27  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      etre       trouvees       a       l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis  2010,  cette  traduction est maintenue a l'aide de l'outil po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone        au        sein        du       projet       perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Christophe Blaess  <URL:http://www.blaess.fr/christophe/>  (1996-2003),
       Alain   Portal  <URL:http://manpagesfr.free.fr/>  (2003-2006).   Julien
       Cristau et l'equipe francophone de traduction de Debian (2006-2009).

       Veuillez  signaler  toute  erreur   de   traduction   en   ecrivant   a
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir acces a la version anglaise de  ce  document
       en utilisant la commande << man -L C <section> <page_de_man> >>.