WebSVN – HelenOS – Diff – /tags/0.3.0/uspace/app/ash/exec.c


/*  $NetBSD: exec.c,v 1.31 2000/11/01 19:21:41 christos Exp $   */
 
/*-
 * Copyright (c) 1991, 1993
 *  The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Kenneth Almquist.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by the University of
 *  California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
 
#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)exec.c  8.4 (Berkeley) 6/8/95";
#else
__RCSID("$NetBSD: exec.c,v 1.31 2000/11/01 19:21:41 christos Exp $");
#endif
#endif /* not lint */
 
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <sysexits.h>
 
/*
 * When commands are first encountered, they are entered in a hash table.
 * This ensures that a full path search will not have to be done for them
 * on each invocation.
 *
 * We should investigate converting to a linear search, even though that
 * would make the command name "hash" a misnomer.
 */
 
#include "shell.h"
#include "main.h"
#include "nodes.h"
#include "parser.h"
#include "redir.h"
#include "eval.h"
#include "exec.h"
#include "builtins.h"
#include "var.h"
#include "options.h"
#include "input.h"
#include "output.h"
#include "syntax.h"
#include "memalloc.h"
#include "error.h"
#include "init.h"
#include "mystring.h"
#include "show.h"
#include "jobs.h"
#include "alias.h"
 
 
#define CMDTABLESIZE 31     /* should be prime */
#define ARB 1           /* actual size determined at run time */
 
 
 
struct tblentry {
    struct tblentry *next;  /* next entry in hash chain */
    union param param;  /* definition of builtin function */
    short cmdtype;      /* index identifying command */
    char rehash;        /* if set, cd done since entry created */
    char cmdname[ARB];  /* name of command */
};
 
 
STATIC struct tblentry *cmdtable[CMDTABLESIZE];
STATIC int builtinloc = -1;     /* index in path of %builtin, or -1 */
int exerrno = 0;            /* Last exec error */
 
 
STATIC void tryexec (char *, char **, char **);
STATIC void execinterp (char **, char **);
STATIC void printentry (struct tblentry *, int);
STATIC void clearcmdentry (int);
STATIC struct tblentry *cmdlookup (char *, int);
STATIC void delete_cmd_entry (void);
STATIC int describe_command (char *, int);
STATIC int path_change (const char *, int *);
STATIC int is_regular_builtin (const char *);
 
 
 
/*
 * Exec a program.  Never returns.  If you change this routine, you may
 * have to change the find_command routine as well.
 */
 
void
shellexec(argv, envp, path, idx)
    char **argv, **envp;
    const char *path;
    int idx;
{
    char *cmdname;
    int e;
 
    if (fd2 >= 0 && fd2 != 2) {
        close(fd2);
    }
 
    if (strchr(argv[0], '/') != NULL) {
        tryexec(argv[0], argv, envp);
        e = errno;
    } else {
        e = ENOENT;
        while ((cmdname = padvance(&path, argv[0])) != NULL) {
            if (--idx < 0 && pathopt == NULL) {
                tryexec(cmdname, argv, envp);
                if (errno != ENOENT && errno != ENOTDIR)
                    e = errno;
            }
            stunalloc(cmdname);
        }
    }
 
    /* Map to POSIX errors */
    switch (e) {
    case EACCES:
        exerrno = 126;
        break;
    case ENOENT:
        exerrno = 127;
        break;
    default:
        exerrno = 2;
        break;
    }
    exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
    /* NOTREACHED */
}
 
 
STATIC void
tryexec(cmd, argv, envp)
    char *cmd;
    char **argv;
    char **envp;
    {
    int e;
#if !defined(BSD) && !defined(linux)
    char *p;
#endif
 
#ifdef SYSV
    do {
        execve(cmd, argv, envp);
    } while (errno == EINTR);
#else
    execve(cmd, argv, envp);
#endif
    e = errno;
    if (e == ENOEXEC) {
        initshellproc();
        setinputfile(cmd, 0);
        commandname = arg0 = savestr(argv[0]);
#if !defined(BSD) && !defined(linux)
        pgetc(); pungetc();     /* fill up input buffer */
        p = parsenextc;
        if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
            argv[0] = cmd;
            execinterp(argv, envp);
        }
#endif
        setparam(argv + 1);
        exraise(EXSHELLPROC);
    }
    errno = e;
}
 
 
#if !defined(BSD) && !defined(linux)
/*
 * Execute an interpreter introduced by "#!", for systems where this
 * feature has not been built into the kernel.  If the interpreter is
 * the shell, return (effectively ignoring the "#!").  If the execution
 * of the interpreter fails, exit.
 *
 * This code peeks inside the input buffer in order to avoid actually
 * reading any input.  It would benefit from a rewrite.
 */
 
#define NEWARGS 5
 
STATIC void
execinterp(argv, envp)
    char **argv, **envp;
    {
    int n;
    char *inp;
    char *outp;
    char c;
    char *p;
    char **ap;
    char *newargs[NEWARGS];
    int i;
    char **ap2;
    char **new;
 
    n = parsenleft - 2;
    inp = parsenextc + 2;
    ap = newargs;
    for (;;) {
        while (--n >= 0 && (*inp == ' ' || *inp == '\t'))
            inp++;
        if (n < 0)
            goto bad;
        if ((c = *inp++) == '\n')
            break;
        if (ap == &newargs[NEWARGS])
bad:          error("Bad #! line");
        STARTSTACKSTR(outp);
        do {
            STPUTC(c, outp);
        } while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');
        STPUTC('\0', outp);
        n++, inp--;
        *ap++ = grabstackstr(outp);
    }
    if (ap == newargs + 1) {    /* if no args, maybe no exec is needed */
        p = newargs[0];
        for (;;) {
            if (equal(p, "sh") || equal(p, "ash")) {
                return;
            }
            while (*p != '/') {
                if (*p == '\0')
                    goto break2;
                p++;
            }
            p++;
        }
break2:;
    }
    i = (char *)ap - (char *)newargs;       /* size in bytes */
    if (i == 0)
        error("Bad #! line");
    for (ap2 = argv ; *ap2++ != NULL ; );
    new = ckmalloc(i + ((char *)ap2 - (char *)argv));
    ap = newargs, ap2 = new;
    while ((i -= sizeof (char **)) >= 0)
        *ap2++ = *ap++;
    ap = argv;
    while (*ap2++ = *ap++);
    shellexec(new, envp, pathval(), 0);
    /* NOTREACHED */
}
#endif
 
 
 
/*
 * Do a path search.  The variable path (passed by reference) should be
 * set to the start of the path before the first call; padvance will update
 * this value as it proceeds.  Successive calls to padvance will return
 * the possible path expansions in sequence.  If an option (indicated by
 * a percent sign) appears in the path entry then the global variable
 * pathopt will be set to point to it; otherwise pathopt will be set to
 * NULL.
 */
 
const char *pathopt;
 
