/**

 * @file oval_resultCriteriaNode.c

 * \brief Open Vulnerability and Assessment Language

 *

 * See more details at http://oval.mitre.org/

 */

/*

 * Copyright 2009--2013 Red Hat Inc., Durham, North Carolina.

 * All Rights Reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 *

 * Authors:

 *      "David Niemoller" <David.Niemoller@g2-inc.com>

 *      Šimon Lukašík

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include "oval_agent_api_impl.h"

#include "results/oval_results_impl.h"

#include "adt/oval_collection_impl.h"

#include "common/util.h"

#include "common/debug_priv.h"

typedef struct oval_result_criteria_node {

	struct oval_result_system *sys;

	oval_criteria_node_type_t type;

	oval_result_t result;

	int negate;

	int applicability_check;

} oval_result_criteria_node_t;

typedef struct oval_result_criteria_node_CRITERIA {

	struct oval_result_system *sys;

	oval_criteria_node_type_t type;

	oval_result_t result;

	int negate;

	int applicability_check;

	oval_operator_t operator;

	struct oval_collection *subnodes;

} oval_result_criteria_node_CRITERIA_t;

typedef struct oval_result_criteria_node_CRITERION {

	struct oval_result_system *sys;

	oval_criteria_node_type_t type;

	oval_result_t result;

	int negate;

	int applicability_check;

	int variable_instance;

	struct oval_result_test *test;

} oval_result_criteria_node_CRITERION_t;

typedef struct oval_result_criteria_node_EXTENDDEF {

	struct oval_result_system *sys;

	oval_criteria_node_type_t type;

	oval_result_t result;

	int negate;

	int applicability_check;

	int variable_instance;

	struct oval_result_definition *extends;

} oval_result_criteria_node_EXTENDDEF_t;

struct oval_result_criteria_node *oval_result_criteria_node_new(struct oval_result_system *sys,

								oval_criteria_node_type_t type,

								int negate,

								int applicability_check,

								...) {

	oval_result_criteria_node_t *node = NULL;

	va_list ap;

	va_start(ap, applicability_check);

	switch (type) {

	case OVAL_NODETYPE_CRITERIA:{

			/*(NODETYPE_CRITERIA, negate, applicability_check, operator); */

			node = (oval_result_criteria_node_t *)

			    malloc(sizeof(oval_result_criteria_node_CRITERIA_t));

			if (node == NULL) {

				va_end(ap);

				return NULL;

			}

			oval_result_criteria_node_CRITERIA_t *criteria = (oval_result_criteria_node_CRITERIA_t *) node;

			criteria->operator =(oval_operator_t) va_arg(ap, int);

			criteria->subnodes = oval_collection_new();

		};

		break;

	case OVAL_NODETYPE_CRITERION:{

			/*(NODETYPE_CRITERION, negate, applicability_check, test, variable_instance); */

			node = (oval_result_criteria_node_t *)

			    malloc(sizeof(oval_result_criteria_node_CRITERION_t));

			if (node == NULL) {

				va_end(ap);

				return NULL;

			}

			oval_result_criteria_node_CRITERION_t *criterion =

			    (oval_result_criteria_node_CRITERION_t *) node;

			criterion->test = (struct oval_result_test *)va_arg(ap, void *);

			criterion->variable_instance = va_arg(ap, int);

		};

		break;

	case OVAL_NODETYPE_EXTENDDEF:{

			/*(NODETYPE_EXTENDDEF, negate, applicability_check, definition, variable_instance); */

			node = (oval_result_criteria_node_t *)

			    malloc(sizeof(oval_result_criteria_node_EXTENDDEF_t));

			if (node == NULL) {

				va_end(ap);

				return NULL;

			}

			oval_result_criteria_node_EXTENDDEF_t *extenddef =

			    (oval_result_criteria_node_EXTENDDEF_t *) node;

			extenddef->extends = (struct oval_result_definition *)va_arg(ap, void *);

			extenddef->variable_instance = va_arg(ap, int);

		} break;

	default:

		va_end(ap);

		dE("Unsupported criteria node type: %d.", type);

		return NULL;

	}

	node->sys = sys;

	node->negate = negate;

	node->applicability_check = applicability_check;

	node->result = OVAL_RESULT_NOT_EVALUATED;

	node->type = type;

	va_end(ap);

	return node;

}

