(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.93 and 1.239

version 1.93, 2003/05/27 21:37:03 version 1.239, 2011/10/13 05:25:40
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 //  
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  
 // The Open Group, Tivoli Systems  
 //  
 // Permission is hereby granted, free of charge, to any person obtaining a copy  
 // of this software and associated documentation files (the "Software"), to  
 // deal in the Software without restriction, including without limitation the  
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  
 // sell copies of the Software, and to permit persons to whom the Software is  
 // furnished to do so, subject to the following conditions:  
 //  
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // 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.  
 //  
 //==============================================================================  
 //  
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Mike Day (mdday@us.ibm.com)  
 //  
 // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)  
 // //
 // Modified By: Nag Boranna (nagaraja_boranna@hp.com)  // Licensed to The Open Group (TOG) under one or more contributor license
   // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
   //
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 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.
 // //
 // Modified By: Jenny Yu (jenny_yu@hp.com)  //////////////////////////////////////////////////////////////////////////
 //  
 // Modified By: Sushma Fernandes (sushma_fernandes@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                (carolann_graves@hp.com)  
 //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)  
 //  
 // Modified By: Dave Rosckes (rosckes@us.ibm.com)  
 //  
 // Modified By: Humberto Rivero (hurivero@us.ibm.com)  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
  
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
 // //
 // 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: // To run pegasus as a daemon on Unix platforms:
 // //
Line 56 
Line 43 
 // //
 // cimserver daemon=false // cimserver daemon=false
 // //
 // The daemon config property has no effect on windows operation.  // The daemon config property has no effect on windows operation or when
   // privilege separation is enabled.
 // //
 // To shutdown pegasus, use the -s option: // To shutdown pegasus, use the -s option:
 // //
Line 75 
Line 63 
 // To START the Pegasus service, // To START the Pegasus service,
 // //
 // net start cimserver // net start cimserver
   // or
   // cimserver -start
 // //
 // To STOP the Pegasus service, // To STOP the Pegasus service,
 // //
 // net stop cimserver // net stop cimserver
   // or
   // cimserver -stop
 // //
 // Alternatively, you can use the windows service manager. Pegasus shows up // Alternatively, you can use the windows service manager. Pegasus shows up
 // in the service database as "Pegasus CIM Object Manager" // in the service database as "Pegasus CIM Object Manager"
 // //
 // Mike Day, mdday@us.ibm.com  
 //  
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
  
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <iostream>  #include <Pegasus/Common/PegasusAssert.h>
 #include <cassert>  
 #include <cstdlib>  
 #include <fstream>  
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Monitor.h>  
 #include <Pegasus/Server/CIMServer.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/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
 #include <Pegasus/Client/CIMClient.h> #include <Pegasus/Client/CIMClient.h>
 #include <Pegasus/Server/ShutdownService.h>  #include <Pegasus/Server/CIMServer.h>
 #include <Pegasus/Common/Destroyer.h>  #include <Service/ServerProcess.h>
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)  #include <Service/ServerShutdownClient.h>
 #include <slp/slp.h>  #include <Service/ServerRunStatus.h>
   
   #if defined(PEGASUS_OS_ZOS)
   #include <Pegasus/General/SetFileDescriptorToEBCDICEncoding.h>
   #include <Service/ARM_zOS.h>
   #include <Service/TimeZone_zOS.h>
   #include <Service/WaitForTCPIP_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 #endif
  
   #if defined(PEGASUS_OS_TYPE_UNIX)
   # include <unistd.h>
   # include <sys/types.h>
   # include <sys/stat.h>
   # include <fcntl.h>
   #endif
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS)  #ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION
 # include "cimserver_windows.cpp"  # define PEGASUS_PROCESS_NAME "cimservermain"
 #elif defined(PEGASUS_OS_TYPE_UNIX)  
 # if defined(PEGASUS_OS_OS400)  
 #  include "cimserver_os400.cpp"  
 # else # else
 #  include "cimserver_unix.cpp"  # define PEGASUS_PROCESS_NAME "cimserver"
 #endif #endif
 #else  
 # error "Unsupported platform"  #include <Pegasus/Common/Executor.h>
   
   #ifdef PEGASUS_OS_PASE
   # include <ILEWrapper/ILEUtilities2.h>
   # include <ILEWrapper/qumemultiutil.h>
 #endif #endif
  
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
   //Windows service variables are not defined elsewhere in the product
   //enable ability to override these
   #ifndef PEGASUS_FLAVOR
   #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
   #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
   #include <as400_protos.h> //for _SETCCSID
   #endif
   
   class CIMServerProcess : public ServerProcess
   {
   public:
   
       CIMServerProcess()
       {
           cimserver_set_process(this);
       }
   
       virtual ~CIMServerProcess()
       {
       }
   
       //defined in PegasusVersion.h
       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. //  The command name.
 // //
Line 146 
Line 238 
  
 static const char OPTION_SHUTDOWN    = 's'; static const char OPTION_SHUTDOWN    = 's';
  
 static const char OPTION_INSTALL[]   = "install";  static const char LONG_HELP[]        = "help";
   
 static const char OPTION_REMOVE[]   = "remove";  
   
 static const char OPTION_START[]   = "start";  
  
 static const char OPTION_STOP[]   = "stop";  static const char LONG_VERSION[]     = "version";
  
 #if defined(PEGASUS_OS_HPUX)  static const char OPTION_DEBUGOUTPUT = 'X';
 static const char OPTION_BINDVERBOSE = 'X';  
 #endif  
   
 static const String PROPERTY_TIMEOUT = "shutdownTimeout";  
   
 ConfigManager*    configManager;  
  
 /** GetOptions function - This function defines the Options Table /** GetOptions function - This function defines the Options Table
     and sets up the options from that table using the config 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( void GetOptions(
     ConfigManager* cm,     ConfigManager* cm,
     int& argc,     int& argc,
     char** argv,     char** argv,
     const String& pegasusHome)      Boolean shutdownOption)
 {  
     try  
     {  
         cm->mergeConfigFiles();  
   
         cm->mergeCommandLine(argc, argv);  
     }  
     catch (NoSuchFile nsf)  
     {  
         throw nsf;  
     }  
     catch (FileNotReadable fnr)  
     {  
         throw fnr;  
     }  
     catch (CannotRenameFile ftrf)  
     {     {
         throw ftrf;      if (shutdownOption)
     }  
     catch (ConfigFileSyntaxError cfse)  
     {  
         throw cfse;  
     }  
     catch(UnrecognizedConfigProperty ucp)  
     {     {
         throw ucp;          cm->loadConfigFiles();
     }     }
     catch(InvalidPropertyValue ipv)      else
     {     {
         throw ipv;          cm->mergeConfigFiles();
     }     }
   
       // Temporarily disable updates to the current configuration
       // file if shutdownOption is true
       cm->useConfigFiles = (shutdownOption==false);
   
       cm->mergeCommandLine(argc, argv);
   
       // Enable updates again
       cm->useConfigFiles = true;
 } }
  
 /* PrintHelp - This is temporary until we expand the options manager to allow /* PrintHelp - This is temporary until we expand the options manager to allow
Line 209 
Line 282 
 */ */
 void PrintHelp(const char* arg0) void PrintHelp(const char* arg0)
 { {
     /**  
         Build the usage string for the config command.  
     */  
     String usage = String (USAGE);     String usage = String (USAGE);
     usage.append (COMMAND_NAME);     usage.append (COMMAND_NAME);
     usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");     usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");
     usage.append ("  options\n");     usage.append ("  options\n");
     usage.append ("    -v              - displays CIM Server version number\n");      usage.append("    -v, --version   - displays CIM Server version number\n");
     usage.append ("    -h              - prints this help message\n");      usage.append("    --status        - displays the running status of"
           " the CIM Server\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_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  #if !defined(PEGASUS_USE_RELEASE_DIRS)
     usage.append ("    -D [home]       - sets pegasus home directory\n");     usage.append ("    -D [home]       - sets pegasus home directory\n");
 #endif #endif
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
     usage.append ("    -install [name] - installs pegasus as a Windows NT Service\n");      usage.append("    -install [name] - installs pegasus as a Windows "
     usage.append ("                      [name] is optional and overrides the\n");          "Service\n");
       usage.append("                      [name] is optional and overrides "
           "the\n");
     usage.append ("                      default CIM Server Service Name\n");     usage.append ("                      default CIM Server Service Name\n");
     usage.append ("    -remove [name]  - removes pegasus as a Windows NT Service\n");      usage.append("                      by appending [name]\n");
     usage.append ("                      [name] is optional and overrides the\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 ("                      default CIM Server Service Name\n");
     usage.append ("    -start [name]   - starts pegasus as a Windows NT Service\n");      usage.append("                      by appending [name]\n");
     usage.append ("                      [name] is optional and overrides the\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 ("                      default CIM Server Service Name\n");
     usage.append ("    -stop [name]    - stops pegasus as a Windows NT Service\n");      usage.append("                      by appending [name]\n");
     usage.append ("                      [name] is optional and overrides the\n");      usage.append("    -stop [name]    - stops pegasus as a Windows Service\n");
     usage.append ("                      default CIM Server Service Name\n\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 #endif
     usage.append ("  configProperty=value\n");     usage.append ("  configProperty=value\n");
     usage.append ("                    - sets CIM Server configuration property\n");      usage.append("                    - sets CIM Server configuration "
           "property\n");
  
     cout << endl;     cout << endl;
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)      cout << _cimServerProcess->getProductName() << " " <<
     cout << PLATFORM_PRODUCT_NAME << " " << PLATFORM_PRODUCT_VERSION << endl;          _cimServerProcess->getCompleteVersion() << endl;
 #else  
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;  
 #endif  
     cout << endl;     cout << endl;
     cout << usage << endl;  
 }  
  
 //  #if defined(PEGASUS_OS_TYPE_WINDOWS)
 // cimserver_exit: platform specific exit routine calls      MessageLoaderParms parms("src.Server.cimserver.MENU.WINDOWS", usage);
 //  #elif defined(PEGASUS_USE_RELEASE_DIRS)
 void cimserver_exit( int rc ){      MessageLoaderParms parms(
 #ifdef PEGASUS_OS_OS400          "src.Server.cimserver.MENU.HPUXLINUXIA64GNU",
     cimserver_exitRC(rc);          usage);
   #else
       MessageLoaderParms parms("src.Server.cimserver.MENU.STANDARD", usage);
 #endif #endif
     exit(rc);      cout << MessageLoader::getMessage(parms) << endl;
 } }
  
 void shutdownCIMOM(Uint32 timeoutValue)  // This needs to be called at various points in the code depending on the
   // platform and error conditions.
   // We need to delete the _cimServer reference on exit in order for the
   // destructors to get called.
   void deleteCIMServer()
 { {
     //      delete _cimServer;
     // Create CIMClient object      _cimServer = 0;
     //  
     CIMClient client;  
   
     //  
     // Get local host name  
     //  
     String hostStr = System::getHostName();  
  
     //      if (dummyInitialThread)
     // open connection to CIMOM  
     //  
     try  
     {     {
         client.connectLocal();          Thread::clearLanguages();
           delete dummyInitialThread;
         //  
         // set client timeout to 2 seconds  
         //  
         client.setTimeout(2000);  
     }     }
     catch(Exception& e)      _serverRunStatus.setServerNotRunning();
     {  
 #ifdef PEGASUS_OS_OS400  
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                     "Unable to connect to CIM Server.  CIM Server may not be running." );  
         // The server job may still be active but not responding.  
         // Kill the job if it exists.  
         if(cimserver_kill() == -1)  
            cimserver_exit(2);  
         cimserver_exit(1);  
 #else  
         PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);  
         PEGASUS_STD(cerr) << "CIM Server may not be running." << PEGASUS_STD(endl);  
 #endif  
         cimserver_exit(0);  
     }     }
  
     try  
     {  
         //         //
         // construct CIMObjectPath  // Dummy function for the Thread object associated with the initial thread.
         //  // Since the initial thread is used to process CIM requests, this is
         String referenceStr = "//";  // needed to localize the exceptions thrown during CIM request processing.
         referenceStr.append(hostStr);  // Note: This function should never be called!
         referenceStr.append("/");  
         referenceStr.append(PEGASUS_NAMESPACENAME_SHUTDOWN.getString());  
         referenceStr.append(":");  
         referenceStr.append(PEGASUS_CLASSNAME_SHUTDOWN.getString());  
         CIMObjectPath reference(referenceStr);  
   
         //         //
         // issue the invokeMethod request on the shutdown method  ThreadReturnType PEGASUS_THREAD_CDECL dummyThreadFunc(void* parm)
         //  {
         Array<CIMParamValue> inParams;      return (ThreadReturnType)0;
         Array<CIMParamValue> outParams;  }
   
         // set force option to true for now  
         inParams.append(CIMParamValue("force",  
             CIMValue(Boolean(true))));  
  
         inParams.append(CIMParamValue("timeout",  #ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION
             CIMValue(Uint32(timeoutValue))));  
  
         CIMValue retValue = client.invokeMethod(  static int _extractExecutorSockOpt(int& argc, char**& argv)
             PEGASUS_NAMESPACENAME_SHUTDOWN,  
             reference,  
             "shutdown",  
             inParams,  
             outParams);  
     }  
     catch(CIMException& e)  
     {     {
 #ifdef PEGASUS_OS_OS400      // 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.
  
         if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)      int sock = -1;
         {      const char OPT[] = "--executor-socket";
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                     "Failed to shutdown server: $0", "The repository may be empty.");      for (int i = 1; i < argc; i++)
         }  
         else  
         {         {
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,          if (strcmp(argv[i], OPT) == 0)
                         "Failed to shutdown server: $0", e.getMessage());  
         }  
         // Kill the server job.  
         if(cimserver_kill() == -1)  
            cimserver_exit(2);  
 #else  
         PEGASUS_STD(cerr) << "Failed to shutdown server: ";  
         if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)  
         {         {
             PEGASUS_STD(cerr) << "The repository may be empty.";              // Check for missing option argument.
             PEGASUS_STD(cerr) << PEGASUS_STD(endl);  
         }              if (i + 1 == argc)
         else  
         {         {
             PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);                  MessageLoaderParms parms(
                       "src.Server.cimserver.MISSING_OPTION_ARGUMENT",
                       "Missing argument for $0 option.",
                       OPT);
                   cerr << argv[0] << ": " << MessageLoader::getMessage(parms) <<
                       endl;
                   exit(1);
         }         }
 #endif  
         cimserver_exit(1);  
  
     }              // Convert argument to positive integer.
     catch(Exception& e)  
     {              char* end;
         //              unsigned long x = strtoul(argv[i+1], &end, 10);
         // This may mean that the CIM Server has terminated, causing this  
         // client to get a "Empty HTTP response message" exception.  It may              // Check whether option argument will fit in a signed integer.
         // also mean that the CIM Server is taking longer than 2 seconds  
         // (client timeout value) to terminate, causing this client to              if (*end != '\0' || x > 2147483647)
         // timeout with a "connection timeout" exception.  
         //  
         // Check to see if CIM Server is still running.  If CIM Server  
         // is still running and the shutdown timeout has not expired,  
         // loop and wait one second until either the CIM Server is  
         // terminated or timeout expires.  If timeout expires and  
         // the CIM Server is still running, kill the CIMServer process.  
         //  
         Uint32 maxWaitTime = timeoutValue - 2;  
         Boolean running = isCIMServerRunning();  
         while ( running && maxWaitTime > 0 )  
         {         {
             System::sleep(1);                  MessageLoaderParms parms(
             running = isCIMServerRunning();                      "src.Server.cimserver.BAD_OPTION_ARGUMENT",
             maxWaitTime = maxWaitTime - 1;                      "Bad $0 option argument: $1.",
                       OPT,
                       argv[i+1]);
                   cerr << argv[0] << ": " << MessageLoader::getMessage(parms) <<
                       endl;
                   exit(1);
         }         }
  
         if (running)              sock = int(x);
         {  
             int kill_rc = cimserver_kill();  
 #ifdef PEGASUS_OS_OS400  
             if(kill_rc == -1)  
                 cimserver_exit(2);  
             cimserver_exit(1);  
 #endif  
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)              // Remove "-x <sock>" from argv-argc.
             if (kill_rc != -1)  
             {              memmove(argv + i, argv + i + 2, sizeof(char*) * (argc - i - 1));
                 cout << "Shutdown timeout expired.  CIM Server process killed." << endl;              argc -= 2;
                 exit(0);              break;
             }             }
 #endif  
         }         }
   
       if (sock == -1)
       {
           MessageLoaderParms parms(
               "src.Server.cimserver.MISSING_OPTION",
               "Missing $0 option.",
               OPT);
           cerr << argv[0] << ": " << MessageLoader::getMessage(parms) << endl;
           exit(1);
     }     }
  
     return;      return sock;
 } }
  
   #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));
   }
  
 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
 //  MAIN //  MAIN
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
   
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
     String pegasusHome  = String::EMPTY;      String pegasusHome;
     String logsDirectory = String::EMPTY;  
     Boolean useSLP = false;  
     Boolean daemonOption = false;  
     Boolean shutdownOption = false;     Boolean shutdownOption = false;
     Uint32 timeoutValue  = 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)
       initialize_zOS_timezone();
   #endif
  
 #ifdef PEGASUS_OS_OS400  #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)
     // Initialize Pegasus home to the shipped OS/400 directory.      setlocale(LC_ALL, "");
     pegasusHome = OS400_DEFAULT_PEGASUS_HOME;  
 #endif #endif
  
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
     //     //
     // Get environment variables:     // 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_OS_ZOS)
     const char* tmp = getenv("PEGASUS_HOME");     const char* tmp = getenv("PEGASUS_HOME");
  
     if (tmp)     if (tmp)
     {     {
         pegasusHome = tmp;         pegasusHome = tmp;
     }     }
   # endif
  
     FileSystem::translateSlashes(pegasusHome);     FileSystem::translateSlashes(pegasusHome);
 #else #else
  
   // windows only   // windows only
   setHome(pegasusHome);      //setHome(pegasusHome);
       pegasusHome = _cimServerProcess->getHome();
 #endif #endif
     // on Windows NT if there are no command-line options, run as a service  
  
     if (argc == 1 )  #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)
     {     {
       cim_server_service(argc, argv);          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);
     }     }
     else  
     {  #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; )
         {         {
             const char* arg = argv[i];             const char* arg = argv[i];
               if (strcmp(arg, "--help") == 0)
               {
                   PrintHelp(argv[0]);
                   Executor::daemonizeExecutor();
                   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)
               {
                   cout << _cimServerProcess->getCompleteVersion() << endl;
                   Executor::daemonizeExecutor();
                   exit(0);
               }
             // Check for -option             // Check for -option
             if (*arg == '-')              else if (*arg == '-')
             {             {
                 // Get the option                 // Get the option
                 const char* option = arg + 1;                 const char* option = arg + 1;
Line 472 
Line 579 
                 if (*option == OPTION_VERSION &&                 if (*option == OPTION_VERSION &&
                     strlen(option) == 1)                     strlen(option) == 1)
                 {                 {
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)                      cout << _cimServerProcess->getCompleteVersion() << endl;
                     cout << PLATFORM_PRODUCT_VERSION << endl;                      Executor::daemonizeExecutor();
 #else  
                     cout << PEGASUS_VERSION << endl;  
 #endif  
                     exit(0);                     exit(0);
                 }                 }
                 //                 //
Line 486 
Line 590 
                         (strlen(option) == 1))                         (strlen(option) == 1))
                 {                 {
                     PrintHelp(argv[0]);                     PrintHelp(argv[0]);
                       Executor::daemonizeExecutor();
                     exit(0);                     exit(0);
                 }                 }
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  #if !defined(PEGASUS_USE_RELEASE_DIRS)
                 else if (*option == OPTION_HOME &&                 else if (*option == OPTION_HOME &&
                         (strlen(option) == 1))                         (strlen(option) == 1))
                 {                 {
Line 498 
Line 603 
                     }                     }
                     else                     else
                     {                     {
                         cout << "Missing argument for option -" << option << endl;                          String opt(option);
                         exit(0);                          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*));                     memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
                     argc -= 2;                     argc -= 2;
                 }                 }
 #endif #endif
 #if defined(PEGASUS_OS_HPUX)  
                 //                 //
                 // Check to see if user asked for the version (-X option):                  // Check to see if user asked for debug output (-X option):
                 //                 //
                 if (*option == OPTION_BINDVERBOSE &&                  else if (*option == OPTION_DEBUGOUTPUT &&
                         (strlen(option) == 1))                         (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;                     System::bindVerbose = true;
                     cout << "Unsupported debug option, BIND_VERBOSE, enabled."  #endif
                          << endl;  
                     // remove the option from the command line                     // remove the option from the command line
                     memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));                     memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                     argc--;                     argc--;
                 }                 }
 #endif  
                 //                 //
                 // Check to see if user asked for shutdown (-s option):                 // Check to see if user asked for shutdown (-s option):
                 //                 //
