1 /* $NetBSD: test.c,v 1.21 1999/04/05 09:48:38 kleink Exp $ */ 2 3 /*- 4 * test(1); version 7-like -- author Erik Baalbergen 5 * modified by Eric Gisin to be used as built-in. 6 * modified by Arnold Robbins to add SVR3 compatibility 7 * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket). 8 * modified by J.T. Conklin for NetBSD. 9 * 10 * This program is in the Public Domain. 11 */ 12 /* 13 * Important: This file is used both as a standalone program /bin/test and 14 * as a builtin for /bin/sh (#define SHELL). 15 */ 16 17 #include <sys/cdefs.h> 18 __FBSDID("$FreeBSD$"); 19 20 #include <sys/types.h> 21 #include <sys/stat.h> 22 23 #include <ctype.h> 24 #include <err.h> 25 #include <errno.h> 26 #include <inttypes.h> 27 #include <limits.h> 28 #include <stdarg.h> 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include <unistd.h> 33 34 #ifdef SHELL 35 #define main testcmd 36 #include "bltin/bltin.h" 37 #else 38 #include <locale.h> 39 40 static void error(const char *, ...) __dead2 __printf0like(1, 2); 41 42 static void 43 error(const char *msg, ...) 44 { 45 va_list ap; 46 va_start(ap, msg); 47 verrx(2, msg, ap); 48 /*NOTREACHED*/ 49 va_end(ap); 50 } 51 #endif 52 53 /* test(1) accepts the following grammar: 54 oexpr ::= aexpr | aexpr "-o" oexpr ; 55 aexpr ::= nexpr | nexpr "-a" aexpr ; 56 nexpr ::= primary | "!" primary 57 primary ::= unary-operator operand 58 | operand binary-operator operand 59 | operand 60 | "(" oexpr ")" 61 ; 62 unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"| 63 "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S"; 64 65 binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| 66 "-nt"|"-ot"|"-ef"; 67 operand ::= <any legal UNIX file name> 68 */ 69 70 enum token_types { 71 UNOP = 0x100, 72 BINOP = 0x200, 73 BUNOP = 0x300, 74 BBINOP = 0x400, 75 PAREN = 0x500 76 }; 77 78 enum token { 79 EOI, 80 OPERAND, 81 FILRD = UNOP + 1, 82 FILWR, 83 FILEX, 84 FILEXIST, 85 FILREG, 86 FILDIR, 87 FILCDEV, 88 FILBDEV, 89 FILFIFO, 90 FILSOCK, 91 FILSYM, 92 FILGZ, 93 FILTT, 94 FILSUID, 95 FILSGID, 96 FILSTCK, 97 STREZ, 98 STRNZ, 99 FILUID, 100 FILGID, 101 FILNT = BINOP + 1, 102 FILOT, 103 FILEQ, 104 STREQ, 105 STRNE, 106 STRLT, 107 STRGT, 108 INTEQ, 109 INTNE, 110 INTGE, 111 INTGT, 112 INTLE, 113 INTLT, 114 UNOT = BUNOP + 1, 115 BAND = BBINOP + 1, 116 BOR, 117 LPAREN = PAREN + 1, 118 RPAREN 119 }; 120 121 #define TOKEN_TYPE(token) ((token) & 0xff00) 122 123 static const struct t_op { 124 char op_text[2]; 125 short op_num; 126 } ops1[] = { 127 {"=", STREQ}, 128 {"<", STRLT}, 129 {">", STRGT}, 130 {"!", UNOT}, 131 {"(", LPAREN}, 132 {")", RPAREN}, 133 }, opsm1[] = { 134 {"r", FILRD}, 135 {"w", FILWR}, 136 {"x", FILEX}, 137 {"e", FILEXIST}, 138 {"f", FILREG}, 139 {"d", FILDIR}, 140 {"c", FILCDEV}, 141 {"b", FILBDEV}, 142 {"p", FILFIFO}, 143 {"u", FILSUID}, 144 {"g", FILSGID}, 145 {"k", FILSTCK}, 146 {"s", FILGZ}, 147 {"t", FILTT}, 148 {"z", STREZ}, 149 {"n", STRNZ}, 150 {"h", FILSYM}, /* for backwards compat */ 151 {"O", FILUID}, 152 {"G", FILGID}, 153 {"L", FILSYM}, 154 {"S", FILSOCK}, 155 {"a", BAND}, 156 {"o", BOR}, 157 }, ops2[] = { 158 {"==", STREQ}, 159 {"!=", STRNE}, 160 }, opsm2[] = { 161 {"eq", INTEQ}, 162 {"ne", INTNE}, 163 {"ge", INTGE}, 164 {"gt", INTGT}, 165 {"le", INTLE}, 166 {"lt", INTLT}, 167 {"nt", FILNT}, 168 {"ot", FILOT}, 169 {"ef", FILEQ}, 170 }; 171 172 static int nargc; 173 static char **t_wp; 174 static int parenlevel; 175 176 static int aexpr(enum token); 177 static int binop(enum token); 178 static int equalf(const char *, const char *); 179 static int filstat(char *, enum token); 180 static int getn(const char *); 181 static intmax_t getq(const char *); 182 static int intcmp(const char *, const char *); 183 static int isunopoperand(void); 184 static int islparenoperand(void); 185 static int isrparenoperand(void); 186 static int newerf(const char *, const char *); 187 static int nexpr(enum token); 188 static int oexpr(enum token); 189 static int olderf(const char *, const char *); 190 static int primary(enum token); 191 static void syntax(const char *, const char *); 192 static enum token t_lex(char *); 193 194 int 195 main(int argc, char **argv) 196 { 197 int res; 198 char *p; 199 200 if ((p = strrchr(argv[0], '/')) == NULL) 201 p = argv[0]; 202 else 203 p++; 204 if (strcmp(p, "[") == 0) { 205 if (strcmp(argv[--argc], "]") != 0) 206 error("missing ]"); 207 argv[argc] = NULL; 208 } 209 210 /* no expression => false */ 211 if (--argc <= 0) 212 return 1; 213 214 #ifndef SHELL 215 (void)setlocale(LC_CTYPE, ""); 216 #endif 217 nargc = argc; 218 t_wp = &argv[1]; 219 parenlevel = 0; 220 if (nargc == 4 && strcmp(*t_wp, "!") == 0) { 221 /* Things like ! "" -o x do not fit in the normal grammar. */ 222 --nargc; 223 ++t_wp; 224 res = oexpr(t_lex(*t_wp)); 225 } else 226 res = !oexpr(t_lex(*t_wp)); 227 228 if (--nargc > 0) 229 syntax(*t_wp, "unexpected operator"); 230 231 return res; 232 } 233 234 static void 235 syntax(const char *op, const char *msg) 236 { 237 238 if (op && *op) 239 error("%s: %s", op, msg); 240 else 241 error("%s", msg); 242 } 243 244 static int 245 oexpr(enum token n) 246 { 247 int res; 248 249 res = aexpr(n); 250 if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BOR) 251 return oexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) || 252 res; 253 t_wp--; 254 nargc++; 255 return res; 256 } 257 258 static int 259 aexpr(enum token n) 260 { 261 int res; 262 263 res = nexpr(n); 264 if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BAND) 265 return aexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) && 266 res; 267 t_wp--; 268 nargc++; 269 return res; 270 } 271 272 static int 273 nexpr(enum token n) 274 { 275 if (n == UNOT) 276 return !nexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)); 277 return primary(n); 278 } 279 280 static int 281 primary(enum token n) 282 { 283 enum token nn; 284 int res; 285 286 if (n == EOI) 287 return 0; /* missing expression */ 288 if (n == LPAREN) { 289 parenlevel++; 290 if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) == 291 RPAREN) { 292 parenlevel--; 293 return 0; /* missing expression */ 294 } 295 res = oexpr(nn); 296 if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN) 297 syntax(NULL, "closing paren expected"); 298 parenlevel--; 299 return res; 300 } 301 if (TOKEN_TYPE(n) == UNOP) { 302 /* unary expression */ 303 if (--nargc == 0) 304 syntax(NULL, "argument expected"); /* impossible */ 305 switch (n) { 306 case STREZ: 307 return strlen(*++t_wp) == 0; 308 case STRNZ: 309 return strlen(*++t_wp) != 0; 310 case FILTT: 311 return isatty(getn(*++t_wp)); 312 default: 313 return filstat(*++t_wp, n); 314 } 315 } 316 317 nn = t_lex(nargc > 0 ? t_wp[1] : NULL); 318 if (TOKEN_TYPE(nn) == BINOP) 319 return binop(nn); 320 321 return strlen(*t_wp) > 0; 322 } 323 324 static int 325 binop(enum token n) 326 { 327 const char *opnd1, *op, *opnd2; 328 329 opnd1 = *t_wp; 330 op = nargc > 0 ? (--nargc, *++t_wp) : NULL; 331 332 if ((opnd2 = nargc > 0 ? (--nargc, *++t_wp) : NULL) == NULL) 333 syntax(op, "argument expected"); 334 335 switch (n) { 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 intcmp(opnd1, opnd2) == 0; 346 case INTNE: 347 return intcmp(opnd1, opnd2) != 0; 348 case INTGE: 349 return intcmp(opnd1, opnd2) >= 0; 350 case INTGT: 351 return intcmp(opnd1, opnd2) > 0; 352 case INTLE: 353 return intcmp(opnd1, opnd2) <= 0; 354 case INTLT: 355 return intcmp(opnd1, opnd2) < 0; 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 default: 363 abort(); 364 /* NOTREACHED */ 365 } 366 } 367 368 static int 369 filstat(char *nm, enum token mode) 370 { 371 struct stat s; 372 373 if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s)) 374 return 0; 375 376 switch (mode) { 377 case FILRD: 378 return (eaccess(nm, R_OK) == 0); 379 case FILWR: 380 return (eaccess(nm, W_OK) == 0); 381 case FILEX: 382 /* XXX work around eaccess(2) false positives for superuser */ 383 if (eaccess(nm, X_OK) != 0) 384 return 0; 385 if (S_ISDIR(s.st_mode) || geteuid() != 0) 386 return 1; 387 return (s.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0; 388 case FILEXIST: 389 return (eaccess(nm, F_OK) == 0); 390 case FILREG: 391 return S_ISREG(s.st_mode); 392 case FILDIR: 393 return S_ISDIR(s.st_mode); 394 case FILCDEV: 395 return S_ISCHR(s.st_mode); 396 case FILBDEV: 397 return S_ISBLK(s.st_mode); 398 case FILFIFO: 399 return S_ISFIFO(s.st_mode); 400 case FILSOCK: 401 return S_ISSOCK(s.st_mode); 402 case FILSYM: 403 return S_ISLNK(s.st_mode); 404 case FILSUID: 405 return (s.st_mode & S_ISUID) != 0; 406 case FILSGID: 407 return (s.st_mode & S_ISGID) != 0; 408 case FILSTCK: 409 return (s.st_mode & S_ISVTX) != 0; 410 case FILGZ: 411 return s.st_size > (off_t)0; 412 case FILUID: 413 return s.st_uid == geteuid(); 414 case FILGID: 415 return s.st_gid == getegid(); 416 default: 417 return 1; 418 } 419 } 420 421 static int 422 find_op_1char(const struct t_op *op, const struct t_op *end, const char *s) 423 { 424 char c; 425 426 c = s[0]; 427 while (op != end) { 428 if (c == *op->op_text) 429 return op->op_num; 430 op++; 431 } 432 return OPERAND; 433 } 434 435 static int 436 find_op_2char(const struct t_op *op, const struct t_op *end, const char *s) 437 { 438 while (op != end) { 439 if (s[0] == op->op_text[0] && s[1] == op->op_text[1]) 440 return op->op_num; 441 op++; 442 } 443 return OPERAND; 444 } 445 446 static int 447 find_op(const char *s) 448 { 449 if (s[0] == '\0') 450 return OPERAND; 451 else if (s[1] == '\0') 452 return find_op_1char(ops1, (&ops1)[1], s); 453 else if (s[2] == '\0') 454 return s[0] == '-' ? find_op_1char(opsm1, (&opsm1)[1], s + 1) : 455 find_op_2char(ops2, (&ops2)[1], s); 456 else if (s[3] == '\0') 457 return s[0] == '-' ? find_op_2char(opsm2, (&opsm2)[1], s + 1) : 458 OPERAND; 459 else 460 return OPERAND; 461 } 462 463 static enum token 464 t_lex(char *s) 465 { 466 int num; 467 468 if (s == NULL) { 469 return EOI; 470 } 471 num = find_op(s); 472 if (((TOKEN_TYPE(num) == UNOP || TOKEN_TYPE(num) == BUNOP) 473 && isunopoperand()) || 474 (num == LPAREN && islparenoperand()) || 475 (num == RPAREN && isrparenoperand())) 476 return OPERAND; 477 return num; 478 } 479 480 static int 481 isunopoperand(void) 482 { 483 char *s; 484 char *t; 485 int num; 486 487 if (nargc == 1) 488 return 1; 489 s = *(t_wp + 1); 490 if (nargc == 2) 491 return parenlevel == 1 && strcmp(s, ")") == 0; 492 t = *(t_wp + 2); 493 num = find_op(s); 494 return TOKEN_TYPE(num) == BINOP && 495 (parenlevel == 0 || t[0] != ')' || t[1] != '\0'); 496 } 497 498 static int 499 islparenoperand(void) 500 { 501 char *s; 502 int num; 503 504 if (nargc == 1) 505 return 1; 506 s = *(t_wp + 1); 507 if (nargc == 2) 508 return parenlevel == 1 && strcmp(s, ")") == 0; 509 if (nargc != 3) 510 return 0; 511 num = find_op(s); 512 return TOKEN_TYPE(num) == BINOP; 513 } 514 515 static int 516 isrparenoperand(void) 517 { 518 char *s; 519 520 if (nargc == 1) 521 return 0; 522 s = *(t_wp + 1); 523 if (nargc == 2) 524 return parenlevel == 1 && strcmp(s, ")") == 0; 525 return 0; 526 } 527 528 /* atoi with error detection */ 529 static int 530 getn(const char *s) 531 { 532 char *p; 533 long r; 534 535 errno = 0; 536 r = strtol(s, &p, 10); 537 538 if (s == p) 539 error("%s: bad number", s); 540 541 if (errno != 0) 542 error((errno == EINVAL) ? "%s: bad number" : 543 "%s: out of range", s); 544 545 while (isspace((unsigned char)*p)) 546 p++; 547 548 if (*p) 549 error("%s: bad number", s); 550 551 return (int) r; 552 } 553 554 /* atoi with error detection and 64 bit range */ 555 static intmax_t 556 getq(const char *s) 557 { 558 char *p; 559 intmax_t r; 560 561 errno = 0; 562 r = strtoimax(s, &p, 10); 563 564 if (s == p) 565 error("%s: bad number", s); 566 567 if (errno != 0) 568 error((errno == EINVAL) ? "%s: bad number" : 569 "%s: out of range", s); 570 571 while (isspace((unsigned char)*p)) 572 p++; 573 574 if (*p) 575 error("%s: bad number", s); 576 577 return r; 578 } 579 580 static int 581 intcmp (const char *s1, const char *s2) 582 { 583 intmax_t q1, q2; 584 585 586 q1 = getq(s1); 587 q2 = getq(s2); 588 589 if (q1 > q2) 590 return 1; 591 592 if (q1 < q2) 593 return -1; 594 595 return 0; 596 } 597 598 static int 599 newerf (const char *f1, const char *f2) 600 { 601 struct stat b1, b2; 602 603 if (stat(f1, &b1) != 0 || stat(f2, &b2) != 0) 604 return 0; 605 606 if (b1.st_mtim.tv_sec > b2.st_mtim.tv_sec) 607 return 1; 608 if (b1.st_mtim.tv_sec < b2.st_mtim.tv_sec) 609 return 0; 610 611 return (b1.st_mtim.tv_nsec > b2.st_mtim.tv_nsec); 612 } 613 614 static int 615 olderf (const char *f1, const char *f2) 616 { 617 return (newerf(f2, f1)); 618 } 619 620 static int 621 equalf (const char *f1, const char *f2) 622 { 623 struct stat b1, b2; 624 625 return (stat (f1, &b1) == 0 && 626 stat (f2, &b2) == 0 && 627 b1.st_dev == b2.st_dev && 628 b1.st_ino == b2.st_ino); 629 } 630