xref: /openbmc/qemu/tests/unit/test-util-sockets.c (revision 2df1eb27) 
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 
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 
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 
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  */
74 Monitor *monitor_cur(void) { return cur_mon; }
75 Monitor *monitor_set_cur(Coroutine *co, Monitor *mon) { abort(); }
76 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); }
77 
78 #ifndef _WIN32
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 
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 
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 
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 
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 
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 
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 
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 
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     g_free(addr.u.q_unix.path);
330 }
331 
332 #endif  /* CONFIG_LINUX */
333 
334 int 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 
379 end:
380     return g_test_run();
381 }
382