Provided by: manpages-nl-dev_4.21.0-2_all bug

NAAM

       execve - voer programma uit

BIBLIOTHEEK

       Standard C bibliotheek  (libc, -lc)

SAMENVATTING

       #include <unistd.h>

       int execve(const char *padnaam, char *const argv[],
                  char *const _NULL_baarenvp[]);

BESCHRIJVING

       execve()  voert  het  programma  uit  waar  padnaam naar wijst.  Dit zorgt er voor dat het
       programma dan momenteel wordt uitgevoerd door het aanroepende proces wordt vervangen  door
       een  nieuw  programma,  met  een niet-geïnitialiseerde stack, heap en (geïnitialiseerde en
       niet-geïnitialiseerde) data segmenten.

       padnaam moet ofwel een binair uitvoerbaar bestand zijn, ofwel een script  dat  begint  met
       een regel van de vorm:

           #!interpreter[optioneel-arg]

       Voor details over het laatste geval, zie "Interpreter scripts" hieronder.

       argv  is  een  lijst  van  wijzers naar tekenreeksen die worden doorgegeven naar een nieuw
       programma als zijn commando-regel  argumenten.  Per  conventie  zou  de  eerste  van  deze
       tekenreeksen  (m.a.w.  argv[0]) de bestandsnaam moeten zijn van het bestand dat uitgevoerd
       wordt. De argv lijst moet worden afgesloten met een  NULL  wijzer.  (Daarom,  zal  in  het
       nieuwe programma, argv[argc] NULL zijn.)

       envp  is een lijst van wijzers naar tekenreeksen, bij conventie van de vorm key=value, die
       worden doorgegeven als omgeving van  een  nieuw  programma.  De  envp  lijst  moet  worden
       afgesloten met een NULL wijzer.

       Deze  handleiding beschrijft de Linux systeem aanroep in detail; voor een overzicht van de
       nomenclatuur en de vele, vaak te prefereren, gestandaardiseerde varianten van  de  functie
       voorzien in libc, inclusief die de PATH omgevingsvariabele doorzoeken, zie exec(3).

       De  argumenten  vector  en  omgeving  kunnen  worden benaderd door de main-functie van het
       nieuwe programma, mits deze is gedefinieerd als:

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

       Let evenwel  op  dat  het  gebruik  van  het  derde  argument  van  de  main-functie  niet
       gespecificeerd  is in POSIX.1; volgens POSIX.1, zou de omgeving moeten worden benaderd via
       de externe variabele environ(7).

       Bij  succes  keert   execve()   niet   terug,   en   de   text,   geïnitialiseerde   data,
       niet-geinitialiseerde  data  (bss) en stack van het aanroepende proces worden overschreven
       volgens de inhoud van het nieuw geladen programma.

       Als het huidige programma momenteel wordt ge-ptrace´ed, dan wordt er een  SIGTRAP  signaal
       naar verstuurd na een succesvolle execve() aanroep .

       Als  het  set-user-ID  bit  is gezet op het programma bestand aangewezen door padnaam, dan
       wordt het effectieve gebruiker ID van het aanroepende proces veranderd  naar  dat  van  de
       eigenaar van het programma bestand. Vergelijkbaar, is het set-group-ID bit is gezet op het
       programma bestand, dan wordt het effectieve group ID van het aanroepende proces  gezet  op
       de groep van het programma bestand.

       De hiervoor genoemde transformaties van de effectieve ID worden niet uitgevoerd (m.a.w. de
       set-user-ID en set-group-ID bits worden genegeerd) als een van de volgende waar is:

       •  het  no_new_privs attribuut wordt gezet voor de aanroepende thread (zie prctl(2));

       •  het  onderliggende  bestandssysteem  is  gekoppeld  nosuid  (de  MS_NOSUID  vlag   voor
          mount(2)); of

       •  het aanroepende proces wordt ge-ptrace´d.

       De  capaciteiten  van  het programma bestand (zie capabilities(7) worden ook genegeerd als
       enig van de bovenstaande waar is.

       Het effectieve gebruiker ID van het proces wordt gekopieerd naar het bewaarde set-user-ID;
       vergelijkbaar,  het  effectieve  groep ID wordt gekopieerd naar het bewaarde set-group-ID.
       Het kopiëren  vindt  plaats  na  effectieve  ID  veranderingen  die  optreden  vanwege  de
       set-user-ID en set-group-ID modus bits.

       De echte UID en echte GID van het proces, zowel als zijn supplementaire groep ID´s blijven
       onveranderd door de aanroep van execve().

       Als het uitvoerbaar bestand een a.out dynamisch gelinked binair uitvoerbaar bestand is dat
       ook  shared-library  stompjes  bevat,  dan  wordt  de  Linux  dynamische  linker  ld.so(8)
       aangeroepen na de aanvang van uitvoering, om zo de  benodigde  gedeelde  objecten  in  het
       geheugen te laden en het uitvoerbaar bestand hiermee te linken.

       Als  de  executable  een  dynamisch  gelinkte  ELF executable is, dan wordt de interpreter
       genoemd in het PT_INTERP segment gebruikt om de benodigde gedeelde objecten te laden. Deze
       interpreter  is  typisch /lib/ld-linux.so.2 voor binaire bestanden gelinked met glibc (zie
       ld-linux.so(8)).

   Effect op proces attributen
       Alle proces attributen blijven behouden tijdens een execve(), behalve de volgende:

       •  De disposities van elk signaal dat wordt gevangen  wordt  gereset  naar  het  standaard
          (signal(7)).

       •  Alle afwisselende signaal stacks blijven niet behouden (sigaltstack(2)).

       •  Geheugen indelingen blijven niet behouden (mmap(2)).

       •  Aangekoppelde System V gedeelde geheugen segmenten worden los gekoppeld (shmat(2)).

       •  POSIX gedeelde geheugen regionen worden vrijgegeven (shm_open(3)).

       •  Open POSIX berichtrij beschrijvingen worden gesloten  (mq_overview(7)).

       •  Alle open POSIX genaamde semaforen worden gesloten  (sem_overview(7)).

       •  POSIX timers blijven niet behouden (timer_create(2)).

       •  Alle open map streams worden gesloten (opendir(3)).

       •  Geheugen sloten blijven niet behouden mlock(2), mlockall(2)).

       •  Beëindiging afhandelaren blijven niet behouden (atexit(3), on_exit(3)).

       •  De drijvende-komma omgeving wordt gereset naar de standaard (zie fenv(3)).

       De  proces  attributen  in  de  voorafgaande lijst zijn alle gespecificeerd in POSIX.1. De
       volgende Linux-specifieke proces attributen blijven niet behouden tijdens een execve():

       •  Het "dumpable" attribuut van het proces is gezet  op  de  waarde  1,  behalve  als  een
          set-user-ID  programma,  of  een  programma  met capaciteiten wordt uitgevoerd, in welk
          geval de "dumpable" vlag mag worden gereset op de waarde in /proc/sys/fs/suid_dumpable,
          in  de  omstandigheden  zoals  beschreven  in  PR_SET_DUMPABLE in prctl(2). Merk op dat
          veranderingen in het ¨dumpable" attribuut ervoor kunnen zorgen  dat  het  eigenaarschap
          van  de  bestanden  in  de  /proc/pid  map  van het proces kunnen worden veranderd naar
          root:root, zoals beschreven in proc(5).

       •  De prctl(2)  PR_SET_KEEPCAPS vlag wordt gewist.

       •  (Vanaf Linux 2.4.36 / 2.6.23)  Als  een  set-user-ID  of  set-user-ID  programma  wordt
          uitgevoerd,  dan  wordt  het  dood  signaal  van  de  ouder,  gezet  door  de  prctl(2)
          PR_SET_PDEATHSIG vlag, gewist.

       •  De proces naam, zoals gezet door prctl(2)  PR_SET_NAME (en getoond  door  ps -o  comm),
          wordt gereset naar de naam van het nieuwe uitvoerbare bestand.

       •  De SECBIT_KEEP_CAPS securebits vlag wordt gewist.  Zie capabilities(7).

       •  Het beëindiging signaal wordt gereset naar SIGCHLD (zie clone(2)).

       •  De  bestandsindicator tabel is niet meer gedeeld, daarbij het effect van de CLONE_FILES
          vlag van clone(2) ongedaan makend.

       Let op de volgende punten:

       •  Alle thread anders dan de aanroepende thread worden vernietigd  tijdens  een  execve().
          Mutexes, conditie variabelen, en andere pthreads objecten blijven niet behouden.

       •  Het  equivalent  van  setlocale(LC_ALL,  "C")  wordt  uitgevoerd  bij  de start van een
          programma.

       •  POSIX.1 specificeert dat de disposities van enig signaal dat wordt genegeerd  of  gezet
          op  de  standaard onveranderd zullen blijven. POSIX.1 specificeer een uitzondering: als
          SIGCHLD wordt genegeerd, dan mag de implementatie deze dispositie onveranderd laten  of
          deze op de standaard zetten; Linux doet het eerste.

       •  Alle  uitstaande  asynchrone  Invoer/Uitvoer  operaties  worden beëindigd (aio_read(3),
          aio_write(3)).

       •  Voor de behandeling van capaciteiten tijdens execve(), zie capabilities(7).

       •  Standaard blijven bestandsindicatoren open langs een execve(). Bestandsindicatoren  die
          zijn  gemarkeerd  als close-on-exec worden gesloten; die de beschrijving van FD_CLOEXEC
          in fcntl(2).  (Als een bestandsindicator wordt gesloten, dan zal dit  de  vrijgave  van
          alle  locks op het onderliggende bestand door dit proces veroorzaken. Zie fcntl(2) voor
          details.) POSIX.1 zegt dat als de bestandsindicatoren 0,  1  en  2  ook  zouden  worden
          gesloten  na  een  succesvolle execve(),  en het proces zou privileges verkrijgen omdat
          het set-user-ID of set-group-ID bit werd gezet om het uitgevoerde bestand, dan mag  het
          systeem  een  niet gespecificeerd bestand voor elk van deze bestandsindicatoren openen.
          Als  een  algemeen  principe  kan  een  niet-overdraagbaar  programma,  al   dan   niet
          geprivilegieerd,  aannemen dat deze drie bestandsindicatoren gesloten blijven langs een
          execve().

   Interpreter scripts
       Een interpreter script is een tekst bestand met de uitvoer permissie aan  gezet  en  wiens
       eerste regel van de vorm is:

           #!interpreter[optioneel-arg]

       De interpreter moet een geldige padnaam voor een uitvoerbaar bestand zijn.

       Als  het  padnaam  argument  van  execve()  een interpreter script specificeert dan zal de
       interpreter worden aangeroepen met de volgende argumenten:

           interpreter  [optional-arg] padnaam arg...

       waar padnaam de padnaam van het bestand dat als eerste argument  werd  gespecificeerd  van
       execve(),  en  arg...  is een serie woorden aangewezen door het argv argument van execve()
       beginnende bij argv[1]. Merk op dat er  geen  manier  is  om  argv[0]  te  verkrijgen  die
       doorgegeven werd naar de execve() aanroep.

       Voor  overdraagbaar  gebruik,  zou  optional-arg  afwezig  moeten  zijn  of  moeten worden
       gespecificeerd als een enkel woord (m.a.w. het zou geen witruimtes moeten  bevatten);  zie
       OPMERKINGEN hieronder.

       Vanaf  Linux 2.6.28 staat de kernel toe dat de interpreter van een script, zelf een script
       is. Dit recht is recursief, tot aan een limiet van vier recursies,  zodat  de  interpreter
       een script  mag zijn dat wordt geïnterpreteerd door een script, en zo voorts.

   Limieten op de grootte van argumenten en omgeving
       De  meeste UNIX implementaties stellen een limiet aan de totale lengte van het argument op
       de commando regel (argv) en de omgevings (envp) tekenreeksen die mogen worden  doorgegeven
       aan  een  nieuw  programma.  POSIX.1 staat een implementatie toe deze limiet te adverteren
       gebruikmakend van de ARG_MAX constante (ofwel gedefinieerd in <limits.h> ofwel beschikbaar
       tijdens de uitvoering door gebruik te maken van de aanroep sysconf(_SC_ARG_MAX)).

       Voor  Linux  2.6.23,  was  het  geheugen  dat gebruikt wordt om de omgeving en de argument
       tekenreeksen op te slaan beperkt tot 32 pagina´s  (gedefinieerd  in  de  kernel  constante
       MAX_ARG_PAGES).  Bij  architecturen  met  een  4-kB  pagina grootte, dit geeft een maximum
       grootte van 128 kB.

       Op Linux 2.6.23 en later, ondersteunen de meeste architecturen een grootte limiet afgeleid
       van  de zachte RLIMIT_STACK hulpbron limiet (zie getrlimit(2))  die geldig is te tijde van
       de execve() aanroep.  (Architecturen zonder geheugen management  unit  zijn  uitgezonderd:
       deze  behouden  de  limiet  die  geldig  was  voor  Linux 2.6.23.)  Deze verandering staat
       programma´s toe een veel grotere argument en/of omgevings  lijst  te  hebben.   Voor  deze
       architecturen, is de totale grootte beperkt tot 1/4 van de toegestane stack grootte.  (Het
       opleggen van de 1/4-limiet verzekert dat een nieuw programma  altijd  enige  stack  ruimte
       heeft.)   Daarenboven  is de totale grootte beperkt tot 3/4 van de waarde van de constante
       _STK_LIM (8 MiB).  Vanaf Linux 2.6.25, zet de kernel een ondergrens  van  32  pagina´s   o
       deze  grootte  limiet,  zodat  zelfs,  wanneer RLIMIT_STACK erg laag is gezet, applicaties
       worden gegarandeerd dat ze op zijn minst  evenveel   argument  en  omgevingsruimte  hebben
       zoals  voorzien  door  Linux 2.6.22 en eerder.  (Deze garantie werd niet voorzien in Linux
       2.6.23 en 2.6.24.) Aanvullend:  de  limiet  per  tekenreeks  is  32  pagina´s  (de  kernel
       constante MAX_ARG_STRLEN), en het maximum aantal tekenreeksen is 0x7FFFFFFF.

