/* SPDX-License-Identifier: MPL-2.0 */

#include "testutil.hpp"

#include "testutil_unity.hpp"

#include <stdarg.h>

#include <string.h>

#if defined _WIN32

#include "../src/windows.hpp"

#if defined ZMQ_HAVE_WINDOWS

#if defined ZMQ_HAVE_IPC

#include <direct.h>

#include <afunix.h>

#endif

#include <crtdbg.h>

#pragma warning(disable : 4996)

// iphlpapi is needed for if_nametoindex (not on Windows XP)

#if _WIN32_WINNT > _WIN32_WINNT_WINXP

#pragma comment(lib, "iphlpapi")

#endif

#endif

#else

#include <pthread.h>

#include <unistd.h>

#include <signal.h>

#include <stdlib.h>

#include <grp.h>

#include <sys/wait.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <net/if.h>

#include <netdb.h>

#include <sys/un.h>

#include <dirent.h>

#if defined(ZMQ_HAVE_AIX)

#include <sys/types.h>

#include <sys/socketvar.h>

#endif

#endif

#if defined(ZMQ_HAVE_VSOCK)

#include "linux/vm_sockets.h"

#include <sys/ioctl.h>

#include <fcntl.h>

#endif

#ifndef PATH_MAX

#define PATH_MAX 1024

#endif

const char *SEQ_END = (const char *) 1;

const char bounce_content[] = "12345678ABCDEFGH12345678abcdefgh";

static void send_bounce_msg (void *socket_)

{

    send_string_expect_success (socket_, bounce_content, ZMQ_SNDMORE);

    send_string_expect_success (socket_, bounce_content, 0);

}

static void recv_bounce_msg (void *socket_)

{

    recv_string_expect_success (socket_, bounce_content, 0);

    int rcvmore;

    size_t sz = sizeof (rcvmore);

    TEST_ASSERT_SUCCESS_ERRNO (

      zmq_getsockopt (socket_, ZMQ_RCVMORE, &rcvmore, &sz));

    TEST_ASSERT_TRUE (rcvmore);

    recv_string_expect_success (socket_, bounce_content, 0);

    TEST_ASSERT_SUCCESS_ERRNO (

      zmq_getsockopt (socket_, ZMQ_RCVMORE, &rcvmore, &sz));

    TEST_ASSERT_FALSE (rcvmore);

}

void bounce (void *server_, void *client_)

{

    //  Send message from client to server

    send_bounce_msg (client_);

    //  Receive message at server side and

    //  check that message is still the same

    recv_bounce_msg (server_);

    //  Send two parts back to client

    send_bounce_msg (server_);

    //  Receive the two parts at the client side

    recv_bounce_msg (client_);

}

static void send_bounce_msg_may_fail (void *socket_)

{

    int timeout = 250;

    TEST_ASSERT_SUCCESS_ERRNO (

      zmq_setsockopt (socket_, ZMQ_SNDTIMEO, &timeout, sizeof (int)));

    int rc = zmq_send (socket_, bounce_content, 32, ZMQ_SNDMORE);

    TEST_ASSERT_TRUE ((rc == 32) || ((rc == -1) && (errno == EAGAIN)));

    rc = zmq_send (socket_, bounce_content, 32, 0);

    TEST_ASSERT_TRUE ((rc == 32) || ((rc == -1) && (errno == EAGAIN)));

}

static void recv_bounce_msg_fail (void *socket_)

{

    int timeout = 250;

    char buffer[32];

    TEST_ASSERT_SUCCESS_ERRNO (

      zmq_setsockopt (socket_, ZMQ_RCVTIMEO, &timeout, sizeof (int)));

    TEST_ASSERT_FAILURE_ERRNO (EAGAIN, zmq_recv (socket_, buffer, 32, 0));

}

void expect_bounce_fail (void *server_, void *client_)

{

    //  Send message from client to server

    send_bounce_msg_may_fail (client_);

    //  Receive message at server side (should not succeed)

    recv_bounce_msg_fail (server_);

    //  Send message from server to client to test other direction

    //  If connection failed, send may block, without a timeout

    send_bounce_msg_may_fail (server_);

    //  Receive message at client side (should not succeed)

    recv_bounce_msg_fail (client_);

}

char *s_recv (void *socket_)

