void ProviderAgent::_asynchronousSignalHandler( int s_n, PEGASUS_SIGINFO_T* s_info, void* sig) { static bool amark = false; if (amark) exit(1); amark = true; if (_providerAgent != 0) { _providerAgent->_terminating = true; } char fullJobName[29]; umeGetJobName(fullJobName, true); Logger::put_l(Logger::ERROR_LOG, "provider agent", Logger::SEVERE, MessageLoaderParms( "ProviderManager.ProviderAgent.RECEIVE_ASYN_SIGNAL.PEGASUS_OS_PASE", "$0 received asynchronous signal: $1", fullJobName, s_n)); }
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; }