/*******************************************************************************
 * Copyright (C) 2004-2006 Intel Corp. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  - Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *  - Neither the name of Intel Corp. nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

/**
 * @author Anas Nashif
 * @author Liang Hou
 * Contributions from:
 * @author Sumeet Kukreja, Dell Inc.
 */

#ifdef HAVE_CONFIG_H
#include "wsman_config.h"
#endif

#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "ctype.h"

#include "u/libu.h"


#include "wsman-xml-api.h"
#include "wsman-soap.h"
#include "wsman-xml.h"
#include "wsman-client-api.h"
#include "wsman-xml-serializer.h"

#include "wsman-soap-envelope.h"
#include "wsman-soap-message.h"
#include "sfcc-interface.h"
#include "cim_data.h"


static void
CimResource_destroy(CimClientInfo *cimclient)
{
	if (!cimclient)
		return;
	if (cimclient->resource_uri)
		u_free(cimclient->resource_uri);
	if (cimclient->method)
		u_free(cimclient->method);
	if (cimclient->requested_class)
		u_free(cimclient->requested_class);
	if (cimclient->method_args) {
		/* NOTE: clean up is performed with call to wsman_free_method_hnode() and hash_free() */
		hash_free(cimclient->method_args);
	}
	if (cimclient->selectors) {
		hash_free(cimclient->selectors);
		debug("selectors destroyed");
	}
	if (cimclient->username)
		u_free(cimclient->username);
	if (cimclient->password)
		u_free(cimclient->password);
	cim_release_client(cimclient);
	u_free(cimclient);
	debug("cimclient destroyed");
	return;
}


static CimClientInfo*
CimResource_Init(WsContextH cntx, char *username, char *password)
{
	char *_tmp = NULL;
	char *resource_uri = NULL;
	char *show_extensions;
	char *exclude_nil_properties;
	CimClientInfo *cimclient= (CimClientInfo *)u_zalloc(sizeof(CimClientInfo));
	if(!cimclient){
		return NULL;
	}
	WsmanStatus status;

	wsman_status_init(&status);
	resource_uri = wsman_get_resource_uri(cntx, NULL);
	debug ("username: %s, password: %s", username, (password)?"XXXXX":"Not Set" );

	debug("Connecting using sfcc %s frontend", get_cim_client_frontend());

	cimclient->cc = (void *)cim_connect_to_cimom(get_cim_host(),
			get_cim_port(), username, password , get_cim_client_frontend(), &status);

	if (!cimclient->cc) {
		CimResource_destroy(cimclient);
		u_free(status.fault_msg);
		return NULL;
	}

	cimclient->cntx = cntx;
	cimclient->namespaces = get_vendor_namespaces();
	cimclient->selectors = wsman_get_selector_list(cntx, NULL);

	cimclient->requested_class = wsman_get_class_name(cntx);

	cimclient->method = wsman_get_method_name(cntx);
	if(username) {
		cimclient->username = u_strdup(username);
	}
	if(password) {
		cimclient->password = u_strdup(password);
	}

	if (cimclient->selectors) {
		_tmp = cim_get_namespace_selector(cimclient->selectors);
	}
	if (_tmp) {
		cimclient->cim_namespace = _tmp;
	} else {
		cimclient->cim_namespace = get_cim_namespace();
	}
	if(resource_uri) {
		cimclient->resource_uri = u_strdup(resource_uri);
		cimclient->method_args = wsman_get_method_args(cntx, resource_uri );
	}
	show_extensions = wsman_get_option_set(cntx, NULL, WSMB_SHOW_EXTENSION );

	if (show_extensions && strcmp(show_extensions, "true") == 0) {
		cimclient->flags |= FLAG_CIM_EXTENSIONS;
	}
	
	exclude_nil_properties = wsman_get_option_set(cntx, NULL, WSMB_EXCLUDE_NIL_PROPS);
	if (exclude_nil_properties && strcmp(exclude_nil_properties, "true") == 0) {
		cimclient->flags |= FLAG_CIM_SCHEMA_OPT;
	}
	if (get_omit_schema_optional() == 1) {
		cimclient->flags |= FLAG_CIM_SCHEMA_OPT;
	}

	u_free(show_extensions);
	u_free(status.fault_msg);
	return cimclient;
}

