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 "sysemu/char.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     quit = true;
  57 }
  58
  59 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
  60 #ifdef _WIN32
  61 static void char_console_test_subprocess(void)
  62 {
  63     QemuOpts *opts;
  64     Chardev *chr;
  65
  66     opts = qemu_opts_create(qemu_find_opts("chardev"), "console-label",
  67                             1, &error_abort);
  68     qemu_opt_set(opts, "backend", "console", &error_abort);
  69
  70     chr = qemu_chr_new_from_opts(opts, NULL);
  71     g_assert_nonnull(chr);
  72
  73     qemu_chr_write_all(chr, (const uint8_t *)"CONSOLE", 7);
  74
  75     qemu_opts_del(opts);
  76     object_unparent(OBJECT(chr));
  77 }
  78
  79 static void char_console_test(void)
  80 {
  81     g_test_trap_subprocess("/char/console/subprocess", 0, 0);
  82     g_test_trap_assert_passed();
  83     g_test_trap_assert_stdout("CONSOLE");
  84 }
  85 #endif
  86 static void char_stdio_test_subprocess(void)
  87 {
  88     Chardev *chr;
  89     CharBackend be;
  90     int ret;
  91
  92     chr = qemu_chr_new("label", "stdio");
  93     g_assert_nonnull(chr);
  94
  95     qemu_chr_fe_init(&be, chr, &error_abort);
  96     qemu_chr_fe_set_open(&be, true);
  97     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
  98     g_assert_cmpint(ret, ==, 4);
  99
 100     qemu_chr_fe_deinit(&be);
 101     object_unparent(OBJECT(chr));
 102 }
 103
 104 static void char_stdio_test(void)
 105 {
 106     g_test_trap_subprocess("/char/stdio/subprocess", 0, 0);
 107     g_test_trap_assert_passed();
 108     g_test_trap_assert_stdout("buf");
 109 }
 110 #endif
 111
 112 static void char_ringbuf_test(void)
 113 {
 114     QemuOpts *opts;
 115     Chardev *chr;
 116     CharBackend be;
 117     char *data;
 118     int ret;
 119
 120     opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
 121                             1, &error_abort);
 122     qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
 123
 124     qemu_opt_set(opts, "size", "5", &error_abort);
 125     chr = qemu_chr_new_from_opts(opts, NULL);
 126     g_assert_null(chr);
 127     qemu_opts_del(opts);
 128
 129     opts = qemu_opts_create(qemu_find_opts("chardev"), "ringbuf-label",
 130                             1, &error_abort);
 131     qemu_opt_set(opts, "backend", "ringbuf", &error_abort);
 132     qemu_opt_set(opts, "size", "2", &error_abort);
 133     chr = qemu_chr_new_from_opts(opts, &error_abort);
 134     g_assert_nonnull(chr);
 135     qemu_opts_del(opts);
 136
 137     qemu_chr_fe_init(&be, chr, &error_abort);
 138     ret = qemu_chr_fe_write(&be, (void *)"buff", 4);
 139     g_assert_cmpint(ret, ==, 4);
 140
 141     data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
 142     g_assert_cmpstr(data, ==, "ff");
 143     g_free(data);
 144
 145     data = qmp_ringbuf_read("ringbuf-label", 4, false, 0, &error_abort);
 146     g_assert_cmpstr(data, ==, "");
 147     g_free(data);
 148
 149     qemu_chr_fe_deinit(&be);
 150     object_unparent(OBJECT(chr));
 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);
 235     qemu_chr_fe_deinit(&chr_be2);
 236     object_unparent(OBJECT(chr));
 237 }
 238
 239 typedef struct SocketIdleData {
 240     GMainLoop *loop;
 241     Chardev *chr;
 242     bool conn_expected;
 243     CharBackend *be;
 244     CharBackend *client_be;
 245 } SocketIdleData;
 246
 247 static gboolean char_socket_test_idle(gpointer user_data)
 248 {
 249     SocketIdleData *data = user_data;
 250
 251     if (object_property_get_bool(OBJECT(data->chr), "connected", NULL)
 252         == data->conn_expected) {
 253         quit = true;
 254         return FALSE;
 255     }
 256
 257     return TRUE;
 258 }
 259
 260 static void socket_read(void *opaque, const uint8_t *buf, int size)
 261 {
 262     SocketIdleData *data = opaque;
 263
 264     g_assert_cmpint(size, ==, 1);
 265     g_assert_cmpint(*buf, ==, 'Z');
 266
 267     size = qemu_chr_fe_write(data->be, (const uint8_t *)"hello", 5);
 268     g_assert_cmpint(size, ==, 5);
 269 }
 270
 271 static int socket_can_read(void *opaque)
 272 {
 273     return 10;
 274 }
 275
 276 static void socket_read_hello(void *opaque, const uint8_t *buf, int size)
 277 {
 278     g_assert_cmpint(size, ==, 5);
 279     g_assert(strncmp((char *)buf, "hello", 5) == 0);
 280
 281     quit = true;
 282 }
 283
 284 static int socket_can_read_hello(void *opaque)
 285 {
 286     return 10;
 287 }
 288
 289 static void char_socket_test(void)
 290 {
 291     Chardev *chr = qemu_chr_new("server", "tcp:127.0.0.1:0,server,nowait");
 292     Chardev *chr_client;
 293     QObject *addr;
 294     QDict *qdict, *data;
 295     const char *port;
 296     SocketIdleData d = { .chr = chr };
 297     CharBackend be;
 298     CharBackend client_be;
 299     char *tmp;
 300
 301     d.be = &be;
 302     d.client_be = &be;
 303
 304     g_assert_nonnull(chr);
 305     g_assert(!object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 306
 307     addr = object_property_get_qobject(OBJECT(chr), "addr", &error_abort);
 308     qdict = qobject_to_qdict(addr);
 309     data = qdict_get_qdict(qdict, "data");
 310     port = qdict_get_str(data, "port");
 311     tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
 312     QDECREF(qdict);
 313
 314     qemu_chr_fe_init(&be, chr, &error_abort);
 315     qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read,
 316                              NULL, &d, NULL, true);
 317
 318     chr_client = qemu_chr_new("client", tmp);
 319     qemu_chr_fe_init(&client_be, chr_client, &error_abort);
 320     qemu_chr_fe_set_handlers(&client_be, socket_can_read_hello,
 321                              socket_read_hello,
 322                              NULL, &d, NULL, true);
 323     g_free(tmp);
 324
 325     d.conn_expected = true;
 326     guint id = g_idle_add(char_socket_test_idle, &d);
 327     g_source_set_name_by_id(id, "test-idle");
 328     g_assert_cmpint(id, >, 0);
 329     main_loop();
 330
 331     g_assert(object_property_get_bool(OBJECT(chr), "connected", &error_abort));
 332     g_assert(object_property_get_bool(OBJECT(chr_client),
 333                                       "connected", &error_abort));
 334
 335     qemu_chr_write_all(chr_client, (const uint8_t *)"Z", 1);
 336     main_loop();
 337
 338     object_unparent(OBJECT(chr_client));
 339
 340     d.conn_expected = false;
 341     g_idle_add(char_socket_test_idle, &d);
 342     main_loop();
 343
 344     object_unparent(OBJECT(chr));
 345 }
 346
 347 #ifndef _WIN32
 348 static void char_pipe_test(void)
 349 {
 350     gchar *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 351     gchar *tmp, *in, *out, *pipe = g_build_filename(tmp_path, "pipe", NULL);
 352     Chardev *chr;
 353     CharBackend be;
 354     int ret, fd;
 355     char buf[10];
 356     FeHandler fe = { 0, };
 357
 358     in = g_strdup_printf("%s.in", pipe);
 359     if (mkfifo(in, 0600) < 0) {
 360         abort();
 361     }
 362     out = g_strdup_printf("%s.out", pipe);
 363     if (mkfifo(out, 0600) < 0) {
 364         abort();
 365     }
 366
 367     tmp = g_strdup_printf("pipe:%s", pipe);
 368     chr = qemu_chr_new("pipe", tmp);
 369     g_assert_nonnull(chr);
 370     g_free(tmp);
 371
 372     qemu_chr_fe_init(&be, chr, &error_abort);
 373
 374     ret = qemu_chr_fe_write(&be, (void *)"pipe-out", 9);
 375     g_assert_cmpint(ret, ==, 9);
 376
 377     fd = open(out, O_RDWR);
 378     ret = read(fd, buf, sizeof(buf));
 379     g_assert_cmpint(ret, ==, 9);
 380     g_assert_cmpstr(buf, ==, "pipe-out");
 381     close(fd);
 382
 383     fd = open(in, O_WRONLY);
 384     ret = write(fd, "pipe-in", 8);
 385     g_assert_cmpint(ret, ==, 8);
 386     close(fd);
 387
 388     qemu_chr_fe_set_handlers(&be,
 389                              fe_can_read,
 390                              fe_read,
 391                              fe_event,
 392                              &fe,
 393                              NULL, true);
 394
 395     main_loop();
 396
 397     g_assert_cmpint(fe.read_count, ==, 8);
 398     g_assert_cmpstr(fe.read_buf, ==, "pipe-in");
 399
 400     qemu_chr_fe_deinit(&be);
 401     object_unparent(OBJECT(chr));
 402
 403     g_assert(g_unlink(in) == 0);
 404     g_assert(g_unlink(out) == 0);
 405     g_assert(g_rmdir(tmp_path) == 0);
 406     g_free(in);
 407     g_free(out);
 408     g_free(tmp_path);
 409     g_free(pipe);
 410 }
 411 #endif
 412
 413 static void char_udp_test(void)
 414 {
 415     struct sockaddr_in addr = { 0, }, other;
 416     SocketIdleData d = { 0, };
 417     Chardev *chr;
 418     CharBackend be;
 419     socklen_t alen = sizeof(addr);
 420     int ret, sock = qemu_socket(PF_INET, SOCK_DGRAM, 0);
 421     char buf[10];
 422     char *tmp;
 423
 424     g_assert_cmpint(sock, >, 0);
 425     addr.sin_family = AF_INET ;
 426     addr.sin_addr.s_addr = htonl(INADDR_ANY);
 427     addr.sin_port = 0;
 428     ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
 429     g_assert_cmpint(ret, ==, 0);
 430     ret = getsockname(sock, (struct sockaddr *)&addr, &alen);
 431     g_assert_cmpint(ret, ==, 0);
 432
 433     tmp = g_strdup_printf("udp:127.0.0.1:%d",
 434                           ntohs(addr.sin_port));
 435     chr = qemu_chr_new("client", tmp);
 436     g_assert_nonnull(chr);
 437
 438     d.chr = chr;
 439     qemu_chr_fe_init(&be, chr, &error_abort);
 440     qemu_chr_fe_set_handlers(&be, socket_can_read_hello, socket_read_hello,
 441                              NULL, &d, NULL, true);
 442     ret = qemu_chr_write_all(chr, (uint8_t *)"hello", 5);
 443     g_assert_cmpint(ret, ==, 5);
 444
 445     alen = sizeof(addr);
 446     ret = recvfrom(sock, buf, sizeof(buf), 0,
 447                    (struct sockaddr *)&other, &alen);
 448     g_assert_cmpint(ret, ==, 5);
 449     ret = sendto(sock, buf, 5, 0, (struct sockaddr *)&other, alen);
 450     g_assert_cmpint(ret, ==, 5);
 451
 452     main_loop();
 453
 454     close(sock);
 455     g_free(tmp);
 456 }
 457
 458 static void char_file_test(void)
 459 {
 460     char *tmp_path = g_dir_make_tmp("qemu-test-char.XXXXXX", NULL);
 461     char *out = g_build_filename(tmp_path, "out", NULL);
 462     char *contents = NULL;
 463     ChardevFile file = { .out = out };
 464     ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
 465                                .u.file.data = &file };
 466     Chardev *chr;
 467     gsize length;
 468     int ret;
 469
 470     chr = qemu_chardev_new(NULL, TYPE_CHARDEV_FILE, &backend,
 471                            &error_abort);
 472     ret = qemu_chr_write_all(chr, (uint8_t *)"hello!", 6);
 473     g_assert_cmpint(ret, ==, 6);
 474     object_unref(OBJECT(chr));
 475
 476     ret = g_file_get_contents(out, &contents, &length, NULL);
 477     g_assert(ret == TRUE);
 478     g_assert_cmpint(length, ==, 6);
 479     g_assert(strncmp(contents, "hello!", 6) == 0);
 480     g_free(contents);
 481
 482 #ifndef _WIN32
 483     {
 484         CharBackend be;
 485         FeHandler fe = { 0, };
 486         char *fifo = g_build_filename(tmp_path, "fifo", NULL);
 487         int fd;
 488
 489         if (mkfifo(fifo, 0600) < 0) {
 490             abort();
 491         }
 492
 493         fd = open(fifo, O_RDWR);
 494         ret = write(fd, "fifo-in", 8);
 495         g_assert_cmpint(ret, ==, 8);
 496
 497         file.in = fifo;
 498         file.has_in = true;
 499         chr = qemu_chardev_new(NULL, TYPE_CHARDEV_FILE, &backend,
 500                                &error_abort);
 501
 502         qemu_chr_fe_init(&be, chr, &error_abort);
 503         qemu_chr_fe_set_handlers(&be,
 504                                  fe_can_read,
 505                                  fe_read,
 506                                  fe_event,
 507                                  &fe, NULL, true);
 508
 509         main_loop();
 510
 511         close(fd);
 512
 513         g_assert_cmpint(fe.read_count, ==, 8);
 514         g_assert_cmpstr(fe.read_buf, ==, "fifo-in");
 515         qemu_chr_fe_deinit(&be);
 516         object_unref(OBJECT(chr));
 517         g_unlink(fifo);
 518         g_free(fifo);
 519     }
 520 #endif
 521
 522     g_unlink(out);
 523     g_rmdir(tmp_path);
 524     g_free(tmp_path);
 525     g_free(out);
 526 }
 527
 528 static void char_null_test(void)
 529 {
 530     Error *err = NULL;
 531     Chardev *chr;
 532     CharBackend be;
 533     int ret;
 534
 535     chr = qemu_chr_find("label-null");
 536     g_assert_null(chr);
 537
 538     chr = qemu_chr_new("label-null", "null");
 539     chr = qemu_chr_find("label-null");
 540     g_assert_nonnull(chr);
 541
 542     g_assert(qemu_chr_has_feature(chr,
 543                  QEMU_CHAR_FEATURE_FD_PASS) == false);
 544     g_assert(qemu_chr_has_feature(chr,
 545                  QEMU_CHAR_FEATURE_RECONNECTABLE) == false);
 546
 547     /* check max avail */
 548     qemu_chr_fe_init(&be, chr, &error_abort);
 549     qemu_chr_fe_init(&be, chr, &err);
 550     error_free_or_abort(&err);
 551
 552     /* deinit & reinit */
 553     qemu_chr_fe_deinit(&be);
 554     qemu_chr_fe_init(&be, chr, &error_abort);
 555
 556     qemu_chr_fe_set_open(&be, true);
 557
 558     qemu_chr_fe_set_handlers(&be,
 559                              fe_can_read,
 560                              fe_read,
 561                              fe_event,
 562                              NULL, NULL, true);
 563
 564     ret = qemu_chr_fe_write(&be, (void *)"buf", 4);
 565     g_assert_cmpint(ret, ==, 4);
 566
 567     qemu_chr_fe_deinit(&be);
 568     object_unparent(OBJECT(chr));
 569 }
 570
 571 static void char_invalid_test(void)
 572 {
 573     Chardev *chr;
 574
 575     chr = qemu_chr_new("label-invalid", "invalid");
 576     g_assert_null(chr);
 577 }
 578
 579 int main(int argc, char **argv)
 580 {
 581     qemu_init_main_loop(&error_abort);
 582     socket_init();
 583
 584     g_test_init(&argc, &argv, NULL);
 585
 586     module_call_init(MODULE_INIT_QOM);
 587     qemu_add_opts(&qemu_chardev_opts);
 588
 589     g_test_add_func("/char/null", char_null_test);
 590     g_test_add_func("/char/invalid", char_invalid_test);
 591     g_test_add_func("/char/ringbuf", char_ringbuf_test);
 592     g_test_add_func("/char/mux", char_mux_test);
 593 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
 594 #ifdef _WIN32
 595     g_test_add_func("/char/console/subprocess", char_console_test_subprocess);
 596     g_test_add_func("/char/console", char_console_test);
 597 #endif
 598     g_test_add_func("/char/stdio/subprocess", char_stdio_test_subprocess);
 599     g_test_add_func("/char/stdio", char_stdio_test);
 600 #endif
 601 #ifndef _WIN32
 602     g_test_add_func("/char/pipe", char_pipe_test);
 603 #endif
 604     g_test_add_func("/char/file", char_file_test);
 605     g_test_add_func("/char/socket", char_socket_test);
 606     g_test_add_func("/char/udp", char_udp_test);
 607
 608     return g_test_run();
 609 }