// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2026 Christian Brauner <brauner@kernel.org>
/*
 * Test user.* xattrs on various socket families.
 *
 * All socket types use sockfs for their inodes, so user.* xattrs should
 * work on any socket regardless of address family. This tests AF_INET,
 * AF_INET6, AF_NETLINK, AF_PACKET, and abstract namespace AF_UNIX sockets.
 */

#define _GNU_SOURCE
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/xattr.h>
#include <linux/netlink.h>
#include <unistd.h>

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

#define TEST_XATTR_NAME         "user.testattr"
#define TEST_XATTR_VALUE        "testvalue"

FIXTURE(xattr_socket_types)
{
        int sockfd;
};

FIXTURE_VARIANT(xattr_socket_types)
{
        int family;
        int type;
        int protocol;
};

FIXTURE_VARIANT_ADD(xattr_socket_types, inet) {
        .family = AF_INET,
        .type = SOCK_STREAM,
        .protocol = 0,
};

FIXTURE_VARIANT_ADD(xattr_socket_types, inet6) {
        .family = AF_INET6,
        .type = SOCK_STREAM,
        .protocol = 0,
};

FIXTURE_VARIANT_ADD(xattr_socket_types, netlink) {
        .family = AF_NETLINK,
        .type = SOCK_RAW,
        .protocol = NETLINK_USERSOCK,
};

FIXTURE_VARIANT_ADD(xattr_socket_types, packet) {
        .family = AF_PACKET,
        .type = SOCK_DGRAM,
        .protocol = 0,
};

FIXTURE_SETUP(xattr_socket_types)
{
        self->sockfd = socket(variant->family, variant->type,
                              variant->protocol);
        if (self->sockfd < 0 &&
            (errno == EAFNOSUPPORT || errno == EPERM || errno == EACCES))
                SKIP(return, "socket(%d, %d, %d) not available: %s",
                     variant->family, variant->type, variant->protocol,
                     strerror(errno));
        ASSERT_GE(self->sockfd, 0) {
                TH_LOG("Failed to create socket(%d, %d, %d): %s",
                       variant->family, variant->type, variant->protocol,
                       strerror(errno));
        }
}

FIXTURE_TEARDOWN(xattr_socket_types)
{
        if (self->sockfd >= 0)
                close(self->sockfd);
}

TEST_F(xattr_socket_types, set_get_list_remove)
{
        char buf[256], list[4096], *ptr;
        ssize_t ret;
        bool found;

        ret = fsetxattr(self->sockfd, TEST_XATTR_NAME,
                        TEST_XATTR_VALUE, strlen(TEST_XATTR_VALUE), 0);
        ASSERT_EQ(ret, 0) {
                TH_LOG("fsetxattr failed: %s", strerror(errno));
        }

        memset(buf, 0, sizeof(buf));
        ret = fgetxattr(self->sockfd, TEST_XATTR_NAME, buf, sizeof(buf));
        ASSERT_EQ(ret, (ssize_t)strlen(TEST_XATTR_VALUE));
        ASSERT_STREQ(buf, TEST_XATTR_VALUE);

        memset(list, 0, sizeof(list));
        ret = flistxattr(self->sockfd, list, sizeof(list));
        ASSERT_GT(ret, 0);
        found = false;
        for (ptr = list; ptr < list + ret; ptr += strlen(ptr) + 1) {
                if (strcmp(ptr, TEST_XATTR_NAME) == 0)
                        found = true;
        }
        ASSERT_TRUE(found);

        ret = fremovexattr(self->sockfd, TEST_XATTR_NAME);
        ASSERT_EQ(ret, 0);

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

/*
 * Test abstract namespace AF_UNIX socket.
 * Abstract sockets don't have a filesystem path; their inodes live in
 * sockfs so user.* xattrs should work via fsetxattr/fgetxattr.
 */
FIXTURE(xattr_abstract)
{
        int sockfd;
};

FIXTURE_SETUP(xattr_abstract)
{
        struct sockaddr_un addr;
        char name[64];
        int ret, len;

        self->sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
        ASSERT_GE(self->sockfd, 0);

        len = snprintf(name, sizeof(name), "xattr_test_abstract_%d", getpid());

        memset(&addr, 0, sizeof(addr));
        addr.sun_family = AF_UNIX;
        addr.sun_path[0] = '\0';
        memcpy(&addr.sun_path[1], name, len);

        ret = bind(self->sockfd, (struct sockaddr *)&addr,
                   offsetof(struct sockaddr_un, sun_path) + 1 + len);
        ASSERT_EQ(ret, 0);
}

FIXTURE_TEARDOWN(xattr_abstract)
{
        if (self->sockfd >= 0)
                close(self->sockfd);
}

TEST_F(xattr_abstract, set_get)
{
        char buf[256];
        ssize_t ret;

        ret = fsetxattr(self->sockfd, TEST_XATTR_NAME,
                        TEST_XATTR_VALUE, strlen(TEST_XATTR_VALUE), 0);
        ASSERT_EQ(ret, 0) {
                TH_LOG("fsetxattr on abstract socket failed: %s",
                       strerror(errno));
        }

        memset(buf, 0, sizeof(buf));
        ret = fgetxattr(self->sockfd, TEST_XATTR_NAME, buf, sizeof(buf));
        ASSERT_EQ(ret, (ssize_t)strlen(TEST_XATTR_VALUE));
        ASSERT_STREQ(buf, TEST_XATTR_VALUE);
}

TEST_HARNESS_MAIN