[mirror_qemu.git] / tests / 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; }
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 __linux__
static gpointer unix_server_thread_func(gpointer user_data)
{
    SocketAddress *addr = user_data;
    int fd;
    int connfd;
    struct sockaddr_un un;
    socklen_t len = sizeof(un);

    fd = socket_listen(addr, 1, &error_abort);
    g_assert_cmpint(fd, >=, 0);
    g_assert(fd_is_socket(fd));

    connfd = accept(fd, (struct sockaddr *)&un, &len);
    g_assert_cmpint(connfd, !=, -1);
    close(connfd);

    close(fd);
    return NULL;
}

static gpointer unix_client_thread_func(gpointer user_data)
{
    SocketAddress *addr = user_data;
    int fd;

    fd = socket_connect(addr, &error_abort);
    g_assert_cmpint(fd, >=, 0);
    close(fd);
    return NULL;
}

static void test_socket_unix_abstract_one(SocketAddress *addr)
{
    GThread *serv, *cli;

    serv = g_thread_new("abstract_unix_server",
                        unix_server_thread_func,
                        addr);

    sleep(1);

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

    g_thread_join(cli);
    g_thread_join(serv);
}

static void test_socket_unix_abstract_good(void)
{
    SocketAddress addr;

    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;

    /* non tight socklen serv and cli */
    addr.u.q_unix.has_tight = false;
    addr.u.q_unix.tight = false;
    test_socket_unix_abstract_one(&addr);

    /* tight socklen serv and cli */
    addr.u.q_unix.has_tight = true;
    addr.u.q_unix.tight = true;
    test_socket_unix_abstract_one(&addr);

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

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 __linux__
    g_test_add_func("/util/socket/unix-abstract/good",
                    test_socket_unix_abstract_good);
#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; }
637de4db	76	int monitor_vprintf(Monitor mon, const char fmt, va_list ap) { abort(); }
30bdb3c5	77
8330bd53	78	#ifndef _WIN32
1723d6b1	79	static void test_socket_fd_pass_name_good(void)
30bdb3c5 DB	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
e5b6353c	97	fd = socket_listen(&addr, 1, &error_abort);
30bdb3c5 DB	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
1723d6b1	110	static void test_socket_fd_pass_name_bad(void)
30bdb3c5 DB	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
e5b6353c	128	fd = socket_listen(&addr, 1, &err);
30bdb3c5 DB	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
1723d6b1 DB	140	static 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
e5b6353c	155	fd = socket_listen(&addr, 1, &err);
1723d6b1 DB	156	g_assert_cmpint(fd, ==, -1);
	157	error_free_or_abort(&err);
	158
	159	g_free(addr.u.fd.str);
	160	}
	161
	162
	163	static 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
e5b6353c	178	fd = socket_listen(&addr, 1, &error_abort);
1723d6b1 DB	179	g_assert_cmpint(fd, ==, sfd);
	180
	181	g_free(addr.u.fd.str);
	182	close(sfd);
	183	}
	184
	185	static 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
e5b6353c	201	fd = socket_listen(&addr, 1, &err);
1723d6b1 DB	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
	209	static 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
e5b6353c	224	fd = socket_listen(&addr, 1, &err);
1723d6b1 DB	225	g_assert_cmpint(fd, ==, -1);
	226	error_free_or_abort(&err);
	227
	228	g_free(addr.u.fd.str);
	229	}
8330bd53	230	#endif
1723d6b1	231
4d3a329a	232	#ifdef __linux__
4d3a329a XZ	233	static gpointer unix_server_thread_func(gpointer user_data)
4d3a329a XZ	234	{
718a9be0 MA	235	SocketAddress *addr = user_data;
	236	int fd;
	237	int connfd;
4d3a329a XZ	238	struct sockaddr_un un;
	239	socklen_t len = sizeof(un);
	240
718a9be0	241	fd = socket_listen(addr, 1, &error_abort);
4d3a329a XZ	242	g_assert_cmpint(fd, >=, 0);
	243	g_assert(fd_is_socket(fd));
	244
	245	connfd = accept(fd, (struct sockaddr *)&un, &len);
	246	g_assert_cmpint(connfd, !=, -1);
9ce22da0	247	close(connfd);
4d3a329a XZ	248
4d3a329a XZ	249	close(fd);
4d3a329a XZ	250	return NULL;
	251	}
	252
	253	static gpointer unix_client_thread_func(gpointer user_data)
	254	{
718a9be0 MA	255	SocketAddress *addr = user_data;
718a9be0 MA	256	int fd;
4d3a329a	257
718a9be0	258	fd = socket_connect(addr, &error_abort);
4d3a329a	259	g_assert_cmpint(fd, >=, 0);
4d3a329a	260	close(fd);
4d3a329a XZ	261	return NULL;
	262	}
	263