{

    char buffer[256];

    int size = zmq_recv (socket_, buffer, 255, 0);

    if (size == -1)

        return NULL;

    if (size > 255)

        size = 255;

    buffer[size] = 0;

    return strdup (buffer);

}

void s_send_seq (void *socket_, ...)

{

    va_list ap;

    va_start (ap, socket_);

    const char *data = va_arg (ap, const char *);

    while (true) {

        const char *prev = data;

        data = va_arg (ap, const char *);

        bool end = data == SEQ_END;

        if (!prev) {

            TEST_ASSERT_SUCCESS_ERRNO (

              zmq_send (socket_, 0, 0, end ? 0 : ZMQ_SNDMORE));

        } else {

            TEST_ASSERT_SUCCESS_ERRNO (zmq_send (

              socket_, prev, strlen (prev) + 1, end ? 0 : ZMQ_SNDMORE));

        }

        if (end)

            break;

    }

    va_end (ap);

}

void s_recv_seq (void *socket_, ...)

{

    zmq_msg_t msg;

    zmq_msg_init (&msg);

    int more;

    size_t more_size = sizeof (more);

    va_list ap;

    va_start (ap, socket_);

    const char *data = va_arg (ap, const char *);

    while (true) {

        TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, socket_, 0));

        if (!data)

            TEST_ASSERT_EQUAL_INT (0, zmq_msg_size (&msg));

        else

            TEST_ASSERT_EQUAL_STRING (data, (const char *) zmq_msg_data (&msg));

        data = va_arg (ap, const char *);

        bool end = data == SEQ_END;

        TEST_ASSERT_SUCCESS_ERRNO (

          zmq_getsockopt (socket_, ZMQ_RCVMORE, &more, &more_size));

        TEST_ASSERT_TRUE (!more == end);

        if (end)

            break;

    }

    va_end (ap);

    zmq_msg_close (&msg);

}

void close_zero_linger (void *socket_)

{

    int linger = 0;

    int rc = zmq_setsockopt (socket_, ZMQ_LINGER, &linger, sizeof (linger));

    TEST_ASSERT_TRUE (rc == 0 || errno == ETERM);

    TEST_ASSERT_SUCCESS_ERRNO (zmq_close (socket_));

}

void setup_test_environment (int timeout_seconds_)

{

#if defined _WIN32

#if defined _MSC_VER

    _set_abort_behavior (0, _WRITE_ABORT_MSG);

    _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_FILE);

    _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);

#endif

#else

#if defined ZMQ_HAVE_CYGWIN

    // abort test after 121 seconds

    alarm (121);

#else

#if !defined ZMQ_DISABLE_TEST_TIMEOUT

    // abort test after timeout_seconds_ seconds

    alarm (timeout_seconds_);

#endif

#endif

#endif

#if defined __MVS__

    // z/OS UNIX System Services: Ignore SIGPIPE during test runs, as a

    // workaround for no SO_NOGSIGPIPE socket option.

    signal (SIGPIPE, SIG_IGN);

#endif

}

void msleep (int milliseconds_)

{

#ifdef ZMQ_HAVE_WINDOWS

    Sleep (milliseconds_);

#else

    usleep (static_cast<useconds_t> (milliseconds_) * 1000);

#endif

}

int is_ipv6_available ()

{

#if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600)

    return 0;

#else

    int rc, ipv6 = 1;

    struct sockaddr_in6 test_addr;

    memset (&test_addr, 0, sizeof (test_addr));

    test_addr.sin6_family = AF_INET6;

    inet_pton (AF_INET6, "::1", &(test_addr.sin6_addr));

    fd_t fd = socket (AF_INET6, SOCK_STREAM, IPPROTO_IP);

    if (fd == retired_fd)

        ipv6 = 0;

    else {

#ifdef ZMQ_HAVE_WINDOWS

        setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const char *) &ipv6,

                    sizeof (int));

        rc = setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, (const char *) &ipv6,

                         sizeof (int));

        if (rc == SOCKET_ERROR)

            ipv6 = 0;

        else {

            rc = bind (fd, (struct sockaddr *) &test_addr, sizeof (test_addr));

            if (rc == SOCKET_ERROR)

                ipv6 = 0;

        }