Line 528 
Line 644 
                         (strlen(option) == 1))                         (strlen(option) == 1))
                 {                 {
                     //                     //
                     // check to see if user is root  
                     //  
 #ifndef PEGASUS_OS_OS400  
                     if (!System::isPrivilegedUser(System::getEffectiveUserName()))  
                     {  
                         cout << "You must have superuser privilege to run ";  
                         cout << "cimserver." << endl;  
                         exit(0);  
                     }  
 #endif  
   
                     //  
                     // Check to see if shutdown has already been specified:                     // Check to see if shutdown has already been specified:
                     //                     //
                     if (shutdownOption)                     if (shutdownOption)
                     {                     {
                         cout << "Duplicate shutdown option specified." << endl;                          MessageLoaderParms parms(
                         exit(0);                              "src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",
                               "Duplicate shutdown option specified.");
   
                           cout << MessageLoader::getMessage(parms) << endl;
                           exit(1);
                     }                     }
  
                     shutdownOption = true;                     shutdownOption = true;
Line 554 
Line 662 
                     memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));                     memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                     argc--;                     argc--;
                 }                 }
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
                 else if (strcmp(option, OPTION_INSTALL) == 0)  
                 {  
                   //  
                   // Install as a NT service  
                   //  
                   char *opt_arg = NULL;  
                   if (i+1 < argc)  
                   {  
                     opt_arg = argv[i+1];  
   
                   }  
                   if(cimserver_install_nt_service(opt_arg))  
                   {  
                       cout << "\nPegasus installed as NT Service";  
                       exit(0);  
                   }  
                   else                   else
                   {                      i++;
                       exit(0);  
                   }                   }
               else
                   i++;
                 }                 }
                 else if (strcmp(option, OPTION_REMOVE) == 0)  
                 {  
                   //                   //
                   // Remove Pegasus as an NT service      // Set the value for pegasusHome property
                   //                   //
                   char *opt_arg = NULL;      ConfigManager::setPegasusHome(pegasusHome);
                   if (i+1 < argc)  
                   {  
                     opt_arg = argv[i+1];  
                   }  
                   if(cimserver_remove_nt_service(opt_arg))  
                   {  
                       cout << "\nPegasus removed as NT Service";  
                       exit(0);  
                   }  
                   else  
                   {  
                       exit(0);  
                   }  
  
                 }  
                 else if (strcmp(option, OPTION_START) == 0)  
                 {  
                   //                   //
                   // Start as a NT service      // Do the platform specific run
                   //                   //
                   char *opt_arg = NULL;  
                   if (i+1 < argc)      return _cimServerProcess->platform_run(
                   {          argc, argv, shutdownOption, debugOutputOption);
                     opt_arg = argv[i+1];  
                   }  
                   if(cimserver_start_nt_service(opt_arg))  
                   {  
                       cout << "\nPegasus started as NT Service";  
                       exit(0);  
                   }                   }
                   else  
   void CIMServerProcess::cimserver_stop()
                   {                   {
                       exit(0);      _cimServer->shutdownSignal();
                   }  
                 }                 }
                 else if (strcmp(option, OPTION_STOP) == 0)  
                 {  
                   //                   //
                   // Stop as a NT service  // The main, common, running code
                   //                   //
                   char *opt_arg = NULL;  // NOTE: Do NOT call exit().  Use return(), otherwise some platforms
                   if (i+1 < argc)  // will fail to shutdown properly/cleanly.
                   {  //
                     opt_arg = argv[i+1];  // TODO: Current change minimal for platform "service" shutdown bug fixes.
                   }  // Perhaps further extract out common stuff and put into main(), put
                   if(cimserver_stop_nt_service(opt_arg))  // daemon stuff into platform specific platform_run(), etc.
                   {  // Note: make sure to not put error handling stuff that platform
                       cout << "\nPegasus stopped as NT Service";  // specific runs may need to deal with better (instead of exit(), etc).
                       exit(0);  //
                   }  
                   else  int CIMServerProcess::cimserver_run(
       int argc,
       char** argv,
       Boolean shutdownOption,
       Boolean debugOutputOption)
                   {                   {
                       exit(0);      Boolean daemonOption = false;
                   }  
                 }  #if defined (PEGASUS_OS_PASE) && !defined (PEGASUS_DEBUG)
 #endif      // PASE have itself regular for checking privileged user
                 else      if (!System::isPrivilegedUser("*CURRENT  "))
                     i++;      {
             }          MessageLoaderParms parms(
             else                  "src.Server.cimserver.NO_AUTHORITY.PEGASUS_OS_PASE",
                 i++;                  "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,
     // Set the value for pegasusHome property      // PASE run this job in background, any output in not allowed
     //      freopen("/dev/null", "r", stdin);
     ConfigManager::setPegasusHome(pegasusHome);      freopen("/dev/null", "w", stdout);
       freopen("/dev/null", "w", stderr);
   #endif
  
     //     //
     // Get an instance of the Config Manager.     // Get an instance of the Config Manager.
     //     //
     configManager = ConfigManager::getInstance();      ConfigManager* configManager = ConfigManager::getInstance();
       configManager->useConfigFiles = true;
  
       try
       {
     //     //
     // Get options (from command line and from configuration file); this     // Get options (from command line and from configuration file); this
     // removes corresponding options and their arguments from the command     // removes corresponding options and their arguments from the command
     // line.          // line.  NOTE: If shutdownOption=true, the contents of current config
           // file are not overwritten by the planned config file.
     //     //
     try          GetOptions(configManager, argc, argv, shutdownOption);
     {  
         GetOptions(configManager, argc, argv, pegasusHome);          //
     }          // Initialize the message home directory in the MessageLoader.
     catch (Exception& e)          // This is the default directory where the resource bundles are found.
     {          //
 #ifdef PEGASUS_OS_OS400          MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,              ConfigManager::getInstance()->getCurrentValue("messageDir")));
                         "$0: $1",argv[0] ,e.getMessage());  
 #else  #if !defined(PEGASUS_USE_SYSLOGS)
         cerr << argv[0] << ": " << e.getMessage() << endl;          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 #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);         exit(1);
     }     }
  
     Boolean enableHttpConnection = String::equal(          char fullJobName[29];
         configManager->getCurrentValue("enableHttpConnection"), "true");          umeGetJobName(fullJobName, true);
     Boolean enableHttpsConnection = String::equal(          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
         configManager->getCurrentValue("enableHttpsConnection"), "true");                  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     // Make sure at least one connection is enabled
 #ifndef PEGASUS_LOCAL_DOMAIN_SOCKET  
           Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
               configManager->getCurrentValue("enableHttpConnection"));
           Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
               configManager->getCurrentValue("enableHttpsConnection"));
   
     if (!enableHttpConnection && !enableHttpsConnection)     if (!enableHttpConnection && !enableHttpsConnection)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,              MessageLoaderParms parms(
                   "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.");
         cerr << "Neither HTTP nor HTTPS connection is enabled.  "              Logger::put_l(
             "CIMServer will not be started." << endl;                  Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
         exit(1);                  parms);
               cerr << MessageLoader::getMessage(parms) << endl;
               return 1;
     }     }
 #endif #endif
  
     try  
     {  
         //         //
         // Check to see if we should Pegasus as a daemon          // Check to see if we should start Pegasus as a daemon
         //         //
           daemonOption = ConfigManager::parseBooleanValue(
               configManager->getCurrentValue("daemon"));
  
         if (String::equal(configManager->getCurrentValue("daemon"), "true"))          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;             daemonOption = true;
         }         }
  
         // Get the log file directory definition.  
         // We put String into Cstring because  
         // Directory functions only handle Cstring.  
         // ATTN-KS: create String based directory functions.  
   
         logsDirectory = configManager->getCurrentValue("logdir");  
         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.  
   
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \  
 !defined(PEGASUS_OS_OS400)  
         Logger::setHomeDirectory(logsDirectory);  
 #endif  
   
         //         //
         // Check to see if we need to shutdown CIMOM         // Check to see if we need to shutdown CIMOM
         //         //
