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