/* $Id$
 *
 * Lasso - A free implementation of the Liberty Alliance specifications.
 *
 * Copyright (C) 2004-2007 Entr'ouvert
 * http://lasso.entrouvert.org
 *
 * Authors: See AUTHORS file in top-level directory.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

/**
 * SECTION:data_service
 * @short_description: ID-WSF Data Service profile
 *
 * DataService allows Attribute Consumers (WSC) to request an Attribute Provider (WSP) to get
 * or modify data about users with their consent.
 *
 * Following up on #LassoDiscovery first example, it created a @service object,
 * this is a #LassoDataService instance.  This example continues from that step
 * and retrieves the name of the principal:
 *
 * <informalexample>
 * <programlisting>
 * char *soap_answer;            // SOAP answer from data service
 * xmlNode *principal_name;      // libxml2 xmlNode with the principal name
 *
 * service = lasso_discovery_get_service(discovery);
 * lasso_data_service_init_query(service, "/pp:PP/pp:InformalName", NULL);
 * lasso_data_service_build_request_msg(service);
 *
 * // service must perform SOAP call to LASSO_WSF_PROFILE(service)->msg_url
 * // the SOAP message is LASSO_WSF_PROFILE(service)->msg_body.  The answer
 * // is stored in char* soap_answer;
 *
 * lasso_data_service_process_query_response_msg(service, soap_answer);
 * principal_name = lasso_data_service_get_answer(service, "/pp:PP/pp:InformalName");
 *
 * // app should probably then use xmlNodeGetContent libxml2 function to get
 * // access to node content.
 * </programlisting>
 * </informalexample>
 *
 */

#include "../xml/private.h"
#include "../utils.h"
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>

#include "discovery.h"
#include "data_service.h"
#include "../xml/idwsf_strings.h"
#include "../xml/dst_query.h"
#include "../xml/dst_query_response.h"
#include "../xml/dst_modify.h"
#include "../xml/dst_modify_response.h"
#include "../xml/soap_binding_correlation.h"
#include "../xml/soap-1.1/soap_fault.h"
#include "../xml/is_redirect_request.h"

#include <xmlsec/xmltree.h>
#include <xmlsec/xmldsig.h>
#include <xmlsec/templates.h>
#include <xmlsec/crypto.h>
#include "wsf_profile_private.h"

extern GHashTable *dst_services_by_prefix; /* cf xml/xml.c */

static void lasso_register_idwsf_xpath_namespaces(xmlXPathContext *xpathCtx);
static gint lasso_data_service_process_query_msg(LassoDataService *service,
		LassoDstQuery *query);
static gint lasso_data_service_process_modify_msg(LassoDataService *service,
		LassoDstModify *modify);
static gint lasso_data_service_validate_query_request(LassoDataService *service, xmlNode *data);
static gint lasso_data_service_apply_queries(LassoDataService *service,
		LassoDstQueryResponse *query_response, GList *queries, xmlNode *data);
static gint lasso_data_service_apply_query(LassoDataService *service,
		LassoDstQueryResponse *query_response, xmlXPathContext *xpathCtx,
		LassoDstQueryItem *item);
static gint lasso_data_service_validate_modify_request(LassoDataService *service, xmlNode **data);
static gint lasso_data_service_apply_modifications(LassoDstModify *modify,
		LassoDstModifyResponse *modify_response, GList *modifications,
		xmlNode **resource_data);
static gint lasso_data_service_apply_modification(LassoDstModify *modify,
		LassoDstModification *modification, LassoDstModifyResponse *modify_response,
		xmlNode **resource_data);

struct _LassoDataServicePrivate {
	xmlNode *resource_data;
	LassoDiscoResourceID *ResourceID;
	LassoDiscoResourceID *EncryptedResourceID;
};

/*****************************************************************************/
/* public methods                                                            */
/*****************************************************************************/

/**
 * lasso_data_service_init_query
 * @service: a #LassoDataService
 * @select: resource selection string (typically a XPath query)
 * @item_id: (allow-none): query item identifier (optional)
 * @security_mech_id: (allow-none): a security mechanism id
 *
 * Initializes a new dst:Query request, asking for element @select (with optional itemID set to
 * @item_id).  @item_id may be NULL only if the query won't contain other query items. You must
 * follow this constraint, it will not be checked.
 *
 * If both @select and @item_id are NULL, only a skeleton request is created and calls to
 * lasso_data_service_add_query_item() will need to be done.
 *
 * Return value: 0 on success; or a negative value otherwise.
 **/
gint
lasso_data_service_init_query(LassoDataService *service, const char *select,
	const char *item_id, const char *security_mech_id)
{
	LassoWsfProfile *wsf_profile = NULL;
	LassoDstQuery *query = NULL;
	LassoDiscoResourceOffering *offering = NULL;
	gint rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	wsf_profile = &service->parent;

	/* 1. build the message content */
	if (select) {
		query = lasso_dst_query_new(lasso_dst_query_item_new(select, item_id));
	} else {
		query = lasso_dst_query_new(NULL);
	}
	offering = lasso_wsf_profile_get_resource_offering(wsf_profile);
	if (! LASSO_IS_DISCO_RESOURCE_OFFERING(offering))
		goto cleanup;
	lasso_assign_string(query->hrefServiceType, offering->ServiceInstance->ServiceType);
	lasso_assign_new_string(query->prefixServiceType, lasso_get_prefix_for_dst_service_href(
				query->hrefServiceType));
	goto_cleanup_if_fail_with_rc (query->prefixServiceType != NULL,
			LASSO_DATA_SERVICE_ERROR_UNREGISTERED_DST);
	lasso_wsf_profile_helper_assign_resource_id(query, offering);

	/* 2. build the envelope */
	rc = lasso_wsf_profile_init_soap_request(wsf_profile, &query->parent);
	if (rc)
		goto cleanup;

	/* 3. set the security mechanism */
	rc = lasso_wsf_profile_set_security_mech_id(wsf_profile, security_mech_id);

cleanup:
	lasso_release_gobject(query);
	lasso_release_gobject(offering);
	return rc;
}