static int
verify_class_namespace(CimClientInfo *client)
{
	hscan_t hs;
	hnode_t *hn;
	int rv = 0;
	if(!client){
		return 0;
	}
	if (client->resource_uri && (strcmp( client->resource_uri, CIM_ALL_AVAILABLE_CLASSES ) ==0) ) {
		return 1;
	}
        if ( client->resource_uri && (strstr( client->resource_uri, XML_NS_CIM_INTRINSIC ) != NULL )) {
	        return 1;
	}
  
        /* Ok if class schema is CIM, uri starts with XML_NS_CIM_CLASS
         * and method is not 'Create' (CIM_ is abstract, cannot be created)
         */
	if (client->requested_class && client->resource_uri && client->method
            && (strncmp(client->requested_class, "CIM_", 4) == 0 )
	    && (strstr(client->resource_uri , XML_NS_CIM_CLASS) == client->resource_uri )
	    && (strcmp(client->method, TRANSFER_CREATE) != 0)) {
		return 1;
	}

	if (client->requested_class && client->namespaces && client->resource_uri) {
		hash_scan_begin(&hs, client->namespaces);
		while ((hn = hash_scan_next(&hs))) {
			if ( ( strstr(client->requested_class,
							(char*) hnode_getkey(hn)) != NULL) &&
					(strstr(client->resource_uri ,
						(char*) hnode_get(hn) ) != NULL) ) {
				rv = 1;
				break;
			}
		}
	}
	return rv;
}


int
CimResource_Delete_EP( SoapOpH op,
		void* appData,
		void *opaqueData )
{
	WsmanStatus status;
	CimClientInfo *cimclient = NULL;
	SoapH soap = soap_get_op_soap(op);
	WsmanMessage *msg = wsman_get_msg_from_op(op);
	WsXmlDocH in_doc = NULL;
	WsXmlDocH doc = NULL;
	WsContextH cntx;
	debug( "Delete Endpoint Called");
	wsman_status_init(&status);

	in_doc = soap_get_op_doc(op, 1);
	cntx = ws_create_ep_context(soap, in_doc);

	if (!msg) {
		status.fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status.fault_detail_code=0;
		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			msg->auth_data.username,
			msg->auth_data.password );
	if (!cimclient) {
		status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status.fault_detail_code = 0;
		goto cleanup;
	}

	if (!verify_class_namespace(cimclient) ) {
		status.fault_code = WSA_DESTINATION_UNREACHABLE;
		status.fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
	} else if ( (doc = wsman_create_response_envelope( in_doc, NULL)) ) {
		if (strstr(cimclient->resource_uri , XML_NS_CIM_CLASS ) != NULL) {
			cim_delete_instance_from_enum(cimclient, &status);
		} else {
			debug("no base class, getting instance directly with getInstance");
			cim_delete_instance(cimclient, &status);
		}
	}
cleanup:
	if (wsman_check_status(&status) != 0) {
		ws_xml_destroy_doc(doc);
		doc = wsman_generate_fault( soap_get_op_doc(op, 1),
				status.fault_code, status.fault_detail_code, status.fault_msg);
	}
	if (doc) {
		soap_set_op_doc(op, doc, 0);
	} else {
		error("Invalid doc");
	}

	CimResource_destroy(cimclient);
	ws_destroy_context(cntx);
	u_free(status.fault_msg);
	return 0;
}

