busybox/coreutils/test.c

/* vi: set sw=4 ts=4: */
/*
 * test implementation for busybox
 *
 * Copyright (c) by a whole pile of folks:
 *
 *     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).
 *     modified by J.T. Conklin for NetBSD.
 *     modified by Herbert Xu to be used as built-in in ash.
 *     modified by Erik Andersen <andersen@codepoet.org> to be used
 *     in busybox.
 *     modified by Bernhard Reutner-Fischer to be useable (i.e. a bit less bloaty).
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 *
 * Original copyright notice states:
 *     "This program is in the Public Domain."
 */

#include "libbb.h"
#include <setjmp.h>

/* This is a NOFORK applet. Be very careful! */

/* test_main() is called from shells, and we need to be extra careful here.
 * This is true regardless of PREFER_APPLETS and STANDALONE_SHELL
 * state. */


/* 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 TEST_DEBUG 0

enum token {
	EOI,
	FILRD,
	FILWR,
	FILEX,
	FILEXIST,
	FILREG,
	FILDIR,
	FILCDEV,
	FILBDEV,
	FILFIFO,
	FILSOCK,
	FILSYM,
	FILGZ,
	FILTT,
	FILSUID,
	FILSGID,
	FILSTCK,
	FILNT,
	FILOT,
	FILEQ,
	FILUID,
	FILGID,
	STREZ,
	STRNZ,
	STREQ,
	STRNE,
	STRLT,
	STRGT,
	INTEQ,
	INTNE,
	INTGE,
	INTGT,
	INTLE,
	INTLT,
	UNOT,
	BAND,
	BOR,
	LPAREN,
	RPAREN,
	OPERAND
};
#define is_int_op(a)      (((unsigned char)((a) - INTEQ)) <= 5)
#define is_str_op(a)      (((unsigned char)((a) - STREZ)) <= 5)
#define is_file_op(a)     (((unsigned char)((a) - FILNT)) <= 2)
#define is_file_access(a) (((unsigned char)((a) - FILRD)) <= 2)
#define is_file_type(a)   (((unsigned char)((a) - FILREG)) <= 5)
#define is_file_bit(a)    (((unsigned char)((a) - FILSUID)) <= 2)

#if TEST_DEBUG
int depth;
#define nest_msg(...) do { \
	depth++; \
	fprintf(stderr, "%*s", depth*2, ""); \
	fprintf(stderr, __VA_ARGS__); \
} while (0)
#define unnest_msg(...) do { \
	fprintf(stderr, "%*s", depth*2, ""); \
	fprintf(stderr, __VA_ARGS__); \
	depth--; \
} while (0)
#define dbg_msg(...) do { \
	fprintf(stderr, "%*s", depth*2, ""); \
	fprintf(stderr, __VA_ARGS__); \
} while (0)
#define unnest_msg_and_return(expr, ...) do { \
	number_t __res = (expr); \
	fprintf(stderr, "%*s", depth*2, ""); \
	fprintf(stderr, __VA_ARGS__, res); \
	depth--; \
	return __res; \
} while (0)
static const char *const TOKSTR[] = {
	"EOI",
	"FILRD",
	"FILWR",
	"FILEX",
	"FILEXIST",
	"FILREG",
	"FILDIR",
	"FILCDEV",
	"FILBDEV",
	"FILFIFO",
	"FILSOCK",
	"FILSYM",
	"FILGZ",
	"FILTT",
	"FILSUID",
	"FILSGID",
	"FILSTCK",
	"FILNT",
	"FILOT",
	"FILEQ",
	"FILUID",
	"FILGID",
	"STREZ",
	"STRNZ",
	"STREQ",
	"STRNE",
	"STRLT",
	"STRGT",
	"INTEQ",
	"INTNE",
	"INTGE",
	"INTGT",
	"INTLE",
	"INTLT",
	"UNOT",
	"BAND",
	"BOR",
	"LPAREN",
	"RPAREN",
	"OPERAND"
};
#else
#define nest_msg(...)   ((void)0)
#define unnest_msg(...) ((void)0)
#define dbg_msg(...)    ((void)0)
#define unnest_msg_and_return(expr, ...) return expr
#endif

enum token_types {
	UNOP,
	BINOP,
	BUNOP,
	BBINOP,
	PAREN
};

struct operator_t {
	char op_text[4];
	unsigned char op_num, op_type;
};

static const struct operator_t ops[] = {
	{ "-r", FILRD   , UNOP   },
	{ "-w", FILWR   , UNOP   },
	{ "-x", FILEX   , UNOP   },
	{ "-e", FILEXIST, UNOP   },
	{ "-f", FILREG  , UNOP   },
	{ "-d", FILDIR  , UNOP   },
	{ "-c", FILCDEV , UNOP   },
	{ "-b", FILBDEV , UNOP   },
	{ "-p", FILFIFO , UNOP   },
	{ "-u", FILSUID , UNOP   },
	{ "-g", FILSGID , UNOP   },
	{ "-k", FILSTCK , UNOP   },
	{ "-s", FILGZ   , UNOP   },
	{ "-t", FILTT   , UNOP   },
	{ "-z", STREZ   , UNOP   },
	{ "-n", STRNZ   , UNOP   },
	{ "-h", FILSYM  , UNOP   },    /* for backwards compat */

	{ "-O" , FILUID , UNOP   },
	{ "-G" , FILGID , UNOP   },
	{ "-L" , FILSYM , UNOP   },
	{ "-S" , FILSOCK, UNOP   },
	{ "="  , STREQ  , BINOP  },
	{ "==" , STREQ  , BINOP  },
	{ "!=" , STRNE  , BINOP  },
	{ "<"  , STRLT  , BINOP  },
	{ ">"  , STRGT  , 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  },
};