/**
 * lasso_data_service_add_query_item:
 * @service: a #LassoDataService
 * @select: resource selection string (typically a XPath query)
 * @item_id: query item identifier
 *
 * Adds a dst:QueryItem to the current dst:Query request. If there are already query item in the
 * request and @itemId is NULL, the call will fail.
 *
 * Return value: 0 if sucessfull, an error code otherwise.
 **/
gint
lasso_data_service_add_query_item(LassoDataService *service,
		const char *select, const char *item_id)
{
	LassoWsfProfile *wsf_profile;
	LassoDstQuery *query = NULL;
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	wsf_profile = &service->parent;

	lasso_return_val_if_invalid_param(DST_QUERY, wsf_profile->request,
			LASSO_PROFILE_ERROR_MISSING_REQUEST);
	query = (LassoDstQuery*)wsf_profile->request;

	/** Check that we can add a new item */
	if (query->QueryItem && (
		(query->QueryItem->data &&
		 (! LASSO_IS_DST_QUERY_ITEM(query->QueryItem->data) ||
		  LASSO_DST_QUERY_ITEM(query->QueryItem->data)->itemID == NULL)) ||
		(item_id == NULL))) {
		return LASSO_DATA_SERVICE_ERROR_CANNOT_ADD_ITEM;
	}

	lasso_list_add_new_gobject(query->QueryItem, lasso_dst_query_item_new(select, item_id));

	return rc;
}

/**
 * lasso_data_service_get_query_item:
 * @service: a #LassoDataService
 * @select: the select string of the query item to found
 * @item_id: the item id of the query item to found
 * @output:(transfer none): a #LassoDstQueryItem handle to store the result object, its reference count is not
 * incremented.
 *
 * Look up the first query item in the current request matching the given criteria, @select or
 * @item_id. At least one of the criteria must be present for the call to succeed.
 *
 * Return value: 0 if successful, an error code otherwise.
 */
gint
lasso_data_service_get_query_item(LassoDataService *service,
		const char *select, const char *item_id, LassoDstQueryItem **output)
{
	LassoDstQuery *query = NULL;
	GList *query_items = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	gint rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	g_return_val_if_fail(select || item_id, LASSO_PARAM_ERROR_BAD_TYPE_OR_NULL_OBJ);
	wsf_profile = &service->parent;
	lasso_extract_node_or_fail(query, wsf_profile->request, DST_QUERY, LASSO_PROFILE_ERROR_MISSING_REQUEST);
	lasso_foreach(query_items, query->QueryItem)
	{
		LassoDstQueryItem *query_item = NULL;
		lasso_extract_node_or_fail(query_item, query_items->data, DST_QUERY_ITEM, LASSO_ERROR_CAST_FAILED);
		if ((select && lasso_strisequal(select,query_item->Select)) ||
			(item_id && lasso_strisequal(item_id,query_item->itemID)))
		{
			if (output) {
				lasso_assign_new_gobject(*output, query_item);
			}
		}
	}

cleanup:
	return rc;
}

/**
 * lasso_data_service_process_query_msg:
 * @service: a #LassoDataService
 * @message: the dst query message
 *
 * Processes a dst:Query message.  Rebuilds a request object from the message
 * and extracts ResourceID.
 *
 * Return value: 0 on success; or a negative value otherwise.
 **/
static gint
lasso_data_service_process_query_msg(LassoDataService *service, LassoDstQuery *query)
{
	LassoWsfProfile *wsf_profile = NULL;
	LassoDstQueryResponse *query_response = NULL;
	gchar *service_type = NULL;
	int rc = 0;

	wsf_profile = &service->parent;

	lasso_assign_string(service_type, query->hrefServiceType);

	lasso_wsf_profile_helper_assign_resource_id(service->private_data, query);
	query_response = lasso_dst_query_response_new(lasso_utility_status_new(LASSO_DST_STATUS_CODE_OK));
	query_response->prefixServiceType = g_strdup(query->prefixServiceType);
	query_response->hrefServiceType = g_strdup(query->hrefServiceType);

	rc = lasso_wsf_profile_init_soap_response(wsf_profile, LASSO_NODE(query_response));
	lasso_release_gobject(query_response);
	return rc;
}


/**
 * lasso_data_service_build_response_msg:
 * @service: a #LassoDataService
 *
 * Builds a dst:QueryResponse message.
 *
 * Return value: 0 on success; or a negative value otherwise.
 **/
gint
lasso_data_service_build_response_msg(LassoDataService *service)
{
	lasso_bad_param(DATA_SERVICE, service);
	return lasso_wsf_profile_build_soap_response_msg(&service->parent);
}

/**
 * lasso_data_service_get_answers:
 * @service: a #LassoDataService object.
 * @output:(transfer full)(allow-none)(element-type xmlNode): an xmlNode** pointer where to put the xmlNode* of the result
 *
 * Get all the xmlNode content of the first Data element of the QueryResponse message.
 *
 * Return value: 0 if sucessful, an error code otherwise.
 */
