cmd/sh/name.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * UNIX shell
 */

#include    "defs.h"
#include    <stropts.h>

extern BOOL chkid();
extern unsigned char    *simple();
extern int  mailchk;

static void setname(unsigned char *, int);
static void set_builtins_path();
static int  patheq();
static void namwalk(struct namnod *);
static void dolocale();

struct namnod ps2nod =
{
    (struct namnod *)NIL,
    &acctnod,
    (unsigned char *)ps2name
};
struct namnod cdpnod =
{
    (struct namnod *)NIL,
    (struct namnod *)NIL,
    (unsigned char *)cdpname
};
struct namnod pathnod =
{
    &mailpnod,
    (struct namnod *)NIL,
    (unsigned char *)pathname
};
struct namnod ifsnod =
{
    &homenod,
    &mailnod,
    (unsigned char *)ifsname
};
struct namnod ps1nod =
{
    &pathnod,
    &ps2nod,
    (unsigned char *)ps1name
};
struct namnod homenod =
{
    &cdpnod,
    (struct namnod *)NIL,
    (unsigned char *)homename
};
struct namnod mailnod =
{
    (struct namnod *)NIL,
    (struct namnod *)NIL,
    (unsigned char *)mailname
};
struct namnod mchknod =
{
    &ifsnod,
    &ps1nod,
    (unsigned char *)mchkname
};
struct namnod acctnod =
{
    (struct namnod *)NIL,
    (struct namnod *)NIL,
    (unsigned char *)acctname
};
struct namnod mailpnod =
{
    (struct namnod *)NIL,
    (struct namnod *)NIL,
    (unsigned char *)mailpname
};


struct namnod *namep = &mchknod;

/* ======== variable and string handling    ======== */

int
syslook(unsigned char *w, struct sysnod syswds[], int n)
{
    int low;
    int high;
    int mid;
    int cond;

    if (w == 0 || *w == 0)
        return(0);

    low = 0;
    high = n - 1;

    while (low <= high)
    {
        mid = (low + high) / 2;

        if ((cond = cf(w, syswds[mid].sysnam)) < 0)
            high = mid - 1;
        else if (cond > 0)
            low = mid + 1;
        else
            return(syswds[mid].sysval);
    }
    return(0);
}

void
setlist(struct argnod *arg, int xp)
{
    if (flags & exportflg)
        xp |= N_EXPORT;

    while (arg)
    {
        unsigned char *s = mactrim(arg->argval);
        setname(s, xp);
        arg = arg->argnxt;
        if (flags & execpr)
        {
            prs(s);
            if (arg)
                blank();
            else
                newline();
        }
    }
}

static void
setname(unsigned char *argi, int xp)    /* does parameter assignments */
{
    unsigned char *argscan = argi;
    struct namnod *n;

    if (letter(*argscan))
    {
        while (alphanum(*argscan))
            argscan++;

        if (*argscan == '=')
        {
            *argscan = 0;   /* make name a cohesive string */

            n = lookup(argi);
            *argscan++ = '=';
            attrib(n, xp);
            if (xp & N_ENVNAM)
            {
                n->namenv = n->namval = argscan;
                if (n == &pathnod)
                    set_builtins_path();
            }
            else
                assign(n, argscan);

            dolocale(n->namid);
            return;
        }
    }
}

void
replace(unsigned char **a, unsigned char *v)
{
    free(*a);
    *a = make(v);
}

void
dfault(struct namnod *n, unsigned char  *v)
{
    if (n->namval == 0)
        assign(n, v);
}

void
assign(struct namnod *n, unsigned char *v)
{
    if (n->namflg & N_RDONLY)
        failed(n->namid, wtfailed);

#ifndef RES

    else if (flags & rshflg)
    {
        if (n == &pathnod || eq(n->namid,"SHELL"))
            failed(n->namid, restricted);
    }
#endif

    else if (n->namflg & N_FUNCTN)
    {
        func_unhash(n->namid);
        freefunc(n);

        n->namenv = 0;
        n->namflg = N_DEFAULT;
    }

    if (n == &mchknod)
    {
        mailchk = stoi(v);
    }

    replace(&n->namval, v);
    attrib(n, N_ENVCHG);

    if (n == &pathnod)
    {
        zaphash();
        set_dotpath();
        set_builtins_path();
        return;
    }

    if (flags & prompt)
    {
        if ((n == &mailpnod) || (n == &mailnod && mailpnod.namflg == N_DEFAULT))
            setmail(n->namval);
    }
}

