/* 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.\n", 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_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\n", object_id);
return OVAL_RESULT_UNKNOWN;
}
/* evaluate items */
oval_result_t result = _oval_result_test_evaluate_items(test, syschar, args);
return result;
}
struct oval_result_definition *oval_result_definition_new(struct oval_result_system *sys, char *definition_id) {
oval_result_definition_t *definition = (oval_result_definition_t *)
oscap_alloc(sizeof(oval_result_definition_t));
if (definition == NULL)
return NULL;
definition->system = sys;
struct oval_syschar_model *syschar_model = oval_result_system_get_syschar_model(sys);
struct oval_definition_model *definition_model = oval_syschar_model_get_definition_model(syschar_model);
definition->definition = oval_definition_model_get_new_definition(definition_model, definition_id);
definition->result = OVAL_RESULT_NOT_EVALUATED;
definition->criteria = NULL;
definition->messages = oval_collection_new();
definition->variable_instance_hint = 1;
definition->instance = 1;
return definition;
}
struct oval_result_test *oval_result_test_new(struct oval_result_system *sys, char *tstid)
{
oval_result_test_t *test = (oval_result_test_t *)
oscap_alloc(sizeof(oval_result_test_t));
if (test == NULL)
return NULL;
struct oval_syschar_model *syschar_model = oval_result_system_get_syschar_model(sys);
struct oval_definition_model *definition_model = oval_syschar_model_get_definition_model(syschar_model);
test->system = sys;
test->test = oval_definition_model_get_new_test(definition_model, tstid);
test->messages = oval_collection_new();
test->result = OVAL_RESULT_NOT_EVALUATED;
test->instance = 1;
test->items = oval_collection_new();
test->bindings = oval_collection_new();
test->bindings_initialized = false;
return test;
}
static int _oval_result_test_binding_parse(xmlTextReaderPtr reader, struct oval_parser_context *context, void **args) {
int return_code = 0;
xmlChar *variable_id = xmlTextReaderGetAttribute(reader, BAD_CAST "variable_id");
struct oval_syschar_model *syschar_model = oval_result_system_get_syschar_model(SYSTEM);
struct oval_definition_model *definition_model = oval_syschar_model_get_definition_model(syschar_model);
struct oval_variable *variable = oval_definition_model_get_new_variable
(definition_model, (char *)variable_id, OVAL_VARIABLE_UNKNOWN);
xmlChar *value = xmlTextReaderValue(reader);
struct oval_variable_binding *binding = oval_variable_binding_new(variable, oscap_strdup((char *) value));
oval_result_test_add_binding(TEST, binding);
xmlFree(value);
xmlFree(variable_id);
return return_code;
}
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;
}
static oval_result_t eval_check_state(struct oval_test *test, void **args)
{
struct oval_syschar_model *syschar_model;
struct oval_result_item_iterator *ritems_itr;
struct oresults item_ores;
oval_result_t result;
oval_check_t ste_check;
oval_operator_t ste_opr;
ste_check = oval_test_get_check(test);
ste_opr = oval_test_get_state_operator(test);
syschar_model = oval_result_system_get_syschar_model(SYSTEM);
ores_clear(&item_ores);
ritems_itr = oval_result_test_get_items(TEST);
while (oval_result_item_iterator_has_more(ritems_itr)) {
struct oval_result_item *ritem;
struct oval_sysitem *item;
oval_syschar_status_t item_status;
struct oresults ste_ores;
struct oval_state_iterator *ste_itr;
oval_result_t item_res;
ritem = oval_result_item_iterator_next(ritems_itr);
item = oval_result_item_get_sysitem(ritem);
item_status = oval_sysitem_get_status(item);
switch (item_status) {
case SYSCHAR_STATUS_ERROR:
case SYSCHAR_STATUS_NOT_COLLECTED:
item_res = OVAL_RESULT_ERROR;
ores_add_res(&item_ores, item_res);
oval_result_item_set_result(ritem, item_res);
continue;
case SYSCHAR_STATUS_DOES_NOT_EXIST:
item_res = OVAL_RESULT_FALSE;
ores_add_res(&item_ores, item_res);
oval_result_item_set_result(ritem, item_res);
continue;
default:
break;
}
ores_clear(&ste_ores);
ste_itr = oval_test_get_states(test);
while (oval_state_iterator_has_more(ste_itr)) {
struct oval_state *ste;
oval_result_t ste_res;
ste = oval_state_iterator_next(ste_itr);
ste_res = eval_item(syschar_model, item, ste);
ores_add_res(&ste_ores, ste_res);
}
oval_state_iterator_free(ste_itr);
item_res = ores_get_result_byopr(&ste_ores, ste_opr);
ores_add_res(&item_ores, item_res);
oval_result_item_set_result(ritem, item_res);
}
oval_result_item_iterator_free(ritems_itr);
result = ores_get_result_bychk(&item_ores, ste_check);
return result;
}
