(file) Return to cimserver.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Server

Diff for /pegasus/src/Server/cimserver.cpp between version 1.217 and 1.244

version 1.217, 2008/03/05 22:27:38 version 1.244, 2013/08/26 13:11:04
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  // Permission is hereby granted, free of charge, to any person obtaining a
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  // copy of this software and associated documentation files (the "Software"),
 // EMC Corporation; Symantec Corporation; The Open Group.  // to deal in the Software without restriction, including without limitation
 //  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // and/or sell copies of the Software, and to permit persons to whom the
 // of this software and associated documentation files (the "Software"), to  // Software is furnished to do so, subject to the following conditions:
 // deal in the Software without restriction, including without limitation the  //
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // The above copyright notice and this permission notice shall be included
 // sell copies of the Software, and to permit persons to whom the Software is  // in all copies or substantial portions of the Software.
 // furnished to do so, subject to the following conditions:  //
 //  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 86 
Line 84 
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
   #include <Pegasus/Common/StringConversion.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/LanguageParser.h> #include <Pegasus/Common/LanguageParser.h>
Line 96 
Line 95 
 #include <Service/ServerShutdownClient.h> #include <Service/ServerShutdownClient.h>
 #include <Service/ServerRunStatus.h> #include <Service/ServerRunStatus.h>
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
 #include <Pegasus/Common/SetFileDescriptorToEBCDICEncoding.h>  #include <Pegasus/General/SetFileDescriptorToEBCDICEncoding.h>
 #include <Service/ARM_zOS.h> #include <Service/ARM_zOS.h>
   #include <Service/TimeZone_zOS.h>
   #include <Service/WaitForTCPIP_zOS.h>
 # ifdef PEGASUS_ZOS_SECURITY # ifdef PEGASUS_ZOS_SECURITY
 // This include file will not be provided in the OpenGroup CVS for now. // This include file will not be provided in the OpenGroup CVS for now.
 // Do NOT try to include it in your compile // Do NOT try to include it in your compile
Line 131 
Line 132 
  
 //Windows service variables are not defined elsewhere in the product //Windows service variables are not defined elsewhere in the product
 //enable ability to override these //enable ability to override these
   #ifndef PEGASUS_FLAVOR
 #ifndef PEGASUS_SERVICE_NAME #ifndef PEGASUS_SERVICE_NAME
 #define PEGASUS_SERVICE_NAME "Pegasus CIM Object Manager"; #define PEGASUS_SERVICE_NAME "Pegasus CIM Object Manager";
 #endif #endif
 #ifndef PEGASUS_SERVICE_DESCRIPTION #ifndef PEGASUS_SERVICE_DESCRIPTION
 #define PEGASUS_SERVICE_DESCRIPTION "Pegasus CIM Object Manager Service"; #define PEGASUS_SERVICE_DESCRIPTION "Pegasus CIM Object Manager Service";
 #endif #endif
   #else
   #ifndef PEGASUS_SERVICE_NAME
   #define PEGASUS_SERVICE_NAME PEGASUS_FLAVOR " Pegasus CIM Object Manager"
   #endif
   #ifndef PEGASUS_SERVICE_DESCRIPTION
   #define PEGASUS_SERVICE_DESCRIPTION PEGASUS_FLAVOR \
               " Pegasus CIM Object Manager Service";
   #endif
   #endif
  
 #ifdef PEGASUS_OS_PASE #ifdef PEGASUS_OS_PASE
 #include <as400_protos.h> //for _SETCCSID #include <as400_protos.h> //for _SETCCSID
Line 276 
Line 287 
     usage.append(" [ [ options ] | [ configProperty=value, ... ] ]\n");     usage.append(" [ [ options ] | [ configProperty=value, ... ] ]\n");
     usage.append("  options\n");     usage.append("  options\n");
     usage.append("    -v, --version   - displays CIM Server version number\n");     usage.append("    -v, --version   - displays CIM Server version number\n");
       usage.append("    --status        - displays the running status of"
           " the CIM Server\n");
     usage.append("    -h, --help      - prints this help message\n");     usage.append("    -h, --help      - prints this help message\n");
     usage.append("    -s              - shuts down CIM Server\n");     usage.append("    -s              - shuts down CIM Server\n");
 #if !defined(PEGASUS_USE_RELEASE_DIRS) #if !defined(PEGASUS_USE_RELEASE_DIRS)
