]>
Commit | Line | Data |
---|---|---|
ea3af47d | 1 | #include "qemu/osdep.h" |
a86c83d7 | 2 | #include <glib/gstdio.h> |
ea3af47d MAL |
3 | |
4 | #include "qemu-common.h" | |
5 | #include "qemu/config-file.h" | |
d47fb5d1 | 6 | #include "qemu/sockets.h" |
4d43a603 | 7 | #include "chardev/char-fe.h" |
ea3af47d MAL |
8 | #include "sysemu/sysemu.h" |
9 | #include "qapi/error.h" | |
d47fb5d1 | 10 | #include "qom/qom-qobject.h" |
ea3af47d MAL |
11 | #include "qmp-commands.h" |
12 | ||
a86c83d7 MAL |
13 | static bool quit; |
14 | ||
ea3af47d MAL |
15 | typedef struct FeHandler { |
16 | int read_count; | |
17 | int last_event; | |
18 | char read_buf[128]; | |
19 | } FeHandler; | |
20 | ||
a86c83d7 MAL |
21 | static void main_loop(void) |
22 | { | |
a86c83d7 MAL |
23 | quit = false; |
24 | do { | |
be59df79 | 25 | main_loop_wait(false); |
a86c83d7 MAL |
26 | } while (!quit); |
27 | } | |
a86c83d7 | 28 | |
ea3af47d MAL |
29 | static int fe_can_read(void *opaque) |
30 | { | |
31 | FeHandler *h = opaque; | |
32 | ||
33 | return sizeof(h->read_buf) - h->read_count; | |
34 | } | |
35 | ||
36 | static void fe_read(void *opaque, const uint8_t *buf, int size) | |
37 | { | |
38 | FeHandler *h = opaque; | |
39 | ||
40 | g_assert_cmpint(size, <=, fe_can_read(opaque)); | |
41 | ||
42 | memcpy(h->read_buf + h->read_count, buf, size); | |
43 | h->read_count += size; | |
a86c83d7 | 44 | quit = true; |
ea3af47d MAL |
45 | } |
46 | ||
47 | static void fe_event(void *opaque, int event) | |
48 | { | |
49 | FeHandler *h = opaque; | |
50 | ||
51 | h->last_event = event; | |
bd1d5ad9 SF |
52 | if (event != CHR_EVENT_BREAK) { |
53 | quit = true; | |
54 | } | |
ea3af47d MAL |
55 | } |
56 | ||
57 | #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS | |
79c8db5a MAL |
58 | #ifdef _WIN32 |
59 | static void char_console_test_subprocess(void) | |
60 | { | |
61 | QemuOpts *opts; | |
62 | Chardev *chr; | |
63 | ||
64 | opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label", | |
65 | 1, &error_abort); | |
66 | qemu_opt_set(opts, "backend", "console", &error_abort); | |
67 | ||
68 | chr = qemu_chr_new_from_opts(opts, NULL); | |
69 | g_assert_nonnull(chr); | |
70 | ||
71 | qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7); | |
72 | ||
73 | qemu_opts_del(opts); | |
74 | object_unparent(OBJECT(chr)); | |
75 | } | |
76 | ||
77 | static void char_console_test(void) | |
78 | { | |
79 | g_test_trap_subprocess("/char/console/subprocess", 0, 0); | |
80 | g_test_trap_assert_passed(); | |
81 | g_test_trap_assert_stdout("CONSOLE"); | |
82 | } | |
83 | #endif | |
ea3af47d MAL |
84 | static void char_stdio_test_subprocess(void) |
85 | { | |
0ec7b3e7 | 86 | Chardev *chr; |
ea3af47d MAL |
87 | CharBackend be; |
88 | int ret; | |
89 | ||
90 | chr = qemu_chr_new("label", "stdio"); | |
91 | g_assert_nonnull(chr); | |
92 | ||
93 | qemu_chr_fe_init(&be, chr, &error_abort); | |
94 | qemu_chr_fe_set_open(&be, true); | |
95 | ret = qemu_chr_fe_write(&be, (void *)"buf", 4); | |
96 | g_assert_cmpint(ret, ==, 4); | |
97 | ||
1ce2610c | 98 | qemu_chr_fe_deinit(&be, true); |
ea3af47d MAL |
99 | } |
100 | ||
101 | static void char_stdio_test(void) | |
102 | { | |
103 | g_test_trap_subprocess("/char/stdio/subprocess", 0, 0); | |
104 | g_test_trap_assert_passed(); | |
105 | g_test_trap_assert_stdout("buf"); | |
106 | } | |
107 | #endif | |
108 | ||
ea3af47d MAL |
109 | static void char_ringbuf_test(void) |
110 | { | |
111 | QemuOpts *opts; | |
0ec7b3e7 | 112 | Chardev *chr; |
ea3af47d MAL |
113 | CharBackend be; |
114 | char *data; | |
115 | int ret; | |
116 | ||
117 | opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label", | |
118 | 1, &error_abort); | |
119 | qemu_opt_set(opts, "backend", "ringbuf", &error_abort); | |
120 | ||
121 | qemu_opt_set(opts, "size", "5", &error_abort); | |
122 | chr = qemu_chr_new_from_opts(opts, NULL); | |
123 | g_assert_null(chr); | |
124 | qemu_opts_del(opts); | |
125 | ||
126 | opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label", | |
127 | 1, &error_abort); | |
128 | qemu_opt_set(opts, "backend", "ringbuf", &error_abort); | |
129 | qemu_opt_set(opts, "size", "2", &error_abort); | |
130 | chr = qemu_chr_new_from_opts(opts, &error_abort); | |
131 | g_assert_nonnull(chr); | |
132 | qemu_opts_del(opts); | |
133 | ||
134 | qemu_chr_fe_init(&be, chr, &error_abort); | |
135 | ret = qemu_chr_fe_write(&be, (void *)"buff", 4); | |
136 | g_assert_cmpint(ret, ==, 4); | |
137 | ||
138 | data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort); | |
139 | g_assert_cmpstr(data, ==, "ff"); | |
140 | g_free(data); | |
141 | ||
142 | data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort); | |
143 | g_assert_cmpstr(data, ==, ""); | |
144 | g_free(data); | |
145 | ||
1ce2610c | 146 | qemu_chr_fe_deinit(&be, true); |
e24ef0db MAL |
147 | |
148 | /* check alias */ | |
149 | opts = qemu_opts_create(qemu_find_opts("chardev"), "memory-label", | |
150 | 1, &error_abort); | |
151 | qemu_opt_set(opts, "backend", "memory", &error_abort); | |
152 | qemu_opt_set(opts, "size", "2", &error_abort); | |
153 | chr = qemu_chr_new_from_opts(opts, NULL); | |
154 | g_assert_nonnull(chr); | |
155 | object_unparent(OBJECT(chr)); | |
156 | qemu_opts_del(opts); | |
ea3af47d MAL |
157 | } |
158 | ||
159 | static void char_mux_test(void) | |
160 | { | |
161 | QemuOpts *opts; | |
0ec7b3e7 | 162 | Chardev *chr, *base; |
ea3af47d MAL |
163 | char *data; |
164 | FeHandler h1 = { 0, }, h2 = { 0, }; | |
165 | CharBackend chr_be1, chr_be2; | |
166 | ||
167 | opts = qemu_opts_create(qemu_find_opts("chardev"), "mux-label", | |
168 | 1, &error_abort); | |
169 | qemu_opt_set(opts, "backend", "ringbuf", &error_abort); | |
170 | qemu_opt_set(opts, "size", "128", &error_abort); | |
171 | qemu_opt_set(opts, "mux", "on", &error_abort); | |
172 | chr = qemu_chr_new_from_opts(opts, &error_abort); | |
173 | g_assert_nonnull(chr); | |
174 | qemu_opts_del(opts); | |
175 | ||
176 | qemu_chr_fe_init(&chr_be1, chr, &error_abort); | |
177 | qemu_chr_fe_set_handlers(&chr_be1, | |
178 | fe_can_read, | |
179 | fe_read, | |
180 | fe_event, | |
81517ba3 | 181 | NULL, |
ea3af47d | 182 | &h1, |
39ab61c6 | 183 | NULL, true); |
ea3af47d MAL |
184 | |
185 | qemu_chr_fe_init(&chr_be2, chr, &error_abort); | |
186 | qemu_chr_fe_set_handlers(&chr_be2, | |
187 | fe_can_read, | |
188 | fe_read, | |
189 | fe_event, | |
81517ba3 | 190 | NULL, |
ea3af47d | 191 | &h2, |
39ab61c6 | 192 | NULL, true); |
ea3af47d MAL |
193 | qemu_chr_fe_take_focus(&chr_be2); |
194 | ||
195 | base = qemu_chr_find("mux-label-base"); | |
196 | g_assert_cmpint(qemu_chr_be_can_write(base), !=, 0); | |
197 | ||
198 | qemu_chr_be_write(base, (void *)"hello", 6); | |
199 | g_assert_cmpint(h1.read_count, ==, 0); | |
200 | g_assert_cmpint(h2.read_count, ==, 6); | |
201 | g_assert_cmpstr(h2.read_buf, ==, "hello"); | |
202 | h2.read_count = 0; | |
203 | ||
204 | /* switch focus */ | |
205 | qemu_chr_be_write(base, (void *)"\1c", 2); | |
206 | ||
207 | qemu_chr_be_write(base, (void *)"hello", 6); | |
208 | g_assert_cmpint(h2.read_count, ==, 0); | |
209 | g_assert_cmpint(h1.read_count, ==, 6); | |
210 | g_assert_cmpstr(h1.read_buf, ==, "hello"); | |
211 | h1.read_count = 0; | |
212 | ||
213 | /* remove first handler */ | |
81517ba3 AN |
214 | qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL, |
215 | NULL, NULL, true); | |
ea3af47d MAL |
216 | qemu_chr_be_write(base, (void *)"hello", 6); |
217 | g_assert_cmpint(h1.read_count, ==, 0); | |
218 | g_assert_cmpint(h2.read_count, ==, 0); | |
219 | ||
220 | qemu_chr_be_write(base, (void *)"\1c", 2); | |
221 | qemu_chr_be_write(base, (void *)"hello", 6); | |
222 | g_assert_cmpint(h1.read_count, ==, 0); | |
223 | g_assert_cmpint(h2.read_count, ==, 6); | |
224 | g_assert_cmpstr(h2.read_buf, ==, "hello"); | |
225 | h2.read_count = 0; | |
226 | ||
227 | /* print help */ | |
228 | qemu_chr_be_write(base, (void *)"\1?", 2); | |
229 | data = qmp_ringbuf_read("mux-label-base", 128, false, 0, &error_abort); | |
230 | g_assert_cmpint(strlen(data), !=, 0); | |
231 | g_free(data); | |
232 | ||
1ce2610c MAL |
233 | qemu_chr_fe_deinit(&chr_be1, false); |
234 | qemu_chr_fe_deinit(&chr_be2, true); | |
ea3af47d MAL |
235 | } |
236 | ||
d47fb5d1 MAL |
237 | typedef struct SocketIdleData { |
238 | GMainLoop *loop; | |
239 | Chardev *chr; | |
240 | bool conn_expected; | |
241 | CharBackend *be; | |
242 | CharBackend *client_be; | |
243 | } SocketIdleData; | |
244 | ||
245 | static gboolean char_socket_test_idle(gpointer user_data) | |
246 | { | |
247 | SocketIdleData *data = user_data; | |
248 | ||
249 | if (object_property_get_bool(OBJECT(data->chr), "connected", NULL) | |
250 | == data->conn_expected) { | |
251 | quit = true; | |
252 | return FALSE; | |
253 | } | |
254 | ||
255 | return TRUE; | |
256 | } | |
257 | ||
258 | static void socket_read(void *opaque, const uint8_t *buf, int size) | |
259 | { | |
260 | SocketIdleData *data = opaque; | |
261 | ||
262 | g_assert_cmpint(size, ==, 1); | |
263 | g_assert_cmpint(*buf, ==, 'Z'); | |
264 | ||
265 | size = qemu_chr_fe_write(data->be, (const uint8_t *)"hello", 5); | |
266 | g_assert_cmpint(size, ==, 5); | |
267 | } | |
268 | ||
269 | static int socket_can_read(void *opaque) | |
270 | { | |
271 | return 10; | |
272 | } | |
273 | ||
274 | static void socket_read_hello(void *opaque, const uint8_t *buf, int size) | |
275 | { | |
276 | g_assert_cmpint(size, ==, 5); | |
277 | g_assert(strncmp((char *)buf, "hello", 5) == 0); | |
278 | ||
279 | quit = true; | |
280 | } | |
281 | ||
282 | static int socket_can_read_hello(void *opaque) | |
283 | { | |
284 | return 10; | |
285 | } | |
286 | ||
287 | static void char_socket_test(void) | |
288 | { | |
289 | Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait"); | |
290 | Chardev *chr_client; | |
291 | QObject *addr; | |
bd269ebc | 292 | QDict *qdict; |
d47fb5d1 MAL |
293 | const char *port; |
294 | SocketIdleData d = { .chr = chr }; | |
295 | CharBackend be; | |
296 | CharBackend client_be; | |
297 | char *tmp; | |
298 | ||
299 | d.be = &be; | |
300 | d.client_be = &be; | |
301 | ||
302 | g_assert_nonnull(chr); | |
303 | g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort)); | |
304 | ||
305 | addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort); | |
306 | qdict = qobject_to_qdict(addr); | |
bd269ebc | 307 | port = qdict_get_str(qdict, "port"); |
d47fb5d1 MAL |
308 | tmp = g_strdup_printf("tcp:127.0.0.1:%s", port); |
309 | QDECREF(qdict); | |
310 | ||
311 | qemu_chr_fe_init(&be, chr, &error_abort); | |
312 | qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read, | |
81517ba3 | 313 | NULL, NULL, &d, NULL, true); |
d47fb5d1 MAL |
314 | |
315 | chr_client = qemu_chr_new("client", tmp); | |
316 | qemu_chr_fe_init(&client_be, chr_client, &error_abort); | |
317 | qemu_chr_fe_set_handlers(&client_be, socket_can_read_hello, | |
318 | socket_read_hello, | |
81517ba3 | 319 | NULL, NULL, &d, NULL, true); |
d47fb5d1 MAL |
320 | g_free(tmp); |
321 | ||
322 | d.conn_expected = true; | |
323 | guint id = g_idle_add(char_socket_test_idle, &d); | |
324 | g_source_set_name_by_id(id, "test-idle"); | |
325 | g_assert_cmpint(id, >, 0); | |
326 | main_loop(); | |
327 | ||
328 | g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort)); | |
329 | g_assert(object_property_get_bool(OBJECT(chr_client), | |
330 | "connected", &error_abort)); | |
331 | ||
332 | qemu_chr_write_all(chr_client, (const uint8_t *)"Z", 1); | |
333 | main_loop(); | |
334 | ||
335 | object_unparent(OBJECT(chr_client)); | |
336 | ||
337 | d.conn_expected = false; | |
338 | g_idle_add(char_socket_test_idle, &d); | |
339 | main_loop(); | |
340 | ||
341 | object_unparent(OBJECT(chr)); | |
342 | } | |
343 | ||
a86c83d7 MAL |
344 | #ifndef _WIN32 |
345 | static void char_pipe_test(void) | |
346 | { | |
347 | gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL); | |
348 | gchar *tmp, *in, *out, *pipe = g_build_filename(tmp_path, "pipe", NULL); | |
349 | Chardev *chr; | |
350 | CharBackend be; | |
351 | int ret, fd; | |
352 | char buf[10]; | |
353 | FeHandler fe = { 0, }; | |
354 | ||
355 | in = g_strdup_printf("%s.in", pipe); | |
356 | if (mkfifo(in, 0600) < 0) { | |
357 | abort(); | |
358 | } | |
359 | out = g_strdup_printf("%s.out", pipe); | |
360 | if (mkfifo(out, 0600) < 0) { | |
361 | abort(); | |
362 | } | |
363 | ||
364 | tmp = g_strdup_printf("pipe:%s", pipe); | |
365 | chr = qemu_chr_new("pipe", tmp); | |
366 | g_assert_nonnull(chr); | |
367 | g_free(tmp); | |
368 | ||
369 | qemu_chr_fe_init(&be, chr, &error_abort); | |
370 | ||
371 | ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9); | |
372 | g_assert_cmpint(ret, ==, 9); | |
373 | ||
374 | fd = open(out, O_RDWR); | |
375 | ret = read(fd, buf, sizeof(buf)); | |
376 | g_assert_cmpint(ret, ==, 9); | |
377 | g_assert_cmpstr(buf, ==, "pipe-out"); | |
378 | close(fd); | |
379 | ||
380 | fd = open(in, O_WRONLY); | |
381 | ret = write(fd, "pipe-in", 8); | |
382 | g_assert_cmpint(ret, ==, 8); | |
383 | close(fd); | |
384 | ||
385 | qemu_chr_fe_set_handlers(&be, | |
386 | fe_can_read, | |
387 | fe_read, | |
388 | fe_event, | |
81517ba3 | 389 | NULL, |
a86c83d7 MAL |
390 | &fe, |
391 | NULL, true); | |
392 | ||
393 | main_loop(); | |
394 | ||
395 | g_assert_cmpint(fe.read_count, ==, 8); | |
396 | g_assert_cmpstr(fe.read_buf, ==, "pipe-in"); | |
397 | ||
1ce2610c | 398 | qemu_chr_fe_deinit(&be, true); |
a86c83d7 MAL |
399 | |
400 | g_assert(g_unlink(in) == 0); | |
401 | g_assert(g_unlink(out) == 0); | |
402 | g_assert(g_rmdir(tmp_path) == 0); | |
403 | g_free(in); | |
404 | g_free(out); | |
405 | g_free(tmp_path); | |
406 | g_free(pipe); | |
407 | } | |
408 | #endif | |
409 | ||
bb149048 MAL |
410 | static void char_udp_test(void) |
411 | { | |
412 | struct sockaddr_in addr = { 0, }, other; | |
413 | SocketIdleData d = { 0, }; | |
414 | Chardev *chr; | |
415 | CharBackend be; | |
416 | socklen_t alen = sizeof(addr); | |
417 | int ret, sock = qemu_socket(PF_INET, SOCK_DGRAM, 0); | |
418 | char buf[10]; | |
419 | char *tmp; | |
420 | ||
421 | g_assert_cmpint(sock, >, 0); | |
422 | addr.sin_family = AF_INET ; | |
423 | addr.sin_addr.s_addr = htonl(INADDR_ANY); | |
424 | addr.sin_port = 0; | |
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); | |
429 | ||
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); | |
434 | ||
435 | d.chr = chr; | |
436 | qemu_chr_fe_init(&be, chr, &error_abort); | |
437 | qemu_chr_fe_set_handlers(&be, socket_can_read_hello, socket_read_hello, | |
81517ba3 | 438 | NULL, NULL, &d, NULL, true); |
bb149048 MAL |
439 | ret = qemu_chr_write_all(chr, (uint8_t *)"hello", 5); |
440 | g_assert_cmpint(ret, ==, 5); | |
441 | ||
442 | alen = sizeof(addr); | |
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); | |
448 | ||
449 | main_loop(); | |
450 | ||
451 | close(sock); | |
452 | g_free(tmp); | |
453 | } | |
454 | ||
27d4c378 MAL |
455 | #ifdef HAVE_CHARDEV_SERIAL |
456 | static void char_serial_test(void) | |
457 | { | |
458 | QemuOpts *opts; | |
459 | Chardev *chr; | |
460 | ||
461 | opts = qemu_opts_create(qemu_find_opts("chardev"), "serial-id", | |
462 | 1, &error_abort); | |
463 | qemu_opt_set(opts, "backend", "serial", &error_abort); | |
464 | qemu_opt_set(opts, "path", "/dev/null", &error_abort); | |
465 | ||
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)); | |
470 | ||
471 | /* test tty alias */ | |
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)); | |
476 | ||
477 | qemu_opts_del(opts); | |
478 | } | |
479 | #endif | |
480 | ||
9dbaa4ce MAL |
481 | static void char_file_test(void) |
482 | { | |
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 }; | |
489 | Chardev *chr; | |
490 | gsize length; | |
491 | int ret; | |
492 | ||
493 | chr = qemu_chardev_new(NULL, TYPE_CHARDEV_FILE, &backend, | |
494 | &error_abort); | |
495 | ret = qemu_chr_write_all(chr, (uint8_t *)"hello!", 6); | |
496 | g_assert_cmpint(ret, ==, 6); | |
497 | object_unref(OBJECT(chr)); | |
498 | ||
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); | |
503 | g_free(contents); | |
504 | ||
505 | #ifndef _WIN32 | |
506 | { | |
507 | CharBackend be; | |
508 | FeHandler fe = { 0, }; | |
509 | char *fifo = g_build_filename(tmp_path, "fifo", NULL); | |
510 | int fd; | |
511 | ||
512 | if (mkfifo(fifo, 0600) < 0) { | |
513 | abort(); | |
514 | } | |
515 | ||
516 | fd = open(fifo, O_RDWR); | |
517 | ret = write(fd, "fifo-in", 8); | |
518 | g_assert_cmpint(ret, ==, 8); | |
519 | ||
520 | file.in = fifo; | |
521 | file.has_in = true; | |
bd1d5ad9 | 522 | chr = qemu_chardev_new("label-file", TYPE_CHARDEV_FILE, &backend, |
9dbaa4ce MAL |
523 | &error_abort); |
524 | ||
525 | qemu_chr_fe_init(&be, chr, &error_abort); | |
526 | qemu_chr_fe_set_handlers(&be, | |
527 | fe_can_read, | |
528 | fe_read, | |
529 | fe_event, | |
81517ba3 | 530 | NULL, |
9dbaa4ce MAL |
531 | &fe, NULL, true); |
532 | ||
bd1d5ad9 SF |
533 | g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK); |
534 | qmp_chardev_send_break("label-foo", NULL); | |
535 | g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK); | |
536 | qmp_chardev_send_break("label-file", NULL); | |
537 | g_assert_cmpint(fe.last_event, ==, CHR_EVENT_BREAK); | |
538 | ||
9dbaa4ce MAL |
539 | main_loop(); |
540 | ||
541 | close(fd); | |
542 | ||
543 | g_assert_cmpint(fe.read_count, ==, 8); | |
544 | g_assert_cmpstr(fe.read_buf, ==, "fifo-in"); | |
1ce2610c | 545 | qemu_chr_fe_deinit(&be, true); |
9dbaa4ce MAL |
546 | g_unlink(fifo); |
547 | g_free(fifo); | |
548 | } | |
549 | #endif | |
550 | ||
551 | g_unlink(out); | |
552 | g_rmdir(tmp_path); | |
553 | g_free(tmp_path); | |
554 | g_free(out); | |
555 | } | |
556 | ||
ea3af47d MAL |
557 | static void char_null_test(void) |
558 | { | |
559 | Error *err = NULL; | |
0ec7b3e7 | 560 | Chardev *chr; |
ea3af47d MAL |
561 | CharBackend be; |
562 | int ret; | |
563 | ||
564 | chr = qemu_chr_find("label-null"); | |
565 | g_assert_null(chr); | |
566 | ||
567 | chr = qemu_chr_new("label-null", "null"); | |
568 | chr = qemu_chr_find("label-null"); | |
569 | g_assert_nonnull(chr); | |
570 | ||
571 | g_assert(qemu_chr_has_feature(chr, | |
572 | QEMU_CHAR_FEATURE_FD_PASS) == false); | |
573 | g_assert(qemu_chr_has_feature(chr, | |
574 | QEMU_CHAR_FEATURE_RECONNECTABLE) == false); | |
575 | ||
576 | /* check max avail */ | |
577 | qemu_chr_fe_init(&be, chr, &error_abort); | |
578 | qemu_chr_fe_init(&be, chr, &err); | |
579 | error_free_or_abort(&err); | |
580 | ||
581 | /* deinit & reinit */ | |
1ce2610c | 582 | qemu_chr_fe_deinit(&be, false); |
ea3af47d MAL |
583 | qemu_chr_fe_init(&be, chr, &error_abort); |
584 | ||
585 | qemu_chr_fe_set_open(&be, true); | |
586 | ||
587 | qemu_chr_fe_set_handlers(&be, | |
588 | fe_can_read, | |
589 | fe_read, | |
590 | fe_event, | |
81517ba3 | 591 | NULL, |
39ab61c6 | 592 | NULL, NULL, true); |
ea3af47d MAL |
593 | |
594 | ret = qemu_chr_fe_write(&be, (void *)"buf", 4); | |
595 | g_assert_cmpint(ret, ==, 4); | |
596 | ||
1ce2610c | 597 | qemu_chr_fe_deinit(&be, true); |
ea3af47d MAL |
598 | } |
599 | ||
600 | static void char_invalid_test(void) | |
601 | { | |
0ec7b3e7 | 602 | Chardev *chr; |
ea3af47d MAL |
603 | |
604 | chr = qemu_chr_new("label-invalid", "invalid"); | |
605 | g_assert_null(chr); | |
606 | } | |
607 | ||
608 | int main(int argc, char **argv) | |
609 | { | |
a86c83d7 | 610 | qemu_init_main_loop(&error_abort); |
d47fb5d1 | 611 | socket_init(); |
a86c83d7 | 612 | |
ea3af47d MAL |
613 | g_test_init(&argc, &argv, NULL); |
614 | ||
615 | module_call_init(MODULE_INIT_QOM); | |
616 | qemu_add_opts(&qemu_chardev_opts); | |
617 | ||
618 | g_test_add_func("/char/null", char_null_test); | |
619 | g_test_add_func("/char/invalid", char_invalid_test); | |
620 | g_test_add_func("/char/ringbuf", char_ringbuf_test); | |
621 | g_test_add_func("/char/mux", char_mux_test); | |
622 | #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS | |
79c8db5a MAL |
623 | #ifdef _WIN32 |
624 | g_test_add_func("/char/console/subprocess", char_console_test_subprocess); | |
625 | g_test_add_func("/char/console", char_console_test); | |
626 | #endif | |
ea3af47d MAL |
627 | g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess); |
628 | g_test_add_func("/char/stdio", char_stdio_test); | |
629 | #endif | |
a86c83d7 MAL |
630 | #ifndef _WIN32 |
631 | g_test_add_func("/char/pipe", char_pipe_test); | |
632 | #endif | |
9dbaa4ce | 633 | g_test_add_func("/char/file", char_file_test); |
d47fb5d1 | 634 | g_test_add_func("/char/socket", char_socket_test); |
bb149048 | 635 | g_test_add_func("/char/udp", char_udp_test); |
27d4c378 MAL |
636 | #ifdef HAVE_CHARDEV_SERIAL |
637 | g_test_add_func("/char/serial", char_serial_test); | |
638 | #endif | |
ea3af47d MAL |
639 | |
640 | return g_test_run(); | |
641 | } |