bin/test: Sync with FreeBSD
[dragonfly.git] / bin / test / test.c
CommitLineData
984263bc
MD
1/* $NetBSD: test.c,v 1.21 1999/04/05 09:48:38 kleink Exp $ */
2
b3967821 3/*-
984263bc
MD
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.
1de703da 11 *
b3967821 12 * $FreeBSD: src/bin/test/test.c,v 1.55 2010/03/28 13:16:08 ed Exp $
984263bc
MD
13 */
14
984263bc
MD
15#include <sys/types.h>
16#include <sys/stat.h>
17
18#include <ctype.h>
19#include <err.h>
20#include <errno.h>
b3967821 21#include <inttypes.h>
984263bc
MD
22#include <limits.h>
23#include <stdarg.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <unistd.h>
28
29#ifdef SHELL
30#define main testcmd
31#include "bltin/bltin.h"
99512ac4 32#include "error.h"
984263bc 33#else
b3967821
PA
34#include <locale.h>
35
36static void error(const char *, ...) __dead2 __printf0like(1, 2);
984263bc
MD
37
38static void
984263bc 39error(const char *msg, ...)
984263bc
MD
40{
41 va_list ap;
984263bc 42
984263bc 43 va_start(ap, msg);
984263bc
MD
44 verrx(2, msg, ap);
45 /*NOTREACHED*/
46 va_end(ap);
47}
48#endif
49
50/* test(1) accepts the following grammar:
51 oexpr ::= aexpr | aexpr "-o" oexpr ;
52 aexpr ::= nexpr | nexpr "-a" aexpr ;
53 nexpr ::= primary | "!" primary
54 primary ::= unary-operator operand
55 | operand binary-operator operand
56 | operand
57 | "(" oexpr ")"
58 ;
59 unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
60 "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";
61
62 binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
63 "-nt"|"-ot"|"-ef";
64 operand ::= <any legal UNIX file name>
65*/
66
67enum token {
68 EOI,
69 FILRD,
70 FILWR,
71 FILEX,
72 FILEXIST,
73 FILREG,
74 FILDIR,
75 FILCDEV,
76 FILBDEV,
77 FILFIFO,
78 FILSOCK,
79 FILSYM,
80 FILGZ,
81 FILTT,
82 FILSUID,
83 FILSGID,
84 FILSTCK,
85 FILNT,
86 FILOT,
87 FILEQ,
88 FILUID,
89 FILGID,
90 STREZ,
91 STRNZ,
92 STREQ,
93 STRNE,
94 STRLT,
95 STRGT,
96 INTEQ,
97 INTNE,
98 INTGE,
99 INTGT,
100 INTLE,
101 INTLT,
102 UNOT,
103 BAND,
104 BOR,
105 LPAREN,
106 RPAREN,
107 OPERAND
108};
109
110enum token_types {
111 UNOP,
112 BINOP,
113 BUNOP,
114 BBINOP,
115 PAREN
116};
117
118struct t_op {
119 const char *op_text;
120 short op_num, op_type;
121} const ops [] = {
122 {"-r", FILRD, UNOP},
123 {"-w", FILWR, UNOP},
124 {"-x", FILEX, UNOP},
125 {"-e", FILEXIST,UNOP},
126 {"-f", FILREG, UNOP},
127 {"-d", FILDIR, UNOP},
128 {"-c", FILCDEV,UNOP},
129 {"-b", FILBDEV,UNOP},
130 {"-p", FILFIFO,UNOP},
131 {"-u", FILSUID,UNOP},
132 {"-g", FILSGID,UNOP},
133 {"-k", FILSTCK,UNOP},
134 {"-s", FILGZ, UNOP},
135 {"-t", FILTT, UNOP},
136 {"-z", STREZ, UNOP},
137 {"-n", STRNZ, UNOP},
138 {"-h", FILSYM, UNOP}, /* for backwards compat */
139 {"-O", FILUID, UNOP},
140 {"-G", FILGID, UNOP},
141 {"-L", FILSYM, UNOP},
142 {"-S", FILSOCK,UNOP},
143 {"=", STREQ, BINOP},
144 {"!=", STRNE, BINOP},
145 {"<", STRLT, BINOP},
146 {">", STRGT, BINOP},
147 {"-eq", INTEQ, BINOP},
148 {"-ne", INTNE, BINOP},
149 {"-ge", INTGE, BINOP},
150 {"-gt", INTGT, BINOP},
151 {"-le", INTLE, BINOP},
152 {"-lt", INTLT, BINOP},
153 {"-nt", FILNT, BINOP},
154 {"-ot", FILOT, BINOP},
155 {"-ef", FILEQ, BINOP},
156 {"!", UNOT, BUNOP},
157 {"-a", BAND, BBINOP},
158 {"-o", BOR, BBINOP},
159 {"(", LPAREN, PAREN},
160 {")", RPAREN, PAREN},
161 {0, 0, 0}
162};
163
164struct t_op const *t_wp_op;
165int nargc;
166char **t_wp;
b3967821
PA
167int parenlevel;
168
169static int aexpr(enum token);
170static int binop(void);
171static int equalf(const char *, const char *);
172static int filstat(char *, enum token);
173static int getn(const char *);
174static intmax_t getq(const char *);
175static int intcmp(const char *, const char *);
176static int isunopoperand(void);
177static int islparenoperand(void);
178static int isrparenoperand(void);
179static int newerf(const char *, const char *);
180static int nexpr(enum token);
181static int oexpr(enum token);
182static int olderf(const char *, const char *);
183static int primary(enum token);
184static void syntax(const char *, const char *);
185static enum token t_lex(char *);
984263bc
MD
186
187int
b5744197 188main(int argc, char **argv)
984263bc
MD
189{
190 gid_t egid, gid;
191 uid_t euid, uid;
192 int res;
193 char *p;
194
17b61719 195 if ((p = strrchr(argv[0], '/')) == NULL)
984263bc
MD
196 p = argv[0];
197 else
198 p++;
199 if (strcmp(p, "[") == 0) {
200 if (strcmp(argv[--argc], "]") != 0)
201 error("missing ]");
202 argv[argc] = NULL;
203 }
204
205 /* no expression => false */
206 if (--argc <= 0)
207 return 1;
208
b3967821
PA
209#ifndef SHELL
210 setlocale(LC_CTYPE, "");
211#endif
984263bc
MD
212 /* XXX work around the absence of an eaccess(2) syscall */
213 egid = getegid();
214 euid = geteuid();
215 gid = getgid();
216 uid = getuid();
461f8894
EN
217 setregid(egid, gid);
218 setreuid(euid, uid);
984263bc
MD
219
220 nargc = argc;
221 t_wp = &argv[1];
b3967821
PA
222 parenlevel = 0;
223 if (nargc == 4 && strcmp(*t_wp, "!") == 0) {
224 /* Things like ! "" -o x do not fit in the normal grammar. */
225 --nargc;
226 ++t_wp;
227 res = oexpr(t_lex(*t_wp));
228 } else
229 res = !oexpr(t_lex(*t_wp));
984263bc
MD
230
231 if (--nargc > 0)
232 syntax(*t_wp, "unexpected operator");
461f8894
EN
233 setregid(gid, egid);
234 setreuid(uid, euid);
984263bc
MD
235
236 return res;
237}
238
239static void
b5744197 240syntax(const char *op, const char *msg)
984263bc
MD
241{
242
243 if (op && *op)
244 error("%s: %s", op, msg);
245 else
246 error("%s", msg);
247}
248
249static int
b5744197 250oexpr(enum token n)
984263bc
MD
251{
252 int res;
253
254 res = aexpr(n);
255 if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BOR)
256 return oexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) ||
257 res;
258 t_wp--;
259 nargc++;
260 return res;
261}
262
263static int
b5744197 264aexpr(enum token n)
984263bc
MD
265{
266 int res;
267
268 res = nexpr(n);
269 if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BAND)
270 return aexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) &&
271 res;
272 t_wp--;
273 nargc++;
274 return res;
275}
276
277static int
b5744197 278nexpr(enum token n)
984263bc
MD
279{
280 if (n == UNOT)
281 return !nexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL));
282 return primary(n);
283}
284
285static int
b5744197 286primary(enum token n)
984263bc
MD
287{
288 enum token nn;
289 int res;
290
291 if (n == EOI)
292 return 0; /* missing expression */
293 if (n == LPAREN) {
b3967821 294 parenlevel++;
984263bc 295 if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) ==
b3967821
PA
296 RPAREN) {
297 parenlevel--;
984263bc 298 return 0; /* missing expression */
b3967821 299 }
984263bc
MD
300 res = oexpr(nn);
301 if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN)
302 syntax(NULL, "closing paren expected");
b3967821 303 parenlevel--;
984263bc
MD
304 return res;
305 }
306 if (t_wp_op && t_wp_op->op_type == UNOP) {
307 /* unary expression */
308 if (--nargc == 0)
309 syntax(t_wp_op->op_text, "argument expected");
310 switch (n) {
311 case STREZ:
312 return strlen(*++t_wp) == 0;
313 case STRNZ:
314 return strlen(*++t_wp) != 0;
315 case FILTT:
316 return isatty(getn(*++t_wp));
317 default:
318 return filstat(*++t_wp, n);
319 }
320 }
321
322 if (t_lex(nargc > 0 ? t_wp[1] : NULL), t_wp_op && t_wp_op->op_type ==
323 BINOP) {
324 return binop();
325 }
326
327 return strlen(*t_wp) > 0;
328}
329
330static int
b5744197 331binop(void)
984263bc
MD
332{
333 const char *opnd1, *opnd2;
334 struct t_op const *op;
335
336 opnd1 = *t_wp;
461f8894 337 t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL);
984263bc
MD
338 op = t_wp_op;
339
340 if ((opnd2 = nargc > 0 ? (--nargc, *++t_wp) : NULL) == NULL)
341 syntax(op->op_text, "argument expected");
342
343 switch (op->op_num) {
344 case STREQ:
345 return strcmp(opnd1, opnd2) == 0;
346 case STRNE:
347 return strcmp(opnd1, opnd2) != 0;
348 case STRLT:
349 return strcmp(opnd1, opnd2) < 0;
350 case STRGT:
351 return strcmp(opnd1, opnd2) > 0;
352 case INTEQ:
353 return intcmp(opnd1, opnd2) == 0;
354 case INTNE:
355 return intcmp(opnd1, opnd2) != 0;
356 case INTGE:
357 return intcmp(opnd1, opnd2) >= 0;
358 case INTGT:
359 return intcmp(opnd1, opnd2) > 0;
360 case INTLE:
361 return intcmp(opnd1, opnd2) <= 0;
362 case INTLT:
363 return intcmp(opnd1, opnd2) < 0;
364 case FILNT:
365 return newerf (opnd1, opnd2);
366 case FILOT:
367 return olderf (opnd1, opnd2);
368 case FILEQ:
369 return equalf (opnd1, opnd2);
370 default:
371 abort();
372 /* NOTREACHED */
373 }
374}
375
376static int
b5744197 377filstat(char *nm, enum token mode)
984263bc
MD
378{
379 struct stat s;
380
381 if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s))
382 return 0;
383
384 switch (mode) {
385 case FILRD:
386 return access(nm, R_OK) == 0;
387 case FILWR:
388 return access(nm, W_OK) == 0;
389 case FILEX:
390 /* XXX work around access(2) false positives for superuser */
391 if (access(nm, X_OK) != 0)
392 return 0;
393 if (S_ISDIR(s.st_mode) || getuid() != 0)
394 return 1;
395 return (s.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0;
396 case FILEXIST:
397 return access(nm, F_OK) == 0;
398 case FILREG:
399 return S_ISREG(s.st_mode);
400 case FILDIR:
401 return S_ISDIR(s.st_mode);
402 case FILCDEV:
403 return S_ISCHR(s.st_mode);
404 case FILBDEV:
405 return S_ISBLK(s.st_mode);
406 case FILFIFO:
407 return S_ISFIFO(s.st_mode);
408 case FILSOCK:
409 return S_ISSOCK(s.st_mode);
410 case FILSYM:
411 return S_ISLNK(s.st_mode);
412 case FILSUID:
413 return (s.st_mode & S_ISUID) != 0;
414 case FILSGID:
415 return (s.st_mode & S_ISGID) != 0;
416 case FILSTCK:
417 return (s.st_mode & S_ISVTX) != 0;
418 case FILGZ:
419 return s.st_size > (off_t)0;
420 case FILUID:
421 return s.st_uid == geteuid();
422 case FILGID:
423 return s.st_gid == getegid();
424 default:
425 return 1;
426 }
427}
428
429static enum token
b5744197 430t_lex(char *s)
984263bc
MD
431{
432 struct t_op const *op = ops;
433
434 if (s == 0) {
435 t_wp_op = NULL;
436 return EOI;
437 }
438 while (op->op_text) {
439 if (strcmp(s, op->op_text) == 0) {
b3967821
PA
440 if (((op->op_type == UNOP || op->op_type == BUNOP)
441 && isunopoperand()) ||
442 (op->op_num == LPAREN && islparenoperand()) ||
443 (op->op_num == RPAREN && isrparenoperand()))
984263bc
MD
444 break;
445 t_wp_op = op;
446 return op->op_num;
447 }
448 op++;
449 }
450 t_wp_op = NULL;
451 return OPERAND;
452}
453
454static int
b3967821 455isunopoperand(void)
984263bc
MD
456{
457 struct t_op const *op = ops;
458 char *s;
459 char *t;
460
461 if (nargc == 1)
462 return 1;
984263bc 463 s = *(t_wp + 1);
b3967821
PA
464 if (nargc == 2)
465 return parenlevel == 1 && strcmp(s, ")") == 0;
984263bc
MD
466 t = *(t_wp + 2);
467 while (op->op_text) {
468 if (strcmp(s, op->op_text) == 0)
469 return op->op_type == BINOP &&
b3967821 470 (parenlevel == 0 || t[0] != ')' || t[1] != '\0');
984263bc
MD
471 op++;
472 }
473 return 0;
474}
475
b3967821
PA
476static int
477islparenoperand(void)
478{
479 struct t_op const *op = ops;
480 char *s;
481
482 if (nargc == 1)
483 return 1;
484 s = *(t_wp + 1);
485 if (nargc == 2)
486 return parenlevel == 1 && strcmp(s, ")") == 0;
487 if (nargc != 3)
488 return 0;
489 while (op->op_text) {
490 if (strcmp(s, op->op_text) == 0)
491 return op->op_type == BINOP;
492 op++;
493 }
494 return 0;
495}
496
497static int
498isrparenoperand(void)
499{
500 char *s;
501
502 if (nargc == 1)
503 return 0;
504 s = *(t_wp + 1);
505 if (nargc == 2)
506 return parenlevel == 1 && strcmp(s, ")") == 0;
507 return 0;
508}
509
984263bc
MD
510/* atoi with error detection */
511static int
b5744197 512getn(const char *s)
984263bc
MD
513{
514 char *p;
515 long r;
516
517 errno = 0;
518 r = strtol(s, &p, 10);
519
b3967821
PA
520 if (s == p)
521 error("%s: bad number", s);
522
984263bc
MD
523 if (errno != 0)
524 error((errno == EINVAL) ? "%s: bad number" :
525 "%s: out of range", s);
526
527 while (isspace((unsigned char)*p))
528 p++;
529
530 if (*p)
531 error("%s: bad number", s);
532
533 return (int) r;
534}
535
536/* atoi with error detection and 64 bit range */
b3967821
PA
537static intmax_t
538getq(const char *s)
984263bc
MD
539{
540 char *p;
b3967821 541 intmax_t r;
984263bc
MD
542
543 errno = 0;
b3967821
PA
544 r = strtoimax(s, &p, 10);
545
546 if (s == p)
547 error("%s: bad number", s);
984263bc
MD
548
549 if (errno != 0)
550 error((errno == EINVAL) ? "%s: bad number" :
551 "%s: out of range", s);
552
553 while (isspace((unsigned char)*p))
554 p++;
555
556 if (*p)
557 error("%s: bad number", s);
558
559 return r;
560}
561
562static int
b5744197 563intcmp (const char *s1, const char *s2)
984263bc 564{
b3967821 565 intmax_t q1, q2;
984263bc
MD
566
567
b3967821
PA
568 q1 = getq(s1);
569 q2 = getq(s2);
984263bc
MD
570
571 if (q1 > q2)
572 return 1;
573
574 if (q1 < q2)
575 return -1;
576
577 return 0;
578}
579
580static int
b5744197 581newerf (const char *f1, const char *f2)
984263bc
MD
582{
583 struct stat b1, b2;
584
585 if (stat(f1, &b1) != 0 || stat(f2, &b2) != 0)
586 return 0;
587
b3967821 588 if (b1.st_mtim.tv_sec > b2.st_mtim.tv_sec)
984263bc 589 return 1;
b3967821 590 if (b1.st_mtim.tv_sec < b2.st_mtim.tv_sec)
984263bc
MD
591 return 0;
592
b3967821 593 return (b1.st_mtim.tv_nsec > b2.st_mtim.tv_nsec);
984263bc
MD
594}
595
596static int
b5744197 597olderf (const char *f1, const char *f2)
984263bc
MD
598{
599 return (newerf(f2, f1));
600}
601
602static int
b5744197 603equalf (const char *f1, const char *f2)
984263bc
MD
604{
605 struct stat b1, b2;
606
607 return (stat (f1, &b1) == 0 &&
608 stat (f2, &b2) == 0 &&
609 b1.st_dev == b2.st_dev &&
610 b1.st_ino == b2.st_ino);
611}