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.33 and 1.217

version 1.33, 2001/07/16 22:28:06

version 1.217, 2008/03/05 22:27:38

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

Line 20

Line 29

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

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

// privilege separation is enabled.

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

// cimserver -s

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

Line 52

Line 65

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

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

#ifdef PEGASUS_OS_PASE

# include <ILEWrapper/ILEUtilities2.h>

# include <ILEWrapper/qumemultiutil.h>

#endif

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

#ifdef PEGASUS_OS_PASE

#include <as400_protos.h> //for _SETCCSID

#endif

class CIMServerProcess : public ServerProcess

{

// Get environment variables:

public:

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

CIMServerProcess()

{

cimserver_set_process(this);

}

if (!tmp)

virtual ~CIMServerProcess()

{

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;

}

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 optionsTable[] =

if (shutdownOption)

{

{"home", "/etc/pegasus", false, Option::STRING, 0, 0, "D",

cm->loadConfigFiles();

"Sets the pegasus home directory"},

}

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

else

"specifies port number to listen on" },

{

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

cm->mergeConfigFiles();

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

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

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

if (FileSystem::exists(configFile))

// Temporarily disable updates to the current configuration

om.mergeFile(configFile);

// file if shutdownOption is true

if(argc && argv != NULL)

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

om.mergeCommandLine(argc, argv);

om.checkRequiredOptions();

cm->mergeCommandLine(argc, argv);

// Enable updates again

cm->useConfigFiles = true;

}

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

Line 176

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.

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