EIND WAARDE

       Bij  succes  keert  execve()  niet  terug, bij falen wordt -1 teruggegeven, en wordt errno
       overeenkomstig gezet.

FOUTEN

       E2BIG  Het totaal aantal bytes in de omgeving (envp) en de argumenten lijst (argv)  is  te
              groot.

       EACCES Zoek  recht wordt geweigerd op een component van het pad voorvoegsel van padnaam of
              de naam van een script interpreter. Zie ook path_resolution(7).)

       EACCES Het bestand of de script interpreter is geen normaal bestand.

       EACCES Uitvoer  toestemming  werd  geweigerd  voor  het  bestand  of  een  script  of  ELF
              interpreter.

       EACCES Het bestandsysteem is gemount met noexec.

       EAGAIN (sinds Linux 3.1)
              Ondanks  dat  de  echte UID van de aanroeper is verandert door een van de set*uid()
              aanroepen, was en — is nog steeds— de aanroeper nog steeds boven zijn  RLIMIT_NPROC
              resource  limiet  (zie  setrlimit(2)).  Voor een gedetailleerde verklaring van deze
              fout, zie OPMERKINGEN.

       EFAULT padnaam of een van de wijzers in de vectoren argv of envp  wijst  buiten  door  de,
              voor u, toegankelijke adres ruimte.

       EINVAL Een  ELF uitvoerbaar bestand heeft meer dan 1 PT_INTERP segment (probeerde meer dan
              1 interpreter te benoemen).

       EIO    Een Invoer/Uitvoer fout trad op.

       EISDIR Een ELF interpreter was een map.

       ELIBBAD
              Een ELF interpreter had een onbekende vorm.

       ELOOP  Teveel symbolische koppelingen werden tegengekomen bij het "oplossen"  van  padnaam
              of de naam van een script of ELF interpreter.

       ELOOP  De  maximale  recursie  limiet werd bereikt door uitvoeren van de recursieve script
              interpreter (zie "Interpreter scripts", hierboven) Voor  Linux  3.8  werd  de  fout
              ENOEXEC geproduceerd voor dit geval.

       EMFILE De per-proces limiet van het aantal open bestandsbeschrijvingen werd bereikt.

       ENAMETOOLONG
              padnaam is te lang.

       ENFILE De grens aan het aantal open bestanden van het systeem is bereikt.

       ENOENT Het bestand padnaam of een script of een ELF interpreter bestaat niet.

       ENOEXEC
              Een  uitvoerbaar  bestand  is  niet  in  een bekende vorm: het is voor de verkeerde
              architectuur, of heeft  een  of  andere  vormfout  waardoor  het  niet  kan  worden
              uitgevoerd.

       ENOMEM Onvoldoende kernelgeheugen voorhanden.

       ENOTDIR
              Een  deel  van het pad-voorvoegsel van padnaam of van een script of ELF interpreter
              is geen map.

       EPERM  Het  bestandssysteem  was  gekoppeld  met  nosuid,  de   gebruiker   is   niet   de
              supergebruiker, en het bestand heeft het set-user-ID of set-group-ID bit aan staan.

       EPERM  Het  proces  wordt  gevolgd,  de gebruiker is niet de supergebruiker en het bestand
              heeft een set-user-ID of set-group-ID bit aan staan.

       EPERM  Een  "domme-capaciteiten"  toepassing  zou  niet  de  volledige   verzameling   van
              toegestane  capaciteiten  die  door  het  uitvoerbaar bestand zijn toegekend kunnen
              verkrijgen. Zie capaciteiten(7).

       ETXTBSY
              Uitvoerbaar bestand is open voor schrijven bij een of meer processen.

