• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*	$OpenBSD: c_ksh.c,v 1.33 2009/02/07 14:03:24 kili Exp $	*/
2 /*	$OpenBSD: c_sh.c,v 1.41 2010/03/27 09:10:01 jmc Exp $	*/
3 /*	$OpenBSD: c_test.c,v 1.18 2009/03/01 20:11:06 otto Exp $	*/
4 /*	$OpenBSD: c_ulimit.c,v 1.17 2008/03/21 12:51:19 millert Exp $	*/
5 
6 /*-
7  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
8  *		 2010, 2011
9  *	Thorsten Glaser <tg@mirbsd.org>
10  *
11  * Provided that these terms and disclaimer and all copyright notices
12  * are retained or reproduced in an accompanying document, permission
13  * is granted to deal in this work without restriction, including un-
14  * limited rights to use, publicly perform, distribute, sell, modify,
15  * merge, give away, or sublicence.
16  *
17  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
18  * the utmost extent permitted by applicable law, neither express nor
19  * implied; without malicious intent or gross negligence. In no event
20  * may a licensor, author or contributor be held liable for indirect,
21  * direct, other damage, loss, or other issues arising in any way out
22  * of dealing in the work, even if advised of the possibility of such
23  * damage or existence of a defect, except proven that it results out
24  * of said person's immediate fault when using the work as intended.
25  */
26 
27 #include "sh.h"
28 
29 #if HAVE_SELECT
30 #if HAVE_SYS_BSDTYPES_H
31 #include <sys/bsdtypes.h>
32 #endif
33 #if HAVE_SYS_SELECT_H
34 #include <sys/select.h>
35 #endif
36 #if HAVE_BSTRING_H
37 #include <bstring.h>
38 #endif
39 #endif
40 
41 __RCSID("$MirOS: src/bin/mksh/funcs.c,v 1.197 2011/09/07 15:24:15 tg Exp $");
42 
43 #if HAVE_KILLPG
44 /*
45  * use killpg if < -1 since -1 does special things
46  * for some non-killpg-endowed kills
47  */
48 #define mksh_kill(p,s)	((p) < -1 ? killpg(-(p), (s)) : kill((p), (s)))
49 #else
50 /* cross fingers and hope kill is killpg-endowed */
51 #define mksh_kill	kill
52 #endif
53 
54 /* XXX conditions correct? */
55 #if !defined(RLIM_INFINITY) && !defined(MKSH_NO_LIMITS)
56 #define MKSH_NO_LIMITS	1
57 #endif
58 
59 #ifdef MKSH_NO_LIMITS
60 #define c_ulimit	c_true
61 #endif
62 
63 #if defined(ANDROID)
64 static int c_android_lsmod(const char **);
65 #endif
66 
67 static int
c_true(const char ** wp MKSH_A_UNUSED)68 c_true(const char **wp MKSH_A_UNUSED)
69 {
70 	return (0);
71 }
72 
73 static int
c_false(const char ** wp MKSH_A_UNUSED)74 c_false(const char **wp MKSH_A_UNUSED)
75 {
76 	return (1);
77 }
78 
79 /*
80  * A leading = means assignments before command are kept;
81  * a leading * means a POSIX special builtin;
82  * a leading + means a POSIX regular builtin
83  * (* and + should not be combined).
84  */
85 const struct builtin mkshbuiltins[] = {
86 	{"*=.", c_dot},
87 	{"*=:", c_true},
88 	{"[", c_test},
89 	{"*=break", c_brkcont},
90 	{Tgbuiltin, c_builtin},
91 	{"*=continue", c_brkcont},
92 	{"*=eval", c_eval},
93 	{"*=exec", c_exec},
94 	{"*=exit", c_exitreturn},
95 	{"+false", c_false},
96 	{"*=return", c_exitreturn},
97 	{Tsgset, c_set},
98 	{"*=shift", c_shift},
99 	{"=times", c_times},
100 	{"*=trap", c_trap},
101 	{"+=wait", c_wait},
102 	{"+read", c_read},
103 	{"test", c_test},
104 	{"+true", c_true},
105 	{"ulimit", c_ulimit},
106 	{"+umask", c_umask},
107 	{"*=unset", c_unset},
108 	/* no =: AT&T manual wrong */
109 	{Tpalias, c_alias},
110 	{"+cd", c_cd},
111 	/* dash compatibility hack */
112 	{"chdir", c_cd},
113 	{"+command", c_command},
114 	{"echo", c_print},
115 	{"*=export", c_typeset},
116 	{"+fc", c_fc},
117 	{"+getopts", c_getopts},
118 	{"=global", c_typeset},
119 	{"+jobs", c_jobs},
120 	{"+kill", c_kill},
121 	{"let", c_let},
122 	{"print", c_print},
123 #ifdef MKSH_PRINTF_BUILTIN
124 	{"printf", c_printf},
125 #endif
126 	{"pwd", c_pwd},
127 	{"*=readonly", c_typeset},
128 	{T_typeset, c_typeset},
129 	{Tpunalias, c_unalias},
130 	{"whence", c_whence},
131 #ifndef MKSH_UNEMPLOYED
132 	{"+bg", c_fgbg},
133 	{"+fg", c_fgbg},
134 #endif
135 	{"bind", c_bind},
136 	{"cat", c_cat},
137 #if HAVE_MKNOD
138 	{"mknod", c_mknod},
139 #endif
140 	{"realpath", c_realpath},
141 	{"rename", c_rename},
142 #if HAVE_SELECT
143 	{"sleep", c_sleep},
144 #endif
145 #ifdef __MirBSD__
146 	/* alias to "true" for historical reasons */
147 	{"domainname", c_true},
148 #endif
149 #if defined(ANDROID)
150 	{"lsmod", c_android_lsmod},
151 #endif
152 	{NULL, (int (*)(const char **))NULL}
153 };
154 
155 struct kill_info {
156 	int num_width;
157 	int name_width;
158 };
159 
160 static const struct t_op {
161 	char op_text[4];
162 	Test_op op_num;
163 } u_ops[] = {
164 	{"-a",	TO_FILAXST },
165 	{"-b",	TO_FILBDEV },
166 	{"-c",	TO_FILCDEV },
167 	{"-d",	TO_FILID },
168 	{"-e",	TO_FILEXST },
169 	{"-f",	TO_FILREG },
170 	{"-G",	TO_FILGID },
171 	{"-g",	TO_FILSETG },
172 	{"-h",	TO_FILSYM },
173 	{"-H",	TO_FILCDF },
174 	{"-k",	TO_FILSTCK },
175 	{"-L",	TO_FILSYM },
176 	{"-n",	TO_STNZE },
177 	{"-O",	TO_FILUID },
178 	{"-o",	TO_OPTION },
179 	{"-p",	TO_FILFIFO },
180 	{"-r",	TO_FILRD },
181 	{"-s",	TO_FILGZ },
182 	{"-S",	TO_FILSOCK },
183 	{"-t",	TO_FILTT },
184 	{"-u",	TO_FILSETU },
185 	{"-w",	TO_FILWR },
186 	{"-x",	TO_FILEX },
187 	{"-z",	TO_STZER },
188 	{"",	TO_NONOP }
189 };
190 static const struct t_op b_ops[] = {
191 	{"=",	TO_STEQL },
192 	{"==",	TO_STEQL },
193 	{"!=",	TO_STNEQ },
194 	{"<",	TO_STLT },
195 	{">",	TO_STGT },
196 	{"-eq",	TO_INTEQ },
197 	{"-ne",	TO_INTNE },
198 	{"-gt",	TO_INTGT },
199 	{"-ge",	TO_INTGE },
200 	{"-lt",	TO_INTLT },
201 	{"-le",	TO_INTLE },
202 	{"-ef",	TO_FILEQ },
203 	{"-nt",	TO_FILNT },
204 	{"-ot",	TO_FILOT },
205 	{"",	TO_NONOP }
206 };
207 
208 static int test_oexpr(Test_env *, bool);
209 static int test_aexpr(Test_env *, bool);
210 static int test_nexpr(Test_env *, bool);
211 static int test_primary(Test_env *, bool);
212 static Test_op ptest_isa(Test_env *, Test_meta);
213 static const char *ptest_getopnd(Test_env *, Test_op, bool);
214 static void ptest_error(Test_env *, int, const char *);
215 static char *kill_fmt_entry(char *, size_t, int, const void *);
216 static void p_time(struct shf *, bool, long, int, int,
217     const char *, const char *)
218     MKSH_A_NONNULL((__nonnull__ (6, 7)));
219 
220 int
c_pwd(const char ** wp)221 c_pwd(const char **wp)
222 {
223 	int optc;
224 	bool physical = tobool(Flag(FPHYSICAL));
225 	char *p, *allocd = NULL;
226 
227 	while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != -1)
228 		switch (optc) {
229 		case 'L':
230 			physical = false;
231 			break;
232 		case 'P':
233 			physical = true;
234 			break;
235 		case '?':
236 			return (1);
237 		}
238 	wp += builtin_opt.optind;
239 
240 	if (wp[0]) {
241 		bi_errorf("too many arguments");
242 		return (1);
243 	}
244 	p = current_wd[0] ? (physical ? allocd = do_realpath(current_wd) :
245 	    current_wd) : NULL;
246 	/* LINTED use of access */
247 	if (p && access(p, R_OK) < 0)
248 		p = NULL;
249 	if (!p && !(p = allocd = ksh_get_wd())) {
250 		bi_errorf("%s: %s", "can't determine current directory",
251 		    strerror(errno));
252 		return (1);
253 	}
254 	shprintf("%s\n", p);
255 	afree(allocd, ATEMP);
256 	return (0);
257 }
258 
259 static const char *s_ptr;
260 static int s_get(void);
261 static void s_put(int);
262 
263 int
c_print(const char ** wp)264 c_print(const char **wp)
265 {
266 #define PO_NL		BIT(0)	/* print newline */
267 #define PO_EXPAND	BIT(1)	/* expand backslash sequences */
268 #define PO_PMINUSMINUS	BIT(2)	/* print a -- argument */
269 #define PO_HIST		BIT(3)	/* print to history instead of stdout */
270 #define PO_COPROC	BIT(4)	/* printing to coprocess: block SIGPIPE */
271 	int fd = 1, c;
272 	int flags = PO_EXPAND|PO_NL;
273 	const char *s, *emsg;
274 	XString xs;
275 	char *xp;
276 
277 	if (wp[0][0] == 'e') {
278 		/* echo builtin */
279 		wp++;
280 		if (Flag(FPOSIX) || Flag(FSH) || Flag(FAS_BUILTIN)) {
281 			/* Debian Policy 10.4 compliant "echo" builtin */
282 			if (*wp && !strcmp(*wp, "-n")) {
283 				/* we recognise "-n" only as the first arg */
284 				flags = 0;
285 				wp++;
286 			} else
287 				/* otherwise, we print everything as-is */
288 				flags = PO_NL;
289 		} else {
290 			int nflags = flags;
291 
292 			/**
293 			 * a compromise between sysV and BSD echo commands:
294 			 * escape sequences are enabled by default, and -n,
295 			 * -e and -E are recognised if they appear in argu-
296 			 * ments with no illegal options (ie, echo -nq will
297 			 * print -nq).
298 			 * Different from sysV echo since options are reco-
299 			 * gnised, different from BSD echo since escape se-
300 			 * quences are enabled by default.
301 			 */
302 
303 			while ((s = *wp) && *s == '-' && s[1]) {
304 				while (*++s)
305 					if (*s == 'n')
306 						nflags &= ~PO_NL;
307 					else if (*s == 'e')
308 						nflags |= PO_EXPAND;
309 					else if (*s == 'E')
310 						nflags &= ~PO_EXPAND;
311 					else
312 						/*
313 						 * bad option: don't use
314 						 * nflags, print argument
315 						 */
316 						break;
317 
318 				if (*s)
319 					break;
320 				wp++;
321 				flags = nflags;
322 			}
323 		}
324 	} else {
325 		int optc;
326 		const char *opts = "Rnprsu,";
327 
328 		while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1)
329 			switch (optc) {
330 			case 'R':
331 				/* fake BSD echo command */
332 				flags |= PO_PMINUSMINUS;
333 				flags &= ~PO_EXPAND;
334 				opts = "ne";
335 				break;
336 			case 'e':
337 				flags |= PO_EXPAND;
338 				break;
339 			case 'n':
340 				flags &= ~PO_NL;
341 				break;
342 			case 'p':
343 				if ((fd = coproc_getfd(W_OK, &emsg)) < 0) {
344 					bi_errorf("%s: %s", "-p", emsg);
345 					return (1);
346 				}
347 				break;
348 			case 'r':
349 				flags &= ~PO_EXPAND;
350 				break;
351 			case 's':
352 				flags |= PO_HIST;
353 				break;
354 			case 'u':
355 				if (!*(s = builtin_opt.optarg))
356 					fd = 0;
357 				else if ((fd = check_fd(s, W_OK, &emsg)) < 0) {
358 					bi_errorf("%s: %s: %s", "-u", s, emsg);
359 					return (1);
360 				}
361 				break;
362 			case '?':
363 				return (1);
364 			}
365 
366 		if (!(builtin_opt.info & GI_MINUSMINUS)) {
367 			/* treat a lone - like -- */
368 			if (wp[builtin_opt.optind] &&
369 			    ksh_isdash(wp[builtin_opt.optind]))
370 				builtin_opt.optind++;
371 		} else if (flags & PO_PMINUSMINUS)
372 			builtin_opt.optind--;
373 		wp += builtin_opt.optind;
374 	}
375 
376 	Xinit(xs, xp, 128, ATEMP);
377 
378 	while (*wp != NULL) {
379 		s = *wp;
380 		while ((c = *s++) != '\0') {
381 			Xcheck(xs, xp);
382 			if ((flags & PO_EXPAND) && c == '\\') {
383 				s_ptr = s;
384 				c = unbksl(false, s_get, s_put);
385 				s = s_ptr;
386 				if (c == -1) {
387 					/* rejected by generic function */
388 					switch ((c = *s++)) {
389 					case 'c':
390 						flags &= ~PO_NL;
391 						/* AT&T brain damage */
392 						continue;
393 					case '\0':
394 						s--;
395 						c = '\\';
396 						break;
397 					default:
398 						Xput(xs, xp, '\\');
399 					}
400 				} else if ((unsigned int)c > 0xFF) {
401 					/* generic function returned Unicode */
402 					char ts[4];
403 
404 					ts[utf_wctomb(ts, c - 0x100)] = 0;
405 					for (c = 0; ts[c]; ++c)
406 						Xput(xs, xp, ts[c]);
407 					continue;
408 				}
409 			}
410 			Xput(xs, xp, c);
411 		}
412 		if (*++wp != NULL)
413 			Xput(xs, xp, ' ');
414 	}
415 	if (flags & PO_NL)
416 		Xput(xs, xp, '\n');
417 
418 	if (flags & PO_HIST) {
419 		Xput(xs, xp, '\0');
420 		histsave(&source->line, Xstring(xs, xp), true, false);
421 		Xfree(xs, xp);
422 	} else {
423 		int len = Xlength(xs, xp);
424 		int opipe = 0;
425 
426 		/*
427 		 * Ensure we aren't killed by a SIGPIPE while writing to
428 		 * a coprocess. AT&T ksh doesn't seem to do this (seems
429 		 * to just check that the co-process is alive which is
430 		 * not enough).
431 		 */
432 		if (coproc.write >= 0 && coproc.write == fd) {
433 			flags |= PO_COPROC;
434 			opipe = block_pipe();
435 		}
436 		for (s = Xstring(xs, xp); len > 0; ) {
437 			if ((c = write(fd, s, len)) < 0) {
438 				if (flags & PO_COPROC)
439 					restore_pipe(opipe);
440 				if (errno == EINTR) {
441 					/* allow user to ^C out */
442 					intrcheck();
443 					if (flags & PO_COPROC)
444 						opipe = block_pipe();
445 					continue;
446 				}
447 				return (1);
448 			}
449 			s += c;
450 			len -= c;
451 		}
452 		if (flags & PO_COPROC)
453 			restore_pipe(opipe);
454 	}
455 
456 	return (0);
457 }
458 
459 static int
s_get(void)460 s_get(void)
461 {
462 	return (*s_ptr++);
463 }
464 
465 static void
s_put(int c MKSH_A_UNUSED)466 s_put(int c MKSH_A_UNUSED)
467 {
468 	--s_ptr;
469 }
470 
471 int
c_whence(const char ** wp)472 c_whence(const char **wp)
473 {
474 	struct tbl *tp;
475 	const char *id;
476 	bool pflag = false, vflag = false, Vflag = false;
477 	int rv = 0, optc, fcflags;
478 	bool iam_whence = wp[0][0] == 'w';
479 	const char *opts = iam_whence ? "pv" : "pvV";
480 
481 	while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1)
482 		switch (optc) {
483 		case 'p':
484 			pflag = true;
485 			break;
486 		case 'v':
487 			vflag = true;
488 			break;
489 		case 'V':
490 			Vflag = true;
491 			break;
492 		case '?':
493 			return (1);
494 		}
495 	wp += builtin_opt.optind;
496 
497 	fcflags = FC_BI | FC_PATH | FC_FUNC;
498 	if (!iam_whence) {
499 		/* Note that -p on its own is deal with in comexec() */
500 		if (pflag)
501 			fcflags |= FC_DEFPATH;
502 		/*
503 		 * Convert command options to whence options - note that
504 		 * command -pV uses a different path search than whence -v
505 		 * or whence -pv. This should be considered a feature.
506 		 */
507 		vflag = Vflag;
508 	}
509 	if (pflag)
510 		fcflags &= ~(FC_BI | FC_FUNC);
511 
512 	while ((vflag || rv == 0) && (id = *wp++) != NULL) {
513 		uint32_t h = 0;
514 
515 		tp = NULL;
516 		if ((iam_whence || vflag) && !pflag)
517 			tp = ktsearch(&keywords, id, h = hash(id));
518 		if (!tp && !pflag) {
519 			tp = ktsearch(&aliases, id, h ? h : hash(id));
520 			if (tp && !(tp->flag & ISSET))
521 				tp = NULL;
522 		}
523 		if (!tp)
524 			tp = findcom(id, fcflags);
525 		if (vflag || (tp->type != CALIAS && tp->type != CEXEC &&
526 		    tp->type != CTALIAS))
527 			shf_puts(id, shl_stdout);
528 		if (vflag)
529 			switch (tp->type) {
530 			case CKEYWD:
531 			case CALIAS:
532 			case CFUNC:
533 			case CSHELL:
534 				shf_puts(" is a", shl_stdout);
535 				break;
536 			}
537 
538 		switch (tp->type) {
539 		case CKEYWD:
540 			if (vflag)
541 				shf_puts(" reserved word", shl_stdout);
542 			break;
543 		case CALIAS:
544 			if (vflag)
545 				shprintf("n %s%s for ",
546 				    (tp->flag & EXPORT) ? "exported " : null,
547 				    Talias);
548 			if (!iam_whence && !vflag)
549 				shprintf("%s %s=", Talias, id);
550 			print_value_quoted(tp->val.s);
551 			break;
552 		case CFUNC:
553 			if (vflag) {
554 				if (tp->flag & EXPORT)
555 					shf_puts("n exported", shl_stdout);
556 				if (tp->flag & TRACE)
557 					shf_puts(" traced", shl_stdout);
558 				if (!(tp->flag & ISSET)) {
559 					shf_puts(" undefined", shl_stdout);
560 					if (tp->u.fpath)
561 						shprintf(" (autoload from %s)",
562 						    tp->u.fpath);
563 				}
564 				shf_puts(T_function, shl_stdout);
565 			}
566 			break;
567 		case CSHELL:
568 			if (vflag)
569 				shprintf("%s %s %s",
570 				    (tp->flag & SPEC_BI) ? " special" : null,
571 				    "shell", Tbuiltin);
572 			break;
573 		case CTALIAS:
574 		case CEXEC:
575 			if (tp->flag & ISSET) {
576 				if (vflag) {
577 					shf_puts(" is ", shl_stdout);
578 					if (tp->type == CTALIAS)
579 						shprintf("a tracked %s%s for ",
580 						    (tp->flag & EXPORT) ?
581 						    "exported " : null,
582 						    Talias);
583 				}
584 				shf_puts(tp->val.s, shl_stdout);
585 			} else {
586 				if (vflag)
587 					shprintf(" %s\n", "not found");
588 				rv = 1;
589 			}
590 			break;
591 		default:
592 			shprintf("%s is *GOK*", id);
593 			break;
594 		}
595 		if (vflag || !rv)
596 			shf_putc('\n', shl_stdout);
597 	}
598 	return (rv);
599 }
600 
601 /* Deal with command -vV - command -p dealt with in comexec() */
602 int
c_command(const char ** wp)603 c_command(const char **wp)
604 {
605 	/*
606 	 * Let c_whence do the work. Note that c_command() must be
607 	 * a distinct function from c_whence() (tested in comexec()).
608 	 */
609 	return (c_whence(wp));
610 }
611 
612 /* typeset, global, export, and readonly */
613 int
c_typeset(const char ** wp)614 c_typeset(const char **wp)
615 {
616 	struct block *l;
617 	struct tbl *vp, **p;
618 	uint32_t fset = 0, fclr = 0, flag;
619 	int thing = 0, field, base, optc;
620 	const char *opts;
621 	const char *fieldstr, *basestr;
622 	bool localv = false, func = false, pflag = false, istset = true;
623 
624 	switch (**wp) {
625 
626 	/* export */
627 	case 'e':
628 		fset |= EXPORT;
629 		istset = false;
630 		break;
631 
632 	/* readonly */
633 	case 'r':
634 		fset |= RDONLY;
635 		istset = false;
636 		break;
637 
638 	/* set */
639 	case 's':
640 		/* called with 'typeset -' */
641 		break;
642 
643 	/* typeset */
644 	case 't':
645 		localv = true;
646 		break;
647 	}
648 
649 	/* see comment below regarding possible opions */
650 	opts = istset ? "L#R#UZ#afi#lnprtux" : "p";
651 
652 	fieldstr = basestr = NULL;
653 	builtin_opt.flags |= GF_PLUSOPT;
654 	/*
655 	 * AT&T ksh seems to have 0-9 as options which are multiplied
656 	 * to get a number that is used with -L, -R, -Z or -i (eg, -1R2
657 	 * sets right justify in a field of 12). This allows options
658 	 * to be grouped in an order (eg, -Lu12), but disallows -i8 -L3 and
659 	 * does not allow the number to be specified as a separate argument
660 	 * Here, the number must follow the RLZi option, but is optional
661 	 * (see the # kludge in ksh_getopt()).
662 	 */
663 	while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1) {
664 		flag = 0;
665 		switch (optc) {
666 		case 'L':
667 			flag = LJUST;
668 			fieldstr = builtin_opt.optarg;
669 			break;
670 		case 'R':
671 			flag = RJUST;
672 			fieldstr = builtin_opt.optarg;
673 			break;
674 		case 'U':
675 			/*
676 			 * AT&T ksh uses u, but this conflicts with
677 			 * upper/lower case. If this option is changed,
678 			 * need to change the -U below as well
679 			 */
680 			flag = INT_U;
681 			break;
682 		case 'Z':
683 			flag = ZEROFIL;
684 			fieldstr = builtin_opt.optarg;
685 			break;
686 		case 'a':
687 			/*
688 			 * this is supposed to set (-a) or unset (+a) the
689 			 * indexed array attribute; it does nothing on an
690 			 * existing regular string or indexed array though
691 			 */
692 			break;
693 		case 'f':
694 			func = true;
695 			break;
696 		case 'i':
697 			flag = INTEGER;
698 			basestr = builtin_opt.optarg;
699 			break;
700 		case 'l':
701 			flag = LCASEV;
702 			break;
703 		case 'n':
704 			set_refflag = (builtin_opt.info & GI_PLUS) ?
705 			    SRF_DISABLE : SRF_ENABLE;
706 			break;
707 		/* export, readonly: POSIX -p flag */
708 		case 'p':
709 			/* typeset: show values as well */
710 			pflag = true;
711 			if (istset)
712 				continue;
713 			break;
714 		case 'r':
715 			flag = RDONLY;
716 			break;
717 		case 't':
718 			flag = TRACE;
719 			break;
720 		case 'u':
721 			/* upper case / autoload */
722 			flag = UCASEV_AL;
723 			break;
724 		case 'x':
725 			flag = EXPORT;
726 			break;
727 		case '?':
728 			return (1);
729 		}
730 		if (builtin_opt.info & GI_PLUS) {
731 			fclr |= flag;
732 			fset &= ~flag;
733 			thing = '+';
734 		} else {
735 			fset |= flag;
736 			fclr &= ~flag;
737 			thing = '-';
738 		}
739 	}
740 
741 	field = 0;
742 	if (fieldstr && !bi_getn(fieldstr, &field))
743 		return (1);
744 	base = 0;
745 	if (basestr && !bi_getn(basestr, &base))
746 		return (1);
747 
748 	if (!(builtin_opt.info & GI_MINUSMINUS) && wp[builtin_opt.optind] &&
749 	    (wp[builtin_opt.optind][0] == '-' ||
750 	    wp[builtin_opt.optind][0] == '+') &&
751 	    wp[builtin_opt.optind][1] == '\0') {
752 		thing = wp[builtin_opt.optind][0];
753 		builtin_opt.optind++;
754 	}
755 
756 	if (func && (((fset|fclr) & ~(TRACE|UCASEV_AL|EXPORT)) ||
757 	    set_refflag != SRF_NOP)) {
758 		bi_errorf("only -t, -u and -x options may be used with -f");
759 		set_refflag = SRF_NOP;
760 		return (1);
761 	}
762 	if (wp[builtin_opt.optind]) {
763 		/*
764 		 * Take care of exclusions.
765 		 * At this point, flags in fset are cleared in fclr and vice
766 		 * versa. This property should be preserved.
767 		 */
768 		if (fset & LCASEV)
769 			/* LCASEV has priority over UCASEV_AL */
770 			fset &= ~UCASEV_AL;
771 		if (fset & LJUST)
772 			/* LJUST has priority over RJUST */
773 			fset &= ~RJUST;
774 		if ((fset & (ZEROFIL|LJUST)) == ZEROFIL) {
775 			/* -Z implies -ZR */
776 			fset |= RJUST;
777 			fclr &= ~RJUST;
778 		}
779 		/*
780 		 * Setting these attributes clears the others, unless they
781 		 * are also set in this command
782 		 */
783 		if ((fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL | LCASEV |
784 		    INTEGER | INT_U | INT_L)) || set_refflag != SRF_NOP)
785 			fclr |= ~fset & (LJUST | RJUST | ZEROFIL | UCASEV_AL |
786 			    LCASEV | INTEGER | INT_U | INT_L);
787 	}
788 
789 	/* set variables and attributes */
790 	if (wp[builtin_opt.optind]) {
791 		int i, rv = 0;
792 		struct tbl *f;
793 
794 		if (localv && !func)
795 			fset |= LOCAL;
796 		for (i = builtin_opt.optind; wp[i]; i++) {
797 			if (func) {
798 				f = findfunc(wp[i], hash(wp[i]),
799 				    tobool(fset & UCASEV_AL));
800 				if (!f) {
801 					/* AT&T ksh does ++rv: bogus */
802 					rv = 1;
803 					continue;
804 				}
805 				if (fset | fclr) {
806 					f->flag |= fset;
807 					f->flag &= ~fclr;
808 				} else {
809 					fpFUNCTf(shl_stdout, 0,
810 					    tobool(f->flag & FKSH),
811 					    wp[i], f->val.t);
812 					shf_putc('\n', shl_stdout);
813 				}
814 			} else if (!typeset(wp[i], fset, fclr, field, base)) {
815 				bi_errorf("%s: %s", wp[i], "not identifier");
816 				set_refflag = SRF_NOP;
817 				return (1);
818 			}
819 		}
820 		set_refflag = SRF_NOP;
821 		return (rv);
822 	}
823 
824 	/* list variables and attributes */
825 
826 	/* no difference at this point.. */
827 	flag = fset | fclr;
828 	if (func) {
829 		for (l = e->loc; l; l = l->next) {
830 			for (p = ktsort(&l->funs); (vp = *p++); ) {
831 				if (flag && (vp->flag & flag) == 0)
832 					continue;
833 				if (thing == '-')
834 					fpFUNCTf(shl_stdout, 0,
835 					    tobool(vp->flag & FKSH),
836 					    vp->name, vp->val.t);
837 				else
838 					shf_puts(vp->name, shl_stdout);
839 				shf_putc('\n', shl_stdout);
840 			}
841 		}
842 	} else {
843 		for (l = e->loc; l; l = l->next) {
844 			for (p = ktsort(&l->vars); (vp = *p++); ) {
845 				struct tbl *tvp;
846 				bool any_set = false;
847 				/*
848 				 * See if the parameter is set (for arrays, if any
849 				 * element is set).
850 				 */
851 				for (tvp = vp; tvp; tvp = tvp->u.array)
852 					if (tvp->flag & ISSET) {
853 						any_set = true;
854 						break;
855 					}
856 
857 				/*
858 				 * Check attributes - note that all array elements
859 				 * have (should have?) the same attributes, so checking
860 				 * the first is sufficient.
861 				 *
862 				 * Report an unset param only if the user has
863 				 * explicitly given it some attribute (like export);
864 				 * otherwise, after "echo $FOO", we would report FOO...
865 				 */
866 				if (!any_set && !(vp->flag & USERATTRIB))
867 					continue;
868 				if (flag && (vp->flag & flag) == 0)
869 					continue;
870 				for (; vp; vp = vp->u.array) {
871 					/*
872 					 * Ignore array elements that aren't
873 					 * set unless there are no set elements,
874 					 * in which case the first is reported on
875 					 */
876 					if ((vp->flag&ARRAY) && any_set &&
877 					    !(vp->flag & ISSET))
878 						continue;
879 					/* no arguments */
880 					if (thing == 0 && flag == 0) {
881 						/*
882 						 * AT&T ksh prints things
883 						 * like export, integer,
884 						 * leftadj, zerofill, etc.,
885 						 * but POSIX says must
886 						 * be suitable for re-entry...
887 						 */
888 						shf_puts("typeset ", shl_stdout);
889 						if (((vp->flag&(ARRAY|ASSOC))==ASSOC))
890 							shprintf("%s ", "-n");
891 						if ((vp->flag&INTEGER))
892 							shprintf("%s ", "-i");
893 						if ((vp->flag&EXPORT))
894 							shprintf("%s ", "-x");
895 						if ((vp->flag&RDONLY))
896 							shprintf("%s ", "-r");
897 						if ((vp->flag&TRACE))
898 							shprintf("%s ", "-t");
899 						if ((vp->flag&LJUST))
900 							shprintf("-L%d ", vp->u2.field);
901 						if ((vp->flag&RJUST))
902 							shprintf("-R%d ", vp->u2.field);
903 						if ((vp->flag&ZEROFIL))
904 							shprintf("%s ", "-Z");
905 						if ((vp->flag&LCASEV))
906 							shprintf("%s ", "-l");
907 						if ((vp->flag&UCASEV_AL))
908 							shprintf("%s ", "-u");
909 						if ((vp->flag&INT_U))
910 							shprintf("%s ", "-U");
911 						shf_puts(vp->name, shl_stdout);
912 						if (pflag) {
913 							char *s = str_val(vp);
914 
915 							shf_putc('=', shl_stdout);
916 							/*
917 							 * AT&T ksh can't have
918 							 * justified integers...
919 							 */
920 							if ((vp->flag &
921 							    (INTEGER|LJUST|RJUST)) ==
922 							    INTEGER)
923 								shf_puts(s, shl_stdout);
924 							else
925 								print_value_quoted(s);
926 						}
927 						shf_putc('\n', shl_stdout);
928 						if (vp->flag & ARRAY)
929 							break;
930 					} else {
931 						if (pflag)
932 							shf_puts(istset ?
933 							    "typeset " :
934 							    (flag & EXPORT) ?
935 							    "export " :
936 							    "readonly ",
937 							    shl_stdout);
938 						if ((vp->flag&ARRAY) && any_set)
939 							shprintf("%s[%lu]",
940 							    vp->name,
941 							    arrayindex(vp));
942 						else
943 							shf_puts(vp->name, shl_stdout);
944 						if (thing == '-' && (vp->flag&ISSET)) {
945 							char *s = str_val(vp);
946 
947 							shf_putc('=', shl_stdout);
948 							/*
949 							 * AT&T ksh can't have
950 							 * justified integers...
951 							 */
952 							if ((vp->flag &
953 							    (INTEGER|LJUST|RJUST)) ==
954 							    INTEGER)
955 								shf_puts(s, shl_stdout);
956 							else
957 								print_value_quoted(s);
958 						}
959 						shf_putc('\n', shl_stdout);
960 					}
961 					/*
962 					 * Only report first 'element' of an array with
963 					 * no set elements.
964 					 */
965 					if (!any_set)
966 						break;
967 				}
968 			}
969 		}
970 	}
971 	return (0);
972 }
973 
974 int
c_alias(const char ** wp)975 c_alias(const char **wp)
976 {
977 	struct table *t = &aliases;
978 	int rv = 0, prefix = 0;
979 	bool rflag = false, tflag, Uflag = false, pflag = false;
980 	uint32_t xflag = 0;
981 	int optc;
982 
983 	builtin_opt.flags |= GF_PLUSOPT;
984 	while ((optc = ksh_getopt(wp, &builtin_opt, "dprtUx")) != -1) {
985 		prefix = builtin_opt.info & GI_PLUS ? '+' : '-';
986 		switch (optc) {
987 		case 'd':
988 #ifdef MKSH_NOPWNAM
989 			t = NULL;	/* fix "alias -dt" */
990 #else
991 			t = &homedirs;
992 #endif
993 			break;
994 		case 'p':
995 			pflag = true;
996 			break;
997 		case 'r':
998 			rflag = true;
999 			break;
1000 		case 't':
1001 			t = &taliases;
1002 			break;
1003 		case 'U':
1004 			/*
1005 			 * kludge for tracked alias initialization
1006 			 * (don't do a path search, just make an entry)
1007 			 */
1008 			Uflag = true;
1009 			break;
1010 		case 'x':
1011 			xflag = EXPORT;
1012 			break;
1013 		case '?':
1014 			return (1);
1015 		}
1016 	}
1017 #ifdef MKSH_NOPWNAM
1018 	if (t == NULL)
1019 		return (0);
1020 #endif
1021 	wp += builtin_opt.optind;
1022 
1023 	if (!(builtin_opt.info & GI_MINUSMINUS) && *wp &&
1024 	    (wp[0][0] == '-' || wp[0][0] == '+') && wp[0][1] == '\0') {
1025 		prefix = wp[0][0];
1026 		wp++;
1027 	}
1028 
1029 	tflag = t == &taliases;
1030 
1031 	/* "hash -r" means reset all the tracked aliases.. */
1032 	if (rflag) {
1033 		static const char *args[] = {
1034 			Tunalias, "-ta", NULL
1035 		};
1036 
1037 		if (!tflag || *wp) {
1038 			shprintf("%s: -r flag can only be used with -t"
1039 			    " and without arguments\n", Talias);
1040 			return (1);
1041 		}
1042 		ksh_getopt_reset(&builtin_opt, GF_ERROR);
1043 		return (c_unalias(args));
1044 	}
1045 
1046 	if (*wp == NULL) {
1047 		struct tbl *ap, **p;
1048 
1049 		for (p = ktsort(t); (ap = *p++) != NULL; )
1050 			if ((ap->flag & (ISSET|xflag)) == (ISSET|xflag)) {
1051 				if (pflag)
1052 					shprintf("%s ", Talias);
1053 				shf_puts(ap->name, shl_stdout);
1054 				if (prefix != '+') {
1055 					shf_putc('=', shl_stdout);
1056 					print_value_quoted(ap->val.s);
1057 				}
1058 				shf_putc('\n', shl_stdout);
1059 			}
1060 	}
1061 
1062 	for (; *wp != NULL; wp++) {
1063 		const char *alias = *wp, *val, *newval;
1064 		char *xalias = NULL;
1065 		struct tbl *ap;
1066 		uint32_t h;
1067 
1068 		if ((val = cstrchr(alias, '='))) {
1069 			strndupx(xalias, alias, val++ - alias, ATEMP);
1070 			alias = xalias;
1071 		}
1072 		h = hash(alias);
1073 		if (val == NULL && !tflag && !xflag) {
1074 			ap = ktsearch(t, alias, h);
1075 			if (ap != NULL && (ap->flag&ISSET)) {
1076 				if (pflag)
1077 					shprintf("%s ", Talias);
1078 				shf_puts(ap->name, shl_stdout);
1079 				if (prefix != '+') {
1080 					shf_putc('=', shl_stdout);
1081 					print_value_quoted(ap->val.s);
1082 				}
1083 				shf_putc('\n', shl_stdout);
1084 			} else {
1085 				shprintf("%s %s %s\n", alias, Talias,
1086 				    "not found");
1087 				rv = 1;
1088 			}
1089 			continue;
1090 		}
1091 		ap = ktenter(t, alias, h);
1092 		ap->type = tflag ? CTALIAS : CALIAS;
1093 		/* Are we setting the value or just some flags? */
1094 		if ((val && !tflag) || (!val && tflag && !Uflag)) {
1095 			if (ap->flag&ALLOC) {
1096 				ap->flag &= ~(ALLOC|ISSET);
1097 				afree(ap->val.s, APERM);
1098 			}
1099 			/* ignore values for -t (AT&T ksh does this) */
1100 			newval = tflag ?
1101 			    search_path(alias, path, X_OK, NULL) :
1102 			    val;
1103 			if (newval) {
1104 				strdupx(ap->val.s, newval, APERM);
1105 				ap->flag |= ALLOC|ISSET;
1106 			} else
1107 				ap->flag &= ~ISSET;
1108 		}
1109 		ap->flag |= DEFINED;
1110 		if (prefix == '+')
1111 			ap->flag &= ~xflag;
1112 		else
1113 			ap->flag |= xflag;
1114 		afree(xalias, ATEMP);
1115 	}
1116 
1117 	return (rv);
1118 }
1119 
1120 int
c_unalias(const char ** wp)1121 c_unalias(const char **wp)
1122 {
1123 	struct table *t = &aliases;
1124 	struct tbl *ap;
1125 	int optc, rv = 0;
1126 	bool all = false;
1127 
1128 	while ((optc = ksh_getopt(wp, &builtin_opt, "adt")) != -1)
1129 		switch (optc) {
1130 		case 'a':
1131 			all = true;
1132 			break;
1133 		case 'd':
1134 #ifdef MKSH_NOPWNAM
1135 			/* fix "unalias -dt" */
1136 			t = NULL;
1137 #else
1138 			t = &homedirs;
1139 #endif
1140 			break;
1141 		case 't':
1142 			t = &taliases;
1143 			break;
1144 		case '?':
1145 			return (1);
1146 		}
1147 #ifdef MKSH_NOPWNAM
1148 	if (t == NULL)
1149 		return (0);
1150 #endif
1151 	wp += builtin_opt.optind;
1152 
1153 	for (; *wp != NULL; wp++) {
1154 		ap = ktsearch(t, *wp, hash(*wp));
1155 		if (ap == NULL) {
1156 			/* POSIX */
1157 			rv = 1;
1158 			continue;
1159 		}
1160 		if (ap->flag&ALLOC) {
1161 			ap->flag &= ~(ALLOC|ISSET);
1162 			afree(ap->val.s, APERM);
1163 		}
1164 		ap->flag &= ~(DEFINED|ISSET|EXPORT);
1165 	}
1166 
1167 	if (all) {
1168 		struct tstate ts;
1169 
1170 		for (ktwalk(&ts, t); (ap = ktnext(&ts)); ) {
1171 			if (ap->flag&ALLOC) {
1172 				ap->flag &= ~(ALLOC|ISSET);
1173 				afree(ap->val.s, APERM);
1174 			}
1175 			ap->flag &= ~(DEFINED|ISSET|EXPORT);
1176 		}
1177 	}
1178 
1179 	return (rv);
1180 }
1181 
1182 int
c_let(const char ** wp)1183 c_let(const char **wp)
1184 {
1185 	int rv = 1;
1186 	mksh_ari_t val;
1187 
1188 	if (wp[1] == NULL)
1189 		/* AT&T ksh does this */
1190 		bi_errorf("no arguments");
1191 	else
1192 		for (wp++; *wp; wp++)
1193 			if (!evaluate(*wp, &val, KSH_RETURN_ERROR, true)) {
1194 				/* distinguish error from zero result */
1195 				rv = 2;
1196 				break;
1197 			} else
1198 				rv = val == 0;
1199 	return (rv);
1200 }
1201 
1202 int
c_jobs(const char ** wp)1203 c_jobs(const char **wp)
1204 {
1205 	int optc, flag = 0, nflag = 0, rv = 0;
1206 
1207 	while ((optc = ksh_getopt(wp, &builtin_opt, "lpnz")) != -1)
1208 		switch (optc) {
1209 		case 'l':
1210 			flag = 1;
1211 			break;
1212 		case 'p':
1213 			flag = 2;
1214 			break;
1215 		case 'n':
1216 			nflag = 1;
1217 			break;
1218 		case 'z':
1219 			/* debugging: print zombies */
1220 			nflag = -1;
1221 			break;
1222 		case '?':
1223 			return (1);
1224 		}
1225 	wp += builtin_opt.optind;
1226 	if (!*wp) {
1227 		if (j_jobs(NULL, flag, nflag))
1228 			rv = 1;
1229 	} else {
1230 		for (; *wp; wp++)
1231 			if (j_jobs(*wp, flag, nflag))
1232 				rv = 1;
1233 	}
1234 	return (rv);
1235 }
1236 
1237 #ifndef MKSH_UNEMPLOYED
1238 int
c_fgbg(const char ** wp)1239 c_fgbg(const char **wp)
1240 {
1241 	bool bg = strcmp(*wp, "bg") == 0;
1242 	int rv = 0;
1243 
1244 	if (!Flag(FMONITOR)) {
1245 		bi_errorf("job control not enabled");
1246 		return (1);
1247 	}
1248 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1249 		return (1);
1250 	wp += builtin_opt.optind;
1251 	if (*wp)
1252 		for (; *wp; wp++)
1253 			rv = j_resume(*wp, bg);
1254 	else
1255 		rv = j_resume("%%", bg);
1256 	return (bg ? 0 : rv);
1257 }
1258 #endif
1259 
1260 /* format a single kill item */
1261 static char *
kill_fmt_entry(char * buf,size_t buflen,int i,const void * arg)1262 kill_fmt_entry(char *buf, size_t buflen, int i, const void *arg)
1263 {
1264 	const struct kill_info *ki = (const struct kill_info *)arg;
1265 
1266 	i++;
1267 	shf_snprintf(buf, buflen, "%*d %*s %s",
1268 	    ki->num_width, i,
1269 	    ki->name_width, sigtraps[i].name,
1270 	    sigtraps[i].mess);
1271 	return (buf);
1272 }
1273 
1274 int
c_kill(const char ** wp)1275 c_kill(const char **wp)
1276 {
1277 	Trap *t = NULL;
1278 	const char *p;
1279 	bool lflag = false;
1280 	int i, n, rv, sig;
1281 
1282 	/* assume old style options if -digits or -UPPERCASE */
1283 	if ((p = wp[1]) && *p == '-' && (ksh_isdigit(p[1]) ||
1284 	    ksh_isupper(p[1]))) {
1285 		if (!(t = gettrap(p + 1, true))) {
1286 			bi_errorf("bad signal '%s'", p + 1);
1287 			return (1);
1288 		}
1289 		i = (wp[2] && strcmp(wp[2], "--") == 0) ? 3 : 2;
1290 	} else {
1291 		int optc;
1292 
1293 		while ((optc = ksh_getopt(wp, &builtin_opt, "ls:")) != -1)
1294 			switch (optc) {
1295 			case 'l':
1296 				lflag = true;
1297 				break;
1298 			case 's':
1299 				if (!(t = gettrap(builtin_opt.optarg, true))) {
1300 					bi_errorf("bad signal '%s'",
1301 					    builtin_opt.optarg);
1302 					return (1);
1303 				}
1304 				break;
1305 			case '?':
1306 				return (1);
1307 			}
1308 		i = builtin_opt.optind;
1309 	}
1310 	if ((lflag && t) || (!wp[i] && !lflag)) {
1311 #ifndef MKSH_SMALL
1312 		shf_puts("usage:\tkill [-s signame | -signum | -signame]"
1313 		    " { job | pid | pgrp } ...\n"
1314 		    "\tkill -l [exit_status ...]\n", shl_out);
1315 #endif
1316 		bi_errorfz();
1317 		return (1);
1318 	}
1319 
1320 	if (lflag) {
1321 		if (wp[i]) {
1322 			for (; wp[i]; i++) {
1323 				if (!bi_getn(wp[i], &n))
1324 					return (1);
1325 				if (n > 128 && n < 128 + NSIG)
1326 					n -= 128;
1327 				if (n > 0 && n < NSIG)
1328 					shprintf("%s\n", sigtraps[n].name);
1329 				else
1330 					shprintf("%d\n", n);
1331 			}
1332 		} else {
1333 			ssize_t w, mess_cols, mess_octs;
1334 			int j;
1335 			struct kill_info ki;
1336 
1337 			for (j = NSIG, ki.num_width = 1; j >= 10; j /= 10)
1338 				ki.num_width++;
1339 			ki.name_width = mess_cols = mess_octs = 0;
1340 			for (j = 0; j < NSIG; j++) {
1341 				w = strlen(sigtraps[j].name);
1342 				if (w > ki.name_width)
1343 					ki.name_width = w;
1344 				w = strlen(sigtraps[j].mess);
1345 				if (w > mess_octs)
1346 					mess_octs = w;
1347 				w = utf_mbswidth(sigtraps[j].mess);
1348 				if (w > mess_cols)
1349 					mess_cols = w;
1350 			}
1351 
1352 			print_columns(shl_stdout, NSIG - 1,
1353 			    kill_fmt_entry, (void *)&ki,
1354 			    ki.num_width + 1 + ki.name_width + 1 + mess_octs,
1355 			    ki.num_width + 1 + ki.name_width + 1 + mess_cols,
1356 			    true);
1357 		}
1358 		return (0);
1359 	}
1360 	rv = 0;
1361 	sig = t ? t->signal : SIGTERM;
1362 	for (; (p = wp[i]); i++) {
1363 		if (*p == '%') {
1364 			if (j_kill(p, sig))
1365 				rv = 1;
1366 		} else if (!getn(p, &n)) {
1367 			bi_errorf("%s: %s", p,
1368 			    "arguments must be jobs or process IDs");
1369 			rv = 1;
1370 		} else {
1371 			if (mksh_kill(n, sig) < 0) {
1372 				bi_errorf("%s: %s", p, strerror(errno));
1373 				rv = 1;
1374 			}
1375 		}
1376 	}
1377 	return (rv);
1378 }
1379 
1380 void
getopts_reset(int val)1381 getopts_reset(int val)
1382 {
1383 	if (val >= 1) {
1384 		ksh_getopt_reset(&user_opt, GF_NONAME | GF_PLUSOPT);
1385 		user_opt.optind = user_opt.uoptind = val;
1386 	}
1387 }
1388 
1389 int
c_getopts(const char ** wp)1390 c_getopts(const char **wp)
1391 {
1392 	int argc, optc, rv;
1393 	const char *opts, *var;
1394 	char buf[3];
1395 	struct tbl *vq, *voptarg;
1396 
1397 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1398 		return (1);
1399 	wp += builtin_opt.optind;
1400 
1401 	opts = *wp++;
1402 	if (!opts) {
1403 		bi_errorf("missing %s argument", "options");
1404 		return (1);
1405 	}
1406 
1407 	var = *wp++;
1408 	if (!var) {
1409 		bi_errorf("missing %s argument", "name");
1410 		return (1);
1411 	}
1412 	if (!*var || *skip_varname(var, true)) {
1413 		bi_errorf("%s: %s", var, "is not an identifier");
1414 		return (1);
1415 	}
1416 
1417 	if (e->loc->next == NULL) {
1418 		internal_warningf("%s: %s", "c_getopts", "no argv");
1419 		return (1);
1420 	}
1421 	/* Which arguments are we parsing... */
1422 	if (*wp == NULL)
1423 		wp = e->loc->next->argv;
1424 	else
1425 		*--wp = e->loc->next->argv[0];
1426 
1427 	/* Check that our saved state won't cause a core dump... */
1428 	for (argc = 0; wp[argc]; argc++)
1429 		;
1430 	if (user_opt.optind > argc ||
1431 	    (user_opt.p != 0 &&
1432 	    user_opt.p > strlen(wp[user_opt.optind - 1]))) {
1433 		bi_errorf("arguments changed since last call");
1434 		return (1);
1435 	}
1436 
1437 	user_opt.optarg = NULL;
1438 	optc = ksh_getopt(wp, &user_opt, opts);
1439 
1440 	if (optc >= 0 && optc != '?' && (user_opt.info & GI_PLUS)) {
1441 		buf[0] = '+';
1442 		buf[1] = optc;
1443 		buf[2] = '\0';
1444 	} else {
1445 		/*
1446 		 * POSIX says var is set to ? at end-of-options, AT&T ksh
1447 		 * sets it to null - we go with POSIX...
1448 		 */
1449 		buf[0] = optc < 0 ? '?' : optc;
1450 		buf[1] = '\0';
1451 	}
1452 
1453 	/* AT&T ksh93 in fact does change OPTIND for unknown options too */
1454 	user_opt.uoptind = user_opt.optind;
1455 
1456 	voptarg = global("OPTARG");
1457 	/* AT&T ksh clears ro and int */
1458 	voptarg->flag &= ~RDONLY;
1459 	/* Paranoia: ensure no bizarre results. */
1460 	if (voptarg->flag & INTEGER)
1461 	    typeset("OPTARG", 0, INTEGER, 0, 0);
1462 	if (user_opt.optarg == NULL)
1463 		unset(voptarg, 1);
1464 	else
1465 		/* This can't fail (have cleared readonly/integer) */
1466 		setstr(voptarg, user_opt.optarg, KSH_RETURN_ERROR);
1467 
1468 	rv = 0;
1469 
1470 	vq = global(var);
1471 	/* Error message already printed (integer, readonly) */
1472 	if (!setstr(vq, buf, KSH_RETURN_ERROR))
1473 		rv = 2;
1474 	if (Flag(FEXPORT))
1475 		typeset(var, EXPORT, 0, 0, 0);
1476 
1477 	return (optc < 0 ? 1 : rv);
1478 }
1479 
1480 int
c_bind(const char ** wp)1481 c_bind(const char **wp)
1482 {
1483 	int optc, rv = 0;
1484 #ifndef MKSH_SMALL
1485 	bool macro = false;
1486 #endif
1487 	bool list = false;
1488 	const char *cp;
1489 	char *up;
1490 
1491 	while ((optc = ksh_getopt(wp, &builtin_opt,
1492 #ifndef MKSH_SMALL
1493 	    "lm"
1494 #else
1495 	    "l"
1496 #endif
1497 	    )) != -1)
1498 		switch (optc) {
1499 		case 'l':
1500 			list = true;
1501 			break;
1502 #ifndef MKSH_SMALL
1503 		case 'm':
1504 			macro = true;
1505 			break;
1506 #endif
1507 		case '?':
1508 			return (1);
1509 		}
1510 	wp += builtin_opt.optind;
1511 
1512 	if (*wp == NULL)
1513 		/* list all */
1514 		rv = x_bind(NULL, NULL,
1515 #ifndef MKSH_SMALL
1516 		    false,
1517 #endif
1518 		    list);
1519 
1520 	for (; *wp != NULL; wp++) {
1521 		if ((cp = cstrchr(*wp, '=')) == NULL)
1522 			up = NULL;
1523 		else {
1524 			strdupx(up, *wp, ATEMP);
1525 			up[cp++ - *wp] = '\0';
1526 		}
1527 		if (x_bind(up ? up : *wp, cp,
1528 #ifndef MKSH_SMALL
1529 		    macro,
1530 #endif
1531 		    false))
1532 			rv = 1;
1533 		afree(up, ATEMP);
1534 	}
1535 
1536 	return (rv);
1537 }
1538 
1539 int
c_shift(const char ** wp)1540 c_shift(const char **wp)
1541 {
1542 	struct block *l = e->loc;
1543 	int n;
1544 	mksh_ari_t val;
1545 	const char *arg;
1546 
1547 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1548 		return (1);
1549 	arg = wp[builtin_opt.optind];
1550 
1551 	if (arg) {
1552 		evaluate(arg, &val, KSH_UNWIND_ERROR, false);
1553 		n = val;
1554 	} else
1555 		n = 1;
1556 	if (n < 0) {
1557 		bi_errorf("%s: %s", arg, "bad number");
1558 		return (1);
1559 	}
1560 	if (l->argc < n) {
1561 		bi_errorf("nothing to shift");
1562 		return (1);
1563 	}
1564 	l->argv[n] = l->argv[0];
1565 	l->argv += n;
1566 	l->argc -= n;
1567 	return (0);
1568 }
1569 
1570 int
c_umask(const char ** wp)1571 c_umask(const char **wp)
1572 {
1573 	int i, optc;
1574 	const char *cp;
1575 	bool symbolic = false;
1576 	mode_t old_umask;
1577 
1578 	while ((optc = ksh_getopt(wp, &builtin_opt, "S")) != -1)
1579 		switch (optc) {
1580 		case 'S':
1581 			symbolic = true;
1582 			break;
1583 		case '?':
1584 			return (1);
1585 		}
1586 	cp = wp[builtin_opt.optind];
1587 	if (cp == NULL) {
1588 		old_umask = umask((mode_t)0);
1589 		umask(old_umask);
1590 		if (symbolic) {
1591 			char buf[18], *p;
1592 			int j;
1593 
1594 			old_umask = ~old_umask;
1595 			p = buf;
1596 			for (i = 0; i < 3; i++) {
1597 				*p++ = "ugo"[i];
1598 				*p++ = '=';
1599 				for (j = 0; j < 3; j++)
1600 					if (old_umask & (1 << (8 - (3*i + j))))
1601 						*p++ = "rwx"[j];
1602 				*p++ = ',';
1603 			}
1604 			p[-1] = '\0';
1605 			shprintf("%s\n", buf);
1606 		} else
1607 			shprintf("%#3.3o\n", (unsigned int)old_umask);
1608 	} else {
1609 		mode_t new_umask;
1610 
1611 		if (ksh_isdigit(*cp)) {
1612 			for (new_umask = 0; *cp >= '0' && *cp <= '7'; cp++)
1613 				new_umask = new_umask * 8 + (*cp - '0');
1614 			if (*cp) {
1615 				bi_errorf("bad number");
1616 				return (1);
1617 			}
1618 		} else {
1619 			/* symbolic format */
1620 			int positions, new_val;
1621 			char op;
1622 
1623 			old_umask = umask((mode_t)0);
1624 			/* in case of error */
1625 			umask(old_umask);
1626 			old_umask = ~old_umask;
1627 			new_umask = old_umask;
1628 			positions = 0;
1629 			while (*cp) {
1630 				while (*cp && vstrchr("augo", *cp))
1631 					switch (*cp++) {
1632 					case 'a':
1633 						positions |= 0111;
1634 						break;
1635 					case 'u':
1636 						positions |= 0100;
1637 						break;
1638 					case 'g':
1639 						positions |= 0010;
1640 						break;
1641 					case 'o':
1642 						positions |= 0001;
1643 						break;
1644 					}
1645 				if (!positions)
1646 					/* default is a */
1647 					positions = 0111;
1648 				if (!vstrchr("=+-", op = *cp))
1649 					break;
1650 				cp++;
1651 				new_val = 0;
1652 				while (*cp && vstrchr("rwxugoXs", *cp))
1653 					switch (*cp++) {
1654 					case 'r': new_val |= 04; break;
1655 					case 'w': new_val |= 02; break;
1656 					case 'x': new_val |= 01; break;
1657 					case 'u':
1658 						new_val |= old_umask >> 6;
1659 						break;
1660 					case 'g':
1661 						new_val |= old_umask >> 3;
1662 						break;
1663 					case 'o':
1664 						new_val |= old_umask >> 0;
1665 						break;
1666 					case 'X':
1667 						if (old_umask & 0111)
1668 							new_val |= 01;
1669 						break;
1670 					case 's':
1671 						/* ignored */
1672 						break;
1673 					}
1674 				new_val = (new_val & 07) * positions;
1675 				switch (op) {
1676 				case '-':
1677 					new_umask &= ~new_val;
1678 					break;
1679 				case '=':
1680 					new_umask = new_val |
1681 					    (new_umask & ~(positions * 07));
1682 					break;
1683 				case '+':
1684 					new_umask |= new_val;
1685 				}
1686 				if (*cp == ',') {
1687 					positions = 0;
1688 					cp++;
1689 				} else if (!vstrchr("=+-", *cp))
1690 					break;
1691 			}
1692 			if (*cp) {
1693 				bi_errorf("bad mask");
1694 				return (1);
1695 			}
1696 			new_umask = ~new_umask;
1697 		}
1698 		umask(new_umask);
1699 	}
1700 	return (0);
1701 }
1702 
1703 int
c_dot(const char ** wp)1704 c_dot(const char **wp)
1705 {
1706 	const char *file, *cp, **argv;
1707 	int argc, i, errcode;
1708 
1709 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1710 		return (1);
1711 
1712 	if ((cp = wp[builtin_opt.optind]) == NULL) {
1713 		bi_errorf("missing argument");
1714 		return (1);
1715 	}
1716 	if ((file = search_path(cp, path, R_OK, &errcode)) == NULL) {
1717 		bi_errorf("%s: %s", cp, strerror(errcode));
1718 		return (1);
1719 	}
1720 
1721 	/* Set positional parameters? */
1722 	if (wp[builtin_opt.optind + 1]) {
1723 		argv = wp + builtin_opt.optind;
1724 		/* preserve $0 */
1725 		argv[0] = e->loc->argv[0];
1726 		for (argc = 0; argv[argc + 1]; argc++)
1727 			;
1728 	} else {
1729 		argc = 0;
1730 		argv = NULL;
1731 	}
1732 	if ((i = include(file, argc, argv, 0)) < 0) {
1733 		/* should not happen */
1734 		bi_errorf("%s: %s", cp, strerror(errno));
1735 		return (1);
1736 	}
1737 	return (i);
1738 }
1739 
1740 int
c_wait(const char ** wp)1741 c_wait(const char **wp)
1742 {
1743 	int rv = 0, sig;
1744 
1745 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1746 		return (1);
1747 	wp += builtin_opt.optind;
1748 	if (*wp == NULL) {
1749 		while (waitfor(NULL, &sig) >= 0)
1750 			;
1751 		rv = sig;
1752 	} else {
1753 		for (; *wp; wp++)
1754 			rv = waitfor(*wp, &sig);
1755 		if (rv < 0)
1756 			/* magic exit code: bad job-id */
1757 			rv = sig ? sig : 127;
1758 	}
1759 	return (rv);
1760 }
1761 
1762 int
c_read(const char ** wp)1763 c_read(const char **wp)
1764 {
1765 #define is_ifsws(c) (ctype((c), C_IFS) && ctype((c), C_IFSWS))
1766 	static char REPLY[] = "REPLY";
1767 	int c, fd = 0, rv = 0, lastparm = 0;
1768 	bool savehist = false, intoarray = false, aschars = false;
1769 	bool rawmode = false, expanding = false;
1770 	enum { LINES, BYTES, UPTO, READALL } readmode = LINES;
1771 	char delim = '\n';
1772 	size_t bytesleft = 128, bytesread;
1773 	struct tbl *vp /* FU gcc */ = NULL, *vq;
1774 	char *cp, *allocd = NULL, *xp;
1775 	const char *ccp;
1776 	XString xs;
1777 	ptrdiff_t xsave = 0;
1778 	struct termios tios;
1779 	bool restore_tios = false;
1780 #if HAVE_SELECT
1781 	bool hastimeout = false;
1782 	struct timeval tv, tvlim;
1783 #define c_read_opts "Aad:N:n:prst:u,"
1784 #else
1785 #define c_read_opts "Aad:N:n:prsu,"
1786 #endif
1787 
1788 	while ((c = ksh_getopt(wp, &builtin_opt, c_read_opts)) != -1)
1789 	switch (c) {
1790 	case 'a':
1791 		aschars = true;
1792 		/* FALLTHROUGH */
1793 	case 'A':
1794 		intoarray = true;
1795 		break;
1796 	case 'd':
1797 		delim = builtin_opt.optarg[0];
1798 		break;
1799 	case 'N':
1800 	case 'n':
1801 		readmode = c == 'N' ? BYTES : UPTO;
1802 		if (!bi_getn(builtin_opt.optarg, &c))
1803 			return (2);
1804 		if (c == -1) {
1805 			readmode = READALL;
1806 			bytesleft = 1024;
1807 		} else
1808 			bytesleft = (unsigned int)c;
1809 		break;
1810 	case 'p':
1811 		if ((fd = coproc_getfd(R_OK, &ccp)) < 0) {
1812 			bi_errorf("%s: %s", "-p", ccp);
1813 			return (2);
1814 		}
1815 		break;
1816 	case 'r':
1817 		rawmode = true;
1818 		break;
1819 	case 's':
1820 		savehist = true;
1821 		break;
1822 #if HAVE_SELECT
1823 	case 't':
1824 		if (parse_usec(builtin_opt.optarg, &tv)) {
1825 			bi_errorf("%s: %s '%s'", Tsynerr, strerror(errno),
1826 			    builtin_opt.optarg);
1827 			return (2);
1828 		}
1829 		hastimeout = true;
1830 		break;
1831 #endif
1832 	case 'u':
1833 		if (!builtin_opt.optarg[0])
1834 			fd = 0;
1835 		else if ((fd = check_fd(builtin_opt.optarg, R_OK, &ccp)) < 0) {
1836 			bi_errorf("%s: %s: %s", "-u", builtin_opt.optarg, ccp);
1837 			return (2);
1838 		}
1839 		break;
1840 	case '?':
1841 		return (2);
1842 	}
1843 	wp += builtin_opt.optind;
1844 	if (*wp == NULL)
1845 		*--wp = REPLY;
1846 
1847 	if (intoarray && wp[1] != NULL) {
1848 		bi_errorf("too many arguments");
1849 		return (2);
1850 	}
1851 
1852 	if ((ccp = cstrchr(*wp, '?')) != NULL) {
1853 		strdupx(allocd, *wp, ATEMP);
1854 		allocd[ccp - *wp] = '\0';
1855 		*wp = allocd;
1856 		if (isatty(fd)) {
1857 			/*
1858 			 * AT&T ksh says it prints prompt on fd if it's open
1859 			 * for writing and is a tty, but it doesn't do it
1860 			 * (it also doesn't check the interactive flag,
1861 			 * as is indicated in the Korn Shell book).
1862 			 */
1863 			shf_puts(ccp + 1, shl_out);
1864 			shf_flush(shl_out);
1865 		}
1866 	}
1867 
1868 	Xinit(xs, xp, bytesleft, ATEMP);
1869 
1870 	if (readmode == LINES)
1871 		bytesleft = 1;
1872 	else if (isatty(fd)) {
1873 		x_mkraw(fd, &tios, true);
1874 		restore_tios = true;
1875 	}
1876 
1877 #if HAVE_SELECT
1878 	if (hastimeout) {
1879 		gettimeofday(&tvlim, NULL);
1880 		timeradd(&tvlim, &tv, &tvlim);
1881 	}
1882 #endif
1883 
1884  c_read_readloop:
1885 #if HAVE_SELECT
1886 	if (hastimeout) {
1887 		fd_set fdset;
1888 
1889 		FD_ZERO(&fdset);
1890 		FD_SET(fd, &fdset);
1891 		gettimeofday(&tv, NULL);
1892 		timersub(&tvlim, &tv, &tv);
1893 		if (tv.tv_sec < 0) {
1894 			/* timeout expired globally */
1895 			rv = 1;
1896 			goto c_read_out;
1897 		}
1898 
1899 		switch (select(fd + 1, &fdset, NULL, NULL, &tv)) {
1900 		case 1:
1901 			break;
1902 		case 0:
1903 			/* timeout expired for this call */
1904 			rv = 1;
1905 			goto c_read_out;
1906 		default:
1907 			bi_errorf("%s: %s", Tselect, strerror(errno));
1908 			rv = 2;
1909 			goto c_read_out;
1910 		}
1911 	}
1912 #endif
1913 
1914 	bytesread = blocking_read(fd, xp, bytesleft);
1915 	if (bytesread == (size_t)-1) {
1916 		/* interrupted */
1917 		if (errno == EINTR && fatal_trap_check()) {
1918 			/*
1919 			 * Was the offending signal one that would
1920 			 * normally kill a process? If so, pretend
1921 			 * the read was killed.
1922 			 */
1923 			rv = 2;
1924 			goto c_read_out;
1925 		}
1926 		/* just ignore the signal */
1927 		goto c_read_readloop;
1928 	}
1929 
1930 	switch (readmode) {
1931 	case READALL:
1932 		if (bytesread == 0) {
1933 			/* end of file reached */
1934 			rv = 1;
1935 			goto c_read_readdone;
1936 		}
1937 		xp += bytesread;
1938 		XcheckN(xs, xp, bytesleft);
1939 		break;
1940 
1941 	case UPTO:
1942 		if (bytesread == 0)
1943 			/* end of file reached */
1944 			rv = 1;
1945 		xp += bytesread;
1946 		goto c_read_readdone;
1947 
1948 	case BYTES:
1949 		if (bytesread == 0) {
1950 			/* end of file reached */
1951 			rv = 1;
1952 			xp = Xstring(xs, xp);
1953 			goto c_read_readdone;
1954 		}
1955 		xp += bytesread;
1956 		if ((bytesleft -= bytesread) == 0)
1957 			goto c_read_readdone;
1958 		break;
1959 	case LINES:
1960 		if (bytesread == 0) {
1961 			/* end of file reached */
1962 			rv = 1;
1963 			goto c_read_readdone;
1964 		}
1965 		if ((c = *xp) == '\0' && !aschars && delim != '\0') {
1966 			/* skip any read NULs unless delimiter */
1967 			break;
1968 		}
1969 		if (expanding) {
1970 			expanding = false;
1971 			if (c == delim) {
1972 				if (Flag(FTALKING_I) && isatty(fd)) {
1973 					/*
1974 					 * set prompt in case this is
1975 					 * called from .profile or $ENV
1976 					 */
1977 					set_prompt(PS2, NULL);
1978 					pprompt(prompt, 0);
1979 				}
1980 				/* drop the backslash */
1981 				--xp;
1982 				/* and the delimiter */
1983 				break;
1984 			}
1985 		} else if (c == delim) {
1986 			goto c_read_readdone;
1987 		} else if (!rawmode && c == '\\') {
1988 			expanding = true;
1989 		}
1990 		Xcheck(xs, xp);
1991 		++xp;
1992 		break;
1993 	}
1994 	goto c_read_readloop;
1995 
1996  c_read_readdone:
1997 	bytesread = Xlength(xs, xp);
1998 	Xput(xs, xp, '\0');
1999 
2000 	/*-
2001 	 * state: we finished reading the input and NUL terminated it
2002 	 * Xstring(xs, xp) -> xp-1 = input string without trailing delim
2003 	 * rv = 1 if EOF, 0 otherwise (errors handled already)
2004 	 */
2005 
2006 	if (rv == 1) {
2007 		/* clean up coprocess if needed, on EOF */
2008 		coproc_read_close(fd);
2009 		if (readmode == READALL)
2010 			/* EOF is no error here */
2011 			rv = 0;
2012 	}
2013 
2014 	if (savehist)
2015 		histsave(&source->line, Xstring(xs, xp), true, false);
2016 
2017 	ccp = cp = Xclose(xs, xp);
2018 	expanding = false;
2019 	XinitN(xs, 128, ATEMP);
2020 	if (intoarray) {
2021 		vp = global(*wp);
2022 		if (vp->flag & RDONLY) {
2023  c_read_splitro:
2024 			bi_errorf("%s: %s", *wp, "is read only");
2025  c_read_spliterr:
2026 			rv = 2;
2027 			afree(cp, ATEMP);
2028 			goto c_read_out;
2029 		}
2030 		/* exporting an array is currently pointless */
2031 		unset(vp, 1);
2032 		/* counter for array index */
2033 		c = 0;
2034 	}
2035 	if (!aschars) {
2036 		/* skip initial IFS whitespace */
2037 		while (bytesread && is_ifsws(*ccp)) {
2038 			++ccp;
2039 			--bytesread;
2040 		}
2041 		/* trim trailing IFS whitespace */
2042 		while (bytesread && is_ifsws(ccp[bytesread - 1])) {
2043 			--bytesread;
2044 		}
2045 	}
2046  c_read_splitloop:
2047 	xp = Xstring(xs, xp);
2048 	/* generate next word */
2049 	if (!bytesread) {
2050 		/* no more input */
2051 		if (intoarray)
2052 			goto c_read_splitdone;
2053 		/* zero out next parameters */
2054 		goto c_read_gotword;
2055 	}
2056 	if (aschars) {
2057 		Xput(xs, xp, '1');
2058 		Xput(xs, xp, '#');
2059 		bytesleft = utf_ptradj(ccp);
2060 		while (bytesleft && bytesread) {
2061 			*xp++ = *ccp++;
2062 			--bytesleft;
2063 			--bytesread;
2064 		}
2065 		if (xp[-1] == '\0') {
2066 			xp[-1] = '0';
2067 			xp[-3] = '2';
2068 		}
2069 		goto c_read_gotword;
2070 	}
2071 
2072 	if (!intoarray && wp[1] == NULL)
2073 		lastparm = 1;
2074 
2075  c_read_splitlast:
2076 	/* copy until IFS character */
2077 	while (bytesread) {
2078 		char ch;
2079 
2080 		ch = *ccp;
2081 		if (expanding) {
2082 			expanding = false;
2083 			goto c_read_splitcopy;
2084 		} else if (ctype(ch, C_IFS)) {
2085 			break;
2086 		} else if (!rawmode && ch == '\\') {
2087 			expanding = true;
2088 		} else {
2089  c_read_splitcopy:
2090 			Xcheck(xs, xp);
2091 			Xput(xs, xp, ch);
2092 		}
2093 		++ccp;
2094 		--bytesread;
2095 	}
2096 	xsave = Xsavepos(xs, xp);
2097 	/* copy word delimiter: IFSWS+IFS,IFSWS */
2098 	while (bytesread) {
2099 		char ch;
2100 
2101 		ch = *ccp;
2102 		if (!ctype(ch, C_IFS))
2103 			break;
2104 		Xcheck(xs, xp);
2105 		Xput(xs, xp, ch);
2106 		++ccp;
2107 		--bytesread;
2108 		if (!ctype(ch, C_IFSWS))
2109 			break;
2110 	}
2111 	while (bytesread && is_ifsws(*ccp)) {
2112 		Xcheck(xs, xp);
2113 		Xput(xs, xp, *ccp);
2114 		++ccp;
2115 		--bytesread;
2116 	}
2117 	/* if no more parameters, rinse and repeat */
2118 	if (lastparm && bytesread) {
2119 		++lastparm;
2120 		goto c_read_splitlast;
2121 	}
2122 	/* get rid of the delimiter unless we pack the rest */
2123 	if (lastparm < 2)
2124 		xp = Xrestpos(xs, xp, xsave);
2125  c_read_gotword:
2126 	Xput(xs, xp, '\0');
2127 	if (intoarray) {
2128 		vq = arraysearch(vp, c++);
2129 	} else {
2130 		vq = global(*wp);
2131 		/* must be checked before exporting */
2132 		if (vq->flag & RDONLY)
2133 			goto c_read_splitro;
2134 		if (Flag(FEXPORT))
2135 			typeset(*wp, EXPORT, 0, 0, 0);
2136 	}
2137 	if (!setstr(vq, Xstring(xs, xp), KSH_RETURN_ERROR))
2138 		goto c_read_spliterr;
2139 	if (aschars) {
2140 		setint_v(vq, vq, false);
2141 		/* protect from UTFMODE changes */
2142 		vq->type = 0;
2143 	}
2144 	if (intoarray || *++wp != NULL)
2145 		goto c_read_splitloop;
2146 
2147  c_read_splitdone:
2148 	/* free up */
2149 	afree(cp, ATEMP);
2150 
2151  c_read_out:
2152 	afree(allocd, ATEMP);
2153 	Xfree(xs, xp);
2154 	if (restore_tios)
2155 		tcsetattr(fd, TCSADRAIN, &tios);
2156 	return (rv);
2157 #undef is_ifsws
2158 }
2159 
2160 int
c_eval(const char ** wp)2161 c_eval(const char **wp)
2162 {
2163 	struct source *s, *saves = source;
2164 	unsigned char savef;
2165 	int rv;
2166 
2167 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
2168 		return (1);
2169 	s = pushs(SWORDS, ATEMP);
2170 	s->u.strv = wp + builtin_opt.optind;
2171 
2172 	/*-
2173 	 * The following code handles the case where the command is
2174 	 * empty due to failed command substitution, for example by
2175 	 *	eval "$(false)"
2176 	 * This has historically returned 1 by AT&T ksh88. In this
2177 	 * case, shell() will not set or change exstat because the
2178 	 * compiled tree is empty, so it will use the value we pass
2179 	 * from subst_exstat, which is cleared in execute(), so it
2180 	 * should have been 0 if there were no substitutions.
2181 	 *
2182 	 * POSIX however says we don't do this, even though it is
2183 	 * traditionally done. AT&T ksh93 agrees with POSIX, so we
2184 	 * do. The following is an excerpt from SUSv4 [1003.2-2008]:
2185 	 *
2186 	 * 2.9.1: Simple Commands
2187 	 *	... If there is a command name, execution shall
2188 	 *	continue as described in 2.9.1.1 [Command Search
2189 	 *	and Execution]. If there is no command name, but
2190 	 *	the command contained a command substitution, the
2191 	 *	command shall complete with the exit status of the
2192 	 *	last command substitution performed.
2193 	 * 2.9.1.1: Command Search and Execution
2194 	 *	(1) a. If the command name matches the name of a
2195 	 *	special built-in utility, that special built-in
2196 	 *	utility shall be invoked.
2197 	 * 2.14.5: eval
2198 	 *	If there are no arguments, or only null arguments,
2199 	 *	eval shall return a zero exit status; ...
2200 	 */
2201 	/* exstat = subst_exstat; */	/* AT&T ksh88 */
2202 	exstat = 0;			/* SUSv4 */
2203 
2204 	savef = Flag(FERREXIT);
2205 	Flag(FERREXIT) = 0;
2206 	rv = shell(s, false);
2207 	Flag(FERREXIT) = savef;
2208 	source = saves;
2209 	afree(s, ATEMP);
2210 	return (rv);
2211 }
2212 
2213 int
c_trap(const char ** wp)2214 c_trap(const char **wp)
2215 {
2216 	int i;
2217 	const char *s;
2218 	Trap *p;
2219 
2220 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
2221 		return (1);
2222 	wp += builtin_opt.optind;
2223 
2224 	if (*wp == NULL) {
2225 		for (p = sigtraps, i = NSIG+1; --i >= 0; p++)
2226 			if (p->trap != NULL) {
2227 				shf_puts("trap -- ", shl_stdout);
2228 				print_value_quoted(p->trap);
2229 				shprintf(" %s\n", p->name);
2230 			}
2231 		return (0);
2232 	}
2233 
2234 	/*
2235 	 * Use case sensitive lookup for first arg so the
2236 	 * command 'exit' isn't confused with the pseudo-signal
2237 	 * 'EXIT'.
2238 	 */
2239 	/* get command */
2240 	s = (gettrap(*wp, false) == NULL) ? *wp++ : NULL;
2241 	if (s != NULL && s[0] == '-' && s[1] == '\0')
2242 		s = NULL;
2243 
2244 	/* set/clear traps */
2245 	i = 0;
2246 	while (*wp != NULL)
2247 		if ((p = gettrap(*wp++, true)) == NULL) {
2248 			warningf(true, "%s: %s '%s'", builtin_argv0,
2249 			    "bad signal", wp[-1]);
2250 			++i;
2251 		} else
2252 			settrap(p, s);
2253 	return (i);
2254 }
2255 
2256 int
c_exitreturn(const char ** wp)2257 c_exitreturn(const char **wp)
2258 {
2259 	int n, how = LEXIT;
2260 	const char *arg;
2261 
2262 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
2263 		return (1);
2264 	arg = wp[builtin_opt.optind];
2265 
2266 	if (arg) {
2267 		if (!getn(arg, &n)) {
2268 			exstat = 1;
2269 			warningf(true, "%s: %s", arg, "bad number");
2270 		} else
2271 			exstat = n;
2272 	} else if (trap_exstat != -1)
2273 		exstat = trap_exstat;
2274 	if (wp[0][0] == 'r') {
2275 		/* return */
2276 		struct env *ep;
2277 
2278 		/*
2279 		 * need to tell if this is exit or return so trap exit will
2280 		 * work right (POSIX)
2281 		 */
2282 		for (ep = e; ep; ep = ep->oenv)
2283 			if (STOP_RETURN(ep->type)) {
2284 				how = LRETURN;
2285 				break;
2286 			}
2287 	}
2288 
2289 	if (how == LEXIT && !really_exit && j_stopped_running()) {
2290 		really_exit = 1;
2291 		how = LSHELL;
2292 	}
2293 
2294 	/* get rid of any i/o redirections */
2295 	quitenv(NULL);
2296 	unwind(how);
2297 	/* NOTREACHED */
2298 }
2299 
2300 int
c_brkcont(const char ** wp)2301 c_brkcont(const char **wp)
2302 {
2303 	int n, quit;
2304 	struct env *ep, *last_ep = NULL;
2305 	const char *arg;
2306 
2307 	if (ksh_getopt(wp, &builtin_opt, null) == '?')
2308 		return (1);
2309 	arg = wp[builtin_opt.optind];
2310 
2311 	if (!arg)
2312 		n = 1;
2313 	else if (!bi_getn(arg, &n))
2314 		return (1);
2315 	quit = n;
2316 	if (quit <= 0) {
2317 		/* AT&T ksh does this for non-interactive shells only - weird */
2318 		bi_errorf("%s: %s", arg, "bad value");
2319 		return (1);
2320 	}
2321 
2322 	/* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */
2323 	for (ep = e; ep && !STOP_BRKCONT(ep->type); ep = ep->oenv)
2324 		if (ep->type == E_LOOP) {
2325 			if (--quit == 0)
2326 				break;
2327 			ep->flags |= EF_BRKCONT_PASS;
2328 			last_ep = ep;
2329 		}
2330 
2331 	if (quit) {
2332 		/*
2333 		 * AT&T ksh doesn't print a message - just does what it
2334 		 * can. We print a message 'cause it helps in debugging
2335 		 * scripts, but don't generate an error (ie, keep going).
2336 		 */
2337 		if (n == quit) {
2338 			warningf(true, "%s: %s %s", wp[0], "can't", wp[0]);
2339 			return (0);
2340 		}
2341 		/*
2342 		 * POSIX says if n is too big, the last enclosing loop
2343 		 * shall be used. Doesn't say to print an error but we
2344 		 * do anyway 'cause the user messed up.
2345 		 */
2346 		if (last_ep)
2347 			last_ep->flags &= ~EF_BRKCONT_PASS;
2348 		warningf(true, "%s: can only %s %d level(s)",
2349 		    wp[0], wp[0], n - quit);
2350 	}
2351 
2352 	unwind(*wp[0] == 'b' ? LBREAK : LCONTIN);
2353 	/* NOTREACHED */
2354 }
2355 
2356 int
c_set(const char ** wp)2357 c_set(const char **wp)
2358 {
2359 	int argi;
2360 	bool setargs;
2361 	struct block *l = e->loc;
2362 	const char **owp;
2363 
2364 	if (wp[1] == NULL) {
2365 		static const char *args[] = { Tset, "-", NULL };
2366 		return (c_typeset(args));
2367 	}
2368 
2369 	argi = parse_args(wp, OF_SET, &setargs);
2370 	if (argi < 0)
2371 		return (1);
2372 	/* set $# and $* */
2373 	if (setargs) {
2374 		wp += argi - 1;
2375 		owp = wp;
2376 		/* save $0 */
2377 		wp[0] = l->argv[0];
2378 		while (*++wp != NULL)
2379 			strdupx(*wp, *wp, &l->area);
2380 		l->argc = wp - owp - 1;
2381 		l->argv = alloc2(l->argc + 2, sizeof(char *), &l->area);
2382 		for (wp = l->argv; (*wp++ = *owp++) != NULL; )
2383 			;
2384 	}
2385 	/*-
2386 	 * POSIX says set exit status is 0, but old scripts that use
2387 	 * getopt(1) use the construct
2388 	 *	set -- $(getopt ab:c "$@")
2389 	 * which assumes the exit value set will be that of the $()
2390 	 * (subst_exstat is cleared in execute() so that it will be 0
2391 	 * if there are no command substitutions).
2392 	 * Switched ksh (!posix !sh) to POSIX in mksh R39b.
2393 	 */
2394 	return (Flag(FSH) ? subst_exstat : 0);
2395 }
2396 
2397 int
c_unset(const char ** wp)2398 c_unset(const char **wp)
2399 {
2400 	const char *id;
2401 	int optc, rv = 0;
2402 	bool unset_var = true;
2403 
2404 	while ((optc = ksh_getopt(wp, &builtin_opt, "fv")) != -1)
2405 		switch (optc) {
2406 		case 'f':
2407 			unset_var = false;
2408 			break;
2409 		case 'v':
2410 			unset_var = true;
2411 			break;
2412 		case '?':
2413 			/*XXX not reached due to GF_ERROR */
2414 			return (2);
2415 		}
2416 	wp += builtin_opt.optind;
2417 	for (; (id = *wp) != NULL; wp++)
2418 		if (unset_var) {
2419 			/* unset variable */
2420 			struct tbl *vp;
2421 			char *cp = NULL;
2422 			size_t n;
2423 
2424 			n = strlen(id);
2425 			if (n > 3 && id[n-3] == '[' && id[n-2] == '*' &&
2426 			    id[n-1] == ']') {
2427 				strndupx(cp, id, n - 3, ATEMP);
2428 				id = cp;
2429 				optc = 3;
2430 			} else
2431 				optc = vstrchr(id, '[') ? 0 : 1;
2432 
2433 			vp = global(id);
2434 			afree(cp, ATEMP);
2435 
2436 			if ((vp->flag&RDONLY)) {
2437 				warningf(true, "%s: %s", vp->name,
2438 				    "is read only");
2439 				rv = 1;
2440 			} else
2441 				unset(vp, optc);
2442 		} else
2443 			/* unset function */
2444 			define(id, NULL);
2445 	return (rv);
2446 }
2447 
2448 static void
p_time(struct shf * shf,bool posix,long tv_sec,int tv_usec,int width,const char * prefix,const char * suffix)2449 p_time(struct shf *shf, bool posix, long tv_sec, int tv_usec, int width,
2450     const char *prefix, const char *suffix)
2451 {
2452 	tv_usec /= 10000;
2453 	if (posix)
2454 		shf_fprintf(shf, "%s%*ld.%02d%s", prefix, width,
2455 		    tv_sec, tv_usec, suffix);
2456 	else
2457 		shf_fprintf(shf, "%s%*ldm%d.%02ds%s", prefix, width,
2458 		    tv_sec / 60, (int)(tv_sec % 60), tv_usec, suffix);
2459 }
2460 
2461 int
c_times(const char ** wp MKSH_A_UNUSED)2462 c_times(const char **wp MKSH_A_UNUSED)
2463 {
2464 	struct rusage usage;
2465 
2466 	getrusage(RUSAGE_SELF, &usage);
2467 	p_time(shl_stdout, false, usage.ru_utime.tv_sec,
2468 	    usage.ru_utime.tv_usec, 0, null, " ");
2469 	p_time(shl_stdout, false, usage.ru_stime.tv_sec,
2470 	    usage.ru_stime.tv_usec, 0, null, "\n");
2471 
2472 	getrusage(RUSAGE_CHILDREN, &usage);
2473 	p_time(shl_stdout, false, usage.ru_utime.tv_sec,
2474 	    usage.ru_utime.tv_usec, 0, null, " ");
2475 	p_time(shl_stdout, false, usage.ru_stime.tv_sec,
2476 	    usage.ru_stime.tv_usec, 0, null, "\n");
2477 
2478 	return (0);
2479 }
2480 
2481 /*
2482  * time pipeline (really a statement, not a built-in command)
2483  */
2484 int
timex(struct op * t,int f,volatile int * xerrok)2485 timex(struct op *t, int f, volatile int *xerrok)
2486 {
2487 #define TF_NOARGS	BIT(0)
2488 #define TF_NOREAL	BIT(1)		/* don't report real time */
2489 #define TF_POSIX	BIT(2)		/* report in POSIX format */
2490 	int rv = 0, tf = 0;
2491 	struct rusage ru0, ru1, cru0, cru1;
2492 	struct timeval usrtime, systime, tv0, tv1;
2493 
2494 	gettimeofday(&tv0, NULL);
2495 	getrusage(RUSAGE_SELF, &ru0);
2496 	getrusage(RUSAGE_CHILDREN, &cru0);
2497 	if (t->left) {
2498 		/*
2499 		 * Two ways of getting cpu usage of a command: just use t0
2500 		 * and t1 (which will get cpu usage from other jobs that
2501 		 * finish while we are executing t->left), or get the
2502 		 * cpu usage of t->left. AT&T ksh does the former, while
2503 		 * pdksh tries to do the later (the j_usrtime hack doesn't
2504 		 * really work as it only counts the last job).
2505 		 */
2506 		timerclear(&j_usrtime);
2507 		timerclear(&j_systime);
2508 		rv = execute(t->left, f | XTIME, xerrok);
2509 		if (t->left->type == TCOM)
2510 			tf |= t->left->str[0];
2511 		gettimeofday(&tv1, NULL);
2512 		getrusage(RUSAGE_SELF, &ru1);
2513 		getrusage(RUSAGE_CHILDREN, &cru1);
2514 	} else
2515 		tf = TF_NOARGS;
2516 
2517 	if (tf & TF_NOARGS) {
2518 		/* ksh93 - report shell times (shell+kids) */
2519 		tf |= TF_NOREAL;
2520 		timeradd(&ru0.ru_utime, &cru0.ru_utime, &usrtime);
2521 		timeradd(&ru0.ru_stime, &cru0.ru_stime, &systime);
2522 	} else {
2523 		timersub(&ru1.ru_utime, &ru0.ru_utime, &usrtime);
2524 		timeradd(&usrtime, &j_usrtime, &usrtime);
2525 		timersub(&ru1.ru_stime, &ru0.ru_stime, &systime);
2526 		timeradd(&systime, &j_systime, &systime);
2527 	}
2528 
2529 	if (!(tf & TF_NOREAL)) {
2530 		timersub(&tv1, &tv0, &tv1);
2531 		if (tf & TF_POSIX)
2532 			p_time(shl_out, true, tv1.tv_sec, tv1.tv_usec,
2533 			    5, "real ", "\n");
2534 		else
2535 			p_time(shl_out, false, tv1.tv_sec, tv1.tv_usec,
2536 			    5, null, " real ");
2537 	}
2538 	if (tf & TF_POSIX)
2539 		p_time(shl_out, true, usrtime.tv_sec, usrtime.tv_usec,
2540 		    5, "user ", "\n");
2541 	else
2542 		p_time(shl_out, false, usrtime.tv_sec, usrtime.tv_usec,
2543 		    5, null, " user ");
2544 	if (tf & TF_POSIX)
2545 		p_time(shl_out, true, systime.tv_sec, systime.tv_usec,
2546 		    5, "sys  ", "\n");
2547 	else
2548 		p_time(shl_out, false, systime.tv_sec, systime.tv_usec,
2549 		    5, null, " system\n");
2550 	shf_flush(shl_out);
2551 
2552 	return (rv);
2553 }
2554 
2555 void
timex_hook(struct op * t,char ** volatile * app)2556 timex_hook(struct op *t, char **volatile *app)
2557 {
2558 	char **wp = *app;
2559 	int optc, i, j;
2560 	Getopt opt;
2561 
2562 	ksh_getopt_reset(&opt, 0);
2563 	/* start at the start */
2564 	opt.optind = 0;
2565 	while ((optc = ksh_getopt((const char **)wp, &opt, ":p")) != -1)
2566 		switch (optc) {
2567 		case 'p':
2568 			t->str[0] |= TF_POSIX;
2569 			break;
2570 		case '?':
2571 			errorf("time: -%s %s", opt.optarg,
2572 			    "unknown option");
2573 		case ':':
2574 			errorf("time: -%s %s", opt.optarg,
2575 			    "requires an argument");
2576 		}
2577 	/* Copy command words down over options. */
2578 	if (opt.optind != 0) {
2579 		for (i = 0; i < opt.optind; i++)
2580 			afree(wp[i], ATEMP);
2581 		for (i = 0, j = opt.optind; (wp[i] = wp[j]); i++, j++)
2582 			;
2583 	}
2584 	if (!wp[0])
2585 		t->str[0] |= TF_NOARGS;
2586 	*app = wp;
2587 }
2588 
2589 /* exec with no args - args case is taken care of in comexec() */
2590 int
c_exec(const char ** wp MKSH_A_UNUSED)2591 c_exec(const char **wp MKSH_A_UNUSED)
2592 {
2593 	int i;
2594 
2595 	/* make sure redirects stay in place */
2596 	if (e->savefd != NULL) {
2597 		for (i = 0; i < NUFILE; i++) {
2598 			if (e->savefd[i] > 0)
2599 				close(e->savefd[i]);
2600 			/*
2601 			 * keep all file descriptors > 2 private for ksh,
2602 			 * but not for POSIX or legacy/kludge sh
2603 			 */
2604 			if (!Flag(FPOSIX) && !Flag(FSH) && i > 2 &&
2605 			    e->savefd[i])
2606 				fcntl(i, F_SETFD, FD_CLOEXEC);
2607 		}
2608 		e->savefd = NULL;
2609 	}
2610 	return (0);
2611 }
2612 
2613 #if HAVE_MKNOD
2614 int
c_mknod(const char ** wp)2615 c_mknod(const char **wp)
2616 {
2617 	int argc, optc, rv = 0;
2618 	bool ismkfifo = false;
2619 	const char **argv;
2620 	void *set = NULL;
2621 	mode_t mode = 0, oldmode = 0;
2622 
2623 	while ((optc = ksh_getopt(wp, &builtin_opt, "m:")) != -1) {
2624 		switch (optc) {
2625 		case 'm':
2626 			set = setmode(builtin_opt.optarg);
2627 			if (set == NULL) {
2628 				bi_errorf("invalid file mode");
2629 				return (1);
2630 			}
2631 			mode = getmode(set, (mode_t)(DEFFILEMODE));
2632 			free_ossetmode(set);
2633 			break;
2634 		default:
2635 			goto c_mknod_usage;
2636 		}
2637 	}
2638 	argv = &wp[builtin_opt.optind];
2639 	if (argv[0] == NULL)
2640 		goto c_mknod_usage;
2641 	for (argc = 0; argv[argc]; argc++)
2642 		;
2643 	if (argc == 2 && argv[1][0] == 'p')
2644 		ismkfifo = true;
2645 	else if (argc != 4 || (argv[1][0] != 'b' && argv[1][0] != 'c'))
2646 		goto c_mknod_usage;
2647 
2648 	if (set != NULL)
2649 		oldmode = umask((mode_t)0);
2650 	else
2651 		mode = DEFFILEMODE;
2652 
2653 	mode |= (argv[1][0] == 'b') ? S_IFBLK :
2654 	    (argv[1][0] == 'c') ? S_IFCHR : 0;
2655 
2656 	if (!ismkfifo) {
2657 		unsigned long majnum, minnum;
2658 		dev_t dv;
2659 		char *c;
2660 
2661 		majnum = strtoul(argv[2], &c, 0);
2662 		if ((c == argv[2]) || (*c != '\0')) {
2663 			bi_errorf("non-numeric %s %s '%s'", "device", "major", argv[2]);
2664 			goto c_mknod_err;
2665 		}
2666 		minnum = strtoul(argv[3], &c, 0);
2667 		if ((c == argv[3]) || (*c != '\0')) {
2668 			bi_errorf("non-numeric %s %s '%s'", "device", "minor", argv[3]);
2669 			goto c_mknod_err;
2670 		}
2671 		dv = makedev(majnum, minnum);
2672 		if ((unsigned long)(major(dv)) != majnum) {
2673 			bi_errorf("%s %s too large: %lu", "device", "major", majnum);
2674 			goto c_mknod_err;
2675 		}
2676 		if ((unsigned long)(minor(dv)) != minnum) {
2677 			bi_errorf("%s %s too large: %lu", "device", "minor", minnum);
2678 			goto c_mknod_err;
2679 		}
2680 		if (mknod(argv[0], mode, dv))
2681 			goto c_mknod_failed;
2682 	} else if (mkfifo(argv[0], mode)) {
2683  c_mknod_failed:
2684 		bi_errorf("%s: %s", argv[0], strerror(errno));
2685  c_mknod_err:
2686 		rv = 1;
2687 	}
2688 
2689 	if (set)
2690 		umask(oldmode);
2691 	return (rv);
2692  c_mknod_usage:
2693 	bi_errorf("%s: %s", "usage", "mknod [-m mode] name b|c major minor");
2694 	bi_errorf("%s: %s", "usage", "mknod [-m mode] name p");
2695 	return (1);
2696 }
2697 #endif
2698 
2699 /*-
2700    test(1) accepts the following grammar:
2701 	oexpr	::= aexpr | aexpr "-o" oexpr ;
2702 	aexpr	::= nexpr | nexpr "-a" aexpr ;
2703 	nexpr	::= primary | "!" nexpr ;
2704 	primary	::= unary-operator operand
2705 		| operand binary-operator operand
2706 		| operand
2707 		| "(" oexpr ")"
2708 		;
2709 
2710 	unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"|
2711 			   "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|
2712 			   "-L"|"-h"|"-S"|"-H";
2713 
2714 	binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
2715 			    "-nt"|"-ot"|"-ef"|
2716 			    "<"|">"	# rules used for [[ .. ]] expressions
2717 			    ;
2718 	operand ::= <any thing>
2719 */
2720 
2721 /* POSIX says > 1 for errors */
2722 #define T_ERR_EXIT	2
2723 
2724 int
c_test(const char ** wp)2725 c_test(const char **wp)
2726 {
2727 	int argc, res;
2728 	Test_env te;
2729 
2730 	te.flags = 0;
2731 	te.isa = ptest_isa;
2732 	te.getopnd = ptest_getopnd;
2733 	te.eval = test_eval;
2734 	te.error = ptest_error;
2735 
2736 	for (argc = 0; wp[argc]; argc++)
2737 		;
2738 
2739 	if (strcmp(wp[0], "[") == 0) {
2740 		if (strcmp(wp[--argc], "]") != 0) {
2741 			bi_errorf("missing ]");
2742 			return (T_ERR_EXIT);
2743 		}
2744 	}
2745 
2746 	te.pos.wp = wp + 1;
2747 	te.wp_end = wp + argc;
2748 
2749 	/*
2750 	 * Handle the special cases from POSIX.2, section 4.62.4.
2751 	 * Implementation of all the rules isn't necessary since
2752 	 * our parser does the right thing for the omitted steps.
2753 	 */
2754 	if (argc <= 5) {
2755 		const char **owp = wp, **owpend = te.wp_end;
2756 		int invert = 0;
2757 		Test_op op;
2758 		const char *opnd1, *opnd2;
2759 
2760 		if (argc >= 2 && ((*te.isa)(&te, TM_OPAREN))) {
2761 			te.pos.wp = te.wp_end - 1;
2762 			if ((*te.isa)(&te, TM_CPAREN)) {
2763 				argc -= 2;
2764 				te.wp_end--;
2765 				te.pos.wp = owp + 2;
2766 			} else {
2767 				te.pos.wp = owp + 1;
2768 				te.wp_end = owpend;
2769 			}
2770 		}
2771 
2772 		while (--argc >= 0) {
2773 			if ((*te.isa)(&te, TM_END))
2774 				return (!0);
2775 			if (argc == 3) {
2776 				opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
2777 				if ((op = (*te.isa)(&te, TM_BINOP))) {
2778 					opnd2 = (*te.getopnd)(&te, op, 1);
2779 					res = (*te.eval)(&te, op, opnd1,
2780 					    opnd2, 1);
2781 					if (te.flags & TEF_ERROR)
2782 						return (T_ERR_EXIT);
2783 					if (invert & 1)
2784 						res = !res;
2785 					return (!res);
2786 				}
2787 				/* back up to opnd1 */
2788 				te.pos.wp--;
2789 			}
2790 			if (argc == 1) {
2791 				opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
2792 				res = (*te.eval)(&te, TO_STNZE, opnd1,
2793 				    NULL, 1);
2794 				if (invert & 1)
2795 					res = !res;
2796 				return (!res);
2797 			}
2798 			if ((*te.isa)(&te, TM_NOT)) {
2799 				invert++;
2800 			} else
2801 				break;
2802 		}
2803 		te.pos.wp = owp + 1;
2804 		te.wp_end = owpend;
2805 	}
2806 
2807 	return (test_parse(&te));
2808 }
2809 
2810 /*
2811  * Generic test routines.
2812  */
2813 
2814 Test_op
test_isop(Test_meta meta,const char * s)2815 test_isop(Test_meta meta, const char *s)
2816 {
2817 	char sc1;
2818 	const struct t_op *tbl;
2819 
2820 	tbl = meta == TM_UNOP ? u_ops : b_ops;
2821 	if (*s) {
2822 		sc1 = s[1];
2823 		for (; tbl->op_text[0]; tbl++)
2824 			if (sc1 == tbl->op_text[1] && !strcmp(s, tbl->op_text))
2825 				return (tbl->op_num);
2826 	}
2827 	return (TO_NONOP);
2828 }
2829 
2830 int
test_eval(Test_env * te,Test_op op,const char * opnd1,const char * opnd2,bool do_eval)2831 test_eval(Test_env *te, Test_op op, const char *opnd1, const char *opnd2,
2832     bool do_eval)
2833 {
2834 	int i, s;
2835 	size_t k;
2836 	struct stat b1, b2;
2837 	mksh_ari_t v1, v2;
2838 
2839 	if (!do_eval)
2840 		return (0);
2841 
2842 	switch (op) {
2843 
2844 	/*
2845 	 * Unary Operators
2846 	 */
2847 
2848 	/* -n */
2849 	case TO_STNZE:
2850 		return (*opnd1 != '\0');
2851 
2852 	/* -z */
2853 	case TO_STZER:
2854 		return (*opnd1 == '\0');
2855 
2856 	/* -o */
2857 	case TO_OPTION:
2858 		if ((i = *opnd1) == '!' || i == '?')
2859 			opnd1++;
2860 		if ((k = option(opnd1)) == (size_t)-1)
2861 			return (0);
2862 		return (i == '?' ? 1 : i == '!' ? !Flag(k) : Flag(k));
2863 
2864 	/* -r */
2865 	case TO_FILRD:
2866 		/* LINTED use of access */
2867 		return (access(opnd1, R_OK) == 0);
2868 
2869 	/* -w */
2870 	case TO_FILWR:
2871 		/* LINTED use of access */
2872 		return (access(opnd1, W_OK) == 0);
2873 
2874 	/* -x */
2875 	case TO_FILEX:
2876 		return (ksh_access(opnd1, X_OK) == 0);
2877 
2878 	/* -a */
2879 	case TO_FILAXST:
2880 	/* -e */
2881 	case TO_FILEXST:
2882 		return (stat(opnd1, &b1) == 0);
2883 
2884 	/* -r */
2885 	case TO_FILREG:
2886 		return (stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode));
2887 
2888 	/* -d */
2889 	case TO_FILID:
2890 		return (stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode));
2891 
2892 	/* -c */
2893 	case TO_FILCDEV:
2894 		return (stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode));
2895 
2896 	/* -b */
2897 	case TO_FILBDEV:
2898 		return (stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode));
2899 
2900 	/* -p */
2901 	case TO_FILFIFO:
2902 		return (stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode));
2903 
2904 	/* -h or -L */
2905 	case TO_FILSYM:
2906 		return (lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode));
2907 
2908 	/* -S */
2909 	case TO_FILSOCK:
2910 		return (stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode));
2911 
2912 	/* -H => HP context dependent files (directories) */
2913 	case TO_FILCDF:
2914 #ifdef S_ISCDF
2915 	{
2916 		char *nv;
2917 
2918 		/*
2919 		 * Append a + to filename and check to see if result is
2920 		 * a setuid directory. CDF stuff in general is hookey,
2921 		 * since it breaks for, e.g., the following sequence:
2922 		 * echo hi >foo+; mkdir foo; echo bye >foo/default;
2923 		 * chmod u+s foo (foo+ refers to the file with hi in it,
2924 		 * there is no way to get at the file with bye in it;
2925 		 * please correct me if I'm wrong about this).
2926 		 */
2927 
2928 		nv = shf_smprintf("%s+", opnd1);
2929 		i = (stat(nv, &b1) == 0 && S_ISCDF(b1.st_mode));
2930 		afree(nv, ATEMP);
2931 		return (i);
2932 	}
2933 #else
2934 		return (0);
2935 #endif
2936 
2937 	/* -u */
2938 	case TO_FILSETU:
2939 		return (stat(opnd1, &b1) == 0 &&
2940 		    (b1.st_mode & S_ISUID) == S_ISUID);
2941 
2942 	/* -g */
2943 	case TO_FILSETG:
2944 		return (stat(opnd1, &b1) == 0 &&
2945 		    (b1.st_mode & S_ISGID) == S_ISGID);
2946 
2947 	/* -k */
2948 	case TO_FILSTCK:
2949 #ifdef S_ISVTX
2950 		return (stat(opnd1, &b1) == 0 &&
2951 		    (b1.st_mode & S_ISVTX) == S_ISVTX);
2952 #else
2953 		return (0);
2954 #endif
2955 
2956 	/* -s */
2957 	case TO_FILGZ:
2958 		return (stat(opnd1, &b1) == 0 && b1.st_size > 0L);
2959 
2960 	/* -t */
2961 	case TO_FILTT:
2962 		if (opnd1 && !bi_getn(opnd1, &i)) {
2963 			te->flags |= TEF_ERROR;
2964 			i = 0;
2965 		} else
2966 			i = isatty(opnd1 ? i : 0);
2967 		return (i);
2968 
2969 	/* -O */
2970 	case TO_FILUID:
2971 		return (stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid);
2972 
2973 	/* -G */
2974 	case TO_FILGID:
2975 		return (stat(opnd1, &b1) == 0 && b1.st_gid == getegid());
2976 
2977 	/*
2978 	 * Binary Operators
2979 	 */
2980 
2981 	/* = */
2982 	case TO_STEQL:
2983 		if (te->flags & TEF_DBRACKET)
2984 			return (gmatchx(opnd1, opnd2, false));
2985 		return (strcmp(opnd1, opnd2) == 0);
2986 
2987 	/* != */
2988 	case TO_STNEQ:
2989 		if (te->flags & TEF_DBRACKET)
2990 			return (!gmatchx(opnd1, opnd2, false));
2991 		return (strcmp(opnd1, opnd2) != 0);
2992 
2993 	/* < */
2994 	case TO_STLT:
2995 		return (strcmp(opnd1, opnd2) < 0);
2996 
2997 	/* > */
2998 	case TO_STGT:
2999 		return (strcmp(opnd1, opnd2) > 0);
3000 
3001 	/* -eq */
3002 	case TO_INTEQ:
3003 	/* -ne */
3004 	case TO_INTNE:
3005 	/* -ge */
3006 	case TO_INTGE:
3007 	/* -gt */
3008 	case TO_INTGT:
3009 	/* -le */
3010 	case TO_INTLE:
3011 	/* -lt */
3012 	case TO_INTLT:
3013 		if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR, false) ||
3014 		    !evaluate(opnd2, &v2, KSH_RETURN_ERROR, false)) {
3015 			/* error already printed.. */
3016 			te->flags |= TEF_ERROR;
3017 			return (1);
3018 		}
3019 		switch (op) {
3020 		case TO_INTEQ:
3021 			return (v1 == v2);
3022 		case TO_INTNE:
3023 			return (v1 != v2);
3024 		case TO_INTGE:
3025 			return (v1 >= v2);
3026 		case TO_INTGT:
3027 			return (v1 > v2);
3028 		case TO_INTLE:
3029 			return (v1 <= v2);
3030 		case TO_INTLT:
3031 			return (v1 < v2);
3032 		default:
3033 			/* NOTREACHED */
3034 			break;
3035 		}
3036 		/* NOTREACHED */
3037 
3038 	/* -nt */
3039 	case TO_FILNT:
3040 		/*
3041 		 * ksh88/ksh93 succeed if file2 can't be stated
3042 		 * (subtly different from 'does not exist').
3043 		 */
3044 		return (stat(opnd1, &b1) == 0 &&
3045 		    (((s = stat(opnd2, &b2)) == 0 &&
3046 		    b1.st_mtime > b2.st_mtime) || s < 0));
3047 
3048 	/* -ot */
3049 	case TO_FILOT:
3050 		/*
3051 		 * ksh88/ksh93 succeed if file1 can't be stated
3052 		 * (subtly different from 'does not exist').
3053 		 */
3054 		return (stat(opnd2, &b2) == 0 &&
3055 		    (((s = stat(opnd1, &b1)) == 0 &&
3056 		    b1.st_mtime < b2.st_mtime) || s < 0));
3057 
3058 	/* -ef */
3059 	case TO_FILEQ:
3060 		return (stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0 &&
3061 		    b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino);
3062 
3063 	/* all other cases */
3064 	case TO_NONOP:
3065 	case TO_NONNULL:
3066 		/* throw the error */
3067 		break;
3068 	}
3069 	(*te->error)(te, 0, "internal error: unknown op");
3070 	return (1);
3071 }
3072 
3073 int
test_parse(Test_env * te)3074 test_parse(Test_env *te)
3075 {
3076 	int rv;
3077 
3078 	rv = test_oexpr(te, 1);
3079 
3080 	if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END))
3081 		(*te->error)(te, 0, "unexpected operator/operand");
3082 
3083 	return ((te->flags & TEF_ERROR) ? T_ERR_EXIT : !rv);
3084 }
3085 
3086 static int
test_oexpr(Test_env * te,bool do_eval)3087 test_oexpr(Test_env *te, bool do_eval)
3088 {
3089 	int rv;
3090 
3091 	if ((rv = test_aexpr(te, do_eval)))
3092 		do_eval = false;
3093 	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR))
3094 		return (test_oexpr(te, do_eval) || rv);
3095 	return (rv);
3096 }
3097 
3098 static int
test_aexpr(Test_env * te,bool do_eval)3099 test_aexpr(Test_env *te, bool do_eval)
3100 {
3101 	int rv;
3102 
3103 	if (!(rv = test_nexpr(te, do_eval)))
3104 		do_eval = false;
3105 	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND))
3106 		return (test_aexpr(te, do_eval) && rv);
3107 	return (rv);
3108 }
3109 
3110 static int
test_nexpr(Test_env * te,bool do_eval)3111 test_nexpr(Test_env *te, bool do_eval)
3112 {
3113 	if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT))
3114 		return (!test_nexpr(te, do_eval));
3115 	return (test_primary(te, do_eval));
3116 }
3117 
3118 static int
test_primary(Test_env * te,bool do_eval)3119 test_primary(Test_env *te, bool do_eval)
3120 {
3121 	const char *opnd1, *opnd2;
3122 	int rv;
3123 	Test_op op;
3124 
3125 	if (te->flags & TEF_ERROR)
3126 		return (0);
3127 	if ((*te->isa)(te, TM_OPAREN)) {
3128 		rv = test_oexpr(te, do_eval);
3129 		if (te->flags & TEF_ERROR)
3130 			return (0);
3131 		if (!(*te->isa)(te, TM_CPAREN)) {
3132 			(*te->error)(te, 0, "missing )");
3133 			return (0);
3134 		}
3135 		return (rv);
3136 	}
3137 	/*
3138 	 * Binary should have precedence over unary in this case
3139 	 * so that something like test \( -f = -f \) is accepted
3140 	 */
3141 	if ((te->flags & TEF_DBRACKET) || (&te->pos.wp[1] < te->wp_end &&
3142 	    !test_isop(TM_BINOP, te->pos.wp[1]))) {
3143 		if ((op = (*te->isa)(te, TM_UNOP))) {
3144 			/* unary expression */
3145 			opnd1 = (*te->getopnd)(te, op, do_eval);
3146 			if (!opnd1) {
3147 				(*te->error)(te, -1, "missing argument");
3148 				return (0);
3149 			}
3150 
3151 			return ((*te->eval)(te, op, opnd1, NULL, do_eval));
3152 		}
3153 	}
3154 	opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval);
3155 	if (!opnd1) {
3156 		(*te->error)(te, 0, "expression expected");
3157 		return (0);
3158 	}
3159 	if ((op = (*te->isa)(te, TM_BINOP))) {
3160 		/* binary expression */
3161 		opnd2 = (*te->getopnd)(te, op, do_eval);
3162 		if (!opnd2) {
3163 			(*te->error)(te, -1, "missing second argument");
3164 			return (0);
3165 		}
3166 
3167 		return ((*te->eval)(te, op, opnd1, opnd2, do_eval));
3168 	}
3169 	return ((*te->eval)(te, TO_STNZE, opnd1, NULL, do_eval));
3170 }
3171 
3172 /*
3173  * Plain test (test and [ .. ]) specific routines.
3174  */
3175 
3176 /*
3177  * Test if the current token is a whatever. Accepts the current token if
3178  * it is. Returns 0 if it is not, non-zero if it is (in the case of
3179  * TM_UNOP and TM_BINOP, the returned value is a Test_op).
3180  */
3181 static Test_op
ptest_isa(Test_env * te,Test_meta meta)3182 ptest_isa(Test_env *te, Test_meta meta)
3183 {
3184 	/* Order important - indexed by Test_meta values */
3185 	static const char *const tokens[] = {
3186 		"-o", "-a", "!", "(", ")"
3187 	};
3188 	Test_op rv;
3189 
3190 	if (te->pos.wp >= te->wp_end)
3191 		return (meta == TM_END ? TO_NONNULL : TO_NONOP);
3192 
3193 	if (meta == TM_UNOP || meta == TM_BINOP)
3194 		rv = test_isop(meta, *te->pos.wp);
3195 	else if (meta == TM_END)
3196 		rv = TO_NONOP;
3197 	else
3198 		rv = !strcmp(*te->pos.wp, tokens[(int)meta]) ?
3199 		    TO_NONNULL : TO_NONOP;
3200 
3201 	/* Accept the token? */
3202 	if (rv != TO_NONOP)
3203 		te->pos.wp++;
3204 
3205 	return (rv);
3206 }
3207 
3208 static const char *
ptest_getopnd(Test_env * te,Test_op op,bool do_eval MKSH_A_UNUSED)3209 ptest_getopnd(Test_env *te, Test_op op, bool do_eval MKSH_A_UNUSED)
3210 {
3211 	if (te->pos.wp >= te->wp_end)
3212 		return (op == TO_FILTT ? "1" : NULL);
3213 	return (*te->pos.wp++);
3214 }
3215 
3216 static void
ptest_error(Test_env * te,int ofs,const char * msg)3217 ptest_error(Test_env *te, int ofs, const char *msg)
3218 {
3219 	const char *op;
3220 
3221 	te->flags |= TEF_ERROR;
3222 	if ((op = te->pos.wp + ofs >= te->wp_end ? NULL : te->pos.wp[ofs]))
3223 		bi_errorf("%s: %s", op, msg);
3224 	else
3225 		bi_errorf("%s", msg);
3226 }
3227 
3228 #ifndef MKSH_NO_LIMITS
3229 #define SOFT	0x1
3230 #define HARD	0x2
3231 
3232 struct limits {
3233 	const char *name;
3234 	int resource;		/* resource to get/set */
3235 	int factor;		/* multiply by to get rlim_{cur,max} values */
3236 	char option;
3237 };
3238 
3239 static void print_ulimit(const struct limits *, int);
3240 static int set_ulimit(const struct limits *, const char *, int);
3241 
3242 /* Magic to divine the 'm' and 'v' limits */
3243 
3244 #ifdef RLIMIT_AS
3245 #if !defined(RLIMIT_VMEM) || (RLIMIT_VMEM == RLIMIT_AS) || \
3246     !defined(RLIMIT_RSS) || (RLIMIT_VMEM == RLIMIT_RSS)
3247 #define ULIMIT_V_IS_AS
3248 #elif defined(RLIMIT_VMEM)
3249 #if !defined(RLIMIT_RSS) || (RLIMIT_RSS == RLIMIT_AS)
3250 #define ULIMIT_V_IS_AS
3251 #else
3252 #define ULIMIT_V_IS_VMEM
3253 #endif
3254 #endif
3255 #endif
3256 
3257 #ifdef RLIMIT_RSS
3258 #ifdef ULIMIT_V_IS_VMEM
3259 #define ULIMIT_M_IS_RSS
3260 #elif defined(RLIMIT_VMEM) && (RLIMIT_VMEM == RLIMIT_RSS)
3261 #define ULIMIT_M_IS_VMEM
3262 #else
3263 #define ULIMIT_M_IS_RSS
3264 #endif
3265 #if defined(ULIMIT_M_IS_RSS) && defined(RLIMIT_AS) && (RLIMIT_RSS == RLIMIT_AS)
3266 #undef ULIMIT_M_IS_RSS
3267 #endif
3268 #endif
3269 
3270 #if !defined(RLIMIT_AS) && !defined(ULIMIT_M_IS_VMEM) && defined(RLIMIT_VMEM)
3271 #define ULIMIT_V_IS_VMEM
3272 #endif
3273 
3274 #if !defined(ULIMIT_V_IS_VMEM) && defined(RLIMIT_VMEM) && \
3275     (!defined(RLIMIT_RSS) || (defined(RLIMIT_AS) && (RLIMIT_RSS == RLIMIT_AS)))
3276 #define ULIMIT_M_IS_VMEM
3277 #endif
3278 
3279 #if defined(ULIMIT_M_IS_VMEM) && defined(RLIMIT_AS) && \
3280     (RLIMIT_VMEM == RLIMIT_AS)
3281 #undef ULIMIT_M_IS_VMEM
3282 #endif
3283 
3284 
3285 int
c_ulimit(const char ** wp)3286 c_ulimit(const char **wp)
3287 {
3288 	static const struct limits limits[] = {
3289 		/* do not use options -H, -S or -a or change the order */
3290 #ifdef RLIMIT_CPU
3291 		{ "time(cpu-seconds)", RLIMIT_CPU, 1, 't' },
3292 #endif
3293 #ifdef RLIMIT_FSIZE
3294 		{ "file(blocks)", RLIMIT_FSIZE, 512, 'f' },
3295 #endif
3296 #ifdef RLIMIT_CORE
3297 		{ "coredump(blocks)", RLIMIT_CORE, 512, 'c' },
3298 #endif
3299 #ifdef RLIMIT_DATA
3300 		{ "data(KiB)", RLIMIT_DATA, 1024, 'd' },
3301 #endif
3302 #ifdef RLIMIT_STACK
3303 		{ "stack(KiB)", RLIMIT_STACK, 1024, 's' },
3304 #endif
3305 #ifdef RLIMIT_MEMLOCK
3306 		{ "lockedmem(KiB)", RLIMIT_MEMLOCK, 1024, 'l' },
3307 #endif
3308 #ifdef RLIMIT_NOFILE
3309 		{ "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' },
3310 #endif
3311 #ifdef RLIMIT_NPROC
3312 		{ "processes", RLIMIT_NPROC, 1, 'p' },
3313 #endif
3314 #ifdef RLIMIT_SWAP
3315 		{ "swap(KiB)", RLIMIT_SWAP, 1024, 'w' },
3316 #endif
3317 #ifdef RLIMIT_LOCKS
3318 		{ "flocks", RLIMIT_LOCKS, -1, 'L' },
3319 #endif
3320 #ifdef RLIMIT_TIME
3321 		{ "humantime(seconds)", RLIMIT_TIME, 1, 'T' },
3322 #endif
3323 #ifdef RLIMIT_NOVMON
3324 		{ "vnodemonitors", RLIMIT_NOVMON, 1, 'V' },
3325 #endif
3326 #ifdef RLIMIT_SIGPENDING
3327 		{ "sigpending", RLIMIT_SIGPENDING, 1, 'i' },
3328 #endif
3329 #ifdef RLIMIT_MSGQUEUE
3330 		{ "msgqueue(bytes)", RLIMIT_MSGQUEUE, 1, 'q' },
3331 #endif
3332 #ifdef RLIMIT_AIO_MEM
3333 		{ "AIOlockedmem(KiB)", RLIMIT_AIO_MEM, 1024, 'M' },
3334 #endif
3335 #ifdef RLIMIT_AIO_OPS
3336 		{ "AIOoperations", RLIMIT_AIO_OPS, 1, 'O' },
3337 #endif
3338 #ifdef RLIMIT_TCACHE
3339 		{ "cachedthreads", RLIMIT_TCACHE, 1, 'C' },
3340 #endif
3341 #ifdef RLIMIT_SBSIZE
3342 		{ "sockbufsiz(KiB)", RLIMIT_SBSIZE, 1024, 'B' },
3343 #endif
3344 #ifdef RLIMIT_PTHREAD
3345 		{ "threadsperprocess", RLIMIT_PTHREAD, 1, 'P' },
3346 #endif
3347 #ifdef RLIMIT_NICE
3348 		{ "maxnice", RLIMIT_NICE, 1, 'e' },
3349 #endif
3350 #ifdef RLIMIT_RTPRIO
3351 		{ "maxrtprio", RLIMIT_RTPRIO, 1, 'r' },
3352 #endif
3353 #if defined(ULIMIT_M_IS_RSS)
3354 		{ "resident-set(KiB)", RLIMIT_RSS, 1024, 'm' },
3355 #elif defined(ULIMIT_M_IS_VMEM)
3356 		{ "memory(KiB)", RLIMIT_VMEM, 1024, 'm' },
3357 #endif
3358 #if defined(ULIMIT_V_IS_VMEM)
3359 		{ "virtual-memory(KiB)", RLIMIT_VMEM, 1024, 'v' },
3360 #elif defined(ULIMIT_V_IS_AS)
3361 		{ "address-space(KiB)", RLIMIT_AS, 1024, 'v' },
3362 #endif
3363 		{ NULL, 0, 0, 0 }
3364 	};
3365 	static char opts[3 + NELEM(limits)];
3366 	int how = SOFT | HARD, optc, what = 'f';
3367 	bool all = false;
3368 	const struct limits *l;
3369 
3370 	if (!opts[0]) {
3371 		/* build options string on first call - yuck */
3372 		char *p = opts;
3373 
3374 		*p++ = 'H'; *p++ = 'S'; *p++ = 'a';
3375 		for (l = limits; l->name; l++)
3376 			*p++ = l->option;
3377 		*p = '\0';
3378 	}
3379 
3380 	while ((optc = ksh_getopt(wp, &builtin_opt, opts)) != -1)
3381 		switch (optc) {
3382 		case 'H':
3383 			how = HARD;
3384 			break;
3385 		case 'S':
3386 			how = SOFT;
3387 			break;
3388 		case 'a':
3389 			all = true;
3390 			break;
3391 		case '?':
3392 			bi_errorf("%s: %s", "usage",
3393 			    "ulimit [-acdfHLlmnpSsTtvw] [value]");
3394 			return (1);
3395 		default:
3396 			what = optc;
3397 		}
3398 
3399 	for (l = limits; l->name && l->option != what; l++)
3400 		;
3401 	if (!l->name) {
3402 		internal_warningf("ulimit: %c", what);
3403 		return (1);
3404 	}
3405 
3406 	if (wp[builtin_opt.optind]) {
3407 		if (all || wp[builtin_opt.optind + 1]) {
3408 			bi_errorf("too many arguments");
3409 			return (1);
3410 		}
3411 		return (set_ulimit(l, wp[builtin_opt.optind], how));
3412 	}
3413 	if (!all)
3414 		print_ulimit(l, how);
3415 	else for (l = limits; l->name; l++) {
3416 		shprintf("%-20s ", l->name);
3417 		print_ulimit(l, how);
3418 	}
3419 	return (0);
3420 }
3421 
3422 static int
set_ulimit(const struct limits * l,const char * v,int how)3423 set_ulimit(const struct limits *l, const char *v, int how)
3424 {
3425 	rlim_t val = (rlim_t)0;
3426 	struct rlimit limit;
3427 
3428 	if (strcmp(v, "unlimited") == 0)
3429 		val = (rlim_t)RLIM_INFINITY;
3430 	else {
3431 		mksh_ari_t rval;
3432 
3433 		if (!evaluate(v, &rval, KSH_RETURN_ERROR, false))
3434 			return (1);
3435 		/*
3436 		 * Avoid problems caused by typos that evaluate misses due
3437 		 * to evaluating unset parameters to 0...
3438 		 * If this causes problems, will have to add parameter to
3439 		 * evaluate() to control if unset params are 0 or an error.
3440 		 */
3441 		if (!rval && !ksh_isdigit(v[0])) {
3442 			bi_errorf("invalid %s limit: %s", l->name, v);
3443 			return (1);
3444 		}
3445 		val = (rlim_t)((rlim_t)rval * l->factor);
3446 	}
3447 
3448 	if (getrlimit(l->resource, &limit) < 0) {
3449 		/* some can't be read, e.g. Linux RLIMIT_LOCKS */
3450 		limit.rlim_cur = RLIM_INFINITY;
3451 		limit.rlim_max = RLIM_INFINITY;
3452 	}
3453 	if (how & SOFT)
3454 		limit.rlim_cur = val;
3455 	if (how & HARD)
3456 		limit.rlim_max = val;
3457 	if (!setrlimit(l->resource, &limit))
3458 		return (0);
3459 	if (errno == EPERM)
3460 		bi_errorf("%s exceeds allowable %s limit", v, l->name);
3461 	else
3462 		bi_errorf("bad %s limit: %s", l->name, strerror(errno));
3463 	return (1);
3464 }
3465 
3466 static void
print_ulimit(const struct limits * l,int how)3467 print_ulimit(const struct limits *l, int how)
3468 {
3469 	rlim_t val = (rlim_t)0;
3470 	struct rlimit limit;
3471 
3472 	if (getrlimit(l->resource, &limit)) {
3473 		shf_puts("unknown\n", shl_stdout);
3474 		return;
3475 	}
3476 	if (how & SOFT)
3477 		val = limit.rlim_cur;
3478 	else if (how & HARD)
3479 		val = limit.rlim_max;
3480 	if (val == (rlim_t)RLIM_INFINITY)
3481 		shf_puts("unlimited\n", shl_stdout);
3482 	else
3483 		shprintf("%ld\n", (long)(val / l->factor));
3484 }
3485 #endif
3486 
3487 int
c_rename(const char ** wp)3488 c_rename(const char **wp)
3489 {
3490 	int rv = 1;
3491 
3492 	/* skip argv[0] */
3493 	++wp;
3494 	if (wp[0] && !strcmp(wp[0], "--"))
3495 		/* skip "--" (options separator) */
3496 		++wp;
3497 
3498 	/* check for exactly two arguments */
3499 	if (wp[0] == NULL	/* first argument */ ||
3500 	    wp[1] == NULL	/* second argument */ ||
3501 	    wp[2] != NULL	/* no further args please */)
3502 		bi_errorf(Tsynerr);
3503 	else if ((rv = rename(wp[0], wp[1])) != 0) {
3504 		rv = errno;
3505 		bi_errorf("%s: %s", "failed", strerror(rv));
3506 	}
3507 
3508 	return (rv);
3509 }
3510 
3511 int
c_realpath(const char ** wp)3512 c_realpath(const char **wp)
3513 {
3514 	int rv = 1;
3515 	char *buf;
3516 
3517 	/* skip argv[0] */
3518 	++wp;
3519 	if (wp[0] && !strcmp(wp[0], "--"))
3520 		/* skip "--" (options separator) */
3521 		++wp;
3522 
3523 	/* check for exactly one argument */
3524 	if (wp[0] == NULL || wp[1] != NULL)
3525 		bi_errorf(Tsynerr);
3526 	else if ((buf = do_realpath(wp[0])) == NULL) {
3527 		rv = errno;
3528 		bi_errorf("%s: %s", wp[0], strerror(rv));
3529 		if ((unsigned int)rv > 255)
3530 			rv = 255;
3531 	} else {
3532 		shprintf("%s\n", buf);
3533 		afree(buf, ATEMP);
3534 		rv = 0;
3535 	}
3536 
3537 	return (rv);
3538 }
3539 
3540 int
c_cat(const char ** wp)3541 c_cat(const char **wp)
3542 {
3543 	int fd = STDIN_FILENO, rv;
3544 	ssize_t n, w;
3545 	const char *fn = "<stdin>";
3546 	char *buf, *cp;
3547 #define MKSH_CAT_BUFSIZ 4096
3548 
3549 	if ((buf = malloc_osfunc(MKSH_CAT_BUFSIZ)) == NULL) {
3550 		bi_errorf(Toomem, (unsigned long)MKSH_CAT_BUFSIZ);
3551 		return (1);
3552 	}
3553 
3554 	/* parse options: POSIX demands we support "-u" as no-op */
3555 	while ((rv = ksh_getopt(wp, &builtin_opt, "u")) != -1) {
3556 		switch (rv) {
3557 		case 'u':
3558 			/* we already operate unbuffered */
3559 			break;
3560 		default:
3561 			bi_errorf(Tsynerr);
3562 			return (1);
3563 		}
3564 	}
3565 	wp += builtin_opt.optind;
3566 	rv = 0;
3567 
3568 	do {
3569 		if (*wp) {
3570 			fn = *wp++;
3571 			if (fn[0] == '-' && fn[1] == '\0')
3572 				fd = STDIN_FILENO;
3573 			else if ((fd = open(fn, O_RDONLY)) < 0) {
3574 				rv = errno;
3575 				bi_errorf("%s: %s", fn, strerror(rv));
3576 				rv = 1;
3577 				continue;
3578 			}
3579 		}
3580 		while (/* CONSTCOND */ 1) {
3581 			n = blocking_read(fd, (cp = buf), MKSH_CAT_BUFSIZ);
3582 			if (n == -1) {
3583 				if (errno == EINTR) {
3584 					/* give the user a chance to ^C out */
3585 					intrcheck();
3586 					/* interrupted, try again */
3587 					continue;
3588 				}
3589 				/* an error occured during reading */
3590 				rv = errno;
3591 				bi_errorf("%s: %s", fn, strerror(rv));
3592 				rv = 1;
3593 				break;
3594 			} else if (n == 0)
3595 				/* end of file reached */
3596 				break;
3597 			while (n) {
3598 				w = write(STDOUT_FILENO, cp, n);
3599 				if (w == -1) {
3600 					if (errno == EINTR)
3601 						/* interrupted, try again */
3602 						continue;
3603 					/* an error occured during writing */
3604 					rv = errno;
3605 					bi_errorf("%s: %s", "<stdout>",
3606 					    strerror(rv));
3607 					rv = 1;
3608 					if (fd != STDIN_FILENO)
3609 						close(fd);
3610 					goto out;
3611 				}
3612 				n -= w;
3613 				cp += w;
3614 			}
3615 		}
3616 		if (fd != STDIN_FILENO)
3617 			close(fd);
3618 	} while (*wp);
3619 
3620  out:
3621 	free_osfunc(buf);
3622 	return (rv);
3623 }
3624 
3625 #if HAVE_SELECT
3626 int
c_sleep(const char ** wp)3627 c_sleep(const char **wp)
3628 {
3629 	struct timeval tv;
3630 	int rv = 1;
3631 
3632 	/* skip argv[0] */
3633 	++wp;
3634 	if (wp[0] && !strcmp(wp[0], "--"))
3635 		/* skip "--" (options separator) */
3636 		++wp;
3637 
3638 	if (!wp[0] || wp[1])
3639 		bi_errorf(Tsynerr);
3640 	else if (parse_usec(wp[0], &tv))
3641 		bi_errorf("%s: %s '%s'", Tsynerr, strerror(errno), wp[0]);
3642 	else {
3643 #ifndef MKSH_NOPROSPECTOFWORK
3644 		sigset_t omask;
3645 
3646 		/* block SIGCHLD from interrupting us, though */
3647 		sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
3648 #endif
3649 		if (select(0, NULL, NULL, NULL, &tv) == 0 || errno == EINTR)
3650 			/*
3651 			 * strictly speaking only for SIGALRM, but the
3652 			 * execution may be interrupted by other signals
3653 			 */
3654 			rv = 0;
3655 		else
3656 			bi_errorf("%s: %s", Tselect, strerror(errno));
3657 #ifndef MKSH_NOPROSPECTOFWORK
3658 		sigprocmask(SIG_SETMASK, &omask, NULL);
3659 #endif
3660 	}
3661 	return (rv);
3662 }
3663 #endif
3664 
3665 #if defined(ANDROID)
3666 static int
c_android_lsmod(const char ** wp MKSH_A_UNUSED)3667 c_android_lsmod(const char **wp MKSH_A_UNUSED)
3668 {
3669 	const char *cwp[3] = { "cat", "/proc/modules", NULL };
3670 
3671 	builtin_argv0 = cwp[0];
3672 	return (c_cat(cwp));
3673 }
3674 #endif
3675