static void
set_builtins_path()
{
    unsigned char *path;

        ucb_builtins = 0;
        path = getpath("");
        while (path && *path)
        {
                if (patheq(path, "/usr/ucb"))
                {
                        ucb_builtins++;
                        break;
                }
                else if (patheq(path, "/usr/bin"))
                        break;
                else if (patheq(path, "/bin"))
                        break;
                else if (patheq(path, "/usr/5bin"))
                        break;
                path = nextpath(path);
        }
}

static int
patheq(unsigned char *component, char *dir)
{
    unsigned char   c;

        for (;;)
        {
                c = *component++;
                if (c == COLON)
                        c = '\0';       /* end of component of path */
        if (c != *dir++)
            return (0);
                if (c == '\0')
                        return(1);
        }
}

int
readvar(unsigned char **names)
{
    struct fileblk  fb;
    struct fileblk *f = &fb;
    unsigned char   c[MULTI_BYTE_MAX+1];
    int rc = 0;
    struct namnod *n = lookup(*names++);    /* done now to avoid storage mess */
    unsigned char   *rel = (unsigned char *)relstak();
    unsigned char *oldstak;
    unsigned char *pc, *rest;
    int     d;

    push(f);
    initf(dup(0));

    /*
     * If stdin is a pipe then this lseek(2) will fail with ESPIPE, so
     * the read buffer size is set to 1 because we will not be able
     * lseek(2) back towards the beginning of the file, so we have
     * to read a byte at a time instead
     *
     */
    if (lseek(0, (off_t)0, SEEK_CUR) == -1)
        f->fsiz = 1;

    /*
     * If stdin is a socket then this isastream(3C) will return 1, so
     * the read buffer size is set to 1 because we will not be able
     * lseek(2) back towards the beginning of the file, so we have
     * to read a byte at a time instead
     *
     */
    if (isastream(0) == 1)
        f->fsiz = 1;

    /*
     * strip leading IFS characters
     */
    for (;;)
    {
        d = nextwc();
        if(eolchar(d))
            break;
        rest = readw(d);
        pc = c;
        while(*pc++ = *rest++);
        if(!anys(c, ifsnod.namval))
            break;
    }

    oldstak = curstak();
    for (;;)
    {
        if ((*names && anys(c, ifsnod.namval)) || eolchar(d))
        {
            if (staktop >= brkend)
                growstak(staktop);
            zerostak();
            assign(n, absstak(rel));
            setstak(rel);
            if (*names)
                n = lookup(*names++);
            else
                n = 0;
            if (eolchar(d))
            {
                break;
            }
            else        /* strip imbedded IFS characters */
                while(1) {
                    d = nextwc();
                    if(eolchar(d))
                        break;
                    rest = readw(d);
                    pc = c;
                    while(*pc++ = *rest++);
                    if(!anys(c, ifsnod.namval))
                        break;
                }
        }
        else
        {
            if(d == '\\') {
                d = readwc();
                rest = readw(d);
                while(d = *rest++) {
                    if (staktop >= brkend)
                        growstak(staktop);
                    pushstak(d);
                }
                oldstak = staktop;
            }
            else
            {
                pc = c;
                while(d = *pc++) {
                    if (staktop >= brkend)
                        growstak(staktop);
                    pushstak(d);
                }
                if(!anys(c, ifsnod.namval))
                    oldstak = staktop;
            }
            d = nextwc();

            if (eolchar(d))
                staktop = oldstak;
            else
            {
                rest = readw(d);
                pc = c;
                while(*pc++ = *rest++);
            }
        }
    }
    while (n)
    {
        assign(n, (unsigned char *)nullstr);
        if (*names)
            n = lookup(*names++);
        else
            n = 0;
    }

    if (eof)
        rc = 1;

    if (isastream(0) != 1)
        /*
         * If we are reading on a stream do not attempt to
         * lseek(2) back towards the start because this is
         * logically meaningless, but there is nothing in
         * the standards to pervent the stream implementation
         * from attempting it and breaking our code here
         *
         */
        lseek(0, (off_t)(f->nxtoff - f->endoff), SEEK_CUR);

    pop();
    return(rc);
}

