LXR busybox/shell/shell

   1/* vi: set sw=4 ts=4: */
   2/*
   3 * Adapted from ash applet code
   4 *
   5 * This code is derived from software contributed to Berkeley by
   6 * Kenneth Almquist.
   7 *
   8 * Copyright (c) 1989, 1991, 1993, 1994
   9 *      The Regents of the University of California.  All rights reserved.
  10 *
  11 * Copyright (c) 1997-2005 Herbert Xu <herbert@gondor.apana.org.au>
  12 * was re-ported from NetBSD and debianized.
  13 *
  14 * Copyright (c) 2010 Denys Vlasenko
  15 * Split from ash.c
  16 *
  17 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  18 */
  19#include "libbb.h"
  20#include "shell_common.h"
  21
  22const char defifsvar[] ALIGN1 = "IFS= \t\n";
  23const char defoptindvar[] ALIGN1 = "OPTIND=1";
  24
  25/* read builtin */
  26
  27/* Needs to be interruptible: shell must handle traps and shell-special signals
  28 * while inside read. To implement this, be sure to not loop on EINTR
  29 * and return errno == EINTR reliably.
  30 */
  31//TODO: use more efficient setvar() which takes a pointer to malloced "VAR=VAL"
  32//string. hush naturally has it, and ash has setvareq().
  33//Here we can simply store "VAR=" at buffer start and store read data directly
  34//after "=", then pass buffer to setvar() to consume.
  35const char* FAST_FUNC
  36shell_builtin_read(struct builtin_read_params *params)
  37{
  38        struct pollfd pfd[1];
  39#define fd (pfd[0].fd) /* -u FD */
  40        unsigned err;
  41        unsigned end_ms; /* -t TIMEOUT */
  42        int nchars; /* -n NUM */
  43        char **pp;
  44        char *buffer;
  45        char delim;
  46        struct termios tty, old_tty;
  47        const char *retval;
  48        int bufpos; /* need to be able to hold -1 */
  49        int startword;
  50        smallint backslash;
  51        char **argv;
  52        const char *ifs;
  53        int read_flags;
  54
  55        errno = err = 0;
  56
  57        argv = params->argv;
  58        pp = argv;
  59        while (*pp) {
  60                if (endofname(*pp)[0] != '\0') {
  61                        /* Mimic bash message */
  62                        bb_error_msg("read: '%s': not a valid identifier", *pp);
  63                        return (const char *)(uintptr_t)1;
  64                }
  65                pp++;
  66        }
  67
  68        nchars = 0; /* if != 0, -n is in effect */
  69        if (params->opt_n) {
  70                nchars = bb_strtou(params->opt_n, NULL, 10);
  71                if (nchars < 0 || errno)
  72                        return "invalid count";
  73                /* note: "-n 0": off (bash 3.2 does this too) */
  74        }
  75
  76        end_ms = 0;
  77        if (params->opt_t && !ENABLE_FEATURE_SH_READ_FRAC) {
  78                end_ms = bb_strtou(params->opt_t, NULL, 10);
  79                if (errno)
  80                        return "invalid timeout";
  81                if (end_ms > UINT_MAX / 2048) /* be safely away from overflow */
  82                        end_ms = UINT_MAX / 2048;
  83                end_ms *= 1000;
  84        }
  85        if (params->opt_t && ENABLE_FEATURE_SH_READ_FRAC) {
  86                /* bash 4.3 (maybe earlier) supports -t N.NNNNNN */
  87                char *p;
  88                /* Eat up to three fractional digits */
  89                int frac_digits = 3 + 1;
  90
  91                end_ms = bb_strtou(params->opt_t, &p, 10);
  92                if (end_ms > UINT_MAX / 2048) /* be safely away from overflow */
  93                        end_ms = UINT_MAX / 2048;
  94
  95                if (errno) {
  96                        /* EINVAL = number is ok, but not NUL terminated */
  97                        if (errno != EINVAL || *p != '.')
  98                                return "invalid timeout";
  99                        /* Do not check the rest: bash allows "0.123456xyz" */
 100                        while (*++p && --frac_digits) {
 101                                end_ms *= 10;
 102                                end_ms += (*p - '0');
 103                                if ((unsigned char)(*p - '0') > 9)
 104                                        return "invalid timeout";
 105                        }
 106                }
 107                while (--frac_digits > 0) {
 108                        end_ms *= 10;
 109                }
 110        }
 111
 112        fd = STDIN_FILENO;
 113        if (params->opt_u) {
 114                fd = bb_strtou(params->opt_u, NULL, 10);
 115                if (fd < 0 || errno)
 116                        return "invalid file descriptor";
 117        }
 118
 119        if (params->opt_t && end_ms == 0) {
 120                /* "If timeout is 0, read returns immediately, without trying
 121                 * to read any data. The exit status is 0 if input is available
 122                 * on the specified file descriptor, non-zero otherwise."
 123                 * bash seems to ignore -p PROMPT for this use case.
 124                 */
 125                int r;
 126                pfd[0].events = POLLIN;
 127                r = poll(pfd, 1, /*timeout:*/ 0);
 128                /* Return 0 only if poll returns 1 ("one fd ready"), else return 1: */
 129                return (const char *)(uintptr_t)(r <= 0);
 130        }
 131
 132        if (params->opt_p && isatty(fd)) {
 133                fputs(params->opt_p, stderr);
 134                fflush_all();
 135        }
 136
 137        ifs = params->ifs;
 138        if (ifs == NULL)
 139                ifs = defifs;
 140
 141        read_flags = params->read_flags;
 142        if (nchars || (read_flags & BUILTIN_READ_SILENT)) {
 143                tcgetattr(fd, &tty);
 144                old_tty = tty;
 145                if (nchars) {
 146                        tty.c_lflag &= ~ICANON;
 147                        // Setting it to more than 1 breaks poll():
 148                        // it blocks even if there's data. !??
 149                        //tty.c_cc[VMIN] = nchars < 256 ? nchars : 255;
 150                        /* reads will block only if < 1 char is available */
 151                        tty.c_cc[VMIN] = 1;
 152                        /* no timeout (reads block forever) */
 153                        tty.c_cc[VTIME] = 0;
 154                }
 155                if (read_flags & BUILTIN_READ_SILENT) {
 156                        tty.c_lflag &= ~(ECHO | ECHOK | ECHONL);
 157                }
 158                /* This forces execution of "restoring" tcgetattr later */
 159                read_flags |= BUILTIN_READ_SILENT;
 160                /* if tcgetattr failed, tcsetattr will fail too.
 161                 * Ignoring, it's harmless. */
 162                tcsetattr(fd, TCSANOW, &tty);
 163        }
 164
 165        retval = (const char *)(uintptr_t)0;
 166        startword = 1;
 167        backslash = 0;
 168        if (params->opt_t)
 169                end_ms += (unsigned)monotonic_ms();
 170        buffer = NULL;
 171        bufpos = 0;
 172        delim = params->opt_d ? params->opt_d[0] : '\n';
 173        do {
 174                char c;
 175                int timeout;
 176
 177                if ((bufpos & 0xff) == 0)
 178                        buffer = xrealloc(buffer, bufpos + 0x101);
 179
 180                timeout = -1;
 181                if (params->opt_t) {
 182                        timeout = end_ms - (unsigned)monotonic_ms();
 183                        /* ^^^^^^^^^^^^^ all values are unsigned,
 184                         * wrapping math is used here, good even if
 185                         * 32-bit unix time wrapped (year 2038+).
 186                         */
 187                        if (timeout <= 0) { /* already late? */
 188                                retval = (const char *)(uintptr_t)1;
 189                                goto ret;
 190                        }
 191                }
 192
 193                /* We must poll even if timeout is -1:
 194                 * we want to be interrupted if signal arrives,
 195                 * regardless of SA_RESTART-ness of that signal!
 196                 */
 197                errno = 0;
 198                pfd[0].events = POLLIN;
 199                if (poll(pfd, 1, timeout) <= 0) {
 200                        /* timed out, or EINTR */
 201                        err = errno;
 202                        retval = (const char *)(uintptr_t)1;
 203                        goto ret;
 204                }
 205                if (read(fd, &buffer[bufpos], 1) != 1) {
 206                        err = errno;
 207                        retval = (const char *)(uintptr_t)1;
 208                        break;
 209                }
 210
 211                c = buffer[bufpos];
 212                if (c == '\0')
 213                        continue;
 214                if (!(read_flags & BUILTIN_READ_RAW)) {
 215                        if (backslash) {
 216                                backslash = 0;
 217                                if (c != '\n')
 218                                        goto put;
 219                                continue;
 220                        }
 221                        if (c == '\\') {
 222                                backslash = 1;
 223                                continue;
 224                        }
 225                }
 226                if (c == delim) /* '\n' or -d CHAR */
 227                        break;
 228
 229                /* $IFS splitting. NOT done if we run "read"
 230                 * without variable names (bash compat).
 231                 * Thus, "read" and "read REPLY" are not the same.
 232                 */
 233                if (!params->opt_d && argv[0]) {
 234/* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05 */
 235                        const char *is_ifs = strchr(ifs, c);
 236                        if (startword && is_ifs) {
 237                                if (isspace(c))
 238                                        continue;
 239                                /* it is a non-space ifs char */
 240                                startword--;
 241                                if (startword == 1) /* first one? */
 242                                        continue; /* yes, it is not next word yet */
 243                        }
 244                        startword = 0;
 245                        if (argv[1] != NULL && is_ifs) {
 246                                buffer[bufpos] = '\0';
 247                                bufpos = 0;
 248                                params->setvar(*argv, buffer);
 249                                argv++;
 250                                /* can we skip one non-space ifs char? (2: yes) */
 251                                startword = isspace(c) ? 2 : 1;
 252                                continue;
 253                        }
 254                }
 255 put:
 256                bufpos++;
 257        } while (--nchars);
 258
 259        if (argv[0]) {
 260                /* Remove trailing space $IFS chars */
 261                while (--bufpos >= 0
 262                 && isspace(buffer[bufpos])
 263                 && strchr(ifs, buffer[bufpos]) != NULL
 264                ) {
 265                        continue;
 266                }
 267                buffer[bufpos + 1] = '\0';
 268
 269                /* Last variable takes the entire remainder with delimiters
 270                 * (sans trailing whitespace $IFS),
 271                 * but ***only "if there are fewer vars than fields"(c)***!
 272                 * The "X:Y:" case below: there are two fields,
 273                 * and therefore last delimiter (:) is eaten:
 274                 * IFS=": "
 275                 * echo "X:Y:Z:"  | (read x y; echo "|$x|$y|") # |X|Y:Z:|
 276                 * echo "X:Y:Z"   | (read x y; echo "|$x|$y|") # |X|Y:Z|
 277                 * echo "X:Y:"    | (read x y; echo "|$x|$y|") # |X|Y|, not |X|Y:|
 278                 * echo "X:Y  : " | (read x y; echo "|$x|$y|") # |X|Y|
 279                 */
 280                if (bufpos >= 0
 281                 && strchr(ifs, buffer[bufpos]) != NULL
 282                ) {
 283                        /* There _is_ a non-whitespace IFS char */
 284                        /* Skip whitespace IFS char before it */
 285                        while (--bufpos >= 0
 286                         && isspace(buffer[bufpos])
 287                         && strchr(ifs, buffer[bufpos]) != NULL
 288                        ) {
 289                                continue;
 290                        }
 291                        /* Are there $IFS chars? */
 292                        if (strcspn(buffer, ifs) >= ++bufpos) {
 293                                /* No: last var takes one field, not more */
 294                                /* So, drop trailing IFS delims */
 295                                buffer[bufpos] = '\0';
 296                        }
 297                }
 298
 299                /* Use the remainder as a value for the next variable */
 300                params->setvar(*argv, buffer);
 301                /* Set the rest to "" */
 302                while (*++argv)
 303                        params->setvar(*argv, "");
 304        } else {
 305                /* Note: no $IFS removal */
 306                buffer[bufpos] = '\0';
 307                params->setvar("REPLY", buffer);
 308        }
 309
 310 ret:
 311        free(buffer);
 312        if (read_flags & BUILTIN_READ_SILENT)
 313                tcsetattr(fd, TCSANOW, &old_tty);
 314
 315        errno = err;
 316        return retval;
 317#undef fd
 318}
 319
 320/* ulimit builtin */
 321
 322struct limits {
 323        uint8_t cmd;            /* RLIMIT_xxx fit into it */
 324        uint8_t factor_shift;   /* shift by to get rlim_{cur,max} values */
 325        const char *name;
 326};
 327
 328static const struct limits limits_tbl[] = {
 329        { RLIMIT_CORE,          9,      "core file size (blocks)" }, // -c
 330        { RLIMIT_DATA,          10,     "data seg size (kb)" },      // -d
 331        { RLIMIT_NICE,          0,      "scheduling priority" },     // -e
 332        { RLIMIT_FSIZE,         9,      "file size (blocks)" },      // -f
 333#define LIMIT_F_IDX     3
 334#ifdef RLIMIT_SIGPENDING
 335        { RLIMIT_SIGPENDING,    0,      "pending signals" },         // -i
 336#endif
 337#ifdef RLIMIT_MEMLOCK
 338        { RLIMIT_MEMLOCK,       10,     "max locked memory (kb)" },  // -l
 339#endif
 340#ifdef RLIMIT_RSS
 341        { RLIMIT_RSS,           10,     "max memory size (kb)" },    // -m
 342#endif
 343#ifdef RLIMIT_NOFILE
 344        { RLIMIT_NOFILE,        0,      "open files" },              // -n
 345#endif
 346#ifdef RLIMIT_MSGQUEUE
 347        { RLIMIT_MSGQUEUE,      0,      "POSIX message queues (bytes)" }, // -q
 348#endif
 349#ifdef RLIMIT_RTPRIO
 350        { RLIMIT_RTPRIO,        0,      "real-time priority" },      // -r
 351#endif
 352#ifdef RLIMIT_STACK
 353        { RLIMIT_STACK,         10,     "stack size (kb)" },         // -s
 354#endif
 355#ifdef RLIMIT_CPU
 356        { RLIMIT_CPU,           0,      "cpu time (seconds)" },      // -t
 357#endif
 358#ifdef RLIMIT_NPROC
 359        { RLIMIT_NPROC,         0,      "max user processes" },      // -u
 360#endif
 361#ifdef RLIMIT_AS
 362        { RLIMIT_AS,            10,     "virtual memory (kb)" },     // -v
 363#endif
 364#ifdef RLIMIT_LOCKS
 365        { RLIMIT_LOCKS,         0,      "file locks" },              // -x
 366#endif
 367};
 368// bash also shows:
 369//pipe size            (512 bytes, -p) 8
 370
 371static const char limit_chars[] ALIGN1 =
 372                        "c"
 373                        "d"
 374                        "e"
 375                        "f"
 376#ifdef RLIMIT_SIGPENDING
 377                        "i"
 378#endif
 379#ifdef RLIMIT_MEMLOCK
 380                        "l"
 381#endif
 382#ifdef RLIMIT_RSS
 383                        "m"
 384#endif
 385#ifdef RLIMIT_NOFILE
 386                        "n"
 387#endif
 388#ifdef RLIMIT_MSGQUEUE
 389                        "q"
 390#endif
 391#ifdef RLIMIT_RTPRIO
 392                        "r"
 393#endif
 394#ifdef RLIMIT_STACK
 395                        "s"
 396#endif
 397#ifdef RLIMIT_CPU
 398                        "t"
 399#endif
 400#ifdef RLIMIT_NPROC
 401                        "u"
 402#endif
 403#ifdef RLIMIT_AS
 404                        "v"
 405#endif
 406#ifdef RLIMIT_LOCKS
 407                        "x"
 408#endif
 409;
 410
 411/* "-": treat args as parameters of option with ASCII code 1 */
 412static const char ulimit_opt_string[] ALIGN1 = "-HSa"
 413                        "c::"
 414                        "d::"
 415                        "e::"
 416                        "f::"
 417#ifdef RLIMIT_SIGPENDING
 418                        "i::"
 419#endif
 420#ifdef RLIMIT_MEMLOCK
 421                        "l::"
 422#endif
 423#ifdef RLIMIT_RSS
 424                        "m::"
 425#endif
 426#ifdef RLIMIT_NOFILE
 427                        "n::"
 428#endif
 429#ifdef RLIMIT_MSGQUEUE
 430                        "q::"
 431#endif
 432#ifdef RLIMIT_RTPRIO
 433                        "r::"
 434#endif
 435#ifdef RLIMIT_STACK
 436                        "s::"
 437#endif
 438#ifdef RLIMIT_CPU
 439                        "t::"
 440#endif
 441#ifdef RLIMIT_NPROC
 442                        "u::"
 443#endif
 444#ifdef RLIMIT_AS
 445                        "v::"
 446#endif
 447#ifdef RLIMIT_LOCKS
 448                        "x::"
 449#endif
 450;
 451
 452enum {
 453        OPT_hard = (1 << 0),
 454        OPT_soft = (1 << 1),
 455        OPT_all  = (1 << 2),
 456};
 457
 458static void printlim(unsigned opts, const struct rlimit *limit,
 459                        const struct limits *l)
 460{
 461        rlim_t val;
 462
 463        val = limit->rlim_max;
 464        if (opts & OPT_soft)
 465                val = limit->rlim_cur;
 466
 467        if (val == RLIM_INFINITY)
 468                puts("unlimited");
 469        else {
 470                val >>= l->factor_shift;
 471                printf("%llu\n", (long long) val);
 472        }
 473}
 474
 475int FAST_FUNC
 476shell_builtin_ulimit(char **argv)
 477{
 478        struct rlimit limit;
 479        unsigned opt_cnt;
 480        unsigned opts;
 481        unsigned argc;
 482        unsigned i;
 483
 484        /* We can't use getopt32: need to handle commands like
 485         * ulimit 123 -c2 -l 456
 486         */
 487
 488        /* In case getopt() was already called:
 489         * reset libc getopt() internal state.
 490         */
 491        GETOPT_RESET();
 492
 493// bash 4.4.23:
 494//
 495// -H and/or -S change meaning even of options *before* them: ulimit -f 2000 -H
 496// sets hard limit, ulimit -a -H prints hard limits.
 497//
 498// -a is equivalent for requesting all limits to be shown.
 499//
 500// If -a is specified, attempts to set limits are ignored:
 501//  ulimit -m 1000; ulimit -m 2000 -a
 502// shows 1000, not 2000. HOWEVER, *implicit* -f form "ulimit 2000 -a"
 503// DOES set -f limit [we don't implement this quirk], "ulimit -a 2000" does not.
 504// Options are still parsed: ulimit -az complains about unknown -z opt.
 505//
 506// -a is not cumulative: "ulimit -a -a" = "ulimit -a -f -m" = "ulimit -a"
 507//
 508// -HSa can be combined in one argument and with one other option (example: -Sm),
 509// but other options can't: limit value is an optional argument,
 510// thus "-mf" means "-m f", f is the parameter of -m.
 511//
 512// Limit can be set and then printed: ulimit -m 2000 -m
 513// If set more than once, they are set and printed in order:
 514// try ulimit -m -m 1000 -m -m 2000 -m -m 3000 -m
 515//
 516// Limits are shown in the order of options given:
 517// ulimit -m -f is not the same as ulimit -f -m.
 518//
 519// If both -S and -H are given, show soft limit.
 520//
 521// Short printout (limit value only) is printed only if just one option
 522// is given: ulimit -m. ulimit -f -m prints verbose lines.
 523// ulimit -f -f prints same verbose line twice.
 524// ulimit -m 10000 -f prints verbose line for -f.
 525
 526        argc = string_array_len(argv);
 527
 528        /* First pass over options: detect -H/-S/-a status,
 529         * and "bare ulimit" and "only one option" cases
 530         * by counting other opts.
 531         */
 532        opt_cnt = 0;
 533        opts = 0;
 534        while (1) {
 535                int opt_char = getopt(argc, argv, ulimit_opt_string);
 536
 537                if (opt_char == -1)
 538                        break;
 539                if (opt_char == 'H') {
 540                        opts |= OPT_hard;
 541                        continue;
 542                }
 543                if (opt_char == 'S') {
 544                        opts |= OPT_soft;
 545                        continue;
 546                }
 547                if (opt_char == 'a') {
 548                        opts |= OPT_all;
 549                        continue;
 550                }
 551                if (opt_char == '?') {
 552                        /* bad option. getopt already complained. */
 553                        return EXIT_FAILURE;
 554                }
 555                opt_cnt++;
 556        } /* while (there are options) */
 557
 558        if (!(opts & (OPT_hard | OPT_soft)))
 559                opts |= (OPT_hard | OPT_soft);
 560        if (opts & OPT_all) {
 561                for (i = 0; i < ARRAY_SIZE(limits_tbl); i++) {
 562                        getrlimit(limits_tbl[i].cmd, &limit);
 563                        printf("%-32s(-%c) ", limits_tbl[i].name, limit_chars[i]);
 564                        printlim(opts, &limit, &limits_tbl[i]);
 565                }
 566                return EXIT_SUCCESS;
 567        }
 568
 569        /* Second pass: set or print limits, in order */
 570        GETOPT_RESET();
 571        while (1) {
 572                char *val_str;
 573                int opt_char = getopt(argc, argv, ulimit_opt_string);
 574
 575                if (opt_char == -1)
 576                        break;
 577                if (opt_char == 'H')
 578                        continue;
 579                if (opt_char == 'S')
 580                        continue;
 581                //if (opt_char == 'a') - impossible
 582
 583                if (opt_char == 1) /* if "ulimit NNN", -f is assumed */
 584                        opt_char = 'f';
 585                i = strchrnul(limit_chars, opt_char) - limit_chars;
 586                //if (i >= ARRAY_SIZE(limits_tbl)) - bad option, impossible
 587
 588                val_str = optarg;
 589                if (!val_str && argv[optind] && argv[optind][0] != '-')
 590                        val_str = argv[optind++]; /* ++ skips NN in "-c NN" case */
 591
 592                getrlimit(limits_tbl[i].cmd, &limit);
 593                if (!val_str) {
 594                        if (opt_cnt > 1)
 595                                printf("%-32s(-%c) ", limits_tbl[i].name, limit_chars[i]);
 596                        printlim(opts, &limit, &limits_tbl[i]);
 597                } else {
 598                        rlim_t val = RLIM_INFINITY;
 599                        if (strcmp(val_str, "unlimited") != 0) {
 600                                if (sizeof(val) == sizeof(int))
 601                                        val = bb_strtou(val_str, NULL, 10);
 602                                else if (sizeof(val) == sizeof(long))
 603                                        val = bb_strtoul(val_str, NULL, 10);
 604                                else
 605                                        val = bb_strtoull(val_str, NULL, 10);
 606                                if (errno) {
 607                                        bb_error_msg("invalid number '%s'", val_str);
 608                                        return EXIT_FAILURE;
 609                                }
 610                                val <<= limits_tbl[i].factor_shift;
 611                        }
 612//bb_error_msg("opt %c val_str:'%s' val:%lld", opt_char, val_str, (long long)val);
 613                        /* from man bash: "If neither -H nor -S
 614                         * is specified, both the soft and hard
 615                         * limits are set. */
 616                        if (opts & OPT_hard)
 617                                limit.rlim_max = val;
 618                        if (opts & OPT_soft)
 619                                limit.rlim_cur = val;
 620//bb_error_msg("setrlimit(%d, %lld, %lld)", limits_tbl[i].cmd, (long long)limit.rlim_cur, (long long)limit.rlim_max);
 621                        if (setrlimit(limits_tbl[i].cmd, &limit) < 0) {
 622                                bb_perror_msg("error setting limit");
 623                                return EXIT_FAILURE;
 624                        }
 625                }
 626        } /* while (there are options) */
 627
 628        if (opt_cnt == 0) {
 629                /* "bare ulimit": treat it as if it was -f */
 630                getrlimit(limits_tbl[LIMIT_F_IDX].cmd, &limit);
 631                printlim(opts, &limit, &limits_tbl[LIMIT_F_IDX]);
 632        }
 633
 634        return EXIT_SUCCESS;
 635}
 636