struct oval_result_criteria_node *oval_result_criteria_node_clone

    (struct oval_result_system *new_system, struct oval_result_criteria_node *old_node) {

	oval_criteria_node_type_t type = oval_result_criteria_node_get_type(old_node);

	struct oval_result_criteria_node *new_node = NULL;

	bool negate = oval_result_criteria_node_get_negate(old_node);

	bool applicability_check = oval_result_criteria_node_get_applicability_check(old_node);

	switch (type) {

	case OVAL_NODETYPE_CRITERIA:{

			oval_operator_t operator = oval_result_criteria_node_get_operator(old_node);

			new_node = oval_result_criteria_node_new(new_system,

								 OVAL_NODETYPE_CRITERIA,

								 negate,

								 applicability_check,

								 operator);

			struct oval_result_criteria_node_iterator *old_subs =

			    oval_result_criteria_node_get_subnodes(old_node);

			while (oval_result_criteria_node_iterator_has_more(old_subs)) {

				struct oval_result_criteria_node *old_sub =

				    oval_result_criteria_node_iterator_next(old_subs);

				struct oval_result_criteria_node *new_sub =

				    oval_result_criteria_node_clone(new_system, old_sub);

				oval_result_criteria_node_add_subnode(new_node, new_sub);

			}

			oval_result_criteria_node_iterator_free(old_subs);

		};

		break;

	case OVAL_NODETYPE_CRITERION:{

			struct oval_result_test *old_test = oval_result_criteria_node_get_test(old_node);

			struct oval_result_test *new_test = oval_result_test_clone(new_system, old_test);

			new_node = oval_result_criteria_node_new(new_system,

								 OVAL_NODETYPE_CRITERION,

								 negate,

								 applicability_check,

								 new_test,

								 1);

		};

		break;

	case OVAL_NODETYPE_EXTENDDEF:{

			struct oval_result_definition *old_def = oval_result_criteria_node_get_extends(old_node);

			struct oval_result_definition *new_def = oval_result_definition_clone(new_system, old_def);

			new_node = oval_result_criteria_node_new(new_system,

								 OVAL_NODETYPE_EXTENDDEF,

								 negate,

								 applicability_check,

								 new_def, 1);

		} break;

	default:

		break;

	}

	oval_result_criteria_node_set_result(old_node, oval_result_criteria_node_get_result(old_node));

	return new_node;

}

void oval_result_criteria_node_free(struct oval_result_criteria_node *node)

{

	__attribute__nonnull__(node);

	switch (node->type) {

	case OVAL_NODETYPE_CRITERIA:{

			oval_result_criteria_node_CRITERIA_t *criteria = (oval_result_criteria_node_CRITERIA_t *) node;

			criteria->operator = OVAL_OPERATOR_UNKNOWN;

			oval_collection_free_items

			    (criteria->subnodes, (oscap_destruct_func) oval_result_criteria_node_free);

		};

		break;

	case OVAL_NODETYPE_CRITERION:{

			oval_result_criteria_node_CRITERION_t *criterion =

			    (oval_result_criteria_node_CRITERION_t *) node;

			criterion->test = NULL;

		};

		break;

	case OVAL_NODETYPE_EXTENDDEF:{

			oval_result_criteria_node_EXTENDDEF_t *extenddef =

			    (oval_result_criteria_node_EXTENDDEF_t *) node;

			extenddef->extends = NULL;

		}

		break;

	default:

		break;

	}

	node->result = OVAL_RESULT_UNKNOWN;

	node->type = OVAL_NODETYPE_UNKNOWN;

	free(node);

}

