1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1982-2009 AT&T Intellectual Property * 5 * and is licensed under the * 6 * Common Public License, Version 1.0 * 7 * by AT&T Intellectual Property * 8 * * 9 * A copy of the License is available at * 10 * http://www.opensource.org/licenses/cpl1.0.txt * 11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * 12 * * 13 * Information and Software Systems Research * 14 * AT&T Research * 15 * Florham Park NJ * 16 * * 17 * David Korn <dgk@research.att.com> * 18 * * 19 ***********************************************************************/ 20 #pragma prototyped 21 /* 22 * test expression 23 * [ expression ] 24 * 25 * David Korn 26 * AT&T Labs 27 * 28 */ 29 30 31 #include "defs.h" 32 #include <error.h> 33 #include <ls.h> 34 #include "io.h" 35 #include "terminal.h" 36 #include "test.h" 37 #include "builtins.h" 38 #include "FEATURE/externs" 39 #include "FEATURE/poll" 40 #include <tmx.h> 41 42 #if !_lib_setregid 43 # undef _lib_setreuid 44 #endif /* _lib_setregid */ 45 46 #ifdef S_ISSOCK 47 # if _pipe_socketpair 48 # if _socketpair_shutdown_mode 49 # define isapipe(f,p) (test_stat(f,p)>=0&&S_ISFIFO((p)->st_mode)||S_ISSOCK((p)->st_mode)&&(p)->st_ino&&((p)->st_mode&(S_IRUSR|S_IWUSR))!=(S_IRUSR|S_IWUSR)) 50 # else 51 # define isapipe(f,p) (test_stat(f,p)>=0&&S_ISFIFO((p)->st_mode)||S_ISSOCK((p)->st_mode)&&(p)->st_ino) 52 # endif 53 # else 54 # define isapipe(f,p) (test_stat(f,p)>=0&&S_ISFIFO((p)->st_mode)||S_ISSOCK((p)->st_mode)&&(p)->st_ino) 55 # endif 56 # define isasock(f,p) (test_stat(f,p)>=0&&S_ISSOCK((p)->st_mode)) 57 #else 58 # define isapipe(f,p) (test_stat(f,p)>=0&&S_ISFIFO((p)->st_mode)) 59 # define isasock(f,p) (0) 60 #endif 61 62 #define permission(a,f) (sh_access(a,f)==0) 63 static time_t test_time(const char*, const char*); 64 static int test_stat(const char*, struct stat*); 65 static int test_mode(const char*); 66 67 /* single char string compare */ 68 #define c_eq(a,c) (*a==c && *(a+1)==0) 69 /* two character string compare */ 70 #define c2_eq(a,c1,c2) (*a==c1 && *(a+1)==c2 && *(a+2)==0) 71 72 struct test 73 { 74 Shell_t *sh; 75 int ap; 76 int ac; 77 char **av; 78 }; 79 80 static char *nxtarg(struct test*,int); 81 static int expr(struct test*,int); 82 static int e3(struct test*); 83 84 static int test_strmatch(const char *str, const char *pat) 85 { 86 int match[2*(MATCH_MAX+1)],n; 87 register int c, m=0; 88 register const char *cp=pat; 89 while(c = *cp++) 90 { 91 if(c=='(') 92 m++; 93 if(c=='\\' && *cp) 94 cp++; 95 } 96 if(m) 97 m++; 98 else 99 match[0] = 0; 100 if(m > elementsof(match)/2) 101 m = elementsof(match)/2; 102 n = strgrpmatch(str, pat, match, m, STR_MAXIMAL|STR_LEFT|STR_RIGHT); 103 if(m==0 && n==1) 104 match[1] = strlen(str); 105 if(n) 106 sh_setmatch(str, -1, n, match); 107 return(n); 108 } 109 110 int b_test(int argc, char *argv[],void *extra) 111 { 112 struct test tdata; 113 register char *cp = argv[0]; 114 register int not; 115 tdata.sh = ((Shbltin_t*)extra)->shp; 116 tdata.av = argv; 117 tdata.ap = 1; 118 if(c_eq(cp,'[')) 119 { 120 cp = argv[--argc]; 121 if(!c_eq(cp, ']')) 122 errormsg(SH_DICT,ERROR_exit(2),e_missing,"']'"); 123 } 124 if(argc <= 1) 125 return(1); 126 cp = argv[1]; 127 if(c_eq(cp,'(') && argc<=6 && c_eq(argv[argc-1],')')) 128 { 129 /* special case ( binop ) to conform with standard */ 130 if(!(argc==4 && (not=sh_lookup(cp=argv[2],shtab_testops)))) 131 { 132 cp = (++argv)[1]; 133 argc -= 2; 134 } 135 } 136 not = c_eq(cp,'!'); 137 /* posix portion for test */ 138 switch(argc) 139 { 140 case 5: 141 if(!not) 142 break; 143 argv++; 144 /* fall through */ 145 case 4: 146 { 147 register int op = sh_lookup(cp=argv[2],shtab_testops); 148 if(op&TEST_BINOP) 149 break; 150 if(!op) 151 { 152 if(argc==5) 153 break; 154 if(not && cp[0]=='-' && cp[2]==0) 155 return(test_unop(cp[1],argv[3])!=0); 156 else if(argv[1][0]=='-' && argv[1][2]==0) 157 return(!test_unop(argv[1][1],cp)); 158 errormsg(SH_DICT,ERROR_exit(2),e_badop,cp); 159 } 160 return(test_binop(op,argv[1],argv[3])^(argc!=5)); 161 } 162 case 3: 163 if(not) 164 return(*argv[2]!=0); 165 if(cp[0] != '-' || cp[2] || cp[1]=='?') 166 { 167 if(cp[0]=='-' && (cp[1]=='-' || cp[1]=='?') && 168 strcmp(argv[2],"--")==0) 169 { 170 char *av[3]; 171 av[0] = argv[0]; 172 av[1] = argv[1]; 173 av[2] = 0; 174 optget(av,sh_opttest); 175 errormsg(SH_DICT,ERROR_usage(2), "%s",opt_info.arg); 176 return(2); 177 } 178 break; 179 } 180 return(!test_unop(cp[1],argv[2])); 181 case 2: 182 return(*cp==0); 183 } 184 tdata.ac = argc; 185 return(!expr(&tdata,0)); 186 } 187 188 /* 189 * evaluate a test expression. 190 * flag is 0 on outer level 191 * flag is 1 when in parenthesis 192 * flag is 2 when evaluating -a 193 */ 194 static int expr(struct test *tp,register int flag) 195 { 196 register int r; 197 register char *p; 198 r = e3(tp); 199 while(tp->ap < tp->ac) 200 { 201 p = nxtarg(tp,0); 202 /* check for -o and -a */ 203 if(flag && c_eq(p,')')) 204 { 205 tp->ap--; 206 break; 207 } 208 if(*p=='-' && *(p+2)==0) 209 { 210 if(*++p == 'o') 211 { 212 if(flag==2) 213 { 214 tp->ap--; 215 break; 216 } 217 r |= expr(tp,3); 218 continue; 219 } 220 else if(*p == 'a') 221 { 222 r &= expr(tp,2); 223 continue; 224 } 225 } 226 if(flag==0) 227 break; 228 errormsg(SH_DICT,ERROR_exit(2),e_badsyntax); 229 } 230 return(r); 231 } 232 233 static char *nxtarg(struct test *tp,int mt) 234 { 235 if(tp->ap >= tp->ac) 236 { 237 if(mt) 238 { 239 tp->ap++; 240 return(0); 241 } 242 errormsg(SH_DICT,ERROR_exit(2),e_argument); 243 } 244 return(tp->av[tp->ap++]); 245 } 246 247 248 static int e3(struct test *tp) 249 { 250 register char *arg, *cp; 251 register int op; 252 char *binop; 253 arg=nxtarg(tp,0); 254 if(arg && c_eq(arg, '!')) 255 return(!e3(tp)); 256 if(c_eq(arg, '(')) 257 { 258 op = expr(tp,1); 259 cp = nxtarg(tp,0); 260 if(!cp || !c_eq(cp, ')')) 261 errormsg(SH_DICT,ERROR_exit(2),e_missing,"')'"); 262 return(op); 263 } 264 cp = nxtarg(tp,1); 265 if(cp!=0 && (c_eq(cp,'=') || c2_eq(cp,'!','='))) 266 goto skip; 267 if(c2_eq(arg,'-','t')) 268 { 269 if(cp) 270 { 271 op = strtol(cp,&binop, 10); 272 return(*binop?0:tty_check(op)); 273 } 274 else 275 { 276 /* test -t with no arguments */ 277 tp->ap--; 278 return(tty_check(1)); 279 } 280 } 281 if(*arg=='-' && arg[2]==0) 282 { 283 op = arg[1]; 284 if(!cp) 285 { 286 /* for backward compatibility with new flags */ 287 if(op==0 || !strchr(test_opchars+10,op)) 288 return(1); 289 errormsg(SH_DICT,ERROR_exit(2),e_argument); 290 } 291 if(strchr(test_opchars,op)) 292 return(test_unop(op,cp)); 293 } 294 if(!cp) 295 { 296 tp->ap--; 297 return(*arg!=0); 298 } 299 skip: 300 op = sh_lookup(binop=cp,shtab_testops); 301 if(!(op&TEST_BINOP)) 302 cp = nxtarg(tp,0); 303 if(!op) 304 errormsg(SH_DICT,ERROR_exit(2),e_badop,binop); 305 if(op==TEST_AND || op==TEST_OR) 306 tp->ap--; 307 return(test_binop(op,arg,cp)); 308 } 309 310 int test_unop(register int op,register const char *arg) 311 { 312 struct stat statb; 313 int f; 314 switch(op) 315 { 316 case 'r': 317 return(permission(arg, R_OK)); 318 case 'w': 319 return(permission(arg, W_OK)); 320 case 'x': 321 return(permission(arg, X_OK)); 322 case 'V': 323 #if SHOPT_FS_3D 324 { 325 register int offset = staktell(); 326 if(stat(arg,&statb)<0 || !S_ISREG(statb.st_mode)) 327 return(0); 328 /* add trailing / */ 329 stakputs(arg); 330 stakputc('/'); 331 stakputc(0); 332 arg = (const char*)stakptr(offset); 333 stakseek(offset); 334 /* FALL THRU */ 335 } 336 #else 337 return(0); 338 #endif /* SHOPT_FS_3D */ 339 case 'd': 340 return(test_stat(arg,&statb)>=0 && S_ISDIR(statb.st_mode)); 341 case 'c': 342 return(test_stat(arg,&statb)>=0 && S_ISCHR(statb.st_mode)); 343 case 'b': 344 return(test_stat(arg,&statb)>=0 && S_ISBLK(statb.st_mode)); 345 case 'f': 346 return(test_stat(arg,&statb)>=0 && S_ISREG(statb.st_mode)); 347 case 'u': 348 return(test_mode(arg)&S_ISUID); 349 case 'g': 350 return(test_mode(arg)&S_ISGID); 351 case 'k': 352 #ifdef S_ISVTX 353 return(test_mode(arg)&S_ISVTX); 354 #else 355 return(0); 356 #endif /* S_ISVTX */ 357 #if SHOPT_TEST_L 358 case 'l': 359 #endif 360 case 'L': 361 case 'h': /* undocumented, and hopefully will disappear */ 362 if(*arg==0 || arg[strlen(arg)-1]=='/' || lstat(arg,&statb)<0) 363 return(0); 364 return(S_ISLNK(statb.st_mode)); 365 366 case 'C': 367 #ifdef S_ISCTG 368 return(test_stat(arg,&statb)>=0 && S_ISCTG(statb.st_mode)); 369 #else 370 return(0); 371 #endif /* S_ISCTG */ 372 case 'H': 373 #ifdef S_ISCDF 374 { 375 register int offset = staktell(); 376 if(test_stat(arg,&statb)>=0 && S_ISCDF(statb.st_mode)) 377 return(1); 378 stakputs(arg); 379 stakputc('+'); 380 stakputc(0); 381 arg = (const char*)stakptr(offset); 382 stakseek(offset); 383 return(test_stat(arg,&statb)>=0 && S_ISCDF(statb.st_mode)); 384 } 385 #else 386 return(0); 387 #endif /* S_ISCDF */ 388 389 case 'S': 390 return(isasock(arg,&statb)); 391 case 'N': 392 return(test_stat(arg,&statb)>=0 && tmxgetmtime(&statb) > tmxgetatime(&statb)); 393 case 'p': 394 return(isapipe(arg,&statb)); 395 case 'n': 396 return(*arg != 0); 397 case 'z': 398 return(*arg == 0); 399 case 's': 400 sfsync(sfstdout); 401 case 'O': 402 case 'G': 403 if(*arg==0 || test_stat(arg,&statb)<0) 404 return(0); 405 if(op=='s') 406 return(statb.st_size>0); 407 else if(op=='O') 408 return(statb.st_uid==sh.userid); 409 return(statb.st_gid==sh.groupid); 410 case 'a': 411 case 'e': 412 return(permission(arg, F_OK)); 413 case 'o': 414 f=1; 415 if(*arg=='?') 416 return(sh_lookopt(arg+1,&f)>0); 417 op = sh_lookopt(arg,&f); 418 return(op && (f==(sh_isoption(op)!=0))); 419 case 't': 420 { 421 char *last; 422 op = strtol(arg,&last, 10); 423 return(*last?0:tty_check(op)); 424 } 425 case 'v': 426 case 'R': 427 { 428 Namval_t *np; 429 Namarr_t *ap; 430 int isref; 431 if(!(np = nv_open(arg,sh.var_tree,NV_VARNAME|NV_NOFAIL|NV_NOADD|NV_NOREF))) 432 return(0); 433 isref = nv_isref(np); 434 if(op=='R') 435 return(isref); 436 if(isref) 437 { 438 if(np->nvalue.cp) 439 np = nv_refnode(np); 440 else 441 return(0); 442 443 } 444 if(ap = nv_arrayptr(np)) 445 return(nv_arrayisset(np,ap)); 446 return(!nv_isnull(np) || nv_isattr(np,NV_INTEGER)); 447 } 448 default: 449 { 450 static char a[3] = "-?"; 451 a[1]= op; 452 errormsg(SH_DICT,ERROR_exit(2),e_badop,a); 453 /* NOTREACHED */ 454 return(0); 455 } 456 } 457 } 458 459 int test_binop(register int op,const char *left,const char *right) 460 { 461 register double lnum,rnum; 462 if(op&TEST_ARITH) 463 { 464 while(*left=='0') 465 left++; 466 while(*right=='0') 467 right++; 468 lnum = sh_arith(left); 469 rnum = sh_arith(right); 470 } 471 switch(op) 472 { 473 /* op must be one of the following values */ 474 case TEST_AND: 475 case TEST_OR: 476 return(*left!=0); 477 case TEST_PEQ: 478 return(test_strmatch(left, right)); 479 case TEST_PNE: 480 return(!test_strmatch(left, right)); 481 case TEST_SGT: 482 return(strcoll(left, right)>0); 483 case TEST_SLT: 484 return(strcoll(left, right)<0); 485 case TEST_SEQ: 486 return(strcmp(left, right)==0); 487 case TEST_SNE: 488 return(strcmp(left, right)!=0); 489 case TEST_EF: 490 return(test_inode(left,right)); 491 case TEST_NT: 492 return(test_time(left,right)>0); 493 case TEST_OT: 494 return(test_time(left,right)<0); 495 case TEST_EQ: 496 return(lnum==rnum); 497 case TEST_NE: 498 return(lnum!=rnum); 499 case TEST_GT: 500 return(lnum>rnum); 501 case TEST_LT: 502 return(lnum<rnum); 503 case TEST_GE: 504 return(lnum>=rnum); 505 case TEST_LE: 506 return(lnum<=rnum); 507 } 508 /* NOTREACHED */ 509 return(0); 510 } 511 512 /* 513 * returns the modification time of f1 - modification time of f2 514 */ 515 516 static time_t test_time(const char *file1,const char *file2) 517 { 518 Time_t t1, t2; 519 struct stat statb1,statb2; 520 int r=test_stat(file2,&statb2); 521 if(test_stat(file1,&statb1)<0) 522 return(r<0?0:-1); 523 if(r<0) 524 return(1); 525 t1 = tmxgetmtime(&statb1); 526 t2 = tmxgetmtime(&statb2); 527 if (t1 > t2) 528 return(1); 529 if (t1 < t2) 530 return(-1); 531 return(0); 532 } 533 534 /* 535 * return true if inode of two files are the same 536 */ 537 538 int test_inode(const char *file1,const char *file2) 539 { 540 struct stat stat1,stat2; 541 if(test_stat(file1,&stat1)>=0 && test_stat(file2,&stat2)>=0) 542 if(stat1.st_dev == stat2.st_dev && stat1.st_ino == stat2.st_ino) 543 return(1); 544 return(0); 545 } 546 547 548 /* 549 * This version of access checks against effective uid/gid 550 * The static buffer statb is shared with test_mode. 551 */ 552 553 int sh_access(register const char *name, register int mode) 554 { 555 struct stat statb; 556 if(*name==0) 557 return(-1); 558 if(strmatch(name,(char*)e_devfdNN)) 559 return(sh_ioaccess((int)strtol(name+8, (char**)0, 10),mode)); 560 /* can't use access function for execute permission with root */ 561 if(mode==X_OK && sh.euserid==0) 562 goto skip; 563 if(sh.userid==sh.euserid && sh.groupid==sh.egroupid) 564 return(access(name,mode)); 565 #ifdef _lib_setreuid 566 /* swap the real uid to effective, check access then restore */ 567 /* first swap real and effective gid, if different */ 568 if(sh.groupid==sh.euserid || setregid(sh.egroupid,sh.groupid)==0) 569 { 570 /* next swap real and effective uid, if needed */ 571 if(sh.userid==sh.euserid || setreuid(sh.euserid,sh.userid)==0) 572 { 573 mode = access(name,mode); 574 /* restore ids */ 575 if(sh.userid!=sh.euserid) 576 setreuid(sh.userid,sh.euserid); 577 if(sh.groupid!=sh.egroupid) 578 setregid(sh.groupid,sh.egroupid); 579 return(mode); 580 } 581 else if(sh.groupid!=sh.egroupid) 582 setregid(sh.groupid,sh.egroupid); 583 } 584 #endif /* _lib_setreuid */ 585 skip: 586 if(test_stat(name, &statb) == 0) 587 { 588 if(mode == F_OK) 589 return(mode); 590 else if(sh.euserid == 0) 591 { 592 if(!S_ISREG(statb.st_mode) || mode!=X_OK) 593 return(0); 594 /* root needs execute permission for someone */ 595 mode = (S_IXUSR|S_IXGRP|S_IXOTH); 596 } 597 else if(sh.euserid == statb.st_uid) 598 mode <<= 6; 599 else if(sh.egroupid == statb.st_gid) 600 mode <<= 3; 601 #ifdef _lib_getgroups 602 /* on some systems you can be in several groups */ 603 else 604 { 605 static int maxgroups; 606 gid_t *groups; 607 register int n; 608 if(maxgroups==0) 609 { 610 /* first time */ 611 if((maxgroups=getgroups(0,(gid_t*)0)) <= 0) 612 { 613 /* pre-POSIX system */ 614 maxgroups=NGROUPS_MAX; 615 } 616 } 617 groups = (gid_t*)stakalloc((maxgroups+1)*sizeof(gid_t)); 618 n = getgroups(maxgroups,groups); 619 while(--n >= 0) 620 { 621 if(groups[n] == statb.st_gid) 622 { 623 mode <<= 3; 624 break; 625 } 626 } 627 } 628 # endif /* _lib_getgroups */ 629 if(statb.st_mode & mode) 630 return(0); 631 } 632 return(-1); 633 } 634 635 /* 636 * Return the mode bits of file <file> 637 * If <file> is null, then the previous stat buffer is used. 638 * The mode bits are zero if the file doesn't exist. 639 */ 640 641 static int test_mode(register const char *file) 642 { 643 struct stat statb; 644 if(file && (*file==0 || test_stat(file,&statb)<0)) 645 return(0); 646 return(statb.st_mode); 647 } 648 649 /* 650 * do an fstat() for /dev/fd/n, otherwise stat() 651 */ 652 static int test_stat(const char *name,struct stat *buff) 653 { 654 if(*name==0) 655 { 656 errno = ENOENT; 657 return(-1); 658 } 659 if(strmatch(name,(char*)e_devfdNN)) 660 return(fstat((int)strtol(name+8, (char**)0, 10),buff)); 661 else 662 return(stat(name,buff)); 663 } 664