gint
lasso_data_service_get_answers(LassoDataService *service, GList **output)
{
	LassoDstQueryResponse *query_response = NULL;
	LassoDstData *data = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	GList *datas = NULL;
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	wsf_profile = &service->parent;
	lasso_extract_node_or_fail(query_response, wsf_profile->request, DST_QUERY_RESPONSE,
			LASSO_PROFILE_ERROR_MISSING_REQUEST);

	datas = query_response->Data;

	if (datas) {
		lasso_extract_node_or_fail(data, datas->data, DST_DATA,
				LASSO_ERROR_CAST_FAILED);
	}

	if (data) {
		if (output) {
			GList *data_content = data->any;
			lasso_release_list_of_xml_node(*output);
			for (;data_content; data_content = g_list_next(data_content)) {
				lasso_list_add_xml_node(*output, data_content->data);
			}
		}
	} else {
		rc = LASSO_DST_ERROR_NO_DATA;
	}

cleanup:
	return rc;
}
/**
 * lasso_data_service_get_answer:
 * @service: a #LassoDataService object.
 * @output: (out): an xmlNode** pointer where to put the xmlNode* of the result
 *
 * Get the first xmlNode of the first Data element of the QueryResponse message.
 *
 * Return value: 0 if sucessful, an error code otherwise.
 */
gint
lasso_data_service_get_answer(LassoDataService *service, xmlNode **output)
{
	LassoDstQueryResponse *query_response = NULL;
	LassoDstData *data = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	GList *datas = NULL;
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	wsf_profile = &service->parent;
	lasso_extract_node_or_fail(query_response, wsf_profile->response, DST_QUERY_RESPONSE,
			LASSO_PROFILE_ERROR_MISSING_RESPONSE);

	datas = query_response->Data;

	if (datas) {
		lasso_extract_node_or_fail(data, datas->data, DST_DATA,
				LASSO_ERROR_CAST_FAILED);
	}

	if (data) {
		if (output) {
			xmlNode *first_element = NULL;
			if (data->any) {
				first_element = data->any->data;
			}
			lasso_assign_xml_node(*output, first_element);
		}
	} else {
		rc = LASSO_DST_ERROR_NO_DATA;
	}

cleanup:
	return rc;
}

/**
 * lasso_data_service_get_answers_by_select:
 * @service: a #LassoDataService
 * @select: resource selection string (typically a XPath query)
 * @output: (allow-none) (element-type xmlNode): a GList** to store a GList* containing the result, it must be freed.
 *
 * Returns the answers for the specified @select request.
 *
 * Return value: 0 if successful, an error code otheriwse
 *
 **/
gint
lasso_data_service_get_answers_by_select(LassoDataService *service, const char *select, GList **output)
{
	LassoDstQuery *query = NULL;
	LassoDstQueryResponse *query_response = NULL;
	LassoDstData *data = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	LassoDstQueryItem *query_item = NULL;
	GList *iter = NULL;
	GList *datas = NULL;
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_null_param(select);
	wsf_profile = &service->parent;
	lasso_extract_node_or_fail(query, wsf_profile->request, DST_QUERY,
			LASSO_PROFILE_ERROR_MISSING_REQUEST);
	lasso_extract_node_or_fail(query_response, wsf_profile->response, DST_QUERY_RESPONSE,
			LASSO_PROFILE_ERROR_MISSING_RESPONSE);

	iter = query->QueryItem;
	datas = query_response->Data;

	/* one query, no need for itemID, data is the first one, or absent */
	if (iter && iter->next == NULL) {
		lasso_extract_node_or_fail(query_item, iter->data, DST_QUERY_ITEM,
				LASSO_ERROR_CAST_FAILED);

		if (datas) {
			lasso_extract_node_or_fail(data, datas->data, DST_DATA,
					LASSO_ERROR_CAST_FAILED);
			if (lasso_strisnotequal(select,query_item->Select)) {
				data = NULL;
				rc = LASSO_DST_ERROR_QUERY_NOT_FOUND;
			}
		} else {
			rc = LASSO_DST_ERROR_NO_DATA;
		}
	/* many queries */
	} else {
		/* lookup select in query to get itemId, then get data with itemIdRef */
		while (iter) {
			lasso_extract_node_or_fail(query_item, iter->data, DST_QUERY_ITEM,
					LASSO_ERROR_CAST_FAILED);
			if (lasso_strisequal(query_item->Select,select)) {
				break;
			}
			query_item = NULL;
			iter = g_list_next(iter);
		}
		if (query_item && ! query_item->itemID) {
			goto_cleanup_with_rc(LASSO_DST_ERROR_MALFORMED_QUERY);
		}

		while (datas) {
			lasso_extract_node_or_fail(data, datas->data, DST_DATA,
					LASSO_ERROR_CAST_FAILED);
			if (lasso_strisequal(data->itemIDRef,query_item->itemID)) {
				break;
			}
			data = NULL;
			datas = g_list_next(datas);
		}
	}

	if (data) {
		if (output) {
			GList *data_content = data->any;
			lasso_release_list_of_xml_node(*output);
			for (;data_content; data_content = g_list_next(data_content)) {
				lasso_list_add_xml_node(*output, data_content->data);
			}
		}
	} else {
		rc = LASSO_DST_ERROR_NO_DATA;
	}

cleanup:
	return rc;
}

