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