pegasus/src/Server/cimserver.cpp - diff

Return to cimserver.cpp CVS log

Up to [Pegasus] / pegasus / src / Server

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

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

version 1.212, 2007/10/22 15:00:00

Line 1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// cimserver -s

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

// To INSTALL the Pegasus service,

// cimserver -install

// To REMOVE the Pegasus service,

// cimserver -remove

// To START the Pegasus service,

// net start cimserver

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

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

#include <iostream>

#include <cstdlib>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Constants.h>

#include <Pegasus/Common/PegasusAssert.h>

#include <Pegasus/Common/FileSystem.h>

#include <Pegasus/Common/Selector.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 <Pegasus/Common/SetFileDescriptorToEBCDICEncoding.h>

#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

#ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION

# define PEGASUS_PROCESS_NAME "cimservermain"

#else

# define PEGASUS_PROCESS_NAME "cimserver"

#endif

#include <Pegasus/Common/Executor.h>

#ifdef PEGASUS_OS_PASE

# include <ILEWrapper/ILEUtilities2.h>

# include <ILEWrapper/qumemultiutil.h>

#endif

PEGASUS_USING_PEGASUS;

PEGASUS_USING_STD;

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

//enable ability to override these

#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

#ifdef PEGASUS_OS_PASE

#include <as400_protos.h> //for _SETCCSID

#endif

class CIMServerProcess : public ServerProcess

{

public:

void GetEnvironmentVariables(

CIMServerProcess()

const char* arg0,

String& pegasusHome)

{

// Get environment variables:

cimserver_set_process(this);

}

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

virtual ~CIMServerProcess()

{

}

if (!tmp)

//defined in PegasusVersion.h

virtual const char* getProductName() const

{

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

return PEGASUS_PRODUCT_NAME;

exit(1);

}

pegasusHome = tmp;

virtual const char* getExtendedName() const

FileSystem::translateSlashes(pegasusHome);

{

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;

}

int cimserver_run(

int argc,

char** argv,

Boolean shutdownOption,

Boolean debugOutputOption);

void cimserver_stop();

};

ServerRunStatus _serverRunStatus(

PEGASUS_PROCESS_NAME, PEGASUS_CIMSERVER_START_FILE);

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

static CIMServer* _cimServer = 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';

/** 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 options[] =

if (shutdownOption)

{

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

cm->loadConfigFiles();

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

}

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

else

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

{

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

cm->mergeConfigFiles();

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

}

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

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

};

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

om.registerOptions(options, NUM_OPTIONS);

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

if (FileSystem::exists(configFile))

// Temporarily disable updates to the current configuration

om.mergeFile(configFile);

// file if shutdownOption is true

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

om.mergeCommandLine(argc, argv);

cm->mergeCommandLine(argc, argv);

om.checkRequiredOptions();

// Enable updates again

cm->useConfigFiles = true;

}

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

Line 98

Line 270

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 << " [-port <port_num> -t -h -v]\n";

usage.append(" options\n");

cout << '\n';

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

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

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

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

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

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

#if !defined(PEGASUS_USE_RELEASE_DIRS)

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

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

cout << " -d - turns on debug mode\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.

// We need to delete the _cimServer reference on exit in order for the

// destructors to get called.

void deleteCIMServer()

{

delete _cimServer;

_cimServer = 0;

if (dummyInitialThread)

{

Thread::clearLanguages();

delete dummyInitialThread;

}

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

}

#ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION

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.

int sock = -1;

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

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

{

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

{

// Check for missing option argument.

if (i + 1 == argc)

{

MessageLoaderParms parms(

"src.Server.cimserver.MISSING_OPTION_ARGUMENT",

"Missing argument for $0 option.",

OPT);

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

endl;

exit(1);

}

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

{

MessageLoaderParms parms(

"src.Server.cimserver.MISSING_OPTION",

"Missing $0 option.",

OPT);

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

exit(1);

}

return sock;

}

#endif /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION */

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

// MAIN

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

int main(int argc, char** argv)

{

String pegasusHome;

Boolean shutdownOption = false;

Boolean debugOutputOption = false;

// Set Message loading to process locale

MessageLoader::_useProcessLocale = true;

#ifdef PEGASUS_OS_ZOS

// Direct standard input to /dev/null,

close(STDIN_FILENO);

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

if ( setEBCDICEncoding(STDOUT_FILENO)==-1 ||

setEBCDICEncoding(STDERR_FILENO)==-1 )

{

PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4,

"Coud not set stdout or stderr to EBCDIC encoding.");

}

// Need to initialize timezone information in the

// initial processing thread (IPT)

tzset();

#endif

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

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

pegasusHome = (tmp == 0) ? PASE_DEFAULT_PEGASUS_HOME : tmp;

# elif !defined(PEGASUS_USE_RELEASE_DIRS) || \

defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

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

String pegasusHome;

if (tmp)

GetEnvironmentVariables(argv[0], pegasusHome);

{

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

}

#endif /* !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */

