xref: /dragonfly/bin/sh/var.c (revision 92fc8b5c) 
1 /*-
2  * Copyright (c) 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by the University of
19  *	California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)var.c	8.3 (Berkeley) 5/4/95
37  * $FreeBSD: src/bin/sh/var.c,v 1.56 2011/02/04 22:47:55 jilles Exp $
38  */
39 
40 #include <unistd.h>
41 #include <stdlib.h>
42 
43 /*
44  * Shell variables.
45  */
46 
47 #include <locale.h>
48 #include <paths.h>
49 
50 #include "shell.h"
51 #include "output.h"
52 #include "expand.h"
53 #include "nodes.h"	/* for other headers */
54 #include "eval.h"	/* defines cmdenviron */
55 #include "exec.h"
56 #include "syntax.h"
57 #include "options.h"
58 #include "mail.h"
59 #include "var.h"
60 #include "memalloc.h"
61 #include "error.h"
62 #include "mystring.h"
63 #include "parser.h"
64 #ifndef NO_HISTORY
65 #include "myhistedit.h"
66 #endif
67 
68 
69 #define VTABSIZE 39
70 
71 
72 struct varinit {
73 	struct var *var;
74 	int flags;
75 	const char *text;
76 	void (*func)(const char *);
77 };
78 
79 
80 #ifndef NO_HISTORY
81 struct var vhistsize;
82 struct var vterm;
83 #endif
84 struct var vifs;
85 struct var vmail;
86 struct var vmpath;
87 struct var vpath;
88 struct var vppid;
89 struct var vps1;
90 struct var vps2;
91 struct var vps4;
92 struct var vvers;
93 static struct var voptind;
94 
95 static const struct varinit varinit[] = {
96 #ifndef NO_HISTORY
97 	{ &vhistsize,	VUNSET,				"HISTSIZE=",
98 	  sethistsize },
99 #endif
100 	{ &vifs,	0,				"IFS= \t\n",
101 	  NULL },
102 	{ &vmail,	VUNSET,				"MAIL=",
103 	  NULL },
104 	{ &vmpath,	VUNSET,				"MAILPATH=",
105 	  NULL },
106 	{ &vpath,	0,				"PATH=" _PATH_DEFPATH,
107 	  changepath },
108 	{ &vppid,	VUNSET,				"PPID=",
109 	  NULL },
110 	/*
111 	 * vps1 depends on uid
112 	 */
113 	{ &vps2,	0,				"PS2=> ",
114 	  NULL },
115 	{ &vps4,	0,				"PS4=+ ",
116 	  NULL },
117 #ifndef NO_HISTORY
118 	{ &vterm,	VUNSET,				"TERM=",
119 	  setterm },
120 #endif
121 	{ &voptind,	0,				"OPTIND=1",
122 	  getoptsreset },
123 	{ NULL,	0,				NULL,
124 	  NULL }
125 };
126 
127 static struct var *vartab[VTABSIZE];
128 
129 static const char *const locale_names[7] = {
130 	"LC_COLLATE", "LC_CTYPE", "LC_MONETARY",
131 	"LC_NUMERIC", "LC_TIME", "LC_MESSAGES", NULL
132 };
133 static const int locale_categories[7] = {
134 	LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME, LC_MESSAGES, 0
135 };
136 
137 static struct var **hashvar(const char *);
138 static int varequal(const char *, const char *);
139 static int localevar(const char *);
140 
141 /*
142  * Initialize the variable symbol tables and import the environment.
143  */
144 
145 #ifdef mkinit
146 INCLUDE "var.h"
147 MKINIT char **environ;
148 INIT {
149 	char **envp;
150 
151 	initvar();
152 	for (envp = environ ; *envp ; envp++) {
153 		if (strchr(*envp, '=')) {
154 			setvareq(*envp, VEXPORT|VTEXTFIXED);
155 		}
156 	}
157 }
158 #endif
159 
160 
161 /*
162  * This routine initializes the builtin variables.  It is called when the
163  * shell is initialized.
164  */
165 
166 void
167 initvar(void)
168 {
169 	char ppid[20];
170 	const struct varinit *ip;
171 	struct var *vp;
172 	struct var **vpp;
173 
174 	for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
175 		if ((vp->flags & VEXPORT) == 0) {
176 			vpp = hashvar(ip->text);
177 			vp->next = *vpp;
178 			*vpp = vp;
179 			vp->text = __DECONST(char *, ip->text);
180 			vp->flags = ip->flags | VSTRFIXED | VTEXTFIXED;
181 			vp->func = ip->func;
182 		}
183 	}
184 	/*
185 	 * PS1 depends on uid
186 	 */
187 	if ((vps1.flags & VEXPORT) == 0) {
188 		vpp = hashvar("PS1=");
189 		vps1.next = *vpp;
190 		*vpp = &vps1;
191 		vps1.text = __DECONST(char *, geteuid() ? "PS1=$ " : "PS1=# ");
192 		vps1.flags = VSTRFIXED|VTEXTFIXED;
193 	}
194 	if ((vppid.flags & VEXPORT) == 0) {
195 		fmtstr(ppid, sizeof(ppid), "%d", (int)getppid());
196 		setvarsafe("PPID", ppid, 0);
197 	}
198 }
199 
200 /*
201  * Safe version of setvar, returns 1 on success 0 on failure.
202  */
203 
204 int
205 setvarsafe(const char *name, const char *val, int flags)
206 {
207 	struct jmploc jmploc;
208 	struct jmploc *const savehandler = handler;
209 	int err = 0;
210 	int inton;
211 
212 	inton = is_int_on();
213 	if (setjmp(jmploc.loc))
214 		err = 1;
215 	else {
216 		handler = &jmploc;
217 		setvar(name, val, flags);
218 	}
219 	handler = savehandler;
220 	SETINTON(inton);
221 	return err;
222 }
223 
224 /*
225  * Set the value of a variable.  The flags argument is stored with the
226  * flags of the variable.  If val is NULL, the variable is unset.
227  */
228 
229 void
230 setvar(const char *name, const char *val, int flags)
231 {
232 	const char *p;
233 	int len;
234 	int namelen;
235 	char *nameeq;
236 	int isbad;
237 
238 	isbad = 0;
239 	p = name;
240 	if (!is_name(*p))
241 		isbad = 1;
242 	p++;
243 	for (;;) {
244 		if (!is_in_name(*p)) {
245 			if (*p == '\0' || *p == '=')
246 				break;
247 			isbad = 1;
248 		}
249 		p++;
250 	}
251 	namelen = p - name;
252 	if (isbad)
253 		error("%.*s: bad variable name", namelen, name);
254 	len = namelen + 2;		/* 2 is space for '=' and '\0' */
255 	if (val == NULL) {
256 		flags |= VUNSET;
257 	} else {
258 		len += strlen(val);
259 	}
260 	nameeq = ckmalloc(len);
261 	memcpy(nameeq, name, namelen);
262 	nameeq[namelen] = '=';
263 	if (val)
264 		scopy(val, nameeq + namelen + 1);
265 	else
266 		nameeq[namelen + 1] = '\0';
267 	setvareq(nameeq, flags);
268 }
269 
270 static int
271 localevar(const char *s)
272 {
273 	const char *const *ss;
274 
275 	if (*s != 'L')
276 		return 0;
277 	if (varequal(s + 1, "ANG"))
278 		return 1;
279 	if (strncmp(s + 1, "C_", 2) != 0)
280 		return 0;
281 	if (varequal(s + 3, "ALL"))
282 		return 1;
283 	for (ss = locale_names; *ss ; ss++)
284 		if (varequal(s + 3, *ss + 3))
285 			return 1;
286 	return 0;
287 }
288 
289 /*
290  * Sets/unsets an environment variable from a pointer that may actually be a
291  * pointer into environ where the string should not be manipulated.
292  */
293 static void
294 change_env(const char *s, int set)
295 {
296 	char *eqp;
297 	char *ss;
298 
299 	ss = savestr(s);
300 	if ((eqp = strchr(ss, '=')) != NULL)
301 		*eqp = '\0';
302 	if (set && eqp != NULL) {
303 		if (setenv(ss, eqp + 1, 1) != 0)
304 			error("setenv: cannot set %s=%s", ss, eqp + 1);
305 	} else
306 		unsetenv(ss);
307 	ckfree(ss);
308 }
309 
310 
311 /*
312  * Same as setvar except that the variable and value are passed in
313  * the first argument as name=value.  Since the first argument will
314  * be actually stored in the table, it should not be a string that
315  * will go away.
316  */
317 
318 void
319 setvareq(char *s, int flags)
320 {
321 	struct var *vp, **vpp;
322 	int len;
323 
324 	if (aflag)
325 		flags |= VEXPORT;
326 	vpp = hashvar(s);
327 	for (vp = *vpp ; vp ; vp = vp->next) {
328 		if (varequal(s, vp->text)) {
329 			if (vp->flags & VREADONLY) {
330 				len = strchr(s, '=') - s;
331 				error("%.*s: is read only", len, s);
332 			}
333 			if (flags & VNOSET)
334 				return;
335 			INTOFF;
336 
337 			if (vp->func && (flags & VNOFUNC) == 0)
338 				(*vp->func)(strchr(s, '=') + 1);
339 
340 			if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
341 				ckfree(vp->text);
342 
343 			vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
344 			vp->flags |= flags;
345 			vp->text = s;
346 
347 			/*
348 			 * We could roll this to a function, to handle it as
349 			 * a regular variable function callback, but why bother?
350 			 *
351 			 * Note: this assumes iflag is not set to 1 initially.
352 			 * As part of init(), this is called before arguments
353 			 * are looked at.
354 			 */
355 			if ((vp == &vmpath || (vp == &vmail && ! mpathset())) &&
356 			    iflag == 1)
357 				chkmail(1);
358 			if ((vp->flags & VEXPORT) && localevar(s)) {
359 				change_env(s, 1);
360 				setlocale(LC_ALL, "");
361 			}
362 			INTON;
363 			return;
364 		}
365 	}
366 	/* not found */
367 	if (flags & VNOSET)
368 		return;
369 	vp = ckmalloc(sizeof (*vp));
370 	vp->flags = flags;
371 	vp->text = s;
372 	vp->next = *vpp;
373 	vp->func = NULL;
374 	INTOFF;
375 	*vpp = vp;
376 	if ((vp->flags & VEXPORT) && localevar(s)) {
377 		change_env(s, 1);
378 		setlocale(LC_ALL, "");
379 	}
380 	INTON;
381 }
382 
383 
384 
385 /*
386  * Process a linked list of variable assignments.
387  */
388 
389 void
390 listsetvar(struct strlist *list, int flags)
391 {
392 	struct strlist *lp;
393 
394 	INTOFF;
395 	for (lp = list ; lp ; lp = lp->next) {
396 		setvareq(savestr(lp->text), flags);
397 	}
398 	INTON;
399 }
400 
401 
402 
403 /*
404  * Find the value of a variable.  Returns NULL if not set.
405  */
406 
407 char *
408 lookupvar(const char *name)
409 {
410 	struct var *v;
411 
412 	for (v = *hashvar(name) ; v ; v = v->next) {
413 		if (varequal(v->text, name)) {
414 			if (v->flags & VUNSET)
415 				return NULL;
416 			return strchr(v->text, '=') + 1;
417 		}
418 	}
419 	return NULL;
420 }
421 
422 
423 
424 /*
425  * Search the environment of a builtin command.  If the second argument
426  * is nonzero, return the value of a variable even if it hasn't been
427  * exported.
428  */
429 
430 char *
431 bltinlookup(const char *name, int doall)
432 {
433 	struct strlist *sp;
434 	struct var *v;
435 	char *result;
436 
437 	result = NULL;
438 	for (sp = cmdenviron ; sp ; sp = sp->next) {
439 		if (varequal(sp->text, name))
440 			result = strchr(sp->text, '=') + 1;
441 	}
442 	if (result != NULL)
443 		return result;
444 	for (v = *hashvar(name) ; v ; v = v->next) {
445 		if (varequal(v->text, name)) {
446 			if ((v->flags & VUNSET)
447 			 || (!doall && (v->flags & VEXPORT) == 0))
448 				return NULL;
449 			return strchr(v->text, '=') + 1;
450 		}
451 	}
452 	return NULL;
453 }
454 
455 
456 /*
457  * Set up locale for a builtin (LANG/LC_* assignments).
458  */
459 void
460 bltinsetlocale(void)
461 {
462 	struct strlist *lp;
463 	int act = 0;
464 	char *loc, *locdef;
465 	int i;
466 
467 	for (lp = cmdenviron ; lp ; lp = lp->next) {
468 		if (localevar(lp->text)) {
469 			act = 1;
470 			break;
471 		}
472 	}
473 	if (!act)
474 		return;
475 	loc = bltinlookup("LC_ALL", 0);
476 	INTOFF;
477 	if (loc != NULL) {
478 		setlocale(LC_ALL, loc);
479 		INTON;
480 		return;
481 	}
482 	locdef = bltinlookup("LANG", 0);
483 	for (i = 0; locale_names[i] != NULL; i++) {
484 		loc = bltinlookup(locale_names[i], 0);
485 		if (loc == NULL)
486 			loc = locdef;
487 		if (loc != NULL)
488 			setlocale(locale_categories[i], loc);
489 	}
490 	INTON;
491 }
492 
493 /*
494  * Undo the effect of bltinlocaleset().
495  */
496 void
497 bltinunsetlocale(void)
498 {
499 	struct strlist *lp;
500 
501 	INTOFF;
502 	for (lp = cmdenviron ; lp ; lp = lp->next) {
503 		if (localevar(lp->text)) {
504 			setlocale(LC_ALL, "");
505 			return;
506 		}
507 	}
508 	INTON;
509 }
510 
511 
512 /*
513  * Generate a list of exported variables.  This routine is used to construct
514  * the third argument to execve when executing a program.
515  */
516 
517 char **
518 environment(void)
519 {
520 	int nenv;
521 	struct var **vpp;
522 	struct var *vp;
523 	char **env, **ep;
524 
525 	nenv = 0;
526 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
527 		for (vp = *vpp ; vp ; vp = vp->next)
528 			if (vp->flags & VEXPORT)
529 				nenv++;
530 	}
531 	ep = env = stalloc((nenv + 1) * sizeof *env);
532 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
533 		for (vp = *vpp ; vp ; vp = vp->next)
534 			if (vp->flags & VEXPORT)
535 				*ep++ = vp->text;
536 	}
537 	*ep = NULL;
538 	return env;
539 }
540 
541 
542 static int
543 var_compare(const void *a, const void *b)
544 {
545 	const char *const *sa, *const *sb;
546 
547 	sa = a;
548 	sb = b;
549 	/*
550 	 * This compares two var=value strings which creates a different
551 	 * order from what you would probably expect.  POSIX is somewhat
552 	 * ambiguous on what should be sorted exactly.
553 	 */
554 	return strcoll(*sa, *sb);
555 }
556 
557 
558 /*
559  * Command to list all variables which are set.  This is invoked from the
560  * set command when it is called without any options or operands.
561  */
562 
563 int
564 showvarscmd(int argc __unused, char **argv __unused)
565 {
566 	struct var **vpp;
567 	struct var *vp;
568 	const char *s;
569 	const char **vars;
570 	int i, n;
571 
572 	/*
573 	 * POSIX requires us to sort the variables.
574 	 */
575 	n = 0;
576 	for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
577 		for (vp = *vpp; vp; vp = vp->next) {
578 			if (!(vp->flags & VUNSET))
579 				n++;
580 		}
581 	}
582 
583 	INTON;
584 	vars = ckmalloc(n * sizeof(*vars));
585 	i = 0;
586 	for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
587 		for (vp = *vpp; vp; vp = vp->next) {
588 			if (!(vp->flags & VUNSET))
589 				vars[i++] = vp->text;
590 		}
591 	}
592 
593 	qsort(vars, n, sizeof(*vars), var_compare);
594 	for (i = 0; i < n; i++) {
595 		s = strchr(vars[i], '=');
596 		s++;
597 		outbin(vars[i], s - vars[i], out1);
598 		out1qstr(s);
599 		out1c('\n');
600 	}
601 	ckfree(vars);
602 	INTOFF;
603 
604 	return 0;
605 }
606 
607 
608 
609 /*
610  * The export and readonly commands.
611  */
612 
613 int
614 exportcmd(int argc, char **argv)
615 {
616 	struct var **vpp;
617 	struct var *vp;
618 	char *name;
619 	char *p;
620 	char *cmdname;
621 	int ch, values;
622 	int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
623 
624 	cmdname = argv[0];
625 	optreset = optind = 1;
626 	opterr = 0;
627 	values = 0;
628 	while ((ch = getopt(argc, argv, "p")) != -1) {
629 		switch (ch) {
630 		case 'p':
631 			values = 1;
632 			break;
633 		case '?':
634 		default:
635 			error("unknown option: -%c", optopt);
636 		}
637 	}
638 	argc -= optind;
639 	argv += optind;
640 
641 	if (values && argc != 0)
642 		error("-p requires no arguments");
643 	if (argc != 0) {
644 		while ((name = *argv++) != NULL) {
645 			if ((p = strchr(name, '=')) != NULL) {
646 				p++;
647 			} else {
648 				vpp = hashvar(name);
649 				for (vp = *vpp ; vp ; vp = vp->next) {
650 					if (varequal(vp->text, name)) {
651 
652 						vp->flags |= flag;
653 						if ((vp->flags & VEXPORT) && localevar(vp->text)) {
654 							change_env(vp->text, 1);
655 							setlocale(LC_ALL, "");
656 						}
657 						goto found;
658 					}
659 				}
660 			}
661 			setvar(name, p, flag);
662 found:;
663 		}
664 	} else {
665 		for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
666 			for (vp = *vpp ; vp ; vp = vp->next) {
667 				if (vp->flags & flag) {
668 					if (values) {
669 						out1str(cmdname);
670 						out1c(' ');
671 					}
672 					p = strchr(vp->text, '=');
673 					if (values && !(vp->flags & VUNSET)) {
674 						p++;
675 						outbin(vp->text, p - vp->text,
676 						    out1);
677 						out1qstr(p);
678 					} else
679 						outbin(vp->text, p - vp->text,
680 						    out1);
681 					out1c('\n');
682 				}
683 			}
684 		}
685 	}
686 	return 0;
687 }
688 
689 
690 /*
691  * The "local" command.
692  */
693 
694 int
695 localcmd(int argc __unused, char **argv __unused)
696 {
697 	char *name;
698 
699 	if (! in_function())
700 		error("Not in a function");
701 	while ((name = *argptr++) != NULL) {
702 		mklocal(name);
703 	}
704 	return 0;
705 }
706 
707 
708 /*
709  * Make a variable a local variable.  When a variable is made local, it's
710  * value and flags are saved in a localvar structure.  The saved values
711  * will be restored when the shell function returns.  We handle the name
712  * "-" as a special case.
713  */
714 
715 void
716 mklocal(char *name)
717 {
718 	struct localvar *lvp;
719 	struct var **vpp;
720 	struct var *vp;
721 
722 	INTOFF;
723 	lvp = ckmalloc(sizeof (struct localvar));
724 	if (name[0] == '-' && name[1] == '\0') {
725 		lvp->text = ckmalloc(sizeof optlist);
726 		memcpy(lvp->text, optlist, sizeof optlist);
727 		vp = NULL;
728 	} else {
729 		vpp = hashvar(name);
730 		for (vp = *vpp ; vp && ! varequal(vp->text, name) ; vp = vp->next);
731 		if (vp == NULL) {
732 			if (strchr(name, '='))
733 				setvareq(savestr(name), VSTRFIXED);
734 			else
735 				setvar(name, NULL, VSTRFIXED);
736 			vp = *vpp;	/* the new variable */
737 			lvp->text = NULL;
738 			lvp->flags = VUNSET;
739 		} else {
740 			lvp->text = vp->text;
741 			lvp->flags = vp->flags;
742 			vp->flags |= VSTRFIXED|VTEXTFIXED;
743 			if (strchr(name, '='))
744 				setvareq(savestr(name), 0);
745 		}
746 	}
747 	lvp->vp = vp;
748 	lvp->next = localvars;
749 	localvars = lvp;
750 	INTON;
751 }
752 
753 
754 /*
755  * Called after a function returns.
756  */
757 
758 void
759 poplocalvars(void)
760 {
761 	struct localvar *lvp;
762 	struct var *vp;
763 
764 	while ((lvp = localvars) != NULL) {
765 		localvars = lvp->next;
766 		vp = lvp->vp;
767 		if (vp == NULL) {	/* $- saved */
768 			memcpy(optlist, lvp->text, sizeof optlist);
769 			ckfree(lvp->text);
770 			optschanged();
771 		} else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
772 			unsetvar(vp->text);
773 		} else {
774 			if ((vp->flags & VTEXTFIXED) == 0)
775 				ckfree(vp->text);
776 			vp->flags = lvp->flags;
777 			vp->text = lvp->text;
778 		}
779 		ckfree(lvp);
780 	}
781 }
782 
783 
784 int
785 setvarcmd(int argc, char **argv)
786 {
787 	if (argc <= 2)
788 		return unsetcmd(argc, argv);
789 	else if (argc == 3)
790 		setvar(argv[1], argv[2], 0);
791 	else
792 		error("too many arguments");
793 	return 0;
794 }
795 
796 
797 /*
798  * The unset builtin command.
799  */
800 
801 int
802 unsetcmd(int argc __unused, char **argv __unused)
803 {
804 	char **ap;
805 	int i;
806 	int flg_func = 0;
807 	int flg_var = 0;
808 	int ret = 0;
809 
810 	while ((i = nextopt("vf")) != '\0') {
811 		if (i == 'f')
812 			flg_func = 1;
813 		else
814 			flg_var = 1;
815 	}
816 	if (flg_func == 0 && flg_var == 0)
817 		flg_var = 1;
818 
819 	for (ap = argptr; *ap ; ap++) {
820 		if (flg_func)
821 			ret |= unsetfunc(*ap);
822 		if (flg_var)
823 			ret |= unsetvar(*ap);
824 	}
825 	return ret;
826 }
827 
828 
829 /*
830  * Unset the specified variable.
831  */
832 
833 int
834 unsetvar(const char *s)
835 {
836 	struct var **vpp;
837 	struct var *vp;
838 
839 	vpp = hashvar(s);
840 	for (vp = *vpp ; vp ; vpp = &vp->next, vp = *vpp) {
841 		if (varequal(vp->text, s)) {
842 			if (vp->flags & VREADONLY)
843 				return (1);
844 			INTOFF;
845 			if (*(strchr(vp->text, '=') + 1) != '\0')
846 				setvar(s, nullstr, 0);
847 			if ((vp->flags & VEXPORT) && localevar(vp->text)) {
848 				change_env(__DECONST(char *, s), 0);
849 				setlocale(LC_ALL, "");
850 			}
851 			vp->flags &= ~VEXPORT;
852 			vp->flags |= VUNSET;
853 			if ((vp->flags & VSTRFIXED) == 0) {
854 				if ((vp->flags & VTEXTFIXED) == 0)
855 					ckfree(vp->text);
856 				*vpp = vp->next;
857 				ckfree(vp);
858 			}
859 			INTON;
860 			return (0);
861 		}
862 	}
863 	return (0);
864 }
865 
866 
867 
868 /*
869  * Find the appropriate entry in the hash table from the name.
870  */
871 
872 static struct var **
873 hashvar(const char *p)
874 {
875 	unsigned int hashval;
876 
877 	hashval = ((unsigned char) *p) << 4;
878 	while (*p && *p != '=')
879 		hashval += (unsigned char) *p++;
880 	return &vartab[hashval % VTABSIZE];
881 }
882 
883 
884 
885 /*
886  * Returns true if the two strings specify the same varable.  The first
887  * variable name is terminated by '='; the second may be terminated by
888  * either '=' or '\0'.
889  */
890 
891 static int
892 varequal(const char *p, const char *q)
893 {
894 	while (*p == *q++) {
895 		if (*p++ == '=')
896 			return 1;
897 	}
898 	if (*p == '=' && *(q - 1) == '\0')
899 		return 1;
900 	return 0;
901 }
902