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 "qobject/qdict.h"
9 #include "qobject/qlist.h"
10
11 typedef struct {
12 char *test_dir;
13 GMainLoop *loop;
14 int fd;
15 GPid pid;
16 } TestFixture;
17
connect_qga(char * path)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
qga_watch(GPid pid,gint status,gpointer user_data)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
fixture_setup(TestFixture * fixture,gconstpointer data,gchar ** envp)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
fixture_tear_down(TestFixture * fixture,gconstpointer data)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
qmp_assertion_message_error(const char * domain,const char * file,int line,const char * func,const char * expr,QDict * dict)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
test_qga_sync_delimited(gconstpointer fix)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
test_qga_sync(gconstpointer fix)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
test_qga_ping(gconstpointer fix)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
test_qga_id(gconstpointer fix)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
test_qga_invalid_oob(gconstpointer fix)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
test_qga_invalid_args(gconstpointer fix)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
test_qga_invalid_cmd(gconstpointer fix)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
test_qga_info(gconstpointer fix)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
test_qga_get_vcpus(gconstpointer fix)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
test_qga_get_fsinfo(gconstpointer fix)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
test_qga_get_memory_block_info(gconstpointer fix)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
test_qga_get_memory_blocks(gconstpointer fix)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
test_qga_network_get_interfaces(gconstpointer fix)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
test_qga_file_ops(gconstpointer fix)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
test_qga_file_write_read(gconstpointer fix)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
test_qga_get_time(gconstpointer fix)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
test_qga_blockedrpcs(gconstpointer data)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
test_qga_allowedrpcs(gconstpointer data)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
test_qga_config(gconstpointer data)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
test_qga_fsfreeze_status(gconstpointer fix)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
wait_for_guest_exec_completion(int fd,int64_t pid)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
test_qga_guest_exec(gconstpointer fix)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)
test_qga_guest_exec_separated(gconstpointer fix)847 static void test_qga_guest_exec_separated(gconstpointer fix)
848 {
849 }
test_qga_guest_exec_merged(gconstpointer fix)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
test_qga_guest_exec_separated(gconstpointer fix)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
test_qga_guest_exec_merged(gconstpointer fix)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
test_qga_guest_exec_invalid(gconstpointer fix)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
test_qga_guest_get_host_name(gconstpointer fix)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
test_qga_guest_get_timezone(gconstpointer fix)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
test_qga_guest_get_users(gconstpointer fix)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
test_qga_guest_get_osinfo(gconstpointer data)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
main(int argc,char ** argv)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