struct oval_result_criteria_node *make_result_criteria_node_from_oval_criteria_node

    (struct oval_result_system *sys, struct oval_criteria_node *oval_node, int variable_instance) {

	struct oval_result_criteria_node *rslt_node = NULL;

	if (oval_node) {

		oval_criteria_node_type_t type = oval_criteria_node_get_type(oval_node);

		bool negate = oval_criteria_node_get_negate(oval_node);

		bool applicability_check = oval_criteria_node_get_applicability_check(oval_node);

		switch (type) {

		case OVAL_NODETYPE_CRITERIA:{

				oval_operator_t operator = oval_criteria_node_get_operator(oval_node);

				rslt_node = oval_result_criteria_node_new(sys,

									  type,

									  negate,

									  applicability_check,

									  operator);

				struct oval_criteria_node_iterator *oval_subnodes

				    = oval_criteria_node_get_subnodes(oval_node);

				while (oval_criteria_node_iterator_has_more(oval_subnodes)) {

					struct oval_criteria_node *oval_subnode

					    = oval_criteria_node_iterator_next(oval_subnodes);

					struct oval_result_criteria_node *rslt_subnode

					    = make_result_criteria_node_from_oval_criteria_node(sys, oval_subnode, variable_instance);

					oval_result_criteria_node_add_subnode(rslt_node, rslt_subnode);

				}

				oval_criteria_node_iterator_free(oval_subnodes);

			} break;

		case OVAL_NODETYPE_CRITERION:{

				struct oval_test *oval_test = oval_criteria_node_get_test(oval_node);

				struct oval_result_test *rslt_test = oval_result_system_get_new_test(sys, oval_test, variable_instance);

				rslt_node = oval_result_criteria_node_new(sys,

									  type,

									  negate,

									  applicability_check,

									  rslt_test, 1);

			} break;

		case OVAL_NODETYPE_EXTENDDEF:{

				struct oval_definition *oval_definition = oval_criteria_node_get_definition(oval_node);

				struct oval_result_definition *rslt_definition

				    = oval_result_system_get_new_definition(sys, oval_definition, variable_instance);

				rslt_node = oval_result_criteria_node_new(sys,

									  type,

									  negate,

									  applicability_check,

									  rslt_definition, 1);

			} break;

		default:

			rslt_node = NULL;

		}

	}

	return rslt_node;

}

bool oval_result_criteria_node_iterator_has_more(struct oval_result_criteria_node_iterator * oc_result_criteria_node)

{

	return oval_collection_iterator_has_more((struct oval_iterator *)

						 oc_result_criteria_node);

}

struct oval_result_criteria_node *oval_result_criteria_node_iterator_next(struct

									  oval_result_criteria_node_iterator

									  *oc_result_criteria_node)

{

	return (struct oval_result_criteria_node *)

	    oval_collection_iterator_next((struct oval_iterator *)

					  oc_result_criteria_node);

}

void oval_result_criteria_node_iterator_free(struct

					     oval_result_criteria_node_iterator

					     *oc_result_criteria_node)

{

	oval_collection_iterator_free((struct oval_iterator *)

				      oc_result_criteria_node);

}

oval_criteria_node_type_t oval_result_criteria_node_get_type(struct oval_result_criteria_node *node)

{

	__attribute__nonnull__(node);

	oval_criteria_node_type_t type = ((struct oval_result_criteria_node *)node)->type;

	return type;

}

static struct oval_result_system *oval_result_criteria_get_system(struct oval_result_criteria_node *node)

{

        __attribute__nonnull__(node);

        return node->sys;

}

oval_result_t oval_result_criteria_node_negate(struct oval_result_criteria_node *node, oval_result_t result)

{

	bool negate = node->negate;

	return (negate && result == OVAL_RESULT_TRUE) ? OVAL_RESULT_FALSE :

	    (negate && result == OVAL_RESULT_FALSE) ? OVAL_RESULT_TRUE : result;

}

static oval_result_t _oval_result_criteria_node_result(struct oval_result_criteria_node *node) {

	__attribute__nonnull__(node);

	oval_result_t result;

	switch (node->type) {

	case OVAL_NODETYPE_CRITERIA:{

			struct oval_result_criteria_node_iterator *subnodes

			    = oval_result_criteria_node_get_subnodes(node);

			oval_operator_t operator = oval_result_criteria_node_get_operator(node);

			struct oresults node_res;

			ores_clear(&node_res);

			while (oval_result_criteria_node_iterator_has_more(subnodes)) {

				struct oval_result_criteria_node *subnode

				    = oval_result_criteria_node_iterator_next(subnodes);

				oval_result_t subres = oval_result_criteria_node_eval(subnode);

				ores_add_res(&node_res, subres);

			}

			oval_result_criteria_node_iterator_free(subnodes);

			result = ores_get_result_byopr(&node_res, operator);

		} break;

	case OVAL_NODETYPE_CRITERION:{

			struct oval_result_test *test = oval_result_criteria_node_get_test(node);

			result = oval_result_test_eval(test);

		} break;

	case OVAL_NODETYPE_EXTENDDEF:{

			struct oval_result_definition *extends = oval_result_criteria_node_get_extends(node);

			const char *def_id = oval_result_definition_get_id(extends);

			dI("Criteria are extended by definition '%s'.", def_id);

			result = oval_result_definition_eval(extends);

		} break;

	default:

		abort ();

		break;

	}

	result = oval_result_criteria_node_negate(node, result);

	return result;

}