/**
 * lasso_data_service_get_answers_by_item_id:
 * @service: a #LassoDataService
 * @item_id: query item identifier
 * @output: (allow-none) (element-type xmlNode): a GList** to store a GList* containing the result, it must be freed.
 *
 * Returns the answers for the specified @itemID request.
 *
 * Return value: 0 if successful, an error code otherwise
 *
 **/
gint
lasso_data_service_get_answers_by_item_id(LassoDataService *service, const char *item_id, GList **output)
{
	LassoDstQueryResponse *query_response = NULL;
	LassoDstData *data = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	GList *datas = NULL;
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_null_param(select);
	wsf_profile = &service->parent;
	lasso_extract_node_or_fail(query_response, wsf_profile->request, DST_QUERY_RESPONSE,
			LASSO_PROFILE_ERROR_MISSING_REQUEST);

	datas = query_response->Data;
	while (datas) {
		lasso_extract_node_or_fail(data, datas->data, DST_DATA, LASSO_ERROR_CAST_FAILED);
		if (lasso_strisequal(data->itemIDRef,item_id)) {
			break;
		}
		data = NULL;
		datas = g_list_next(datas);
	}

	if (data) {
		if (output) {
			GList *data_content = data->any;
			lasso_release_list_of_xml_node(*output);
			for (;data_content; data_content = g_list_next(data_content)) {
				lasso_list_add_xml_node(*output, data_content->data);
			}
		}
	} else {
		rc = LASSO_DST_ERROR_NO_DATA;
	}

cleanup:
	return rc;
}

/**
 * lasso_data_service_process_query_response_msg:
 * @service: a #LassoDataService
 * @message: the dst query response message
 *
 * Processes a dst:Query message.  Rebuilds a request object from the message
 * and extracts ResourcedID.
 *
 * Return value: 0 on success; or a negative value otherwise.
 **/
gint
lasso_data_service_process_query_response_msg(LassoDataService *service,
	const char *message)
{
	int rc = 0;

	rc = lasso_wsf_profile_process_soap_response_msg(LASSO_WSF_PROFILE(service), message);
	if (! rc && ! LASSO_IS_DST_QUERY_RESPONSE(service->parent.response)) {
		rc = LASSO_PROFILE_ERROR_MISSING_RESPONSE;
	}

	return rc;
}

/**
 * lasso_data_service_init_modify:
 * @service: a #LassoDataService object
 * @security_mech_id: (allow-none): a security mechanism id
 *
 * Initialize a Data Service Template Modify request using a command to select some data, and an XML
 * fragment to replace the selected data.
 *
 * Return value: 0 if successful, an error code otherwise.
 */
gint
lasso_data_service_init_modify(LassoDataService *service, const char *security_mech_id)
{
	LassoDiscoResourceOffering *offering = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	LassoDstModify *modify = NULL;
	gint rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_null_param(service);
	wsf_profile = &service->parent;

	/* 1. build the message content */
	modify = lasso_dst_modify_new();

	offering = lasso_wsf_profile_get_resource_offering(wsf_profile);
	goto_cleanup_if_fail_with_rc (LASSO_IS_DISCO_RESOURCE_OFFERING(offering), LASSO_PROFILE_ERROR_MISSING_RESOURCE_OFFERING);
	goto_cleanup_if_fail_with_rc (offering->ServiceInstance != NULL &&
			offering->ServiceInstance->ServiceType != NULL,
			LASSO_PROFILE_ERROR_MISSING_SERVICE_TYPE);
	lasso_assign_string(modify->hrefServiceType, offering->ServiceInstance->ServiceType);
	lasso_assign_new_string(modify->prefixServiceType, lasso_get_prefix_for_dst_service_href(
				modify->hrefServiceType));
	goto_cleanup_if_fail_with_rc (modify->prefixServiceType != NULL, LASSO_DATA_SERVICE_ERROR_UNREGISTERED_DST);
	lasso_wsf_profile_helper_assign_resource_id(modify, offering);

	/* 2. build the envelope */
	rc = lasso_wsf_profile_init_soap_request(wsf_profile, &modify->parent);
	if (rc)
		goto cleanup;

	/* 3. set the security mechanism */
	rc = lasso_wsf_profile_set_security_mech_id(wsf_profile, security_mech_id);

cleanup:
	lasso_release_gobject(modify);
	lasso_release_gobject(offering);
	return rc;
}

/**
 * lasso_data_service_add_modification:
 * @service: a #LassoDataService object
 * @select: a selector string
 * @xmlData: (allow-none): optional NewData content
 * @overrideAllowed: (allow-none)(default FALSE):whether to permit delete or replace of existings
 * @notChangedSince: (allow-none): if not NULL, give the time (as a local time_t value) of the last known
 * modification to the datas, it is used to permit secure concurrent accesses.
 * @output: (out): a #LassoDstModification** pointer where to put the #LassoDstModification of the result
 *
 * Add a new modification to the current modify request. If overrideAllowed is FALSE, xmlData must
 * absolutely be present. Refer to the ID-WSF DST 1.0 specification for the semantic of the created
 * message.
 *
 * Return value: 0 if successful and the new modification object in *output, an error code
 * otherwise.
 */
