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.17 and 1.76

version 1.17, 2001/06/07 12:24:21

version 1.76, 2002/10/02 19:31:23

Line 1

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

// The Open Group, Tivoli Systems

// 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 above copyright notice and this permission notice shall be included in

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

// all copies or substantial portions of the Software.

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

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

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

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

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

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

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

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

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

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

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

// LIABILITY, WHETHER IN AN 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: 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)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)

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

Line 36

Line 43

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

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

// To run pegasus as a daemon on Unix platforms:

// cimserver

// cimserver -d

// To NOT run pegasus as a daemon on Unix platforms, set the daemon config

// property to false:

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

// cimserver daemon=false

// The daemon config property has no effect on windows operation.

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

// cimserver -s

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

Line 68

Line 84

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

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Constants.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) && ! defined(PEGASUS_NO_SLP)

#include <slp/slp.h>

#endif

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# include "cimserver_windows.cpp"

#elif defined(PEGASUS_OS_TYPE_UNIX)

# if defined(PEGASUS_OS_OS400)

# include "cimserver_os400.cpp"

# else

# include "cimserver_unix.cpp"

#endif

#else

# error "Unsupported platform"

#endif

Line 91

Line 121

PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

void GetEnvironmentVariables(

const char* arg0,

// The command name.

String& pegasusHome)

