test_socks.cpp

Go to the documentation of this file.

/* SPDX-License-Identifier: MPL-2.0 */
 
#ifdef _WIN32
#include "../src/windows.hpp"
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
 
#include "testutil.hpp"
#include "testutil_unity.hpp"
 
 
SETUP_TEARDOWN_TESTCONTEXT
 
void recvall (int sock_fd, char *buffer, int len)
{
    int res;
    int total = 0;
    while (len - total > 0) {
        res = recv (sock_fd, buffer + total, len - total, 0);
        if (res == -1)
            fprintf (stderr, "socks_server: error receiving %d bytes: %d %d\n",
                     len, res, errno);
        TEST_ASSERT_SUCCESS_RAW_ERRNO (res);
        TEST_ASSERT (res != 0);
        total += res;
    }
    TEST_ASSERT (total == len);
}
 
int recvonce (int sock_fd, char *buffer, int len)
{
    int res;
    res = recv (sock_fd, buffer, len, 0);
    if (res == -1)
        fprintf (stderr, "socks_server: error receiving bytes: %d %d\n", res,
                 errno);
    TEST_ASSERT_SUCCESS_RAW_ERRNO (res);
    return res;
}
 
void sendall (int sock_fd, char *buffer, int len)
{
    int res;
    int total = 0;
    while (len - total > 0) {
        res = send (sock_fd, buffer + total, len - total, 0);
        if (res == -1)
            fprintf (stderr, "socks_server: error sending %d bytes: %d %d\n",
                     len, res, errno);
        TEST_ASSERT_SUCCESS_RAW_ERRNO (res);
        TEST_ASSERT (res != 0);
        total += res;
    }
}
 
int remote_connect (int socket, uint32_t addr, uint16_t port)
{
    int res;
    struct sockaddr_in ip4addr;
    ip4addr.sin_family = AF_INET;
    ip4addr.sin_addr.s_addr = htonl (addr);
    ip4addr.sin_port = htons (port);
    res = connect (socket, (struct sockaddr *) &ip4addr, sizeof ip4addr);
    return res;
}
 
void *setup_socks_server (char *socks_server_address,
                          int socks_server_address_len)
{
    LIBZMQ_UNUSED (socks_server_address_len);
    fprintf (stderr, "socks_server: setup socks server\n");
    int server_fd =
      bind_socket_resolve_port ("127.0.0.1", "0", socks_server_address);
    memmove (socks_server_address, strchr (socks_server_address, '/') + 2,
             strlen (strchr (socks_server_address, '/') + 1));
    fprintf (stderr, "socks_server: bound to: tcp://%s\n",
             socks_server_address);
    return (void *) (intptr_t) server_fd;
}
 
