tests/test-char.c

   1 #include "qemu/osdep.h"
   2 #include <glib/gstdio.h>
   3
   4 #include "qemu/config-file.h"
   5 #include "qemu/option.h"
   6 #include "qemu/sockets.h"
   7 #include "chardev/char-fe.h"
   8 #include "chardev/char-mux.h"
   9 #include "sysemu/sysemu.h"
  10 #include "qapi/error.h"
  11 #include "qapi/qapi-commands-char.h"
  12 #include "qapi/qmp/qdict.h"
  13 #include "qom/qom-qobject.h"
  14
  15 static bool quit;
  16
  17 typedef struct FeHandler {
  18     int read_count;
  19     int last_event;
  20     char read_buf[128];
  21 } FeHandler;
  22
  23 static void main_loop(void)
  24 {
  25     quit = false;
  26     do {
  27         main_loop_wait(false);
  28     } while (!quit);
  29 }
  30
  31 static int fe_can_read(void *opaque)
  32 {
  33     FeHandler *h = opaque;
  34
  35     return sizeof(h->read_buf) - h->read_count;
  36 }
  37
  38 static void fe_read(void *opaque, const uint8_t *buf, int size)
  39 {
  40     FeHandler *h = opaque;
  41
  42     g_assert_cmpint(size, <=, fe_can_read(opaque));
  43
  44     memcpy(h->read_buf + h->read_count, buf, size);
  45     h->read_count += size;
  46     quit = true;
  47 }
  48
  49 static void fe_event(void *opaque, int event)
  50 {
  51     FeHandler *h = opaque;
  52
  53     h->last_event = event;
  54     if (event != CHR_EVENT_BREAK) {
  55         quit = true;
  56     }
  57 }
  58
  59 #ifdef _WIN32
  60 static void char_console_test_subprocess(void)
  61 {
  62     QemuOpts *opts;
  63     Chardev *chr;
  64
  65     opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label",
  66                             1, &error_abort);
  67     qemu_opt_set(opts, "backend", "console", &error_abort);
  68
  69     chr = qemu_chr_new_from_opts(opts, NULL);
  70     g_assert_nonnull(chr);
  71
  72     qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7);
  73
  74     qemu_opts_del(opts);
  75     object_unparent(OBJECT(chr));
  76 }
  77
  78 static void char_console_test(void)
  79 {
  80     g_test_trap_subprocess("/char/console/subprocess", 0, 0);
  81     g_test_trap_assert_passed();
  82     g_test_trap_assert_stdout("CONSOLE");
  83 }
  84 #endif
  85 static void char_stdio_test_subprocess(void)
  86 {
  87     Chardev *chr;
  88     CharBackend be;
  89     int ret;
  90
  91     chr = qemu_chr_new("label", "stdio");
  92     g_assert_nonnull(chr);
  93
  94     qemu_chr_fe_init(&be, chr, &error_abort);
  95     qemu_chr_fe_set_open(&be, true);
  96     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
  97     g_assert_cmpint(ret, ==, 4);
  98
  99     qemu_chr_fe_deinit(&be, true);
 100 }
 101
 102 static void char_stdio_test(void)
 103 {
 104     g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
 105     g_test_trap_assert_passed();
 106     g_test_trap_assert_stdout("buf");
 107 }
 108
 109 static void char_ringbuf_test(void)
 110 {
 111     QemuOpts *opts;
 112     Chardev *chr;
 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
 146     qemu_chr_fe_deinit(&be, true);
 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);
 157 }
 158
 159 static void char_mux_test(void)
 160 {
 161     QemuOpts *opts;
 162     Chardev *chr, *base;
 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,
 181                              NULL,
 182                              &h1,
 183                              NULL, true);
 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,
 190                              NULL,
 191                              &h2,
 192                              NULL, true);
 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     g_assert_cmpint(h1.last_event, !=, 42); /* should be MUX_OUT or OPENED */
 205     g_assert_cmpint(h2.last_event, !=, 42); /* should be MUX_IN or OPENED */
 206     /* sending event on the base broadcast to all fe, historical reasons? */
 207     qemu_chr_be_event(base, 42);
 208     g_assert_cmpint(h1.last_event, ==, 42);
 209     g_assert_cmpint(h2.last_event, ==, 42);
 210     qemu_chr_be_event(chr, -1);
 211     g_assert_cmpint(h1.last_event, ==, 42);
 212     g_assert_cmpint(h2.last_event, ==, -1);
 213
 214     /* switch focus */
 215     qemu_chr_be_write(base, (void *)"\1b", 2);
 216     g_assert_cmpint(h1.last_event, ==, 42);
 217     g_assert_cmpint(h2.last_event, ==, CHR_EVENT_BREAK);
 218
 219     qemu_chr_be_write(base, (void *)"\1c", 2);
 220     g_assert_cmpint(h1.last_event, ==, CHR_EVENT_MUX_IN);
 221     g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
 222     qemu_chr_be_event(chr, -1);
 223     g_assert_cmpint(h1.last_event, ==, -1);
 224     g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
 225
 226     qemu_chr_be_write(base, (void *)"hello", 6);
 227     g_assert_cmpint(h2.read_count, ==, 0);
 228     g_assert_cmpint(h1.read_count, ==, 6);
 229     g_assert_cmpstr(h1.read_buf, ==, "hello");
 230     h1.read_count = 0;
 231
 232     qemu_chr_be_write(base, (void *)"\1b", 2);
 233     g_assert_cmpint(h1.last_event, ==, CHR_EVENT_BREAK);
 234     g_assert_cmpint(h2.last_event, ==, CHR_EVENT_MUX_OUT);
 235
 236     /* remove first handler */
 237     qemu_chr_fe_set_handlers(&chr_be1, NULL, NULL, NULL, NULL,
 238                              NULL, NULL, true);
 239     qemu_chr_be_write(base, (void *)"hello", 6);
 240     g_assert_cmpint(h1.read_count, ==, 0);
 241     g_assert_cmpint(h2.read_count, ==, 0);
 242
 243     qemu_chr_be_write(base, (void *)"\1c", 2);
 244     qemu_chr_be_write(base, (void *)"hello", 6);
 245     g_assert_cmpint(h1.read_count, ==, 0);
 246     g_assert_cmpint(h2.read_count, ==, 6);
 247     g_assert_cmpstr(h2.read_buf, ==, "hello");
 248     h2.read_count = 0;
 249
 250     /* print help */
 251     qemu_chr_be_write(base, (void *)"\1?", 2);
 252     data = qmp_ringbuf_read("mux-label-base", 128, false, 0, &error_abort);
 253     g_assert_cmpint(strlen(data), !=, 0);
 254     g_free(data);
 255
 256     qemu_chr_fe_deinit(&chr_be1, false);
 257     qemu_chr_fe_deinit(&chr_be2, true);
 258 }
 259
 260 typedef struct SocketIdleData {
 261     GMainLoop *loop;
 262     Chardev *chr;
 263     bool conn_expected;
 264     CharBackend *be;
 265     CharBackend *client_be;
 266 } SocketIdleData;
 267
 268 static gboolean char_socket_test_idle(gpointer user_data)
 269 {
 270     SocketIdleData *data = user_data;
 271
 272     if (object_property_get_bool(OBJECT(data->chr), "connected", NULL)
 273         == data->conn_expected) {
 274         quit = true;
 275         return FALSE;
 276     }
 277
 278     return TRUE;
 279 }
 280
 281 static void socket_read(void *opaque, const uint8_t *buf, int size)
 282 {
 283     SocketIdleData *data = opaque;
 284
 285     g_assert_cmpint(size, ==, 1);
 286     g_assert_cmpint(*buf, ==, 'Z');
 287
 288     size = qemu_chr_fe_write(data->be, (const uint8_t *)"hello", 5);
 289     g_assert_cmpint(size, ==, 5);
 290 }
 291
 292 static int socket_can_read(void *opaque)
 293 {
 294     return 10;
 295 }
 296
 297 static void socket_read_hello(void *opaque, const uint8_t *buf, int size)
 298 {
 299     g_assert_cmpint(size, ==, 5);
 300     g_assert(strncmp((char *)buf, "hello", 5) == 0);
 301
 302     quit = true;
 303 }
 304
 305 static int socket_can_read_hello(void *opaque)
 306 {
 307     return 10;
 308 }
 309
 310 static void char_socket_test_common(Chardev *chr, bool reconnect)
 311 {
 312     Chardev *chr_client;
 313     QObject *addr;
 314     QDict *qdict;
 315     const char *port;
 316     SocketIdleData d = { .chr = chr };
 317     CharBackend be;
 318     CharBackend client_be;
 319     char *tmp;
 320
 321     d.be = &be;
 322     d.client_be = &be;
 323
 324     g_assert_nonnull(chr);
 325     g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 326
 327     addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
 328     qdict = qobject_to(QDict, addr);
 329     port = qdict_get_str(qdict, "port");
 330     tmp = g_strdup_printf("tcp:127.0.0.1:%s%s", port,
 331                           reconnect ? ",reconnect=1" : "");
 332     qobject_unref(qdict);
 333
 334     qemu_chr_fe_init(&be, chr, &error_abort);
 335     qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read,
 336                              NULL, NULL, &d, NULL, true);
 337
 338     chr_client = qemu_chr_new("client", tmp);
 339     qemu_chr_fe_init(&client_be, chr_client, &error_abort);
 340     qemu_chr_fe_set_handlers(&client_be, socket_can_read_hello,
 341                              socket_read_hello,
 342                              NULL, NULL, &d, NULL, true);
 343     g_free(tmp);
 344
 345     d.conn_expected = true;
 346     guint id = g_idle_add(char_socket_test_idle, &d);
 347     g_source_set_name_by_id(id, "test-idle");
 348     g_assert_cmpint(id, >, 0);
 349     main_loop();
 350
 351     d.chr = chr_client;
 352     id = g_idle_add(char_socket_test_idle, &d);
 353     g_source_set_name_by_id(id, "test-idle");
 354     g_assert_cmpint(id, >, 0);
 355     main_loop();
 356
 357     g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 358     g_assert(object_property_get_bool(OBJECT(chr_client),
 359                                       "connected", &error_abort));
 360
 361     qemu_chr_write_all(chr_client, (const uint8_t *)"Z", 1);
 362     main_loop();
 363
 364     object_unparent(OBJECT(chr_client));
 365
 366     d.chr = chr;
 367     d.conn_expected = false;
 368     g_idle_add(char_socket_test_idle, &d);
 369     main_loop();
 370
 371     object_unparent(OBJECT(chr));
 372 }
 373
 374
 375 static void char_socket_basic_test(void)
 376 {
 377     Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
 378
 379     char_socket_test_common(chr, false);
 380 }
 381
 382
 383 static void char_socket_reconnect_test(void)
 384 {
 385     Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
 386
 387     char_socket_test_common(chr, true);
 388 }
 389
 390
 391 static void char_socket_fdpass_test(void)
 392 {
 393     Chardev *chr;
 394     char *optstr;
 395     QemuOpts *opts;
 396     int fd;
 397     SocketAddress *addr = g_new0(SocketAddress, 1);
 398
 399     addr->type = SOCKET_ADDRESS_TYPE_INET;
 400     addr->u.inet.host = g_strdup("127.0.0.1");
 401     addr->u.inet.port = g_strdup("0");
 402
 403     fd = socket_listen(addr, &error_abort);
 404     g_assert(fd >= 0);
 405
 406     qapi_free_SocketAddress(addr);
 407
 408     optstr = g_strdup_printf("socket,id=cdev,fd=%d,server,nowait", fd);
 409
 410     opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"),
 411                                    optstr, true);
 412     g_free(optstr);
 413     g_assert_nonnull(opts);
 414
 415     chr = qemu_chr_new_from_opts(opts, &error_abort);
 416
 417     qemu_opts_del(opts);
 418
 419     char_socket_test_common(chr, false);
 420 }
 421
 422
 423 #ifndef _WIN32
 424 static void char_pipe_test(void)
 425 {
 426     gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 427     gchar *tmp, *in, *out, *pipe = g_build_filename(tmp_path, "pipe", NULL);
 428     Chardev *chr;
 429     CharBackend be;
 430     int ret, fd;
 431     char buf[10];
 432     FeHandler fe = { 0, };
 433
 434     in = g_strdup_printf("%s.in", pipe);
 435     if (mkfifo(in, 0600) < 0) {
 436         abort();
 437     }
 438     out = g_strdup_printf("%s.out", pipe);
 439     if (mkfifo(out, 0600) < 0) {
 440         abort();
 441     }
 442
 443     tmp = g_strdup_printf("pipe:%s", pipe);
 444     chr = qemu_chr_new("pipe", tmp);
 445     g_assert_nonnull(chr);
 446     g_free(tmp);
 447
 448     qemu_chr_fe_init(&be, chr, &error_abort);
 449
 450     ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9);
 451     g_assert_cmpint(ret, ==, 9);
 452
 453     fd = open(out, O_RDWR);
 454     ret = read(fd, buf, sizeof(buf));
 455     g_assert_cmpint(ret, ==, 9);
 456     g_assert_cmpstr(buf, ==, "pipe-out");
 457     close(fd);
 458
 459     fd = open(in, O_WRONLY);
 460     ret = write(fd, "pipe-in", 8);
 461     g_assert_cmpint(ret, ==, 8);
 462     close(fd);
 463
 464     qemu_chr_fe_set_handlers(&be,
 465                              fe_can_read,
 466                              fe_read,
 467                              fe_event,
 468                              NULL,
 469                              &fe,
 470                              NULL, true);
 471
 472     main_loop();
 473
 474     g_assert_cmpint(fe.read_count, ==, 8);
 475     g_assert_cmpstr(fe.read_buf, ==, "pipe-in");
 476
 477     qemu_chr_fe_deinit(&be, true);
 478
 479     g_assert(g_unlink(in) == 0);
 480     g_assert(g_unlink(out) == 0);
 481     g_assert(g_rmdir(tmp_path) == 0);
 482     g_free(in);
 483     g_free(out);
 484     g_free(tmp_path);
 485     g_free(pipe);
 486 }
 487 #endif
 488
 489 static int make_udp_socket(int *port)
 490 {
 491     struct sockaddr_in addr = { 0, };
 492     socklen_t alen = sizeof(addr);
 493     int ret, sock = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 494
 495     g_assert_cmpint(sock, >, 0);
 496     addr.sin_family = AF_INET ;
 497     addr.sin_addr.s_addr = htonl(INADDR_ANY);
 498     addr.sin_port = 0;
 499     ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
 500     g_assert_cmpint(ret, ==, 0);
 501     ret = getsockname(sock, (struct sockaddr *)&addr, &alen);
 502     g_assert_cmpint(ret, ==, 0);
 503
 504     *port = ntohs(addr.sin_port);
 505     return sock;
 506 }
 507
 508 static void char_udp_test_internal(Chardev *reuse_chr, int sock)
 509 {
 510     struct sockaddr_in other;
 511     SocketIdleData d = { 0, };
 512     Chardev *chr;
 513     CharBackend *be;
 514     socklen_t alen = sizeof(other);
 515     int ret;
 516     char buf[10];
 517     char *tmp = NULL;
 518
 519     if (reuse_chr) {
 520         chr = reuse_chr;
 521         be = chr->be;
 522     } else {
 523         int port;
 524         sock = make_udp_socket(&port);
 525         tmp = g_strdup_printf("udp:127.0.0.1:%d", port);
 526         chr = qemu_chr_new("client", tmp);
 527         g_assert_nonnull(chr);
 528
 529         be = g_alloca(sizeof(CharBackend));
 530         qemu_chr_fe_init(be, chr, &error_abort);
 531     }
 532
 533     d.chr = chr;
 534     qemu_chr_fe_set_handlers(be, socket_can_read_hello, socket_read_hello,
 535                              NULL, NULL, &d, NULL, true);
 536     ret = qemu_chr_write_all(chr, (uint8_t *)"hello", 5);
 537     g_assert_cmpint(ret, ==, 5);
 538
 539     ret = recvfrom(sock, buf, sizeof(buf), 0,
 540                    (struct sockaddr *)&other, &alen);
 541     g_assert_cmpint(ret, ==, 5);
 542     ret = sendto(sock, buf, 5, 0, (struct sockaddr *)&other, alen);
 543     g_assert_cmpint(ret, ==, 5);
 544
 545     main_loop();
 546
 547     if (!reuse_chr) {
 548         close(sock);
 549         qemu_chr_fe_deinit(be, true);
 550     }
 551     g_free(tmp);
 552 }
 553
 554 static void char_udp_test(void)
 555 {
 556     char_udp_test_internal(NULL, 0);
 557 }
 558
 559 #ifdef HAVE_CHARDEV_SERIAL
 560 static void char_serial_test(void)
 561 {
 562     QemuOpts *opts;
 563     Chardev *chr;
 564
 565     opts = qemu_opts_create(qemu_find_opts("chardev"), "serial-id",
 566                             1, &error_abort);
 567     qemu_opt_set(opts, "backend", "serial", &error_abort);
 568     qemu_opt_set(opts, "path", "/dev/null", &error_abort);
 569
 570     chr = qemu_chr_new_from_opts(opts, NULL);
 571     g_assert_nonnull(chr);
 572     /* TODO: add more tests with a pty */
 573     object_unparent(OBJECT(chr));
 574
 575     /* test tty alias */
 576     qemu_opt_set(opts, "backend", "tty", &error_abort);
 577     chr = qemu_chr_new_from_opts(opts, NULL);
 578     g_assert_nonnull(chr);
 579     object_unparent(OBJECT(chr));
 580
 581     qemu_opts_del(opts);
 582 }
 583 #endif
 584
 585 #ifndef _WIN32
 586 static void char_file_fifo_test(void)
 587 {
 588     Chardev *chr;
 589     CharBackend be;
 590     char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 591     char *fifo = g_build_filename(tmp_path, "fifo", NULL);
 592     char *out = g_build_filename(tmp_path, "out", NULL);
 593     ChardevFile file = { .in = fifo,
 594                          .has_in = true,
 595                          .out = out };
 596     ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
 597                                .u.file.data = &file };
 598     FeHandler fe = { 0, };
 599     int fd, ret;
 600
 601     if (mkfifo(fifo, 0600) < 0) {
 602         abort();
 603     }
 604
 605     fd = open(fifo, O_RDWR);
 606     ret = write(fd, "fifo-in", 8);
 607     g_assert_cmpint(ret, ==, 8);
 608
 609     chr = qemu_chardev_new("label-file", TYPE_CHARDEV_FILE, &backend,
 610                            &error_abort);
 611
 612     qemu_chr_fe_init(&be, chr, &error_abort);
 613     qemu_chr_fe_set_handlers(&be,
 614                              fe_can_read,
 615                              fe_read,
 616                              fe_event,
 617                              NULL,
 618                              &fe, NULL, true);
 619
 620     g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK);
 621     qmp_chardev_send_break("label-foo", NULL);
 622     g_assert_cmpint(fe.last_event, !=, CHR_EVENT_BREAK);
 623     qmp_chardev_send_break("label-file", NULL);
 624     g_assert_cmpint(fe.last_event, ==, CHR_EVENT_BREAK);
 625
 626     main_loop();
 627
 628     close(fd);
 629
 630     g_assert_cmpint(fe.read_count, ==, 8);
 631     g_assert_cmpstr(fe.read_buf, ==, "fifo-in");
 632
 633     qemu_chr_fe_deinit(&be, true);
 634
 635     g_unlink(fifo);
 636     g_free(fifo);
 637     g_unlink(out);
 638     g_free(out);
 639     g_rmdir(tmp_path);
 640     g_free(tmp_path);
 641 }
 642 #endif
 643
 644 static void char_file_test_internal(Chardev *ext_chr, const char *filepath)
 645 {
 646     char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 647     char *out;
 648     Chardev *chr;
 649     char *contents = NULL;
 650     ChardevFile file = {};
 651     ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
 652                                .u.file.data = &file };
 653     gsize length;
 654     int ret;
 655
 656     if (ext_chr) {
 657         chr = ext_chr;
 658         out = g_strdup(filepath);
 659         file.out = out;
 660     } else {
 661         out = g_build_filename(tmp_path, "out", NULL);
 662         file.out = out;
 663         chr = qemu_chardev_new(NULL, TYPE_CHARDEV_FILE, &backend,
 664                                &error_abort);
 665     }
 666     ret = qemu_chr_write_all(chr, (uint8_t *)"hello!", 6);
 667     g_assert_cmpint(ret, ==, 6);
 668
 669     ret = g_file_get_contents(out, &contents, &length, NULL);
 670     g_assert(ret == TRUE);
 671     g_assert_cmpint(length, ==, 6);
 672     g_assert(strncmp(contents, "hello!", 6) == 0);
 673
 674     if (!ext_chr) {
 675         object_unref(OBJECT(chr));
 676         g_unlink(out);
 677     }
 678     g_free(contents);
 679     g_rmdir(tmp_path);
 680     g_free(tmp_path);
 681     g_free(out);
 682 }
 683
 684 static void char_file_test(void)
 685 {
 686     char_file_test_internal(NULL, NULL);
 687 }
 688
 689 static void char_null_test(void)
 690 {
 691     Error *err = NULL;
 692     Chardev *chr;
 693     CharBackend be;
 694     int ret;
 695
 696     chr = qemu_chr_find("label-null");
 697     g_assert_null(chr);
 698
 699     chr = qemu_chr_new("label-null", "null");
 700     chr = qemu_chr_find("label-null");
 701     g_assert_nonnull(chr);
 702
 703     g_assert(qemu_chr_has_feature(chr,
 704                  QEMU_CHAR_FEATURE_FD_PASS) == false);
 705     g_assert(qemu_chr_has_feature(chr,
 706                  QEMU_CHAR_FEATURE_RECONNECTABLE) == false);
 707
 708     /* check max avail */
 709     qemu_chr_fe_init(&be, chr, &error_abort);
 710     qemu_chr_fe_init(&be, chr, &err);
 711     error_free_or_abort(&err);
 712
 713     /* deinit & reinit */
 714     qemu_chr_fe_deinit(&be, false);
 715     qemu_chr_fe_init(&be, chr, &error_abort);
 716
 717     qemu_chr_fe_set_open(&be, true);
 718
 719     qemu_chr_fe_set_handlers(&be,
 720                              fe_can_read,
 721                              fe_read,
 722                              fe_event,
 723                              NULL,
 724                              NULL, NULL, true);
 725
 726     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
 727     g_assert_cmpint(ret, ==, 4);
 728
 729     qemu_chr_fe_deinit(&be, true);
 730 }
 731
 732 static void char_invalid_test(void)
 733 {
 734     Chardev *chr;
 735
 736     chr = qemu_chr_new("label-invalid", "invalid");
 737     g_assert_null(chr);
 738 }
 739
 740 static int chardev_change(void *opaque)
 741 {
 742     return 0;
 743 }
 744
 745 static int chardev_change_denied(void *opaque)
 746 {
 747     return -1;
 748 }
 749
 750 static void char_hotswap_test(void)
 751 {
 752     char *chr_args;
 753     Chardev *chr;
 754     CharBackend be;
 755
 756     gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 757     char *filename = g_build_filename(tmp_path, "file", NULL);
 758     ChardevFile file = { .out = filename };
 759     ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
 760                                .u.file.data = &file };
 761     ChardevReturn *ret;
 762
 763     int port;
 764     int sock = make_udp_socket(&port);
 765     g_assert_cmpint(sock, >, 0);
 766
 767     chr_args = g_strdup_printf("udp:127.0.0.1:%d", port);
 768
 769     chr = qemu_chr_new("chardev", chr_args);
 770     qemu_chr_fe_init(&be, chr, &error_abort);
 771
 772     /* check that chardev operates correctly */
 773     char_udp_test_internal(chr, sock);
 774
 775     /* set the handler that denies the hotswap */
 776     qemu_chr_fe_set_handlers(&be, NULL, NULL,
 777                              NULL, chardev_change_denied, NULL, NULL, true);
 778
 779     /* now, change is denied and has to keep the old backend operating */
 780     ret = qmp_chardev_change("chardev", &backend, NULL);
 781     g_assert(!ret);
 782     g_assert(be.chr == chr);
 783
 784     char_udp_test_internal(chr, sock);
 785
 786     /* now allow the change */
 787     qemu_chr_fe_set_handlers(&be, NULL, NULL,
 788                              NULL, chardev_change, NULL, NULL, true);
 789
 790     /* has to succeed now */
 791     ret = qmp_chardev_change("chardev", &backend, &error_abort);
 792     g_assert(be.chr != chr);
 793
 794     close(sock);
 795     chr = be.chr;
 796
 797     /* run the file chardev test */
 798     char_file_test_internal(chr, filename);
 799
 800     object_unparent(OBJECT(chr));
 801
 802     qapi_free_ChardevReturn(ret);
 803     g_unlink(filename);
 804     g_free(filename);
 805     g_rmdir(tmp_path);
 806     g_free(tmp_path);
 807     g_free(chr_args);
 808 }
 809
 810 int main(int argc, char **argv)
 811 {
 812     qemu_init_main_loop(&error_abort);
 813     socket_init();
 814
 815     g_test_init(&argc, &argv, NULL);
 816
 817     module_call_init(MODULE_INIT_QOM);
 818     qemu_add_opts(&qemu_chardev_opts);
 819
 820     g_test_add_func("/char/null", char_null_test);
 821     g_test_add_func("/char/invalid", char_invalid_test);
 822     g_test_add_func("/char/ringbuf", char_ringbuf_test);
 823     g_test_add_func("/char/mux", char_mux_test);
 824 #ifdef _WIN32
 825     g_test_add_func("/char/console/subprocess", char_console_test_subprocess);
 826     g_test_add_func("/char/console", char_console_test);
 827 #endif
 828     g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess);
 829     g_test_add_func("/char/stdio", char_stdio_test);
 830 #ifndef _WIN32
 831     g_test_add_func("/char/pipe", char_pipe_test);
 832 #endif
 833     g_test_add_func("/char/file", char_file_test);
 834 #ifndef _WIN32
 835     g_test_add_func("/char/file-fifo", char_file_fifo_test);
 836 #endif
 837     g_test_add_func("/char/socket/basic", char_socket_basic_test);
 838     g_test_add_func("/char/socket/reconnect", char_socket_reconnect_test);
 839     g_test_add_func("/char/socket/fdpass", char_socket_fdpass_test);
 840     g_test_add_func("/char/udp", char_udp_test);
 841 #ifdef HAVE_CHARDEV_SERIAL
 842     g_test_add_func("/char/serial", char_serial_test);
 843 #endif
 844     g_test_add_func("/char/hotswap", char_hotswap_test);
 845
 846     return g_test_run();
 847 }