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);
}
/**
* 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;
}
static void test_serialize2(void)
{
epr_t *epr = epr_from_string("http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/CIM_IndicationFilter?Name=OperatingSystemFilter0&CreationClassName=CIM_IndicationFilter&SystemName=localhost.localdomain&SystemCreationClassName=CIM_ComputerSystem");
if(epr == NULL) {
printf("test serialize from string failed!\n");
return;
}
epr_add_selector_text(epr, CIM_NAMESPACE_SELECTOR, "root/interop"); //test epr_add_selector_text
WsXmlDocH doc = ws_xml_create_envelope();
WsXmlNodeH header = ws_xml_get_soap_header(doc);
epr_serialize(header,NULL,NULL,epr,0);
ws_xml_dump_doc(stdout, doc);
ws_xml_destroy_doc(doc);
epr_destroy(epr);
printf("\033[22;32mtest create epr from string successfully!\033[m\n\n");
}
static void test_epr_delete_selector(void)
{
WsXmlDocH doc1 = ws_xml_read_file("./epr3.xml", "utf-8", 0);
if(doc1 == NULL) return;
WsXmlNodeH node = ws_xml_get_soap_header(doc1);
epr_t *epr = epr_deserialize(node, NULL, NULL, 0);
epr_delete_selector(epr, "Handler");
WsXmlDocH doc = ws_xml_create_envelope();
WsXmlNodeH header = ws_xml_get_soap_header(doc);
epr_serialize(header,NULL,NULL,epr,0);
ws_xml_dump_doc(stdout, doc);
ws_xml_destroy_doc(doc1);
ws_xml_destroy_doc(doc);
epr_destroy(epr);
printf("\033[22;32mdelete selector \"Handler\" from EPR\033[m\n\n");
}
static void test_deserialize(void)
{
WsXmlDocH doc = ws_xml_read_file("./sample.xml", "utf-8", 0);
if(doc == NULL) return;
WsXmlNodeH node = ws_xml_get_soap_header(doc);
epr_t *epr = epr_deserialize(node, NULL, NULL, 0);
if(epr == NULL) {
printf("epr deserialize failed!\n");
return;
}
ws_xml_destroy_doc(doc);
doc = ws_xml_create_envelope();
node = ws_xml_get_soap_header(doc);
epr_serialize(node, NULL, NULL,epr, 0);
ws_xml_dump_doc(stdout, doc);
epr_destroy(epr);
ws_xml_destroy_doc(doc);
printf("\033[22;32mtest deserialize epr successfully!\033[m\n\n");
}
WsXmlDocH ws_xml_create_soap_envelope(void)
{
return ws_xml_create_envelope();
}
static void test_serialize1(void)
{
hash_t *selectors_filter = hash_create(HASHCOUNT_T_MAX, 0, 0);
selector_entry *entry1 = NULL;
entry1 = u_malloc(sizeof(selector_entry)*4);
entry1[0].type = 0;
entry1[0].entry.text = "OperatingSystemFilter0";
entry1[1].type = 0;
entry1[1].entry.text = "localhost.localdomain";
entry1[2].type = 0;
entry1[2].entry.text = "CIM_IndicationFilter";
entry1[3].type = 0;
entry1[3].entry.text = "CIM_ComputerSystem";
hash_alloc_insert(selectors_filter, "Name", &entry1[0]);
hash_alloc_insert(selectors_filter, "SystemName", &entry1[1]);
hash_alloc_insert(selectors_filter, "CreationClassName", &entry1[2]);
hash_alloc_insert(selectors_filter, "SystemCreationClassName", &entry1[3]);
epr_t *epr_filter = epr_create("http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/CIM_IndicationFilter", selectors_filter, NULL);
if(epr_filter == NULL) {
printf("epr_create filter failed!\n");
return;
}
hash_t *selectors_handler = hash_create(HASHCOUNT_T_MAX, 0, 0);
selector_entry *entry2 = u_malloc(sizeof(selector_entry)*4);
entry2[0].type = 0;
entry2[0].entry.text = "OperatingSystemHandler0";
entry2[1].type = 0;
entry2[1].entry.text = "localhost.localdomain";
entry2[2].type = 0;
entry2[2].entry.text = "CIM_IndicationHandlerCIMXML";
entry2[3].type = 0;
entry2[3].entry.text = "CIM_ComputerSystem";
hash_alloc_insert(selectors_handler, "Name", &entry2[0]);
hash_alloc_insert(selectors_handler, "SystemName", &entry2[1]);
hash_alloc_insert(selectors_handler, "CreationClassName", &entry2[2]);
hash_alloc_insert(selectors_handler, "SystemCreationClassName", &entry2[3]);
epr_t *epr_handler = epr_create("http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/CIM_IndicationHandlerCIMXML", selectors_handler, NULL);
if(epr_handler == NULL) {
printf("epr_create handler failed!\n");
return;
}
hash_t *selectors_subscription = hash_create(HASHCOUNT_T_MAX, 0, 0);
selector_entry *entry3 = NULL;
entry3 = u_malloc(sizeof(selector_entry)*2);
entry3[0].type = 1;
entry3[0].entry.eprp = epr_filter;
entry3[1].type = 1;
entry3[1].entry.eprp = epr_handler;
hash_alloc_insert(selectors_subscription, "Filter", &entry3[1]);
hash_alloc_insert(selectors_subscription, "Handler", &entry3[1]);
epr_t *epr_subscription = epr_create("http://schema.omc-project.org/wbem/wscim/1/cim-schema/2/CIM_IndicationSubscription", selectors_subscription, NULL);
if(epr_subscription == NULL) {
printf("epr_create subscription failed!\n");
return;
}
epr_t *epr_cpy = epr_copy(epr_subscription); //test epr_copy
WsXmlDocH doc = ws_xml_create_envelope();
WsXmlNodeH header = ws_xml_get_soap_header(doc);
epr_serialize(header,NULL,NULL,epr_cpy,0);
ws_xml_dump_doc(stdout, doc);
epr_destroy(epr_filter);
epr_destroy(epr_handler);
epr_destroy(epr_subscription);
epr_destroy(epr_cpy);
hash_free(selectors_filter);
hash_free(selectors_handler);
hash_free(selectors_subscription);
u_free(entry1);
u_free(entry2);
u_free(entry3);
ws_xml_destroy_doc(doc);
printf("\033[22;32mtest serialize epr successfully!\033[m\n\n");
}
WsXmlDocH
wsmc_create_request(WsManClient * cl, const char *resource_uri,
client_opt_t *options, filter_t *filter,
WsmanAction action, char *method, void *data)
{
WsXmlDocH request;
WsXmlNodeH body;
WsXmlNodeH header;
WsXmlNodeH node;
char *_action = NULL;
char buf[20];
if (action == WSMAN_ACTION_IDENTIFY) {
request = ws_xml_create_envelope();
} else {
if (method) {
if (strchr(method, '/'))
_action = u_strdup(method);
else
_action = wsman_make_action((char *)resource_uri, method);
} else {
_action = wsmc_create_action_str(action);
}
if (_action) {
request = wsmc_build_envelope(cl->serctx, _action,
WSA_TO_ANONYMOUS, (char *)resource_uri,
cl->data.endpoint, options);
} else {
return NULL;
}
u_free(_action);
}
body = ws_xml_get_soap_body(request);
header = ws_xml_get_soap_header(request);
if (!body || !header )
return NULL;
/*
* flags to be passed as <w:OptionSet ...> <w:Option Name="..." ...> > */
if (options && (options->flags & (FLAG_CIM_EXTENSIONS|FLAG_EXCLUDE_NIL_PROPS))) {
WsXmlNodeH opset = ws_xml_add_child(header,
XML_NS_WS_MAN, WSM_OPTION_SET, NULL);
if ((options->flags & FLAG_CIM_EXTENSIONS) == FLAG_CIM_EXTENSIONS) {
WsXmlNodeH op = ws_xml_add_child(opset,
XML_NS_WS_MAN, WSM_OPTION, NULL);
ws_xml_add_node_attr(op, NULL, WSM_NAME, WSMB_SHOW_EXTENSION);
}
if ((options->flags & FLAG_EXCLUDE_NIL_PROPS) == FLAG_EXCLUDE_NIL_PROPS) {
/* ExcludeNilProperties is non-standard, so put it under an openwsman namespace */
WsXmlNodeH op = ws_xml_add_child(opset,
XML_NS_OPENWSMAN, WSM_OPTION, NULL);
ws_xml_add_node_attr(op, NULL, WSM_NAME, WSMB_EXCLUDE_NIL_PROPS);
}
}
switch (action) {
case WSMAN_ACTION_IDENTIFY:
case WSMAN_ACTION_ANON_IDENTIFY:
ws_xml_add_child(body,
XML_NS_WSMAN_ID, WSMID_IDENTIFY, NULL);
break;
case WSMAN_ACTION_CUSTOM:
break;
case WSMAN_ACTION_ENUMERATION:
case WSMAN_ACTION_ASSOCIATORS:
case WSMAN_ACTION_REFERENCES:
node = ws_xml_add_child(body,
XML_NS_ENUMERATION, WSENUM_ENUMERATE, NULL);
wsman_set_enumeration_options(cl, body, resource_uri, options, filter);
break;
case WSMAN_ACTION_PULL:
node = ws_xml_add_child(body,
XML_NS_ENUMERATION, WSENUM_PULL, NULL);
if (data) {
ws_xml_add_child(node, XML_NS_ENUMERATION,
WSENUM_ENUMERATION_CONTEXT, (char *) data);
}
break;
case WSMAN_ACTION_RELEASE:
node = ws_xml_add_child(body,
XML_NS_ENUMERATION, WSENUM_RELEASE, NULL);
if (data) {
ws_xml_add_child(node, XML_NS_ENUMERATION,
WSENUM_ENUMERATION_CONTEXT, (char *) data);
}
break;
case WSMAN_ACTION_SUBSCRIBE:
wsman_set_subscribe_options(cl, request, resource_uri, options, filter);
break;
case WSMAN_ACTION_UNSUBSCRIBE:
node = ws_xml_add_child(body,
XML_NS_EVENTING, WSEVENT_UNSUBSCRIBE,NULL);
if(data) {
if(((char *)data)[0] != 0)
add_subscription_context(ws_xml_get_soap_header(request), (char *)data);
}
break;
case WSMAN_ACTION_RENEW:
node = ws_xml_add_child(body,
XML_NS_EVENTING, WSEVENT_RENEW, NULL);
sprintf(buf, "PT%fS", options->expires);
ws_xml_add_child(node, XML_NS_EVENTING, WSEVENT_EXPIRES, buf);
if(data) {
if(((char *)data)[0] != 0)
add_subscription_context(ws_xml_get_soap_header(request), (char *)data);
}
break;
case WSMAN_ACTION_NONE:
case WSMAN_ACTION_TRANSFER_CREATE:
case WSMAN_ACTION_TEST:
case WSMAN_ACTION_TRANSFER_GET:
case WSMAN_ACTION_TRANSFER_PUT:
case WSMAN_ACTION_TRANSFER_DELETE:
break;
}
if (action == WSMAN_ACTION_PULL || action == WSMAN_ACTION_ENUMERATION) {
if (options->max_elements > 0 ) {
node = ws_xml_get_child(body, 0, NULL, NULL);
if (action == WSMAN_ACTION_ENUMERATION) {
if ((options->flags & FLAG_ENUMERATION_OPTIMIZATION) ==
FLAG_ENUMERATION_OPTIMIZATION ) {
/* wsman:MaxElements is for Enumerate */
ws_xml_add_child_format(node, XML_NS_WS_MAN,
WSENUM_MAX_ELEMENTS, "%d", options->max_elements);
}
} else {
/* wsen:MaxElements is for Pull */
ws_xml_add_child_format(node, XML_NS_ENUMERATION,
WSENUM_MAX_ELEMENTS, "%d", options->max_elements);
}
}
if ((options->flags & FLAG_ENUMERATION_COUNT_ESTIMATION) ==
FLAG_ENUMERATION_COUNT_ESTIMATION) {
ws_xml_add_child(header, XML_NS_WS_MAN, WSM_REQUEST_TOTAL, NULL);
}
}
if (action != WSMAN_ACTION_TRANSFER_CREATE &&
action != WSMAN_ACTION_TRANSFER_PUT &&
action != WSMAN_ACTION_CUSTOM) {
if ((options->flags & FLAG_DUMP_REQUEST) == FLAG_DUMP_REQUEST) {
ws_xml_dump_node_tree(cl->dumpfile, ws_xml_get_doc_root(request));
}
}
return request;
}
static WsXmlDocH
wsmc_build_envelope(WsSerializerContextH serctx,
const char *action,
const char *reply_to_uri,
const char *resource_uri,
const char *to_uri,
client_opt_t *options)
{
WsXmlNodeH node;
char uuidBuf[100];
WsXmlNodeH header;
WsXmlDocH doc = ws_xml_create_envelope();
if (!doc) {
error("Error while creating envelope");
return NULL;
}
header = ws_xml_get_soap_header(doc);
generate_uuid(uuidBuf, sizeof(uuidBuf), 0);
if (reply_to_uri == NULL) {
reply_to_uri = WSA_TO_ANONYMOUS;
}
if (to_uri == NULL) {
to_uri = WSA_TO_ANONYMOUS;
}
if (action != NULL) {
ws_serialize_str(serctx, header,
(char *)action, XML_NS_ADDRESSING, WSA_ACTION, 1);
}
if (to_uri) {
ws_serialize_str(serctx, header, (char *)to_uri,
XML_NS_ADDRESSING, WSA_TO, 1);
}
if (resource_uri) {
ws_serialize_str(serctx, header, (char *)resource_uri,
XML_NS_WS_MAN, WSM_RESOURCE_URI, 1);
}
if (uuidBuf[0] != 0) {
ws_serialize_str(serctx, header, uuidBuf,
XML_NS_ADDRESSING, WSA_MESSAGE_ID, 1);
}
if (options->timeout) {
/* FIXME: see wsman-xml-serialize.c */
char buf[20];
sprintf(buf, "PT%u.%uS", (unsigned int) options->timeout / 1000,
(unsigned int) options->timeout % 1000);
ws_serialize_str(serctx, header, buf,
XML_NS_WS_MAN, WSM_OPERATION_TIMEOUT, 0);
}
if (options->max_envelope_size) {
ws_serialize_uint32(serctx, header, options->max_envelope_size,
XML_NS_WS_MAN, WSM_MAX_ENVELOPE_SIZE,
options->flags & FLAG_MUND_MAX_ESIZE);
}
if (options->fragment) {
int mu = 0;
if ((options->flags & FLAG_MUND_FRAGMENT) ==
FLAG_MUND_FRAGMENT)
mu = 1;
ws_serialize_str(serctx, header, options->fragment,
XML_NS_WS_MAN, WSM_FRAGMENT_TRANSFER,
1);
}
node = ws_xml_add_child(header, XML_NS_ADDRESSING, WSA_REPLY_TO, NULL);
ws_xml_add_child(node, XML_NS_ADDRESSING, WSA_ADDRESS, (char *)reply_to_uri);
/* Do not add the selectors to the header for reference instances */
if ((options->flags & FLAG_CIM_REFERENCES) != FLAG_CIM_REFERENCES) {
wsmc_add_selector_from_options(doc, options);
if (options->cim_ns) {
wsman_add_selector(header,
CIM_NAMESPACE_SELECTOR, options->cim_ns);
}
}
return doc;
}
/**
* Create a Fault
* @param rqstDoc Request document (Envelope)
* @param code Fault code
* @param subCodeNs Namespace of sub code
* @param subCode Sub code
* @param lang Language for Reason section
* @param reason Fault Reason
* @param addDetailProc Callback for details
* @param addDetailProcData Pointer to callback data
* @return XML document of the fault
*/
WsXmlDocH
wsman_create_fault_envelope(WsXmlDocH rqstDoc,
const char *code,
const char *subCodeNs,
const char *subCode,
const char *fault_action,
const char *lang, const char *reason, const char *faultDetail)
{
WsXmlDocH doc = NULL;
WsXmlNodeH header, body, fault, codeNode, node;
char uuidBuf[50];
char *soapNs;
if (rqstDoc) {
doc = wsman_create_response_envelope(rqstDoc, fault_action);
} else {
/* FIXME */
doc = ws_xml_create_envelope();
}
if (doc == NULL) {
return NULL;
}
header = ws_xml_get_soap_header(doc);
body = ws_xml_get_soap_body(doc);
soapNs = ws_xml_get_node_name_ns(body);
fault = ws_xml_add_child(body, soapNs, SOAP_FAULT, NULL);
codeNode = ws_xml_add_child(fault, soapNs, SOAP_CODE, NULL);
node = ws_xml_add_child(codeNode, soapNs, SOAP_VALUE, NULL);
ws_xml_set_node_qname_val(node, soapNs, code);
if (subCode && subCode[0] != 0 ) {
node =
ws_xml_add_child(codeNode, soapNs, SOAP_SUBCODE, NULL);
node = ws_xml_add_child(node, soapNs, SOAP_VALUE, NULL);
if (subCodeNs)
ws_xml_set_node_qname_val(node, subCodeNs,
subCode);
else
ws_xml_set_node_text(node, subCode);
}
if (reason) {
node = ws_xml_add_child(fault, soapNs, SOAP_REASON, NULL);
node = ws_xml_add_child(node, soapNs, SOAP_TEXT, NULL);
ws_xml_set_node_text(node, reason);
ws_xml_set_node_lang(node, !lang ? "en" : lang);
}
if (faultDetail) {
WsXmlNodeH d =
ws_xml_add_child(fault, soapNs, SOAP_DETAIL, NULL);
node =
ws_xml_add_child_format(d, XML_NS_WS_MAN,
SOAP_FAULT_DETAIL, "%s/%s",
XML_NS_WSMAN_FAULT_DETAIL,
faultDetail);
}
generate_uuid(uuidBuf, sizeof(uuidBuf), 0);
ws_xml_add_child(header, XML_NS_ADDRESSING, WSA_MESSAGE_ID,
uuidBuf);
return doc;
}