oval_result_t oval_result_criteria_node_eval(struct oval_result_criteria_node * node)

{

	__attribute__nonnull__(node);

	if (node->result == OVAL_RESULT_NOT_EVALUATED) {

		node->result = _oval_result_criteria_node_result(node);

	}

	return node->result;

}

oval_result_t oval_result_criteria_node_get_result(struct oval_result_criteria_node * node)

{

	__attribute__nonnull__(node);

	return node->result;

}

bool oval_result_criteria_node_get_negate(struct oval_result_criteria_node * node) {

	__attribute__nonnull__(node);

	return node->negate;

}

bool oval_result_criteria_node_get_applicability_check(struct oval_result_criteria_node * node) {

	__attribute__nonnull__(node);

	return node->applicability_check;

}

oval_operator_t oval_result_criteria_node_get_operator(struct oval_result_criteria_node * node)

{

	/*type==NODETYPE_CRITERIA */

	oval_operator_t operator = OVAL_OPERATOR_UNKNOWN;

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_CRITERIA) {

		operator =((struct oval_result_criteria_node_CRITERIA *)node)->operator;

	}

	return operator;

}

struct oval_result_criteria_node_iterator *oval_result_criteria_node_get_subnodes(struct

										  oval_result_criteria_node

										  *node)

{

	/*type==NODETYPE_CRITERIA */

	struct oval_result_criteria_node_iterator *subnodes = NULL;

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_CRITERIA) {

		struct oval_result_criteria_node_CRITERIA *criteria = (struct oval_result_criteria_node_CRITERIA *)node;

		subnodes = (struct oval_result_criteria_node_iterator *)

		    oval_collection_iterator(criteria->subnodes);

	}

	return subnodes;

}

struct oval_result_test *oval_result_criteria_node_get_test(struct oval_result_criteria_node *node) {

	/*type==NODETYPE_CRITERION */

	struct oval_result_test *test = NULL;

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_CRITERION) {

		test = ((struct oval_result_criteria_node_CRITERION *)node)->test;

	}

	return test;

}

struct oval_result_definition *oval_result_criteria_node_get_extends(struct oval_result_criteria_node *node) {

	/*type==NODETYPE_EXTENDDEF */

	struct oval_result_definition *extends = NULL;

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_EXTENDDEF) {

		extends = ((struct oval_result_criteria_node_EXTENDDEF *)node)->extends;

	}

	return extends;

}

void oval_result_criteria_node_set_result(struct oval_result_criteria_node *node, oval_result_t result)

{

	__attribute__nonnull__(node);

	node->result = result;

}

void oval_result_criteria_node_set_negate(struct oval_result_criteria_node *node, bool negate)

{

	__attribute__nonnull__(node);

	node->negate = negate;

}

void oval_result_criteria_node_set_applicability_check(struct oval_result_criteria_node *node,

						       bool applicability_check)

{

	__attribute__nonnull__(node);

	node->applicability_check = applicability_check;

}

void oval_result_criteria_node_add_subnode(struct oval_result_criteria_node *node, struct oval_result_criteria_node *subnode)

{

	__attribute__nonnull__(node);

       /*type==NODETYPE_CRITERIA */

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_CRITERIA) {

		struct oval_result_criteria_node_CRITERIA *criteria = ((struct oval_result_criteria_node_CRITERIA *)node);

		oval_collection_add(criteria->subnodes, subnode);

	}

}

void oval_result_criteria_node_set_operator(struct oval_result_criteria_node *node, oval_operator_t operator)

{

	__attribute__nonnull__(node);

	/*type==NODETYPE_CRITERIA */

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_CRITERIA) {

		((struct oval_result_criteria_node_CRITERIA *)node)->operator = operator;

	}

}

void oval_result_criteria_node_set_test(struct oval_result_criteria_node *node, struct oval_result_test *test) 

{

	__attribute__nonnull__(node);

	/*type==NODETYPE_CRITERION */

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_CRITERION) {

		((struct oval_result_criteria_node_CRITERION *)node)->test = test;

	}

}

void oval_result_criteria_node_set_extends(struct oval_result_criteria_node *node, struct oval_result_definition *extends) 

{

	__attribute__nonnull__(node);

	/*type==NODETYPE_EXTENDDEF */

	if (oval_result_criteria_node_get_type(node) == OVAL_NODETYPE_EXTENDDEF) {

		((struct oval_result_criteria_node_EXTENDDEF *)node)->extends = extends;

	}

}

