pegasus/src/Server/cimserver.cpp - diff

Return to cimserver.cpp CVS log

Up to [Pegasus] / pegasus / src / Server

Diff for /pegasus/src/Server/cimserver.cpp between version 1.13 and 1.46

version 1.13, 2001/06/02 02:25:33

version 1.46, 2002/05/13 21:47:11

Line 1

//%/////////////////////////////////////////////////////////////////////////////

// Permission is hereby granted, free of charge, to any person obtaining a

// Permission is hereby granted, free of charge, to any person obtaining a copy

// copy of this software and associated documentation files (the "Software"),

// of this software and associated documentation files (the "Software"), to

// to deal in the Software without restriction, including without limitation

// deal in the Software without restriction, including without limitation the

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// and/or sell copies of the Software, and to permit persons to whom the

// sell copies of the Software, and to permit persons to whom the Software is

// Software is furnished to do so, subject to the following conditions:

// furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// DEALINGS IN THE SOFTWARE.

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Mike Day (mdday@us.ibm.com)

// Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)

// Modified By: Nag Boranna (nagaraja_boranna@hp.com)

// Modified By: Jenny Yu (jenny_yu@hp.com)

// Modified By: Sushma Fernandes (sushma_fernandes@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////

// Notes on deamon operation (Unix) and service operation (Win 32):

// To run pegasus as a daemon on Unix platforms, use the -d option:

// cimserver -d

// The -d option has no effect on windows operation.

// To shutdown pegasus, use the -s option:

// cimserver -s [-f] [-T timeout_value]

// To run pegasus as an NT service, there are FOUR different possibilities:

// To INSTALL the Pegasus service,

// cimserver -install

// To REMOVE the Pegasus service,

// cimserver -remove

// To START the Pegasus service,

// net start cimserver

// To STOP the Pegasus service,

// net stop cimserver

// Alternatively, you can use the windows service manager. Pegasus shows up

// in the service database as "Pegasus CIM Object Manager"

// Mike Day, mdday@us.ibm.com

//////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>

#include <iostream>

#include <cassert>

#include <cstdlib>

#include <fstream>

#include <Pegasus/Common/FileSystem.h>

#include <Pegasus/Common/Selector.h>

#include <Pegasus/Common/Monitor.h>

#include <Pegasus/Common/OptionManager.h>

#include <Pegasus/Server/CIMServer.h>

#include <Pegasus/Common/PegasusVersion.h>

#include <Pegasus/Protocol/Handler.h>

#include <Pegasus/Common/Logger.h>

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Config/ConfigManager.h>

#include <Pegasus/Client/CIMClient.h>

#include <Pegasus/Server/ShutdownService.h>

#include <Pegasus/Common/Destroyer.h>

#if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX)

#include <slp/slp.h>

#endif

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# include "cimserver_windows.cpp"

#elif defined(PEGASUS_OS_TYPE_UNIX)

# include "cimserver_unix.cpp"

#else

# error "Unsupported platform"

#endif

PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

// The command name.

static const char COMMAND_NAME [] = "cimserver";

// The constant defining usage string.

static const char USAGE [] = "Usage: ";