gint
lasso_data_service_add_modification(LassoDataService *service, const gchar *select,
		xmlNode *xmlData, gboolean overrideAllowed, time_t *notChangedSince,
		LassoDstModification **output)
{
	LassoWsfProfile *wsf_profile = NULL;
	LassoDstModification *modification = NULL;
	LassoDstNewData *newData = NULL;
	LassoDstModify *modify = NULL;
	gint rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_null_param(select);

	wsf_profile = &service->parent;
	lasso_extract_node_or_fail(modify, wsf_profile->request, DST_MODIFY,
			LASSO_ERROR_CAST_FAILED);

	modification = lasso_dst_modification_new(select);
	newData = lasso_dst_new_data_new();
	lasso_release_list_of_xml_node(newData->any);
	lasso_list_add_xml_node(newData->any, xmlData);
	lasso_assign_new_gobject(modification->NewData, newData);
	lasso_list_add_new_gobject(modify->Modification,
			modification);
	modification->overrideAllowed = overrideAllowed;
	if (notChangedSince) {
		lasso_assign_new_string(modification->notChangedSince,
				lasso_time_to_iso_8601_gmt(*notChangedSince));
	}

	if (*output) {
		lasso_assign_gobject(*output, modification);
	}

cleanup:
	return rc;
}

static gint
lasso_data_service_apply_modification(LassoDstModify *modify, LassoDstModification *modification, LassoDstModifyResponse *modify_response,
		xmlNode **resource_data)
{
	gint rc = 0;
	xmlXPathObject *xpathObj = NULL;
	gint xpath_error_code = 0;
	char *failure_code = NULL;
	LassoDstNewData *NewData = NULL;
	xmlNode *cur_data = NULL;
	xmlDoc *doc = NULL;
	xmlXPathContext *xpathCtx = NULL;
	GList *node_to_free = NULL;
	gboolean overrideAllowed = modification->overrideAllowed;

	if (LASSO_IS_DST_NEW_DATA(modification->NewData)) {
		NewData = modification->NewData;
	}

	if (! modification->Select) {
		failure_code = LASSO_DST_STATUS_CODE_MISSING_SELECT;
		goto failure;
	}

	if ((! NewData || ! NewData->any) && ! overrideAllowed) {
		failure_code = LASSO_DST_STATUS_CODE_MISSING_NEW_DATA_ELEMENT;
		goto failure;
	}

	lasso_assign_xml_node(cur_data, *resource_data);
	doc = xmlNewDoc((xmlChar*)"1.0");
	xmlDocSetRootElement(doc, cur_data);
	xpathCtx = xmlXPathNewContext(doc);
	lasso_register_idwsf_xpath_namespaces(xpathCtx);

	/* register namespace of the query */
	xmlXPathRegisterNs(xpathCtx, BAD_CAST(modify->prefixServiceType), BAD_CAST(modify->hrefServiceType));
	if (lasso_eval_xpath_expression(xpathCtx, modification->Select, &xpathObj, &xpath_error_code)) {
		if (xpathObj && xpathObj->type == XPATH_NODESET) {
			if (xmlXPathNodeSetIsEmpty(xpathObj->nodesetval) || (xpathObj->nodesetval->nodeNr > 1 && NewData))
			{
				failure_code = "too few or too much targets";
				goto failure;
			}
			if (NewData) {
				xmlNode *target = xpathObj->nodesetval->nodeTab[0];
				GList *new_nodes = NewData->any;

				if (target == cur_data && overrideAllowed){
					if (new_nodes->next) {
						failure_code = "cannot replace root node by multiple nodes";
						goto failure;
					}
					xmlDocSetRootElement(doc,
							xmlCopyNode((xmlNode*)new_nodes->data,
								1));
					lasso_list_add_xml_node(node_to_free, target);
				} else {
					while (new_nodes) {
						xmlNode *new_data = NULL;
						lasso_assign_xml_node(new_data, (xmlNode*)new_nodes->data);
						if (overrideAllowed)
							xmlAddNextSibling(target, new_data);
						else
							xmlAddChild(target, new_data);
						new_nodes = g_list_next(new_nodes);
					}
					if (overrideAllowed) {
						xmlUnlinkNode(target);
						lasso_list_add_xml_node(node_to_free, target);
					}
				}
			} else {
				int i;
				for (i = 0; i < xpathObj->nodesetval->nodeNr; i++) {
					xmlNode *target = xpathObj->nodesetval->nodeTab[i];
					g_assert(overrideAllowed);
					xmlUnlinkNode(target);
					lasso_list_add_xml_node(node_to_free, target);
				}
			}
		} else {
			failure_code = LASSO_DST_STATUS_CODE_INVALID_SELECT;
			goto failure;
		}

	}
	lasso_assign_xml_node(*resource_data, xmlDocGetRootElement(doc));
	goto cleanup;

failure:
		lasso_wsf_profile_helper_set_status(modify_response, LASSO_DST_STATUS_CODE_FAILED);
		lasso_wsf_profile_helper_set_status(modify_response->Status, failure_code);
		rc = LASSO_DST_ERROR_MODIFY_FAILED;

cleanup:
	lasso_release_xpath_object(xpathObj);
	lasso_release_xpath_context(xpathCtx);
	g_list_foreach(node_to_free, (GFunc)xmlFreeNode, NULL);
	lasso_release_doc(doc);
	lasso_release_list(node_to_free);
	return rc;
}

