static void test_event_c(TestEventData *data, const void *unused) { QDict *d, *d_data, *d_b; UserDefOne b; b.integer = 2; b.string = g_strdup("test1"); b.has_enum1 = false; d_b = qdict_new(); qdict_put(d_b, "integer", qint_from_int(2)); qdict_put(d_b, "string", qstring_from_str("test1")); d_data = qdict_new(); qdict_put(d_data, "a", qint_from_int(1)); qdict_put(d_data, "b", d_b); qdict_put(d_data, "c", qstring_from_str("test2")); d = data->expect; qdict_put(d, "event", qstring_from_str("EVENT_C")); qdict_put(d, "data", d_data); qapi_event_send_event_c(true, 1, true, &b, "test2", &error_abort); g_free(b.string); }
/* Valid blkverify filenames look like blkverify:path/to/raw_image:path/to/image */ static void blkverify_parse_filename(const char *filename, QDict *options, Error **errp) { const char *c; QString *raw_path; /* Parse the blkverify: prefix */ if (!strstart(filename, "blkverify:", &filename)) { /* There was no prefix; therefore, all options have to be already present in the QDict (except for the filename) */ qdict_put(options, "x-image", qstring_from_str(filename)); return; } /* Parse the raw image filename */ c = strchr(filename, ':'); if (c == NULL) { error_setg(errp, "blkverify requires raw copy and original image path"); return; } /* TODO Implement option pass-through and set raw.filename here */ raw_path = qstring_from_substr(filename, 0, c - filename - 1); qdict_put(options, "x-raw", raw_path); /* TODO Allow multi-level nesting and set file.filename here */ filename = c + 1; qdict_put(options, "x-image", qstring_from_str(filename)); }
/* test commands that involve both input parameters and return values */ static void test_dispatch_cmd_io(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QDict *ud1a = qdict_new(); QDict *ud1b = qdict_new(); QObject *resp; qdict_put_obj(ud1a, "integer", QOBJECT(qint_from_int(42))); qdict_put_obj(ud1a, "string", QOBJECT(qstring_from_str("hello"))); qdict_put_obj(ud1b, "integer", QOBJECT(qint_from_int(422))); qdict_put_obj(ud1b, "string", QOBJECT(qstring_from_str("hello2"))); qdict_put_obj(args, "ud1a", QOBJECT(ud1a)); qdict_put_obj(args, "ud1b", QOBJECT(ud1b)); qdict_put_obj(req, "arguments", QOBJECT(args)); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); /* TODO: put in full payload and check for errors */ resp = qmp_dispatch(QOBJECT(req)); assert(resp != NULL); assert(!qdict_haskey(qobject_to_qdict(resp), "error")); g_print("\nresp: %s\n", qstring_get_str(qobject_to_json_pretty(resp))); qobject_decref(resp); QDECREF(req); }
/* test commands that return an error due to invalid parameters */ static void test_dispatch_cmd_failure(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); /* check that with extra arguments it throws an error */ req = qdict_new(); qdict_put(args, "a", qint_from_int(66)); qdict_put(req, "arguments", args); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); }
static void test_qemu_opt_get_size(void) { QemuOptsList *list; QemuOpts *opts; uint64_t opt; QDict *dict; list = qemu_find_opts("opts_list_02"); g_assert(list != NULL); g_assert(QTAILQ_EMPTY(&list->head)); g_assert_cmpstr(list->name, ==, "opts_list_02"); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); /* create the opts */ opts = qemu_opts_create(list, NULL, 0, &error_abort); g_assert(opts != NULL); g_assert(!QTAILQ_EMPTY(&list->head)); /* haven't set anything to size1 yet, so defval should be returned */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 5); dict = qdict_new(); g_assert(dict != NULL); qdict_put(dict, "size1", qstring_from_str("10")); qemu_opts_absorb_qdict(opts, dict, &error_abort); g_assert(error_abort == NULL); /* now we have set size1, should know about it */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 10); /* reset value */ qdict_put(dict, "size1", qstring_from_str("15")); qemu_opts_absorb_qdict(opts, dict, &error_abort); g_assert(error_abort == NULL); /* test the reset value */ opt = qemu_opt_get_size(opts, "size1", 5); g_assert(opt == 15); qdict_del(dict, "size1"); g_free(dict); qemu_opts_del(opts); /* should not find anything at this point */ opts = qemu_opts_find(list, NULL); g_assert(opts == NULL); }
static void qobject_output_type_str(Visitor *v, const char *name, char **obj, Error **errp) { QObjectOutputVisitor *qov = to_qov(v); if (*obj) { qobject_output_add(qov, name, qstring_from_str(*obj)); } else { qobject_output_add(qov, name, qstring_from_str("")); } }
static void qdict_crumple_test_bad_inputs(void) { QDict *src; Error *error = NULL; src = qdict_new(); /* rule.0 can't be both a string and a dict */ qdict_put(src, "rule.0", qstring_from_str("fred")); qdict_put(src, "rule.0.policy", qstring_from_str("allow")); g_assert(qdict_crumple(src, &error) == NULL); g_assert(error != NULL); error_free(error); error = NULL; QDECREF(src); src = qdict_new(); /* rule can't be both a list and a dict */ qdict_put(src, "rule.0", qstring_from_str("fred")); qdict_put(src, "rule.a", qstring_from_str("allow")); g_assert(qdict_crumple(src, &error) == NULL); g_assert(error != NULL); error_free(error); error = NULL; QDECREF(src); src = qdict_new(); /* The input should be flat, ie no dicts or lists */ qdict_put(src, "rule.a", qdict_new()); qdict_put(src, "rule.b", qstring_from_str("allow")); g_assert(qdict_crumple(src, &error) == NULL); g_assert(error != NULL); error_free(error); error = NULL; QDECREF(src); src = qdict_new(); /* List indexes must not have gaps */ qdict_put(src, "rule.0", qstring_from_str("deny")); qdict_put(src, "rule.3", qstring_from_str("allow")); g_assert(qdict_crumple(src, &error) == NULL); g_assert(error != NULL); error_free(error); error = NULL; QDECREF(src); src = qdict_new(); /* List indexes must be in %zu format */ qdict_put(src, "rule.0", qstring_from_str("deny")); qdict_put(src, "rule.+1", qstring_from_str("allow")); g_assert(qdict_crumple(src, &error) == NULL); g_assert(error != NULL); error_free(error); error = NULL; QDECREF(src); }
static void qdict_crumple_test_recursive(void) { QDict *src, *dst, *rule, *vnc, *acl, *listen; QList *rules; src = qdict_new(); qdict_put(src, "vnc.listen.addr", qstring_from_str("127.0.0.1")); qdict_put(src, "vnc.listen.port", qstring_from_str("5901")); qdict_put(src, "vnc.acl.rules.0.match", qstring_from_str("fred")); qdict_put(src, "vnc.acl.rules.0.policy", qstring_from_str("allow")); qdict_put(src, "vnc.acl.rules.1.match", qstring_from_str("bob")); qdict_put(src, "vnc.acl.rules.1.policy", qstring_from_str("deny")); qdict_put(src, "vnc.acl.default", qstring_from_str("deny")); qdict_put(src, "vnc.acl..name", qstring_from_str("acl0")); qdict_put(src, "vnc.acl.rule..name", qstring_from_str("acl0")); dst = qobject_to_qdict(qdict_crumple(src, &error_abort)); g_assert(dst); g_assert_cmpint(qdict_size(dst), ==, 1); vnc = qdict_get_qdict(dst, "vnc"); g_assert(vnc); g_assert_cmpint(qdict_size(vnc), ==, 3); listen = qdict_get_qdict(vnc, "listen"); g_assert(listen); g_assert_cmpint(qdict_size(listen), ==, 2); g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr")); g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port")); acl = qdict_get_qdict(vnc, "acl"); g_assert(acl); g_assert_cmpint(qdict_size(acl), ==, 3); rules = qdict_get_qlist(acl, "rules"); g_assert(rules); g_assert_cmpint(qlist_size(rules), ==, 2); rule = qobject_to_qdict(qlist_pop(rules)); g_assert(rule); g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); QDECREF(rule); rule = qobject_to_qdict(qlist_pop(rules)); g_assert(rule); g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); QDECREF(rule); /* With recursive crumpling, we should see all names unescaped */ g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name")); g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name")); QDECREF(src); QDECREF(dst); }
/* test generated deallocation on an object whose construction was prematurely * terminated due to an error */ static void test_dealloc_partial(void) { static const char text[] = "don't leak me"; UserDefTwo *ud2 = NULL; Error *err = NULL; /* create partial object */ { QDict *ud2_dict; Visitor *v; ud2_dict = qdict_new(); qdict_put_obj(ud2_dict, "string0", QOBJECT(qstring_from_str(text))); v = qobject_input_visitor_new(QOBJECT(ud2_dict)); visit_type_UserDefTwo(v, NULL, &ud2, &err); visit_free(v); QDECREF(ud2_dict); } /* verify that visit_type_XXX() cleans up properly on error */ error_free_or_abort(&err); assert(!ud2); /* Manually create a partial object, leaving ud2->dict1 at NULL */ ud2 = g_new0(UserDefTwo, 1); ud2->string0 = g_strdup(text); /* tear down partial object */ qapi_free_UserDefTwo(ud2); }
/* test generated deallocation on an object whose construction was prematurely * terminated due to an error */ static void test_dealloc_partial(void) { static const char text[] = "don't leak me"; UserDefTwo *ud2 = NULL; Error *err = NULL; /* create partial object */ { QDict *ud2_dict; QmpInputVisitor *qiv; ud2_dict = qdict_new(); qdict_put_obj(ud2_dict, "string0", QOBJECT(qstring_from_str(text))); qiv = qmp_input_visitor_new(QOBJECT(ud2_dict)); visit_type_UserDefTwo(qmp_input_get_visitor(qiv), &ud2, NULL, &err); qmp_input_visitor_cleanup(qiv); QDECREF(ud2_dict); } /* verify partial success */ assert(ud2 != NULL); assert(ud2->string0 != NULL); assert(strcmp(ud2->string0, text) == 0); assert(ud2->dict1 == NULL); /* confirm & release construction error */ assert(err != NULL); error_free(err); /* tear down partial object */ qapi_free_UserDefTwo(ud2); }
static void blkverify_refresh_filename(BlockDriverState *bs) { BDRVBlkverifyState *s = bs->opaque; /* bs->file has already been refreshed */ bdrv_refresh_filename(s->test_file); if (bs->file->full_open_options && s->test_file->full_open_options) { QDict *opts = qdict_new(); qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkverify"))); QINCREF(bs->file->full_open_options); qdict_put_obj(opts, "raw", QOBJECT(bs->file->full_open_options)); QINCREF(s->test_file->full_open_options); qdict_put_obj(opts, "test", QOBJECT(s->test_file->full_open_options)); bs->full_open_options = opts; } if (bs->file->exact_filename[0] && s->test_file->exact_filename[0]) { snprintf(bs->exact_filename, sizeof(bs->exact_filename), "blkverify:%s:%s", bs->file->exact_filename, s->test_file->exact_filename); } }
void do_info_migrate(Monitor *mon, QObject **ret_data) { QDict *qdict; MigrationState *s = current_migration; if (s) { switch (s->get_status(s)) { case MIG_STATE_ACTIVE: qdict = qdict_new(); qdict_put(qdict, "status", qstring_from_str("active")); migrate_put_status(qdict, "ram", ram_bytes_transferred(), ram_bytes_remaining(), ram_bytes_total()); if (blk_mig_active()) { migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(), blk_mig_bytes_remaining(), blk_mig_bytes_total()); } *ret_data = QOBJECT(qdict); break; case MIG_STATE_COMPLETED: *ret_data = qobject_from_jsonf("{ 'status': 'completed' }"); break; case MIG_STATE_ERROR: *ret_data = qobject_from_jsonf("{ 'status': 'failed' }"); break; case MIG_STATE_CANCELLED: *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }"); break; } } }
/* test commands that involve both input parameters and return values */ static void test_dispatch_cmd_io(void) { QDict *req = qdict_new(); QDict *args = qdict_new(); QDict *args3 = qdict_new(); QDict *ud1a = qdict_new(); QDict *ud1b = qdict_new(); QDict *ret, *ret_dict, *ret_dict_dict, *ret_dict_dict_userdef; QDict *ret_dict_dict2, *ret_dict_dict2_userdef; QInt *ret3; qdict_put_obj(ud1a, "integer", QOBJECT(qint_from_int(42))); qdict_put_obj(ud1a, "string", QOBJECT(qstring_from_str("hello"))); qdict_put_obj(ud1b, "integer", QOBJECT(qint_from_int(422))); qdict_put_obj(ud1b, "string", QOBJECT(qstring_from_str("hello2"))); qdict_put_obj(args, "ud1a", QOBJECT(ud1a)); qdict_put_obj(args, "ud1b", QOBJECT(ud1b)); qdict_put_obj(req, "arguments", QOBJECT(args)); qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); ret = qobject_to_qdict(test_qmp_dispatch(req)); assert(!strcmp(qdict_get_str(ret, "string0"), "blah1")); ret_dict = qdict_get_qdict(ret, "dict1"); assert(!strcmp(qdict_get_str(ret_dict, "string1"), "blah2")); ret_dict_dict = qdict_get_qdict(ret_dict, "dict2"); ret_dict_dict_userdef = qdict_get_qdict(ret_dict_dict, "userdef"); assert(qdict_get_int(ret_dict_dict_userdef, "integer") == 42); assert(!strcmp(qdict_get_str(ret_dict_dict_userdef, "string"), "hello")); assert(!strcmp(qdict_get_str(ret_dict_dict, "string"), "blah3")); ret_dict_dict2 = qdict_get_qdict(ret_dict, "dict3"); ret_dict_dict2_userdef = qdict_get_qdict(ret_dict_dict2, "userdef"); assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422); assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2")); assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4")); QDECREF(ret); qdict_put(args3, "a", qint_from_int(66)); qdict_put(req, "arguments", args3); qdict_put(req, "execute", qstring_from_str("guest-get-time")); ret3 = qobject_to_qint(test_qmp_dispatch(req)); assert(qint_get_int(ret3) == 66); QDECREF(ret3); QDECREF(req); }
static void qjson_initfn(Object *obj) { QJSON *json = (QJSON *)object_dynamic_cast(obj, TYPE_QJSON); assert(json); json->str = qstring_from_str("{ "); json->omit_comma = true; }
static void test_event_b(TestEventData *data, const void *unused) { QDict *d; d = data->expect; qdict_put(d, "event", qstring_from_str("EVENT_B")); qapi_event_send_event_b(&error_abort); }
QJSON *qjson_new(void) { QJSON *json = g_new0(QJSON, 1); json->str = qstring_from_str("{ "); json->omit_comma = true; return json; }
static void archipelago_parse_filename(const char *filename, QDict *options, Error **errp) { const char *start; char *volume = NULL, *segment_name = NULL; xport mport = NoPort, vport = NoPort; if (qdict_haskey(options, ARCHIPELAGO_OPT_VOLUME) || qdict_haskey(options, ARCHIPELAGO_OPT_SEGMENT) || qdict_haskey(options, ARCHIPELAGO_OPT_MPORT) || qdict_haskey(options, ARCHIPELAGO_OPT_VPORT)) { error_setg(errp, "volume/mport/vport/segment and a file name may not" " be specified at the same time"); return; } if (!strstart(filename, "archipelago:", &start)) { error_setg(errp, "File name must start with 'archipelago:'"); return; } if (!strlen(start) || strstart(start, "/", NULL)) { error_setg(errp, "volume name must be specified"); return; } parse_filename_opts(filename, errp, &volume, &segment_name, &mport, &vport); if (volume) { qdict_put(options, ARCHIPELAGO_OPT_VOLUME, qstring_from_str(volume)); g_free(volume); } if (segment_name) { qdict_put(options, ARCHIPELAGO_OPT_SEGMENT, qstring_from_str(segment_name)); g_free(segment_name); } if (mport != NoPort) { qdict_put(options, ARCHIPELAGO_OPT_MPORT, qint_from_int(mport)); } if (vport != NoPort) { qdict_put(options, ARCHIPELAGO_OPT_VPORT, qint_from_int(vport)); } }
static void qdict_destroy_simple_test(void) { QDict *qdict; qdict = qdict_new(); qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0))); qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo"))); QDECREF(qdict); }
static QString *read_line(FILE *file, char *key) { char value[128]; if (fscanf(file, "%127s%127s", key, value) == EOF) { return NULL; } remove_dots(key); return qstring_from_str(value); }
static void curl_parse_filename(const char *filename, QDict *options, Error **errp) { #define RA_OPTSTR ":readahead=" char *file; char *ra; const char *ra_val; int parse_state = 0; file = g_strdup(filename); /* Parse a trailing ":readahead=#:" param, if present. */ ra = file + strlen(file) - 1; while (ra >= file) { if (parse_state == 0) { if (*ra == ':') { parse_state++; } else { break; } } else if (parse_state == 1) { if (*ra > '9' || *ra < '0') { char *opt_start = ra - strlen(RA_OPTSTR) + 1; if (opt_start > file && strncmp(opt_start, RA_OPTSTR, strlen(RA_OPTSTR)) == 0) { ra_val = ra + 1; ra -= strlen(RA_OPTSTR) - 1; *ra = '\0'; qdict_put(options, "readahead", qstring_from_str(ra_val)); } break; } } ra--; } qdict_put(options, "url", qstring_from_str(file)); g_free(file); }
static int process_memory_info(QemuHttpConnection *conn) { int l1, l2; int st; uint32_t pgd, pde, pte; int buf_size; char buf[128]; CPUState *env = first_cpu; QList *res = qlist_new(); if (!(env->cr[0] & CR0_PG_MASK)) goto out; if (env->cr[4] & CR4_PAE_MASK) goto out; pgd = env->cr[3] & ~0xfff; for (l1 = 0; l1 < 1024; ++l1) { cpu_physical_memory_read(pgd + l1 * 4, &pde, 4); pde = le32_to_cpu(pde); if (pde & PG_PRESENT_MASK) { /* 4kb pages */ if (!(pde & PG_PSE_MASK) || !(env->cr[4] & CR4_PSE_MASK)) { for (l2 = 0; l2 < 1024; ++l2) { cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4); pte = le32_to_cpu(pte); if (pte & PG_PRESENT_MASK) { buf_size = snprintf(buf, sizeof(buf), "%02X (%02X) (%c%c%c%c%c%c%c%c%c)", (l1 << 22) + (l2 << 12), (pde & ~0xfff) + l2 * 4, pte & PG_NX_MASK ? 'X' : '-', pte & PG_GLOBAL_MASK ? 'G' : '-', pte & PG_PSE_MASK ? 'P' : '-', pte & PG_DIRTY_MASK ? 'D' : '-', pte & PG_ACCESSED_MASK ? 'A' : '-', pte & PG_PCD_MASK ? 'C' : '-', pte & PG_PWT_MASK ? 'T' : '-', pte & PG_USER_MASK ? 'U' : '-', pte & PG_RW_MASK ? 'W' : '-'); buf[buf_size] = 0; qlist_append(res, qstring_from_str(buf)); } } } } } out: st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
static int iscsi_create(const char *filename, QEMUOptionParameter *options) { int ret = 0; int64_t total_size = 0; BlockDriverState bs; IscsiLun *iscsilun = NULL; QDict *bs_options; memset(&bs, 0, sizeof(BlockDriverState)); /* Read out options */ while (options && options->name) { if (!strcmp(options->name, "size")) { total_size = options->value.n / BDRV_SECTOR_SIZE; } options++; } bs.opaque = g_malloc0(sizeof(struct IscsiLun)); iscsilun = bs.opaque; bs_options = qdict_new(); qdict_put(bs_options, "filename", qstring_from_str(filename)); ret = iscsi_open(&bs, bs_options, 0); QDECREF(bs_options); if (ret != 0) { goto out; } if (iscsilun->nop_timer) { qemu_del_timer(iscsilun->nop_timer); qemu_free_timer(iscsilun->nop_timer); } if (iscsilun->type != TYPE_DISK) { ret = -ENODEV; goto out; } if (bs.total_sectors < total_size) { ret = -ENOSPC; goto out; } ret = 0; out: if (iscsilun->iscsi != NULL) { iscsi_destroy_context(iscsilun->iscsi); } g_free(bs.opaque); return ret; }
/* test commands with no input and no return value */ static void test_dispatch_cmd(void) { QDict *req = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd"))); resp = qmp_dispatch(&qmp_commands, QOBJECT(req)); assert(resp != NULL); assert(!qdict_haskey(qobject_to_qdict(resp), "error")); qobject_decref(resp); QDECREF(req); }
static void qdict_get_try_str_test(void) { const char *p; const char *key = "key"; const char *str = "string"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qstring_from_str(str)); p = qdict_get_try_str(tests_dict, key); g_assert(p != NULL); g_assert(strcmp(p, str) == 0); QDECREF(tests_dict); }
static void qdict_del_test(void) { const char *key = "key test"; QDict *tests_dict = qdict_new(); qdict_put(tests_dict, key, qstring_from_str("foo")); g_assert(qdict_size(tests_dict) == 1); qdict_del(tests_dict, key); g_assert(qdict_size(tests_dict) == 0); g_assert(qdict_haskey(tests_dict, key) == 0); QDECREF(tests_dict); }
/* test commands that return an error due to invalid parameters */ static void test_dispatch_cmd_error(void) { QDict *req = qdict_new(); QObject *resp; qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd2"))); resp = qmp_dispatch(QOBJECT(req)); assert(resp != NULL); assert(qdict_haskey(qobject_to_qdict(resp), "error")); g_print("\nresp: %s\n", qstring_get_str(qobject_to_json_pretty(resp))); qobject_decref(resp); QDECREF(req); }
static int process_disas_info(QemuHttpConnection *conn) { TranslationBlock *tb; DisasBuffer disas_buf = { {0}, 0 }; QList *res = qlist_new(); tb = &tbs[0]; disassemble_to_buffer(tb, &disas_buf); qlist_append(res, qstring_from_str(disas_buf.buffer)); int st = 0; st = respond_with_json(conn, QOBJECT(res)); qobject_decref(QOBJECT(res)); return st; }
static void to_json_dict_iter(const char *key, QObject *obj, void *opaque) { ToJsonIterState *s = opaque; QString *qkey; if (s->count) { qstring_append(s->str, ", "); } qkey = qstring_from_str(key); to_json(QOBJECT(qkey), s->str); QDECREF(qkey); qstring_append(s->str, ": "); to_json(obj, s->str); s->count++; }
static QList *qom_list_types(const char *implements, bool abstract) { QDict *resp; QList *ret; QDict *args = qdict_new(); qdict_put(args, "abstract", qbool_from_bool(abstract)); if (implements) { qdict_put(args, "implements", qstring_from_str(implements)); } resp = qmp("{'execute': 'qom-list-types'," " 'arguments': %p }", args); g_assert(qdict_haskey(resp, "return")); ret = qdict_get_qlist(resp, "return"); QINCREF(ret); QDECREF(resp); return ret; }
static bool ssh_process_legacy_socket_options(QDict *output_opts, QemuOpts *legacy_opts, Error **errp) { const char *host = qemu_opt_get(legacy_opts, "host"); const char *port = qemu_opt_get(legacy_opts, "port"); if (!host && port) { error_setg(errp, "port may not be used without host"); return false; } if (host) { qdict_put(output_opts, "server.host", qstring_from_str(host)); qdict_put(output_opts, "server.port", qstring_from_str(port ?: stringify(22))); } return true; }