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