static void qdict_iterapi_test(void) { int count; const QDictEntry *ent; QDict *tests_dict = qdict_new(); g_assert(qdict_first(tests_dict) == NULL); qdict_put(tests_dict, "key1", qint_from_int(1)); qdict_put(tests_dict, "key2", qint_from_int(2)); qdict_put(tests_dict, "key3", qint_from_int(3)); count = 0; for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){ g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1); count++; } g_assert(count == qdict_size(tests_dict)); /* Do it again to test restarting */ count = 0; for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){ g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1); count++; } g_assert(count == qdict_size(tests_dict)); QDECREF(tests_dict); }
static QDict *qmp_dispatch_check_obj(const QObject *request, bool allow_oob, Error **errp) { const char *exec_key = NULL; const QDictEntry *ent; const char *arg_name; const QObject *arg_obj; QDict *dict; dict = qobject_to(QDict, request); if (!dict) { error_setg(errp, "QMP input must be a JSON object"); return NULL; } for (ent = qdict_first(dict); ent; ent = qdict_next(dict, ent)) { arg_name = qdict_entry_key(ent); arg_obj = qdict_entry_value(ent); if (!strcmp(arg_name, "execute") || (!strcmp(arg_name, "exec-oob") && allow_oob)) { if (qobject_type(arg_obj) != QTYPE_QSTRING) { error_setg(errp, "QMP input member '%s' must be a string", arg_name); return NULL; } if (exec_key) { error_setg(errp, "QMP input member '%s' clashes with '%s'", arg_name, exec_key); return NULL; } exec_key = arg_name; } else if (!strcmp(arg_name, "arguments")) { if (qobject_type(arg_obj) != QTYPE_QDICT) { error_setg(errp, "QMP input member 'arguments' must be an object"); return NULL; } } else if (!strcmp(arg_name, "id")) { continue; } else { error_setg(errp, "QMP input member '%s' is unexpected", arg_name); return NULL; } } if (!exec_key) { error_setg(errp, "QMP input lacks member 'execute'"); return NULL; } return dict; }
static int qdict_count_entries(QDict *dict) { const QDictEntry *e; int count = 0; for (e = qdict_first(dict); e; e = qdict_next(dict, e)) { count++; } return count; }
static bool ssh_has_filename_options_conflict(QDict *options, Error **errp) { const QDictEntry *qe; for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) { if (!strcmp(qe->key, "host") || !strcmp(qe->key, "port") || !strcmp(qe->key, "path") || !strcmp(qe->key, "user") || !strcmp(qe->key, "host_key_check") || strstart(qe->key, "server.", NULL)) { error_setg(errp, "Option '%s' cannot be used with a file name", qe->key); return true; } } return false; }
static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp) { const QDictEntry *ent; const char *arg_name; const QObject *arg_obj; bool has_exec_key = false; QDict *dict = NULL; if (qobject_type(request) != QTYPE_QDICT) { error_set(errp, QERR_QMP_BAD_INPUT_OBJECT, "request is not a dictionary"); return NULL; } dict = qobject_to_qdict(request); for (ent = qdict_first(dict); ent; ent = qdict_next(dict, ent)) { arg_name = qdict_entry_key(ent); arg_obj = qdict_entry_value(ent); if (!strcmp(arg_name, "execute")) { if (qobject_type(arg_obj) != QTYPE_QSTRING) { error_set(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute", "string"); return NULL; } has_exec_key = true; } else if (strcmp(arg_name, "arguments")) { error_set(errp, QERR_QMP_EXTRA_MEMBER, arg_name); return NULL; } } if (!has_exec_key) { error_set(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute"); return NULL; } return dict; }
void update_insn_class_info(const char* class_idx, const char* insn) { // Assuming class indexes are positive const QDictEntry* pentry; int64_t idx= -1; assert(class_info != NULL); pentry = qdict_first(class_info); do { QObject* temp = qdict_entry_value(pentry); QDict* pdict = qobject_to_qdict(temp); idx = qdict_get_int(pdict, "idx"); const char * str = qdict_get_str(pdict, "class_name"); if(strcmp(str, class_idx) == 0) break; idx = -1; pentry = qdict_next(class_info, pentry); } while(pentry != NULL); assert(insn_map != NULL); if(idx != -1) get_map_entry(insn)->instruction_type = idx; }
static bool nfs_has_filename_options_conflict(QDict *options, Error **errp) { const QDictEntry *qe; for (qe = qdict_first(options); qe; qe = qdict_next(options, qe)) { if (!strcmp(qe->key, "host") || !strcmp(qe->key, "path") || !strcmp(qe->key, "user") || !strcmp(qe->key, "group") || !strcmp(qe->key, "tcp-syn-count") || !strcmp(qe->key, "readahead-size") || !strcmp(qe->key, "page-cache-size") || !strcmp(qe->key, "debug") || strstart(qe->key, "server.", NULL)) { error_setg(errp, "Option %s cannot be used with a filename", qe->key); return true; } } return false; }
Object *user_creatable_add_type(const char *type, const char *id, const QDict *qdict, Visitor *v, Error **errp) { Object *obj; ObjectClass *klass; const QDictEntry *e; Error *local_err = NULL; klass = object_class_by_name(type); if (!klass) { error_setg(errp, "invalid object type: %s", type); return NULL; } if (!object_class_dynamic_cast(klass, TYPE_USER_CREATABLE)) { error_setg(errp, "object type '%s' isn't supported by object-add", type); return NULL; } if (object_class_is_abstract(klass)) { error_setg(errp, "object type '%s' is abstract", type); return NULL; } assert(qdict); obj = object_new(type); visit_start_struct(v, NULL, NULL, 0, &local_err); if (local_err) { goto out; } for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { object_property_set(obj, v, e->key, &local_err); if (local_err) { break; } } if (!local_err) { visit_check_struct(v, &local_err); } visit_end_struct(v, NULL); if (local_err) { goto out; } if (id != NULL) { object_property_add_child(object_get_objects_root(), id, obj, &local_err); if (local_err) { goto out; } } user_creatable_complete(USER_CREATABLE(obj), &local_err); if (local_err) { if (id != NULL) { object_property_del(object_get_objects_root(), id, &error_abort); } goto out; } out: if (local_err) { error_propagate(errp, local_err); object_unref(obj); return NULL; } return obj; }
static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info, Error **errp) { const QDict *qdict = NULL; const QDictEntry *e; Visitor *visitor; ObjectClass *oc; S390CPU *cpu; Object *obj; if (info->props) { qdict = qobject_to_qdict(info->props); if (!qdict) { error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict"); return; } } oc = cpu_class_by_name(TYPE_S390_CPU, info->name); if (!oc) { error_setg(errp, "The CPU definition \'%s\' is unknown.", info->name); return; } if (S390_CPU_CLASS(oc)->kvm_required && !kvm_enabled()) { error_setg(errp, "The CPU definition '%s' requires KVM", info->name); return; } obj = object_new(object_class_get_name(oc)); cpu = S390_CPU(obj); if (!cpu->model) { error_setg(errp, "Details about the host CPU model are not available, " "it cannot be used."); object_unref(obj); return; } if (qdict) { visitor = qobject_input_visitor_new(info->props); visit_start_struct(visitor, NULL, NULL, 0, errp); if (*errp) { object_unref(obj); return; } for (e = qdict_first(qdict); e; e = qdict_next(qdict, e)) { object_property_set(obj, visitor, e->key, errp); if (*errp) { break; } } if (!*errp) { visit_check_struct(visitor, errp); } visit_end_struct(visitor, NULL); visit_free(visitor); if (*errp) { object_unref(obj); return; } } /* copy the model and throw the cpu away */ memcpy(model, cpu->model, sizeof(*model)); object_unref(obj); }