/* failed - NULL
* success - oval_definition_model
* */
struct oval_definition_model *oval_definition_model_new()
{
oval_definition_model_t *newmodel = (oval_definition_model_t *) oscap_alloc(sizeof(oval_definition_model_t));
if (newmodel == NULL)
return NULL;
newmodel->generator = oval_generator_new();
newmodel->definition_map = oval_string_map_new();
newmodel->object_map = oval_string_map_new();
newmodel->state_map = oval_string_map_new();
newmodel->test_map = oval_string_map_new();
newmodel->variable_map = oval_string_map_new();
newmodel->bound_variable_models = NULL;
newmodel->schema = strdup(OVAL_DEF_SCHEMA_LOCATION);
newmodel->vardef_map = NULL;
return newmodel;
}
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);
}
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;
}
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;
}