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