xmlNode *oval_result_test_to_dom(struct oval_result_test *rslt_test, xmlDocPtr doc, xmlNode * parent) {
__attribute__nonnull__(rslt_test);
xmlNs *ns_results = xmlSearchNsByHref(doc, parent, OVAL_RESULTS_NAMESPACE);
xmlNode *test_node = xmlNewTextChild(parent, ns_results, BAD_CAST "test", NULL);
struct oval_test *oval_test = oval_result_test_get_test(rslt_test);
char *test_id = oval_test_get_id(oval_test);
xmlNewProp(test_node, BAD_CAST "test_id", BAD_CAST test_id);
char version[10];
*version = '\0';
snprintf(version, sizeof(version), "%d", oval_test_get_version(oval_test));
xmlNewProp(test_node, BAD_CAST "version", BAD_CAST version);
oval_existence_t existence = oval_test_get_existence(oval_test);
if (existence != OVAL_AT_LEAST_ONE_EXISTS) {
xmlNewProp(test_node, BAD_CAST "check_existence", BAD_CAST oval_existence_get_text(existence));
}
oval_check_t check = oval_test_get_check(oval_test);
xmlNewProp(test_node, BAD_CAST "check", BAD_CAST oval_check_get_text(check));
int instance_val = oval_result_test_get_instance(rslt_test);
if (instance_val > 1) {
char instance[10];
*instance = '\0';
snprintf(instance, sizeof(instance), "%d", instance_val);
xmlNewProp(test_node, BAD_CAST "variable_instance", BAD_CAST instance);
}
oval_result_t result = oval_result_test_get_result(rslt_test);
xmlNewProp(test_node, BAD_CAST "result", BAD_CAST oval_result_get_text(result));
/* does not make sense to report these when test(definition) is not evaluated */
if( result != OVAL_RESULT_NOT_EVALUATED) {
struct oval_result_item_iterator *items = oval_result_test_get_items(rslt_test);
while (oval_result_item_iterator_has_more(items)) {
struct oval_result_item *item = oval_result_item_iterator_next(items);
oval_result_item_to_dom(item, doc, test_node);
}
oval_result_item_iterator_free(items);
struct oval_variable_binding_iterator *bindings = oval_result_test_get_bindings(rslt_test);
while (oval_variable_binding_iterator_has_more(bindings)) {
struct oval_variable_binding *binding = oval_variable_binding_iterator_next(bindings);
_oval_result_binding_to_dom(binding, doc, test_node);
}
oval_variable_binding_iterator_free(bindings);
}
return test_node;
}
xmlNode *oval_state_content_to_dom(struct oval_state_content * content, xmlDoc * doc, xmlNode * parent) {
__attribute__nonnull__(content);
struct oval_record_field_iterator *rf_itr;
bool parent_mask;
xmlNode *content_node = oval_entity_to_dom(content->entity, doc, parent);
parent_mask = oval_entity_get_mask(content->entity);
rf_itr = oval_state_content_get_record_fields(content);
if (oval_record_field_iterator_has_more(rf_itr)) {
xmlNsPtr field_ns = NULL;
field_ns = xmlSearchNsByHref(doc, xmlDocGetRootElement(doc), OVAL_DEFINITIONS_NAMESPACE);
if (field_ns == NULL) {
field_ns = xmlNewNs(xmlDocGetRootElement(doc), OVAL_DEFINITIONS_NAMESPACE, BAD_CAST "oval-def");
}
while (oval_record_field_iterator_has_more(rf_itr)) {
struct oval_record_field *rf;
rf = oval_record_field_iterator_next(rf_itr);
oval_record_field_to_dom(rf, parent_mask, doc, content_node, field_ns);
}
}
oval_record_field_iterator_free(rf_itr);
oval_check_t var_check = oval_state_content_get_var_check(content);
if (var_check != OVAL_CHECK_ALL || xmlHasProp(content_node, BAD_CAST "var_ref"))
xmlNewProp(content_node, BAD_CAST "var_check", BAD_CAST oval_check_get_text(var_check));
oval_check_t ent_check = oval_state_content_get_ent_check(content);
if (ent_check != OVAL_CHECK_ALL)
xmlNewProp(content_node, BAD_CAST "entity_check", BAD_CAST oval_check_get_text(ent_check));
oval_schema_version_t ver = oval_definition_model_get_core_schema_version(content->model);
if (oval_schema_version_cmp(ver, OVAL_SCHEMA_VERSION(5.11.1)) >= 0) {
oval_existence_t check_existence = oval_state_content_get_check_existence(content);
if (check_existence != OVAL_AT_LEAST_ONE_EXISTS) {
// at_least_one_exists is default value
xmlNewProp(content_node, BAD_CAST "check_existence", BAD_CAST oval_existence_get_text(check_existence));
}
}
return content_node;
}
xmlNode *oval_test_to_dom(struct oval_test *test, xmlDoc * doc, xmlNode * parent)
{
xmlNode * test_node=NULL;
/* skip unknown test */
oval_subtype_t subtype = oval_test_get_subtype(test);
if ( subtype == OVAL_SUBTYPE_UNKNOWN ) {
oscap_dlprintf(DBG_E, "Unknown Test %s.\n", oval_test_get_id(test));
return test_node;
}
/* get test name */
const char *subtype_text = oval_subtype_get_text(subtype);
char test_name[strlen(subtype_text) + 6];
sprintf(test_name, "%s_test", subtype_text);
/* get family URI */
oval_family_t family = oval_test_get_family(test);
const char *family_text = oval_family_get_text(family);
char family_uri[strlen((const char *)OVAL_DEFINITIONS_NAMESPACE) + strlen(family_text) + 2];
sprintf(family_uri,"%s#%s", OVAL_DEFINITIONS_NAMESPACE, family_text);
/* search namespace & create child */
xmlNs *ns_family = xmlSearchNsByHref(doc, parent, BAD_CAST family_uri);
test_node = xmlNewTextChild(parent, ns_family, BAD_CAST test_name, NULL);
char *id = oval_test_get_id(test);
xmlNewProp(test_node, BAD_CAST "id", BAD_CAST id);
char version[10];
*version = '\0';
snprintf(version, sizeof(version), "%d", oval_test_get_version(test));
xmlNewProp(test_node, BAD_CAST "version", BAD_CAST version);
oval_existence_t existence = oval_test_get_existence(test);
if (existence != OVAL_AT_LEAST_ONE_EXISTS)
xmlNewProp(test_node, BAD_CAST "check_existence", BAD_CAST oval_existence_get_text(existence));
oval_check_t check = oval_test_get_check(test);
xmlNewProp(test_node, BAD_CAST "check", BAD_CAST oval_check_get_text(check));
oval_operator_t ste_operator = oval_test_get_state_operator(test);
if (ste_operator != OVAL_OPERATOR_AND)
xmlNewProp(test_node, BAD_CAST "state_operator", BAD_CAST oval_operator_get_text(ste_operator));
char *comm = oval_test_get_comment(test);
xmlNewProp(test_node, BAD_CAST "comment", BAD_CAST comm);
bool deprecated = oval_test_get_deprecated(test);
if (deprecated)
xmlNewProp(test_node, BAD_CAST "deprecated", BAD_CAST "true");
struct oval_string_iterator *notes = oval_test_get_notes(test);
if (oval_string_iterator_has_more(notes)) {
xmlNs *ns_definitions = xmlSearchNsByHref(doc, parent, OVAL_DEFINITIONS_NAMESPACE);
xmlNode *notes_node = xmlNewTextChild(test_node, ns_definitions, BAD_CAST "notes", NULL);
while (oval_string_iterator_has_more(notes)) {
char *note = oval_string_iterator_next(notes);
xmlNewTextChild(notes_node, ns_definitions, BAD_CAST "note", BAD_CAST note);
}
}
oval_string_iterator_free(notes);
struct oval_object *object = oval_test_get_object(test);
if (object) {
xmlNode *object_node = xmlNewTextChild(test_node, ns_family, BAD_CAST "object", NULL);
xmlNewProp(object_node, BAD_CAST "object_ref", BAD_CAST oval_object_get_id(object));
}
struct oval_state_iterator *ste_itr = oval_test_get_states(test);
while (oval_state_iterator_has_more(ste_itr)) {
struct oval_state *state;
state = oval_state_iterator_next(ste_itr);
xmlNode *state_node = xmlNewTextChild(test_node, ns_family, BAD_CAST "state", NULL);
xmlNewProp(state_node, BAD_CAST "state_ref", BAD_CAST oval_state_get_id(state));
}
oval_state_iterator_free(ste_itr);
return test_node;
}