Line 730 
Line 847 
         {         {
             String configTimeout =             String configTimeout =
                 configManager->getCurrentValue("shutdownTimeout");                 configManager->getCurrentValue("shutdownTimeout");
             timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);              Uint32 timeoutValue =
                   strtol(configTimeout.getCString(), (char **)0, 10);
  
             shutdownCIMOM(timeoutValue);              ServerShutdownClient serverShutdownClient(&_serverRunStatus);
               serverShutdownClient.shutdown(timeoutValue);
  
 #ifdef PEGASUS_OS_OS400              MessageLoaderParms parms(
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,                  "src.Server.cimserver.SERVER_STOPPED",
                         "CIM Server stopped.");                         "CIM Server stopped.");
 #else  
             cout << "CIM Server stopped." << endl;              cout << MessageLoader::getMessage(parms) << endl;
 #endif              return 0;
             cimserver_exit(0);  
         }         }
  
   #if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS)
         // Leave this in until people get familiar with the logs.         // Leave this in until people get familiar with the logs.
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \          MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",
 !defined(PEGASUS_OS_OS400)                                   "Logs Directory = ");
         cout << "Logs Directory = " << logsDirectory << endl;          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 #endif
  
         if (String::equal(configManager->getCurrentValue("slp"), "true"))  #if defined(PEGASUS_DEBUG)
       // Put out startup up message.
       cout << _cimServerProcess->getProductName() << " " <<
           _cimServerProcess->getCompleteVersion() << endl;
   #endif
   
       // 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)
         {         {
             useSLP =  true;          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 (UnrecognizedConfigProperty e)      catch (InvalidAcceptLanguageHeader& e)
     {     {
           Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
 #ifdef PEGASUS_OS_OS400              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,         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                     "Error: $0",e.getMessage());              e.getMessage());
 #else  
         cout << "Error: " << e.getMessage() << endl;  
 #endif  
     }     }
  
     Uint32 portNumberHttps;  #ifndef PEGASUS_OS_TYPE_WINDOWS
     Uint32 portNumberHttp;      umask(S_IRWXG|S_IRWXO);
   #endif
  
     if (enableHttpsConnection)      // Start up the CIM Server
     {  
         String httpsPort = configManager->getCurrentValue("httpsPort");  
         CString portString = httpsPort.getCString();  
         char* end = 0;  
         Uint32 port = strtol(portString, &end, 10);  
         assert(end != 0 && *end == '\0');  
  
       try
       {
   #if defined(PEGASUS_OS_TYPE_UNIX)
         //         //
         // Look up the WBEM-HTTPS port number          // 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.
         //         //
         portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, port);          CString startupLockFileName = ConfigManager::getHomedPath(
     }              PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();
  
     if (enableHttpConnection)          // Make sure the start-up lock file exists
           FILE* startupLockFile;
           if ((startupLockFile = fopen(startupLockFileName, "w")) != 0)
     {     {
         String httpPort = configManager->getCurrentValue("httpPort");              fclose(startupLockFile);
         CString portString = httpPort.getCString();          }
         char* end = 0;  
         Uint32 port = strtol(portString, &end, 10);  
         assert(end != 0 && *end == '\0');  
  
           AutoFileLock fileLock(startupLockFileName);
   #endif
   
   #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
         //         //
         // Look up the WBEM-HTTP port number          // 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
         //         //
         portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME, port);          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);
     }     }
  
     // Put out startup up message.              return 1;
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \          }
 !defined(PEGASUS_OS_OS400)  
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;          //
     cout << "Built " << __DATE__ << " " << __TIME__ << endl;          // Declare ourselves as the running CIM Server process, and write our
     cout <<"Starting..."          // PID to the PID file.
          << (useSLP ? " SLP reg. " : " No SLP ")          //
         << endl;          _serverRunStatus.setServerRunning();
 #endif #endif
  
     // do we need to run as a daemon ?          // Create and initialize the CIMServer object
     if (daemonOption)  
     {          _cimServer = new CIMServer();
         if(-1 == cimserver_fork())  
 #ifndef PEGASUS_OS_OS400          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)
         {         {
             exit(-1);              MessageLoaderParms parms(
                   "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
                   "Neither HTTP nor HTTPS connection is enabled.");
               throw Exception(parms);
         }         }
 #else  #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())
         {         {
             return(-1);              addIP6Acceptor = true;
         }         }
         else         else
         {         {
             return(0);              PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4,
                   "IPv6 stack is not active, using IPv4 socket.");
         }         }
 #endif #endif
           if (!addIP6Acceptor)
     }  
   
 #ifdef PEGASUS_OS_OS400  
     // Special server initialization code for OS/400.  
     if (cimserver_initialize() != 0)  
     {     {
         // do some logging here!              addIP4Acceptor = true;
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                     "CIM Server failed to initialize");  
         exit(-1);  
     }     }
 #endif  
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)          // The server HTTP and HTTPS ports are determined via this algorithm:
     umask(S_IWGRP|S_IWOTH);          // 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)
               {
     //     //
     // check if CIMServer is already running                  // Look up the WBEM-HTTP port number
     // if CIMServer is already running, print message and  
     // notify parent process (if there is a parent process) to terminate  
     //     //
     if(isCIMServerRunning())                  portNumberHttp = System::lookupPort(
                       WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);
                   _initConfigProperty("httpPort", portNumberHttp);
               }
               else
     {     {
         cout << "Unable to start CIMServer." << endl;  
         cout << "CIMServer is already running." << endl;  
   
         //         //
         // notify parent process (if there is a parent process) to terminate                  // user-specified
         //         //
         if (daemonOption)                  CString portString = httpPort.getCString();
                 notify_parent();                  char* end = 0;
                   portNumberHttp = strtol(portString, &end, 10);
         exit(1);                  if (!(end != 0 && *end == '\0'))
                   {
                       throw InvalidPropertyValue("httpPort", httpPort);
                   }
     }     }
  
 #endif              if (addIP6Acceptor)
               {
     // try loop to bind the address, and run the server                  _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
     try                      portNumberHttp, false);
               }
               if (addIP4Acceptor)
     {     {
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)                  _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
         char slp_address[32];                      portNumberHttp, false);
         slp_client *discovery = new slp_client() ;;              }
         String serviceURL;              // The port number is converted to a string to avoid the
         serviceURL.assign("service:cim.pegasus://");              //  addition of localized characters (e.g., "5,988").
         String host_name = slp_get_host_name();              char scratchBuffer[22];
         serviceURL.append(host_name);              Uint32 n;
         serviceURL.append(":");              const char * portNumberHttpStr = Uint32ToString(
         // ATTN: Fix this to work for multiple connections                  scratchBuffer, portNumberHttp, n);
         sprintf(slp_address, "%u",              MessageLoaderParms parms(
                 enableHttpConnection ? portNumberHttp : portNumberHttps);                  "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
         serviceURL.append(slp_address);                  "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 #endif
           }
  
         Monitor monitor(true);          if (enableHttpsConnection)
         CIMServer server(&monitor);  
   
         if (enableHttpConnection)  
         {         {
             server.addAcceptor(false, portNumberHttp, false);              Uint32 portNumberHttps = 0;
             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              String httpsPort = configManager->getCurrentValue("httpsPort");
                         "Listening on HTTP port $0.", portNumberHttp);              if (httpsPort == String::EMPTY)
               {
                   //
                   // Look up the WBEM-HTTPS port number
                   //
                   portNumberHttps = System::lookupPort(
                       WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);
                   _initConfigProperty("httpsPort", portNumberHttps);
         }         }
         if (enableHttpsConnection)              else
         {         {
             server.addAcceptor(false, portNumberHttps, true);                  //
             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                  // user-specified
                         "Listening on HTTPS port $0.", portNumberHttps);                  //
         }                  CString portString = httpsPort.getCString();
 #ifdef PEGASUS_LOCAL_DOMAIN_SOCKET                  char* end = 0;
         server.addAcceptor(true, 0, false);                  portNumberHttps = strtol(portString, &end, 10);
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                  if (!(end != 0 && *end == '\0'))
                     "Listening on local connection socket.");  
 #endif  
   
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && !defined(PEGASUS_OS_OS400)  
         if (enableHttpConnection)  
         {         {
             cout << "Listening on HTTP port " << portNumberHttp << endl;                      throw InvalidPropertyValue("httpsPort", httpsPort);
         }         }
         if (enableHttpsConnection)              }
               if (addIP6Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
                       portNumberHttps, true);
               }
               if (addIP4Acceptor)
         {         {
             cout << "Listening on HTTPS port " << portNumberHttps << endl;                  _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                       portNumberHttps, true);
         }         }
 # ifdef PEGASUS_LOCAL_DOMAIN_SOCKET              // The port number is converted to a string to avoid the
         cout << "Listening on local connection socket" << endl;              //  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 # 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 #endif
  
         // bind throws an exception if the bind fails          _cimServer->bind();
         server.bind();  
  
         // notify parent process (if there is a parent process) to terminate         // notify parent process (if there is a parent process) to terminate
         // so user knows that cimserver is ready to serve CIM requests.          // so user knows that there is cimserver ready to serve CIM requests.
         if (daemonOption)         if (daemonOption)
                 notify_parent();          {
               _cimServerProcess->notify_parent(0);
           }
   
   #if defined(PEGASUS_DEBUG)
           cout << "Started. " << endl;
   #endif
  
         time_t last = 0;          // 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();
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  
         //         //
         // create a file to indicate that the cimserver has started and          // notify parent process (if there is a parent process) to terminate
         // save the process id of the cimserver process in the file  
         //         //
         // remove the old file if it exists          if (daemonOption)
         System::removeFile(CIMSERVER_START_FILE);              _cimServerProcess->notify_parent(1);
  
         // open the file          return 1;
         FILE *pid_file = fopen(CIMSERVER_START_FILE, "w");      }
  
         if (pid_file)      // Run the main CIM Server loop
   
       try
         {         {
             // save the pid in the file  #if defined(PEGASUS_OS_ZOS)
             fprintf(pid_file, "%ld\n", (long)server_pid);  
             fclose(pid_file);  
         }  
 #endif  
  
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \          // ARM is a z/OS internal restart facility.
 !defined(PEGASUS_OS_OS400)          // This is a z/OS specific change.
         cout << "Started. " << endl;  
 #endif          // Instatiating the automatic restart manager for zOS
           ARM_zOS automaticRestartManager;
   
           // register to zOS ARM
           automaticRestartManager.Register();
  
         // Put server started message to the logger  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                     "Started $0 version $1.",  
                     PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);  
 #else  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                     "Started $0 version $1.",  
                     PEGASUS_NAME, PEGASUS_VERSION);  
 #endif #endif
  
   #ifdef PEGASUS_ENABLE_SLP
           _cimServer->startSLPProvider();
   #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
         //         //
         while( !server.terminated() )          while (!_cimServer->terminated())
         {         {
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)              _cimServer->runForever();
           if(useSLP  )  
           {  
             if(  (time(NULL) - last ) > 60 )  
             {  
               if( discovery != NULL && serviceURL.size() )  
                 discovery->srv_reg_all(serviceURL.getCString(),  
                                        "(namespace=root/cimv2)",  
                                        "service:cim.pegasus",  
                                        "DEFAULT",  
                                        70) ;  
               time(&last);  
             }  
   
             discovery->service_listener();  
           }  
 #endif  
           server.runForever();  
         }         }
  
         //         //
         // normal termination         // normal termination
         //         //
         // Put server shutdown message to the logger  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
             "$0 stopped.", PLATFORM_PRODUCT_NAME);  
 #else  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
             "$0 stopped.", PEGASUS_NAME);  
 #endif  
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
         //  
         // close the file created at startup time to indicate that the          // ARM is a z/OS internal restart facility.
         // cimserver has terminated normally.          // This is a z/OS specific change.
         //  
         FileSystem::removeFile(CIMSERVER_START_FILE);          // register to zOS ARM
           automaticRestartManager.DeRegister();
   
 #endif #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)     catch(Exception& e)
     {     {
 #ifdef PEGASUS_OS_OS400          MessageLoaderParms parms(
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,              "src.Server.cimserver.ERROR",
                     "Error: $0", e.getMessage());              "Error: $0",
 #else              e.getMessage());
         PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
 #endif              parms);
           cerr << MessageLoader::getMessage(parms) << endl;
         //  
         // notify parent process (if there is a parent process) to terminate  
         //  
         if (daemonOption)  
                 notify_parent();  
  
           deleteCIMServer();
         return 1;         return 1;
     }     }
  
       deleteCIMServer();
     return 0;     return 0;
 } }


Legend:
Removed from v.1.93  
changed lines
  Added in v.1.239

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2