char *
padvance(path, name)
    const char **path;
    const char *name;
    {
    const char *p;
    char *q;
    const char *start;
    int len;
 
    if (*path == NULL)
        return NULL;
    start = *path;
    for (p = start ; *p && *p != ':' && *p != '%' ; p++);
    len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
    while (stackblocksize() < len)
        growstackblock();
    q = stackblock();
    if (p != start) {
        memcpy(q, start, p - start);
        q += p - start;
        *q++ = '/';
    }
    strcpy(q, name);
    pathopt = NULL;
    if (*p == '%') {
        pathopt = ++p;
        while (*p && *p != ':')  p++;
    }
    if (*p == ':')
        *path = p + 1;
    else
        *path = NULL;
    return stalloc(len);
}
 
 
 
/*** Command hashing code ***/
 
 
int
hashcmd(argc, argv)
    int argc;
    char **argv;
{
    struct tblentry **pp;
    struct tblentry *cmdp;
    int c;
    int verbose;
    struct cmdentry entry;
    char *name;
 
    verbose = 0;
    while ((c = nextopt("rv")) != '\0') {
        if (c == 'r') {
            clearcmdentry(0);
        } else if (c == 'v') {
            verbose++;
        }
    }
    if (*argptr == NULL) {
        for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
            for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
                if (cmdp->cmdtype != CMDBUILTIN) {
                    printentry(cmdp, verbose);
                }
            }
        }
        return 0;
    }
    c = 0;
    while ((name = *argptr) != NULL) {
        if ((cmdp = cmdlookup(name, 0)) != NULL
         && (cmdp->cmdtype == CMDNORMAL
             || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
            delete_cmd_entry();
        find_command(name, &entry, DO_ERR, pathval());
        if (entry.cmdtype == CMDUNKNOWN) c = 1;
        else if (verbose) {
            cmdp = cmdlookup(name, 0);
            if (cmdp) printentry(cmdp, verbose);
            flushall();
        }
        argptr++;
    }
    return c;
}
 
 
STATIC void
printentry(cmdp, verbose)
    struct tblentry *cmdp;
    int verbose;
    {
    int idx;
    const char *path;
    char *name;
 
    if (cmdp->cmdtype == CMDNORMAL) {
        idx = cmdp->param.index;
        path = pathval();
        do {
            name = padvance(&path, cmdp->cmdname);
            stunalloc(name);
        } while (--idx >= 0);
        out1str(name);
    } else if (cmdp->cmdtype == CMDBUILTIN) {
        out1fmt("builtin %s", cmdp->cmdname);
    } else if (cmdp->cmdtype == CMDFUNCTION) {
        out1fmt("function %s", cmdp->cmdname);
        if (verbose) {
            INTOFF;
            name = commandtext(cmdp->param.func);
            out1c(' ');
            out1str(name);
            ckfree(name);
            INTON;
        }
#ifdef DEBUG
    } else {
        error("internal error: cmdtype %d", cmdp->cmdtype);
#endif
    }
    if (cmdp->rehash)
        out1c('*');
    out1c('\n');
}
 
 
 
/*
 * Resolve a command name.  If you change this routine, you may have to
 * change the shellexec routine as well.
 */
 
void
find_command(name, entry, act, path)
    char *name;
    struct cmdentry *entry;
    int act;
    const char *path;
{
    struct tblentry *cmdp;
    int idx;
    int prev;
    char *fullname;
    struct stat statb;
    int e;
    int i;
    int bltin;
    int firstchange;
    int updatetbl;
    int regular;
 
    /* If name contains a slash, don't use the hash table */
    if (strchr(name, '/') != NULL) {
        if (act & DO_ABS) {
            while (stat(name, &statb) < 0) {
    #ifdef SYSV
                if (errno == EINTR)
                    continue;
    #endif
                if (errno != ENOENT && errno != ENOTDIR)
                    e = errno;
                entry->cmdtype = CMDUNKNOWN;
                entry->u.index = -1;
                return;
            }
            entry->cmdtype = CMDNORMAL;
            entry->u.index = -1;
            return;
        }
        entry->cmdtype = CMDNORMAL;
        entry->u.index = 0;
        return;
    }
 
    updatetbl = 1;
    if (act & DO_BRUTE) {
        firstchange = path_change(path, &bltin);
    } else {
        bltin = builtinloc;
        firstchange = 9999;
    }
 
    /* If name is in the table, and not invalidated by cd, we're done */
    if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
        if (cmdp->cmdtype == CMDFUNCTION) {
            if (act & DO_NOFUN) {
                updatetbl = 0;
            } else {
                goto success;
            }
        } else if (act & DO_BRUTE) {
            if ((cmdp->cmdtype == CMDNORMAL &&
                 cmdp->param.index >= firstchange) ||
                (cmdp->cmdtype == CMDBUILTIN &&
                 ((builtinloc < 0 && bltin >= 0) ?
                  bltin : builtinloc) >= firstchange)) {
                /* need to recompute the entry */
            } else {
                goto success;
            }
        } else {
            goto success;
        }
    }
 
    if ((regular = is_regular_builtin(name))) {
        if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
                goto success;
        }
    } else if (act & DO_BRUTE) {
        if (firstchange == 0) {
            updatetbl = 0;
        }
    }
 
    /* If %builtin not in path, check for builtin next */
    if ((bltin < 0 || regular) && (i = find_builtin(name)) >= 0) {
        if (!updatetbl) {
            entry->cmdtype = CMDBUILTIN;
            entry->u.index = i;
            return;
        }
        INTOFF;
        cmdp = cmdlookup(name, 1);
        cmdp->cmdtype = CMDBUILTIN;
        cmdp->param.index = i;
        INTON;
        goto success;
    }
 
    /* We have to search path. */
    prev = -1;      /* where to start */
    if (cmdp && cmdp->rehash) { /* doing a rehash */
        if (cmdp->cmdtype == CMDBUILTIN)
            prev = builtinloc;
        else
            prev = cmdp->param.index;
    }
 
    e = ENOENT;
    idx = -1;
loop:
    while ((fullname = padvance(&path, name)) != NULL) {
        stunalloc(fullname);
        idx++;
        if (idx >= firstchange) {
            updatetbl = 0;
        }
        if (pathopt) {
            if (prefix("builtin", pathopt)) {
                if ((i = find_builtin(name)) >= 0) {
                    if (!updatetbl) {
                        entry->cmdtype = CMDBUILTIN;
                        entry->u.index = i;
                        return;
                    }
                    INTOFF;
                    cmdp = cmdlookup(name, 1);
                    cmdp->cmdtype = CMDBUILTIN;
                    cmdp->param.index = i;
                    INTON;
                    goto success;
                } else {
                    continue;
                }
            } else if (!(act & DO_NOFUN) &&
                   prefix("func", pathopt)) {
                /* handled below */
            } else {
                continue;   /* ignore unimplemented options */
            }
        }
        /* if rehash, don't redo absolute path names */
        if (fullname[0] == '/' && idx <= prev &&
            idx < firstchange) {
            if (idx < prev)
                continue;
            TRACE(("searchexec \"%s\": no change\n", name));
            goto success;
        }
        while (stat(fullname, &statb) < 0) {
#ifdef SYSV
            if (errno == EINTR)
                continue;
#endif
            if (errno != ENOENT && errno != ENOTDIR)
                e = errno;
            goto loop;
        }
        e = EACCES; /* if we fail, this will be the error */
        if (!S_ISREG(statb.st_mode))
            continue;
        if (pathopt) {      /* this is a %func directory */
            stalloc(strlen(fullname) + 1);
            readcmdfile(fullname);
            if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION)
                error("%s not defined in %s", name, fullname);
            stunalloc(fullname);
            goto success;
        }