#else

        setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &ipv6, sizeof (int));

        rc = setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6, sizeof (int));

        if (rc != 0)

            ipv6 = 0;

        else {

            rc = bind (fd, reinterpret_cast<struct sockaddr *> (&test_addr),

                       sizeof (test_addr));

            if (rc != 0)

                ipv6 = 0;

        }

#endif

        close (fd);

    }

    return ipv6;

#endif // _WIN32_WINNT < 0x0600

}

int is_tipc_available ()

{

#ifndef ZMQ_HAVE_TIPC

    return 0;

#else

    int tipc = 0;

    void *ctx = zmq_init (1);

    TEST_ASSERT_NOT_NULL (ctx);

    void *rep = zmq_socket (ctx, ZMQ_REP);

    TEST_ASSERT_NOT_NULL (rep);

    tipc = zmq_bind (rep, "tipc://{5560,0,0}");

    zmq_close (rep);

    zmq_ctx_term (ctx);

    return tipc == 0;

#endif // ZMQ_HAVE_TIPC

}

int is_vsock_available ()

{

#ifndef ZMQ_HAVE_VSOCK

    return 0;

#else

    unsigned int cid = VMADDR_CID_ANY;

    int vsock = -1;

    if ((vsock = open ("/dev/vsock", O_RDONLY, 0)) < 0) {

        TEST_IGNORE_MESSAGE ("failed to open /dev/vsock, skipping test");

    } else if (ioctl (vsock, IOCTL_VM_SOCKETS_GET_LOCAL_CID, &cid) < 0) {

        TEST_IGNORE_MESSAGE ("failed to get local cid, skipping test");

    }

    if (vsock >= 0) {

        close (vsock);

    }

    if (cid == VMADDR_CID_ANY) {

        TEST_IGNORE_MESSAGE (

          "vsock_loopback environment unavailable, skipping test");

    }

    return cid != VMADDR_CID_ANY;

#endif // ZMQ_HAVE_VSOCK

}

int test_inet_pton (int af_, const char *src_, void *dst_)

{

#if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600)

    if (af_ == AF_INET) {

        struct in_addr *ip4addr = (struct in_addr *) dst_;

        ip4addr->s_addr = inet_addr (src_);

        //  INADDR_NONE is -1 which is also a valid representation for IP

        //  255.255.255.255

        if (ip4addr->s_addr == INADDR_NONE

            && strcmp (src_, "255.255.255.255") != 0) {

            return 0;

        }

        //  Success

        return 1;

    } else {

        //  Not supported.

        return 0;

    }

#else

    return inet_pton (af_, src_, dst_);

#endif

}

sockaddr_in bind_bsd_socket (int socket_)

{

    struct sockaddr_in saddr;

    memset (&saddr, 0, sizeof (saddr));

    saddr.sin_family = AF_INET;

    saddr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);

#if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)

    saddr.sin_port = 0;

#else

    saddr.sin_port = htons (PORT_6);

#endif

    TEST_ASSERT_SUCCESS_RAW_ERRNO (

      bind (socket_, (struct sockaddr *) &saddr, sizeof (saddr)));

#if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)

    socklen_t saddr_len = sizeof (saddr);

    TEST_ASSERT_SUCCESS_RAW_ERRNO (

      getsockname (socket_, (struct sockaddr *) &saddr, &saddr_len));

#endif

    return saddr;

}

fd_t connect_socket (const char *endpoint_, const int af_, const int protocol_)

