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

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

version 1.200, 2007/06/05 10:22:40

Line 1

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

//%2006////////////////////////////////////////////////////////////////////////

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

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

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

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// all copies or substantial portions of the Software.

// EMC Corporation; Symantec Corporation; The Open Group.

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

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

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

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

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

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

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

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

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

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

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

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

// DEALINGS IN THE SOFTWARE.

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

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

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

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

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

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

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

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

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

// cimserver

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

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

// property to false:

// cimserver -d

// cimserver daemon=false

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

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

Line 64

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

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

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

#include <iostream>

#include <Pegasus/Common/Config.h>

#include <cstdlib>

#include <Pegasus/Common/Constants.h>

#include <Pegasus/Common/PegasusAssert.h>

#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/Common/LanguageParser.h>

#include <Pegasus/Config/ConfigManager.h>

#include <Pegasus/Client/CIMClient.h>

#include <Pegasus/Server/CIMServer.h>

#include <Service/ServerProcess.h>

#include <Service/ServerShutdownClient.h>

#include <Service/ServerRunStatus.h>

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

#include <Service/ARM_zOS.h>

# ifdef PEGASUS_ZOS_SECURITY

// This include file will not be provided in the OpenGroup CVS for now.

// Do NOT try to include it in your compile

# include <Pegasus/Common/safCheckzOS_inline.h>

# endif

#endif

#if defined(PEGASUS_OS_TYPE_UNIX)

# include <unistd.h>

# include <sys/types.h>

# include <sys/stat.h>

# include <fcntl.h>

#endif

#if defined(PEGASUS_OS_TYPE_WINDOWS)

#ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION

# include "cimserver_windows.cpp"

# define PEGASUS_PROCESS_NAME "cimservermain"

#elif defined(PEGASUS_OS_TYPE_UNIX)

# include "cimserver_unix.cpp"

#else

# error "Unsupported platform"

# define PEGASUS_PROCESS_NAME "cimserver"

#endif

#include <Pegasus/Common/Executor.h>

PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

void GetEnvironmentVariables(

//Windows service variables are not defined elsewhere in the product

const char* arg0,

//enable ability to override these

String& pegasusHome)

#ifndef PEGASUS_SERVICE_NAME

#define PEGASUS_SERVICE_NAME "Pegasus CIM Object Manager";

#endif

#ifndef PEGASUS_SERVICE_DESCRIPTION

#define PEGASUS_SERVICE_DESCRIPTION "Pegasus CIM Object Manager Service";

#endif

class CIMServerProcess : public ServerProcess

{

// Get environment variables:

public:

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

CIMServerProcess(void)

{

cimserver_set_process(this);

}

if (!tmp)

virtual ~CIMServerProcess(void)

{

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

exit(1);

}

pegasusHome = tmp;

//defined in PegasusVersion.h

FileSystem::translateSlashes(pegasusHome);

virtual const char* getProductName() const

{

return PEGASUS_PRODUCT_NAME;

}

virtual const char* getExtendedName() const

{

return PEGASUS_SERVICE_NAME;

}

virtual const char* getDescription() const

{

return PEGASUS_SERVICE_DESCRIPTION;

}

//defined in PegasusVersion.h

virtual const char* getCompleteVersion() const

{

if (*PEGASUS_PRODUCT_STATUS == '\0' )

return PEGASUS_PRODUCT_VERSION;

else

return PEGASUS_PRODUCT_VERSION " " PEGASUS_PRODUCT_STATUS;

}

//defined in PegasusVersion.h

virtual const char* getVersion() const

{

return PEGASUS_PRODUCT_VERSION;

}

virtual const char* getProcessName() const

{

return PEGASUS_PROCESS_NAME;

}

//defined in Constants.h

virtual const char* getPIDFileName() const

{

return PEGASUS_CIMSERVER_START_FILE;

}

int cimserver_run(

int argc,

char** argv,

Boolean shutdownOption,

Boolean debugOutputOption);

void cimserver_stop(void);

};

ServerRunStatus _serverRunStatus(

PEGASUS_PROCESS_NAME, PEGASUS_CIMSERVER_START_FILE);

AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess());

static CIMServer* _cimServer = 0;

static Monitor* _monitor = 0;

static Thread* dummyInitialThread = 0;

// The command name.

static const char COMMAND_NAME [] = "cimserver";

// The constant defining usage string.

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