void
assnum(unsigned char **p, long i)
{
    int j = ltos(i);
    replace(p, &numbuf[j]);
}

unsigned char *
make(v)
unsigned char   *v;
{
    unsigned char   *p;

    if (v)
    {
        movstr(v, p = (unsigned char *)alloc(length(v)));
        return(p);
    }
    else
        return(0);
}


struct namnod *
lookup(unsigned char *nam)
{
    struct namnod *nscan = namep;
    struct namnod **prev;
    int     LR;

    if (!chkid(nam))
        failed(nam, notid);

    while (nscan)
    {
        if ((LR = cf(nam, nscan->namid)) == 0)
            return(nscan);

        else if (LR < 0)
            prev = &(nscan->namlft);
        else
            prev = &(nscan->namrgt);
        nscan = *prev;
    }
    /*
     * add name node
     */
    nscan = (struct namnod *)alloc(sizeof *nscan);
    nscan->namlft = nscan->namrgt = (struct namnod *)NIL;
    nscan->namid = make(nam);
    nscan->namval = 0;
    nscan->namflg = N_DEFAULT;
    nscan->namenv = 0;

    return(*prev = nscan);
}

BOOL
chkid(nam)
unsigned char   *nam;
{
    unsigned char *cp = nam;

    if (!letter(*cp))
        return(FALSE);
    else
    {
        while (*++cp)
        {
            if (!alphanum(*cp))
                return(FALSE);
        }
    }
    return(TRUE);
}

static void (*namfn)();

void
namscan(void (*fn)())
{
    namfn = fn;
    namwalk(namep);
}

static void
namwalk(struct namnod *np)
{
    if (np)
    {
        namwalk(np->namlft);
        (*namfn)(np);
        namwalk(np->namrgt);
    }
}

void
printnam(struct namnod *n)
{
    unsigned char   *s;

    sigchk();

    if (n->namflg & N_FUNCTN)
    {
        struct fndnod *f = fndptr(n->namenv);

        prs_buff(n->namid);
        prs_buff("(){\n");
        if (f != NULL)
            prf(f->fndval);
        prs_buff("\n}\n");
    }
    else if (s = n->namval)
    {
        prs_buff(n->namid);
        prc_buff('=');
        prs_buff(s);
        prc_buff(NL);
    }
}

static int namec;

void
printro(struct namnod *n)
{
    if (n->namflg & N_RDONLY)
    {
        prs_buff(_gettext(readonly));
        prc_buff(SPACE);
        prs_buff(n->namid);
        prc_buff(NL);
    }
}

void
printexp(struct namnod *n)
{
    if (n->namflg & N_EXPORT)
    {
        prs_buff(_gettext(export));
        prc_buff(SPACE);
        prs_buff(n->namid);
        prc_buff(NL);
    }
}

void
setup_env(void)
{
    unsigned char **e = environ;

    while (*e)
        setname(*e++, N_ENVNAM);
}


static unsigned char **argnam;

static void
countnam(struct namnod *n)
{
    if (n->namval)
        namec++;
}

static void
pushnam(struct namnod *n)
{
    int     flg = n->namflg;
    unsigned char   *p;
    unsigned char   *namval;

    if (((flg & N_ENVCHG) && (flg & N_EXPORT)) || (flg & N_FUNCTN))
        namval = n->namval;
    else {
        /* Discard Local variable in child process */
        if (!(flg & ~N_ENVCHG)) {
            n->namflg = 0;
            n->namenv = 0;
            if (n->namval) {
                /* Release for re-use */
                free(n->namval);
                n->namval = (unsigned char *)NIL;
            }
        }
        namval = n->namenv;
    }

    if (namval)
    {
        p = movstrstak(n->namid, staktop);
        p = movstrstak("=", p);
        p = movstrstak(namval, p);
        *argnam++ = getstak(p + 1 - (unsigned char *)(stakbot));
    }
}

unsigned char **
local_setenv()
{
    unsigned char   **er;

    namec = 0;
    namscan(countnam);

    argnam = er = (unsigned char **)getstak(namec * BYTESPERWORD + BYTESPERWORD);
    namscan(pushnam);
    *argnam++ = 0;
    return(er);
}

