static int oval_probe_query_extend_definition(oval_probe_session_t *sess, struct oval_criteria_node *cnode)
{
struct oval_definition *oval_def = oval_criteria_node_get_definition(cnode);
const char *def_id = oval_definition_get_id(oval_def);
dI("Criteria are extended by definition '%s'.", def_id);
return oval_probe_query_definition(sess, def_id);
}
struct oval_result_definition *make_result_definition_from_oval_definition
(struct oval_result_system *sys, struct oval_definition *oval_definition, int variable_instance) {
char *defid = oval_definition_get_id(oval_definition);
struct oval_result_definition *rslt_definition = oval_result_definition_new(sys, defid);
oval_result_definition_set_instance(rslt_definition, variable_instance);
struct oval_criteria_node *oval_criteria = oval_definition_get_criteria(oval_definition);
struct oval_result_criteria_node *rslt_criteria =
make_result_criteria_node_from_oval_criteria_node(sys, oval_criteria, variable_instance);
if (rslt_criteria)
oval_result_definition_set_criteria(rslt_definition, rslt_criteria);
return rslt_definition;
}
xmlNode *oval_result_definition_to_dom
(struct oval_result_definition * definition, oval_result_directive_content_t content,
xmlDocPtr doc, xmlNode * parent) {
xmlNs *ns_results = xmlSearchNsByHref(doc, parent, OVAL_RESULTS_NAMESPACE);
xmlNode *definition_node = xmlNewTextChild(parent, ns_results, BAD_CAST "definition", NULL);
struct oval_definition *oval_definition = oval_result_definition_get_definition(definition);
char *definition_id = oval_definition_get_id(oval_definition);
xmlNewProp(definition_node, BAD_CAST "definition_id", BAD_CAST definition_id);
oval_result_t result = oval_result_definition_get_result(definition);
const char *result_att = oval_result_get_text(result);
xmlNewProp(definition_node, BAD_CAST "result", BAD_CAST result_att);
int version = oval_definition_get_version(oval_definition);
char version_att[10] = "";
snprintf(version_att, sizeof(version_att), "%d", version);
xmlNewProp(definition_node, BAD_CAST "version", BAD_CAST version_att);
int instance = oval_result_definition_get_instance(definition);
if (instance != 1 ||
oval_result_definition_get_variable_instance_hint(definition) != instance) {
char instance_att[10] = "";
snprintf(instance_att, sizeof(instance_att), "%d", instance);
xmlNewProp(definition_node, BAD_CAST "variable_instance", BAD_CAST instance_att);
}
struct oval_message_iterator *messages = oval_result_definition_get_messages(definition);
while (oval_message_iterator_has_more(messages)) {
oval_message_to_dom(oval_message_iterator_next(messages), doc, definition_node);
}
oval_message_iterator_free(messages);
if (content == OVAL_DIRECTIVE_CONTENT_FULL) {
struct oval_result_criteria_node *criteria = oval_result_definition_get_criteria(definition);
if (criteria) {
oval_result_criteria_node_to_dom(criteria, doc, definition_node);
}
}
return definition_node;
}
int oval_agent_eval_system(oval_agent_session_t * ag_sess, agent_reporter cb, void *arg) {
struct oval_definition *oval_def;
struct oval_definition_iterator *oval_def_it;
char *id;
int ret = 0;
dI("OVAL agent started to evaluate OVAL definitions on your system.");
oval_def_it = oval_definition_model_get_definitions(ag_sess->def_model);
while (oval_definition_iterator_has_more(oval_def_it)) {
oval_def = oval_definition_iterator_next(oval_def_it);
id = oval_definition_get_id(oval_def);
/* probe and eval */
ret = oval_agent_eval_definition(ag_sess, id);
if (ret==-1) {
goto cleanup;
}
/* callback */
if (cb != NULL) {
struct oval_result_definition * res_def = oval_agent_get_result_definition(ag_sess, id);
ret = cb(res_def,arg);
/* stop? */
if (ret!=0)
goto cleanup;
}
/* probe evaluation terminated by signal */
if (ret == -2) {
ret = 1;
break;
}
}
cleanup:
oval_definition_iterator_free(oval_def_it);
dI("OVAL agent finished evaluation.");
return ret;
}
/**
* @returns 0 on success; -1 on error; 1 on warning
*/
static int oval_probe_query_criteria(oval_probe_session_t *sess, struct oval_criteria_node *cnode) {
int ret;
switch (oval_criteria_node_get_type(cnode)) {
/* Criterion node is the final node that has a reference to a test */
case OVAL_NODETYPE_CRITERION:{
/* There should be a test .. */
struct oval_test *test;
struct oval_object *object;
struct oval_state_iterator *ste_itr;
test = oval_criteria_node_get_test(cnode);
if (test == NULL)
return 0;
object = oval_test_get_object(test);
if (object == NULL)
return 0;
/* probe object */
ret = oval_probe_query_object(sess, object, 0, NULL);
if (ret == -1)
return ret;
/* probe objects referenced like this: test->state->variable->object */
ste_itr = oval_test_get_states(test);
while (oval_state_iterator_has_more(ste_itr)) {
struct oval_state *state = oval_state_iterator_next(ste_itr);
struct oval_state_content_iterator *contents = oval_state_get_contents(state);
while (oval_state_content_iterator_has_more(contents)) {
struct oval_state_content *content = oval_state_content_iterator_next(contents);
struct oval_entity * entity = oval_state_content_get_entity(content);
if (oval_entity_get_varref_type(entity) == OVAL_ENTITY_VARREF_ATTRIBUTE) {
oval_syschar_collection_flag_t flag;
struct oval_variable *var = oval_entity_get_variable(entity);
ret = oval_probe_query_variable(sess, var);
if (ret == -1) {
oval_state_content_iterator_free(contents);
oval_state_iterator_free(ste_itr);
return ret;
}
flag = oval_variable_get_collection_flag(var);
switch (flag) {
case SYSCHAR_FLAG_COMPLETE:
case SYSCHAR_FLAG_INCOMPLETE:
break;
default:
oval_state_content_iterator_free(contents);
oval_state_iterator_free(ste_itr);
return 0;
}
}
}
oval_state_content_iterator_free(contents);
}
oval_state_iterator_free(ste_itr);
return 0;
}
break;
/* Criteria node is type of set that contains more criterias. Criteria node
* child can be also type of criteria, criterion or extended definition */
case OVAL_NODETYPE_CRITERIA:{
/* group of criterion nodes, get subnodes, continue recursive */
struct oval_criteria_node_iterator *cnode_it = oval_criteria_node_get_subnodes(cnode);
if (cnode_it == NULL)
return 0;
/* we have subnotes */
struct oval_criteria_node *node;
while (oval_criteria_node_iterator_has_more(cnode_it)) {
node = oval_criteria_node_iterator_next(cnode_it);
ret = oval_probe_query_criteria(sess, node);
if (ret != 0) {
oval_criteria_node_iterator_free(cnode_it);
return ret;
}
}
oval_criteria_node_iterator_free(cnode_it);
return 0;
}
break;
/* Extended definition contains reference to definition, we need criteria of this
* definition to be evaluated completely */
case OVAL_NODETYPE_EXTENDDEF:{
struct oval_definition *oval_def = oval_criteria_node_get_definition(cnode);
struct oval_criteria_node *node = oval_definition_get_criteria(oval_def);
if (node == NULL) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Could not find extended definition: %s.",
oval_definition_get_id(oval_def));
return -1;
}
return oval_probe_query_criteria(sess, node);
}
break;
case OVAL_NODETYPE_UNKNOWN:
break;
}
/* we shouldn't get here */
return -1;
}
void oval_definition_model_add_definition(struct oval_definition_model *model, struct oval_definition *definition)
{
__attribute__nonnull__(model);
char *key = oval_definition_get_id(definition);
oval_string_map_put(model->definition_map, key, (void *)definition);
}
const char *oval_result_definition_get_id(const struct oval_result_definition *rslt_definition)
{
__attribute__nonnull__(rslt_definition);
struct oval_definition *def = oval_result_definition_get_definition(rslt_definition);
return (def == NULL) ? NULL : oval_definition_get_id(def);
}
