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