[mirror_qemu.git] / tests / unit / test-util-sockets.c

/*
 * Tests for util/qemu-sockets.c
 *
 * Copyright 2018 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "qemu/osdep.h"
#include "qemu-common.h"
#include "qemu/sockets.h"
#include "qapi/error.h"
#include "socket-helpers.h"
#include "monitor/monitor.h"

static void test_fd_is_socket_bad(void)
{
    char *tmp = g_strdup("qemu-test-util-sockets-XXXXXX");
    int fd = mkstemp(tmp);
    if (fd != 0) {
        unlink(tmp);
    }
    g_free(tmp);

    g_assert(fd >= 0);

    g_assert(!fd_is_socket(fd));
    close(fd);
}

static void test_fd_is_socket_good(void)
{
    int fd = qemu_socket(PF_INET, SOCK_STREAM, 0);

    g_assert(fd >= 0);

    g_assert(fd_is_socket(fd));
    close(fd);
}

static int mon_fd = -1;
static const char *mon_fdname;
__thread Monitor *cur_mon;

int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
{
    g_assert(cur_mon);
    g_assert(mon == cur_mon);
    if (mon_fd == -1 || !g_str_equal(mon_fdname, fdname)) {
        error_setg(errp, "No fd named %s", fdname);
        return -1;
    }
    return dup(mon_fd);
}

/*
 * Syms of stubs in libqemuutil.a are discarded at .o file
 * granularity.  To replace monitor_get_fd() and monitor_cur(), we
 * must ensure that we also replace any other symbol that is used in
 * the binary and would be taken from the same stub object file,
 * otherwise we get duplicate syms at link time.
 */
Monitor *monitor_cur(void) { return cur_mon; }
Monitor *monitor_set_cur(Coroutine *co, Monitor *mon) { abort(); }
int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); }

#ifndef _WIN32
static void test_socket_fd_pass_name_good(void)
{
    SocketAddress addr;
    int fd;

    cur_mon = g_malloc(1); /* Fake a monitor */
    mon_fdname = "myfd";
    mon_fd = qemu_socket(AF_INET, SOCK_STREAM, 0);
    g_assert_cmpint(mon_fd, >, STDERR_FILENO);

    addr.type = SOCKET_ADDRESS_TYPE_FD;
    addr.u.fd.str = g_strdup(mon_fdname);

    fd = socket_connect(&addr, &error_abort);
    g_assert_cmpint(fd, !=, -1);
    g_assert_cmpint(fd, !=, mon_fd);
    close(fd);

    fd = socket_listen(&addr, 1, &error_abort);
    g_assert_cmpint(fd, !=, -1);
    g_assert_cmpint(fd, !=, mon_fd);
    close(fd);

    g_free(addr.u.fd.str);
    mon_fdname = NULL;
    close(mon_fd);
    mon_fd = -1;
    g_free(cur_mon);
    cur_mon = NULL;
}