void socks_server_task (void *socks_server,
                        const char *username,
                        const char *password,
                        int max_client_connect)
{
    int server_fd = (int) (intptr_t) socks_server;
    fprintf (stderr, "socks_server: starting server thread\n");
 
    int res;
    res = listen (server_fd, max_client_connect);
    TEST_ASSERT_SUCCESS_RAW_ERRNO (res);
 
    int auth_method;
    if (username == NULL || username[0] == '\0') {
        auth_method = 0x0; /* No auth */
    } else {
        auth_method = 0x2; /* Basic auth */
        if (password == NULL)
            password = "";
    }
 
    int count = 0;
    while (count < max_client_connect) {
        int client = -1;
        do {
            char buffer[4096];
            fprintf (stderr, "socks_server: waiting for connection\n");
            client = accept (server_fd, NULL, NULL);
            TEST_ASSERT_SUCCESS_RAW_ERRNO (client);
            count++;
            fprintf (stderr, "socks_server: accepted client connection %d/%d\n",
                     count, max_client_connect);
 
            /* Greetings [version, nmethods, methods...]. */
            recvall (client, buffer, 2);
            TEST_ASSERT (buffer[0] == 0x5);
            int nmethods = buffer[1];
            int method = 0xff;
            recvall (client, buffer, nmethods);
            for (int i = 0; i < nmethods; i++) {
                if (buffer[i] == auth_method)
                    method = auth_method;
            }
            fprintf (stderr, "socks_server: received greetings\n");
 
            /* Greetings response [version, method]. */
            buffer[0] = 0x5;
            buffer[1] = method;
            sendall (client, buffer, 2);
            fprintf (stderr,
                     "socks_server: answered greetings (method: 0x%x)\n",
                     method);
 
            if (method == 0xff)
                break; /* Out of client connection */
 
            if (method == 0x2) {
                int len;
                int err = 0;
                recvall (client, buffer, 1);
                if (buffer[0] != 0x1) {
                    err = 1;
                } else {
                    recvall (client, buffer, 1);
                    len = (unsigned char) buffer[0];
                    recvall (client, buffer, len);
                    buffer[len] = '\0';
                    if (strcmp (username, buffer) != 0) {
                        fprintf (stderr,
                                 "socks_server: error on username check: '%s', "
                                 "expected: '%s'\n",
                                 buffer, username);
                        err = 1;
                    }
                    recvall (client, buffer, 1);
                    len = (unsigned char) buffer[0];
                    recvall (client, buffer, len);
                    buffer[len] = '\0';
                    if (strcmp (password, buffer) != 0) {
                        fprintf (stderr,
                                 "socks_server: error on password check: '%s', "
                                 "expected: '%s'\n",
                                 buffer, password);
                        err = 1;
                    }
                }
                fprintf (stderr, "socks_server: received credentials\n");
                buffer[0] = 0x1;
                buffer[1] = err;
                sendall (client, buffer, 2);
                fprintf (stderr,
                         "socks_server: answered credentials (err: 0x%x)\n",
                         err);
                if (err != 0)
                    break; /* Out of client connection. */
            }
 
            /* Request [version, cmd, rsv, atype, dst.addr, dst.port */
            /* Test only tcp connect on top of IPV4 */
            recvall (client, buffer, 4);
            TEST_ASSERT (buffer[0] == 0x5);
            TEST_ASSERT (buffer[1] == 0x1); /* CONNECT cmd */
            TEST_ASSERT (buffer[2] == 0x0); /* reserved, ensure we send 0 */
            fprintf (stderr,
                     "socks_server: received command (cmd: %d, atype: %d)\n",
                     buffer[1], buffer[3]);
            /* IPv4 ADDR & PORT */
            uint32_t naddr = 0, bind_naddr = 0;
            uint16_t nport = 0, bind_nport = 0;
            int remote = -1;
            int err = 0;
            int request_atype = buffer[3];
            if (request_atype == 0x1) /* ATYPE IPv4 */ {
                recvall (client, (char *) &naddr, 4);
                fprintf (stderr,
                         "socks_server: received address (addr: 0x%x)\n",
                         ntohl (naddr));
            } else if (request_atype == 0x3) /* ATYPE DOMAINNAME */ {
                int len;
                recvall (client, buffer, 1);
                len = (unsigned char) buffer[0];
                recvall (client, buffer, len);
                buffer[len] = '\0';
                fprintf (stderr,
                         "socks_server: received domainname (hostname: %s)\n",
                         buffer);
                /* For the test we support static resolution of
                   hostname "somedomainnmame.org" to localhost */
                if (strcmp ("somedomainname.org", buffer) == 0) {
                    naddr = htonl (0x7f000001); /* 127.0.0.1 */
                } else {
                    err = 0x4; /* Host unreachable */
                }
            } else if (request_atype == 0x4) {
                /* For the test we simulate IPV6 connection request ::1, but connect to IPv4 localhost */
                unsigned char nipv6local[16] = {0};
                nipv6local[15] = 1;
                recvall (client, buffer, 16);
                fprintf (stderr,
                         "socks_server: received ipv6 address (buffer:");
                for (int i = 0; i < 16; i++)
                    fprintf (stderr, " 0x%x", (unsigned char) buffer[i]);
                fprintf (stderr, ")\n");
                if (memcmp (buffer, nipv6local, 16) == 0) {
                    naddr = htonl (0x7f000001); /* 127.0.0.1 */
                } else {
                    err = 0x4; /* Host unreachable */
                }
            } else {
                err = 0x8; /* ATYPE not supported */
            }
            recvall (client, (char *) &nport, 2);
            fprintf (stderr, "socks_server: received port (port: %d)\n",
                     ntohs (nport));
            if (err == 0) {
                fprintf (stderr, "socks_server: trying to connect to %x:%d\n",
                         ntohl (naddr), ntohs (nport));
                remote = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
                res = remote_connect (remote, ntohl (naddr), ntohs (nport));
                if (res != 0) {
                    err = 0x5; /* Connection refused */
                } else {
                    struct sockaddr_in ip4addr;
                    socklen_t len = sizeof (ip4addr);
                    res =
                      getsockname (remote, (struct sockaddr *) &ip4addr, &len);
                    TEST_ASSERT_SUCCESS_RAW_ERRNO (res);
                    fprintf (stderr,
                             "socks_server: connected and bound at: %x:%d\n",
                             ntohl (ip4addr.sin_addr.s_addr),
                             ntohs (ip4addr.sin_port));
                    bind_naddr = ip4addr.sin_addr.s_addr;
                    bind_nport = ip4addr.sin_port;
                }
            }
 
            /* Reply request */
            buffer[0] = 0x5;
            buffer[1] = err;
            buffer[2] = 0;
            buffer[3] = request_atype;
            sendall (client, buffer, 4);
            if (request_atype == 0x1) /* ATYPE IPv4 */ {
                sendall (client, (char *) &bind_naddr, 4);
            } else if (request_atype == 0x3) {
                /* This is just for testing reply with a hostname,
                   normally a resolved address is passed in return to connect. */
                buffer[0] = strlen ("localhost");
                sendall (client, buffer, 1);
                strcpy (buffer, "localhost");
                sendall (client, buffer, strlen ("localhost"));
            } else if (request_atype == 0x4) {
                /* We simulate a bind to ::1, though the actual connection is IPv4 */
                char nipv6local[16] = {0};
                nipv6local[15] = 1;
                sendall (client, nipv6local, sizeof nipv6local);
            }
            sendall (client, (char *) &bind_nport, 2);
            fprintf (stderr, "socks_server: replied to request (err: 0x%x)\n",
                     err);
            if (err != 0)
                break; /* Out of client connection. */
 
            /* Communication loop */
            zmq_pollitem_t items[] = {
              {NULL, client, ZMQ_POLLIN, 0},
              {NULL, remote, ZMQ_POLLIN, 0},
            };
            fprintf (stderr,
                     "socks_server: waiting for input (client fd: %d, remote "
                     "fd: %d)\n",
                     client, remote);
            while (1) {
                if (client == -1 || remote == -1)
                    break;
                if (zmq_poll (items, 2, -1) < 0)
                    break;
                int nbytes;
                for (int i = 0; i < 2; i++) {
                    if ((items[i].revents & ZMQ_POLLIN) == 0)
                        continue;
                    fprintf (stderr, "socks_server: ready to read from fd %d\n",
                             items[i].fd);
                    int write_fd, read_fd = items[i].fd;
                    if (read_fd == client) {
                        write_fd = remote;
                    } else {
                        write_fd = client;
                    }
                    nbytes = recvonce (read_fd, buffer, sizeof buffer);
                    fprintf (stderr, "socks_server: read returned: %d\n",
                             nbytes);
                    if (nbytes == 0 || nbytes == -1) {
                        /* End of stream or error */
                        if (read_fd == client) {
                            close (client);
                            client = -1;
                        }
                        if (read_fd == remote) {
                            close (remote);
                            remote = -1;
                        }
                        break;
                    }
                    sendall (write_fd, buffer, nbytes);
                }
            }
            if (remote != -1) {
                close (remote);
                remote = -1;
            }
            fprintf (stderr, "socks_server: closed remote connection %d/%d\n",
                     count, max_client_connect);
        } while (0); /* Client socket scope. */
        if (client != -1) {
            close (client);
            client = -1;
        }
        fprintf (stderr, "socks_server: closed client connection %d/%d\n",
                 count, max_client_connect);
    }
    close (server_fd);
    fprintf (stderr, "socks_server: closed server\n");
}
 
