static
void
check_line(int fd, const char *exp)
{
char *line = atf_utils_readline(fd);
ATF_CHECK(line != NULL);
ATF_CHECK_STREQ_MSG(exp, line, "read: '%s', expected: '%s'", line, exp);
free(line);
}
ATF_TC_BODY(isc_aes192, tc) {
UNUSED(tc);
aes_testcase_t testcases[] = {
/* Test 1 (KAT ECBVarTxt192 #3) */
{
"000000000000000000000000000000000000000000000000",
"F0000000000000000000000000000000",
"2A560364CE529EFC21788779568D5555"
},
/* Test 2 (KAT ECBVarTxt192 #123) */
{
"000000000000000000000000000000000000000000000000",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"2AABB999F43693175AF65C6C612C46FB"
},
/* Test 3 (KAT ECBVarKey192 #3) */
{
"F00000000000000000000000000000000000000000000000",
"00000000000000000000000000000000",
"180B09F267C45145DB2F826C2582D35C"
},
/* Test 4 (KAT ECBVarKey192 #187) */
{
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"00000000000000000000000000000000",
"EACF1E6C4224EFB38900B185AB1DFD42"
},
/* Test 5 (KAT ECBGFSbox192 #3) */
{
"000000000000000000000000000000000000000000000000",
"51719783D3185A535BD75ADC65071CE1",
"4F354592FF7C8847D2D0870CA9481B7C"
},
/* Test 6 (KAT ECBKeySbox192 #3) */
{
"CD62376D5EBB414917F0C78F05266433DC9192A1EC943300",
"00000000000000000000000000000000",
"7F6C25FF41858561BB62F36492E93C29"
},
{ NULL, NULL, NULL }
};
aes_testcase_t *testcase = testcases;
while (testcase->key != NULL) {
len = fromhexstr(testcase->key, key);
ATF_CHECK_EQ(len, ISC_AES192_KEYLENGTH);
len = fromhexstr(testcase->input, plaintext);
ATF_CHECK_EQ(len, ISC_AES_BLOCK_LENGTH);
isc_aes192_crypt(key, plaintext, ciphertext);
ATF_CHECK(tohexstr(ciphertext, str) == ISC_R_SUCCESS);
ATF_CHECK_STREQ(str, testcase->result);
testcase++;
}
}
ATF_TC_BODY(msgrcv_basic, tc)
{
struct msg msg1 = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
struct msg msg2 = { MSG_MTYPE_1, { 'x', 'y', 'z' } };
int id;
id = msgget(MSG_KEY, IPC_CREAT | 0600);
ATF_REQUIRE(id != -1);
(void)msgsnd(id, &msg1, sizeof(struct msg), IPC_NOWAIT);
(void)msgrcv(id, &msg2, sizeof(struct msg), MSG_MTYPE_1, IPC_NOWAIT);
ATF_CHECK(msg1.buf[0] == msg2.buf[0]);
ATF_CHECK(msg1.buf[1] == msg2.buf[1]);
ATF_CHECK(msg1.buf[2] == msg2.buf[2]);
ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
}
ATF_TC_BODY(isc_errno_toresult, tc) {
isc_result_t result, expect;
size_t i;
for (i = 0; i < sizeof(testpair)/sizeof(testpair[0]); i++) {
result = isc_errno_toresult(testpair[i].err);
expect = testpair[i].result;
ATF_CHECK(result == expect);
}
}
ATF_TC_BODY(cam_open_device_negative_test_O_RDONLY, tc)
{
const char *cam_test_device;
cam_test_device = get_cam_test_device(tc);
cam_clear_error();
ATF_CHECK(cam_open_device(cam_test_device, O_RDONLY) == NULL);
ATF_REQUIRE(cam_has_error());
}
ATF_TC_BODY(listen_unbound, tc)
{
int s, r;
s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
ATF_REQUIRE(s > 0);
r = listen(s, -1);
/* expect listen to fail since we haven't called bind(2) */
ATF_CHECK(r != 0);
}
ATF_TC_BODY(exec_umask, tc)
{
atf_check_result_t result;
atf_fs_path_t process_helpers;
const char *argv[3];
get_process_helpers_path(tc, false, &process_helpers);
argv[0] = atf_fs_path_cstring(&process_helpers);
argv[1] = "exit-success";
argv[2] = NULL;
umask(0222);
atf_error_t err = atf_check_exec_array(argv, &result);
ATF_CHECK(atf_is_error(err));
ATF_CHECK(atf_error_is(err, "invalid_umask"));
atf_error_free(err);
atf_fs_path_fini(&process_helpers);
}
ATF_TC_BODY(exec_cleanup, tc)
{
atf_fs_path_t out, err;
atf_check_result_t result;
bool exists;
do_exec(tc, "exit-success", &result);
RE(atf_fs_path_init_fmt(&out, "%s", atf_check_result_stdout(&result)));
RE(atf_fs_path_init_fmt(&err, "%s", atf_check_result_stderr(&result)));
RE(atf_fs_exists(&out, &exists)); ATF_CHECK(exists);
RE(atf_fs_exists(&err, &exists)); ATF_CHECK(exists);
atf_check_result_fini(&result);
RE(atf_fs_exists(&out, &exists)); ATF_CHECK(!exists);
RE(atf_fs_exists(&err, &exists)); ATF_CHECK(!exists);
atf_fs_path_fini(&err);
atf_fs_path_fini(&out);
}
ATF_TC_BODY(dispatchset_get, tc) {
isc_result_t result;
dns_dispatch_t *d1, *d2, *d3, *d4, *d5;
UNUSED(tc);
result = dns_test_begin(NULL, ISC_TRUE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = make_dispatchset(1);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
d1 = dns_dispatchset_get(dset);
d2 = dns_dispatchset_get(dset);
d3 = dns_dispatchset_get(dset);
d4 = dns_dispatchset_get(dset);
d5 = dns_dispatchset_get(dset);
ATF_CHECK_EQ(d1, d2);
ATF_CHECK_EQ(d2, d3);
ATF_CHECK_EQ(d3, d4);
ATF_CHECK_EQ(d4, d5);
teardown();
result = make_dispatchset(4);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
d1 = dns_dispatchset_get(dset);
d2 = dns_dispatchset_get(dset);
d3 = dns_dispatchset_get(dset);
d4 = dns_dispatchset_get(dset);
d5 = dns_dispatchset_get(dset);
ATF_CHECK_EQ(d1, d5);
ATF_CHECK(d1 != d2);
ATF_CHECK(d2 != d3);
ATF_CHECK(d3 != d4);
ATF_CHECK(d4 != d5);
teardown();
dns_test_end();
}
ATF_TC_BODY(memrchr_simple, tc)
{
char buf[] = "abcdabcd";
ATF_CHECK(memrchr(buf, 'a', 0) == NULL);
ATF_CHECK(memrchr(buf, 'g', 0) == NULL);
ATF_CHECK(memrchr(buf, 'x', 8) == NULL);
ATF_CHECK(memrchr("\0", 'x', 0) == NULL);
ATF_CHECK(memrchr("\0", 'x', 1) == NULL);
ATF_CHECK(memrchr(buf, 'a', 8) == buf + 4);
ATF_CHECK(memrchr(buf, 'b', 8) == buf + 5);
ATF_CHECK(memrchr(buf, 'c', 8) == buf + 6);
ATF_CHECK(memrchr(buf, 'd', 8) == buf + 7);
}
ATF_TC_BODY(uid_hash_rt29851, tc) {
unsigned char clientid1[] = { 0x0 };
unsigned char clientid2[] = { 0x0 };
unsigned char clientid3[] = { 0x0 };
int clientid1_len = 1;
int clientid2_len = 1;
int clientid3_len = 0;
struct lease *lease1 = 0, *lease2 = 0, *lease3 = 0;
dhcp_db_objects_setup ();
dhcp_common_objects_setup ();
ATF_CHECK(lease_id_new_hash(&lease_uid_hash, LEASE_HASH_SIZE, MDL));
ATF_CHECK(lease_allocate (&lease1, MDL) == ISC_R_SUCCESS);
ATF_CHECK(lease_allocate (&lease2, MDL) == ISC_R_SUCCESS);
ATF_CHECK(lease_allocate (&lease3, MDL) == ISC_R_SUCCESS);
lease1->uid = clientid1;
lease2->uid = clientid2;
lease3->uid = clientid3;
lease1->uid_len = clientid1_len;
lease2->uid_len = clientid2_len;
lease3->uid_len = clientid3_len;
uid_hash_add(lease1);
/* uid_hash_delete(lease2); // not necessary for actual issue repro */
uid_hash_add(lease3);
/* lease2->uid_len = 0; // not necessary for actual issue repro */
/* uid_hash_delete(lease2); // not necessary for actual issue repro */
/* uid_hash_delete(lease3); // not necessary for actual issue repro */
uid_hash_delete(lease1);
/* lease2->uid_len = 1; // not necessary for actual issue repro */
uid_hash_add(lease1);
uid_hash_delete(lease2);
}
ATF_TC_BODY(strtod_gherman_bug, tc)
{
const char *str =
"1.8254370818746402660437411213933955878019332885742187";
errno = 0;
volatile double d = strtod(str, NULL);
ATF_CHECK(d == 0x1.d34fd8378ea83p+0);
}
ATF_TC_BODY(strncat_simple, tc)
{
char buf[100] = "abcdefg";
ATF_CHECK(strncat(buf, "xxx", 0) == buf);
ATF_CHECK(strcmp(buf, "abcdefg") == 0);
ATF_CHECK(strncat(buf, "xxx", 1) == buf);
ATF_CHECK(strcmp(buf, "abcdefgx") == 0);
ATF_CHECK(strncat(buf, "xxx", 2) == buf);
ATF_CHECK(strcmp(buf, "abcdefgxxx") == 0);
ATF_CHECK(strncat(buf, "\0", 1) == buf);
ATF_CHECK(strcmp(buf, "abcdefgxxx") == 0);
}
static void
read_directory(const atf_tc_t *tc, const char *mp)
{
char buf[1024];
int fd, res;
ssize_t size;
FSTEST_ENTER();
fd = rump_sys_open(".", O_DIRECTORY | O_RDONLY, 0777);
ATF_REQUIRE(fd != -1);
size = rump_sys_pread(fd, buf, sizeof(buf), 0);
ATF_CHECK(size != -1 || errno == EISDIR);
size = rump_sys_read(fd, buf, sizeof(buf));
ATF_CHECK(size != -1 || errno == EISDIR);
res = rump_sys_close(fd);
ATF_REQUIRE(res != -1);
FSTEST_EXIT();
}
ATF_TC_BODY (status_coredump, tc)
{
struct rlimit rl;
rl.rlim_cur = RLIM_INFINITY;
rl.rlim_max = RLIM_INFINITY;
if (setrlimit (RLIMIT_CORE, &rl) == -1)
atf_tc_skip ("Cannot unlimit the core file size; check limits " "manually");
const int rawstatus = fork_and_wait_child (child_sigquit);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (!atf_process_status_exited (&s));
ATF_CHECK (atf_process_status_signaled (&s));
ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGQUIT);
ATF_CHECK (atf_process_status_coredump (&s));
atf_process_status_fini (&s);
}
ATF_TC_BODY(setrlimit_stack, tc)
{
struct rlimit res;
/* Ensure soft limit is not bigger than hard limit */
res.rlim_cur = res.rlim_max = 4192256;
ATF_REQUIRE(setrlimit(RLIMIT_STACK, &res) == 0);
ATF_REQUIRE(getrlimit(RLIMIT_STACK, &res) == 0);
ATF_CHECK(res.rlim_cur <= res.rlim_max);
}
ATF_TC_BODY(types_unsigned, tc)
{
fsblkcnt_t fb;
fsfilcnt_t ff;
size_t size;
rlim_t lim;
ino_t ino;
fb = 0;
ff = 0;
ino = 0;
lim = 0;
size = 0;
ATF_CHECK((fb - 1) > 0);
ATF_CHECK((ff - 1) > 0);
ATF_CHECK((ino - 1) > 0);
ATF_CHECK((lim - 1) > 0);
ATF_CHECK((size - 1) > 0);
}
ATF_TC_BODY(mkdtemp_err, tc)
{
atf_error_t err;
atf_fs_path_t p;
ATF_REQUIRE(mkdir("dir", 0555) != -1);
RE(atf_fs_path_init_fmt(&p, "dir/testdir.XXXXXX"));
err = atf_fs_mkdtemp(&p);
ATF_REQUIRE(atf_is_error(err));
ATF_REQUIRE(atf_error_is(err, "libc"));
ATF_CHECK_EQ(atf_libc_error_code(err), EACCES);
atf_error_free(err);
ATF_CHECK(!exists(&p));
ATF_CHECK(strcmp(atf_fs_path_cstring(&p), "dir/testdir.XXXXXX") == 0);
atf_fs_path_fini(&p);
}
ATF_TC_BODY (exec_list, tc)
{
atf_fs_path_t process_helpers;
atf_list_t argv;
atf_process_status_t status;
RE (atf_list_init (&argv));
get_process_helpers_path (tc, true, &process_helpers);
atf_list_append (&argv, strdup (atf_fs_path_cstring (&process_helpers)), true);
atf_list_append (&argv, strdup ("echo"), true);
atf_list_append (&argv, strdup ("test-message"), true);
{
atf_fs_path_t outpath;
atf_process_stream_t outsb;
RE (atf_fs_path_init_fmt (&outpath, "stdout"));
RE (atf_process_stream_init_redirect_path (&outsb, &outpath));
RE (atf_process_exec_list (&status, &process_helpers, &argv, &outsb, NULL));
atf_process_stream_fini (&outsb);
atf_fs_path_fini (&outpath);
}
atf_list_fini (&argv);
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), EXIT_SUCCESS);
{
int fd = open ("stdout", O_RDONLY);
ATF_CHECK (fd != -1);
check_line (fd, "test-message");
close (fd);
}
atf_process_status_fini (&status);
atf_fs_path_fini (&process_helpers);
}
static void capture_stream_fini (void *v)
{
struct capture_stream *s = v;
switch (s->m_base.m_type)
{
case stdout_type:
ATF_CHECK (grep_string (&s->m_msg, "stdout: msg"));
ATF_CHECK (!grep_string (&s->m_msg, "stderr: msg"));
break;
case stderr_type:
ATF_CHECK (!grep_string (&s->m_msg, "stdout: msg"));
ATF_CHECK (grep_string (&s->m_msg, "stderr: msg"));
break;
default:
UNREACHABLE;
}
atf_dynstr_fini (&s->m_msg);
atf_process_stream_fini (&s->m_base.m_sb);
}
ATF_TC_BODY (status_signaled, tc)
{
{
const int rawstatus = fork_and_wait_child (child_sigkill);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (!atf_process_status_exited (&s));
ATF_CHECK (atf_process_status_signaled (&s));
ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGKILL);
ATF_CHECK (!atf_process_status_coredump (&s));
atf_process_status_fini (&s);
}
{
const int rawstatus = fork_and_wait_child (child_sigterm);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (!atf_process_status_exited (&s));
ATF_CHECK (atf_process_status_signaled (&s));
ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGTERM);
ATF_CHECK (!atf_process_status_coredump (&s));
atf_process_status_fini (&s);
}
}
ATF_TC_BODY (fork_cookie, tc)
{
atf_process_stream_t outsb, errsb;
RE (atf_process_stream_init_inherit (&outsb));
RE (atf_process_stream_init_inherit (&errsb));
{
atf_process_child_t child;
atf_process_status_t status;
RE (atf_process_fork (&child, child_cookie, &outsb, &errsb, NULL));
RE (atf_process_child_wait (&child, &status));
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), exit_v_null);
atf_process_status_fini (&status);
}
{
atf_process_child_t child;
atf_process_status_t status;
int dummy_int;
RE (atf_process_fork (&child, child_cookie, &outsb, &errsb, &dummy_int));
RE (atf_process_child_wait (&child, &status));
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), exit_v_notnull);
atf_process_status_fini (&status);
}
atf_process_stream_fini (&errsb);
atf_process_stream_fini (&outsb);
}
ATF_TC_BODY(setenv_basic, tc)
{
const size_t numvars = 8192;
size_t i, offset;
char name[1024];
char value[1024];
offset = lrand48();
for (i = 0; i < numvars; i++) {
(void)snprintf(name, sizeof(name), "var%zu",
(i * 7 + offset) % numvars);
(void)snprintf(value, sizeof(value), "value%ld", lrand48());
ATF_CHECK(setenv(name, value, 1) != -1);
ATF_CHECK(setenv(name, "foo", 0) != -1);
ATF_CHECK_STREQ(getenv(name), value);
}
offset = lrand48();
for (i = 0; i < numvars; i++) {
(void)snprintf(name, sizeof(name), "var%zu",
(i * 11 + offset) % numvars);
ATF_CHECK(unsetenv(name) != -1);
ATF_CHECK(getenv(name) == NULL);
ATF_CHECK(unsetenv(name) != -1);
}
ATF_CHECK_ERRNO(EINVAL, setenv(NULL, "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("", "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("v=r", "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("var", NULL, 1) == -1);
ATF_CHECK(setenv("var", "=val", 1) == 0);
ATF_CHECK_STREQ(getenv("var"), "=val");
}
ATF_TC_BODY(wcscasecmp_same_len_buffers, tc)
{
ATF_REQUIRE(setlocale(LC_CTYPE, "C") != NULL);
ATF_CHECK(wcscasecmp(L"abc", L"xyz") < 0);
ATF_CHECK(wcscasecmp(L"ABC", L"xyz") < 0);
ATF_CHECK(wcscasecmp(L"abc", L"XYZ") < 0);
ATF_CHECK(wcscasecmp(L"ABC", L"XYZ") < 0);
ATF_CHECK(wcscasecmp(L"xyz", L"abc") > 0);
ATF_CHECK(wcscasecmp(L"XYZ", L"abc") > 0);
ATF_CHECK(wcscasecmp(L"xyz", L"ABC") > 0);
ATF_CHECK(wcscasecmp(L"XYZ", L"ABC") > 0);
}
ATF_TC_BODY(isc_file_sanitize, tc) {
isc_result_t result;
char buf[1024];
ATF_CHECK(chdir(TESTS) != -1);
result = isc_file_sanitize("testdata/file", NAME, "test", buf, 1024);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
ATF_CHECK(strcmp(buf, F(NAME)) == 0);
touch(F(TRUNC_SHA));
result = isc_file_sanitize("testdata/file", NAME, "test", buf, 1024);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
ATF_CHECK(strcmp(buf, F(TRUNC_SHA)) == 0);
touch(F(SHA));
result = isc_file_sanitize("testdata/file", NAME, "test", buf, 1024);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
ATF_CHECK(strcmp(buf, F(SHA)) == 0);
result = isc_file_sanitize("testdata/file", BAD1, "test", buf, 1024);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
ATF_CHECK(strcmp(buf, F(BADHASH1)) == 0);
result = isc_file_sanitize("testdata/file", BAD2, "test", buf, 1024);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
ATF_CHECK(strcmp(buf, F(BADHASH2)) == 0);
unlink(F(TRUNC_SHA));
unlink(F(SHA));
}
ATF_TC_BODY(ldexp_nan, tc)
{
const double x = 0.0L / 0.0L;
double y;
size_t i;
ATF_REQUIRE(isnan(x) != 0);
for (i = 0; i < __arraycount(exps); i++) {
y = ldexp(x, exps[i]);
ATF_CHECK(isnan(y) != 0);
}
}
ATF_TC_BODY(shutdown_send_sigpipe, tc)
{
int s;
const char *data = "data";
ssize_t ssize;
s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
ATF_CHECK(s >= 0);
ATF_CHECK_EQ(0, shutdown(s, SHUT_RDWR));
ATF_REQUIRE(SIG_ERR != signal(SIGPIPE, shutdown_send_sigpipe_handler));
ssize = send(s, data, sizeof(data), MSG_EOR);
ATF_CHECK_EQ(1, got_sigpipe);
}
ATF_TC_BODY(ldexpf_nan, tc)
{
const float x = 0.0L / 0.0L;
float y;
size_t i;
ATF_REQUIRE(isnan(x) != 0);
for (i = 0; i < __arraycount(exps); i++) {
y = ldexpf(x, exps[i]);
ATF_CHECK(isnan(y) != 0);
}
}
ATF_TC_BODY(clearenv_basic, tc)
{
char name[1024], value[1024];
for (size_t i = 0; i < 1024; i++) {
snprintf(name, sizeof(name), "crap%zu", i);
snprintf(value, sizeof(value), "%zu", i);
ATF_CHECK(setenv(name, value, 1) != -1);
}
*environ = NULL;
for (size_t i = 0; i < 1; i++) {
snprintf(name, sizeof(name), "crap%zu", i);
snprintf(value, sizeof(value), "%zu", i);
ATF_CHECK(setenv(name, value, 1) != -1);
}
ATF_CHECK_STREQ(getenv("crap0"), "0");
ATF_CHECK(getenv("crap1") == NULL);
ATF_CHECK(getenv("crap2") == NULL);
}
ATF_TC_BODY(grep_string, tc)
{
const char *str = "a string - aaaabbbb";
ATF_CHECK(atf_utils_grep_string("a string", str));
ATF_CHECK(atf_utils_grep_string("^a string", str));
ATF_CHECK(atf_utils_grep_string("aaaabbbb$", str));
ATF_CHECK(atf_utils_grep_string("a%s*bb", str, "a."));
ATF_CHECK(!atf_utils_grep_string("foo", str));
ATF_CHECK(!atf_utils_grep_string("bar", str));
ATF_CHECK(!atf_utils_grep_string("aaaaa", str));
}