89cb0bb5 MA	264	static void test_socket_unix_abstract_one(SocketAddress *addr)
	265	{
	266	GThread serv, cli;
	267
	268	serv = g_thread_new("abstract_unix_server",
	269	unix_server_thread_func,
	270	addr);
	271
	272	sleep(1);
	273
	274	cli = g_thread_new("abstract_unix_client",
	275	unix_client_thread_func,
	276	addr);
	277
	278	g_thread_join(cli);
	279	g_thread_join(serv);
	280	}
	281
4d3a329a XZ	282	static void test_socket_unix_abstract_good(void)
4d3a329a XZ	283	{
718a9be0	284	SocketAddress addr;
4d3a329a	285
718a9be0 MA	286	addr.type = SOCKET_ADDRESS_TYPE_UNIX;
	287	addr.u.q_unix.path = g_strdup_printf("unix-%d-%u",
	288	getpid(), g_random_int());
	289	addr.u.q_unix.has_abstract = true;
	290	addr.u.q_unix.abstract = true;
4d3a329a XZ	291
4d3a329a XZ	292	/* non tight socklen serv and cli */
718a9be0 MA	293	addr.u.q_unix.has_tight = false;
718a9be0 MA	294	addr.u.q_unix.tight = false;
89cb0bb5	295	test_socket_unix_abstract_one(&addr);
4d3a329a XZ	296
4d3a329a XZ	297	/* tight socklen serv and cli */
718a9be0 MA	298	addr.u.q_unix.has_tight = true;
718a9be0 MA	299	addr.u.q_unix.tight = true;
89cb0bb5	300	test_socket_unix_abstract_one(&addr);
4d3a329a	301
718a9be0	302	g_free(addr.u.q_unix.path);
4d3a329a XZ	303	}
4d3a329a XZ	304	#endif
1723d6b1	305
58dc31f1 DB	306	int main(int argc, char **argv)
	307	{
	308	bool has_ipv4, has_ipv6;
	309
8330bd53	310	qemu_init_main_loop(&error_abort);
58dc31f1 DB	311	socket_init();
	312
	313	g_test_init(&argc, &argv, NULL);
	314
	315	/* We're creating actual IPv4/6 sockets, so we should
	316	* check if the host running tests actually supports
	317	* each protocol to avoid breaking tests on machines
	318	* with either IPv4 or IPv6 disabled.
	319	*/
	320	if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) {
a4eb74a6 MAL	321	g_printerr("socket_check_protocol_support() failed\n");
a4eb74a6 MAL	322	goto end;
58dc31f1 DB	323	}
	324
	325	if (has_ipv4) {
	326	g_test_add_func("/util/socket/is-socket/bad",
	327	test_fd_is_socket_bad);
	328	g_test_add_func("/util/socket/is-socket/good",
	329	test_fd_is_socket_good);
8330bd53	330	#ifndef _WIN32
1723d6b1 DB	331	g_test_add_func("/socket/fd-pass/name/good",
	332	test_socket_fd_pass_name_good);
	333	g_test_add_func("/socket/fd-pass/name/bad",
	334	test_socket_fd_pass_name_bad);
	335	g_test_add_func("/socket/fd-pass/name/nomon",
	336	test_socket_fd_pass_name_nomon);
	337	g_test_add_func("/socket/fd-pass/num/good",
	338	test_socket_fd_pass_num_good);
	339	g_test_add_func("/socket/fd-pass/num/bad",
	340	test_socket_fd_pass_num_bad);
	341	g_test_add_func("/socket/fd-pass/num/nocli",
	342	test_socket_fd_pass_num_nocli);
8330bd53	343	#endif
58dc31f1 DB	344	}
58dc31f1 DB	345
4d3a329a XZ	346	#ifdef __linux__
	347	g_test_add_func("/util/socket/unix-abstract/good",
	348	test_socket_unix_abstract_good);
	349	#endif
	350
a4eb74a6	351	end:
58dc31f1 DB	352	return g_test_run();
58dc31f1 DB	353	}