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