int
CimResource_Get_EP( SoapOpH op,
		void* appData,
		void *opaqueData )
{
	WsXmlDocH doc = NULL;
	WsmanStatus status;
	CimClientInfo *cimclient = NULL;
	char *fragstr = NULL;
	WsmanMessage *msg = wsman_get_msg_from_op(op);
	SoapH soap = soap_get_op_soap(op);

	WsXmlDocH in_doc = soap_get_op_doc(op, 1);
	WsContextH cntx = ws_create_ep_context(soap, in_doc);

	wsman_status_init(&status);
	if (!msg) {
		status.fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status.fault_detail_code=0;
		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			msg->auth_data.username,
			msg->auth_data.password );
	if (!cimclient) {
		status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status.fault_detail_code = 0;
		goto cleanup;
	}
	if (!verify_class_namespace(cimclient) ) {
		status.fault_code = WSA_DESTINATION_UNREACHABLE;
		status.fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
	} else {
		if ( (doc = wsman_create_response_envelope( in_doc, NULL)) ) {
			WsXmlNodeH body = ws_xml_get_soap_body(doc);
			fragstr = wsman_get_fragment_string(cntx, in_doc);
			if(fragstr)
				body = ws_xml_add_child(body, XML_NS_WS_MAN, WSM_XML_FRAGMENT,
				NULL);
			if (strstr(cimclient->resource_uri , XML_NS_CIM_CLASS ) != NULL) {
				cim_get_instance_from_enum(cimclient, cntx, body, fragstr, &status);
			} else {
				debug("no base class, getting instance directly with getInstance");
				cim_get_instance(cimclient, cntx, body, fragstr, &status);
			}
		}
	}
cleanup:
	if (wsman_check_status(&status) != 0) {
		ws_xml_destroy_doc(doc);
		doc = wsman_generate_fault( soap_get_op_doc(op, 1),
				status.fault_code, status.fault_detail_code, status.fault_msg);
	}
	if ( doc ) {
		soap_set_op_doc(op, doc, 0);
	} else {
		debug( "Invalid doc" );
	}

	CimResource_destroy(cimclient);
	ws_destroy_context(cntx);
	u_free(status.fault_msg);
	return 0;
}

int
CimResource_Custom_EP( SoapOpH op,
		void* appData,
		void *opaqueData )
{
	debug( "Custom Method Endpoint Called");
	WsXmlDocH doc = NULL, in_doc = NULL;
	CimClientInfo *cimclient = NULL;
	WsmanStatus status;
	WsmanMessage *msg = NULL;
	char *action;
	WsContextH cntx;

	wsman_status_init(&status);
	in_doc = soap_get_op_doc(op, 1);
	cntx = ws_create_ep_context(soap_get_op_soap(op), in_doc);

	msg = wsman_get_msg_from_op(op);
	action = wsman_get_action(cntx, in_doc );
	if (!msg) {
		status.fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status.fault_detail_code=0;
		goto cleanup;
	}
	cimclient = CimResource_Init(cntx, msg->auth_data.username,
			msg->auth_data.password);
	if (!cimclient) {
		status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status.fault_detail_code = 0;
		goto cleanup;
	}
	if (action && cimclient->resource_uri &&
			!strstr(action, cimclient->resource_uri)) {
		status.fault_code = WSA_ACTION_NOT_SUPPORTED;
		status.fault_detail_code = OWSMAN_NO_DETAILS;
		debug("action not supported");
		goto cleanup;
	}
	if (!verify_class_namespace(cimclient) ) {
		status.fault_code = WSA_DESTINATION_UNREACHABLE;
		status.fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
	} else {

		if ((doc = wsman_create_response_envelope( in_doc, NULL))) {
			WsXmlNodeH body = ws_xml_get_soap_body(doc);
			cim_invoke_method(cimclient, cntx, body, &status);
		}
	}

cleanup:
	if (wsman_check_status(&status) != 0) {
		ws_xml_destroy_doc(doc);
		doc = wsman_generate_fault( in_doc,
				status.fault_code, status.fault_detail_code, status.fault_msg);
	}
	if (doc) {
		soap_set_op_doc(op, doc, 0);
	} else {
		error("Invalid doc");
	}

	ws_destroy_context(cntx);
	CimResource_destroy(cimclient);
	u_free(status.fault_msg);
	return 0;
}