static gint
lasso_data_service_apply_modifications(LassoDstModify *modify,
		LassoDstModifyResponse *modify_response, GList *modifications,
		xmlNode **resource_data)
{
	gint rc = 0;

	/* 1. check modifications */
	if (modifications && modifications->next) {
		lasso_foreach_full_begin(LassoDstModification*, modification, i, modifications)
		{
			if (! LASSO_IS_DST_MODIFICATION(modification) ||
					! modification->id)
			{
				lasso_wsf_profile_helper_set_status(modify_response,
						LASSO_DST_STATUS_CODE_FAILED);
				lasso_wsf_profile_helper_set_status(modify_response->Status,
						"id expected");
				goto_cleanup_with_rc(LASSO_DST_ERROR_QUERY_FAILED);
			}
		}
		lasso_foreach_full_end()
	}
	/* 2. setup workbench */

	lasso_foreach_full_begin(LassoDstModification*, modification, i, modifications)
	{
		rc = lasso_data_service_apply_modification(modify, modification, modify_response,
				resource_data);
		// First error, stop
		if (rc) {
			goto cleanup;
		}
	}
	lasso_foreach_full_end()
cleanup:
	return rc;
}

/* Internal implementation for processing query request messages */
static gint
lasso_data_service_validate_query_request(LassoDataService *service, xmlNode *data)
{
	LassoWsfProfile *wsf_profile = &service->parent;
	LassoDstQuery *query = NULL;
	LassoDstQueryResponse *query_response = NULL;
	gint rc = 0;

	/* already checked by lasso_data_service_validate_request */
	query = (LassoDstQuery*)wsf_profile->request;
	lasso_extract_node_or_fail(query_response, wsf_profile->response, DST_QUERY_RESPONSE, LASSO_PROFILE_ERROR_MISSING_RESPONSE);

	rc = lasso_data_service_apply_queries(service, query_response, query->QueryItem, data);

cleanup:
	return rc;
}

/* Internal implementation for processing modify request messages */
static gint
lasso_data_service_validate_modify_request(LassoDataService *service, xmlNode **data)
{
	LassoWsfProfile *wsf_profile = &service->parent;
	LassoDstModify *modify = NULL;
	LassoDstModifyResponse *modify_response = NULL;
	gint rc = 0;

	/* already checked in lasso_data_service_validate_request */
	modify = (LassoDstModify*)wsf_profile->request;
	lasso_extract_node_or_fail(modify_response, service->parent.response, DST_MODIFY_RESPONSE,
			LASSO_PROFILE_ERROR_MISSING_RESPONSE);

	rc = lasso_data_service_apply_modifications(modify, modify_response, modify->Modification, data);

cleanup:
	return rc;
}

gint
lasso_data_service_validate_request(LassoDataService *service)
{
	LassoWsfProfile *wsf_profile = NULL;
	xmlNode *resource_data = NULL;
	gint rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	wsf_profile = &service->parent;
	g_return_val_if_fail(service->private_data, LASSO_PARAM_ERROR_NON_INITIALIZED_OBJECT);
	resource_data = service->private_data->resource_data;
	if (! resource_data) {
		rc = LASSO_DST_ERROR_MISSING_SERVICE_DATA;
		goto cleanup;
	}

	if (! LASSO_IS_NODE(wsf_profile->request)) {
		rc = LASSO_PROFILE_ERROR_INVALID_REQUEST;
		goto cleanup;
	} else {
		if (LASSO_IS_DST_QUERY(wsf_profile->request)) {
			rc = lasso_data_service_validate_query_request(service, service->private_data->resource_data);
		} else if (LASSO_IS_DST_MODIFY(wsf_profile->request)) {
			rc = lasso_data_service_validate_modify_request(service, &service->private_data->resource_data);
		} else {
			rc = LASSO_PROFILE_ERROR_INVALID_REQUEST;
			goto cleanup;
		}
	}

cleanup:
	return rc;
}

gint
lasso_data_service_build_modify_response_msg(LassoDataService *service)
{
	return lasso_data_service_build_response_msg(service);
}

gint
lasso_data_service_build_query_response_msg(LassoDataService *service)
{
	return lasso_data_service_build_response_msg(service);
}

/**
 * lasso_data_service_process_modify_msg:
 * @service: a #LassoDataService object
 * @modify_soap_msg: the SOAP request string
 * @security_mech_id: the security mechanism to apply
 *
 * Parse the given request message, and initialize needed structures.
 *
 * Return value: 0 if successful, an error code otherwise.
 */
static gint
lasso_data_service_process_modify_msg(LassoDataService *service, LassoDstModify *modify)
{
	LassoDstModifyResponse *modify_response = NULL;
	LassoWsfProfile *wsf_profile = NULL;
	int rc = 0;

	wsf_profile = &service->parent;

	lasso_wsf_profile_helper_assign_resource_id(service->private_data, modify);
	modify_response = lasso_dst_modify_response_new(lasso_utility_status_new(LASSO_DST_STATUS_CODE_OK));
	lasso_assign_string(modify_response->prefixServiceType, modify->prefixServiceType);
	lasso_assign_string(modify_response->hrefServiceType, modify->hrefServiceType);
	rc = lasso_wsf_profile_init_soap_response(wsf_profile, LASSO_NODE(modify_response));
	lasso_release_gobject(modify_response);
	return rc;
}

/**
 * lasso_data_service_process_modify_response_msg
 * @service: a #LassoDataService
 * @soap_msg: the SOAP message
 *
 * Process a modify response message.
 *
 * Return value: 0 on success; or a negative value otherwise.
 **/
gint
lasso_data_service_process_modify_response_msg(LassoDataService *service, const gchar *soap_msg)
{
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_null_param(soap_msg);

	rc = lasso_wsf_profile_process_soap_response_msg(&service->parent, soap_msg);

	if ( rc == 0 && ! LASSO_IS_DST_MODIFY_RESPONSE(service->parent.response)) {
		rc = LASSO_PROFILE_ERROR_MISSING_RESPONSE;
	}

	return rc;
}


