bin/ksh/c_sh.c

   1 /*      $OpenBSD: c_sh.c,v 1.63 2018/04/09 17:53:36 tobias 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
  26 c_label(char **wp)
  27 {
  28         return wp[0][0] == 'f' ? 1 : 0;
  29 }
  30
  31 int
  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
  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
 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
 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
 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
 424 c_eval(char **wp)
 425 {
 426         struct source *s;
 427         int rv;
 428
 429         if (ksh_getopt(wp, &builtin_opt, null) == '?')
 430                 return 1;
 431         s = pushs(SWORDS, ATEMP);
 432         s->u.strv = wp + builtin_opt.optind;
 433         if (!Flag(FPOSIX)) {
 434                 /*
 435                  * Handle case where the command is empty due to failed
 436                  * command substitution, eg, eval "$(false)".
 437                  * In this case, shell() will not set/change exstat (because
 438                  * compiled tree is empty), so will use this value.
 439                  * subst_exstat is cleared in execute(), so should be 0 if
 440                  * there were no substitutions.
 441                  *
 442                  * A strict reading of POSIX says we don't do this (though
 443                  * it is traditionally done). [from 1003.2-1992]
 444                  *    3.9.1: Simple Commands
 445                  *      ... If there is a command name, execution shall
 446                  *      continue as described in 3.9.1.1.  If there
 447                  *      is no command name, but the command contained a command
 448                  *      substitution, the command shall complete with the exit
 449                  *      status of the last command substitution
 450                  *    3.9.1.1: Command Search and Execution
 451                  *      ...(1)...(a) If the command name matches the name of
 452                  *      a special built-in utility, that special built-in
 453                  *      utility shall be invoked.
 454                  * 3.14.5: Eval
 455                  *      ... If there are no arguments, or only null arguments,
 456                  *      eval shall return an exit status of zero.
 457                  */
 458                 exstat = subst_exstat;
 459         }
 460
 461         rv = shell(s, false);
 462         afree(s, ATEMP);
 463         return (rv);
 464 }
 465
 466 int
 467 c_trap(char **wp)
 468 {
 469         int i;
 470         char *s;
 471         Trap *p;
 472
 473         if (ksh_getopt(wp, &builtin_opt, null) == '?')
 474                 return 1;
 475         wp += builtin_opt.optind;
 476
 477         if (*wp == NULL) {
 478                 for (p = sigtraps, i = NSIG+1; --i >= 0; p++) {
 479                         if (p->trap != NULL) {
 480                                 shprintf("trap -- ");
 481                                 print_value_quoted(p->trap);
 482                                 shprintf(" %s\n", p->name);
 483                         }
 484                 }
 485                 return 0;
 486         }
 487
 488         /*
 489          * Use case sensitive lookup for first arg so the
 490          * command 'exit' isn't confused with the pseudo-signal
 491          * 'EXIT'.
 492          */
 493         s = (gettrap(*wp, false) == NULL) ? *wp++ : NULL; /* get command */
 494         if (s != NULL && s[0] == '-' && s[1] == '\0')
 495                 s = NULL;
 496
 497         /* set/clear traps */
 498         while (*wp != NULL) {
 499                 p = gettrap(*wp++, true);
 500                 if (p == NULL) {
 501                         bi_errorf("bad signal %s", wp[-1]);
 502                         return 1;
 503                 }
 504                 settrap(p, s);
 505         }
 506         return 0;
 507 }
 508
 509 int
 510 c_exitreturn(char **wp)
 511 {
 512         int how = LEXIT;
 513         int n;
 514         char *arg;
 515
 516         if (ksh_getopt(wp, &builtin_opt, null) == '?')
 517                 return 1;
 518         arg = wp[builtin_opt.optind];
 519
 520         if (arg) {
 521                 if (!getn(arg, &n)) {
 522                         exstat = 1;
 523                         warningf(true, "%s: bad number", arg);
 524                 } else
 525                         exstat = n;
 526         }
 527         if (wp[0][0] == 'r') { /* return */
 528                 struct env *ep;
 529
 530                 /* need to tell if this is exit or return so trap exit will
 531                  * work right (POSIX)
 532                  */
 533                 for (ep = genv; ep; ep = ep->oenv)
 534                         if (STOP_RETURN(ep->type)) {
 535                                 how = LRETURN;
 536                                 break;
 537                         }
 538         }
 539
 540         if (how == LEXIT && !really_exit && j_stopped_running()) {
 541                 really_exit = 1;
 542                 how = LSHELL;
 543         }
 544
 545         quitenv(NULL);  /* get rid of any i/o redirections */
 546         unwind(how);
 547         /* NOTREACHED */
 548         return 0;
 549 }
 550
 551 int
 552 c_brkcont(char **wp)
 553 {
 554         int n, quit;
 555         struct env *ep, *last_ep = NULL;
 556         char *arg;
 557
 558         if (ksh_getopt(wp, &builtin_opt, null) == '?')
 559                 return 1;
 560         arg = wp[builtin_opt.optind];
 561
 562         if (!arg)
 563                 n = 1;
 564         else if (!bi_getn(arg, &n))
 565                 return 1;
 566         quit = n;
 567         if (quit <= 0) {
 568                 /* at&t ksh does this for non-interactive shells only - weird */
 569                 bi_errorf("%s: bad value", arg);
 570                 return 1;
 571         }
 572
 573         /* Stop at E_NONE, E_PARSE, E_FUNC, or E_INCL */
 574         for (ep = genv; ep && !STOP_BRKCONT(ep->type); ep = ep->oenv)
 575                 if (ep->type == E_LOOP) {
 576                         if (--quit == 0)
 577                                 break;
 578                         ep->flags |= EF_BRKCONT_PASS;
 579                         last_ep = ep;
 580                 }
 581
 582         if (quit) {
 583                 /* at&t ksh doesn't print a message - just does what it
 584                  * can.  We print a message 'cause it helps in debugging
 585                  * scripts, but don't generate an error (ie, keep going).
 586                  */
 587                 if (n == quit) {
 588                         warningf(true, "%s: cannot %s", wp[0], wp[0]);
 589                         return 0;
 590                 }
 591                 /* POSIX says if n is too big, the last enclosing loop
 592                  * shall be used.  Doesn't say to print an error but we
 593                  * do anyway 'cause the user messed up.
 594                  */
 595                 if (last_ep)
 596                         last_ep->flags &= ~EF_BRKCONT_PASS;
 597                 warningf(true, "%s: can only %s %d level(s)",
 598                     wp[0], wp[0], n - quit);
 599         }
 600
 601         unwind(*wp[0] == 'b' ? LBREAK : LCONTIN);
 602         /* NOTREACHED */
 603 }
 604
 605 int
 606 c_set(char **wp)
 607 {
 608         int argi, setargs;
 609         struct block *l = genv->loc;
 610         char **owp = wp;
 611
 612         if (wp[1] == NULL) {
 613                 static const char *const args [] = { "set", "-", NULL };
 614                 return c_typeset((char **) args);
 615         }
 616
 617         argi = parse_args(wp, OF_SET, &setargs);
 618         if (argi < 0)
 619                 return 1;
 620         /* set $# and $* */
 621         if (setargs) {
 622                 owp = wp += argi - 1;
 623                 wp[0] = l->argv[0]; /* save $0 */
 624                 while (*++wp != NULL)
 625                         *wp = str_save(*wp, &l->area);
 626                 l->argc = wp - owp - 1;
 627                 l->argv = areallocarray(NULL, l->argc+2, sizeof(char *), &l->area);
 628                 for (wp = l->argv; (*wp++ = *owp++) != NULL; )
 629                         ;
 630         }
 631         /* POSIX says set exit status is 0, but old scripts that use
 632          * getopt(1), use the construct: set -- `getopt ab:c "$@"`
 633          * which assumes the exit value set will be that of the ``
 634          * (subst_exstat is cleared in execute() so that it will be 0
 635          * if there are no command substitutions).
 636          */
 637         return Flag(FPOSIX) ? 0 : subst_exstat;
 638 }
 639
 640 int
 641 c_unset(char **wp)
 642 {
 643         char *id;
 644         int optc, unset_var = 1;
 645
 646         while ((optc = ksh_getopt(wp, &builtin_opt, "fv")) != -1)
 647                 switch (optc) {
 648                 case 'f':
 649                         unset_var = 0;
 650                         break;
 651                 case 'v':
 652                         unset_var = 1;
 653                         break;
 654                 case '?':
 655                         return 1;
 656                 }
 657         wp += builtin_opt.optind;
 658         for (; (id = *wp) != NULL; wp++)
 659                 if (unset_var) {        /* unset variable */
 660                         struct tbl *vp = global(id);
 661
 662                         if ((vp->flag&RDONLY)) {
 663                                 bi_errorf("%s is read only", vp->name);
 664                                 return 1;
 665                         }
 666                         unset(vp, strchr(id, '[') ? 1 : 0);
 667                 } else {                /* unset function */
 668                         define(id, NULL);
 669                 }
 670         return 0;
 671 }
 672
 673 static void
 674 p_tv(struct shf *shf, int posix, struct timeval *tv, int width, char *prefix,
 675     char *suffix)
 676 {
 677         if (posix)
 678                 shf_fprintf(shf, "%s%*lld.%02ld%s", prefix ? prefix : "",
 679                     width, (long long)tv->tv_sec, tv->tv_usec / 10000, suffix);
 680         else
 681                 shf_fprintf(shf, "%s%*lldm%02lld.%02lds%s", prefix ? prefix : "",
 682                     width, (long long)tv->tv_sec / 60,
 683                     (long long)tv->tv_sec % 60,
 684                     tv->tv_usec / 10000, suffix);
 685 }
 686
 687 static void
 688 p_ts(struct shf *shf, int posix, struct timespec *ts, int width, char *prefix,
 689     char *suffix)
 690 {
 691         if (posix)
 692                 shf_fprintf(shf, "%s%*lld.%02ld%s", prefix ? prefix : "",
 693                     width, (long long)ts->tv_sec, ts->tv_nsec / 10000000,
 694                     suffix);
 695         else
 696                 shf_fprintf(shf, "%s%*lldm%02lld.%02lds%s", prefix ? prefix : "",
 697                     width, (long long)ts->tv_sec / 60,
 698                     (long long)ts->tv_sec % 60,
 699                     ts->tv_nsec / 10000000, suffix);
 700 }
 701
 702
 703 int
 704 c_times(char **wp)
 705 {
 706         struct rusage usage;
 707
 708         (void) getrusage(RUSAGE_SELF, &usage);
 709         p_tv(shl_stdout, 0, &usage.ru_utime, 0, NULL, " ");
 710         p_tv(shl_stdout, 0, &usage.ru_stime, 0, NULL, "\n");
 711
 712         (void) getrusage(RUSAGE_CHILDREN, &usage);
 713         p_tv(shl_stdout, 0, &usage.ru_utime, 0, NULL, " ");
 714         p_tv(shl_stdout, 0, &usage.ru_stime, 0, NULL, "\n");
 715
 716         return 0;
 717 }
 718
 719 /*
 720  * time pipeline (really a statement, not a built-in command)
 721  */
 722 int
 723 timex(struct op *t, int f, volatile int *xerrok)
 724 {
 725 #define TF_NOARGS       BIT(0)
 726 #define TF_NOREAL       BIT(1)          /* don't report real time */
 727 #define TF_POSIX        BIT(2)          /* report in posix format */
 728         int rv = 0;
 729         struct rusage ru0, ru1, cru0, cru1;
 730         struct timeval usrtime, systime;
 731         struct timespec ts0, ts1, ts2;
 732         int tf = 0;
 733         extern struct timeval j_usrtime, j_systime; /* computed by j_wait */
 734
 735         clock_gettime(CLOCK_MONOTONIC, &ts0);
 736         getrusage(RUSAGE_SELF, &ru0);
 737         getrusage(RUSAGE_CHILDREN, &cru0);
 738         if (t->left) {
 739                 /*
 740                  * Two ways of getting cpu usage of a command: just use t0
 741                  * and t1 (which will get cpu usage from other jobs that
 742                  * finish while we are executing t->left), or get the
 743                  * cpu usage of t->left. at&t ksh does the former, while
 744                  * pdksh tries to do the later (the j_usrtime hack doesn't
 745                  * really work as it only counts the last job).
 746                  */
 747                 timerclear(&j_usrtime);
 748                 timerclear(&j_systime);
 749                 rv = execute(t->left, f | XTIME, xerrok);
 750                 if (t->left->type == TCOM)
 751                         tf |= t->left->str[0];
 752                 clock_gettime(CLOCK_MONOTONIC, &ts1);
 753                 getrusage(RUSAGE_SELF, &ru1);
 754                 getrusage(RUSAGE_CHILDREN, &cru1);
 755         } else
 756                 tf = TF_NOARGS;
 757
 758         if (tf & TF_NOARGS) { /* ksh93 - report shell times (shell+kids) */
 759                 tf |= TF_NOREAL;
 760                 timeradd(&ru0.ru_utime, &cru0.ru_utime, &usrtime);
 761                 timeradd(&ru0.ru_stime, &cru0.ru_stime, &systime);
 762         } else {
 763                 timersub(&ru1.ru_utime, &ru0.ru_utime, &usrtime);
 764                 timeradd(&usrtime, &j_usrtime, &usrtime);
 765                 timersub(&ru1.ru_stime, &ru0.ru_stime, &systime);
 766                 timeradd(&systime, &j_systime, &systime);
 767         }
 768
 769         if (!(tf & TF_NOREAL)) {
 770                 timespecsub(&ts1, &ts0, &ts2);
 771                 if (tf & TF_POSIX)
 772                         p_ts(shl_out, 1, &ts2, 5, "real ", "\n");
 773                 else
 774                         p_ts(shl_out, 0, &ts2, 5, NULL, " real ");
 775         }
 776         if (tf & TF_POSIX)
 777                 p_tv(shl_out, 1, &usrtime, 5, "user ", "\n");
 778         else
 779                 p_tv(shl_out, 0, &usrtime, 5, NULL, " user ");
 780         if (tf & TF_POSIX)
 781                 p_tv(shl_out, 1, &systime, 5, "sys  ", "\n");
 782         else
 783                 p_tv(shl_out, 0, &systime, 5, NULL, " system\n");
 784         shf_flush(shl_out);
 785
 786         return rv;
 787 }
 788
 789 void
 790 timex_hook(struct op *t, char **volatile *app)
 791 {
 792         char **wp = *app;
 793         int optc;
 794         int i, j;
 795         Getopt opt;
 796
 797         ksh_getopt_reset(&opt, 0);
 798         opt.optind = 0; /* start at the start */
 799         while ((optc = ksh_getopt(wp, &opt, ":p")) != -1)
 800                 switch (optc) {
 801                 case 'p':
 802                         t->str[0] |= TF_POSIX;
 803                         break;
 804                 case '?':
 805                         errorf("time: -%s unknown option", opt.optarg);
 806                 case ':':
 807                         errorf("time: -%s requires an argument",
 808                             opt.optarg);
 809                 }
 810         /* Copy command words down over options. */
 811         if (opt.optind != 0) {
 812                 for (i = 0; i < opt.optind; i++)
 813                         afree(wp[i], ATEMP);
 814                 for (i = 0, j = opt.optind; (wp[i] = wp[j]); i++, j++)
 815                         ;
 816         }
 817         if (!wp[0])
 818                 t->str[0] |= TF_NOARGS;
 819         *app = wp;
 820 }
 821
 822 /* exec with no args - args case is taken care of in comexec() */
 823 int
 824 c_exec(char **wp)
 825 {
 826         int i;
 827
 828         /* make sure redirects stay in place */
 829         if (genv->savefd != NULL) {
 830                 for (i = 0; i < NUFILE; i++) {
 831                         if (genv->savefd[i] > 0)
 832                                 close(genv->savefd[i]);
 833                         /*
 834                          * For ksh keep anything > 2 private,
 835                          * for sh, let them be (POSIX says what
 836                          * happens is unspecified and the bourne shell
 837                          * keeps them open).
 838                          */
 839                         if (!Flag(FSH) && i > 2 && genv->savefd[i])
 840                                 fcntl(i, F_SETFD, FD_CLOEXEC);
 841                 }
 842                 genv->savefd = NULL;
 843         }
 844         return 0;
 845 }
 846
 847 static int
 848 c_suspend(char **wp)
 849 {
 850         if (wp[1] != NULL) {
 851                 bi_errorf("too many arguments");
 852                 return 1;
 853         }
 854         if (Flag(FLOGIN)) {
 855                 /* Can't suspend an orphaned process group. */
 856                 pid_t parent = getppid();
 857                 if (getpgid(parent) == getpgid(0) ||
 858                     getsid(parent) != getsid(0)) {
 859                         bi_errorf("can't suspend a login shell");
 860                         return 1;
 861                 }
 862         }
 863         j_suspend();
 864         return 0;
 865 }
 866
 867 /* dummy function, special case in comexec() */
 868 int
 869 c_builtin(char **wp)
 870 {
 871         return 0;
 872 }
 873
 874 extern  int c_test(char **wp);                  /* in c_test.c */
 875 extern  int c_ulimit(char **wp);                /* in c_ulimit.c */
 876
 877 /* A leading = means assignments before command are kept;
 878  * a leading * means a POSIX special builtin;
 879  * a leading + means a POSIX regular builtin
 880  * (* and + should not be combined).
 881  */
 882 const struct builtin shbuiltins [] = {
 883         {"*=.", c_dot},
 884         {"*=:", c_label},
 885         {"[", c_test},
 886         {"*=break", c_brkcont},
 887         {"=builtin", c_builtin},
 888         {"*=continue", c_brkcont},
 889         {"*=eval", c_eval},
 890         {"*=exec", c_exec},
 891         {"*=exit", c_exitreturn},
 892         {"+false", c_label},
 893         {"*=return", c_exitreturn},
 894         {"*=set", c_set},
 895         {"*=shift", c_shift},
 896         {"*=times", c_times},
 897         {"*=trap", c_trap},
 898         {"+=wait", c_wait},
 899         {"+read", c_read},
 900         {"test", c_test},
 901         {"+true", c_label},
 902         {"ulimit", c_ulimit},
 903         {"+umask", c_umask},
 904         {"*=unset", c_unset},
 905         {"suspend", c_suspend},
 906         {NULL, NULL}
 907 };