void socks_server_no_auth (void *socks_server)
{
    socks_server_task (socks_server, NULL, NULL, 1);
}
 
void socks_server_no_auth_delay (void *socks_server)
{
    fprintf (stderr, "socks_server: delay no auth socks server start\n");
    // Enough delay to have client connecting before proxy listens
    msleep (SETTLE_TIME * 10);
    socks_server_task (socks_server, NULL, NULL, 1);
}
 
void socks_server_basic_auth (void *socks_server)
{
    socks_server_task (socks_server, "someuser", "somepass", 1);
}
 
void socks_server_basic_auth_delay (void *socks_server)
{
    fprintf (stderr, "socks_server: delay basic auth socks server start\n");
    // Enough delay to have client connecting before proxy listens
    msleep (SETTLE_TIME * 10);
    socks_server_task (socks_server, "someuser", "somepass", 1);
}
 
void socks_server_basic_auth_no_pass (void *socks_server)
{
    socks_server_task (socks_server, "someuser", NULL, 1);
}
 
void *setup_push_server (char *connect_address, int connect_address_size)
{
    int res;
    const char *bind_address = "tcp://127.0.0.1:*";
    void *push = test_context_socket (ZMQ_PUSH);
    res = zmq_bind (push, bind_address);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    size_t len = connect_address_size;
    res = zmq_getsockopt (push, ZMQ_LAST_ENDPOINT, connect_address, &len);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    fprintf (stderr, "push_server: bound to: %s\n", connect_address);
    return push;
}
 