{

static const char COMMAND_NAME [] = "cimserver";

// Get environment variables:

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

// The constant defining usage string.

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

if (!tmp)

/**

{

Constants representing the command line options.

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

exit(1);

static const char OPTION_VERSION = 'v';

}

pegasusHome = tmp;

static const char OPTION_HELP = 'h';

FileSystem::translateSlashes(pegasusHome);

}

static const char OPTION_HOME = 'D';

static const char OPTION_SHUTDOWN = 's';

#if defined(PEGASUS_OS_HPUX)

static const char OPTION_BINDVERBOSE = 'X';

#endif

static const String PROPERTY_TIMEOUT = "shutdownTimeout";

static const String CIMSERVERSTART_FILE = "/etc/opt/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 optionsTable[] =

try

{

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

cm->mergeConfigFiles();

"specifies port number to listen on" },

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

"turns on trace of Client IO to console "},

{"logtrace", "false", false, Option::BOOLEAN, 0, 0, "l",

"Turns on trace of Client IO to trace log "},

{"options", "false", false, Option::BOOLEAN, 0, 0, "options",

" Displays the settings of the Options "},

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

"Sets the severity level that will be logged "},

{"logs", "ALL", false, Option::STRING, 0, 0, "X",

"Not Used "},

{"daemon", "false", false, Option::BOOLEAN, 0, 0, "d",

"Detach Pegasus from the console and run it in the background "},

{"logdir", "./logs", false, Option::STRING, 0, 0, "logdir",

"Directory for log files"},

{"cleanlogs", "false", false, Option::BOOLEAN, 0, 0, "clean",

"Clears the log files at startup"},

{"daemon", "false", false, Option::BOOLEAN, 0, 0, "d",

"Not Used "},

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

"Displays Pegasus Version "},

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

"Prints help message with command line options "},

{"install", "false", false, Option::BOOLEAN, 0, 0, "install",

"Installs Pegasus as a Windows NT Service "},

{"remove", "false", false, Option::BOOLEAN, 0, 0, "remove",

"Removes Pegasus as a Windows NT Service "},

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

"Not Used "}

};

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

om.registerOptions(optionsTable, NUM_OPTIONS);

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

cout << "Config file from " << configFile << endl;

if (FileSystem::exists(configFile))

om.mergeFile(configFile);

if(argc && argv != NULL)

om.mergeCommandLine(argc, argv);

om.checkRequiredOptions();

cm->mergeCommandLine(argc, argv);

}

catch (NoSuchFile nsf)

{

throw nsf;

}

catch (FileNotReadable fnr)

{

throw fnr;

}

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 174

Line 198

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 CIM Server version number\n");

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

usage.append (" -s - shuts down CIM Server\n");

#ifndef PEGASUS_OS_HPUX

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

#endif

#if defined(PEGASUS_OS_TYPE_WINDOWS)

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

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

#endif

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

usage.append (" - sets CIM Server configuration property\n");

cout << endl;

#if defined(PEGASUS_OS_HPUX)

cout << PLATFORM_PRODUCT_NAME << " " << PLATFORM_PRODUCT_VERSION << endl;

#else

cout << PEGASUS_NAME << PEGASUS_VERSION << endl;

cout << '\n';

#endif

cout << "Usage: " << arg0 << endl;

cout << endl;

cout << usage << endl;

}

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

void shutdownCIMOM(Uint32 timeoutValue)

{

// Create CIMClient object

CIMClient client;

// Get local host name

String hostStr = System::getHostName();

// open connection to CIMOM

try

{

client.connectLocal();

// set client timeout to 2 seconds

client.setTimeout(2000);

}

catch(Exception& e)

{

PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);

PEGASUS_STD(cerr) << "CIM Server may not be running." << PEGASUS_STD(endl);

#ifdef PEGASUS_OS_OS400

// The server job may still be active but not responding.

// Kill the job if it exists.

cimserver_kill();

#endif

exit(0);

}

try

{

// construct CIMObjectPath

String referenceStr = "//";

referenceStr.append(hostStr);

referenceStr.append("/");

referenceStr.append(PEGASUS_NAMESPACENAME_SHUTDOWN.getString());

referenceStr.append(":");

referenceStr.append(PEGASUS_CLASSNAME_SHUTDOWN.getString());

CIMObjectPath reference(referenceStr);

// issue the invokeMethod request on the shutdown method

Array<CIMParamValue> inParams;

Array<CIMParamValue> outParams;

// set force option to true for now

inParams.append(CIMParamValue("force",

CIMValue(Boolean(true))));

inParams.append(CIMParamValue("timeout",

CIMValue(Uint32(timeoutValue))));

CIMValue retValue = client.invokeMethod(

PEGASUS_NAMESPACENAME_SHUTDOWN,

reference,

"shutdown",

inParams,

outParams);

}

catch(CIMException& e)

{

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

if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)

{

PEGASUS_STD(cerr) << "The repository may be empty.";

PEGASUS_STD(cerr) << PEGASUS_STD(endl);

}

else

{

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

}

#ifdef PEGASUS_OS_OS400

// Kill the server job.

cimserver_kill();

#endif

exit(1);

}

catch(Exception& e)

{

// This may mean the CIM Server has been terminated and returns a

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

// CIM Server gets shutdown, if CIM Server is still running at

// this time, we will kill the cimserver process.

// give CIM Server some time to finish up

//System::sleep(1);

//cimserver_kill();

// Check to see if CIMServer is still running. If CIMServer

// is still running and the shutdown timeout has not expired,

// loop and wait one second until either CIM Server is

// terminated or until timeout expires. If timeout expires

// and CIMServer is still running, kill the CIMServer

// process.

Uint32 maxWaitTime = timeoutValue - 2;

Boolean running = isCIMServerRunning();

while ( running && maxWaitTime > 0 )

{

System::sleep(1);

running = isCIMServerRunning();

maxWaitTime = maxWaitTime - 1;

}

if (running)

{

cimserver_kill();

}

//catch(Exception& e)

//{

// PEGASUS_STD(cerr) << "Error occurred while stopping the CIM Server: ";

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

// exit(1);

//}

return;

}

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

// MAIN

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

int main(int argc, char** argv)

{

String pegasusHome = String::EMPTY;

Boolean pegasusIOLog = false;

String httpPort = String::EMPTY;

String httpsPort = String::EMPTY;

String logsDirectory = String::EMPTY;

Boolean useSLP = false;

Boolean useSSL = false;

Boolean daemonOption = false;

Boolean shutdownOption = false;

Uint32 timeoutValue = 0;

#ifdef PEGASUS_OS_OS400

// Initialize Pegasus home to the shipped OS/400 directory.

pegasusHome = OS400_DEFAULT_PEGASUS_HOME;

#endif

// 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 shutdown options

// Get environment variables:

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

{

const char* arg = argv[i];

String pegasusHome;

// Check for -option

if (*arg == '-')

{

// Get the option

const char* option = arg + 1;

GetEnvironmentVariables(argv[0], pegasusHome);

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

if (*option == OPTION_VERSION)

{

#if defined(PEGASUS_OS_HPUX)

cout << PLATFORM_PRODUCT_VERSION << endl;

#else

cout << PEGASUS_VERSION << endl;

#endif

exit(0);

}

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

else if (*option == OPTION_HELP)

{

PrintHelp(argv[0]);

exit(0);

}

#ifndef PEGASUS_OS_HPUX

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;

}

#endif

#if defined(PEGASUS_OS_HPUX)

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

if (*option == OPTION_BINDVERBOSE)

{

System::bindVerbose = true;

cout << "Unsupported debug option, BIND_VERBOSE, enabled."

<< endl;

// remove the option from the command line

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

argc--;

}

#endif

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

else if (*option == OPTION_SHUTDOWN)

{

// check to see if user is root

#ifndef PEGASUS_OS_OS400

if (!System::isPrivilegedUser(System::getEffectiveUserName()))

{

cout << "You must have superuser privilege to run ";

cout << "cimserver." << endl;

exit(0);

}

#endif

// 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

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 214

Line 530

exit(1);

}

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

try

// error if there are any remaining:

if (argc != 1)

{

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

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

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

cout << endl;

exit(1);

}

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

String installOption;

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

if(om.lookupValue("install", installOption) && installOption == "true")

{

if( 0 != cimserver_install_nt_service( pegasusHome ))

{

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

exit(0);

}

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

String removeOption;

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

if(om.lookupValue("remove", removeOption) && removeOption == "true")

{

if( 0 != cimserver_remove_nt_service() )

{

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

exit(0);

}

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

String versionOption;

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

{

cerr << PEGASUS_VERSION << endl;

exit(0);

}

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

String helpOption;

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

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

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

{

PrintHelp(argv[0]);

daemonOption = true;

om.printHelp();

exit(0);

}

// Check the trace options and set global variable

Boolean pegasusIOTrace = false;

// Check the log trace options and set global variable

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

{

Handler::setMessageTrace(true);

pegasusIOTrace = true;

}

Boolean pegasusIOLog = false;

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

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

{

Handler::setMessageLogTrace(true);

pegasusIOLog = true;

}

// Grab the port otpion:

String portOption;

om.lookupValue("port", portOption);

// Get the log file directory definition.

// We put String into Cstring because

// Directory functions only handle Cstring.

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

String logsDirectory;

om.lookupValue("logdir", logsDirectory);

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

logsDirectory =

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

// 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.

#ifndef PEGASUS_OS_HPUX

Logger::setHomeDirectory(logsDirectory);

#endif

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

// Check to see if we need to shutdown CIMOM

if (shutdownOption)

{

Logger::clean(logsDirectory);;

String configTimeout =

configManager->getCurrentValue("shutdownTimeout");

timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);

shutdownCIMOM(timeoutValue);

cout << "CIM Server stopped." << endl;

exit(0);

}

// Get the port numbers

httpPort = configManager->getCurrentValue("httpPort");

httpsPort = configManager->getCurrentValue("httpsPort");

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

#ifndef PEGASUS_OS_HPUX

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

#endif

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

{

Logger::clean(logsDirectory);;

}

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

{

useSLP = true;

}

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

{

useSSL = true;

}

catch (UnrecognizedConfigProperty e)

{

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

}

char* address = portOption.allocateCString();

Uint32 portNumber;

char address[32];

if (useSSL)

{

char* end = 0;

CString portString = httpsPort.getCString();

Uint32 port = strtol(portString, &end, 10);

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

// Look up the WBEM-HTTPS port number

portNumber = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, port);

sprintf(address, "%u", portNumber);

}

else

{

char* end = 0;

CString portString = httpPort.getCString();

Uint32 port = strtol(portString, &end, 10);

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

// Look up the WBEM-HTTP port number

portNumber = System::lookupPort(WBEM_HTTP_SERVICE_NAME, port);

sprintf(address, "%u", portNumber);

}

// Put out startup up message.

#ifndef PEGASUS_OS_HPUX

cout << PEGASUS_NAME << PEGASUS_VERSION <<

" on port " << address << endl;

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

cout <<"Started..."

cout <<"Starting..."

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

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

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

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

<< endl;

#endif

// Option to Display the options table. Primarily

// a diagnostic tool.

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

om.print();

// Put server start message to the logger

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

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

PEGASUS_NAME,

PEGASUS_VERSION,

address,

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

// do we need to run as a daemon ?

String daemonOption;

if (daemonOption)

if(om.lookupValue("daemon", daemonOption) && daemonOption == "true")

{

if(-1 == cimserver_fork())

exit(-1);

}

#ifdef PEGASUS_OS_OS400

// Special server initialization code for OS/400.

if (cimserver_initialize() != 0)

{

// do some logging here!

exit(-1);

}

#endif

#ifdef PEGASUS_OS_HPUX

umask(S_IWGRP|S_IWOTH);

#endif

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

try

{

Selector selector;

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

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.append(host_name);

serviceURL.append(":");

serviceURL.append(address);

#endif

Monitor monitor(true);

CIMServer server(&monitor, useSSL);

// bind throws an exception of the bind fails

// bind throws an exception if the bind fails

server.bind(address);

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

delete [] address;

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

#elif !defined(PEGASUS_OS_HPUX)

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

#endif

server.bind(portNumber);

// notify parent process (if there is a parent process) to terminate

// so user knows that cimserver is ready to serve CIM requests.

if (daemonOption)

notify_parent();

time_t last = 0;

#if defined(PEGASUS_OS_HPUX)

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

// save the process id of the cimserver process in the file

// remove the old file if it exists

System::removeFile(fname);

// open the file

FILE *pid_file = fopen(fname, "w");

if (pid_file)

{

// save the pid in the file

fprintf(pid_file, "%ld\n", (long)server_pid);

fclose(pid_file);

}

#endif

#ifndef PEGASUS_OS_HPUX

cout << "Started. " << endl;

#endif

// Put server started message to the logger

#ifdef PEGASUS_OS_HPUX

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

"Started $0 version $1 on port $2.",

PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION, address);

#else

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

"Started $0 version $1 on port $2.",

PEGASUS_NAME, PEGASUS_VERSION, address);

#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) && ! defined(PEGASUS_NO_SLP)

if(useSLP )

{

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

{

if( discovery != NULL && serviceURL.size() )

discovery->srv_reg_all(serviceURL.getCString(),

"(namespace=root/cimv2)",

"service:cim.pegasus",

"DEFAULT",

70) ;

time(&last);

}

discovery->service_listener();

}

#endif

server.runForever();

}

// normal termination

// Put server shutdown message to the logger

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

"Normal Termination");

"$0 stopped.", PEGASUS_NAME);

#if defined(PEGASUS_OS_HPUX)

// close the file created 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);

return 1;

}

return 0;

}

Legend:

Removed from v.1.17
changed lines
	Added in v.1.76

No CVS admin address has been configured