int
CimResource_Enumerate_EP( WsContextH cntx,
		WsEnumerateInfo* enumInfo,
		WsmanStatus *status,
		void *opaqueData)
{
	debug("CIM Enumeration");
	WsXmlDocH doc;
	int retval = 0;

	CimClientInfo *cimclient = NULL;

	if (!enumInfo) {
		status->fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status->fault_detail_code = 0;
		retval = 1;
		goto cleanup;
	}

	cimclient = CimResource_Init(cntx,
			enumInfo->auth_data.username,
			enumInfo->auth_data.password );
	if (!cimclient) {
		status->fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status->fault_detail_code = 0;
		retval = 1;
		goto cleanup;
	}

	if (!verify_class_namespace(cimclient)) {
		error("resource uri namespace mismatch");
		status->fault_code = WSA_DESTINATION_UNREACHABLE;
		status->fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
		retval = 1;
		goto cleanup;
	}

	if (!wsman_parse_enum_request(cntx, enumInfo, status)) {
          retval = 1;
          goto cleanup;
        }
	cim_enum_instances(cimclient, enumInfo, status);

	if (status && status->fault_code != 0) {
		retval = 1;
		goto cleanup;
	}
	if (enumInfo->flags & WSMAN_ENUMINFO_OPT) {
		doc = wsman_create_response_envelope( cntx->indoc , NULL);
		WsXmlNodeH node = ws_xml_add_child(ws_xml_get_soap_body(doc),
				XML_NS_ENUMERATION, WSENUM_ENUMERATE_RESP , NULL);
		cim_get_enum_items(cimclient, cntx, node,
				enumInfo, XML_NS_WS_MAN, enumInfo->maxItems,
				enumInfo->maxsize);
		int index2 = enumInfo->index + 1;
		if (enumInfo->totalItems == 0 ||index2 == enumInfo->totalItems)  {
			cim_release_enum_context(enumInfo);
			CimResource_destroy(cimclient);
			return retval;
		}
	}
cleanup:
	/* the cimclient is stored inside the enumInfo and kept in-memory
	 * during the Pull_EP requests until the final Release_EP call.
	 * 
	 * Only destroy it here in case of error
	 * 
	 */
	if (retval && cimclient) {
		CimResource_destroy(cimclient);
	}
	else if(cimclient && cimclient->selectors) {
		hash_free(cimclient->selectors);
		cimclient->selectors = NULL;
		debug("selectors destroyed");
	}
	return retval;
}


int
CimResource_Release_EP( WsContextH cntx,
		WsEnumerateInfo* enumInfo,
		WsmanStatus *status,
		void *opaqueData)
{
	debug( "Release Endpoint Called");
	if(enumInfo->flags & WSMAN_ENUMINFO_CIM_CONTEXT_CLEANUP)
		return 0;
	CimClientInfo * cimclient = cim_getclient_from_enum_context(enumInfo);
	cim_release_enum_context(enumInfo);
	if (cimclient) {
		CimResource_destroy(cimclient);
	}
	return 0;
}


