tests/unit/test-qga.c

   1 #include "qemu/osdep.h"
   2 #include <locale.h>
   3 #include <glib/gstdio.h>
   4 #include <sys/socket.h>
   5 #include <sys/un.h>
   6
   7 #include "../qtest/libqtest.h"
   8 #include "qapi/qmp/qdict.h"
   9 #include "qapi/qmp/qlist.h"
  10
  11 typedef struct {
  12     char *test_dir;
  13     GMainLoop *loop;
  14     int fd;
  15     GPid pid;
  16 } TestFixture;
  17
  18 static int connect_qga(char *path)
  19 {
  20     int s, ret, len, i = 0;
  21     struct sockaddr_un remote;
  22
  23     s = socket(AF_UNIX, SOCK_STREAM, 0);
  24     g_assert(s != -1);
  25
  26     remote.sun_family = AF_UNIX;
  27     do {
  28         strcpy(remote.sun_path, path);
  29         len = strlen(remote.sun_path) + sizeof(remote.sun_family);
  30         ret = connect(s, (struct sockaddr *)&remote, len);
  31         if (ret == -1) {
  32             g_usleep(G_USEC_PER_SEC);
  33         }
  34         if (i++ == 10) {
  35             return -1;
  36         }
  37     } while (ret == -1);
  38
  39     return s;
  40 }
  41
  42 static void qga_watch(GPid pid, gint status, gpointer user_data)
  43 {
  44     TestFixture *fixture = user_data;
  45
  46     g_assert_cmpint(status, ==, 0);
  47     g_main_loop_quit(fixture->loop);
  48 }
  49
  50 static void
  51 fixture_setup(TestFixture *fixture, gconstpointer data, gchar **envp)
  52 {
  53     const gchar *extra_arg = data;
  54     GError *error = NULL;
  55     g_autofree char *cwd = NULL;
  56     g_autofree char *path = NULL;
  57     g_autofree char *cmd = NULL;
  58     g_auto(GStrv) argv = NULL;
  59
  60     fixture->loop = g_main_loop_new(NULL, FALSE);
  61
  62     fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX");
  63     g_assert_nonnull(mkdtemp(fixture->test_dir));
  64
  65     path = g_build_filename(fixture->test_dir, "sock", NULL);
  66     cwd = g_get_current_dir();
  67     cmd = g_strdup_printf("%s%cqga%cqemu-ga -m unix-listen -t %s -p %s %s %s",
  68                           cwd, G_DIR_SEPARATOR, G_DIR_SEPARATOR,
  69                           fixture->test_dir, path,
  70                           getenv("QTEST_LOG") ? "-v" : "",
  71                           extra_arg ?: "");
  72     g_shell_parse_argv(cmd, NULL, &argv, &error);
  73     g_assert_no_error(error);
  74
  75     g_spawn_async(fixture->test_dir, argv, envp,
  76                   G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
  77                   NULL, NULL, &fixture->pid, &error);
  78     g_assert_no_error(error);
  79
  80     g_child_watch_add(fixture->pid, qga_watch, fixture);
  81
  82     fixture->fd = connect_qga(path);
  83     g_assert_cmpint(fixture->fd, !=, -1);
  84 }
  85
  86 static void
  87 fixture_tear_down(TestFixture *fixture, gconstpointer data)
  88 {
  89     g_autofree char *tmp = NULL;
  90
  91     kill(fixture->pid, SIGTERM);
  92
  93     g_main_loop_run(fixture->loop);
  94     g_main_loop_unref(fixture->loop);
  95
  96     g_spawn_close_pid(fixture->pid);
  97
  98     tmp = g_build_filename(fixture->test_dir, "foo", NULL);
  99     g_unlink(tmp);
 100     g_free(tmp);
 101
 102     tmp = g_build_filename(fixture->test_dir, "qga.state", NULL);
 103     g_unlink(tmp);
 104     g_free(tmp);
 105
 106     tmp = g_build_filename(fixture->test_dir, "sock", NULL);
 107     g_unlink(tmp);
 108
 109     g_rmdir(fixture->test_dir);
 110     g_free(fixture->test_dir);
 111     close(fixture->fd);
 112 }
 113
 114 static void qmp_assertion_message_error(const char     *domain,
 115                                         const char     *file,
 116                                         int             line,
 117                                         const char     *func,
 118                                         const char     *expr,
 119                                         QDict          *dict)
 120 {
 121     const char *class, *desc;
 122     g_autofree char *s = NULL;
 123     QDict *error;
 124
 125     error = qdict_get_qdict(dict, "error");
 126     class = qdict_get_try_str(error, "class");
 127     desc = qdict_get_try_str(error, "desc");
 128
 129     s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc);
 130     g_assertion_message(domain, file, line, func, s);
 131 }
 132
 133 #define qmp_assert_no_error(err) do {                                   \
 134     if (qdict_haskey(err, "error")) {                                   \
 135         qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__,   \
 136                                     G_STRFUNC, #err, err);              \
 137     }                                                                   \
 138 } while (0)
 139
 140 static void test_qga_sync_delimited(gconstpointer fix)
 141 {
 142     const TestFixture *fixture = fix;
 143     guint32 v, r = g_test_rand_int();
 144     unsigned char c;
 145     g_autoptr(QDict) ret = NULL;
 146
 147     qmp_fd_send_raw(fixture->fd, "\xff");
 148     qmp_fd_send(fixture->fd,
 149                 "{'execute': 'guest-sync-delimited',"
 150                 " 'arguments': {'id': %u } }",
 151                 r);
 152
 153     /*
 154      * Read and ignore garbage until resynchronized.
 155      *
 156      * Note that the full reset sequence would involve checking the
 157      * response of guest-sync-delimited and repeating the loop if
 158      * 'id' field of the response does not match the 'id' field of
 159      * the request. Testing this fully would require inserting
 160      * garbage in the response stream and is left as a future test
 161      * to implement.
 162      *
 163      * TODO: The server shouldn't emit so much garbage (among other
 164      * things, it loudly complains about the client's \xff being
 165      * invalid JSON, even though it is a documented part of the
 166      * handshake.
 167      */
 168     do {
 169         v = read(fixture->fd, &c, 1);
 170         g_assert_cmpint(v, ==, 1);
 171     } while (c != 0xff);
 172
 173     ret = qmp_fd_receive(fixture->fd);
 174     g_assert_nonnull(ret);
 175     qmp_assert_no_error(ret);
 176
 177     v = qdict_get_int(ret, "return");
 178     g_assert_cmpint(r, ==, v);
 179 }
 180
 181 static void test_qga_sync(gconstpointer fix)
 182 {
 183     const TestFixture *fixture = fix;
 184     guint32 v, r = g_test_rand_int();
 185     g_autoptr(QDict) ret = NULL;
 186
 187     /*
 188      * TODO guest-sync is inherently limited: we cannot distinguish
 189      * failure caused by reacting to garbage on the wire prior to this
 190      * command, from failure of this actual command. Clients are
 191      * supposed to be able to send a raw '\xff' byte to at least
 192      * re-synchronize the server's parser prior to this command, but
 193      * we are not in a position to test that here because (at least
 194      * for now) it causes the server to issue an error message about
 195      * invalid JSON. Testing of '\xff' handling is done in
 196      * guest-sync-delimited instead.
 197      */
 198     ret = qmp_fd(fixture->fd,
 199                  "{'execute': 'guest-sync', 'arguments': {'id': %u } }",
 200                  r);
 201
 202     g_assert_nonnull(ret);
 203     qmp_assert_no_error(ret);
 204
 205     v = qdict_get_int(ret, "return");
 206     g_assert_cmpint(r, ==, v);
 207 }
 208
 209 static void test_qga_ping(gconstpointer fix)
 210 {
 211     const TestFixture *fixture = fix;
 212     g_autoptr(QDict) ret = NULL;
 213
 214     ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
 215     g_assert_nonnull(ret);
 216     qmp_assert_no_error(ret);
 217 }
 218
 219 static void test_qga_id(gconstpointer fix)
 220 {
 221     const TestFixture *fixture = fix;
 222     g_autoptr(QDict) ret = NULL;
 223
 224     ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping', 'id': 1}");
 225     g_assert_nonnull(ret);
 226     qmp_assert_no_error(ret);
 227     g_assert_cmpint(qdict_get_int(ret, "id"), ==, 1);
 228 }
 229
 230 static void test_qga_invalid_oob(gconstpointer fix)
 231 {
 232     const TestFixture *fixture = fix;
 233     QDict *ret;
 234
 235     ret = qmp_fd(fixture->fd, "{'exec-oob': 'guest-ping'}");
 236     g_assert_nonnull(ret);
 237
 238     qmp_expect_error_and_unref(ret, "GenericError");
 239 }
 240
 241 static void test_qga_invalid_args(gconstpointer fix)
 242 {
 243     const TestFixture *fixture = fix;
 244     g_autoptr(QDict) ret = NULL;
 245     QDict *error;
 246     const gchar *class, *desc;
 247
 248     ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping', "
 249                  "'arguments': {'foo': 42 }}");
 250     g_assert_nonnull(ret);
 251
 252     error = qdict_get_qdict(ret, "error");
 253     class = qdict_get_try_str(error, "class");
 254     desc = qdict_get_try_str(error, "desc");
 255
 256     g_assert_cmpstr(class, ==, "GenericError");
 257     g_assert_cmpstr(desc, ==, "Parameter 'foo' is unexpected");
 258 }
 259
 260 static void test_qga_invalid_cmd(gconstpointer fix)
 261 {
 262     const TestFixture *fixture = fix;
 263     g_autoptr(QDict) ret = NULL;
 264     QDict *error;
 265     const gchar *class, *desc;
 266
 267     ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}");
 268     g_assert_nonnull(ret);
 269
 270     error = qdict_get_qdict(ret, "error");
 271     class = qdict_get_try_str(error, "class");
 272     desc = qdict_get_try_str(error, "desc");
 273
 274     g_assert_cmpstr(class, ==, "CommandNotFound");
 275     g_assert_cmpint(strlen(desc), >, 0);
 276 }
 277
 278 static void test_qga_info(gconstpointer fix)
 279 {
 280     const TestFixture *fixture = fix;
 281     g_autoptr(QDict) ret = NULL;
 282     QDict *val;
 283     const gchar *version;
 284
 285     ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}");
 286     g_assert_nonnull(ret);
 287     qmp_assert_no_error(ret);
 288
 289     val = qdict_get_qdict(ret, "return");
 290     version = qdict_get_try_str(val, "version");
 291     g_assert_cmpstr(version, ==, QEMU_VERSION);
 292 }
 293
 294 static void test_qga_get_vcpus(gconstpointer fix)
 295 {
 296     const TestFixture *fixture = fix;
 297     g_autoptr(QDict) ret = NULL;
 298     QList *list;
 299     const QListEntry *entry;
 300
 301     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}");
 302     g_assert_nonnull(ret);
 303     qmp_assert_no_error(ret);
 304
 305     /* check there is at least a cpu */
 306     list = qdict_get_qlist(ret, "return");
 307     entry = qlist_first(list);
 308     g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
 309     g_assert(qdict_haskey(qobject_to(QDict, entry->value), "logical-id"));
 310 }
 311
 312 static void test_qga_get_fsinfo(gconstpointer fix)
 313 {
 314     const TestFixture *fixture = fix;
 315     g_autoptr(QDict) ret = NULL;
 316     QList *list;
 317     const QListEntry *entry;
 318
 319     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
 320     g_assert_nonnull(ret);
 321     qmp_assert_no_error(ret);
 322
 323     /* sanity-check the response if there are any filesystems */
 324     list = qdict_get_qlist(ret, "return");
 325     entry = qlist_first(list);
 326     if (entry) {
 327         g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
 328         g_assert(qdict_haskey(qobject_to(QDict, entry->value), "mountpoint"));
 329         g_assert(qdict_haskey(qobject_to(QDict, entry->value), "type"));
 330         g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk"));
 331     }
 332 }
 333
 334 static void test_qga_get_memory_block_info(gconstpointer fix)
 335 {
 336     const TestFixture *fixture = fix;
 337     g_autoptr(QDict) ret = NULL;
 338     QDict *val;
 339     int64_t size;
 340
 341     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
 342     g_assert_nonnull(ret);
 343
 344     /* some systems might not expose memory block info in sysfs */
 345     if (!qdict_haskey(ret, "error")) {
 346         /* check there is at least some memory */
 347         val = qdict_get_qdict(ret, "return");
 348         size = qdict_get_int(val, "size");
 349         g_assert_cmpint(size, >, 0);
 350     }
 351 }
 352
 353 static void test_qga_get_memory_blocks(gconstpointer fix)
 354 {
 355     const TestFixture *fixture = fix;
 356     g_autoptr(QDict) ret = NULL;
 357     QList *list;
 358     const QListEntry *entry;
 359
 360     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
 361     g_assert_nonnull(ret);
 362
 363     /* some systems might not expose memory block info in sysfs */
 364     if (!qdict_haskey(ret, "error")) {
 365         list = qdict_get_qlist(ret, "return");
 366         entry = qlist_first(list);
 367         /* newer versions of qga may return empty list without error */
 368         if (entry) {
 369             g_assert(qdict_haskey(qobject_to(QDict, entry->value),
 370                                   "phys-index"));
 371             g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
 372         }
 373     }
 374 }
 375
 376 static void test_qga_network_get_interfaces(gconstpointer fix)
 377 {
 378     const TestFixture *fixture = fix;
 379     g_autoptr(QDict) ret = NULL;
 380     QList *list;
 381     const QListEntry *entry;
 382
 383     ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}");
 384     g_assert_nonnull(ret);
 385     qmp_assert_no_error(ret);
 386
 387     /* check there is at least an interface */
 388     list = qdict_get_qlist(ret, "return");
 389     entry = qlist_first(list);
 390     g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
 391 }
 392
 393 static void test_qga_file_ops(gconstpointer fix)
 394 {
 395     const TestFixture *fixture = fix;
 396     const unsigned char helloworld[] = "Hello World!\n";
 397     const char *b64;
 398     gchar *path, *enc;
 399     unsigned char *dec;
 400     QDict *ret, *val;
 401     int64_t id, eof;
 402     gsize count;
 403     FILE *f;
 404     char tmp[100];
 405
 406     /* open */
 407     ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
 408                  " 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
 409     g_assert_nonnull(ret);
 410     qmp_assert_no_error(ret);
 411     id = qdict_get_int(ret, "return");
 412     qobject_unref(ret);
 413
 414     enc = g_base64_encode(helloworld, sizeof(helloworld));
 415     /* write */
 416     ret = qmp_fd(fixture->fd,
 417                  "{'execute': 'guest-file-write',"
 418                  " 'arguments': { 'handle': %" PRId64 ", 'buf-b64': %s } }",
 419                  id, enc);
 420     g_assert_nonnull(ret);
 421     qmp_assert_no_error(ret);
 422
 423     val = qdict_get_qdict(ret, "return");
 424     count = qdict_get_int(val, "count");
 425     eof = qdict_get_bool(val, "eof");
 426     g_assert_cmpint(count, ==, sizeof(helloworld));
 427     g_assert_cmpint(eof, ==, 0);
 428     qobject_unref(ret);
 429
 430     /* flush */
 431     ret = qmp_fd(fixture->fd,
 432                  "{'execute': 'guest-file-flush',"
 433                  " 'arguments': {'handle': %" PRId64 "} }",
 434                  id);
 435     qobject_unref(ret);
 436
 437     /* close */
 438     ret = qmp_fd(fixture->fd,
 439                  "{'execute': 'guest-file-close',"
 440                  " 'arguments': {'handle': %" PRId64 "} }",
 441                  id);
 442     qobject_unref(ret);
 443
 444     /* check content */
 445     path = g_build_filename(fixture->test_dir, "foo", NULL);
 446     f = fopen(path, "r");
 447     g_free(path);
 448     g_assert_nonnull(f);
 449     count = fread(tmp, 1, sizeof(tmp), f);
 450     g_assert_cmpint(count, ==, sizeof(helloworld));
 451     tmp[count] = 0;
 452     g_assert_cmpstr(tmp, ==, (char *)helloworld);
 453     fclose(f);
 454
 455     /* open */
 456     ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
 457                  " 'arguments': { 'path': 'foo', 'mode': 'r' } }");
 458     g_assert_nonnull(ret);
 459     qmp_assert_no_error(ret);
 460     id = qdict_get_int(ret, "return");
 461     qobject_unref(ret);
 462
 463     /* read */
 464     ret = qmp_fd(fixture->fd,
 465                  "{'execute': 'guest-file-read',"
 466                  " 'arguments': { 'handle': %" PRId64 "} }",
 467                  id);
 468     val = qdict_get_qdict(ret, "return");
 469     count = qdict_get_int(val, "count");
 470     eof = qdict_get_bool(val, "eof");
 471     b64 = qdict_get_str(val, "buf-b64");
 472     g_assert_cmpint(count, ==, sizeof(helloworld));
 473     g_assert(eof);
 474     g_assert_cmpstr(b64, ==, enc);
 475
 476     qobject_unref(ret);
 477     g_free(enc);
 478
 479     /* read eof */
 480     ret = qmp_fd(fixture->fd,
 481                  "{'execute': 'guest-file-read',"
 482                  " 'arguments': { 'handle': %" PRId64 "} }",
 483                  id);
 484     val = qdict_get_qdict(ret, "return");
 485     count = qdict_get_int(val, "count");
 486     eof = qdict_get_bool(val, "eof");
 487     b64 = qdict_get_str(val, "buf-b64");
 488     g_assert_cmpint(count, ==, 0);
 489     g_assert(eof);
 490     g_assert_cmpstr(b64, ==, "");
 491     qobject_unref(ret);
 492
 493     /* seek */
 494     ret = qmp_fd(fixture->fd,
 495                  "{'execute': 'guest-file-seek',"
 496                  " 'arguments': { 'handle': %" PRId64 ", "
 497                  " 'offset': %d, 'whence': %s } }",
 498                  id, 6, "set");
 499     qmp_assert_no_error(ret);
 500     val = qdict_get_qdict(ret, "return");
 501     count = qdict_get_int(val, "position");
 502     eof = qdict_get_bool(val, "eof");
 503     g_assert_cmpint(count, ==, 6);
 504     g_assert(!eof);
 505     qobject_unref(ret);
 506
 507     /* partial read */
 508     ret = qmp_fd(fixture->fd,
 509                  "{'execute': 'guest-file-read',"
 510                  " 'arguments': { 'handle': %" PRId64 "} }",
 511                  id);
 512     val = qdict_get_qdict(ret, "return");
 513     count = qdict_get_int(val, "count");
 514     eof = qdict_get_bool(val, "eof");
 515     b64 = qdict_get_str(val, "buf-b64");
 516     g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
 517     g_assert(eof);
 518     dec = g_base64_decode(b64, &count);
 519     g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
 520     g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6);
 521     g_free(dec);
 522
 523     qobject_unref(ret);
 524
 525     /* close */
 526     ret = qmp_fd(fixture->fd,
 527                  "{'execute': 'guest-file-close',"
 528                  " 'arguments': {'handle': %" PRId64 "} }",
 529                  id);
 530     qobject_unref(ret);
 531 }
 532
 533 static void test_qga_file_write_read(gconstpointer fix)
 534 {
 535     const TestFixture *fixture = fix;
 536     const unsigned char helloworld[] = "Hello World!\n";
 537     const char *b64;
 538     gchar *enc;
 539     QDict *ret, *val;
 540     int64_t id, eof;
 541     gsize count;
 542
 543     /* open */
 544     ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
 545                  " 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
 546     g_assert_nonnull(ret);
 547     qmp_assert_no_error(ret);
 548     id = qdict_get_int(ret, "return");
 549     qobject_unref(ret);
 550
 551     enc = g_base64_encode(helloworld, sizeof(helloworld));
 552     /* write */
 553     ret = qmp_fd(fixture->fd,
 554                  "{'execute': 'guest-file-write',"
 555                  " 'arguments': { 'handle': %" PRId64 ","
 556                  " 'buf-b64': %s } }", id, enc);
 557     g_assert_nonnull(ret);
 558     qmp_assert_no_error(ret);
 559
 560     val = qdict_get_qdict(ret, "return");
 561     count = qdict_get_int(val, "count");
 562     eof = qdict_get_bool(val, "eof");
 563     g_assert_cmpint(count, ==, sizeof(helloworld));
 564     g_assert_cmpint(eof, ==, 0);
 565     qobject_unref(ret);
 566
 567     /* read (check implicit flush) */
 568     ret = qmp_fd(fixture->fd,
 569                  "{'execute': 'guest-file-read',"
 570                  " 'arguments': { 'handle': %" PRId64 "} }",
 571                  id);
 572     val = qdict_get_qdict(ret, "return");
 573     count = qdict_get_int(val, "count");
 574     eof = qdict_get_bool(val, "eof");
 575     b64 = qdict_get_str(val, "buf-b64");
 576     g_assert_cmpint(count, ==, 0);
 577     g_assert(eof);
 578     g_assert_cmpstr(b64, ==, "");
 579     qobject_unref(ret);
 580
 581     /* seek to 0 */
 582     ret = qmp_fd(fixture->fd,
 583                  "{'execute': 'guest-file-seek',"
 584                  " 'arguments': { 'handle': %" PRId64 ", "
 585                  " 'offset': %d, 'whence': %s } }",
 586                  id, 0, "set");
 587     qmp_assert_no_error(ret);
 588     val = qdict_get_qdict(ret, "return");
 589     count = qdict_get_int(val, "position");
 590     eof = qdict_get_bool(val, "eof");
 591     g_assert_cmpint(count, ==, 0);
 592     g_assert(!eof);
 593     qobject_unref(ret);
 594
 595     /* read */
 596     ret = qmp_fd(fixture->fd,
 597                  "{'execute': 'guest-file-read',"
 598                  " 'arguments': { 'handle': %" PRId64 "} }",
 599                  id);
 600     val = qdict_get_qdict(ret, "return");
 601     count = qdict_get_int(val, "count");
 602     eof = qdict_get_bool(val, "eof");
 603     b64 = qdict_get_str(val, "buf-b64");
 604     g_assert_cmpint(count, ==, sizeof(helloworld));
 605     g_assert(eof);
 606     g_assert_cmpstr(b64, ==, enc);
 607     qobject_unref(ret);
 608     g_free(enc);
 609
 610     /* close */
 611     ret = qmp_fd(fixture->fd,
 612                  "{'execute': 'guest-file-close',"
 613                  " 'arguments': {'handle': %" PRId64 "} }",
 614                  id);
 615     qobject_unref(ret);
 616 }
 617
 618 static void test_qga_get_time(gconstpointer fix)
 619 {
 620     const TestFixture *fixture = fix;
 621     g_autoptr(QDict) ret = NULL;
 622     int64_t time;
 623
 624     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
 625     g_assert_nonnull(ret);
 626     qmp_assert_no_error(ret);
 627
 628     time = qdict_get_int(ret, "return");
 629     g_assert_cmpint(time, >, 0);
 630 }
 631
 632 static void test_qga_blockedrpcs(gconstpointer data)
 633 {
 634     TestFixture fix;
 635     QDict *ret, *error;
 636     const gchar *class, *desc;
 637
 638     fixture_setup(&fix, "-b guest-ping,guest-get-time", NULL);
 639
 640     /* check blocked RPCs */
 641     ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}");
 642     g_assert_nonnull(ret);
 643     error = qdict_get_qdict(ret, "error");
 644     class = qdict_get_try_str(error, "class");
 645     desc = qdict_get_try_str(error, "desc");
 646     g_assert_cmpstr(class, ==, "CommandNotFound");
 647     g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
 648     qobject_unref(ret);
 649
 650     ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}");
 651     g_assert_nonnull(ret);
 652     error = qdict_get_qdict(ret, "error");
 653     class = qdict_get_try_str(error, "class");
 654     desc = qdict_get_try_str(error, "desc");
 655     g_assert_cmpstr(class, ==, "CommandNotFound");
 656     g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
 657     qobject_unref(ret);
 658
 659     /* check something work */
 660     ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
 661     qmp_assert_no_error(ret);
 662     qobject_unref(ret);
 663
 664     fixture_tear_down(&fix, NULL);
 665 }
 666
 667 static void test_qga_config(gconstpointer data)
 668 {
 669     GError *error = NULL;
 670     g_autofree char *out = NULL;
 671     g_autofree char *err = NULL;
 672     g_autofree char *cwd = NULL;
 673     g_autofree char *cmd = NULL;
 674     g_auto(GStrv) argv = NULL;
 675     g_auto(GStrv) strv = NULL;
 676     g_autoptr(GKeyFile) kf = NULL;
 677     char *str;
 678     char *env[2];
 679     int status;
 680     gsize n;
 681
 682     cwd = g_get_current_dir();
 683     cmd = g_strdup_printf("%s%cqga%cqemu-ga -D",
 684                           cwd, G_DIR_SEPARATOR, G_DIR_SEPARATOR);
 685     g_shell_parse_argv(cmd, NULL, &argv, &error);
 686     g_assert_no_error(error);
 687
 688     env[0] = g_strdup_printf("QGA_CONF=tests%cdata%ctest-qga-config",
 689                              G_DIR_SEPARATOR, G_DIR_SEPARATOR);
 690     env[1] = NULL;
 691     g_spawn_sync(NULL, argv, env, 0,
 692                  NULL, NULL, &out, &err, &status, &error);
 693
 694     g_assert_no_error(error);
 695     g_assert_cmpstr(err, ==, "");
 696     g_assert_cmpint(status, ==, 0);
 697
 698     kf = g_key_file_new();
 699     g_key_file_load_from_data(kf, out, -1, G_KEY_FILE_NONE, &error);
 700     g_assert_no_error(error);
 701
 702     str = g_key_file_get_start_group(kf);
 703     g_assert_cmpstr(str, ==, "general");
 704     g_free(str);
 705
 706     g_assert_false(g_key_file_get_boolean(kf, "general", "daemon", &error));
 707     g_assert_no_error(error);
 708
 709     str = g_key_file_get_string(kf, "general", "method", &error);
 710     g_assert_no_error(error);
 711     g_assert_cmpstr(str, ==, "virtio-serial");
 712     g_free(str);
 713
 714     str = g_key_file_get_string(kf, "general", "path", &error);
 715     g_assert_no_error(error);
 716     g_assert_cmpstr(str, ==, "/path/to/org.qemu.guest_agent.0");
 717     g_free(str);
 718
 719     str = g_key_file_get_string(kf, "general", "pidfile", &error);
 720     g_assert_no_error(error);
 721     g_assert_cmpstr(str, ==, "/var/foo/qemu-ga.pid");
 722     g_free(str);
 723
 724     str = g_key_file_get_string(kf, "general", "statedir", &error);
 725     g_assert_no_error(error);
 726     g_assert_cmpstr(str, ==, "/var/state");
 727     g_free(str);
 728
 729     g_assert_true(g_key_file_get_boolean(kf, "general", "verbose", &error));
 730     g_assert_no_error(error);
 731
 732     strv = g_key_file_get_string_list(kf, "general", "blacklist", &n, &error);
 733     g_assert_cmpint(n, ==, 2);
 734     g_assert_true(g_strv_contains((const char * const *)strv,
 735                                   "guest-ping"));
 736     g_assert_true(g_strv_contains((const char * const *)strv,
 737                                   "guest-get-time"));
 738     g_assert_no_error(error);
 739
 740     g_free(env[0]);
 741 }
 742
 743 static void test_qga_fsfreeze_status(gconstpointer fix)
 744 {
 745     const TestFixture *fixture = fix;
 746     g_autoptr(QDict) ret = NULL;
 747     const gchar *status;
 748
 749     ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}");
 750     g_assert_nonnull(ret);
 751     qmp_assert_no_error(ret);
 752
 753     status = qdict_get_try_str(ret, "return");
 754     g_assert_cmpstr(status, ==, "thawed");
 755 }
 756
 757 static void test_qga_guest_exec(gconstpointer fix)
 758 {
 759     const TestFixture *fixture = fix;
 760     g_autoptr(QDict) ret = NULL;
 761     QDict *val;
 762     const gchar *out;
 763     g_autofree guchar *decoded = NULL;
 764     int64_t pid, now, exitcode;
 765     gsize len;
 766     bool exited;
 767
 768     /* exec 'echo foo bar' */
 769     ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
 770                  " 'path': '/bin/echo', 'arg': [ '-n', '\" test_str \"' ],"
 771                  " 'capture-output': true } }");
 772     g_assert_nonnull(ret);
 773     qmp_assert_no_error(ret);
 774     val = qdict_get_qdict(ret, "return");
 775     pid = qdict_get_int(val, "pid");
 776     g_assert_cmpint(pid, >, 0);
 777     qobject_unref(ret);
 778
 779     /* wait for completion */
 780     now = g_get_monotonic_time();
 781     do {
 782         ret = qmp_fd(fixture->fd,
 783                      "{'execute': 'guest-exec-status',"
 784                      " 'arguments': { 'pid': %" PRId64 " } }", pid);
 785         g_assert_nonnull(ret);
 786         val = qdict_get_qdict(ret, "return");
 787         exited = qdict_get_bool(val, "exited");
 788         if (!exited) {
 789             qobject_unref(ret);
 790         }
 791     } while (!exited &&
 792              g_get_monotonic_time() < now + 5 * G_TIME_SPAN_SECOND);
 793     g_assert(exited);
 794
 795     /* check stdout */
 796     exitcode = qdict_get_int(val, "exitcode");
 797     g_assert_cmpint(exitcode, ==, 0);
 798     out = qdict_get_str(val, "out-data");
 799     decoded = g_base64_decode(out, &len);
 800     g_assert_cmpint(len, ==, 12);
 801     g_assert_cmpstr((char *)decoded, ==, "\" test_str \"");
 802 }
 803
 804 static void test_qga_guest_exec_invalid(gconstpointer fix)
 805 {
 806     const TestFixture *fixture = fix;
 807     g_autoptr(QDict) ret = NULL;
 808     QDict *error;
 809     const gchar *class, *desc;
 810
 811     /* invalid command */
 812     ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
 813                  " 'path': '/bin/invalid-cmd42' } }");
 814     g_assert_nonnull(ret);
 815     error = qdict_get_qdict(ret, "error");
 816     g_assert_nonnull(error);
 817     class = qdict_get_str(error, "class");
 818     desc = qdict_get_str(error, "desc");
 819     g_assert_cmpstr(class, ==, "GenericError");
 820     g_assert_cmpint(strlen(desc), >, 0);
 821     qobject_unref(ret);
 822
 823     /* invalid pid */
 824     ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec-status',"
 825                  " 'arguments': { 'pid': 0 } }");
 826     g_assert_nonnull(ret);
 827     error = qdict_get_qdict(ret, "error");
 828     g_assert_nonnull(error);
 829     class = qdict_get_str(error, "class");
 830     desc = qdict_get_str(error, "desc");
 831     g_assert_cmpstr(class, ==, "GenericError");
 832     g_assert_cmpint(strlen(desc), >, 0);
 833 }
 834
 835 static void test_qga_guest_get_host_name(gconstpointer fix)
 836 {
 837     const TestFixture *fixture = fix;
 838     g_autoptr(QDict) ret = NULL;
 839     QDict *val;
 840
 841     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-host-name'}");
 842     g_assert_nonnull(ret);
 843     qmp_assert_no_error(ret);
 844
 845     val = qdict_get_qdict(ret, "return");
 846     g_assert(qdict_haskey(val, "host-name"));
 847 }
 848
 849 static void test_qga_guest_get_timezone(gconstpointer fix)
 850 {
 851     const TestFixture *fixture = fix;
 852     g_autoptr(QDict) ret = NULL;
 853     QDict *val;
 854
 855     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-timezone'}");
 856     g_assert_nonnull(ret);
 857     qmp_assert_no_error(ret);
 858
 859     /* Make sure there's at least offset */
 860     val = qdict_get_qdict(ret, "return");
 861     g_assert(qdict_haskey(val, "offset"));
 862 }
 863
 864 static void test_qga_guest_get_users(gconstpointer fix)
 865 {
 866     const TestFixture *fixture = fix;
 867     g_autoptr(QDict) ret = NULL;
 868     QList *val;
 869
 870     ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-users'}");
 871     g_assert_nonnull(ret);
 872     qmp_assert_no_error(ret);
 873
 874     /* There is not much to test here */
 875     val = qdict_get_qlist(ret, "return");
 876     g_assert_nonnull(val);
 877 }
 878
 879 static void test_qga_guest_get_osinfo(gconstpointer data)
 880 {
 881     TestFixture fixture;
 882     const gchar *str;
 883     g_autoptr(QDict) ret = NULL;
 884     char *env[2];
 885     QDict *val;
 886
 887     env[0] = g_strdup_printf(
 888         "QGA_OS_RELEASE=%s%c..%cdata%ctest-qga-os-release",
 889         g_test_get_dir(G_TEST_DIST), G_DIR_SEPARATOR, G_DIR_SEPARATOR, G_DIR_SEPARATOR);
 890     env[1] = NULL;
 891     fixture_setup(&fixture, NULL, env);
 892
 893     ret = qmp_fd(fixture.fd, "{'execute': 'guest-get-osinfo'}");
 894     g_assert_nonnull(ret);
 895     qmp_assert_no_error(ret);
 896
 897     val = qdict_get_qdict(ret, "return");
 898
 899     str = qdict_get_try_str(val, "id");
 900     g_assert_nonnull(str);
 901     g_assert_cmpstr(str, ==, "qemu-ga-test");
 902
 903     str = qdict_get_try_str(val, "name");
 904     g_assert_nonnull(str);
 905     g_assert_cmpstr(str, ==, "QEMU-GA");
 906
 907     str = qdict_get_try_str(val, "pretty-name");
 908     g_assert_nonnull(str);
 909     g_assert_cmpstr(str, ==, "QEMU Guest Agent test");
 910
 911     str = qdict_get_try_str(val, "version");
 912     g_assert_nonnull(str);
 913     g_assert_cmpstr(str, ==, "Test 1");
 914
 915     str = qdict_get_try_str(val, "version-id");
 916     g_assert_nonnull(str);
 917     g_assert_cmpstr(str, ==, "1");
 918
 919     str = qdict_get_try_str(val, "variant");
 920     g_assert_nonnull(str);
 921     g_assert_cmpstr(str, ==, "Unit test \"'$`\\ and \\\\ etc.");
 922
 923     str = qdict_get_try_str(val, "variant-id");
 924     g_assert_nonnull(str);
 925     g_assert_cmpstr(str, ==, "unit-test");
 926
 927     g_free(env[0]);
 928     fixture_tear_down(&fixture, NULL);
 929 }
 930
 931 int main(int argc, char **argv)
 932 {
 933     TestFixture fix;
 934     int ret;
 935
 936 #ifdef QEMU_SANITIZE_THREAD
 937     {
 938         g_test_skip("tsan enabled, https://github.com/google/sanitizers/issues/1116");
 939         return 0;
 940     }
 941 #endif
 942
 943     setlocale (LC_ALL, "");
 944     g_test_init(&argc, &argv, NULL);
 945     fixture_setup(&fix, NULL, NULL);
 946
 947     g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited);
 948     g_test_add_data_func("/qga/sync", &fix, test_qga_sync);
 949     g_test_add_data_func("/qga/ping", &fix, test_qga_ping);
 950     g_test_add_data_func("/qga/info", &fix, test_qga_info);
 951     g_test_add_data_func("/qga/network-get-interfaces", &fix,
 952                          test_qga_network_get_interfaces);
 953     if (!access("/sys/devices/system/cpu/cpu0", F_OK)) {
 954         g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
 955     }
 956     g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo);
 957     g_test_add_data_func("/qga/get-memory-block-info", &fix,
 958                          test_qga_get_memory_block_info);
 959     g_test_add_data_func("/qga/get-memory-blocks", &fix,
 960                          test_qga_get_memory_blocks);
 961     g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops);
 962     g_test_add_data_func("/qga/file-write-read", &fix, test_qga_file_write_read);
 963     g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
 964     g_test_add_data_func("/qga/id", &fix, test_qga_id);
 965     g_test_add_data_func("/qga/invalid-oob", &fix, test_qga_invalid_oob);
 966     g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
 967     g_test_add_data_func("/qga/invalid-args", &fix, test_qga_invalid_args);
 968     g_test_add_data_func("/qga/fsfreeze-status", &fix,
 969                          test_qga_fsfreeze_status);
 970
 971     g_test_add_data_func("/qga/blockedrpcs", NULL, test_qga_blockedrpcs);
 972     g_test_add_data_func("/qga/config", NULL, test_qga_config);
 973     g_test_add_data_func("/qga/guest-exec", &fix, test_qga_guest_exec);
 974     g_test_add_data_func("/qga/guest-exec-invalid", &fix,
 975                          test_qga_guest_exec_invalid);
 976     g_test_add_data_func("/qga/guest-get-osinfo", &fix,
 977                          test_qga_guest_get_osinfo);
 978     g_test_add_data_func("/qga/guest-get-host-name", &fix,
 979                          test_qga_guest_get_host_name);
 980     g_test_add_data_func("/qga/guest-get-timezone", &fix,
 981                          test_qga_guest_get_timezone);
 982     g_test_add_data_func("/qga/guest-get-users", &fix,
 983                          test_qga_guest_get_users);
 984
 985     ret = g_test_run();
 986
 987     fixture_tear_down(&fix, NULL);
 988
 989     return ret;
 990 }