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.27 and 1.220

version 1.27, 2001/06/19 23:53:41

version 1.220, 2008/06/18 12:20:56

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 NOT run pegasus as a daemon on Unix platforms, set the daemon config

// property to false:

// cimserver daemon=false

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

// The daemon config property has no effect on windows operation or when

// privilege separation is enabled.

// cimserver -d

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

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

// cimserver -s

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

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

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# define PEGASUS_PROCESS_NAME "cimservermain"

# include "cimserver_windows.cpp"

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

{

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

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

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

Line 272

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

// MAIN

// platform and error conditions.

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

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

int main(int argc, char** argv)

// destructors to get called.

void deleteCIMServer()

{

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

delete _cimServer;

_cimServer = 0;

if (argc == 1 )

if (dummyInitialThread)

cim_server_service(argc, argv) ;

{

Thread::clearLanguages();

delete dummyInitialThread;

}

// Get environment variables:

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

{

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

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

}

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

sock = int(x);

// error if there are any remaining:

if (argc != 1)

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

{

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

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

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

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

argc -= 2;

cout << endl;

break;

}

if (sock == -1)

{

MessageLoaderParms parms(

"src.Server.cimserver.MISSING_OPTION",

"Missing $0 option.",

OPT);

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

exit(1);

}

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

return sock;

}

#endif /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION */

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

// MAIN

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

String installOption;

int main(int argc, char** argv)

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

{

if( 0 != cimserver_install_nt_service( pegasusHome ))

String pegasusHome;

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

Boolean shutdownOption = false;

exit(0);

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::LEVEL1,

"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

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

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

if (tmp)

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

{

if( 0 != cimserver_remove_nt_service() )

pegasusHome = tmp;

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

}

exit(0);

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

#endif /* !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */

String versionOption;

// Get help, version, and shutdown options

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

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

{

const char* arg = argv[i];

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

{

cerr << PEGASUS_VERSION << endl;

PrintHelp(argv[0]);

Executor::daemonizeExecutor();

exit(0);

}

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 help (-h otpion):

String helpOption;

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

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

if (*option == OPTION_VERSION &&

strlen(option) == 1)

{

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

om.printHelp();

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

}

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

}

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

}

// Check the trace options and set global variable

void CIMServerProcess::cimserver_stop()

Boolean pegasusIOTrace = false;

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

{

Handler::setMessageTrace(true);

_cimServer->shutdownSignal();

pegasusIOTrace = true;

}

Boolean pegasusIOLog = false;

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

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

{

Handler::setMessageLogTrace(true);

Boolean daemonOption = false;

pegasusIOLog = true;

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

}

// Grab the port 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 portOption;

om.lookupValue("port", portOption);

// Get an instance of the Config Manager.

ConfigManager* configManager = ConfigManager::getInstance();

configManager->useConfigFiles = true;

// Get the log file directory definition.

try

// We put String into Cstring because

{

// Directory functions only handle Cstring.

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

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

String logsDirectory;

// removes corresponding options and their arguments from the command

om.lookupValue("logdir", logsDirectory);

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

}

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

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

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 ((Executor::detectExecutor() == 0) && (daemonOption == false))

{

MessageLoaderParms parms(

"src.Server.cimserver.PRIVSEP_REQUIRES_DAEMON",

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

"with privilege separation enabled.");

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

daemonOption = true;

}

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

// ATTN: Need tool to completely disable logging.

Logger::setHomeDirectory(logsDirectory);

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

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

{

Logger::clean(logsDirectory);;

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

// Option to Display the options table. Primarily

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

// a diagnostic tool.

return 0;

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

}

om.print();

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

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

return 1;

}

char* address = portOption.allocateCString();

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

startupCheckBPXServer(true);

startupCheckProfileCIMSERVclassWBEM();

startupEnableMSC();

#endif

#if defined(PEGASUS_DEBUG)

// Put out startup up message.

cout << PEGASUS_NAME << PEGASUS_VERSION <<

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

" on port " << address << endl;

_cimServerProcess->getCompleteVersion() << endl;

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

#endif

cout <<"Started..."

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

// reset message loading to NON-process locale

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

MessageLoader::_useProcessLocale = false;

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

<< endl;

// Get the parent's PID before forking

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

// Put server start message to the logger

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

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

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

// itself later).

PEGASUS_NAME,

if (daemonOption)

PEGASUS_VERSION,

{

address,

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

(pegasusIOTrace ? " Tracing": " "),

return -1;

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

}

// do we need to run as a daemon ?

// Now we are after the fork...

String daemonOption;

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

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

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

{

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

}

catch (InvalidAcceptLanguageHeader& e)

{

if(-1 == cimserver_fork())

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

exit(-1);

"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

// Start up the CIM Server

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

try

{

Selector selector;

#if defined(PEGASUS_OS_TYPE_UNIX)

CIMServer server(&selector, pegasusHome);

server.setSLP(useSLP);

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

// concurrent writes to this file by multiple cimserver processes

// bind throws an exception of the bind fails

// starting at the same time.

server.bind(address);

delete [] address;

CString startupLockFileName = ConfigManager::getHomedPath(

server.runForever();

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;

}

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

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

#ifdef PEGASUS_OS_TYPE_WINDOWS

"Normal Termination");

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)

{

addIP4Acceptor = true;

}

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

if (enableHttpConnection)

{

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

}

if (addIP6Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,

portNumberHttp, false);

}

if (addIP4Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,

portNumberHttp, false);

}

char scratchBuffer[22];

Uint32 n;

const char * portNumberHttpStr = Uint32ToString(

scratchBuffer, portNumberHttp, n);

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_HTTP_PORT",

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

Logger::put(

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

MessageLoader::getMessage(parms));

#if defined(PEGASUS_DEBUG)

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

#endif

}

if (enableHttpsConnection)

{

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)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,

portNumberHttps, true);

}

if (addIP4Acceptor)

{

_cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,

portNumberHttps, true);

}

char scratchBuffer[22];

Uint32 n;

const char * portNumberHttpsStr = Uint32ToString(

scratchBuffer, portNumberHttps, n);

MessageLoaderParms parms(

"src.Server.cimserver.LISTENING_ON_HTTPS_PORT",

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

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)

{

_cimServerProcess->notify_parent(0);

}

#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

{

#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

#ifdef PEGASUS_ENABLE_SLP

_cimServer->startSLPProvider();

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

}

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.27
changed lines
	Added in v.1.220

No CVS admin address has been configured