/* libminijail_unittest.c
 * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 *
 * Test platform independent logic of Minijail.
 */

#include <errno.h>

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>

#include "test_harness.h"

#include "libminijail-private.h"
#include "libminijail.h"
#include "util.h"

#if defined(__ANDROID__)
const char *kShellPath = "/system/bin/sh";
#else
const char *kShellPath = "/bin/sh";
#endif

/* Prototypes needed only by test. */
void *consumebytes(size_t length, char **buf, size_t *buflength);
char *consumestr(char **buf, size_t *buflength);

/* Silence unused variable warnings. */
TEST(silence_unused)
{
	EXPECT_STREQ(kLdPreloadEnvVar, kLdPreloadEnvVar);
	EXPECT_STREQ(kFdEnvVar, kFdEnvVar);
	EXPECT_STRNE(kFdEnvVar, kLdPreloadEnvVar);
}

TEST(consumebytes_zero)
{
	char buf[1024];
	size_t len = sizeof(buf);
	char *pos = &buf[0];
	EXPECT_NE(NULL, consumebytes(0, &pos, &len));
	EXPECT_EQ(&buf[0], pos);
	EXPECT_EQ(sizeof(buf), len);
}

TEST(consumebytes_exact)
{
	char buf[1024];
	size_t len = sizeof(buf);
	char *pos = &buf[0];
	/* One past the end since it consumes the whole buffer. */
	char *end = &buf[sizeof(buf)];
	EXPECT_NE(NULL, consumebytes(len, &pos, &len));
	EXPECT_EQ((size_t)0, len);
	EXPECT_EQ(end, pos);
}

TEST(consumebytes_half)
{
	char buf[1024];
	size_t len = sizeof(buf);
	char *pos = &buf[0];
	/* One past the end since it consumes the whole buffer. */
	char *end = &buf[sizeof(buf) / 2];
	EXPECT_NE(NULL, consumebytes(len / 2, &pos, &len));
	EXPECT_EQ(sizeof(buf) / 2, len);
	EXPECT_EQ(end, pos);
}

TEST(consumebytes_toolong)
{
	char buf[1024];
	size_t len = sizeof(buf);
	char *pos = &buf[0];
	/* One past the end since it consumes the whole buffer. */
	EXPECT_EQ(NULL, consumebytes(len + 1, &pos, &len));
	EXPECT_EQ(sizeof(buf), len);
	EXPECT_EQ(&buf[0], pos);
}

TEST(consumestr_zero)
{
	char buf[1024];
	size_t len = 0;
	char *pos = &buf[0];
	memset(buf, 0xff, sizeof(buf));
	EXPECT_EQ(NULL, consumestr(&pos, &len));
	EXPECT_EQ((size_t)0, len);
	EXPECT_EQ(&buf[0], pos);
}

TEST(consumestr_nonul)
{
	char buf[1024];
	size_t len = sizeof(buf);
	char *pos = &buf[0];
	memset(buf, 0xff, sizeof(buf));
	EXPECT_EQ(NULL, consumestr(&pos, &len));
	EXPECT_EQ(sizeof(buf), len);
	EXPECT_EQ(&buf[0], pos);
}

TEST(consumestr_full)
{
	char buf[1024];
	size_t len = sizeof(buf);
	char *pos = &buf[0];
	memset(buf, 0xff, sizeof(buf));
	buf[sizeof(buf) - 1] = '\0';
	EXPECT_EQ((void *)buf, consumestr(&pos, &len));
	EXPECT_EQ((size_t)0, len);
	EXPECT_EQ(&buf[sizeof(buf)], pos);
}

TEST(consumestr_trailing_nul)
{
	char buf[1024];
	size_t len = sizeof(buf) - 1;
	char *pos = &buf[0];
	memset(buf, 0xff, sizeof(buf));
	buf[sizeof(buf) - 1] = '\0';
	EXPECT_EQ(NULL, consumestr(&pos, &len));
	EXPECT_EQ(sizeof(buf) - 1, len);
	EXPECT_EQ(&buf[0], pos);
}

FIXTURE(marshal)
{
	char buf[4096];
	struct minijail *m;
	struct minijail *j;
	size_t size;
};

FIXTURE_SETUP(marshal)
{
	self->m = minijail_new();
	self->j = minijail_new();
	ASSERT_TRUE(self->m && self->j) TH_LOG("allocation failed");
	self->size = minijail_size(self->m);
	ASSERT_GT(sizeof(self->buf), self->size)
	{
		TH_LOG("static buffer too small for test");
	}
}