#if ENABLE_FEATURE_TEST_64
typedef int64_t number_t;
#else
typedef int number_t;
#endif


/* We try to minimize both static and stack usage. */
struct test_statics {
	char **args;
	/* set only by check_operator(), either to bogus struct
	 * or points to matching operator_t struct. Never NULL. */
	const struct operator_t *last_operator;
	gid_t *group_array;
	int ngroups;
	jmp_buf leaving;
};

/* See test_ptr_hack.c */
extern struct test_statics *const test_ptr_to_statics;

#define S (*test_ptr_to_statics)
#define args            (S.args         )
#define last_operator   (S.last_operator)
#define group_array     (S.group_array  )
#define ngroups         (S.ngroups      )
#define leaving         (S.leaving      )

#define INIT_S() do { \
	(*(struct test_statics**)&test_ptr_to_statics) = xzalloc(sizeof(S)); \
	barrier(); \
} while (0)
#define DEINIT_S() do { \
	free(test_ptr_to_statics); \
} while (0)

static number_t primary(enum token n);

static void syntax(const char *op, const char *msg) NORETURN;
static void syntax(const char *op, const char *msg)
{
	if (op && *op) {
		bb_error_msg("%s: %s", op, msg);
	} else {
		bb_error_msg("%s: %s"+4, msg);
	}
	longjmp(leaving, 2);
}

/* atoi with error detection */
//XXX: FIXME: duplicate of existing libbb function?
static number_t getn(const char *s)
{
	char *p;
#if ENABLE_FEATURE_TEST_64
	long long r;
#else
	long r;
#endif

	errno = 0;
#if ENABLE_FEATURE_TEST_64
	r = strtoll(s, &p, 10);
#else
	r = strtol(s, &p, 10);
#endif

	if (errno != 0)
		syntax(s, "out of range");

	if (*(skip_whitespace(p)))
		syntax(s, "bad number");

	return r;
}

/* UNUSED
static int newerf(const char *f1, const char *f2)
{
	struct stat b1, b2;

	return (stat(f1, &b1) == 0 &&
			stat(f2, &b2) == 0 && b1.st_mtime > b2.st_mtime);
}

static int olderf(const char *f1, const char *f2)
{
	struct stat b1, b2;

	return (stat(f1, &b1) == 0 &&
			stat(f2, &b2) == 0 && b1.st_mtime < b2.st_mtime);
}

static int equalf(const char *f1, const char *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);
}
*/


static enum token check_operator(char *s)
{
	static const struct operator_t no_op = {
		.op_num = -1,
		.op_type = -1
	};
	const struct operator_t *op;

	last_operator = &no_op;
	if (s == NULL) {
		return EOI;
	}

	op = ops;
	do {
		if (strcmp(s, op->op_text) == 0) {
			last_operator = op;
			return op->op_num;
		}
		op++;
	} while (op < ops + ARRAY_SIZE(ops));

	return OPERAND;
}


static int binop(void)
{
	const char *opnd1, *opnd2;
	const struct operator_t *op;
	number_t val1, val2;

	opnd1 = *args;
	check_operator(*++args);
	op = last_operator;

	opnd2 = *++args;
	if (opnd2 == NULL)
		syntax(op->op_text, "argument expected");

	if (is_int_op(op->op_num)) {
		val1 = getn(opnd1);
		val2 = getn(opnd2);
		if (op->op_num == INTEQ)
			return val1 == val2;
		if (op->op_num == INTNE)
			return val1 != val2;
		if (op->op_num == INTGE)
			return val1 >= val2;
		if (op->op_num == INTGT)
			return val1 >  val2;
		if (op->op_num == INTLE)
			return val1 <= val2;
		if (op->op_num == INTLT)
			return val1 <  val2;
	}
	if (is_str_op(op->op_num)) {
		val1 = strcmp(opnd1, opnd2);
		if (op->op_num == STREQ)
			return val1 == 0;
		if (op->op_num == STRNE)
			return val1 != 0;
		if (op->op_num == STRLT)
			return val1 < 0;
		if (op->op_num == STRGT)
			return val1 > 0;
	}
	/* We are sure that these three are by now the only binops we didn't check
	 * yet, so we do not check if the class is correct:
	 */
/*	if (is_file_op(op->op_num)) */
	{
		struct stat b1, b2;

		if (stat(opnd1, &b1) || stat(opnd2, &b2))
			return 0; /* false, since at least one stat failed */
		if (op->op_num == FILNT)
			return b1.st_mtime > b2.st_mtime;
		if (op->op_num == FILOT)
			return b1.st_mtime < b2.st_mtime;
		if (op->op_num == FILEQ)
			return b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino;
	}
	return 1; /* NOTREACHED */
}


static void initialize_group_array(void)
{
	ngroups = getgroups(0, NULL);
	if (ngroups > 0) {
		/* FIXME: ash tries so hard to not die on OOM,
		 * and we spoil it with just one xrealloc here */
		/* We realloc, because test_main can be entered repeatedly by shell.
		 * Testcase (ash): 'while true; do test -x some_file; done'
		 * and watch top. (some_file must have owner != you) */
		group_array = xrealloc(group_array, ngroups * sizeof(gid_t));
		getgroups(ngroups, group_array);
	}
}


