// SPDX-License-Identifier: GPL-2.0
#define _GNU_SOURCE
#include <fcntl.h>
#include <sched.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

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

/*
 * Test that a process can become PID 1 (init) in a new PID namespace
 * created via unshare() and joined via setns().
 *
 * Flow:
 *  1. Parent creates a pipe for synchronization.
 *  2. Parent forks a child.
 *  3. Parent calls unshare(CLONE_NEWPID) to create a new PID namespace.
 *  4. Parent signals the child via the pipe.
 *  5. Child opens parent's /proc/<ppid>/ns/pid_for_children and calls
 *     setns(fd, CLONE_NEWPID) to join the new namespace.
 *  6. Child forks a grandchild.
 *  7. Grandchild verifies getpid() == 1.
 */
TEST(pidns_init_via_setns)
{
        pid_t child, parent_pid;
        int pipe_fd[2];
        char buf;

        if (geteuid())
                ASSERT_EQ(0, unshare(CLONE_NEWUSER));

        parent_pid = getpid();

        ASSERT_EQ(0, pipe(pipe_fd));

        child = fork();
        ASSERT_GE(child, 0);

        if (child == 0) {
                char path[256];
                int nsfd;
                pid_t grandchild;

                close(pipe_fd[1]);

                /* Wait for parent to complete unshare */
                ASSERT_EQ(1, read_nointr(pipe_fd[0], &buf, 1));
                close(pipe_fd[0]);

                snprintf(path, sizeof(path),
                         "/proc/%d/ns/pid_for_children", parent_pid);
                nsfd = open(path, O_RDONLY);
                ASSERT_GE(nsfd, 0);

                ASSERT_EQ(0, setns(nsfd, CLONE_NEWPID));
                close(nsfd);

                grandchild = fork();
                ASSERT_GE(grandchild, 0);

                if (grandchild == 0) {
                        /* Should be init (PID 1) in the new namespace */
                        if (getpid() != 1)
                                _exit(1);
                        _exit(0);
                }

                ASSERT_EQ(0, wait_for_pid(grandchild));
                _exit(0);
        }

        close(pipe_fd[0]);

        ASSERT_EQ(0, unshare(CLONE_NEWPID));

        /* Signal child that the new PID namespace is ready */
        buf = 0;
        ASSERT_EQ(1, write_nointr(pipe_fd[1], &buf, 1));
        close(pipe_fd[1]);

        ASSERT_EQ(0, wait_for_pid(child));
}

/*
 * Similar to pidns_init_via_setns, but:
 *  1. Parent enters a new PID namespace right from the start to be able to
 *     later freely use pid 1001 in it.
 *  2. After forking child, parent also calls unshare(CLONE_NEWUSER)
 *     before unshare(CLONE_NEWPID) so that new old and new pid namespaces have
 *     different user namespace owners.
 *  3. Child uses clone3() with set_tid={1, 1001} instead of fork() and
 *     grandchild checks that it gets desired pids .
 *
 * Flow:
 *  1. Test process creates a new PID namespace and forks a wrapper
 *     (PID 1 in the outer namespace).
 *  2. Wrapper forks a child.
 *  3. Wrapper calls unshare(CLONE_NEWUSER) + unshare(CLONE_NEWPID)
 *     to create an inner PID namespace.
 *  4. Wrapper signals the child via pipe.
 *  5. Child opens wrapper's /proc/<pid>/ns/pid_for_children and calls
 *     setns(fd, CLONE_NEWPID) to join the inner namespace.
 *  6. Child calls clone3() with set_tid={1, 1001}.
 *  7. Grandchild verifies its NSpid ends with "1001 1".
 */

pid_t set_tid[] = {1, 1001};

static int pidns_init_via_setns_set_tid_grandchild(struct __test_metadata *_metadata)
{
        char *line = NULL;
        size_t len = 0;
        int found = 0;
        FILE *gf;

        gf = fopen("/proc/self/status", "r");
        ASSERT_NE(gf, NULL);

        while (getline(&line, &len, gf) != -1) {
                if (strncmp(line, "NSpid:", 6) != 0)
                        continue;

                for (int i = 0; i < 2; i++) {
                        char *last = strrchr(line, '\t');
                        pid_t pid;

                        ASSERT_NE(last, NULL);
                        ASSERT_EQ(sscanf(last, "%d", &pid), 1);
                        ASSERT_EQ(pid, set_tid[i]);
                        *last = '\0';
                }

                found = true;
                break;
        }

        free(line);
        fclose(gf);
        ASSERT_TRUE(found);
        return 0;
}

static int pidns_init_via_setns_set_tid_child(struct __test_metadata *_metadata,
                                              pid_t parent_pid, int pipe_fd[2])
{
        struct __clone_args args = {
                .exit_signal    = SIGCHLD,
                .set_tid        = ptr_to_u64(set_tid),
                .set_tid_size   = 2,
        };
        pid_t grandchild;
        char path[256];
        char buf;
        int nsfd;

        close(pipe_fd[1]);

        ASSERT_EQ(1, read_nointr(pipe_fd[0], &buf, 1));
        close(pipe_fd[0]);

        snprintf(path, sizeof(path),
                 "/proc/%d/ns/pid_for_children", parent_pid);
        nsfd = open(path, O_RDONLY);
        ASSERT_GE(nsfd, 0);

        ASSERT_EQ(0, setns(nsfd, CLONE_NEWPID));
        close(nsfd);

        grandchild = sys_clone3(&args, sizeof(args));
        ASSERT_GE(grandchild, 0);

        if (grandchild == 0)
                _exit(pidns_init_via_setns_set_tid_grandchild(_metadata));

        ASSERT_EQ(0, wait_for_pid(grandchild));
        return 0;
}

static int pidns_init_via_setns_set_tid_wrapper(struct __test_metadata *_metadata)
{
        int pipe_fd[2];
        pid_t child, parent_pid;
        char buf;
        FILE *f;

        /*
         * We are PID 1 inside the new namespace, but /proc is
         * mounted from the host.  Read our host-visible PID so
         * the child can reach our pid_for_children via /proc.
         */
        f = fopen("/proc/self/stat", "r");
        ASSERT_NE(f, NULL);
        ASSERT_EQ(fscanf(f, "%d", &parent_pid), 1);
        ASSERT_EQ(0, pipe(pipe_fd));

        child = fork();
        ASSERT_GE(child, 0);

        if (child == 0)
                _exit(pidns_init_via_setns_set_tid_child(_metadata, parent_pid, pipe_fd));

        close(pipe_fd[0]);

        ASSERT_EQ(0, unshare(CLONE_NEWUSER));
        ASSERT_EQ(0, unshare(CLONE_NEWPID));

        buf = 0;
        ASSERT_EQ(1, write_nointr(pipe_fd[1], &buf, 1));
        close(pipe_fd[1]);

        ASSERT_EQ(0, wait_for_pid(child));

        fclose(f);
        return 0;
}

TEST(pidns_init_via_setns_set_tid)
{
        pid_t wrapper;

        if (geteuid())
                SKIP(return, "This test needs root to run!");

        ASSERT_EQ(0, unshare(CLONE_NEWPID));

        wrapper = fork();
        ASSERT_GE(wrapper, 0);

        if (wrapper == 0)
                _exit(pidns_init_via_setns_set_tid_wrapper(_metadata));

        ASSERT_EQ(0, wait_for_pid(wrapper));
}

TEST_HARNESS_MAIN