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