1 #include "qemu/osdep.h"
2 #include <glib/gstdio.h>
4 #include "qemu-common.h"
5 #include "qemu/config-file.h"
6 #include "qemu/sockets.h"
7 #include "chardev/char-fe.h"
8 #include "sysemu/sysemu.h"
9 #include "qapi/error.h"
10 #include "qom/qom-qobject.h"
11 #include "qmp-commands.h"
15 typedef struct FeHandler
{
21 static void main_loop(void)
28 nonblocking
= last_io
> 0;
29 last_io
= main_loop_wait(nonblocking
);
33 static int fe_can_read(void *opaque
)
35 FeHandler
*h
= opaque
;
37 return sizeof(h
->read_buf
) - h
->read_count
;
40 static void fe_read(void *opaque
, const uint8_t *buf
, int size
)
42 FeHandler
*h
= opaque
;
44 g_assert_cmpint(size
, <=, fe_can_read(opaque
));
46 memcpy(h
->read_buf
+ h
->read_count
, buf
, size
);
47 h
->read_count
+= size
;
51 static void fe_event(void *opaque
, int event
)
53 FeHandler
*h
= opaque
;
55 h
->last_event
= event
;
56 if (event
!= CHR_EVENT_BREAK
) {
61 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
63 static void char_console_test_subprocess(void)
68 opts
= qemu_opts_create(qemu_find_opts("chardev"), "console-label",
70 qemu_opt_set(opts
, "backend", "console", &error_abort
);
72 chr
= qemu_chr_new_from_opts(opts
, NULL
);
73 g_assert_nonnull(chr
);
75 qemu_chr_write_all(chr
, (const uint8_t *)"CONSOLE", 7);
78 object_unparent(OBJECT(chr
));
81 static void char_console_test(void)
83 g_test_trap_subprocess("/char/console/subprocess", 0, 0);
84 g_test_trap_assert_passed();
85 g_test_trap_assert_stdout("CONSOLE");
88 static void char_stdio_test_subprocess(void)
94 chr
= qemu_chr_new("label", "stdio");
95 g_assert_nonnull(chr
);
97 qemu_chr_fe_init(&be
, chr
, &error_abort
);
98 qemu_chr_fe_set_open(&be
, true);
99 ret
= qemu_chr_fe_write(&be
, (void *)"buf", 4);
100 g_assert_cmpint(ret
, ==, 4);
102 qemu_chr_fe_deinit(&be
, true);
105 static void char_stdio_test(void)
107 g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
108 g_test_trap_assert_passed();
109 g_test_trap_assert_stdout("buf");
113 static void char_ringbuf_test(void)
121 opts
= qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
123 qemu_opt_set(opts
, "backend", "ringbuf", &error_abort
);
125 qemu_opt_set(opts
, "size", "5", &error_abort
);
126 chr
= qemu_chr_new_from_opts(opts
, NULL
);
130 opts
= qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
132 qemu_opt_set(opts
, "backend", "ringbuf", &error_abort
);
133 qemu_opt_set(opts
, "size", "2", &error_abort
);
134 chr
= qemu_chr_new_from_opts(opts
, &error_abort
);
135 g_assert_nonnull(chr
);
138 qemu_chr_fe_init(&be
, chr
, &error_abort
);
139 ret
= qemu_chr_fe_write(&be
, (void *)"buff", 4);
140 g_assert_cmpint(ret
, ==, 4);
142 data
= qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort
);
143 g_assert_cmpstr(data
, ==, "ff");
146 data
= qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort
);
147 g_assert_cmpstr(data
, ==, "");
150 qemu_chr_fe_deinit(&be
, true);
153 opts
= qemu_opts_create(qemu_find_opts("chardev"), "memory-label",
155 qemu_opt_set(opts
, "backend", "memory", &error_abort
);
156 qemu_opt_set(opts
, "size", "2", &error_abort
);
157 chr
= qemu_chr_new_from_opts(opts
, NULL
);
158 g_assert_nonnull(chr
);
159 object_unparent(OBJECT(chr
));
163 static void char_mux_test(void)
168 FeHandler h1
= { 0, }, h2
= { 0, };
169 CharBackend chr_be1
, chr_be2
;
171 opts
= qemu_opts_create(qemu_find_opts("chardev"), "mux-label",
173 qemu_opt_set(opts
, "backend", "ringbuf", &error_abort
);
174 qemu_opt_set(opts
, "size", "128", &error_abort
);
175 qemu_opt_set(opts
, "mux", "on", &error_abort
);
176 chr
= qemu_chr_new_from_opts(opts
, &error_abort
);
177 g_assert_nonnull(chr
);
180 qemu_chr_fe_init(&chr_be1
, chr
, &error_abort
);
181 qemu_chr_fe_set_handlers(&chr_be1
,
188 qemu_chr_fe_init(&chr_be2
, chr
, &error_abort
);
189 qemu_chr_fe_set_handlers(&chr_be2
,
195 qemu_chr_fe_take_focus(&chr_be2
);
197 base
= qemu_chr_find("mux-label-base");
198 g_assert_cmpint(qemu_chr_be_can_write(base
), !=, 0);
200 qemu_chr_be_write(base
, (void *)"hello", 6);
201 g_assert_cmpint(h1
.read_count
, ==, 0);
202 g_assert_cmpint(h2
.read_count
, ==, 6);
203 g_assert_cmpstr(h2
.read_buf
, ==, "hello");
207 qemu_chr_be_write(base
, (void *)"\1c", 2);
209 qemu_chr_be_write(base
, (void *)"hello", 6);
210 g_assert_cmpint(h2
.read_count
, ==, 0);
211 g_assert_cmpint(h1
.read_count
, ==, 6);
212 g_assert_cmpstr(h1
.read_buf
, ==, "hello");
215 /* remove first handler */
216 qemu_chr_fe_set_handlers(&chr_be1
, NULL
, NULL
, NULL
, NULL
, NULL
, true);
217 qemu_chr_be_write(base
, (void *)"hello", 6);
218 g_assert_cmpint(h1
.read_count
, ==, 0);
219 g_assert_cmpint(h2
.read_count
, ==, 0);
221 qemu_chr_be_write(base
, (void *)"\1c", 2);
222 qemu_chr_be_write(base
, (void *)"hello", 6);
223 g_assert_cmpint(h1
.read_count
, ==, 0);
224 g_assert_cmpint(h2
.read_count
, ==, 6);
225 g_assert_cmpstr(h2
.read_buf
, ==, "hello");
229 qemu_chr_be_write(base
, (void *)"\1?", 2);
230 data
= qmp_ringbuf_read("mux-label-base", 128, false, 0, &error_abort
);
231 g_assert_cmpint(strlen(data
), !=, 0);
234 qemu_chr_fe_deinit(&chr_be1
, false);
235 qemu_chr_fe_deinit(&chr_be2
, true);
238 typedef struct SocketIdleData
{
243 CharBackend
*client_be
;
246 static gboolean
char_socket_test_idle(gpointer user_data
)
248 SocketIdleData
*data
= user_data
;
250 if (object_property_get_bool(OBJECT(data
->chr
), "connected", NULL
)
251 == data
->conn_expected
) {
259 static void socket_read(void *opaque
, const uint8_t *buf
, int size
)
261 SocketIdleData
*data
= opaque
;
263 g_assert_cmpint(size
, ==, 1);
264 g_assert_cmpint(*buf
, ==, 'Z');
266 size
= qemu_chr_fe_write(data
->be
, (const uint8_t *)"hello", 5);
267 g_assert_cmpint(size
, ==, 5);
270 static int socket_can_read(void *opaque
)
275 static void socket_read_hello(void *opaque
, const uint8_t *buf
, int size
)
277 g_assert_cmpint(size
, ==, 5);
278 g_assert(strncmp((char *)buf
, "hello", 5) == 0);
283 static int socket_can_read_hello(void *opaque
)
288 static void char_socket_test(void)
290 Chardev
*chr
= qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
295 SocketIdleData d
= { .chr
= chr
};
297 CharBackend client_be
;
303 g_assert_nonnull(chr
);
304 g_assert(!object_property_get_bool(OBJECT(chr
), "connected", &error_abort
));
306 addr
= object_property_get_qobject(OBJECT(chr
), "addr", &error_abort
);
307 qdict
= qobject_to_qdict(addr
);
308 port
= qdict_get_str(qdict
, "port");
309 tmp
= g_strdup_printf("tcp:127.0.0.1:%s", port
);
312 qemu_chr_fe_init(&be
, chr
, &error_abort
);
313 qemu_chr_fe_set_handlers(&be
, socket_can_read
, socket_read
,
314 NULL
, &d
, NULL
, true);
316 chr_client
= qemu_chr_new("client", tmp
);
317 qemu_chr_fe_init(&client_be
, chr_client
, &error_abort
);
318 qemu_chr_fe_set_handlers(&client_be
, socket_can_read_hello
,
320 NULL
, &d
, NULL
, true);
323 d
.conn_expected
= true;
324 guint id
= g_idle_add(char_socket_test_idle
, &d
);
325 g_source_set_name_by_id(id
, "test-idle");
326 g_assert_cmpint(id
, >, 0);
329 g_assert(object_property_get_bool(OBJECT(chr
), "connected", &error_abort
));
330 g_assert(object_property_get_bool(OBJECT(chr_client
),
331 "connected", &error_abort
));
333 qemu_chr_write_all(chr_client
, (const uint8_t *)"Z", 1);
336 object_unparent(OBJECT(chr_client
));
338 d
.conn_expected
= false;
339 g_idle_add(char_socket_test_idle
, &d
);
342 object_unparent(OBJECT(chr
));
346 static void char_pipe_test(void)
348 gchar
*tmp_path
= g_dir_make_tmp("qemu-test-char.XXXXXX", NULL
);
349 gchar
*tmp
, *in
, *out
, *pipe
= g_build_filename(tmp_path
, "pipe", NULL
);
354 FeHandler fe
= { 0, };
356 in
= g_strdup_printf("%s.in", pipe
);
357 if (mkfifo(in
, 0600) < 0) {
360 out
= g_strdup_printf("%s.out", pipe
);
361 if (mkfifo(out
, 0600) < 0) {
365 tmp
= g_strdup_printf("pipe:%s", pipe
);
366 chr
= qemu_chr_new("pipe", tmp
);
367 g_assert_nonnull(chr
);
370 qemu_chr_fe_init(&be
, chr
, &error_abort
);
372 ret
= qemu_chr_fe_write(&be
, (void *)"pipe-out", 9);
373 g_assert_cmpint(ret
, ==, 9);
375 fd
= open(out
, O_RDWR
);
376 ret
= read(fd
, buf
, sizeof(buf
));
377 g_assert_cmpint(ret
, ==, 9);
378 g_assert_cmpstr(buf
, ==, "pipe-out");
381 fd
= open(in
, O_WRONLY
);
382 ret
= write(fd
, "pipe-in", 8);
383 g_assert_cmpint(ret
, ==, 8);
386 qemu_chr_fe_set_handlers(&be
,
395 g_assert_cmpint(fe
.read_count
, ==, 8);
396 g_assert_cmpstr(fe
.read_buf
, ==, "pipe-in");
398 qemu_chr_fe_deinit(&be
, true);
400 g_assert(g_unlink(in
) == 0);
401 g_assert(g_unlink(out
) == 0);
402 g_assert(g_rmdir(tmp_path
) == 0);
410 static void char_udp_test(void)
412 struct sockaddr_in addr
= { 0, }, other
;
413 SocketIdleData d
= { 0, };
416 socklen_t alen
= sizeof(addr
);
417 int ret
, sock
= qemu_socket(PF_INET
, SOCK_DGRAM
, 0);
421 g_assert_cmpint(sock
, >, 0);
422 addr
.sin_family
= AF_INET
;
423 addr
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
425 ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
));
426 g_assert_cmpint(ret
, ==, 0);
427 ret
= getsockname(sock
, (struct sockaddr
*)&addr
, &alen
);
428 g_assert_cmpint(ret
, ==, 0);
430 tmp
= g_strdup_printf("udp:127.0.0.1:%d",
431 ntohs(addr
.sin_port
));
432 chr
= qemu_chr_new("client", tmp
);
433 g_assert_nonnull(chr
);
436 qemu_chr_fe_init(&be
, chr
, &error_abort
);
437 qemu_chr_fe_set_handlers(&be
, socket_can_read_hello
, socket_read_hello
,
438 NULL
, &d
, NULL
, true);
439 ret
= qemu_chr_write_all(chr
, (uint8_t *)"hello", 5);
440 g_assert_cmpint(ret
, ==, 5);
443 ret
= recvfrom(sock
, buf
, sizeof(buf
), 0,
444 (struct sockaddr
*)&other
, &alen
);
445 g_assert_cmpint(ret
, ==, 5);
446 ret
= sendto(sock
, buf
, 5, 0, (struct sockaddr
*)&other
, alen
);
447 g_assert_cmpint(ret
, ==, 5);
455 #ifdef HAVE_CHARDEV_SERIAL
456 static void char_serial_test(void)
461 opts
= qemu_opts_create(qemu_find_opts("chardev"), "serial-id",
463 qemu_opt_set(opts
, "backend", "serial", &error_abort
);
464 qemu_opt_set(opts
, "path", "/dev/null", &error_abort
);
466 chr
= qemu_chr_new_from_opts(opts
, NULL
);
467 g_assert_nonnull(chr
);
468 /* TODO: add more tests with a pty */
469 object_unparent(OBJECT(chr
));
472 qemu_opt_set(opts
, "backend", "tty", &error_abort
);
473 chr
= qemu_chr_new_from_opts(opts
, NULL
);
474 g_assert_nonnull(chr
);
475 object_unparent(OBJECT(chr
));
481 static void char_file_test(void)
483 char *tmp_path
= g_dir_make_tmp("qemu-test-char.XXXXXX", NULL
);
484 char *out
= g_build_filename(tmp_path
, "out", NULL
);
485 char *contents
= NULL
;
486 ChardevFile file
= { .out
= out
};
487 ChardevBackend backend
= { .type
= CHARDEV_BACKEND_KIND_FILE
,
488 .u
.file
.data
= &file
};
493 chr
= qemu_chardev_new(NULL
, TYPE_CHARDEV_FILE
, &backend
,
495 ret
= qemu_chr_write_all(chr
, (uint8_t *)"hello!", 6);
496 g_assert_cmpint(ret
, ==, 6);
497 object_unref(OBJECT(chr
));
499 ret
= g_file_get_contents(out
, &contents
, &length
, NULL
);
500 g_assert(ret
== TRUE
);
501 g_assert_cmpint(length
, ==, 6);
502 g_assert(strncmp(contents
, "hello!", 6) == 0);
508 FeHandler fe
= { 0, };
509 char *fifo
= g_build_filename(tmp_path
, "fifo", NULL
);
512 if (mkfifo(fifo
, 0600) < 0) {
516 fd
= open(fifo
, O_RDWR
);
517 ret
= write(fd
, "fifo-in", 8);
518 g_assert_cmpint(ret
, ==, 8);
522 chr
= qemu_chardev_new("label-file", TYPE_CHARDEV_FILE
, &backend
,
525 qemu_chr_fe_init(&be
, chr
, &error_abort
);
526 qemu_chr_fe_set_handlers(&be
,
532 g_assert_cmpint(fe
.last_event
, !=, CHR_EVENT_BREAK
);
533 qmp_chardev_send_break("label-foo", NULL
);
534 g_assert_cmpint(fe
.last_event
, !=, CHR_EVENT_BREAK
);
535 qmp_chardev_send_break("label-file", NULL
);
536 g_assert_cmpint(fe
.last_event
, ==, CHR_EVENT_BREAK
);
542 g_assert_cmpint(fe
.read_count
, ==, 8);
543 g_assert_cmpstr(fe
.read_buf
, ==, "fifo-in");
544 qemu_chr_fe_deinit(&be
, true);
556 static void char_null_test(void)
563 chr
= qemu_chr_find("label-null");
566 chr
= qemu_chr_new("label-null", "null");
567 chr
= qemu_chr_find("label-null");
568 g_assert_nonnull(chr
);
570 g_assert(qemu_chr_has_feature(chr
,
571 QEMU_CHAR_FEATURE_FD_PASS
) == false);
572 g_assert(qemu_chr_has_feature(chr
,
573 QEMU_CHAR_FEATURE_RECONNECTABLE
) == false);
575 /* check max avail */
576 qemu_chr_fe_init(&be
, chr
, &error_abort
);
577 qemu_chr_fe_init(&be
, chr
, &err
);
578 error_free_or_abort(&err
);
580 /* deinit & reinit */
581 qemu_chr_fe_deinit(&be
, false);
582 qemu_chr_fe_init(&be
, chr
, &error_abort
);
584 qemu_chr_fe_set_open(&be
, true);
586 qemu_chr_fe_set_handlers(&be
,
592 ret
= qemu_chr_fe_write(&be
, (void *)"buf", 4);
593 g_assert_cmpint(ret
, ==, 4);
595 qemu_chr_fe_deinit(&be
, true);
598 static void char_invalid_test(void)
602 chr
= qemu_chr_new("label-invalid", "invalid");
606 int main(int argc
, char **argv
)
608 qemu_init_main_loop(&error_abort
);
611 g_test_init(&argc
, &argv
, NULL
);
613 module_call_init(MODULE_INIT_QOM
);
614 qemu_add_opts(&qemu_chardev_opts
);
616 g_test_add_func("/char/null", char_null_test
);
617 g_test_add_func("/char/invalid", char_invalid_test
);
618 g_test_add_func("/char/ringbuf", char_ringbuf_test
);
619 g_test_add_func("/char/mux", char_mux_test
);
620 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
622 g_test_add_func("/char/console/subprocess", char_console_test_subprocess
);
623 g_test_add_func("/char/console", char_console_test
);
625 g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess
);
626 g_test_add_func("/char/stdio", char_stdio_test
);
629 g_test_add_func("/char/pipe", char_pipe_test
);
631 g_test_add_func("/char/file", char_file_test
);
632 g_test_add_func("/char/socket", char_socket_test
);
633 g_test_add_func("/char/udp", char_udp_test
);
634 #ifdef HAVE_CHARDEV_SERIAL
635 g_test_add_func("/char/serial", char_serial_test
);