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