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