1 /* $OpenBSD: c_sh.c,v 1.65 2023/09/14 18:32:03 cheloha Exp $ */
2
3 /*
4 * built-in Bourne commands
5 */
6
7 #include <sys/resource.h>
8 #include <sys/stat.h>
9 #include <sys/time.h>
10
11 #include <ctype.h>
12 #include <errno.h>
13 #include <fcntl.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <unistd.h>
18
19 #include "sh.h"
20
21 static void p_tv(struct shf *, int, struct timeval *, int, char *, char *);
22 static void p_ts(struct shf *, int, struct timespec *, int, char *, char *);
23
24 /* :, false and true */
25 int
c_label(char ** wp)26 c_label(char **wp)
27 {
28 return wp[0][0] == 'f' ? 1 : 0;
29 }
30
31 int
c_shift(char ** wp)32 c_shift(char **wp)
33 {
34 struct block *l = genv->loc;
35 int n;
36 int64_t val;
37 char *arg;
38
39 if (ksh_getopt(wp, &builtin_opt, null) == '?')
40 return 1;
41 arg = wp[builtin_opt.optind];
42
43 if (arg) {
44 evaluate(arg, &val, KSH_UNWIND_ERROR, false);
45 n = val;
46 } else
47 n = 1;
48 if (n < 0) {
49 bi_errorf("%s: bad number", arg);
50 return (1);
51 }
52 if (l->argc < n) {
53 bi_errorf("nothing to shift");
54 return (1);
55 }
56 l->argv[n] = l->argv[0];
57 l->argv += n;
58 l->argc -= n;
59 return 0;
60 }
61
62 int
c_umask(char ** wp)63 c_umask(char **wp)
64 {
65 int i;
66 char *cp;
67 int symbolic = 0;
68 mode_t old_umask;
69 int optc;
70
71 while ((optc = ksh_getopt(wp, &builtin_opt, "S")) != -1)
72 switch (optc) {
73 case 'S':
74 symbolic = 1;
75 break;
76 case '?':
77 return 1;
78 }
79 cp = wp[builtin_opt.optind];
80 if (cp == NULL) {
81 old_umask = umask(0);
82 umask(old_umask);
83 if (symbolic) {
84 char buf[18];
85 int j;
86
87 old_umask = ~old_umask;
88 cp = buf;
89 for (i = 0; i < 3; i++) {
90 *cp++ = "ugo"[i];
91 *cp++ = '=';
92 for (j = 0; j < 3; j++)
93 if (old_umask & (1 << (8 - (3*i + j))))
94 *cp++ = "rwx"[j];
95 *cp++ = ',';
96 }
97 cp[-1] = '\0';
98 shprintf("%s\n", buf);
99 } else
100 shprintf("%#3.3o\n", old_umask);
101 } else {
102 mode_t new_umask;
103
104 if (digit(*cp)) {
105 for (new_umask = 0; *cp >= '0' && *cp <= '7'; cp++)
106 new_umask = new_umask * 8 + (*cp - '0');
107 if (*cp) {
108 bi_errorf("bad number");
109 return 1;
110 }
111 } else {
112 /* symbolic format */
113 int positions, new_val;
114 char op;
115
116 old_umask = umask(0);
117 umask(old_umask); /* in case of error */
118 old_umask = ~old_umask;
119 new_umask = old_umask;
120 positions = 0;
121 while (*cp) {
122 while (*cp && strchr("augo", *cp))
123 switch (*cp++) {
124 case 'a':
125 positions |= 0111;
126 break;
127 case 'u':
128 positions |= 0100;
129 break;
130 case 'g':
131 positions |= 0010;
132 break;
133 case 'o':
134 positions |= 0001;
135 break;
136 }
137 if (!positions)
138 positions = 0111; /* default is a */
139 if (!strchr("=+-", op = *cp))
140 break;
141 cp++;
142 new_val = 0;
143 while (*cp && strchr("rwxugoXs", *cp))
144 switch (*cp++) {
145 case 'r': new_val |= 04; break;
146 case 'w': new_val |= 02; break;
147 case 'x': new_val |= 01; break;
148 case 'u': new_val |= old_umask >> 6;
149 break;
150 case 'g': new_val |= old_umask >> 3;
151 break;
152 case 'o': new_val |= old_umask >> 0;
153 break;
154 case 'X': if (old_umask & 0111)
155 new_val |= 01;
156 break;
157 case 's': /* ignored */
158 break;
159 }
160 new_val = (new_val & 07) * positions;
161 switch (op) {
162 case '-':
163 new_umask &= ~new_val;
164 break;
165 case '=':
166 new_umask = new_val |
167 (new_umask & ~(positions * 07));
168 break;
169 case '+':
170 new_umask |= new_val;
171 }
172 if (*cp == ',') {
173 positions = 0;
174 cp++;
175 } else if (!strchr("=+-", *cp))
176 break;
177 }
178 if (*cp) {
179 bi_errorf("bad mask");
180 return 1;
181 }
182 new_umask = ~new_umask;
183 }
184 umask(new_umask);
185 }
186 return 0;
187 }
188
189 int
c_dot(char ** wp)190 c_dot(char **wp)
191 {
192 char *file, *cp;
193 char **argv;
194 int argc;
195 int i;
196 int err;
197
198 if (ksh_getopt(wp, &builtin_opt, null) == '?')
199 return 1;
200
201 if ((cp = wp[builtin_opt.optind]) == NULL)
202 return 0;
203 file = search(cp, search_path, R_OK, &err);
204 if (file == NULL) {
205 bi_errorf("%s: %s", cp, err ? strerror(err) : "not found");
206 return 1;
207 }
208
209 /* Set positional parameters? */
210 if (wp[builtin_opt.optind + 1]) {
211 argv = wp + builtin_opt.optind;
212 argv[0] = genv->loc->argv[0]; /* preserve $0 */
213 for (argc = 0; argv[argc + 1]; argc++)
214 ;
215 } else {
216 argc = 0;
217 argv = NULL;
218 }
219 i = include(file, argc, argv, 0);
220 if (i < 0) { /* should not happen */
221 bi_errorf("%s: %s", cp, strerror(errno));
222 return 1;
223 }
224 return i;
225 }
226
227 int
c_wait(char ** wp)228 c_wait(char **wp)
229 {
230 int rv = 0;
231 int sig;
232
233 if (ksh_getopt(wp, &builtin_opt, null) == '?')
234 return 1;
235 wp += builtin_opt.optind;
236 if (*wp == NULL) {
237 while (waitfor(NULL, &sig) >= 0)
238 ;
239 rv = sig;
240 } else {
241 for (; *wp; wp++)
242 rv = waitfor(*wp, &sig);
243 if (rv < 0)
244 rv = sig ? sig : 127; /* magic exit code: bad job-id */
245 }
246 return rv;
247 }
248
249 int
c_read(char ** wp)250 c_read(char **wp)
251 {
252 int c = 0;
253 int expand = 1, savehist = 0;
254 int expanding;
255 int ecode = 0;
256 char *cp;
257 int fd = 0;
258 struct shf *shf;
259 int optc;
260 const char *emsg;
261 XString cs, xs;
262 struct tbl *vp;
263 char *xp = NULL;
264
265 while ((optc = ksh_getopt(wp, &builtin_opt, "prsu,")) != -1)
266 switch (optc) {
267 case 'p':
268 if ((fd = coproc_getfd(R_OK, &emsg)) < 0) {
269 bi_errorf("-p: %s", emsg);
270 return 1;
271 }
272 break;
273 case 'r':
274 expand = 0;
275 break;
276 case 's':
277 savehist = 1;
278 break;
279 case 'u':
280 if (!*(cp = builtin_opt.optarg))
281 fd = 0;
282 else if ((fd = check_fd(cp, R_OK, &emsg)) < 0) {
283 bi_errorf("-u: %s: %s", cp, emsg);
284 return 1;
285 }
286 break;
287 case '?':
288 return 1;
289 }
290 wp += builtin_opt.optind;
291
292 if (*wp == NULL)
293 *--wp = "REPLY";
294
295 /* Since we can't necessarily seek backwards on non-regular files,
296 * don't buffer them so we can't read too much.
297 */
298 shf = shf_reopen(fd, SHF_RD | SHF_INTERRUPT | can_seek(fd), shl_spare);
299
300 if ((cp = strchr(*wp, '?')) != NULL) {
301 *cp = 0;
302 if (isatty(fd)) {
303 /* at&t ksh says it prints prompt on fd if it's open
304 * for writing and is a tty, but it doesn't do it
305 * (it also doesn't check the interactive flag,
306 * as is indicated in the Kornshell book).
307 */
308 shellf("%s", cp+1);
309 }
310 }
311
312 /* If we are reading from the co-process for the first time,
313 * make sure the other side of the pipe is closed first. This allows
314 * the detection of eof.
315 *
316 * This is not compatible with at&t ksh... the fd is kept so another
317 * coproc can be started with same output, however, this means eof
318 * can't be detected... This is why it is closed here.
319 * If this call is removed, remove the eof check below, too.
320 * coproc_readw_close(fd);
321 */
322
323 if (savehist)
324 Xinit(xs, xp, 128, ATEMP);
325 expanding = 0;
326 Xinit(cs, cp, 128, ATEMP);
327 for (; *wp != NULL; wp++) {
328 for (cp = Xstring(cs, cp); ; ) {
329 if (c == '\n' || c == EOF)
330 break;
331 while (1) {
332 c = shf_getc(shf);
333 if (c == '\0')
334 continue;
335 if (c == EOF && shf_error(shf) &&
336 shf->errno_ == EINTR) {
337 /* Was the offending signal one that
338 * would normally kill a process?
339 * If so, pretend the read was killed.
340 */
341 ecode = fatal_trap_check();
342
343 /* non fatal (eg, CHLD), carry on */
344 if (!ecode) {
345 shf_clearerr(shf);
346 continue;
347 }
348 }
349 break;
350 }
351 if (savehist) {
352 Xcheck(xs, xp);
353 Xput(xs, xp, c);
354 }
355 Xcheck(cs, cp);
356 if (expanding) {
357 expanding = 0;
358 if (c == '\n') {
359 c = 0;
360 if (Flag(FTALKING_I) && isatty(fd)) {
361 /* set prompt in case this is
362 * called from .profile or $ENV
363 */
364 set_prompt(PS2);
365 pprompt(prompt, 0);
366 }
367 } else if (c != EOF)
368 Xput(cs, cp, c);
369 continue;
370 }
371 if (expand && c == '\\') {
372 expanding = 1;
373 continue;
374 }
375 if (c == '\n' || c == EOF)
376 break;
377 if (ctype(c, C_IFS)) {
378 if (Xlength(cs, cp) == 0 && ctype(c, C_IFSWS))
379 continue;
380 if (wp[1])
381 break;
382 }
383 Xput(cs, cp, c);
384 }
385 /* strip trailing IFS white space from last variable */
386 if (!wp[1])
387 while (Xlength(cs, cp) && ctype(cp[-1], C_IFS) &&
388 ctype(cp[-1], C_IFSWS))
389 cp--;
390 Xput(cs, cp, '\0');
391 vp = global(*wp);
392 /* Must be done before setting export. */
393 if (vp->flag & RDONLY) {
394 shf_flush(shf);
395 bi_errorf("%s is read only", *wp);
396 return 1;
397 }
398 if (Flag(FEXPORT))
399 typeset(*wp, EXPORT, 0, 0, 0);
400 if (!setstr(vp, Xstring(cs, cp), KSH_RETURN_ERROR)) {
401 shf_flush(shf);
402 return 1;
403 }
404 }
405
406 shf_flush(shf);
407 if (savehist) {
408 Xput(xs, xp, '\0');
409 source->line++;
410 histsave(source->line, Xstring(xs, xp), 1);
411 Xfree(xs, xp);
412 }
413 /* if this is the co-process fd, close the file descriptor
414 * (can get eof if and only if all processes are have died, ie,
415 * coproc.njobs is 0 and the pipe is closed).
416 */
417 if (c == EOF && !ecode)
418 coproc_read_close(fd);
419
420 return ecode ? ecode : c == EOF;
421 }
422
423 int
c_eval(char ** wp)424 c_eval(char **wp)
425 {
426 struct source *s;
427 struct source *saves = source;
428 int savef;
429 int rv;
430
431 if (ksh_getopt(wp, &builtin_opt, null) == '?')
432 return 1;
433 s = pushs(SWORDS, ATEMP);
434 s->u.strv = wp + builtin_opt.optind;
435 if (!Flag(FPOSIX)) {
436 /*
437 * Handle case where the command is empty due to failed
438 * command substitution, eg, eval "$(false)".
439 * In this case, shell() will not set/change exstat (because
440 * compiled tree is empty), so will use this value.
441 * subst_exstat is cleared in execute(), so should be 0 if
442 * there were no substitutions.
443 *
444 * A strict reading of POSIX says we don't do this (though
445 * it is traditionally done). [from 1003.2-1992]
446 * 3.9.1: Simple Commands
447 * ... If there is a command name, execution shall
448 * continue as described in 3.9.1.1. If there
449 * is no command name, but the command contained a command
450 * substitution, the command shall complete with the exit
451 * status of the last command substitution
452 * 3.9.1.1: Command Search and Execution
453 * ...(1)...(a) If the command name matches the name of
454 * a special built-in utility, that special built-in
455 * utility shall be invoked.
456 * 3.14.5: Eval
457 * ... If there are no arguments, or only null arguments,
458 * eval shall return an exit status of zero.
459 */
460 exstat = subst_exstat;
461 }
462
463 savef = Flag(FERREXIT);
464 Flag(FERREXIT) = 0;
465 rv = shell(s, false);
466 Flag(FERREXIT) = savef;
467 source = saves;
468 afree(s, ATEMP);
469 return (rv);
470 }
471
472 int
c_trap(char ** wp)473 c_trap(char **wp)
474 {
475 int i;
476 char *s;
477 Trap *p;
478
479 if (ksh_getopt(wp, &builtin_opt, null) == '?')
480 return 1;
481 wp += builtin_opt.optind;
482
483 if (*wp == NULL) {
484 for (p = sigtraps, i = NSIG+1; --i >= 0; p++) {
485 if (p->trap != NULL) {
486 shprintf("trap -- ");
487 print_value_quoted(p->trap);
488 shprintf(" %s\n", p->name);
489 }
490 }
491 return 0;
492 }
493
494 /*
495 * Use case sensitive lookup for first arg so the
496 * command 'exit' isn't confused with the pseudo-signal
497 * 'EXIT'.
498 */
499 s = (gettrap(*wp, false) == NULL) ? *wp++ : NULL; /* get command */
500 if (s != NULL && s[0] == '-' && s[1] == '\0')
501 s = NULL;
502
503 /* set/clear traps */
504 while (*wp != NULL) {
505 p = gettrap(*wp++, true);
506 if (p == NULL) {
507 bi_errorf("bad signal %s", wp[-1]);
508 return 1;
509 }
510 settrap(p, s);
511 }
512 return 0;
513 }
514
515 int
c_exitreturn(char ** wp)516 c_exitreturn(char **wp)
517 {
518 int how = LEXIT;
519 int n;
520 char *arg;
521
522 if (ksh_getopt(wp, &builtin_opt, null) == '?')
523 return 1;
524 arg = wp[builtin_opt.optind];
525
526 if (arg) {
527 if (!getn(arg, &n)) {
528 exstat = 1;
529 warningf(true, "%s: bad number", arg);
530 } else
531 exstat = n;
532 }
533 if (wp[0][0] == 'r') { /* return */
534 struct env *ep;
535
536 /* need to tell if this is exit or return so trap exit will
537 * work right (POSIX)
538 */
539 for (ep = genv; ep; ep = ep->oenv)
540 if (STOP_RETURN(ep->type)) {
541 how = LRETURN;
542 break;
543 }
544 }
545
546 if (how == LEXIT && !really_exit && j_stopped_running()) {
547 really_exit = 1;
548 how = LSHELL;
549 }
550
551 quitenv(NULL); /* get rid of any i/o redirections */
552 unwind(how);
553 /* NOTREACHED */
554 return 0;
555 }
556
557 int
c_brkcont(char ** wp)558 c_brkcont(char **wp)
559 {
560 int n, quit;
561 struct env *ep, *last_ep = NULL;
562 char *arg;
563
564 if (ksh_getopt(wp, &builtin_opt, null) == '?')
565 return 1;
566 arg = wp[builtin_opt.optind];
567
568 if (!arg)
569 n = 1;
570 else if (!bi_getn(arg, &n))
571 return 1;
572 quit = n;
573 if (quit <= 0) {
574 /* at&t ksh does this for non-interactive shells only - weird */
575 bi_errorf("%s: bad value", arg);
576 return 1;
577 }
578
579 /* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */
580 for (ep = genv; ep && !STOP_BRKCONT(ep->type); ep = ep->oenv)
581 if (ep->type == E_LOOP) {
582 if (--quit == 0)
583 break;
584 ep->flags |= EF_BRKCONT_PASS;
585 last_ep = ep;
586 }
587
588 if (quit) {
589 /* at&t ksh doesn't print a message - just does what it
590 * can. We print a message 'cause it helps in debugging
591 * scripts, but don't generate an error (ie, keep going).
592 */
593 if (n == quit) {
594 warningf(true, "%s: cannot %s", wp[0], wp[0]);
595 return 0;
596 }
597 /* POSIX says if n is too big, the last enclosing loop
598 * shall be used. Doesn't say to print an error but we
599 * do anyway 'cause the user messed up.
600 */
601 if (last_ep)
602 last_ep->flags &= ~EF_BRKCONT_PASS;
603 warningf(true, "%s: can only %s %d level(s)",
604 wp[0], wp[0], n - quit);
605 }
606
607 unwind(*wp[0] == 'b' ? LBREAK : LCONTIN);
608 /* NOTREACHED */
609 }
610
611 int
c_set(char ** wp)612 c_set(char **wp)
613 {
614 int argi, setargs;
615 struct block *l = genv->loc;
616 char **owp = wp;
617
618 if (wp[1] == NULL) {
619 static const char *const args [] = { "set", "-", NULL };
620 return c_typeset((char **) args);
621 }
622
623 argi = parse_args(wp, OF_SET, &setargs);
624 if (argi < 0)
625 return 1;
626 /* set $# and $* */
627 if (setargs) {
628 owp = wp += argi - 1;
629 wp[0] = l->argv[0]; /* save $0 */
630 while (*++wp != NULL)
631 *wp = str_save(*wp, &l->area);
632 l->argc = wp - owp - 1;
633 l->argv = areallocarray(NULL, l->argc+2, sizeof(char *), &l->area);
634 for (wp = l->argv; (*wp++ = *owp++) != NULL; )
635 ;
636 }
637 /* POSIX says set exit status is 0, but old scripts that use
638 * getopt(1), use the construct: set -- `getopt ab:c "$@"`
639 * which assumes the exit value set will be that of the ``
640 * (subst_exstat is cleared in execute() so that it will be 0
641 * if there are no command substitutions).
642 */
643 return Flag(FPOSIX) ? 0 : subst_exstat;
644 }
645
646 int
c_unset(char ** wp)647 c_unset(char **wp)
648 {
649 char *id;
650 int optc, unset_var = 1;
651
652 while ((optc = ksh_getopt(wp, &builtin_opt, "fv")) != -1)
653 switch (optc) {
654 case 'f':
655 unset_var = 0;
656 break;
657 case 'v':
658 unset_var = 1;
659 break;
660 case '?':
661 return 1;
662 }
663 wp += builtin_opt.optind;
664 for (; (id = *wp) != NULL; wp++)
665 if (unset_var) { /* unset variable */
666 struct tbl *vp = global(id);
667
668 if ((vp->flag&RDONLY)) {
669 bi_errorf("%s is read only", vp->name);
670 return 1;
671 }
672 unset(vp, strchr(id, '[') ? 1 : 0);
673 } else { /* unset function */
674 define(id, NULL);
675 }
676 return 0;
677 }
678
679 static void
p_tv(struct shf * shf,int posix,struct timeval * tv,int width,char * prefix,char * suffix)680 p_tv(struct shf *shf, int posix, struct timeval *tv, int width, char *prefix,
681 char *suffix)
682 {
683 struct timespec ts;
684
685 TIMEVAL_TO_TIMESPEC(tv, &ts);
686 p_ts(shf, posix, &ts, width, prefix, suffix);
687 }
688
689 static void
p_ts(struct shf * shf,int posix,struct timespec * ts,int width,char * prefix,char * suffix)690 p_ts(struct shf *shf, int posix, struct timespec *ts, int width, char *prefix,
691 char *suffix)
692 {
693 if (posix)
694 shf_fprintf(shf, "%s%*lld.%02ld%s", prefix ? prefix : "",
695 width, (long long)ts->tv_sec, ts->tv_nsec / 10000000,
696 suffix);
697 else
698 shf_fprintf(shf, "%s%*lldm%02lld.%02lds%s", prefix ? prefix : "",
699 width, (long long)ts->tv_sec / 60,
700 (long long)ts->tv_sec % 60,
701 ts->tv_nsec / 10000000, suffix);
702 }
703
704
705 int
c_times(char ** wp)706 c_times(char **wp)
707 {
708 struct rusage usage;
709
710 (void) getrusage(RUSAGE_SELF, &usage);
711 p_tv(shl_stdout, 0, &usage.ru_utime, 0, NULL, " ");
712 p_tv(shl_stdout, 0, &usage.ru_stime, 0, NULL, "\n");
713
714 (void) getrusage(RUSAGE_CHILDREN, &usage);
715 p_tv(shl_stdout, 0, &usage.ru_utime, 0, NULL, " ");
716 p_tv(shl_stdout, 0, &usage.ru_stime, 0, NULL, "\n");
717
718 return 0;
719 }
720
721 /*
722 * time pipeline (really a statement, not a built-in command)
723 */
724 int
timex(struct op * t,int f,volatile int * xerrok)725 timex(struct op *t, int f, volatile int *xerrok)
726 {
727 #define TF_NOARGS BIT(0)
728 #define TF_NOREAL BIT(1) /* don't report real time */
729 #define TF_POSIX BIT(2) /* report in posix format */
730 int rv = 0;
731 struct rusage ru0, ru1, cru0, cru1;
732 struct timeval usrtime, systime;
733 struct timespec ts0, ts1, ts2;
734 int tf = 0;
735 extern struct timeval j_usrtime, j_systime; /* computed by j_wait */
736
737 clock_gettime(CLOCK_MONOTONIC, &ts0);
738 getrusage(RUSAGE_SELF, &ru0);
739 getrusage(RUSAGE_CHILDREN, &cru0);
740 if (t->left) {
741 /*
742 * Two ways of getting cpu usage of a command: just use t0
743 * and t1 (which will get cpu usage from other jobs that
744 * finish while we are executing t->left), or get the
745 * cpu usage of t->left. at&t ksh does the former, while
746 * pdksh tries to do the later (the j_usrtime hack doesn't
747 * really work as it only counts the last job).
748 */
749 timerclear(&j_usrtime);
750 timerclear(&j_systime);
751 rv = execute(t->left, f | XTIME, xerrok);
752 if (t->left->type == TCOM)
753 tf |= t->left->str[0];
754 clock_gettime(CLOCK_MONOTONIC, &ts1);
755 getrusage(RUSAGE_SELF, &ru1);
756 getrusage(RUSAGE_CHILDREN, &cru1);
757 } else
758 tf = TF_NOARGS;
759
760 if (tf & TF_NOARGS) { /* ksh93 - report shell times (shell+kids) */
761 tf |= TF_NOREAL;
762 timeradd(&ru0.ru_utime, &cru0.ru_utime, &usrtime);
763 timeradd(&ru0.ru_stime, &cru0.ru_stime, &systime);
764 } else {
765 timersub(&ru1.ru_utime, &ru0.ru_utime, &usrtime);
766 timeradd(&usrtime, &j_usrtime, &usrtime);
767 timersub(&ru1.ru_stime, &ru0.ru_stime, &systime);
768 timeradd(&systime, &j_systime, &systime);
769 }
770
771 if (!(tf & TF_NOREAL)) {
772 timespecsub(&ts1, &ts0, &ts2);
773 if (tf & TF_POSIX)
774 p_ts(shl_out, 1, &ts2, 5, "real ", "\n");
775 else
776 p_ts(shl_out, 0, &ts2, 5, NULL, " real ");
777 }
778 if (tf & TF_POSIX)
779 p_tv(shl_out, 1, &usrtime, 5, "user ", "\n");
780 else
781 p_tv(shl_out, 0, &usrtime, 5, NULL, " user ");
782 if (tf & TF_POSIX)
783 p_tv(shl_out, 1, &systime, 5, "sys ", "\n");
784 else
785 p_tv(shl_out, 0, &systime, 5, NULL, " system\n");
786 shf_flush(shl_out);
787
788 return rv;
789 }
790
791 void
timex_hook(struct op * t,char ** volatile * app)792 timex_hook(struct op *t, char **volatile *app)
793 {
794 char **wp = *app;
795 int optc;
796 int i, j;
797 Getopt opt;
798
799 ksh_getopt_reset(&opt, 0);
800 opt.optind = 0; /* start at the start */
801 while ((optc = ksh_getopt(wp, &opt, ":p")) != -1)
802 switch (optc) {
803 case 'p':
804 t->str[0] |= TF_POSIX;
805 break;
806 case '?':
807 errorf("time: -%s unknown option", opt.optarg);
808 case ':':
809 errorf("time: -%s requires an argument",
810 opt.optarg);
811 }
812 /* Copy command words down over options. */
813 if (opt.optind != 0) {
814 for (i = 0; i < opt.optind; i++)
815 afree(wp[i], ATEMP);
816 for (i = 0, j = opt.optind; (wp[i] = wp[j]); i++, j++)
817 ;
818 }
819 if (!wp[0])
820 t->str[0] |= TF_NOARGS;
821 *app = wp;
822 }
823
824 /* exec with no args - args case is taken care of in comexec() */
825 int
c_exec(char ** wp)826 c_exec(char **wp)
827 {
828 int i;
829
830 /* make sure redirects stay in place */
831 if (genv->savefd != NULL) {
832 for (i = 0; i < NUFILE; i++) {
833 if (genv->savefd[i] > 0)
834 close(genv->savefd[i]);
835 /*
836 * For ksh keep anything > 2 private,
837 * for sh, let them be (POSIX says what
838 * happens is unspecified and the bourne shell
839 * keeps them open).
840 */
841 if (!Flag(FSH) && i > 2 && genv->savefd[i])
842 fcntl(i, F_SETFD, FD_CLOEXEC);
843 }
844 genv->savefd = NULL;
845 }
846 return 0;
847 }
848
849 static int
c_suspend(char ** wp)850 c_suspend(char **wp)
851 {
852 if (wp[1] != NULL) {
853 bi_errorf("too many arguments");
854 return 1;
855 }
856 if (Flag(FLOGIN)) {
857 /* Can't suspend an orphaned process group. */
858 pid_t parent = getppid();
859 if (getpgid(parent) == getpgid(0) ||
860 getsid(parent) != getsid(0)) {
861 bi_errorf("can't suspend a login shell");
862 return 1;
863 }
864 }
865 j_suspend();
866 return 0;
867 }
868
869 /* dummy function, special case in comexec() */
870 int
c_builtin(char ** wp)871 c_builtin(char **wp)
872 {
873 return 0;
874 }
875
876 extern int c_test(char **wp); /* in c_test.c */
877 extern int c_ulimit(char **wp); /* in c_ulimit.c */
878
879 /* A leading = means assignments before command are kept;
880 * a leading * means a POSIX special builtin;
881 * a leading + means a POSIX regular builtin
882 * (* and + should not be combined).
883 */
884 const struct builtin shbuiltins [] = {
885 {"*=.", c_dot},
886 {"*=:", c_label},
887 {"[", c_test},
888 {"*=break", c_brkcont},
889 {"=builtin", c_builtin},
890 {"*=continue", c_brkcont},
891 {"*=eval", c_eval},
892 {"*=exec", c_exec},
893 {"*=exit", c_exitreturn},
894 {"+false", c_label},
895 {"*=return", c_exitreturn},
896 {"*=set", c_set},
897 {"*=shift", c_shift},
898 {"*=times", c_times},
899 {"*=trap", c_trap},
900 {"+=wait", c_wait},
901 {"+read", c_read},
902 {"test", c_test},
903 {"+true", c_label},
904 {"ulimit", c_ulimit},
905 {"+umask", c_umask},
906 {"*=unset", c_unset},
907 {"suspend", c_suspend},
908 {NULL, NULL}
909 };
910