#define _GNU_SOURCE

#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

static int has_status_flag(int fd, int flag) {
    int value = fcntl(fd, F_GETFL);
    return value >= 0 && (value & flag) != 0;
}

static int has_fd_flag(int fd, int flag) {
    int value = fcntl(fd, F_GETFD);
    return value >= 0 && (value & flag) != 0;
}

int main(void) {
    int ok = 1;
    int flagged = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
    if (flagged < 0) {
        perror("socket(flags)");
        return 1;
    }

    int socket_nonblock = has_status_flag(flagged, O_NONBLOCK);
    int socket_cloexec = has_fd_flag(flagged, FD_CLOEXEC);
    printf("socket_nonblock=%s\n", socket_nonblock ? "yes" : "no");
    printf("socket_cloexec=%s\n", socket_cloexec ? "yes" : "no");
    ok &= socket_nonblock && socket_cloexec;
    close(flagged);

    errno = 0;
    int invalid_socket = socket(AF_INET, SOCK_STREAM | 0x20000000, 0);
    int invalid_socket_errno = errno;
    if (invalid_socket >= 0)
        close(invalid_socket);
    int invalid_socket_einval =
        invalid_socket == -1 && invalid_socket_errno == EINVAL;
    printf("socket_invalid_flag_einval=%s\n",
           invalid_socket_einval ? "yes" : "no");
    ok &= invalid_socket_einval;

    /* Linux looks up the descriptor before validating accept4 flags. */
    errno = 0;
    int badfd_accept = accept4(-1, NULL, NULL, 0x20000000);
    int badfd_accept_errno = errno;
    int badfd_accept_ebadf =
        badfd_accept == -1 && badfd_accept_errno == EBADF;
    printf("accept4_badfd_ebadf=%s\n",
           badfd_accept_ebadf ? "yes" : "no");
    ok &= badfd_accept_ebadf;

    /* Establish a loopback connection in one process. TCP connect may finish
     * before accept because the listening socket's backlog owns the pending
     * connection, so no fork/thread is needed by the WASM fixture. */
    int listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener < 0) {
        perror("socket(listener)");
        return 1;
    }

    struct sockaddr_in address;
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    address.sin_port = 0;
    if (bind(listener, (struct sockaddr *)&address, sizeof(address)) < 0 ||
        listen(listener, 1) < 0) {
        perror("listen(loopback)");
        close(listener);
        return 1;
    }

    errno = 0;
    int invalid_accept = accept4(listener, NULL, NULL, 0x20000000);
    int invalid_accept_errno = errno;
    int invalid_accept_einval =
        invalid_accept == -1 && invalid_accept_errno == EINVAL;
    printf("accept4_invalid_flag_einval=%s\n",
           invalid_accept_einval ? "yes" : "no");
    ok &= invalid_accept_einval;

    socklen_t address_len = sizeof(address);
    if (getsockname(listener, (struct sockaddr *)&address, &address_len) < 0) {
        perror("getsockname(listener)");
        close(listener);
        return 1;
    }

    int client = socket(AF_INET, SOCK_STREAM, 0);
    if (client < 0 ||
        connect(client, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("connect(loopback)");
        if (client >= 0)
            close(client);
        close(listener);
        return 1;
    }

    int accepted = accept4(listener, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
    if (accepted < 0) {
        perror("accept4(flags)");
        close(client);
        close(listener);
        return 1;
    }

    int accept_nonblock = has_status_flag(accepted, O_NONBLOCK);
    int accept_cloexec = has_fd_flag(accepted, FD_CLOEXEC);
    printf("accept4_nonblock=%s\n", accept_nonblock ? "yes" : "no");
    printf("accept4_cloexec=%s\n", accept_cloexec ? "yes" : "no");
    ok &= accept_nonblock && accept_cloexec;

    /* dup/F_DUPFD share the socket open-file description (including status
     * flags), but each descriptor has independent FD_CLOEXEC state. */
    int duplicate = dup(accepted);
    int duplicate_ok = duplicate >= 0 && !has_fd_flag(duplicate, FD_CLOEXEC) &&
        has_status_flag(duplicate, O_NONBLOCK);
    if (duplicate >= 0 && fcntl(duplicate, F_SETFL, 0) == 0)
        duplicate_ok &= !has_status_flag(accepted, O_NONBLOCK);
    if (duplicate >= 0 && fcntl(duplicate, F_SETFD, FD_CLOEXEC) == 0)
        duplicate_ok &= has_fd_flag(duplicate, FD_CLOEXEC) &&
            has_fd_flag(accepted, FD_CLOEXEC);
    printf("socket_dup_shared_ofd=%s\n", duplicate_ok ? "yes" : "no");
    ok &= duplicate_ok;

    int exact = duplicate >= 0 ? dup2(duplicate, 42) : -1;
    int dup2_exact = exact == 42 && !has_fd_flag(exact, FD_CLOEXEC);
    printf("socket_dup2_exact=%s\n", dup2_exact ? "yes" : "no");
    ok &= dup2_exact;

    int minimum = exact >= 0 ? fcntl(exact, F_DUPFD, 50) : -1;
    int dup_min = minimum >= 50 && !has_fd_flag(minimum, FD_CLOEXEC);
    printf("socket_f_dupfd_min=%s\n", dup_min ? "yes" : "no");
    ok &= dup_min;

    /* Closing the source must leave each duplicate usable. */
    close(accepted);
    const char byte = 'x';
    char received = 0;
    int independent_close = exact >= 0 && send(client, &byte, 1, 0) == 1 &&
        recv(exact, &received, 1, 0) == 1 && received == byte;
    printf("socket_dup_independent_close=%s\n",
           independent_close ? "yes" : "no");
    ok &= independent_close;

    if (duplicate >= 0)
        close(duplicate);
    if (exact >= 0)
        close(exact);
    if (minimum >= 0)
        close(minimum);
    close(client);
    close(listener);

    printf("socket_flags=%s\n", ok ? "ok" : "FAIL");
    return ok ? 0 : 1;
}