coreutils/test.c

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