static void _oval_test_item_consumer(struct oval_result_item *item, void **args) {
struct oval_sysitem *oval_sysitem = oval_result_item_get_sysitem(item);
char *item_id = oval_sysitem_get_id(oval_sysitem);
struct oval_result_item *mapped_item = oval_string_map_get_value(ITEMMAP, item_id);
if (mapped_item == NULL) {
oval_string_map_put(ITEMMAP, item_id, item);
oval_result_test_add_item(TEST, item);
} else {
oval_result_item_free(item);
}
}
static void _oval_definition_model_clone(struct oval_string_map *oldmap,
struct oval_definition_model *newmodel,
_oval_clone_func cloner)
{
struct oval_string_iterator *keys = (struct oval_string_iterator *)oval_string_map_keys(oldmap);
while (oval_string_iterator_has_more(keys)) {
char *key = oval_string_iterator_next(keys);
void *olditem = oval_string_map_get_value(oldmap, key);
(*cloner) (newmodel, olditem);
}
oval_string_iterator_free(keys);
}
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);
}
struct oval_string_iterator *oval_definition_model_get_definitions_dependent_on_variable(struct oval_definition_model *model, struct oval_variable *variable)
{
__attribute__nonnull__(model);
__attribute__nonnull__(variable);
if (model->vardef_map == NULL)
model->vardef_map = oval_definition_model_build_vardef_mapping(model);
struct oval_string_map *def_list = (struct oval_string_map *) oval_string_map_get_value(model->vardef_map, oval_variable_get_id(variable));
return (struct oval_string_iterator *) (def_list != NULL ?
oval_string_map_keys(def_list) : oval_collection_iterator_new());
}
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;
}
struct oval_variable *oval_definition_model_get_variable(struct oval_definition_model *model, const char *key)
{
__attribute__nonnull__(model);
return (struct oval_variable *)oval_string_map_get_value(model->variable_map, key);
}
struct oval_object *oval_definition_model_get_object(struct oval_definition_model *model, const char *key)
{
__attribute__nonnull__(model);
return (struct oval_object *)oval_string_map_get_value(model->object_map, key);
}
static struct oval_sysent *oval_sexp_to_sysent(struct oval_syschar_model *model, struct oval_sysitem *item, SEXP_t * sexp, struct oval_string_map *mask_map)
{
char *key;
oval_syschar_status_t status;
oval_datatype_t dt;
struct oval_sysent *ent;
key = probe_ent_getname(sexp);
if (!key)
return NULL;
if (strcmp("message", key) == 0 && item != NULL) {
struct oval_message *msg;
oval_message_level_t lvl;
SEXP_t *lvl_sexp, *txt_sexp;
char txt[1024];
lvl_sexp = probe_obj_getattrval(sexp, "level");
lvl = SEXP_number_getu_32(lvl_sexp);
txt_sexp = probe_ent_getval(sexp);
SEXP_string_cstr_r(txt_sexp, txt, sizeof txt);
SEXP_vfree(lvl_sexp, txt_sexp);
/* TODO: sanity checks */
msg = oval_message_new();
oval_message_set_level(msg, lvl);
oval_message_set_text(msg, txt);
oval_sysitem_add_message(item, msg);
return (NULL);
}
status = probe_ent_getstatus(sexp);
dt = probe_ent_getdatatype(sexp);
ent = oval_sysent_new(model);
oval_sysent_set_name(ent, key);
oval_sysent_set_status(ent, status);
oval_sysent_set_datatype(ent, dt);
if (mask_map == NULL || oval_string_map_get_value(mask_map, key) == NULL)
oval_sysent_set_mask(ent, 0);
else
oval_sysent_set_mask(ent, 1);
if (status != SYSCHAR_STATUS_EXISTS)
return ent;
if (dt == OVAL_DATATYPE_RECORD) {
SEXP_t *srf, *srfs;
probe_ent_getvals(sexp, &srfs);
SEXP_list_foreach(srf, srfs) {
struct oval_record_field *rf;
rf = oval_record_field_ITEM_from_sexp(srf);
oval_sysent_add_record_field(ent, rf);
}
SEXP_free(srfs);
} else {
