1 /* $NetBSD: test.c,v 1.23 2001/07/30 10:17:41 wiz 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 #include <sys/cdefs.h> 14 #ifndef lint 15 __RCSID("$NetBSD: test.c,v 1.23 2001/07/30 10:17:41 wiz Exp $"); 16 #endif 17 18 #include <sys/stat.h> 19 #include <sys/types.h> 20 21 #include <ctype.h> 22 #include <err.h> 23 #include <errno.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <unistd.h> 28 #ifdef __STDC__ 29 #include <stdarg.h> 30 #else 31 #include <varargs.h> 32 #endif 33 34 /* test(1) accepts the following grammar: 35 oexpr ::= aexpr | aexpr "-o" oexpr ; 36 aexpr ::= nexpr | nexpr "-a" aexpr ; 37 nexpr ::= primary | "!" primary 38 primary ::= unary-operator operand 39 | operand binary-operator operand 40 | operand 41 | "(" oexpr ")" 42 ; 43 unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"| 44 "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S"; 45 46 binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| 47 "-nt"|"-ot"|"-ef"; 48 operand ::= <any legal UNIX file name> 49 */ 50 51 enum token { 52 EOI, 53 FILRD, 54 FILWR, 55 FILEX, 56 FILEXIST, 57 FILREG, 58 FILDIR, 59 FILCDEV, 60 FILBDEV, 61 FILFIFO, 62 FILSOCK, 63 FILSYM, 64 FILGZ, 65 FILTT, 66 FILSUID, 67 FILSGID, 68 FILSTCK, 69 FILNT, 70 FILOT, 71 FILEQ, 72 FILUID, 73 FILGID, 74 STREZ, 75 STRNZ, 76 STREQ, 77 STRNE, 78 STRLT, 79 STRGT, 80 INTEQ, 81 INTNE, 82 INTGE, 83 INTGT, 84 INTLE, 85 INTLT, 86 UNOT, 87 BAND, 88 BOR, 89 LPAREN, 90 RPAREN, 91 OPERAND 92 }; 93 94 enum token_types { 95 UNOP, 96 BINOP, 97 BUNOP, 98 BBINOP, 99 PAREN 100 }; 101 102 static struct t_op { 103 const char *op_text; 104 short op_num, op_type; 105 } const ops [] = { 106 {"-r", FILRD, UNOP}, 107 {"-w", FILWR, UNOP}, 108 {"-x", FILEX, UNOP}, 109 {"-e", FILEXIST,UNOP}, 110 {"-f", FILREG, UNOP}, 111 {"-d", FILDIR, UNOP}, 112 {"-c", FILCDEV,UNOP}, 113 {"-b", FILBDEV,UNOP}, 114 {"-p", FILFIFO,UNOP}, 115 {"-u", FILSUID,UNOP}, 116 {"-g", FILSGID,UNOP}, 117 {"-k", FILSTCK,UNOP}, 118 {"-s", FILGZ, UNOP}, 119 {"-t", FILTT, UNOP}, 120 {"-z", STREZ, UNOP}, 121 {"-n", STRNZ, UNOP}, 122 {"-h", FILSYM, UNOP}, /* for backwards compat */ 123 {"-O", FILUID, UNOP}, 124 {"-G", FILGID, UNOP}, 125 {"-L", FILSYM, UNOP}, 126 {"-S", FILSOCK,UNOP}, 127 {"=", STREQ, BINOP}, 128 {"!=", STRNE, BINOP}, 129 {"<", STRLT, BINOP}, 130 {">", STRGT, BINOP}, 131 {"-eq", INTEQ, BINOP}, 132 {"-ne", INTNE, BINOP}, 133 {"-ge", INTGE, BINOP}, 134 {"-gt", INTGT, BINOP}, 135 {"-le", INTLE, BINOP}, 136 {"-lt", INTLT, BINOP}, 137 {"-nt", FILNT, BINOP}, 138 {"-ot", FILOT, BINOP}, 139 {"-ef", FILEQ, BINOP}, 140 {"!", UNOT, BUNOP}, 141 {"-a", BAND, BBINOP}, 142 {"-o", BOR, BBINOP}, 143 {"(", LPAREN, PAREN}, 144 {")", RPAREN, PAREN}, 145 {0, 0, 0} 146 }; 147 148 static char **t_wp; 149 static struct t_op const *t_wp_op; 150 151 static void syntax(const char *, const char *); 152 static int oexpr(enum token); 153 static int aexpr(enum token); 154 static int nexpr(enum token); 155 static int primary(enum token); 156 static int binop(void); 157 static int filstat(char *, enum token); 158 static enum token t_lex(char *); 159 static int isoperand(void); 160 static int getn(const char *); 161 static int newerf(const char *, const char *); 162 static int olderf(const char *, const char *); 163 static int equalf(const char *, const char *); 164 165 #if defined(SHELL) 166 extern void error(const char *, ...) __attribute__((__noreturn__)); 167 #else 168 static void error(const char *, ...) __attribute__((__noreturn__)); 169 170 static void 171 #ifdef __STDC__ 172 error(const char *msg, ...) 173 #else 174 error(va_alist) 175 va_dcl 176 #endif 177 { 178 va_list ap; 179 #ifndef __STDC__ 180 const char *msg; 181 182 va_start(ap); 183 msg = va_arg(ap, const char *); 184 #else 185 va_start(ap, msg); 186 #endif 187 verrx(2, msg, ap); 188 /*NOTREACHED*/ 189 va_end(ap); 190 } 191 #endif 192 193 #ifdef SHELL 194 int testcmd(int, char **); 195 196 int 197 testcmd(int argc, char **argv) 198 #else 199 int main(int, char **); 200 201 int 202 main(int argc, char **argv) 203 #endif 204 { 205 int res; 206 207 208 if (strcmp(argv[0], "[") == 0) { 209 if (strcmp(argv[--argc], "]")) 210 error("missing ]"); 211 argv[argc] = NULL; 212 } 213 214 if (argc < 2) 215 return 1; 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, "unexpected operator"); 222 223 return res; 224 } 225 226 static void 227 syntax(const char *op, const char *msg) 228 { 229 if (op && *op) 230 error("%s: %s", op, msg); 231 else 232 error("%s", msg); 233 } 234 235 static int 236 oexpr(enum token n) 237 { 238 int res; 239 240 res = aexpr(n); 241 if (t_lex(*++t_wp) == BOR) 242 return oexpr(t_lex(*++t_wp)) || res; 243 t_wp--; 244 return res; 245 } 246 247 static int 248 aexpr(enum token n) 249 { 250 int res; 251 252 res = nexpr(n); 253 if (t_lex(*++t_wp) == BAND) 254 return aexpr(t_lex(*++t_wp)) && res; 255 t_wp--; 256 return res; 257 } 258 259 static int 260 nexpr(enum token n) 261 { 262 if (n == UNOT) 263 return !nexpr(t_lex(*++t_wp)); 264 return primary(n); 265 } 266 267 static int 268 primary(enum token n) 269 { 270 enum token nn; 271 int res; 272 273 if (n == EOI) 274 return 0; /* missing expression */ 275 if (n == LPAREN) { 276 if ((nn = t_lex(*++t_wp)) == RPAREN) 277 return 0; /* missing expression */ 278 res = oexpr(nn); 279 if (t_lex(*++t_wp) != RPAREN) 280 syntax(NULL, "closing paren expected"); 281 return res; 282 } 283 if (t_wp_op && t_wp_op->op_type == UNOP) { 284 /* unary expression */ 285 if (*++t_wp == NULL) 286 syntax(t_wp_op->op_text, "argument expected"); 287 switch (n) { 288 case STREZ: 289 return strlen(*t_wp) == 0; 290 case STRNZ: 291 return strlen(*t_wp) != 0; 292 case FILTT: 293 return isatty(getn(*t_wp)); 294 default: 295 return filstat(*t_wp, n); 296 } 297 } 298 299 if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) { 300 return binop(); 301 } 302 303 return strlen(*t_wp) > 0; 304 } 305 306 static int 307 binop(void) 308 { 309 const char *opnd1, *opnd2; 310 struct t_op const *op; 311 312 opnd1 = *t_wp; 313 (void) t_lex(*++t_wp); 314 op = t_wp_op; 315 316 if ((opnd2 = *++t_wp) == (char *)0) 317 syntax(op->op_text, "argument expected"); 318 319 switch (op->op_num) { 320 case STREQ: 321 return strcmp(opnd1, opnd2) == 0; 322 case STRNE: 323 return strcmp(opnd1, opnd2) != 0; 324 case STRLT: 325 return strcmp(opnd1, opnd2) < 0; 326 case STRGT: 327 return strcmp(opnd1, opnd2) > 0; 328 case INTEQ: 329 return getn(opnd1) == getn(opnd2); 330 case INTNE: 331 return getn(opnd1) != getn(opnd2); 332 case INTGE: 333 return getn(opnd1) >= getn(opnd2); 334 case INTGT: 335 return getn(opnd1) > getn(opnd2); 336 case INTLE: 337 return getn(opnd1) <= getn(opnd2); 338 case INTLT: 339 return getn(opnd1) < getn(opnd2); 340 case FILNT: 341 return newerf (opnd1, opnd2); 342 case FILOT: 343 return olderf (opnd1, opnd2); 344 case FILEQ: 345 return equalf (opnd1, opnd2); 346 default: 347 abort(); 348 /* NOTREACHED */ 349 } 350 } 351 352 static int 353 filstat(char *nm, enum token mode) 354 { 355 struct stat s; 356 357 if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s)) 358 return 0; 359 360 switch (mode) { 361 case FILRD: 362 return access(nm, R_OK) == 0; 363 case FILWR: 364 return access(nm, W_OK) == 0; 365 case FILEX: 366 return access(nm, X_OK) == 0; 367 case FILEXIST: 368 return access(nm, F_OK) == 0; 369 case FILREG: 370 return S_ISREG(s.st_mode); 371 case FILDIR: 372 return S_ISDIR(s.st_mode); 373 case FILCDEV: 374 return S_ISCHR(s.st_mode); 375 case FILBDEV: 376 return S_ISBLK(s.st_mode); 377 case FILFIFO: 378 return S_ISFIFO(s.st_mode); 379 case FILSOCK: 380 return S_ISSOCK(s.st_mode); 381 case FILSYM: 382 return S_ISLNK(s.st_mode); 383 case FILSUID: 384 return (s.st_mode & S_ISUID) != 0; 385 case FILSGID: 386 return (s.st_mode & S_ISGID) != 0; 387 case FILSTCK: 388 return (s.st_mode & S_ISVTX) != 0; 389 case FILGZ: 390 return s.st_size > (off_t)0; 391 case FILUID: 392 return s.st_uid == geteuid(); 393 case FILGID: 394 return s.st_gid == getegid(); 395 default: 396 return 1; 397 } 398 } 399 400 static enum token 401 t_lex(char *s) 402 { 403 struct t_op const *op = ops; 404 405 if (s == 0) { 406 t_wp_op = (struct t_op *)0; 407 return EOI; 408 } 409 while (op->op_text) { 410 if (strcmp(s, op->op_text) == 0) { 411 if ((op->op_type == UNOP && isoperand()) || 412 (op->op_num == LPAREN && *(t_wp+1) == 0)) 413 break; 414 t_wp_op = op; 415 return op->op_num; 416 } 417 op++; 418 } 419 t_wp_op = (struct t_op *)0; 420 return OPERAND; 421 } 422 423 static int 424 isoperand(void) 425 { 426 struct t_op const *op = ops; 427 char *s; 428 char *t; 429 430 if ((s = *(t_wp+1)) == 0) 431 return 1; 432 if ((t = *(t_wp+2)) == 0) 433 return 0; 434 while (op->op_text) { 435 if (strcmp(s, op->op_text) == 0) 436 return op->op_type == BINOP && 437 (t[0] != ')' || t[1] != '\0'); 438 op++; 439 } 440 return 0; 441 } 442 443 /* atoi with error detection */ 444 static int 445 getn(const char *s) 446 { 447 char *p; 448 long r; 449 450 errno = 0; 451 r = strtol(s, &p, 10); 452 453 if (errno != 0) 454 error("%s: out of range", s); 455 456 while (isspace((unsigned char)*p)) 457 p++; 458 459 if (*p) 460 error("%s: bad number", s); 461 462 return (int) r; 463 } 464 465 static int 466 newerf (const char *f1, const char *f2) 467 { 468 struct stat b1, b2; 469 470 return (stat (f1, &b1) == 0 && 471 stat (f2, &b2) == 0 && 472 b1.st_mtime > b2.st_mtime); 473 } 474 475 static int 476 olderf (const char *f1, const char *f2) 477 { 478 struct stat b1, b2; 479 480 return (stat (f1, &b1) == 0 && 481 stat (f2, &b2) == 0 && 482 b1.st_mtime < b2.st_mtime); 483 } 484 485 static int 486 equalf (const char *f1, const char *f2) 487 { 488 struct stat b1, b2; 489 490 return (stat (f1, &b1) == 0 && 491 stat (f2, &b2) == 0 && 492 b1.st_dev == b2.st_dev && 493 b1.st_ino == b2.st_ino); 494 } 495