VOLDOET AAN

       POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD.  POSIX documenteert het #! gedrag niet, maar het
       bestaat (met enige variaties) op andere UNIX systems.

OPMERKINGEN

       Soms  ziet  men   execve()   (en  de  gerelateerde  functies  beschreven  in  in  exec(3))
       beschreven als "uitvoeren van een nieuw proces" (of  vergelijkbaar).  Dit  is  een  hoogst
       misleidende  beschrijving:  er  is  geen nieuw proces; veel attributen van het aanroepende
       proces blijven onveranderd (in het bijzonder, zijn PID). Het enige dat  execve()  doet  is
       het  regelen  dat  een  bestand  proces  (het  aanroepende  proces)  een nieuw program kan
       uitvoeren.

       Set-user-ID en set-group-ID processen kunnen niet ptrace(2)d zijn.

       Het resultaat van het aankoppelen van een bestandssysteem nosuid varieert van Linux kernel
       versies:  sommigen  weigeren  het  uitvoeren  van  set-user-ID en set-group-ID uitvoerbare
       bestanden als dat zou betekenen dat de gebruiker rechten zou krijgen die hij  eerder  niet
       had  (en EPERM retourneren), sommige zullen de set-user-ID en set-group-ID bits negeren en
       exec() succesvol uitvoeren,

       Op Linux kunnen argv en envp worden opgegeven  als  NULL.  In  beide  gevallen  heeft  dat
       hetzelfde  effect  als  het opgeven van het argument als een wijzer naar een lijst die een
       enkele NULL wijzer bevat. Maak geen gebruik van dit niet-standaard  en  neit-overdraagbaar
       gedrag.  Op veel andere Linux systemen zal het opgeven van argv als NULL resulteren in een
       fout (EFAULT). Sommige andere Linux systemen behandelen het envp==NULL geval hetzelfde als
       Linux.

       POSIX.1  zegt  dat  waarden  zoals teruggeven worden door sysconf(3) niet mogen veranderen
       gedurende de levensduur van een proces. Hoewel vanaf  Linux  2.6.23  de  door  _SC_ARG_MAX
       gerapporteerde  waarde zal veranderen zodra de RLIMIT_STACK resource limiet veranderd. Dit
       om  het  feit  aan  te  geve  dan  de  limiet  op  de  ruimte  die  de  argumenten  en  de
       omgevingsvariabelen op commando regel in beslag nemen werd veranderd.

       In  de  meeste  gevallen waar execve() faalt, wordt controle naar de originele uitvoerbare
       afbeelding teruggegeven, en kan de  aanroeper  van  execve()  de  foutmelding  afhandelen.
       Hoewel,  in  (zeldzame) gevallen (typisch veroorzaakt door uitputting van hulpbronnen) kan
       een fout optreden voorbij het punt waarbij terugkeer niet mogelijk is:  de  oorspronkelijk
       uitvoerbare afbeelding is al afgebroken, maar de nieuwe nog niet compleet gebouwd. In deze
       gevallen, stopt de kernel het proces met een SIGSEGV (SIGKILL tot Linux 3.17) signaal.

   Interpreter scripts
       De kernel beperkt de maximale lengte van de tekst die volgt op de "#!"   lettertekens  aan
       het  begin  van  een script; lettertekens voorbij deze limiet worden genegeerd. Voor Linux
       5.1 bedroeg deze limiet 127 tekens. Vanaf Linux 5.1 bedraagt de limiet 255 tekens.

       De semantiek van het  optional-arg  argument  van  een  interpreter  script  varieert  per
       implementatie.  Op  Linux  wordt  de volledige tekenreeks die volgt op de interpreter naam
       doorgegeven als één enkel argument aan  de  interpreter,  en  mag  deze  tekenreeks  witte
       spaties bevatten. Hoewel dit gedrag verschilt op enkelen andere systemen. Sommige systemen
       gebruiken de eerste witte spatie om optional-arg te beëindigen. Op  sommige  systemen  kan
       een interpeter-script meerdere argumenten hebben, en kunnen witte spaties in  optional-arg
       worden gebruikt om argumenten te onderscheiden.

       Linux (net als andere moderne UNIX systemen) negeert de set-user-ID en  set-group-ID  bits
       bij scripts.

   execve() en EAGAIN
       Een  meer  gedetailleerde uitleg van de EAGAIN fout die kan optreden (vanaf Linux 3.1) bij
       het aanroepen van execve() is als volgt.

       De EAGAIN fout kan optreden wanneer een voorafgaande aanroep van  setuid(2),  setreuid(2),
       of setresuid(2) ervoor zorgde dat het echte user ID van het proces veranderde, en dat deze
       verandering er voor zorgde dat het proces zijn RLIMIT_NPROC  hulpbron  limiet  overschreed
       (m.a.w.  het  aantal  processen  behorende bij de nieuwe echte UID overschreed de hulpbron
       limiet). Van Linux 2.6.0 tot 3.0 zorgde dit voor het falen  van  de  set*  uid()  aanroep.
       (Voor  2.6,  werd  deze  resource  limiet  niet  opgelegd  op  processen die hun user ID´s
       veranderden.)

       Vanaf Linux 3.1 veroorzaakt het zojuist beschreven scenario het  falen  van  de  set*uid()
       aanroep  niet  langer,  omdat  het  te  vaak  leidde  tot  veiligheids gaten waar foutieve
       applicaties niet de teruggeven status  controleerden  en  aannamen  dat—als  de  aanroeper
       systeembeheerder  rechten had—de aanroep altijd zou slagen. In plaats daarvan verandert de
       set*uid() aanroep nu succesvol  de  echte  UID  maar  zet  de  kernel  een  interne  vlag,
       PF_NPROC_EXCEEDED  genaamd,  op  aan  te  geven dat de limiet van de RLIMIT_NPROC hulpbron
       overschreden werd.  Als de PF_NPROC_EXCEEDED vlag werd gezet en de hulpbron limiet is  nog
       steeds  overschreden  op  het  tijdstip  van  een  volgende execve() aanroep, dan zal deze
       aanroep falen met de fout  EAGAIN.  Deze  kernel  logica  verzekert  dat  de  RLIMIT_NPROC
       hulpbron limiet afgedwongen blijft voor de gewoonlijke geprivilegieerde workflow– namelijk
       fork(2)  + set*uid()  + execve().

       Indien de hulpbron limiet nog niet overschreden was ten  tijde  van  de  execve()  aanroep
       (omdat  andere  processen behorende bij dit echte UID werden beëindigd tussen de set*uid()
       aanroep en de execve() aanroep), dan is de execve() aanroep succesvol en wist de kernel de
       PF_NPROC_EXCEEDED  proces  vlag.  Deze  vlag wordt ook gewist als een volgende aanroep van
       fork(2) door dit proces succesvol is.

   Historisch
       Met UNIX V6, eindigde de argumenten lijst  van  een  exec()  aanroep  op   0,  terwijl  de
       argumenten  lijst  van  main  eindigde op -1. Daarom was deze argumenten lijst niet meteen
       bruikbaar in een volgende exec() aanroep.  Vanaf UNIX V7, zijn beiden NULL.