Line 340 
Line 353 
         Thread::clearLanguages();         Thread::clearLanguages();
         delete dummyInitialThread;         delete dummyInitialThread;
     }     }
       _serverRunStatus.setServerNotRunning();
 } }
  
 // //
Line 426 
Line 440 
  
 #endif /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION */ #endif /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION */
  
   static void _initConfigProperty(const String &propName, Uint32 value)
   {
       char strValue[22];
       Uint32 n;
       const char *startP = Uint32ToString(
           strValue,
           value,
           n);
       ConfigManager::getInstance()->initCurrentValue(propName, String(startP, n));
   }
   static void _restrictListening(
       ConfigManager* configManager,
       const String &listenOn,
       const Uint32 &portNumberHttp,
       const Boolean useSSL)
   {
       static Array<HostAddress> laddr = configManager ->getListenAddress(
                                             listenOn);
       for(Uint32 i = 0, n = laddr.size(); i < n; ++i)
       {
           if(laddr[i].getAddressType() == HostAddress::AT_IPV6)
           {
   #ifdef PEGASUS_ENABLE_IPV6
               _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
                       portNumberHttp, useSSL,
                       &laddr[i]);
   #endif
           }
           else if(laddr[i].getAddressType() == HostAddress::AT_IPV4)
           {
               _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                       portNumberHttp, useSSL,
                       &laddr[i]);
           }
       }
   }
   
 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
 //  MAIN //  MAIN
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
Line 447 
Line 498 
     if ( setEBCDICEncoding(STDOUT_FILENO)==-1 ||     if ( setEBCDICEncoding(STDOUT_FILENO)==-1 ||
          setEBCDICEncoding(STDERR_FILENO)==-1 )          setEBCDICEncoding(STDERR_FILENO)==-1 )
     {     {
        PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4,         PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL1,
            "Coud not set stdout or stderr to EBCDIC encoding.");            "Coud not set stdout or stderr to EBCDIC encoding.");
     }     }
     // Need to initialize timezone information in the     // Need to initialize timezone information in the
     // initial processing thread (IPT)     // initial processing thread (IPT)
     tzset();      initialize_zOS_timezone();
 #endif #endif
  
 #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES) #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)
Line 469 
Line 520 
     const char *tmp = getenv("PEGASUS_HOME");     const char *tmp = getenv("PEGASUS_HOME");
     pegasusHome = (tmp == 0) ? PASE_DEFAULT_PEGASUS_HOME : tmp;     pegasusHome = (tmp == 0) ? PASE_DEFAULT_PEGASUS_HOME : tmp;
 # elif !defined(PEGASUS_USE_RELEASE_DIRS) || \ # elif !defined(PEGASUS_USE_RELEASE_DIRS) || \
     defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)      defined(PEGASUS_OS_ZOS)
     const char* tmp = getenv("PEGASUS_HOME");     const char* tmp = getenv("PEGASUS_HOME");
  
     if (tmp)     if (tmp)