{

    struct sockaddr_storage addr;

    //  OSX is very opinionated and wants the size to match the AF family type

    socklen_t addr_len;

    const fd_t s_pre = socket (af_, SOCK_STREAM,

                               protocol_ == IPPROTO_UDP   ? IPPROTO_UDP

                               : protocol_ == IPPROTO_TCP ? IPPROTO_TCP

                                                          : 0);

#ifdef ZMQ_HAVE_WINDOWS

    TEST_ASSERT_NOT_EQUAL (INVALID_SOCKET, s_pre);

#else

    TEST_ASSERT_NOT_EQUAL (-1, s_pre);

#endif

    if (af_ == AF_INET || af_ == AF_INET6) {

        const char *port = strrchr (endpoint_, ':') + 1;

        char address[MAX_SOCKET_STRING];

        // getaddrinfo does not like [x:y::z]

        if (*strchr (endpoint_, '/') + 2 == '[') {

            strcpy (address, strchr (endpoint_, '[') + 1);

            address[strlen (address) - strlen (port) - 2] = '\0';

        } else {

            strcpy (address, strchr (endpoint_, '/') + 2);

            address[strlen (address) - strlen (port) - 1] = '\0';

        }

        struct addrinfo *in, hint;

        memset (&hint, 0, sizeof (struct addrinfo));

        hint.ai_flags = AI_NUMERICSERV;

        hint.ai_family = af_;

        hint.ai_socktype = protocol_ == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;

        hint.ai_protocol = protocol_ == IPPROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;

        TEST_ASSERT_SUCCESS_RAW_ZERO_ERRNO (

          getaddrinfo (address, port, &hint, &in));

        TEST_ASSERT_NOT_NULL (in);

        memcpy (&addr, in->ai_addr, in->ai_addrlen);

        addr_len = (socklen_t) in->ai_addrlen;

        freeaddrinfo (in);

    } else {

#if defined(ZMQ_HAVE_IPC)

        //  Cannot cast addr as gcc 4.4 will fail with strict aliasing errors

        (*(struct sockaddr_un *) &addr).sun_family = AF_UNIX;

        strcpy ((*(struct sockaddr_un *) &addr).sun_path, endpoint_);

        addr_len = sizeof (struct sockaddr_un);

#else

        return retired_fd;

#endif

    }

    TEST_ASSERT_SUCCESS_RAW_ERRNO (

      connect (s_pre, (struct sockaddr *) &addr, addr_len));

    return s_pre;

}

fd_t bind_socket_resolve_port (const char *address_,

                               const char *port_,

                               char *my_endpoint_,

                               const int af_,

                               const int protocol_)

{

    struct sockaddr_storage addr;

    //  OSX is very opinionated and wants the size to match the AF family type

    socklen_t addr_len;

    const fd_t s_pre = socket (af_, SOCK_STREAM,

                               protocol_ == IPPROTO_UDP   ? IPPROTO_UDP

                               : protocol_ == IPPROTO_TCP ? IPPROTO_TCP

                                                          : 0);

#ifdef ZMQ_HAVE_WINDOWS

    TEST_ASSERT_NOT_EQUAL (INVALID_SOCKET, s_pre);

#else

    TEST_ASSERT_NOT_EQUAL (-1, s_pre);

#endif

    if (af_ == AF_INET || af_ == AF_INET6) {

#ifdef ZMQ_HAVE_WINDOWS

        const char flag = '\1';

#elif defined ZMQ_HAVE_VXWORKS

        char flag = '\1';

#else

        int flag = 1;

#endif

        struct addrinfo *in, hint;

        memset (&hint, 0, sizeof (struct addrinfo));

        hint.ai_flags = AI_NUMERICSERV;

        hint.ai_family = af_;

        hint.ai_socktype = protocol_ == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;

        hint.ai_protocol = protocol_ == IPPROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;

        TEST_ASSERT_SUCCESS_RAW_ERRNO (

          setsockopt (s_pre, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof (int)));

        TEST_ASSERT_SUCCESS_RAW_ZERO_ERRNO (

          getaddrinfo (address_, port_, &hint, &in));

        TEST_ASSERT_NOT_NULL (in);

        memcpy (&addr, in->ai_addr, in->ai_addrlen);

        addr_len = (socklen_t) in->ai_addrlen;

        freeaddrinfo (in);

    } else {

#if defined(ZMQ_HAVE_IPC)

        //  Cannot cast addr as gcc 4.4 will fail with strict aliasing errors

        (*(struct sockaddr_un *) &addr).sun_family = AF_UNIX;

        addr_len = sizeof (struct sockaddr_un);

#if defined ZMQ_HAVE_WINDOWS

        char buffer[MAX_PATH] = "";

        TEST_ASSERT_SUCCESS_RAW_ERRNO (tmpnam_s (buffer));

        TEST_ASSERT_SUCCESS_RAW_ERRNO (_mkdir (buffer));

        strcat (buffer, "/ipc");

#else

        char buffer[PATH_MAX] = "";

        strcpy (buffer, "tmpXXXXXX");

#ifdef HAVE_MKDTEMP

        TEST_ASSERT_TRUE (mkdtemp (buffer));

        strcat (buffer, "/socket");

#else

        int fd = mkstemp (buffer);

        TEST_ASSERT_TRUE (fd != -1);

        close (fd);

#endif

#endif

        strcpy ((*(struct sockaddr_un *) &addr).sun_path, buffer);

        memcpy (my_endpoint_, "ipc://", 7);

        strcat (my_endpoint_, buffer);

        // TODO check return value of unlink

        unlink (buffer);

#else

        return retired_fd;

#endif

    }

    TEST_ASSERT_SUCCESS_RAW_ERRNO (

      bind (s_pre, (struct sockaddr *) &addr, addr_len));

    TEST_ASSERT_SUCCESS_RAW_ERRNO (listen (s_pre, SOMAXCONN));

    if (af_ == AF_INET || af_ == AF_INET6) {

        addr_len = sizeof (struct sockaddr_storage);

        TEST_ASSERT_SUCCESS_RAW_ERRNO (

          getsockname (s_pre, (struct sockaddr *) &addr, &addr_len));

        snprintf (

          my_endpoint_, 6 + strlen (address_) + 7 * sizeof (char), "%s://%s:%u",

          protocol_ == IPPROTO_TCP   ? "tcp"

          : protocol_ == IPPROTO_UDP ? "udp"

          : protocol_ == IPPROTO_WSS ? "wss"

                                     : "ws",

          address_,

          af_ == AF_INET ? ntohs ((*(struct sockaddr_in *) &addr).sin_port)

                         : ntohs ((*(struct sockaddr_in6 *) &addr).sin6_port));

    }

    return s_pre;

}