VOORBEELDEN

       Het volgende programma is ontworpen om te worden  uitgevoerd  door  het  tweede  programma
       daaronder. Het echo´d de commando-regel argumenten, een per regel.

           /* myecho.c */

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

           int
           main(int argc, char *argv[])
           {
               for (int j = 0; j < argc; j++)
                   printf("argv[%zu]: %s\n", j, argv[j]);

               exit(EXIT_SUCCESS);
           }

       Dit  programma  kan  worden gebruikt om het op de commando regel genoemde programma uit te
       voeren:

           /* execve.c */

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

           int
           main(int argc, char *argv[])
           {
               static char *newargv[] = { NULL, "hallo", "wereld", NULL };
               static char *newenviron[] = { NULL };

               if (argc != 2) {
                   fprintf(stderr, "Gebruik: %s <bestand-om-uit-te-voeren>\n", argv[0]);
                   exit(EXIT_FAILURE);
               }

               newargv[0] = argv[1];

               execve(argv[1], newargv, newenviron);
               perror("execve");   /* execve() returns only on error */
               exit(EXIT_FAILURE);
           }

       We kunnen het tweede programma om het eerste, als volgt, uit te voeren

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

       We kunnen deze programma´s ook gebruiken om het  gebruik  van  ee  script  interpreter  te
       demonstreren.  Om  dit  te  doen  creëren  wij  een  script  wiens "interpreter' on myecho
       programma is:

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

       We kunnen nu ons programma gebruiken om het script uit te voeren:

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

ZIE OOK

       chmod(2),  execveat(2),  fork(2),  get_robust_list(2),  ptrace(2),  exec(3),   fexecve(3),
       getauxval(3),   getopt(3),   system(3),   capabilities(7),   credentials(7),   environ(7),
       path_resolution(7), ld.so(8)

VERTALING

       De  Nederlandse  vertaling  van  deze  handleiding  is  geschreven   door   Jos   Boersema
       <joshb@xs4all.nl>,  Mario  Blättermann  <mario.blaettermann@gmail.com>  en  Luc Castermans
       <luc.castermans@gmail.com>

       Deze vertaling is vrije documentatie;  lees  de  GNU  General  Public  License  Version  3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  of later over de Copyright-voorwaarden. Er is
       geen AANSPRAKELIJKHEID.

       Indien U fouten in de vertaling van deze handleiding zou vinden,  stuur  een  e-mail  naar
       ⟨debian-l10n-dutch@lists.debian.org⟩.