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 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 granularity. 69 * To replace monitor_get_fd() we must ensure everything in 70 * stubs/monitor.c is defined, to make sure monitor.o is discarded 71 * otherwise we get duplicate syms at link time. 72 */ 73 __thread Monitor *cur_mon; 74 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap) { abort(); } 75 void monitor_init_qmp(Chardev *chr, bool pretty, Error **errp) {} 76 void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp) {} 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 __linux__ 233 static gchar *abstract_sock_name; 234 235 static gpointer unix_server_thread_func(gpointer user_data) 236 { 237 SocketAddress addr; 238 Error *err = NULL; 239 int fd = -1; 240 int connfd = -1; 241 struct sockaddr_un un; 242 socklen_t len = sizeof(un); 243 244 addr.type = SOCKET_ADDRESS_TYPE_UNIX; 245 addr.u.q_unix.path = abstract_sock_name; 246 addr.u.q_unix.tight = user_data != NULL; 247 addr.u.q_unix.abstract = true; 248 249 fd = socket_listen(&addr, 1, &err); 250 g_assert_cmpint(fd, >=, 0); 251 g_assert(fd_is_socket(fd)); 252 253 connfd = accept(fd, (struct sockaddr *)&un, &len); 254 g_assert_cmpint(connfd, !=, -1); 255 256 close(fd); 257 258 return NULL; 259 } 260 261 static gpointer unix_client_thread_func(gpointer user_data) 262 { 263 SocketAddress addr; 264 Error *err = NULL; 265 int fd = -1; 266 267 addr.type = SOCKET_ADDRESS_TYPE_UNIX; 268 addr.u.q_unix.path = abstract_sock_name; 269 addr.u.q_unix.tight = user_data != NULL; 270 addr.u.q_unix.abstract = true; 271 272 fd = socket_connect(&addr, &err); 273 274 g_assert_cmpint(fd, >=, 0); 275 276 close(fd); 277 278 return NULL; 279 } 280 281 static void test_socket_unix_abstract_good(void) 282 { 283 GRand *r = g_rand_new(); 284 285 abstract_sock_name = g_strdup_printf("unix-%d-%d", getpid(), 286 g_rand_int_range(r, 100, 1000)); 287 288 /* non tight socklen serv and cli */ 289 GThread *serv = g_thread_new("abstract_unix_server", 290 unix_server_thread_func, 291 NULL); 292 293 sleep(1); 294 295 GThread *cli = g_thread_new("abstract_unix_client", 296 unix_client_thread_func, 297 NULL); 298 299 g_thread_join(cli); 300 g_thread_join(serv); 301 302 /* tight socklen serv and cli */ 303 serv = g_thread_new("abstract_unix_server", 304 unix_server_thread_func, 305 (gpointer)1); 306 307 sleep(1); 308 309 cli = g_thread_new("abstract_unix_client", 310 unix_client_thread_func, 311 (gpointer)1); 312 313 g_thread_join(cli); 314 g_thread_join(serv); 315 316 g_free(abstract_sock_name); 317 g_rand_free(r); 318 } 319 #endif 320 321 int main(int argc, char **argv) 322 { 323 bool has_ipv4, has_ipv6; 324 325 qemu_init_main_loop(&error_abort); 326 socket_init(); 327 328 g_test_init(&argc, &argv, NULL); 329 330 /* We're creating actual IPv4/6 sockets, so we should 331 * check if the host running tests actually supports 332 * each protocol to avoid breaking tests on machines 333 * with either IPv4 or IPv6 disabled. 334 */ 335 if (socket_check_protocol_support(&has_ipv4, &has_ipv6) < 0) { 336 g_printerr("socket_check_protocol_support() failed\n"); 337 goto end; 338 } 339 340 if (has_ipv4) { 341 g_test_add_func("/util/socket/is-socket/bad", 342 test_fd_is_socket_bad); 343 g_test_add_func("/util/socket/is-socket/good", 344 test_fd_is_socket_good); 345 #ifndef _WIN32 346 g_test_add_func("/socket/fd-pass/name/good", 347 test_socket_fd_pass_name_good); 348 g_test_add_func("/socket/fd-pass/name/bad", 349 test_socket_fd_pass_name_bad); 350 g_test_add_func("/socket/fd-pass/name/nomon", 351 test_socket_fd_pass_name_nomon); 352 g_test_add_func("/socket/fd-pass/num/good", 353 test_socket_fd_pass_num_good); 354 g_test_add_func("/socket/fd-pass/num/bad", 355 test_socket_fd_pass_num_bad); 356 g_test_add_func("/socket/fd-pass/num/nocli", 357 test_socket_fd_pass_num_nocli); 358 #endif 359 } 360 361 #ifdef __linux__ 362 g_test_add_func("/util/socket/unix-abstract/good", 363 test_socket_unix_abstract_good); 364 #endif 365 366 end: 367 return g_test_run(); 368 } 369