/* Return non-zero if GID is one that we have in our groups list. */
//XXX: FIXME: duplicate of existing libbb function?
// see toplevel TODO file:
// possible code duplication ingroup() and is_a_group_member()
static int is_a_group_member(gid_t gid)
{
	int i;

	/* Short-circuit if possible, maybe saving a call to getgroups(). */
	if (gid == getgid() || gid == getegid())
		return 1;

	if (ngroups == 0)
		initialize_group_array();

	/* Search through the list looking for GID. */
	for (i = 0; i < ngroups; i++)
		if (gid == group_array[i])
			return 1;

	return 0;
}


/* Do the same thing access(2) does, but use the effective uid and gid,
   and don't make the mistake of telling root that any file is
   executable. */
static int test_eaccess(char *path, int mode)
{
	struct stat st;
	unsigned int euid = geteuid();

	if (stat(path, &st) < 0)
		return -1;

	if (euid == 0) {
		/* Root can read or write any file. */
		if (mode != X_OK)
			return 0;

		/* Root can execute any file that has any one of the execute
		   bits set. */
		if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
			return 0;
	}

	if (st.st_uid == euid)  /* owner */
		mode <<= 6;
	else if (is_a_group_member(st.st_gid))
		mode <<= 3;

	if (st.st_mode & mode)
		return 0;

	return -1;
}


static int filstat(char *nm, enum token mode)
{
	struct stat s;
	unsigned i = i; /* gcc 3.x thinks it can be used uninitialized */

	if (mode == FILSYM) {
#ifdef S_IFLNK
		if (lstat(nm, &s) == 0) {
			i = S_IFLNK;
			goto filetype;
		}
#endif
		return 0;
	}

	if (stat(nm, &s) != 0)
		return 0;
	if (mode == FILEXIST)
		return 1;
	if (is_file_access(mode)) {
		if (mode == FILRD)
			i = R_OK;
		if (mode == FILWR)
			i = W_OK;
		if (mode == FILEX)
			i = X_OK;
		return test_eaccess(nm, i) == 0;
	}
	if (is_file_type(mode)) {
		if (mode == FILREG)
			i = S_IFREG;
		if (mode == FILDIR)
			i = S_IFDIR;
		if (mode == FILCDEV)
			i = S_IFCHR;
		if (mode == FILBDEV)
			i = S_IFBLK;
		if (mode == FILFIFO) {
#ifdef S_IFIFO
			i = S_IFIFO;
#else
			return 0;
#endif
		}
		if (mode == FILSOCK) {
#ifdef S_IFSOCK
			i = S_IFSOCK;
#else
			return 0;
#endif
		}
 filetype:
		return ((s.st_mode & S_IFMT) == i);
	}
	if (is_file_bit(mode)) {
		if (mode == FILSUID)
			i = S_ISUID;
		if (mode == FILSGID)
			i = S_ISGID;
		if (mode == FILSTCK)
			i = S_ISVTX;
		return ((s.st_mode & i) != 0);
	}
	if (mode == FILGZ)
		return s.st_size > 0L;
	if (mode == FILUID)
		return s.st_uid == geteuid();
	if (mode == FILGID)
		return s.st_gid == getegid();
	return 1; /* NOTREACHED */
}


static number_t nexpr(enum token n)
{
	number_t res;

	nest_msg(">nexpr(%s)\n", TOKSTR[n]);
	if (n == UNOT) {
		res = !nexpr(check_operator(*++args));
		unnest_msg("<nexpr:%lld\n", res);
		return res;
	}
	res = primary(n);
	unnest_msg("<nexpr:%lld\n", res);
	return res;
}


static number_t aexpr(enum token n)
{
	number_t res;

	nest_msg(">aexpr(%s)\n", TOKSTR[n]);
	res = nexpr(n);
	dbg_msg("aexpr: nexpr:%lld, next args:%s\n", res, args[1]);
	if (check_operator(*++args) == BAND) {
		dbg_msg("aexpr: arg is AND, next args:%s\n", args[1]);
		res = aexpr(check_operator(*++args)) && res;
		unnest_msg("<aexpr:%lld\n", res);
		return res;
	}
	args--;
	unnest_msg("<aexpr:%lld, args:%s\n", res, args[0]);
	return res;
}


static number_t oexpr(enum token n)
{
	number_t res;

	nest_msg(">oexpr(%s)\n", TOKSTR[n]);
	res = aexpr(n);
	dbg_msg("oexpr: aexpr:%lld, next args:%s\n", res, args[1]);
	if (check_operator(*++args) == BOR) {
		dbg_msg("oexpr: next arg is OR, next args:%s\n", args[1]);
		res = oexpr(check_operator(*++args)) || res;
		unnest_msg("<oexpr:%lld\n", res);
		return res;
	}
	args--;
	unnest_msg("<oexpr:%lld, args:%s\n", res, args[0]);
	return res;
}