void *setup_pull_client (const char *connect_address, const char *socks_proxy)
{
    int res;
    void *pull = test_context_socket (ZMQ_PULL);
    if (socks_proxy != NULL) {
        res = zmq_setsockopt (pull, ZMQ_SOCKS_PROXY, socks_proxy,
                              strlen (socks_proxy));
        TEST_ASSERT_SUCCESS_ERRNO (res);
        fprintf (stderr, "pull_client: use socks proxy: tcp://%s\n",
                 socks_proxy);
    }
    res = zmq_connect (pull, connect_address);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    fprintf (stderr, "pull_client: connected to: %s\n", connect_address);
    return pull;
}
 
#ifdef ZMQ_BUILD_DRAFT_API
void *setup_pull_client_with_auth (const char *connect_address,
                                   const char *socks_proxy,
                                   const char *username,
                                   const char *password)
{
    int res;
    void *pull = test_context_socket (ZMQ_PULL);
 
    if (socks_proxy != NULL) {
        res = zmq_setsockopt (pull, ZMQ_SOCKS_PROXY, socks_proxy,
                              strlen (socks_proxy));
        TEST_ASSERT_SUCCESS_ERRNO (res);
        fprintf (stderr, "pull_client: use socks proxy: tcp://%s\n",
                 socks_proxy);
    }
 
    res = zmq_setsockopt (pull, ZMQ_SOCKS_USERNAME, username,
                          username == NULL ? 0 : strlen (username));
    TEST_ASSERT_SUCCESS_ERRNO (res);
 
    res = zmq_setsockopt (pull, ZMQ_SOCKS_PASSWORD, password,
                          password == NULL ? 0 : strlen (password));
    TEST_ASSERT_SUCCESS_ERRNO (res);
 
    res = zmq_connect (pull, connect_address);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    fprintf (stderr, "pull_client: connected to: %s\n", connect_address);
    return pull;
}
#endif
 
void communicate (void *push, void *pull)
{
    fprintf (stderr, "push_server: sending 2 messages\n");
    s_send_seq (push, "ABC", SEQ_END);
    s_send_seq (push, "DEF", SEQ_END);
 
    fprintf (stderr, "pull_client: receiving 2 messages\n");
    s_recv_seq (pull, "ABC", SEQ_END);
    s_recv_seq (pull, "DEF", SEQ_END);
}
 
void test_socks_no_socks (void)
{
    char connect_address[MAX_SOCKET_STRING];
 
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client (connect_address, NULL);
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
}
 
void test_socks (void)
{
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client (connect_address, socks_server_address);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
}
 
