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_TCP_KEEPCNT 363 g_assert_cmpint(addr.has_keep_alive_count, ==, 364 exp_addr->has_keep_alive_count); 365 g_assert_cmpint(addr.keep_alive_count, ==, 366 exp_addr->keep_alive_count); 367 #endif 368 #ifdef HAVE_TCP_KEEPIDLE 369 g_assert_cmpint(addr.has_keep_alive_idle, ==, 370 exp_addr->has_keep_alive_idle); 371 g_assert_cmpint(addr.keep_alive_idle, ==, 372 exp_addr->keep_alive_idle); 373 #endif 374 #ifdef HAVE_TCP_KEEPINTVL 375 g_assert_cmpint(addr.has_keep_alive_interval, ==, 376 exp_addr->has_keep_alive_interval); 377 g_assert_cmpint(addr.keep_alive_interval, ==, 378 exp_addr->keep_alive_interval); 379 #endif 380 #ifdef HAVE_IPPROTO_MPTCP 381 g_assert_cmpint(addr.has_mptcp, ==, exp_addr->has_mptcp); 382 g_assert_cmpint(addr.mptcp, ==, exp_addr->mptcp); 383 #endif 384 } 385 386 g_free(addr.host); 387 g_free(addr.port); 388 } 389 390 static void test_inet_parse_nohost_good(void) 391 { 392 char host[] = ""; 393 char port[] = "5000"; 394 InetSocketAddress exp_addr = { 395 .host = host, 396 .port = port, 397 }; 398 inet_parse_test_helper(":5000", &exp_addr, true); 399 } 400 401 static void test_inet_parse_empty_bad(void) 402 { 403 inet_parse_test_helper("", NULL, false); 404 } 405 406 static void test_inet_parse_only_colon_bad(void) 407 { 408 inet_parse_test_helper(":", NULL, false); 409 } 410 411 static void test_inet_parse_ipv4_good(void) 412 { 413 char host[] = "127.0.0.1"; 414 char port[] = "5000"; 415 InetSocketAddress exp_addr = { 416 .host = host, 417 .port = port, 418 }; 419 inet_parse_test_helper("127.0.0.1:5000", &exp_addr, true); 420 } 421 422 static void test_inet_parse_ipv4_noport_bad(void) 423 { 424 inet_parse_test_helper("127.0.0.1", NULL, false); 425 } 426 427 static void test_inet_parse_ipv6_good(void) 428 { 429 char host[] = "::1"; 430 char port[] = "5000"; 431 InetSocketAddress exp_addr = { 432 .host = host, 433 .port = port, 434 }; 435 inet_parse_test_helper("[::1]:5000", &exp_addr, true); 436 } 437 438 static void test_inet_parse_ipv6_noend_bad(void) 439 { 440 inet_parse_test_helper("[::1", NULL, false); 441 } 442 443 static void test_inet_parse_ipv6_noport_bad(void) 444 { 445 inet_parse_test_helper("[::1]:", NULL, false); 446 } 447 448 static void test_inet_parse_ipv6_empty_bad(void) 449 { 450 inet_parse_test_helper("[]:5000", NULL, false); 451 } 452 453 static void test_inet_parse_hostname_good(void) 454 { 455 char host[] = "localhost"; 456 char port[] = "5000"; 457 InetSocketAddress exp_addr = { 458 .host = host, 459 .port = port, 460 }; 461 inet_parse_test_helper("localhost:5000", &exp_addr, true); 462 } 463 464 static void test_inet_parse_all_options_good(void) 465 { 466 char host[] = "::1"; 467 char port[] = "5000"; 468 InetSocketAddress exp_addr = { 469 .host = host, 470 .port = port, 471 .has_numeric = true, 472 .numeric = true, 473 .has_to = true, 474 .to = 5006, 475 .has_ipv4 = true, 476 .ipv4 = false, 477 .has_ipv6 = true, 478 .ipv6 = true, 479 .has_keep_alive = true, 480 .keep_alive = true, 481 #ifdef HAVE_TCP_KEEPCNT 482 .has_keep_alive_count = true, 483 .keep_alive_count = 10, 484 #endif 485 #ifdef HAVE_TCP_KEEPIDLE 486 .has_keep_alive_idle = true, 487 .keep_alive_idle = 60, 488 #endif 489 #ifdef HAVE_TCP_KEEPINTVL 490 .has_keep_alive_interval = true, 491 .keep_alive_interval = 30, 492 #endif 493 #ifdef HAVE_IPPROTO_MPTCP 494 .has_mptcp = true, 495 .mptcp = false, 496 #endif 497 }; 498 inet_parse_test_helper( 499 "[::1]:5000,numeric=on,to=5006,ipv4=off,ipv6=on,keep-alive=on" 500 #ifdef HAVE_TCP_KEEPCNT 501 ",keep-alive-count=10" 502 #endif 503 #ifdef HAVE_TCP_KEEPIDLE 504 ",keep-alive-idle=60" 505 #endif 506 #ifdef HAVE_TCP_KEEPINTVL 507 ",keep-alive-interval=30" 508 #endif 509 #ifdef HAVE_IPPROTO_MPTCP 510 ",mptcp=off" 511 #endif 512 , &exp_addr, true); 513 } 514 515 static void test_inet_parse_all_implicit_bool_good(void) 516 { 517 char host[] = "::1"; 518 char port[] = "5000"; 519 InetSocketAddress exp_addr = { 520 .host = host, 521 .port = port, 522 .has_numeric = true, 523 .numeric = true, 524 .has_to = true, 525 .to = 5006, 526 .has_ipv4 = true, 527 .ipv4 = true, 528 .has_ipv6 = true, 529 .ipv6 = true, 530 .has_keep_alive = true, 531 .keep_alive = true, 532 #ifdef HAVE_IPPROTO_MPTCP 533 .has_mptcp = true, 534 .mptcp = true, 535 #endif 536 }; 537 inet_parse_test_helper( 538 "[::1]:5000,numeric,to=5006,ipv4,ipv6,keep-alive" 539 #ifdef HAVE_IPPROTO_MPTCP 540 ",mptcp" 541 #endif 542 , &exp_addr, true); 543 } 544 545 int main(int argc, char **argv) 546 { 547 bool has_ipv4, has_ipv6; 548 549 qemu_init_main_loop(&error_abort); 550 socket_init(); 551 552 g_test_init(&argc, &argv, NULL); 553 554 /* We're creating actual IPv4/6 sockets, so we should 555 * check if the host running tests actually supports 556 * each protocol to avoid breaking tests on machines 557 * with either IPv4 or IPv6 disabled. 558 */ 559 if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) { 560 g_printerr("socket_check_protocol_support() failed\n"); 561 goto end; 562 } 563 564 if (has_ipv4) { 565 g_test_add_func("/util/socket/is-socket/bad", 566 test_fd_is_socket_bad); 567 g_test_add_func("/util/socket/is-socket/good", 568 test_fd_is_socket_good); 569 #ifndef _WIN32 570 g_test_add_func("/socket/fd-pass/name/good", 571 test_socket_fd_pass_name_good); 572 g_test_add_func("/socket/fd-pass/name/bad", 573 test_socket_fd_pass_name_bad); 574 g_test_add_func("/socket/fd-pass/name/nomon", 575 test_socket_fd_pass_name_nomon); 576 g_test_add_func("/socket/fd-pass/num/good", 577 test_socket_fd_pass_num_good); 578 g_test_add_func("/socket/fd-pass/num/bad", 579 test_socket_fd_pass_num_bad); 580 g_test_add_func("/socket/fd-pass/num/nocli", 581 test_socket_fd_pass_num_nocli); 582 #endif 583 } 584 585 #ifdef CONFIG_LINUX 586 g_test_add_func("/util/socket/unix-abstract", 587 test_socket_unix_abstract); 588 #endif 589 590 g_test_add_func("/util/socket/inet-parse/nohost-good", 591 test_inet_parse_nohost_good); 592 g_test_add_func("/util/socket/inet-parse/empty-bad", 593 test_inet_parse_empty_bad); 594 g_test_add_func("/util/socket/inet-parse/only-colon-bad", 595 test_inet_parse_only_colon_bad); 596 g_test_add_func("/util/socket/inet-parse/ipv4-good", 597 test_inet_parse_ipv4_good); 598 g_test_add_func("/util/socket/inet-parse/ipv4-noport-bad", 599 test_inet_parse_ipv4_noport_bad); 600 g_test_add_func("/util/socket/inet-parse/ipv6-good", 601 test_inet_parse_ipv6_good); 602 g_test_add_func("/util/socket/inet-parse/ipv6-noend-bad", 603 test_inet_parse_ipv6_noend_bad); 604 g_test_add_func("/util/socket/inet-parse/ipv6-noport-bad", 605 test_inet_parse_ipv6_noport_bad); 606 g_test_add_func("/util/socket/inet-parse/ipv6-empty-bad", 607 test_inet_parse_ipv6_empty_bad); 608 g_test_add_func("/util/socket/inet-parse/hostname-good", 609 test_inet_parse_hostname_good); 610 g_test_add_func("/util/socket/inet-parse/all-options-good", 611 test_inet_parse_all_options_good); 612 g_test_add_func("/util/socket/inet-parse/all-bare-bool-good", 613 test_inet_parse_all_implicit_bool_good); 614 615 end: 616 return g_test_run(); 617 } 618