/**

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';

static const char LONG_HELP [] = "help";

static const char LONG_VERSION [] = "version";

static const char OPTION_DEBUGOUTPUT = 'X';

static const String PROPERTY_TIMEOUT = "shutdownTimeout";

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.

Some possible exceptions: NoSuchFile, FileNotReadable, CannotRenameFile,

ConfigFileSyntaxError, UnrecognizedConfigProperty, InvalidPropertyValue,

CannotOpenFile.

void GetOptions(

OptionManager& om,

ConfigManager* cm,

int& argc,

char** argv,

const String& pegasusHome)

Boolean shutdownOption)

{

static struct OptionRow optionsTable[] =

if (shutdownOption)

{

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

cm->loadConfigFiles();

"specifies port number to listen on" },

}

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

else

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

{

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

cm->mergeConfigFiles();

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

// Temporarily disable updates to the current configuration

// file if shutdownOption is true

cm->useConfigFiles = (shutdownOption==false);

if (FileSystem::exists(configFile))

cm->mergeCommandLine(argc, argv);

om.mergeFile(configFile);

if(argc && argv != NULL)

om.mergeCommandLine(argc, argv);

om.checkRequiredOptions();

// Enable updates again

cm->useConfigFiles = true;

}

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

Line 174

Line 271

void PrintHelp(const char* arg0)

{

cout << '\n';

String usage = String (USAGE);

cout << PEGASUS_NAME << PEGASUS_VERSION << endl;

usage.append (COMMAND_NAME);

cout << '\n';

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

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

usage.append (" options\n");

usage.append (" -v, --version - displays CIM Server version number\n");

usage.append (" -h, --help - 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 Service\n");

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

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

usage.append (" by appending [name]\n");

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

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

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

usage.append (" by appending [name]\n");

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

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

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

usage.append (" by appending [name]\n");

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

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

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

usage.append (" by appending [name]\n\n");

#endif

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

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

cout << endl;

cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getCompleteVersion() << endl;

cout << endl;

#if defined(PEGASUS_OS_TYPE_WINDOWS)

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

#elif defined(PEGASUS_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;

}

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

//This needs to be called at various points in the code depending on the platform and error conditions.

// MAIN

//We need to delete the _cimServer reference on exit in order for the destructors to get called.

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

void deleteCIMServer()

int main(int argc, char** argv)

{

if (_cimServer)

{

delete _cimServer;

_cimServer = 0;

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

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) \

if (argc == 1 )

|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \

cim_server_service(argc, argv) ;

|| defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS)

// Remove the PID file to indicate CIMServer termination

FileSystem::removeFile(_cimServerProcess->getPIDFileName());

#endif

}

delete _monitor;

if (dummyInitialThread)

{

Thread::clearLanguages();

delete dummyInitialThread;

}

// Get environment variables:

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

ThreadReturnType PEGASUS_THREAD_CDECL dummyThreadFunc(void *parm)

{

return((ThreadReturnType)0);

}

String pegasusHome;

#ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION

GetEnvironmentVariables(argv[0], pegasusHome);

static int _extractExecutorSockOpt(int& argc, char**& argv)

{

// Extract the "--executor-socket <sock>" option if any. This indicates

// that the e[x]ecutor is running. The option argument is the socket used

// to communicate with the executor. Remove the option from the

// argv list and decrease argc by two.

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

int sock = -1;

// removes corresponding options and their arguments fromt he command

const char OPT[] = "--executor-socket";

// line.

OptionManager om;

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

{

if (strcmp(argv[i], OPT) == 0)

{

// Check for missing option argument.

try

if (i + 1 == argc)

{

GetOptions(om, argc, argv, pegasusHome);

MessageLoaderParms parms(

// om.print();

"src.Server.cimserver.MISSING_OPTION_ARGUMENT",

"Missing argument for $0 option.",

OPT);

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

endl;

exit(1);

}

catch (Exception& e)

// Convert argument to positive integer.

char* end;

unsigned long x = strtoul(argv[i+1], &end, 10);

// Check whether option argument will fit in a signed integer.

if (*end != '\0' || x > 2147483647)

{

MessageLoaderParms parms(

"src.Server.cimserver.BAD_OPTION_ARGUMENT",

"Bad $0 option argument: $1.",

OPT,

argv[i+1]);

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

endl;

exit(1);

}

sock = int(x);

// Remove "-x <sock>" from argv-argc.

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

argc -= 2;

break;

}

if (sock == -1)

{

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

MessageLoaderParms parms(

"src.Server.cimserver.MISSING_OPTION",

"Missing $0 option.",

OPT);

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

exit(1);

}

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

return sock;

// error if there are any remaining:

}

#endif /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION */

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

