int oval_result_test_parse_tag(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr) { struct oval_result_system *sys = (struct oval_result_system *) usr; int return_code = 0; struct oval_definition_model *dmod; struct oval_test *dtst; struct oval_result_test *test; xmlChar *test_id = xmlTextReaderGetAttribute(reader, BAD_CAST "test_id"); dmod = context->definition_model; dtst = oval_definition_model_get_new_test(dmod, (char *) test_id); oval_result_t result = oval_result_parse(reader, "result", 0); int variable_instance = oval_parser_int_attribute(reader, "variable_instance", 1); test = oval_result_system_get_new_test(sys, dtst, variable_instance); if (test == NULL) return -1; oval_result_test_set_result(test, result); oval_result_test_set_instance(test, variable_instance); struct oval_test *ovaltst = oval_result_test_get_test(test); oval_existence_t check_existence = oval_existence_parse(reader, "check_existence", OVAL_AT_LEAST_ONE_EXISTS); oval_existence_t tst_check_existence = oval_test_get_existence(ovaltst); if (tst_check_existence == OVAL_EXISTENCE_UNKNOWN) { oval_test_set_existence(ovaltst, check_existence); } else if (tst_check_existence != check_existence) { oscap_dlprintf(DBG_W, "@check_existence does not match, test_id: %s.\n", test_id); } oval_check_t check = oval_check_parse(reader, "check", OVAL_CHECK_UNKNOWN); oval_check_t tst_check = oval_test_get_check(ovaltst); if (tst_check == OVAL_CHECK_UNKNOWN) { oval_test_set_check(ovaltst, check); } else if (tst_check != check) { oscap_dlprintf(DBG_W, "@check does not match, test_id: %s.\n", test_id); } int version = oval_parser_int_attribute(reader, "version", 0); int tst_version = oval_test_get_version(ovaltst); if (tst_version == 0) { oval_test_set_version(ovaltst, version); } else if (tst_version != version) { oscap_dlprintf(DBG_W, "@version does not match, test_id: %s.\n", test_id); } struct oval_string_map *itemmap = oval_string_map_new(); void *args[] = { sys, test, itemmap }; return_code = oval_parser_parse_tag(reader, context, (oval_xml_tag_parser) _oval_result_test_parse, args); oval_string_map_free(itemmap, NULL); test->bindings_initialized = true; oscap_free(test_id); return return_code; }
void oval_definition_model_optimize_by_filter_propagation(struct oval_definition_model *model) { struct oval_object_iterator *obj_itr; struct oval_string_map *processed_obj_map; processed_obj_map = oval_string_map_new(); obj_itr = oval_definition_model_get_objects(model); while (oval_object_iterator_has_more(obj_itr)) { struct oval_object *obj; char *obj_id; struct oval_object_content_iterator *cont_itr; struct oval_object_content *cont; struct oval_setobject *set; struct oval_filter_iterator *filter_itr; obj = oval_object_iterator_next(obj_itr); obj_id = oval_object_get_id(obj); if (oval_string_map_get_value(processed_obj_map, obj_id) != NULL) continue; oval_string_map_put(processed_obj_map, obj_id, obj); cont_itr = oval_object_get_object_contents(obj); if (!oval_object_content_iterator_has_more(cont_itr)) { oval_object_content_iterator_free(cont_itr); continue; } cont = oval_object_content_iterator_next(cont_itr); oval_object_content_iterator_free(cont_itr); if (oval_object_content_get_type(cont) != OVAL_OBJECTCONTENT_SET) continue; set = oval_object_content_get_setobject(cont); if (oval_setobject_get_type(set) == OVAL_SET_AGGREGATE) { _fp_set_recurse(model, set, obj_id); continue; } filter_itr = oval_setobject_get_filters(set); if (!oval_filter_iterator_has_more(filter_itr)) { oval_filter_iterator_free(filter_itr); continue; } oval_filter_iterator_free(filter_itr); oval_set_propagate_filters(model, set, obj_id); } oval_object_iterator_free(obj_itr); oval_string_map_free(processed_obj_map, NULL); }
void oval_definition_model_free(struct oval_definition_model *model) { __attribute__nonnull__(model); oval_string_map_free(model->definition_map, (oscap_destruct_func) oval_definition_free); oval_string_map_free(model->object_map, (oscap_destruct_func) oval_object_free); oval_string_map_free(model->state_map, (oscap_destruct_func) oval_state_free); oval_string_map_free(model->test_map, (oscap_destruct_func) oval_test_free); oval_string_map_free(model->variable_map, (oscap_destruct_func) oval_variable_free); if (model->vardef_map != NULL) oval_string_map_free(model->vardef_map, (oscap_destruct_func) oval_string_map_free0); if (model->bound_variable_models) oval_collection_free_items(model->bound_variable_models, (oscap_destruct_func) oval_variable_model_free); if (model->schema != NULL) oscap_free(model->schema); model->definition_map = NULL; model->object_map = NULL; model->state_map = NULL; model->test_map = NULL; model->variable_map = NULL; model->schema = NULL; oval_generator_free(model->generator); oscap_free(model); }
oval_result_t oval_result_test_eval(struct oval_result_test *rtest) { __attribute__nonnull__(rtest); if (rtest->result == OVAL_RESULT_NOT_EVALUATED) { if ((oval_independent_subtype_t)oval_test_get_subtype(oval_result_test_get_test(rtest)) != OVAL_INDEPENDENT_UNKNOWN ) { struct oval_string_map *tmp_map = oval_string_map_new(); void *args[] = { rtest->system, rtest, tmp_map }; rtest->result = _oval_result_test_result(rtest, args); oval_string_map_free(tmp_map, NULL); if (!rtest->bindings_initialized) { _oval_result_test_initialize_bindings(rtest); } } else rtest->result = OVAL_RESULT_UNKNOWN; } dI("\t%s => %s\n", oval_result_test_get_id(rtest), oval_result_get_text(rtest->result)); return rtest->result; }
static void _oval_result_test_initialize_bindings(struct oval_result_test *rslt_test) { __attribute__nonnull__(rslt_test); struct oval_test *oval_test = oval_result_test_get_test(rslt_test); struct oval_string_map *vm; struct oval_state_iterator *ste_itr; struct oval_iterator *var_itr; vm = oval_string_map_new(); /* Gather bindings pertaining to the referenced states */ /* TODO: cache bindings collected for each state */ ste_itr = oval_test_get_states(oval_test); while (oval_state_iterator_has_more(ste_itr)) { struct oval_state *ste; ste = oval_state_iterator_next(ste_itr); oval_ste_collect_var_refs(ste, vm); } oval_state_iterator_free(ste_itr); var_itr = oval_string_map_values(vm); while (oval_collection_iterator_has_more(var_itr)) { struct oval_variable *var; struct oval_value_iterator *val_itr; struct oval_variable_binding *binding; var = oval_collection_iterator_next(var_itr); binding = oval_variable_binding_new(var, NULL); val_itr = oval_variable_get_values(var); while (oval_value_iterator_has_more(val_itr)) { struct oval_value *val; char *txt; val = oval_value_iterator_next(val_itr); txt = oval_value_get_text(val); txt = oscap_strdup(txt); oval_variable_binding_add_value(binding, txt); } oval_value_iterator_free(val_itr); oval_result_test_add_binding(rslt_test, binding); } oval_collection_iterator_free(var_itr); /* Gather bindings pertaining to the collected object */ struct oval_object *oval_object = oval_test_get_object(oval_test); if (oval_object) { char *object_id = oval_object_get_id(oval_object); struct oval_result_system *sys = oval_result_test_get_system(rslt_test); struct oval_syschar_model *syschar_model = oval_result_system_get_syschar_model(sys); struct oval_syschar *syschar = oval_syschar_model_get_syschar(syschar_model, object_id); /* no syschar if system characteristics was a subset of definitions */ if(syschar) { struct oval_variable_binding_iterator *bindings = oval_syschar_get_variable_bindings(syschar); while (oval_variable_binding_iterator_has_more(bindings)) { struct oval_variable *var; char *var_id; struct oval_variable_binding *binding = oval_variable_binding_iterator_next(bindings); var = oval_variable_binding_get_variable(binding); var_id = oval_variable_get_id(var); /* Don't add bindings that were already * collected from states. Assumtion is made * that object's own bindings don't contain * duplicates. */ if (oval_string_map_get_value(vm, var_id) == NULL) { struct oval_definition_model *definition_model = oval_syschar_model_get_definition_model(syschar_model); struct oval_variable_binding *binding_copy = oval_variable_binding_clone(binding, definition_model); oval_result_test_add_binding(rslt_test, binding_copy); } } oval_variable_binding_iterator_free(bindings); } } oval_string_map_free(vm, NULL); rslt_test->bindings_initialized = true; }
void oval_string_map_free_string(struct oval_string_map *map) { oval_string_map_free(map, oscap_free); }
int oval_probe_query_object(oval_probe_session_t *psess, struct oval_object *object, int flags, struct oval_syschar **out_syschar) { char *oid; struct oval_syschar *sysc; oval_subtype_t type; oval_ph_t *ph; struct oval_string_map *vm; struct oval_syschar_model *model; int ret; oid = oval_object_get_id(object); model = psess->sys_model; dI("Querying object id: \"%s\", flags: %u.\n", oid, flags); sysc = oval_syschar_model_get_syschar(model, oid); if (sysc != NULL) { int variable_instance_hint = oval_syschar_get_variable_instance_hint(sysc); if (oval_syschar_get_variable_instance_hint(sysc) != oval_syschar_get_variable_instance(sysc)) { dI("Creating another syschar for variable_instance=%d)\n", variable_instance_hint); sysc = oval_syschar_new(model, object); oval_syschar_set_variable_instance(sysc, variable_instance_hint); oval_syschar_set_variable_instance_hint(sysc, variable_instance_hint); } else { oval_syschar_collection_flag_t sc_flg; sc_flg = oval_syschar_get_flag(sysc); dI("Syschar already exists, flag: %u, '%s'.\n", sc_flg, oval_syschar_collection_flag_get_text(sc_flg)); if (sc_flg != SYSCHAR_FLAG_UNKNOWN || (flags & OVAL_PDFLAG_NOREPLY)) { if (out_syschar) *out_syschar = sysc; return 0; } } } else sysc = oval_syschar_new(model, object); if (out_syschar) *out_syschar = sysc; type = oval_object_get_subtype(object); ph = oval_probe_handler_get(psess->ph, type); if (ph == NULL) { char *msg = "OVAL object not supported."; dW("%s\n", msg); oval_syschar_add_new_message(sysc, msg, OVAL_MESSAGE_LEVEL_WARNING); oval_syschar_set_flag(sysc, SYSCHAR_FLAG_NOT_COLLECTED); return 1; } if ((ret = ph->func(type, ph->uptr, PROBE_HANDLER_ACT_EVAL, sysc, flags)) != 0) { return ret; } if (!(flags & OVAL_PDFLAG_NOREPLY)) { vm = oval_string_map_new(); oval_obj_collect_var_refs(object, vm); _syschar_add_bindings(sysc, vm); oval_string_map_free(vm, NULL); } return 0; }