// Get help, version, and shutdown options

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

{

const char* arg = argv[i];

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

{

PrintHelp(argv[0]);

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 user asked for the version (-v option):

if (*option == OPTION_VERSION &&

strlen(option) == 1)

{

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

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

{

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;

debugOutputOption = true;

#if defined(PEGASUS_OS_HPUX)

System::bindVerbose = true;

#endif

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

{

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

if (shutdownOption)

{

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

return _cimServerProcess->platform_run(

argc, argv, shutdownOption, debugOutputOption);

}

void CIMServerProcess::cimserver_stop()

{

_cimServer->shutdownSignal();

}

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

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

{

Boolean daemonOption = false;

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

// PASE have itself regular for checking privileged user

if (!System::isPrivilegedUser("*CURRENT "))

{

MessageLoaderParms parms(

"src.Server.cimserver.NO_AUTHORITY.PEGASUS_OS_PASE",

"The caller should be a privileged user,"

" or the server will not run.");

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

exit (1);

}

char jobName[11];

// this function only can be found in PASE environment

umeGetJobName(jobName, false);

if (strncmp("QUMECIMOM ", jobName, 10) != 0

&& strncmp("QUMEENDCIM", jobName, 10) != 0)

{

MessageLoaderParms parms(

"src.Server.cimserver.NOT_OFFICIAL_START.PEGASUS_OS_PASE",

"cimserver can not be started by user.\nServer will not run.");

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

exit (1);

}

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

// PASE run this job in background, any output in not allowed

freopen("/dev/null", "r", stdin);

freopen("/dev/null", "w", stdout);

freopen("/dev/null", "w", stderr);

#endif

// Get an instance of the Config Manager.

ConfigManager* configManager = ConfigManager::getInstance();

configManager->useConfigFiles = true;

try

{

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

// removes corresponding options and their arguments fromt he command

// line.

// line. NOTE: If shutdownOption=true, the contents of current config

// file are not overwritten by the planned config file.

GetOptions(configManager, argc, argv, shutdownOption);

OptionManager om;

// Initialize the message home directory in the MessageLoader.

// This is the default directory where the resource bundles are found.

MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(

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

try

#ifdef PEGASUS_OS_PASE

// set ccsid to unicode for entire job

// ccsid is globolization mechanism in PASE environment

if (_SETCCSID(1208) == -1)

{

GetOptions(om, argc, argv, pegasusHome);

MessageLoaderParms parms(

// om.print();

"src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",

"Failed to set CCSID, server will stop.");

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

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

"src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",

"Failed to set CCSID, server will stop.\n");

exit (1);

}

char fullJobName[29];

umeGetJobName(fullJobName, true);

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

"src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",

"CIM Server's Job Name is: $0", fullJobName);

#endif

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)

{

//l10n

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

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

daemonOption = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("daemon"));

#if !defined(PEGASUS_USE_SYSLOGS)

String logsDirectory = ConfigManager::getHomedPath(

configManager->getCurrentValue("logdir"));

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

// Might be more logical to clean before set.

Logger::setHomeDirectory(logsDirectory);

# ifdef PEGASUS_OS_PASE

/* write job log to tell where pegasus log is.*/

if(logsDirectory.size() > 0)

// this function only can be found in PASE environment

logPegasusDir2joblog(logsDirectory.getCString());

else

logPegasusDir2joblog(".");

# endif

#endif

// Check to see if we need to shutdown CIMOM

if (shutdownOption)

{

String configTimeout =

configManager->getCurrentValue("shutdownTimeout");

Uint32 timeoutValue =

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

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.

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

"Logs Directory = ");

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

#endif

}

catch (Exception& e)

{

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

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

exit(1);

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

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

MessageLoader::getMessage(parms));

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

return 1;

}

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

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

// error if there are any remaining:

startupCheckBPXServer(true);

startupCheckProfileCIMSERVclassWBEM();

startupEnableMSC();

#endif

if (argc != 1)

#if defined(PEGASUS_DEBUG)

// Put out startup up message.

cout << _cimServerProcess->getProductName() << " " <<

_cimServerProcess->getCompleteVersion() << endl;

#endif

// reset message loading to NON-process locale

MessageLoader::_useProcessLocale = false;

// Get the parent's PID before forking

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

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

// itself later).

if (daemonOption)

{

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

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

return -1;

}

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

// Now we are after the fork...

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

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

cout << endl;

// AcceptLanguageList object for CIM requests that are serviced

exit(1);

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

}

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

#ifndef PEGASUS_OS_TYPE_WINDOWS

umask(S_IRWXG|S_IRWXO);

#endif

String versionOption;

// Start up the CIM Server

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

try

{

cerr << PEGASUS_VERSION << endl;

#if defined(PEGASUS_OS_TYPE_UNIX)

exit(0);

// Lock the CIMSERVER_LOCK_FILE during CIM Server start-up to prevent

// concurrent writes to this file by multiple cimserver processes

// starting at the same time.

CString startupLockFileName = ConfigManager::getHomedPath(

PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();

// Make sure the start-up lock file exists

FILE* startupLockFile;

if ((startupLockFile = fopen(startupLockFileName, "w")) != 0)

{

fclose(startupLockFile);

}

AutoFileLock fileLock(startupLockFileName);

#endif

#if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)

// Check if a CIM Server is already running. If so, print an error

// message and notify the parent process (if there is one) to terminate

if (_serverRunStatus.isServerRunning())

{

MessageLoaderParms parms(

"src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",

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

Logger::put(

Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

MessageLoader::getMessage(parms));

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

if (daemonOption)

{

_cimServerProcess->notify_parent(1);

}

return 1;

}

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

// Declare ourselves as the running CIM Server process, and write our

// PID to the PID file.

_serverRunStatus.setServerRunning();

#endif

// Create and initialize the CIMServer object

_cimServer = new CIMServer();

String helpOption;

Boolean enableHttpConnection = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("enableHttpConnection"));

Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("enableHttpsConnection"));

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

#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

// Make sure at least one connection is enabled

if (!enableHttpConnection && !enableHttpsConnection)

{

PrintHelp(argv[0]);

MessageLoaderParms parms(

exit(0);

"src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",

"Neither HTTP nor HTTPS connection is enabled.");

throw Exception(parms);

}

#endif

Boolean addIP6Acceptor = false;

Boolean addIP4Acceptor = false;

// Check the trace options and set global variable

#ifdef PEGASUS_OS_TYPE_WINDOWS

Boolean pegasusIOTrace = false;

addIP4Acceptor = true;

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

#endif

#ifdef PEGASUS_ENABLE_IPV6

// If IPv6 stack is disabled swicth to IPv4 stack.

if (System::isIPv6StackActive())

{

addIP6Acceptor = true;

}

else

{

MessageLoaderParms parms(

"src.Server.cimserver.IPV6_STACK_NOT_ACTIVE",

"IPv6 stack is not active, using IPv4 socket.");

Logger::put(

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

MessageLoader::getMessage(parms));

#if defined(PEGASUS_DEBUG)

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

#endif

}

#endif

if (!addIP6Acceptor)

{

Handler::sethandlerTrace(true);

addIP4Acceptor = true;

pegasusIOTrace = true;

cout << "Trace Set" << endl;

}

// Grab the port otpion:

// The server HTTP and HTTPS ports are determined via this algorithm:

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

String portOption;

if (enableHttpConnection)

om.lookupValue("port", portOption);

{

Uint32 portNumberHttp = 0;

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

{

throw InvalidPropertyValue("httpPort", httpPort);

}

char* address = portOption.allocateCString();

if (addIP6Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,

portNumberHttp, false);

}

if (addIP4Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,

portNumberHttp, false);

}

// Put out startup up message.

MessageLoaderParms parms(

// Put to cout if not daemon

"src.Server.cimserver.LISTENING_ON_HTTP_PORT",

// ATTN: modify when we add daemon

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

cout << PEGASUS_NAME << PEGASUS_VERSION <<

Logger::put(

" on port " << address << endl;

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

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

MessageLoader::getMessage(parms));

cout <<"Started..."

#if defined(PEGASUS_DEBUG)

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

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

#endif

// Set up the Logger

}

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

if (enableHttpsConnection)

// Put server start message to the logger

{

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

Uint32 portNumberHttps = 0;

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

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

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

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

{

throw InvalidPropertyValue("httpsPort", httpsPort);

}

if (addIP6Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,

portNumberHttps, true);

}

if (addIP4Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,

portNumberHttps, true);

}

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_HTTPS_PORT",

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

Logger::put(

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

MessageLoader::getMessage(parms));

#if defined(PEGASUS_DEBUG)

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

#endif

}

#ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

{

_cimServer->addAcceptor(HTTPAcceptor::LOCAL_CONNECTION, 0, false);

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_LOCAL",

"Listening on local connection socket.");

Logger::put(

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

MessageLoader::getMessage(parms));

# if defined(PEGASUS_DEBUG)

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

# endif

}

#endif

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

{

#if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)

Executor::daemonizeExecutor();

#else

_cimServerProcess->notify_parent(0);

#endif

}

#if defined(PEGASUS_DEBUG)

cout << "Started. " << endl;

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

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

close(STDOUT_FILENO);

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

close(STDERR_FILENO);

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

}

#endif

}

catch (Exception& e)

{

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

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

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

MessageLoader::getMessage(parms));

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;

}

// Run the main CIM Server loop

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

try

{

Selector selector;

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

CIMServer server(&selector, pegasusHome);

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

server.bind(address);

#if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)

delete [] address;

server.runForever();

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

}

catch(Exception& e)

{

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

MessageLoaderParms parms(

"src.Server.cimserver.ERROR",

"Error: $0",

e.getMessage());

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

MessageLoader::getMessage(parms));

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

deleteCIMServer();

return 1;

}

deleteCIMServer();

return 0;

}

Legend:

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

No CVS admin address has been configured