// MAIN

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

if (argc != 1)

int main(int argc, char** argv)

{

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

String pegasusHome;

Boolean shutdownOption = false;

Boolean debugOutputOption = false;

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

//l10n

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

// Set Message loading to process locale

cout << endl;

MessageLoader::_useProcessLocale = true;

//l10n

#if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)

setlocale(LC_ALL, "");

#endif

#ifndef PEGASUS_OS_TYPE_WINDOWS

// Get environment variables:

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

pegasusHome = AIX_RELEASE_PEGASUS_HOME;

#elif !defined(PEGASUS_USE_RELEASE_DIRS) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

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

if (tmp)

{

pegasusHome = tmp;

}

#endif

FileSystem::translateSlashes(pegasusHome);

#else

// windows only

//setHome(pegasusHome);

pegasusHome = _cimServerProcess->getHome();

#endif

#ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION

// If invoked with "--executor-socket <socket>" option, then use executor.

Executor::setSock(_extractExecutorSockOpt(argc, argv));

// Ping executor to verify the specified socket is valid.

if (Executor::ping() != 0)

{

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

"Failed to ping the executor on the specified socket.");

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

exit(1);

}

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

#endif /* !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */

// Get help, version, and shutdown options

String installOption;

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

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

{

const char* arg = argv[i];

if(String::equal(arg,"--help"))

{

if( 0 != cimserver_install_nt_service( pegasusHome ))

PrintHelp(argv[0]);

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

exit(0);

}

else if(String::equal(arg,"--version"))

{

cout << _cimServerProcess->getCompleteVersion() << endl;

exit(0);

}

// Check for -option

else if (*arg == '-')

{

// Get the option

const char* option = arg + 1;

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

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

String removeOption;

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

if (*option == OPTION_VERSION &&

strlen(option) == 1)

{

if( 0 != cimserver_remove_nt_service() )

cout << _cimServerProcess->getCompleteVersion() << endl;

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

exit(0);

}

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

else if (*option == OPTION_HELP &&

(strlen(option) == 1))

{

PrintHelp(argv[0]);

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

// Check to see if user asked for debug output (-X option):

else if (*option == OPTION_DEBUGOUTPUT &&

(strlen(option) == 1))

{

MessageLoaderParms parms(

"src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",

"Unsupported debug output option is enabled.");

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

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

debugOutputOption = true;

String versionOption;

#if defined(PEGASUS_OS_HPUX)

System::bindVerbose = true;

#endif

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

// remove the option from the command line

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

argc--;

}

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

else if (*option == OPTION_SHUTDOWN &&

(strlen(option) == 1))

{

cerr << PEGASUS_VERSION << endl;

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

}

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

shutdownOption = true;

String helpOption;

// 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 platform specific run

return _cimServerProcess->platform_run(

argc, argv, shutdownOption, debugOutputOption);

}

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

void CIMServerProcess::cimserver_stop()

{

PrintHelp(argv[0]);

_cimServer->shutdownSignal();

om.printHelp();

exit(0);

}

// Check the trace options and set global variable

Boolean pegasusIOTrace = false;

// The main, common, running code

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

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

// Perhaps 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 better (instead of exit(), etc).

int CIMServerProcess::cimserver_run(

int argc,

char** argv,

Boolean shutdownOption,

Boolean debugOutputOption)

{

String logsDirectory;

Boolean daemonOption = false;

// Get an instance of the Config Manager.

configManager = ConfigManager::getInstance();

configManager->useConfigFiles = true;

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

// removes corresponding options and their arguments from the command

// line.

try

{

Handler::setMessageTrace(true);

// If current process is "cimserver -s" (shutdown option = true) the contents

pegasusIOTrace = true;

// of current config should not be overwriten by planned config

GetOptions(configManager, argc, argv, shutdownOption);

}

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

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

return(1);

}

Boolean pegasusIOLog = false;

// l10n

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

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

Boolean enableHttpConnection = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("enableHttpConnection"));

Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("enableHttpsConnection"));

// Make sure at least one connection is enabled

#ifdef PEGASUS_DISABLE_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 start Pegasus as a daemon

String portOption;

daemonOption = ConfigManager::parseBooleanValue(

om.lookupValue("port", portOption);

configManager->getCurrentValue("daemon"));

// Get the log file directory definition.

#if !defined(PEGASUS_USE_SYSLOGS)

// We put String into Cstring because

logsDirectory =