FIXTURE_TEARDOWN(marshal)
{
	minijail_destroy(self->m);
	minijail_destroy(self->j);
}

TEST_F(marshal, empty)
{
	ASSERT_EQ(0, minijail_marshal(self->m, self->buf, sizeof(self->buf)));
	EXPECT_EQ(0, minijail_unmarshal(self->j, self->buf, self->size));
}

TEST_F(marshal, 0xff)
{
	memset(self->buf, 0xff, sizeof(self->buf));
	/* Should fail on the first consumestr since a NUL will never be found.
	 */
	EXPECT_EQ(-EINVAL,
		  minijail_unmarshal(self->j, self->buf, sizeof(self->buf)));
}

TEST(test_minijail_run_pid_pipes_no_preload)
{
	pid_t pid;
	int child_stdin, child_stdout, child_stderr;
	int mj_run_ret;
	ssize_t write_ret, read_ret;
	const size_t buf_len = 128;
	char buf[buf_len];
	int status;
#if defined(__ANDROID__)
	char filename[] = "/system/bin/cat";
#else
	char filename[] = "/bin/cat";
#endif
	char teststr[] = "test\n";
	size_t teststr_len = strlen(teststr);
	char *argv[4];

	struct minijail *j = minijail_new();

	argv[0] = filename;
	argv[1] = NULL;
	mj_run_ret = minijail_run_pid_pipes_no_preload(
	    j, argv[0], argv, &pid, &child_stdin, &child_stdout, NULL);
	EXPECT_EQ(mj_run_ret, 0);

	write_ret = write(child_stdin, teststr, teststr_len);
	EXPECT_EQ(write_ret, (int)teststr_len);

	read_ret = read(child_stdout, buf, 8);
	EXPECT_EQ(read_ret, (int)teststr_len);
	buf[teststr_len] = 0;
	EXPECT_EQ(strcmp(buf, teststr), 0);

	EXPECT_EQ(kill(pid, SIGTERM), 0);
	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFSIGNALED(status));
	EXPECT_EQ(WTERMSIG(status), SIGTERM);

	argv[0] = (char *)kShellPath;
	argv[1] = "-c";
	argv[2] = "echo test >&2";
	argv[3] = NULL;
	mj_run_ret = minijail_run_pid_pipes_no_preload(
	    j, argv[0], argv, &pid, &child_stdin, &child_stdout, &child_stderr);
	EXPECT_EQ(mj_run_ret, 0);

	read_ret = read(child_stderr, buf, buf_len);
	EXPECT_GE(read_ret, (int)teststr_len);

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFEXITED(status));
	EXPECT_EQ(WEXITSTATUS(status), 0);

	minijail_destroy(j);
}

TEST(test_minijail_no_fd_leaks)
{
	pid_t pid;
	int child_stdout;
	int mj_run_ret;
	ssize_t read_ret;
	const size_t buf_len = 128;
	char buf[buf_len];
	char script[buf_len];
	int status;
	char *argv[4];

	int dev_null = open("/dev/null", O_RDONLY);
	ASSERT_NE(dev_null, -1);
	snprintf(script, sizeof(script),
		 "[ -e /proc/self/fd/%d ] && echo yes || echo no", dev_null);

	struct minijail *j = minijail_new();

	argv[0] = (char *)kShellPath;
	argv[1] = "-c";
	argv[2] = script;
	argv[3] = NULL;
	mj_run_ret = minijail_run_pid_pipes_no_preload(
	    j, argv[0], argv, &pid, NULL, &child_stdout, NULL);
	EXPECT_EQ(mj_run_ret, 0);

	read_ret = read(child_stdout, buf, buf_len);
	EXPECT_GE(read_ret, 0);
	buf[read_ret] = '\0';
	EXPECT_STREQ(buf, "yes\n");

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFEXITED(status));
	EXPECT_EQ(WEXITSTATUS(status), 0);

	minijail_close_open_fds(j);
	mj_run_ret = minijail_run_pid_pipes_no_preload(
	    j, argv[0], argv, &pid, NULL, &child_stdout, NULL);
	EXPECT_EQ(mj_run_ret, 0);

	read_ret = read(child_stdout, buf, buf_len);
	EXPECT_GE(read_ret, 0);
	buf[read_ret] = '\0';
	EXPECT_STREQ(buf, "no\n");

	waitpid(pid, &status, 0);
	ASSERT_TRUE(WIFEXITED(status));
	EXPECT_EQ(WEXITSTATUS(status), 0);

	minijail_destroy(j);

	close(dev_null);
}

TEST_HARNESS_MAIN