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