# -*- Autotest -*-
AT_BANNER([problem data])
## ---------------- ##
## problem_data_add ##
## ---------------- ##
AT_TESTFUN([problem_data_add],
[[
#include "problem_data.h"
#include "internal_libreport.h"
#include <assert.h>
#define TEST_NAME "package"
#define TEST_CONTENTS "libreport"
#define TEST_FLAGS (CD_FLAG_TXT | CD_FLAG_ISNOTEDITABLE | CD_FLAG_UNIXTIME)
int main(int argc, char **argv)
{
g_verbose = 3;
problem_data_t *data = problem_data_new();
problem_data_add(data, TEST_NAME, TEST_CONTENTS, TEST_FLAGS);
struct problem_item *itm = problem_data_get_item_or_NULL(data, TEST_NAME);
assert(strcmp(itm->content, TEST_CONTENTS) == 0);
assert(itm->flags == TEST_FLAGS);
assert(itm->size == PROBLEM_ITEM_UNINITIALIZED_SIZE);
problem_data_free(data);
return 0;
}
]])
## -------------------- ##
## problem_data_add_ext ##
## -------------------- ##
AT_TESTFUN([problem_data_add_ext],
[[
#include "problem_data.h"
#include "internal_libreport.h"
#include <assert.h>
#define TEST_NAME "package"
#define TEST_CONTENTS "libreport"
#define TEST_FLAGS (CD_FLAG_TXT | CD_FLAG_ISNOTEDITABLE | CD_FLAG_UNIXTIME)
int main(int argc, char **argv)
{
g_verbose = 3;
problem_data_t *data = problem_data_new();
struct problem_item *itm = problem_data_add_ext(data, TEST_NAME, TEST_CONTENTS, TEST_FLAGS, strlen(TEST_CONTENTS));
struct problem_item *found = problem_data_get_item_or_NULL(data, TEST_NAME);
assert(itm == found);
assert(strcmp(itm->content, TEST_CONTENTS) == 0);
assert(itm->flags == TEST_FLAGS);
assert(itm->size == strlen(TEST_CONTENTS));
problem_data_free(data);
return 0;
}
]])
## ---------------------- ##
## problem_item_get_size ##
## ---------------------- ##
AT_TESTFUN([problem_item_get_size],
[[
#include "problem_data.h"
#include "internal_libreport.h"
#include <assert.h>
int main(int argc, char **argv)
{
g_verbose = 3;
problem_data_t *data = problem_data_new();
{
struct problem_item *itm = problem_data_add_ext(data, "1", "foo", CD_FLAG_TXT | CD_FLAG_ISNOTEDITABLE, PROBLEM_ITEM_UNINITIALIZED_SIZE);
const size_t old_size = strlen(itm->content);
{
size_t current_size = PROBLEM_ITEM_UNINITIALIZED_SIZE;
assert(problem_item_get_size(itm, ¤t_size) == 0);
assert(current_size != PROBLEM_ITEM_UNINITIALIZED_SIZE);
assert(current_size == old_size);
}
{
free(itm->content);
itm->content = NULL;
size_t current_size = PROBLEM_ITEM_UNINITIALIZED_SIZE;
assert(problem_item_get_size(itm, ¤t_size) == 0);
assert(current_size != PROBLEM_ITEM_UNINITIALIZED_SIZE);
assert(current_size == old_size);
}
}
{
char flnm[] = "/tmp/libreport.unittest.XXXXXXX";
int flds = mkstemp(flnm);
assert(flds >= 0);
/* sizeof(flnm) is strlen + '\0' */
assert(write(flds, flnm, strlen(flnm)) == strlen(flnm));
fsync(flds);
struct stat buf;
assert(fstat(flds, &buf) == 0);
assert(buf.st_size != 0);
size_t old_size = buf.st_size;
struct problem_item *itm = problem_data_add_ext(data, "2", flnm, CD_FLAG_BIN, PROBLEM_ITEM_UNINITIALIZED_SIZE);
{
size_t current_size = PROBLEM_ITEM_UNINITIALIZED_SIZE;
assert(problem_item_get_size(itm, ¤t_size) == 0);
assert(current_size != PROBLEM_ITEM_UNINITIALIZED_SIZE);
assert(current_size == old_size);
}
{
close(flds);
unlink(flnm);
assert(stat(flnm, &buf) != 0);
size_t current_size = PROBLEM_ITEM_UNINITIALIZED_SIZE;
assert(problem_item_get_size(itm, ¤t_size) == 0);
assert(current_size != PROBLEM_ITEM_UNINITIALIZED_SIZE);
assert(current_size == old_size);
}
}
problem_data_free(data);
return 0;
}
]])
## ------------------------------- ##
## problem_data_load_from_dump_dir ##
## ------------------------------- ##
AT_TESTFUN([problem_data_load_from_dump_dir],
[[
#include "problem_data.h"
#include "internal_libreport.h"
#include <assert.h>
int main(int argc, char **argv)
{
g_verbose = 3;
char template[] = "/tmp/XXXXXX";
if (mkdtemp(template) == NULL) {
perror("mkdtemp()");
return EXIT_FAILURE;
}
printf("Dump dir path: %s\n", template);
struct dump_dir *dd = dd_create(template, (uid_t)-1, 0640);
assert(dd != NULL || !"Cannot create new dump directory");
/* dd_create_basic_files() should create these files:
FILENAME_TIME, FILENAME_LAST_OCCURRENCE, FILENAME_UID, FILENAME_KERNEL,
FILENAME_ARCHITECTURE, FILENAME_HOSTNAME, FILENAME_OS_INFO, FILENAME_OS_RELEASE
*/
dd_create_basic_files(dd, geteuid(), NULL);
dd_save_text(dd, FILENAME_TYPE, "attest");
dd_save_text(dd, FILENAME_ANALYZER, "attest-problem_data");
dd_save_text(dd, FILENAME_DUPHASH, "0123456789ABCDEF");
dd_save_text(dd, FILENAME_UUID, "FEDCBA9876543210");
dd_save_text(dd, FILENAME_USERNAME, "perhaps_tester");
dd_save_text(dd, FILENAME_PACKAGE, "1:attest-1.1-3.x86_64");
dd_save_text(dd, FILENAME_PKG_EPOCH, "1");
dd_save_text(dd, FILENAME_PKG_NAME, "attest");
dd_save_text(dd, FILENAME_PKG_VERSION, "1.1");
dd_save_text(dd, FILENAME_PKG_RELEASE, "3");
dd_save_text(dd, FILENAME_PKG_ARCH, "x86_64");
dd_save_text(dd, FILENAME_CMDLINE, "$TESTSUITE.DIR/$NUM/problem_data_load_from_dump_dir foo blah");
dd_save_text(dd, FILENAME_EXECUTABLE, "$TESTSUITE.DIR/$NUM/problem_data_load_from_dump_dir");
dd_save_text(dd, FILENAME_ROOTDIR, "/");
dd_save_text(dd, FILENAME_PWD, "$TESTSUITE.DIR");
dd_save_text(dd, FILENAME_PID, "12345");
dd_save_text(dd, FILENAME_GLOBAL_PID, "12345");
dd_save_text(dd, FILENAME_TID, "12345");
dd_save_text(dd, FILENAME_COUNT, "1");
dd_save_text(dd, FILENAME_REASON, "Unit testing problem_data_load_from_dump_dir");
dd_save_text(dd, FILENAME_COMMENT, "Random comment");
dd_save_text(dd, FILENAME_BACKTRACE, "Pseudo-backtrace");
dd_save_text(dd, FILENAME_OPEN_FDS, "Opened FDs");
dd_save_text(dd, FILENAME_MAPS, "/proc/[pid]/maps");
dd_save_text(dd, FILENAME_SMAPS, "/proc/[pid]/smaps");
dd_save_text(dd, FILENAME_ENVIRON, "/proc/[pid]/environ");
dd_save_text(dd, FILENAME_LIMITS, "/proc/[pid]/limits");
dd_save_text(dd, FILENAME_CGROUP, "/proc/[pid]/cgroup");
dd_save_text(dd, FILENAME_PROC_PID_STATUS, "/proc/[pid]/status");
dd_save_text(dd, FILENAME_MOUNTINFO, "/proc/[pid]/mountinfo");
dd_save_text(dd, FILENAME_CRASH_FUNCTION, "main");
dd_save_text(dd, FILENAME_REMOTE, "0");
dd_save_text(dd, FILENAME_RATING, "4");
dd_save_text(dd, FILENAME_EXPLOITABLE, "6");
dd_save_text(dd, FILENAME_TAINTED, "Not tainted");
dd_save_text(dd, FILENAME_TAINTED_SHORT, "Not tainted");
dd_save_text(dd, FILENAME_TAINTED_LONG, "Not tainted");
dd_save_text(dd, FILENAME_NOT_REPORTABLE, "Despite 'not tainted' this problem cannot be reported.");
dd_save_text(dd, FILENAME_REPORTED_TO, "Bugzilla: URL=https://bugzilla.redhat.com/1000000");
dd_save_text(dd, FILENAME_EVENT_LOG, "--- report_Bugzilla has finished successfully ---");
dd_save_text(dd, FILENAME_KICKSTART_CFG, "kickstart.cfg");
dd_save_text(dd, FILENAME_ANACONDA_TB, "anaconda.tb");
dd_save_text(dd, FILENAME_NAMESPACES, "FILENAME_NAMESPACES");
dd_save_text(dd, FILENAME_OS_INFO_IN_ROOTDIR, "FILENAME_OS_INFO_IN_ROOTDIR");
dd_save_text(dd, FILENAME_OS_RELEASE_IN_ROOTDIR, "FILENAME_OS_RELEASE_IN_ROOTDIR");
dd_save_text(dd, FILENAME_KERNEL_LOG, "FILENAME_KERNEL_LOG");
dd_save_text(dd, FILENAME_DESCRIPTION, "FILENAME_DESCRIPTION");
dd_save_text(dd, FILENAME_CORE_BACKTRACE, "FILENAME_CORE_BACKTRACE");
dd_save_text(dd, FILENAME_REMOTE_RESULT, "FILENAME_REMOTE_RESULT");
dd_save_text(dd, FILENAME_ABRT_VERSION, "FILENAME_ABRT_VERSION");
dd_save_text(dd, FILENAME_CONTAINER, "FILENAME_CONTAINER");
dd_save_text(dd, FILENAME_CONTAINER_ID, "FILENAME_CONTAINER_ID");
dd_save_text(dd, FILENAME_CONTAINER_UUID, "FILENAME_CONTAINER_UUID");
dd_save_text(dd, FILENAME_CONTAINER_IMAGE, "FILENAME_CONTAINER_IMAGE");
dd_save_text(dd, FILENAME_CONTAINER_CMDLINE, "FILENAME_CONTAINER_CMDLINE");
dd_save_text(dd, FILENAME_DOCKER_INSPECT, "FILENAME_DOCKER_INSPECT");
dd_save_text(dd, "attestsuite-random-file", "random content");
dd_save_text(dd, "attestsuite-oneliner-newline", "newline\n");
dd_save_text(dd, "attestsuite-newline-followed", "newline\nfollowed");
dd_save_text(dd, "attestsuite-multi-line", "newline\nextra\n");
dd_save_text(dd, "attestsuite-tab", "tab\ttab");
dd_save_text(dd, "attestsuite-cr", "cr\rcr");
char buffer[1024*3];
memset(buffer, 'x', sizeof(buffer));
{
int fd4k = openat(dd->dd_fd, "attestsuite-over4k", O_WRONLY | O_CREAT | O_TRUNC, 0550);
assert(fd4k >= 0);
full_write(fd4k, buffer, sizeof(buffer));
full_write(fd4k, buffer, sizeof(buffer));
close(fd4k);
}
{
int bigfd = openat(dd->dd_fd, "attestsuite-bigtext", O_WRONLY | O_CREAT | O_TRUNC, 0550);
assert(bigfd >= 0);
for (int i = 3000; i > 0; --i)
full_write(bigfd, buffer, sizeof(buffer));
close(bigfd);
}
dd_copy_file(dd, FILENAME_BINARY, "/usr/bin/sh");
dd_copy_file(dd, FILENAME_COREDUMP, "/usr/bin/sh");
dd_copy_file(dd, FILENAME_VMCORE, "/usr/bin/sh");
static const char *const list_elements[] = { FILENAME_UID, FILENAME_PACKAGE,
FILENAME_CMDLINE, FILENAME_TIME, FILENAME_COUNT, FILENAME_REASON };
static const char *const editable_files[] = { FILENAME_COMMENT, FILENAME_BACKTRACE,
FILENAME_REASON, FILENAME_OPEN_FDS, FILENAME_CMDLINE, FILENAME_MAPS,
FILENAME_SMAPS, FILENAME_ENVIRON, FILENAME_HOSTNAME, FILENAME_REMOTE,
FILENAME_KICKSTART_CFG, FILENAME_ANACONDA_TB, FILENAME_CONTAINER_CMDLINE,
FILENAME_MOUNTINFO};
static const char *const binary_files[] = { FILENAME_BINARY, FILENAME_COREDUMP,
FILENAME_VMCORE, };
problem_data_t *pd = problem_data_new();
problem_data_load_from_dump_dir(pd, dd, /*excluding*/NULL);
GHashTableIter pd_iter;
char *element_name;
struct problem_item *item;
g_hash_table_iter_init(&pd_iter, pd);
while (g_hash_table_iter_next(&pd_iter, (void**)&element_name, (void**)&item))
{
printf("Testing element : %s\n", element_name);
size_t i;
for (i = 0; i < ARRAY_SIZE(list_elements); ++i)
{
if (strcmp(element_name, list_elements[i]) == 0)
{
assert((item->flags & CD_FLAG_LIST));
break;
}
}
if (i == ARRAY_SIZE(list_elements))
assert(!(item->flags & CD_FLAG_LIST));
for (i = 0; i < ARRAY_SIZE(editable_files); ++i)
{
if (strcmp(element_name, editable_files[i]) == 0)
{
assert((item->flags & CD_FLAG_ISEDITABLE) && !(item->flags & CD_FLAG_ISNOTEDITABLE));
break;
}
}
if (i == ARRAY_SIZE(editable_files))
assert(!(item->flags & CD_FLAG_ISEDITABLE) && (item->flags & CD_FLAG_ISNOTEDITABLE));
for (i = 0; i < ARRAY_SIZE(binary_files); ++i)
{
if (strcmp(element_name, binary_files[i]) == 0)
{
assert((item->flags & CD_FLAG_BIN) && !(item->flags & CD_FLAG_TXT) && !(item->flags & CD_FLAG_BIGTXT));
break;
}
}
if (i == ARRAY_SIZE(binary_files))
{
if(strstr(element_name, "bigtext") == 0)
assert((item->flags & CD_FLAG_TXT) && !(item->flags & CD_FLAG_BIN) && !(item->flags & CD_FLAG_BIGTXT));
else
assert((item->flags & CD_FLAG_BIGTXT) && (item->flags & CD_FLAG_BIN) && !(item->flags & CD_FLAG_TXT));
}
if (strcmp(element_name, FILENAME_TIME) == 0)
assert(item->flags & CD_FLAG_UNIXTIME);
else
assert(!(item->flags & CD_FLAG_UNIXTIME));
}
{
char *cnt = problem_data_get_content_or_NULL(pd, "attestsuite-oneliner-newline");
assert(cnt != NULL && "attestsuite-oneliner-newline");
assert(strcmp(cnt, "newline") == 0);
}
{
char *cnt = problem_data_get_content_or_NULL(pd, "attestsuite-newline-followed");
assert(cnt != NULL && "attestsuite-newline-followed");
assert(strcmp(cnt, "newline\nfollowed") == 0);
}
{
char *cnt = problem_data_get_content_or_NULL(pd, "attestsuite-multi-line");
assert(cnt != NULL && "attestsuite-multi-line");
assert(strcmp(cnt, "newline\nextra\n") == 0);
}
{
char *cnt = problem_data_get_content_or_NULL(pd, "attestsuite-over4k");
assert(cnt != NULL && "attestsuite-over4k");
assert(strlen(cnt) == (2 * sizeof(buffer)));
}
{
char *cnt = problem_data_get_content_or_NULL(pd, "attestsuite-tab");
assert(cnt != NULL && "attestsuite-tab");
assert(strcmp(cnt, "tab\ttab") == 0);
}
{
char *cnt = problem_data_get_content_or_NULL(pd, "attestsuite-cr");
assert(cnt != NULL && "attestsuite-cr");
assert(strcmp(cnt, "cr[0D]cr") == 0);
}
return 0;
}
]])
## ---------------------------------- ##
## problem_data_load_dump_dir_element ##
## ---------------------------------- ##
AT_TESTFUN([problem_data_load_dump_dir_element],
[[
#include "problem_data.h"
#include "internal_libreport.h"
#include <assert.h>
void test(struct dump_dir *dd, const char *path, const char *exp_content, int exp_flags, int exp_retval)
{
char *content = NULL;
int flags = -1;
int fd = -1;
int retval = problem_data_load_dump_dir_element(dd, path, &content, &flags, &fd);
fprintf(stderr, "'%-20s' -> retval = %10i, flags=%8x, fd=%10d, content='%s'\n", path, retval, flags, fd, content);
if (retval != 0)
assert(fd == -1);
assert(exp_retval == retval);
assert(exp_flags == flags);
assert((exp_content == NULL && content == NULL) || strcmp(exp_content, content) == 0);
if (content)
free(content);
if (fd >= 0)
close(fd);
}
int main(int argc, char **argv)
{
g_verbose = 3;
char template[] = "/tmp/XXXXXX";
if (mkdtemp(template) == NULL) {
perror("mkdtemp()");
return EXIT_FAILURE;
}
FILE *test_file = fopen("/tmp/libreport-test", "w");
assert(NULL != test_file);
fprintf(test_file, "problem_data_load_from_dump_dir");
fclose(test_file);
printf("Dump dir path: %s\n", template);
struct dump_dir *dd = dd_create(template, (uid_t)-1, 0640);
assert(dd != NULL || !"Cannot create new dump directory");
/* dd_create_basic_files() should create these files:
FILENAME_TIME, FILENAME_LAST_OCCURRENCE, FILENAME_UID, FILENAME_KERNEL,
FILENAME_ARCHITECTURE, FILENAME_HOSTNAME, FILENAME_OS_INFO, FILENAME_OS_RELEASE
*/
dd_create_basic_files(dd, geteuid(), NULL);
test(dd, "/tmp/libreport-test", NULL, -1, -EINVAL);
test(dd, "../libreport-test", NULL, -1, -EINVAL);
char *os_rel = dd_load_text(dd, FILENAME_OS_RELEASE);
test(dd, FILENAME_OS_RELEASE, os_rel, CD_FLAG_TXT, 0);
free(os_rel);
dd_delete(dd);
}
]])
## ------------------------- ##
## problem_data_reproducible ##
## ------------------------- ##
AT_TESTFUN([problem_data_reproducible],
[[
#include "testsuite.h"
#define TEST_FLAGS (CD_FLAG_TXT | CD_FLAG_ISNOTEDITABLE | CD_FLAG_UNIXTIME)
TS_MAIN
{
TS_ASSERT_STRING_NULL_OR_EMPTY(get_problem_data_reproducible_name(-1), "Invalid value");
TS_ASSERT_PTR_IS_NOT_NULL(get_problem_data_reproducible_name(PROBLEM_REPRODUCIBLE_UNKNOWN));
TS_ASSERT_PTR_IS_NOT_NULL(get_problem_data_reproducible_name(PROBLEM_REPRODUCIBLE_YES));
TS_ASSERT_PTR_IS_NOT_NULL(get_problem_data_reproducible_name(PROBLEM_REPRODUCIBLE_RECURRENT));
TS_ASSERT_STRING_NULL_OR_EMPTY(get_problem_data_reproducible_name(_PROBLEM_REPRODUCIBLE_MAX_), "Upper boundary");
TS_ASSERT_STRING_NULL_OR_EMPTY(get_problem_data_reproducible_name(_PROBLEM_REPRODUCIBLE_MAX_ + 1), "Upper boundary + 1");
TS_ASSERT_SIGNED_EQ(_PROBLEM_REPRODUCIBLE_MAX_, 3);
problem_data_t *pd = problem_data_new();
TS_ASSERT_SIGNED_EQ(get_problem_data_reproducible(pd), -1);
problem_data_add(pd, FILENAME_REPRODUCIBLE,
get_problem_data_reproducible_name(PROBLEM_REPRODUCIBLE_UNKNOWN), TEST_FLAGS);
TS_ASSERT_SIGNED_EQ(get_problem_data_reproducible(pd), PROBLEM_REPRODUCIBLE_UNKNOWN);
problem_data_add(pd, FILENAME_REPRODUCIBLE,
get_problem_data_reproducible_name(PROBLEM_REPRODUCIBLE_YES), TEST_FLAGS);
TS_ASSERT_SIGNED_EQ(get_problem_data_reproducible(pd), PROBLEM_REPRODUCIBLE_YES);
problem_data_add(pd, FILENAME_REPRODUCIBLE,
get_problem_data_reproducible_name(PROBLEM_REPRODUCIBLE_RECURRENT), TEST_FLAGS);
TS_ASSERT_SIGNED_EQ(get_problem_data_reproducible(pd), PROBLEM_REPRODUCIBLE_RECURRENT);
problem_data_add(pd, FILENAME_REPRODUCIBLE,
get_problem_data_reproducible_name(_PROBLEM_REPRODUCIBLE_MAX_), TEST_FLAGS);
TS_ASSERT_SIGNED_EQ(get_problem_data_reproducible(pd), -1);
problem_data_free(pd);
}
TS_RETURN_MAIN
]])