bool streq (const char *lhs_, const char *rhs_)

{

    return strcmp (lhs_, rhs_) == 0;

}

bool strneq (const char *lhs_, const char *rhs_)

{

    return strcmp (lhs_, rhs_) != 0;

}

#if defined _WIN32

int fuzzer_corpus_encode (const char *dirname,

                          uint8_t ***data,

                          size_t **len,

                          size_t *num_cases)

{

    (void) dirname;

    (void) data;

    (void) len;

    (void) num_cases;

    return -1;

}

#else

int fuzzer_corpus_encode (const char *dirname,

                          uint8_t ***data,

                          size_t **len,

                          size_t *num_cases)

{

    TEST_ASSERT_NOT_NULL (dirname);

    TEST_ASSERT_NOT_NULL (data);

    TEST_ASSERT_NOT_NULL (len);

    struct dirent *ent;

    DIR *dir = opendir (dirname);

    if (!dir)

        return -1;

    *len = NULL;

    *data = NULL;

    *num_cases = 0;

    while ((ent = readdir (dir)) != NULL) {

        if (!strcmp (ent->d_name, ".") || !strcmp (ent->d_name, ".."))

            continue;

        char *filename =

          (char *) malloc (strlen (dirname) + strlen (ent->d_name) + 2);

        TEST_ASSERT_NOT_NULL (filename);

        strcpy (filename, dirname);

        strcat (filename, "/");

        strcat (filename, ent->d_name);

        FILE *f = fopen (filename, "r");

        free (filename);

        if (!f)

            continue;

        fseek (f, 0, SEEK_END);

        size_t file_len = ftell (f);

        fseek (f, 0, SEEK_SET);

        if (file_len == 0) {

            fclose (f);

            continue;

        }

        *len = (size_t *) realloc (*len, (*num_cases + 1) * sizeof (size_t));

        TEST_ASSERT_NOT_NULL (*len);

        *(*len + *num_cases) = file_len;

        *data =

          (uint8_t **) realloc (*data, (*num_cases + 1) * sizeof (uint8_t *));

        TEST_ASSERT_NOT_NULL (*data);

        *(*data + *num_cases) =

          (uint8_t *) malloc (file_len * sizeof (uint8_t));

        TEST_ASSERT_NOT_NULL (*(*data + *num_cases));

        size_t read_bytes = 0;

        read_bytes = fread (*(*data + *num_cases), 1, file_len, f);

        TEST_ASSERT_EQUAL (file_len, read_bytes);

        (*num_cases)++;

        fclose (f);

    }

    closedir (dir);

    return 0;

}

#endif