/*******************************************************************************
* Copyright (C) 2004-2007 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 Liang Hou
*/
#include "u/libu.h"
#include "wsman-faults.h"
#include "wsman-soap.h"
#include "wsman-names.h"
#include "wsman-soap-message.h"
#include "wsman-soap-envelope.h"
#include "wsman-xml-api.h"
#include "wsman-xml.h"
#include "wsman-event-pool.h"
#include "wsman-cimindication-processor.h"
static int isvalidCIMIndicationExport(WsXmlDocH doc){
if(doc == NULL) return 0;
WsXmlNodeH node = ws_xml_get_doc_root(doc);
WsXmlNodeH temp = NULL;
node = ws_xml_get_child(node, 0, NULL, CIMXML_MESSAGE);
temp = ws_xml_get_child(node, 0, NULL, CIMXML_SIMPLEEXPREQ);
if(temp == NULL) {
temp = ws_xml_get_child(node, 0, NULL, CIMXML_MULTIEXPREQ);
if(temp == NULL) return 0;
}
return 1;
}
static void cimxml_build_response_msg(WsXmlDocH indoc, WsXmlDocH *outdoc) {
WsXmlDocH doc = NULL;
WsXmlNodeH outnode = NULL;
WsXmlNodeH innode = NULL;
WsXmlNodeH temp = NULL;
WsXmlNodeH temp2 = NULL;
doc = ws_xml_create_doc(NULL, CIMXML_CIM);
outnode = ws_xml_get_doc_root(doc);
innode = ws_xml_get_doc_root(indoc);
// char *value = ws_xml_get_node_attr(WsXmlNodeH node, int index)
ws_xml_add_node_attr(outnode, NULL, CIMXML_CIMVERSION, "2.0");
ws_xml_add_node_attr(outnode, NULL, CIMXML_DTDVERSION, "2.0");
outnode = ws_xml_add_child(outnode, NULL, CIMXML_MESSAGE, NULL);
innode = ws_xml_get_child(innode, 0, NULL, CIMXML_MESSAGE);
int n = ws_xml_get_node_attr_count(innode);
int i = 0;
while(i < n) {
WsXmlAttrH attr = ws_xml_get_node_attr(innode, i);
char *name = ws_xml_get_attr_name(attr);
char *value = ws_xml_get_attr_value(attr);
ws_xml_add_node_attr(outnode, NULL, name, value);
i++;
}
temp = ws_xml_get_child(innode, 0, NULL, CIMXML_SIMPLEEXPREQ);
if(temp) {
outnode = ws_xml_add_child(outnode, NULL, CIMXML_SIMPLEEXPRSP, NULL);
outnode = ws_xml_add_child(outnode, NULL, CIMXML_EXPMETHODRESPONSE, NULL);
ws_xml_add_node_attr(outnode, NULL, CIMXML_NAME, "ExportIndication");
ws_xml_add_child(outnode, NULL, CIMXML_IRETURNVALUE, NULL);
}
else {
temp = ws_xml_get_child(innode, 0, NULL, CIMXML_MULTIEXPREQ);
outnode = ws_xml_add_child(outnode, NULL, CIMXML_MULTIEXPRSQ, NULL);
n = ws_xml_get_child_count(temp);
i = 0;
while(i < n) {
innode = ws_xml_get_child(temp, i, NULL, CIMXML_SIMPLEEXPREQ);
temp2 = ws_xml_add_child(outnode, NULL, CIMXML_EXPMETHODRESPONSE, NULL);
ws_xml_add_node_attr(temp2, NULL, CIMXML_NAME, "ExportIndication");
ws_xml_add_child(temp2, NULL, CIMXML_IRETURNVALUE, NULL);
i++;
}
}
*outdoc = doc;
}
static
char * get_cim_indication_namespace(WsSubscribeInfo *subsInfo, char *classname) {
hscan_t hs;
hnode_t *hn;
char *sub;
if (strstr(subsInfo->uri, XML_NS_CIM_CLASS) != NULL) {
return u_strdup(subsInfo->uri);
}
hash_t *namespaces = subsInfo->vendor_namespaces;
if (namespaces) {
hash_scan_begin(&hs, namespaces);
while ((hn = hash_scan_next(&hs))) {
debug("namespace=%s", (char *) hnode_get(hn));
if ((sub = strstr(classname, (char *) hnode_getkey(hn)))) {
return u_strdup((char *)hnode_get(hn));
}
}
}
return NULL;
}
static WsNotificationInfoH
create_notification_entity(WsSubscribeInfo *subsInfo, WsXmlNodeH node)
{
char *classname = NULL;
char *class_namespace = NULL;
WsXmlNodeH indicationnode = NULL;
WsNotificationInfoH notificationinfo = NULL;
notificationinfo = u_zalloc(sizeof(*notificationinfo));
if (notificationinfo == NULL) {
return NULL;
}
WsXmlNodeH instance = ws_xml_get_child(node, 0, NULL, CIMXML_EXPMETHODCALL);
if (instance == NULL) {
u_free(notificationinfo);
return NULL;
}
instance = ws_xml_get_child(instance, 0, NULL, CIMXML_EXPPARAMVALUE);
if (instance == NULL) {
u_free(notificationinfo);
return NULL;
}
instance = ws_xml_get_child(instance, 0, NULL, CIMXML_INSTANCE);
if (instance == NULL) {
u_free(notificationinfo);
return NULL;
}
WsXmlAttrH attr = ws_xml_find_node_attr(instance, NULL, CIMXML_CLASSNAME);
if (attr) {
classname = ws_xml_get_attr_value(attr);
class_namespace = get_cim_indication_namespace(subsInfo, classname);
notificationinfo->EventAction = u_strdup_printf("%s/%s", class_namespace, classname);
}
notificationinfo->EventContent = ws_xml_create_doc(notificationinfo->EventAction, classname);
indicationnode = ws_xml_get_doc_root(notificationinfo->EventContent);
//Parse "PROPERTY"
int n = 0;
while ( (node = ws_xml_get_child(instance, n++, NULL, CIMXML_PROPERTY)) ) {
attr = ws_xml_find_node_attr(node, NULL, CIMXML_NAME);
char *property = NULL;
char *value = NULL;
if ( attr ) {
property = ws_xml_get_attr_value(attr);
}
value = ws_xml_get_node_text(node);
ws_xml_add_child(indicationnode, notificationinfo->EventAction, property, value);
}
//Parse "PROPERTY.ARRAY"
n = 0;
while ( (node = ws_xml_get_child(instance, n++, NULL, CIMXML_PROPERTYARRAY)) ) {
attr = ws_xml_find_node_attr(node, NULL, CIMXML_NAME);
char *property = NULL;
if ( attr ) {
property = ws_xml_get_attr_value(attr);
WsXmlNodeH valarraynode = ws_xml_get_child(node, 0, NULL, CIMXML_VALUEARRAY);
if ( valarraynode ) {
int m = 0;
WsXmlNodeH valnode = NULL;
while ( (valnode = ws_xml_get_child(valarraynode, m++, NULL, CIMXML_VALUE)) ) {
char *value = ws_xml_get_node_text(valnode);
ws_xml_add_child(indicationnode, notificationinfo->EventAction, property, value);
}
}
}
}
if (class_namespace)
u_free(class_namespace);
return notificationinfo;
}
static
void create_indication_event(WsXmlDocH indoc, WsSubscribeInfo *subsInfo, EventPoolOpSetH opset) {
int count, i;
int retval;
WsNotificationInfoH notificationinfo = NULL;
WsXmlNodeH node = ws_xml_get_doc_root(indoc);
node = ws_xml_get_child(node, 0, NULL, CIMXML_MESSAGE);
WsXmlNodeH tmp = ws_xml_get_child(node, 0, NULL, CIMXML_MULTIEXPREQ);
if(tmp) {
count = ws_xml_get_child_count(tmp);
i = 0;
while(i < count) {
node = ws_xml_get_child(tmp, i, NULL, CIMXML_SIMPLEEXPREQ);
notificationinfo = create_notification_entity(subsInfo, node);
if(notificationinfo == NULL) {
i++;
continue;
}
if(subsInfo->deliveryMode == WS_EVENT_DELIVERY_MODE_PULL)
retval = opset->addpull(subsInfo->subsId, notificationinfo);
else
retval = opset->add(subsInfo->subsId, notificationinfo);
if(retval) {
u_free(notificationinfo->EventAction);
ws_xml_destroy_doc(notificationinfo->EventContent);
u_free(notificationinfo);
}
i++;
}
}
else {
tmp = ws_xml_get_child(node, 0, NULL, CIMXML_SIMPLEEXPREQ);
notificationinfo = create_notification_entity(subsInfo, tmp);
if(subsInfo->deliveryMode == WS_EVENT_DELIVERY_MODE_PULL)
retval = opset->addpull(subsInfo->subsId, notificationinfo);
else
retval = opset->add(subsInfo->subsId, notificationinfo);
if(retval) {
u_free(notificationinfo->EventAction);
ws_xml_destroy_doc(notificationinfo->EventContent);
u_free(notificationinfo);
}
}
}
CimxmlMessage *cimxml_message_new() {
CimxmlMessage *cimxml_msg = u_zalloc(sizeof(CimxmlMessage));
u_buf_create(&cimxml_msg->request);
u_buf_create(&cimxml_msg->response);
cimxml_msg->status.code = CIMXML_STATUS_OK;
return cimxml_msg;
}
void cimxml_message_destroy(CimxmlMessage *msg) {
u_buf_free(msg->request);
u_buf_free(msg->response);
u_free(msg->charset);
u_free(msg);
}
static
void cimxml_set_fault(CimxmlMessage *message, CIMXMLKnownStatusCode status) {
struct cimxml_code_map {
int code;
char *reason_phrase;
};
struct cimxml_code_map maps[] = {
{CIMXML_STATUS_UNSUPPORTED_PROTOCOL_VERSIOIN, "unsupported-protocol-version"},
{CIMXML_STATUS_MULTIPLE_REQUESTS_UNSUPPORTED, "multiple-requests-unsupported"},
{CIMXML_STATUS_UNSUPPORTED_CIM_VERSION, "unsupported-cim-version"},
{CIMXML_STATUS_UNSUPPORTED_DTD_VERSION, "unsupported-dtd-version"},
{CIMXML_STATUS_REQUEST_NOT_VALID, "request-not-valid"},
{CIMXML_STATUS_REQUEST_NOT_WELL_FORMED, "request-not-well-formed"},
{CIMXML_STATUS_REQUEST_NOT_LOOSELY_VALID, "request-not-loosely-valid"},
{CIMXML_STATUS_HEADER_MISMATCH, "header-mismatch"},
{CIMXML_STATUS_UNSUPPORTED_OPERATION, "unsupported-operatioin"},
{0, NULL}
};
int i = 0;
if(message == NULL) return;
while(maps[i].code) {
if(maps[i].code == status) {
message->status.code = status;
message->status.fault_msg = maps[i].reason_phrase;
break;
}
i++;
}
}
void CIM_Indication_call(cimxml_context *cntx, CimxmlMessage *message, void *opaqueData) {
char *response = NULL;
int len;
WsXmlDocH indicationRequest = NULL;
WsXmlDocH indicationResponse = NULL;
SoapH soap = cntx->soap;
char *uuid = cntx->uuid;
WsContextH soapCntx = ws_get_soap_context(soap);
debug("**********in CIM_Indication_call:: %s", u_buf_ptr(message->request));
indicationRequest = ws_xml_read_memory(u_buf_ptr(message->request), u_buf_len(message->request),
message->charset, 0);
if(indicationRequest == NULL) {
debug("error, request cannot be parsed !");
message->http_code = WSMAN_STATUS_BAD_REQUEST;
cimxml_set_fault(message, CIMXML_STATUS_REQUEST_NOT_VALID);
goto DONE;
}
if(!isvalidCIMIndicationExport(indicationRequest)) {
debug("error, invalid cim indication");
message->http_code = WSMAN_STATUS_FORBIDDEN;
cimxml_set_fault(message, CIMXML_STATUS_UNSUPPORTED_OPERATION);
goto DONE;
}
//to do here: put indication in event pool
WsSubscribeInfo *subsInfo = NULL;
list_t *subslist = soapCntx->subscriptionMemList;
lnode_t *node = list_first(subslist);
while(node) {
subsInfo = (WsSubscribeInfo *)node->list_data;
if(!strcmp(subsInfo->subsId, uuid)) break;
node = list_next(subslist, node);
}
if(node == NULL) {
message->http_code = WSMAN_STATUS_NOT_FOUND;
cimxml_set_fault(message, CIMXML_STATUS_REQUEST_NOT_VALID);
debug("error. uuid:%s not registered!", uuid);
goto DONE;
}
EventPoolOpSetH opset = soap->eventpoolOpSet;
create_indication_event(indicationRequest, subsInfo, opset);
cimxml_build_response_msg(indicationRequest, &indicationResponse);
ws_xml_dump_memory_enc(indicationResponse, &response, &len, "utf-8");
u_buf_construct(message->response, response, len, len);
DONE:
u_free(cntx);
ws_xml_destroy_doc(indicationRequest);
ws_xml_destroy_doc(indicationResponse);
}