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
test_fd_is_socket_bad(void)27 static 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
test_fd_is_socket_good(void)42 static 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
52 static int mon_fd = -1;
53 static const char *mon_fdname;
54 __thread Monitor *cur_mon;
55
monitor_get_fd(Monitor * mon,const char * fdname,Error ** errp)56 int 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 */
monitor_cur(void)74 Monitor *monitor_cur(void) { return cur_mon; }
monitor_set_cur(Coroutine * co,Monitor * mon)75 Monitor *monitor_set_cur(Coroutine *co, Monitor *mon) { abort(); }
monitor_vprintf(Monitor * mon,const char * fmt,va_list ap)76 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); }
77
78 #ifndef _WIN32
test_socket_fd_pass_name_good(void)79 static 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
test_socket_fd_pass_name_bad(void)110 static 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
test_socket_fd_pass_name_nomon(void)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
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
test_socket_fd_pass_num_good(void)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
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
test_socket_fd_pass_num_bad(void)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
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
test_socket_fd_pass_num_nocli(void)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
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
236 typedef struct {
237 SocketAddress *server, *client[ABSTRACT_SOCKET_VARIANTS];
238 bool expect_connect[ABSTRACT_SOCKET_VARIANTS];
239 } abstract_socket_matrix_row;
240
unix_client_thread_func(gpointer user_data)241 static 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
test_socket_unix_abstract_row(abstract_socket_matrix_row * test)261 static 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
test_socket_unix_abstract(void)291 static 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 unlink(addr.u.q_unix.path);
330 g_free(addr.u.q_unix.path);
331 }
332
333 #endif /* CONFIG_LINUX */
334
main(int argc,char ** argv)335 int main(int argc, char **argv)
336 {
337 bool has_ipv4, has_ipv6;
338
339 qemu_init_main_loop(&error_abort);
340 socket_init();
341
342 g_test_init(&argc, &argv, NULL);
343
344 /* We're creating actual IPv4/6 sockets, so we should
345 * check if the host running tests actually supports
346 * each protocol to avoid breaking tests on machines
347 * with either IPv4 or IPv6 disabled.
348 */
349 if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) {
350 g_printerr("socket_check_protocol_support() failed\n");
351 goto end;
352 }
353
354 if (has_ipv4) {
355 g_test_add_func("/util/socket/is-socket/bad",
356 test_fd_is_socket_bad);
357 g_test_add_func("/util/socket/is-socket/good",
358 test_fd_is_socket_good);
359 #ifndef _WIN32
360 g_test_add_func("/socket/fd-pass/name/good",
361 test_socket_fd_pass_name_good);
362 g_test_add_func("/socket/fd-pass/name/bad",
363 test_socket_fd_pass_name_bad);
364 g_test_add_func("/socket/fd-pass/name/nomon",
365 test_socket_fd_pass_name_nomon);
366 g_test_add_func("/socket/fd-pass/num/good",
367 test_socket_fd_pass_num_good);
368 g_test_add_func("/socket/fd-pass/num/bad",
369 test_socket_fd_pass_num_bad);
370 g_test_add_func("/socket/fd-pass/num/nocli",
371 test_socket_fd_pass_num_nocli);
372 #endif
373 }
374
375 #ifdef CONFIG_LINUX
376 g_test_add_func("/util/socket/unix-abstract",
377 test_socket_unix_abstract);
378 #endif
379
380 end:
381 return g_test_run();
382 }
383