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 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 53 static int mon_fd = -1; 54 static const char *mon_fdname; 55 __thread Monitor *cur_mon; 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 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 */ 75 Monitor *monitor_cur(void) { return cur_mon; } 76 Monitor *monitor_set_cur(Coroutine *co, Monitor *mon) { abort(); } 77 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); } 78 79 #ifndef _WIN32 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 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 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 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 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 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 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 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 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 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