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;
}
static void
debug_message_handler(const char *str,
debug_level_e level, void *user_data)
{
if (log_pid == 0)
log_pid = getpid();
if ( is_debug > 0) {
struct tm *tm;
time_t now;
char timestr[128];
char *log_msg;
//int p;
time(&now);
tm = localtime(&now);
//strftime(timestr, 128, "%b %e %T", tm);
log_msg = u_strdup_printf("%s [%d] %s\n",
timestr, log_pid, str);
//if ((p =
// write(STDERR_FILENO, log_msg, strlen(log_msg))) < 0)
// fprintf(stderr, "Failed writing to log file\n");
//fsync(STDERR_FILENO);
u_free(log_msg);
}
}
static void enumeration_test(void) {
char *enumContext = NULL;
static int i = 0;
char *selectors = NULL;
wsmc_reinit_conn(cl);
options = wsmc_options_init();
options->flags = tests[i].flags;
if (tests[i].selectors) {
selectors =
u_strdup_printf(tests[i].selectors, host, host, host);
wsmc_add_selectors_from_str(options, selectors);
}
options->max_elements = tests[i].max_elements;
WsXmlDocH enum_response = wsmc_action_enumerate(cl,
(char *)tests[i].resource_uri, options, NULL);
CU_ASSERT_TRUE(wsmc_get_response_code(cl) == tests[i].final_status);
if (wsmc_get_response_code(cl) != tests[i].final_status) {
if (verbose) {
printf("\nExpected = %d\nReturned = %ld ",
tests[i].final_status, wsmc_get_response_code(cl));
}
goto RETURN;
}
CU_ASSERT_PTR_NOT_NULL(enum_response);
if (enum_response) {
enumContext = wsmc_get_enum_context(enum_response);
} else {
goto RETURN;
}
check_response_header(enum_response, wsmc_get_response_code(cl),
ENUM_ACTION_ENUMERATERESPONSE);
//if (i==11) ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(enum_response));
handle_filters(enum_response, filters);
handle_filters(enum_response, tests[i].common_filters);
handle_filters(enum_response, tests[i].filters);
RETURN:
u_free(selectors);
if (enumContext) {
wsmc_action_release(cl,
(char *)tests[i].resource_uri,
options,
enumContext);
}
if (enum_response) {
ws_xml_destroy_doc(enum_response);
}
wsmc_options_destroy(options);
i++; // decrease executed test number
}
const char *wsmand_options_get_config_file(void)
{
char *p;
if (config_file == NULL) {
config_file = DEFAULT_CONFIG_FILE;
}
if (config_file != NULL && !u_path_is_absolute(config_file)) {
char cwd[PATH_MAX];
if ((p = getcwd(cwd, PATH_MAX)) != NULL)
config_file =
u_strdup_printf("%s/%s", cwd, config_file);
}
return config_file;
}
static void
scan_plugins_in_directory ( WsManListenerH *listener,
const char *dir_name)
{
list_t *files = scan_files_in_dir ( dir_name, select_all_files);
lnode_t *node = list_first(files);
listener->plugins = list_create(LISTCOUNT_T_MAX);
while (node != NULL)
{
const char* entry_name;
int retv = -1;
entry_name = (const char*) node->list_data;
node = list_next(files, node);
if ((NULL != entry_name) && strlen (entry_name) > strlen(PLUGIN_EXT)
&& (0 == strcmp (&entry_name[strlen(entry_name)-strlen(PLUGIN_EXT)], PLUGIN_EXT)))
{
char *plugin_path = u_strdup_printf ("%s/%s", dir_name, entry_name);
WsManPlugin *plugin = plugin_new();
if ((NULL != plugin) && (NULL != plugin_path))
{
if (load_plugin(plugin, plugin_path) == 0 )
{
lnode_t *plg = lnode_create (plugin);
list_append (listener->plugins, plg);
retv = 0 ;
}
} else {
error("Out of memory scanning for plugins.");
}
if (plugin_path)
u_free (plugin_path);
if (retv != 0 && (NULL != plugin))
plugin_free(plugin);
}
}
list_destroy_nodes(files);
list_destroy(files);
return;
}
void
wsmc_handler( WsManClient *cl,
WsXmlDocH rqstDoc,
void* user_data)
{
#define curl_err(str) debug("Error = %d (%s); %s", \
r, curl_easy_strerror(r), str);
WsManConnection *con = cl->connection;
CURL *curl = NULL;
CURLcode r;
char *upwd = NULL;
char *usag = NULL;
struct curl_slist *headers=NULL;
char *buf = NULL;
int len;
char *soapact_header = NULL;
long http_code;
long auth_avail = 0;
char *_user = NULL, *_pass = NULL;
u_buf_t *response = NULL;
//char *soapaction;
char *tmp_str = NULL;
if (!cl->initialized && wsmc_transport_init(cl, NULL)) {
cl->last_error = WS_LASTERR_FAILED_INIT;
return;
}
if (cl->transport == NULL) {
cl->transport = init_curl_transport(cl);
if (cl->transport == NULL) {
return;
}
}
curl = (CURL *)cl->transport;
r = curl_easy_setopt(curl, CURLOPT_URL, cl->data.endpoint);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("Could not curl_easy_setopt(curl, CURLOPT_URL, ...)");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_handler);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("Could not curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ..)");
goto DONE;
}
u_buf_create(&response);
r = curl_easy_setopt(curl, CURLOPT_WRITEDATA, response);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("Could not curl_easy_setopt(curl, CURLOPT_WRITEDATA, ..)");
goto DONE;
}
char content_type[64];
snprintf(content_type, 64, "Content-Type: application/soap+xml;charset=%s", cl->content_encoding);
headers = curl_slist_append(headers, content_type);
tmp_str = wsman_transport_get_agent(cl);
usag = malloc(12 + strlen(tmp_str) + 1);
if (usag == NULL) {
r = CURLE_OUT_OF_MEMORY;
cl->fault_string = u_strdup("Could not malloc memory");
curl_err("Could not malloc memory");
goto DONE;
}
sprintf(usag, "User-Agent: %s", tmp_str);
free(tmp_str);
headers = curl_slist_append(headers, usag);
#if 0
soapaction = ws_xml_get_xpath_value(rqstDoc, "/s:Envelope/s:Header/wsa:Action");
if (soapaction) {
soapact_header = malloc(12 + strlen(soapaction) + 1);
if (soapact_header) {
sprintf(soapact_header, "SOAPAction: %s", soapaction);
headers = curl_slist_append(headers, soapact_header);
}
u_free(soapaction);
}
#endif
r = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("Could not curl_easy_setopt(curl, CURLOPT_HTTPHEADER, ..)");
goto DONE;
}
ws_xml_dump_memory_enc(rqstDoc, &buf, &len, cl->content_encoding);
#if 0
int count = 0;
while(count < len) {
printf("%c",buf[count++]);
}
#endif
debug("*****set post buf len = %d******",len);
r = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, buf);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("Could not curl_easy_setopt(curl, CURLOPT_POSTFIELDS, ..)");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("Could not curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, ..)");
goto DONE;
}
int iDone = 0;
while (1) {
u_free(_user);
u_free(_pass);
_user = wsmc_get_user(cl);
_pass = wsmc_get_password(cl);
if (_user && _pass && cl->data.auth_set) {
r = curl_easy_setopt(curl, CURLOPT_HTTPAUTH, cl->data.auth_set);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("curl_easy_setopt(CURLOPT_HTTPAUTH) failed");
goto DONE;
}
u_free(upwd);
upwd = u_strdup_printf( "%s:%s", _user , _pass);
if (!upwd) {
r = CURLE_OUT_OF_MEMORY;
cl->fault_string = u_strdup("Could not malloc memory");
curl_err("Could not malloc memory");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_USERPWD, upwd);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("curl_easy_setopt(curl, CURLOPT_USERPWD, ..) failed");
goto DONE;
}
}
if (wsman_debug_level_debugged(DEBUG_LEVEL_MESSAGE)) {
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
r = curl_easy_perform(curl);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("curl_easy_perform failed");
goto DONE;
}
r = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("curl_easy_getinfo(CURLINFO_RESPONSE_CODE) failed");
goto DONE;
}
switch (http_code)
{
case 200:
case 400:
case 500:
// The resource was successfully retrieved or WSMan server
// returned a HTTP status code. You can use WinHttpReadData to
// read the contents of the server's response.
iDone = 1;
break;
case 401:
// The server requires authentication.
break;
default:
// The status code does not indicate success.
r = WS_LASTERR_OTHER_ERROR;
iDone = 1;
break;
}
if(iDone == 1) {
break;
}
/* we are here because of authentication required */
r = curl_easy_getinfo(curl, CURLINFO_HTTPAUTH_AVAIL, &auth_avail);
if (r != CURLE_OK) {
cl->fault_string = u_strdup(curl_easy_strerror(r));
curl_err("curl_easy_getinfo(CURLINFO_HTTPAUTH_AVAIL) failed");
goto DONE;
}
cl->data.auth_set = reauthenticate(cl, cl->data.auth_set, auth_avail,
&cl->data.user, &cl->data.pwd);
u_buf_clear(response);
if (cl->data.auth_set == 0) {
/* FIXME: user wants to cancel authentication */
#if LIBCURL_VERSION_NUM >= 0x70D01
r = CURLE_LOGIN_DENIED;
#else
/* Map the login failure error to CURLE_LOGIN_DENIED (67) so that we
* get the same error code in case of login failure
*/
r = 67;
#endif
curl_err("user/password wrong or empty.");
break;
}
}
#if 0
unsigned char *mbbuf = NULL;
iconv_t cd;
if(strcmp(cl->content_encoding, "UTF-8")) {
cd = iconv_open("UTF-8", cl->content_encoding);
if(cd == -1) {
cl->last_error = WS_LASTERR_BAD_CONTENT_ENCODING;
goto DONE2;
}
mbbuf = u_zalloc(u_buf_len(response));
size_t outbuf_len = u_buf_len(response);
size_t inbuf_len = outbuf_len;
char *inbuf = u_buf_ptr(response);
char *outbuf = mbbuf;
size_t coverted = iconv(cd, &inbuf, &inbuf_len, &outbuf, &outbuf_len);
iconv_close(cd);
if( coverted == -1) {
cl->last_error = WS_LASTERR_BAD_CONTENT_ENCODING;
goto DONE2;
}
u_buf_append(con->response, mbbuf, u_buf_len(response) - inbuf_len);
}
u_free(mbbuf);
#endif
u_buf_append(con->response, u_buf_ptr(response), u_buf_len(response));
DONE:
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
cl->response_code = http_code;
cl->last_error = convert_to_last_error(r);
debug("curl error code: %d.", r);
debug("cl->response_code: %d.", cl->response_code);
debug("cl->last_error code: %d.", cl->last_error);
curl_slist_free_all(headers);
u_buf_free(response);
u_free(soapact_header);
u_free(usag);
u_free(upwd);
u_free(_pass);
u_free(_user);
#ifdef _WIN32
ws_xml_free_memory(buf);
#else
u_free(buf);
#endif
return;
#undef curl_err
}
int main(int argc, char** argv)
{
int i;
int choice = 0;
WsManClient *cl;
WsXmlDocH doc;
client_opt_t *options = NULL;
WsXmlDocH resource = NULL;
if (getenv("OPENWSMAN_TEST_HOST")) {
host = getenv("OPENWSMAN_TEST_HOST");
}
resource = wsmc_read_file("./requests/create.xml", "UTF-8", 0);
if(argc > 1)
choice = atoi(argv[1]);
for (i = 0; i < ntests; i++)
{
if(choice && i != choice -1)
continue;
if (tests[i].selectors) {
tests[i].selectors = u_strdup_printf(tests[i].selectors, host, host, host);
}
if (tests[i].expected_value) {
tests[i].expected_value = u_strdup_printf(tests[i].expected_value, host, host, host);
}
printf ("Test %3d: %s ", i + 1, tests[i].explanation);
cl = wsmc_create(
sd[0].server,
sd[0].port,
sd[0].path,
sd[0].scheme,
sd[0].username,
sd[0].password);
wsmc_transport_init(cl, NULL);
options = wsmc_options_init();
if (tests[i].selectors != NULL)
wsmc_add_selectors_from_str (options, tests[i].selectors);
wsmc_set_action_option(options, FLAG_DUMP_REQUEST);
doc = wsmc_action_create(cl, (char *)tests[i].resource_uri, options, resource);
if (!doc) {
printf("\t\t\033[22;31mUNRESOLVED\033[m\n");
goto CONTINUE;
}
wsman_output(doc);
if (tests[i].final_status != wsmc_get_response_code(cl)) {
printf("Status = %ld \t\t\033[22;31mFAILED\033[m\n",
wsmc_get_response_code(cl));
goto CONTINUE;
}
if ((char *)tests[i].expected_value != NULL)
{
char *xp = ws_xml_get_xpath_value(doc, (char *)tests[i].xpath_expression);
if (xp)
{
if (strcmp(xp,(char *)tests[i].expected_value ) == 0)
printf("\t\t\033[22;32mPASSED\033[m\n");
else
printf("%s = %s\t\033[22;31mFAILED\033[m\n",(char *)tests[i].xpath_expression, xp);
u_free(xp);
} else {
printf(" No %s\t\033[22;31mFAILED\033[m\n", (char *)tests[i].xpath_expression);
ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(doc));
}
} else {
printf("\t\t\033[22;32mPASSED\033[m\n");
}
ws_xml_destroy_doc(doc);
CONTINUE:
u_free(tests[i].selectors);
u_free(tests[i].expected_value);
wsmc_options_destroy(options);
wsmc_release(cl);
}
return 0;
}
static void transfer_put_test(void) {
WsXmlDocH doc;
char *xpf = NULL;
char *xpd = NULL;
static int i = 0; // executed test number.
char *selectors = NULL;
if (put_tests[i].selectors) {
selectors =
u_strdup_printf(put_tests[i].selectors, host, host, host);
}
options = wsmc_options_init();
if (put_tests[i].selectors != NULL) {
wsmc_add_selectors_from_str (options, selectors);
}
if (put_tests[i].properties != NULL) {
wsmc_add_prop_from_str (options,
put_tests[i].properties);
}
options->flags = put_tests[i].flags;
doc = wsmc_action_get_and_put(cl, (char *)put_tests[i].resource_uri, options);
//ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(doc));
CU_ASSERT_TRUE(wsmc_get_response_code(cl) ==
put_tests[i].final_status);
if (wsmc_get_response_code(cl) !=
put_tests[i].final_status) {
if (verbose) {
printf("\nExpected = %d, Returned = %ld ",
put_tests[i].final_status,
wsmc_get_response_code(cl));
// ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(doc));
}
goto RETURN;
}
CU_ASSERT_PTR_NOT_NULL(doc);
if (!doc) {
goto RETURN;
}
if (put_tests[i].expr1 == NULL) {
goto RETURN;
}
CU_ASSERT_PTR_NOT_NULL(put_tests[i].value1);
if (put_tests[i].value1 == NULL) {
goto RETURN;
}
xpf = ws_xml_get_xpath_value(doc, put_tests[i].expr1);
CU_ASSERT_PTR_NOT_NULL(xpf);
if (!xpf) {
goto RETURN;
}
CU_ASSERT_STRING_EQUAL(xpf, put_tests[i].value1);
if (strcmp(xpf, put_tests[i].value1)) {
if (verbose) {
printf("Expected %s\nReturned %s ",
put_tests[i].value1, xpf);
}
goto RETURN;
}
if (put_tests[i].expr2 == NULL) {
goto RETURN;
}
xpd = ws_xml_get_xpath_value(doc, put_tests[i].expr2);
CU_ASSERT_PTR_NOT_NULL(xpd);
if (!xpd) {
goto RETURN;
}
CU_ASSERT_PTR_NOT_NULL(put_tests[i].value2);
if (put_tests[i].value2 == NULL) {
goto RETURN;
}
CU_ASSERT_STRING_EQUAL(xpd, put_tests[i].value2 );
if (strcmp(xpd, put_tests[i].value2)) {
if (verbose) {
printf("\nExpected %sReturned %s ",
put_tests[i].value2, xpd);
}
goto RETURN;
}
RETURN:
u_free(xpf);
u_free(xpd);
if (doc) {
ws_xml_destroy_doc(doc);
}
u_free(selectors);
wsmc_options_destroy(options);
i++; // increase executed test number
}
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;
}
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;
}
