Home | History | Annotate | Line # | Download | only in sh
var.c revision 1.78
      1  1.78       kre /*	$NetBSD: var.c,v 1.78 2019/02/14 11:15:24 kre Exp $	*/
      2  1.12       cgd 
      3   1.1       cgd /*-
      4   1.5       jtc  * Copyright (c) 1991, 1993
      5   1.5       jtc  *	The Regents of the University of California.  All rights reserved.
      6   1.1       cgd  *
      7   1.1       cgd  * This code is derived from software contributed to Berkeley by
      8   1.1       cgd  * Kenneth Almquist.
      9   1.1       cgd  *
     10   1.1       cgd  * Redistribution and use in source and binary forms, with or without
     11   1.1       cgd  * modification, are permitted provided that the following conditions
     12   1.1       cgd  * are met:
     13   1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     14   1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     15   1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     17   1.1       cgd  *    documentation and/or other materials provided with the distribution.
     18  1.33       agc  * 3. Neither the name of the University nor the names of its contributors
     19   1.1       cgd  *    may be used to endorse or promote products derived from this software
     20   1.1       cgd  *    without specific prior written permission.
     21   1.1       cgd  *
     22   1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23   1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24   1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25   1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26   1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27   1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28   1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29   1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30   1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31   1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32   1.1       cgd  * SUCH DAMAGE.
     33   1.1       cgd  */
     34   1.1       cgd 
     35  1.19  christos #include <sys/cdefs.h>
     36   1.1       cgd #ifndef lint
     37  1.12       cgd #if 0
     38  1.13  christos static char sccsid[] = "@(#)var.c	8.3 (Berkeley) 5/4/95";
     39  1.12       cgd #else
     40  1.78       kre __RCSID("$NetBSD: var.c,v 1.78 2019/02/14 11:15:24 kre Exp $");
     41  1.12       cgd #endif
     42   1.1       cgd #endif /* not lint */
     43   1.1       cgd 
     44  1.58       kre #include <stdio.h>
     45  1.13  christos #include <unistd.h>
     46  1.13  christos #include <stdlib.h>
     47  1.42  christos #include <string.h>
     48  1.21      fair #include <paths.h>
     49  1.41  christos #include <limits.h>
     50  1.63       kre #include <time.h>
     51  1.63       kre #include <pwd.h>
     52  1.63       kre #include <fcntl.h>
     53  1.70       kre #include <inttypes.h>
     54  1.13  christos 
     55   1.1       cgd /*
     56   1.1       cgd  * Shell variables.
     57   1.1       cgd  */
     58   1.1       cgd 
     59   1.1       cgd #include "shell.h"
     60   1.1       cgd #include "output.h"
     61   1.1       cgd #include "expand.h"
     62   1.1       cgd #include "nodes.h"	/* for other headers */
     63   1.1       cgd #include "eval.h"	/* defines cmdenviron */
     64   1.1       cgd #include "exec.h"
     65   1.1       cgd #include "syntax.h"
     66   1.1       cgd #include "options.h"
     67  1.40  christos #include "builtins.h"
     68   1.1       cgd #include "mail.h"
     69   1.1       cgd #include "var.h"
     70   1.1       cgd #include "memalloc.h"
     71   1.1       cgd #include "error.h"
     72   1.1       cgd #include "mystring.h"
     73  1.15  christos #include "parser.h"
     74  1.32       dsl #include "show.h"
     75  1.63       kre #include "machdep.h"
     76  1.17  christos #ifndef SMALL
     77  1.13  christos #include "myhistedit.h"
     78  1.13  christos #endif
     79   1.1       cgd 
     80  1.35       dsl #ifdef SMALL
     81   1.1       cgd #define VTABSIZE 39
     82  1.35       dsl #else
     83  1.35       dsl #define VTABSIZE 517
     84  1.35       dsl #endif
     85   1.1       cgd 
     86   1.1       cgd 
     87   1.1       cgd struct varinit {
     88   1.1       cgd 	struct var *var;
     89   1.1       cgd 	int flags;
     90  1.23  christos 	const char *text;
     91  1.57       kre 	union var_func_union v_u;
     92   1.1       cgd };
     93  1.57       kre #define	func v_u.set_func
     94  1.57       kre #define	rfunc v_u.ref_func
     95  1.57       kre 
     96  1.57       kre char *get_lineno(struct var *);
     97   1.1       cgd 
     98  1.63       kre #ifndef SMALL
     99  1.63       kre char *get_tod(struct var *);
    100  1.63       kre char *get_hostname(struct var *);
    101  1.63       kre char *get_seconds(struct var *);
    102  1.63       kre char *get_euser(struct var *);
    103  1.63       kre char *get_random(struct var *);
    104  1.63       kre #endif
    105  1.63       kre 
    106  1.39  dholland struct localvar *localvars;
    107   1.1       cgd 
    108  1.17  christos #ifndef SMALL
    109   1.5       jtc struct var vhistsize;
    110  1.18  christos struct var vterm;
    111  1.61       kre struct var editrc;
    112  1.62       kre struct var ps_lit;
    113   1.7       cgd #endif
    114   1.1       cgd struct var vifs;
    115   1.1       cgd struct var vmail;
    116   1.1       cgd struct var vmpath;
    117   1.1       cgd struct var vpath;
    118   1.1       cgd struct var vps1;
    119   1.1       cgd struct var vps2;
    120  1.32       dsl struct var vps4;
    121  1.49  christos struct var vvers;
    122  1.14  christos struct var voptind;
    123  1.56       kre struct var line_num;
    124  1.63       kre #ifndef SMALL
    125  1.63       kre struct var tod;
    126  1.63       kre struct var host_name;
    127  1.63       kre struct var seconds;
    128  1.63       kre struct var euname;
    129  1.63       kre struct var random_num;
    130  1.63       kre 
    131  1.63       kre intmax_t sh_start_time;
    132  1.63       kre #endif
    133   1.1       cgd 
    134  1.57       kre struct var line_num;
    135  1.57       kre int line_number;
    136  1.57       kre int funclinebase = 0;
    137  1.57       kre int funclineabs = 0;
    138  1.57       kre 
    139  1.48  christos char ifs_default[] = " \t\n";
    140  1.48  christos 
    141   1.1       cgd const struct varinit varinit[] = {
    142  1.17  christos #ifndef SMALL
    143  1.14  christos 	{ &vhistsize,	VSTRFIXED|VTEXTFIXED|VUNSET,	"HISTSIZE=",
    144  1.57       kre 	   { .set_func= sethistsize } },
    145   1.7       cgd #endif
    146  1.14  christos 	{ &vifs,	VSTRFIXED|VTEXTFIXED,		"IFS= \t\n",
    147  1.57       kre 	   { NULL } },
    148  1.14  christos 	{ &vmail,	VSTRFIXED|VTEXTFIXED|VUNSET,	"MAIL=",
    149  1.57       kre 	   { NULL } },
    150  1.14  christos 	{ &vmpath,	VSTRFIXED|VTEXTFIXED|VUNSET,	"MAILPATH=",
    151  1.57       kre 	   { NULL } },
    152  1.49  christos 	{ &vvers,	VSTRFIXED|VTEXTFIXED|VNOEXPORT, "NETBSD_SHELL=",
    153  1.57       kre 	   { NULL } },
    154  1.26       cgd 	{ &vpath,	VSTRFIXED|VTEXTFIXED,		"PATH=" _PATH_DEFPATH,
    155  1.57       kre 	   { .set_func= changepath } },
    156  1.15  christos 	/*
    157   1.1       cgd 	 * vps1 depends on uid
    158   1.1       cgd 	 */
    159  1.14  christos 	{ &vps2,	VSTRFIXED|VTEXTFIXED,		"PS2=> ",
    160  1.57       kre 	   { NULL } },
    161  1.32       dsl 	{ &vps4,	VSTRFIXED|VTEXTFIXED,		"PS4=+ ",
    162  1.57       kre 	   { NULL } },
    163  1.18  christos #ifndef SMALL
    164  1.14  christos 	{ &vterm,	VSTRFIXED|VTEXTFIXED|VUNSET,	"TERM=",
    165  1.57       kre 	   { .set_func= setterm } },
    166  1.61       kre 	{ &editrc, 	VSTRFIXED|VTEXTFIXED|VUNSET,	"EDITRC=",
    167  1.61       kre 	   { .set_func= set_editrc } },
    168  1.62       kre 	{ &ps_lit, 	VSTRFIXED|VTEXTFIXED|VUNSET,	"PSlit=",
    169  1.62       kre 	   { .set_func= set_prompt_lit } },
    170   1.1       cgd #endif
    171  1.32       dsl 	{ &voptind,	VSTRFIXED|VTEXTFIXED|VNOFUNC,	"OPTIND=1",
    172  1.57       kre 	   { .set_func= getoptsreset } },
    173  1.72       kre 	{ &line_num,	VSTRFIXED|VTEXTFIXED|VFUNCREF|VSPECIAL,	"LINENO=1",
    174  1.57       kre 	   { .ref_func= get_lineno } },
    175  1.63       kre #ifndef SMALL
    176  1.63       kre 	{ &tod,		VSTRFIXED|VTEXTFIXED|VFUNCREF,	"ToD=",
    177  1.63       kre 	   { .ref_func= get_tod } },
    178  1.63       kre 	{ &host_name,	VSTRFIXED|VTEXTFIXED|VFUNCREF,	"HOSTNAME=",
    179  1.63       kre 	   { .ref_func= get_hostname } },
    180  1.63       kre 	{ &seconds,	VSTRFIXED|VTEXTFIXED|VFUNCREF,	"SECONDS=",
    181  1.63       kre 	   { .ref_func= get_seconds } },
    182  1.63       kre 	{ &euname,	VSTRFIXED|VTEXTFIXED|VFUNCREF,	"EUSER=",
    183  1.63       kre 	   { .ref_func= get_euser } },
    184  1.72       kre 	{ &random_num,	VSTRFIXED|VTEXTFIXED|VFUNCREF|VSPECIAL,	"RANDOM=",
    185  1.63       kre 	   { .ref_func= get_random } },
    186  1.63       kre #endif
    187  1.14  christos 	{ NULL,	0,				NULL,
    188  1.57       kre 	   { NULL } }
    189   1.1       cgd };
    190   1.1       cgd 
    191   1.1       cgd struct var *vartab[VTABSIZE];
    192   1.1       cgd 
    193  1.35       dsl STATIC int strequal(const char *, const char *);
    194  1.35       dsl STATIC struct var *find_var(const char *, struct var ***, int *);
    195  1.74       kre STATIC void showvar(struct var *, const char *, const char *, int);
    196  1.74       kre static void export_usage(const char *) __dead;
    197  1.78       kre STATIC int makespecial(const char *);
    198   1.1       cgd 
    199   1.1       cgd /*
    200   1.1       cgd  * Initialize the varable symbol tables and import the environment
    201   1.1       cgd  */
    202   1.1       cgd 
    203   1.1       cgd #ifdef mkinit
    204  1.47  christos INCLUDE <stdio.h>
    205  1.47  christos INCLUDE <unistd.h>
    206  1.63       kre INCLUDE <time.h>
    207   1.1       cgd INCLUDE "var.h"
    208  1.49  christos INCLUDE "version.h"
    209  1.27  christos MKINIT char **environ;
    210   1.1       cgd INIT {
    211   1.1       cgd 	char **envp;
    212  1.47  christos 	char buf[64];
    213   1.1       cgd 
    214  1.63       kre #ifndef SMALL
    215  1.63       kre 	sh_start_time = (intmax_t)time((time_t *)0);
    216  1.63       kre #endif
    217  1.63       kre 	/*
    218  1.63       kre 	 * Set up our default variables and their values.
    219  1.63       kre 	 */
    220   1.1       cgd 	initvar();
    221  1.63       kre 
    222  1.63       kre 	/*
    223  1.63       kre 	 * Import variables from the environment, which will
    224  1.63       kre 	 * override anything initialised just previously.
    225  1.63       kre 	 */
    226   1.1       cgd 	for (envp = environ ; *envp ; envp++) {
    227   1.1       cgd 		if (strchr(*envp, '=')) {
    228   1.1       cgd 			setvareq(*envp, VEXPORT|VTEXTFIXED);
    229   1.1       cgd 		}
    230   1.1       cgd 	}
    231  1.47  christos 
    232  1.47  christos 	/*
    233  1.53       kre 	 * Set variables which override anything read from environment.
    234  1.53       kre 	 *
    235  1.47  christos 	 * PPID is readonly
    236  1.53       kre 	 * Always default IFS
    237  1.70       kre 	 * POSIX: "Whenever the shell is invoked, OPTIND shall
    238  1.70       kre 	 *         be initialized to 1."
    239  1.63       kre 	 * PSc indicates the root/non-root status of this shell.
    240  1.70       kre 	 * START_TIME belongs only to this shell.
    241  1.53       kre 	 * NETBSD_SHELL is a constant (readonly), and is never exported
    242  1.57       kre 	 * LINENO is simply magic...
    243  1.47  christos 	 */
    244  1.47  christos 	snprintf(buf, sizeof(buf), "%d", (int)getppid());
    245  1.47  christos 	setvar("PPID", buf, VREADONLY);
    246  1.48  christos 	setvar("IFS", ifs_default, VTEXTFIXED);
    247  1.70       kre 	setvar("OPTIND", "1", VTEXTFIXED);
    248  1.63       kre 	setvar("PSc", (geteuid() == 0 ? "#" : "$"), VTEXTFIXED);
    249  1.63       kre 
    250  1.63       kre #ifndef SMALL
    251  1.63       kre 	snprintf(buf, sizeof(buf), "%jd", sh_start_time);
    252  1.63       kre 	setvar("START_TIME", buf, VTEXTFIXED);
    253  1.63       kre #endif
    254  1.53       kre 
    255  1.53       kre 	setvar("NETBSD_SHELL", NETBSD_SHELL
    256  1.53       kre #ifdef BUILD_DATE
    257  1.53       kre 		" BUILD:" BUILD_DATE
    258  1.53       kre #endif
    259  1.53       kre #ifdef DEBUG
    260  1.53       kre 		" DEBUG"
    261  1.53       kre #endif
    262  1.53       kre #if !defined(JOBS) || JOBS == 0
    263  1.53       kre 		" -JOBS"
    264  1.53       kre #endif
    265  1.53       kre #ifndef DO_SHAREDVFORK
    266  1.53       kre 		" -VFORK"
    267  1.53       kre #endif
    268  1.53       kre #ifdef SMALL
    269  1.53       kre 		" SMALL"
    270  1.53       kre #endif
    271  1.53       kre #ifdef TINY
    272  1.53       kre 		" TINY"
    273  1.53       kre #endif
    274  1.53       kre #ifdef OLD_TTY_DRIVER
    275  1.53       kre 		" OLD_TTY"
    276  1.53       kre #endif
    277  1.53       kre #ifdef SYSV
    278  1.53       kre 		" SYSV"
    279  1.53       kre #endif
    280  1.53       kre #ifndef BSD
    281  1.53       kre 		" -BSD"
    282  1.53       kre #endif
    283  1.55       kre #ifdef BOGUS_NOT_COMMAND
    284  1.55       kre 		" BOGUS_NOT"
    285  1.55       kre #endif
    286  1.53       kre 		    , VTEXTFIXED|VREADONLY|VNOEXPORT);
    287  1.56       kre 
    288  1.56       kre 	setvar("LINENO", "1", VTEXTFIXED);
    289   1.1       cgd }
    290   1.1       cgd #endif
    291   1.1       cgd 
    292   1.1       cgd 
    293   1.1       cgd /*
    294   1.1       cgd  * This routine initializes the builtin variables.  It is called when the
    295   1.1       cgd  * shell is initialized and again when a shell procedure is spawned.
    296   1.1       cgd  */
    297   1.1       cgd 
    298   1.1       cgd void
    299  1.30  christos initvar(void)
    300  1.30  christos {
    301   1.1       cgd 	const struct varinit *ip;
    302   1.1       cgd 	struct var *vp;
    303   1.1       cgd 	struct var **vpp;
    304   1.1       cgd 
    305   1.1       cgd 	for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
    306  1.35       dsl 		if (find_var(ip->text, &vpp, &vp->name_len) != NULL)
    307  1.35       dsl 			continue;
    308  1.35       dsl 		vp->next = *vpp;
    309  1.35       dsl 		*vpp = vp;
    310  1.35       dsl 		vp->text = strdup(ip->text);
    311  1.63       kre 		vp->flags = (ip->flags & ~VTEXTFIXED) | VSTRFIXED;
    312  1.57       kre 		vp->v_u = ip->v_u;
    313   1.1       cgd 	}
    314   1.1       cgd 	/*
    315   1.1       cgd 	 * PS1 depends on uid
    316   1.1       cgd 	 */
    317  1.35       dsl 	if (find_var("PS1", &vpp, &vps1.name_len) == NULL) {
    318   1.1       cgd 		vps1.next = *vpp;
    319   1.1       cgd 		*vpp = &vps1;
    320  1.63       kre 		vps1.flags = VSTRFIXED;
    321  1.44  christos 		vps1.text = NULL;
    322  1.44  christos 		choose_ps1();
    323   1.1       cgd 	}
    324   1.1       cgd }
    325   1.1       cgd 
    326  1.44  christos void
    327  1.44  christos choose_ps1(void)
    328  1.44  christos {
    329  1.71       kre 	uid_t u = geteuid();
    330  1.71       kre 
    331  1.63       kre 	if ((vps1.flags & (VTEXTFIXED|VSTACK)) == 0)
    332  1.63       kre 		free(vps1.text);
    333  1.71       kre 	vps1.text = strdup(u != 0 ? "PS1=$ " : "PS1=# ");
    334  1.63       kre 	vps1.flags &= ~(VTEXTFIXED|VSTACK);
    335  1.63       kre 
    336  1.63       kre 	/*
    337  1.63       kre 	 * Update PSc whenever we feel the need to update PS1
    338  1.63       kre 	 */
    339  1.71       kre 	setvarsafe("PSc", (u == 0 ? "#" : "$"), 0);
    340  1.44  christos }
    341  1.44  christos 
    342   1.1       cgd /*
    343  1.68       kre  * Validate a string as a valid variable name
    344  1.68       kre  * nb: not parameter - special params and such are "invalid" here.
    345  1.68       kre  * Name terminated by either \0 or the term param (usually '=' or '\0').
    346  1.68       kre  *
    347  1.68       kre  * If not NULL, the length of the (intended) name is returned via len
    348  1.68       kre  */
    349  1.68       kre 
    350  1.68       kre int
    351  1.68       kre validname(const char *name, int term, int *len)
    352  1.68       kre {
    353  1.68       kre 	const char *p = name;
    354  1.68       kre 	int ok = 1;
    355  1.68       kre 
    356  1.68       kre 	if (p == NULL || *p == '\0' || *p == term) {
    357  1.68       kre 		if (len != NULL)
    358  1.68       kre 			*len = 0;
    359  1.68       kre 		return 0;
    360  1.68       kre 	}
    361  1.68       kre 
    362  1.68       kre 	if (!is_name(*p))
    363  1.68       kre 		ok = 0;
    364  1.68       kre 	p++;
    365  1.68       kre 	for (;;) {
    366  1.68       kre 		if (*p == '\0' || *p == term)
    367  1.68       kre 			break;
    368  1.68       kre 		if (!is_in_name(*p))
    369  1.68       kre 			ok = 0;
    370  1.68       kre 		p++;
    371  1.68       kre 	}
    372  1.68       kre 	if (len != NULL)
    373  1.68       kre 		*len = p - name;
    374  1.68       kre 
    375  1.68       kre 	return ok;
    376  1.68       kre }
    377  1.68       kre 
    378  1.68       kre /*
    379  1.14  christos  * Safe version of setvar, returns 1 on success 0 on failure.
    380  1.14  christos  */
    381  1.14  christos 
    382  1.14  christos int
    383  1.30  christos setvarsafe(const char *name, const char *val, int flags)
    384  1.14  christos {
    385  1.14  christos 	struct jmploc jmploc;
    386  1.59       kre 	struct jmploc * const savehandler = handler;
    387  1.38  christos 	int volatile err = 0;
    388  1.14  christos 
    389  1.14  christos 	if (setjmp(jmploc.loc))
    390  1.14  christos 		err = 1;
    391  1.14  christos 	else {
    392  1.14  christos 		handler = &jmploc;
    393  1.14  christos 		setvar(name, val, flags);
    394  1.14  christos 	}
    395  1.14  christos 	handler = savehandler;
    396  1.14  christos 	return err;
    397  1.14  christos }
    398  1.14  christos 
    399  1.14  christos /*
    400   1.1       cgd  * Set the value of a variable.  The flags argument is ored with the
    401   1.1       cgd  * flags of the variable.  If val is NULL, the variable is unset.
    402  1.63       kre  *
    403  1.63       kre  * This always copies name and val when setting a variable, so
    404  1.63       kre  * the source strings can be from anywhere, and are no longer needed
    405  1.63       kre  * after this function returns.  The VTEXTFIXED and VSTACK flags should
    406  1.63       kre  * not be used (but just in case they were, clear them.)
    407   1.1       cgd  */
    408   1.1       cgd 
    409   1.1       cgd void
    410  1.30  christos setvar(const char *name, const char *val, int flags)
    411  1.10       cgd {
    412  1.23  christos 	const char *p;
    413  1.23  christos 	const char *q;
    414  1.23  christos 	char *d;
    415   1.1       cgd 	int len;
    416   1.1       cgd 	int namelen;
    417   1.1       cgd 	char *nameeq;
    418   1.1       cgd 
    419   1.1       cgd 	p = name;
    420  1.68       kre 
    421  1.68       kre 	if (!validname(p, '=', &namelen))
    422   1.5       jtc 		error("%.*s: bad variable name", namelen, name);
    423   1.1       cgd 	len = namelen + 2;		/* 2 is space for '=' and '\0' */
    424   1.1       cgd 	if (val == NULL) {
    425   1.1       cgd 		flags |= VUNSET;
    426   1.1       cgd 	} else {
    427   1.1       cgd 		len += strlen(val);
    428   1.1       cgd 	}
    429  1.23  christos 	d = nameeq = ckmalloc(len);
    430   1.1       cgd 	q = name;
    431   1.1       cgd 	while (--namelen >= 0)
    432  1.23  christos 		*d++ = *q++;
    433  1.23  christos 	*d++ = '=';
    434  1.23  christos 	*d = '\0';
    435   1.1       cgd 	if (val)
    436  1.23  christos 		scopy(val, d);
    437  1.63       kre 	setvareq(nameeq, flags & ~(VTEXTFIXED | VSTACK));
    438   1.1       cgd }
    439   1.1       cgd 
    440   1.1       cgd 
    441   1.1       cgd 
    442   1.1       cgd /*
    443   1.1       cgd  * Same as setvar except that the variable and value are passed in
    444   1.1       cgd  * the first argument as name=value.  Since the first argument will
    445   1.1       cgd  * be actually stored in the table, it should not be a string that
    446  1.63       kre  * will go away.   The flags (VTEXTFIXED or VSTACK) can be used to
    447  1.63       kre  * indicate the source of the string (if neither is set, the string will
    448  1.63       kre  * eventually be free()d when a replacement value is assigned.)
    449   1.1       cgd  */
    450   1.1       cgd 
    451   1.1       cgd void
    452  1.30  christos setvareq(char *s, int flags)
    453  1.10       cgd {
    454   1.1       cgd 	struct var *vp, **vpp;
    455  1.35       dsl 	int nlen;
    456   1.1       cgd 
    457  1.66       kre 	VTRACE(DBG_VARS, ("setvareq([%s],%#x) aflag=%d ", s, flags, aflag));
    458  1.49  christos 	if (aflag && !(flags & VNOEXPORT))
    459  1.28     bjh21 		flags |= VEXPORT;
    460  1.35       dsl 	vp = find_var(s, &vpp, &nlen);
    461  1.35       dsl 	if (vp != NULL) {
    462  1.66       kre 		VTRACE(DBG_VARS, ("was [%s] fl:%#x\n", vp->text,
    463  1.66       kre 		    vp->flags));
    464  1.60       kre 		if (vp->flags & VREADONLY) {
    465  1.60       kre 			if ((flags & (VTEXTFIXED|VSTACK)) == 0)
    466  1.60       kre 				ckfree(s);
    467  1.60       kre 			if (flags & VNOERROR)
    468  1.60       kre 				return;
    469  1.65       kre 			error("%.*s: is read only", vp->name_len, vp->text);
    470  1.60       kre 		}
    471  1.60       kre 		if (flags & VNOSET) {
    472  1.60       kre 			if ((flags & (VTEXTFIXED|VSTACK)) == 0)
    473  1.60       kre 				ckfree(s);
    474  1.35       dsl 			return;
    475  1.60       kre 		}
    476  1.57       kre 
    477  1.35       dsl 		INTOFF;
    478  1.14  christos 
    479  1.57       kre 		if (vp->func && !(vp->flags & VFUNCREF) && !(flags & VNOFUNC))
    480  1.35       dsl 			(*vp->func)(s + vp->name_len + 1);
    481  1.14  christos 
    482  1.35       dsl 		if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
    483  1.35       dsl 			ckfree(vp->text);
    484  1.14  christos 
    485  1.72       kre 		/*
    486  1.72       kre 		 * if we set a magic var, the magic dissipates,
    487  1.72       kre 		 * unless it is very special indeed.
    488  1.72       kre 		 */
    489  1.72       kre 		if (vp->rfunc && (vp->flags & (VFUNCREF|VSPECIAL)) == VFUNCREF)
    490  1.72       kre 			vp->rfunc = NULL;
    491  1.72       kre 
    492  1.35       dsl 		vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
    493  1.49  christos 		if (flags & VNOEXPORT)
    494  1.49  christos 			vp->flags &= ~VEXPORT;
    495  1.71       kre 		if (flags & VDOEXPORT)
    496  1.71       kre 			vp->flags &= ~VNOEXPORT;
    497  1.54       kre 		if (vp->flags & VNOEXPORT)
    498  1.54       kre 			flags &= ~VEXPORT;
    499  1.71       kre 		vp->flags |= flags & ~(VNOFUNC | VDOEXPORT);
    500  1.35       dsl 		vp->text = s;
    501  1.35       dsl 
    502  1.35       dsl 		/*
    503  1.35       dsl 		 * We could roll this to a function, to handle it as
    504  1.35       dsl 		 * a regular variable function callback, but why bother?
    505  1.35       dsl 		 */
    506  1.35       dsl 		if (vp == &vmpath || (vp == &vmail && ! mpathset()))
    507  1.35       dsl 			chkmail(1);
    508  1.57       kre 
    509  1.35       dsl 		INTON;
    510  1.35       dsl 		return;
    511   1.1       cgd 	}
    512   1.1       cgd 	/* not found */
    513  1.60       kre 	if (flags & VNOSET) {
    514  1.71       kre 		VTRACE(DBG_VARS, ("new noset\n"));
    515  1.60       kre 		if ((flags & (VTEXTFIXED|VSTACK)) == 0)
    516  1.60       kre 			ckfree(s);
    517  1.30  christos 		return;
    518  1.60       kre 	}
    519   1.1       cgd 	vp = ckmalloc(sizeof (*vp));
    520  1.71       kre 	vp->flags = flags & ~(VNOFUNC|VFUNCREF|VDOEXPORT);
    521   1.1       cgd 	vp->text = s;
    522  1.35       dsl 	vp->name_len = nlen;
    523  1.71       kre 	vp->func = NULL;
    524   1.1       cgd 	vp->next = *vpp;
    525   1.1       cgd 	*vpp = vp;
    526  1.71       kre 
    527  1.71       kre 	VTRACE(DBG_VARS, ("new [%s] (%d) %#x\n", s, nlen, vp->flags));
    528   1.1       cgd }
    529   1.1       cgd 
    530   1.1       cgd 
    531   1.1       cgd 
    532   1.1       cgd /*
    533   1.1       cgd  * Process a linked list of variable assignments.
    534   1.1       cgd  */
    535   1.1       cgd 
    536   1.1       cgd void
    537  1.30  christos listsetvar(struct strlist *list, int flags)
    538  1.30  christos {
    539   1.1       cgd 	struct strlist *lp;
    540   1.1       cgd 
    541   1.1       cgd 	INTOFF;
    542   1.1       cgd 	for (lp = list ; lp ; lp = lp->next) {
    543  1.30  christos 		setvareq(savestr(lp->text), flags);
    544   1.1       cgd 	}
    545   1.1       cgd 	INTON;
    546   1.1       cgd }
    547   1.1       cgd 
    548  1.32       dsl void
    549  1.32       dsl listmklocal(struct strlist *list, int flags)
    550  1.32       dsl {
    551  1.32       dsl 	struct strlist *lp;
    552  1.32       dsl 
    553  1.32       dsl 	for (lp = list ; lp ; lp = lp->next)
    554  1.32       dsl 		mklocal(lp->text, flags);
    555  1.32       dsl }
    556   1.1       cgd 
    557   1.1       cgd 
    558   1.1       cgd /*
    559   1.1       cgd  * Find the value of a variable.  Returns NULL if not set.
    560   1.1       cgd  */
    561   1.1       cgd 
    562   1.1       cgd char *
    563  1.30  christos lookupvar(const char *name)
    564  1.30  christos {
    565   1.1       cgd 	struct var *v;
    566  1.77       kre 	char *p;
    567   1.1       cgd 
    568  1.35       dsl 	v = find_var(name, NULL, NULL);
    569  1.35       dsl 	if (v == NULL || v->flags & VUNSET)
    570  1.35       dsl 		return NULL;
    571  1.77       kre 	if (v->rfunc && (v->flags & VFUNCREF) != 0) {
    572  1.77       kre 		p = (*v->rfunc)(v);
    573  1.77       kre 		if (p == NULL)
    574  1.77       kre 			return NULL;
    575  1.77       kre 	} else
    576  1.77       kre 		p = v->text;
    577  1.77       kre 
    578  1.77       kre 	return p + v->name_len + 1;
    579   1.1       cgd }
    580   1.1       cgd 
    581   1.1       cgd 
    582   1.1       cgd 
    583   1.1       cgd /*
    584   1.1       cgd  * Search the environment of a builtin command.  If the second argument
    585   1.1       cgd  * is nonzero, return the value of a variable even if it hasn't been
    586   1.1       cgd  * exported.
    587   1.1       cgd  */
    588   1.1       cgd 
    589   1.1       cgd char *
    590  1.30  christos bltinlookup(const char *name, int doall)
    591  1.10       cgd {
    592   1.1       cgd 	struct strlist *sp;
    593   1.1       cgd 	struct var *v;
    594  1.77       kre 	char *p;
    595   1.1       cgd 
    596   1.1       cgd 	for (sp = cmdenviron ; sp ; sp = sp->next) {
    597  1.35       dsl 		if (strequal(sp->text, name))
    598   1.1       cgd 			return strchr(sp->text, '=') + 1;
    599   1.1       cgd 	}
    600  1.35       dsl 
    601  1.35       dsl 	v = find_var(name, NULL, NULL);
    602  1.35       dsl 
    603  1.35       dsl 	if (v == NULL || v->flags & VUNSET || (!doall && !(v->flags & VEXPORT)))
    604  1.35       dsl 		return NULL;
    605  1.77       kre 
    606  1.77       kre 	if (v->rfunc && (v->flags & VFUNCREF) != 0) {
    607  1.77       kre 		p = (*v->rfunc)(v);
    608  1.77       kre 		if (p == NULL)
    609  1.77       kre 			return NULL;
    610  1.77       kre 	} else
    611  1.77       kre 		p = v->text;
    612  1.77       kre 
    613  1.77       kre 	return p + v->name_len + 1;
    614   1.1       cgd }
    615   1.1       cgd 
    616   1.1       cgd 
    617   1.1       cgd 
    618   1.1       cgd /*
    619   1.1       cgd  * Generate a list of exported variables.  This routine is used to construct
    620   1.1       cgd  * the third argument to execve when executing a program.
    621   1.1       cgd  */
    622   1.1       cgd 
    623   1.1       cgd char **
    624  1.30  christos environment(void)
    625  1.30  christos {
    626   1.1       cgd 	int nenv;
    627   1.1       cgd 	struct var **vpp;
    628   1.1       cgd 	struct var *vp;
    629  1.23  christos 	char **env;
    630  1.23  christos 	char **ep;
    631   1.1       cgd 
    632   1.1       cgd 	nenv = 0;
    633   1.1       cgd 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
    634   1.1       cgd 		for (vp = *vpp ; vp ; vp = vp->next)
    635  1.51       kre 			if ((vp->flags & (VEXPORT|VUNSET)) == VEXPORT)
    636   1.1       cgd 				nenv++;
    637   1.1       cgd 	}
    638  1.58       kre 	CTRACE(DBG_VARS, ("environment: %d vars to export\n", nenv));
    639   1.1       cgd 	ep = env = stalloc((nenv + 1) * sizeof *env);
    640   1.1       cgd 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
    641   1.1       cgd 		for (vp = *vpp ; vp ; vp = vp->next)
    642  1.57       kre 			if ((vp->flags & (VEXPORT|VUNSET)) == VEXPORT) {
    643  1.77       kre 				if (vp->rfunc && (vp->flags & VFUNCREF)) {
    644  1.77       kre 					*ep = (*vp->rfunc)(vp);
    645  1.77       kre 					if (*ep != NULL)
    646  1.77       kre 						ep++;
    647  1.77       kre 				} else
    648  1.57       kre 					*ep++ = vp->text;
    649  1.58       kre 				VTRACE(DBG_VARS, ("environment: %s\n", ep[-1]));
    650  1.57       kre 			}
    651   1.1       cgd 	}
    652   1.1       cgd 	*ep = NULL;
    653   1.1       cgd 	return env;
    654   1.1       cgd }
    655   1.1       cgd 
    656   1.1       cgd 
    657   1.1       cgd /*
    658   1.1       cgd  * Called when a shell procedure is invoked to clear out nonexported
    659   1.1       cgd  * variables.  It is also necessary to reallocate variables of with
    660   1.1       cgd  * VSTACK set since these are currently allocated on the stack.
    661   1.1       cgd  */
    662   1.1       cgd 
    663   1.1       cgd #ifdef mkinit
    664  1.30  christos void shprocvar(void);
    665   1.1       cgd 
    666   1.1       cgd SHELLPROC {
    667   1.1       cgd 	shprocvar();
    668   1.1       cgd }
    669   1.1       cgd #endif
    670   1.1       cgd 
    671   1.1       cgd void
    672  1.30  christos shprocvar(void)
    673  1.30  christos {
    674   1.1       cgd 	struct var **vpp;
    675   1.1       cgd 	struct var *vp, **prev;
    676   1.1       cgd 
    677   1.1       cgd 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
    678   1.1       cgd 		for (prev = vpp ; (vp = *prev) != NULL ; ) {
    679   1.1       cgd 			if ((vp->flags & VEXPORT) == 0) {
    680   1.1       cgd 				*prev = vp->next;
    681   1.1       cgd 				if ((vp->flags & VTEXTFIXED) == 0)
    682   1.1       cgd 					ckfree(vp->text);
    683   1.1       cgd 				if ((vp->flags & VSTRFIXED) == 0)
    684   1.1       cgd 					ckfree(vp);
    685   1.1       cgd 			} else {
    686   1.1       cgd 				if (vp->flags & VSTACK) {
    687   1.1       cgd 					vp->text = savestr(vp->text);
    688   1.1       cgd 					vp->flags &=~ VSTACK;
    689   1.1       cgd 				}
    690   1.1       cgd 				prev = &vp->next;
    691   1.1       cgd 			}
    692   1.1       cgd 		}
    693   1.1       cgd 	}
    694   1.1       cgd 	initvar();
    695   1.1       cgd }
    696   1.1       cgd 
    697   1.1       cgd 
    698   1.1       cgd 
    699   1.1       cgd /*
    700   1.1       cgd  * Command to list all variables which are set.  Currently this command
    701   1.1       cgd  * is invoked from the set command when the set command is called without
    702   1.1       cgd  * any variables.
    703   1.1       cgd  */
    704   1.1       cgd 
    705  1.30  christos void
    706  1.30  christos print_quoted(const char *p)
    707  1.30  christos {
    708  1.30  christos 	const char *q;
    709  1.30  christos 
    710  1.50       kre 	if (p[0] == '\0') {
    711  1.50       kre 		out1fmt("''");
    712  1.50       kre 		return;
    713  1.50       kre 	}
    714  1.30  christos 	if (strcspn(p, "|&;<>()$`\\\"' \t\n*?[]#~=%") == strlen(p)) {
    715  1.30  christos 		out1fmt("%s", p);
    716  1.30  christos 		return;
    717  1.30  christos 	}
    718  1.30  christos 	while (*p) {
    719  1.30  christos 		if (*p == '\'') {
    720  1.30  christos 			out1fmt("\\'");
    721  1.30  christos 			p++;
    722  1.30  christos 			continue;
    723  1.30  christos 		}
    724  1.42  christos 		q = strchr(p, '\'');
    725  1.30  christos 		if (!q) {
    726  1.30  christos 			out1fmt("'%s'", p );
    727  1.30  christos 			return;
    728  1.30  christos 		}
    729  1.31       agc 		out1fmt("'%.*s'", (int)(q - p), p );
    730  1.30  christos 		p = q;
    731  1.30  christos 	}
    732  1.30  christos }
    733  1.30  christos 
    734  1.30  christos static int
    735  1.30  christos sort_var(const void *v_v1, const void *v_v2)
    736  1.30  christos {
    737  1.30  christos 	const struct var * const *v1 = v_v1;
    738  1.30  christos 	const struct var * const *v2 = v_v2;
    739  1.52       kre 	char *t1 = (*v1)->text, *t2 = (*v2)->text;
    740  1.30  christos 
    741  1.52       kre 	if (*t1 == *t2) {
    742  1.52       kre 		char *p, *s;
    743  1.52       kre 
    744  1.52       kre 		STARTSTACKSTR(p);
    745  1.52       kre 
    746  1.52       kre 		/*
    747  1.52       kre 		 * note: if lengths are equal, strings must be different
    748  1.52       kre 		 * so we don't care which string we pick for the \0 in
    749  1.52       kre 		 * that case.
    750  1.52       kre 		 */
    751  1.52       kre 		if ((strchr(t1, '=') - t1) <= (strchr(t2, '=') - t2)) {
    752  1.52       kre 			s = t1;
    753  1.52       kre 			t1 = p;
    754  1.52       kre 		} else {
    755  1.52       kre 			s = t2;
    756  1.52       kre 			t2 = p;
    757  1.52       kre 		}
    758  1.52       kre 
    759  1.52       kre 		while (*s && *s != '=') {
    760  1.52       kre 			STPUTC(*s, p);
    761  1.52       kre 			s++;
    762  1.52       kre 		}
    763  1.52       kre 		STPUTC('\0', p);
    764  1.52       kre 	}
    765  1.52       kre 
    766  1.52       kre 	return strcoll(t1, t2);
    767  1.30  christos }
    768  1.30  christos 
    769  1.30  christos /*
    770  1.30  christos  * POSIX requires that 'set' (but not export or readonly) output the
    771  1.30  christos  * variables in lexicographic order - by the locale's collating order (sigh).
    772  1.30  christos  * Maybe we could keep them in an ordered balanced binary tree
    773  1.30  christos  * instead of hashed lists.
    774  1.30  christos  * For now just roll 'em through qsort for printing...
    775  1.30  christos  */
    776  1.30  christos 
    777  1.74       kre STATIC void
    778  1.74       kre showvar(struct var *vp, const char *cmd, const char *xtra, int show_value)
    779  1.74       kre {
    780  1.74       kre 	const char *p;
    781  1.74       kre 
    782  1.74       kre 	p = vp->text;
    783  1.74       kre 	if (vp->rfunc && (vp->flags & VFUNCREF) != 0) {
    784  1.74       kre 		p = (*vp->rfunc)(vp);
    785  1.77       kre 		if (p == NULL) {
    786  1.77       kre 			if (!(show_value & 2))
    787  1.77       kre 				return;
    788  1.74       kre 			p = vp->text;
    789  1.77       kre 			show_value = 0;
    790  1.77       kre 		}
    791  1.74       kre 	}
    792  1.77       kre 	if (cmd)
    793  1.77       kre 		out1fmt("%s ", cmd);
    794  1.77       kre 	if (xtra)
    795  1.77       kre 		out1fmt("%s ", xtra);
    796  1.74       kre 	for ( ; *p != '=' ; p++)
    797  1.74       kre 		out1c(*p);
    798  1.74       kre 	if (!(vp->flags & VUNSET) && show_value) {
    799  1.74       kre 		out1fmt("=");
    800  1.74       kre 		print_quoted(++p);
    801  1.74       kre 	}
    802  1.74       kre 	out1c('\n');
    803  1.74       kre }
    804  1.74       kre 
    805   1.1       cgd int
    806  1.74       kre showvars(const char *cmd, int flag, int show_value, const char *xtra)
    807  1.10       cgd {
    808   1.1       cgd 	struct var **vpp;
    809   1.1       cgd 	struct var *vp;
    810  1.30  christos 
    811  1.30  christos 	static struct var **list;	/* static in case we are interrupted */
    812  1.30  christos 	static int list_len;
    813  1.30  christos 	int count = 0;
    814  1.30  christos 
    815  1.30  christos 	if (!list) {
    816  1.30  christos 		list_len = 32;
    817  1.30  christos 		list = ckmalloc(list_len * sizeof *list);
    818  1.30  christos 	}
    819   1.1       cgd 
    820   1.1       cgd 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
    821   1.1       cgd 		for (vp = *vpp ; vp ; vp = vp->next) {
    822  1.30  christos 			if (flag && !(vp->flags & flag))
    823  1.30  christos 				continue;
    824  1.30  christos 			if (vp->flags & VUNSET && !(show_value & 2))
    825  1.30  christos 				continue;
    826  1.30  christos 			if (count >= list_len) {
    827  1.30  christos 				list = ckrealloc(list,
    828  1.30  christos 					(list_len << 1) * sizeof *list);
    829  1.30  christos 				list_len <<= 1;
    830  1.30  christos 			}
    831  1.30  christos 			list[count++] = vp;
    832   1.1       cgd 		}
    833   1.1       cgd 	}
    834  1.30  christos 
    835  1.30  christos 	qsort(list, count, sizeof *list, sort_var);
    836  1.30  christos 
    837  1.74       kre 	for (vpp = list; count--; vpp++)
    838  1.74       kre 		showvar(*vpp, cmd, xtra, show_value);
    839  1.74       kre 
    840  1.74       kre 	/* no free(list), will be used again next time ... */
    841  1.74       kre 
    842   1.1       cgd 	return 0;
    843   1.1       cgd }
    844   1.1       cgd 
    845   1.1       cgd 
    846   1.1       cgd 
    847   1.1       cgd /*
    848   1.1       cgd  * The export and readonly commands.
    849   1.1       cgd  */
    850   1.1       cgd 
    851  1.74       kre static void __dead
    852  1.74       kre export_usage(const char *cmd)
    853  1.74       kre {
    854  1.74       kre #ifdef SMALL
    855  1.74       kre 	if (*cmd == 'r')
    856  1.74       kre 	    error("Usage: %s [ -p | var[=val]... ]", cmd);
    857  1.74       kre 	else
    858  1.74       kre 	    error("Usage: %s [ -p | [-n] var[=val]... ]", cmd);
    859  1.74       kre #else
    860  1.74       kre 	if (*cmd == 'r')
    861  1.74       kre 	    error("Usage: %s [-p [var...] | -q var... | var[=val]... ]", cmd);
    862  1.74       kre 	else
    863  1.74       kre 	    error(
    864  1.74       kre 	     "Usage: %s [ -px [var...] | -q[x] var... | [-n|x] var[=val]... ]",
    865  1.74       kre 		cmd);
    866  1.74       kre #endif
    867  1.74       kre }
    868  1.74       kre 
    869   1.1       cgd int
    870  1.30  christos exportcmd(int argc, char **argv)
    871  1.10       cgd {
    872   1.1       cgd 	struct var *vp;
    873   1.1       cgd 	char *name;
    874  1.74       kre 	const char *p = argv[0];
    875  1.74       kre 	int flag = p[0] == 'r'? VREADONLY : VEXPORT;
    876  1.49  christos 	int pflg = 0;
    877  1.49  christos 	int nflg = 0;
    878  1.74       kre #ifndef SMALL
    879  1.49  christos 	int xflg = 0;
    880  1.74       kre 	int qflg = 0;
    881  1.74       kre #endif
    882  1.49  christos 	int res;
    883  1.49  christos 	int c;
    884  1.51       kre 	int f;
    885  1.49  christos 
    886  1.74       kre #ifdef SMALL
    887  1.74       kre #define EXPORT_OPTS "np"
    888  1.74       kre #else
    889  1.74       kre #define	EXPORT_OPTS "npqx"
    890  1.74       kre #endif
    891  1.74       kre 
    892  1.74       kre 	while ((c = nextopt(EXPORT_OPTS)) != '\0') {
    893  1.74       kre 
    894  1.74       kre #undef EXPORT_OPTS
    895  1.74       kre 
    896  1.49  christos 		switch (c) {
    897  1.74       kre 		case 'n':
    898  1.74       kre 			if (pflg || flag == VREADONLY
    899  1.74       kre #ifndef SMALL
    900  1.74       kre 				|| qflg || xflg
    901  1.74       kre #endif
    902  1.74       kre 						)
    903  1.74       kre 				export_usage(p);
    904  1.74       kre 			nflg = 1;
    905  1.74       kre 			break;
    906  1.49  christos 		case 'p':
    907  1.74       kre 			if (nflg
    908  1.74       kre #ifndef SMALL
    909  1.74       kre 				|| qflg
    910  1.74       kre #endif
    911  1.74       kre 					)
    912  1.74       kre 				export_usage(p);
    913  1.49  christos 			pflg = 3;
    914  1.49  christos 			break;
    915  1.74       kre #ifndef SMALL
    916  1.74       kre 		case 'q':
    917  1.74       kre 			if (nflg || pflg)
    918  1.74       kre 				export_usage(p);
    919  1.74       kre 			qflg = 1;
    920  1.49  christos 			break;
    921  1.49  christos 		case 'x':
    922  1.49  christos 			if (nflg || flag == VREADONLY)
    923  1.74       kre 				export_usage(p);
    924  1.49  christos 			flag = VNOEXPORT;
    925  1.49  christos 			xflg = 1;
    926  1.49  christos 			break;
    927  1.74       kre #endif
    928  1.49  christos 		}
    929  1.49  christos 	}
    930   1.1       cgd 
    931  1.74       kre 	if ((nflg
    932  1.74       kre #ifndef SMALL
    933  1.74       kre 		|| qflg
    934  1.74       kre #endif
    935  1.74       kre 		 ) && *argptr == NULL)
    936  1.74       kre 		export_usage(p);
    937  1.74       kre 
    938  1.74       kre #ifndef SMALL
    939  1.74       kre 	if (pflg && *argptr != NULL) {
    940  1.74       kre 		while ((name = *argptr++) != NULL) {
    941  1.74       kre 			int len;
    942  1.74       kre 
    943  1.74       kre 			vp = find_var(name, NULL, &len);
    944  1.74       kre 			if (name[len] == '=')
    945  1.74       kre 				export_usage(p);
    946  1.74       kre 			if (!goodname(name))
    947  1.74       kre 				error("%s: bad variable name", name);
    948  1.49  christos 
    949  1.74       kre 			if (vp && vp->flags & flag)
    950  1.74       kre 				showvar(vp, p, xflg ? "-x" : NULL, 1);
    951  1.74       kre 		}
    952  1.30  christos 		return 0;
    953  1.30  christos 	}
    954  1.74       kre #endif
    955  1.74       kre 
    956  1.74       kre 	if (pflg || *argptr == NULL)
    957  1.74       kre 		return showvars( pflg ? p : 0, flag, pflg,
    958  1.74       kre #ifndef SMALL
    959  1.74       kre 		    pflg && xflg ? "-x" :
    960  1.74       kre #endif
    961  1.74       kre 					    NULL );
    962  1.30  christos 
    963  1.49  christos 	res = 0;
    964  1.74       kre #ifndef SMALL
    965  1.74       kre 	if (qflg) {
    966  1.74       kre 		while ((name = *argptr++) != NULL) {
    967  1.74       kre 			int len;
    968  1.74       kre 
    969  1.74       kre 			vp = find_var(name, NULL, &len);
    970  1.74       kre 			if (name[len] == '=')
    971  1.74       kre 				export_usage(p);
    972  1.74       kre 			if (!goodname(name))
    973  1.74       kre 				error("%s: bad variable name", name);
    974  1.74       kre 
    975  1.74       kre 			if (vp == NULL || !(vp->flags & flag))
    976  1.74       kre 				res = 1;
    977  1.74       kre 		}
    978  1.74       kre 		return res;
    979  1.74       kre 	}
    980  1.74       kre #endif
    981  1.74       kre 
    982  1.30  christos 	while ((name = *argptr++) != NULL) {
    983  1.71       kre 		int len;
    984  1.71       kre 
    985  1.51       kre 		f = flag;
    986  1.71       kre 
    987  1.71       kre 		vp = find_var(name, NULL, &len);
    988  1.71       kre 		p = name + len;
    989  1.71       kre 		if (*p++ != '=')
    990  1.71       kre 			p = NULL;
    991  1.71       kre 
    992  1.71       kre 		if (vp != NULL) {
    993  1.71       kre 			if (nflg)
    994  1.71       kre 				vp->flags &= ~flag;
    995  1.71       kre 			else if (flag&VEXPORT && vp->flags&VNOEXPORT) {
    996  1.73       kre 				/* note we go ahead and do any assignment */
    997  1.71       kre 				sh_warnx("%.*s: not available for export",
    998  1.71       kre 				    len, name);
    999  1.71       kre 				res = 1;
   1000  1.71       kre 			} else {
   1001  1.71       kre 				if (flag == VNOEXPORT)
   1002  1.71       kre 					vp->flags &= ~VEXPORT;
   1003  1.73       kre 
   1004  1.73       kre 				/* if not NULL will be done in setvar below */
   1005  1.73       kre 				if (p == NULL)
   1006  1.73       kre 					vp->flags |= flag;
   1007  1.71       kre 			}
   1008  1.71       kre 			if (p == NULL)
   1009  1.36     enami 				continue;
   1010  1.74       kre 		} else if (nflg && p == NULL && !goodname(name))
   1011  1.74       kre 			error("%s: bad variable name", name);
   1012  1.71       kre 
   1013  1.71       kre 		if (!nflg || p != NULL)
   1014  1.51       kre 			setvar(name, p, f);
   1015   1.1       cgd 	}
   1016  1.49  christos 	return res;
   1017   1.1       cgd }
   1018   1.1       cgd 
   1019   1.1       cgd 
   1020   1.1       cgd /*
   1021   1.1       cgd  * The "local" command.
   1022   1.1       cgd  */
   1023   1.1       cgd 
   1024  1.10       cgd int
   1025  1.30  christos localcmd(int argc, char **argv)
   1026  1.10       cgd {
   1027   1.1       cgd 	char *name;
   1028  1.54       kre 	int c;
   1029  1.54       kre 	int flags = 0;		/*XXX perhaps VUNSET from a -o option value */
   1030   1.1       cgd 
   1031   1.1       cgd 	if (! in_function())
   1032   1.1       cgd 		error("Not in a function");
   1033  1.54       kre 
   1034  1.54       kre 	/* upper case options, as bash stole all the good ones ... */
   1035  1.54       kre 	while ((c = nextopt("INx")) != '\0')
   1036  1.54       kre 		switch (c) {
   1037  1.54       kre 		case 'I':	flags &= ~VUNSET;	break;
   1038  1.54       kre 		case 'N':	flags |= VUNSET;	break;
   1039  1.54       kre 		case 'x':	flags |= VEXPORT;	break;
   1040  1.54       kre 		}
   1041  1.54       kre 
   1042   1.1       cgd 	while ((name = *argptr++) != NULL) {
   1043  1.54       kre 		mklocal(name, flags);
   1044   1.1       cgd 	}
   1045   1.1       cgd 	return 0;
   1046   1.1       cgd }
   1047   1.1       cgd 
   1048   1.1       cgd 
   1049   1.1       cgd /*
   1050  1.37       snj  * Make a variable a local variable.  When a variable is made local, its
   1051   1.1       cgd  * value and flags are saved in a localvar structure.  The saved values
   1052   1.1       cgd  * will be restored when the shell function returns.  We handle the name
   1053   1.1       cgd  * "-" as a special case.
   1054   1.1       cgd  */
   1055   1.1       cgd 
   1056   1.1       cgd void
   1057  1.32       dsl mklocal(const char *name, int flags)
   1058  1.30  christos {
   1059   1.1       cgd 	struct localvar *lvp;
   1060   1.1       cgd 	struct var **vpp;
   1061   1.1       cgd 	struct var *vp;
   1062   1.1       cgd 
   1063   1.1       cgd 	INTOFF;
   1064   1.1       cgd 	lvp = ckmalloc(sizeof (struct localvar));
   1065   1.1       cgd 	if (name[0] == '-' && name[1] == '\0') {
   1066  1.23  christos 		char *p;
   1067  1.30  christos 		p = ckmalloc(sizeof_optlist);
   1068  1.30  christos 		lvp->text = memcpy(p, optlist, sizeof_optlist);
   1069  1.72       kre 		lvp->rfunc = NULL;
   1070   1.1       cgd 		vp = NULL;
   1071  1.69       kre 		xtrace_clone(0);
   1072   1.1       cgd 	} else {
   1073  1.35       dsl 		vp = find_var(name, &vpp, NULL);
   1074   1.1       cgd 		if (vp == NULL) {
   1075  1.54       kre 			flags &= ~VNOEXPORT;
   1076   1.1       cgd 			if (strchr(name, '='))
   1077  1.54       kre 				setvareq(savestr(name),
   1078  1.54       kre 				    VSTRFIXED | (flags & ~VUNSET));
   1079   1.1       cgd 			else
   1080  1.29  christos 				setvar(name, NULL, VSTRFIXED|flags);
   1081   1.1       cgd 			vp = *vpp;	/* the new variable */
   1082   1.1       cgd 			lvp->text = NULL;
   1083   1.1       cgd 			lvp->flags = VUNSET;
   1084  1.72       kre 			lvp->rfunc = NULL;
   1085   1.1       cgd 		} else {
   1086   1.1       cgd 			lvp->text = vp->text;
   1087   1.1       cgd 			lvp->flags = vp->flags;
   1088  1.72       kre 			lvp->v_u = vp->v_u;
   1089   1.1       cgd 			vp->flags |= VSTRFIXED|VTEXTFIXED;
   1090  1.71       kre 			if (flags & (VDOEXPORT | VUNSET))
   1091  1.71       kre 				vp->flags &= ~VNOEXPORT;
   1092  1.71       kre 			if (vp->flags & VNOEXPORT &&
   1093  1.71       kre 			    (flags & (VEXPORT|VDOEXPORT|VUNSET)) == VEXPORT)
   1094  1.54       kre 				flags &= ~VEXPORT;
   1095  1.54       kre 			if (flags & (VNOEXPORT | VUNSET))
   1096  1.54       kre 				vp->flags &= ~VEXPORT;
   1097  1.54       kre 			flags &= ~VNOEXPORT;
   1098  1.35       dsl 			if (name[vp->name_len] == '=')
   1099  1.54       kre 				setvareq(savestr(name), flags & ~VUNSET);
   1100  1.54       kre 			else if (flags & VUNSET)
   1101  1.54       kre 				unsetvar(name, 0);
   1102  1.54       kre 			else
   1103  1.54       kre 				vp->flags |= flags & (VUNSET|VEXPORT);
   1104  1.57       kre 
   1105  1.57       kre 			if (vp == &line_num) {
   1106  1.57       kre 				if (name[vp->name_len] == '=')
   1107  1.57       kre 					funclinebase = funclineabs -1;
   1108  1.57       kre 				else
   1109  1.57       kre 					funclinebase = 0;
   1110  1.57       kre 			}
   1111   1.1       cgd 		}
   1112   1.1       cgd 	}
   1113   1.1       cgd 	lvp->vp = vp;
   1114   1.1       cgd 	lvp->next = localvars;
   1115   1.1       cgd 	localvars = lvp;
   1116   1.1       cgd 	INTON;
   1117   1.1       cgd }
   1118   1.1       cgd 
   1119   1.1       cgd 
   1120   1.1       cgd /*
   1121   1.1       cgd  * Called after a function returns.
   1122   1.1       cgd  */
   1123   1.1       cgd 
   1124   1.1       cgd void
   1125  1.30  christos poplocalvars(void)
   1126  1.30  christos {
   1127   1.1       cgd 	struct localvar *lvp;
   1128   1.1       cgd 	struct var *vp;
   1129   1.1       cgd 
   1130   1.1       cgd 	while ((lvp = localvars) != NULL) {
   1131   1.1       cgd 		localvars = lvp->next;
   1132   1.1       cgd 		vp = lvp->vp;
   1133  1.71       kre 		VTRACE(DBG_VARS, ("poplocalvar %s\n", vp ? vp->text : "-"));
   1134   1.1       cgd 		if (vp == NULL) {	/* $- saved */
   1135  1.30  christos 			memcpy(optlist, lvp->text, sizeof_optlist);
   1136   1.1       cgd 			ckfree(lvp->text);
   1137  1.69       kre 			xtrace_pop();
   1138  1.57       kre 			optschanged();
   1139   1.1       cgd 		} else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
   1140  1.30  christos 			(void)unsetvar(vp->text, 0);
   1141   1.1       cgd 		} else {
   1142  1.72       kre 			if (lvp->func && (lvp->flags & (VNOFUNC|VFUNCREF)) == 0)
   1143  1.72       kre 				(*lvp->func)(lvp->text + vp->name_len + 1);
   1144   1.1       cgd 			if ((vp->flags & VTEXTFIXED) == 0)
   1145   1.1       cgd 				ckfree(vp->text);
   1146   1.1       cgd 			vp->flags = lvp->flags;
   1147   1.1       cgd 			vp->text = lvp->text;
   1148  1.72       kre 			vp->v_u = lvp->v_u;
   1149   1.1       cgd 		}
   1150   1.1       cgd 		ckfree(lvp);
   1151   1.1       cgd 	}
   1152   1.1       cgd }
   1153   1.1       cgd 
   1154   1.1       cgd 
   1155  1.10       cgd int
   1156  1.30  christos setvarcmd(int argc, char **argv)
   1157  1.10       cgd {
   1158   1.1       cgd 	if (argc <= 2)
   1159   1.1       cgd 		return unsetcmd(argc, argv);
   1160   1.1       cgd 	else if (argc == 3)
   1161   1.1       cgd 		setvar(argv[1], argv[2], 0);
   1162   1.1       cgd 	else
   1163   1.1       cgd 		error("List assignment not implemented");
   1164   1.1       cgd 	return 0;
   1165   1.1       cgd }
   1166   1.1       cgd 
   1167   1.1       cgd 
   1168   1.1       cgd /*
   1169   1.1       cgd  * The unset builtin command.  We unset the function before we unset the
   1170   1.1       cgd  * variable to allow a function to be unset when there is a readonly variable
   1171   1.1       cgd  * with the same name.
   1172   1.1       cgd  */
   1173   1.1       cgd 
   1174  1.10       cgd int
   1175  1.30  christos unsetcmd(int argc, char **argv)
   1176  1.10       cgd {
   1177   1.1       cgd 	char **ap;
   1178   1.5       jtc 	int i;
   1179   1.5       jtc 	int flg_func = 0;
   1180   1.5       jtc 	int flg_var = 0;
   1181  1.54       kre 	int flg_x = 0;
   1182   1.5       jtc 	int ret = 0;
   1183   1.5       jtc 
   1184  1.54       kre 	while ((i = nextopt("efvx")) != '\0') {
   1185  1.54       kre 		switch (i) {
   1186  1.54       kre 		case 'f':
   1187   1.5       jtc 			flg_func = 1;
   1188  1.54       kre 			break;
   1189  1.54       kre 		case 'e':
   1190  1.54       kre 		case 'x':
   1191  1.54       kre 			flg_x = (2 >> (i == 'e'));
   1192  1.54       kre 			/* FALLTHROUGH */
   1193  1.54       kre 		case 'v':
   1194  1.54       kre 			flg_var = 1;
   1195  1.54       kre 			break;
   1196  1.54       kre 		}
   1197   1.5       jtc 	}
   1198  1.54       kre 
   1199   1.5       jtc 	if (flg_func == 0 && flg_var == 0)
   1200   1.5       jtc 		flg_var = 1;
   1201  1.15  christos 
   1202   1.5       jtc 	for (ap = argptr; *ap ; ap++) {
   1203   1.5       jtc 		if (flg_func)
   1204   1.5       jtc 			ret |= unsetfunc(*ap);
   1205   1.5       jtc 		if (flg_var)
   1206  1.54       kre 			ret |= unsetvar(*ap, flg_x);
   1207   1.1       cgd 	}
   1208   1.5       jtc 	return ret;
   1209   1.1       cgd }
   1210   1.1       cgd 
   1211   1.1       cgd 
   1212   1.1       cgd /*
   1213   1.1       cgd  * Unset the specified variable.
   1214   1.1       cgd  */
   1215   1.1       cgd 
   1216  1.14  christos int
   1217  1.30  christos unsetvar(const char *s, int unexport)
   1218  1.30  christos {
   1219   1.1       cgd 	struct var **vpp;
   1220   1.1       cgd 	struct var *vp;
   1221   1.1       cgd 
   1222  1.35       dsl 	vp = find_var(s, &vpp, NULL);
   1223  1.35       dsl 	if (vp == NULL)
   1224  1.43  christos 		return 0;
   1225  1.35       dsl 
   1226  1.54       kre 	if (vp->flags & VREADONLY && !(unexport & 1))
   1227  1.43  christos 		return 1;
   1228  1.35       dsl 
   1229  1.35       dsl 	INTOFF;
   1230  1.54       kre 	if (unexport & 1) {
   1231  1.35       dsl 		vp->flags &= ~VEXPORT;
   1232  1.35       dsl 	} else {
   1233  1.35       dsl 		if (vp->text[vp->name_len + 1] != '\0')
   1234  1.35       dsl 			setvar(s, nullstr, 0);
   1235  1.54       kre 		if (!(unexport & 2))
   1236  1.54       kre 			vp->flags &= ~VEXPORT;
   1237  1.35       dsl 		vp->flags |= VUNSET;
   1238  1.54       kre 		if ((vp->flags&(VEXPORT|VSTRFIXED|VREADONLY|VNOEXPORT)) == 0) {
   1239  1.35       dsl 			if ((vp->flags & VTEXTFIXED) == 0)
   1240  1.35       dsl 				ckfree(vp->text);
   1241  1.35       dsl 			*vpp = vp->next;
   1242  1.35       dsl 			ckfree(vp);
   1243   1.1       cgd 		}
   1244   1.1       cgd 	}
   1245  1.35       dsl 	INTON;
   1246  1.35       dsl 	return 0;
   1247   1.1       cgd }
   1248   1.1       cgd 
   1249   1.1       cgd 
   1250   1.1       cgd /*
   1251   1.1       cgd  * Returns true if the two strings specify the same varable.  The first
   1252   1.1       cgd  * variable name is terminated by '='; the second may be terminated by
   1253   1.1       cgd  * either '=' or '\0'.
   1254   1.1       cgd  */
   1255   1.1       cgd 
   1256   1.1       cgd STATIC int
   1257  1.35       dsl strequal(const char *p, const char *q)
   1258  1.30  christos {
   1259   1.1       cgd 	while (*p == *q++) {
   1260   1.1       cgd 		if (*p++ == '=')
   1261   1.1       cgd 			return 1;
   1262   1.1       cgd 	}
   1263   1.1       cgd 	if (*p == '=' && *(q - 1) == '\0')
   1264   1.1       cgd 		return 1;
   1265   1.1       cgd 	return 0;
   1266   1.1       cgd }
   1267  1.35       dsl 
   1268  1.35       dsl /*
   1269  1.35       dsl  * Search for a variable.
   1270  1.35       dsl  * 'name' may be terminated by '=' or a NUL.
   1271  1.35       dsl  * vppp is set to the pointer to vp, or the list head if vp isn't found
   1272  1.71       kre  * lenp is set to the number of characters in 'name'
   1273  1.35       dsl  */
   1274  1.35       dsl 
   1275  1.35       dsl STATIC struct var *
   1276  1.35       dsl find_var(const char *name, struct var ***vppp, int *lenp)
   1277  1.35       dsl {
   1278  1.35       dsl 	unsigned int hashval;
   1279  1.35       dsl 	int len;
   1280  1.35       dsl 	struct var *vp, **vpp;
   1281  1.35       dsl 	const char *p = name;
   1282  1.35       dsl 
   1283  1.35       dsl 	hashval = 0;
   1284  1.35       dsl 	while (*p && *p != '=')
   1285  1.35       dsl 		hashval = 2 * hashval + (unsigned char)*p++;
   1286  1.71       kre 
   1287  1.35       dsl 	len = p - name;
   1288  1.35       dsl 	if (lenp)
   1289  1.35       dsl 		*lenp = len;
   1290  1.71       kre 
   1291  1.35       dsl 	vpp = &vartab[hashval % VTABSIZE];
   1292  1.35       dsl 	if (vppp)
   1293  1.35       dsl 		*vppp = vpp;
   1294  1.35       dsl 
   1295  1.35       dsl 	for (vp = *vpp ; vp ; vpp = &vp->next, vp = *vpp) {
   1296  1.35       dsl 		if (vp->name_len != len)
   1297  1.35       dsl 			continue;
   1298  1.35       dsl 		if (memcmp(vp->text, name, len) != 0)
   1299  1.35       dsl 			continue;
   1300  1.35       dsl 		if (vppp)
   1301  1.35       dsl 			*vppp = vpp;
   1302  1.35       dsl 		return vp;
   1303  1.35       dsl 	}
   1304  1.35       dsl 	return NULL;
   1305  1.35       dsl }
   1306  1.57       kre 
   1307  1.63       kre /*
   1308  1.63       kre  * The following are the functions that create the values for
   1309  1.63       kre  * shell variables that are dynamically produced when needed.
   1310  1.63       kre  *
   1311  1.63       kre  * The output strings cannot be malloc'd as there is nothing to
   1312  1.63       kre  * free them - callers assume these are ordinary variables where
   1313  1.63       kre  * the value returned is vp->text
   1314  1.63       kre  *
   1315  1.63       kre  * Each function needs its own storage space, as the results are
   1316  1.63       kre  * used to create processes' environment, and (if exported) all
   1317  1.63       kre  * the values will (might) be needed simultaneously.
   1318  1.63       kre  *
   1319  1.63       kre  * It is not a problem if a var is updated while nominally in use
   1320  1.63       kre  * somewhere, all these are intended to be dynamic, the value they
   1321  1.63       kre  * return is not guaranteed, an updated vaue is just as good.
   1322  1.63       kre  *
   1323  1.63       kre  * So, malloc a single buffer for the result of each function,
   1324  1.63       kre  * grow, and even shrink, it as needed, but once we have one that
   1325  1.63       kre  * is a suitable size for the actual usage, simply hold it forever.
   1326  1.63       kre  *
   1327  1.63       kre  * For a SMALL shell we implement only LINENO, none of the others,
   1328  1.63       kre  * and give it just a fixed length static buffer for its result.
   1329  1.63       kre  */
   1330  1.63       kre 
   1331  1.63       kre #ifndef SMALL
   1332  1.63       kre 
   1333  1.63       kre struct space_reserved {		/* record of space allocated for results */
   1334  1.63       kre 	char *b;
   1335  1.63       kre 	int len;
   1336  1.63       kre };
   1337  1.63       kre 
   1338  1.63       kre /* rough (over-)estimate of the number of bytes needed to hold a number */
   1339  1.63       kre static int
   1340  1.63       kre digits_in(intmax_t number)
   1341  1.63       kre {
   1342  1.63       kre 	int res = 0;
   1343  1.63       kre 
   1344  1.63       kre 	if (number & ~((1LL << 62) - 1))
   1345  1.63       kre 		res = 64;	/* enough for 2^200 and a bit more */
   1346  1.63       kre 	else if (number & ~((1LL << 32) - 1))
   1347  1.63       kre 		res = 20;	/* enough for 2^64 */
   1348  1.63       kre 	else if (number & ~((1 << 23) - 1))
   1349  1.63       kre 		res = 10;	/* enough for 2^32 */
   1350  1.63       kre 	else
   1351  1.63       kre 		res = 8;	/* enough for 2^23 or smaller */
   1352  1.63       kre 
   1353  1.63       kre 	return res;
   1354  1.63       kre }
   1355  1.63       kre 
   1356  1.63       kre static int
   1357  1.63       kre make_space(struct space_reserved *m, int bytes)
   1358  1.63       kre {
   1359  1.63       kre 	void *p;
   1360  1.63       kre 
   1361  1.63       kre 	if (m->len >= bytes && m->len <= (bytes<<2))
   1362  1.63       kre 		return 1;
   1363  1.63       kre 
   1364  1.63       kre 	bytes = SHELL_ALIGN(bytes);
   1365  1.76       kre 	INTOFF;
   1366  1.63       kre 	/* not ckrealloc() - we want failure, not error() here */
   1367  1.63       kre 	p = realloc(m->b, bytes);
   1368  1.76       kre 	if (p != NULL) {
   1369  1.76       kre 		m->b = p;
   1370  1.76       kre 		m->len = bytes;
   1371  1.76       kre 		m->b[bytes - 1] = '\0';
   1372  1.76       kre 	}
   1373  1.76       kre 	INTON;
   1374  1.63       kre 
   1375  1.76       kre 	return p != NULL;
   1376  1.63       kre }
   1377  1.63       kre #endif
   1378  1.63       kre 
   1379  1.57       kre char *
   1380  1.57       kre get_lineno(struct var *vp)
   1381  1.57       kre {
   1382  1.63       kre #ifdef SMALL
   1383  1.63       kre #define length (8 + 10)		/* 10 digits is enough for a 32 bit line num */
   1384  1.63       kre 	static char result[length];
   1385  1.63       kre #else
   1386  1.63       kre 	static struct space_reserved buf;
   1387  1.63       kre #define result buf.b
   1388  1.63       kre #define length buf.len
   1389  1.63       kre #endif
   1390  1.57       kre 	int ln = line_number;
   1391  1.57       kre 
   1392  1.57       kre 	if (vp->flags & VUNSET)
   1393  1.57       kre 		return NULL;
   1394  1.57       kre 
   1395  1.57       kre 	ln -= funclinebase;
   1396  1.63       kre 
   1397  1.63       kre #ifndef SMALL
   1398  1.63       kre 	if (!make_space(&buf, vp->name_len + 2 + digits_in(ln)))
   1399  1.63       kre 		return vp->text;
   1400  1.63       kre #endif
   1401  1.63       kre 
   1402  1.75       kre 	snprintf(result, length, "%.*s=%d", vp->name_len, vp->text, ln);
   1403  1.63       kre 	return result;
   1404  1.63       kre }
   1405  1.63       kre #undef result
   1406  1.63       kre #undef length
   1407  1.63       kre 
   1408  1.63       kre #ifndef SMALL
   1409  1.63       kre 
   1410  1.63       kre char *
   1411  1.63       kre get_hostname(struct var *vp)
   1412  1.63       kre {
   1413  1.63       kre 	static struct space_reserved buf;
   1414  1.63       kre 
   1415  1.63       kre 	if (vp->flags & VUNSET)
   1416  1.63       kre 		return NULL;
   1417  1.63       kre 
   1418  1.63       kre 	if (!make_space(&buf, vp->name_len + 2 + 256))
   1419  1.63       kre 		return vp->text;
   1420  1.63       kre 
   1421  1.63       kre 	memcpy(buf.b, vp->text, vp->name_len + 1);	/* include '=' */
   1422  1.63       kre 	(void)gethostname(buf.b + vp->name_len + 1,
   1423  1.63       kre 	    buf.len - vp->name_len - 3);
   1424  1.63       kre 	return buf.b;
   1425  1.63       kre }
   1426  1.63       kre 
   1427  1.63       kre char *
   1428  1.63       kre get_tod(struct var *vp)
   1429  1.63       kre {
   1430  1.63       kre 	static struct space_reserved buf;	/* space for answers */
   1431  1.63       kre 	static struct space_reserved tzs;	/* remember TZ last used */
   1432  1.63       kre 	static timezone_t last_zone;		/* timezone data for tzs zone */
   1433  1.63       kre 	const char *fmt;
   1434  1.63       kre 	char *tz;
   1435  1.63       kre 	time_t now;
   1436  1.63       kre 	struct tm tm_now, *tmp;
   1437  1.63       kre 	timezone_t zone = NULL;
   1438  1.63       kre 	static char t_err[] = "time error";
   1439  1.63       kre 	int len;
   1440  1.63       kre 
   1441  1.63       kre 	if (vp->flags & VUNSET)
   1442  1.63       kre 		return NULL;
   1443  1.63       kre 
   1444  1.63       kre 	fmt = lookupvar("ToD_FORMAT");
   1445  1.63       kre 	if (fmt == NULL)
   1446  1.63       kre 		fmt="%T";
   1447  1.63       kre 	tz = lookupvar("TZ");
   1448  1.63       kre 	(void)time(&now);
   1449  1.63       kre 
   1450  1.63       kre 	if (tz != NULL) {
   1451  1.63       kre 		if (tzs.b == NULL || strcmp(tzs.b, tz) != 0) {
   1452  1.76       kre 			INTOFF;
   1453  1.63       kre 			if (make_space(&tzs, strlen(tz) + 1)) {
   1454  1.63       kre 				strcpy(tzs.b, tz);
   1455  1.63       kre 				if (last_zone)
   1456  1.63       kre 					tzfree(last_zone);
   1457  1.63       kre 				last_zone = zone = tzalloc(tz);
   1458  1.63       kre 				INTON;
   1459  1.63       kre 			} else
   1460  1.63       kre 				zone = tzalloc(tz);
   1461  1.63       kre 		} else
   1462  1.63       kre 			zone = last_zone;
   1463  1.63       kre 
   1464  1.63       kre 		tmp = localtime_rz(zone, &now, &tm_now);
   1465  1.63       kre 	} else
   1466  1.63       kre 		tmp = localtime_r(&now, &tm_now);
   1467  1.63       kre 
   1468  1.63       kre 	len = (strlen(fmt) * 4) + vp->name_len + 2;
   1469  1.63       kre 	while (make_space(&buf, len)) {
   1470  1.63       kre 		memcpy(buf.b, vp->text, vp->name_len+1);
   1471  1.63       kre 		if (tmp == NULL) {
   1472  1.63       kre 			if (buf.len >= vp->name_len+2+(int)(sizeof t_err - 1)) {
   1473  1.63       kre 				strcpy(buf.b + vp->name_len + 1, t_err);
   1474  1.76       kre 				if (zone && zone != last_zone) {
   1475  1.63       kre 					tzfree(zone);
   1476  1.76       kre 					INTON;
   1477  1.76       kre 				}
   1478  1.63       kre 				return buf.b;
   1479  1.63       kre 			}
   1480  1.63       kre 			len = vp->name_len + 4 + sizeof t_err - 1;
   1481  1.63       kre 			continue;
   1482  1.63       kre 		}
   1483  1.63       kre 		if (strftime_z(zone, buf.b + vp->name_len + 1,
   1484  1.63       kre 		     buf.len - vp->name_len - 2, fmt, tmp)) {
   1485  1.76       kre 			if (zone && zone != last_zone) {
   1486  1.63       kre 				tzfree(zone);
   1487  1.76       kre 				INTON;
   1488  1.76       kre 			}
   1489  1.63       kre 			return buf.b;
   1490  1.63       kre 		}
   1491  1.63       kre 		if (len >= 4096)	/* Let's be reasonable */
   1492  1.63       kre 			break;
   1493  1.63       kre 		len <<= 1;
   1494  1.63       kre 	}
   1495  1.76       kre 	if (zone && zone != last_zone) {
   1496  1.63       kre 		tzfree(zone);
   1497  1.76       kre 		INTON;
   1498  1.76       kre 	}
   1499  1.63       kre 	return vp->text;
   1500  1.57       kre }
   1501  1.63       kre 
   1502  1.63       kre char *
   1503  1.63       kre get_seconds(struct var *vp)
   1504  1.63       kre {
   1505  1.63       kre 	static struct space_reserved buf;
   1506  1.63       kre 	intmax_t secs;
   1507  1.63       kre 
   1508  1.63       kre 	if (vp->flags & VUNSET)
   1509  1.63       kre 		return NULL;
   1510  1.63       kre 
   1511  1.63       kre 	secs = (intmax_t)time((time_t *)0) - sh_start_time;
   1512  1.63       kre 	if (!make_space(&buf, vp->name_len + 2 + digits_in(secs)))
   1513  1.63       kre 		return vp->text;
   1514  1.63       kre 
   1515  1.75       kre 	snprintf(buf.b, buf.len, "%.*s=%jd", vp->name_len, vp->text, secs);
   1516  1.63       kre 	return buf.b;
   1517  1.63       kre }
   1518  1.63       kre 
   1519  1.63       kre char *
   1520  1.63       kre get_euser(struct var *vp)
   1521  1.63       kre {
   1522  1.63       kre 	static struct space_reserved buf;
   1523  1.63       kre 	static uid_t lastuid = 0;
   1524  1.63       kre 	uid_t euid;
   1525  1.63       kre 	struct passwd *pw;
   1526  1.63       kre 
   1527  1.63       kre 	if (vp->flags & VUNSET)
   1528  1.63       kre 		return NULL;
   1529  1.63       kre 
   1530  1.63       kre 	euid = geteuid();
   1531  1.63       kre 	if (buf.b != NULL && lastuid == euid)
   1532  1.63       kre 		return buf.b;
   1533  1.63       kre 
   1534  1.63       kre 	pw = getpwuid(euid);
   1535  1.63       kre 	if (pw == NULL)
   1536  1.63       kre 		return vp->text;
   1537  1.63       kre 
   1538  1.63       kre 	if (make_space(&buf, vp->name_len + 2 + strlen(pw->pw_name))) {
   1539  1.76       kre 		INTOFF;
   1540  1.63       kre 		lastuid = euid;
   1541  1.63       kre 		snprintf(buf.b, buf.len, "%.*s=%s", vp->name_len, vp->text,
   1542  1.63       kre 		    pw->pw_name);
   1543  1.76       kre 		INTON;
   1544  1.63       kre 		return buf.b;
   1545  1.63       kre 	}
   1546  1.63       kre 
   1547  1.63       kre 	return vp->text;
   1548  1.63       kre }
   1549  1.63       kre 
   1550  1.63       kre char *
   1551  1.63       kre get_random(struct var *vp)
   1552  1.63       kre {
   1553  1.63       kre 	static struct space_reserved buf;
   1554  1.63       kre 	static intmax_t random_val = 0;
   1555  1.63       kre 
   1556  1.63       kre #ifdef USE_LRAND48
   1557  1.63       kre #define random lrand48
   1558  1.63       kre #define srandom srand48
   1559  1.63       kre #endif
   1560  1.63       kre 
   1561  1.63       kre 	if (vp->flags & VUNSET)
   1562  1.63       kre 		return NULL;
   1563  1.63       kre 
   1564  1.63       kre 	if (vp->text != buf.b) {
   1565  1.63       kre 		/*
   1566  1.63       kre 		 * Either initialisation, or a new seed has been set
   1567  1.63       kre 		 */
   1568  1.63       kre 		if (vp->text[vp->name_len + 1] == '\0') {
   1569  1.63       kre 			int fd;
   1570  1.63       kre 
   1571  1.63       kre 			/*
   1572  1.63       kre 			 * initialisation (without pre-seeding),
   1573  1.63       kre 			 * or explictly requesting a truly random seed.
   1574  1.63       kre 			 */
   1575  1.76       kre 			INTOFF;
   1576  1.63       kre 			fd = open("/dev/urandom", 0);
   1577  1.63       kre 			if (fd == -1) {
   1578  1.63       kre 				out2str("RANDOM initialisation failed\n");
   1579  1.63       kre 				random_val = (getpid()<<3) ^ time((time_t *)0);
   1580  1.63       kre 			} else {
   1581  1.63       kre 				int n;
   1582  1.63       kre 
   1583  1.63       kre 				do {
   1584  1.63       kre 				    n = read(fd,&random_val,sizeof random_val);
   1585  1.63       kre 				} while (n != sizeof random_val);
   1586  1.63       kre 				close(fd);
   1587  1.63       kre 			}
   1588  1.76       kre 			INTON;
   1589  1.63       kre 		} else
   1590  1.63       kre 			/* good enough for today */
   1591  1.70       kre 			random_val = strtoimax(vp->text+vp->name_len+1,NULL,0);
   1592  1.63       kre 
   1593  1.63       kre 		srandom((long)random_val);
   1594  1.63       kre 	}
   1595  1.63       kre 
   1596  1.63       kre #if 0
   1597  1.63       kre 	random_val = (random_val + 1) & 0x7FFF;	/* 15 bit "random" numbers */
   1598  1.63       kre #else
   1599  1.63       kre 	random_val = (random() >> 5) & 0x7FFF;
   1600  1.63       kre #endif
   1601  1.63       kre 
   1602  1.63       kre 	if (!make_space(&buf, vp->name_len + 2 + digits_in(random_val)))
   1603  1.63       kre 		return vp->text;
   1604  1.63       kre 
   1605  1.75       kre 	snprintf(buf.b, buf.len, "%.*s=%jd", vp->name_len, vp->text,
   1606  1.63       kre 	    random_val);
   1607  1.63       kre 
   1608  1.76       kre 	INTOFF;
   1609  1.63       kre 	if (buf.b != vp->text && (vp->flags & (VTEXTFIXED|VSTACK)) == 0)
   1610  1.63       kre 		free(vp->text);
   1611  1.63       kre 	vp->flags |= VTEXTFIXED;
   1612  1.63       kre 	vp->text = buf.b;
   1613  1.76       kre 	INTON;
   1614  1.63       kre 
   1615  1.63       kre 	return vp->text;
   1616  1.63       kre #undef random
   1617  1.63       kre #undef srandom
   1618  1.63       kre }
   1619  1.63       kre 
   1620  1.78       kre STATIC int
   1621  1.78       kre makespecial(const char *name)
   1622  1.78       kre {
   1623  1.78       kre 	const struct varinit *ip;
   1624  1.78       kre 	struct var *vp;
   1625  1.78       kre 
   1626  1.78       kre 	CTRACE(DBG_VARS, ("makespecial('%s') -> ", name));
   1627  1.78       kre 	for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
   1628  1.78       kre 		if (strequal(ip->text, name)) {
   1629  1.78       kre 			if (!(ip->flags & VFUNCREF)) {
   1630  1.78       kre 				CTRACE(DBG_VARS, ("+1\n"));
   1631  1.78       kre 				return 1;
   1632  1.78       kre 			}
   1633  1.78       kre 			INTOFF;
   1634  1.78       kre 			vp->flags &= ~VUNSET;
   1635  1.78       kre 			vp->v_u = ip->v_u;
   1636  1.78       kre 			INTON;
   1637  1.78       kre 			CTRACE(DBG_VARS, ("0\n"));
   1638  1.78       kre 			return 0;
   1639  1.78       kre 		}
   1640  1.78       kre 	}
   1641  1.78       kre 	CTRACE(DBG_VARS, ("1\n"));
   1642  1.78       kre 	return 1;
   1643  1.78       kre }
   1644  1.78       kre 
   1645  1.78       kre int
   1646  1.78       kre specialvarcmd(int argc, char **argv)
   1647  1.78       kre {
   1648  1.78       kre 	int res = 0;
   1649  1.78       kre 	char **ap;
   1650  1.78       kre 
   1651  1.78       kre 	(void) nextopt("");
   1652  1.78       kre 
   1653  1.78       kre 	if (!*argptr)
   1654  1.78       kre 		error("Usage: specialvar var...");
   1655  1.78       kre 
   1656  1.78       kre 	for (ap = argptr; *ap ; ap++)
   1657  1.78       kre 		res |= makespecial(*ap);
   1658  1.78       kre 
   1659  1.78       kre 	return res;
   1660  1.78       kre }
   1661  1.78       kre 
   1662  1.63       kre #endif /* SMALL */
   1663