int
CimResource_Pull_EP( WsContextH cntx,
		WsEnumerateInfo* enumInfo,
		WsmanStatus *status,
		void *opaqueData)
{

	WsXmlDocH doc = NULL;
	CimClientInfo *cimclient = NULL;
	WsXmlNodeH body, pullnode;
	int maxelements;
	unsigned long maxsize;
	debug( "Pull Endpoint Called");

	if (!enumInfo) {
		status->fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status->fault_detail_code=0;
		doc = wsman_generate_fault( cntx->indoc, status->fault_code,
			status->fault_detail_code, NULL);
		goto cleanup;
	}

	cimclient = cim_getclient_from_enum_context(enumInfo);
	if (!cimclient) {
		status->fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status->fault_detail_code = 0;
		doc = wsman_generate_fault( cntx->indoc, status->fault_code,
			status->fault_detail_code, NULL);
		goto cleanup;
	}
	cimclient->cntx = cntx;

	if (!verify_class_namespace(cimclient) ) {
		status->fault_code = WSA_DESTINATION_UNREACHABLE;
		status->fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
		doc = wsman_generate_fault( cntx->indoc, status->fault_code,
				status->fault_detail_code, NULL);
		goto cleanup;
	}

	doc = wsman_create_response_envelope( cntx->indoc, NULL);
	body = ws_xml_get_soap_body(doc);
	pullnode = ws_xml_add_child(body, XML_NS_ENUMERATION,
			WSENUM_PULL_RESP, NULL);

	maxelements= wsman_get_max_elements(cntx, NULL);
	maxsize = wsman_get_max_envelope_size(cntx, NULL);
	if(maxsize == 0) {
		body = ws_xml_get_soap_body(cntx->indoc);
		body = ws_xml_get_child(body, 0, XML_NS_ENUMERATION, WSENUM_PULL);
		maxsize = ws_deserialize_uint32(NULL, body,
					     0, XML_NS_ENUMERATION,
					     WSENUM_MAX_CHARACTERS);
	}
	cim_get_enum_items(cimclient, cntx, pullnode,
			enumInfo, XML_NS_ENUMERATION,  maxelements, maxsize);

cleanup:
	if ( enumInfo->totalItems == 0 ||
		( enumInfo->index + 1 ) == enumInfo->totalItems) {
		cim_release_enum_context(enumInfo);
		if (cimclient) {
			CimResource_destroy(cimclient);
		}
		enumInfo->flags |= WSMAN_ENUMINFO_CIM_CONTEXT_CLEANUP;
	}

	ws_destroy_context(cntx);
	return 0;
}

int
CimResource_Create_EP( SoapOpH op,
		void* appData,
		void *opaqueData )
{

	WsXmlDocH doc = NULL;
	CimClientInfo *cimclient = NULL;
	WsmanStatus status;
	char *fragstr = NULL;

	SoapH soap = soap_get_op_soap(op);
	WsContextH cntx = ws_create_ep_context(soap, soap_get_op_doc(op, 1));
	WsmanMessage *msg = wsman_get_msg_from_op(op);
	debug( "Create Endpoint Called");
	wsman_status_init(&status);

	if (!msg) {
		status.fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status.fault_detail_code=0;
		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			msg->auth_data.username, msg->auth_data.password );
	if (!cimclient) {
		status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status.fault_detail_code = 0;
		goto cleanup;
	}
	if (!verify_class_namespace(cimclient) ) {
		status.fault_code = WSA_DESTINATION_UNREACHABLE;
		status.fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
		goto cleanup;
	}

	if ((doc = wsman_create_response_envelope( soap_get_op_doc(op, 1), NULL))) {
		WsXmlNodeH body = ws_xml_get_soap_body(doc);
		WsXmlNodeH in_body = ws_xml_get_soap_body(soap_get_op_doc(op, 1));
		if (!ws_xml_get_child(in_body, 0, NULL, NULL)) {
			status.fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
			status.fault_detail_code = 0;
		} else {
			char *xsd = u_strdup_printf("%s.xsd", cimclient->resource_uri);
			fragstr = wsman_get_fragment_string(cntx, cntx->indoc);
			if(fragstr) {
				if(ws_xml_get_child(in_body, 0, XML_NS_WS_MAN, WSM_XML_FRAGMENT))
					cim_create_instance(cimclient, cntx, in_body, body, fragstr, &status);
			}
			else {
				if (ws_xml_get_child(in_body, 0, cimclient->resource_uri, cimclient->requested_class)) {
					cim_create_instance(cimclient, cntx , in_body, body, NULL, &status);
				} else if (ws_xml_get_child(in_body, 0, xsd, cimclient->requested_class)) {
					cim_create_instance(cimclient, cntx , in_body, body, NULL, &status);
				} else {
					status.fault_code = WXF_INVALID_REPRESENTATION;
					status.fault_detail_code = WSMAN_DETAIL_INVALID_NAMESPACE;
				}
			}
			u_free(xsd);
		}
	}

cleanup:
	if (wsman_check_status(&status) != 0) {
		ws_xml_destroy_doc(doc);
		doc = wsman_generate_fault( soap_get_op_doc(op, 1),
				status.fault_code, status.fault_detail_code, status.fault_msg);
	}

	if ( doc ) {
		soap_set_op_doc(op, doc, 0);
	} else {
		debug( "Invalid doc" );
	}

	CimResource_destroy(cimclient);
	ws_destroy_context(cntx);
	u_free(status.fault_msg);
	return 0;
}


