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 <andersee@debian.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         {"-r",  FILRD,  UNOP},
 115         {"-w",  FILWR,  UNOP},
 116         {"-x",  FILEX,  UNOP},
 117         {"-e",  FILEXIST,UNOP},
 118         {"-f",  FILREG, UNOP},
 119         {"-d",  FILDIR, UNOP},
 120         {"-c",  FILCDEV,UNOP},
 121         {"-b",  FILBDEV,UNOP},
 122         {"-p",  FILFIFO,UNOP},
 123         {"-u",  FILSUID,UNOP},
 124         {"-g",  FILSGID,UNOP},
 125         {"-k",  FILSTCK,UNOP},
 126         {"-s",  FILGZ,  UNOP},
 127         {"-t",  FILTT,  UNOP},
 128         {"-z",  STREZ,  UNOP},
 129         {"-n",  STRNZ,  UNOP},
 130         {"-h",  FILSYM, UNOP},          /* for backwards compat */
 131         {"-O",  FILUID, UNOP},
 132         {"-G",  FILGID, UNOP},
 133         {"-L",  FILSYM, UNOP},
 134         {"-S",  FILSOCK,UNOP},
 135         {"=",   STREQ,  BINOP},
 136         {"!=",  STRNE,  BINOP},
 137         {"<",   STRLT,  BINOP},
 138         {">",   STRGT,  BINOP},
 139         {"-eq", INTEQ,  BINOP},
 140         {"-ne", INTNE,  BINOP},
 141         {"-ge", INTGE,  BINOP},
 142         {"-gt", INTGT,  BINOP},
 143         {"-le", INTLE,  BINOP},
 144         {"-lt", INTLT,  BINOP},
 145         {"-nt", FILNT,  BINOP},
 146         {"-ot", FILOT,  BINOP},
 147         {"-ef", FILEQ,  BINOP},
 148         {"!",   UNOT,   BUNOP},
 149         {"-a",  BAND,   BBINOP},
 150         {"-o",  BOR,    BBINOP},
 151         {"(",   LPAREN, PAREN},
 152         {")",   RPAREN, PAREN},
 153         {0,     0,      0}
 154 };
 155
 156 static char **t_wp;
 157 static struct t_op const *t_wp_op;
 158 static gid_t *group_array = NULL;
 159 static int ngroups;
 160
 161 static enum token t_lex();
 162 static int oexpr();
 163 static int aexpr();
 164 static int nexpr();
 165 static int binop();
 166 static int primary();
 167 static int filstat();
 168 static int getn();
 169 static int newerf();
 170 static int olderf();
 171 static int equalf();
 172 static void syntax();
 173 static int test_eaccess();
 174 static int is_a_group_member();
 175 static void initialize_group_array();
 176
 177 extern int
 178 test_main(int argc, char** argv)
 179 {
 180         int     res;
 181
 182         if (strcmp(applet_name, "[") == 0) {
 183                 if (strcmp(argv[--argc], "]"))
 184                         error_msg_and_die("missing ]");
 185                 argv[argc] = NULL;
 186         }
 187         /* Implement special cases from POSIX.2, section 4.62.4 */
 188         switch (argc) {
 189         case 1:
 190                 exit( 1);
 191         case 2:
 192                 exit (*argv[1] == '\0');
 193         case 3:
 194                 if (argv[1][0] == '!' && argv[1][1] == '\0') {
 195                         exit (!(*argv[2] == '\0'));
 196                 }
 197                 break;
 198         case 4:
 199                 if (argv[1][0] != '!' || argv[1][1] != '\0') {
 200                         if (t_lex(argv[2]),
 201                             t_wp_op && t_wp_op->op_type == BINOP) {
 202                                 t_wp = &argv[1];
 203                                 exit (binop() == 0);
 204                         }
 205                 }
 206                 break;
 207         case 5:
 208                 if (argv[1][0] == '!' && argv[1][1] == '\0') {
 209                         if (t_lex(argv[3]),
 210                             t_wp_op && t_wp_op->op_type == BINOP) {
 211                                 t_wp = &argv[2];
 212                                 exit (!(binop() == 0));
 213                         }
 214                 }
 215                 break;
 216         }
 217
 218         t_wp = &argv[1];
 219         res = !oexpr(t_lex(*t_wp));
 220
 221         if (*t_wp != NULL && *++t_wp != NULL)
 222                 syntax(*t_wp, "unknown operand");
 223
 224         return( res);
 225 }
 226
 227 static void
 228 syntax(op, msg)
 229         char    *op;
 230         char    *msg;
 231 {
 232         if (op && *op)
 233                 error_msg_and_die("%s: %s", op, msg);
 234         else
 235                 error_msg_and_die("%s", msg);
 236 }
 237
 238 static int
 239 oexpr(n)
 240         enum token n;
 241 {
 242         int res;
 243
 244         res = aexpr(n);
 245         if (t_lex(*++t_wp) == BOR)
 246                 return oexpr(t_lex(*++t_wp)) || res;
 247         t_wp--;
 248         return res;
 249 }
 250
 251 static int
 252 aexpr(n)
 253         enum token n;
 254 {
 255         int res;
 256
 257         res = nexpr(n);
 258         if (t_lex(*++t_wp) == BAND)
 259                 return aexpr(t_lex(*++t_wp)) && res;
 260         t_wp--;
 261         return res;
 262 }
 263
 264 static int
 265 nexpr(n)
 266         enum token n;                   /* token */
 267 {
 268         if (n == UNOT)
 269                 return !nexpr(t_lex(*++t_wp));
 270         return primary(n);
 271 }
 272
 273 static int
 274 primary(n)
 275         enum token n;
 276 {
 277         int res;
 278
 279         if (n == EOI)
 280                 syntax(NULL, "argument expected");
 281         if (n == LPAREN) {
 282                 res = oexpr(t_lex(*++t_wp));
 283                 if (t_lex(*++t_wp) != RPAREN)
 284                         syntax(NULL, "closing paren expected");
 285                 return res;
 286         }
 287         if (t_wp_op && t_wp_op->op_type == UNOP) {
 288                 /* unary expression */
 289                 if (*++t_wp == NULL)
 290                         syntax(t_wp_op->op_text, "argument expected");
 291                 switch (n) {
 292                 case STREZ:
 293                         return strlen(*t_wp) == 0;
 294                 case STRNZ:
 295                         return strlen(*t_wp) != 0;
 296                 case FILTT:
 297                         return isatty(getn(*t_wp));
 298                 default:
 299                         return filstat(*t_wp, n);
 300                 }
 301         }
 302
 303         if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) {
 304                 return binop();
 305         }
 306
 307         return strlen(*t_wp) > 0;
 308 }
 309
 310 static int
 311 binop()
 312 {
 313         const char *opnd1, *opnd2;
 314         struct t_op const *op;
 315
 316         opnd1 = *t_wp;
 317         (void) t_lex(*++t_wp);
 318         op = t_wp_op;
 319
 320         if ((opnd2 = *++t_wp) == (char *)0)
 321                 syntax(op->op_text, "argument expected");
 322
 323         switch (op->op_num) {
 324         case STREQ:
 325                 return strcmp(opnd1, opnd2) == 0;
 326         case STRNE:
 327                 return strcmp(opnd1, opnd2) != 0;
 328         case STRLT:
 329                 return strcmp(opnd1, opnd2) < 0;
 330         case STRGT:
 331                 return strcmp(opnd1, opnd2) > 0;
 332         case INTEQ:
 333                 return getn(opnd1) == getn(opnd2);
 334         case INTNE:
 335                 return getn(opnd1) != getn(opnd2);
 336         case INTGE:
 337                 return getn(opnd1) >= getn(opnd2);
 338         case INTGT:
 339                 return getn(opnd1) > getn(opnd2);
 340         case INTLE:
 341                 return getn(opnd1) <= getn(opnd2);
 342         case INTLT:
 343                 return getn(opnd1) < getn(opnd2);
 344         case FILNT:
 345                 return newerf (opnd1, opnd2);
 346         case FILOT:
 347                 return olderf (opnd1, opnd2);
 348         case FILEQ:
 349                 return equalf (opnd1, opnd2);
 350         }
 351         /* NOTREACHED */
 352         return 1;
 353 }
 354
 355 static int
 356 filstat(nm, mode)
 357         char *nm;
 358         enum token mode;
 359 {
 360         struct stat s;
 361         unsigned int i;
 362
 363         if (mode == FILSYM) {
 364 #ifdef S_IFLNK
 365                 if (lstat(nm, &s) == 0) {
 366                         i = S_IFLNK;
 367                         goto filetype;
 368                 }
 369 #endif
 370                 return 0;
 371         }
 372
 373         if (stat(nm, &s) != 0)
 374                 return 0;
 375
 376         switch (mode) {
 377         case FILRD:
 378                 return test_eaccess(nm, R_OK) == 0;
 379         case FILWR:
 380                 return test_eaccess(nm, W_OK) == 0;
 381         case FILEX:
 382                 return test_eaccess(nm, X_OK) == 0;
 383         case FILEXIST:
 384                 return 1;
 385         case FILREG:
 386                 i = S_IFREG;
 387                 goto filetype;
 388         case FILDIR:
 389                 i = S_IFDIR;
 390                 goto filetype;
 391         case FILCDEV:
 392                 i = S_IFCHR;
 393                 goto filetype;
 394         case FILBDEV:
 395                 i = S_IFBLK;
 396                 goto filetype;
 397         case FILFIFO:
 398 #ifdef S_IFIFO
 399                 i = S_IFIFO;
 400                 goto filetype;
 401 #else
 402                 return 0;
 403 #endif
 404         case FILSOCK:
 405 #ifdef S_IFSOCK
 406                 i = S_IFSOCK;
 407                 goto filetype;
 408 #else
 409                 return 0;
 410 #endif
 411         case FILSUID:
 412                 i = S_ISUID;
 413                 goto filebit;
 414         case FILSGID:
 415                 i = S_ISGID;
 416                 goto filebit;
 417         case FILSTCK:
 418                 i = S_ISVTX;
 419                 goto filebit;
 420         case FILGZ:
 421                 return s.st_size > 0L;
 422         case FILUID:
 423                 return s.st_uid == geteuid();
 424         case FILGID:
 425                 return s.st_gid == getegid();
 426         default:
 427                 return 1;
 428         }
 429
 430 filetype:
 431         return ((s.st_mode & S_IFMT) == i);
 432
 433 filebit:
 434         return ((s.st_mode & i) != 0);
 435 }
 436
 437 static enum token
 438 t_lex(s)
 439         char *s;
 440 {
 441         struct t_op const *op = ops;
 442
 443         if (s == 0) {
 444                 t_wp_op = (struct t_op *)0;
 445                 return EOI;
 446         }
 447         while (op->op_text) {
 448                 if (strcmp(s, op->op_text) == 0) {
 449                         t_wp_op = op;
 450                         return op->op_num;
 451                 }
 452                 op++;
 453         }
 454         t_wp_op = (struct t_op *)0;
 455         return OPERAND;
 456 }
 457
 458 /* atoi with error detection */
 459 static int
 460 getn(s)
 461         char *s;
 462 {
 463         char *p;
 464         long r;
 465
 466         errno = 0;
 467         r = strtol(s, &p, 10);
 468
 469         if (errno != 0)
 470           error_msg_and_die("%s: out of range", s);
 471
 472         while (isspace(*p))
 473           p++;
 474
 475         if (*p)
 476           error_msg_and_die("%s: bad number", s);
 477
 478         return (int) r;
 479 }
 480
 481 static int
 482 newerf (f1, f2)
 483 char *f1, *f2;
 484 {
 485         struct stat b1, b2;
 486
 487         return (stat (f1, &b1) == 0 &&
 488                 stat (f2, &b2) == 0 &&
 489                 b1.st_mtime > b2.st_mtime);
 490 }
 491
 492 static int
 493 olderf (f1, f2)
 494 char *f1, *f2;
 495 {
 496         struct stat b1, b2;
 497
 498         return (stat (f1, &b1) == 0 &&
 499                 stat (f2, &b2) == 0 &&
 500                 b1.st_mtime < b2.st_mtime);
 501 }
 502
 503 static int
 504 equalf (f1, f2)
 505 char *f1, *f2;
 506 {
 507         struct stat b1, b2;
 508
 509         return (stat (f1, &b1) == 0 &&
 510                 stat (f2, &b2) == 0 &&
 511                 b1.st_dev == b2.st_dev &&
 512                 b1.st_ino == b2.st_ino);
 513 }
 514
 515 /* Do the same thing access(2) does, but use the effective uid and gid,
 516    and don't make the mistake of telling root that any file is
 517    executable. */
 518 static int
 519 test_eaccess (path, mode)
 520 char *path;
 521 int mode;
 522 {
 523         struct stat st;
 524         unsigned int euid = geteuid();
 525
 526         if (stat (path, &st) < 0)
 527                 return (-1);
 528
 529         if (euid == 0) {
 530                 /* Root can read or write any file. */
 531                 if (mode != X_OK)
 532                 return (0);
 533
 534                 /* Root can execute any file that has any one of the execute
 535                    bits set. */
 536                 if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
 537                         return (0);
 538         }
 539
 540         if (st.st_uid == euid)          /* owner */
 541                 mode <<= 6;
 542         else if (is_a_group_member (st.st_gid))
 543                 mode <<= 3;
 544
 545         if (st.st_mode & mode)
 546                 return (0);
 547
 548         return (-1);
 549 }
 550
 551 static void
 552 initialize_group_array ()
 553 {
 554         ngroups = getgroups(0, NULL);
 555         group_array = xrealloc(group_array, ngroups * sizeof(gid_t));
 556         getgroups(ngroups, group_array);
 557 }
 558
 559 /* Return non-zero if GID is one that we have in our groups list. */
 560 static int
 561 is_a_group_member (gid)
 562 gid_t gid;
 563 {
 564         register int i;
 565
 566         /* Short-circuit if possible, maybe saving a call to getgroups(). */
 567         if (gid == getgid() || gid == getegid())
 568                 return (1);
 569
 570         if (ngroups == 0)
 571                 initialize_group_array ();
 572
 573         /* Search through the list looking for GID. */
 574         for (i = 0; i < ngroups; i++)
 575                 if (gid == group_array[i])
 576                         return (1);
 577
 578         return (0);
 579 }