Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/mkinitrd-magellan/busybox/coreutils/test.c

    Contents of /trunk/mkinitrd-magellan/busybox/coreutils/test.c

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 532 - (show annotations) (download)
    Sat Sep 1 22:45:15 2007 UTC (16 years, 8 months ago) by niro
    File MIME type: text/plain
    File size: 11204 byte(s) 
    -import if magellan mkinitrd; it is a fork of redhats mkinitrd-5.0.8 with all magellan patches and features; deprecates magellan-src/mkinitrd
    1 /* vi: set sw=4 ts=4: */
    2 /*
    3 * test implementation for busybox
    4 *
    5 * Copyright (c) by a whole pile of folks:
    6 *
    7 * test(1); version 7-like -- author Erik Baalbergen
    8 * modified by Eric Gisin to be used as built-in.
    9 * modified by Arnold Robbins to add SVR3 compatibility
    10 * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
    11 * modified by J.T. Conklin for NetBSD.
    12 * modified by Herbert Xu to be used as built-in in ash.
    13 * modified by Erik Andersen <andersen@codepoet.org> to be used
    14 * in busybox.
    15 *
    16 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
    17 *
    18 * Original copyright notice states:
    19 * "This program is in the Public Domain."
    20 */
    21
    22 #include "busybox.h"
    23 #include <unistd.h>
    24 #include <ctype.h>
    25 #include <errno.h>
    26 #include <string.h>
    27 #include <setjmp.h>
    28
    29 /* test(1) accepts the following grammar:
    30 oexpr ::= aexpr | aexpr "-o" oexpr ;
    31 aexpr ::= nexpr | nexpr "-a" aexpr ;
    32 nexpr ::= primary | "!" primary
    33 primary ::= unary-operator operand
    34 | operand binary-operator operand
    35 | operand
    36 | "(" oexpr ")"
    37 ;
    38 unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
    39 "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";
    40
    41 binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
    42 "-nt"|"-ot"|"-ef";
    43 operand ::= <any legal UNIX file name>
    44 */
    45
    46 enum token {
    47 EOI,
    48 FILRD,
    49 FILWR,
    50 FILEX,
    51 FILEXIST,
    52 FILREG,
    53 FILDIR,
    54 FILCDEV,
    55 FILBDEV,
    56 FILFIFO,
    57 FILSOCK,
    58 FILSYM,
    59 FILGZ,
    60 FILTT,
    61 FILSUID,
    62 FILSGID,
    63 FILSTCK,
    64 FILNT,
    65 FILOT,
    66 FILEQ,
    67 FILUID,
    68 FILGID,
    69 STREZ,
    70 STRNZ,
    71 STREQ,
    72 STRNE,
    73 STRLT,
    74 STRGT,
    75 INTEQ,
    76 INTNE,
    77 INTGE,
    78 INTGT,
    79 INTLE,
    80 INTLT,
    81 UNOT,
    82 BAND,
    83 BOR,
    84 LPAREN,
    85 RPAREN,
    86 OPERAND
    87 };
    88
    89 enum token_types {
    90 UNOP,
    91 BINOP,
    92 BUNOP,
    93 BBINOP,
    94 PAREN
    95 };
    96
    97 static const struct t_op {
    98 const char *op_text;
    99 short op_num, op_type;
    100 } ops[] = {
    101 {
    102 "-r", FILRD, UNOP}, {
    103 "-w", FILWR, UNOP}, {
    104 "-x", FILEX, UNOP}, {
    105 "-e", FILEXIST, UNOP}, {
    106 "-f", FILREG, UNOP}, {
    107 "-d", FILDIR, UNOP}, {
    108 "-c", FILCDEV, UNOP}, {
    109 "-b", FILBDEV, UNOP}, {
    110 "-p", FILFIFO, UNOP}, {
    111 "-u", FILSUID, UNOP}, {
    112 "-g", FILSGID, UNOP}, {
    113 "-k", FILSTCK, UNOP}, {
    114 "-s", FILGZ, UNOP}, {
    115 "-t", FILTT, UNOP}, {
    116 "-z", STREZ, UNOP}, {
    117 "-n", STRNZ, UNOP}, {
    118 "-h", FILSYM, UNOP}, /* for backwards compat */
    119 {
    120 "-O", FILUID, UNOP}, {
    121 "-G", FILGID, UNOP}, {
    122 "-L", FILSYM, UNOP}, {
    123 "-S", FILSOCK, UNOP}, {
    124 "=", STREQ, BINOP}, {
    125 "==", STREQ, BINOP}, {
    126 "!=", STRNE, BINOP}, {
    127 "<", STRLT, BINOP}, {
    128 ">", STRGT, BINOP}, {
    129 "-eq", INTEQ, BINOP}, {
    130 "-ne", INTNE, BINOP}, {
    131 "-ge", INTGE, BINOP}, {
    132 "-gt", INTGT, BINOP}, {
    133 "-le", INTLE, BINOP}, {
    134 "-lt", INTLT, BINOP}, {
    135 "-nt", FILNT, BINOP}, {
    136 "-ot", FILOT, BINOP}, {
    137 "-ef", FILEQ, BINOP}, {
    138 "!", UNOT, BUNOP}, {
    139 "-a", BAND, BBINOP}, {
    140 "-o", BOR, BBINOP}, {
    141 "(", LPAREN, PAREN}, {
    142 ")", RPAREN, PAREN}, {
    143 0, 0, 0}
    144 };
    145
    146 #ifdef CONFIG_FEATURE_TEST_64
    147 typedef int64_t arith_t;
    148 #else
    149 typedef int arith_t;
    150 #endif
    151
    152 static char **t_wp;
    153 static struct t_op const *t_wp_op;
    154 static gid_t *group_array;
    155 static int ngroups;
    156
    157 static enum token t_lex(char *s);
    158 static arith_t oexpr(enum token n);
    159 static arith_t aexpr(enum token n);
    160 static arith_t nexpr(enum token n);
    161 static int binop(void);
    162 static arith_t primary(enum token n);
    163 static int filstat(char *nm, enum token mode);
    164 static arith_t getn(const char *s);
    165 static int newerf(const char *f1, const char *f2);
    166 static int olderf(const char *f1, const char *f2);
    167 static int equalf(const char *f1, const char *f2);
    168 static int test_eaccess(char *path, int mode);
    169 static int is_a_group_member(gid_t gid);
    170 static void initialize_group_array(void);
    171
    172 static jmp_buf leaving;
    173
    174 int bb_test(int argc, char **argv)
    175 {
    176 int res;
    177
    178 if (LONE_CHAR(argv[0], '[')) {
    179 --argc;
    180 if (NOT_LONE_CHAR(argv[argc], ']')) {
    181 bb_error_msg("missing ]");
    182 return 2;
    183 }
    184 argv[argc] = NULL;
    185 } else if (strcmp(argv[0], "[[") == 0) {
    186 --argc;
    187 if (strcmp(argv[argc], "]]")) {
    188 bb_error_msg("missing ]]");
    189 return 2;
    190 }
    191 argv[argc] = NULL;
    192 }
    193
    194 res = setjmp(leaving);
    195 if (res)
    196 return res;
    197
    198 /* resetting ngroups is probably unnecessary. it will
    199 * force a new call to getgroups(), which prevents using
    200 * group data fetched during a previous call. but the
    201 * only way the group data could be stale is if there's
    202 * been an intervening call to setgroups(), and this
    203 * isn't likely in the case of a shell. paranoia
    204 * prevails...
    205 */
    206 ngroups = 0;
    207
    208 /* Implement special cases from POSIX.2, section 4.62.4 */
    209 switch (argc) {
    210 case 1:
    211 return 1;
    212 case 2:
    213 return *argv[1] == '\0';
    214 case 3:
    215 if (argv[1][0] == '!' && argv[1][1] == '\0') {
    216 return *argv[2] != '\0';
    217 }
    218 break;
    219 case 4:
    220 if (argv[1][0] != '!' || argv[1][1] != '\0') {
    221 if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) {
    222 t_wp = &argv[1];
    223 return binop() == 0;
    224 }
    225 }
    226 break;
    227 case 5:
    228 if (argv[1][0] == '!' && argv[1][1] == '\0') {
    229 if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) {
    230 t_wp = &argv[2];
    231 return binop() != 0;
    232 }
    233 }
    234 break;
    235 }
    236
    237 t_wp = &argv[1];
    238 res = !oexpr(t_lex(*t_wp));
    239
    240 if (*t_wp != NULL && *++t_wp != NULL) {
    241 bb_error_msg("%s: unknown operand", *t_wp);
    242 return 2;
    243 }
    244 return res;
    245 }
    246
    247 static void syntax(const char *op, const char *msg)
    248 {
    249 if (op && *op) {
    250 bb_error_msg("%s: %s", op, msg);
    251 } else {
    252 bb_error_msg("%s", msg);
    253 }
    254 longjmp(leaving, 2);
    255 }
    256
    257 static arith_t oexpr(enum token n)
    258 {
    259 arith_t res;
    260
    261 res = aexpr(n);
    262 if (t_lex(*++t_wp) == BOR) {
    263 return oexpr(t_lex(*++t_wp)) || res;
    264 }
    265 t_wp--;
    266 return res;
    267 }
    268
    269 static arith_t aexpr(enum token n)
    270 {
    271 arith_t res;
    272
    273 res = nexpr(n);
    274 if (t_lex(*++t_wp) == BAND)
    275 return aexpr(t_lex(*++t_wp)) && res;
    276 t_wp--;
    277 return res;
    278 }
    279
    280 static arith_t nexpr(enum token n)
    281 {
    282 if (n == UNOT)
    283 return !nexpr(t_lex(*++t_wp));
    284 return primary(n);
    285 }
    286
    287 static arith_t primary(enum token n)
    288 {
    289 arith_t res;
    290
    291 if (n == EOI) {
    292 syntax(NULL, "argument expected");
    293 }
    294 if (n == LPAREN) {
    295 res = oexpr(t_lex(*++t_wp));
    296 if (t_lex(*++t_wp) != RPAREN)
    297 syntax(NULL, "closing paren expected");
    298 return res;
    299 }
    300 if (t_wp_op && t_wp_op->op_type == UNOP) {
    301 /* unary expression */
    302 if (*++t_wp == NULL)
    303 syntax(t_wp_op->op_text, "argument expected");
    304 switch (n) {
    305 case STREZ:
    306 return strlen(*t_wp) == 0;
    307 case STRNZ:
    308 return strlen(*t_wp) != 0;
    309 case FILTT:
    310 return isatty(getn(*t_wp));
    311 default:
    312 return filstat(*t_wp, n);
    313 }
    314 }
    315
    316 if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) {
    317 return binop();
    318 }
    319
    320 return strlen(*t_wp) > 0;
    321 }
    322
    323 static int binop(void)
    324 {
    325 const char *opnd1, *opnd2;
    326 struct t_op const *op;
    327
    328 opnd1 = *t_wp;
    329 (void) t_lex(*++t_wp);
    330 op = t_wp_op;
    331
    332 if ((opnd2 = *++t_wp) == (char *) 0)
    333 syntax(op->op_text, "argument expected");
    334
    335 switch (op->op_num) {
    336 case STREQ:
    337 return strcmp(opnd1, opnd2) == 0;
    338 case STRNE:
    339 return strcmp(opnd1, opnd2) != 0;
    340 case STRLT:
    341 return strcmp(opnd1, opnd2) < 0;
    342 case STRGT:
    343 return strcmp(opnd1, opnd2) > 0;
    344 case INTEQ:
    345 return getn(opnd1) == getn(opnd2);
    346 case INTNE:
    347 return getn(opnd1) != getn(opnd2);
    348 case INTGE:
    349 return getn(opnd1) >= getn(opnd2);
    350 case INTGT:
    351 return getn(opnd1) > getn(opnd2);
    352 case INTLE:
    353 return getn(opnd1) <= getn(opnd2);
    354 case INTLT:
    355 return getn(opnd1) < getn(opnd2);
    356 case FILNT:
    357 return newerf(opnd1, opnd2);
    358 case FILOT:
    359 return olderf(opnd1, opnd2);
    360 case FILEQ:
    361 return equalf(opnd1, opnd2);
    362 }
    363 /* NOTREACHED */
    364 return 1;
    365 }
    366
    367 static int filstat(char *nm, enum token mode)
    368 {
    369 struct stat s;
    370 unsigned int i;
    371
    372 if (mode == FILSYM) {
    373 #ifdef S_IFLNK
    374 if (lstat(nm, &s) == 0) {
    375 i = S_IFLNK;
    376 goto filetype;
    377 }
    378 #endif
    379 return 0;
    380 }
    381
    382 if (stat(nm, &s) != 0)
    383 return 0;
    384
    385 switch (mode) {
    386 case FILRD:
    387 return test_eaccess(nm, R_OK) == 0;
    388 case FILWR:
    389 return test_eaccess(nm, W_OK) == 0;
    390 case FILEX:
    391 return test_eaccess(nm, X_OK) == 0;
    392 case FILEXIST:
    393 return 1;
    394 case FILREG:
    395 i = S_IFREG;
    396 goto filetype;
    397 case FILDIR:
    398 i = S_IFDIR;
    399 goto filetype;
    400 case FILCDEV:
    401 i = S_IFCHR;
    402 goto filetype;
    403 case FILBDEV:
    404 i = S_IFBLK;
    405 goto filetype;
    406 case FILFIFO:
    407 #ifdef S_IFIFO
    408 i = S_IFIFO;
    409 goto filetype;
    410 #else
    411 return 0;
    412 #endif
    413 case FILSOCK:
    414 #ifdef S_IFSOCK
    415 i = S_IFSOCK;
    416 goto filetype;
    417 #else
    418 return 0;
    419 #endif
    420 case FILSUID:
    421 i = S_ISUID;
    422 goto filebit;
    423 case FILSGID:
    424 i = S_ISGID;
    425 goto filebit;
    426 case FILSTCK:
    427 i = S_ISVTX;
    428 goto filebit;
    429 case FILGZ:
    430 return s.st_size > 0L;
    431 case FILUID:
    432 return s.st_uid == geteuid();
    433 case FILGID:
    434 return s.st_gid == getegid();
    435 default:
    436 return 1;
    437 }
    438
    439 filetype:
    440 return ((s.st_mode & S_IFMT) == i);
    441
    442 filebit:
    443 return ((s.st_mode & i) != 0);
    444 }
    445
    446 static enum token t_lex(char *s)
    447 {
    448 struct t_op const *op = ops;
    449
    450 if (s == 0) {
    451 t_wp_op = (struct t_op *) 0;
    452 return EOI;
    453 }
    454 while (op->op_text) {
    455 if (strcmp(s, op->op_text) == 0) {
    456 t_wp_op = op;
    457 return op->op_num;
    458 }
    459 op++;
    460 }
    461 t_wp_op = (struct t_op *) 0;
    462 return OPERAND;
    463 }
    464
    465 /* atoi with error detection */
    466 static arith_t getn(const char *s)
    467 {
    468 char *p;
    469 #ifdef CONFIG_FEATURE_TEST_64
    470 long long r;
    471 #else
    472 long r;
    473 #endif
    474
    475 errno = 0;
    476 #ifdef CONFIG_FEATURE_TEST_64
    477 r = strtoll(s, &p, 10);
    478 #else
    479 r = strtol(s, &p, 10);
    480 #endif
    481
    482 if (errno != 0)
    483 syntax(s, "out of range");
    484
    485 if (*(skip_whitespace(p)))
    486 syntax(s, "bad number");
    487
    488 return r;
    489 }
    490
    491 static int newerf(const char *f1, const char *f2)
    492 {
    493 struct stat b1, b2;
    494
    495 return (stat(f1, &b1) == 0 &&
    496 stat(f2, &b2) == 0 && b1.st_mtime > b2.st_mtime);
    497 }
    498
    499 static int olderf(const char *f1, const char *f2)
    500 {
    501 struct stat b1, b2;
    502
    503 return (stat(f1, &b1) == 0 &&
    504 stat(f2, &b2) == 0 && b1.st_mtime < b2.st_mtime);
    505 }
    506
    507 static int equalf(const char *f1, const char *f2)
    508 {
    509 struct stat b1, b2;
    510
    511 return (stat(f1, &b1) == 0 &&
    512 stat(f2, &b2) == 0 &&
    513 b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino);
    514 }
    515
    516 /* Do the same thing access(2) does, but use the effective uid and gid,
    517 and don't make the mistake of telling root that any file is
    518 executable. */
    519 static int test_eaccess(char *path, int mode)
    520 {
    521 struct stat st;
    522 unsigned int euid = geteuid();
    523
    524 if (stat(path, &st) < 0)
    525 return -1;
    526
    527 if (euid == 0) {
    528 /* Root can read or write any file. */
    529 if (mode != X_OK)
    530 return 0;
    531
    532 /* Root can execute any file that has any one of the execute
    533 bits set. */
    534 if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
    535 return 0;
    536 }
    537
    538 if (st.st_uid == euid) /* owner */
    539 mode <<= 6;
    540 else if (is_a_group_member(st.st_gid))
    541 mode <<= 3;
    542
    543 if (st.st_mode & mode)
    544 return 0;
    545
    546 return -1;
    547 }
    548
    549 static void initialize_group_array(void)
    550 {
    551 ngroups = getgroups(0, NULL);
    552 if (ngroups > 0) {
    553 group_array = xmalloc(ngroups * sizeof(gid_t));
    554 getgroups(ngroups, group_array);
    555 }
    556 }
    557
    558 /* Return non-zero if GID is one that we have in our groups list. */
    559 static int is_a_group_member(gid_t gid)
    560 {
    561 int i;
    562
    563 /* Short-circuit if possible, maybe saving a call to getgroups(). */
    564 if (gid == getgid() || gid == getegid())
    565 return 1;
    566
    567 if (ngroups == 0)
    568 initialize_group_array();
    569
    570 /* Search through the list looking for GID. */
    571 for (i = 0; i < ngroups; i++)
    572 if (gid == group_array[i])
    573 return 1;
    574
    575 return 0;
    576 }
    577
    578
    579 /* applet entry point */
    580
    581 int test_main(int argc, char **argv)
    582 {
    583 return bb_test(argc, argv);
    584 }
    585