// SPDX-License-Identifier: GPL-2.0

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <linux/types.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syscall.h>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/kcmp.h>
#include <sys/stat.h>
#include <sys/xattr.h>

#include "pidfd.h"
#include "kselftest_harness.h"

FIXTURE(pidfs_xattr)
{
        pid_t child_pid;
        int child_pidfd;
};

FIXTURE_SETUP(pidfs_xattr)
{
        self->child_pid = create_child(&self->child_pidfd, CLONE_NEWUSER | CLONE_NEWPID);
        EXPECT_GE(self->child_pid, 0);

        if (self->child_pid == 0)
                _exit(EXIT_SUCCESS);
}

FIXTURE_TEARDOWN(pidfs_xattr)
{
        sys_waitid(P_PID, self->child_pid, NULL, WEXITED);
}

TEST_F(pidfs_xattr, set_get_list_xattr_multiple)
{
        int ret, i;
        char xattr_name[32];
        char xattr_value[32];
        char buf[32];
        const int num_xattrs = 10;
        char list[PATH_MAX] = {};

        for (i = 0; i < num_xattrs; i++) {
                snprintf(xattr_name, sizeof(xattr_name), "trusted.testattr%d", i);
                snprintf(xattr_value, sizeof(xattr_value), "testvalue%d", i);
                ret = fsetxattr(self->child_pidfd, xattr_name, xattr_value, strlen(xattr_value), 0);
                ASSERT_EQ(ret, 0);
        }

        for (i = 0; i < num_xattrs; i++) {
                snprintf(xattr_name, sizeof(xattr_name), "trusted.testattr%d", i);
                snprintf(xattr_value, sizeof(xattr_value), "testvalue%d", i);
                memset(buf, 0, sizeof(buf));
                ret = fgetxattr(self->child_pidfd, xattr_name, buf, sizeof(buf));
                ASSERT_EQ(ret, strlen(xattr_value));
                ASSERT_EQ(strcmp(buf, xattr_value), 0);
        }

        ret = flistxattr(self->child_pidfd, list, sizeof(list));
        ASSERT_GT(ret, 0);
        for (i = 0; i < num_xattrs; i++) {
                snprintf(xattr_name, sizeof(xattr_name), "trusted.testattr%d", i);
                bool found = false;
                for (char *it = list; it < list + ret; it += strlen(it) + 1) {
                        if (strcmp(it, xattr_name))
                                continue;
                        found = true;
                        break;
                }
                ASSERT_TRUE(found);
        }

        for (i = 0; i < num_xattrs; i++) {
                snprintf(xattr_name, sizeof(xattr_name), "trusted.testattr%d", i);
                ret = fremovexattr(self->child_pidfd, xattr_name);
                ASSERT_EQ(ret, 0);

                ret = fgetxattr(self->child_pidfd, xattr_name, buf, sizeof(buf));
                ASSERT_EQ(ret, -1);
                ASSERT_EQ(errno, ENODATA);
        }
}

TEST_F(pidfs_xattr, set_get_list_xattr_persistent)
{
        int ret;
        char buf[32];
        char list[PATH_MAX] = {};

        ret = fsetxattr(self->child_pidfd, "trusted.persistent", "persistent value", strlen("persistent value"), 0);
        ASSERT_EQ(ret, 0);

        memset(buf, 0, sizeof(buf));
        ret = fgetxattr(self->child_pidfd, "trusted.persistent", buf, sizeof(buf));
        ASSERT_EQ(ret, strlen("persistent value"));
        ASSERT_EQ(strcmp(buf, "persistent value"), 0);

        ret = flistxattr(self->child_pidfd, list, sizeof(list));
        ASSERT_GT(ret, 0);
        ASSERT_EQ(strcmp(list, "trusted.persistent"), 0)

        ASSERT_EQ(close(self->child_pidfd), 0);
        self->child_pidfd = -EBADF;
        sleep(2);

        self->child_pidfd = sys_pidfd_open(self->child_pid, 0);
        ASSERT_GE(self->child_pidfd, 0);

        memset(buf, 0, sizeof(buf));
        ret = fgetxattr(self->child_pidfd, "trusted.persistent", buf, sizeof(buf));
        ASSERT_EQ(ret, strlen("persistent value"));
        ASSERT_EQ(strcmp(buf, "persistent value"), 0);

        ret = flistxattr(self->child_pidfd, list, sizeof(list));
        ASSERT_GT(ret, 0);
        ASSERT_EQ(strcmp(list, "trusted.persistent"), 0);
}

TEST_HARNESS_MAIN