Boolean ProviderAgent::_readAndProcessRequest() { PEG_METHOD_ENTER(TRC_PROVIDERAGENT, "ProviderAgent::_readAndProcessRequest"); CIMRequestMessage* request; // // Read the request from CIM Server // CIMMessage* cimMessage; AnonymousPipe::Status readStatus = _pipeFromServer->readMessage(cimMessage); request = dynamic_cast<CIMRequestMessage*>(cimMessage); // Read operation was interrupted if (readStatus == AnonymousPipe::STATUS_INTERRUPT) { PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL1, "Read operation was interrupted."); PEG_METHOD_EXIT(); return false; } if (readStatus == AnonymousPipe::STATUS_CLOSED) { // The CIM Server connection is closed PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL2, "CIMServer connection closed. Exiting."); _terminating = true; PEG_METHOD_EXIT(); return false; } if (readStatus == AnonymousPipe::STATUS_ERROR) { PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL1, "Error reading from pipe. Exiting."); Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING, MessageLoaderParms( "ProviderManager.ProviderAgent.ProviderAgent." "CIMSERVER_COMMUNICATION_FAILED", "cimprovagt \"$0\" communication with CIM Server failed. " "Exiting.", _agentId)); _terminating = true; PEG_METHOD_EXIT(); return false; } // The message was not a request message. if (request == 0) { // The message was not empty. if (0 != cimMessage ) { // The message was not a "wake up" message. if (cimMessage->getType() == PROVAGT_GET_SCMOCLASS_RESPONSE_MESSAGE) { PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL3, "Processing a SCMOClassResponseMessage."); AutoPtr<ProvAgtGetScmoClassResponseMessage> response( dynamic_cast<ProvAgtGetScmoClassResponseMessage*> (cimMessage)); PEGASUS_DEBUG_ASSERT(response.get()); _processGetSCMOClassResponse(response.get()); // The provider agent is still busy. PEG_METHOD_EXIT(); return true; } } // A "wake up" message means we should unload idle providers PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL4, "Got a wake up message."); if (!_providerManagerRouter.hasActiveProviders()) { // No active providers, so do not start an idle unload thread return false; } try { _unloadIdleProviders(); } catch (...) { // Ignore exceptions from idle provider unloading PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL2, "Ignoring exception from _unloadIdleProviders()"); } PEG_METHOD_EXIT(); return false; } PEG_TRACE((TRC_PROVIDERAGENT, Tracer::LEVEL3, "Received request from server with messageId %s", (const char*)request->messageId.getCString())); const AcceptLanguageListContainer acceptLang = request->operationContext.get(AcceptLanguageListContainer::NAME); Thread::setLanguages(acceptLang.getLanguages()); // Get the ProviderIdContainer to complete the provider module instance // optimization. If the provider module instance is blank (optimized // out), fill it in from our cache. If it is not blank, update our // cache. (See the _providerModuleCache member description.) if (request->operationContext.contains(ProviderIdContainer::NAME)) { ProviderIdContainer pidc = request->operationContext.get( ProviderIdContainer::NAME); if (pidc.getModule().isUninitialized()) { // Provider module is optimized out. Fill it in from the cache. request->operationContext.set(ProviderIdContainer( _providerModuleCache, pidc.getProvider(), pidc.isRemoteNameSpace(), pidc.getRemoteInfo())); } else { // Update the cache with the new provider module instance. _providerModuleCache = pidc.getModule(); } } // // It never should be possible to receive a request other than "initialise" // before the provider agent is in state isInitialised // // Bail out. // if (!_isInitialised && (request->getType() != CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE)) { Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING, MessageLoaderParms( "ProviderManager.ProviderAgent.ProviderAgent." "PROVIDERAGENT_NOT_INITIALIZED", "cimprovagt \"$0\" was not yet initialized " "prior to receiving a request message. Exiting.", _agentId)); _terminating = true; PEG_METHOD_EXIT(); return false; } // // Check for messages to be handled by the Agent itself. // if (request->getType() == CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE) { // Process the request in this thread AutoPtr<CIMInitializeProviderAgentRequestMessage> ipaRequest( dynamic_cast<CIMInitializeProviderAgentRequestMessage*>(request)); PEGASUS_ASSERT(ipaRequest.get() != 0); ConfigManager::setPegasusHome(ipaRequest->pegasusHome); ConfigManager* configManager = ConfigManager::getInstance(); // Initialize the configuration properties for (Uint32 i = 0; i < ipaRequest->configProperties.size(); i++) { configManager->initCurrentValue( ipaRequest->configProperties[i].first, ipaRequest->configProperties[i].second); } // Set the default resource bundle directory for the MessageLoader MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath( configManager->getCurrentValue("messageDir"))); // Set the log file directory #if !defined(PEGASUS_USE_SYSLOGS) Logger::setHomeDirectory(ConfigManager::getHomedPath( configManager->getCurrentValue("logdir"))); #endif System::bindVerbose = ipaRequest->bindVerbose; // // Set _subscriptionInitComplete from value in // InitializeProviderAgent request // _providerManagerRouter.setSubscriptionInitComplete (ipaRequest->subscriptionInitComplete); PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL2, "Processed the agent initialization message."); // Notify the cimserver that the provider agent is initialized. Uint32 messageLength = 0; _pipeToServer->writeBuffer((const char*)&messageLength, sizeof(Uint32)); #if defined(PEGASUS_OS_ZOS) && defined(PEGASUS_ZOS_SECURITY) // prepare and setup the thread-level security environment on z/OS // if security initialization fails startupCheckBPXServer(false); startupCheckMSC(); if (!isZOSSecuritySetup()) { Logger::put_l(Logger::ERROR_LOG, ZOS_SECURITY_NAME, Logger::FATAL, MessageLoaderParms( "ProviderManager.ProviderAgent.ProviderAgent." "UNINITIALIZED_SECURITY_SETUP.PEGASUS_OS_ZOS", "Security environment could not be initialised. " "Assume security fraud. Stopping Provider Agent.")); exit(1); } #endif // provider agent is initialised and ready to go _isInitialised = true; } else if (request->getType() == CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE) { // Process the request in this thread AutoPtr<CIMNotifyConfigChangeRequestMessage> notifyRequest( dynamic_cast<CIMNotifyConfigChangeRequestMessage*>(request)); PEGASUS_ASSERT(notifyRequest.get() != 0); // // Update the ConfigManager with the new property value // ConfigManager* configManager = ConfigManager::getInstance(); CIMException responseException; try { if (notifyRequest->currentValueModified) { String userName = ((IdentityContainer) request->operationContext.get( IdentityContainer::NAME)).getUserName(); configManager->updateCurrentValue( notifyRequest->propertyName, notifyRequest->newPropertyValue, userName, 0, false); } else { configManager->updatePlannedValue( notifyRequest->propertyName, notifyRequest->newPropertyValue, true); } } catch (Exception& e) { responseException = PEGASUS_CIM_EXCEPTION( CIM_ERR_FAILED, e.getMessage()); } AutoPtr<CIMResponseMessage> response(notifyRequest->buildResponse()); response->cimException = responseException; // Return response to CIM Server _writeResponse(response.get()); } else if ((request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE) || (request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE)) { // Process the request in this thread AutoPtr<Message> response(_processRequest(request)); _writeResponse(response.get()); CIMResponseMessage * respMsg = dynamic_cast<CIMResponseMessage*>(response.get()); // If StopAllProviders, terminate the agent process. // If DisableModule not successful, leave agent process running. if ((request->getType() == CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) || ((request->getType() == CIM_DISABLE_MODULE_REQUEST_MESSAGE) && (!dynamic_cast<CIMDisableModuleRequestMessage*>(request)-> disableProviderOnly) && (respMsg->cimException.getCode() == CIM_ERR_SUCCESS))) { // Operation is successful. End the agent process. _providersStopped = true; _terminating = true; } delete request; } else if (request->getType () == CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE || request->getType () == CIM_INDICATION_SERVICE_DISABLED_REQUEST_MESSAGE) { // // Process the request in this thread // AutoPtr <Message> response (_processRequest (request)); _writeResponse (response.get ()); // // Note: the response does not contain interesting data // delete request; } else { // Start a new thread to process the request ProviderAgentRequest* agentRequest = new ProviderAgentRequest(this, request); ThreadStatus rtn = PEGASUS_THREAD_OK; while ((rtn = _threadPool.allocate_and_awaken(agentRequest, ProviderAgent::_processRequestAndWriteResponse)) != PEGASUS_THREAD_OK) { if (rtn == PEGASUS_THREAD_INSUFFICIENT_RESOURCES) { Threads::yield(); } else { PEG_TRACE_CSTRING(TRC_PROVIDERAGENT, Tracer::LEVEL1, "Could not allocate thread to process agent request."); AutoPtr<CIMResponseMessage> response(request->buildResponse()); response->cimException = PEGASUS_CIM_EXCEPTION_L( CIM_ERR_FAILED, MessageLoaderParms( "ProviderManager.ProviderAgent.ProviderAgent." "THREAD_ALLOCATION_FAILED", "Failed to allocate a thread in cimprovagt \"$0\".", _agentId)); // Return response to CIM Server _writeResponse(response.get()); delete agentRequest; delete request; break; } } } PEG_METHOD_EXIT(); return true; }
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 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"))); #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); #endif #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("."); // 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, parms); exit (1); } char fullJobName[29]; umeGetJobName(fullJobName, true); Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, MessageLoaderParms( "src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE", "CIM Server's Job Name is: $0", fullJobName)); #endif #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET // Make sure at least one connection is enabled Boolean enableHttpConnection = ConfigManager::parseBooleanValue( configManager->getCurrentValue("enableHttpConnection")); Boolean enableHttpsConnection = ConfigManager::parseBooleanValue( configManager->getCurrentValue("enableHttpsConnection")); if (!enableHttpConnection && !enableHttpsConnection) { MessageLoaderParms parms( "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING", "Neither HTTP nor HTTPS connection is enabled." " CIMServer will not be started."); Logger::put_l( Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING, parms); 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; } // // Check to see if we need to shutdown CIMOM // if (shutdownOption) { #if defined(PEGASUS_OS_ZOS) && defined(PEGASUS_ZOS_SECURITY) // This checks whether user is authorized to stop the // CIM Server. When unauthorized a message is logged to // to the user and program exits. shutdownCheckProfileCIMSERVclassWBEM(); // Depending on the success of the previous check we may not // reach this code!!! #endif 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) { MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED", "cimserver not started: $0", e.getMessage()); Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, parms); cerr << MessageLoader::getMessage(parms) << endl; return 1; } #if defined(PEGASUS_OS_ZOS) # if defined(PEGASUS_ZOS_SECURITY) startupCheckBPXServer(true); startupCheckProfileCIMSERVclassWBEM(); startupEnableMSC(); # endif startupWaitForTCPIP(); #endif #if defined(PEGASUS_DEBUG) // Put out startup up message. cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getCompleteVersion() << endl; #endif // Force initialization of hostname and fullyQualifiedHostName through // retrieving current value from Configuration Manager // - this will run getCurrentValue() in DefaultPropertyOwner.cpp configManager->getCurrentValue("hostname"); configManager->getCurrentValue("fullyQualifiedHostName"); // 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) { 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 { Thread::setLanguages(LanguageParser::getDefaultAcceptLanguages()); } catch (InvalidAcceptLanguageHeader& e) { Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, MessageLoaderParms( "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 { #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(); // 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_l( Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, 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; #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 { PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4, "IPv6 stack is not active, using IPv4 socket."); } #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.size() == 0) { // // Look up the WBEM-HTTP port number // portNumberHttp = System::lookupPort( WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT); _initConfigProperty("httpPort", portNumberHttp); } else { Uint64 longNumber; // use the current value which has been checked for validity at // load(fct. GetOptions), see DefaultPropertyOwner::isValid() StringConversion::decimalStringToUint64( httpPort.getCString(), longNumber); portNumberHttp = longNumber & 0xffff; } String listenOn = configManager->getCurrentValue("listenAddress"); if(String::equalNoCase(listenOn, "All")) { if (addIP6Acceptor) { _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION, portNumberHttp, false); } if (addIP4Acceptor) { _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION, portNumberHttp, false); } } else // Restricted listening { _restrictListening( configManager, listenOn, portNumberHttp, false); } // The port number is converted to a string to avoid the // addition of localized characters (e.g., "5,988"). 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_l( Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, parms); #if defined(PEGASUS_DEBUG) cout << MessageLoader::getMessage(parms) << endl; #endif } if (enableHttpsConnection) { Uint32 portNumberHttps = 0; String httpsPort = configManager->getCurrentValue("httpsPort"); if (httpsPort.size() == 0) { // // Look up the WBEM-HTTPS port number // portNumberHttps = System::lookupPort( WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT); _initConfigProperty("httpsPort", portNumberHttps); } else { Uint64 longNumber; // use the current value which has been checked for validity at // load(fct. GetOptions), see DefaultPropertyOwner::isValid() StringConversion::decimalStringToUint64( httpsPort.getCString(), longNumber); portNumberHttps = longNumber & 0xffff; } String listenOn = configManager->getCurrentValue("listenAddress"); if(String::equalNoCase(listenOn, "All")) { if (addIP6Acceptor) { _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION, portNumberHttps, true); } if (addIP4Acceptor) { _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION, portNumberHttps, true); } } else //Restricted { _restrictListening( configManager, listenOn, portNumberHttps, true); } // The port number is converted to a string to avoid the // addition of localized characters (e.g., "5,989"). 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_l( Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, 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_l( Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, 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, MessageLoaderParms( "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_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, parms); cerr << MessageLoader::getMessage(parms) << endl; deleteCIMServer(); // // notify parent process (if there is a parent process) to terminate // if (daemonOption) _cimServerProcess->notify_parent(1); return 1; } // Run the main CIM Server loop try { #if defined(PEGASUS_OS_ZOS) // 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 _cimServer->initComplete(); // // Loop to call CIMServer's runForever() method until CIMServer // has been shutdown // while (!_cimServer->terminated()) { _cimServer->runForever(); } // // normal termination // #if defined(PEGASUS_OS_ZOS) // 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, MessageLoaderParms( "src.Server.cimserver.STOPPED", "$0 stopped.", _cimServerProcess->getProductName())); } catch (Exception& e) { MessageLoaderParms parms( "src.Server.cimserver.ERROR", "Error: $0", e.getMessage()); Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING, parms); cerr << MessageLoader::getMessage(parms) << endl; deleteCIMServer(); return 1; } deleteCIMServer(); return 0; }