LXR qemu/tests/unit/test-util-sockets.c

   1/*
   2 * Tests for util/qemu-sockets.c
   3 *
   4 * Copyright 2018 Red Hat, Inc.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this library; if not, see <http://www.gnu.org/licenses/>.
  18 *
  19 */
  20
  21#include "qemu/osdep.h"
  22#include "qemu/sockets.h"
  23#include "qapi/error.h"
  24#include "socket-helpers.h"
  25#include "monitor/monitor.h"
  26
  27static void test_fd_is_socket_bad(void)
  28{
  29    char *tmp = g_strdup("qemu-test-util-sockets-XXXXXX");
  30    int fd = mkstemp(tmp);
  31    if (fd != 0) {
  32        unlink(tmp);
  33    }
  34    g_free(tmp);
  35
  36    g_assert(fd >= 0);
  37
  38    g_assert(!fd_is_socket(fd));
  39    close(fd);
  40}
  41
  42static void test_fd_is_socket_good(void)
  43{
  44    int fd = qemu_socket(PF_INET, SOCK_STREAM, 0);
  45
  46    g_assert(fd >= 0);
  47
  48    g_assert(fd_is_socket(fd));
  49    close(fd);
  50}
  51
  52static int mon_fd = -1;
  53static const char *mon_fdname;
  54__thread Monitor *cur_mon;
  55
  56int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
  57{
  58    g_assert(cur_mon);
  59    g_assert(mon == cur_mon);
  60    if (mon_fd == -1 || !g_str_equal(mon_fdname, fdname)) {
  61        error_setg(errp, "No fd named %s", fdname);
  62        return -1;
  63    }
  64    return dup(mon_fd);
  65}
  66
  67/*
  68 * Syms of stubs in libqemuutil.a are discarded at .o file
  69 * granularity.  To replace monitor_get_fd() and monitor_cur(), we
  70 * must ensure that we also replace any other symbol that is used in
  71 * the binary and would be taken from the same stub object file,
  72 * otherwise we get duplicate syms at link time.
  73 */
  74Monitor *monitor_cur(void) { return cur_mon; }
  75Monitor *monitor_set_cur(Coroutine *co, Monitor *mon) { abort(); }
  76int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); }
  77
  78#ifndef _WIN32
  79static void test_socket_fd_pass_name_good(void)
  80{
  81    SocketAddress addr;
  82    int fd;
  83
  84    cur_mon = g_malloc(1); /* Fake a monitor */
  85    mon_fdname = "myfd";
  86    mon_fd = qemu_socket(AF_INET, SOCK_STREAM, 0);
  87    g_assert_cmpint(mon_fd, >, STDERR_FILENO);
  88
  89    addr.type = SOCKET_ADDRESS_TYPE_FD;
  90    addr.u.fd.str = g_strdup(mon_fdname);
  91
  92    fd = socket_connect(&addr, &error_abort);
  93    g_assert_cmpint(fd, !=, -1);
  94    g_assert_cmpint(fd, !=, mon_fd);
  95    close(fd);
  96
  97    fd = socket_listen(&addr, 1, &error_abort);
  98    g_assert_cmpint(fd, !=, -1);
  99    g_assert_cmpint(fd, !=, mon_fd);
 100    close(fd);
 101
 102    g_free(addr.u.fd.str);
 103    mon_fdname = NULL;
 104    close(mon_fd);
 105    mon_fd = -1;
 106    g_free(cur_mon);
 107    cur_mon = NULL;
 108}
 109
 110static void test_socket_fd_pass_name_bad(void)
 111{
 112    SocketAddress addr;
 113    Error *err = NULL;
 114    int fd;
 115
 116    cur_mon = g_malloc(1); /* Fake a monitor */
 117    mon_fdname = "myfd";
 118    mon_fd = dup(STDOUT_FILENO);
 119    g_assert_cmpint(mon_fd, >, STDERR_FILENO);
 120
 121    addr.type = SOCKET_ADDRESS_TYPE_FD;
 122    addr.u.fd.str = g_strdup(mon_fdname);
 123
 124    fd = socket_connect(&addr, &err);
 125    g_assert_cmpint(fd, ==, -1);
 126    error_free_or_abort(&err);
 127
 128    fd = socket_listen(&addr, 1, &err);
 129    g_assert_cmpint(fd, ==, -1);
 130    error_free_or_abort(&err);
 131
 132    g_free(addr.u.fd.str);
 133    mon_fdname = NULL;
 134    close(mon_fd);
 135    mon_fd = -1;
 136    g_free(cur_mon);
 137    cur_mon = NULL;
 138}
 139
 140static void test_socket_fd_pass_name_nomon(void)
 141{
 142    SocketAddress addr;
 143    Error *err = NULL;
 144    int fd;
 145
 146    g_assert(cur_mon == NULL);
 147
 148    addr.type = SOCKET_ADDRESS_TYPE_FD;
 149    addr.u.fd.str = g_strdup("myfd");
 150
 151    fd = socket_connect(&addr, &err);
 152    g_assert_cmpint(fd, ==, -1);
 153    error_free_or_abort(&err);
 154
 155    fd = socket_listen(&addr, 1, &err);
 156    g_assert_cmpint(fd, ==, -1);
 157    error_free_or_abort(&err);
 158
 159    g_free(addr.u.fd.str);
 160}
 161
 162
 163static void test_socket_fd_pass_num_good(void)
 164{
 165    SocketAddress addr;
 166    int fd, sfd;
 167
 168    g_assert(cur_mon == NULL);
 169    sfd = qemu_socket(AF_INET, SOCK_STREAM, 0);
 170    g_assert_cmpint(sfd, >, STDERR_FILENO);
 171
 172    addr.type = SOCKET_ADDRESS_TYPE_FD;
 173    addr.u.fd.str = g_strdup_printf("%d", sfd);
 174
 175    fd = socket_connect(&addr, &error_abort);
 176    g_assert_cmpint(fd, ==, sfd);
 177
 178    fd = socket_listen(&addr, 1, &error_abort);
 179    g_assert_cmpint(fd, ==, sfd);
 180
 181    g_free(addr.u.fd.str);
 182    close(sfd);
 183}
 184
 185static void test_socket_fd_pass_num_bad(void)
 186{
 187    SocketAddress addr;
 188    Error *err = NULL;
 189    int fd, sfd;
 190
 191    g_assert(cur_mon == NULL);
 192    sfd = dup(STDOUT_FILENO);
 193
 194    addr.type = SOCKET_ADDRESS_TYPE_FD;
 195    addr.u.fd.str = g_strdup_printf("%d", sfd);
 196
 197    fd = socket_connect(&addr, &err);
 198    g_assert_cmpint(fd, ==, -1);
 199    error_free_or_abort(&err);
 200
 201    fd = socket_listen(&addr, 1, &err);
 202    g_assert_cmpint(fd, ==, -1);
 203    error_free_or_abort(&err);
 204
 205    g_free(addr.u.fd.str);
 206    close(sfd);
 207}
 208
 209static void test_socket_fd_pass_num_nocli(void)
 210{
 211    SocketAddress addr;
 212    Error *err = NULL;
 213    int fd;
 214
 215    cur_mon = g_malloc(1); /* Fake a monitor */
 216
 217    addr.type = SOCKET_ADDRESS_TYPE_FD;
 218    addr.u.fd.str = g_strdup_printf("%d", STDOUT_FILENO);
 219
 220    fd = socket_connect(&addr, &err);
 221    g_assert_cmpint(fd, ==, -1);
 222    error_free_or_abort(&err);
 223
 224    fd = socket_listen(&addr, 1, &err);
 225    g_assert_cmpint(fd, ==, -1);
 226    error_free_or_abort(&err);
 227
 228    g_free(addr.u.fd.str);
 229}
 230#endif
 231
 232#ifdef CONFIG_LINUX
 233
 234#define ABSTRACT_SOCKET_VARIANTS 3
 235
 236typedef struct {
 237    SocketAddress *server, *client[ABSTRACT_SOCKET_VARIANTS];
 238    bool expect_connect[ABSTRACT_SOCKET_VARIANTS];
 239} abstract_socket_matrix_row;
 240
 241static gpointer unix_client_thread_func(gpointer user_data)
 242{
 243    abstract_socket_matrix_row *row = user_data;
 244    Error *err = NULL;
 245    int i, fd;
 246
 247    for (i = 0; i < ABSTRACT_SOCKET_VARIANTS; i++) {
 248        if (row->expect_connect[i]) {
 249            fd = socket_connect(row->client[i], &error_abort);
 250            g_assert_cmpint(fd, >=, 0);
 251        } else {
 252            fd = socket_connect(row->client[i], &err);
 253            g_assert_cmpint(fd, ==, -1);
 254            error_free_or_abort(&err);
 255        }
 256        close(fd);
 257    }
 258    return NULL;
 259}
 260
 261static void test_socket_unix_abstract_row(abstract_socket_matrix_row *test)
 262{
 263    int fd, connfd, i;
 264    GThread *cli;
 265    struct sockaddr_un un;
 266    socklen_t len = sizeof(un);
 267
 268    /* Last one must connect, or else accept() below hangs */
 269    assert(test->expect_connect[ABSTRACT_SOCKET_VARIANTS - 1]);
 270
 271    fd = socket_listen(test->server, 1, &error_abort);
 272    g_assert_cmpint(fd, >=, 0);
 273    g_assert(fd_is_socket(fd));
 274
 275    cli = g_thread_new("abstract_unix_client",
 276                       unix_client_thread_func,
 277                       test);
 278
 279    for (i = 0; i < ABSTRACT_SOCKET_VARIANTS; i++) {
 280        if (test->expect_connect[i]) {
 281            connfd = accept(fd, (struct sockaddr *)&un, &len);
 282            g_assert_cmpint(connfd, !=, -1);
 283            close(connfd);
 284        }
 285    }
 286
 287    close(fd);
 288    g_thread_join(cli);
 289}
 290
 291static void test_socket_unix_abstract(void)
 292{
 293    SocketAddress addr, addr_tight, addr_padded;
 294    abstract_socket_matrix_row matrix[ABSTRACT_SOCKET_VARIANTS] = {
 295        { &addr,
 296          { &addr_tight, &addr_padded, &addr },
 297          { true, false, true } },
 298        { &addr_tight,
 299          { &addr_padded, &addr, &addr_tight },
 300          { false, true, true } },
 301        { &addr_padded,
 302          { &addr, &addr_tight, &addr_padded },
 303          { false, false, true } }
 304    };
 305    int i;
 306
 307    i = g_file_open_tmp("unix-XXXXXX", &addr.u.q_unix.path, NULL);
 308    g_assert_true(i >= 0);
 309    close(i);
 310
 311    addr.type = SOCKET_ADDRESS_TYPE_UNIX;
 312    addr.u.q_unix.has_abstract = true;
 313    addr.u.q_unix.abstract = true;
 314    addr.u.q_unix.has_tight = false;
 315    addr.u.q_unix.tight = false;
 316
 317    addr_tight = addr;
 318    addr_tight.u.q_unix.has_tight = true;
 319    addr_tight.u.q_unix.tight = true;
 320
 321    addr_padded = addr;
 322    addr_padded.u.q_unix.has_tight = true;
 323    addr_padded.u.q_unix.tight = false;
 324
 325    for (i = 0; i < ABSTRACT_SOCKET_VARIANTS; i++) {
 326        test_socket_unix_abstract_row(&matrix[i]);
 327    }
 328
 329    g_free(addr.u.q_unix.path);
 330}
 331
 332#endif  /* CONFIG_LINUX */
 333
 334int main(int argc, char **argv)
 335{
 336    bool has_ipv4, has_ipv6;
 337
 338    qemu_init_main_loop(&error_abort);
 339    socket_init();
 340
 341    g_test_init(&argc, &argv, NULL);
 342
 343    /* We're creating actual IPv4/6 sockets, so we should
 344     * check if the host running tests actually supports
 345     * each protocol to avoid breaking tests on machines
 346     * with either IPv4 or IPv6 disabled.
 347     */
 348    if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) {
 349        g_printerr("socket_check_protocol_support() failed\n");
 350        goto end;
 351    }
 352
 353    if (has_ipv4) {
 354        g_test_add_func("/util/socket/is-socket/bad",
 355                        test_fd_is_socket_bad);
 356        g_test_add_func("/util/socket/is-socket/good",
 357                        test_fd_is_socket_good);
 358#ifndef _WIN32
 359        g_test_add_func("/socket/fd-pass/name/good",
 360                        test_socket_fd_pass_name_good);
 361        g_test_add_func("/socket/fd-pass/name/bad",
 362                        test_socket_fd_pass_name_bad);
 363        g_test_add_func("/socket/fd-pass/name/nomon",
 364                        test_socket_fd_pass_name_nomon);
 365        g_test_add_func("/socket/fd-pass/num/good",
 366                        test_socket_fd_pass_num_good);
 367        g_test_add_func("/socket/fd-pass/num/bad",
 368                        test_socket_fd_pass_num_bad);
 369        g_test_add_func("/socket/fd-pass/num/nocli",
 370                        test_socket_fd_pass_num_nocli);
 371#endif
 372    }
 373
 374#ifdef CONFIG_LINUX
 375    g_test_add_func("/util/socket/unix-abstract",
 376                    test_socket_unix_abstract);
 377#endif
 378
 379end:
 380    return g_test_run();
 381}
 382