static SEXP_t *oval_probe_cmd_obj_eval(SEXP_t *sexp, void *arg)
{
char *id_str;
struct oval_definition_model *defs;
struct oval_object *obj;
struct oval_syschar *res;
oval_pext_t *pext = (oval_pext_t *) arg;
SEXP_t *ret, *ret_code;
int r;
if (sexp == NULL || arg == NULL) {
return NULL;
}
if (!SEXP_stringp(sexp)) {
dE("Invalid argument: type=%s.", SEXP_strtype(sexp));
return (NULL);
}
id_str = SEXP_string_cstr(sexp);
defs = oval_syschar_model_get_definition_model(*(pext->model));
obj = oval_definition_model_get_object(defs, id_str);
ret = SEXP_list_new (sexp, NULL);
dI("Get_object: %s.", id_str);
if (obj == NULL) {
dE("Can't find obj: id=%s.", id_str);
free(id_str);
SEXP_free(ret);
return (NULL);
}
oscap_clearerr();
r = oval_probe_query_object(pext->sess_ptr, obj, OVAL_PDFLAG_NOREPLY|OVAL_PDFLAG_SLAVE, &res);
if (r < 0)
ret_code = SEXP_number_newu((unsigned int) SYSCHAR_FLAG_COMPLETE);
else
ret_code = SEXP_number_newu((unsigned int) oval_syschar_get_flag(res));
SEXP_list_add(ret, ret_code);
SEXP_free(ret_code);
if (oscap_err()) {
dE("Failed: id: %s, err: %d, %s.",
id_str, oscap_err_family(), oscap_err_desc());
oscap_clearerr();
free(id_str);
SEXP_free(ret);
return (NULL);
}
free(id_str);
return (ret);
}
static SEXP_t *oval_probe_cmd_ste_fetch(SEXP_t *sexp, void *arg)
{
SEXP_t *id, *ste_list, *ste_sexp;
char *id_str;
struct oval_state *ste;
struct oval_definition_model *definition_model;
oval_pext_t *pext = (oval_pext_t *)arg;
int ret;
if (sexp == NULL || arg == NULL) {
return NULL;
}
ste_list = SEXP_list_new(NULL);
SEXP_list_foreach(id, sexp) {
if (SEXP_stringp(id)) {
id_str = SEXP_string_cstr(id);
definition_model = oval_syschar_model_get_definition_model(*(pext->model));
ste = oval_definition_model_get_state(definition_model, id_str);
if (ste == NULL) {
dE("Can't find ste: id: %s.", id_str);
SEXP_list_free(ste_list);
free(id_str);
SEXP_free(id);
return (NULL);
}
ret = oval_state_to_sexp(pext->sess_ptr, ste, &ste_sexp);
if (ret !=0) {
dE("Failed to convert OVAL state to SEXP, id: %s.",
id_str);
SEXP_list_free(ste_list);
free(id_str);
SEXP_free(id);
return (NULL);
}
SEXP_list_add(ste_list, ste_sexp);
SEXP_free(ste_sexp);
free(id_str);
}
}
return (ste_list);
}
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;
}
int oval_probe_query_definition(oval_probe_session_t *sess, const char *id) {
struct oval_syschar_model * syschar_model;
struct oval_definition_model *definition_model;
struct oval_definition *definition;
int ret;
syschar_model = sess->sys_model;
definition_model = oval_syschar_model_get_definition_model(syschar_model);
definition = oval_definition_model_get_definition(definition_model, id);
if (definition == NULL) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "No definition with ID: %s in definition model.", id);
return -1;
}
struct oval_criteria_node * cnode = oval_definition_get_criteria(definition);
if (cnode == NULL)
return -1;
ret = oval_probe_query_criteria(sess, cnode);
return ret;
}
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;
}
