Return to execve.c CVS log

Up to [MW Coherent from dump] / coherent / b / lib / libc / sys

Annotation of coherent/b/lib/libc/sys/execve.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * libc/sys/i386/execve.c
                      3:  * This version of execve() understands "#!interpreter [ arg ...]\n" lines.
                      4:  * The original version of this source was "iexec.c" Version 1.6,
                      5:  * written by David MacKenzie <[email protected]> and placed in the public domain.
                      6:  * Extensively modified by steve 8/12/92 for COHERENT.
                      7:  */
                      8: 
                      9: #include <errno.h>
                     10: #include <string.h>
                     11: #include <stdlib.h>
                     12: #include <fcntl.h>
                     13: 
                     14: #define MAXLINELEN     512     /* bytes to read from first line of a script */
                     15: #define        iswhite(c)      ((c) == ' ' || (c) == '\t')     /* whitespace */
                     16: 
                     17: /* Try _execve(), i.e. sys exec; then try running as a script if it fails. */
                     18: int
                     19: execve(cmd, argv, envp) char *cmd; char **argv; char **envp;
                     20: {
                     21: 
                     22:        if (_execve(cmd, argv, envp) == -1 && errno == ENOEXEC) {
                     23:                script_execve(cmd, argv, envp);
                     24:                errno = ENOEXEC;
                     25:        }
                     26:        return -1;
                     27: }
                     28: 
                     29: /*
                     30:  * If 'file' is a script which begins "#!interp [ arg ...]\n",
                     31:  * set 'interp' to the name of the program that should run it
                     32:  * and 'int_args' to the given args (or NULL if none).
                     33:  * Create a new argument list containing 'interp',
                     34:  * expanded 'int_args' (if non-NULL), 'file', and the original argv.
                     35:  * Then try to run 'interp' with the new argument list and 'envp'.
                     36:  * Return -1 if it fails.
                     37:  */
                     38: static
                     39: int
                     40: script_execve(file, argv, envp) char *file, **argv, **envp;
                     41: {
                     42:        char line[MAXLINELEN + 1];
                     43:        register char *cp, **ap, **nargv;
                     44:        char *interp, *int_args;
                     45:        register int argc, fd, n;
                     46:        char c, inquote;
                     47: 
                     48:        /* Open the file, read a chunk, see how it starts. */
                     49:        if ((fd = open(file, O_RDONLY, 0)) == -1)
                     50:                return -1;
                     51:        n = read(fd, line, MAXLINELEN);
                     52:        if (close(fd) == -1 || n < 4 || line[0] != '#' || line[1] != '!')
                     53:                return -1;
                     54: 
                     55:        /* The first line looks appropriate. */
                     56:        line[n] = '\0';                         /* NUL-terminate */
                     57:        if ((cp = strchr(line, '\n')) == NULL)
                     58:                return -1;
                     59:        *cp = '\0';                             /* zap newline */
                     60: 
                     61:        /* Find interpreter name and args. */
                     62:        for (cp = line + 2; iswhite(*cp); ++cp)
                     63:                ;                               /* skip whitespace after #! */
                     64:        if (*cp == '\0')
                     65:                return -1;
                     66:        interp = cp;                            /* interpreter name */
                     67:        for (; *cp != '\0' && !iswhite(*cp); ++cp)
                     68:                ;                               /* scan to whitespace or NUL */
                     69:        if (*cp == '\0')
                     70:                int_args = NULL;
                     71:        else {
                     72:                *cp++ = '\0';                   /* NUL-terminate name */
                     73:                int_args = cp;                  /* interpreter args */
                     74:        }
                     75: 
                     76:        /* Find new arg count max and allocate space for new argv. */
                     77:        for (argc = 2, ap = argv; *ap != NULL; ++ap)
                     78:                ++argc;                         /* count old argv args + 1 */
                     79:        if (int_args != NULL)
                     80:                argc += strlen(int_args)/2;     /* add max int_args args */
                     81:        if ((nargv = (char **)malloc(sizeof(char *) * argc)) == NULL)
                     82:                return -1;
                     83: 
                     84:        /* Initialize the new argv. */
                     85:        argc = 0;
                     86:        nargv[argc++] = interp;                 /* interpreter name */
                     87:        if (int_args != NULL) {
                     88: 
                     89:                /* Add whitespace-separated args from int_args. */
                     90:                for (cp = int_args; (c = *cp) != '\0'; ) {
                     91:                        while (iswhite(c))
                     92:                                c = *++cp;      /* skip whitespace */
                     93:                        if (c == '\0')
                     94:                                break;
                     95:                        else if (c == '\'' || c == '"') {
                     96:                                inquote = c;    /* quoted arg */
                     97:                                ++cp;
                     98:                        } else
                     99:                                inquote = 0;
                    100:                        nargv[argc++] = cp;     /* start new arg */
                    101:                        while ((c = *cp++) != '\0') {
                    102:                                if (!inquote && iswhite(c))
                    103:                                        break;
                    104:                                else if (inquote && c == inquote) {
                    105:                                        inquote = cp[-1] = '\0';        /* zap close quote */
                    106:                                        c = *cp++;      /* next char */
                    107:                                        break;
                    108:                                }
                    109:                        }
                    110:                        if (inquote) {
                    111:                                free(nargv);
                    112:                                return -1;      /* fail on missing close quote */
                    113:                        } else if (c == '\0')
                    114:                                break;
                    115:                        else
                    116:                                cp[-1] = '\0';  /* NUL-terminate arg */
                    117:                }
                    118:        }
                    119:        nargv[argc++] = file;                   /* script name */
                    120: 
                    121:        /* Copy the old arguments. */
                    122:        for (ap = argv + 1; *ap != NULL; ++ap)
                    123:                nargv[argc++] = *ap;
                    124:        nargv[argc] = NULL;
                    125: 
                    126:        /* Go for smoke. */
                    127:        _execve(interp, nargv, envp);
                    128:        free(nargv);
                    129:        return -1;
                    130: }
                    131: 
                    132: /* end of libc/sys/i386/execve.c */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.