static void
wsmc_set_put_prop(WsXmlDocH get_response,
WsXmlDocH put_request,
client_opt_t *options)
{
WsXmlNodeH resource_node;
char *ns_uri;
hscan_t hs;
hnode_t *hn;
WsXmlNodeH get_body = ws_xml_get_soap_body(get_response);
WsXmlNodeH put_body = ws_xml_get_soap_body(put_request);
ws_xml_copy_node(ws_xml_get_child(get_body, 0, NULL, NULL), put_body);
resource_node = ws_xml_get_child(put_body, 0, NULL, NULL);
ns_uri = ws_xml_get_node_name_ns_uri(resource_node);
if (!options->properties) {
return;
}
hash_scan_begin(&hs, options->properties);
while ((hn = hash_scan_next(&hs))) {
WsXmlNodeH n = ws_xml_get_child(resource_node, 0,
ns_uri, (char *) hnode_getkey(hn));
ws_xml_set_node_text(n, (char *) hnode_get(hn));
}
}
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 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;
}
int wsman_clean_subsrepository(SoapH soap, SubsRepositoryEntryH entry)
{
int retVal = 0;
WsXmlDocH doc = ws_xml_read_memory( (char *)entry->strdoc, entry->len, "UTF-8", 0);
unsigned long expire;
WsmanFaultCodeType fault_code;
if(doc) {
WsXmlNodeH node = ws_xml_get_soap_body(doc);
if(node) {
node = ws_xml_get_child(node, 0, XML_NS_EVENTING, WSEVENT_SUBSCRIBE);
node = ws_xml_get_child(node, 0, XML_NS_EVENTING, WSEVENT_EXPIRES);
if(node == NULL) { //No specified expiration, delete it
debug("subscription %s deleted from the repository", entry->uuid);
soap->subscriptionOpSet->delete_subscription(soap->uri_subsRepository, entry->uuid+5);
retVal = 1;
}
else {
wsman_set_expiretime(node, &expire, &fault_code);
if(fault_code == WSMAN_RC_OK) {
if(time_expired(expire)) {
debug("subscription %s deleted from the repository", entry->uuid);
soap->subscriptionOpSet->delete_subscription(soap->uri_subsRepository, entry->uuid+5);
retVal = 1;
}
}
}
}
ws_xml_destroy_doc(doc);
}
return retVal;
}
static void example106()
{
char *data =
"<dummy><qq>This is qq body</qq><pp>This is pp</pp></dummy>";
// WsXmlDocH response;
WsManClient *cl = wsman_create_client("mstevbakrov.ims.intel.com",
8889,
"/wsman",
"http",
"wsman",
"secret");
client_opt_t *options = wsmc_options_init();
WsXmlDocH request = wsmc_create_request(cl,
"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem",
options,
WSMAN_ACTION_TRANSFER_CREATE,
NULL, NULL);
WsXmlDocH d =
wsmc_read_memory(cl, data, strlen(data), NULL, 0);
ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(d));
// WsXmlNodeH n = ws_xml_get_doc_root(d);
ws_xml_duplicate_tree(ws_xml_get_soap_body(request),
ws_xml_get_doc_root(d));
ws_xml_destroy_doc(d);
// ws_xml_copy_node(ws_xml_get_doc_root(d), ws_xml_get_soap_body(request));
ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(request));
wsman_release_client(cl);
ws_xml_destroy_doc(request);
}
int wsman_is_identify_request(WsXmlDocH doc)
{
WsXmlNodeH node = ws_xml_get_soap_body(doc);
node = ws_xml_get_child(node, 0, XML_NS_WSMAN_ID, WSMID_IDENTIFY);
if (node)
return 1;
else
return 0;
}
int
wsman_is_fault_envelope( WsXmlDocH doc )
{
WsXmlNodeH node = ws_xml_get_child(ws_xml_get_soap_body(doc),
0 , XML_NS_SOAP_1_2 , SOAP_FAULT);
if ( node != NULL )
return 1;
else
return 0;
}
int
wsman_parse_event_request(WsXmlDocH doc, WsSubscribeInfo * subsInfo,
WsmanFaultCodeType *faultcode,
WsmanFaultDetailType *detailcode)
{
WsXmlNodeH node;
filter_t *wsman_f = NULL;
filter_t *wse_f = NULL;
if (!doc)
return 0;
node = ws_xml_get_soap_body(doc);
if (node && (node = ws_xml_get_child(node, 0,
XML_NS_EVENTING,
WSEVENT_SUBSCRIBE))) {
/* See DSP0226 (WS-Management), Section 10.2.2 Filtering
* WS-Management defines wsman:Filter as the filter element to wse:Subscribe
* but also allows wse:Filter to be compatible with WS-Eventing implementations
* R10.2.2-50, R10.2.2-51 to DSP0226 */
wsman_f = filter_deserialize(node, XML_NS_WS_MAN);
wse_f = filter_deserialize(node, XML_NS_EVENTING);
if (wsman_f && wse_f) {
/* return wse:InvalidMessage if wsman:Filter and wse:Filter are given
* see R10.2.2-52 of DSP0226 */
*faultcode = WSE_INVALID_MESSAGE;
return -1;
}
/* use the wse:Filter variant if wsman:Filter not given */
if (!wsman_f)
wsman_f = wse_f;
subsInfo->filter = wsman_f;
if (wsman_f) {
if (strcmp(wsman_f->dialect, WSM_CQL_FILTER_DIALECT) == 0)
subsInfo->flags |= WSMAN_SUBSCRIPTION_CQL;
else if (strcmp(wsman_f->dialect, WSM_WQL_FILTER_DIALECT) == 0)
subsInfo->flags |= WSMAN_SUBSCRIPTION_WQL;
else {
*faultcode = WSE_FILTERING_NOT_SUPPORTED;
return -1;
}
} else {
if (is_existing_filter_epr(ws_xml_get_soap_header(doc), &wsman_f)) {
*faultcode = WSE_FILTERING_NOT_SUPPORTED;
return -1;
} else {
subsInfo->flags |= WSMAN_SUBSCRIPTION_SELECTORSET;
}
}
}
return 0;
}
static void
handle_resource_request(WsManClient * cl, WsXmlDocH request,
void *data,
void *typeInfo,
char *resource_uri)
{
if (data && typeInfo) {
char *class = u_strdup(strrchr(resource_uri, '/') + 1);
ws_serialize(cl->serctx, ws_xml_get_soap_body(request),
data, (XmlSerializerInfo *) typeInfo,
class, resource_uri, NULL, 1);
ws_serializer_free_mem(cl->serctx, data,
(XmlSerializerInfo *) typeInfo);
u_free(class);
} else if (data != NULL) {
hash_t *
wsman_get_selector_list_from_filter(WsContextH cntx, WsXmlDocH doc)
{
WsXmlNodeH body;
WsXmlNodeH node, assInst, object;
if (doc == NULL) {
doc = cntx->indoc;
if (!doc)
return NULL;
}
body = ws_xml_get_soap_body(doc);
node = ws_xml_get_child(body, 0, XML_NS_ENUMERATION, WSENUM_ENUMERATE);
if(!node) {
debug("no SelectorSet defined. Missing Enumerate");
return NULL;
}
node = ws_xml_get_child(node, 0, XML_NS_WS_MAN, WSENUM_FILTER);
if(!node) {
debug("no SelectorSet defined. Missing Filter");
return NULL;
}
assInst = ws_xml_get_child(node, 0, XML_NS_CIM_BINDING, WSMB_ASSOCIATION_INSTANCES);
if(!assInst) {
assInst = ws_xml_get_child(node, 0, XML_NS_CIM_BINDING, WSMB_ASSOCIATED_INSTANCES);
if(!assInst) {
debug("no SelectorSet defined. Missing AssociationInstances / AssociatedInstances");
return NULL;
}
}
object = ws_xml_get_child(assInst, 0, XML_NS_CIM_BINDING, WSMB_OBJECT);
if(!node) {
debug("no SelectorSet defined. Missing Object");
return NULL;
}
node = ws_xml_get_child(object, 0, XML_NS_ADDRESSING, WSA_REFERENCE_PARAMETERS);
if(!node) {
debug("no SelectorSet defined. Missing ReferenceParameters");
return NULL;
}
return wsman_get_selectors_from_epr(cntx, node);
}
char *xml_parser_get_xpath_value(WsXmlDocH doc, const char *expression)
{
//int i;
char *result = NULL;
xmlXPathObject *obj;
xmlNodeSetPtr nodeset;
xmlXPathContextPtr ctxt;
xmlDocPtr d = (xmlDocPtr) doc->parserDoc;
WsXmlNodeH body;
ctxt = xmlXPathNewContext(d);
if (ctxt == NULL) {
error("failed while creating xpath context");
return NULL;
}
body = ws_xml_get_soap_body(doc);
register_namespaces(ctxt, doc, xml_parser_get_root(doc));
if (ws_xml_get_child(body, 0, NULL, NULL)) {
register_namespaces(ctxt, doc,
ws_xml_get_child(body, 0, NULL, NULL));
}
obj = xmlXPathEvalExpression(BAD_CAST expression, ctxt);
if (obj) {
nodeset = obj->nodesetval;
if (nodeset && nodeset->nodeNr > 0)
result = (char *) xmlNodeListGetString(d,
nodeset->
nodeTab[0]->
xmlChildrenNode,
1);
xmlXPathFreeContext(ctxt);
xmlXPathFreeObject(obj);
} else {
return NULL;
}
return result;
}
int main(int argc, char *argv[])
{
WsSerializerContextH cntx = ws_serializer_init();
// SoapH soap = ws_context_get_runtime(cntx);
WsXmlDocH doc = ws_xml_read_file( argv[1], "UTF-8", 0 );
WsXmlNodeH node = ws_xml_get_soap_body(doc);
if (!node)
printf("no xml\n");
//node = ws_xml_get_child(node, 0, NULL, NULL);
CIM_ComputerSystem *cs = (CIM_ComputerSystem *)ws_deserialize(cntx,
node,
CIM_ComputerSystem_TypeInfo,
"CIM_ComputerSystem",
NULL, NULL,
0, 0);
if (cs == NULL) {
printf("No cs\n");
return 1;
}
printf("NameFormat = <%s>\n", cs->NameFormat);
/*
printf("test[0] <%s>\n", cs->test[0]);
printf("test[1] <%s>\n", cs->test[1]);
printf("cs->foo.count = %d\n", cs->foo.count);
if (cs->foo.data == NULL) {
printf("No cs->foo.data\n");
return 1;
}
int i;
char **p = (char **)cs->foo.data;
for (i = 0; i < cs->foo.count; i++) {
printf(" foo[%d] = <%s>\n", i, *p);
p++;
}
*/
return 0;
}
/**
* Check if Envelope is valid
* @param msg Message data
* @param doc XML document
* @return 1 if envelope is valid, 0 if not
*/
int wsman_is_valid_xml_envelope(WsXmlDocH doc)
{
int retval = 1;
char *soapNsUri;
WsXmlNodeH root = ws_xml_get_doc_root(doc);
if (strcmp(SOAP_ENVELOPE, ws_xml_get_node_local_name(root)) != 0) {
retval = 0;
goto cleanup;
}
soapNsUri = ws_xml_get_node_name_ns(root);
if (strcmp(soapNsUri, XML_NS_SOAP_1_2) != 0) {
retval = 0;
goto cleanup;
}
if (ws_xml_get_soap_body(doc) == NULL) {
retval = 0;
goto cleanup;
}
cleanup:
return retval;
}
/* This function guarantees that query is freed, even on failure */
int
hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root,
XmlSerializerInfo *serializerInfo, const char *resourceUri,
const char *className, hypervObject **list)
{
int result = -1;
WsSerializerContextH serializerContext;
client_opt_t *options = NULL;
char *query_string = NULL;
filter_t *filter = NULL;
WsXmlDocH response = NULL;
char *enumContext = NULL;
hypervObject *head = NULL;
hypervObject *tail = NULL;
WsXmlNodeH node = NULL;
XML_TYPE_PTR data = NULL;
hypervObject *object;
if (virBufferCheckError(query) < 0) {
virBufferFreeAndReset(query);
return -1;
}
query_string = virBufferContentAndReset(query);
if (list == NULL || *list != NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument"));
VIR_FREE(query_string);
return -1;
}
serializerContext = wsmc_get_serialization_context(priv->client);
options = wsmc_options_init();
if (options == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not initialize options"));
goto cleanup;
}
filter = filter_create_simple(WSM_WQL_FILTER_DIALECT, query_string);
if (filter == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not create filter"));
goto cleanup;
}
response = wsmc_action_enumerate(priv->client, root, options, filter);
if (hyperyVerifyResponse(priv->client, response, "enumeration") < 0)
goto cleanup;
enumContext = wsmc_get_enum_context(response);
ws_xml_destroy_doc(response);
response = NULL;
while (enumContext != NULL && *enumContext != '\0') {
response = wsmc_action_pull(priv->client, resourceUri, options,
filter, enumContext);
if (hyperyVerifyResponse(priv->client, response, "pull") < 0)
goto cleanup;
node = ws_xml_get_soap_body(response);
if (node == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not lookup SOAP body"));
goto cleanup;
}
node = ws_xml_get_child(node, 0, XML_NS_ENUMERATION, WSENUM_PULL_RESP);
if (node == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not lookup pull response"));
goto cleanup;
}
node = ws_xml_get_child(node, 0, XML_NS_ENUMERATION, WSENUM_ITEMS);
if (node == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not lookup pull response items"));
goto cleanup;
}
if (ws_xml_get_child(node, 0, resourceUri, className) == NULL)
break;
data = ws_deserialize(serializerContext, node, serializerInfo,
className, resourceUri, NULL, 0, 0);
if (data == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not deserialize pull response item"));
goto cleanup;
}
if (VIR_ALLOC(object) < 0)
goto cleanup;
object->serializerInfo = serializerInfo;
object->data = data;
data = NULL;
if (head == NULL) {
head = object;
} else {
tail->next = object;
}
tail = object;
VIR_FREE(enumContext);
enumContext = wsmc_get_enum_context(response);
ws_xml_destroy_doc(response);
response = NULL;
}
*list = head;
head = NULL;
result = 0;
cleanup:
if (options != NULL)
wsmc_options_destroy(options);
if (filter != NULL)
filter_destroy(filter);
if (data != NULL) {
#if WS_SERIALIZER_FREE_MEM_WORKS
/* FIXME: ws_serializer_free_mem is broken in openwsman <= 2.2.6,
* see hypervFreeObject for a detailed explanation. */
if (ws_serializer_free_mem(serializerContext, data,
serializerInfo) < 0) {
VIR_ERROR(_("Could not free deserialized data"));
}
#endif
}
VIR_FREE(query_string);
ws_xml_destroy_doc(response);
VIR_FREE(enumContext);
hypervFreeObject(priv, head);
return result;
}
/**
* Check if Envelope is valid
* @param msg Message data
* @param doc XML document
* @return 1 if envelope is valid, 0 if not
*/
int wsman_is_valid_envelope(WsmanMessage * msg, WsXmlDocH doc)
{
int retval = 1;
char *soapNsUri;
WsXmlNodeH header;
WsXmlNodeH root = ws_xml_get_doc_root(doc);
if (strcmp(SOAP_ENVELOPE, ws_xml_get_node_local_name(root)) != 0) {
wsman_set_fault(msg,
WSA_INVALID_MESSAGE_INFORMATION_HEADER, 0,
"No Envelope");
retval = 0;
debug("no envelope");
goto cleanup;
}
soapNsUri = ws_xml_get_node_name_ns(root);
if (strcmp(soapNsUri, XML_NS_SOAP_1_2) != 0) {
wsman_set_fault(msg, SOAP_FAULT_VERSION_MISMATCH, 0, NULL);
retval = 0;
debug("version mismatch");
goto cleanup;
}
if (ws_xml_get_soap_body(doc) == NULL) {
wsman_set_fault(msg,
WSA_INVALID_MESSAGE_INFORMATION_HEADER, 0,
"No Body");
retval = 0;
debug("no body");
goto cleanup;
}
header = ws_xml_get_soap_header(doc);
if (!header) {
wsman_set_fault(msg,
WSA_INVALID_MESSAGE_INFORMATION_HEADER, 0,
"No Header");
retval = 0;
debug("no header");
goto cleanup;
} else {
if (!wsman_is_identify_request(doc) && !wsman_is_event_related_request(doc)) {
WsXmlNodeH resource_uri =
ws_xml_get_child(header, 0,
XML_NS_WS_MAN,
WSM_RESOURCE_URI);
WsXmlNodeH action = ws_xml_get_child(header, 0,
XML_NS_ADDRESSING,
WSA_ACTION);
WsXmlNodeH reply = ws_xml_get_child(header, 0,
XML_NS_ADDRESSING,
WSA_REPLY_TO);
WsXmlNodeH to = ws_xml_get_child(header, 0,
XML_NS_ADDRESSING,
WSA_TO);
if (!resource_uri) {
wsman_set_fault(msg,
WSA_DESTINATION_UNREACHABLE,
WSMAN_DETAIL_INVALID_RESOURCEURI,
NULL);
retval = 0;
debug("no wsman:ResourceURI");
goto cleanup;
}
if (!action) {
wsman_set_fault(msg,
WSA_ACTION_NOT_SUPPORTED,
0, NULL);
retval = 0;
debug("no wsa:Action");
goto cleanup;
}
if (!reply) {
wsman_set_fault(msg,
WSA_MESSAGE_INFORMATION_HEADER_REQUIRED,
0, NULL);
retval = 0;
debug("no wsa:ReplyTo");
goto cleanup;
}
if (!to) {
wsman_set_fault(msg,
WSA_DESTINATION_UNREACHABLE,
0, NULL);
retval = 0;
debug("no wsa:To");
goto cleanup;
}
}
}
cleanup:
return retval;
}
/**
* 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;
}
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;
}
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;
}
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;
}
/**
* 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;
}
static void
wsman_set_subscribe_options(WsManClient * cl,
WsXmlDocH request,
const char* resource_uri,
client_opt_t *options,
filter_t *filter)
{
WsXmlNodeH body = ws_xml_get_soap_body(request);
WsXmlNodeH header = ws_xml_get_soap_header(request);
WsXmlNodeH node = NULL, temp = NULL, node2 = NULL, node3 = NULL;
char buf[32];
if(options->delivery_certificatethumbprint ||options->delivery_password ||
options->delivery_password) {
node = ws_xml_add_child(header, XML_NS_TRUST, WST_ISSUEDTOKENS, NULL);
ws_xml_add_node_attr(node, XML_NS_SOAP_1_2, SOAP_MUST_UNDERSTAND, "true");
if(options->delivery_certificatethumbprint) {
node2 = ws_xml_add_child(node, XML_NS_TRUST, WST_REQUESTSECURITYTOKENRESPONSE, NULL);
ws_xml_add_child(node2, XML_NS_TRUST, WST_TOKENTYPE,WST_CERTIFICATETHUMBPRINT );
node3 = ws_xml_add_child(node2, XML_NS_TRUST, WST_REQUESTEDSECURITYTOKEN, NULL);
ws_xml_add_child(node3, XML_NS_WS_MAN, WSM_CERTIFICATETHUMBPRINT,
options->delivery_certificatethumbprint);
node3 = ws_xml_add_child(node2, XML_NS_POLICY, WSP_APPLIESTO, NULL);
node3 = ws_xml_add_child(node3, XML_NS_ADDRESSING, WSA_EPR, NULL);
ws_xml_add_child(node3, XML_NS_ADDRESSING, WSA_ADDRESS, options->delivery_uri);
}
if(options->delivery_username || options->delivery_password) {
node2 = ws_xml_add_child(node, XML_NS_TRUST, WST_REQUESTSECURITYTOKENRESPONSE, NULL);
ws_xml_add_child(node2, XML_NS_TRUST, WST_TOKENTYPE,WST_USERNAMETOKEN);
node3 = ws_xml_add_child(node2, XML_NS_TRUST, WST_REQUESTEDSECURITYTOKEN, NULL);
node3 = ws_xml_add_child(node3, XML_NS_SE, WSSE_USERNAMETOKEN, NULL);
if(options->delivery_username)
ws_xml_add_child(node3, XML_NS_SE, WSSE_USERNAME, options->delivery_username);
if(options->delivery_password)
ws_xml_add_child(node3, XML_NS_SE, WSSE_PASSWORD, options->delivery_password);
node3 = ws_xml_add_child(node2, XML_NS_POLICY, WSP_APPLIESTO, NULL);
node3 = ws_xml_add_child(node3, XML_NS_ADDRESSING, WSA_EPR, NULL);
ws_xml_add_child(node3, XML_NS_ADDRESSING, WSA_ADDRESS, options->delivery_uri);
}
}
node = ws_xml_add_child(body,
XML_NS_EVENTING, WSEVENT_SUBSCRIBE,NULL);
temp = ws_xml_add_child(node, XML_NS_EVENTING, WSEVENT_DELIVERY, NULL);
if(temp) {
ws_xml_add_node_attr(temp, NULL, WSEVENT_DELIVERY_MODE,
wsmc_create_delivery_mode_str(options->delivery_mode));
if(options->delivery_uri) {
node2 = ws_xml_add_child(temp, XML_NS_EVENTING, WSEVENT_NOTIFY_TO, NULL);
ws_xml_add_child(node2, XML_NS_ADDRESSING, WSA_ADDRESS, options->delivery_uri);
}
if(options->delivery_sec_mode) {
temp = ws_xml_add_child(temp, XML_NS_WS_MAN, WSM_AUTH, NULL);
ws_xml_add_node_attr(temp, NULL, WSM_PROFILE,
wsmc_create_delivery_sec_mode_str(options->delivery_sec_mode));
}
if(options->heartbeat_interval) {
snprintf(buf, 32, "PT%fS", options->heartbeat_interval);
ws_xml_add_child(temp, XML_NS_WS_MAN, WSM_HEARTBEATS, buf);
}
if(options->reference) {
WsXmlDocH doc = ws_xml_read_memory( options->reference, strlen(options->reference), "UTF-8", 0);
node3 = ws_xml_get_doc_root(doc);
temp = ws_xml_add_child(node2, XML_NS_ADDRESSING, WSA_REFERENCE_PROPERTIES, NULL);
if(temp)
ws_xml_duplicate_tree(temp, node3);
}
}
if (options->expires) {
snprintf(buf, 32, "PT%fS", options->expires);
ws_xml_add_child(node, XML_NS_EVENTING, WSEVENT_EXPIRES, buf);
}
if (filter) {
filter_serialize(node, filter, XML_NS_WS_MAN);
}
if (options->flags & FLAG_EVENT_SENDBOOKMARK) {
ws_xml_add_child(node, XML_NS_WS_MAN, WSM_SENDBOOKMARKS, NULL);
}
}