int
CimResource_Put_EP( SoapOpH op,
		void* appData,
		void *opaqueData )
{
	debug( "Put Endpoint Called");
	WsXmlDocH doc = NULL;
	CimClientInfo *cimclient = NULL;
	WsmanStatus status;
	WsmanMessage *msg;
	char *fragstr;

	SoapH soap = soap_get_op_soap(op);
	WsContextH cntx = ws_create_ep_context(soap, soap_get_op_doc(op, 1));
	WsXmlDocH indoc = soap_get_op_doc(op, 1);

	wsman_status_init(&status);
	msg = wsman_get_msg_from_op(op);

	if (!msg) {
		status.fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status.fault_detail_code=0;
		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			msg->auth_data.username, msg->auth_data.password );
	if (!cimclient) {
		status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status.fault_detail_code = 0;
		goto cleanup;
	}

	if (!verify_class_namespace(cimclient) ) {
		status.fault_code = WSA_DESTINATION_UNREACHABLE;
		status.fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
	}

	if ((doc = wsman_create_response_envelope( indoc, NULL))) {
		WsXmlNodeH body = ws_xml_get_soap_body(doc);
		WsXmlNodeH in_body = ws_xml_get_soap_body(indoc);
		fragstr = wsman_get_fragment_string(cntx, indoc);
		if(fragstr)
			body = ws_xml_add_child(body, XML_NS_WS_MAN, WSM_XML_FRAGMENT,
			NULL);
		if (ws_xml_get_child(in_body, 0, NULL, NULL)) {
			cim_put_instance(cimclient, cntx , in_body, body, fragstr, &status);
		} else {
			status.fault_code = WXF_INVALID_REPRESENTATION;
			status.fault_detail_code = WSMAN_DETAIL_MISSING_VALUES;
		}
	}

cleanup:
	if (wsman_check_status(&status) != 0) {
		ws_xml_destroy_doc(doc);
		doc = wsman_generate_fault( indoc,
				status.fault_code, status.fault_detail_code, status.fault_msg);
	}

	if ( doc ) {
		soap_set_op_doc(op, doc, 0);
	} else {
		debug( "Invalid doc" );
	}

	CimResource_destroy(cimclient);
	ws_destroy_context(cntx);
	u_free(status.fault_msg);
	return 0;
}
#ifdef ENABLE_EVENTING_SUPPORT
int
CimResource_EventPoll_EP(WsEventThreadContextH cntx)
{
	int retval = 0;
	return retval;
}

