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; }