// Directory functions only handle Cstring.

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

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

#endif

String logsDirectory;

om.lookupValue("logdir", logsDirectory);

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

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

// To deregister Pegasus with SLP

#ifdef PEGASUS_SLP_REG_TIMEOUT

unregisterPegasusFromSLP();

#endif

ServerShutdownClient serverShutdownClient(&_serverRunStatus);

serverShutdownClient.shutdown(timeoutValue);

MessageLoaderParms parms(

"src.Server.cimserver.SERVER_STOPPED",

"CIM Server stopped.");

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

return(0);

}

#if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS)

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

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

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

"Logs Directory = ");

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

#endif

}

catch (UnrecognizedConfigProperty& e)

{

// UnrecognizedConfigProperty is already translated

// thus, just output the message

Logger::put(Logger::ERROR_LOG,

System::CIMSERVER,

Logger::SEVERE,

e.getMessage());

cout << e.getMessage() << endl;

}

catch (Exception& ex)

{

Logger::put(Logger::ERROR_LOG,

System::CIMSERVER,

Logger::SEVERE,

ex.getMessage());

cout << ex.getMessage() << endl;

exit(1);

}

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY)

startupCheckBPXServer(true);

startupCheckProfileCIMSERVclassWBEM();

startupEnableMSC();

#endif

// Bug 2148 - Here is the order of operations for determining the server HTTP and HTTPS ports.

// 1) If the user explicitly specified a port, use it.

// 2) If the user did not specify a port, get the port from the services file.

// 3) If no value is specified in the services file, use the IANA WBEM default port.

// Note that 2 and 3 are done within the System::lookupPort method

// An empty string from the ConfigManager implies that the user did not specify a port.

Uint32 portNumberHttps=0;

Uint32 portNumberHttp=0;

Uint32 portNumberExportHttps=0;

char* address = portOption.allocateCString();

if (enableHttpsConnection)