int
CimResource_Subscribe_EP(WsContextH cntx,
		WsSubscribeInfo* subsInfo,
		WsmanStatus *status,
		void *opaqueData)
{
	debug("CIM Subscription");
	int retval = 0;
	CimClientInfo *cimclient = NULL;
	CMPIInstance *instance = NULL;
	CMPIObjectPath *indicationfilter = NULL;
	CMPIObjectPath *indicationhandler = NULL;
	CMPIObjectPath *indicationsubscription = NULL;
	if (!subsInfo) {
		status->fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status->fault_detail_code=0;
		retval = 1;
		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			subsInfo->auth_data.username,
			subsInfo->auth_data.password );
	if (!cimclient) {
		status->fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status->fault_detail_code = 0;
		retval = 1;
		goto cleanup;
	}

	if (!verify_class_namespace(cimclient)) {
		error("resource uri namespace mismatch");
		status->fault_code = WSA_DESTINATION_UNREACHABLE;
		status->fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
		retval = 1;
		goto cleanup;
	}
// to do here: create indication filter here and something else necessary
	subsInfo->eventpoll= CimResource_EventPoll_EP;
	subsInfo->cancel = CimResource_SubscriptionCancel_EP;
	subsInfo->vendor_namespaces = cimclient->namespaces;
	subsInfo->cim_namespace = u_strdup(cimclient->cim_namespace);
	if(subsInfo->flags & WSMAN_SUBSCRIPTION_SELECTORSET) { //Subscribe to an Indication filter instance
		indicationfilter = cim_get_indicationfilter_objectpath_from_selectors(cimclient, cntx, status);
		if(indicationfilter)
			subsInfo->existingfilterOP = CMClone(indicationfilter, NULL);
		else {
			status->fault_code = WSA_DESTINATION_UNREACHABLE;
			status->fault_detail_code = WSMAN_DETAIL_INVALID_RESOURCEURI;
		}

		debug("subscribe to an existing filter");
	}
	else {
		indicationfilter = cim_create_indication_filter(cimclient, subsInfo, status);
	}
	if(status->fault_code ) {
		retval = 1;
		goto cleanup;
	}

	indicationhandler = cim_create_indication_handler(cimclient, subsInfo, status);
	if(status->fault_code) {
		retval = 1;
		goto cleanup;
	}
	cim_create_indication_subscription(cimclient, subsInfo,
		indicationfilter, indicationhandler, status);
	if(status->fault_code)
		retval = 1;
cleanup:
	if(instance)
		CMRelease(instance);
	if(indicationfilter)
		CMRelease(indicationfilter);
	if(indicationhandler)
		CMRelease(indicationhandler);
	if(indicationsubscription)
		CMRelease(indicationsubscription);
	CimResource_destroy(cimclient);
	return retval;
}

int CimResource_Renew_EP(WsContextH cntx,
		WsSubscribeInfo* subsInfo,
		WsmanStatus *status,
		void *opaqueData)
{
	debug("CIM Renew");
	int retval = 0;
	CimClientInfo *cimclient = NULL;
	if (!subsInfo) {
		status->fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status->fault_detail_code=0;
		retval = 1;
 		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			subsInfo->auth_data.username,
			subsInfo->auth_data.password );
	if (!cimclient) {
		status->fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status->fault_detail_code = 0;
		retval = 1;
		goto cleanup;
	}
	cim_update_indication_subscription(cimclient, subsInfo, status);
	if(status->fault_code)
		retval = 1;
	CimResource_destroy(cimclient);
cleanup:
	return retval;
}

int CimResource_UnSubscribe_EP(WsContextH cntx,
		WsSubscribeInfo* subsInfo,
		WsmanStatus *status,
		void *opaqueData)
{
	debug("CIM UnSubscribe");
	int retval = 0;
	CimClientInfo *cimclient = NULL;
	if (!subsInfo) {
		status->fault_code = WSMAN_SCHEMA_VALIDATION_ERROR;
		status->fault_detail_code=0;
		retval = 1;
 		goto cleanup;
	}
	cimclient = CimResource_Init(cntx,
			subsInfo->auth_data.username,
			subsInfo->auth_data.password );
	if (!cimclient) {
		status->fault_code = WSA_ENDPOINT_UNAVAILABLE;
		status->fault_detail_code = 0;
		retval = 1;
 		goto cleanup;
	}
	cim_delete_indication_subscription(cimclient, subsInfo, status);
	if(status->fault_code)
		retval = 1;
	CimResource_destroy(cimclient);
cleanup:
	return retval;
}

int CimResource_SubscriptionCancel_EP(WsEventThreadContextH cntx)
{
	WsmanStatus status;
	return CimResource_UnSubscribe_EP(cntx->soap->cntx, cntx->subsInfo, &status, NULL);
}
#endif