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.22 and 1.138

version 1.22, 2001/06/14 22:26:45

version 1.138, 2004/07/22 23:13:11

Line 1

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

//%2003////////////////////////////////////////////////////////////////////////

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

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

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

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

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

// IBM Corp.; EMC Corporation, The Open Group.

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

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

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

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

// The above copyright notice and this permission notice shall be included in

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

// all copies or substantial portions of the Software.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DEALINGS IN THE SOFTWARE.

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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)

// Modified By: Dave Rosckes (rosckes@us.ibm.com)

// Modified By: Humberto Rivero (hurivero@us.ibm.com)

// Modified By: Steve Hills (steve.hills@ncr.com)

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

Line 36

Line 51

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

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

// property to false:

// cimserver daemon=false

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

// cimserver -d

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

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

// cimserver -s

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

Line 55

Line 79

// To START the Pegasus service,

// net start cimserver

// or

// cimserver -start

// To STOP the Pegasus service,

// net stop cimserver

// or

// cimserver -stop

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

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

Line 68

Line 96

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

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

PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

int cimserver_run( int argc, char** argv, Boolean shutdownOption );

Uint32 parentPid = 0;

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# include "cimserver_windows.cpp"

#elif defined(PEGASUS_OS_TYPE_UNIX)

# if defined(PEGASUS_OS_OS400)

# include "vfyptrs.cinc"

# include "OS400ConvertChar.h"

# include "cimserver_os400.cpp"

# else

# include "cimserver_unix.cpp"

#endif

#else

# error "Unsupported platform"

#endif

PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

// The command name.

static const char COMMAND_NAME [] = "cimserver";

void GetEnvironmentVariables(

const char* arg0,

// The constant defining usage string.

String& pegasusHome)

