var.c revision 293635
159078Smdodd/*- 259078Smdodd * Copyright (c) 1991, 1993 359078Smdodd * The Regents of the University of California. All rights reserved. 432801Sjulian * 559078Smdodd * This code is derived from software contributed to Berkeley by 659078Smdodd * Kenneth Almquist. 759078Smdodd * 832801Sjulian * Redistribution and use in source and binary forms, with or without 932801Sjulian * modification, are permitted provided that the following conditions 1032801Sjulian * are met: 1132801Sjulian * 1. Redistributions of source code must retain the above copyright 1259078Smdodd * notice, this list of conditions and the following disclaimer. 1332801Sjulian * 2. Redistributions in binary form must reproduce the above copyright 1432801Sjulian * notice, this list of conditions and the following disclaimer in the 1532801Sjulian * documentation and/or other materials provided with the distribution. 1632801Sjulian * 4. Neither the name of the University nor the names of its contributors 1732801Sjulian * may be used to endorse or promote products derived from this software 1832801Sjulian * without specific prior written permission. 1932801Sjulian * 2059078Smdodd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 2159078Smdodd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2232801Sjulian * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2332801Sjulian * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 2432801Sjulian * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2532801Sjulian * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2632801Sjulian * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2732801Sjulian * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2832801Sjulian * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2932801Sjulian * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30119418Sobrien * SUCH DAMAGE. 31119418Sobrien */ 32119418Sobrien 3332801Sjulian#ifndef lint 3432801Sjulian#if 0 3532801Sjulianstatic char sccsid[] = "@(#)var.c 8.3 (Berkeley) 5/4/95"; 3659078Smdodd#endif 37117126Sscottl#endif /* not lint */ 38117126Sscottl#include <sys/cdefs.h> 3959078Smdodd__FBSDID("$FreeBSD: head/bin/sh/var.c 293635 2016-01-10 16:31:28Z jilles $"); 4032801Sjulian 4139234Sgibbs#include <unistd.h> 4239234Sgibbs#include <stdlib.h> 4339234Sgibbs#include <paths.h> 4459078Smdodd 4559078Smdodd/* 4639234Sgibbs * Shell variables. 47119277Simp */ 48119277Simp 4959078Smdodd#include <locale.h> 5039234Sgibbs#include <langinfo.h> 5139234Sgibbs 5239234Sgibbs#include "shell.h" 5332801Sjulian#include "output.h" 5459078Smdodd#include "expand.h" 5559078Smdodd#include "nodes.h" /* for other headers */ 5632801Sjulian#include "eval.h" /* defines cmdenviron */ 57119690Sjhb#include "exec.h" 58119690Sjhb#include "syntax.h" 5932801Sjulian#include "options.h" 6059078Smdodd#include "mail.h" 6132801Sjulian#include "var.h" 6259078Smdodd#include "memalloc.h" 6359078Smdodd#include "error.h" 6432801Sjulian#include "mystring.h" 6559078Smdodd#include "parser.h" 6659078Smdodd#include "builtins.h" 6759078Smdodd#ifndef NO_HISTORY 6859078Smdodd#include "myhistedit.h" 6959078Smdodd#endif 7059078Smdodd 7159078Smdodd 7259078Smdodd#define VTABSIZE 39 7359078Smdodd 7459078Smdodd 7532801Sjulianstruct varinit { 7659078Smdodd struct var *var; 7759078Smdodd int flags; 7832801Sjulian const char *text; 7959078Smdodd void (*func)(const char *); 8059078Smdodd}; 8159078Smdodd 8232801Sjulian 8359078Smdodd#ifndef NO_HISTORY 8432801Sjulianstruct var vhistsize; 85112780Smdoddstruct var vterm; 86112780Smdodd#endif 8759078Smdoddstruct var vifs; 8832801Sjulianstruct var vmail; 8959078Smdoddstruct var vmpath; 9059078Smdoddstruct var vpath; 91112780Smdoddstruct var vps1; 92112780Smdoddstruct var vps2; 93112780Smdoddstruct var vps4; 94112780Smdoddstatic struct var voptind; 95112780Smdoddstruct var vdisvfork; 9659078Smdodd 9732801Sjulianstruct localvar *localvars; 98112780Smdoddint forcelocal; 99112780Smdodd 100112780Smdoddstatic const struct varinit varinit[] = { 101112780Smdodd#ifndef NO_HISTORY 102112780Smdodd { &vhistsize, VUNSET, "HISTSIZE=", 103112780Smdodd sethistsize }, 10459078Smdodd#endif 10532801Sjulian { &vifs, 0, "IFS= \t\n", 106112780Smdodd NULL }, 10759078Smdodd { &vmail, VUNSET, "MAIL=", 10859078Smdodd NULL }, 10959078Smdodd { &vmpath, VUNSET, "MAILPATH=", 11059078Smdodd NULL }, 111112780Smdodd { &vpath, 0, "PATH=" _PATH_DEFPATH, 11232801Sjulian changepath }, 113112780Smdodd /* 114112780Smdodd * vps1 depends on uid 115112780Smdodd */ 116112780Smdodd { &vps2, 0, "PS2=> ", 11759078Smdodd NULL }, 11859078Smdodd { &vps4, 0, "PS4=+ ", 11959078Smdodd NULL }, 12059078Smdodd#ifndef NO_HISTORY 12132801Sjulian { &vterm, VUNSET, "TERM=", 12259078Smdodd setterm }, 12359078Smdodd#endif 12459078Smdodd { &voptind, 0, "OPTIND=1", 12532801Sjulian getoptsreset }, 126112780Smdodd { &vdisvfork, VUNSET, "SH_DISABLE_VFORK=", 12732801Sjulian NULL }, 12859078Smdodd { NULL, 0, NULL, 12959078Smdodd NULL } 13032801Sjulian}; 13159078Smdodd 13259078Smdoddstatic struct var *vartab[VTABSIZE]; 13339234Sgibbs 13432801Sjulianstatic const char *const locale_names[7] = { 135112780Smdodd "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", 13632801Sjulian "LC_NUMERIC", "LC_TIME", "LC_MESSAGES", NULL 13739234Sgibbs}; 13839234Sgibbsstatic const int locale_categories[7] = { 13959078Smdodd LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME, LC_MESSAGES, 0 14059078Smdodd}; 14159078Smdodd 14259078Smdoddstatic int varequal(const char *, const char *); 14359078Smdoddstatic struct var *find_var(const char *, struct var ***, int *); 14459078Smdoddstatic int localevar(const char *); 14559078Smdoddstatic void setvareq_const(const char *s, int flags); 14659078Smdodd 147104710Speterextern char **environ; 14859078Smdodd 14959078Smdodd/* 150117126Sscottl * This routine initializes the builtin variables and imports the environment. 151117126Sscottl * It is called when the shell is initialized. 15259078Smdodd */ 15339234Sgibbs 15459078Smdoddvoid 15559078Smdoddinitvar(void) 15639234Sgibbs{ 15732801Sjulian char ppid[20]; 15859078Smdodd const struct varinit *ip; 15932801Sjulian struct var *vp; 16039234Sgibbs struct var **vpp; 16139234Sgibbs char **envp; 16259078Smdodd 16359078Smdodd for (ip = varinit ; (vp = ip->var) != NULL ; ip++) { 16439234Sgibbs if (find_var(ip->text, &vpp, &vp->name_len) != NULL) 16532801Sjulian continue; 16639234Sgibbs vp->next = *vpp; 16739234Sgibbs *vpp = vp; 16859078Smdodd vp->text = __DECONST(char *, ip->text); 16939234Sgibbs vp->flags = ip->flags | VSTRFIXED | VTEXTFIXED; 17059078Smdodd vp->func = ip->func; 171112780Smdodd } 172112780Smdodd /* 17359078Smdodd * PS1 depends on uid 17459078Smdodd */ 17559078Smdodd if (find_var("PS1", &vpp, &vps1.name_len) == NULL) { 17659078Smdodd vps1.next = *vpp; 17759078Smdodd *vpp = &vps1; 17859078Smdodd vps1.text = __DECONST(char *, geteuid() ? "PS1=$ " : "PS1=# "); 17959078Smdodd vps1.flags = VSTRFIXED|VTEXTFIXED; 18059078Smdodd } 181112780Smdodd fmtstr(ppid, sizeof(ppid), "%d", (int)getppid()); 18259078Smdodd setvarsafe("PPID", ppid, 0); 183112780Smdodd for (envp = environ ; *envp ; envp++) { 184112780Smdodd if (strchr(*envp, '=')) { 185112780Smdodd setvareq(*envp, VEXPORT|VTEXTFIXED); 18659078Smdodd } 18732801Sjulian } 18859078Smdodd setvareq_const("OPTIND=1", 0); 18959078Smdodd} 19059078Smdodd 19159078Smdodd/* 19259078Smdodd * Safe version of setvar, returns 1 on success 0 on failure. 193112780Smdodd */ 19459078Smdodd 19559078Smdoddint 19659078Smdoddsetvarsafe(const char *name, const char *val, int flags) 19759078Smdodd{ 19859078Smdodd struct jmploc jmploc; 19959078Smdodd struct jmploc *const savehandler = handler; 20059078Smdodd int err = 0; 20159078Smdodd int inton; 20259078Smdodd 20359078Smdodd inton = is_int_on(); 20459078Smdodd if (setjmp(jmploc.loc)) 205 err = 1; 206 else { 207 handler = &jmploc; 208 setvar(name, val, flags); 209 } 210 handler = savehandler; 211 SETINTON(inton); 212 return err; 213} 214 215/* 216 * Set the value of a variable. The flags argument is stored with the 217 * flags of the variable. If val is NULL, the variable is unset. 218 */ 219 220void 221setvar(const char *name, const char *val, int flags) 222{ 223 const char *p; 224 size_t len; 225 size_t namelen; 226 size_t vallen; 227 char *nameeq; 228 int isbad; 229 230 isbad = 0; 231 p = name; 232 if (! is_name(*p)) 233 isbad = 1; 234 p++; 235 for (;;) { 236 if (! is_in_name(*p)) { 237 if (*p == '\0' || *p == '=') 238 break; 239 isbad = 1; 240 } 241 p++; 242 } 243 namelen = p - name; 244 if (isbad) 245 error("%.*s: bad variable name", (int)namelen, name); 246 len = namelen + 2; /* 2 is space for '=' and '\0' */ 247 if (val == NULL) { 248 flags |= VUNSET; 249 vallen = 0; 250 } else { 251 vallen = strlen(val); 252 len += vallen; 253 } 254 INTOFF; 255 nameeq = ckmalloc(len); 256 memcpy(nameeq, name, namelen); 257 nameeq[namelen] = '='; 258 if (val) 259 memcpy(nameeq + namelen + 1, val, vallen + 1); 260 else 261 nameeq[namelen + 1] = '\0'; 262 setvareq(nameeq, flags); 263 INTON; 264} 265 266static int 267localevar(const char *s) 268{ 269 const char *const *ss; 270 271 if (*s != 'L') 272 return 0; 273 if (varequal(s + 1, "ANG")) 274 return 1; 275 if (strncmp(s + 1, "C_", 2) != 0) 276 return 0; 277 if (varequal(s + 3, "ALL")) 278 return 1; 279 for (ss = locale_names; *ss ; ss++) 280 if (varequal(s + 3, *ss + 3)) 281 return 1; 282 return 0; 283} 284 285 286/* 287 * Sets/unsets an environment variable from a pointer that may actually be a 288 * pointer into environ where the string should not be manipulated. 289 */ 290static void 291change_env(const char *s, int set) 292{ 293 char *eqp; 294 char *ss; 295 296 INTOFF; 297 ss = savestr(s); 298 if ((eqp = strchr(ss, '=')) != NULL) 299 *eqp = '\0'; 300 if (set && eqp != NULL) 301 (void) setenv(ss, eqp + 1, 1); 302 else 303 (void) unsetenv(ss); 304 ckfree(ss); 305 INTON; 306 307 return; 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 318void 319setvareq(char *s, int flags) 320{ 321 struct var *vp, **vpp; 322 int nlen; 323 324 if (aflag) 325 flags |= VEXPORT; 326 if (forcelocal && !(flags & (VNOSET | VNOLOCAL))) 327 mklocal(s); 328 vp = find_var(s, &vpp, &nlen); 329 if (vp != NULL) { 330 if (vp->flags & VREADONLY) { 331 if ((flags & (VTEXTFIXED|VSTACK)) == 0) 332 ckfree(s); 333 error("%.*s: is read only", vp->name_len, vp->text); 334 } 335 if (flags & VNOSET) { 336 if ((flags & (VTEXTFIXED|VSTACK)) == 0) 337 ckfree(s); 338 return; 339 } 340 INTOFF; 341 342 if (vp->func && (flags & VNOFUNC) == 0) 343 (*vp->func)(s + vp->name_len + 1); 344 345 if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0) 346 ckfree(vp->text); 347 348 vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET); 349 vp->flags |= flags; 350 vp->text = s; 351 352 /* 353 * We could roll this to a function, to handle it as 354 * a regular variable function callback, but why bother? 355 * 356 * Note: this assumes iflag is not set to 1 initially. 357 * As part of initvar(), this is called before arguments 358 * are looked at. 359 */ 360 if ((vp == &vmpath || (vp == &vmail && ! mpathset())) && 361 iflag == 1) 362 chkmail(1); 363 if ((vp->flags & VEXPORT) && localevar(s)) { 364 change_env(s, 1); 365 (void) setlocale(LC_ALL, ""); 366 updatecharset(); 367 } 368 INTON; 369 return; 370 } 371 /* not found */ 372 if (flags & VNOSET) { 373 if ((flags & (VTEXTFIXED|VSTACK)) == 0) 374 ckfree(s); 375 return; 376 } 377 INTOFF; 378 vp = ckmalloc(sizeof (*vp)); 379 vp->flags = flags; 380 vp->text = s; 381 vp->name_len = nlen; 382 vp->next = *vpp; 383 vp->func = NULL; 384 *vpp = vp; 385 if ((vp->flags & VEXPORT) && localevar(s)) { 386 change_env(s, 1); 387 (void) setlocale(LC_ALL, ""); 388 updatecharset(); 389 } 390 INTON; 391} 392 393 394static void 395setvareq_const(const char *s, int flags) 396{ 397 setvareq(__DECONST(char *, s), flags | VTEXTFIXED); 398} 399 400 401/* 402 * Process a linked list of variable assignments. 403 */ 404 405void 406listsetvar(struct arglist *list, int flags) 407{ 408 int i; 409 410 INTOFF; 411 for (i = 0; i < list->count; i++) 412 setvareq(savestr(list->args[i]), flags); 413 INTON; 414} 415 416 417 418/* 419 * Find the value of a variable. Returns NULL if not set. 420 */ 421 422char * 423lookupvar(const char *name) 424{ 425 struct var *v; 426 427 v = find_var(name, NULL, NULL); 428 if (v == NULL || v->flags & VUNSET) 429 return NULL; 430 return v->text + v->name_len + 1; 431} 432 433 434 435/* 436 * Search the environment of a builtin command. If the second argument 437 * is nonzero, return the value of a variable even if it hasn't been 438 * exported. 439 */ 440 441char * 442bltinlookup(const char *name, int doall) 443{ 444 struct var *v; 445 char *result; 446 int i; 447 448 result = NULL; 449 if (cmdenviron) for (i = 0; i < cmdenviron->count; i++) { 450 if (varequal(cmdenviron->args[i], name)) 451 result = strchr(cmdenviron->args[i], '=') + 1; 452 } 453 if (result != NULL) 454 return result; 455 456 v = find_var(name, NULL, NULL); 457 if (v == NULL || v->flags & VUNSET || 458 (!doall && (v->flags & VEXPORT) == 0)) 459 return NULL; 460 return v->text + v->name_len + 1; 461} 462 463 464/* 465 * Set up locale for a builtin (LANG/LC_* assignments). 466 */ 467void 468bltinsetlocale(void) 469{ 470 int act = 0; 471 char *loc, *locdef; 472 int i; 473 474 if (cmdenviron) for (i = 0; i < cmdenviron->count; i++) { 475 if (localevar(cmdenviron->args[i])) { 476 act = 1; 477 break; 478 } 479 } 480 if (!act) 481 return; 482 loc = bltinlookup("LC_ALL", 0); 483 INTOFF; 484 if (loc != NULL) { 485 setlocale(LC_ALL, loc); 486 INTON; 487 updatecharset(); 488 return; 489 } 490 locdef = bltinlookup("LANG", 0); 491 for (i = 0; locale_names[i] != NULL; i++) { 492 loc = bltinlookup(locale_names[i], 0); 493 if (loc == NULL) 494 loc = locdef; 495 if (loc != NULL) 496 setlocale(locale_categories[i], loc); 497 } 498 INTON; 499 updatecharset(); 500} 501 502/* 503 * Undo the effect of bltinlocaleset(). 504 */ 505void 506bltinunsetlocale(void) 507{ 508 int i; 509 510 INTOFF; 511 if (cmdenviron) for (i = 0; i < cmdenviron->count; i++) { 512 if (localevar(cmdenviron->args[i])) { 513 setlocale(LC_ALL, ""); 514 updatecharset(); 515 return; 516 } 517 } 518 INTON; 519} 520 521/* 522 * Update the localeisutf8 flag. 523 */ 524void 525updatecharset(void) 526{ 527 char *charset; 528 529 charset = nl_langinfo(CODESET); 530 localeisutf8 = !strcmp(charset, "UTF-8"); 531} 532 533void 534initcharset(void) 535{ 536 updatecharset(); 537 initial_localeisutf8 = localeisutf8; 538} 539 540/* 541 * Generate a list of exported variables. This routine is used to construct 542 * the third argument to execve when executing a program. 543 */ 544 545char ** 546environment(void) 547{ 548 int nenv; 549 struct var **vpp; 550 struct var *vp; 551 char **env, **ep; 552 553 nenv = 0; 554 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) { 555 for (vp = *vpp ; vp ; vp = vp->next) 556 if (vp->flags & VEXPORT) 557 nenv++; 558 } 559 ep = env = stalloc((nenv + 1) * sizeof *env); 560 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) { 561 for (vp = *vpp ; vp ; vp = vp->next) 562 if (vp->flags & VEXPORT) 563 *ep++ = vp->text; 564 } 565 *ep = NULL; 566 return env; 567} 568 569 570static int 571var_compare(const void *a, const void *b) 572{ 573 const char *const *sa, *const *sb; 574 575 sa = a; 576 sb = b; 577 /* 578 * This compares two var=value strings which creates a different 579 * order from what you would probably expect. POSIX is somewhat 580 * ambiguous on what should be sorted exactly. 581 */ 582 return strcoll(*sa, *sb); 583} 584 585 586/* 587 * Command to list all variables which are set. This is invoked from the 588 * set command when it is called without any options or operands. 589 */ 590 591int 592showvarscmd(int argc __unused, char **argv __unused) 593{ 594 struct var **vpp; 595 struct var *vp; 596 const char *s; 597 const char **vars; 598 int i, n; 599 600 /* 601 * POSIX requires us to sort the variables. 602 */ 603 n = 0; 604 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) { 605 for (vp = *vpp; vp; vp = vp->next) { 606 if (!(vp->flags & VUNSET)) 607 n++; 608 } 609 } 610 611 INTOFF; 612 vars = ckmalloc(n * sizeof(*vars)); 613 i = 0; 614 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) { 615 for (vp = *vpp; vp; vp = vp->next) { 616 if (!(vp->flags & VUNSET)) 617 vars[i++] = vp->text; 618 } 619 } 620 621 qsort(vars, n, sizeof(*vars), var_compare); 622 for (i = 0; i < n; i++) { 623 /* 624 * Skip improper variable names so the output remains usable as 625 * shell input. 626 */ 627 if (!isassignment(vars[i])) 628 continue; 629 s = strchr(vars[i], '='); 630 s++; 631 outbin(vars[i], s - vars[i], out1); 632 out1qstr(s); 633 out1c('\n'); 634 } 635 ckfree(vars); 636 INTON; 637 638 return 0; 639} 640 641 642 643/* 644 * The export and readonly commands. 645 */ 646 647int 648exportcmd(int argc __unused, char **argv) 649{ 650 struct var **vpp; 651 struct var *vp; 652 char **ap; 653 char *name; 654 char *p; 655 char *cmdname; 656 int ch, values; 657 int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT; 658 659 cmdname = argv[0]; 660 values = 0; 661 while ((ch = nextopt("p")) != '\0') { 662 switch (ch) { 663 case 'p': 664 values = 1; 665 break; 666 } 667 } 668 669 if (values && *argptr != NULL) 670 error("-p requires no arguments"); 671 if (*argptr != NULL) { 672 for (ap = argptr; (name = *ap) != NULL; ap++) { 673 if ((p = strchr(name, '=')) != NULL) { 674 p++; 675 } else { 676 vp = find_var(name, NULL, NULL); 677 if (vp != NULL) { 678 vp->flags |= flag; 679 if ((vp->flags & VEXPORT) && localevar(vp->text)) { 680 change_env(vp->text, 1); 681 (void) setlocale(LC_ALL, ""); 682 updatecharset(); 683 } 684 continue; 685 } 686 } 687 setvar(name, p, flag); 688 } 689 } else { 690 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) { 691 for (vp = *vpp ; vp ; vp = vp->next) { 692 if (vp->flags & flag) { 693 if (values) { 694 /* 695 * Skip improper variable names 696 * so the output remains usable 697 * as shell input. 698 */ 699 if (!isassignment(vp->text)) 700 continue; 701 out1str(cmdname); 702 out1c(' '); 703 } 704 if (values && !(vp->flags & VUNSET)) { 705 outbin(vp->text, 706 vp->name_len + 1, out1); 707 out1qstr(vp->text + 708 vp->name_len + 1); 709 } else 710 outbin(vp->text, vp->name_len, 711 out1); 712 out1c('\n'); 713 } 714 } 715 } 716 } 717 return 0; 718} 719 720 721/* 722 * The "local" command. 723 */ 724 725int 726localcmd(int argc __unused, char **argv __unused) 727{ 728 char *name; 729 730 nextopt(""); 731 if (! in_function()) 732 error("Not in a function"); 733 while ((name = *argptr++) != NULL) { 734 mklocal(name); 735 } 736 return 0; 737} 738 739 740/* 741 * Make a variable a local variable. When a variable is made local, it's 742 * value and flags are saved in a localvar structure. The saved values 743 * will be restored when the shell function returns. We handle the name 744 * "-" as a special case. 745 */ 746 747void 748mklocal(char *name) 749{ 750 struct localvar *lvp; 751 struct var **vpp; 752 struct var *vp; 753 754 INTOFF; 755 lvp = ckmalloc(sizeof (struct localvar)); 756 if (name[0] == '-' && name[1] == '\0') { 757 lvp->text = ckmalloc(sizeof optval); 758 memcpy(lvp->text, optval, sizeof optval); 759 vp = NULL; 760 } else { 761 vp = find_var(name, &vpp, NULL); 762 if (vp == NULL) { 763 if (strchr(name, '=')) 764 setvareq(savestr(name), VSTRFIXED | VNOLOCAL); 765 else 766 setvar(name, NULL, VSTRFIXED | VNOLOCAL); 767 vp = *vpp; /* the new variable */ 768 lvp->text = NULL; 769 lvp->flags = VUNSET; 770 } else { 771 lvp->text = vp->text; 772 lvp->flags = vp->flags; 773 vp->flags |= VSTRFIXED|VTEXTFIXED; 774 if (name[vp->name_len] == '=') 775 setvareq(savestr(name), VNOLOCAL); 776 } 777 } 778 lvp->vp = vp; 779 lvp->next = localvars; 780 localvars = lvp; 781 INTON; 782} 783 784 785/* 786 * Called after a function returns. 787 */ 788 789void 790poplocalvars(void) 791{ 792 struct localvar *lvp; 793 struct var *vp; 794 int islocalevar; 795 796 INTOFF; 797 while ((lvp = localvars) != NULL) { 798 localvars = lvp->next; 799 vp = lvp->vp; 800 if (vp == NULL) { /* $- saved */ 801 memcpy(optval, lvp->text, sizeof optval); 802 ckfree(lvp->text); 803 optschanged(); 804 } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) { 805 (void)unsetvar(vp->text); 806 } else { 807 islocalevar = (vp->flags | lvp->flags) & VEXPORT && 808 localevar(lvp->text); 809 if ((vp->flags & VTEXTFIXED) == 0) 810 ckfree(vp->text); 811 vp->flags = lvp->flags; 812 vp->text = lvp->text; 813 if (vp->func) 814 (*vp->func)(vp->text + vp->name_len + 1); 815 if (islocalevar) { 816 change_env(vp->text, vp->flags & VEXPORT && 817 (vp->flags & VUNSET) == 0); 818 setlocale(LC_ALL, ""); 819 updatecharset(); 820 } 821 } 822 ckfree(lvp); 823 } 824 INTON; 825} 826 827 828int 829setvarcmd(int argc, char **argv) 830{ 831 if (argc <= 2) 832 return unsetcmd(argc, argv); 833 else if (argc == 3) 834 setvar(argv[1], argv[2], 0); 835 else 836 error("too many arguments"); 837 return 0; 838} 839 840 841/* 842 * The unset builtin command. 843 */ 844 845int 846unsetcmd(int argc __unused, char **argv __unused) 847{ 848 char **ap; 849 int i; 850 int flg_func = 0; 851 int flg_var = 0; 852 int ret = 0; 853 854 while ((i = nextopt("vf")) != '\0') { 855 if (i == 'f') 856 flg_func = 1; 857 else 858 flg_var = 1; 859 } 860 if (flg_func == 0 && flg_var == 0) 861 flg_var = 1; 862 863 INTOFF; 864 for (ap = argptr; *ap ; ap++) { 865 if (flg_func) 866 ret |= unsetfunc(*ap); 867 if (flg_var) 868 ret |= unsetvar(*ap); 869 } 870 INTON; 871 return ret; 872} 873 874 875/* 876 * Unset the specified variable. 877 * Called with interrupts off. 878 */ 879 880int 881unsetvar(const char *s) 882{ 883 struct var **vpp; 884 struct var *vp; 885 886 vp = find_var(s, &vpp, NULL); 887 if (vp == NULL) 888 return (0); 889 if (vp->flags & VREADONLY) 890 return (1); 891 if (vp->text[vp->name_len + 1] != '\0') 892 setvar(s, "", 0); 893 if ((vp->flags & VEXPORT) && localevar(vp->text)) { 894 change_env(s, 0); 895 setlocale(LC_ALL, ""); 896 updatecharset(); 897 } 898 vp->flags &= ~VEXPORT; 899 vp->flags |= VUNSET; 900 if ((vp->flags & VSTRFIXED) == 0) { 901 if ((vp->flags & VTEXTFIXED) == 0) 902 ckfree(vp->text); 903 *vpp = vp->next; 904 ckfree(vp); 905 } 906 return (0); 907} 908 909 910 911/* 912 * Returns true if the two strings specify the same variable. The first 913 * variable name is terminated by '='; the second may be terminated by 914 * either '=' or '\0'. 915 */ 916 917static int 918varequal(const char *p, const char *q) 919{ 920 while (*p == *q++) { 921 if (*p++ == '=') 922 return 1; 923 } 924 if (*p == '=' && *(q - 1) == '\0') 925 return 1; 926 return 0; 927} 928 929/* 930 * Search for a variable. 931 * 'name' may be terminated by '=' or a NUL. 932 * vppp is set to the pointer to vp, or the list head if vp isn't found 933 * lenp is set to the number of characters in 'name' 934 */ 935 936static struct var * 937find_var(const char *name, struct var ***vppp, int *lenp) 938{ 939 unsigned int hashval; 940 int len; 941 struct var *vp, **vpp; 942 const char *p = name; 943 944 hashval = 0; 945 while (*p && *p != '=') 946 hashval = 2 * hashval + (unsigned char)*p++; 947 len = p - name; 948 949 if (lenp) 950 *lenp = len; 951 vpp = &vartab[hashval % VTABSIZE]; 952 if (vppp) 953 *vppp = vpp; 954 955 for (vp = *vpp ; vp ; vpp = &vp->next, vp = *vpp) { 956 if (vp->name_len != len) 957 continue; 958 if (memcmp(vp->text, name, len) != 0) 959 continue; 960 if (vppp) 961 *vppp = vpp; 962 return vp; 963 } 964 return NULL; 965} 966