/* this function will gather all the necessary ingredients and call 'evaluate_items' when it finds them */ static oval_result_t _oval_result_test_result(struct oval_result_test *rtest, void **args) { __attribute__nonnull__(rtest); /* is the test already evaluated? */ if (rtest->result != OVAL_RESULT_NOT_EVALUATED) { dI("Found result from previous evaluation: %d, returning without further processing.", rtest->result); return (rtest->result); } /* get syschar of rtest */ struct oval_test *test = oval_result_test_get_test(rtest); struct oval_object * object = oval_test_get_object(test); char * object_id = oval_object_get_id(object); struct oval_result_system *sys = oval_result_test_get_system(rtest); struct oval_results_model *results_model = oval_result_system_get_results_model(sys); struct oval_probe_session *probe_session = oval_results_model_get_probe_session(results_model); if (probe_session != NULL) { /* probe test */ int ret = oval_probe_query_test(probe_session, test); if (ret != 0) { return ret; } } 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); if (syschar == NULL) { dW("No syschar for object: %s", object_id); return OVAL_RESULT_UNKNOWN; } /* evaluate items */ oval_result_t result = _oval_result_test_evaluate_items(test, syschar, args); return 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; }
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; }