{

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

// Get environment variables:

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

/**

Constants representing the command line options.

static const char OPTION_VERSION = 'v';

static const char OPTION_HELP = 'h';

static const char OPTION_HOME = 'D';

static const char OPTION_SHUTDOWN = 's';

#if defined(PEGASUS_OS_HPUX)

static const char OPTION_BINDVERBOSE = 'X';

#endif

if (!tmp)

static const String PROPERTY_TIMEOUT = "shutdownTimeout";

ConfigManager* configManager;

/** Helper for platform specific handling. So platform specific code

can use our single instance of CIMServer.

class CimserverHolder

{

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

public:

exit(1);

CimserverHolder( CIMServer* s )

{

cimserver_set( s );

}

virtual ~CimserverHolder()

pegasusHome = tmp;

{

FileSystem::translateSlashes(pegasusHome);

cimserver_set( 0 );

}

};

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

char** argv)

const String& pegasusHome)

{

static struct OptionRow optionsTable[] =

try

{

{"port", "5988", 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"},

{"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 "},

{"slp", "true", false, Option::BOOLEAN, 0, 0, "slp",

"Register Pegasus as a Service with SLP"}

};

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

om.registerOptions(optionsTable, NUM_OPTIONS);

cm->mergeCommandLine(argc, argv);

}

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

catch (NoSuchFile&)

{

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

throw;

}

if (FileSystem::exists(configFile))

catch (FileNotReadable&)

om.mergeFile(configFile);

{

if(argc && argv != NULL)

throw;

om.mergeCommandLine(argc, argv);

}

catch (CannotRenameFile&)

om.checkRequiredOptions();

{

throw;

}

catch (ConfigFileSyntaxError&)

{

throw;

}

catch(UnrecognizedConfigProperty&)

{

throw;

}

catch(InvalidPropertyValue&)

{

throw;

}

catch (CannotOpenFile&)

{

throw;

}

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

Line 175

Line 229

void PrintHelp(const char* arg0)

{

cout << '\n';

/**

Build the usage string for the config command.

/* l10n

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");

#if !defined(PEGASUS_USE_RELEASE_DIRS)

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

#endif

#if defined(PEGASUS_OS_TYPE_WINDOWS)

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

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n");

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

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n");

usage.append (" -start [name] - starts pegasus as a Windows NT Service\n");

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n");

usage.append (" -stop [name] - stops pegasus as a Windows NT Service\n");

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n\n");

#endif

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

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

cout << endl;

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

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;

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

// MAIN

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

int main(int argc, char** argv)

{

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

String usage = String (USAGE);

if (argc == 1 )

usage.append (COMMAND_NAME);

cim_server_service(argc, argv) ;

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");

#if !defined(PEGASUS_USE_RELEASE_DIRS)

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

#endif

#if defined(PEGASUS_OS_TYPE_WINDOWS)

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

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n");

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

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n");

usage.append (" -start [name] - starts pegasus as a Windows NT Service\n");

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n");

usage.append (" -stop [name] - stops pegasus as a Windows NT Service\n");

usage.append (" [name] is optional and overrides the\n");

usage.append (" default CIM Server Service Name\n\n");

#endif

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

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

// Get environment variables:

cout << endl;

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

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

#else

cout << PEGASUS_NAME << PEGASUS_VERSION << endl;

#endif

cout << endl;

String pegasusHome;

#if defined(PEGASUS_OS_TYPE_WINDOWS)

MessageLoaderParms parms("src.Server.cimserver.MENU.WINDOWS", usage);

#elif defined(PEGASUS_OS_USE_RELEASE_DIRS)

MessageLoaderParms parms("src.Server.cimserver.MENU.HPUXLINUXIA64GNU", usage);

#else

MessageLoaderParms parms("src.Server.cimserver.MENU.STANDARD", usage);

#endif

cout << MessageLoader::getMessage(parms) << endl;

}

GetEnvironmentVariables(argv[0], pegasusHome);

// l10n

// Dummy function for the Thread object associated with the initial thread.

// Since the initial thread is used to process CIM requests, this is

// needed to localize the exceptions thrown during CIM request processing.

// Note: This function should never be called!

PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL dummyThreadFunc(void *parm)

{

return((PEGASUS_THREAD_RETURN)0);

}

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

void shutdownCIMOM(Uint32 timeoutValue)

// removes corresponding options and their arguments fromt he command

{

// line.

// Create CIMClient object

CIMClient client;

OptionManager om;

// Get local host name

String hostStr = System::getHostName();

// open connection to CIMOM

try

{

GetOptions(om, argc, argv, pegasusHome);

client.connectLocal();

// om.print();

// set client timeout to 2 seconds

client.setTimeout(2000);

}

catch (Exception& e)

catch(Exception&)

{

cerr << argv[0] << ": " << e.getMessage() << endl;

#ifdef PEGASUS_OS_OS400

//l10n

//Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

//"Unable to connect to CIM Server. CIM Server may not be running." );

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",

"Unable to connect to CIM Server. CIM Server may not be running." );

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

// Kill the job if it exists.

if(cimserver_kill() == -1)

cimserver_exitRC(2);

cimserver_exitRC(1);

#else

//l10n

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

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

MessageLoaderParms parms("src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",

"Unable to connect to CIM Server.\nCIM Server may not be running.\n");

PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);

exit(1);

#endif

}

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

try

// error if there are any remaining:

{

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

{

#ifdef PEGASUS_OS_OS400

if (argc != 1)

if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)

{

//l10n

//Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

//"Failed to shutdown server: $0", "The repository may be empty.");

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",

"Error in server shutdown: The repository may be empty.");

}

else

{

//l10n

//Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

//"Failed to shutdown server: $0", e.getMessage());

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SHUTDOWN_FAILED",

"Error in server shutdown: $0", e.getMessage());

}

// Kill the server job.

if(cimserver_kill() == -1)

cimserver_exitRC(2);

#else

//l10n - TODO

MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",

"Error in server shutdown: ");

PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);

if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)

{

// Repository may be empty.

//l10n - TODO

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",

"Error in server shutdown: The repository may be empty.");

MessageLoaderParms parms("src.Server.cimserver.REPOSITORY_EMPTY",

"The repository may be empty.");

PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);

}

else

{

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

//l10n - TODO

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SHUTDOWN_FAILED",

"Error in server shutdown: $0", e.getMessage());

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

}

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

// Kill the cimserver process

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

if (cimserver_kill() == 0)

cout << endl;

{

//l10n - TODO

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SERVER_FORCED_SHUTDOWN",

"Forced shutdown initiated.");

MessageLoaderParms parms("src.Server.cimserver.SERVER_FORCED_SHUTDOWN",

"Forced shutdown initiated.");

PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);

}

exit(1);

#endif

}

catch(Exception&)

{

// This may mean that the CIM Server has terminated, causing this

// client to get a "Empty HTTP response message" exception. It may

// also mean that the CIM Server is taking longer than 2 seconds

// (client timeout value) to terminate, causing this client to

// timeout with a "connection timeout" exception.

// Check to see if CIM Server is still running. If CIM Server

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

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

// terminated or timeout expires. If timeout expires and

// the CIM Server 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;

}

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

if (running)

{

int kill_rc = cimserver_kill();

#ifdef PEGASUS_OS_OS400

if(kill_rc == -1)

cimserver_exitRC(2);

cimserver_exitRC(1);

#endif

String installOption;

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)

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

if (kill_rc != -1)

{

if( 0 != cimserver_install_nt_service( pegasusHome ))

//l10n - TODO

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

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",

"Shutdown timeout expired. Forced shutdown initiated.");

MessageLoaderParms parms("src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",

"Shutdown timeout expired. Forced shutdown initiated.");

cout << MessageLoader::getMessage(parms) << endl;

exit(0);

}

#endif

}

return;

}

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

String removeOption;

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

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

// MAIN

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

int main(int argc, char** argv)

{

if( 0 != cimserver_remove_nt_service() )

String pegasusHome = String::EMPTY;

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

Boolean shutdownOption = false;

exit(0);

//l10n

// Set Message loading to process locale

MessageLoader::_useProcessLocale = true;

//l10n

#ifdef PEGASUS_OS_OS400

VFYPTRS_INCDCL; // VFYPTRS local variables

// verify pointers

#pragma exception_handler (qsyvp_excp_hndlr,qsyvp_excp_comm_area,\

0,_C2_MH_ESCAPE)

for( int arg_index = 1; arg_index < argc; arg_index++ ){

VFYPTRS(VERIFY_SPP_NULL(argv[arg_index]));

}

#pragma disable_handler

// Convert the args to ASCII

for(Uint32 i = 0;i< argc;++i)

{

EtoA(argv[i]);

}

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

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

pegasusHome = OS400_DEFAULT_PEGASUS_HOME;

#endif

String versionOption;

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

#ifndef PEGASUS_OS_TYPE_WINDOWS

// Get environment variables:

#ifdef PEGASUS_OS_OS400

#pragma convert(37)

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

#pragma convert(0)

char home[256] = {0};

if (tmp && strlen(tmp) < 256)

{

cerr << PEGASUS_VERSION << endl;

strcpy(home, tmp);

exit(0);

EtoA(home);

pegasusHome = home;

}

#else

#if defined(PEGASUS_OS_AIX) && defined(PEGASUS_USE_RELEASE_DIRS)

pegasusHome = AIX_RELEASE_PEGASUS_HOME;

#elif !defined(PEGASUS_USE_RELEASE_DIRS)

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

if (tmp)

{

pegasusHome = tmp;

}

#endif

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

FileSystem::translateSlashes(pegasusHome);

String helpOption;

#else

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

// windows only

setHome(pegasusHome);

#endif

// Get help, version, and shutdown options

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

{

const char* arg = argv[i];

// Check for -option

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

strlen(option) == 1)

{

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

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

(strlen(option) == 1))

{

PrintHelp(argv[0]);

om.printHelp();

exit(0);

}

#if !defined(PEGASUS_USE_RELEASE_DIRS)

else if (*option == OPTION_HOME &&

(strlen(option) == 1))

{

if (i + 1 < argc)

{

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

}

else

{

//l10n

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

String opt(option);

MessageLoaderParms parms("src.Server.cimserver.MISSING_ARGUMENT",

"Missing argument for option -$0",

opt);

cout << MessageLoader::getMessage(parms) << 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 &&

(strlen(option) == 1))

{

System::bindVerbose = true;

//l10n

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

//<< endl;

MessageLoaderParms parms("src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",

"Unsupported debug option, BIND_VERBOSE, enabled.");

cout << MessageLoader::getMessage(parms) << 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 &&

(strlen(option) == 1))

{

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

if (shutdownOption)

{

//l10n

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

MessageLoaderParms parms("src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",

"Duplicate shutdown option specified.");

cout << MessageLoader::getMessage(parms) << 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);

// Do the plaform specific run

return platform_run( argc, argv, shutdownOption );

}

// The main, common, running code

// NOTE: Do NOT call exit(). Use return(), otherwise some platforms

// will fail to shutdown properly/cleanly.

// TODO: Current change minimal for platform "service" shutdown bug fixes.

// Perhpas further extract out common stuff and put into main(), put

// daemon stuff into platform specific platform_run(), etc.

// Note: make sure to not put error handling stuff that platform

// specific runs may need to deal with bettter (instead of exit(), etc).

int cimserver_run( int argc, char** argv, Boolean shutdownOption )

{

String logsDirectory = String::EMPTY;

Boolean daemonOption = false;

// Get an instance of the Config Manager.

configManager = ConfigManager::getInstance();

configManager->useConfigFiles = true;

#ifdef PEGASUS_OS_OS400

// In a special startup case for IBM OS400, when the server is

// automatically started when the machine starts up the config

// file cannot be read because of access restrictions for the

// user starting the server. In this case, we need to skip

// reading the config options and therefore any use of the config

// manager also. To make this determinations we will check to see

// if the daemon flag is set to true. If so, then there will be a

// series of checks to bracket all the calls to the configManager

// which would otherwise fail. All this will only be done for

// IBM OS400.

Boolean os400StartupOption = false;

// loop through args to check for daemon=true

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

if (strcmp(argv[i], "daemon=true") == 0)

{

os400StartupOption = true;

daemonOption = true;

}

#endif

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

// removes corresponding options and their arguments from the command

// line.

try

{

#ifdef PEGASUS_OS_OS400

if (os400StartupOption == false)

#endif

GetOptions(configManager, argc, argv);

}

catch (Exception& e)

{

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SERVER_NOT_STARTED",

"cimserver not started: $0", e.getMessage());

#if !defined(PEGASUS_OS_OS400)

MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",

"cimserver not started: $0", e.getMessage());

PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)

<< PEGASUS_STD(endl);

#endif

return(1);

}

// l10n

// Set the home directory, msg sub-dir, into the MessageLoader.

// This will be the default directory where the resource bundles

// are found.

MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(

ConfigManager::getInstance()->getCurrentValue("messageDir")));

#ifdef PEGASUS_OS_OS400

// Still need to declare and set the connection variables.

// Will initialize to false since they are fixed at false for OS400.

// NOTE: OS400 is a LOCAL_DOMAIN_SOCKET, so a few lines down

// the test will not be compiled in. If OS400 ever turns off that

// define, then we will need to change this code path to insure that

// one of the variables is true.

Boolean enableHttpConnection = false;

Boolean enableHttpsConnection = false;

Boolean enableSSLExportClientVerification = false;

// Check the trace options and set global variable

if (os400StartupOption == false)

Boolean pegasusIOTrace = false;

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

{

Handler::setMessageTrace(true);

enableHttpConnection = String::equal(

pegasusIOTrace = true;

configManager->getCurrentValue("enableHttpConnection"), "true");

enableHttpsConnection = String::equal(

configManager->getCurrentValue("enableHttpsConnection"), "true");

enableSSLExportClientVerification = String::equal(

configManager->getCurrentValue("enableSSLExportClientVerification"), "true");

}

#else

Boolean enableHttpConnection = String::equal(

configManager->getCurrentValue("enableHttpConnection"), "true");

Boolean enableHttpsConnection = String::equal(

configManager->getCurrentValue("enableHttpsConnection"), "true");

Boolean enableSSLExportClientVerification = String::equal(

configManager->getCurrentValue("enableSSLExportClientVerification"), "true");

#endif

Boolean pegasusIOLog = false;

// Make sure at least one connection is enabled

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

#ifndef PEGASUS_LOCAL_DOMAIN_SOCKET

if (!enableHttpConnection && !enableHttpsConnection)

{

Handler::setMessageLogTrace(true);

//l10n

pegasusIOLog = true;

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

//"Neither HTTP nor HTTPS connection is enabled. "

//"CIMServer will not be started.");

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",

"Neither HTTP nor HTTPS connection is enabled. CIMServer will not be started.");

//cerr << "Neither HTTP nor HTTPS connection is enabled. "

//"CIMServer will not be started." << endl;

MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",

"Neither HTTP nor HTTPS connection is enabled. CIMServer will not be started.");

cerr << MessageLoader::getMessage(parms) << endl;

return(1);

}

#endif

// Grab the port otpion:

try

{

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

String portOption;

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

om.lookupValue("port", portOption);

{

daemonOption = true;

}

#ifdef PEGASUS_OS_OS400

if (os400StartupOption == false)

{

#endif

// 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"));

#ifdef PEGASUS_OS_OS400

} // end if (os400StartupOption == false)

#endif

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

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \

!defined(PEGASUS_OS_OS400)

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");

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

shutdownCIMOM(timeoutValue);

#ifdef PEGASUS_OS_OS400

//l10n

//Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

//"CIM Server stopped.");

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.SERVER_STOPPED",

"CIM Server stopped.");

cimserver_exitRC(0);

#else

//l10n

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

MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",

"CIM Server stopped.");

cout << MessageLoader::getMessage(parms) << endl;

return(0);

#endif

}

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

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

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \

!defined(PEGASUS_OS_OS400)

//l10n

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

MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",

"Logs Directory = ");

cout << MessageLoader::getMessage(parms) << logsDirectory << endl;

#endif

char* address = portOption.allocateCString();

}

catch (UnrecognizedConfigProperty& e)

{

#ifdef PEGASUS_OS_OS400

//l10n

//Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

//"Error: $0",e.getMessage());

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.ERROR",

"Error: $0",e.getMessage());

#else

//l10n

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

MessageLoaderParms parms("src.Server.cimserver.ERROR",

"Error: $0",

e.getMessage());

cout << MessageLoader::getMessage(parms) << endl;

#endif

}

Uint32 portNumberHttps;

Uint32 portNumberHttp;

Uint32 portNumberExportHttps;

if (enableHttpsConnection)

{

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

CString portString = httpsPort.getCString();

char* end = 0;

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

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

// Look up the WBEM-HTTPS port number

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

}

if (enableHttpConnection)

{

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

CString portString = httpPort.getCString();

char* end = 0;

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

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

// Look up the WBEM-HTTP port number

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

}

if (enableSSLExportClientVerification)

{

// No config property is looked up to get the default port number.

// Lookup the port defined in /etc/services for the service name

// wbem-exp-https and bind to that port. If the service is not defined

// then log a warning message and do not start the cimserver.

Uint32 port = 0;

portNumberExportHttps = System::lookupPort(WBEM_EXPORT_HTTPS_SERVICE_NAME, port);

if (portNumberExportHttps == 0)

{

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

"src.Server.cimserver.EXPORT_HTTPS_PORT_NOT_DEFINED",

"Port not defined for the service wbem-exp-https. CIMServer will not be started.");

MessageLoaderParms parms("src.Server.cimserver.EXPORT_HTTPS_PORT_NOT_DEFINED",

"Port not defined for the service wbem-exp-https. CIMServer will not be started.");

cerr << MessageLoader::getMessage(parms) << endl;

return(1);

}

// Put out startup up message.

cout << PEGASUS_NAME << PEGASUS_VERSION <<

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \

" on port " << address << endl;

!defined(PEGASUS_OS_OS400)

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

cout << PEGASUS_NAME << PEGASUS_VERSION << endl;

cout <<"Started..."

//l10n

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

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

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

//cout <<"Starting..."

<< endl;

MessageLoaderParms parms("src.Server.cimserver.STARTUP_MESSAGE",

"Built $0 $1\nStarting...",

// Option to Display the options table. Primarily

__DATE__,

// a diagnostic tool.

__TIME__);

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

#endif

om.print();

//l10n

// Put server start message to the logger

// reset message loading to NON-process locale

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

MessageLoader::_useProcessLocale = false;

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

//l10n

PEGASUS_NAME,

PEGASUS_VERSION,

// Get the parent's PID before forking

address,

parentPid = System::getPID();

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

Boolean useSLP;

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

useSLP = true;

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

#ifndef PEGASUS_OS_OS400

{

return(-1);

}

#else

{

return(-1);

}

else

{

return(0);

}

#endif

}

// l10n

// Now we are after the fork...

// Create a dummy Thread object that can be used to store the

// AcceptLanguages object for CIM requests that are serviced

// by this thread (initial thread of server). Need to do this

// because this thread is not in a ThreadPool, but is used

// to service CIM requests.

// The run function for the dummy Thread should never be called,

Thread *dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);

Thread::setCurrent(dummyInitialThread);

AcceptLanguages default_al;

try{

default_al = AcceptLanguages::getDefaultAcceptLanguages();

Thread::setLanguages(new AcceptLanguages(default_al));

}catch(InvalidAcceptLanguageHeader& e){

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",

"Could not convert the system process locale into a valid AcceptLanguage format.");

Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

e.getMessage());

}

#ifdef PEGASUS_OS_OS400

// Special server initialization code for OS/400.

if (cimserver_initialize() != 0)

{

// do some logging here!

//l10n

//Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

//"CIM Server failed to initialize");

Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,

"src.Server.cimserver.SERVER_FAILED_TO_INITIALIZE",

"CIM Server failed to initialize");

return(-1);

}

#endif

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) || defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)

umask(S_IWGRP|S_IWOTH);

// check if CIMServer is already running

// if CIMServer is already running, print message and

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

if(isCIMServerRunning())

{

//l10n

//cout << "Unable to start CIMServer." << endl;

//cout << "CIMServer is already running." << endl;

MessageLoaderParms parms("src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",

"Unable to start CIMServer.\nCIMServer is already running.");

PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);

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

if (daemonOption)

notify_parent(1);

return(1);

}

#endif

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

try

{

Selector selector;

CIMServer server(&selector, pegasusHome);

server.setSLP(useSLP );

// bind throws an exception of the bind fails

server.bind(address);

#if defined(PEGASUS_USE_23HTTPMONITOR_SERVER)

delete [] address;

Monitor monitor(true);

CIMServer server(&monitor);

#else

monitor_2 monitor;

CIMServer server(&monitor);

#endif

CimserverHolder cimserverHolder( &server );

if (enableHttpConnection)

{

server.addAcceptor(false, portNumberHttp, false, false);

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"Listening on HTTP port $0.", portNumberHttp);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.LISTENING_ON_HTTP_PORT",

"Listening on HTTP port $0.", portNumberHttp);

}

if (enableHttpsConnection)

{

server.addAcceptor(false, portNumberHttps, true, false);

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"Listening on HTTPS port $0.", portNumberHttps);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.LISTENING_ON_HTTPS_PORT",

"Listening on HTTPS port $0.", portNumberHttps);

}

if (enableSSLExportClientVerification)

{

server.addAcceptor(false, portNumberExportHttps, true, true);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.LISTENING_ON_EXPORT_HTTPS_PORT",

"Listening on Export HTTPS port $0.", portNumberExportHttps);

}

#ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

server.addAcceptor(true, 0, false, false);

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"Listening on local connection socket.");

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.LISTENING_ON_LOCAL",

"Listening on local connection socket.");

#endif

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && !defined(PEGASUS_OS_OS400)

if (enableHttpConnection)

{

//l10n

//cout << "Listening on HTTP port " << portNumberHttp << endl;

MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTP_PORT",

"Listening on HTTP port $0.", portNumberHttp);

cout << MessageLoader::getMessage(parms) << endl;

}

if (enableHttpsConnection)

{

//l10n

//cout << "Listening on HTTPS port " << portNumberHttps << endl;

MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTPS_PORT",

"Listening on HTTPS port $0.", portNumberHttps);

cout << MessageLoader::getMessage(parms) << endl;

}

if (enableSSLExportClientVerification)

{

MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_EXPORT_HTTPS_PORT",

"Listening on Export HTTPS port $0.", portNumberExportHttps);

cout << MessageLoader::getMessage(parms) << endl;

}

# ifdef PEGASUS_LOCAL_DOMAIN_SOCKET

//l10n

//cout << "Listening on local connection socket" << endl;

MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",

"Listening on local connection socket.");

cout << MessageLoader::getMessage(parms) << endl;

# endif

#endif

// bind throws an exception if the bind fails

server.bind();

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

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

if (daemonOption)

notify_parent(0);

time_t last = 0;

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) || defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)

// 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(CIMSERVER_START_FILE);

// open the file

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

if (pid_file)

{

// save the pid in the file

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

fclose(pid_file);

}

#endif

#if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \

!defined(PEGASUS_OS_OS400)

cout << "Started. " << endl;

#endif

// Put server started message to the logger

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"Started $0 version $1.",

//PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.STARTED_VERSION",

"Started $0 version $1.",

PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);

#else

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"Started $0 version $1.",

//PEGASUS_NAME, PEGASUS_VERSION);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.STARTED_VERSION",

"Started $0 version $1.",

PEGASUS_NAME, PEGASUS_VERSION);

#endif

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

// has been shutdown

while( !server.terminated() )

{

server.runForever();

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

}

"Normal Termination");

MessageQueueService::force_shutdown(true);

// normal termination

// Put server shutdown message to the logger

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"$0 stopped.", PLATFORM_PRODUCT_NAME);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.STOPPED",

"$0 stopped.", PLATFORM_PRODUCT_NAME);

#else

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

//"$0 stopped.", PEGASUS_NAME);

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.STOPPED",

"$0 stopped.", PEGASUS_NAME);

#endif

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) || defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)

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

// cimserver has terminated normally.

FileSystem::removeFile(CIMSERVER_START_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);

//l10n

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

//"Error: $0", e.getMessage());

Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

"src.Server.cimserver.ERROR",

"Error: $0", e.getMessage());

#ifndef PEGASUS_OS_OS400

//l10n

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

MessageLoaderParms parms("src.Server.cimserver.ERROR",

"Error: $0", e.getMessage());

PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);

#endif

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

if (daemonOption)

notify_parent(1);

return 1;

}

return 0;

}

Legend:

Removed from v.1.22
changed lines
	Added in v.1.138

No CVS admin address has been configured