static void _oval_result_criteria_consume_subnode(struct oval_result_criteria_node *subnode, struct oval_result_criteria_node *node) {

	oval_result_criteria_node_add_subnode(node, subnode);

}

static int _oval_result_criteria_parse(xmlTextReaderPtr reader, struct oval_parser_context *context, void *usr) {

	struct oval_result_system *sys = oval_result_criteria_get_system(usr);

	return oval_result_criteria_node_parse(reader, context, sys, (oscap_consumer_func) _oval_result_criteria_consume_subnode, usr);

}

int oval_result_criteria_node_parse(xmlTextReaderPtr reader,

				    struct oval_parser_context *context,

				    struct oval_result_system *sys,

				    oscap_consumer_func consumer,

				    void *client)

{

	xmlChar *localName = xmlTextReaderLocalName(reader);

	int rc = 0;

	struct oval_result_criteria_node *node = NULL;

	if (strcmp((const char *)localName, "criteria") == 0) {

		oval_operator_t operator = oval_operator_parse(reader, "operator", OVAL_OPERATOR_UNKNOWN);

		int negate = oval_parser_boolean_attribute(reader, "negate", false);

		int applicability_check = oval_parser_boolean_attribute(reader, "applicability_check", false);

		node = oval_result_criteria_node_new(sys,

						     OVAL_NODETYPE_CRITERIA,

						     negate,

						     applicability_check,

						     operator);

		rc = oval_parser_parse_tag(reader, context, _oval_result_criteria_parse, node);

	} else if (strcmp((const char *)localName, "criterion") == 0) {

		xmlChar *test_ref = xmlTextReaderGetAttribute(reader, BAD_CAST "test_ref");

		int variable_instance = oval_parser_int_attribute(reader, "variable_instance", 1);

		int negate = oval_parser_boolean_attribute(reader, "negate", false);

		int applicability_check = oval_parser_boolean_attribute(reader, "applicability_check", false);

		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);

		struct oval_test *oval_test = oval_definition_model_get_new_test(definition_model, (char *)test_ref);

		struct oval_result_test *rslt_test = oval_result_system_get_new_test(sys, oval_test, variable_instance);

		node = oval_result_criteria_node_new(sys,

						     OVAL_NODETYPE_CRITERION,

						     negate,

						     applicability_check,

						     rslt_test,

						     variable_instance);

		free(test_ref);

	} else if (strcmp((const char *)localName, "extend_definition") == 0) {

		xmlChar *definition_ref = xmlTextReaderGetAttribute(reader, BAD_CAST "definition_ref");

		int variable_instance = oval_parser_int_attribute(reader, "variable_instance", 1);

		int negate = oval_parser_boolean_attribute(reader, "negate", false);

		int applicability_check = oval_parser_boolean_attribute(reader, "applicability_check", false);

		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);

		struct oval_definition *oval_definition = oval_definition_model_get_new_definition(definition_model, (char *)definition_ref);

		struct oval_result_definition *rslt_definition = oval_result_system_get_new_definition(sys, oval_definition, variable_instance);

		node = oval_result_criteria_node_new(sys,

						     OVAL_NODETYPE_EXTENDDEF,

						     negate,

						     applicability_check,

						     rslt_definition,

						     variable_instance);

		free(definition_ref);

	} else {

		dW("unhandled criteria node: <%s>.",(char *)localName);

		oval_parser_skip_tag(reader, context);

	}

	if (node==NULL || rc==-1) {

		dE("Can't parse result criteria node.");

		return 1;

	}

	oval_result_t result = oval_result_parse(reader, "result", 0);

	oval_result_criteria_node_set_result(node, result);

	(*consumer) (node, client);

	free(localName);

	return rc;

}

static xmlNode *_oval_result_CRITERIA_to_dom(struct oval_result_criteria_node *node, xmlDocPtr doc, xmlNode * parent) {

	xmlNs *ns_results = xmlSearchNsByHref(doc, parent, OVAL_RESULTS_NAMESPACE);

	xmlNode *node_root = xmlNewTextChild(parent, ns_results, BAD_CAST "criteria", NULL);

	oval_operator_t operator = oval_result_criteria_node_get_operator(node);

	const char *operator_att = oval_operator_get_text(operator);

	xmlNewProp(node_root, BAD_CAST "operator", BAD_CAST operator_att);

	struct oval_result_criteria_node_iterator *subnodes = oval_result_criteria_node_get_subnodes(node);

	while (oval_result_criteria_node_iterator_has_more(subnodes)) {

		struct oval_result_criteria_node *subnode = oval_result_criteria_node_iterator_next(subnodes);

		oval_result_criteria_node_to_dom(subnode, doc, node_root);

	}

	oval_result_criteria_node_iterator_free(subnodes);

	return node_root;

}