struct namnod *
findnam(nam)
    unsigned char   *nam;
{
    struct namnod   *nscan = namep;
    int     LR;

    if (!chkid(nam))
        return(0);
    while (nscan)
    {
        if ((LR = cf(nam, nscan->namid)) == 0)
            return(nscan);
        else if (LR < 0)
            nscan = nscan->namlft;
        else
            nscan = nscan->namrgt;
    }
    return(0);
}

void
unset_name(unsigned char    *name)
{
    struct namnod   *n;
    unsigned char   call_dolocale = 0;

    if (n = findnam(name))
    {
        if (n->namflg & N_RDONLY)
            failed(name, wtfailed);

        if (n == &pathnod ||
            n == &ifsnod ||
            n == &ps1nod ||
            n == &ps2nod ||
            n == &mchknod)
        {
            failed(name, badunset);
        }

#ifndef RES

        if ((flags & rshflg) && eq(name, "SHELL"))
            failed(name, restricted);

#endif

        if (n->namflg & N_FUNCTN)
        {
            func_unhash(name);
            freefunc(n);
        }
        else
        {
            call_dolocale++;
            free(n->namval);
            free(n->namenv);
        }

        n->namval = n->namenv = 0;
        n->namflg = N_DEFAULT;

        if (call_dolocale)
            dolocale(name);

        if (flags & prompt)
        {
            if (n == &mailpnod)
                setmail(mailnod.namval);
            else if (n == &mailnod && mailpnod.namflg == N_DEFAULT)
                setmail(0);
        }
    }
}

/*
 * The environment variables which affect locale.
 * Note: if all names in this list do not begin with 'L',
 * you MUST modify dolocale().  Also, be sure that the
 * fake_env has the same number of elements as localevar.
 */
static char *localevar[] = {
    "LC_ALL",
    "LC_CTYPE",
    "LC_MESSAGES",
    "LANG",
    0
};

static char *fake_env[] = {
    0,
    0,
    0,
    0,
    0
};

/*
 * If name is one of several special variables which affect the locale,
 * do a setlocale().
 */
static void
dolocale(nm)
    char *nm;
{
    char **real_env;
    struct namnod *n;
    int lv, fe;
    int i;

    /*
     * Take advantage of fact that names of these vars all start
     * with 'L' to avoid unnecessary work.
     * Do locale processing only if /usr is mounted.
     */
    if ((*nm != 'L') || !localedir_exists ||
        (!(eq(nm, "LC_ALL") || eq(nm, "LC_CTYPE") ||
        eq(nm, "LANG") || eq(nm, "LC_MESSAGES"))))
        return;

    /*
     * setlocale() has all the smarts built into it, but
     * it works by examining the environment.  Unfortunately,
     * when you set an environment variable, the shell does
     * not modify its own environment; it just remembers that the
     * variable needs to be exported to any children.  We hack around
     * this by consing up a fake environment for the use of setlocale()
     * and substituting it for the real env before calling setlocale().
     */

    /*
     * Build the fake environment.
     * Look up the value of each of the special environment
     * variables, and put their value into the fake environment,
     * if they are exported.
     */
    for (lv = 0, fe = 0; localevar[lv]; lv++) {
        if ((n = findnam(localevar[lv]))) {
            char *p, *q;

            if (!n->namval)
                continue;

            fake_env[fe++] = p = alloc(length(localevar[lv])
                           + length(n->namval) + 2);
            /* copy name */
            q = localevar[lv];
            while (*q)
                *p++ = *q++;

            *p++ = '=';

            /* copy value */
            q = (char*)(n->namval);
            while (*q)
                *p++ = *q++;
            *p++ = '\0';
        }
    }
    fake_env[fe] = (char *)0;

    /*
     * Switch fake env for real and call setlocale().
     */
    real_env = (char **)environ;
    environ = (unsigned char **)fake_env;

    if (setlocale(LC_ALL, "") == NULL)
        prs(_gettext(badlocale));

    /*
     * Switch back and tear down the fake env.
     */
    environ = (unsigned char **)real_env;
    for (i = 0; i < fe; i++) {
        free(fake_env[i]);
        fake_env[i] = (char *)0;
    }
}