sh/var.c

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