{

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

if (httpsPort == String::EMPTY)

{

// Look up the WBEM-HTTPS port number

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

} else

{

// user-specified

CString portString = httpsPort.getCString();

char* end = 0;

portNumberHttps = strtol(portString, &end, 10);

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

{

InvalidPropertyValue e("httpsPort", httpsPort);

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

"src.Server.cimserver.SERVER_NOT_STARTED",

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

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

exit(1);

}

if (enableHttpConnection)

{

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

if (httpPort == String::EMPTY)

{

// Look up the WBEM-HTTP port number

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

} else

{

// user-specified

CString portString = httpPort.getCString();

char* end = 0;

portNumberHttp = strtol(portString, &end, 10);

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

{

InvalidPropertyValue e("httpPort", httpPort);

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

"src.Server.cimserver.SERVER_NOT_STARTED",

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

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

exit(1);

}

#if defined(PEGASUS_DEBUG)

// Put out startup up message.

cout << PEGASUS_NAME << PEGASUS_VERSION <<

cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getCompleteVersion() << endl;

" on port " << address << endl;

//l10n

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

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

cout <<"Started..."

//cout <<"Starting..."

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

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

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

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

<< endl;

__DATE__,

__TIME__);

// Option to Display the options table. Primarily

#endif

// a diagnostic tool.

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

//l10n

om.print();

// reset message loading to NON-process locale

MessageLoader::_useProcessLocale = false;

// Put server start message to the logger

//l10n

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

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

// Get the parent's PID before forking

PEGASUS_NAME,

_serverRunStatus.setParentPid(System::getPID());

PEGASUS_VERSION,

address,

// Do not fork when using privilege separation (executor will daemonize itself

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

// later).

if (daemonOption)

// do we need to run as a daemon ?

{

String daemonOption;

if(-1 == _cimServerProcess->cimserver_fork())

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

return(-1);

else

return(0);

}

// l10n

// Now we are after the fork...

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

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

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

Thread::setCurrent(dummyInitialThread);

AcceptLanguageList default_al;

try{

default_al = LanguageParser::getDefaultAcceptLanguages();

Thread::setLanguages(new AcceptLanguageList(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());

}

#ifndef PEGASUS_OS_TYPE_WINDOWS

umask(S_IRWXG|S_IRWXO);

#endif

#if defined(PEGASUS_OS_TYPE_UNIX)

// CRITICAL SECTION BEGIN

// This is the beginning of the critical section regarding the

// access to pidfile (file to indicate that the cimserver has started).

// Sometimes, when 2 or more cimserver processes are started at the same

// time, they can't detect the concurrent process execution because the

// logic fails when pidfile is accessed concurrently.

FILE *startupLockFile;

if ((startupLockFile = fopen(ConfigManager::getHomedPath(

CIMSERVER_LOCK_FILE).getCString(), "w")) != 0)

{

lockf(fileno(startupLockFile), F_LOCK, 0);

}

#endif

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \

|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \

|| defined(PEGASUS_OS_SOLARIS) || defined (PEGASUS_OS_VMS)

// 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 (_serverRunStatus.isServerRunning())

{

if(-1 == cimserver_fork())

MessageLoaderParms parms(

exit(-1);

"src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",

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

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

PEGASUS_STD(endl);

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

MessageLoader::getMessage(parms));

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

if (daemonOption)

{

_cimServerProcess->notify_parent(1);

}

return 1;

}

#endif

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

try

{

Selector selector;

_monitor = new Monitor();

CIMServer server(&selector, pegasusHome);

_cimServer = new CIMServer(_monitor);

if (enableHttpConnection)

{

_cimServer->addAcceptor(false, portNumberHttp, false);

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)

{

_cimServer->addAcceptor(false, portNumberHttps, true);

Logger::put_l(

Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,

"src.Server.cimserver.LISTENING_ON_HTTPS_PORT",

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

}

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

_cimServer->addAcceptor(true, 0, false);

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

if (enableHttpConnection)

{

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_HTTP_PORT",

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

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

}

if (enableHttpsConnection)

{

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_HTTPS_PORT",

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

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

}

// bind throws an exception of the bind fails

# ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

server.bind(address);

MessageLoaderParms parms(

delete [] address;

"src.Server.cimserver.LISTENING_ON_LOCAL",

server.runForever();

"Listening on local connection socket.");

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

# endif

#endif

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

_cimServer->bind();

"Normal Termination");

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

{

#if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)

Executor::daemonizeExecutor();

#else

_cimServerProcess->notify_parent(0);

#endif

}

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || \

defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) || \

defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS)

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

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

_serverRunStatus.setServerRunning();

#endif

#if defined(PEGASUS_DEBUG)

cout << "Started. " << endl;

#endif

#if defined(PEGASUS_OS_TYPE_UNIX)

// CRITICAL SECTION END

// Here is the unlock of file 'lock_file'. It closes the

// the critical section that guarantees the non concurrent access to

// pid file (file to indicate that the cimserver has started).

if (startupLockFile)

{

lockf(fileno(startupLockFile), F_ULOCK, 0);

fclose(startupLockFile);

}

#endif

// Put server started message to the logger

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

Logger::INFORMATION,

"src.Server.cimserver.STARTED_VERSION",

"Started $0 version $1.",

_cimServerProcess->getProductName(),

_cimServerProcess->getCompleteVersion());

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

if (daemonOption && !debugOutputOption)

{

// Direct standard input, output, and error to /dev/null,

// since we are running as a daemon.

close(0);

open("/dev/null", O_RDONLY);

close(1);

open("/dev/null", O_RDWR);

close(2);

open("/dev/null", O_RDWR);

}

#endif

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

// ARM is a z/OS internal restart facility.

// This is a z/OS specific change.

// Instatiating the automatic restart manager for zOS

ARM_zOS automaticRestartManager;

// register to zOS ARM

automaticRestartManager.Register();

#endif

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

// has been shutdown

while( !_cimServer->terminated() )

{

_cimServer->runForever();

}

// normal termination

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

// ARM is a z/OS internal restart facility.

// This is a z/OS specific change.

// register to zOS ARM

automaticRestartManager.DeRegister();

#endif

// Put server shutdown message to the logger

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

Logger::INFORMATION, "src.Server.cimserver.STOPPED",

"$0 stopped.", _cimServerProcess->getProductName());

#if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) \

|| defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \

|| defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS)

// Note: do not remove the PID file created at startup time, since

// shutdown is not complete until the CIMServer destructor completes.

#endif

}

catch(BindFailedException& e)

{

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

"src.Server.cimserver.SERVER_NOT_STARTED",

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

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

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

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

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

if (daemonOption)

_cimServerProcess->notify_parent(1);

deleteCIMServer();

return 1;

}

catch(Exception& e)

{

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

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

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

"src.Server.cimserver.ERROR",

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

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

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

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

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

if (daemonOption)

_cimServerProcess->notify_parent(1);

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

deleteCIMServer();

return 1;

}

deleteCIMServer();

return 0;

}

Legend:

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

No CVS admin address has been configured