| /* |
| * test(1); version 7-like -- author Erik Baalbergen |
| * modified by Eric Gisin to be used as built-in. |
| * modified by Arnold Robbins to add SVR3 compatibility |
| * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket). |
| */ |
| |
| static char *RCSid = "$Id: test.c,v 1.1.1.1 2002/08/17 01:36:06 hpa Exp $"; |
| |
| #include <stddef.h> |
| /*#include <string.h>*/ |
| #include <signal.h> |
| #include <errno.h> |
| #include <setjmp.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include "bltin.h" |
| |
| /* test(1) accepts the following grammar: |
| oexpr ::= aexpr | aexpr "-o" oexpr ; |
| aexpr ::= nexpr | nexpr "-a" aexpr ; |
| nexpr ::= primary ! "!" primary |
| primary ::= unary-operator operand |
| | operand binary-operator operand |
| | operand |
| | "(" oexpr ")" |
| ; |
| unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"| |
| "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S"; |
| |
| binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| |
| "-nt"|"-ot"|"-ef"; |
| operand ::= <any legal UNIX file name> |
| */ |
| |
| #define evaluate(x) getn(x) |
| #define errorf error |
| |
| #define EOI 0 |
| #define FILRD 1 |
| #define FILWR 2 |
| #define FILREG 3 |
| #define FILID 4 |
| #define FILGZ 5 |
| #define FILTT 6 |
| #define STZER 7 |
| #define STNZE 8 |
| #define STEQL 9 |
| #define STNEQ 10 |
| #define INTEQ 11 |
| #define INTNE 12 |
| #define INTGE 13 |
| #define INTGT 14 |
| #define INTLE 15 |
| #define INTLT 16 |
| #define UNOT 17 |
| #define BAND 18 |
| #define BOR 19 |
| #define LPAREN 20 |
| #define RPAREN 21 |
| #define OPERAND 22 |
| #define FILEX 23 |
| #define FILCDEV 24 |
| #define FILBDEV 25 |
| #define FILFIFO 26 |
| #define FILSETU 27 |
| #define FILSETG 28 |
| #define FILSTCK 29 |
| #define FILSYM 30 |
| #define FILNT 31 |
| #define FILOT 32 |
| #define FILEQ 33 |
| #define FILSOCK 34 |
| #define FILUID 35 |
| #define FILGID 36 |
| #define OPTION 37 |
| |
| #define UNOP 1 |
| #define BINOP 2 |
| #define BUNOP 3 |
| #define BBINOP 4 |
| #define PAREN 5 |
| |
| struct t_op { |
| char *op_text; |
| short op_num, op_type; |
| } const ops [] = { |
| {"-r", FILRD, UNOP}, |
| {"-w", FILWR, UNOP}, |
| {"-x", FILEX, UNOP}, |
| {"-f", FILREG, UNOP}, |
| {"-d", FILID, UNOP}, |
| {"-c", FILCDEV,UNOP}, |
| {"-b", FILBDEV,UNOP}, |
| {"-p", FILFIFO,UNOP}, |
| {"-u", FILSETU,UNOP}, |
| {"-g", FILSETG,UNOP}, |
| {"-k", FILSTCK,UNOP}, |
| {"-s", FILGZ, UNOP}, |
| {"-t", FILTT, UNOP}, |
| {"-z", STZER, UNOP}, |
| {"-n", STNZE, UNOP}, |
| #if 0 /* conficts with binary -o */ |
| {"-o", OPTION, UNOP}, |
| #endif |
| {"-U", FILUID, UNOP}, |
| {"-G", FILGID, UNOP}, |
| {"-L", FILSYM, UNOP}, |
| {"-S", FILSOCK,UNOP}, |
| {"=", STEQL, BINOP}, |
| {"!=", STNEQ, BINOP}, |
| {"-eq", INTEQ, BINOP}, |
| {"-ne", INTNE, BINOP}, |
| {"-ge", INTGE, BINOP}, |
| {"-gt", INTGT, BINOP}, |
| {"-le", INTLE, BINOP}, |
| {"-lt", INTLT, BINOP}, |
| {"-nt", FILNT, BINOP}, |
| {"-ot", FILOT, BINOP}, |
| {"-ef", FILEQ, BINOP}, |
| {"!", UNOT, BUNOP}, |
| {"-a", BAND, BBINOP}, |
| {"-o", BOR, BBINOP}, |
| {"(", LPAREN, PAREN}, |
| {")", RPAREN, PAREN}, |
| {0, 0, 0} |
| }; |
| |
| char **t_wp; |
| struct t_op const *t_wp_op; |
| |
| static void syntax(); |
| |
| int |
| testcmd(argc, wp) |
| char **wp; |
| { |
| int res; |
| |
| t_wp = wp+1; |
| if (strcmp(wp[0], "[") == 0) { |
| while (*wp != NULL) |
| wp++; |
| if (strcmp(*--wp, "]") != 0) |
| errorf("[: missing ]"); |
| *wp = NULL; |
| } |
| res = *t_wp == NULL || !oexpr(t_lex(*t_wp)); |
| |
| if (*t_wp != NULL && *++t_wp != NULL) |
| syntax(*t_wp, "unknown operand"); |
| |
| return res; |
| } |
| |
| static void |
| syntax(op, msg) |
| char *op; |
| char *msg; |
| { |
| if (op && *op) |
| errorf("%s: %s", op, msg); |
| else |
| errorf("%s", msg); |
| } |
| |
| oexpr(n) |
| { |
| int res; |
| |
| res = aexpr(n); |
| if (t_lex(*++t_wp) == BOR) |
| return oexpr(t_lex(*++t_wp)) || res; |
| t_wp--; |
| return res; |
| } |
| |
| aexpr(n) |
| { |
| int res; |
| |
| res = nexpr(n); |
| if (t_lex(*++t_wp) == BAND) |
| return aexpr(t_lex(*++t_wp)) && res; |
| t_wp--; |
| return res; |
| } |
| |
| nexpr(n) |
| int n; /* token */ |
| { |
| if (n == UNOT) |
| return !nexpr(t_lex(*++t_wp)); |
| return primary(n); |
| } |
| |
| primary(n) |
| int n; /* token */ |
| { |
| register char *opnd1, *opnd2; |
| int res; |
| |
| if (n == EOI) |
| syntax(NULL, "argument expected"); |
| if (n == LPAREN) { |
| res = oexpr(t_lex(*++t_wp)); |
| if (t_lex(*++t_wp) != RPAREN) |
| syntax(NULL, "closing paren expected"); |
| return res; |
| } |
| if (t_wp_op && t_wp_op->op_type == UNOP) { |
| /* unary expression */ |
| if (*++t_wp == NULL && n != FILTT) |
| syntax(t_wp_op->op_text, "argument expected"); |
| switch (n) { |
| /** |
| case OPTION: |
| return flag[option(*t_wp)]; |
| **/ |
| case STZER: |
| return strlen(*t_wp) == 0; |
| case STNZE: |
| return strlen(*t_wp) != 0; |
| case FILTT: |
| if (**t_wp < '0' || **t_wp > '9') |
| return filstat("0", n); |
| default: /* all other FIL* */ |
| return filstat(*t_wp, n); |
| } |
| } |
| opnd1 = *t_wp; |
| (void) t_lex(*++t_wp); |
| if (t_wp_op && t_wp_op->op_type == BINOP) { |
| struct t_op const *op = t_wp_op; |
| |
| if ((opnd2 = *++t_wp) == (char *)0) |
| syntax(op->op_text, "argument expected"); |
| |
| switch (op->op_num) { |
| case STEQL: |
| return strcmp(opnd1, opnd2) == 0; |
| case STNEQ: |
| return strcmp(opnd1, opnd2) != 0; |
| case INTEQ: |
| return evaluate(opnd1) == evaluate(opnd2); |
| case INTNE: |
| return evaluate(opnd1) != evaluate(opnd2); |
| case INTGE: |
| return evaluate(opnd1) >= evaluate(opnd2); |
| case INTGT: |
| return evaluate(opnd1) > evaluate(opnd2); |
| case INTLE: |
| return evaluate(opnd1) <= evaluate(opnd2); |
| case INTLT: |
| return evaluate(opnd1) < evaluate(opnd2); |
| case FILNT: |
| return newerf (opnd1, opnd2); |
| case FILOT: |
| return olderf (opnd1, opnd2); |
| case FILEQ: |
| return equalf (opnd1, opnd2); |
| } |
| } |
| t_wp--; |
| return strlen(opnd1) > 0; |
| } |
| |
| filstat(nm, mode) |
| char *nm; |
| { |
| struct stat s; |
| |
| switch (mode) { |
| case FILRD: |
| return access(nm, 4) == 0; |
| case FILWR: |
| return access(nm, 2) == 0; |
| case FILEX: |
| return access(nm, 1) == 0; |
| case FILREG: |
| return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFREG; |
| case FILID: |
| return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFDIR; |
| case FILCDEV: |
| return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFCHR; |
| case FILBDEV: |
| return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFBLK; |
| case FILFIFO: |
| #ifdef S_IFIFO |
| return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFIFO; |
| #else |
| return 0; |
| #endif |
| case FILSETU: |
| return stat(nm, &s) == 0 && (s.st_mode & S_ISUID) == S_ISUID; |
| case FILSETG: |
| return stat(nm, &s) == 0 && (s.st_mode & S_ISGID) == S_ISGID; |
| case FILSTCK: |
| return stat(nm, &s) == 0 && (s.st_mode & S_ISVTX) == S_ISVTX; |
| case FILGZ: |
| return stat(nm, &s) == 0 && s.st_size > 0L; |
| case FILTT: |
| return isatty(getn(nm)); |
| case FILUID: |
| return stat(nm, &s) == 0 && s.st_uid == geteuid(); |
| case FILGID: |
| return stat(nm, &s) == 0 && s.st_gid == getegid(); |
| #ifdef S_IFLNK |
| case FILSYM: |
| return lstat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFLNK; |
| #endif |
| #ifdef S_IFSOCK |
| case FILSOCK: |
| return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFSOCK; |
| #endif |
| default: |
| return 1; |
| } |
| } |
| |
| int |
| t_lex(s) |
| register char *s; |
| { |
| register struct t_op const *op = ops; |
| |
| if (s == 0) { |
| t_wp_op = (struct t_op *)0; |
| return EOI; |
| } |
| while (op->op_text) { |
| if (strcmp(s, op->op_text) == 0) { |
| t_wp_op = op; |
| return op->op_num; |
| } |
| op++; |
| } |
| t_wp_op = (struct t_op *)0; |
| return OPERAND; |
| } |
| |
| newerf (f1, f2) |
| char *f1, *f2; |
| { |
| struct stat b1, b2; |
| |
| return (stat (f1, &b1) == 0 && |
| stat (f2, &b2) == 0 && |
| b1.st_mtime > b2.st_mtime); |
| } |
| |
| olderf (f1, f2) |
| char *f1, *f2; |
| { |
| struct stat b1, b2; |
| |
| return (stat (f1, &b1) == 0 && |
| stat (f2, &b2) == 0 && |
| b1.st_mtime < b2.st_mtime); |
| } |
| |
| equalf (f1, f2) |
| char *f1, *f2; |
| { |
| struct stat b1, b2; |
| |
| return (stat (f1, &b1) == 0 && |
| stat (f2, &b2) == 0 && |
| b1.st_dev == b2.st_dev && |
| b1.st_ino == b2.st_ino); |
| } |
| |
| /* atoi with error detection */ |
| |
| getn(as) |
| char *as; |
| { |
| register char *s; |
| register int n; |
| |
| s = as; |
| if (*s == '-') |
| s++; |
| for (n = 0; *s >= '0' && *s <= '9'; s++) |
| n = (n*10) + (*s-'0'); |
| if (*s) |
| errorf("%s: bad number", as); |
| return (*as == '-') ? -n : n; |
| } |
| |