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;
}
/**
* Duplicate an XML document
* @param dstSoap Destination SOAP handle
* @param srcDoc the Source document
* @return The new XML document
*/
WsXmlDocH ws_xml_duplicate_doc( WsXmlDocH srcDoc)
{
WsXmlDocH dst = NULL;
WsXmlNodeH srcRoot = NULL;
const char *name, *nsUri;
if (!srcDoc)
return NULL;
srcRoot = ws_xml_get_doc_root(srcDoc);
if (!srcRoot)
return NULL;
name = ws_xml_get_node_local_name(srcRoot);
nsUri = ws_xml_get_node_name_ns(srcRoot);
if ((dst = ws_xml_create_doc(nsUri, name)) != NULL) {
int i;
WsXmlNodeH node;
WsXmlNodeH dstRoot = ws_xml_get_doc_root(dst);
for (i = 0; (node = ws_xml_get_child(srcRoot,
i, NULL, NULL)) != NULL; i++) {
ws_xml_duplicate_tree(dstRoot, node);
}
}
return dst;
}
static int is_mu_header(WsXmlNodeH header)
{
int i;
char *name, *ns;
static struct __MuHeaderInfo s_Info[] = {
{XML_NS_ADDRESSING, WSA_TO},
{XML_NS_ADDRESSING, WSA_MESSAGE_ID},
{XML_NS_ADDRESSING, WSA_RELATES_TO},
{XML_NS_ADDRESSING, WSA_ACTION},
{XML_NS_ADDRESSING, WSA_REPLY_TO},
{XML_NS_ADDRESSING, WSA_FROM},
{XML_NS_WS_MAN, WSM_RESOURCE_URI},
{XML_NS_WS_MAN, WSM_SELECTOR_SET},
{XML_NS_WS_MAN, WSM_MAX_ENVELOPE_SIZE},
{XML_NS_WS_MAN, WSM_OPERATION_TIMEOUT},
{XML_NS_WS_MAN, WSM_FRAGMENT_TRANSFER},
{XML_NS_TRUST, WST_ISSUEDTOKENS},
{NULL, NULL}
};
name = ws_xml_get_node_local_name(header);
ns = ws_xml_get_node_name_ns(header);
for (i = 0; s_Info[i].name != NULL; i++) {
if ((ns == NULL && s_Info[i].ns == NULL) ||
(ns != NULL && s_Info[i].ns != NULL &&
!strcmp(ns, s_Info[i].ns))) {
if (!strcmp(name, s_Info[i].name))
return 1;
}
}
debug("mustUnderstand: %s:%s", !ns ? "null" : ns, name ? name : "NULL");
return 0;
}
static void
generate_notunderstood_fault(op_t * op,
WsXmlNodeH notUnderstoodHeader)
{
WsXmlNodeH child;
WsXmlNodeH header;
if (op->in_doc == NULL)
return;
generate_op_fault(op, SOAP_FAULT_MUSTUNDERSTAND, 0);
if (op->out_doc != NULL) {
header = ws_xml_get_soap_header(op->out_doc);
if (header) {
child = ws_xml_add_child(header, XML_NS_SOAP_1_2,
"NotUnderstood", NULL);
ws_xml_add_qname_attr(child, NULL, "qname",
ws_xml_get_node_name_ns
(notUnderstoodHeader),
ws_xml_get_node_local_name
(notUnderstoodHeader));
}
} else {
error("cant generate fault");
}
return;
}
/**
* Is the XML node a qualified name
* @param node XML node
* @param nsUri Namespace URI
* @param name node name
* @return Returns 1 if node is QName
* @brief Shortcats for QName manipulation name can be NULL, in this case just check namespace
*/
int ws_xml_is_node_qname(WsXmlNodeH node, const char *nsUri,
const char *name)
{
int retVal = 0;
char *nodeNsUri = NULL;
if (!node)
return 0;
nodeNsUri = ws_xml_get_node_name_ns(node);
if ((nsUri == NULL)
|| (nsUri == nodeNsUri)
|| (nsUri != NULL && nodeNsUri != NULL && !strcmp(nodeNsUri, nsUri))) {
if (name == NULL || !strcmp(name, ws_xml_get_node_local_name(node)))
retVal = 1;
}
return retVal;
}
/**
* 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));
}
}
/**
* 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;
}
WsXmlNodeH
ws_xml_add_child_sort(WsXmlNodeH node,
const char *nsUri, const char *localName, const char *val, int xmlescape)
{
int i;
WsXmlNodeH child, newNode = NULL;
int count = ws_xml_get_child_count(node) ;
if ( count == 0 ) {
newNode = xml_parser_node_add(node, XML_LAST_CHILD, nsUri, localName, val, xmlescape);
} else {
for (i = 0; (child = ws_xml_get_child(node, i, NULL, NULL)) != NULL; i++) {
char *name = ws_xml_get_node_local_name(child);
if (strcmp(localName, name) < 0 ) {
newNode = xml_parser_node_add(child, XML_ELEMENT_PREV, nsUri, localName, val, xmlescape);
break;
}
}
if (newNode == NULL) {
newNode = xml_parser_node_add(node, XML_LAST_CHILD, nsUri, localName, val, xmlescape);
}
}
return newNode;
}
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;
}
/**
* 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;
}