void GetEnvironmentVariables(

/**

const char* arg0,

Constants representing the command line options.

String& pegasusHome)

{

static const char OPTION_VERSION = 'v';

// Get environment variables:

const char* tmp = getenv("PEGASUS_HOME");

static const char OPTION_HELP = 'h';

if (!tmp)

static const char OPTION_HOME = 'D';

{

cerr << arg0 << ": PEGASUS_HOME environment variable undefined" << endl;

exit(1);

}

pegasusHome = tmp;

static const char OPTION_SHUTDOWN = 's';

FileSystem::translateSlashes(pegasusHome);

}

static const char OPTION_FORCE = 'f';

static const char OPTION_TIMEOUT = 'T';

static const String NAMESPACE = "root/PG_Internal";

static const String CLASSNAME_SHUTDOWNSERVICE = "PG_ShutdownService";

static const String PROPERTY_TIMEOUT = "operationTimeout";

static const String CIMSERVERSTART_FILE = "/etc/wbem/cimserver_start.conf";

ConfigManager* configManager;

/** GetOptions function - This function defines the Options Table

and sets up the options from that table using the option manager.

and sets up the options from that table using the config manager.

void GetOptions(

OptionManager& om,

ConfigManager* cm,

int& argc,

char** argv,

const String& pegasusHome)

{

static struct OptionRow options[] =

try

{

{"port", "8888", false, Option::WHOLE_NUMBER, 0, 0, "port"},

cm->mergeConfigFiles();

{"trace", "false", false, Option::BOOLEAN, 0, 0, "t"},

{"severity", "ALL", false, Option::STRING, 0, 0, "s"},

{"logs", "ALL", false, Option::STRING, 0, 0, "L"},

{"daemon", "false", false, Option::STRING, 0, 0, "d"},

{"version", "false", false, Option::BOOLEAN, 0, 0, "v"},

{"help", "false", false, Option::BOOLEAN, 0, 0, "h"},

{"debug", "false", false, Option::BOOLEAN, 0, 0, "d"}

};

const Uint32 NUM_OPTIONS = sizeof(options) / sizeof(options[0]);

om.registerOptions(options, NUM_OPTIONS);

cm->mergeCommandLine(argc, argv);

}

String configFile = pegasusHome + "/cimserver.conf";

catch (NoSuchFile nsf)

{

if (FileSystem::exists(configFile))

throw nsf;

om.mergeFile(configFile);

}

catch (FileNotReadable fnr)

om.mergeCommandLine(argc, argv);

{

throw fnr;

om.checkRequiredOptions();

}

catch (CannotRenameFile ftrf)

{

throw ftrf;

}

catch (ConfigFileSyntaxError cfse)

{

throw cfse;

}

catch(UnrecognizedConfigProperty ucp)

{

throw ucp;

}

catch(InvalidPropertyValue ipv)

{

throw ipv;

}

/* PrintHelp - This is temporary until we expand the options manager to allow

Line 98

Line 186

void PrintHelp(const char* arg0)

{

cout << '\n';

/**

Build the usage string for the config command.

String usage = String (USAGE);

usage.append (COMMAND_NAME);

usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");

usage.append (" options\n");

usage.append (" -v - displays pegasus version number\n");

usage.append (" -h - prints this help message\n");

usage.append (" -D [home] - sets pegasus home directory\n");

usage.append (" -t - turns tracing on\n");

usage.append (" -t - turns on trace of client IO to console\n");

usage.append (" -l - turns on trace of client IO to trace file\n");

usage.append (" -d - runs pegasus as a daemon\n");

usage.append (" -s [-f] [-T timeout] \n");

usage.append (" - shuts down pegasus\n");

usage.append (" -cleanlogs - clears the log files at startup\n");

usage.append (" -install - installs pegasus as a Windows NT Service\n");

usage.append (" -remove - removes pegasus as a Windows NT Service\n");

usage.append (" -slp - registers pegasus as a service with SLP\n\n");

usage.append (" -SSL - uses SSL\n\n");

usage.append (" configProperty=value\n");

usage.append (" port=nnnn - sets port number to listen on\n");

usage.append (" logdir=/pegasus/logs - directory for log files\n");

cout << endl;

cout << PEGASUS_NAME << PEGASUS_VERSION << endl;

cout << '\n';

cout << "Usage: " << arg0 << " [-port <port_num> -t -h -v]\n";

cout << '\n';

cout << " -h - prints this help message\n";

cout << " -port - specifies port number to listen on\n";

cout << " -v - prints out the version number\n";

cout << " -t - turns on trace mode\n";

cout << " -d - turns on debug mode\n";

cout << endl;

cout << usage << endl;

}

//////////////////////////////////////////////////////////////////////////

void shutdownCIMOM(Boolean forceOption, Uint32 timeoutValue)

{

// Create CIMClient object

CIMClient client;

// Get the port number

String portNumberStr = configManager->getCurrentValue("port");

String hostStr = System::getHostName();

hostStr.append(":");

hostStr.append(portNumberStr);

// Put server shutdown message to the logger

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"Shutdown $0 on port $1.", PEGASUS_NAME, portNumberStr);

// open connection to CIMOM

try

{

client.connectLocal();

}

catch(CIMClientException& e)

{

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"Failed to connect to $0 $1.", PEGASUS_NAME, e.getMessage());

PEGASUS_STD(cerr) << "Failed to connect to server: ";

PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);

exit(0);

}

try

{

// construct CIMReference

String referenceStr = "//";

referenceStr.append(hostStr);

referenceStr.append("/root/cimv2:PG_ShutdownService");

CIMReference reference(referenceStr);

// issue the invokeMethod request on the shutdown method

Array<CIMParamValue> inParams;

Array<CIMParamValue> outParams;

inParams.append(CIMParamValue("force",

CIMValue(Boolean(forceOption))));

inParams.append(CIMParamValue("timeout",

CIMValue(Uint32(timeoutValue))));

CIMValue retValue = client.invokeMethod(

NAMESPACE,

reference,

"shutdown",

inParams,

outParams);

// Put server shutdown message to the logger

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"$0 terminated on port $1.", PEGASUS_NAME, portNumberStr);

}

catch(CIMClientCIMException& e)

{

PEGASUS_STD(cerr) << "Failed to shutdown server: ";

PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);

exit(1);

}

catch(CIMClientException& e)

{

// This may mean the cimserver has been terminated and returns the

// "Empty HTTP response message" HTTP error response. To be sure,

// we need to check if cimserver is indeed terminated.

#ifdef PEGASUS_OS_TYPE_UNIX

System::sleep(1);

int ret = system("ps -ef | grep cimserver | grep -v grep | grep -v cimserverd >/dev/null");

if (ret == 0)

{

// cimserver has been terminated

// Put server shutdown message to the logger

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"$0 terminated on port $1.", PEGASUS_NAME, portNumberStr);

}

else

{

// cimserver is still running

PEGASUS_STD(cerr) << "Failed to shutdown server: ";

PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);

exit(1);

}

#endif

}

catch(Exception& e)

{

PEGASUS_STD(cerr) << "Failed to shutdown server: ";

PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);

exit(1);

}

return;

}

/////////////////////////////////////////////////////////////////////////

// MAIN

//////////////////////////////////////////////////////////////////////////

int main(int argc, char** argv)

{

String pegasusHome = String::EMPTY;

Boolean pegasusIOTrace = false;

Boolean pegasusIOLog = false;

String portOption = String::EMPTY;

String logsDirectory = String::EMPTY;

Boolean useSLP = false;

Boolean useSSL = false;

Boolean daemonOption = false;

Boolean shutdownOption = false;

Boolean forceOption = false;

Boolean timeoutOption = false;

String timeoutStr = String::EMPTY;

long timeoutValue = 0;

// Get environment variables:

const char* tmp = getenv("PEGASUS_HOME");

if (tmp)

{

pegasusHome = tmp;

}

FileSystem::translateSlashes(pegasusHome);

// on Windows NT if there are no command-line options, run as a service

if (argc == 1 )

{

cim_server_service(argc, argv);

}

else

{

// Get help, version and home options

for (int i = 1; i < argc; )

{

const char* arg = argv[i];

String pegasusHome;

// Check for -option

GetEnvironmentVariables(argv[0], pegasusHome);

if (*arg == '-')

{

// Get the option

const char* option = arg + 1;

// Check to see if user asked for the version (-v option):

if (*option == OPTION_VERSION)

{

cout << PEGASUS_VERSION << endl;

exit(0);

}

// Check to see if user asked for help (-h option):

else if (*option == OPTION_HELP)

{

PrintHelp(argv[0]);

exit(0);

}

else if (*option == OPTION_HOME)

{

if (i + 1 < argc)

{

pegasusHome.assign(argv[i + 1]);

}

else

{

cout << "Missing argument for option -" << option << endl;

exit(0);

}

memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));

argc -= 2;

}

// Check to see if user asked for shutdown (-s option):

else if (*option == OPTION_SHUTDOWN)

{

// Check to see if shutdown has already been specified:

if (shutdownOption)

{

cout << "Duplicate shutdown option specified." << endl;

exit(0);

}

shutdownOption = true;

// remove the option from the command line

memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));

argc--;

}

else if (*option == OPTION_FORCE)

{

// Check to see if shutdown has been specified:

if (!shutdownOption)

{

cout << "Invalid option -" << option << endl;

exit(0);

}

// Check to see if force has already been specified:

if (forceOption)

{

cout << "Duplicate force option specified." << endl;

exit(0);

}

forceOption = true;

// remove the option from the command line

memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));

argc--;

}

else if (*option == OPTION_TIMEOUT)

{

// Check to see if shutdown has been specified:

if (!shutdownOption)

{

cout << "Invalid option -" << option << endl;

exit(0);

}

if (timeoutOption)

{

cout << "Duplicate timeout option specified." << endl;

exit(0);

}

timeoutOption = true;

if (i + 1 < argc)

{

// get timeout value

timeoutStr.assign(argv[i + 1]);

// validate timeout value string

char* tmp = timeoutStr.allocateCString();

char* end = 0;

timeoutValue = strtol(tmp, &end, 10);

if (!end || *end != '\0')

{

cout << "invalid timeout value specified: ";

cout << timeoutStr << endl;

delete [] tmp;

exit(0);

}

else

{

cout << "Missing argument for option -";

cout << option << endl;

exit(0);

}

// remove the option from the command line

memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));

argc -= 2;

}

else

i++;

}

else

i++;

}

// Set the value for pegasusHome property

ConfigManager::setPegasusHome(pegasusHome);

// Get an instance of the Config Manager.

configManager = ConfigManager::getInstance();

// Get options (from command line and from configuration file); this

// removes corresponding options and their arguments fromt he command

// line.

OptionManager om;

try

{

GetOptions(om, argc, argv, pegasusHome);

GetOptions(configManager, argc, argv, pegasusHome);

// om.print();

}

catch (Exception& e)

{

Line 138

Line 540

exit(1);

}

// At this point, all options should have been extracted; print an

// error if there are any remaining:

if (argc != 1)

try

{

cerr << argv[0] << ": unrecognized options: ";

// Check to see if we should (can) install as a NT service

for (int i = 1; i < argc; i++)

if (String::equal(configManager->getCurrentValue("install"), "true"))

cerr << argv[i] << ' ';

{

cout << endl;

if( 0 != cimserver_install_nt_service( pegasusHome ))

exit(1);

{

cout << "\nPegasus installed as NT Service";

exit(0);

}

// Check to see if user asked for the version (-v otpion):

// Check to see if we should (can) remove Pegasus as an NT service

String versionOption;

if (om.lookupValue("version", versionOption) && versionOption == "true")

if (String::equal(configManager->getCurrentValue("remove"), "true"))

{

if( 0 != cimserver_remove_nt_service() )

{

cerr << PEGASUS_VERSION << endl;

cout << "\nPegasus removed as NT Service";

exit(0);

}

// Check to see if we should Pegasus as a daemon

if (String::equal(configManager->getCurrentValue("daemon"), "true"))

{

daemonOption = true;

}

// Check the log trace options and set global variable

if (String::equal(configManager->getCurrentValue("logtrace"), "true"))

{

pegasusIOLog = true;

}

// Get the log file directory definition.

// We put String into Cstring because

// Directory functions only handle Cstring.

// ATTN-KS: create String based directory functions.

logsDirectory = configManager->getCurrentValue("logdir");

logsDirectory =

ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));

// Check to see if user asked for help (-h otpion):

// Set up the Logger. This does not open the logs

// Might be more logical to clean before set.

// ATTN: Need tool to completely disable logging.

String helpOption;

Logger::setHomeDirectory(logsDirectory);

if (om.lookupValue("help", helpOption) && helpOption == "true")

// Check to see if we need to shutdown CIMOM

if (shutdownOption)

{

PrintHelp(argv[0]);

// if timeout was specified, validate the timeout value

if (timeoutOption)

{

Boolean valid = configManager->validatePropertyValue(

PROPERTY_TIMEOUT,

timeoutStr);

if (!valid)

{

cout << "Invalid timeout value specified: " << timeoutValue;

cout << endl;

exit(1);

}

shutdownCIMOM(forceOption, timeoutValue);

cout << "Pegasus CIM Server terminated." << endl;

exit(0);

}

// Grab the port option:

portOption = configManager->getCurrentValue("port");

// Check the trace options and set global variable

Boolean pegasusIOTrace = false;

if (om.valueEquals("trace", "true"))

if (String::equal(configManager->getCurrentValue("trace"), "true"))

{

Handler::sethandlerTrace(true);

pegasusIOTrace = true;

cout << "Trace Set" << endl;

}

// Grab the port otpion:

// Leave this in until people get familiar with the logs.

cout << "Logs Directory = " << logsDirectory << endl;

if (String::equal(configManager->getCurrentValue("cleanlogs"), "true"))

{

Logger::clean(logsDirectory);;

}

String portOption;

if (String::equal(configManager->getCurrentValue("slp"), "true"))

om.lookupValue("port", portOption);

{

useSLP = true;

}

if (String::equal(configManager->getCurrentValue("SSL"), "true"))

{

useSSL = true;

}

catch (UnrecognizedConfigProperty e)

{

cout << "Error: " << e.getMessage() << endl;

}

char* address = portOption.allocateCString();

// Put out startup up message.

// Put to cout if not daemon

// ATTN: modify when we add daemon

cout << PEGASUS_NAME << PEGASUS_VERSION <<

" on port " << address << endl;

cout << "Built " << __DATE__ << " " << __TIME__ << endl;

cout <<"Started..."

<< (pegasusIOTrace ? " Tracing": " ") << endl;

<< (pegasusIOTrace ? " Tracing to Display ": " ")

<< (pegasusIOLog ? " Tracing to Log ": " ")

// Set up the Logger

<< (useSLP ? " SLP reg. " : " No SLP ")

Logger::setHomeDirectory("./logs");

<< (useSSL ? " Use SSL " : " No SSL ")

<< endl;

// Put server start message to the logger

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"Start $0 %1 port $2 $3 ", 88, PEGASUS_NAME, PEGASUS_VERSION,

"Start $0 $1 port $2 $3 $4 $5",

address, (pegasusIOTrace ? " Tracing": " "));

PEGASUS_NAME,

PEGASUS_VERSION,

address,

(pegasusIOTrace ? " Tracing": " "),

(useSLP ? " SLP on " : " SLP off "),

(useSSL ? " Use SSL " : " No SSL "));

// do we need to run as a daemon ?

if (daemonOption)

{

if(-1 == cimserver_fork())

exit(-1);

}

// try loop to bind the address, and run the server

try

{

Selector selector;

#if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX)

CIMServer server(&selector, pegasusHome);

slp_client *discovery = new slp_client() ;;

String serviceURL;

serviceURL.assign("service:cim.pegasus://");

String host_name = slp_get_host_name();

serviceURL += host_name;

serviceURL += ":";

serviceURL += address;

char *url = serviceURL.allocateCString();

// free(host_name);

#endif

Monitor monitor;

CIMServer server(&monitor, useSSL);

// bind throws an exception if the bind fails

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

cout << "Binding to domain socket" << endl;

#else

cout << "Binding to " << address << endl;

#endif

char* end = 0;

long portNumber = strtol(address, &end, 10);

assert(end != 0 && *end == '\0');

server.bind(portNumber);

server.bind(address);

delete [] address;

time_t last = 0;

#if defined(PEGASUS_OS_HPUX)

// create a file to indicate that the cimserver has started

fstream fs;

ArrayDestroyer<char> p(CIMSERVERSTART_FILE.allocateCString());

fs.open(p.getPointer(), ios::in | ios::out);

if (!fs)

{

// failed to create the file, write an entry to the log file

// and proceed

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"Failed to open the $0 file needed by cimserverd.",

CIMSERVERSTART_FILE);

}

else

{

fs.close();

}

#endif

// Loop to call CIMServer's runForever() method until CIMServer

// has been shutdown

while( !server.terminated() )

{

#if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX)

if(useSLP )

{

if( (time(NULL) - last ) > 60 )

{

if( discovery != NULL && url != NULL )

discovery->srv_reg_all(url,

"(namespace=root/cimv2)",

"service:cim.pegasus",

"DEFAULT",

70) ;

time(&last);

}

discovery->service_listener();

}

#endif

server.runForever();

}

// normal termination

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"Normal Termination");

#if defined(PEGASUS_OS_HPUX)

// close the file at startup time to indicate that the cimserver

// has terminated normally.

FileSystem::removeFile(CIMSERVERSTART_FILE);

#endif

}

catch(Exception& e)

{

Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,

"Abnormal Termination $0", e.getMessage());

PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);

}

Legend:

Removed from v.1.13
changed lines
	Added in v.1.46

No CVS admin address has been configured