#ifdef notdef
        if (statb.st_uid == geteuid()) {
            if ((statb.st_mode & 0100) == 0)
                goto loop;
        } else if (statb.st_gid == getegid()) {
            if ((statb.st_mode & 010) == 0)
                goto loop;
        } else {
            if ((statb.st_mode & 01) == 0)
                goto loop;
        }
#endif
        TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
        /* If we aren't called with DO_BRUTE and cmdp is set, it must
           be a function and we're being called with DO_NOFUN */
        if (!updatetbl) {
            entry->cmdtype = CMDNORMAL;
            entry->u.index = idx;
            return;
        }
        INTOFF;
        cmdp = cmdlookup(name, 1);
        cmdp->cmdtype = CMDNORMAL;
        cmdp->param.index = idx;
        INTON;
        goto success;
    }
 
    /* We failed.  If there was an entry for this command, delete it */
    if (cmdp && updatetbl)
        delete_cmd_entry();
    if (act & DO_ERR)
        outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC));
    entry->cmdtype = CMDUNKNOWN;
    return;
 
success:
    cmdp->rehash = 0;
    entry->cmdtype = cmdp->cmdtype;
    entry->u = cmdp->param;
}
 
 
 
/*
 * Search the table of builtin commands.
 */
 
int
find_builtin(name)
    char *name;
{
    const struct builtincmd *bp;
 
    for (bp = builtincmd ; bp->name ; bp++) {
        if (*bp->name == *name && equal(bp->name, name))
            return bp->code;
    }
    return -1;
}
 
 
 
/*
 * Called when a cd is done.  Marks all commands so the next time they
 * are executed they will be rehashed.
 */
 
void
hashcd() {
    struct tblentry **pp;
    struct tblentry *cmdp;
 
    for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
        for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
            if (cmdp->cmdtype == CMDNORMAL
             || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
                cmdp->rehash = 1;
        }
    }
}
 
 
 
/*
 * Called before PATH is changed.  The argument is the new value of PATH;
 * pathval() still returns the old value at this point.  Called with
 * interrupts off.
 */
 
void
changepath(newval)
    const char *newval;
{
    int firstchange;
    int bltin;
 
    firstchange = path_change(newval, &bltin);
    if (builtinloc < 0 && bltin >= 0)
        builtinloc = bltin;     /* zap builtins */
    clearcmdentry(firstchange);
    builtinloc = bltin;
}
 
 
/*
 * Clear out command entries.  The argument specifies the first entry in
 * PATH which has changed.
 */
 
STATIC void
clearcmdentry(firstchange)
    int firstchange;
{
    struct tblentry **tblp;
    struct tblentry **pp;
    struct tblentry *cmdp;
 
    INTOFF;
    for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
        pp = tblp;
        while ((cmdp = *pp) != NULL) {
            if ((cmdp->cmdtype == CMDNORMAL &&
                 cmdp->param.index >= firstchange)
             || (cmdp->cmdtype == CMDBUILTIN &&
                 builtinloc >= firstchange)) {
                *pp = cmdp->next;
                ckfree(cmdp);
            } else {
                pp = &cmdp->next;
            }
        }
    }
    INTON;
}
 
 
/*
 * Delete all functions.
 */
 
#ifdef mkinit
MKINIT void deletefuncs (void);
 
SHELLPROC {
    deletefuncs();
}
#endif
 
void
deletefuncs() {
    struct tblentry **tblp;
    struct tblentry **pp;
    struct tblentry *cmdp;
 
    INTOFF;
    for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
        pp = tblp;
        while ((cmdp = *pp) != NULL) {
            if (cmdp->cmdtype == CMDFUNCTION) {
                *pp = cmdp->next;
                freefunc(cmdp->param.func);
                ckfree(cmdp);
            } else {
                pp = &cmdp->next;
            }
        }
    }
    INTON;
}
 
 
 
/*
 * Locate a command in the command hash table.  If "add" is nonzero,
 * add the command to the table if it is not already present.  The
 * variable "lastcmdentry" is set to point to the address of the link
 * pointing to the entry, so that delete_cmd_entry can delete the
 * entry.
 */
 
struct tblentry **lastcmdentry;
 
 
STATIC struct tblentry *
cmdlookup(name, add)
    char *name;
    int add;
{
    int hashval;
    char *p;
    struct tblentry *cmdp;
    struct tblentry **pp;
 
    p = name;
    hashval = *p << 4;
    while (*p)
        hashval += *p++;
    hashval &= 0x7FFF;
    pp = &cmdtable[hashval % CMDTABLESIZE];
    for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
        if (equal(cmdp->cmdname, name))
            break;
        pp = &cmdp->next;
    }
    if (add && cmdp == NULL) {
        INTOFF;
        cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
                    + strlen(name) + 1);
        cmdp->next = NULL;
        cmdp->cmdtype = CMDUNKNOWN;
        cmdp->rehash = 0;
        strcpy(cmdp->cmdname, name);
        INTON;
    }
    lastcmdentry = pp;
    return cmdp;
}
 
/*
 * Delete the command entry returned on the last lookup.
 */
 
STATIC void
delete_cmd_entry() {
    struct tblentry *cmdp;
 
    INTOFF;
    cmdp = *lastcmdentry;
    *lastcmdentry = cmdp->next;
    ckfree(cmdp);
    INTON;
}
 
 
 
#ifdef notdef
void
getcmdentry(name, entry)
    char *name;
    struct cmdentry *entry;
    {
    struct tblentry *cmdp = cmdlookup(name, 0);
 
    if (cmdp) {
        entry->u = cmdp->param;
        entry->cmdtype = cmdp->cmdtype;
    } else {
        entry->cmdtype = CMDUNKNOWN;
        entry->u.index = 0;
    }
}
#endif
 
 
/*
 * Add a new command entry, replacing any existing command entry for
 * the same name.
 */
 
void
addcmdentry(name, entry)
    char *name;
    struct cmdentry *entry;
    {
    struct tblentry *cmdp;
 
    INTOFF;
    cmdp = cmdlookup(name, 1);
    if (cmdp->cmdtype == CMDFUNCTION) {
        freefunc(cmdp->param.func);
    }
    cmdp->cmdtype = entry->cmdtype;
    cmdp->param = entry->u;
    INTON;
}
 
 
/*
 * Define a shell function.
 */
 