static void test_socket_fd_pass_name_bad(void)
{
    SocketAddress addr;
    Error *err = NULL;
    int fd;

    cur_mon = g_malloc(1); /* Fake a monitor */
    mon_fdname = "myfd";
    mon_fd = dup(STDOUT_FILENO);
    g_assert_cmpint(mon_fd, >, STDERR_FILENO);

    addr.type = SOCKET_ADDRESS_TYPE_FD;
    addr.u.fd.str = g_strdup(mon_fdname);

    fd = socket_connect(&addr, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    fd = socket_listen(&addr, 1, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    g_free(addr.u.fd.str);
    mon_fdname = NULL;
    close(mon_fd);
    mon_fd = -1;
    g_free(cur_mon);
    cur_mon = NULL;
}

static void test_socket_fd_pass_name_nomon(void)
{
    SocketAddress addr;
    Error *err = NULL;
    int fd;

    g_assert(cur_mon == NULL);

    addr.type = SOCKET_ADDRESS_TYPE_FD;
    addr.u.fd.str = g_strdup("myfd");

    fd = socket_connect(&addr, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    fd = socket_listen(&addr, 1, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    g_free(addr.u.fd.str);
}


static void test_socket_fd_pass_num_good(void)
{
    SocketAddress addr;
    int fd, sfd;

    g_assert(cur_mon == NULL);
    sfd = qemu_socket(AF_INET, SOCK_STREAM, 0);
    g_assert_cmpint(sfd, >, STDERR_FILENO);

    addr.type = SOCKET_ADDRESS_TYPE_FD;
    addr.u.fd.str = g_strdup_printf("%d", sfd);

    fd = socket_connect(&addr, &error_abort);
    g_assert_cmpint(fd, ==, sfd);

    fd = socket_listen(&addr, 1, &error_abort);
    g_assert_cmpint(fd, ==, sfd);

    g_free(addr.u.fd.str);
    close(sfd);
}

static void test_socket_fd_pass_num_bad(void)
{
    SocketAddress addr;
    Error *err = NULL;
    int fd, sfd;

    g_assert(cur_mon == NULL);
    sfd = dup(STDOUT_FILENO);

    addr.type = SOCKET_ADDRESS_TYPE_FD;
    addr.u.fd.str = g_strdup_printf("%d", sfd);

    fd = socket_connect(&addr, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    fd = socket_listen(&addr, 1, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    g_free(addr.u.fd.str);
    close(sfd);
}

static void test_socket_fd_pass_num_nocli(void)
{
    SocketAddress addr;
    Error *err = NULL;
    int fd;

    cur_mon = g_malloc(1); /* Fake a monitor */

    addr.type = SOCKET_ADDRESS_TYPE_FD;
    addr.u.fd.str = g_strdup_printf("%d", STDOUT_FILENO);

    fd = socket_connect(&addr, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    fd = socket_listen(&addr, 1, &err);
    g_assert_cmpint(fd, ==, -1);
    error_free_or_abort(&err);

    g_free(addr.u.fd.str);
}
#endif

#ifdef CONFIG_LINUX

#define ABSTRACT_SOCKET_VARIANTS 3

typedef struct {
    SocketAddress *server, *client[ABSTRACT_SOCKET_VARIANTS];
    bool expect_connect[ABSTRACT_SOCKET_VARIANTS];
} abstract_socket_matrix_row;

static gpointer unix_client_thread_func(gpointer user_data)
{
    abstract_socket_matrix_row *row = user_data;
    Error *err = NULL;
    int i, fd;

    for (i = 0; i < ABSTRACT_SOCKET_VARIANTS; i++) {
        if (row->expect_connect[i]) {
            fd = socket_connect(row->client[i], &error_abort);
            g_assert_cmpint(fd, >=, 0);
        } else {
            fd = socket_connect(row->client[i], &err);
            g_assert_cmpint(fd, ==, -1);
            error_free_or_abort(&err);
        }
        close(fd);
    }
    return NULL;
}

static void test_socket_unix_abstract_row(abstract_socket_matrix_row *test)
{
    int fd, connfd, i;
    GThread *cli;
    struct sockaddr_un un;
    socklen_t len = sizeof(un);

    /* Last one must connect, or else accept() below hangs */
    assert(test->expect_connect[ABSTRACT_SOCKET_VARIANTS - 1]);

    fd = socket_listen(test->server, 1, &error_abort);
    g_assert_cmpint(fd, >=, 0);
    g_assert(fd_is_socket(fd));

    cli = g_thread_new("abstract_unix_client",
                       unix_client_thread_func,
                       test);

    for (i = 0; i < ABSTRACT_SOCKET_VARIANTS; i++) {
        if (test->expect_connect[i]) {
            connfd = accept(fd, (struct sockaddr *)&un, &len);
            g_assert_cmpint(connfd, !=, -1);
            close(connfd);
        }
    }

    close(fd);
    g_thread_join(cli);
}

static void test_socket_unix_abstract(void)
{
    SocketAddress addr, addr_tight, addr_padded;
    abstract_socket_matrix_row matrix[ABSTRACT_SOCKET_VARIANTS] = {
        { &addr,
          { &addr_tight, &addr_padded, &addr },
          { true, false, true } },
        { &addr_tight,
          { &addr_padded, &addr, &addr_tight },
          { false, true, true } },
        { &addr_padded,
          { &addr, &addr_tight, &addr_padded },
          { false, false, true } }
    };
    int i;

    addr.type = SOCKET_ADDRESS_TYPE_UNIX;
    addr.u.q_unix.path = g_strdup_printf("unix-%d-%u",
                                         getpid(), g_random_int());
    addr.u.q_unix.has_abstract = true;
    addr.u.q_unix.abstract = true;
    addr.u.q_unix.has_tight = false;
    addr.u.q_unix.tight = false;

    addr_tight = addr;
    addr_tight.u.q_unix.has_tight = true;
    addr_tight.u.q_unix.tight = true;

    addr_padded = addr;
    addr_padded.u.q_unix.has_tight = true;
    addr_padded.u.q_unix.tight = false;

    for (i = 0; i < ABSTRACT_SOCKET_VARIANTS; i++) {
        test_socket_unix_abstract_row(&matrix[i]);
    }

    g_free(addr.u.q_unix.path);
}

#endif  /* CONFIG_LINUX */

int main(int argc, char **argv)
{
    bool has_ipv4, has_ipv6;

    qemu_init_main_loop(&error_abort);
    socket_init();

    g_test_init(&argc, &argv, NULL);

    /* We're creating actual IPv4/6 sockets, so we should
     * check if the host running tests actually supports
     * each protocol to avoid breaking tests on machines
     * with either IPv4 or IPv6 disabled.
     */
    if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) {
        g_printerr("socket_check_protocol_support() failed\n");
        goto end;
    }

    if (has_ipv4) {
        g_test_add_func("/util/socket/is-socket/bad",
                        test_fd_is_socket_bad);
        g_test_add_func("/util/socket/is-socket/good",
                        test_fd_is_socket_good);
#ifndef _WIN32
        g_test_add_func("/socket/fd-pass/name/good",
                        test_socket_fd_pass_name_good);
        g_test_add_func("/socket/fd-pass/name/bad",
                        test_socket_fd_pass_name_bad);
        g_test_add_func("/socket/fd-pass/name/nomon",
                        test_socket_fd_pass_name_nomon);
        g_test_add_func("/socket/fd-pass/num/good",
                        test_socket_fd_pass_num_good);
        g_test_add_func("/socket/fd-pass/num/bad",
                        test_socket_fd_pass_num_bad);
        g_test_add_func("/socket/fd-pass/num/nocli",
                        test_socket_fd_pass_num_nocli);
#endif
    }

#ifdef CONFIG_LINUX
    g_test_add_func("/util/socket/unix-abstract",
                    test_socket_unix_abstract);
#endif

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