lib/libc/posix/_execve.c

   1 /*      execve() - basic program execution call         Author: Kees J. Bot
   2  *                                                              21 Jan 1994
   3  */
   4
   5 #define _MINIX_SOURCE
   6
   7 #define execve _execve
   8 #define sbrk _sbrk
   9 #include <lib.h>
  10 #include <unistd.h>
  11 #include <string.h>
  12 #include <stddef.h>
  13
  14 int execve(const char *path, char * const *argv, char * const *envp)
  15 {
  16         char * const *ap;
  17         char * const *ep;
  18         char *frame;
  19         char **vp;
  20         char *sp;
  21         size_t argc;
  22         size_t frame_size;
  23         size_t string_off;
  24         size_t n;
  25         int ov;
  26         message m;
  27
  28         /* Assumptions: size_t and char *, it's all the same thing. */
  29
  30         /* Create a stack image that only needs to be patched up slightly
  31          * by the kernel to be used for the process to be executed.
  32          */
  33
  34         ov= 0;                  /* No overflow yet. */
  35         frame_size= 0;          /* Size of the new initial stack. */
  36         string_off= 0;          /* Offset to start of the strings. */
  37         argc= 0;                /* Argument count. */
  38
  39         for (ap= argv; *ap != NULL; ap++) {
  40                 n = sizeof(*ap) + strlen(*ap) + 1;
  41                 frame_size+= n;
  42                 if (frame_size < n) ov= 1;
  43                 string_off+= sizeof(*ap);
  44                 argc++;
  45         }
  46
  47         for (ep= envp; *ep != NULL; ep++) {
  48                 n = sizeof(*ep) + strlen(*ep) + 1;
  49                 frame_size+= n;
  50                 if (frame_size < n) ov= 1;
  51                 string_off+= sizeof(*ap);
  52         }
  53
  54         /* Add an argument count and two terminating nulls. */
  55         frame_size+= sizeof(argc) + sizeof(*ap) + sizeof(*ep);
  56         string_off+= sizeof(argc) + sizeof(*ap) + sizeof(*ep);
  57
  58         /* Align. */
  59         frame_size= (frame_size + sizeof(char *) - 1) & ~(sizeof(char *) - 1);
  60
  61         /* The party is off if there is an overflow. */
  62         if (ov || frame_size < 3 * sizeof(char *)) {
  63                 errno= E2BIG;
  64                 return -1;
  65         }
  66
  67         /* Allocate space for the stack frame. */
  68         if ((frame = (char *) sbrk(frame_size)) == (char *) -1) {
  69                 errno = E2BIG;
  70                 return -1;
  71         }
  72
  73         /* Set arg count, init pointers to vector and string tables. */
  74         * (size_t *) frame = argc;
  75         vp = (char **) (frame + sizeof(argc));
  76         sp = frame + string_off;
  77
  78         /* Load the argument vector and strings. */
  79         for (ap= argv; *ap != NULL; ap++) {
  80                 *vp++= (char *) (sp - frame);
  81                 n= strlen(*ap) + 1;
  82                 memcpy(sp, *ap, n);
  83                 sp+= n;
  84         }
  85         *vp++= NULL;
  86
  87         /* Load the environment vector and strings. */
  88         for (ep= envp; *ep != NULL; ep++) {
  89                 *vp++= (char *) (sp - frame);
  90                 n= strlen(*ep) + 1;
  91                 memcpy(sp, *ep, n);
  92                 sp+= n;
  93         }
  94         *vp++= NULL;
  95
  96         /* Padding. */
  97         while (sp < frame + frame_size) *sp++= 0;
  98
  99         /* We can finally make the system call. */
 100         m.m1_i1 = strlen(path) + 1;
 101         m.m1_i2 = frame_size;
 102         m.m1_p1 = (char *) path;
 103         m.m1_p2 = frame;
 104
 105         /* Clear unused fields */
 106         m.m1_i3 = 0;
 107         m.m1_p3 = NULL;
 108
 109         (void) _syscall(MM, EXEC, &m);
 110
 111         /* Failure, return the memory used for the frame and exit. */
 112         (void) sbrk(-frame_size);
 113         return -1;
 114 }