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 {