char *
wsman_get_option_set(WsContextH cntx, WsXmlDocH doc,
const char *op)
{
char *optval = NULL;
int index = 0;
WsXmlNodeH node, option;
if (doc == NULL) {
doc = cntx->indoc;
if (!doc)
return NULL;
}
node = ws_xml_get_soap_header(doc);
if (node && (node = ws_xml_get_child(node, 0,
XML_NS_WS_MAN, WSM_OPTION_SET))) {
while ((option = ws_xml_get_child(node, index++, XML_NS_WS_MAN,
WSM_OPTION))) {
char *attrVal = ws_xml_find_attr_value(option, NULL,
WSM_NAME);
if (attrVal && strcmp(attrVal, op ) == 0 ) {
optval = ws_xml_get_node_text(option);
if (optval[0] == 0)
optval = "true";
optval = u_strdup(optval);
debug("Option: %s=%s", attrVal, optval);
break;
}
}
}
return optval;
}
int
outbound_addressing_filter(SoapOpH opHandle, void *data, void *opaqueData)
{
WsXmlDocH in_doc = soap_get_op_doc(opHandle, 1);
WsXmlDocH out_doc = soap_get_op_doc(opHandle, 0);
WsXmlNodeH outHeaders = wsman_get_soap_header_element(out_doc, NULL, NULL);
if (!outHeaders) {
return 0;
}
if (ws_xml_get_child(outHeaders, 0, XML_NS_ADDRESSING, WSA_MESSAGE_ID) == NULL &&
!wsman_is_identify_request(in_doc)) {
char uuidBuf[100];
generate_uuid(uuidBuf, sizeof(uuidBuf), 0);
ws_xml_add_child(outHeaders, XML_NS_ADDRESSING, WSA_MESSAGE_ID, uuidBuf);
debug("Adding message id: %s", uuidBuf);
}
if (in_doc != NULL) {
WsXmlNodeH inMsgIdNode;
inMsgIdNode = wsman_get_soap_header_element(in_doc,XML_NS_ADDRESSING,
WSA_MESSAGE_ID);
if (inMsgIdNode != NULL &&
!ws_xml_get_child(outHeaders, 0, XML_NS_ADDRESSING, WSA_RELATES_TO)) {
ws_xml_add_child(outHeaders, XML_NS_ADDRESSING, WSA_RELATES_TO,
ws_xml_get_node_text(inMsgIdNode));
}
}
return 0;
}
int wsman_get_max_elements(WsContextH cntx, WsXmlDocH doc)
{
int max_elements = 1;
if (doc == NULL)
doc = cntx->indoc;
if (doc) {
WsXmlNodeH node = ws_xml_get_soap_body(doc);
if (node && (node = ws_xml_get_child(node, 0, XML_NS_ENUMERATION,
WSENUM_PULL))) {
node = ws_xml_get_child(node, 0, XML_NS_WS_MAN,
WSENUM_MAX_ELEMENTS);
if (node) {
char *text = ws_xml_get_node_text(node);
if (text != NULL)
max_elements = atoi(text);
}
}
} else {
return 0;
}
return max_elements;
}
static void accept_events_call(WsmanMessage *wsman_msg,char* ip_addr)
{
char *buf = NULL;
char *messageid;
int len;
WsXmlDocH ackdoc = NULL;
WsXmlDocH in_doc = wsman_build_inbound_envelope(wsman_msg);
WsXmlNodeH header = ws_xml_get_soap_header(in_doc);
WsXmlNodeH acknode = ws_xml_get_child(header, 0, XML_NS_WS_MAN, WSM_ACKREQUESTED);
if(acknode) {
ackdoc = ws_xml_create_envelope();
messageid = ws_xml_get_node_text(ws_xml_get_child(header, 0, XML_NS_ADDRESSING, WSA_MESSAGE_ID));
header = ws_xml_get_soap_header(ackdoc);
ws_xml_add_child(header, XML_NS_ADDRESSING, WSA_TO, WSA_TO_ANONYMOUS);
ws_xml_add_child(header, XML_NS_ADDRESSING, WSA_RELATES_TO, messageid);
ws_xml_add_child(header, XML_NS_ADDRESSING, WSA_ACTION, WSMAN_ACTION_ACK);
ws_xml_dump_memory_enc(ackdoc, &buf, &len, wsman_msg->charset);
u_buf_set(wsman_msg->response, buf, len);
ws_xml_destroy_doc(ackdoc);
u_free(buf);
}
if(listener->eventf)
listener->eventf(in_doc, listener->data,ip_addr);
ws_xml_destroy_doc(in_doc);
}
static int print_events(WsXmlDocH indoc, void *data)
{
FILE *f = stdout;
const char *filename = output_file;
struct tm *tm;
time_t now;
char timestr[128];
char *log_msg;
time(&now);
tm = localtime(&now);
// strftime(timestr, 128, "%b %e %T", tm);
if (filename) {
f = fopen(filename, "a+");
if (f == NULL) {
error("Could not open file for writing");
return -1;
}
}
if(f == stdout)
log_msg = u_strdup_printf("\t\t\033[22;32mAt %s received:\033[m \n\n",timestr);
else
log_msg = u_strdup_printf("At %s received:\n\n", timestr);
//fprintf(f, "%s", log_msg);
// ws_xml_dump_node_tree(f, ws_xml_get_doc_root(indoc));
{
WsXmlNodeH node;
WsXmlNodeH class_node;
char* class_name;
int child_count;
int i;
node = ws_xml_get_soap_body (indoc);
class_node = ws_xml_get_child (node, 0, NULL, NULL);
class_name = ws_xml_get_node_local_name (class_node);
printf ("\n%s\n", class_name);
child_count = ws_xml_get_child_count (class_node);
for (i = 0; i < child_count; i++)
{
WsXmlNodeH child_node;
WsXmlAttrH attr;
char* node_name;
child_node = ws_xml_get_child (class_node, i, NULL, NULL);
attr = ws_xml_get_node_attr (child_node, 0);
node_name = ws_xml_get_attr_value (attr);
printf ("%-25s - %s\n", ws_xml_get_node_local_name (child_node), ws_xml_get_node_text (child_node));
}
}
fflush(f);
if (f != stdout) {
fclose(f);
}
u_free(log_msg);
return 0;
}
char *
wsman_get_selector(WsContextH cntx,
WsXmlDocH doc, const char *name, int index)
{
char *val = NULL;
if (doc == NULL)
doc = cntx->indoc;
if (doc) {
WsXmlNodeH header = ws_xml_get_soap_header(doc);
WsXmlNodeH node = ws_xml_get_child(header, index, XML_NS_WS_MAN,
WSM_SELECTOR_SET);
if (node) {
WsXmlNodeH selector;
int index = 0;
while ((selector = ws_xml_get_child(node, index++,
XML_NS_WS_MAN, WSM_SELECTOR))) {
char *attrVal = ws_xml_find_attr_value(selector,
XML_NS_WS_MAN,
WSM_NAME);
if (attrVal == NULL)
attrVal = ws_xml_find_attr_value(selector, NULL, WSM_NAME);
if (attrVal && !strcmp(attrVal, name)) {
val = ws_xml_get_node_text(selector);
break;
}
}
}
}
debug("Selector value for %s: %s", name, val);
return val;
}
/**
* Change Endpoint Reference from request to response format
* @param dstHeader Destination header
* @param epr The Endpoint Reference
*/
static void
wsman_epr_from_request_to_response(WsXmlNodeH dstHeader, WsXmlNodeH epr)
{
int i;
WsXmlNodeH child;
WsXmlNodeH node = !epr ? NULL : ws_xml_get_child(epr, 0,
XML_NS_ADDRESSING,
WSA_ADDRESS);
ws_xml_add_child(dstHeader, XML_NS_ADDRESSING, WSA_TO,
!node ? WSA_TO_ANONYMOUS :
ws_xml_get_node_text(node));
if (!epr)
goto cleanup;
if ((node = ws_xml_get_child(epr, 0, XML_NS_ADDRESSING,
WSA_REFERENCE_PROPERTIES))) {
for (i = 0; (child = ws_xml_get_child(node, i, NULL, NULL)) != NULL; i++) {
ws_xml_duplicate_tree(dstHeader, child);
}
}
if ((node = ws_xml_get_child(epr, 0, XML_NS_ADDRESSING,
WSA_REFERENCE_PARAMETERS))) {
for (i = 0; (child = ws_xml_get_child(node, i, NULL, NULL)) != NULL; i++) {
ws_xml_duplicate_tree(dstHeader, child);
}
}
cleanup:
return;
}
unsigned long ws_xml_get_node_ulong(WsXmlNodeH node)
{
unsigned long val = 0;
char *text = ws_xml_get_node_text(node);
if (text)
val = atoi(text);
return val;
}
/**
* Create a response SOAP envelope
* @param rqstDoc The XML document of the request
* @param action the Response action
* @return Response envelope
*/
WsXmlDocH
wsman_create_response_envelope(WsXmlDocH rqstDoc, const char *action)
{
WsXmlDocH doc = ws_xml_create_envelope();
WsXmlNodeH dstHeader, srcHeader, srcNode;
if (wsman_is_identify_request(rqstDoc))
return doc;
if (!doc)
return NULL;
dstHeader = ws_xml_get_soap_header(doc);
srcHeader = ws_xml_get_soap_header(rqstDoc);
srcNode = ws_xml_get_child(srcHeader, 0, XML_NS_ADDRESSING,
WSA_REPLY_TO);
wsman_epr_from_request_to_response(dstHeader, srcNode);
if (action != NULL) {
ws_xml_add_child(dstHeader, XML_NS_ADDRESSING, WSA_ACTION,
action);
} else {
if ((srcNode = ws_xml_get_child(srcHeader, 0, XML_NS_ADDRESSING,
WSA_ACTION)) != NULL) {
if ((action = ws_xml_get_node_text(srcNode)) != NULL) {
size_t len = strlen(action) + sizeof(WSFW_RESPONSE_STR) + 2;
char *tmp = (char *) u_malloc(sizeof(char) * len);
if (tmp && action) {
sprintf(tmp, "%s%s", action, WSFW_RESPONSE_STR);
ws_xml_add_child(dstHeader, XML_NS_ADDRESSING,
WSA_ACTION, tmp);
u_free(tmp);
}
}
}
}
if ((srcNode = ws_xml_get_child(srcHeader, 0, XML_NS_ADDRESSING,
WSA_MESSAGE_ID)) != NULL) {
ws_xml_add_child(dstHeader, XML_NS_ADDRESSING, WSA_RELATES_TO,
ws_xml_get_node_text(srcNode));
}
return doc;
}
/**
* Get SOAP header value
* @param fw SOAP Framework handle
* @param doc XML document
* @param nsUri Namespace URI
* @param name Header element name
* @return Header value
*/
char *wsman_get_soap_header_value( WsXmlDocH doc, const char *nsUri, const char *name)
{
char *retVal = NULL;
WsXmlNodeH node = wsman_get_soap_header_element( doc, nsUri, name);
if (node != NULL)
retVal = u_str_clone(ws_xml_get_node_text(node));
return retVal;
}
hash_t *
wsman_get_selectors_from_epr(WsContextH cntx, WsXmlNodeH epr_node)
{
WsXmlNodeH selector, node, epr;
selector_entry *sentry;
int index = 0;
hash_t *h = hash_create2(HASHCOUNT_T_MAX, 0, 0);
node = ws_xml_get_child(epr_node, 0, XML_NS_WS_MAN,
WSM_SELECTOR_SET);
if (!node) {
debug("no SelectorSet defined");
hash_destroy(h);
return NULL;
}
while ((selector =
ws_xml_get_child(node, index++, XML_NS_WS_MAN, WSM_SELECTOR))) {
char *attrVal =
ws_xml_find_attr_value(selector, XML_NS_WS_MAN,
WSM_NAME);
if (attrVal == NULL)
attrVal = ws_xml_find_attr_value(selector, NULL,
WSM_NAME);
if (attrVal && !hash_lookup(h, attrVal)) {
sentry = u_malloc(sizeof(*sentry));
epr = ws_xml_get_child(selector, 0, XML_NS_ADDRESSING,
WSA_EPR);
if (epr) {
debug("epr: %s", attrVal);
sentry->type = 1;
sentry->entry.eprp = epr_deserialize(selector, XML_NS_ADDRESSING,
WSA_EPR, 1);
if (!hash_alloc_insert(h, attrVal, sentry)) {
error("hash_alloc_insert failed");
}
} else {
debug("text: %s", attrVal);
sentry->type = 0;
sentry->entry.text = ws_xml_get_node_text(selector);
if (!hash_alloc_insert(h, attrVal,
sentry)) {
error("hash_alloc_insert failed");
}
}
}
}
if (!hash_isempty(h))
return h;
hash_destroy(h);
return NULL;
}
static int validate_control_headers(op_t * op)
{
unsigned long size = 0;
time_t duration;
WsXmlNodeH header, child, maxsize;
char *mu = NULL;
header = wsman_get_soap_header_element( op->in_doc, NULL, NULL);
maxsize = ws_xml_get_child(header, 0, XML_NS_WS_MAN,
WSM_MAX_ENVELOPE_SIZE);
mu = ws_xml_find_attr_value(maxsize, XML_NS_SOAP_1_2,
SOAP_MUST_UNDERSTAND);
if (mu != NULL && strcmp(mu, "true") == 0) {
size = ws_deserialize_uint32(NULL, header,
0, XML_NS_WS_MAN,
WSM_MAX_ENVELOPE_SIZE);
if (size < WSMAN_MINIMAL_ENVELOPE_SIZE_REQUEST) {
generate_op_fault(op, WSMAN_ENCODING_LIMIT,
WSMAN_DETAIL_MINIMUM_ENVELOPE_LIMIT);
return 0;
}
op->maxsize = size;
}
child = ws_xml_get_child(header, 0,
XML_NS_WS_MAN, WSM_OPERATION_TIMEOUT);
if (child != NULL) {
char *text = ws_xml_get_node_text(child);
char *nsUri = ws_xml_get_node_name_ns(header);
if (text == NULL ||
ws_deserialize_duration(text, &duration)) {
generate_op_fault(op,
WSA_INVALID_MESSAGE_INFORMATION_HEADER,
WSMAN_DETAIL_OPERATION_TIMEOUT);
return 0;
}
if (duration <= 0) {
generate_op_fault(op, WSMAN_TIMED_OUT, 0);
return 0;
}
op->expires = duration;
// Not supported now
if (ws_xml_find_attr_bool
(child, nsUri, SOAP_MUST_UNDERSTAND)) {
generate_op_fault(op,
WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_OPERATION_TIMEOUT);
return 0;
}
}
return 1;
}
char *wsman_get_action(WsContextH cntx, WsXmlDocH doc)
{
char *val = NULL;
if (doc == NULL) {
doc = cntx->indoc;
}
if (doc) {
WsXmlNodeH header = ws_xml_get_soap_header(doc);
WsXmlNodeH node = ws_xml_get_child(header, 0, XML_NS_ADDRESSING,
WSA_ACTION);
val = (!node) ? NULL : ws_xml_get_node_text(node);
}
return val;
}
static int is_existing_filter_epr(WsXmlNodeH node, filter_t **f)
{
char *uri;
WsXmlNodeH xmlnode = ws_xml_get_child(node, 0, XML_NS_WS_MAN, WSM_RESOURCE_URI);
if(xmlnode == NULL)
return -1;
uri = ws_xml_get_node_text(xmlnode);
if(strcmp(uri, CIM_ALL_AVAILABLE_CLASSES) == 0)
return -1;
xmlnode = ws_xml_get_child(node, 0, XML_NS_WS_MAN, WSM_SELECTOR_SET);
if(xmlnode == NULL)
return -1;
*f = u_zalloc(sizeof(filter_t));
return 0;
}
int wsman_is_event_related_request(WsXmlDocH doc)
{
WsXmlNodeH node = ws_xml_get_soap_header(doc);
char *action = NULL;
node = ws_xml_get_child(node, 0, XML_NS_ADDRESSING, WSA_ACTION);
action = ws_xml_get_node_text(node);
if (!action)
return 0;
if(strcmp(action, EVT_ACTION_UNSUBSCRIBE) ==0 || strcmp(action, EVT_ACTION_RENEW) ==0
|| strcmp(action, EVT_ACTION_PULL) == 0)
return 1;
else
return 0;
}
static int check_for_duplicate_selectors(op_t * op)
{
WsXmlNodeH header, node, selector;
int retval = 0, index = 0;
hash_t *h;
header = wsman_get_soap_header_element( op->in_doc, NULL, NULL);
if ((node = ws_xml_get_child(header, 0, XML_NS_WS_MAN,
WSM_SELECTOR_SET)) == NULL) {
// No selectors
return 0;
}
h = hash_create(HASHCOUNT_T_MAX, 0, 0);
if (h == NULL) {
generate_op_fault(op, WSMAN_INTERNAL_ERROR,
OWSMAN_NO_DETAILS);
error("could not create hash");
return 1;
}
while ((selector = ws_xml_get_child(node, index++, XML_NS_WS_MAN,
WSM_SELECTOR))) {
char *attrVal = ws_xml_find_attr_value(selector, NULL,
WSM_NAME);
if (!attrVal)
continue;
if (hash_lookup(h, attrVal)) {
generate_op_fault(op, WSMAN_INVALID_SELECTORS,
WSMAN_DETAIL_DUPLICATE_SELECTORS);
debug("Selector %s duplicated", attrVal);
retval = 1;
break;
}
if (!hash_alloc_insert(h, attrVal,
ws_xml_get_node_text(selector))) {
generate_op_fault(op, WSMAN_INTERNAL_ERROR,
OWSMAN_NO_DETAILS);
retval = 1;
error("hash_alloc_insert failed");
break;
}
}
hash_free_nodes(h);
hash_destroy(h);
return retval;
}
char * wsman_get_fragment_string(WsContextH cntx, WsXmlDocH doc)
{
WsXmlNodeH header, n;
char *mu = NULL;
if(doc == NULL)
doc = cntx->indoc;
header = ws_xml_get_soap_header(doc);
n = ws_xml_get_child(header, 0, XML_NS_WS_MAN,
WSM_FRAGMENT_TRANSFER);
if (n != NULL) {
mu = ws_xml_find_attr_value(n, XML_NS_SOAP_1_2,
SOAP_MUST_UNDERSTAND);
if (mu != NULL && strcmp(mu, "true") == 0) {
return ws_xml_get_node_text(n);
}
}
return NULL;
}
char *
wsman_get_resource_uri(WsContextH cntx, WsXmlDocH doc)
{
char *val = NULL;
WsXmlNodeH header, node;
if (doc == NULL) {
doc = cntx->indoc;
if (!doc)
return NULL;
}
header = ws_xml_get_soap_header(doc);
node = ws_xml_get_child(header, 0, XML_NS_WS_MAN,
WSM_RESOURCE_URI);
val = (!node) ? NULL : ws_xml_get_node_text(node);
return val;
}
/**
* Duplication complete XML tree
* @param dstNode Destination XML node
* @param srcNode Source XML node
*/
void ws_xml_duplicate_tree(WsXmlNodeH dstNode, WsXmlNodeH srcNode)
{
WsXmlNodeH node;
if (!srcNode || !dstNode) {
error("NULL arguments: dst = %p; src = %p", dstNode,
srcNode);
return;
}
node = ws_xml_add_child(dstNode,
ws_xml_get_node_name_ns(srcNode),
ws_xml_get_node_local_name(srcNode), NULL);
if (!node) {
error("could not add node");
return;
}
ws_xml_duplicate_attr(node, srcNode);
if (ws_xml_duplicate_children(node, srcNode) == 0) {
// no children
ws_xml_set_node_text(node, ws_xml_get_node_text(srcNode));
}
}
static WsXmlNodeH
validate_mustunderstand_headers(op_t * op)
{
WsXmlNodeH child = NULL, header = NULL;
int i;
char *nsUri;
header = wsman_get_soap_header_element(op->in_doc, NULL, NULL);
nsUri = ws_xml_get_node_name_ns(header);
for (i = 0;(child = ws_xml_get_child(header, i, NULL, NULL)) != NULL; i++) {
if (ws_xml_find_attr_bool(child, nsUri, SOAP_MUST_UNDERSTAND)) {
if (!is_mu_header(child)) {
break;
}
}
}
if (child != NULL) {
debug("Mustunderstand Fault: %s", ws_xml_get_node_text(child));
}
return child;
}
void
wsman_set_expiretime(WsXmlNodeH node,
unsigned long * expire,
WsmanFaultCodeType *fault_code)
{
struct timeval tv;
time_t timeout;
char *text;
XML_DATETIME tmx;
gettimeofday(&tv, NULL);
text = ws_xml_get_node_text(node);
*fault_code = WSMAN_DETAIL_OK;
if (text == NULL) {
*fault_code = WSEN_INVALID_EXPIRATION_TIME;
return;
}
debug("wsen:Expires = %s", text);
if (text[0] == 'P') {
// xml duration
if (ws_deserialize_duration(text, &timeout)) {
*fault_code = WSEN_INVALID_EXPIRATION_TIME;
goto DONE;
}
*expire = tv.tv_sec + timeout;
goto DONE;
}
// timeout is XML datetime type
if (ws_deserialize_datetime(text, &tmx)) {
*fault_code = WSEN_UNSUPPORTED_EXPIRATION_TYPE;
goto DONE;
}
timeout = mktime(&(tmx.tm)) + 60*tmx.tz_min;
*expire = timeout;
DONE:
return;
}
int wsman_parse_credentials(WsXmlDocH doc, WsSubscribeInfo * subsInfo,
WsmanFaultCodeType *faultcode,
WsmanFaultDetailType *detailcode)
{
int i = 0;
WsXmlNodeH tnode = NULL, snode = NULL, node = NULL, temp = NULL;
char *value = NULL;
snode = ws_xml_get_soap_header(doc);
snode = ws_xml_get_child(snode, 0, XML_NS_TRUST, WST_ISSUEDTOKENS);
if(snode == NULL) return 0;
tnode = ws_xml_get_child(snode, i, XML_NS_TRUST, WST_REQUESTSECURITYTOKENRESPONSE);
while(tnode)
{
i++;
node = ws_xml_get_child(tnode, 0, XML_NS_POLICY, WSP_APPLIESTO);
if(node) {
node = ws_xml_get_child(node, 0, XML_NS_ADDRESSING, WSA_EPR);
if(node) {
node = ws_xml_get_child(node, 0, XML_NS_ADDRESSING, WSA_ADDRESS);
if(node)
if(strcmp(ws_xml_get_node_text(node), subsInfo->epr_notifyto)) {
*faultcode = WSMAN_INVALID_PARAMETER;
*detailcode = WSMAN_DETAIL_INVALID_ADDRESS;
return -1;
}
}
}
node = ws_xml_get_child(tnode, 0, XML_NS_TRUST, WST_TOKENTYPE);
value = ws_xml_get_node_text(node);
if(strcmp(value, WST_USERNAMETOKEN) == 0) {
node = ws_xml_get_child(tnode, 0, XML_NS_TRUST, WST_REQUESTEDSECURITYTOKEN);
if(node) {
node = ws_xml_get_child(node, 0, XML_NS_SE, WSSE_USERNAMETOKEN);
if(node) {
temp = ws_xml_get_child(node, 0, XML_NS_SE, WSSE_USERNAME);
if(temp)
subsInfo->username = u_strdup(ws_xml_get_node_text(temp));
temp = ws_xml_get_child(node, 0, XML_NS_SE, WSSE_PASSWORD);
if(temp)
subsInfo->password = u_strdup(ws_xml_get_node_text(temp));
}
}
debug("subsInfo->username = %s, subsInfo->password = %s", subsInfo->username, \
subsInfo->password);
}
else if(strcmp(value, WST_CERTIFICATETHUMBPRINT) == 0) {
node = ws_xml_get_child(tnode, 0, XML_NS_TRUST, WST_REQUESTEDSECURITYTOKEN);
if(node) {
node = ws_xml_get_child(node, 0, XML_NS_WS_MAN, WSM_CERTIFICATETHUMBPRINT);
if(node)
subsInfo->certificate_thumbprint = u_strdup(ws_xml_get_node_text(node));
}
}
else {
*faultcode = WSMAN_INVALID_OPTIONS;
*detailcode = WST_DETAIL_UNSUPPORTED_TOKENTYPE;
return -1;
}
tnode = ws_xml_get_child(snode, i, XML_NS_TRUST, WST_REQUESTSECURITYTOKENRESPONSE);
}
return 0;
}
int Redirect_Enumerate_EP(WsContextH cntx,
WsEnumerateInfo* enumInfo,
WsmanStatus *status, void *opaqueData)
{
WsXmlNodeH r_header=NULL, r_node=NULL, r_body=NULL, r_opt=NULL;
WsXmlDocH r_response=NULL;
char *resource_uri, *remote_enumContext;
int op;
WsManClient *cl=NULL;
//The redirected Enumeration request must have RequestTotalItemsCountEstimate enabled
r_header = ws_xml_get_soap_header(cntx->indoc);
if ( (r_node = ws_xml_get_child(r_header,0,XML_NS_WS_MAN, WSM_REQUEST_TOTAL )) == NULL )
ws_xml_add_child(r_header, XML_NS_WS_MAN, WSM_REQUEST_TOTAL, NULL);
cl = setup_redirect_client(cntx, enumInfo->auth_data.username, enumInfo->auth_data.password);
//Set the enumInfo flags based on the indoc. This is required while handling the response in wsenum_eunmerate_stub
r_body=ws_xml_get_soap_body(cntx->indoc);
if ( ( r_node = ws_xml_get_child(r_body ,0, XML_NS_ENUMERATION, WSENUM_ENUMERATE )) != NULL )
{
if ( (r_opt = ws_xml_get_child(r_node,0,XML_NS_WS_MAN,WSM_OPTIMIZE_ENUM )) != NULL )
enumInfo->flags |= WSMAN_ENUMINFO_OPT ;
}
wsman_send_request(cl,cntx->indoc);
if (wsmc_get_last_error(cl) != WS_LASTERR_OK ){
//CURL or HTTP errors
enumInfo->pullResultPtr = NULL;
status->fault_code = WSMAN_INTERNAL_ERROR;
status->fault_detail_code = 0;
status->fault_msg = redirect_fault_msg( wsman_transport_get_last_error_string( wsmc_get_last_error(cl) ) );
return 1;
}
r_response = ws_xml_duplicate_doc(wsmc_build_envelope_from_response(cl));
if ( wsman_is_fault_envelope(r_response)){
enumInfo->pullResultPtr = NULL;
wsman_get_fault_status_from_doc(r_response, status);
return 1;
}
//Get the Estimated Total No.of Items from the response.
r_header=ws_xml_get_soap_header(r_response);
r_node=ws_xml_get_child(r_header,0,XML_NS_WS_MAN, WSM_TOTAL_ESTIMATE );
enumInfo->totalItems=(!r_node) ? 0: atoi(ws_xml_get_node_text(r_node));
//Get the remote context
remote_enumContext = wsmc_get_enum_context(r_response);
//Set the pullResultPtr only if some Enum Items are returned, in optimized mode.
r_body= ws_xml_get_soap_body(r_response);
if ( (r_node = ws_xml_get_child(r_body,0,XML_NS_ENUMERATION, WSENUM_ENUMERATE_RESP )) != NULL &&
( ws_xml_get_child(r_node,0,XML_NS_WS_MAN,WSENUM_ITEMS) != NULL) )
{
enumInfo->pullResultPtr = r_response;
if( strlen(remote_enumContext) != 0 )
strncpy(enumInfo->enumId, remote_enumContext, strlen(remote_enumContext)+1);
else // If all the instances are returned, the context will be NULL
enumInfo->enumId[0]='\0';
}
else{
//If not items are returned, set the context and return.
strncpy(enumInfo->enumId, remote_enumContext, strlen(remote_enumContext)+1);
ws_xml_destroy_doc(r_response);
}
wsmc_release(cl);
return 0;
}
int wsman_parse_enum_request(WsContextH cntx,
WsEnumerateInfo * enumInfo)
{
filter_t *filter = NULL;
WsXmlNodeH node;
WsXmlDocH doc = cntx->indoc;
if (!doc)
return 0;
node = ws_xml_get_soap_body(doc);
if (node && (node = ws_xml_get_child(node, 0,
XML_NS_ENUMERATION,
WSENUM_ENUMERATE))) {
WsXmlNodeH opt = ws_xml_get_child(node, 0, XML_NS_WS_MAN,
WSM_ENUM_MODE);
/* Enumeration mode */
if (opt) {
char *text = ws_xml_get_node_text(opt);
if (text != NULL) {
if (strcmp(text, WSM_ENUM_EPR) == 0)
enumInfo->flags |= WSMAN_ENUMINFO_EPR;
else if (strcmp(text, WSM_ENUM_OBJ_AND_EPR) == 0)
enumInfo->flags |= WSMAN_ENUMINFO_OBJEPR;
}
}
/* Polymorphism */
opt = ws_xml_get_child(node, 0, XML_NS_CIM_BINDING,
WSMB_POLYMORPHISM_MODE);
if (opt) {
char *mode = ws_xml_get_node_text(opt);
if (strcmp(mode, WSMB_EXCLUDE_SUBCLASS_PROP) == 0) {
enumInfo->flags |= WSMAN_ENUMINFO_POLY_EXCLUDE;
} else if (strcmp(mode, WSMB_INCLUDE_SUBCLASS_PROP) == 0) {
enumInfo->flags |= WSMAN_ENUMINFO_POLY_INCLUDE;
} else if (strcmp(mode, WSMB_NONE) == 0) {
enumInfo->flags |= WSMAN_ENUMINFO_POLY_NONE;
}
} else {
enumInfo->flags |= WSMAN_ENUMINFO_POLY_INCLUDE;
}
/* Enum Optimization ?
* wsen:Enum/wsman:Optimize
* wsen:Enum/wsman:MaxElements <optional>
*/
opt = ws_xml_get_child(node, 0, XML_NS_WS_MAN,
WSM_OPTIMIZE_ENUM);
if (opt) {
WsXmlNodeH max = ws_xml_get_child(node, 0,
XML_NS_WS_MAN,
WSM_MAX_ELEMENTS);
enumInfo->flags |= WSMAN_ENUMINFO_OPT;
if (max) {
char *text = ws_xml_get_node_text(max);
if (text != NULL) {
enumInfo->maxItems = atoi(text);
}
} else {
enumInfo->maxItems = 1;
}
}
/* Filter */
filter = filter_deserialize(node, XML_NS_WS_MAN);
enumInfo->filter = filter;
if(filter) {
if(strcmp(filter->dialect, WSM_ASSOCIATION_FILTER_DIALECT) == 0) {
if(filter->assocType == 0)
enumInfo->flags |= WSMAN_ENUMINFO_ASSOC;
else
enumInfo->flags |= WSMAN_ENUMINFO_REF;
}
else if(strcmp(filter->dialect, WSM_CQL_FILTER_DIALECT) ==0)
enumInfo->flags |= WSMAN_ENUMINFO_CQL;
else if(strcmp(filter->dialect, WSM_WQL_FILTER_DIALECT) == 0)
enumInfo->flags |= WSMAN_ENUMINFO_WQL;
else if(strcmp(filter->dialect, WSM_SELECTOR_FILTER_DIALECT) == 0)
enumInfo->flags |= WSMAN_ENUMINFO_SELECTOR;
else {
if(interpretxpath(&filter->query))
enumInfo->flags |= WSMAN_ENUMINFO_WQL;
else
return 0;
}
}
}
return 1;
}
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;
}
/**
* Check for duplicate Message ID
* @param op operation
* @return status
*/
static int
check_unsupported_features(op_t * op)
{
WsXmlNodeH enumurate;
WsXmlNodeH subscribe;
WsXmlNodeH header = wsman_get_soap_header_element( op->in_doc, NULL, NULL);
WsXmlNodeH body = ws_xml_get_soap_body(op->in_doc);
int retVal = 0;
WsXmlNodeH n, m, k;
char *resource_uri = NULL, *mu = NULL;
WsXmlAttrH attr = NULL;
n = ws_xml_get_child(header, 0, XML_NS_ADDRESSING, WSA_FAULT_TO);
if (n != NULL) {
retVal = 1;
generate_op_fault(op, WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_ADDRESSING_MODE);
goto DONE;
}
n = ws_xml_get_child(header, 0, XML_NS_WS_MAN, WSM_LOCALE);
if (n != NULL) {
debug("Locale header found");
mu = ws_xml_find_attr_value(n, XML_NS_SOAP_1_2,
SOAP_MUST_UNDERSTAND);
if (mu != NULL && strcmp(mu, "true") == 0) {
retVal = 1;
generate_op_fault(op,
WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_LOCALE);
goto DONE;
}
}
#if 0
n = ws_xml_get_child(header, 0, XML_NS_WS_MAN,
WSM_FRAGMENT_TRANSFER);
if (n != NULL) {
debug("FragmentTransfer header found");
mu = ws_xml_find_attr_value(n, XML_NS_SOAP_1_2,
SOAP_MUST_UNDERSTAND);
if (mu != NULL && strcmp(mu, "true") == 0) {
retVal = 1;
generate_op_fault(op,
WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_FRAGMENT_LEVEL_ACCESS);
goto DONE;
}
}
#endif
enumurate = ws_xml_get_child(body, 0, XML_NS_ENUMERATION,
WSENUM_ENUMERATE);
if (enumurate) {
n = ws_xml_get_child(enumurate, 0, XML_NS_ENUMERATION,
WSENUM_END_TO);
if (n != NULL) {
retVal = 1;
generate_op_fault(op, WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_ADDRESSING_MODE);
}
n = ws_xml_get_child(enumurate, 0, XML_NS_ENUMERATION,
WSENUM_FILTER);
m = ws_xml_get_child(enumurate, 0, XML_NS_WS_MAN, WSM_FILTER);
if (n != NULL && m != NULL) {
retVal = 1;
generate_op_fault(op, WSEN_CANNOT_PROCESS_FILTER, 0);
goto DONE;
} else if (n || m) {
char *dia = NULL;
if (n) {
dia = ws_xml_find_attr_value(n, NULL, WSM_DIALECT);
} else if (m) {
dia = ws_xml_find_attr_value(m, NULL, WSM_DIALECT);
}
if (dia)
retVal = check_supported_dialect(dia);
else
retVal = check_supported_dialect (WSM_XPATH_FILTER_DIALECT);
if (retVal) {
retVal = 1;
generate_op_fault(op, WSEN_FILTER_DIALECT_REQUESTED_UNAVAILABLE,
0);
goto DONE;
}
}
k = ws_xml_get_child(header, 0, XML_NS_WS_MAN, WSM_RESOURCE_URI);
if (k)
resource_uri = ws_xml_get_node_text(k);
if (resource_uri &&
(strcmp(resource_uri, CIM_ALL_AVAILABLE_CLASSES) == 0)) {
if (!n && !m) {
retVal = 1;
generate_op_fault(op, WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_FILTERING_REQUIRED);
goto DONE;
}
}
}
subscribe = ws_xml_get_child(body, 0, XML_NS_EVENTING, WSEVENT_SUBSCRIBE);
if(subscribe) {
/* n = ws_xml_get_child(subscribe, 0, XML_NS_EVENTING, WSEVENT_ENDTO);
if(n) {
retVal = 1;
generate_op_fault(op, WSMAN_UNSUPPORTED_FEATURE,
WSMAN_DETAIL_ADDRESSING_MODE);
goto DONE;
}
*/ n = ws_xml_get_child(subscribe, 0, XML_NS_EVENTING, WSEVENT_DELIVERY);
if(n == NULL) {
retVal = 1;
generate_op_fault(op, WSE_INVALID_MESSAGE, 0);
goto DONE;
}
attr = ws_xml_find_node_attr(n, NULL,WSEVENT_DELIVERY_MODE);
if(attr) {
mu = ws_xml_get_attr_value(attr);
if (strcasecmp(mu, WSEVENT_DELIVERY_MODE_PUSH) &&
strcasecmp(mu, WSEVENT_DELIVERY_MODE_PUSHWITHACK) &&
strcasecmp(mu, WSEVENT_DELIVERY_MODE_EVENTS) &&
strcasecmp(mu, WSEVENT_DELIVERY_MODE_PULL)) {
debug("Unsupported delivery mode : %s",ws_xml_get_attr_value(attr));
retVal = 1;
generate_op_fault(op, WSE_DELIVERY_MODE_REQUESTED_UNAVAILABLE, 0);
goto DONE;
}
}
m = ws_xml_get_child(n, 0, XML_NS_WS_MAN, WSM_CONNECTIONRETRY);
if(m) {
retVal = 1;
generate_op_fault(op, WSMAN_UNSUPPORTED_FEATURE, WSMAN_DETAIL_DELIVERY_RETRIES);
goto DONE;
}
}
DONE:
return retVal;
}
SoapDispatchH wsman_dispatcher(WsContextH cntx, void *data, WsXmlDocH doc)
{
SoapDispatchH disp = NULL;
char *uri = NULL, *action;
WsManDispatcherInfo *dispInfo = (WsManDispatcherInfo *) data;
WsDispatchEndPointInfo *ep = NULL;
WsDispatchEndPointInfo *ep_custom = NULL;
WsXmlDocH notdoc = NULL;
#ifdef ENABLE_EVENTING_SUPPORT
WsXmlNodeH nodedoc = NULL;
#endif
int i; /*, resUriMatch = 0; */
char *ns = NULL;
WsDispatchInterfaceInfo *r = NULL;
lnode_t *node = list_first((list_t *) dispInfo->interfaces);
if (doc == NULL) {
error("doc is null");
u_free(data);
goto cleanup;
}
uri = wsman_get_resource_uri(cntx, doc);
action = wsman_get_action(cntx, doc);
#ifdef ENABLE_EVENTING_SUPPORT
if(wsman_is_event_related_request(doc)) {
WsXmlNodeH temp = ws_xml_get_child( ws_xml_get_soap_header(doc), 0,
XML_NS_EVENTING, WSEVENT_IDENTIFIER);
char *uuid = ws_xml_get_node_text(temp);
debug("Request uuid: %s", uuid ? uuid : "NULL");
if(uuid) {
lnode_t *t = list_first(cntx->subscriptionMemList);
while(t != NULL) {
WsSubscribeInfo *subsInfo = (WsSubscribeInfo *)t->list_data;
if(!strcmp(uuid+5, subsInfo->subsId)) {
uri = subsInfo->uri;
break;
}
else
t = list_next(cntx->subscriptionMemList, t);
}
if(t == NULL) {
unsigned char *buf = NULL;
int len;
if(cntx->soap->subscriptionOpSet->get_subscription(cntx->soap->uri_subsRepository,
uuid+5, &buf, &len) == 0) {
notdoc = ws_xml_read_memory( (char *)buf, len, "UTF-8", 0);
if(notdoc) {
nodedoc = ws_xml_get_soap_header(notdoc);
if(nodedoc) {
nodedoc = ws_xml_get_child(nodedoc, 0, XML_NS_WS_MAN, WSM_RESOURCE_URI);
if(nodedoc) {
uri = ws_xml_get_node_text(nodedoc);
}
}
}
u_free(buf);
}
}
}
}
#endif
debug("uri: %s, action: %s", uri ? uri : "NULL", action ? action : "NULL");
if ((!uri || !action) && !wsman_is_identify_request(doc)) {
goto cleanup;
}
while (node != NULL) {
WsDispatchInterfaceInfo *ifc = (WsDispatchInterfaceInfo *) node->list_data;
if (wsman_is_identify_request(doc)) {
if ((ns = wsman_dispatcher_match_ns(ifc,
XML_NS_WSMAN_ID))) {
r = ifc;
/* resUriMatch = 1; */
break;
}
debug("ns did not match");
}
/*
* If Resource URI is null then most likely we are dealing
* with a generic plugin supporting a namespace with
* multiple Resource URIs (e.g. CIM)
**/
else if (ifc->wsmanResourceUri == NULL &&
(ns = wsman_dispatcher_match_ns(ifc, uri))) {
r = ifc;
/* resUriMatch = 1; */
break;
} else if (ifc->wsmanResourceUri &&
!strcmp(uri, ifc->wsmanResourceUri)) {
r = ifc;
/* resUriMatch = 1; */
break;
}
node = list_next((list_t *) dispInfo->interfaces, node);
}
if (wsman_is_identify_request(doc) && r != NULL) {
ep = &r->endPoints[0];
} else if (r != NULL) {
char *ptr = action;
/*
* See if the action is part of the namespace which means that
* we are dealing with a custom action
*/
if (ns != NULL) {
size_t len = strlen(ns);
if (!strncmp(action, ns, len) &&
action[len] == '/')
ptr = &action[len + 1];
}
for (i = 0; r->endPoints[i].serviceEndPoint != NULL; i++) {
if (r->endPoints[i].inAction != NULL &&
!strcmp(ptr, r->endPoints[i].inAction)) {
ep = &r->endPoints[i];
break;
} else if (r->endPoints[i].inAction == NULL) {
/*
* Just store it for later
* in case no match is found for above condition
*/
ep_custom = &r->endPoints[i];
}
}
}
ws_remove_context_val(cntx, WSM_RESOURCE_URI);
if (ep != NULL) {
for (i = 0; i < dispInfo->mapCount; i++) {
if (dispInfo->map[i].ep == ep) {
disp = dispInfo->map[i].disp;
break;
}
}
} else if (ep_custom != NULL) {
for (i = 0; i < dispInfo->mapCount; i++) {
if (dispInfo->map[i].ep == ep_custom) {
disp = dispInfo->map[i].disp;
break;
}
}
}
cleanup:
if(notdoc)
ws_xml_destroy_doc(notdoc);
if (ns)
u_free(ns);
return disp;
}
/**
* Check for duplicate Message ID
* @param op operation
* @return status
*/
static int wsman_is_duplicate_message_id(op_t * op)
{
WsXmlNodeH header = wsman_get_soap_header_element(op->in_doc, NULL, NULL);
int retVal = 0;
SoapH soap;
WsXmlNodeH msgIdNode;
soap = op->dispatch->soap;
msgIdNode = ws_xml_get_child(header, 0, XML_NS_ADDRESSING, WSA_MESSAGE_ID);
if (msgIdNode != NULL) {
lnode_t *node;
char *msgId;
msgId = ws_xml_get_node_text(msgIdNode);
if (msgId[0] == 0 ) {
generate_op_fault(op, WSA_INVALID_MESSAGE_INFORMATION_HEADER, 0 );
debug("MessageId missing");
return 1;
}
debug("Checking Message ID: %s", msgId);
u_lock(soap);
if (soap->processedMsgIdList == NULL) {
soap->processedMsgIdList = list_create(LISTCOUNT_T_MAX);
}
#ifndef IGNORE_DUPLICATE_ID
node = list_first(soap->processedMsgIdList);
while (node != NULL) {
if (!strcmp(msgId, (char *) node->list_data)) {
debug("Duplicate Message ID: %s", msgId);
retVal = 1;
generate_op_fault(op, WSA_INVALID_MESSAGE_INFORMATION_HEADER,
WSA_DETAIL_DUPLICATE_MESSAGE_ID);
break;
}
node = list_next(soap->processedMsgIdList, node);
}
#endif
if (!retVal) {
while (list_count(soap->processedMsgIdList) >= PROCESSED_MSG_ID_MAX_SIZE) {
node = list_del_first(soap->processedMsgIdList);
u_free(node->list_data);
u_free(node);
}
node = lnode_create(NULL);
if (node) {
node->list_data = u_str_clone(msgId);
if (node->list_data == NULL) {
u_free(node);
} else {
list_append(soap->processedMsgIdList, node);
}
}
}
u_unlock(soap);
} else if (!wsman_is_identify_request(op->in_doc)) {
generate_op_fault(op, WSA_MESSAGE_INFORMATION_HEADER_REQUIRED, 0);
debug("No MessageId Header found");
return 1;
}
return retVal;
}
epr_t *epr_deserialize(WsXmlNodeH node, const char *ns,
const char *epr_node_name, int embedded)
{
int i;
epr_t *epr = u_malloc(sizeof(epr_t));
WsXmlNodeH eprnode = NULL;
WsXmlNodeH refparamnode = NULL;
WsXmlNodeH temp = NULL;
WsXmlNodeH selectorsetnode = NULL;
WsXmlAttrH attr = NULL;
Selector *p = NULL;
if(epr_node_name) {
eprnode = ws_xml_get_child(node, 0, ns, epr_node_name);
if(eprnode == NULL)
goto CLEANUP;
} else {
eprnode = node;
}
if(embedded) {
temp = ws_xml_get_child(eprnode, 0, XML_NS_ADDRESSING, WSA_ADDRESS);
} else {
temp = ws_xml_get_child(eprnode, 0, XML_NS_ADDRESSING, WSA_TO);
}
if(temp == NULL)
goto CLEANUP;
epr->address = u_strdup(ws_xml_get_node_text(temp));
if(embedded) {
refparamnode = ws_xml_get_child(eprnode, 0, XML_NS_ADDRESSING, WSA_REFERENCE_PARAMETERS);
} else {
refparamnode = node;
}
if(refparamnode == NULL)
goto CLEANUP;
temp = ws_xml_get_child(refparamnode, 0, XML_NS_WS_MAN, WSM_RESOURCE_URI);
if(temp == NULL)
goto CLEANUP;
epr->refparams.uri = u_strdup(ws_xml_get_node_text(temp));
selectorsetnode = ws_xml_get_child(refparamnode, 0, XML_NS_WS_MAN, WSM_SELECTOR_SET);
epr->refparams.selectorset.count = ws_xml_get_child_count(selectorsetnode);
epr->refparams.selectorset.selectors = u_malloc(epr->refparams.selectorset.count *
sizeof(Selector));
p = epr->refparams.selectorset.selectors;
for(i = 0; i < epr->refparams.selectorset.count; i++) {
temp = ws_xml_get_child(selectorsetnode, i, XML_NS_WS_MAN, WSM_SELECTOR);
attr = ws_xml_find_node_attr(temp, NULL, "Name");
if(attr) {
p->name = u_strdup(ws_xml_get_attr_value(attr));
}
if(ws_xml_get_child(temp, 0, XML_NS_ADDRESSING, WSA_EPR)) {
p->type = 1;
p->value = (char *)epr_deserialize(temp, XML_NS_ADDRESSING, WSA_EPR, 1);
} else {
p->type = 0;
p->value = u_strdup(ws_xml_get_node_text(temp));
}
p++;
}
return epr;
CLEANUP:
u_free(epr);
return NULL;
}
hash_t *
wsman_get_method_args(WsContextH cntx, const char *resource_uri)
{
char *input = NULL;
WsXmlDocH doc = cntx->indoc;
hash_t *h = hash_create(HASHCOUNT_T_MAX, 0, 0);
hash_set_allocator(h, NULL, wsman_free_method_hnode, NULL);
if (doc) {
WsXmlNodeH in_node;
WsXmlNodeH body = ws_xml_get_soap_body(doc);
char *mn = wsman_get_method_name(cntx);
input = u_strdup_printf("%s_INPUT", mn);
in_node = ws_xml_get_child(body, 0, resource_uri, input);
if (!in_node) {
char *xsd = u_strdup_printf("%s.xsd", resource_uri);
in_node = ws_xml_get_child(body, 0, xsd, input);
u_free(xsd);
}
if (in_node) {
WsXmlNodeH arg, epr;
int index = 0;
list_t *arglist = list_create(LISTCOUNT_T_MAX);
lnode_t *argnode;
while ((arg = ws_xml_get_child(in_node, index++, NULL, NULL))) {
char *key = ws_xml_get_node_local_name(arg);
selector_entry *sentry = u_malloc(sizeof(*sentry));
methodarglist_t *nodeval = u_malloc(sizeof(methodarglist_t));
epr = ws_xml_get_child(arg, 0, XML_NS_ADDRESSING,
WSA_REFERENCE_PARAMETERS);
nodeval->key = u_strdup(key);
nodeval->arraycount = 0;
argnode = lnode_create(nodeval);
if (epr) {
debug("epr: %s", key);
sentry->type = 1;
sentry->entry.eprp = epr_deserialize(arg, NULL, NULL, 1);
//wsman_get_epr(cntx, arg, key, XML_NS_CIM_CLASS);
} else {
debug("text: %s", key);
sentry->type = 0;
sentry->entry.text = u_strdup(ws_xml_get_node_text(arg));
}
nodeval->data = sentry;
list_append(arglist, argnode);
}
if (!hash_alloc_insert(h, METHOD_ARGS_KEY, arglist)) {
error("hash_alloc_insert failed");
wsman_free_method_list(arglist);
}
}
u_free(mn);
u_free(input);
} else {
error("error: xml document is NULL");
}
if (!hash_isempty(h))
return h;
hash_destroy(h);
return NULL;
}
