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