/*****************************************************************************/
/* private methods                                                           */
/*****************************************************************************/

static LassoNodeClass *parent_class = NULL;

static void
register_xpath_namespace(gchar *prefix, gchar *href, xmlXPathContext *xpathCtx)
{
	xmlXPathRegisterNs(xpathCtx, (xmlChar*)prefix, (xmlChar*)href);
}

static void
lasso_register_idwsf_xpath_namespaces(xmlXPathContext *xpathCtx)
{
	xmlXPathRegisterNs(xpathCtx, (xmlChar*)LASSO_PP10_PREFIX,
			(xmlChar*)LASSO_PP10_HREF);
	xmlXPathRegisterNs(xpathCtx, (xmlChar*)LASSO_EP_PREFIX,
			(xmlChar*)LASSO_EP_HREF);
	if (dst_services_by_prefix == NULL)
		return;
	g_hash_table_foreach(dst_services_by_prefix,
			(GHFunc)register_xpath_namespace, xpathCtx);
}

static gint
lasso_data_service_apply_query(LassoDataService *service, LassoDstQueryResponse *query_response, xmlXPathContext *xpathCtx, LassoDstQueryItem *item)
{
	gint rc = 0;
	xmlXPathObject *xpathObj = NULL;
	gint xpath_error_code = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_bad_param(DST_QUERY_RESPONSE, query_response);
	lasso_bad_param(DST_QUERY_ITEM, item);

	if (! item->Select) {
		lasso_wsf_profile_helper_set_status(query_response, LASSO_DST_STATUS_CODE_FAILED);
		lasso_wsf_profile_helper_set_status(query_response->Status, LASSO_DST_STATUS_CODE_MISSING_SELECT);
		goto_cleanup_with_rc(LASSO_DST_ERROR_QUERY_FAILED);
	}

	if (lasso_eval_xpath_expression(xpathCtx, item->Select, &xpathObj, &xpath_error_code)) {
		LassoDstData *data = NULL;

		/* Found zero or more node answers */
		if (xpathObj && xpathObj->type == XPATH_NODESET){
			int i = 0;

			if (xpathObj->nodesetval && xpathObj->nodesetval->nodeNr) {
				data = lasso_dst_data_new();
			}

			for (i = 0; xpathObj->nodesetval && i < xpathObj->nodesetval->nodeNr;
					i++) {
				lasso_list_add_xml_node(data->any,
						xpathObj->nodesetval->nodeTab[i]);
			}
		/* Found other kind of answers, convert to string */
		} else  {
			xmlChar *str;

			data = lasso_dst_data_new();
			str = xmlXPathCastToString(xpathObj);
			lasso_list_add_xml_node(data->any, xmlNewText(str));
			lasso_release_xml_string(str);
		}
		if (data) {
			lasso_assign_string(data->itemIDRef, item->itemID);
			lasso_list_add_gobject(query_response->Data, data);
		}
		lasso_release_gobject(data);
	} else {
		char *code = g_strdup_printf("LIBXML_XPATH_ERROR_%d", xpath_error_code);

		lasso_wsf_profile_helper_set_status(query_response, LASSO_DST_STATUS_CODE_FAILED);
		lasso_wsf_profile_helper_set_status(query_response->Status, LASSO_DST_STATUS_CODE_INVALID_SELECT);
		lasso_wsf_profile_helper_set_status(query_response->Status->Status, code);
		lasso_release_string(code);
		goto_cleanup_with_rc(1);
	}

cleanup:
	lasso_release_xpath_object(xpathObj);
	return rc;
}

static gint
lasso_data_service_apply_queries(LassoDataService *service, LassoDstQueryResponse *query_response, GList *queries, xmlNode *data)
{
	gint rc = 0;
	LassoWsfProfile *wsf_profile = NULL;
	xmlDoc *doc = NULL;
	xmlXPathContext *xpathCtx = NULL;
	GList *query = NULL;

	lasso_bad_param(DATA_SERVICE, service);
	g_return_val_if_fail(service->private_data, LASSO_PARAM_ERROR_NON_INITIALIZED_OBJECT);
	wsf_profile = &service->parent;

	/* 1. Check query */
	if (queries && queries->next) {
		GList *q = queries;
		while (q) {
			if (! LASSO_IS_DST_QUERY_ITEM(q->data) || !
					LASSO_DST_QUERY_ITEM(q->data)->itemID) {
				lasso_wsf_profile_helper_set_status(query_response,
						LASSO_DST_STATUS_CODE_FAILED);
				lasso_wsf_profile_helper_set_status(query_response->Status,
						"itemID expected");
				goto_cleanup_with_rc(LASSO_DST_ERROR_QUERY_FAILED);
			}
			q = g_list_next(q);
		}
	}

	/* 1. Setup workbench */
	doc = xmlNewDoc((xmlChar*)"1.0");
	xmlDocSetRootElement(doc, data);
	xpathCtx = xmlXPathNewContext(doc);
	lasso_register_idwsf_xpath_namespaces(xpathCtx);

	lasso_foreach (query, queries) {
		LassoDstQueryItem *item = query->data;

		goto_cleanup_if_fail_with_rc(lasso_data_service_apply_query(service, query_response,
					xpathCtx, item) == 0, query_response->Data ?
				LASSO_DST_ERROR_QUERY_PARTIALLY_FAILED :
				LASSO_DST_ERROR_QUERY_FAILED);
	}

cleanup:
	xmlUnlinkNode(service->private_data->resource_data);
	xmlSetTreeDoc(service->private_data->resource_data, NULL);
	lasso_release_xpath_context(xpathCtx);
	lasso_release_doc(doc);

	return rc;
}

