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