Line 504 
Line 555 
  
 #endif /* !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
  
         // Get help, version, and shutdown options          // Get help, version, status and shutdown options
  
         for (int i = 1; i < argc; )         for (int i = 1; i < argc; )
         {         {
Line 515 
Line 566 
                 Executor::daemonizeExecutor();                 Executor::daemonizeExecutor();
                 exit(0);                 exit(0);
             }             }
               if (strcmp(arg, "--status") == 0)
               {
                   int retValue = 0;
                   if (_serverRunStatus.isServerRunning())
                   {
                       MessageLoaderParms parms(
                           "src.Server.cimserver.CIMSERVER_RUNNING",
                           "The CIM Server is running.");
                       cout << MessageLoader::getMessage(parms) << endl;
                   }
                   else
                   {
                       MessageLoaderParms parms(
                           "src.Server.cimserver.CIMSERVER_NOT_RUNNING",
                           "The CIM Server is not running.");
                       cout << MessageLoader::getMessage(parms) << endl;
                       retValue = 2;
                   }
                   Executor::daemonizeExecutor();
                   exit(retValue);
               }
             else if (strcmp(arg, "--version") == 0)             else if (strcmp(arg, "--version") == 0)
             {             {
                 cout << _cimServerProcess->getCompleteVersion() << endl;                 cout << _cimServerProcess->getCompleteVersion() << endl;
Line 716 
Line 788 
         MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(         MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
             ConfigManager::getInstance()->getCurrentValue("messageDir")));             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 #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     // set ccsid to unicode for entire job
     // ccsid is globolization mechanism in PASE environment     // ccsid is globolization mechanism in PASE environment
     if (_SETCCSID(1208) == -1)     if (_SETCCSID(1208) == -1)
Line 726 
Line 815 
                 "Failed to set CCSID, server will stop.");                 "Failed to set CCSID, server will stop.");
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::FATAL,         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::FATAL,
                 "src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",                      parms);
                 "Failed to set CCSID, server will stop.\n");  
         exit (1);         exit (1);
     }     }
  
     char fullJobName[29];     char fullJobName[29];
     umeGetJobName(fullJobName, true);     umeGetJobName(fullJobName, true);
     Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
                   Logger::INFORMATION,
                   MessageLoaderParms(
             "src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",             "src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",
             "CIM Server's Job Name is: $0", fullJobName);                      "CIM Server's Job Name is: $0", fullJobName));
 #endif #endif
  
   #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
           // Make sure at least one connection is enabled
   
     Boolean enableHttpConnection = ConfigManager::parseBooleanValue(     Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
         configManager->getCurrentValue("enableHttpConnection"));         configManager->getCurrentValue("enableHttpConnection"));
     Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(     Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
         configManager->getCurrentValue("enableHttpsConnection"));         configManager->getCurrentValue("enableHttpsConnection"));
  
     // Make sure at least one connection is enabled  
 #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET  
     if (!enableHttpConnection && !enableHttpsConnection)     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(         MessageLoaderParms parms(
                 "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",                 "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
                 "Neither HTTP nor HTTPS connection is enabled."                 "Neither HTTP nor HTTPS connection is enabled."
                 "  CIMServer will not be started.");                 "  CIMServer will not be started.");
               Logger::put_l(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                   parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
         return(1);              return 1;
     }     }
 #endif #endif
   
         //         //
         // Check to see if we should start Pegasus as a daemon         // Check to see if we should start Pegasus as a daemon
         //         //
Line 781 
Line 866 
             daemonOption = true;             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.  
         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         // Check to see if we need to shutdown CIMOM
         //         //
         if (shutdownOption)         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 =             String configTimeout =
                 configManager->getCurrentValue("shutdownTimeout");                 configManager->getCurrentValue("shutdownTimeout");
             Uint32 timeoutValue =             Uint32 timeoutValue =
Line 831 
Line 906 
     {     {
         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
             "cimserver not started: $0", e.getMessage());             "cimserver not started: $0", e.getMessage());
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             MessageLoader::getMessage(parms));              parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
  
         return 1;         return 1;
     }     }
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY)  #if defined(PEGASUS_OS_ZOS)
   #  if defined(PEGASUS_ZOS_SECURITY)
     startupCheckBPXServer(true);     startupCheckBPXServer(true);
     startupCheckProfileCIMSERVclassWBEM();     startupCheckProfileCIMSERVclassWBEM();
     startupEnableMSC();     startupEnableMSC();
 #endif #endif
       startupWaitForTCPIP();
   #endif
  
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
     // Put out startup up message.     // Put out startup up message.
Line 850 
Line 928 
         _cimServerProcess->getCompleteVersion() << endl;         _cimServerProcess->getCompleteVersion() << endl;
 #endif #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     // reset message loading to NON-process locale
     MessageLoader::_useProcessLocale = false;     MessageLoader::_useProcessLocale = false;
  
Line 880 
Line 964 
     catch (InvalidAcceptLanguageHeader& e)     catch (InvalidAcceptLanguageHeader& e)
     {     {
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
               MessageLoaderParms(
             "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",             "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
             "Could not convert the system process locale into a valid "             "Could not convert the system process locale into a valid "
                 "AcceptLanguage format.");                      "AcceptLanguage format."));
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             e.getMessage());             e.getMessage());
     }     }