{

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

String pegasusHome;

Boolean shutdownOption = false;

Boolean debugOutputOption = false;

if (argc == 1 )

// Set Message loading to process locale

cim_server_service(argc, argv) ;

MessageLoader::_useProcessLocale = true;

// Get environment variables

#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

String pegasusHome;

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

setlocale(LC_ALL, "");

#endif

for (int i=0; i < argc; i++) {

#ifndef PEGASUS_OS_TYPE_WINDOWS

if (!strcmp(argv[i],"-D")) {

i++;

// Get environment variables:

if (i < argc) pegasusHome = argv[i];

break;

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

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

}

if (pegasusHome.size() == 0)

GetEnvironmentVariables(argv[0], pegasusHome);

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

#endif /* !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */

// removes corresponding options and their arguments fromt he command

// line.

OptionManager om;

// Get help, version, and shutdown options

try

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

{

GetOptions(om, argc, argv, pegasusHome);

const char* arg = argv[i];

// om.print();

if (strcmp(arg, "--help") == 0)

{

PrintHelp(argv[0]);

Executor::daemonizeExecutor();

exit(0);

}

catch (Exception& e)

else if (strcmp(arg, "--version") == 0)

{

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

Executor::daemonizeExecutor();

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)

{

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

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

Executor::daemonizeExecutor();

exit(0);

}

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

else if (*option == OPTION_HELP &&

(strlen(option) == 1))

{

PrintHelp(argv[0]);

Executor::daemonizeExecutor();

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

}

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

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

// error if there are any remaining:

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 (argc != 1)

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

{

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

MessageLoaderParms parms(

"src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",

"Duplicate shutdown option specified.");

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

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

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

cout << endl;

exit(1);

}

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

shutdownOption = true;

String installOption;

// remove the option from the command line

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

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

{

if( 0 != cimserver_install_nt_service( pegasusHome ))

_cimServer->shutdownSignal();

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

exit(0);

}

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

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

String removeOption;

int CIMServerProcess::cimserver_run(

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

int argc,

char** argv,

Boolean shutdownOption,

Boolean debugOutputOption)

{

if( 0 != cimserver_remove_nt_service() )

Boolean daemonOption = false;

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

exit(0);

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

}

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

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

String versionOption;

// Get an instance of the Config Manager.

ConfigManager* configManager = ConfigManager::getInstance();

configManager->useConfigFiles = true;

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

try

{

cerr << PEGASUS_VERSION << endl;

exit(0);

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

// removes corresponding options and their arguments from the command

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

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

GetOptions(configManager, argc, argv, shutdownOption);

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

#ifdef PEGASUS_OS_PASE

// set ccsid to unicode for entire job

// ccsid is globolization mechanism in PASE environment

if (_SETCCSID(1208) == -1)

{

MessageLoaderParms parms(

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

}

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

char fullJobName[29];

String helpOption;

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 (om.lookupValue("help", helpOption) && helpOption == "true")

if ((Executor::detectExecutor() == 0) && (daemonOption == false))

{

PrintHelp(argv[0]);

MessageLoaderParms parms(

om.printHelp();

"src.Server.cimserver.PRIVSEP_REQUIRES_DAEMON",

exit(0);

"Warning: The configuration setting daemon=false is ignored "

"with privilege separation enabled.");

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

daemonOption = true;

}

// Check the trace options and set global variable

#if !defined(PEGASUS_USE_SYSLOGS)

Boolean pegasusIOTrace = false;

String logsDirectory = ConfigManager::getHomedPath(

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

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)

{

Handler::setMessageTrace(true);

String configTimeout =

pegasusIOTrace = true;

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;

}

Boolean pegasusIOLog = false;

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

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

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

{

Handler::setMessageLogTrace(true);

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

pegasusIOLog = true;

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

}

// Grab the port otpion:

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

startupCheckBPXServer(true);

startupCheckProfileCIMSERVclassWBEM();

startupEnableMSC();

#endif

String portOption;

#if defined(PEGASUS_DEBUG)

om.lookupValue("port", portOption);

// Put out startup up message.

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

_cimServerProcess->getCompleteVersion() << endl;

#endif

// Get the log file directory definition.

// reset message loading to NON-process locale

// We put String into Cstring because

MessageLoader::_useProcessLocale = false;

// Directory functions only handle Cstring.

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

String logsDirectory;

om.lookupValue("logdir", logsDirectory);

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

// Get the parent's PID before forking

// Might be more logical to clean before set.

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

// ATTN: Need tool to completely disable logging.

Logger::setHomeDirectory(logsDirectory);

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

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

// itself later).

if (daemonOption)

{

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

return -1;

}

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

try

{

Logger::clean(logsDirectory);;

Thread::setLanguages(LanguageParser::getDefaultAcceptLanguages());

}

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

}

// Option to Display the options table. Primarily

#ifndef PEGASUS_OS_TYPE_WINDOWS

// a diagnostic tool.

umask(S_IRWXG|S_IRWXO);

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

#endif

om.print();

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

// Start up the CIM Server

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

Boolean useSLP = (om.valueEquals("slp", "true")) ? true: false;

try

{

#if defined(PEGASUS_OS_TYPE_UNIX)

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

char* address = portOption.allocateCString();

// Make sure the start-up lock file exists

FILE* startupLockFile;

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

{

fclose(startupLockFile);

}

// Put out startup up message.

AutoFileLock fileLock(startupLockFileName);

cout << PEGASUS_NAME << PEGASUS_VERSION <<

#endif

" on port " << address << endl;

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

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

cout <<"Started..."

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

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

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

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

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

<< endl;

if (_serverRunStatus.isServerRunning())

{

// Put server start message to the logger

MessageLoaderParms parms(

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

"src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",

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

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

PEGASUS_NAME,

Logger::put(

PEGASUS_VERSION,

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

address,

MessageLoader::getMessage(parms));

(pegasusIOTrace ? " Tracing": " "),

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

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

if (daemonOption)

// do we need to run as a daemon ?

String daemonOption;

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

{

if(-1 == cimserver_fork())

_cimServerProcess->notify_parent(1);

exit(-1);

}

return 1;

}

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

try

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

Boolean enableHttpConnection = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("enableHttpConnection"));

Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(

configManager->getCurrentValue("enableHttpsConnection"));

#ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET

// Make sure at least one connection is enabled

if (!enableHttpConnection && !enableHttpsConnection)

{

MessageLoaderParms parms(

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

#ifdef PEGASUS_OS_TYPE_WINDOWS

addIP4Acceptor = 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)

{

slp_client *discovery = new slp_client() ;;

addIP4Acceptor = true;

String serviceURL;

}

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

String host_name = slp_get_host_name();

serviceURL += host_name;

serviceURL += ":";

serviceURL += address;

char *url = serviceURL.allocateCString();

// free(host_name);

Selector selector;

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

CIMServer server(&selector, pegasusHome);

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

// bind throws an exception of the bind fails

if (enableHttpConnection)

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

{

server.bind(address);

Uint32 portNumberHttp = 0;

delete [] address;

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

}

if (addIP6Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,

portNumberHttp, false);

}

if (addIP4Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,

portNumberHttp, false);

}

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_HTTP_PORT",

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

Logger::put(

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

MessageLoader::getMessage(parms));

#if defined(PEGASUS_DEBUG)

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

#endif

}

time_t last = 0;

if (enableHttpsConnection)

while( 1 )

{

Uint32 portNumberHttps = 0;

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

{

throw InvalidPropertyValue("httpsPort", httpsPort);

}

if (addIP6Acceptor)

{

if(useSLP )

_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

{

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

_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( discovery != NULL && url != NULL )

_cimServerProcess->notify_parent(0);

discovery->srv_reg_all(url,

"(namespace=root/cimv20)",

"service:cim.pegasus",

"DEFAULT",

70) ;

time(&last);

}

discovery->service_listener();

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

}

server.runForever();

// Run the main CIM Server loop

try

{

#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

// In case we don't want to reregister to SLP

// (i.e. PEGASUS_SLP_REG_TIMEOUT not set) after CIM Server startup,

// the SLP Provider is started only once,

// right short before entering the runForever loop which then can handle

// the invokeMethod call against the SLP provider

// function startSLPProvider() does create a separate thread to process

// so code continues to go into the forever loop before executing any

// requests against the CIM Server

#ifdef PEGASUS_ENABLE_SLP

# ifndef PEGASUS_SLP_REG_TIMEOUT

_cimServer->startSLPProvider();

# endif

#endif

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

// has been shutdown

while (!_cimServer->terminated())

{

_cimServer->runForever();

}

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

"Normal Termination");

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

}

catch(Exception& e)

{

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

MessageLoaderParms parms(

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

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

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

deleteCIMServer();

return 1;

}

deleteCIMServer();

return 0;

}

Legend:

Removed from v.1.33
changed lines
	Added in v.1.217

No CVS admin address has been configured