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"
26 #include "monitor/monitor.h"
27
test_fd_is_socket_bad(void)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
test_fd_is_socket_good(void)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
53 static int mon_fd = -1;
54 static const char *mon_fdname;
55 __thread Monitor *cur_mon;
56
monitor_get_fd(Monitor * mon,const char * fdname,Error ** errp)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
68 /*
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,
73 * otherwise we get duplicate syms at link time.
74 */
monitor_cur(void)75 Monitor *monitor_cur(void) { return cur_mon; }
monitor_set_cur(Coroutine * co,Monitor * mon)76 Monitor *monitor_set_cur(Coroutine *co, Monitor *mon) { abort(); }
monitor_vprintf(Monitor * mon,const char * fmt,va_list ap)77 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); }
78
79 #ifndef _WIN32
test_socket_fd_pass_name_good(void)80 static void test_socket_fd_pass_name_good(void)
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
98 fd = socket_listen(&addr, 1, &error_abort);
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
test_socket_fd_pass_name_bad(void)111 static void test_socket_fd_pass_name_bad(void)
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
129 fd = socket_listen(&addr, 1, &err);
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
test_socket_fd_pass_name_nomon(void)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
156 fd = socket_listen(&addr, 1, &err);
157 g_assert_cmpint(fd, ==, -1);
158 error_free_or_abort(&err);
159
160 g_free(addr.u.fd.str);
161 }
162
163
test_socket_fd_pass_num_good(void)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
179 fd = socket_listen(&addr, 1, &error_abort);
180 g_assert_cmpint(fd, ==, sfd);
181
182 g_free(addr.u.fd.str);
183 close(sfd);
184 }
185
test_socket_fd_pass_num_bad(void)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
202 fd = socket_listen(&addr, 1, &err);
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
test_socket_fd_pass_num_nocli(void)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
225 fd = socket_listen(&addr, 1, &err);
226 g_assert_cmpint(fd, ==, -1);
227 error_free_or_abort(&err);
228
229 g_free(addr.u.fd.str);
230 }
231 #endif
232
233 #ifdef CONFIG_LINUX
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
unix_client_thread_func(gpointer user_data)242 static gpointer unix_client_thread_func(gpointer user_data)
243 {
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 }
259 return NULL;
260 }
261
test_socket_unix_abstract_row(abstract_socket_matrix_row * test)262 static void test_socket_unix_abstract_row(abstract_socket_matrix_row *test)
263 {
264 int fd, connfd, i;
265 GThread *cli;
266 struct sockaddr_un un;
267 socklen_t len = sizeof(un);
268
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);
273 g_assert_cmpint(fd, >=, 0);
274 g_assert(fd_is_socket(fd));
275
276 cli = g_thread_new("abstract_unix_client",
277 unix_client_thread_func,
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 }
287
288 close(fd);
289 g_thread_join(cli);
290 }
291
test_socket_unix_abstract(void)292 static void test_socket_unix_abstract(void)
293 {
294 SocketAddress addr, addr_tight, addr_padded;
295 abstract_socket_matrix_row matrix[ABSTRACT_SOCKET_VARIANTS] = {
296 { &addr,
297 { &addr_tight, &addr_padded, &addr },
298 { true, false, true } },
299 { &addr_tight,
300 { &addr_padded, &addr, &addr_tight },
301 { false, true, true } },
302 { &addr_padded,
303 { &addr, &addr_tight, &addr_padded },
304 { false, false, true } }
305 };
306 int i;
307
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;
313 addr.u.q_unix.has_tight = false;
314 addr.u.q_unix.tight = false;
315
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 }
327
328 g_free(addr.u.q_unix.path);
329 }
330
331 #endif /* CONFIG_LINUX */
332
main(int argc,char ** argv)333 int main(int argc, char **argv)
334 {
335 bool has_ipv4, has_ipv6;
336
337 qemu_init_main_loop(&error_abort);
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) {
348 g_printerr("socket_check_protocol_support() failed\n");
349 goto end;
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);
357 #ifndef _WIN32
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);
370 #endif
371 }
372
373 #ifdef CONFIG_LINUX
374 g_test_add_func("/util/socket/unix-abstract",
375 test_socket_unix_abstract);
376 #endif
377
378 end:
379 return g_test_run();
380 }
381