void test_socks_delay (void)
{
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client (connect_address, socks_server_address);
    void *thread = zmq_threadstart (&socks_server_no_auth_delay, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
}
 
void test_socks_domainname (void)
{
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
    char connect_address_hostname[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    // Will be resolved by the proxy test server to 127.0.0.1
    strcpy (connect_address_hostname, "tcp://somedomainname.org");
    strcat (connect_address_hostname, strrchr (connect_address, ':'));
    void *pull =
      setup_pull_client (connect_address_hostname, socks_server_address);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
}
 
void test_socks_ipv6 (void)
{
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
    char connect_address_hostname[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    // Will be resolved by the proxy test server to 127.0.0.1
    strcpy (connect_address_hostname, "tcp://::1");
    strcat (connect_address_hostname, strrchr (connect_address, ':'));
    void *pull =
      setup_pull_client (connect_address_hostname, socks_server_address);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
}
 
void test_socks_ipv6_sb (void)
{
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
    char connect_address_hostname[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    // Will be resolved by the proxy test server to 127.0.0.1
    strcpy (connect_address_hostname, "tcp://[::1]");
    strcat (connect_address_hostname, strrchr (connect_address, ':'));
    void *pull =
      setup_pull_client (connect_address_hostname, socks_server_address);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
}
 
void test_socks_bind_before_connect (void)
{
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
    char socks_address_bind_before_connect[MAX_SOCKET_STRING * 2];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    // Will do a bind before connect when connecting to proxy
    strcpy (socks_address_bind_before_connect, "127.0.0.1:0;");
    strcat (socks_address_bind_before_connect, socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull =
      setup_pull_client (connect_address, socks_address_bind_before_connect);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
}
 
void test_socks_basic_auth (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client_with_auth (
      connect_address, socks_server_address, "someuser", "somepass");
    void *thread = zmq_threadstart (&socks_server_basic_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
#else
    TEST_IGNORE_MESSAGE (
      "libzmq without DRAFT support, ignoring socks basic auth test");
#endif
}
 
void test_socks_basic_auth_delay (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client_with_auth (
      connect_address, socks_server_address, "someuser", "somepass");
    void *thread = zmq_threadstart (&socks_server_basic_auth_delay, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
#else
    TEST_IGNORE_MESSAGE (
      "libzmq without DRAFT support, ignoring socks basic auth test");
#endif
}
 
void test_socks_basic_auth_empty_user (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client_with_auth (connect_address,
                                              socks_server_address, "", NULL);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
#else
    TEST_IGNORE_MESSAGE (
      "libzmq without DRAFT support, ignoring socks basic auth test");
#endif
}
 
void test_socks_basic_auth_null_user (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client_with_auth (connect_address,
                                              socks_server_address, NULL, NULL);
    void *thread = zmq_threadstart (&socks_server_no_auth, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
#else
    TEST_IGNORE_MESSAGE (
      "libzmq without DRAFT support, ignoring socks basic auth test");
#endif
}
 
void test_socks_basic_auth_empty_pass (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client_with_auth (
      connect_address, socks_server_address, "someuser", "");
    void *thread = zmq_threadstart (&socks_server_basic_auth_no_pass, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
#else
    TEST_IGNORE_MESSAGE (
      "libzmq without DRAFT support, ignoring socks basic auth test");
#endif
}
 
void test_socks_basic_auth_null_pass (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char socks_server_address[MAX_SOCKET_STRING];
    char connect_address[MAX_SOCKET_STRING];
 
    void *socks =
      setup_socks_server (socks_server_address, sizeof socks_server_address);
    void *push = setup_push_server (connect_address, sizeof connect_address);
    void *pull = setup_pull_client_with_auth (
      connect_address, socks_server_address, "someuser", NULL);
    void *thread = zmq_threadstart (&socks_server_basic_auth_no_pass, socks);
 
    communicate (push, pull);
 
    test_context_socket_close_zero_linger (push);
    test_context_socket_close_zero_linger (pull);
 
    zmq_threadclose (thread);
#else
    TEST_IGNORE_MESSAGE (
      "libzmq without DRAFT support, ignoring socks basic auth test");
#endif
}
 
 
void test_string_opt_ok (const char *msg, int opt, const char *value)
{
    int res;
    void *sub = test_context_socket (ZMQ_SUB);
    fprintf (stderr, "test_string_opt_ok: testing %s\n", msg);
    res = zmq_setsockopt (sub, opt, value, strlen (value));
    TEST_ASSERT_SUCCESS_ERRNO (res);
    char buffer[1024];
    size_t res_len = (size_t) sizeof buffer;
    res = zmq_getsockopt (sub, opt, buffer, &res_len);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    TEST_ASSERT_EQUAL (strlen (value) + 1, res_len);
    TEST_ASSERT (strcmp (buffer, value) == 0);
    test_context_socket_close_zero_linger (sub);
}
 
void test_opt_ok (const char *msg,
                  int opt,
                  const char *value,
                  size_t len,
                  const char *expected_value,
                  size_t expected_len)
{
    int res;
    void *sub = test_context_socket (ZMQ_SUB);
    fprintf (stderr, "test_opt_ok: testing %s\n", msg);
    res = zmq_setsockopt (sub, opt, value, len);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    char buffer[1024];
    size_t res_len = (size_t) sizeof buffer;
    res = zmq_getsockopt (sub, opt, buffer, &res_len);
    TEST_ASSERT_SUCCESS_ERRNO (res);
    TEST_ASSERT_EQUAL (expected_len + 1, res_len);
    TEST_ASSERT_EQUAL (expected_len, strlen (buffer));
    TEST_ASSERT (strncmp (buffer, expected_value, expected_len) == 0);
    test_context_socket_close_zero_linger (sub);
}
 
void test_opt_invalid (const char *msg, int opt, const char *value, int len)
{
    int res;
    void *sub = test_context_socket (ZMQ_SUB);
    fprintf (stderr, "test_opt_invalid: testing %s\n", msg);
    res = zmq_setsockopt (sub, opt, value, len);
    TEST_ASSERT_FAILURE_ERRNO (EINVAL, res);
    test_context_socket_close_zero_linger (sub);
}
 
void test_socks_proxy_options (void)
{
    // NULL is equivalent to not set and returns empty string
    test_opt_ok ("NULL proxy", ZMQ_SOCKS_PROXY, NULL, 0, "", 0);
    test_string_opt_ok ("valid proxy", ZMQ_SOCKS_PROXY, "somehost:1080");
    // Empty value not allowed for proxy server
    test_opt_invalid ("empty proxy", ZMQ_SOCKS_PROXY, "", 0);
}
 
void test_socks_userpass_options (void)
{
#ifdef ZMQ_BUILD_DRAFT_API
    char buffer[1024];
    for (int i = 0; i < (int) sizeof buffer; i++) {
        buffer[i] = 'a' + i % 26;
    }
 
    // NULL is equivalent to not-set or ""
    test_opt_ok ("NULL username", ZMQ_SOCKS_USERNAME, NULL, 0, "", 0);
    // Empty value is allowed for username, means no authentication
    test_string_opt_ok ("empty username", ZMQ_SOCKS_USERNAME, "");
    test_string_opt_ok ("valid username", ZMQ_SOCKS_USERNAME, "someuser");
    test_opt_ok ("255 bytes username", ZMQ_SOCKS_USERNAME, buffer, 255, buffer,
                 255);
    test_opt_invalid ("too long username", ZMQ_SOCKS_USERNAME, buffer, 256);
 
    // NULL is equivalent to not-set or ""
    test_opt_ok ("NULL password", ZMQ_SOCKS_PASSWORD, NULL, 0, "", 0);
    // Empty value allowed for password
    test_string_opt_ok ("empty password", ZMQ_SOCKS_PASSWORD, "");
    test_string_opt_ok ("valid password", ZMQ_SOCKS_PASSWORD, "someuser");
    test_opt_ok ("255 bytes password", ZMQ_SOCKS_PASSWORD, buffer, 255, buffer,
                 255);
    test_opt_invalid ("too long password", ZMQ_SOCKS_PASSWORD, buffer, 256);
#else
    TEST_IGNORE_MESSAGE ("libzmq without DRAFT support, ignoring socks setopt "
                         "username/password test");
#endif
}
 
int main ()
{
    setup_test_environment (180);
 
    UNITY_BEGIN ();
    RUN_TEST (test_socks_proxy_options);
    RUN_TEST (test_socks_userpass_options);
    RUN_TEST (test_socks_no_socks);
    RUN_TEST (test_socks);
    RUN_TEST (test_socks_delay);
    RUN_TEST (test_socks_domainname);
    RUN_TEST (test_socks_ipv6);
    RUN_TEST (test_socks_ipv6_sb);
    RUN_TEST (test_socks_bind_before_connect);
    RUN_TEST (test_socks_basic_auth);
    RUN_TEST (test_socks_basic_auth_delay);
    RUN_TEST (test_socks_basic_auth_empty_user);
    RUN_TEST (test_socks_basic_auth_null_user);
    RUN_TEST (test_socks_basic_auth_empty_pass);
    RUN_TEST (test_socks_basic_auth_null_pass);
    return UNITY_END ();
}