static number_t primary(enum token n)
{
#if TEST_DEBUG
	number_t res = res; /* for compiler */
#else
	number_t res;
#endif
	const struct operator_t *args0_op;

	nest_msg(">primary(%s)\n", TOKSTR[n]);
	if (n == EOI) {
		syntax(NULL, "argument expected");
	}
	if (n == LPAREN) {
		res = oexpr(check_operator(*++args));
		if (check_operator(*++args) != RPAREN)
			syntax(NULL, "closing paren expected");
		unnest_msg("<primary:%lld\n", res);
		return res;
	}

	/* coreutils 6.9 checks "is args[1] binop and args[2] exist?" first,
	 * do the same */
	args0_op = last_operator;
	/* last_operator = operator at args[1] */
	if (check_operator(args[1]) != EOI) { /* if args[1] != NULL */
		if (args[2]) {
			// coreutils also does this:
			// if (args[3] && args[0]="-l" && args[2] is BINOP)
			//	return binop(1 /* prepended by -l */);
			if (last_operator->op_type == BINOP)
				unnest_msg_and_return(binop(), "<primary: binop:%lld\n");
		}
	}
	/* check "is args[0] unop?" second */
	if (args0_op->op_type == UNOP) {
		/* unary expression */
		if (args[1] == NULL)
//			syntax(args0_op->op_text, "argument expected");
			goto check_emptiness;
		args++;
		if (n == STREZ)
			unnest_msg_and_return(args[0][0] == '\0', "<primary:%lld\n");
		if (n == STRNZ)
			unnest_msg_and_return(args[0][0] != '\0', "<primary:%lld\n");
		if (n == FILTT)
			unnest_msg_and_return(isatty(getn(*args)), "<primary: isatty(%s)%lld\n", *args);
		unnest_msg_and_return(filstat(*args, n), "<primary: filstat(%s):%lld\n", *args);
	}

	/*check_operator(args[1]); - already done */
	if (last_operator->op_type == BINOP) {
		/* args[2] is known to be NULL, isn't it bound to fail? */
		unnest_msg_and_return(binop(), "<primary:%lld\n");
	}
 check_emptiness:
	unnest_msg_and_return(args[0][0] != '\0', "<primary:%lld\n");
}


