struct oval_result_test *oval_result_test_clone
(struct oval_result_system *new_system, struct oval_result_test *old_test) {
__attribute__nonnull__(old_test);
const char *testid = oval_result_test_get_id(old_test);
struct oval_result_test *new_test = oval_result_test_new(new_system, (char *) testid);
struct oval_result_item_iterator *old_items = oval_result_test_get_items(old_test);
while (oval_result_item_iterator_has_more(old_items)) {
struct oval_result_item *old_item = oval_result_item_iterator_next(old_items);
struct oval_result_item *new_item = oval_result_item_clone(new_system, old_item);
oval_result_test_add_item(new_test, new_item);
}
oval_result_item_iterator_free(old_items);
struct oval_variable_binding_iterator *old_bindings = oval_result_test_get_bindings(old_test);
while (oval_variable_binding_iterator_has_more(old_bindings)) {
struct oval_variable_binding *old_binding = oval_variable_binding_iterator_next(old_bindings);
struct oval_variable_binding *new_binding = oval_variable_binding_clone(old_binding, NULL);
oval_result_test_add_binding(new_test, new_binding);
}
oval_variable_binding_iterator_free(old_bindings);
struct oval_message_iterator *old_messages = oval_result_test_get_messages(old_test);
while (oval_message_iterator_has_more(old_messages)) {
struct oval_message *old_message = oval_message_iterator_next(old_messages);
struct oval_message *new_message = oval_message_clone(old_message);
oval_result_test_add_message(new_test, new_message);
}
oval_message_iterator_free(old_messages);
oval_result_test_set_instance(new_test, oval_result_test_get_instance(old_test));
oval_result_test_set_result(new_test, old_test->result);
return new_test;
}
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;
}
struct oval_result_definition *oval_result_definition_clone
(struct oval_result_system *new_system, struct oval_result_definition *old_definition) {
const char *id = oval_result_definition_get_id(old_definition);
struct oval_result_definition *new_definition = oval_result_definition_new(new_system, (char *) id);
struct oval_result_criteria_node *old_crit = oval_result_definition_get_criteria(old_definition);
if (old_crit) {
struct oval_result_criteria_node *new_crit = oval_result_criteria_node_clone(new_system, old_crit);
oval_result_definition_set_criteria(new_definition, new_crit);
}
struct oval_message_iterator *old_messages = oval_result_definition_get_messages(old_definition);
while (oval_message_iterator_has_more(old_messages)) {
struct oval_message *old_message = oval_message_iterator_next(old_messages);
struct oval_message *new_message = oval_message_clone(old_message);
oval_result_definition_add_message(new_definition, new_message);
}
oval_message_iterator_free(old_messages);
oval_result_definition_set_result(new_definition, oval_result_definition_get_result(old_definition));
oval_result_definition_set_instance(new_definition, oval_result_definition_get_instance(old_definition));
oval_result_definition_set_variable_instance_hint(new_definition, oval_result_definition_get_variable_instance_hint(old_definition));
return new_definition;
}