void
defun(name, func)
    char *name;
    union node *func;
    {
    struct cmdentry entry;
 
    entry.cmdtype = CMDFUNCTION;
    entry.u.func = copyfunc(func);
    addcmdentry(name, &entry);
}
 
 
/*
 * Delete a function if it exists.
 */
 
int
unsetfunc(name)
    char *name;
    {
    struct tblentry *cmdp;
 
    if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
        freefunc(cmdp->param.func);
        delete_cmd_entry();
        return (0);
    }
    return (1);
}
 
/*
 * Locate and print what a word is...
 */
 
int
typecmd(argc, argv)
    int argc;
    char **argv;
{
    struct cmdentry entry;
    struct tblentry *cmdp;
    char * const *pp;
    struct alias *ap;
    int i;
    int err = 0;
    extern char *const parsekwd[];
 
    for (i = 1; i < argc; i++) {
        out1str(argv[i]);
        /* First look at the keywords */
        for (pp = parsekwd; *pp; pp++)
            if (**pp == *argv[i] && equal(*pp, argv[i]))
                break;
 
        if (*pp) {
            out1str(" is a shell keyword\n");
            continue;
        }
 
        /* Then look at the aliases */
        if ((ap = lookupalias(argv[i], 1)) != NULL) {
            out1fmt(" is an alias for %s\n", ap->val);
            continue;
        }
 
        /* Then check if it is a tracked alias */
        if ((cmdp = cmdlookup(argv[i], 0)) != NULL) {
            entry.cmdtype = cmdp->cmdtype;
            entry.u = cmdp->param;
        }
        else {
            /* Finally use brute force */
            find_command(argv[i], &entry, DO_ABS, pathval());
        }
 
        switch (entry.cmdtype) {
        case CMDNORMAL: {
            if (strchr(argv[i], '/') == NULL) {
                const char *path = pathval();
                char *name;
                int j = entry.u.index;
                do {
                    name = padvance(&path, argv[i]);
                    stunalloc(name);
                } while (--j >= 0);
                out1fmt(" is%s %s\n",
                    cmdp ? " a tracked alias for" : "", name);
            } else {
                if (access(argv[i], X_OK) == 0)
                    out1fmt(" is %s\n", argv[i]);
                else
                    out1fmt(": %s\n", strerror(errno));
            }
            break;
        }
        case CMDFUNCTION:
            out1str(" is a shell function\n");
            break;
 
        case CMDBUILTIN:
            out1str(" is a shell builtin\n");
            break;
 
        default:
            out1str(": not found\n");
            err |= 127;
            break;
        }
    }
    return err;
}
 
STATIC int
describe_command(command, verbose)
    char *command;
    int verbose;
{
    struct cmdentry entry;
    struct tblentry *cmdp;
    char **pp;
    struct alias *ap;
    extern char *const parsekwd[];
 
    for (pp = (char **)parsekwd; *pp; pp++)
        if (**pp == *command && equal(*pp, command))
            break;
 
    if (*pp) {
        if (verbose) {
            out1fmt("%s is a reserved word\n", command);
        } else {
            out1fmt("%s\n", command);
        }
        return 0;
    }
 
    /* Then look at the aliases */
    if ((ap = lookupalias(command, 1)) != NULL) {
        if (verbose) {
            out1fmt("%s is aliased to `%s'\n", command, ap->val);
        } else {
            out1fmt("alias %s='%s'\n", command, ap->val);
        }
        return 0;
    }
 
    /* Then check if it is a tracked alias */
    if ((cmdp = cmdlookup(command, 0)) != NULL) {
        entry.cmdtype = cmdp->cmdtype;
        entry.u = cmdp->param;
    }
    else {
        /* Finally use brute force */
        find_command(command, &entry, DO_ABS, pathval());
    }
 
    switch (entry.cmdtype) {
    case CMDNORMAL: {
        int j = entry.u.index;
        const char *path = pathval();
        char *name;
        if (j == -1)
            name = command;
        else {
            do {
                name = padvance(&path, command);
                stunalloc(name);
            } while (--j >= 0);
        }
        if (verbose) {
            out1fmt("%s is %s\n", command, name);
        } else {
            out1fmt("%s\n", name);
        }
        break;
    }
    case CMDFUNCTION:
        if (verbose) {
            out1fmt("%s is a function\n", command);
        } else {
            out1fmt("%s\n", command);
        }
        break;
    case CMDBUILTIN:
        if (verbose) {
            if (is_special_builtin(command)) {
                out1fmt("%s is a special built-in utility\n", command);
            } else {
                out1fmt("%s is a built-in utility\n", command);
            }
        } else {
            out1fmt("%s\n", command);
        }
        break;
    default:
        outfmt(out2, "%s not found\n", command);
        return 127;
    }
 
    return 0;
}
 
int
commandcmd(argc, argv)
    int argc;
    char **argv;
{
    int c;
    int default_path = 0;
    int verify_only = 0;
    int verbose_verify_only = 0;
 
    while ((c = nextopt("pvV")) != '\0')
        switch (c) {
        case 'p':
            default_path = 1;
            break;
        case 'v':
            verify_only = 1;
            break;
        case 'V':
            verbose_verify_only = 1;
            break;
        default:
            outfmt(out2,
"command: nextopt returned character code 0%o\n", c);
            return EX_SOFTWARE;
        }
 
    if (default_path + verify_only + verbose_verify_only > 1 ||
        !*argptr) {
            outfmt(out2,
"command [-p] command [arg ...]\n");
            outfmt(out2,
"command {-v|-V} command\n");
            return EX_USAGE;
    }
 
    if (verify_only || verbose_verify_only) {
        return describe_command(*argptr, verbose_verify_only);
    }
 
    return 0;
}
 
STATIC int
path_change(newval, bltin)
    const char *newval;
    int *bltin;
{
    const char *old, *new;
    int idx;
    int firstchange;
 
    old = pathval();
    new = newval;
    firstchange = 9999; /* assume no change */
    idx = 0;
    *bltin = -1;
    for (;;) {
        if (*old != *new) {
            firstchange = idx;
            if ((*old == '\0' && *new == ':')
             || (*old == ':' && *new == '\0'))
                firstchange++;
            old = new;  /* ignore subsequent differences */
        }
        if (*new == '\0')
            break;
        if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1))
            *bltin = idx;
        if (*new == ':') {
            idx++;
        }
        new++, old++;
    }
    if (builtinloc >= 0 && *bltin < 0)
        firstchange = 0;
    return firstchange;
}
 
STATIC int
is_regular_builtin(name)
        const char *name;
{
        static const char *regular_builtins[] = {
            "alias", "bg", "cd", "command", "false", "fc", "fg",
            "getopts", "jobs", "kill", "newgrp", "read", "true",
            "umask", "unalias", "wait", (char *)NULL
        };
        int i;
 
        if (!name) return 0;
        for (i = 0; regular_builtins[i]; i++)
                if (equal(name, regular_builtins[i])) return 1;
        return 0;
}
 