int test_main(int argc, char **argv)
{
	int res;
	const char *arg0;
//	bool negate = 0;

	arg0 = bb_basename(argv[0]);
	if (arg0[0] == '[') {
		--argc;
		if (!arg0[1]) { /* "[" ? */
			if (NOT_LONE_CHAR(argv[argc], ']')) {
				bb_error_msg("missing ]");
				return 2;
			}
		} else { /* assuming "[[" */
			if (strcmp(argv[argc], "]]") != 0) {
				bb_error_msg("missing ]]");
				return 2;
			}
		}
		argv[argc] = NULL;
	}

	/* We must do DEINIT_S() prior to returning */
	INIT_S();

	res = setjmp(leaving);
	if (res)
		goto ret;

	/* resetting ngroups is probably unnecessary.  it will
	 * force a new call to getgroups(), which prevents using
	 * group data fetched during a previous call.  but the
	 * only way the group data could be stale is if there's
	 * been an intervening call to setgroups(), and this
	 * isn't likely in the case of a shell.  paranoia
	 * prevails...
	 */
	ngroups = 0;

	//argc--;
	argv++;

	/* Implement special cases from POSIX.2, section 4.62.4 */
	if (!argv[0]) { /* "test" */
		res = 1;
		goto ret;
	}
#if 0
// Now it's fixed in the parser and should not be needed
	if (LONE_CHAR(argv[0], '!') && argv[1]) {
		negate = 1;
		//argc--;
		argv++;
	}
	if (!argv[1]) { /* "test [!] arg" */
		res = (*argv[0] == '\0');
		goto ret;
	}
	if (argv[2] && !argv[3]) {
		check_operator(argv[1]);
		if (last_operator->op_type == BINOP) {
			/* "test [!] arg1 <binary_op> arg2" */
			args = &argv[0];
			res = (binop() == 0);
			goto ret;
		}
	}

	/* Some complex expression. Undo '!' removal */
	if (negate) {
		negate = 0;
		//argc++;
		argv--;
	}
#endif
	args = &argv[0];
	res = !oexpr(check_operator(*args));

	if (*args != NULL && *++args != NULL) {
		/* TODO: example when this happens? */
		bb_error_msg("%s: unknown operand", *args);
		res = 2;
	}
 ret:
	DEINIT_S();
//	return negate ? !res : res;
	return res;
}
1	/* vi: set sw=4 ts=4: */
2	/*
3	* test implementation for busybox
4	*
5	* Copyright (c) by a whole pile of folks:
6	*
7	* test(1); version 7-like -- author Erik Baalbergen
8	* modified by Eric Gisin to be used as built-in.
9	* modified by Arnold Robbins to add SVR3 compatibility
10	* (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
11	* modified by J.T. Conklin for NetBSD.
12	* modified by Herbert Xu to be used as built-in in ash.
13	* modified by Erik Andersen <andersen@codepoet.org> to be used
14	* in busybox.
15	* modified by Bernhard Reutner-Fischer to be useable (i.e. a bit less bloaty).
16	*
17	* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
18	*
19	* Original copyright notice states:
20	* "This program is in the Public Domain."
21	*/
22
23	#include "libbb.h"
24	#include <setjmp.h>
25
26	/* This is a NOFORK applet. Be very careful! */
27
28	/* test_main() is called from shells, and we need to be extra careful here.
29	* This is true regardless of PREFER_APPLETS and STANDALONE_SHELL
30	* state. */
31
32
33	/* test(1) accepts the following grammar:
34	oexpr ::= aexpr \| aexpr "-o" oexpr ;
35	aexpr ::= nexpr \| nexpr "-a" aexpr ;
36	nexpr ::= primary \| "!" primary
37	primary ::= unary-operator operand
38	\| operand binary-operator operand
39	\| operand
40	\| "(" oexpr ")"
41	;
42	unary-operator ::= "-r"\|"-w"\|"-x"\|"-f"\|"-d"\|"-c"\|"-b"\|"-p"\|
43	"-u"\|"-g"\|"-k"\|"-s"\|"-t"\|"-z"\|"-n"\|"-o"\|"-O"\|"-G"\|"-L"\|"-S";
44
45	binary-operator ::= "="\|"=="\|"!="\|"-eq"\|"-ne"\|"-ge"\|"-gt"\|"-le"\|"-lt"\|
46	"-nt"\|"-ot"\|"-ef";
47	operand ::= <any legal UNIX file name>
48	*/
49
50	#define TEST_DEBUG 0
51
52	enum token {
53	EOI,
54	FILRD,
55	FILWR,
56	FILEX,
57	FILEXIST,
58	FILREG,
59	FILDIR,
60	FILCDEV,
61	FILBDEV,
62	FILFIFO,
63	FILSOCK,
64	FILSYM,
65	FILGZ,
66	FILTT,
67	FILSUID,
68	FILSGID,
69	FILSTCK,
70	FILNT,
71	FILOT,
72	FILEQ,
73	FILUID,
74	FILGID,
75	STREZ,
76	STRNZ,
77	STREQ,
78	STRNE,
79	STRLT,
80	STRGT,
81	INTEQ,
82	INTNE,
83	INTGE,
84	INTGT,
85	INTLE,
86	INTLT,
87	UNOT,
88	BAND,
89	BOR,
90	LPAREN,
91	RPAREN,
92	OPERAND
93	};
94	#define is_int_op(a) (((unsigned char)((a) - INTEQ)) <= 5)
95	#define is_str_op(a) (((unsigned char)((a) - STREZ)) <= 5)
96	#define is_file_op(a) (((unsigned char)((a) - FILNT)) <= 2)
97	#define is_file_access(a) (((unsigned char)((a) - FILRD)) <= 2)
98	#define is_file_type(a) (((unsigned char)((a) - FILREG)) <= 5)
99	#define is_file_bit(a) (((unsigned char)((a) - FILSUID)) <= 2)
100
101	#if TEST_DEBUG
102	int depth;
103	#define nest_msg(...) do { \
104	depth++; \
105	fprintf(stderr, "%s", depth2, ""); \
106	fprintf(stderr, __VA_ARGS__); \
107	} while (0)
108	#define unnest_msg(...) do { \
109	fprintf(stderr, "%s", depth2, ""); \
110	fprintf(stderr, __VA_ARGS__); \
111	depth--; \
112	} while (0)
113	#define dbg_msg(...) do { \
114	fprintf(stderr, "%s", depth2, ""); \
115	fprintf(stderr, __VA_ARGS__); \
116	} while (0)
117	#define unnest_msg_and_return(expr, ...) do { \
118	number_t __res = (expr); \
119	fprintf(stderr, "%s", depth2, ""); \
120	fprintf(stderr, __VA_ARGS__, res); \
121	depth--; \
122	return __res; \
123	} while (0)
124	static const char *const TOKSTR[] = {
125	"EOI",
126	"FILRD",
127	"FILWR",
128	"FILEX",
129	"FILEXIST",
130	"FILREG",
131	"FILDIR",
132	"FILCDEV",
133	"FILBDEV",
134	"FILFIFO",
135	"FILSOCK",
136	"FILSYM",
137	"FILGZ",
138	"FILTT",
139	"FILSUID",
140	"FILSGID",
141	"FILSTCK",
142	"FILNT",
143	"FILOT",
144	"FILEQ",
145	"FILUID",
146	"FILGID",
147	"STREZ",
148	"STRNZ",
149	"STREQ",
150	"STRNE",
151	"STRLT",
152	"STRGT",
153	"INTEQ",
154	"INTNE",
155	"INTGE",
156	"INTGT",
157	"INTLE",
158	"INTLT",
159	"UNOT",
160	"BAND",
161	"BOR",
162	"LPAREN",
163	"RPAREN",
164	"OPERAND"
165	};
166	#else
167	#define nest_msg(...) ((void)0)
168	#define unnest_msg(...) ((void)0)
169	#define dbg_msg(...) ((void)0)
170	#define unnest_msg_and_return(expr, ...) return expr
171	#endif
172
173	enum token_types {
174	UNOP,
175	BINOP,
176	BUNOP,
177	BBINOP,
178	PAREN
179	};
180
181	struct operator_t {
182	char op_text[4];
183	unsigned char op_num, op_type;
184	};
185
186	static const struct operator_t ops[] = {
187	{ "-r", FILRD , UNOP },
188	{ "-w", FILWR , UNOP },
189	{ "-x", FILEX , UNOP },
190	{ "-e", FILEXIST, UNOP },
191	{ "-f", FILREG , UNOP },
192	{ "-d", FILDIR , UNOP },
193	{ "-c", FILCDEV , UNOP },
194	{ "-b", FILBDEV , UNOP },
195	{ "-p", FILFIFO , UNOP },
196	{ "-u", FILSUID , UNOP },
197	{ "-g", FILSGID , UNOP },
198	{ "-k", FILSTCK , UNOP },
199	{ "-s", FILGZ , UNOP },
200	{ "-t", FILTT , UNOP },
201	{ "-z", STREZ , UNOP },
202	{ "-n", STRNZ , UNOP },
203	{ "-h", FILSYM , UNOP }, /* for backwards compat */
204
205	{ "-O" , FILUID , UNOP },
206	{ "-G" , FILGID , UNOP },
207	{ "-L" , FILSYM , UNOP },
208	{ "-S" , FILSOCK, UNOP },
209	{ "=" , STREQ , BINOP },
210	{ "==" , STREQ , BINOP },
211	{ "!=" , STRNE , BINOP },
212	{ "<" , STRLT , BINOP },
213	{ ">" , STRGT , BINOP },
214	{ "-eq", INTEQ , BINOP },
215	{ "-ne", INTNE , BINOP },
216	{ "-ge", INTGE , BINOP },
217	{ "-gt", INTGT , BINOP },
218	{ "-le", INTLE , BINOP },
219	{ "-lt", INTLT , BINOP },
220	{ "-nt", FILNT , BINOP },
221	{ "-ot", FILOT , BINOP },
222	{ "-ef", FILEQ , BINOP },
223	{ "!" , UNOT , BUNOP },
224	{ "-a" , BAND , BBINOP },
225	{ "-o" , BOR , BBINOP },
226	{ "(" , LPAREN , PAREN },
227	{ ")" , RPAREN , PAREN },
228	};
229
230
231	#if ENABLE_FEATURE_TEST_64
232	typedef int64_t number_t;
233	#else
234	typedef int number_t;
235	#endif
236
237
238	/* We try to minimize both static and stack usage. */
239	struct test_statics {
240	char **args;
241	/* set only by check_operator(), either to bogus struct
242	* or points to matching operator_t struct. Never NULL. */
243	const struct operator_t *last_operator;
244	gid_t *group_array;
245	int ngroups;
246	jmp_buf leaving;
247	};
248
249	/* See test_ptr_hack.c */
250	extern struct test_statics *const test_ptr_to_statics;
251
252	#define S (*test_ptr_to_statics)
253	#define args (S.args )
254	#define last_operator (S.last_operator)
255	#define group_array (S.group_array )
256	#define ngroups (S.ngroups )
257	#define leaving (S.leaving )
258
259	#define INIT_S() do { \
260	((struct test_statics*)&test_ptr_to_statics) = xzalloc(sizeof(S)); \
261	barrier(); \
262	} while (0)
263	#define DEINIT_S() do { \
264	free(test_ptr_to_statics); \
265	} while (0)
266
267	static number_t primary(enum token n);
268
269	static void syntax(const char op, const char msg) NORETURN;
270	static void syntax(const char op, const char msg)
271	{
272	if (op && *op) {
273	bb_error_msg("%s: %s", op, msg);
274	} else {
275	bb_error_msg("%s: %s"+4, msg);
276	}
277	longjmp(leaving, 2);
278	}
279
280	/* atoi with error detection */
281	//XXX: FIXME: duplicate of existing libbb function?
282	static number_t getn(const char *s)
283	{
284	char *p;
285	#if ENABLE_FEATURE_TEST_64
286	long long r;
287	#else
288	long r;
289	#endif
290
291	errno = 0;
292	#if ENABLE_FEATURE_TEST_64
293	r = strtoll(s, &p, 10);
294	#else
295	r = strtol(s, &p, 10);
296	#endif
297
298	if (errno != 0)
299	syntax(s, "out of range");
300
301	if (*(skip_whitespace(p)))
302	syntax(s, "bad number");
303
304	return r;
305	}
306
307	/* UNUSED
308	static int newerf(const char f1, const char f2)
309	{
310	struct stat b1, b2;
311
312	return (stat(f1, &b1) == 0 &&
313	stat(f2, &b2) == 0 && b1.st_mtime > b2.st_mtime);
314	}
315
316	static int olderf(const char f1, const char f2)
317	{
318	struct stat b1, b2;
319
320	return (stat(f1, &b1) == 0 &&
321	stat(f2, &b2) == 0 && b1.st_mtime < b2.st_mtime);
322	}
323
324	static int equalf(const char f1, const char f2)
325	{
326	struct stat b1, b2;
327
328	return (stat(f1, &b1) == 0 &&
329	stat(f2, &b2) == 0 &&
330	b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino);
331	}
332	*/
333
334
335	static enum token check_operator(char *s)
336	{
337	static const struct operator_t no_op = {
338	.op_num = -1,
339	.op_type = -1
340	};
341	const struct operator_t *op;
342
343	last_operator = &no_op;
344	if (s == NULL) {
345	return EOI;
346	}
347
348	op = ops;
349	do {
350	if (strcmp(s, op->op_text) == 0) {
351	last_operator = op;
352	return op->op_num;
353	}
354	op++;
355	} while (op < ops + ARRAY_SIZE(ops));
356
357	return OPERAND;
358	}
359
360
361	static int binop(void)
362	{
363	const char opnd1, opnd2;
364	const struct operator_t *op;
365	number_t val1, val2;
366
367	opnd1 = *args;
368	check_operator(*++args);
369	op = last_operator;
370
371	opnd2 = *++args;
372	if (opnd2 == NULL)
373	syntax(op->op_text, "argument expected");
374
375	if (is_int_op(op->op_num)) {
376	val1 = getn(opnd1);
377	val2 = getn(opnd2);
378	if (op->op_num == INTEQ)
379	return val1 == val2;
380	if (op->op_num == INTNE)
381	return val1 != val2;
382	if (op->op_num == INTGE)
383	return val1 >= val2;
384	if (op->op_num == INTGT)
385	return val1 > val2;
386	if (op->op_num == INTLE)
387	return val1 <= val2;
388	if (op->op_num == INTLT)
389	return val1 < val2;
390	}
391	if (is_str_op(op->op_num)) {
392	val1 = strcmp(opnd1, opnd2);
393	if (op->op_num == STREQ)
394	return val1 == 0;
395	if (op->op_num == STRNE)
396	return val1 != 0;
397	if (op->op_num == STRLT)
398	return val1 < 0;
399	if (op->op_num == STRGT)
400	return val1 > 0;
401	}
402	/* We are sure that these three are by now the only binops we didn't check
403	* yet, so we do not check if the class is correct:
404	*/
405	/* if (is_file_op(op->op_num)) */
406	{
407	struct stat b1, b2;
408
409	if (stat(opnd1, &b1) \|\| stat(opnd2, &b2))
410	return 0; /* false, since at least one stat failed */
411	if (op->op_num == FILNT)
412	return b1.st_mtime > b2.st_mtime;
413	if (op->op_num == FILOT)
414	return b1.st_mtime < b2.st_mtime;
415	if (op->op_num == FILEQ)
416	return b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino;
417	}
418	return 1; /* NOTREACHED */
419	}
420
421
422	static void initialize_group_array(void)
423	{
424	ngroups = getgroups(0, NULL);
425	if (ngroups > 0) {
426	/* FIXME: ash tries so hard to not die on OOM,
427	* and we spoil it with just one xrealloc here */
428	/* We realloc, because test_main can be entered repeatedly by shell.
429	* Testcase (ash): 'while true; do test -x some_file; done'
430	* and watch top. (some_file must have owner != you) */
431	group_array = xrealloc(group_array, ngroups * sizeof(gid_t));
432	getgroups(ngroups, group_array);
433	}
434	}
435
436
437	/* Return non-zero if GID is one that we have in our groups list. */
438	//XXX: FIXME: duplicate of existing libbb function?
439	// see toplevel TODO file:
440	// possible code duplication ingroup() and is_a_group_member()
441	static int is_a_group_member(gid_t gid)
442	{
443	int i;
444
445	/* Short-circuit if possible, maybe saving a call to getgroups(). */
446	if (gid == getgid() \|\| gid == getegid())
447	return 1;
448
449	if (ngroups == 0)
450	initialize_group_array();
451
452	/* Search through the list looking for GID. */
453	for (i = 0; i < ngroups; i++)
454	if (gid == group_array[i])
455	return 1;
456
457	return 0;
458	}
459
460
461	/* Do the same thing access(2) does, but use the effective uid and gid,
462	and don't make the mistake of telling root that any file is
463	executable. */
464	static int test_eaccess(char *path, int mode)
465	{
466	struct stat st;
467	unsigned int euid = geteuid();
468
469	if (stat(path, &st) < 0)
470	return -1;
471
472	if (euid == 0) {
473	/* Root can read or write any file. */
474	if (mode != X_OK)
475	return 0;
476
477	/* Root can execute any file that has any one of the execute
478	bits set. */
479	if (st.st_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH))
480	return 0;
481	}
482
483	if (st.st_uid == euid) /* owner */
484	mode <<= 6;
485	else if (is_a_group_member(st.st_gid))
486	mode <<= 3;
487
488	if (st.st_mode & mode)
489	return 0;
490
491	return -1;
492	}
493
494
495	static int filstat(char *nm, enum token mode)
496	{
497	struct stat s;
498	unsigned i = i; /* gcc 3.x thinks it can be used uninitialized */
499
500	if (mode == FILSYM) {
501	#ifdef S_IFLNK
502	if (lstat(nm, &s) == 0) {
503	i = S_IFLNK;
504	goto filetype;
505	}
506	#endif
507	return 0;
508	}
509
510	if (stat(nm, &s) != 0)
511	return 0;
512	if (mode == FILEXIST)
513	return 1;
514	if (is_file_access(mode)) {
515	if (mode == FILRD)
516	i = R_OK;
517	if (mode == FILWR)
518	i = W_OK;
519	if (mode == FILEX)
520	i = X_OK;
521	return test_eaccess(nm, i) == 0;
522	}
523	if (is_file_type(mode)) {
524	if (mode == FILREG)
525	i = S_IFREG;
526	if (mode == FILDIR)
527	i = S_IFDIR;
528	if (mode == FILCDEV)
529	i = S_IFCHR;
530	if (mode == FILBDEV)
531	i = S_IFBLK;
532	if (mode == FILFIFO) {
533	#ifdef S_IFIFO
534	i = S_IFIFO;
535	#else
536	return 0;
537	#endif
538	}
539	if (mode == FILSOCK) {
540	#ifdef S_IFSOCK
541	i = S_IFSOCK;
542	#else
543	return 0;
544	#endif
545	}
546	filetype:
547	return ((s.st_mode & S_IFMT) == i);
548	}
549	if (is_file_bit(mode)) {
550	if (mode == FILSUID)
551	i = S_ISUID;
552	if (mode == FILSGID)
553	i = S_ISGID;
554	if (mode == FILSTCK)
555	i = S_ISVTX;
556	return ((s.st_mode & i) != 0);
557	}
558	if (mode == FILGZ)
559	return s.st_size > 0L;
560	if (mode == FILUID)
561	return s.st_uid == geteuid();
562	if (mode == FILGID)
563	return s.st_gid == getegid();
564	return 1; /* NOTREACHED */
565	}
566
567
568	static number_t nexpr(enum token n)
569	{
570	number_t res;
571
572	nest_msg(">nexpr(%s)\n", TOKSTR[n]);
573	if (n == UNOT) {
574	res = !nexpr(check_operator(*++args));
575	unnest_msg("<nexpr:%lld\n", res);
576	return res;
577	}
578	res = primary(n);
579	unnest_msg("<nexpr:%lld\n", res);
580	return res;
581	}
582
583
584	static number_t aexpr(enum token n)
585	{
586	number_t res;
587
588	nest_msg(">aexpr(%s)\n", TOKSTR[n]);
589	res = nexpr(n);
590	dbg_msg("aexpr: nexpr:%lld, next args:%s\n", res, args[1]);
591	if (check_operator(*++args) == BAND) {
592	dbg_msg("aexpr: arg is AND, next args:%s\n", args[1]);
593	res = aexpr(check_operator(*++args)) && res;
594	unnest_msg("<aexpr:%lld\n", res);
595	return res;
596	}
597	args--;
598	unnest_msg("<aexpr:%lld, args:%s\n", res, args[0]);
599	return res;
600	}
601
602
603	static number_t oexpr(enum token n)
604	{
605	number_t res;
606
607	nest_msg(">oexpr(%s)\n", TOKSTR[n]);
608	res = aexpr(n);
609	dbg_msg("oexpr: aexpr:%lld, next args:%s\n", res, args[1]);
610	if (check_operator(*++args) == BOR) {
611	dbg_msg("oexpr: next arg is OR, next args:%s\n", args[1]);
612	res = oexpr(check_operator(*++args)) \|\| res;
613	unnest_msg("<oexpr:%lld\n", res);
614	return res;
615	}
616	args--;
617	unnest_msg("<oexpr:%lld, args:%s\n", res, args[0]);
618	return res;
619	}
620
621
622	static number_t primary(enum token n)
623	{
624	#if TEST_DEBUG
625	number_t res = res; /* for compiler */
626	#else
627	number_t res;
628	#endif
629	const struct operator_t *args0_op;
630
631	nest_msg(">primary(%s)\n", TOKSTR[n]);
632	if (n == EOI) {
633	syntax(NULL, "argument expected");
634	}
635	if (n == LPAREN) {
636	res = oexpr(check_operator(*++args));
637	if (check_operator(*++args) != RPAREN)
638	syntax(NULL, "closing paren expected");
639	unnest_msg("<primary:%lld\n", res);
640	return res;
641	}
642
643	/* coreutils 6.9 checks "is args[1] binop and args[2] exist?" first,
644	* do the same */
645	args0_op = last_operator;
646	/* last_operator = operator at args[1] */
647	if (check_operator(args[1]) != EOI) { /* if args[1] != NULL */
648	if (args[2]) {
649	// coreutils also does this:
650	// if (args[3] && args[0]="-l" && args[2] is BINOP)
651	// return binop(1 /* prepended by -l */);
652	if (last_operator->op_type == BINOP)
653	unnest_msg_and_return(binop(), "<primary: binop:%lld\n");
654	}
655	}
656	/* check "is args[0] unop?" second */
657	if (args0_op->op_type == UNOP) {
658	/* unary expression */
659	if (args[1] == NULL)
660	// syntax(args0_op->op_text, "argument expected");
661	goto check_emptiness;
662	args++;
663	if (n == STREZ)
664	unnest_msg_and_return(args[0][0] == '\0', "<primary:%lld\n");
665	if (n == STRNZ)
666	unnest_msg_and_return(args[0][0] != '\0', "<primary:%lld\n");
667	if (n == FILTT)
668	unnest_msg_and_return(isatty(getn(args)), "<primary: isatty(%s)%lld\n", args);
669	unnest_msg_and_return(filstat(args, n), "<primary: filstat(%s):%lld\n", args);
670	}
671
672	/check_operator(args[1]); - already done /
673	if (last_operator->op_type == BINOP) {
674	/* args[2] is known to be NULL, isn't it bound to fail? */
675	unnest_msg_and_return(binop(), "<primary:%lld\n");
676	}
677	check_emptiness:
678	unnest_msg_and_return(args[0][0] != '\0', "<primary:%lld\n");
679	}
680
681
682	int test_main(int argc, char **argv)
683	{
684	int res;
685	const char *arg0;
686	// bool negate = 0;
687
688	arg0 = bb_basename(argv[0]);
689	if (arg0[0] == '[') {
690	--argc;
691	if (!arg0[1]) { /* "[" ? */
692	if (NOT_LONE_CHAR(argv[argc], ']')) {
693	bb_error_msg("missing ]");
694	return 2;
695	}
696	} else { /* assuming "[[" */
697	if (strcmp(argv[argc], "]]") != 0) {
698	bb_error_msg("missing ]]");
699	return 2;
700	}
701	}
702	argv[argc] = NULL;
703	}
704
705	/* We must do DEINIT_S() prior to returning */
706	INIT_S();
707
708	res = setjmp(leaving);
709	if (res)
710	goto ret;
711
712	/* resetting ngroups is probably unnecessary. it will
713	* force a new call to getgroups(), which prevents using
714	* group data fetched during a previous call. but the
715	* only way the group data could be stale is if there's
716	* been an intervening call to setgroups(), and this
717	* isn't likely in the case of a shell. paranoia
718	* prevails...
719	*/
720	ngroups = 0;
721
722	//argc--;
723	argv++;
724
725	/* Implement special cases from POSIX.2, section 4.62.4 */
726	if (!argv[0]) { /* "test" */
727	res = 1;
728	goto ret;
729	}
730	#if 0
731	// Now it's fixed in the parser and should not be needed
732	if (LONE_CHAR(argv[0], '!') && argv[1]) {
733	negate = 1;
734	//argc--;
735	argv++;
736	}
737	if (!argv[1]) { /* "test [!] arg" */
738	res = (*argv[0] == '\0');
739	goto ret;
740	}
741	if (argv[2] && !argv[3]) {
742	check_operator(argv[1]);
743	if (last_operator->op_type == BINOP) {
744	/* "test [!] arg1 <binary_op> arg2" */
745	args = &argv[0];
746	res = (binop() == 0);
747	goto ret;
748	}
749	}
750
751	/* Some complex expression. Undo '!' removal */
752	if (negate) {
753	negate = 0;
754	//argc++;
755	argv--;
756	}
757	#endif
758	args = &argv[0];
759	res = !oexpr(check_operator(*args));
760
761	if (args != NULL && ++args != NULL) {
762	/* TODO: example when this happens? */
763	bb_error_msg("%s: unknown operand", *args);
764	res = 2;
765	}
766	ret:
767	DEINIT_S();
768	// return negate ? !res : res;
769	return res;
770	}