int main(int argc, char** argv)
{
const char* arg0 = System::findBaseName(argv[0]);
#ifdef PEGASUS_OS_ZOS
// for z/OS set stdout and stderr to EBCDIC
setEBCDICEncoding(STDOUT_FILENO);
setEBCDICEncoding(STDERR_FILENO);
#endif
#ifdef PEGASUS_OS_PASE
// Allow user group name larger than 8 chars in PASE environemnt
setenv("PASE_USRGRP_LIMITED","N",1);
#endif
// If no arguments, simply print usage message and terminate.
MessageLoader::_useProcessLocale = true;
if (argc == 1)
{
showUsage();
exit(0);
}
//****** Show the args diagnostic display
if (strcmp(argv[1],"displayargs") == 0)
{
cout << "argc = " << argc << endl;
for (int i = 0; i < argc; i++)
cout << "argv[" << i << "] = " << argv[i] << endl;
}
// Get options (from command line and from configuration file); this
// removes corresponding options and their arguments from the command
// line.
OptionManager om;
Options opts;
try
{
// assume that the config file is local to directory where called.
String testHome = ".";
om.setMessagePath("pegasus/pegasusCLI");
GetOptions(om, argc, argv, testHome);
// Initialize all of the function input parameters.
opts.location = String::EMPTY;
#ifdef PEGASUS_HAS_SSL
opts.ssl = false;
opts.clientCert = String::EMPTY;
opts.clientKey = String::EMPTY;
#endif
opts.nameSpace = "root/cimv2";
opts.cimCmd = "unknown";
opts.className = CIMName();
opts.objectName = "unknown";
opts.isXmlOutput = false;
opts.outputFormatType = OUTPUT_MOF;
opts.user = String::EMPTY;
opts.password = String::EMPTY;
opts.verboseTest = false;
opts.localOnly = true;
opts.deepInheritance = false;
opts.includeQualifiers = true;
opts.includeClassOrigin = false;
opts.assocClassName = String::EMPTY;
opts.assocClass = CIMName();
opts.resultClassName = String::EMPTY;
opts.resultClass = CIMName();
opts.role = String::EMPTY;
opts.resultRole = String::EMPTY;
opts.propertyListText = String::EMPTY;
opts.propertyList.clear();
opts.propertyName = String::EMPTY;
opts.methodName = CIMName("unknown");
opts.delay = 0;
opts.trace = 0;
opts.count= 97832;
opts.repeat = 0;
opts.time = false;
opts.termCondition = 0;
opts.debug = false;
opts.queryLanguage = "WQL";
// move any other input parameters left to the extraParams List
CheckCommonOptionValues(om, argv, opts);
/* note that this is in error since it assumes a fixed
number of parameters will be used for all of the commands
It needs to be expanded to allow for a variable minimum
number of commands before it picks up any extras
*/
if (argc > 2)
{
for (int i = 2 ; i < argc ; i++ )
opts.extraParams.append(argv[i]);
}
}
catch(CIMException& e)
{
cerr << argv[0] << " Caught CIMException during init: "
<< "\n" << e.getMessage()
<< endl;
exit(1);
}
catch (Exception& e)
{
cerr << argv[0] << ": " << e.getMessage() << endl;
exit(1);
}
catch(...)
{
cerr << argv[0] << " Caught General Exception During Init:" << endl;
exit(1);
}
// if there is still an arg1, assume it is the command name.
if (argc > 1)
{
opts.cimCmd = argv[1];
}
else
{
cout << " Command name must be first parameter or --c parameter."
<< " \n ex. " << argv[0] << " enumerateclasses\n"
<< "Enter " << argv[0] << " -h for help."
<< endl;
exit(1);
}
// if the trace option was set initialize the trace function.
if (opts.trace != 0)
{
const char* tmpDir = getenv ("PEGASUS_TMP");
if (tmpDir == NULL)
{
tmpDir = ".";
}
String traceFile (tmpDir);
traceFile.append("/cliTrace.trc");
Tracer::setTraceFile (traceFile.getCString());
Tracer::setTraceComponents("ALL");
Tracer::setTraceLevel(opts.trace);
}
// Find the command and save index in cmdIndex
Uint32 cmdIndex = 0;
if (opts.verboseTest && opts.debug)
cout << "TEST Command = " << opts.cimCmd << endl;
// Find the command or the short cut name
for( ; cmdIndex < NUM_COMMANDS; cmdIndex++ )
{
if ((String::equalNoCase(opts.cimCmd,
CommandTable[cmdIndex].CommandName))
||
(opts.cimCmd == CommandTable[cmdIndex].ShortCut))
// Break if found
break;
}
Stopwatch totalElapsedExecutionTime;
totalElapsedExecutionTime.start();
// Now try to open the connection to the cim server
CIMClient client;
try
{
if (CommandTable[cmdIndex].ID_Command != ID_ShowOptions)
{
String host;
HostLocator addr;
if (opts.location != String::EMPTY)
{
addr.setHostLocator(opts.location);
if (!addr.isValid())
{
throw InvalidLocatorException(opts.location);
}
host = addr.getHost();
}
Uint32 portNumber = System::lookupPort( WBEM_HTTP_SERVICE_NAME,
WBEM_DEFAULT_HTTP_PORT );
// Set up SSL port and flag for verbose display
// if SSL included in build
String useSSL;
#ifdef PEGASUS_HAS_SSL
if (opts.ssl)
{
portNumber = System::lookupPort( WBEM_HTTPS_SERVICE_NAME,
WBEM_DEFAULT_HTTPS_PORT );
}
useSSL = " ssl=";
useSSL.append((opts.ssl)? "true" : "false");
#endif
if (host != String::EMPTY && addr.isPortSpecified())
{
portNumber = addr.getPort();
}
//check whether we should use connect() or connectLocal()
//an empty location option indicates to use connectLocal()
if (String::equal(host, String::EMPTY))
{
if (opts.verboseTest)
{
cout << "Connect with connectLocal" << endl;
}
client.connectLocal();
}
else
{
if (opts.verboseTest)
{
cout << "Connect to " << host
<< " port=" << portNumber
<< useSSL
<< " for User="******"SSL options "
<< "Cert = " << opts.clientCert
<< "clientKey = " << opts.clientKey << endl;
}
client.connect(host,
portNumber,
SSLContext("",
opts.clientCert,
opts.clientKey,
NULL, "ssl.rnd"),
opts.user,
opts.password);
} else
{
client.connect(host,
portNumber,
SSLContext("", NULL, "ssl.rnd"),
opts.user,
opts.password);
}
} else //connect over HTTP
{
client.connect(host, portNumber, opts.user, opts.password);
}
#else
client.connect(host, portNumber, opts.user, opts.password);
#endif
}
}
}
catch(Exception &e)
{
cerr << "Pegasus Exception: " << e.getMessage() <<
" Trying to connect to " << opts.location << endl;
exit(1);
}
// Register for Client statistics.
ClientStatistics statistics = ClientStatistics();
client.registerClientOpPerformanceDataHandler(statistics);
if (opts.delay != 0)
{
// This was a test because of some delay caused problems.
Threads::sleep(opts.delay * 1000);
}
// If the timeout is not zero, set the timeout for this connection.
if (opts.connectionTimeout != 0)
{
client.setTimeout(opts.connectionTimeout * 1000);
}
// Save the total connect time.
double totalConnectTime = opts.elapsedTime.getElapsed();
double totalTime = 0;
Uint32 repeatCount = opts.repeat;
double maxTime = 0;
double minTime = 10000000;
Uint64 serverTotalTime = 0;
Uint64 maxServerTime = 0;
Uint64 minServerTime = 10000000;
Uint64 rtTotalTime = 0;
Uint64 maxRtTime = 0;
Uint64 minRtTime = 10000000;
// Process the input command within a try block.
try
{
// Loop to repeat the command a number of times.
do
{
// or exit with error through default of case logic
switch(CommandTable[cmdIndex].ID_Command)
{
case ID_EnumerateInstanceNames :
if (!_getClassNameInput(argc, argv, opts, true))
exit(1);
enumerateInstanceNames(client, opts);
break;
case ID_EnumerateAllInstanceNames :
if (!_getClassNameInput(argc, argv, opts, false))
exit(1);
enumerateAllInstanceNames(client, opts);
break;
case ID_EnumerateInstances :
if (!_getClassNameInput(argc, argv, opts, true))
exit(1);
enumerateInstances(client, opts);
break;
case ID_GetInstance :
if (!_getObjectNameInput(argc, argv, opts, true))
exit(1);
getInstance(client, opts);
break;
case ID_EnumerateClassNames :
if (!_getClassNameInput(argc, argv, opts, false))
exit(1);
enumerateClassNames(client, opts);
break;
case ID_EnumerateClasses :
if (!_getClassNameInput(argc, argv, opts, false))
exit(1);
enumerateClasses(client, opts);
break;
case ID_GetClass :
if (!_getClassNameInput(argc, argv, opts, true))
exit(1);
getClass(client, opts);
break;
case ID_CreateInstance :
if (!_getClassNameInput(argc, argv, opts, true))
exit(1);
createInstance(client, opts);
break;
case ID_DeleteInstance :
if (!_getObjectNameInput(argc, argv, opts, true))
exit(1);
deleteInstance(client, opts);
break;
case ID_CreateClass :
cerr << "CreateClass not implemented" << endl;
break;
case ID_DeleteClass :
if (!_getClassNameInput(argc, argv, opts, true))
exit(1);
deleteClass(client, opts);
break;
case ID_GetProperty :
if (argc != 4)
{
cout << "Usage: " << arg0 <<
" getproperty <instancename> <propertyname>" <<
endl;
exit(1);
}
opts.instanceName = argv[2];
opts.inputObjectName = argv[2];
opts.propertyName = argv[3];
getProperty(client, opts);
break;
case ID_SetProperty :
if (argc != 5)
cout <<"Usage: " << arg0 <<
" setproperty instancename propertyname value "
<< endl;
setProperty(client, opts);
break;
case ID_EnumerateQualifiers :
enumerateQualifiers(client, opts);
break;
case ID_SetQualifier :
cerr << "SetQualifer not implemented" << endl;
exit(1);
break;
case ID_GetQualifier :
if (!_getQualifierNameInput(argc, argv, opts))
exit(1);
getQualifier(client, opts);
break;
case ID_DeleteQualifier :
if (!_getQualifierNameInput(argc, argv, opts))
exit(1);
deleteQualifier(client, opts);
break;
/* Reference params are
[IN] <objectName> ObjectName,
[IN,OPTIONAL,NULL] <className> ResultClass = NULL,
[IN,OPTIONAL,NULL] string Role = NULL,
[IN,OPTIONAL] boolean IncludeQualifiers = false,
[IN,OPTIONAL] boolean IncludeClassOrigin = false,
[IN,OPTIONAL,NULL] string PropertyList [] = NULL
*/
case ID_References :
if (!_getObjectNameInput(argc, argv, opts, true))
exit(1);
references(client, opts);
break;
case ID_ReferenceNames :
if (!_getObjectNameInput(argc, argv, opts, true))
exit(1);
referenceNames(client, opts);
break;
case ID_Associators :
if (!_getObjectNameInput(argc, argv, opts, true))
exit(1);
associators(client, opts);
break;
case ID_AssociatorNames :
if (!_getObjectNameInput(argc, argv, opts, true))
exit(1);
associatorNames(client,opts);
break;
case ID_EnumerateNamespaces :
// Note that the following constants are fixed here. We
// should be getting them from the environment to assure
// that others know that we are using them.
opts.className = CIMName("CIM_Namespace");
if (argc > 2)
{
opts.nameSpace = argv[2];
opts.inputObjectName = argv[2];
}
else
// set nameSpace to interop namespace name
opts.nameSpace =
PEGASUS_NAMESPACENAME_INTEROP.getString();
enumerateNamespaces_Namespace(client,opts);
break;
/*
CIMValue invokeMethod(
const CIMNamespaceName& nameSpace,
const CIMObjectPath& instanceName,
const CIMName& methodName,
const Array<CIMParamValue>& inParameters,
Array<CIMParamValue>& outParameters
*/
case ID_InvokeMethod :
if (argc < 4)
{
cout << "Usage: InvokeMethod requires that object and"
" method names be specified.\n"
"Input parameters are optional and can be"
" specified with the -ip option or as"
" additional parameters to this call. "
"Enter each input parameter as name=value"
" (no spaces around equal sign)."
<< endl;
exit(1);
}
opts.objectName = argv[2];
opts.inputObjectName = argv[2];
opts.methodName = CIMName(argv[3]);
// If there are any extra arguments they must be parameters
// These parameters can be used in addtion to parameters
// ifrom the -ip option setting. Parameters found here must
// be key=value pairs or they will generate an exception.
if (argc > 4)
{
// get input params from command line
for (Sint32 i = 4 ; i < argc; i++)
{
CIMParamValue pv;
String s = argv[i];
pv = _createMethodParamValue(s, opts);
opts.inParams.append(pv);
}
}
invokeMethod(client, opts);
break;
case ID_ShowOptions :
showUsage();
break;
case ID_ExecQuery:
opts.query = argv[2];
if (argc==4)
opts.queryLanguage = argv[3];
executeQuery(client, opts);
break;
case ID_StatisticsOn:
setObjectManagerStatistics(client, true);
break;
case ID_StatisticsOff:
setObjectManagerStatistics(client, false);
break;
//case ID_Unknown :
default:
cout << "Invalid Command. Command name must be first parm"
" or --c parameter."
<< " \n ex. " << arg0 << " enumerateclasses\n"
<< "Enter " << argv[0] << " -h for help."
<< endl;
exit(1);
break;
}
if (opts.repeat > 0)
{
if (opts.verboseTest)
{
cout << "Repetitition " << opts.repeat << endl;
}
opts.repeat--;
if (opts.time)
{
totalTime += opts.saveElapsedTime;
maxTime = LOCAL_MAX(maxTime, opts.saveElapsedTime);
minTime = LOCAL_MIN(minTime, opts.saveElapsedTime);
rtTotalTime += (returnedPerformanceData.roundTripTime);
maxRtTime = LOCAL_MAX(maxRtTime,
returnedPerformanceData.roundTripTime);
minRtTime = LOCAL_MIN(minRtTime,
returnedPerformanceData.roundTripTime);
if (returnedPerformanceData.serverTimeKnown)
{
serverTotalTime += (returnedPerformanceData.serverTime);
maxServerTime = LOCAL_MAX(maxServerTime,
returnedPerformanceData.serverTime);
minServerTime = LOCAL_MIN(minServerTime,
returnedPerformanceData.serverTime);
}
}
}
} while (opts.repeat > 0 );
if (opts.time)
{
if (repeatCount == 0)
{
cout << CommandTable[cmdIndex].CommandName
<< " "
<< opts.inputObjectName
<< " Time= "
<< opts.saveElapsedTime
<< " Sec "
<< " SvrTime= "
<< CIMValue(returnedPerformanceData.serverTime).toString()
<< " us "
<< " RtTime= "
<< CIMValue(returnedPerformanceData.roundTripTime).
toString()
<< " us "
<< "Req size= "
<< CIMValue(returnedPerformanceData.requestSize).toString()
<< " b Resp size= "
<< CIMValue(returnedPerformanceData.responseSize).toString()
<< " b"
<< endl;
}
else
{
cout << CommandTable[cmdIndex].CommandName
<< " "
<< opts.inputObjectName
<< " Total Time "
<< totalTime
<< " for "
<< repeatCount
<< " ops. Avg= "
<< (totalTime * 1000000)/repeatCount
<< " us min= "
<< minTime * 1000000
<< " us max= "
<< (maxTime * 1000000)
<< " us SvrTime avg= "
<< CIMValue(serverTotalTime/repeatCount).toString()
<< " us SvrTime min= "
<< CIMValue(minServerTime).toString()
<< " us SvrTime max= "
<< CIMValue(maxServerTime).toString()
<< " us"
<< " RtTime avg= "
<< CIMValue(rtTotalTime/repeatCount).toString()
<< " us RtTime min= "
<< CIMValue(minRtTime).toString()
<< " us RtTime max= "
<< CIMValue(maxRtTime).toString()
<< " us"
<< endl;
}
}
}
catch(CIMException& e)
{
cerr << argv[0] << " CIMException: "<<" Cmd= " << opts.cimCmd
<< " Object= " << opts.inputObjectName
<< "\n" << e.getMessage()
<< endl;
opts.termCondition = 1;
}
catch(Exception& e)
{
PEGASUS_STD(cerr) << argv[0] << " Pegasus Exception: " << e.getMessage()
<< ". Cmd = " << opts.cimCmd
<< " Object = " << opts.inputObjectName
<< PEGASUS_STD(endl);
opts.termCondition = 1;
}
catch(...)
{
cerr << argv[0] << " Caught General Exception:" << endl;
opts.termCondition = 1;
}
totalElapsedExecutionTime.stop();
if (opts.time)
{
// if abnormal term, dump all times
if (opts.termCondition == 1)
{
cout << "Exception" << endl;
cout << "Prev Time " << opts.saveElapsedTime << " Sec" << endl;
opts.saveElapsedTime = opts.elapsedTime.getElapsed();
cout << "Last Time " << opts.saveElapsedTime << " Sec" << endl;
cout << "Total Time " << totalTime << " for "
<< repeatCount << " operations. Avg.= " << totalTime/repeatCount
<< " min= " << minTime << " max= " << maxTime << endl;
}
cout << "Total Elapsed Time= " << totalElapsedExecutionTime.getElapsed()
<< " Sec. Terminated at " << System::getCurrentASCIITime() << endl;
}
if (opts.delay != 0)
{
Threads::sleep(opts.delay * 1000);
}
return(opts.termCondition);
}
HTTPConnection* HTTPConnector::connect(
const String& host,
const Uint32 portNumber,
SSLContext * sslContext,
Uint32 timeoutMilliseconds,
MessageQueue* outputMessageQueue)
{
PEG_METHOD_ENTER(TRC_HTTP, "HTTPConnector::connect()");
#ifdef PEGASUS_OS_PASE
AutoPtr<PaseCcsid> ccsid;
#endif
SocketHandle socket = PEGASUS_INVALID_SOCKET;
// Use an AutoPtr to ensure the socket handle is closed on exception
AutoPtr<SocketHandle, CloseSocketHandle> socketPtr(&socket);
#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
if (0 == host.size())
{
// Set up the domain socket for a local connection
sockaddr_un address;
#ifdef PEGASUS_OS_PASE
// PASE needs ccsid 819 to perform domain socket operation
int orig_ccsid;
orig_ccsid = _SETCCSID(-1);
if (orig_ccsid == -1)
{
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
"HTTPConnector::connect() Can not get current PASE CCSID.");
orig_ccsid = 1208;
}
ccsid.reset(new PaseCcsid(819, orig_ccsid));
#endif
memset(&address, 0, sizeof(address));
address.sun_family = AF_UNIX;
strcpy(address.sun_path, PEGASUS_LOCAL_DOMAIN_SOCKET_PATH);
socket = Socket::createSocket(AF_UNIX, SOCK_STREAM, 0);
if (socket == PEGASUS_INVALID_SOCKET)
{
PEG_METHOD_EXIT();
throw CannotCreateSocketException();
}
Socket::disableBlocking(socket);
// Connect the socket to the address:
if (!Socket::timedConnect(
socket,
reinterpret_cast<sockaddr*>(&address),
sizeof(address),
timeoutMilliseconds))
{
MessageLoaderParms parms(
"Common.HTTPConnector.CONNECTION_FAILED_LOCAL_CIM_SERVER",
"Cannot connect to local CIM server. Connection failed.");
PEG_METHOD_EXIT();
throw CannotConnectException(parms);
}
}
else
#endif
{
// Set up the IP socket connection
// Make the internet address:
#ifdef PEGASUS_ENABLE_IPV6
struct addrinfo *addrInfo, *addrInfoRoot = NULL;
#else
sockaddr_in address;
#endif
#ifdef PEGASUS_ENABLE_IPV6
if (!_MakeAddress(
(const char*)host.getCString(),
portNumber,
(void**)(void*)&addrInfoRoot))
#else
if (!_MakeAddress((const char*)host.getCString(), portNumber, address))
#endif
{
char scratch[22];
Uint32 n;
const char * portStr = Uint32ToString(scratch, portNumber, n);
PEG_METHOD_EXIT();
throw InvalidLocatorException(host+":"+String(portStr,n));
}
#ifdef PEGASUS_ENABLE_IPV6
addrInfo = addrInfoRoot;
while (addrInfo)
{
// Create the socket:
socket = Socket::createSocket(addrInfo->ai_family,
addrInfo->ai_socktype, addrInfo->ai_protocol);
#else
socket = Socket::createSocket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
#endif
if (socket == PEGASUS_INVALID_SOCKET)
{
#ifdef PEGASUS_ENABLE_IPV6
freeaddrinfo(addrInfoRoot);
#endif
PEG_METHOD_EXIT();
throw CannotCreateSocketException();
}
#ifndef PEGASUS_OS_TYPE_WINDOWS
// We need to ensure that the socket number is not higher than
// what fits into FD_SETSIZE,because we else won't be able to select
// on it and won't ever communicate correct on that socket.
if (socket >= FD_SETSIZE)
{
# ifdef PEGASUS_ENABLE_IPV6
freeaddrinfo(addrInfoRoot);
# endif
// the socket is useless to us, close it
Socket::close(socket);
PEG_TRACE(
(TRC_DISCARDED_DATA,
Tracer::LEVEL1,
"createSocket() returned too large socket number %d."
"Cannot connect to %s:%d. Connection failed.",
socket,
(const char*) host.getCString(),
portNumber));
PEG_METHOD_EXIT();
throw CannotCreateSocketException();
}
#endif
Socket::disableBlocking(socket);
// Connect the socket to the address:
if (!Socket::timedConnect(
socket,
#ifdef PEGASUS_ENABLE_IPV6
reinterpret_cast<sockaddr*>(addrInfo->ai_addr),
addrInfo->ai_addrlen,
#else
reinterpret_cast<sockaddr*>(&address),
sizeof(address),
#endif
timeoutMilliseconds))
{
#ifdef PEGASUS_ENABLE_IPV6
addrInfo = addrInfo->ai_next;
if (addrInfo)
{
Socket::close(socket);
continue;
}
#endif
char scratch[22];
Uint32 n;
const char * portStr = Uint32ToString(scratch, portNumber, n);
MessageLoaderParms parms(
"Common.HTTPConnector.CONNECTION_FAILED_TO",
"Cannot connect to $0:$1. Connection failed.",
host,
portStr);
#ifdef PEGASUS_ENABLE_IPV6
freeaddrinfo(addrInfoRoot);
#endif
PEG_METHOD_EXIT();
throw CannotConnectException(parms);
}
#ifdef PEGASUS_ENABLE_IPV6
break;
}
freeaddrinfo(addrInfoRoot);
#endif
}
// Create HTTPConnection object:
SharedPtr<MP_Socket> mp_socket(new MP_Socket(socket, sslContext, 0));
// mp_socket now has responsibility for closing the socket handle
socketPtr.release();
if (mp_socket->connect(timeoutMilliseconds) < 0)
{
char scratch[22];
Uint32 n;
const char * portStr = Uint32ToString(scratch, portNumber, n);
MessageLoaderParms parms(
"Common.HTTPConnector.CONNECTION_FAILED_TO",
"Cannot connect to $0:$1. Connection failed.",
host,
portStr);
PEG_METHOD_EXIT();
throw CannotConnectException(parms);
}
AutoPtr<HTTPConnection> connection(new HTTPConnection(
_monitor,
mp_socket,
String::EMPTY,
0,
outputMessageQueue));
// Solicit events on this new connection's socket:
int index;
if (-1 == (index = _monitor->solicitSocketMessages(
connection->getSocket(),
connection->getQueueId(), MonitorEntry::TYPE_CONNECTION)))
{
PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
"HTTPConnector::connect: Attempt to allocate entry in "
"_entries table failed.");
(connection->getMPSocket()).close();
}
connection->_entry_index = index;
_rep->connections.append(connection.get());
PEG_METHOD_EXIT();
return connection.release();
}
/**
Parses the command line, validates the options, and sets instance
variables based on the option arguments.
@param argc the number of command line arguments
@param argv the string vector of command line arguments
@exception CommandFormatException if an error is encountered in parsing
the command line
*/
void OSInfoCommand::setCommand (Uint32 argc, char* argv [])
{
Uint32 i = 0;
Uint32 c = 0;
String httpVersion = String ();
String httpMethod = String ();
String timeoutStr = String ();
String GetOptString = String ();
getoopt getOpts;
_operationType = OPERATION_TYPE_UNINITIALIZED;
//
// Construct GetOptString
//
#ifndef DISABLE_SUPPORT_FOR_REMOTE_CONNECTIONS
GetOptString.append (_OPTION_HOSTNAME);
GetOptString.append (getoopt::GETOPT_ARGUMENT_DESIGNATOR);
GetOptString.append (_OPTION_PORTNUMBER);
GetOptString.append (getoopt::GETOPT_ARGUMENT_DESIGNATOR);
#ifdef PEGASUS_HAS_SSL
GetOptString.append (_OPTION_SSL);
#endif
GetOptString.append (_OPTION_TIMEOUT);
GetOptString.append (getoopt::GETOPT_ARGUMENT_DESIGNATOR);
GetOptString.append (_OPTION_USERNAME);
GetOptString.append (getoopt::GETOPT_ARGUMENT_DESIGNATOR);
GetOptString.append (_OPTION_PASSWORD);
GetOptString.append (getoopt::GETOPT_ARGUMENT_DESIGNATOR);
#endif
GetOptString.append (_OPTION_RAW_DATETIME_FORMAT);
//
// Initialize and parse getOpts
//
getOpts = getoopt ();
getOpts.addFlagspec (GetOptString);
//PEP#167 - adding long flag for options : 'help' and 'version'
getOpts.addLongFlagspec(LONG_HELP,getoopt::NOARG);
getOpts.addLongFlagspec(LONG_VERSION,getoopt::NOARG);
getOpts.parse (argc, argv);
if (getOpts.hasErrors ())
{
throw CommandFormatException(getOpts.getErrorStrings()[0]);
}
//
// Get options and arguments from the command line
//
for (i = getOpts.first (); i < getOpts.last (); i++)
{
if (getOpts[i].getType () == Optarg::LONGFLAG)
{
if (getOpts[i].getopt () == LONG_HELP)
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
String param = String (LONG_HELP);
//
// More than one operation option was found
//
throw UnexpectedOptionException(param);
}
_operationType = OPERATION_TYPE_HELP;
}
else if (getOpts[i].getopt () == LONG_VERSION)
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(String(LONG_VERSION));
}
_operationType = OPERATION_TYPE_VERSION;
}
}
else if (getOpts [i].getType () == Optarg::REGULAR)
{
throw UnexpectedArgumentException(getOpts[i].Value());
}
else /* getOpts [i].getType () == FLAG */
{
c = getOpts [i].getopt () [0];
switch (c)
{
case _OPTION_HOSTNAME:
{
if (getOpts.isSet (_OPTION_HOSTNAME) > 1)
{
//
// More than one hostname option was found
//
throw DuplicateOptionException(_OPTION_HOSTNAME);
}
_hostName = getOpts [i].Value ();
HostAddress addr(_hostName);
if (!addr.isValid())
{
throw InvalidLocatorException (_hostName);
}
_hostNameSet = true;
break;
}
case _OPTION_PORTNUMBER:
{
if (getOpts.isSet (_OPTION_PORTNUMBER) > 1)
{
//
// More than one portNumber option was found
//
throw DuplicateOptionException(_OPTION_PORTNUMBER);
}
_portNumberStr = getOpts [i].Value ();
try
{
getOpts [i].Value (_portNumber);
}
catch (const TypeMismatchException&)
{
throw InvalidOptionArgumentException(
_portNumberStr,
_OPTION_PORTNUMBER);
}
_portNumberSet = true;
break;
}
case _OPTION_SSL:
{
//
// Use port 5989 as the default port for SSL
//
_useSSL = true;
if (!_portNumberSet)
_portNumber = 5989;
break;
}
case _OPTION_RAW_DATETIME_FORMAT:
{
//
// Display "raw" CIM_DateTime format.
//
_useRawDateTimeFormat = true;
break;
}
case _OPTION_TIMEOUT:
{
if (getOpts.isSet (_OPTION_TIMEOUT) > 1)
{
//
// More than one timeout option was found
//
throw DuplicateOptionException(_OPTION_TIMEOUT);
}
timeoutStr = getOpts [i].Value ();
try
{
getOpts [i].Value (_timeout);
}
catch (const TypeMismatchException&)
{
throw InvalidOptionArgumentException(
timeoutStr,
_OPTION_TIMEOUT);
}
break;
}
case _OPTION_USERNAME:
{
if (getOpts.isSet (_OPTION_USERNAME) > 1)
{
//
// More than one username option was found
//
throw DuplicateOptionException(_OPTION_USERNAME);
}
_userName = getOpts [i].Value ();
_userNameSet = true;
break;
}
case _OPTION_PASSWORD:
{
if (getOpts.isSet (_OPTION_PASSWORD) > 1)
{
//
// More than one password option was found
//
throw DuplicateOptionException(_OPTION_PASSWORD);
}
_password = getOpts [i].Value ();
_passwordSet = true;
break;
}
default:
//
// This path should not be hit
// PEP#167 unless an empty '-' is specified
//_operationType = OPERATION_TYPE_UNINITIALIZED;
break;
}
}
}
//
// Some more validations
//
/*if ( _operationType == OPERATION_TYPE_UNINITIALIZED )
{
//
// No operation type was specified
// Show the usage
//
throw CommandFormatException(localizeMessage(
MSG_PATH,
REQUIRED_ARGS_MISSING_KEY,
REQUIRED_ARGS_MISSING));
}*/
if (getOpts.isSet (_OPTION_PORTNUMBER) < 1)
{
//
// No portNumber specified
// Default to WBEM_DEFAULT_PORT
// Already done in constructor
//
}
else
{
if (_portNumber > _MAX_PORTNUMBER)
{
//
// Portnumber out of valid range
//
throw InvalidOptionArgumentException(
_portNumberStr,
_OPTION_PORTNUMBER);
}
}
if (getOpts.isSet (_OPTION_TIMEOUT) < 1)
{
//
// No timeout specified
// Default to DEFAULT_TIMEOUT_MILLISECONDS
// Already done in constructor
//
}
else
{
if (_timeout == 0)
{
//
// Timeout out of valid range
//
throw InvalidOptionArgumentException(timeoutStr, _OPTION_TIMEOUT);
}
}
}