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 unlink(addr.u.q_unix.path); 330 g_free(addr.u.q_unix.path); 331 } 332 333 #endif /* CONFIG_LINUX */ 334 335 static void inet_parse_test_helper(const char *str, 336 InetSocketAddress *exp_addr, bool success) 337 { 338 InetSocketAddress addr; 339 Error *error = NULL; 340 341 int rc = inet_parse(&addr, str, &error); 342 343 if (success) { 344 g_assert_cmpint(rc, ==, 0); 345 } else { 346 g_assert_cmpint(rc, <, 0); 347 } 348 if (exp_addr != NULL) { 349 g_assert_cmpstr(addr.host, ==, exp_addr->host); 350 g_assert_cmpstr(addr.port, ==, exp_addr->port); 351 /* Own members: */ 352 g_assert_cmpint(addr.has_numeric, ==, exp_addr->has_numeric); 353 g_assert_cmpint(addr.numeric, ==, exp_addr->numeric); 354 g_assert_cmpint(addr.has_to, ==, exp_addr->has_to); 355 g_assert_cmpint(addr.to, ==, exp_addr->to); 356 g_assert_cmpint(addr.has_ipv4, ==, exp_addr->has_ipv4); 357 g_assert_cmpint(addr.ipv4, ==, exp_addr->ipv4); 358 g_assert_cmpint(addr.has_ipv6, ==, exp_addr->has_ipv6); 359 g_assert_cmpint(addr.ipv6, ==, exp_addr->ipv6); 360 g_assert_cmpint(addr.has_keep_alive, ==, exp_addr->has_keep_alive); 361 g_assert_cmpint(addr.keep_alive, ==, exp_addr->keep_alive); 362 #ifdef HAVE_IPPROTO_MPTCP 363 g_assert_cmpint(addr.has_mptcp, ==, exp_addr->has_mptcp); 364 g_assert_cmpint(addr.mptcp, ==, exp_addr->mptcp); 365 #endif 366 } 367 368 g_free(addr.host); 369 g_free(addr.port); 370 } 371 372 static void test_inet_parse_nohost_good(void) 373 { 374 char host[] = ""; 375 char port[] = "5000"; 376 InetSocketAddress exp_addr = { 377 .host = host, 378 .port = port, 379 }; 380 inet_parse_test_helper(":5000", &exp_addr, true); 381 } 382 383 static void test_inet_parse_empty_bad(void) 384 { 385 inet_parse_test_helper("", NULL, false); 386 } 387 388 static void test_inet_parse_only_colon_bad(void) 389 { 390 inet_parse_test_helper(":", NULL, false); 391 } 392 393 static void test_inet_parse_ipv4_good(void) 394 { 395 char host[] = "127.0.0.1"; 396 char port[] = "5000"; 397 InetSocketAddress exp_addr = { 398 .host = host, 399 .port = port, 400 }; 401 inet_parse_test_helper("127.0.0.1:5000", &exp_addr, true); 402 } 403 404 static void test_inet_parse_ipv4_noport_bad(void) 405 { 406 inet_parse_test_helper("127.0.0.1", NULL, false); 407 } 408 409 static void test_inet_parse_ipv6_good(void) 410 { 411 char host[] = "::1"; 412 char port[] = "5000"; 413 InetSocketAddress exp_addr = { 414 .host = host, 415 .port = port, 416 }; 417 inet_parse_test_helper("[::1]:5000", &exp_addr, true); 418 } 419 420 static void test_inet_parse_ipv6_noend_bad(void) 421 { 422 inet_parse_test_helper("[::1", NULL, false); 423 } 424 425 static void test_inet_parse_ipv6_noport_bad(void) 426 { 427 inet_parse_test_helper("[::1]:", NULL, false); 428 } 429 430 static void test_inet_parse_ipv6_empty_bad(void) 431 { 432 inet_parse_test_helper("[]:5000", NULL, false); 433 } 434 435 static void test_inet_parse_hostname_good(void) 436 { 437 char host[] = "localhost"; 438 char port[] = "5000"; 439 InetSocketAddress exp_addr = { 440 .host = host, 441 .port = port, 442 }; 443 inet_parse_test_helper("localhost:5000", &exp_addr, true); 444 } 445 446 static void test_inet_parse_all_options_good(void) 447 { 448 char host[] = "::1"; 449 char port[] = "5000"; 450 InetSocketAddress exp_addr = { 451 .host = host, 452 .port = port, 453 .has_numeric = true, 454 .numeric = true, 455 .has_to = true, 456 .to = 5006, 457 .has_ipv4 = true, 458 .ipv4 = false, 459 .has_ipv6 = true, 460 .ipv6 = true, 461 .has_keep_alive = true, 462 .keep_alive = true, 463 #ifdef HAVE_IPPROTO_MPTCP 464 .has_mptcp = true, 465 .mptcp = false, 466 #endif 467 }; 468 inet_parse_test_helper( 469 "[::1]:5000,numeric=on,to=5006,ipv4=off,ipv6=on,keep-alive=on" 470 #ifdef HAVE_IPPROTO_MPTCP 471 ",mptcp=off" 472 #endif 473 , &exp_addr, true); 474 } 475 476 static void test_inet_parse_all_implicit_bool_good(void) 477 { 478 char host[] = "::1"; 479 char port[] = "5000"; 480 InetSocketAddress exp_addr = { 481 .host = host, 482 .port = port, 483 .has_numeric = true, 484 .numeric = true, 485 .has_to = true, 486 .to = 5006, 487 .has_ipv4 = true, 488 .ipv4 = true, 489 .has_ipv6 = true, 490 .ipv6 = true, 491 .has_keep_alive = true, 492 .keep_alive = true, 493 #ifdef HAVE_IPPROTO_MPTCP 494 .has_mptcp = true, 495 .mptcp = true, 496 #endif 497 }; 498 inet_parse_test_helper( 499 "[::1]:5000,numeric,to=5006,ipv4,ipv6,keep-alive" 500 #ifdef HAVE_IPPROTO_MPTCP 501 ",mptcp" 502 #endif 503 , &exp_addr, true); 504 } 505 506 int main(int argc, char **argv) 507 { 508 bool has_ipv4, has_ipv6; 509 510 qemu_init_main_loop(&error_abort); 511 socket_init(); 512 513 g_test_init(&argc, &argv, NULL); 514 515 /* We're creating actual IPv4/6 sockets, so we should 516 * check if the host running tests actually supports 517 * each protocol to avoid breaking tests on machines 518 * with either IPv4 or IPv6 disabled. 519 */ 520 if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) { 521 g_printerr("socket_check_protocol_support() failed\n"); 522 goto end; 523 } 524 525 if (has_ipv4) { 526 g_test_add_func("/util/socket/is-socket/bad", 527 test_fd_is_socket_bad); 528 g_test_add_func("/util/socket/is-socket/good", 529 test_fd_is_socket_good); 530 #ifndef _WIN32 531 g_test_add_func("/socket/fd-pass/name/good", 532 test_socket_fd_pass_name_good); 533 g_test_add_func("/socket/fd-pass/name/bad", 534 test_socket_fd_pass_name_bad); 535 g_test_add_func("/socket/fd-pass/name/nomon", 536 test_socket_fd_pass_name_nomon); 537 g_test_add_func("/socket/fd-pass/num/good", 538 test_socket_fd_pass_num_good); 539 g_test_add_func("/socket/fd-pass/num/bad", 540 test_socket_fd_pass_num_bad); 541 g_test_add_func("/socket/fd-pass/num/nocli", 542 test_socket_fd_pass_num_nocli); 543 #endif 544 } 545 546 #ifdef CONFIG_LINUX 547 g_test_add_func("/util/socket/unix-abstract", 548 test_socket_unix_abstract); 549 #endif 550 551 g_test_add_func("/util/socket/inet-parse/nohost-good", 552 test_inet_parse_nohost_good); 553 g_test_add_func("/util/socket/inet-parse/empty-bad", 554 test_inet_parse_empty_bad); 555 g_test_add_func("/util/socket/inet-parse/only-colon-bad", 556 test_inet_parse_only_colon_bad); 557 g_test_add_func("/util/socket/inet-parse/ipv4-good", 558 test_inet_parse_ipv4_good); 559 g_test_add_func("/util/socket/inet-parse/ipv4-noport-bad", 560 test_inet_parse_ipv4_noport_bad); 561 g_test_add_func("/util/socket/inet-parse/ipv6-good", 562 test_inet_parse_ipv6_good); 563 g_test_add_func("/util/socket/inet-parse/ipv6-noend-bad", 564 test_inet_parse_ipv6_noend_bad); 565 g_test_add_func("/util/socket/inet-parse/ipv6-noport-bad", 566 test_inet_parse_ipv6_noport_bad); 567 g_test_add_func("/util/socket/inet-parse/ipv6-empty-bad", 568 test_inet_parse_ipv6_empty_bad); 569 g_test_add_func("/util/socket/inet-parse/hostname-good", 570 test_inet_parse_hostname_good); 571 g_test_add_func("/util/socket/inet-parse/all-options-good", 572 test_inet_parse_all_options_good); 573 g_test_add_func("/util/socket/inet-parse/all-bare-bool-good", 574 test_inet_parse_all_implicit_bool_good); 575 576 end: 577 return g_test_run(); 578 } 579