Rev 2714	Rev 2782
1	/* $NetBSD: exec.c,v 1.31 2000/11/01 19:21:41 christos Exp $ */	1	/* $NetBSD: exec.c,v 1.31 2000/11/01 19:21:41 christos Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 1991, 1993	4	* Copyright (c) 1991, 1993
5	* The Regents of the University of California. All rights reserved.	5	* The Regents of the University of California. All rights reserved.
6	*	6	*
7	* This code is derived from software contributed to Berkeley by	7	* This code is derived from software contributed to Berkeley by
8	* Kenneth Almquist.	8	* Kenneth Almquist.
9	*	9	*
10	* Redistribution and use in source and binary forms, with or without	10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions	11	* modification, are permitted provided that the following conditions
12	* are met:	12	* are met:
13	* 1. Redistributions of source code must retain the above copyright	13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.	14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright	15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the	16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.	17	* documentation and/or other materials provided with the distribution.
18	* 3. All advertising materials mentioning features or use of this software	18	* 3. All advertising materials mentioning features or use of this software
19	* must display the following acknowledgement:	19	* must display the following acknowledgement:
20	* This product includes software developed by the University of	20	* This product includes software developed by the University of
21	* California, Berkeley and its contributors.	21	* California, Berkeley and its contributors.
22	* 4. Neither the name of the University nor the names of its contributors	22	* 4. Neither the name of the University nor the names of its contributors
23	* may be used to endorse or promote products derived from this software	23	* may be used to endorse or promote products derived from this software
24	* without specific prior written permission.	24	* without specific prior written permission.
25	*	25	*
26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND	26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE	29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS	31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)	32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT	33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY	34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF	35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36	* SUCH DAMAGE.	36	* SUCH DAMAGE.
37	*/	37	*/
38		38
39	#include <sys/cdefs.h>	39	#include <sys/cdefs.h>
40	#ifndef lint	40	#ifndef lint
41	#if 0	41	#if 0
42	static char sccsid[] = "@(#)exec.c 8.4 (Berkeley) 6/8/95";	42	static char sccsid[] = "@(#)exec.c 8.4 (Berkeley) 6/8/95";
43	#else	43	#else
44	__RCSID("$NetBSD: exec.c,v 1.31 2000/11/01 19:21:41 christos Exp $");	44	__RCSID("$NetBSD: exec.c,v 1.31 2000/11/01 19:21:41 christos Exp $");
45	#endif	45	#endif
46	#endif /* not lint */	46	#endif /* not lint */
47		47
48	#include <sys/types.h>	48	#include <sys/types.h>
49	#include <sys/stat.h>	49	#include <sys/stat.h>
50	#include <unistd.h>	50	#include <unistd.h>
51	#include <fcntl.h>	51	#include <fcntl.h>
52	#include <errno.h>	52	#include <errno.h>
53	#include <stdlib.h>	53	#include <stdlib.h>
54	#include <sysexits.h>	54	#include <sysexits.h>
55		55
56	/*	56	/*
57	* When commands are first encountered, they are entered in a hash table.	57	* When commands are first encountered, they are entered in a hash table.
58	* This ensures that a full path search will not have to be done for them	58	* This ensures that a full path search will not have to be done for them
59	* on each invocation.	59	* on each invocation.
60	*	60	*
61	* We should investigate converting to a linear search, even though that	61	* We should investigate converting to a linear search, even though that
62	* would make the command name "hash" a misnomer.	62	* would make the command name "hash" a misnomer.
63	*/	63	*/
64		64
65	#include "shell.h"	65	#include "shell.h"
66	#include "main.h"	66	#include "main.h"
67	#include "nodes.h"	67	#include "nodes.h"
68	#include "parser.h"	68	#include "parser.h"
69	#include "redir.h"	69	#include "redir.h"
70	#include "eval.h"	70	#include "eval.h"
71	#include "exec.h"	71	#include "exec.h"
72	#include "builtins.h"	72	#include "builtins.h"
73	#include "var.h"	73	#include "var.h"
74	#include "options.h"	74	#include "options.h"
75	#include "input.h"	75	#include "input.h"
76	#include "output.h"	76	#include "output.h"
77	#include "syntax.h"	77	#include "syntax.h"
78	#include "memalloc.h"	78	#include "memalloc.h"
79	#include "error.h"	79	#include "error.h"
80	#include "init.h"	80	#include "init.h"
81	#include "mystring.h"	81	#include "mystring.h"
82	#include "show.h"	82	#include "show.h"
83	#include "jobs.h"	83	#include "jobs.h"
84	#include "alias.h"	84	#include "alias.h"
85		85
86		86
87	#define CMDTABLESIZE 31 /* should be prime */	87	#define CMDTABLESIZE 31 /* should be prime */
88	#define ARB 1 /* actual size determined at run time */	88	#define ARB 1 /* actual size determined at run time */
89		89
90		90
91		91
92	struct tblentry {	92	struct tblentry {
93	struct tblentry next; / next entry in hash chain */	93	struct tblentry next; / next entry in hash chain */
94	union param param; /* definition of builtin function */	94	union param param; /* definition of builtin function */
95	short cmdtype; /* index identifying command */	95	short cmdtype; /* index identifying command */
96	char rehash; /* if set, cd done since entry created */	96	char rehash; /* if set, cd done since entry created */
97	char cmdname[ARB]; /* name of command */	97	char cmdname[ARB]; /* name of command */
98	};	98	};
99		99
100		100
101	STATIC struct tblentry *cmdtable[CMDTABLESIZE];	101	STATIC struct tblentry *cmdtable[CMDTABLESIZE];
102	STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */	102	STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */
103	int exerrno = 0; /* Last exec error */	103	int exerrno = 0; /* Last exec error */
104		104
105		105
106	STATIC void tryexec (char , char , char *);	106	STATIC void tryexec (char , char , char *);
107	STATIC void execinterp (char , char );	107	STATIC void execinterp (char , char );
108	STATIC void printentry (struct tblentry *, int);	108	STATIC void printentry (struct tblentry *, int);
109	STATIC void clearcmdentry (int);	109	STATIC void clearcmdentry (int);
110	STATIC struct tblentry cmdlookup (char , int);	110	STATIC struct tblentry cmdlookup (char , int);
111	STATIC void delete_cmd_entry (void);	111	STATIC void delete_cmd_entry (void);
112	STATIC int describe_command (char *, int);	112	STATIC int describe_command (char *, int);
113	STATIC int path_change (const char , int );	113	STATIC int path_change (const char , int );
114	STATIC int is_regular_builtin (const char *);	114	STATIC int is_regular_builtin (const char *);
115		115
116		116
117		117
118	/*	118	/*
119	* Exec a program. Never returns. If you change this routine, you may	119	* Exec a program. Never returns. If you change this routine, you may
120	* have to change the find_command routine as well.	120	* have to change the find_command routine as well.
121	*/	121	*/
122		122
123	void	123	void
124	shellexec(argv, envp, path, idx)	124	shellexec(argv, envp, path, idx)
125	char argv, envp;	125	char argv, envp;
126	const char *path;	126	const char *path;
127	int idx;	127	int idx;
128	{	128	{
129	char *cmdname;	129	char *cmdname;
130	int e;	130	int e;
131		131
132	if (fd2 >= 0 && fd2 != 2) {	132	if (fd2 >= 0 && fd2 != 2) {
133	close(fd2);	133	close(fd2);
134	}	134	}
135		135
136	if (strchr(argv[0], '/') != NULL) {	136	if (strchr(argv[0], '/') != NULL) {
137	tryexec(argv[0], argv, envp);	137	tryexec(argv[0], argv, envp);
138	e = errno;	138	e = errno;
139	} else {	139	} else {
140	e = ENOENT;	140	e = ENOENT;
141	while ((cmdname = padvance(&path, argv[0])) != NULL) {	141	while ((cmdname = padvance(&path, argv[0])) != NULL) {
142	if (--idx < 0 && pathopt == NULL) {	142	if (--idx < 0 && pathopt == NULL) {
143	tryexec(cmdname, argv, envp);	143	tryexec(cmdname, argv, envp);
144	if (errno != ENOENT && errno != ENOTDIR)	144	if (errno != ENOENT && errno != ENOTDIR)
145	e = errno;	145	e = errno;
146	}	146	}
147	stunalloc(cmdname);	147	stunalloc(cmdname);
148	}	148	}
149	}	149	}
150		150
151	/* Map to POSIX errors */	151	/* Map to POSIX errors */
152	switch (e) {	152	switch (e) {
153	case EACCES:	153	case EACCES:
154	exerrno = 126;	154	exerrno = 126;
155	break;	155	break;
156	case ENOENT:	156	case ENOENT:
157	exerrno = 127;	157	exerrno = 127;
158	break;	158	break;
159	default:	159	default:
160	exerrno = 2;	160	exerrno = 2;
161	break;	161	break;
162	}	162	}
163	exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));	163	exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
164	/* NOTREACHED */	164	/* NOTREACHED */
165	}	165	}
166		166
167		167
168	STATIC void	168	STATIC void
169	tryexec(cmd, argv, envp)	169	tryexec(cmd, argv, envp)
170	char *cmd;	170	char *cmd;
171	char **argv;	171	char **argv;
172	char **envp;	172	char **envp;
173	{	173	{
174	int e;	174	int e;
175	#if !defined(BSD) && !defined(linux)	175	#if !defined(BSD) && !defined(linux)
176	char *p;	176	char *p;
177	#endif	177	#endif
178		178
179	#ifdef SYSV	179	#ifdef SYSV
180	do {	180	do {
181	execve(cmd, argv, envp);	181	execve(cmd, argv, envp);
182	} while (errno == EINTR);	182	} while (errno == EINTR);
183	#else	183	#else
184	execve(cmd, argv, envp);	184	execve(cmd, argv, envp);
185	#endif	185	#endif
186	e = errno;	186	e = errno;
187	if (e == ENOEXEC) {	187	if (e == ENOEXEC) {
188	initshellproc();	188	initshellproc();
189	setinputfile(cmd, 0);	189	setinputfile(cmd, 0);
190	commandname = arg0 = savestr(argv[0]);	190	commandname = arg0 = savestr(argv[0]);
191	#if !defined(BSD) && !defined(linux)	191	#if !defined(BSD) && !defined(linux)
192	pgetc(); pungetc(); /* fill up input buffer */	192	pgetc(); pungetc(); /* fill up input buffer */
193	p = parsenextc;	193	p = parsenextc;
194	if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {	194	if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
195	argv[0] = cmd;	195	argv[0] = cmd;
196	execinterp(argv, envp);	196	execinterp(argv, envp);
197	}	197	}
198	#endif	198	#endif
199	setparam(argv + 1);	199	setparam(argv + 1);
200	exraise(EXSHELLPROC);	200	exraise(EXSHELLPROC);
201	}	201	}
202	errno = e;	202	errno = e;
203	}	203	}
204		204
205		205
206	#if !defined(BSD) && !defined(linux)	206	#if !defined(BSD) && !defined(linux)
207	/*	207	/*
208	* Execute an interpreter introduced by "#!", for systems where this	208	* Execute an interpreter introduced by "#!", for systems where this
209	* feature has not been built into the kernel. If the interpreter is	209	* feature has not been built into the kernel. If the interpreter is
210	* the shell, return (effectively ignoring the "#!"). If the execution	210	* the shell, return (effectively ignoring the "#!"). If the execution
211	* of the interpreter fails, exit.	211	* of the interpreter fails, exit.
212	*	212	*
213	* This code peeks inside the input buffer in order to avoid actually	213	* This code peeks inside the input buffer in order to avoid actually
214	* reading any input. It would benefit from a rewrite.	214	* reading any input. It would benefit from a rewrite.
215	*/	215	*/
216		216
217	#define NEWARGS 5	217	#define NEWARGS 5
218		218
219	STATIC void	219	STATIC void
220	execinterp(argv, envp)	220	execinterp(argv, envp)
221	char argv, envp;	221	char argv, envp;
222	{	222	{
223	int n;	223	int n;
224	char *inp;	224	char *inp;
225	char *outp;	225	char *outp;
226	char c;	226	char c;
227	char *p;	227	char *p;
228	char **ap;	228	char **ap;
229	char *newargs[NEWARGS];	229	char *newargs[NEWARGS];
230	int i;	230	int i;
231	char **ap2;	231	char **ap2;
232	char **new;	232	char **new;
233		233
234	n = parsenleft - 2;	234	n = parsenleft - 2;
235	inp = parsenextc + 2;	235	inp = parsenextc + 2;
236	ap = newargs;	236	ap = newargs;
237	for (;;) {	237	for (;;) {
238	while (--n >= 0 && (inp == ' ' \|\| inp == '\t'))	238	while (--n >= 0 && (inp == ' ' \|\| inp == '\t'))
239	inp++;	239	inp++;
240	if (n < 0)	240	if (n < 0)
241	goto bad;	241	goto bad;
242	if ((c = *inp++) == '\n')	242	if ((c = *inp++) == '\n')
243	break;	243	break;
244	if (ap == &newargs[NEWARGS])	244	if (ap == &newargs[NEWARGS])
245	bad: error("Bad #! line");	245	bad: error("Bad #! line");
246	STARTSTACKSTR(outp);	246	STARTSTACKSTR(outp);
247	do {	247	do {
248	STPUTC(c, outp);	248	STPUTC(c, outp);
249	} while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');	249	} while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');
250	STPUTC('\0', outp);	250	STPUTC('\0', outp);
251	n++, inp--;	251	n++, inp--;
252	*ap++ = grabstackstr(outp);	252	*ap++ = grabstackstr(outp);
253	}	253	}
254	if (ap == newargs + 1) { /* if no args, maybe no exec is needed */	254	if (ap == newargs + 1) { /* if no args, maybe no exec is needed */
255	p = newargs[0];	255	p = newargs[0];
256	for (;;) {	256	for (;;) {
257	if (equal(p, "sh") \|\| equal(p, "ash")) {	257	if (equal(p, "sh") \|\| equal(p, "ash")) {
258	return;	258	return;
259	}	259	}
260	while (*p != '/') {	260	while (*p != '/') {
261	if (*p == '\0')	261	if (*p == '\0')
262	goto break2;	262	goto break2;
263	p++;	263	p++;
264	}	264	}
265	p++;	265	p++;
266	}	266	}
267	break2:;	267	break2:;
268	}	268	}
269	i = (char )ap - (char )newargs; /* size in bytes */	269	i = (char )ap - (char )newargs; /* size in bytes */
270	if (i == 0)	270	if (i == 0)
271	error("Bad #! line");	271	error("Bad #! line");
272	for (ap2 = argv ; *ap2++ != NULL ; );	272	for (ap2 = argv ; *ap2++ != NULL ; );
273	new = ckmalloc(i + ((char )ap2 - (char )argv));	273	new = ckmalloc(i + ((char )ap2 - (char )argv));
274	ap = newargs, ap2 = new;	274	ap = newargs, ap2 = new;
275	while ((i -= sizeof (char **)) >= 0)	275	while ((i -= sizeof (char **)) >= 0)
276	ap2++ = ap++;	276	ap2++ = ap++;
277	ap = argv;	277	ap = argv;
278	while (ap2++ = ap++);	278	while (ap2++ = ap++);
279	shellexec(new, envp, pathval(), 0);	279	shellexec(new, envp, pathval(), 0);
280	/* NOTREACHED */	280	/* NOTREACHED */
281	}	281	}
282	#endif	282	#endif
283		283
284		284
285		285
286	/*	286	/*
287	* Do a path search. The variable path (passed by reference) should be	287	* Do a path search. The variable path (passed by reference) should be
288	* set to the start of the path before the first call; padvance will update	288	* set to the start of the path before the first call; padvance will update
289	* this value as it proceeds. Successive calls to padvance will return	289	* this value as it proceeds. Successive calls to padvance will return
290	* the possible path expansions in sequence. If an option (indicated by	290	* the possible path expansions in sequence. If an option (indicated by
291	* a percent sign) appears in the path entry then the global variable	291	* a percent sign) appears in the path entry then the global variable
292	* pathopt will be set to point to it; otherwise pathopt will be set to	292	* pathopt will be set to point to it; otherwise pathopt will be set to
293	* NULL.	293	* NULL.
294	*/	294	*/
295		295
296	const char *pathopt;	296	const char *pathopt;
297		297
298	char *	298	char *
299	padvance(path, name)	299	padvance(path, name)
300	const char **path;	300	const char **path;
301	const char *name;	301	const char *name;
302	{	302	{
303	const char *p;	303	const char *p;
304	char *q;	304	char *q;
305	const char *start;	305	const char *start;
306	int len;	306	int len;
307		307
308	if (*path == NULL)	308	if (*path == NULL)
309	return NULL;	309	return NULL;
310	start = *path;	310	start = *path;
311	for (p = start ; p && p != ':' && *p != '%' ; p++);	311	for (p = start ; p && p != ':' && *p != '%' ; p++);
312	len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */	312	len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
313	while (stackblocksize() < len)	313	while (stackblocksize() < len)
314	growstackblock();	314	growstackblock();
315	q = stackblock();	315	q = stackblock();
316	if (p != start) {	316	if (p != start) {
317	memcpy(q, start, p - start);	317	memcpy(q, start, p - start);
318	q += p - start;	318	q += p - start;
319	*q++ = '/';	319	*q++ = '/';
320	}	320	}
321	strcpy(q, name);	321	strcpy(q, name);
322	pathopt = NULL;	322	pathopt = NULL;
323	if (*p == '%') {	323	if (*p == '%') {
324	pathopt = ++p;	324	pathopt = ++p;
325	while (p && p != ':') p++;	325	while (p && p != ':') p++;
326	}	326	}
327	if (*p == ':')	327	if (*p == ':')
328	*path = p + 1;	328	*path = p + 1;
329	else	329	else
330	*path = NULL;	330	*path = NULL;
331	return stalloc(len);	331	return stalloc(len);
332	}	332	}
333		333
334		334
335		335
336	/* Command hashing code */	336	/* Command hashing code */
337		337
338		338
339	int	339	int
340	hashcmd(argc, argv)	340	hashcmd(argc, argv)
341	int argc;	341	int argc;
342	char **argv;	342	char **argv;
343	{	343	{
344	struct tblentry **pp;	344	struct tblentry **pp;
345	struct tblentry *cmdp;	345	struct tblentry *cmdp;
346	int c;	346	int c;
347	int verbose;	347	int verbose;
348	struct cmdentry entry;	348	struct cmdentry entry;
349	char *name;	349	char *name;
350		350
351	verbose = 0;	351	verbose = 0;
352	while ((c = nextopt("rv")) != '\0') {	352	while ((c = nextopt("rv")) != '\0') {
353	if (c == 'r') {	353	if (c == 'r') {
354	clearcmdentry(0);	354	clearcmdentry(0);
355	} else if (c == 'v') {	355	} else if (c == 'v') {
356	verbose++;	356	verbose++;
357	}	357	}
358	}	358	}
359	if (*argptr == NULL) {	359	if (*argptr == NULL) {
360	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {	360	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
361	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {	361	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
362	if (cmdp->cmdtype != CMDBUILTIN) {	362	if (cmdp->cmdtype != CMDBUILTIN) {
363	printentry(cmdp, verbose);	363	printentry(cmdp, verbose);
364	}	364	}
365	}	365	}
366	}	366	}
367	return 0;	367	return 0;
368	}	368	}
369	c = 0;	369	c = 0;
370	while ((name = *argptr) != NULL) {	370	while ((name = *argptr) != NULL) {
371	if ((cmdp = cmdlookup(name, 0)) != NULL	371	if ((cmdp = cmdlookup(name, 0)) != NULL
372	&& (cmdp->cmdtype == CMDNORMAL	372	&& (cmdp->cmdtype == CMDNORMAL
373	\|\| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))	373	\|\| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
374	delete_cmd_entry();	374	delete_cmd_entry();
375	find_command(name, &entry, DO_ERR, pathval());	375	find_command(name, &entry, DO_ERR, pathval());
376	if (entry.cmdtype == CMDUNKNOWN) c = 1;	376	if (entry.cmdtype == CMDUNKNOWN) c = 1;
377	else if (verbose) {	377	else if (verbose) {
378	cmdp = cmdlookup(name, 0);	378	cmdp = cmdlookup(name, 0);
379	if (cmdp) printentry(cmdp, verbose);	379	if (cmdp) printentry(cmdp, verbose);
380	flushall();	380	flushall();
381	}	381	}
382	argptr++;	382	argptr++;
383	}	383	}
384	return c;	384	return c;
385	}	385	}
386		386
387		387
388	STATIC void	388	STATIC void
389	printentry(cmdp, verbose)	389	printentry(cmdp, verbose)
390	struct tblentry *cmdp;	390	struct tblentry *cmdp;
391	int verbose;	391	int verbose;
392	{	392	{
393	int idx;	393	int idx;
394	const char *path;	394	const char *path;
395	char *name;	395	char *name;
396		396
397	if (cmdp->cmdtype == CMDNORMAL) {	397	if (cmdp->cmdtype == CMDNORMAL) {
398	idx = cmdp->param.index;	398	idx = cmdp->param.index;
399	path = pathval();	399	path = pathval();
400	do {	400	do {
401	name = padvance(&path, cmdp->cmdname);	401	name = padvance(&path, cmdp->cmdname);
402	stunalloc(name);	402	stunalloc(name);
403	} while (--idx >= 0);	403	} while (--idx >= 0);
404	out1str(name);	404	out1str(name);
405	} else if (cmdp->cmdtype == CMDBUILTIN) {	405	} else if (cmdp->cmdtype == CMDBUILTIN) {
406	out1fmt("builtin %s", cmdp->cmdname);	406	out1fmt("builtin %s", cmdp->cmdname);
407	} else if (cmdp->cmdtype == CMDFUNCTION) {	407	} else if (cmdp->cmdtype == CMDFUNCTION) {
408	out1fmt("function %s", cmdp->cmdname);	408	out1fmt("function %s", cmdp->cmdname);
409	if (verbose) {	409	if (verbose) {
410	INTOFF;	410	INTOFF;
411	name = commandtext(cmdp->param.func);	411	name = commandtext(cmdp->param.func);
412	out1c(' ');	412	out1c(' ');
413	out1str(name);	413	out1str(name);
414	ckfree(name);	414	ckfree(name);
415	INTON;	415	INTON;
416	}	416	}
417	#ifdef DEBUG	417	#ifdef DEBUG
418	} else {	418	} else {
419	error("internal error: cmdtype %d", cmdp->cmdtype);	419	error("internal error: cmdtype %d", cmdp->cmdtype);
420	#endif	420	#endif
421	}	421	}
422	if (cmdp->rehash)	422	if (cmdp->rehash)
423	out1c('*');	423	out1c('*');
424	out1c('\n');	424	out1c('\n');
425	}	425	}
426		426
427		427
428		428
429	/*	429	/*
430	* Resolve a command name. If you change this routine, you may have to	430	* Resolve a command name. If you change this routine, you may have to
431	* change the shellexec routine as well.	431	* change the shellexec routine as well.
432	*/	432	*/
433		433
434	void	434	void
435	find_command(name, entry, act, path)	435	find_command(name, entry, act, path)
436	char *name;	436	char *name;
437	struct cmdentry *entry;	437	struct cmdentry *entry;
438	int act;	438	int act;
439	const char *path;	439	const char *path;
440	{	440	{
441	struct tblentry *cmdp;	441	struct tblentry *cmdp;
442	int idx;	442	int idx;
443	int prev;	443	int prev;
444	char *fullname;	444	char *fullname;
445	struct stat statb;	445	struct stat statb;
446	int e;	446	int e;
447	int i;	447	int i;
448	int bltin;	448	int bltin;
449	int firstchange;	449	int firstchange;
450	int updatetbl;	450	int updatetbl;
451	int regular;	451	int regular;
452		452
453	/* If name contains a slash, don't use the hash table */	453	/* If name contains a slash, don't use the hash table */
454	if (strchr(name, '/') != NULL) {	454	if (strchr(name, '/') != NULL) {
455	if (act & DO_ABS) {	455	if (act & DO_ABS) {
456	while (stat(name, &statb) < 0) {	456	while (stat(name, &statb) < 0) {
457	#ifdef SYSV	457	#ifdef SYSV
458	if (errno == EINTR)	458	if (errno == EINTR)
459	continue;	459	continue;
460	#endif	460	#endif
461	if (errno != ENOENT && errno != ENOTDIR)	461	if (errno != ENOENT && errno != ENOTDIR)
462	e = errno;	462	e = errno;
463	entry->cmdtype = CMDUNKNOWN;	463	entry->cmdtype = CMDUNKNOWN;
464	entry->u.index = -1;	464	entry->u.index = -1;
465	return;	465	return;
466	}	466	}
467	entry->cmdtype = CMDNORMAL;	467	entry->cmdtype = CMDNORMAL;
468	entry->u.index = -1;	468	entry->u.index = -1;
469	return;	469	return;
470	}	470	}
471	entry->cmdtype = CMDNORMAL;	471	entry->cmdtype = CMDNORMAL;
472	entry->u.index = 0;	472	entry->u.index = 0;
473	return;	473	return;
474	}	474	}
475		475
476	updatetbl = 1;	476	updatetbl = 1;
477	if (act & DO_BRUTE) {	477	if (act & DO_BRUTE) {
478	firstchange = path_change(path, &bltin);	478	firstchange = path_change(path, &bltin);
479	} else {	479	} else {
480	bltin = builtinloc;	480	bltin = builtinloc;
481	firstchange = 9999;	481	firstchange = 9999;
482	}	482	}
483		483
484	/* If name is in the table, and not invalidated by cd, we're done */	484	/* If name is in the table, and not invalidated by cd, we're done */
485	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {	485	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
486	if (cmdp->cmdtype == CMDFUNCTION) {	486	if (cmdp->cmdtype == CMDFUNCTION) {
487	if (act & DO_NOFUN) {	487	if (act & DO_NOFUN) {
488	updatetbl = 0;	488	updatetbl = 0;
489	} else {	489	} else {
490	goto success;	490	goto success;
491	}	491	}
492	} else if (act & DO_BRUTE) {	492	} else if (act & DO_BRUTE) {
493	if ((cmdp->cmdtype == CMDNORMAL &&	493	if ((cmdp->cmdtype == CMDNORMAL &&
494	cmdp->param.index >= firstchange) \|\|	494	cmdp->param.index >= firstchange) \|\|
495	(cmdp->cmdtype == CMDBUILTIN &&	495	(cmdp->cmdtype == CMDBUILTIN &&
496	((builtinloc < 0 && bltin >= 0) ?	496	((builtinloc < 0 && bltin >= 0) ?
497	bltin : builtinloc) >= firstchange)) {	497	bltin : builtinloc) >= firstchange)) {
498	/* need to recompute the entry */	498	/* need to recompute the entry */
499	} else {	499	} else {
500	goto success;	500	goto success;

Subversion Repositories HelenOS

(root)/tags/0.3.0/uspace/app/ash/exec.c – Rev 2714 → 2782