c_test.c revision 1.1.1.2
1 /* 2 * test(1); version 7-like -- author Erik Baalbergen 3 * modified by Eric Gisin to be used as built-in. 4 * modified by Arnold Robbins to add SVR3 compatibility 5 * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket). 6 * modified by Michael Rendell to add Korn's [[ .. ]] expressions. 7 * modified by J.T. Conklin to add POSIX compatibility. 8 */ 9 10 #include "sh.h" 11 #include "ksh_stat.h" 12 #include "c_test.h" 13 14 /* test(1) accepts the following grammar: 15 oexpr ::= aexpr | aexpr "-o" oexpr ; 16 aexpr ::= nexpr | nexpr "-a" aexpr ; 17 nexpr ::= primary | "!" nexpr ; 18 primary ::= unary-operator operand 19 | operand binary-operator operand 20 | operand 21 | "(" oexpr ")" 22 ; 23 24 unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"| 25 "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"| 26 "-L"|"-h"|"-S"|"-H"; 27 28 binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| 29 "-nt"|"-ot"|"-ef"| 30 "<"|">" # rules used for [[ .. ]] expressions 31 ; 32 operand ::= <any thing> 33 */ 34 35 #define T_ERR_EXIT 2 /* POSIX says > 1 for errors */ 36 37 struct t_op { 38 char op_text[4]; 39 Test_op op_num; 40 }; 41 static const struct t_op u_ops [] = { 42 {"-a", TO_FILAXST }, 43 {"-b", TO_FILBDEV }, 44 {"-c", TO_FILCDEV }, 45 {"-d", TO_FILID }, 46 {"-e", TO_FILEXST }, 47 {"-f", TO_FILREG }, 48 {"-G", TO_FILGID }, 49 {"-g", TO_FILSETG }, 50 {"-h", TO_FILSYM }, 51 {"-H", TO_FILCDF }, 52 {"-k", TO_FILSTCK }, 53 {"-L", TO_FILSYM }, 54 {"-n", TO_STNZE }, 55 {"-O", TO_FILUID }, 56 {"-o", TO_OPTION }, 57 {"-p", TO_FILFIFO }, 58 {"-r", TO_FILRD }, 59 {"-s", TO_FILGZ }, 60 {"-S", TO_FILSOCK }, 61 {"-t", TO_FILTT }, 62 {"-u", TO_FILSETU }, 63 {"-w", TO_FILWR }, 64 {"-x", TO_FILEX }, 65 {"-z", TO_STZER }, 66 {"", TO_NONOP } 67 }; 68 static const struct t_op b_ops [] = { 69 {"=", TO_STEQL }, 70 #ifdef KSH 71 {"==", TO_STEQL }, 72 #endif /* KSH */ 73 {"!=", TO_STNEQ }, 74 {"<", TO_STLT }, 75 {">", TO_STGT }, 76 {"-eq", TO_INTEQ }, 77 {"-ne", TO_INTNE }, 78 {"-gt", TO_INTGT }, 79 {"-ge", TO_INTGE }, 80 {"-lt", TO_INTLT }, 81 {"-le", TO_INTLE }, 82 {"-ef", TO_FILEQ }, 83 {"-nt", TO_FILNT }, 84 {"-ot", TO_FILOT }, 85 {"", TO_NONOP } 86 }; 87 88 static int test_stat ARGS((const char *path, struct stat *statb)); 89 static int test_eaccess ARGS((const char *path, int mode)); 90 static int test_oexpr ARGS((Test_env *te, int do_eval)); 91 static int test_aexpr ARGS((Test_env *te, int do_eval)); 92 static int test_nexpr ARGS((Test_env *te, int do_eval)); 93 static int test_primary ARGS((Test_env *te, int do_eval)); 94 static int ptest_isa ARGS((Test_env *te, Test_meta meta)); 95 static const char *ptest_getopnd ARGS((Test_env *te, Test_op op, int do_eval)); 96 static int ptest_eval ARGS((Test_env *te, Test_op op, const char *opnd1, 97 const char *opnd2, int do_eval)); 98 static void ptest_error ARGS((Test_env *te, int offset, const char *msg)); 99 100 int 101 c_test(wp) 102 char **wp; 103 { 104 int argc; 105 int res; 106 Test_env te; 107 108 te.flags = 0; 109 te.isa = ptest_isa; 110 te.getopnd = ptest_getopnd; 111 te.eval = ptest_eval; 112 te.error = ptest_error; 113 114 for (argc = 0; wp[argc]; argc++) 115 ; 116 117 if (strcmp(wp[0], "[") == 0) { 118 if (strcmp(wp[--argc], "]") != 0) { 119 bi_errorf("missing ]"); 120 return T_ERR_EXIT; 121 } 122 } 123 124 te.pos.wp = wp + 1; 125 te.wp_end = wp + argc; 126 127 /* 128 * Handle the special cases from POSIX.2, section 4.62.4. 129 * Implementation of all the rules isn't necessary since 130 * our parser does the right thing for the ommited steps. 131 */ 132 if (argc <= 5) { 133 char **owp = wp; 134 int invert = 0; 135 Test_op op; 136 const char *opnd1, *opnd2; 137 138 while (--argc >= 0) { 139 if ((*te.isa)(&te, TM_END)) 140 return !0; 141 if (argc == 3) { 142 opnd1 = (*te.getopnd)(&te, TO_NONOP, 1); 143 if ((op = (Test_op) (*te.isa)(&te, TM_BINOP))) { 144 opnd2 = (*te.getopnd)(&te, op, 1); 145 res = (*te.eval)(&te, op, opnd1, opnd2, 146 1); 147 if (te.flags & TEF_ERROR) 148 return T_ERR_EXIT; 149 if (invert & 1) 150 res = !res; 151 return !res; 152 } 153 /* back up to opnd1 */ 154 te.pos.wp--; 155 } 156 if (argc == 1) { 157 opnd1 = (*te.getopnd)(&te, TO_NONOP, 1); 158 /* Historically, -t by itself test if fd 1 159 * is a file descriptor, but POSIX says its 160 * a string test... 161 */ 162 if (!Flag(FPOSIX) && strcmp(opnd1, "-t") == 0) 163 break; 164 res = (*te.eval)(&te, TO_STNZE, opnd1, 165 (char *) 0, 1); 166 if (invert & 1) 167 res = !res; 168 return !res; 169 } 170 if ((*te.isa)(&te, TM_NOT)) { 171 invert++; 172 } else 173 break; 174 } 175 te.pos.wp = owp + 1; 176 } 177 178 return test_parse(&te); 179 } 180 181 /* 182 * Generic test routines. 183 */ 184 185 Test_op 186 test_isop(te, meta, s) 187 Test_env *te; 188 Test_meta meta; 189 const char *s; 190 { 191 char sc1; 192 const struct t_op *otab; 193 194 otab = meta == TM_UNOP ? u_ops : b_ops; 195 if (*s) { 196 sc1 = s[1]; 197 for (; otab->op_text[0]; otab++) 198 if (sc1 == otab->op_text[1] 199 && strcmp(s, otab->op_text) == 0 200 && ((te->flags & TEF_DBRACKET) 201 || (otab->op_num != TO_STLT 202 && otab->op_num != TO_STGT))) 203 return otab->op_num; 204 } 205 return TO_NONOP; 206 } 207 208 int 209 test_eval(te, op, opnd1, opnd2, do_eval) 210 Test_env *te; 211 Test_op op; 212 const char *opnd1; 213 const char *opnd2; 214 int do_eval; 215 { 216 int res; 217 int not; 218 struct stat b1, b2; 219 220 if (!do_eval) 221 return 0; 222 223 switch ((int) op) { 224 /* 225 * Unary Operators 226 */ 227 case TO_STNZE: /* -n */ 228 return *opnd1 != '\0'; 229 case TO_STZER: /* -z */ 230 return *opnd1 == '\0'; 231 case TO_OPTION: /* -o */ 232 if ((not = *opnd1 == '!')) 233 opnd1++; 234 if ((res = option(opnd1)) < 0) 235 res = 0; 236 else { 237 res = Flag(res); 238 if (not) 239 res = !res; 240 } 241 return res; 242 case TO_FILRD: /* -r */ 243 return test_eaccess(opnd1, R_OK) == 0; 244 case TO_FILWR: /* -w */ 245 return test_eaccess(opnd1, W_OK) == 0; 246 case TO_FILEX: /* -x */ 247 return test_eaccess(opnd1, X_OK) == 0; 248 case TO_FILAXST: /* -a */ 249 return test_stat(opnd1, &b1) == 0; 250 case TO_FILEXST: /* -e */ 251 /* at&t ksh does not appear to do the /dev/fd/ thing for 252 * this (unless the os itself handles it) 253 */ 254 return stat(opnd1, &b1) == 0; 255 case TO_FILREG: /* -r */ 256 return test_stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode); 257 case TO_FILID: /* -d */ 258 return test_stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode); 259 case TO_FILCDEV: /* -c */ 260 #ifdef S_ISCHR 261 return test_stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode); 262 #else 263 return 0; 264 #endif 265 case TO_FILBDEV: /* -b */ 266 #ifdef S_ISBLK 267 return test_stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode); 268 #else 269 return 0; 270 #endif 271 case TO_FILFIFO: /* -p */ 272 #ifdef S_ISFIFO 273 return test_stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode); 274 #else 275 return 0; 276 #endif 277 case TO_FILSYM: /* -h -L */ 278 #ifdef S_ISLNK 279 return lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode); 280 #else 281 return 0; 282 #endif 283 case TO_FILSOCK: /* -S */ 284 #ifdef S_ISSOCK 285 return test_stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode); 286 #else 287 return 0; 288 #endif 289 case TO_FILCDF:/* -H HP context dependent files (directories) */ 290 #ifdef S_ISCDF 291 { 292 /* Append a + to filename and check to see if result is a 293 * setuid directory. CDF stuff in general is hookey, since 294 * it breaks for the following sequence: echo hi > foo+; 295 * mkdir foo; echo bye > foo/default; chmod u+s foo 296 * (foo+ refers to the file with hi in it, there is no way 297 * to get at the file with bye in it - please correct me if 298 * I'm wrong about this). 299 */ 300 int len = strlen(opnd1); 301 char *p = str_nsave(opnd1, len + 1, ATEMP); 302 303 p[len++] = '+'; 304 p[len] = '\0'; 305 return stat(p, &b1) == 0 && S_ISCDF(b1.st_mode); 306 } 307 #else 308 return 0; 309 #endif 310 case TO_FILSETU: /* -u */ 311 #ifdef S_ISUID 312 return test_stat(opnd1, &b1) == 0 313 && (b1.st_mode & S_ISUID) == S_ISUID; 314 #else 315 return 0; 316 #endif 317 case TO_FILSETG: /* -g */ 318 #ifdef S_ISGID 319 return test_stat(opnd1, &b1) == 0 320 && (b1.st_mode & S_ISGID) == S_ISGID; 321 #else 322 return 0; 323 #endif 324 case TO_FILSTCK: /* -k */ 325 return test_stat(opnd1, &b1) == 0 326 && (b1.st_mode & S_ISVTX) == S_ISVTX; 327 case TO_FILGZ: /* -s */ 328 return test_stat(opnd1, &b1) == 0 && b1.st_size > 0L; 329 case TO_FILTT: /* -t */ 330 if (opnd1 && !bi_getn(opnd1, &res)) { 331 te->flags |= TEF_ERROR; 332 res = 0; 333 } else { 334 /* generate error if in FPOSIX mode? */ 335 res = isatty(opnd1 ? res : 0); 336 } 337 return res; 338 case TO_FILUID: /* -O */ 339 return test_stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid; 340 case TO_FILGID: /* -G */ 341 return test_stat(opnd1, &b1) == 0 && b1.st_gid == getegid(); 342 /* 343 * Binary Operators 344 */ 345 case TO_STEQL: /* = */ 346 if (te->flags & TEF_DBRACKET) 347 return gmatch(opnd1, opnd2, FALSE); 348 return strcmp(opnd1, opnd2) == 0; 349 case TO_STNEQ: /* != */ 350 if (te->flags & TEF_DBRACKET) 351 return !gmatch(opnd1, opnd2, FALSE); 352 return strcmp(opnd1, opnd2) != 0; 353 case TO_STLT: /* < */ 354 return strcmp(opnd1, opnd2) < 0; 355 case TO_STGT: /* > */ 356 return strcmp(opnd1, opnd2) > 0; 357 case TO_INTEQ: /* -eq */ 358 case TO_INTNE: /* -ne */ 359 case TO_INTGE: /* -ge */ 360 case TO_INTGT: /* -gt */ 361 case TO_INTLE: /* -le */ 362 case TO_INTLT: /* -lt */ 363 { 364 long v1, v2; 365 366 if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR) 367 || !evaluate(opnd2, &v2, KSH_RETURN_ERROR)) 368 { 369 /* error already printed.. */ 370 te->flags |= TEF_ERROR; 371 return 1; 372 } 373 switch ((int) op) { 374 case TO_INTEQ: 375 return v1 == v2; 376 case TO_INTNE: 377 return v1 != v2; 378 case TO_INTGE: 379 return v1 >= v2; 380 case TO_INTGT: 381 return v1 > v2; 382 case TO_INTLE: 383 return v1 <= v2; 384 case TO_INTLT: 385 return v1 < v2; 386 } 387 } 388 case TO_FILNT: /* -nt */ 389 { 390 int s2; 391 /* ksh88/ksh93 succeed if file2 can't be stated 392 * (subtly different from `does not exist'). 393 */ 394 return stat(opnd1, &b1) == 0 395 && (((s2 = stat(opnd2, &b2)) == 0 396 && b1.st_mtime > b2.st_mtime) || s2 < 0); 397 } 398 case TO_FILOT: /* -ot */ 399 { 400 int s1; 401 /* ksh88/ksh93 succeed if file1 can't be stated 402 * (subtly different from `does not exist'). 403 */ 404 return stat(opnd2, &b2) == 0 405 && (((s1 = stat(opnd1, &b1)) == 0 406 && b1.st_mtime < b2.st_mtime) || s1 < 0); 407 } 408 case TO_FILEQ: /* -ef */ 409 return stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0 410 && b1.st_dev == b2.st_dev 411 && b1.st_ino == b2.st_ino; 412 } 413 (*te->error)(te, 0, "internal error: unknown op"); 414 return 1; 415 } 416 417 /* Nasty kludge to handle Korn's bizarre /dev/fd hack */ 418 static int 419 test_stat(path, statb) 420 const char *path; 421 struct stat *statb; 422 { 423 #if !defined(HAVE_DEV_FD) 424 int fd; 425 426 if (strncmp(path, "/dev/fd/", 8) == 0 && getn(path + 8, &fd)) 427 return fstat(fd, statb); 428 #endif /* !HAVE_DEV_FD */ 429 430 return stat(path, statb); 431 } 432 433 /* Routine to handle Korn's /dev/fd hack, and to deal with X_OK on 434 * non-directories when running as root. 435 */ 436 static int 437 test_eaccess(path, mode) 438 const char *path; 439 int mode; 440 { 441 int res; 442 443 #if !defined(HAVE_DEV_FD) 444 int fd; 445 446 /* Note: doesn't handle //dev/fd, etc.. (this is ok) */ 447 if (strncmp(path, "/dev/fd/", 8) == 0 && getn(path + 8, &fd)) { 448 int flags; 449 450 if ((flags = fcntl(fd, F_GETFL, 0)) < 0 451 || (mode & X_OK) 452 || ((mode & W_OK) && (flags & O_ACCMODE) == O_RDONLY) 453 || ((mode & R_OK) && (flags & O_ACCMODE) == O_WRONLY)) 454 return -1; 455 return 0; 456 } 457 #endif /* !HAVE_DEV_FD */ 458 459 /* On most (all?) unixes, access() says everything is executable for 460 * root - avoid this on files by using stat(). 461 */ 462 if ((mode & X_OK) && ksheuid == 0) { 463 struct stat statb; 464 465 if (stat(path, &statb) < 0) 466 res = -1; 467 else if (S_ISDIR(statb.st_mode)) 468 res = 0; 469 else 470 res = (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) 471 ? 0 : -1; 472 /* Need to check other permissions? If so, use access() as 473 * this will deal with root on NFS. 474 */ 475 if (res == 0 && (mode & (R_OK|W_OK))) 476 res = eaccess(path, mode); 477 } else 478 res = eaccess(path, mode); 479 480 return res; 481 } 482 483 int 484 test_parse(te) 485 Test_env *te; 486 { 487 int res; 488 489 res = test_oexpr(te, 1); 490 491 if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END)) 492 (*te->error)(te, 0, "unexpected operator/operand"); 493 494 return (te->flags & TEF_ERROR) ? T_ERR_EXIT : !res; 495 } 496 497 static int 498 test_oexpr(te, do_eval) 499 Test_env *te; 500 int do_eval; 501 { 502 int res; 503 504 res = test_aexpr(te, do_eval); 505 if (res) 506 do_eval = 0; 507 if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR)) 508 return test_oexpr(te, do_eval) || res; 509 return res; 510 } 511 512 static int 513 test_aexpr(te, do_eval) 514 Test_env *te; 515 int do_eval; 516 { 517 int res; 518 519 res = test_nexpr(te, do_eval); 520 if (!res) 521 do_eval = 0; 522 if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND)) 523 return test_aexpr(te, do_eval) && res; 524 return res; 525 } 526 527 static int 528 test_nexpr(te, do_eval) 529 Test_env *te; 530 int do_eval; 531 { 532 if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT)) 533 return !test_nexpr(te, do_eval); 534 return test_primary(te, do_eval); 535 } 536 537 static int 538 test_primary(te, do_eval) 539 Test_env *te; 540 int do_eval; 541 { 542 const char *opnd1, *opnd2; 543 int res; 544 Test_op op; 545 546 if (te->flags & TEF_ERROR) 547 return 0; 548 if ((*te->isa)(te, TM_OPAREN)) { 549 res = test_oexpr(te, do_eval); 550 if (te->flags & TEF_ERROR) 551 return 0; 552 if (!(*te->isa)(te, TM_CPAREN)) { 553 (*te->error)(te, 0, "missing closing paren"); 554 return 0; 555 } 556 return res; 557 } 558 if ((op = (Test_op) (*te->isa)(te, TM_UNOP))) { 559 /* unary expression */ 560 opnd1 = (*te->getopnd)(te, op, do_eval); 561 if (!opnd1) { 562 (*te->error)(te, -1, "missing argument"); 563 return 0; 564 } 565 566 return (*te->eval)(te, op, opnd1, (const char *) 0, do_eval); 567 } 568 opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval); 569 if (!opnd1) { 570 (*te->error)(te, 0, "expression expected"); 571 return 0; 572 } 573 if ((op = (Test_op) (*te->isa)(te, TM_BINOP))) { 574 /* binary expression */ 575 opnd2 = (*te->getopnd)(te, op, do_eval); 576 if (!opnd2) { 577 (*te->error)(te, -1, "missing second argument"); 578 return 0; 579 } 580 581 return (*te->eval)(te, op, opnd1, opnd2, do_eval); 582 } 583 if (te->flags & TEF_DBRACKET) { 584 (*te->error)(te, -1, "missing expression operator"); 585 return 0; 586 } 587 return (*te->eval)(te, TO_STNZE, opnd1, (const char *) 0, do_eval); 588 } 589 590 /* 591 * Plain test (test and [ .. ]) specific routines. 592 */ 593 594 /* Test if the current token is a whatever. Accepts the current token if 595 * it is. Returns 0 if it is not, non-zero if it is (in the case of 596 * TM_UNOP and TM_BINOP, the returned value is a Test_op). 597 */ 598 static int 599 ptest_isa(te, meta) 600 Test_env *te; 601 Test_meta meta; 602 { 603 /* Order important - indexed by Test_meta values */ 604 static const char *const tokens[] = { 605 "-o", "-a", "!", "(", ")" 606 }; 607 int ret; 608 609 if (te->pos.wp >= te->wp_end) 610 return meta == TM_END; 611 612 if (meta == TM_UNOP || meta == TM_BINOP) 613 ret = (int) test_isop(te, meta, *te->pos.wp); 614 else if (meta == TM_END) 615 ret = 0; 616 else 617 ret = strcmp(*te->pos.wp, tokens[(int) meta]) == 0; 618 619 /* Accept the token? */ 620 if (ret) 621 te->pos.wp++; 622 623 return ret; 624 } 625 626 static const char * 627 ptest_getopnd(te, op, do_eval) 628 Test_env *te; 629 Test_op op; 630 int do_eval; 631 { 632 if (te->pos.wp >= te->wp_end) 633 return op == TO_FILTT ? "1" : (const char *) 0; 634 return *te->pos.wp++; 635 } 636 637 static int 638 ptest_eval(te, op, opnd1, opnd2, do_eval) 639 Test_env *te; 640 Test_op op; 641 const char *opnd1; 642 const char *opnd2; 643 int do_eval; 644 { 645 return test_eval(te, op, opnd1, opnd2, do_eval); 646 } 647 648 static void 649 ptest_error(te, offset, msg) 650 Test_env *te; 651 int offset; 652 const char *msg; 653 { 654 const char *op = te->pos.wp + offset >= te->wp_end ? 655 (const char *) 0 : te->pos.wp[offset]; 656 657 te->flags |= TEF_ERROR; 658 if (op) 659 bi_errorf("%s: %s", op, msg); 660 else 661 bi_errorf("%s", msg); 662 } 663
Indexes created Tue Sep 30 11:09:46 GMT 2025