src/wsman-client-options.c - third_party/wsmancli - Git at Google

 /*******************************************************************************
  * Copyright (C) 2004-2006 Intel Corp. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  - Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  *
  *  - Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  *
  *  - Neither the name of Intel Corp. nor the names of its
  *    contributors may be used to endorse or promote products derived from this
  *    software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *******************************************************************************/

 /**
  * @author Anas Nashif
  */
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif


 #include "u/libu.h"
 #include "wsman-client-api.h"
 #include "wsman-client-transport.h"
 #include "wsman-client-options.h"
 #include "wsman-debug.h"

 #if 0
 static char *auth_methods[] = {
 	"basic",
 	"digest",
 	"ntlm",
 	NULL,
 };
 #endif

 static const char **wsman_argv = NULL;


 static int server_port = 0;
 static char *cafile = NULL;
 static char *username = NULL;
 static char *password = NULL;
 static char *server = "localhost";
 static char *agent = NULL;
 static char *url_path = NULL;
 static char *authentication_method = NULL;
 static char no_verify_peer = 0;
 static int  transport_timeout = 0;
 static char *proxy = NULL;
 static char *proxy_upwd = NULL;


 static int debug_level = -1;
 static char *test_case = NULL;
 static int enum_max_elements = 0;
 char enum_optimize = 0;
 char enum_estimate = 0;
 char dump_request = 0;
 char step = 0;
 char request_only = 0;
 char cim_extensions = 0;
 char cim_references = 0;
 static char *enum_mode = NULL;
 static char *binding_enum_mode = NULL;
 static char *enum_context = NULL;


 static char *cim_namespace = NULL;
 static char *fragment = NULL;
 static char *wsm_filter = NULL;
 static char *wsm_dialect = NULL;
 static char *input = NULL;

 static unsigned long operation_timeout = 0;
 static unsigned long max_envelope_size = 0;

 static char *_action = NULL;
 static char *config_file = NULL;
 static char *output_file = NULL;
 static char *resource_uri = NULL;
 static char *invoke_method = NULL;
 static char **properties = NULL;


 WsActions action_data[] = {
 	{"get", WSMAN_ACTION_TRANSFER_GET},
 	{"put", WSMAN_ACTION_TRANSFER_PUT},
 	{"create", WSMAN_ACTION_TRANSFER_CREATE},
 	{"delete", WSMAN_ACTION_TRANSFER_DELETE},
 	{"enumerate", WSMAN_ACTION_ENUMERATION},
 	{"pull", WSMAN_ACTION_PULL},
 	{"release", WSMAN_ACTION_RELEASE},
 	{"invoke", WSMAN_ACTION_CUSTOM},
 	{"identify", WSMAN_ACTION_IDENTIFY},
 	{"test", WSMAN_ACTION_TEST},
 	{NULL, 0},
 };

 char wsman_parse_options(int argc, char **argv)
 {

 	char retval = 0;
 	u_error_t *error = NULL;

 	u_option_entry_t options[] = {
 		{"debug", 'd', U_OPTION_ARG_INT, &debug_level,
 		 "Set the verbosity of debugging output.", "1-6"},
 		{"cafile", 'c', U_OPTION_ARG_STRING, &cafile,
 		 "Certificate file", "<filename>"},
 		{"username", 'u', U_OPTION_ARG_STRING, &username,
 		 "User name", "<username>"},
 		{"path", 'g', U_OPTION_ARG_STRING, &url_path,
 		 "Path", "<path>"},
 		{"input", 'J', U_OPTION_ARG_STRING, &input,
 		 "File with resource for Create and Put operations in XML, can be a SOAP envelope",
 		 "<filename>"},
 		{"password", 'p', U_OPTION_ARG_STRING, &password,
 		 "Password", "<password>"},
 		{"hostname", 'h', U_OPTION_ARG_STRING, &server,
 		 "Host name", "<hostname>"},
 		{"port", 'P', U_OPTION_ARG_INT, &server_port,
 		 "Server Port", "<port>"},
 		{"proxy", 'X', U_OPTION_ARG_STRING, &proxy,
 		 "Proxy name", "<proxy>"},
 		{"proxyauth", 'Y', U_OPTION_ARG_STRING, &proxy_upwd,
 		 "Proxy user:pwd", "<proxyauth>"},
 		{"auth", 'y', U_OPTION_ARG_STRING, &authentication_method,
 		 "Authentication Method", "<basic|digest|gss>"},
 		{"method", 'a', U_OPTION_ARG_STRING, &invoke_method,
 		 "Method (Works only with 'invoke')", "<custom method>"},
 		{"prop", 'k', U_OPTION_ARG_STRING_ARRAY, &properties,
 		 "Properties with key value pairs (For 'put', 'invoke' and 'create')",
 		 "<key=val>"},
 		{"config-file", 'C', U_OPTION_ARG_STRING, &config_file,
 		 "Alternate configuration file", "<file>"},
 		{"out-file", 'O', U_OPTION_ARG_STRING, &output_file,
 		 "Write output to file", "<file>"},
 		{"noverifypeer", 'V', U_OPTION_ARG_NONE, &no_verify_peer,
 		 "Not to verify peer certificate", NULL},
 		{"transport-timeout", 'I', U_OPTION_ARG_INT, &transport_timeout,
 		 "Transport timeout in seconds", "<time in sec>"},
 		{NULL}
 	};


 	u_option_entry_t request_options[] = {
 		{"filter", 'x', U_OPTION_ARG_STRING, &wsm_filter,
 		 "Filter", "<filter>"},
 		{"dialect", 'D', U_OPTION_ARG_STRING, &wsm_dialect,
 		 "Filter Dialect", "<dialect>"},
 		{"operation-timeout", 't', U_OPTION_ARG_INT, &operation_timeout,
 		 "Operation timeout in seconds", "<time in sec>"},
 		{"max-envelope-size", 'e', U_OPTION_ARG_INT,
 		 &max_envelope_size,
 		 "maximal envelope size", "<size>"},
 		{"fragment", 'F', U_OPTION_ARG_STRING, &fragment,
 		 "Fragment (Supported Dialects: XPATH)", "<fragment>"},
 		{NULL}
 	};

 	u_option_entry_t enum_options[] = {

 		{"max-elements", 'm', U_OPTION_ARG_INT, &enum_max_elements,
 		 "Max Elements Per Pull/Optimized Enumeration",
 		 "<max number of elements>"},
 		{"optimize", 'o', U_OPTION_ARG_NONE, &enum_optimize,
 		 "Optimize enumeration results", NULL},
 		{"estimate-count", 'E', U_OPTION_ARG_NONE, &enum_estimate,
 		 "Return estimation of total items", NULL},
 		{"enum-mode", 'M', U_OPTION_ARG_STRING, &enum_mode,
 		 "Enumeration Mode", "epr|objepr"},
 		{"enum-context", 'U', U_OPTION_ARG_STRING, &enum_context,
 		 "Enumeration Context (For use with Pull and Release)",
 		 "<enum context>"},
 		{NULL}
 	};

 	u_option_entry_t cim_options[] = {

 		{"namespace", 'N', U_OPTION_ARG_STRING, &cim_namespace,
 		 "CIM Namespace (default is root/cimv2)", "<namespace>"},
 		{"binding-enum-mode", 'B', U_OPTION_ARG_STRING,
 		 &binding_enum_mode,
 		 "CIM binding Enumeration Mode", "none|include|exclude"},
 		{"cim-extensions", 'T', U_OPTION_ARG_NONE, &cim_extensions,
 		 "Show CIM Extensions", NULL},
 		{"references", 'W', U_OPTION_ARG_NONE, &cim_references,
 		 "CIM References", NULL},
 		{NULL}
 	};

 	u_option_entry_t test_options[] = {
 		{"from-file", 'f', U_OPTION_ARG_STRING, &test_case,
 		 "Send request from file", "<file name>"},
 		{"print-request", 'R', U_OPTION_ARG_NONE, &dump_request,
 		 "print request on stdout", NULL},
 		{"request", 'Q', U_OPTION_ARG_NONE, &request_only,
 		 "Only output reqest. Not send it.", NULL},
 		{"step", 'S', U_OPTION_ARG_NONE, &step,
 		 "Do not perform multiple operations (do not pull data when enumerating)",
 		 NULL},
 		//{ "print-response", 'N', 0, G_OPTION_ARG_NONE, &dump_response, "print all responses to stdout", NULL},
 		{NULL}
 	};

 	u_option_group_t *enum_group;
 	u_option_group_t *test_group;
 	u_option_group_t *cim_group;
 	u_option_group_t *req_flag_group;

 	u_option_context_t *opt_ctx;
 	opt_ctx = u_option_context_new("<action> <Resource Uri>");
 	enum_group = u_option_group_new("enumeration", "Enumeration",
 					"Enumeration Options");
 	test_group = u_option_group_new("tests", "Tests", "Test Cases");
 	cim_group = u_option_group_new("cim", "CIM", "CIM Options");
 	req_flag_group =
 	    u_option_group_new("flags", "Flags", "Request Flags");

 	u_option_group_add_entries(enum_group, enum_options);
 	u_option_group_add_entries(test_group, test_options);
 	u_option_group_add_entries(cim_group, cim_options);
 	u_option_group_add_entries(req_flag_group, request_options);

 	u_option_context_set_ignore_unknown_options(opt_ctx, FALSE);
 	u_option_context_add_main_entries(opt_ctx, options, "wsman");
 	u_option_context_add_group(opt_ctx, enum_group);
 	u_option_context_add_group(opt_ctx, test_group);
 	u_option_context_add_group(opt_ctx, cim_group);
 	u_option_context_add_group(opt_ctx, req_flag_group);

 	retval = u_option_context_parse(opt_ctx, &argc, &argv, &error);
 	u_option_context_free(opt_ctx);

 	if (error) {
 		if (error->message)
 			printf("%s\n", error->message);
 		u_error_free(error);
 		return FALSE;
 	}

 	if (argc > 2) {
 		_action = argv[1];
 		resource_uri = argv[2];
 	} else {
 		if (argv[1] && (strcmp(argv[1], "identify") == 0 ||
 				strcmp(argv[1], "test") == 0)) {
 			_action = argv[1];
 		} else {
 			fprintf(stderr,
 				"Error: operation can not be completed."
 				" Action or/and Resource Uri missing.\n");
 			return FALSE;
 		}
 	}
 	u_error_free(error);

 	// set default options
 	if (server_port == 0) {
 		server_port = cafile ? 8888 : 8889;
 	}
 	if (url_path == NULL) {
 		url_path = "/wsman";
 	}
 	return TRUE;
 }

 const char *wsman_options_get_output_file(void)
 {
 	return output_file;
 }
 const char *wsman_options_get_config_file(void)
 {
 	return config_file;
 }

 int wsman_read_client_config(dictionary * ini)
 {
 	if (iniparser_find_entry(ini, "client")) {
 		agent = iniparser_getstr(ini, "client:agent");
 		server_port = server_port ?
 		    server_port : iniparser_getint(ini, "client:port", 80);
 		authentication_method = authentication_method ?
 		    authentication_method :
 		    iniparser_getstr(ini, "client:authentication_method");
 	} else {
 		return 0;
 	}
 	return 1;
 }

 void wsman_setup_transport_and_library_options()
 {
 	// transport options
 	wsman_transport_set_auth_method(authentication_method);
 	if (proxy) {
 		wsman_transport_set_proxy(proxy);
 		if (proxy_upwd) {
 			wsman_transport_set_proxyauth(proxy_upwd);
 		}
 	}
 	if (cafile) {
 		wsman_transport_set_cafile(cafile);
 	}
 	wsman_transport_set_no_verify_peer(no_verify_peer);
 	wsman_transport_set_timeout(transport_timeout);

 	// library options
 	wsman_debug_set_level(debug_level);
 }


 const char **wsman_options_get_argv(void)
 {
 	return wsman_argv;
 }


 int wsman_options_get_server_port(void)
 {
 	return server_port;
 }

 unsigned long wsman_options_get_max_envelope_size(void)
 {
 	return max_envelope_size;
 }
 unsigned long wsman_options_get_operation_timeout(void)
 {
 	return operation_timeout;
 }

 char *wsman_options_get_cafile(void)
 {
 	return cafile;
 }

 char *wsman_options_get_server(void)
 {
 	if (server)
 		return server;
 	else
 		return "localhost";
 }

 char *wsman_options_get_invoke_method(void)
 {
 	return invoke_method;
 }

 char *wsman_options_get_username(void)
 {
 	return username;
 }

 char *wsman_options_get_password(void)
 {
 	return password;
 }


 hash_t *wsman_options_get_properties(void)
 {
 	int c = 0;
 	hash_t *h = hash_create(HASHCOUNT_T_MAX, 0, 0);

 	while (properties != NULL && properties[c] != NULL) {
 		char *cc[3];
 		u_tokenize1(cc, 2, properties[c], '=');
 		if (!hash_alloc_insert(h, cc[0], cc[1])) {
 			debug("hash_alloc_insert failed");
 		}
 		c++;
 	}
 	return h;
 }

 int wsman_options_get_action(void)
 {
 	int op = 0;
 	int i;
 	for (i = 0; action_data[i].action != NULL; i++) {
 		if (strcmp(action_data[i].action, _action) == 0) {
 			op = action_data[i].value;
 			break;
 		}
 	}
 	return op;
 }

 char *wsman_options_get_resource_uri(void)
 {
 	return resource_uri;
 }

 int wsman_options_get_max_elements(void)
 {
 	return enum_max_elements;
 }
 char wsman_options_get_optimize_enum(void)
 {
 	return enum_optimize;
 }

 char wsman_options_get_cim_ref(void)
 {
 	return cim_references;
 }

 char wsman_options_get_cim_ext(void)
 {
 	return cim_extensions;
 }

 char wsman_options_get_estimate_enum(void)
 {
 	return enum_estimate;
 }
 char wsman_options_get_dump_request(void)
 {
 	return dump_request;
 }
 char wsman_options_get_step_request(void)
 {
 	return step;
 }

 char *wsman_options_get_enum_context(void)
 {
 	return enum_context;
 }

 char *wsman_options_get_test_file(void)
 {
 	return test_case;
 }

 char *wsman_options_get_input_file(void)
 {
 	return input;
 }

 char *wsman_options_get_enum_mode(void)
 {
 	return enum_mode;
 }

 char *wsman_options_get_binding_enum_mode(void)
 {
 	return binding_enum_mode;
 }
 char *wsman_options_get_cim_namespace(void)
 {
 	return cim_namespace;
 }
 char *wsman_options_get_fragment(void)
 {
 	return fragment;
 }
 char *wsman_options_get_filter(void)
 {
 	return wsm_filter;
 }

 char *wsman_options_get_dialect(void)
 {
 	return wsm_dialect;
 }
 char *wsman_options_get_path(void)
 {
 	return url_path;
 }
	/*******************************************************************************
	* Copyright (C) 2004-2006 Intel Corp. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* - Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	*
	* - Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	*
	* - Neither the name of Intel Corp. nor the names of its
	* contributors may be used to endorse or promote products derived from this
	* software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.
	*******************************************************************************/

	/**
	* @author Anas Nashif
	*/
	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#ifdef HAVE_UNISTD_H
	#include <unistd.h>
	#endif


	#include "u/libu.h"
	#include "wsman-client-api.h"
	#include "wsman-client-transport.h"
	#include "wsman-client-options.h"
	#include "wsman-debug.h"

	#if 0
	static char *auth_methods[] = {
	"basic",
	"digest",
	"ntlm",
	NULL,
	};
	#endif

	static const char **wsman_argv = NULL;


	static int server_port = 0;
	static char *cafile = NULL;
	static char *username = NULL;
	static char *password = NULL;
	static char *server = "localhost";
	static char *agent = NULL;
	static char *url_path = NULL;
	static char *authentication_method = NULL;
	static char no_verify_peer = 0;
	static int transport_timeout = 0;
	static char *proxy = NULL;
	static char *proxy_upwd = NULL;


	static int debug_level = -1;
	static char *test_case = NULL;
	static int enum_max_elements = 0;
	char enum_optimize = 0;
	char enum_estimate = 0;
	char dump_request = 0;
	char step = 0;
	char request_only = 0;
	char cim_extensions = 0;
	char cim_references = 0;
	static char *enum_mode = NULL;
	static char *binding_enum_mode = NULL;
	static char *enum_context = NULL;


	static char *cim_namespace = NULL;
	static char *fragment = NULL;
	static char *wsm_filter = NULL;
	static char *wsm_dialect = NULL;
	static char *input = NULL;

	static unsigned long operation_timeout = 0;
	static unsigned long max_envelope_size = 0;

	static char *_action = NULL;
	static char *config_file = NULL;
	static char *output_file = NULL;
	static char *resource_uri = NULL;
	static char *invoke_method = NULL;
	static char **properties = NULL;


	WsActions action_data[] = {
	{"get", WSMAN_ACTION_TRANSFER_GET},
	{"put", WSMAN_ACTION_TRANSFER_PUT},
	{"create", WSMAN_ACTION_TRANSFER_CREATE},
	{"delete", WSMAN_ACTION_TRANSFER_DELETE},
	{"enumerate", WSMAN_ACTION_ENUMERATION},
	{"pull", WSMAN_ACTION_PULL},
	{"release", WSMAN_ACTION_RELEASE},
	{"invoke", WSMAN_ACTION_CUSTOM},
	{"identify", WSMAN_ACTION_IDENTIFY},
	{"test", WSMAN_ACTION_TEST},
	{NULL, 0},
	};

	char wsman_parse_options(int argc, char **argv)
	{

	char retval = 0;
	u_error_t *error = NULL;

	u_option_entry_t options[] = {
	{"debug", 'd', U_OPTION_ARG_INT, &debug_level,
	"Set the verbosity of debugging output.", "1-6"},
	{"cafile", 'c', U_OPTION_ARG_STRING, &cafile,
	"Certificate file", "<filename>"},
	{"username", 'u', U_OPTION_ARG_STRING, &username,
	"User name", "<username>"},
	{"path", 'g', U_OPTION_ARG_STRING, &url_path,
	"Path", "<path>"},
	{"input", 'J', U_OPTION_ARG_STRING, &input,
	"File with resource for Create and Put operations in XML, can be a SOAP envelope",
	"<filename>"},
	{"password", 'p', U_OPTION_ARG_STRING, &password,
	"Password", "<password>"},
	{"hostname", 'h', U_OPTION_ARG_STRING, &server,
	"Host name", "<hostname>"},
	{"port", 'P', U_OPTION_ARG_INT, &server_port,
	"Server Port", "<port>"},
	{"proxy", 'X', U_OPTION_ARG_STRING, &proxy,
	"Proxy name", "<proxy>"},
	{"proxyauth", 'Y', U_OPTION_ARG_STRING, &proxy_upwd,
	"Proxy user:pwd", "<proxyauth>"},
	{"auth", 'y', U_OPTION_ARG_STRING, &authentication_method,
	"Authentication Method", "<basic\|digest\|gss>"},
	{"method", 'a', U_OPTION_ARG_STRING, &invoke_method,
	"Method (Works only with 'invoke')", "<custom method>"},
	{"prop", 'k', U_OPTION_ARG_STRING_ARRAY, &properties,
	"Properties with key value pairs (For 'put', 'invoke' and 'create')",
	"<key=val>"},
	{"config-file", 'C', U_OPTION_ARG_STRING, &config_file,
	"Alternate configuration file", "<file>"},
	{"out-file", 'O', U_OPTION_ARG_STRING, &output_file,
	"Write output to file", "<file>"},
	{"noverifypeer", 'V', U_OPTION_ARG_NONE, &no_verify_peer,
	"Not to verify peer certificate", NULL},
	{"transport-timeout", 'I', U_OPTION_ARG_INT, &transport_timeout,
	"Transport timeout in seconds", "<time in sec>"},
	{NULL}
	};



	u_option_entry_t request_options[] = {
	{"filter", 'x', U_OPTION_ARG_STRING, &wsm_filter,
	"Filter", "<filter>"},
	{"dialect", 'D', U_OPTION_ARG_STRING, &wsm_dialect,
	"Filter Dialect", "<dialect>"},
	{"operation-timeout", 't', U_OPTION_ARG_INT, &operation_timeout,
	"Operation timeout in seconds", "<time in sec>"},
	{"max-envelope-size", 'e', U_OPTION_ARG_INT,
	&max_envelope_size,
	"maximal envelope size", "<size>"},
	{"fragment", 'F', U_OPTION_ARG_STRING, &fragment,
	"Fragment (Supported Dialects: XPATH)", "<fragment>"},
	{NULL}
	};

	u_option_entry_t enum_options[] = {

	{"max-elements", 'm', U_OPTION_ARG_INT, &enum_max_elements,
	"Max Elements Per Pull/Optimized Enumeration",
	"<max number of elements>"},
	{"optimize", 'o', U_OPTION_ARG_NONE, &enum_optimize,
	"Optimize enumeration results", NULL},
	{"estimate-count", 'E', U_OPTION_ARG_NONE, &enum_estimate,
	"Return estimation of total items", NULL},
	{"enum-mode", 'M', U_OPTION_ARG_STRING, &enum_mode,
	"Enumeration Mode", "epr\|objepr"},
	{"enum-context", 'U', U_OPTION_ARG_STRING, &enum_context,
	"Enumeration Context (For use with Pull and Release)",
	"<enum context>"},
	{NULL}
	};

	u_option_entry_t cim_options[] = {

	{"namespace", 'N', U_OPTION_ARG_STRING, &cim_namespace,
	"CIM Namespace (default is root/cimv2)", "<namespace>"},
	{"binding-enum-mode", 'B', U_OPTION_ARG_STRING,
	&binding_enum_mode,
	"CIM binding Enumeration Mode", "none\|include\|exclude"},
	{"cim-extensions", 'T', U_OPTION_ARG_NONE, &cim_extensions,
	"Show CIM Extensions", NULL},
	{"references", 'W', U_OPTION_ARG_NONE, &cim_references,
	"CIM References", NULL},
	{NULL}
	};

	u_option_entry_t test_options[] = {
	{"from-file", 'f', U_OPTION_ARG_STRING, &test_case,
	"Send request from file", "<file name>"},
	{"print-request", 'R', U_OPTION_ARG_NONE, &dump_request,
	"print request on stdout", NULL},
	{"request", 'Q', U_OPTION_ARG_NONE, &request_only,
	"Only output reqest. Not send it.", NULL},
	{"step", 'S', U_OPTION_ARG_NONE, &step,
	"Do not perform multiple operations (do not pull data when enumerating)",
	NULL},
	//{ "print-response", 'N', 0, G_OPTION_ARG_NONE, &dump_response, "print all responses to stdout", NULL},
	{NULL}
	};

	u_option_group_t *enum_group;
	u_option_group_t *test_group;
	u_option_group_t *cim_group;
	u_option_group_t *req_flag_group;

	u_option_context_t *opt_ctx;
	opt_ctx = u_option_context_new("<action> <Resource Uri>");
	enum_group = u_option_group_new("enumeration", "Enumeration",
	"Enumeration Options");
	test_group = u_option_group_new("tests", "Tests", "Test Cases");
	cim_group = u_option_group_new("cim", "CIM", "CIM Options");
	req_flag_group =
	u_option_group_new("flags", "Flags", "Request Flags");

	u_option_group_add_entries(enum_group, enum_options);
	u_option_group_add_entries(test_group, test_options);
	u_option_group_add_entries(cim_group, cim_options);
	u_option_group_add_entries(req_flag_group, request_options);

	u_option_context_set_ignore_unknown_options(opt_ctx, FALSE);
	u_option_context_add_main_entries(opt_ctx, options, "wsman");
	u_option_context_add_group(opt_ctx, enum_group);
	u_option_context_add_group(opt_ctx, test_group);
	u_option_context_add_group(opt_ctx, cim_group);
	u_option_context_add_group(opt_ctx, req_flag_group);

	retval = u_option_context_parse(opt_ctx, &argc, &argv, &error);
	u_option_context_free(opt_ctx);

	if (error) {
	if (error->message)
	printf("%s\n", error->message);
	u_error_free(error);
	return FALSE;
	}

	if (argc > 2) {
	_action = argv[1];
	resource_uri = argv[2];
	} else {
	if (argv[1] && (strcmp(argv[1], "identify") == 0 \|\|
	strcmp(argv[1], "test") == 0)) {
	_action = argv[1];
	} else {
	fprintf(stderr,
	"Error: operation can not be completed."
	" Action or/and Resource Uri missing.\n");
	return FALSE;
	}
	}
	u_error_free(error);

	// set default options
	if (server_port == 0) {
	server_port = cafile ? 8888 : 8889;
	}
	if (url_path == NULL) {
	url_path = "/wsman";
	}
	return TRUE;
	}

	const char *wsman_options_get_output_file(void)
	{
	return output_file;
	}
	const char *wsman_options_get_config_file(void)
	{
	return config_file;
	}

	int wsman_read_client_config(dictionary * ini)
	{
	if (iniparser_find_entry(ini, "client")) {
	agent = iniparser_getstr(ini, "client:agent");
	server_port = server_port ?
	server_port : iniparser_getint(ini, "client:port", 80);
	authentication_method = authentication_method ?
	authentication_method :
	iniparser_getstr(ini, "client:authentication_method");
	} else {
	return 0;
	}
	return 1;
	}

	void wsman_setup_transport_and_library_options()
	{
	// transport options
	wsman_transport_set_auth_method(authentication_method);
	if (proxy) {
	wsman_transport_set_proxy(proxy);
	if (proxy_upwd) {
	wsman_transport_set_proxyauth(proxy_upwd);
	}
	}
	if (cafile) {
	wsman_transport_set_cafile(cafile);
	}
	wsman_transport_set_no_verify_peer(no_verify_peer);
	wsman_transport_set_timeout(transport_timeout);

	// library options
	wsman_debug_set_level(debug_level);
	}


	const char **wsman_options_get_argv(void)
	{
	return wsman_argv;
	}



	int wsman_options_get_server_port(void)
	{
	return server_port;
	}

	unsigned long wsman_options_get_max_envelope_size(void)
	{
	return max_envelope_size;
	}
	unsigned long wsman_options_get_operation_timeout(void)
	{
	return operation_timeout;
	}

	char *wsman_options_get_cafile(void)
	{
	return cafile;
	}

	char *wsman_options_get_server(void)
	{
	if (server)
	return server;
	else
	return "localhost";
	}

	char *wsman_options_get_invoke_method(void)
	{
	return invoke_method;
	}

	char *wsman_options_get_username(void)
	{
	return username;
	}

	char *wsman_options_get_password(void)
	{
	return password;
	}



	hash_t *wsman_options_get_properties(void)
	{
	int c = 0;
	hash_t *h = hash_create(HASHCOUNT_T_MAX, 0, 0);

	while (properties != NULL && properties[c] != NULL) {
	char *cc[3];
	u_tokenize1(cc, 2, properties[c], '=');
	if (!hash_alloc_insert(h, cc[0], cc[1])) {
	debug("hash_alloc_insert failed");
	}
	c++;
	}
	return h;
	}

	int wsman_options_get_action(void)
	{
	int op = 0;
	int i;
	for (i = 0; action_data[i].action != NULL; i++) {
	if (strcmp(action_data[i].action, _action) == 0) {
	op = action_data[i].value;
	break;
	}
	}
	return op;
	}

	char *wsman_options_get_resource_uri(void)
	{
	return resource_uri;
	}

	int wsman_options_get_max_elements(void)
	{
	return enum_max_elements;
	}
	char wsman_options_get_optimize_enum(void)
	{
	return enum_optimize;
	}

	char wsman_options_get_cim_ref(void)
	{
	return cim_references;
	}

	char wsman_options_get_cim_ext(void)
	{
	return cim_extensions;
	}

	char wsman_options_get_estimate_enum(void)
	{
	return enum_estimate;
	}
	char wsman_options_get_dump_request(void)
	{
	return dump_request;
	}
	char wsman_options_get_step_request(void)
	{
	return step;
	}

	char *wsman_options_get_enum_context(void)
	{
	return enum_context;
	}

	char *wsman_options_get_test_file(void)
	{
	return test_case;
	}

	char *wsman_options_get_input_file(void)
	{
	return input;
	}

	char *wsman_options_get_enum_mode(void)
	{
	return enum_mode;
	}

	char *wsman_options_get_binding_enum_mode(void)
	{
	return binding_enum_mode;
	}
	char *wsman_options_get_cim_namespace(void)
	{
	return cim_namespace;
	}
	char *wsman_options_get_fragment(void)
	{
	return fragment;
	}
	char *wsman_options_get_filter(void)
	{
	return wsm_filter;
	}

	char *wsman_options_get_dialect(void)
	{
	return wsm_dialect;
	}
	char *wsman_options_get_path(void)
	{
	return url_path;
	}