tests/test-char.c

   1 #include "qemu/osdep.h"
   2 #include <glib/gstdio.h>
   3
   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"
  12
  13 static bool quit;
  14
  15 typedef struct FeHandler {
  16     int read_count;
  17     int last_event;
  18     char read_buf[128];
  19 } FeHandler;
  20
  21 static void main_loop(void)
  22 {
  23     bool nonblocking;
  24     int last_io = 0;
  25
  26     quit = false;
  27     do {
  28         nonblocking = last_io > 0;
  29         last_io = main_loop_wait(nonblocking);
  30     } while (!quit);
  31 }
  32
  33 static int fe_can_read(void *opaque)
  34 {
  35     FeHandler *h = opaque;
  36
  37     return sizeof(h->read_buf) - h->read_count;
  38 }
  39
  40 static void fe_read(void *opaque, const uint8_t *buf, int size)
  41 {
  42     FeHandler *h = opaque;
  43
  44     g_assert_cmpint(size, <=, fe_can_read(opaque));
  45
  46     memcpy(h->read_buf + h->read_count, buf, size);
  47     h->read_count += size;
  48     quit = true;
  49 }
  50
  51 static void fe_event(void *opaque, int event)
  52 {
  53     FeHandler *h = opaque;
  54
  55     h->last_event = event;
  56     if (event != CHR_EVENT_BREAK) {
  57         quit = true;
  58     }
  59 }
  60
  61 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
  62 #ifdef _WIN32
  63 static void char_console_test_subprocess(void)
  64 {
  65     QemuOpts *opts;
  66     Chardev *chr;
  67
  68     opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label",
  69                             1, &error_abort);
  70     qemu_opt_set(opts, "backend", "console", &error_abort);
  71
  72     chr = qemu_chr_new_from_opts(opts, NULL);
  73     g_assert_nonnull(chr);
  74
  75     qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7);
  76
  77     qemu_opts_del(opts);
  78     object_unparent(OBJECT(chr));
  79 }
  80
  81 static void char_console_test(void)
  82 {
  83     g_test_trap_subprocess("/char/console/subprocess", 0, 0);
  84     g_test_trap_assert_passed();
  85     g_test_trap_assert_stdout("CONSOLE");
  86 }
  87 #endif
  88 static void char_stdio_test_subprocess(void)
  89 {
  90     Chardev *chr;
  91     CharBackend be;
  92     int ret;
  93
  94     chr = qemu_chr_new("label", "stdio");
  95     g_assert_nonnull(chr);
  96
  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);
 101
 102     qemu_chr_fe_deinit(&be, true);
 103 }
 104
 105 static void char_stdio_test(void)
 106 {
 107     g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
 108     g_test_trap_assert_passed();
 109     g_test_trap_assert_stdout("buf");
 110 }
 111 #endif
 112
 113 static void char_ringbuf_test(void)
 114 {
 115     QemuOpts *opts;
 116     Chardev *chr;
 117     CharBackend be;
 118     char *data;
 119     int ret;
 120
 121     opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
 122                             1, &error_abort);
 123     qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
 124
 125     qemu_opt_set(opts, "size", "5", &error_abort);
 126     chr = qemu_chr_new_from_opts(opts, NULL);
 127     g_assert_null(chr);
 128     qemu_opts_del(opts);
 129
 130     opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
 131                             1, &error_abort);
 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);
 136     qemu_opts_del(opts);
 137
 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);
 141
 142     data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
 143     g_assert_cmpstr(data, ==, "ff");
 144     g_free(data);
 145
 146     data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
 147     g_assert_cmpstr(data, ==, "");
 148     g_free(data);
 149
 150     qemu_chr_fe_deinit(&be, true);
 151
 152     /* check alias */
 153     opts = qemu_opts_create(qemu_find_opts("chardev"), "memory-label",
 154                             1, &error_abort);
 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));
 160     qemu_opts_del(opts);
 161 }
 162
 163 static void char_mux_test(void)
 164 {
 165     QemuOpts *opts;
 166     Chardev *chr, *base;
 167     char *data;
 168     FeHandler h1 = { 0, }, h2 = { 0, };
 169     CharBackend chr_be1, chr_be2;
 170
 171     opts = qemu_opts_create(qemu_find_opts("chardev"), "mux-label",
 172                             1, &error_abort);
 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);
 178     qemu_opts_del(opts);
 179
 180     qemu_chr_fe_init(&chr_be1, chr, &error_abort);
 181     qemu_chr_fe_set_handlers(&chr_be1,
 182                              fe_can_read,
 183                              fe_read,
 184                              fe_event,
 185                              &h1,
 186                              NULL, true);
 187
 188     qemu_chr_fe_init(&chr_be2, chr, &error_abort);
 189     qemu_chr_fe_set_handlers(&chr_be2,
 190                              fe_can_read,
 191                              fe_read,
 192                              fe_event,
 193                              &h2,
 194                              NULL, true);
 195     qemu_chr_fe_take_focus(&chr_be2);
 196
 197     base = qemu_chr_find("mux-label-base");
 198     g_assert_cmpint(qemu_chr_be_can_write(base), !=, 0);
 199
 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");
 204     h2.read_count = 0;
 205
 206     /* switch focus */
 207     qemu_chr_be_write(base, (void *)"\1c", 2);
 208
 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");
 213     h1.read_count = 0;
 214
 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);
 220
 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");
 226     h2.read_count = 0;
 227
 228     /* print help */
 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);
 232     g_free(data);
 233
 234     qemu_chr_fe_deinit(&chr_be1, false);
 235     qemu_chr_fe_deinit(&chr_be2, true);
 236 }
 237
 238 typedef struct SocketIdleData {
 239     GMainLoop *loop;
 240     Chardev *chr;
 241     bool conn_expected;
 242     CharBackend *be;
 243     CharBackend *client_be;
 244 } SocketIdleData;
 245
 246 static gboolean char_socket_test_idle(gpointer user_data)
 247 {
 248     SocketIdleData *data = user_data;
 249
 250     if (object_property_get_bool(OBJECT(data->chr), "connected", NULL)
 251         == data->conn_expected) {
 252         quit = true;
 253         return FALSE;
 254     }
 255
 256     return TRUE;
 257 }
 258
 259 static void socket_read(void *opaque, const uint8_t *buf, int size)
 260 {
 261     SocketIdleData *data = opaque;
 262
 263     g_assert_cmpint(size, ==, 1);
 264     g_assert_cmpint(*buf, ==, 'Z');
 265
 266     size = qemu_chr_fe_write(data->be, (const uint8_t *)"hello", 5);
 267     g_assert_cmpint(size, ==, 5);
 268 }
 269
 270 static int socket_can_read(void *opaque)
 271 {
 272     return 10;
 273 }
 274
 275 static void socket_read_hello(void *opaque, const uint8_t *buf, int size)
 276 {
 277     g_assert_cmpint(size, ==, 5);
 278     g_assert(strncmp((char *)buf, "hello", 5) == 0);
 279
 280     quit = true;
 281 }
 282
 283 static int socket_can_read_hello(void *opaque)
 284 {
 285     return 10;
 286 }
 287
 288 static void char_socket_test(void)
 289 {
 290     Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
 291     Chardev *chr_client;
 292     QObject *addr;
 293     QDict *qdict;
 294     const char *port;
 295     SocketIdleData d = { .chr = chr };
 296     CharBackend be;
 297     CharBackend client_be;
 298     char *tmp;
 299
 300     d.be = &be;
 301     d.client_be = &be;
 302
 303     g_assert_nonnull(chr);
 304     g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 305
 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);
 310     QDECREF(qdict);
 311
 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);
 315
 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,
 319                              socket_read_hello,
 320                              NULL, &d, NULL, true);
 321     g_free(tmp);
 322
 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);
 327     main_loop();
 328
 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));
 332
 333     qemu_chr_write_all(chr_client, (const uint8_t *)"Z", 1);
 334     main_loop();
 335
 336     object_unparent(OBJECT(chr_client));
 337
 338     d.conn_expected = false;
 339     g_idle_add(char_socket_test_idle, &d);
 340     main_loop();
 341
 342     object_unparent(OBJECT(chr));
 343 }
 344
 345 #ifndef _WIN32
 346 static void char_pipe_test(void)
 347 {
 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);
 350     Chardev *chr;
 351     CharBackend be;
 352     int ret, fd;
 353     char buf[10];
 354     FeHandler fe = { 0, };
 355
 356     in = g_strdup_printf("%s.in", pipe);
 357     if (mkfifo(in, 0600) < 0) {
 358         abort();
 359     }
 360     out = g_strdup_printf("%s.out", pipe);
 361     if (mkfifo(out, 0600) < 0) {
 362         abort();
 363     }
 364
 365     tmp = g_strdup_printf("pipe:%s", pipe);
 366     chr = qemu_chr_new("pipe", tmp);
 367     g_assert_nonnull(chr);
 368     g_free(tmp);
 369
 370     qemu_chr_fe_init(&be, chr, &error_abort);
 371
 372     ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9);
 373     g_assert_cmpint(ret, ==, 9);
 374
 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");
 379     close(fd);
 380
 381     fd = open(in, O_WRONLY);
 382     ret = write(fd, "pipe-in", 8);
 383     g_assert_cmpint(ret, ==, 8);
 384     close(fd);
 385
 386     qemu_chr_fe_set_handlers(&be,
 387                              fe_can_read,
 388                              fe_read,
 389                              fe_event,
 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
 398     qemu_chr_fe_deinit(&be, true);
 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
 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,
 438                              NULL, &d, NULL, true);
 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
 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
 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;
 522         chr = qemu_chardev_new("label-file", TYPE_CHARDEV_FILE, &backend,
 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,
 530                                  &fe, NULL, true);
 531
 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);
 537
 538         main_loop();
 539
 540         close(fd);
 541
 542         g_assert_cmpint(fe.read_count, ==, 8);
 543         g_assert_cmpstr(fe.read_buf, ==, "fifo-in");
 544         qemu_chr_fe_deinit(&be, true);
 545         g_unlink(fifo);
 546         g_free(fifo);
 547     }
 548 #endif
 549
 550     g_unlink(out);
 551     g_rmdir(tmp_path);
 552     g_free(tmp_path);
 553     g_free(out);
 554 }
 555
 556 static void char_null_test(void)
 557 {
 558     Error *err = NULL;
 559     Chardev *chr;
 560     CharBackend be;
 561     int ret;
 562
 563     chr = qemu_chr_find("label-null");
 564     g_assert_null(chr);
 565
 566     chr = qemu_chr_new("label-null", "null");
 567     chr = qemu_chr_find("label-null");
 568     g_assert_nonnull(chr);
 569
 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);
 574
 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);
 579
 580     /* deinit & reinit */
 581     qemu_chr_fe_deinit(&be, false);
 582     qemu_chr_fe_init(&be, chr, &error_abort);
 583
 584     qemu_chr_fe_set_open(&be, true);
 585
 586     qemu_chr_fe_set_handlers(&be,
 587                              fe_can_read,
 588                              fe_read,
 589                              fe_event,
 590                              NULL, NULL, true);
 591
 592     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
 593     g_assert_cmpint(ret, ==, 4);
 594
 595     qemu_chr_fe_deinit(&be, true);
 596 }
 597
 598 static void char_invalid_test(void)
 599 {
 600     Chardev *chr;
 601
 602     chr = qemu_chr_new("label-invalid", "invalid");
 603     g_assert_null(chr);
 604 }
 605
 606 int main(int argc, char **argv)
 607 {
 608     qemu_init_main_loop(&error_abort);
 609     socket_init();
 610
 611     g_test_init(&argc, &argv, NULL);
 612
 613     module_call_init(MODULE_INIT_QOM);
 614     qemu_add_opts(&qemu_chardev_opts);
 615
 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
 621 #ifdef _WIN32
 622     g_test_add_func("/char/console/subprocess", char_console_test_subprocess);
 623     g_test_add_func("/char/console", char_console_test);
 624 #endif
 625     g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess);
 626     g_test_add_func("/char/stdio", char_stdio_test);
 627 #endif
 628 #ifndef _WIN32
 629     g_test_add_func("/char/pipe", char_pipe_test);
 630 #endif
 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);
 636 #endif
 637
 638     return g_test_run();
 639 }