static xmlNode *_oval_result_CRITERION_to_dom(struct oval_result_criteria_node *node, xmlDocPtr doc, xmlNode * parent) {

	xmlNs *ns_results = xmlSearchNsByHref(doc, parent, OVAL_RESULTS_NAMESPACE);

	xmlNode *node_root = xmlNewTextChild(parent, ns_results, BAD_CAST "criterion", NULL);

	struct oval_result_test *rslt_test = oval_result_criteria_node_get_test(node);

	struct oval_test *oval_test = oval_result_test_get_test(rslt_test);

	char *test_ref = oval_test_get_id(oval_test);

	xmlNewProp(node_root, BAD_CAST "test_ref", BAD_CAST test_ref);

	char version[10];

	*version = '\0';

	snprintf(version, sizeof(version), "%d", oval_test_get_version(oval_test));

	xmlNewProp(node_root, BAD_CAST "version", BAD_CAST version);

        int instance = ((struct oval_result_criteria_node_CRITERION *) node)->variable_instance;

        if (instance != 1) {

                char instance_att[10] = "";

                snprintf(instance_att, sizeof (instance_att), "%d", instance);

                xmlNewProp(node_root, BAD_CAST "variable_instance", BAD_CAST instance_att);

        }

	return node_root;

}

static xmlNode *_oval_result_EXTENDDEF_to_dom(struct oval_result_criteria_node *node, xmlDocPtr doc, xmlNode * parent) {

	xmlNs *ns_results = xmlSearchNsByHref(doc, parent, OVAL_RESULTS_NAMESPACE);

	xmlNode *node_root = xmlNewTextChild(parent, ns_results, BAD_CAST "extend_definition", NULL);

	struct oval_result_definition *rslt_definition = oval_result_criteria_node_get_extends(node);

	struct oval_definition *oval_definition = oval_result_definition_get_definition(rslt_definition);

	char *definition_ref = oval_definition_get_id(oval_definition);

	xmlNewProp(node_root, BAD_CAST "definition_ref", BAD_CAST definition_ref);

        int version = oval_definition_get_version(oval_definition);

        char version_att[10] = "";

        snprintf(version_att, sizeof(version_att), "%d", version);

        xmlNewProp(node_root, BAD_CAST "version", BAD_CAST version_att);

        int instance = ((struct oval_result_criteria_node_EXTENDDEF *) node)->variable_instance;

        if (instance != 1) {

                char instance_att[10] = "";

                snprintf(instance_att, sizeof (instance_att), "%d", instance);

                xmlNewProp(node_root, BAD_CAST "variable_instance", BAD_CAST instance_att);

        }

	return node_root;

}

xmlNode *oval_result_criteria_node_to_dom(struct oval_result_criteria_node * node, xmlDocPtr doc, xmlNode * parent) {

	xmlNode *criteria_node = NULL;

	switch (oval_result_criteria_node_get_type(node)) {

	case OVAL_NODETYPE_CRITERIA:

		criteria_node = _oval_result_CRITERIA_to_dom(node, doc, parent);

		break;

	case OVAL_NODETYPE_CRITERION:

		criteria_node = _oval_result_CRITERION_to_dom(node, doc, parent);

		break;

	case OVAL_NODETYPE_EXTENDDEF:

		criteria_node = _oval_result_EXTENDDEF_to_dom(node, doc, parent);

		break;

	default:

		break;

	}

	if (criteria_node) {

		oval_result_t result = oval_result_criteria_node_get_result(node);

		const char *result_att = oval_result_get_text(result);

		xmlNewProp(criteria_node, BAD_CAST "result", BAD_CAST result_att);

		bool negate = oval_result_criteria_node_get_negate(node);

		if (negate != false) {

			xmlNewProp(criteria_node, BAD_CAST "negate", BAD_CAST "true");

		}

		bool applicability_check = oval_result_criteria_node_get_applicability_check(node);

		if (applicability_check != false) {

			xmlNewProp(criteria_node, BAD_CAST "applicability_check", BAD_CAST "true");

		}

	}

	return criteria_node;

}