Line 893 
Line 978 
  
     // Start up the CIM Server     // Start up the CIM Server
  
     try  
     {  
 #if defined(PEGASUS_OS_TYPE_UNIX) #if defined(PEGASUS_OS_TYPE_UNIX)
         //         //
         // Lock the CIMSERVER_LOCK_FILE during CIM Server start-up to prevent         // Lock the CIMSERVER_LOCK_FILE during CIM Server start-up to prevent
Line 904 
Line 987 
         CString startupLockFileName = ConfigManager::getHomedPath(         CString startupLockFileName = ConfigManager::getHomedPath(
             PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();             PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();
  
       try
       {
   
         // Make sure the start-up lock file exists         // Make sure the start-up lock file exists
         FILE* startupLockFile;         FILE* startupLockFile;
         if ((startupLockFile = fopen(startupLockFileName, "w")) != 0)         if ((startupLockFile = fopen(startupLockFileName, "w")) != 0)
Line 912 
Line 998 
         }         }
  
         AutoFileLock fileLock(startupLockFileName);         AutoFileLock fileLock(startupLockFileName);
   #else
       try
       {
 #endif #endif
  
 #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS) #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
Line 924 
Line 1013 
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",                 "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
                 "Unable to start CIMServer. CIMServer is already running.");                 "Unable to start CIMServer. CIMServer is already running.");
             Logger::put(              Logger::put_l(
                 Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
             cerr << MessageLoader::getMessage(parms) << endl;             cerr << MessageLoader::getMessage(parms) << endl;
  
             if (daemonOption)             if (daemonOption)
Line 979 
Line 1068 
         }         }
         else         else
         {         {
             MessageLoaderParms parms(              PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4,
                 "src.Server.cimserver.IPV6_STACK_NOT_ACTIVE",  
                 "IPv6 stack is not active, using IPv4 socket.");                 "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 #endif
         if (!addIP6Acceptor)         if (!addIP6Acceptor)
Line 1009 
Line 1091 
         {         {
             Uint32 portNumberHttp = 0;             Uint32 portNumberHttp = 0;
             String httpPort = configManager->getCurrentValue("httpPort");             String httpPort = configManager->getCurrentValue("httpPort");
             if (httpPort == String::EMPTY)              if (httpPort.size() == 0)
             {             {
                 //                 //
                 // Look up the WBEM-HTTP port number                 // Look up the WBEM-HTTP port number
                 //                 //
                 portNumberHttp = System::lookupPort(                 portNumberHttp = System::lookupPort(
                     WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);                     WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);
                   _initConfigProperty("httpPort", portNumberHttp);
             }             }
             else             else
             {             {
                 //                  Uint64 longNumber;
                 // user-specified                  // use the current value which has been checked for validity at
                 //                  // load(fct. GetOptions), see DefaultPropertyOwner::isValid()
                 CString portString = httpPort.getCString();                  StringConversion::decimalStringToUint64(
                 char* end = 0;                      httpPort.getCString(),
                 portNumberHttp = strtol(portString, &end, 10);                      longNumber);
                 if (!(end != 0 && *end == '\0'))                  portNumberHttp = longNumber & 0xffff;
                 {  
                     throw InvalidPropertyValue("httpPort", httpPort);  
                 }  
             }             }
  
               String listenOn = configManager->getCurrentValue("listenAddress");
               if(String::equalNoCase(listenOn, "All"))
               {
             if (addIP6Acceptor)             if (addIP6Acceptor)
             {             {
                 _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,                 _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
Line 1041 
Line 1124 
                 _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,                 _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                     portNumberHttp, false);                     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(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                 "Listening on HTTP port $0.", portNumberHttp);                  "Listening on HTTP port $0.", portNumberHttpStr);
             Logger::put(              Logger::put_l(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
 #endif #endif
Line 1057 
Line 1152 
         {         {
             Uint32 portNumberHttps = 0;             Uint32 portNumberHttps = 0;
             String httpsPort = configManager->getCurrentValue("httpsPort");             String httpsPort = configManager->getCurrentValue("httpsPort");
             if (httpsPort == String::EMPTY)              if (httpsPort.size() == 0)
             {             {
                 //                 //
                 // Look up the WBEM-HTTPS port number                 // Look up the WBEM-HTTPS port number
                 //                 //
                 portNumberHttps = System::lookupPort(                 portNumberHttps = System::lookupPort(
                     WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);                     WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);
                   _initConfigProperty("httpsPort", portNumberHttps);
             }             }
             else             else
             {             {
                 //                  Uint64 longNumber;
                 // user-specified                  // use the current value which has been checked for validity at
                 //                  // load(fct. GetOptions), see DefaultPropertyOwner::isValid()
                 CString portString = httpsPort.getCString();                  StringConversion::decimalStringToUint64(
                 char* end = 0;                      httpsPort.getCString(),
                 portNumberHttps = strtol(portString, &end, 10);                      longNumber);
                 if (!(end != 0 && *end == '\0'))                  portNumberHttps = longNumber & 0xffff;
                 {  
                     throw InvalidPropertyValue("httpsPort", httpsPort);  
                 }  
             }             }
   
               String listenOn = configManager->getCurrentValue("listenAddress");
               if(String::equalNoCase(listenOn, "All"))
               {
             if (addIP6Acceptor)             if (addIP6Acceptor)
             {             {
                 _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,                 _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
Line 1088 
Line 1185 
                 _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,                 _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                     portNumberHttps, true);                     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(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                 "Listening on HTTPS port $0.", portNumberHttps);                  "Listening on HTTPS port $0.", portNumberHttpsStr);
             Logger::put(              Logger::put_l(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
 #endif #endif
Line 1106 
Line 1216 
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_LOCAL",                 "src.Server.cimserver.LISTENING_ON_LOCAL",
                 "Listening on local connection socket.");                 "Listening on local connection socket.");
             Logger::put(              Logger::put_l(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
 # if defined(PEGASUS_DEBUG) # if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
 # endif # endif
Line 1131 
Line 1241 
         // Put server started message to the logger         // Put server started message to the logger
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
             Logger::INFORMATION,             Logger::INFORMATION,
               MessageLoaderParms(
             "src.Server.cimserver.STARTED_VERSION",             "src.Server.cimserver.STARTED_VERSION",
             "Started $0 version $1.",             "Started $0 version $1.",
             _cimServerProcess->getProductName(),             _cimServerProcess->getProductName(),
             _cimServerProcess->getCompleteVersion());                  _cimServerProcess->getCompleteVersion()));
  
 #if defined(PEGASUS_OS_TYPE_UNIX) && !defined(PEGASUS_OS_ZOS) #if defined(PEGASUS_OS_TYPE_UNIX) && !defined(PEGASUS_OS_ZOS)
         if (daemonOption && !debugOutputOption)         if (daemonOption && !debugOutputOption)
Line 1154 
Line 1265 
     {     {
         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
             "cimserver not started: $0", e.getMessage());             "cimserver not started: $0", e.getMessage());
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             MessageLoader::getMessage(parms));              parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
  
           deleteCIMServer();
   
         //         //
         // notify parent process (if there is a parent process) to terminate         // notify parent process (if there is a parent process) to terminate
         //         //
         if (daemonOption)         if (daemonOption)
             _cimServerProcess->notify_parent(1);             _cimServerProcess->notify_parent(1);
  
         deleteCIMServer();  
         return 1;         return 1;
     }     }
  
Line 1172 
Line 1284 
  
     try     try
     {     {
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
  
         // ARM is a z/OS internal restart facility.         // ARM is a z/OS internal restart facility.
         // This is a z/OS specific change.         // This is a z/OS specific change.
Line 1185 
Line 1297 
  
 #endif #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 #ifdef PEGASUS_ENABLE_SLP
 # ifndef PEGASUS_SLP_REG_TIMEOUT  
         _cimServer->startSLPProvider();         _cimServer->startSLPProvider();
 # endif # endif
 #endif          _cimServer->initComplete();
   
         //         //
         // Loop to call CIMServer's runForever() method until CIMServer         // Loop to call CIMServer's runForever() method until CIMServer
         // has been shutdown         // has been shutdown
Line 1211 
Line 1315 
         // normal termination         // normal termination
         //         //
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
  
         // ARM is a z/OS internal restart facility.         // ARM is a z/OS internal restart facility.
         // This is a z/OS specific change.         // This is a z/OS specific change.
Line 1222 
Line 1326 
 #endif #endif
  
         // Put server shutdown message to the logger         // Put server shutdown message to the logger
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,          Logger::put_l(
             Logger::INFORMATION, "src.Server.cimserver.STOPPED",              Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
             "$0 stopped.", _cimServerProcess->getProductName());              MessageLoaderParms(
                   "src.Server.cimserver.STOPPED",
                   "$0 stopped.", _cimServerProcess->getProductName()));
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
Line 1232 
Line 1338 
             "src.Server.cimserver.ERROR",             "src.Server.cimserver.ERROR",
             "Error: $0",             "Error: $0",
             e.getMessage());             e.getMessage());
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
             MessageLoader::getMessage(parms));              parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
  
       //delete the start up lock file
   #if defined(PEGASUS_OS_TYPE_UNIX)
       System::removeFile(startupLockFileName);
   #endif
         deleteCIMServer();         deleteCIMServer();
         return 1;         return 1;
     }     }
  
       //delete the start up lock file
   #if defined(PEGASUS_OS_TYPE_UNIX)
       System::removeFile(startupLockFileName);
   #endif
     deleteCIMServer();     deleteCIMServer();
     return 0;     return 0;
 } }

Legend:
Removed from v.1.217  
changed lines
  Added in v.1.244
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2