docs: Build and install specs manual
[qemu/ar7.git] / tests / test-char.c
blobf9440cdcfdb51f98b2f6542e6f21062e2f122444
1 #include "qemu/osdep.h"
2 #include <glib/gstdio.h>
4 #include "qemu/config-file.h"
5 #include "qemu/module.h"
6 #include "qemu/option.h"
7 #include "qemu/sockets.h"
8 #include "chardev/char-fe.h"
9 #include "chardev/char-mux.h"
10 #include "sysemu/sysemu.h"
11 #include "qapi/error.h"
12 #include "qapi/qapi-commands-char.h"
13 #include "qapi/qmp/qdict.h"
14 #include "qom/qom-qobject.h"
15 #include "io/channel-socket.h"
16 #include "qapi/qobject-input-visitor.h"
17 #include "qapi/qapi-visit-sockets.h"
19 static bool quit;
21 typedef struct FeHandler {
22 int read_count;
23 bool is_open;
24 int openclose_count;
25 bool openclose_mismatch;
26 int last_event;
27 char read_buf[128];
28 } FeHandler;
30 static void main_loop(void)
32 quit = false;
33 do {
34 main_loop_wait(false);
35 } while (!quit);
38 static int fe_can_read(void *opaque)
40 FeHandler *h = opaque;
42 return sizeof(h->read_buf) - h->read_count;
45 static void fe_read(void *opaque, const uint8_t *buf, int size)
47 FeHandler *h = opaque;
49 g_assert_cmpint(size, <=, fe_can_read(opaque));
51 memcpy(h->read_buf + h->read_count, buf, size);
52 h->read_count += size;
53 quit = true;
56 static void fe_event(void *opaque, int event)
58 FeHandler *h = opaque;
59 bool new_open_state;
61 h->last_event = event;
62 switch (event) {
63 case CHR_EVENT_BREAK:
64 break;
65 case CHR_EVENT_OPENED:
66 case CHR_EVENT_CLOSED:
67 h->openclose_count++;
68 new_open_state = (event == CHR_EVENT_OPENED);
69 if (h->is_open == new_open_state) {
70 h->openclose_mismatch = true;
72 h->is_open = new_open_state;
73 /* no break */
74 default:
75 quit = true;
76 break;
80 #ifdef _WIN32
81 static void char_console_test_subprocess(void)
83 QemuOpts *opts;
84 Chardev *chr;
86 opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label",
87 1, &error_abort);
88 qemu_opt_set(opts, "backend", "console", &error_abort);
90 chr = qemu_chr_new_from_opts(opts, NULL, NULL);
91 g_assert_nonnull(chr);
93 qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7);
95 qemu_opts_del(opts);
96 object_unparent(OBJECT(chr));
99 static void char_console_test(void)
101 g_test_trap_subprocess("/char/console/subprocess", 0, 0);
102 g_test_trap_assert_passed();
103 g_test_trap_assert_stdout("CONSOLE");
105 #endif
106 static void char_stdio_test_subprocess(void)
108 Chardev *chr;
109 CharBackend be;
110 int ret;
112 chr = qemu_chr_new("label", "stdio", NULL);
113 g_assert_nonnull(chr);
115 qemu_chr_fe_init(&be, chr, &error_abort);
116 qemu_chr_fe_set_open(&be, true);
117 ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
118 g_assert_cmpint(ret, ==, 4);
120 qemu_chr_fe_deinit(&be, true);
123 static void char_stdio_test(void)
125 g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
126 g_test_trap_assert_passed();
127 g_test_trap_assert_stdout("buf");
130 static void char_ringbuf_test(void)
132 QemuOpts *opts;
133 Chardev *chr;
134 CharBackend be;
135 char *data;
136 int ret;
138 opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
139 1, &error_abort);
140 qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
142 qemu_opt_set(opts, "size", "5", &error_abort);
143 chr = qemu_chr_new_from_opts(opts, NULL, NULL);
144 g_assert_null(chr);
145 qemu_opts_del(opts);
147 opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
148 1, &error_abort);
149 qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
150 qemu_opt_set(opts, "size", "2", &error_abort);
151 chr = qemu_chr_new_from_opts(opts, NULL, &error_abort);
152 g_assert_nonnull(chr);
153 qemu_opts_del(opts);
155 qemu_chr_fe_init(&be, chr, &error_abort);
156 ret = qemu_chr_fe_write(&be, (void *)"buff", 4);
157 g_assert_cmpint(ret, ==, 4);
159 data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
160 g_assert_cmpstr(data, ==, "ff");
161 g_free(data);
163 data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
164 g_assert_cmpstr(data, ==, "");
165 g_free(data);
167 qemu_chr_fe_deinit(&be, true);
169 /* check alias */
170 opts = qemu_opts_create(qemu_find_opts("chardev"), "memory-label",
171 1, &error_abort);
172 qemu_opt_set(opts, "backend", "memory", &error_abort);
173 qemu_opt_set(opts, "size", "2", &error_abort);
174 chr = qemu_chr_new_from_opts(opts, NULL, NULL);
175 g_assert_nonnull(chr);
176 object_unparent(OBJECT(chr));
177 qemu_opts_del(opts);
180 static void char_mux_test(void)
182 QemuOpts *opts;
183 Chardev *chr, *base;
184 char *data;
185 FeHandler h1 = { 0, false, 0, false, }, h2 = { 0, false, 0, false, };
186 CharBackend chr_be1, chr_be2;
188 opts = qemu_opts_create(qemu_find_opts("chardev"), "mux-label",
189 1, &error_abort);
190 qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
191 qemu_opt_set(opts, "size", "128", &error_abort);
192 qemu_opt_set(opts, "mux", "on", &error_abort);
193 chr = qemu_chr_new_from_opts(opts, NULL, &error_abort);
194 g_assert_nonnull(chr);
195 qemu_opts_del(opts);
197 qemu_chr_fe_init(&chr_be1, chr, &error_abort);
198 qemu_chr_fe_set_handlers(&chr_be1,
199 fe_can_read,
200 fe_read,
201 fe_event,
202 NULL,
203 &h1,
204 NULL, true);
206 qemu_chr_fe_init(&chr_be2, chr, &error_abort);
207 qemu_chr_fe_set_handlers(&chr_be2,
208 fe_can_read,
209 fe_read,
210 fe_event,
211 NULL,
212 &h2,
213 NULL, true);
214 qemu_chr_fe_take_focus(&chr_be2);
216 base = qemu_chr_find("mux-label-base");
217 g_assert_cmpint(qemu_chr_be_can_write(base), !=, 0);
219 qemu_chr_be_write(base, (void *)"hello", 6);
220 g_assert_cmpint(h1.read_count, ==, 0);
221 g_assert_cmpint(h2.read_count, ==, 6);
222 g_assert_cmpstr(h2.read_buf, ==, "hello");
223 h2.read_count = 0;
225 g_assert_cmpint(h1.last_event, !=, 42); /* should be MUX_OUT or OPENED */
226 g_assert_cmpint(h2.last_event, !=, 42); /* should be MUX_IN or OPENED */
227 /* sending event on the base broadcast to all fe, historical reasons? */
228 qemu_chr_be_event(base, 42);
229 g_assert_cmpint(h1.last_event, ==, 42);
230 g_assert_cmpint(h2.last_event, ==, 42);
231 qemu_chr_be_event(chr, -1);
232 g_assert_cmpint(h1.last_event, ==, 42);
233 g_assert_cmpint(h2.last_event, ==, -1);
235 /* switch focus */
236 qemu_chr_be_write(base, (void *)"\1b", 2);
237 g_assert_cmpint(h1.last_event, ==, 42);
238 g_assert_cmpint(h2.last_event, ==, CHR_EVENT_BREAK);
240 qemu_chr_be_write(base, (void *)"\1c", 2);
241 g_assert_cmpint(h1.last_event, ==, CHR_EVENT_MUX_IN);
242 g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
243 qemu_chr_be_event(chr, -1);
244 g_assert_cmpint(h1.last_event, ==, -1);
245 g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
247 qemu_chr_be_write(base, (void *)"hello", 6);
248 g_assert_cmpint(h2.read_count, ==, 0);
249 g_assert_cmpint(h1.read_count, ==, 6);
250 g_assert_cmpstr(h1.read_buf, ==, "hello");
251 h1.read_count = 0;
253 qemu_chr_be_write(base, (void *)"\1b", 2);
254 g_assert_cmpint(h1.last_event, ==, CHR_EVENT_BREAK);
255 g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
257 /* open/close state and corresponding events */
258 g_assert_true(qemu_chr_fe_backend_open(&chr_be1));
259 g_assert_true(qemu_chr_fe_backend_open(&chr_be2));
260 g_assert_true(h1.is_open);
261 g_assert_false(h1.openclose_mismatch);
262 g_assert_true(h2.is_open);
263 g_assert_false(h2.openclose_mismatch);
265 h1.openclose_count = h2.openclose_count = 0;
267 qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL,
268 NULL, NULL, false);
269 qemu_chr_fe_set_handlers(&chr_be2, NULL, NULL, NULL, NULL,
270 NULL, NULL, false);
271 g_assert_cmpint(h1.openclose_count, ==, 0);
272 g_assert_cmpint(h2.openclose_count, ==, 0);
274 h1.is_open = h2.is_open = false;
275 qemu_chr_fe_set_handlers(&chr_be1,
276 NULL,
277 NULL,
278 fe_event,
279 NULL,
280 &h1,
281 NULL, false);
282 qemu_chr_fe_set_handlers(&chr_be2,
283 NULL,
284 NULL,
285 fe_event,
286 NULL,
287 &h2,
288 NULL, false);
289 g_assert_cmpint(h1.openclose_count, ==, 1);
290 g_assert_false(h1.openclose_mismatch);
291 g_assert_cmpint(h2.openclose_count, ==, 1);
292 g_assert_false(h2.openclose_mismatch);
294 qemu_chr_be_event(base, CHR_EVENT_CLOSED);
295 qemu_chr_be_event(base, CHR_EVENT_OPENED);
296 g_assert_cmpint(h1.openclose_count, ==, 3);
297 g_assert_false(h1.openclose_mismatch);
298 g_assert_cmpint(h2.openclose_count, ==, 3);
299 g_assert_false(h2.openclose_mismatch);
301 qemu_chr_fe_set_handlers(&chr_be2,
302 fe_can_read,
303 fe_read,
304 fe_event,
305 NULL,
306 &h2,
307 NULL, false);
308 qemu_chr_fe_set_handlers(&chr_be1,
309 fe_can_read,
310 fe_read,
311 fe_event,
312 NULL,
313 &h1,
314 NULL, false);
316 /* remove first handler */
317 qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL,
318 NULL, NULL, true);
319 qemu_chr_be_write(base, (void *)"hello", 6);
320 g_assert_cmpint(h1.read_count, ==, 0);
321 g_assert_cmpint(h2.read_count, ==, 0);
323 qemu_chr_be_write(base, (void *)"\1c", 2);
324 qemu_chr_be_write(base, (void *)"hello", 6);
325 g_assert_cmpint(h1.read_count, ==, 0);
326 g_assert_cmpint(h2.read_count, ==, 6);
327 g_assert_cmpstr(h2.read_buf, ==, "hello");
328 h2.read_count = 0;
330 /* print help */
331 qemu_chr_be_write(base, (void *)"\1?", 2);
332 data = qmp_ringbuf_read("mux-label-base", 128, false, 0, &error_abort);
333 g_assert_cmpint(strlen(data), !=, 0);
334 g_free(data);
336 qemu_chr_fe_deinit(&chr_be1, false);
337 qemu_chr_fe_deinit(&chr_be2, true);
341 static void websock_server_read(void *opaque, const uint8_t *buf, int size)
343 g_assert_cmpint(size, ==, 5);
344 g_assert(memcmp(buf, "world", size) == 0);
345 quit = true;
349 static int websock_server_can_read(void *opaque)
351 return 10;
355 static bool websock_check_http_headers(char *buf, int size)
357 int i;
358 const char *ans[] = { "HTTP/1.1 101 Switching Protocols\r\n",
359 "Server: QEMU VNC\r\n",
360 "Upgrade: websocket\r\n",
361 "Connection: Upgrade\r\n",
362 "Sec-WebSocket-Accept:",
363 "Sec-WebSocket-Protocol: binary\r\n" };
365 for (i = 0; i < 6; i++) {
366 if (g_strstr_len(buf, size, ans[i]) == NULL) {
367 return false;
371 return true;
375 static void websock_client_read(void *opaque, const uint8_t *buf, int size)
377 const uint8_t ping[] = { 0x89, 0x85, /* Ping header */
378 0x07, 0x77, 0x9e, 0xf9, /* Masking key */
379 0x6f, 0x12, 0xf2, 0x95, 0x68 /* "hello" */ };
381 const uint8_t binary[] = { 0x82, 0x85, /* Binary header */
382 0x74, 0x90, 0xb9, 0xdf, /* Masking key */
383 0x03, 0xff, 0xcb, 0xb3, 0x10 /* "world" */ };
384 Chardev *chr_client = opaque;
386 if (websock_check_http_headers((char *) buf, size)) {
387 qemu_chr_fe_write(chr_client->be, ping, sizeof(ping));
388 } else if (buf[0] == 0x8a && buf[1] == 0x05) {
389 g_assert(strncmp((char *) buf + 2, "hello", 5) == 0);
390 qemu_chr_fe_write(chr_client->be, binary, sizeof(binary));
391 } else {
392 g_assert(buf[0] == 0x88 && buf[1] == 0x16);
393 g_assert(strncmp((char *) buf + 4, "peer requested close", 10) == 0);
394 quit = true;
399 static int websock_client_can_read(void *opaque)
401 return 4096;
405 static void char_websock_test(void)
407 QObject *addr;
408 QDict *qdict;
409 const char *port;
410 char *tmp;
411 char *handshake_port;
412 CharBackend be;
413 CharBackend client_be;
414 Chardev *chr_client;
415 Chardev *chr = qemu_chr_new("server",
416 "websocket:127.0.0.1:0,server,nowait", NULL);
417 const char handshake[] = "GET / HTTP/1.1\r\n"
418 "Upgrade: websocket\r\n"
419 "Connection: Upgrade\r\n"
420 "Host: localhost:%s\r\n"
421 "Origin: http://localhost:%s\r\n"
422 "Sec-WebSocket-Key: o9JHNiS3/0/0zYE1wa3yIw==\r\n"
423 "Sec-WebSocket-Version: 13\r\n"
424 "Sec-WebSocket-Protocol: binary\r\n\r\n";
425 const uint8_t close[] = { 0x88, 0x82, /* Close header */
426 0xef, 0xaa, 0xc5, 0x97, /* Masking key */
427 0xec, 0x42 /* Status code */ };
429 addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
430 qdict = qobject_to(QDict, addr);
431 port = qdict_get_str(qdict, "port");
432 tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
433 handshake_port = g_strdup_printf(handshake, port, port);
434 qobject_unref(qdict);
436 qemu_chr_fe_init(&be, chr, &error_abort);
437 qemu_chr_fe_set_handlers(&be, websock_server_can_read, websock_server_read,
438 NULL, NULL, chr, NULL, true);
440 chr_client = qemu_chr_new("client", tmp, NULL);
441 qemu_chr_fe_init(&client_be, chr_client, &error_abort);
442 qemu_chr_fe_set_handlers(&client_be, websock_client_can_read,
443 websock_client_read,
444 NULL, NULL, chr_client, NULL, true);
445 g_free(tmp);
447 qemu_chr_write_all(chr_client,
448 (uint8_t *) handshake_port,
449 strlen(handshake_port));
450 g_free(handshake_port);
451 main_loop();
453 g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
454 g_assert(object_property_get_bool(OBJECT(chr_client),
455 "connected", &error_abort));
457 qemu_chr_write_all(chr_client, close, sizeof(close));
458 main_loop();
460 object_unparent(OBJECT(chr_client));
461 object_unparent(OBJECT(chr));
465 #ifndef _WIN32
466 static void char_pipe_test(void)
468 gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
469 gchar *tmp, *in, *out, *pipe = g_build_filename(tmp_path, "pipe", NULL);
470 Chardev *chr;
471 CharBackend be;
472 int ret, fd;
473 char buf[10];
474 FeHandler fe = { 0, };
476 in = g_strdup_printf("%s.in", pipe);
477 if (mkfifo(in, 0600) < 0) {
478 abort();
480 out = g_strdup_printf("%s.out", pipe);
481 if (mkfifo(out, 0600) < 0) {
482 abort();
485 tmp = g_strdup_printf("pipe:%s", pipe);
486 chr = qemu_chr_new("pipe", tmp, NULL);
487 g_assert_nonnull(chr);
488 g_free(tmp);
490 qemu_chr_fe_init(&be, chr, &error_abort);
492 ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9);
493 g_assert_cmpint(ret, ==, 9);
495 fd = open(out, O_RDWR);
496 ret = read(fd, buf, sizeof(buf));
497 g_assert_cmpint(ret, ==, 9);
498 g_assert_cmpstr(buf, ==, "pipe-out");
499 close(fd);
501 fd = open(in, O_WRONLY);
502 ret = write(fd, "pipe-in", 8);
503 g_assert_cmpint(ret, ==, 8);
504 close(fd);
506 qemu_chr_fe_set_handlers(&be,
507 fe_can_read,
508 fe_read,
509 fe_event,
510 NULL,
511 &fe,
512 NULL, true);
514 main_loop();
516 g_assert_cmpint(fe.read_count, ==, 8);
517 g_assert_cmpstr(fe.read_buf, ==, "pipe-in");
519 qemu_chr_fe_deinit(&be, true);
521 g_assert(g_unlink(in) == 0);
522 g_assert(g_unlink(out) == 0);
523 g_assert(g_rmdir(tmp_path) == 0);
524 g_free(in);
525 g_free(out);
526 g_free(tmp_path);
527 g_free(pipe);
529 #endif
531 typedef struct SocketIdleData {
532 GMainLoop *loop;
533 Chardev *chr;
534 bool conn_expected;
535 CharBackend *be;
536 CharBackend *client_be;
537 } SocketIdleData;
540 static void socket_read_hello(void *opaque, const uint8_t *buf, int size)
542 g_assert_cmpint(size, ==, 5);
543 g_assert(strncmp((char *)buf, "hello", 5) == 0);
545 quit = true;
548 static int socket_can_read_hello(void *opaque)
550 return 10;
553 static int make_udp_socket(int *port)
555 struct sockaddr_in addr = { 0, };
556 socklen_t alen = sizeof(addr);
557 int ret, sock = qemu_socket(PF_INET, SOCK_DGRAM, 0);
559 g_assert_cmpint(sock, >, 0);
560 addr.sin_family = AF_INET ;
561 addr.sin_addr.s_addr = htonl(INADDR_ANY);
562 addr.sin_port = 0;
563 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
564 g_assert_cmpint(ret, ==, 0);
565 ret = getsockname(sock, (struct sockaddr *)&addr, &alen);
566 g_assert_cmpint(ret, ==, 0);
568 *port = ntohs(addr.sin_port);
569 return sock;
572 static void char_udp_test_internal(Chardev *reuse_chr, int sock)
574 struct sockaddr_in other;
575 SocketIdleData d = { 0, };
576 Chardev *chr;
577 CharBackend *be;
578 socklen_t alen = sizeof(other);
579 int ret;
580 char buf[10];
581 char *tmp = NULL;
583 if (reuse_chr) {
584 chr = reuse_chr;
585 be = chr->be;
586 } else {
587 int port;
588 sock = make_udp_socket(&port);
589 tmp = g_strdup_printf("udp:127.0.0.1:%d", port);
590 chr = qemu_chr_new("client", tmp, NULL);
591 g_assert_nonnull(chr);
593 be = g_alloca(sizeof(CharBackend));
594 qemu_chr_fe_init(be, chr, &error_abort);
597 d.chr = chr;
598 qemu_chr_fe_set_handlers(be, socket_can_read_hello, socket_read_hello,
599 NULL, NULL, &d, NULL, true);
600 ret = qemu_chr_write_all(chr, (uint8_t *)"hello", 5);
601 g_assert_cmpint(ret, ==, 5);
603 ret = recvfrom(sock, buf, sizeof(buf), 0,
604 (struct sockaddr *)&other, &alen);
605 g_assert_cmpint(ret, ==, 5);
606 ret = sendto(sock, buf, 5, 0, (struct sockaddr *)&other, alen);
607 g_assert_cmpint(ret, ==, 5);
609 main_loop();
611 if (!reuse_chr) {
612 close(sock);
613 qemu_chr_fe_deinit(be, true);
615 g_free(tmp);
618 static void char_udp_test(void)
620 char_udp_test_internal(NULL, 0);
624 typedef struct {
625 int event;
626 bool got_pong;
627 } CharSocketTestData;
630 #define SOCKET_PING "Hello"
631 #define SOCKET_PONG "World"
634 static void
635 char_socket_event(void *opaque, int event)
637 CharSocketTestData *data = opaque;
638 data->event = event;
642 static void
643 char_socket_read(void *opaque, const uint8_t *buf, int size)
645 CharSocketTestData *data = opaque;
646 g_assert_cmpint(size, ==, sizeof(SOCKET_PONG));
647 g_assert(memcmp(buf, SOCKET_PONG, size) == 0);
648 data->got_pong = true;
652 static int
653 char_socket_can_read(void *opaque)
655 return sizeof(SOCKET_PONG);
659 static char *
660 char_socket_addr_to_opt_str(SocketAddress *addr, bool fd_pass,
661 const char *reconnect, bool is_listen)
663 if (fd_pass) {
664 QIOChannelSocket *ioc = qio_channel_socket_new();
665 int fd;
666 char *optstr;
667 g_assert(!reconnect);
668 if (is_listen) {
669 qio_channel_socket_listen_sync(ioc, addr, &error_abort);
670 } else {
671 qio_channel_socket_connect_sync(ioc, addr, &error_abort);
673 fd = ioc->fd;
674 ioc->fd = -1;
675 optstr = g_strdup_printf("socket,id=cdev0,fd=%d%s",
676 fd, is_listen ? ",server,nowait" : "");
677 object_unref(OBJECT(ioc));
678 return optstr;
679 } else {
680 switch (addr->type) {
681 case SOCKET_ADDRESS_TYPE_INET:
682 return g_strdup_printf("socket,id=cdev0,host=%s,port=%s%s%s",
683 addr->u.inet.host,
684 addr->u.inet.port,
685 reconnect ? reconnect : "",
686 is_listen ? ",server,nowait" : "");
688 case SOCKET_ADDRESS_TYPE_UNIX:
689 return g_strdup_printf("socket,id=cdev0,path=%s%s%s",
690 addr->u.q_unix.path,
691 reconnect ? reconnect : "",
692 is_listen ? ",server,nowait" : "");
694 default:
695 g_assert_not_reached();
701 static void
702 char_socket_ping_pong(QIOChannel *ioc)
704 char greeting[sizeof(SOCKET_PING)];
705 const char *response = SOCKET_PONG;
707 qio_channel_read_all(ioc, greeting, sizeof(greeting), &error_abort);
709 g_assert(memcmp(greeting, SOCKET_PING, sizeof(greeting)) == 0);
711 qio_channel_write_all(ioc, response, sizeof(SOCKET_PONG), &error_abort);
713 object_unref(OBJECT(ioc));
717 static gpointer
718 char_socket_server_client_thread(gpointer data)
720 SocketAddress *addr = data;
721 QIOChannelSocket *ioc = qio_channel_socket_new();
723 qio_channel_socket_connect_sync(ioc, addr, &error_abort);
725 char_socket_ping_pong(QIO_CHANNEL(ioc));
727 return NULL;
731 typedef struct {
732 SocketAddress *addr;
733 bool wait_connected;
734 bool fd_pass;
735 } CharSocketServerTestConfig;
738 static void char_socket_server_test(gconstpointer opaque)
740 const CharSocketServerTestConfig *config = opaque;
741 Chardev *chr;
742 CharBackend be = {0};
743 CharSocketTestData data = {0};
744 QObject *qaddr;
745 SocketAddress *addr;
746 Visitor *v;
747 QemuThread thread;
748 int ret;
749 bool reconnected = false;
750 char *optstr;
751 QemuOpts *opts;
753 g_setenv("QTEST_SILENT_ERRORS", "1", 1);
755 * We rely on config->addr containing "nowait", otherwise
756 * qemu_chr_new() will block until a client connects. We
757 * can't spawn our client thread though, because until
758 * qemu_chr_new() returns we don't know what TCP port was
759 * allocated by the OS
761 optstr = char_socket_addr_to_opt_str(config->addr,
762 config->fd_pass,
763 NULL,
764 true);
765 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
766 optstr, true);
767 g_assert_nonnull(opts);
768 chr = qemu_chr_new_from_opts(opts, NULL, &error_abort);
769 qemu_opts_del(opts);
770 g_assert_nonnull(chr);
771 g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
773 qaddr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
774 g_assert_nonnull(qaddr);
776 v = qobject_input_visitor_new(qaddr);
777 visit_type_SocketAddress(v, "addr", &addr, &error_abort);
778 visit_free(v);
779 qobject_unref(qaddr);
781 qemu_chr_fe_init(&be, chr, &error_abort);
783 reconnect:
784 data.event = -1;
785 qemu_chr_fe_set_handlers(&be, NULL, NULL,
786 char_socket_event, NULL,
787 &data, NULL, true);
788 g_assert(data.event == -1);
791 * Kick off a thread to act as the "remote" client
792 * which just plays ping-pong with us
794 qemu_thread_create(&thread, "client",
795 char_socket_server_client_thread,
796 addr, QEMU_THREAD_JOINABLE);
797 g_assert(data.event == -1);
799 if (config->wait_connected) {
800 /* Synchronously accept a connection */
801 qemu_chr_wait_connected(chr, &error_abort);
802 } else {
804 * Asynchronously accept a connection when the evnt
805 * loop reports the listener socket as readable
807 while (data.event == -1) {
808 main_loop_wait(false);
811 g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
812 g_assert(data.event == CHR_EVENT_OPENED);
813 data.event = -1;
815 /* Send a greeting to the client */
816 ret = qemu_chr_fe_write_all(&be, (const uint8_t *)SOCKET_PING,
817 sizeof(SOCKET_PING));
818 g_assert_cmpint(ret, ==, sizeof(SOCKET_PING));
819 g_assert(data.event == -1);
821 /* Setup a callback to receive the reply to our greeting */
822 qemu_chr_fe_set_handlers(&be, char_socket_can_read,
823 char_socket_read,
824 char_socket_event, NULL,
825 &data, NULL, true);
826 g_assert(data.event == CHR_EVENT_OPENED);
827 data.event = -1;
829 /* Wait for the client to go away */
830 while (data.event == -1) {
831 main_loop_wait(false);
833 g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
834 g_assert(data.event == CHR_EVENT_CLOSED);
835 g_assert(data.got_pong);
837 qemu_thread_join(&thread);
839 if (!reconnected) {
840 reconnected = true;
841 goto reconnect;
844 qapi_free_SocketAddress(addr);
845 object_unparent(OBJECT(chr));
846 g_free(optstr);
847 g_unsetenv("QTEST_SILENT_ERRORS");
851 static gpointer
852 char_socket_client_server_thread(gpointer data)
854 QIOChannelSocket *ioc = data;
855 QIOChannelSocket *cioc;
857 cioc = qio_channel_socket_accept(ioc, &error_abort);
858 g_assert_nonnull(cioc);
860 char_socket_ping_pong(QIO_CHANNEL(cioc));
862 return NULL;
866 typedef struct {
867 SocketAddress *addr;
868 const char *reconnect;
869 bool wait_connected;
870 bool fd_pass;
871 } CharSocketClientTestConfig;
874 static void char_socket_client_test(gconstpointer opaque)
876 const CharSocketClientTestConfig *config = opaque;
877 QIOChannelSocket *ioc;
878 char *optstr;
879 Chardev *chr;
880 CharBackend be = {0};
881 CharSocketTestData data = {0};
882 SocketAddress *addr;
883 QemuThread thread;
884 int ret;
885 bool reconnected = false;
886 QemuOpts *opts;
889 * Setup a listener socket and determine get its address
890 * so we know the TCP port for the client later
892 ioc = qio_channel_socket_new();
893 g_assert_nonnull(ioc);
894 qio_channel_socket_listen_sync(ioc, config->addr, &error_abort);
895 addr = qio_channel_socket_get_local_address(ioc, &error_abort);
896 g_assert_nonnull(addr);
899 * Kick off a thread to act as the "remote" client
900 * which just plays ping-pong with us
902 qemu_thread_create(&thread, "client",
903 char_socket_client_server_thread,
904 ioc, QEMU_THREAD_JOINABLE);
907 * Populate the chardev address based on what the server
908 * is actually listening on
910 optstr = char_socket_addr_to_opt_str(addr,
911 config->fd_pass,
912 config->reconnect,
913 false);
915 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
916 optstr, true);
917 g_assert_nonnull(opts);
918 chr = qemu_chr_new_from_opts(opts, NULL, &error_abort);
919 qemu_opts_del(opts);
920 g_assert_nonnull(chr);
922 if (config->reconnect) {
924 * If reconnect is set, the connection will be
925 * established in a background thread and we won't
926 * see the "connected" status updated until we
927 * run the main event loop, or call qemu_chr_wait_connected
929 g_assert(!object_property_get_bool(OBJECT(chr), "connected",
930 &error_abort));
931 } else {
932 g_assert(object_property_get_bool(OBJECT(chr), "connected",
933 &error_abort));
936 qemu_chr_fe_init(&be, chr, &error_abort);
938 reconnect:
939 data.event = -1;
940 qemu_chr_fe_set_handlers(&be, NULL, NULL,
941 char_socket_event, NULL,
942 &data, NULL, true);
943 if (config->reconnect) {
944 g_assert(data.event == -1);
945 } else {
946 g_assert(data.event == CHR_EVENT_OPENED);
949 if (config->wait_connected) {
951 * Synchronously wait for the connection to complete
952 * This should be a no-op if reconnect is not set.
954 qemu_chr_wait_connected(chr, &error_abort);
955 } else {
957 * Asynchronously wait for the connection to be reported
958 * as complete when the background thread reports its
959 * status.
960 * The loop will short-circuit if reconnect was set
962 while (data.event == -1) {
963 main_loop_wait(false);
966 g_assert(data.event == CHR_EVENT_OPENED);
967 data.event = -1;
968 g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
970 /* Send a greeting to the server */
971 ret = qemu_chr_fe_write_all(&be, (const uint8_t *)SOCKET_PING,
972 sizeof(SOCKET_PING));
973 g_assert_cmpint(ret, ==, sizeof(SOCKET_PING));
974 g_assert(data.event == -1);
976 /* Setup a callback to receive the reply to our greeting */
977 qemu_chr_fe_set_handlers(&be, char_socket_can_read,
978 char_socket_read,
979 char_socket_event, NULL,
980 &data, NULL, true);
981 g_assert(data.event == CHR_EVENT_OPENED);
982 data.event = -1;
984 /* Wait for the server to go away */
985 while (data.event == -1) {
986 main_loop_wait(false);
988 g_assert(data.event == CHR_EVENT_CLOSED);
989 g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
990 g_assert(data.got_pong);
991 qemu_thread_join(&thread);
993 if (config->reconnect && !reconnected) {
994 reconnected = true;
995 qemu_thread_create(&thread, "client",
996 char_socket_client_server_thread,
997 ioc, QEMU_THREAD_JOINABLE);
998 goto reconnect;
1001 object_unref(OBJECT(ioc));
1002 object_unparent(OBJECT(chr));
1003 qapi_free_SocketAddress(addr);
1004 g_free(optstr);
1007 static void
1008 count_closed_event(void *opaque, int event)
1010 int *count = opaque;
1011 if (event == CHR_EVENT_CLOSED) {
1012 (*count)++;
1016 static void
1017 char_socket_discard_read(void *opaque, const uint8_t *buf, int size)
1021 static void char_socket_server_two_clients_test(gconstpointer opaque)
1023 SocketAddress *incoming_addr = (gpointer) opaque;
1024 Chardev *chr;
1025 CharBackend be = {0};
1026 QObject *qaddr;
1027 SocketAddress *addr;
1028 Visitor *v;
1029 char *optstr;
1030 QemuOpts *opts;
1031 QIOChannelSocket *ioc1, *ioc2;
1032 int closed = 0;
1034 g_setenv("QTEST_SILENT_ERRORS", "1", 1);
1036 * We rely on addr containing "nowait", otherwise
1037 * qemu_chr_new() will block until a client connects. We
1038 * can't spawn our client thread though, because until
1039 * qemu_chr_new() returns we don't know what TCP port was
1040 * allocated by the OS
1042 optstr = char_socket_addr_to_opt_str(incoming_addr,
1043 false,
1044 NULL,
1045 true);
1046 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
1047 optstr, true);
1048 g_assert_nonnull(opts);
1049 chr = qemu_chr_new_from_opts(opts, NULL, &error_abort);
1050 qemu_opts_del(opts);
1051 g_assert_nonnull(chr);
1052 g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
1054 qaddr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
1055 g_assert_nonnull(qaddr);
1057 v = qobject_input_visitor_new(qaddr);
1058 visit_type_SocketAddress(v, "addr", &addr, &error_abort);
1059 visit_free(v);
1060 qobject_unref(qaddr);
1062 qemu_chr_fe_init(&be, chr, &error_abort);
1064 qemu_chr_fe_set_handlers(&be, char_socket_can_read, char_socket_discard_read,
1065 count_closed_event, NULL,
1066 &closed, NULL, true);
1068 ioc1 = qio_channel_socket_new();
1069 qio_channel_socket_connect_sync(ioc1, addr, &error_abort);
1070 qemu_chr_wait_connected(chr, &error_abort);
1072 /* switch the chardev to another context */
1073 GMainContext *ctx = g_main_context_new();
1074 qemu_chr_fe_set_handlers(&be, char_socket_can_read, char_socket_discard_read,
1075 count_closed_event, NULL,
1076 &closed, ctx, true);
1078 /* Start a second connection while the first is still connected.
1079 * It will be placed in the listen() backlog, and connect() will
1080 * succeed immediately.
1082 ioc2 = qio_channel_socket_new();
1083 qio_channel_socket_connect_sync(ioc2, addr, &error_abort);
1085 object_unref(OBJECT(ioc1));
1086 /* The two connections should now be processed serially. */
1087 while (g_main_context_iteration(ctx, TRUE)) {
1088 if (closed == 1 && ioc2) {
1089 object_unref(OBJECT(ioc2));
1090 ioc2 = NULL;
1092 if (closed == 2) {
1093 break;
1097 qapi_free_SocketAddress(addr);
1098 object_unparent(OBJECT(chr));
1099 g_main_context_unref(ctx);
1100 g_free(optstr);
1101 g_unsetenv("QTEST_SILENT_ERRORS");
1105 #ifdef HAVE_CHARDEV_SERIAL
1106 static void char_serial_test(void)
1108 QemuOpts *opts;
1109 Chardev *chr;
1111 opts = qemu_opts_create(qemu_find_opts("chardev"), "serial-id",
1112 1, &error_abort);
1113 qemu_opt_set(opts, "backend", "serial", &error_abort);
1114 qemu_opt_set(opts, "path", "/dev/null", &error_abort);
1116 chr = qemu_chr_new_from_opts(opts, NULL, NULL);
1117 g_assert_nonnull(chr);
1118 /* TODO: add more tests with a pty */
1119 object_unparent(OBJECT(chr));
1121 /* test tty alias */
1122 qemu_opt_set(opts, "backend", "tty", &error_abort);
1123 chr = qemu_chr_new_from_opts(opts, NULL, NULL);
1124 g_assert_nonnull(chr);
1125 object_unparent(OBJECT(chr));
1127 qemu_opts_del(opts);
1129 #endif
1131 #ifndef _WIN32
1132 static void char_file_fifo_test(void)
1134 Chardev *chr;
1135 CharBackend be;
1136 char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
1137 char *fifo = g_build_filename(tmp_path, "fifo", NULL);
1138 char *out = g_build_filename(tmp_path, "out", NULL);
1139 ChardevFile file = { .in = fifo,
1140 .has_in = true,
1141 .out = out };
1142 ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
1143 .u.file.data = &file };
1144 FeHandler fe = { 0, };
1145 int fd, ret;
1147 if (mkfifo(fifo, 0600) < 0) {
1148 abort();
1151 fd = open(fifo, O_RDWR);
1152 ret = write(fd, "fifo-in", 8);
1153 g_assert_cmpint(ret, ==, 8);
1155 chr = qemu_chardev_new("label-file", TYPE_CHARDEV_FILE, &backend,
1156 NULL, &error_abort);
1158 qemu_chr_fe_init(&be, chr, &error_abort);
1159 qemu_chr_fe_set_handlers(&be,
1160 fe_can_read,
1161 fe_read,
1162 fe_event,
1163 NULL,
1164 &fe, NULL, true);
1166 g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK);
1167 qmp_chardev_send_break("label-foo", NULL);
1168 g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK);
1169 qmp_chardev_send_break("label-file", NULL);
1170 g_assert_cmpint(fe.last_event, ==, CHR_EVENT_BREAK);
1172 main_loop();
1174 close(fd);
1176 g_assert_cmpint(fe.read_count, ==, 8);
1177 g_assert_cmpstr(fe.read_buf, ==, "fifo-in");
1179 qemu_chr_fe_deinit(&be, true);
1181 g_unlink(fifo);
1182 g_free(fifo);
1183 g_unlink(out);
1184 g_free(out);
1185 g_rmdir(tmp_path);
1186 g_free(tmp_path);
1188 #endif
1190 static void char_file_test_internal(Chardev *ext_chr, const char *filepath)
1192 char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
1193 char *out;
1194 Chardev *chr;
1195 char *contents = NULL;
1196 ChardevFile file = {};
1197 ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
1198 .u.file.data = &file };
1199 gsize length;
1200 int ret;
1202 if (ext_chr) {
1203 chr = ext_chr;
1204 out = g_strdup(filepath);
1205 file.out = out;
1206 } else {
1207 out = g_build_filename(tmp_path, "out", NULL);
1208 file.out = out;
1209 chr = qemu_chardev_new(NULL, TYPE_CHARDEV_FILE, &backend,
1210 NULL, &error_abort);
1212 ret = qemu_chr_write_all(chr, (uint8_t *)"hello!", 6);
1213 g_assert_cmpint(ret, ==, 6);
1215 ret = g_file_get_contents(out, &contents, &length, NULL);
1216 g_assert(ret == TRUE);
1217 g_assert_cmpint(length, ==, 6);
1218 g_assert(strncmp(contents, "hello!", 6) == 0);
1220 if (!ext_chr) {
1221 object_unref(OBJECT(chr));
1222 g_unlink(out);
1224 g_free(contents);
1225 g_rmdir(tmp_path);
1226 g_free(tmp_path);
1227 g_free(out);
1230 static void char_file_test(void)
1232 char_file_test_internal(NULL, NULL);
1235 static void char_null_test(void)
1237 Error *err = NULL;
1238 Chardev *chr;
1239 CharBackend be;
1240 int ret;
1242 chr = qemu_chr_find("label-null");
1243 g_assert_null(chr);
1245 chr = qemu_chr_new("label-null", "null", NULL);
1246 chr = qemu_chr_find("label-null");
1247 g_assert_nonnull(chr);
1249 g_assert(qemu_chr_has_feature(chr,
1250 QEMU_CHAR_FEATURE_FD_PASS) == false);
1251 g_assert(qemu_chr_has_feature(chr,
1252 QEMU_CHAR_FEATURE_RECONNECTABLE) == false);
1254 /* check max avail */
1255 qemu_chr_fe_init(&be, chr, &error_abort);
1256 qemu_chr_fe_init(&be, chr, &err);
1257 error_free_or_abort(&err);
1259 /* deinit & reinit */
1260 qemu_chr_fe_deinit(&be, false);
1261 qemu_chr_fe_init(&be, chr, &error_abort);
1263 qemu_chr_fe_set_open(&be, true);
1265 qemu_chr_fe_set_handlers(&be,
1266 fe_can_read,
1267 fe_read,
1268 fe_event,
1269 NULL,
1270 NULL, NULL, true);
1272 ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
1273 g_assert_cmpint(ret, ==, 4);
1275 qemu_chr_fe_deinit(&be, true);
1278 static void char_invalid_test(void)
1280 Chardev *chr;
1281 g_setenv("QTEST_SILENT_ERRORS", "1", 1);
1282 chr = qemu_chr_new("label-invalid", "invalid", NULL);
1283 g_assert_null(chr);
1284 g_unsetenv("QTEST_SILENT_ERRORS");
1287 static int chardev_change(void *opaque)
1289 return 0;
1292 static int chardev_change_denied(void *opaque)
1294 return -1;
1297 static void char_hotswap_test(void)
1299 char *chr_args;
1300 Chardev *chr;
1301 CharBackend be;
1303 gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
1304 char *filename = g_build_filename(tmp_path, "file", NULL);
1305 ChardevFile file = { .out = filename };
1306 ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
1307 .u.file.data = &file };
1308 ChardevReturn *ret;
1310 int port;
1311 int sock = make_udp_socket(&port);
1312 g_assert_cmpint(sock, >, 0);
1314 chr_args = g_strdup_printf("udp:127.0.0.1:%d", port);
1316 chr = qemu_chr_new("chardev", chr_args, NULL);
1317 qemu_chr_fe_init(&be, chr, &error_abort);
1319 /* check that chardev operates correctly */
1320 char_udp_test_internal(chr, sock);
1322 /* set the handler that denies the hotswap */
1323 qemu_chr_fe_set_handlers(&be, NULL, NULL,
1324 NULL, chardev_change_denied, NULL, NULL, true);
1326 /* now, change is denied and has to keep the old backend operating */
1327 ret = qmp_chardev_change("chardev", &backend, NULL);
1328 g_assert(!ret);
1329 g_assert(be.chr == chr);
1331 char_udp_test_internal(chr, sock);
1333 /* now allow the change */
1334 qemu_chr_fe_set_handlers(&be, NULL, NULL,
1335 NULL, chardev_change, NULL, NULL, true);
1337 /* has to succeed now */
1338 ret = qmp_chardev_change("chardev", &backend, &error_abort);
1339 g_assert(be.chr != chr);
1341 close(sock);
1342 chr = be.chr;
1344 /* run the file chardev test */
1345 char_file_test_internal(chr, filename);
1347 object_unparent(OBJECT(chr));
1349 qapi_free_ChardevReturn(ret);
1350 g_unlink(filename);
1351 g_free(filename);
1352 g_rmdir(tmp_path);
1353 g_free(tmp_path);
1354 g_free(chr_args);
1357 int main(int argc, char **argv)
1359 qemu_init_main_loop(&error_abort);
1360 socket_init();
1362 g_test_init(&argc, &argv, NULL);
1364 module_call_init(MODULE_INIT_QOM);
1365 qemu_add_opts(&qemu_chardev_opts);
1367 g_test_add_func("/char/null", char_null_test);
1368 g_test_add_func("/char/invalid", char_invalid_test);
1369 g_test_add_func("/char/ringbuf", char_ringbuf_test);
1370 g_test_add_func("/char/mux", char_mux_test);
1371 #ifdef _WIN32
1372 g_test_add_func("/char/console/subprocess", char_console_test_subprocess);
1373 g_test_add_func("/char/console", char_console_test);
1374 #endif
1375 g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess);
1376 g_test_add_func("/char/stdio", char_stdio_test);
1377 #ifndef _WIN32
1378 g_test_add_func("/char/pipe", char_pipe_test);
1379 #endif
1380 g_test_add_func("/char/file", char_file_test);
1381 #ifndef _WIN32
1382 g_test_add_func("/char/file-fifo", char_file_fifo_test);
1383 #endif
1385 SocketAddress tcpaddr = {
1386 .type = SOCKET_ADDRESS_TYPE_INET,
1387 .u.inet.host = (char *)"127.0.0.1",
1388 .u.inet.port = (char *)"0",
1390 #ifndef WIN32
1391 SocketAddress unixaddr = {
1392 .type = SOCKET_ADDRESS_TYPE_UNIX,
1393 .u.q_unix.path = (char *)"test-char.sock",
1395 #endif
1397 #define SOCKET_SERVER_TEST(name, addr) \
1398 CharSocketServerTestConfig server1 ## name = \
1399 { addr, false, false }; \
1400 CharSocketServerTestConfig server2 ## name = \
1401 { addr, true, false }; \
1402 CharSocketServerTestConfig server3 ## name = \
1403 { addr, false, true }; \
1404 CharSocketServerTestConfig server4 ## name = \
1405 { addr, true, true }; \
1406 g_test_add_data_func("/char/socket/server/mainloop/" # name, \
1407 &server1 ##name, char_socket_server_test); \
1408 g_test_add_data_func("/char/socket/server/wait-conn/" # name, \
1409 &server2 ##name, char_socket_server_test); \
1410 g_test_add_data_func("/char/socket/server/mainloop-fdpass/" # name, \
1411 &server3 ##name, char_socket_server_test); \
1412 g_test_add_data_func("/char/socket/server/wait-conn-fdpass/" # name, \
1413 &server4 ##name, char_socket_server_test)
1415 #define SOCKET_CLIENT_TEST(name, addr) \
1416 CharSocketClientTestConfig client1 ## name = \
1417 { addr, NULL, false, false }; \
1418 CharSocketClientTestConfig client2 ## name = \
1419 { addr, NULL, true, false }; \
1420 CharSocketClientTestConfig client3 ## name = \
1421 { addr, ",reconnect=1", false }; \
1422 CharSocketClientTestConfig client4 ## name = \
1423 { addr, ",reconnect=1", true }; \
1424 CharSocketClientTestConfig client5 ## name = \
1425 { addr, NULL, false, true }; \
1426 CharSocketClientTestConfig client6 ## name = \
1427 { addr, NULL, true, true }; \
1428 g_test_add_data_func("/char/socket/client/mainloop/" # name, \
1429 &client1 ##name, char_socket_client_test); \
1430 g_test_add_data_func("/char/socket/client/wait-conn/" # name, \
1431 &client2 ##name, char_socket_client_test); \
1432 g_test_add_data_func("/char/socket/client/mainloop-reconnect/" # name, \
1433 &client3 ##name, char_socket_client_test); \
1434 g_test_add_data_func("/char/socket/client/wait-conn-reconnect/" # name, \
1435 &client4 ##name, char_socket_client_test); \
1436 g_test_add_data_func("/char/socket/client/mainloop-fdpass/" # name, \
1437 &client5 ##name, char_socket_client_test); \
1438 g_test_add_data_func("/char/socket/client/wait-conn-fdpass/" # name, \
1439 &client6 ##name, char_socket_client_test)
1441 SOCKET_SERVER_TEST(tcp, &tcpaddr);
1442 SOCKET_CLIENT_TEST(tcp, &tcpaddr);
1443 g_test_add_data_func("/char/socket/server/two-clients/tcp", &tcpaddr,
1444 char_socket_server_two_clients_test);
1445 #ifndef WIN32
1446 SOCKET_SERVER_TEST(unix, &unixaddr);
1447 SOCKET_CLIENT_TEST(unix, &unixaddr);
1448 g_test_add_data_func("/char/socket/server/two-clients/unix", &unixaddr,
1449 char_socket_server_two_clients_test);
1450 #endif
1452 g_test_add_func("/char/udp", char_udp_test);
1453 #ifdef HAVE_CHARDEV_SERIAL
1454 g_test_add_func("/char/serial", char_serial_test);
1455 #endif
1456 g_test_add_func("/char/hotswap", char_hotswap_test);
1457 g_test_add_func("/char/websocket", char_websock_test);
1459 return g_test_run();