/**
 * lasso_data_service_process_request_msg:
 * @service: a #LassoDataService object
 * @message: a C string containing the SOAP request
 * @security_mech_id:(allow-none): a C string describing the required security mechanism or NULL
 *
 * Return value: 0 if successfull, an error code otherwise.
 */
gint
lasso_data_service_process_request_msg(LassoDataService *service,
		const char *message, const char *security_mech_id)
{
	LassoWsfProfile *wsf_profile = NULL;
	LassoNode *request = NULL;
	int rc = 0;

	lasso_bad_param(DATA_SERVICE, service);
	lasso_null_param(message);
	wsf_profile = &service->parent;

	rc = lasso_wsf_profile_process_soap_request_msg(wsf_profile, message, security_mech_id);
	goto_cleanup_if_fail(! rc);
	request = wsf_profile->request;
	if (LASSO_IS_DST_QUERY(request)) {
		rc = lasso_data_service_process_query_msg(service, (LassoDstQuery*)request);
	} else if (LASSO_IS_DST_MODIFY(wsf_profile->request)) {
		rc = lasso_data_service_process_modify_msg(service, (LassoDstModify*)request);
	} else {
		rc = LASSO_PROFILE_ERROR_INVALID_REQUEST;
	}
cleanup:
	return rc;
}

/*****************************************************************************/
/* overrided parent class methods */
/*****************************************************************************/

static void
dispose(GObject *object)
{
	LassoDataService *service = LASSO_DATA_SERVICE(object);

	lasso_release_xml_node(service->private_data->resource_data);
	lasso_release_gobject(service->private_data->ResourceID);
	lasso_release_gobject(service->private_data->EncryptedResourceID);

	G_OBJECT_CLASS(parent_class)->dispose(object);
}

static void
finalize(GObject *object)
{
	lasso_release(((LassoDataService*)object)->private_data);

	G_OBJECT_CLASS(parent_class)->finalize(object);
}


/*****************************************************************************/
/* instance and class init functions                                         */
/*****************************************************************************/

static void
instance_init(LassoDataService *service)
{
	service->private_data = g_new0(LassoDataServicePrivate, 1);
}

static void
class_init(LassoDataServiceClass *klass)
{
	parent_class = g_type_class_peek_parent(klass);

	G_OBJECT_CLASS(klass)->dispose = dispose;
	G_OBJECT_CLASS(klass)->finalize = finalize;
}

GType
lasso_data_service_get_type()
{
	static GType this_type = 0;

	if (!this_type) {
		static const GTypeInfo this_info = {
			sizeof(LassoDataServiceClass),
			NULL,
			NULL,
			(GClassInitFunc) class_init,
			NULL,
			NULL,
			sizeof(LassoDataService),
			0,
			(GInstanceInitFunc) instance_init,
			NULL
		};

		this_type = g_type_register_static(LASSO_TYPE_WSF_PROFILE,
				"LassoDataService", &this_info, 0);
	}
	return this_type;
}


/**
 * lasso_data_service_new:
 * @server: the #LassoServer
 *
 * Creates a new #LassoDataService.
 *
 * Return value: a newly created #LassoDataService object; or NULL if an
 *      error occured.
 **/
LassoDataService*
lasso_data_service_new(LassoServer *server)
{
	LassoDataService *service;

	g_return_val_if_fail(LASSO_IS_SERVER(server), NULL);

	service = g_object_new(LASSO_TYPE_DATA_SERVICE, NULL);
	LASSO_WSF_PROFILE(service)->server = g_object_ref(server);

	return service;
}

/**
 * lasso_data_service_new_full:
 * @server: the #LassoServer
 * @offering: the #LassoDiscoResourceOffering
 *
 * Creates a new #LassoDataService.
 *
 * Return value: a newly created #LassoDataService object; or NULL if an error occured.
 **/
LassoDataService*
lasso_data_service_new_full(LassoServer *server, LassoDiscoResourceOffering *offering)
{
	LassoDataService *service = lasso_data_service_new(server);

	g_return_val_if_fail(LASSO_IS_DISCO_RESOURCE_OFFERING(offering), NULL);

	if (service == NULL) {
		return NULL;
	}

	lasso_wsf_profile_set_resource_offering(&service->parent, offering);

	return service;
}

/**
 * lasso_data_service_set_resource_data:
 * @service: a #LassoDataService object
 * @resource_data: (allow-none): an xmlnode representing the resource data of the service
 *
 * Set the resource data content.
 */
void
lasso_data_service_set_resource_data(LassoDataService *service, const xmlNode *resource_data)
{
	lasso_assign_xml_node(service->private_data->resource_data, (xmlNode*)resource_data);
}


/**
 * lasso_data_service_get_resource_data:
 * @service: a #LassoDataService object
 *
 * Return the XML resrouce data in this data service.
 *
 * Return value:(transfer full)(allow-none): a newly allocated #xmlNode or NULL.
 */
xmlNode *
lasso_data_service_get_resource_data(LassoDataService *service)
{
	xmlNode *rv = NULL;

	lasso_assign_xml_node(rv, service->private_data->resource_data);

	return rv;
}