(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.104 and 1.181

version 1.104, 2003/09/08 14:50:34 version 1.181, 2006/02/08 23:00:22
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 24 
Line 32 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: Mike Day (mdday@us.ibm.com) // Modified By: Mike Day (mdday@us.ibm.com)
 //  //              Karl Schopmeyer (k.schopmeyer@opengroup.org)
 // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)  //              Nag Boranna (nagaraja_boranna@hp.com)
 //  //              Jenny Yu (jenny_yu@hp.com)
 // Modified By: Nag Boranna (nagaraja_boranna@hp.com)  //              Sushma Fernandes (sushma_fernandes@hp.com)
 //  
 // Modified By: Jenny Yu (jenny_yu@hp.com)  
 //  
 // Modified By: Sushma Fernandes (sushma_fernandes@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                (carolann_graves@hp.com) //                (carolann_graves@hp.com)
 //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
 //  //              Dave Rosckes (rosckes@us.ibm.com)
 // Modified By: Dave Rosckes (rosckes@us.ibm.com)  //              Humberto Rivero (hurivero@us.ibm.com)
 //  //              Steve Hills (steve.hills@ncr.com)
 // Modified By: Humberto Rivero (hurivero@us.ibm.com)  //              Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
   //              Amit K Arora, IBM (amitarora@in.ibm.com) - pep 167
   //              Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) - Bug#2555
   //              Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) - Bug#2032
   //              Heather Sterling, IBM (hsterl@us.ibm.com) - PEP#222
   //              Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) - Bug#3452
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
   //              Aruran, IBM (ashanmug@in.ibm.com) for Bug# 4183
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
  
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
 // //
 // 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 75 
Line 87 
 // 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"
Line 90 
Line 106 
  
 #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 <cstdlib>
 #include <fstream>  
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Monitor.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/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/ShutdownService.h>
 #include <Pegasus/Common/Destroyer.h>  #include <Pegasus/Server/CIMServer.h>
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)  #include <Service/ServerProcess.h>
 #include <slp/slp.h>  
 #endif  
   
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS)  
 # include "cimserver_windows.cpp"  
 #elif defined(PEGASUS_OS_TYPE_UNIX)  
 # if defined(PEGASUS_OS_OS400) # if defined(PEGASUS_OS_OS400)
   #  include "vfyptrs.cinc"
 #  include "OS400ConvertChar.h" #  include "OS400ConvertChar.h"
 #  include "cimserver_os400.cpp"  
 # else  
 #  include "cimserver_unix.cpp"  
 #endif #endif
   
   #if defined(PEGASUS_OS_TYPE_UNIX)
   # if defined(PEGASUS_OS_OS400)
   #  include <unistd.cleinc>
 #else #else
 # error "Unsupported platform"  #  include <unistd.h>
   # endif
   # include <sys/types.h>
   # include <sys/stat.h>
   # include <fcntl.h>
 #endif #endif
  
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
   #define PEGASUS_PROCESS_NAME "cimserver";
   
   //Windows service variables are not defined elsewhere in the product
   //enable ability to override these
   #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
   
   class CIMServerProcess : public ServerProcess
   {
   public:
   
       CIMServerProcess(void)
       {
           cimserver_set_process(this);
       }
   
       virtual ~CIMServerProcess(void)
       {
       }
   
       //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;
       }
   
       //defined in ConfigFileDir.h
       virtual const char* getPIDFileName() const
       {
           return CIMSERVER_START_FILE;
       }
   
       int cimserver_run(
           int argc,
           char** argv,
           Boolean shutdownOption,
           Boolean debugOutputOption);
   
       void cimserver_stop(void);
   };
   
   AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess());
   static CIMServer* _cimServer = 0;
   static Monitor* _monitor = 0;
   static Thread* dummyInitialThread = 0;
 // //
 //  The command name. //  The command name.
 // //
Line 147 
Line 240 
  
 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   LONG_VERSION []  = "version";
  
 static const char OPTION_START[]   = "start";  static const char OPTION_DEBUGOUTPUT = 'X';
   
 static const char OPTION_STOP[]   = "stop";  
   
 #if defined(PEGASUS_OS_HPUX)  
 static const char OPTION_BINDVERBOSE = 'X';  
 #endif  
  
 static const String PROPERTY_TIMEOUT = "shutdownTimeout"; static const String PROPERTY_TIMEOUT = "shutdownTimeout";
  
Line 169 
Line 256 
 void GetOptions( void GetOptions(
     ConfigManager* cm,     ConfigManager* cm,
     int& argc,     int& argc,
     char** argv,      char** argv)
     const String& pegasusHome)  
 { {
     try     try
     {     {
Line 178 
Line 264 
  
         cm->mergeCommandLine(argc, argv);         cm->mergeCommandLine(argc, argv);
     }     }
     catch (NoSuchFile nsf)      catch (NoSuchFile&)
     {     {
         throw nsf;          throw;
     }     }
     catch (FileNotReadable fnr)      catch (FileNotReadable&)
     {     {
         throw fnr;          throw;
     }     }
     catch (CannotRenameFile ftrf)      catch (CannotRenameFile&)
     {     {
         throw ftrf;          throw;
     }     }
     catch (ConfigFileSyntaxError cfse)      catch (ConfigFileSyntaxError&)
     {     {
         throw cfse;          throw;
     }     }
     catch(UnrecognizedConfigProperty ucp)      catch(UnrecognizedConfigProperty&)
     {     {
         throw ucp;          throw;
     }     }
     catch(InvalidPropertyValue ipv)      catch(InvalidPropertyValue&)
     {     {
         throw ipv;          throw;
       }
       catch (CannotOpenFile&)
       {
           throw;
     }     }
 } }
  
Line 210 
Line 300 
 */ */
 void PrintHelp(const char* arg0) void PrintHelp(const char* arg0)
 { {
     /**  
         Build the usage string for the config command.  
     */  
     /* l10n  
     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 ("    -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 Service\n");
     usage.append ("                      [name] is optional and overrides the\n");  
     usage.append ("                      default CIM Server Service Name\n");  
     usage.append ("    -remove [name]  - removes pegasus as a Windows NT Service\n");  
     usage.append ("                      [name] is optional and overrides the\n");  
     usage.append ("                      default CIM Server Service Name\n");  
     usage.append ("    -start [name]   - starts pegasus as a Windows NT Service\n");  
     usage.append ("                      [name] is optional and overrides the\n");  
     usage.append ("                      default CIM Server Service Name\n");  
     usage.append ("    -stop [name]    - stops pegasus as a Windows NT Service\n");  
     usage.append ("                      [name] is optional and overrides the\n");  
     usage.append ("                      default CIM Server Service Name\n\n");  
 #endif  
     usage.append ("  configProperty=value\n");  
     usage.append ("                    - sets CIM Server configuration property\n");  
   
     cout << endl;  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  
     cout << PLATFORM_PRODUCT_NAME << " " << PLATFORM_PRODUCT_VERSION << endl;  
 #else  
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;  
 #endif  
     cout << endl;  
     cout << usage << endl;  
     */  
   
     String usage = String (USAGE);  
     usage.append (COMMAND_NAME);  
     usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");  
     usage.append ("  options\n");  
     usage.append ("    -v              - displays CIM Server version number\n");  
     usage.append ("    -h              - prints this help message\n");  
     usage.append ("    -s              - shuts down CIM Server\n");  
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  
     //usage.append ("    -D [home]       - sets pegasus home directory\n");  
     usage.append("$0");  
 #endif  
 #if defined(PEGASUS_OS_TYPE_WINDOWS)  
     usage.append ("    -install [name] - installs pegasus as a Windows NT Service\n");  
     usage.append ("                      [name] is optional and overrides the\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 ("    -remove [name]  - removes pegasus as a Windows Service\n");
     usage.append ("                      [name] is optional and overrides the\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 ("    -start [name]   - starts pegasus as a Windows Service\n");
     usage.append ("                      [name] is optional and overrides the\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 ("    -stop [name]    - stops pegasus as a Windows Service\n");
     usage.append ("                      [name] is optional and overrides the\n");     usage.append ("                      [name] is optional and overrides the\n");
     usage.append ("                      default CIM Server Service Name\n\n");     usage.append ("                      default CIM Server Service Name\n\n");
 #endif #endif
Line 280 
Line 328 
     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() << " " << _cimServerProcess->getCompleteVersion() << endl;
     cout << PLATFORM_PRODUCT_NAME << " " << PLATFORM_PRODUCT_VERSION << endl;  
 #else  
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;  
 #endif  
     cout << endl;     cout << endl;
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
     MessageLoaderParms parms("src.Server.cimserver.MENU.WINDOWS", usage);     MessageLoaderParms parms("src.Server.cimserver.MENU.WINDOWS", usage);
 #elif defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)  #elif defined(PEGASUS_USE_RELEASE_DIRS)
         MessageLoaderParms parms("src.Server.cimserver.MENU.HPUXLINUXIA64GNU", usage);         MessageLoaderParms parms("src.Server.cimserver.MENU.HPUXLINUXIA64GNU", usage);
 #else #else
         MessageLoaderParms parms("src.Server.cimserver.MENU.STANDARD", usage);         MessageLoaderParms parms("src.Server.cimserver.MENU.STANDARD", usage);
 #endif #endif
     //cout << usage << endl;  
     cout << MessageLoader::getMessage(parms) << endl;     cout << MessageLoader::getMessage(parms) << endl;
 } }
  
   //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()
   {
       if (_cimServer)
       {
           delete _cimServer;
           _cimServer = 0;
   
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) \
   || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \
   || defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS)
           //
           //  Remove the PID file to indicate CIMServer termination
           //
           FileSystem::removeFile(_cimServerProcess->getPIDFileName());
   #endif
       }
      if (_monitor)
      {
           delete _monitor;
      }
      if (dummyInitialThread)
      {
           Thread::clearLanguages();
           delete dummyInitialThread;
      }
   }
   
 // l10n // l10n
 // //
 // Dummy function for the Thread object associated with the initial thread. // Dummy function for the Thread object associated with the initial thread.
Line 311 
Line 383 
 } }
  
 // //
 // cimserver_exit: platform specific exit routine calls  //  Waits until either the CIM Server has terminated, or the shutdown timeout
   //  has expired.  If the shutdown timeout has expired, and the CIM Server is
   //  still running, kills the cimserver process.
 // //
 void cimserver_exit( int rc ){  void _waitForTerminationOrTimeout (Uint32 maxWaitTime)
   {
       //
       //  If the CIM Server is still running, and the shutdown timeout has not
       //  expired, loop and wait one second until either the CIM Server has
       //  terminated, or the shutdown timeout has expired
       //
       Boolean running = _cimServerProcess->isCIMServerRunning ();
       while (running && (maxWaitTime > 0))
       {
           System::sleep (1);
           running = _cimServerProcess->isCIMServerRunning ();
           maxWaitTime--;
       }
   
       //
       //  If the shutdown timeout has expired, and the CIM Server is still
       //  running, kill the cimserver process
       //
       if (running)
       {
           int kill_rc = _cimServerProcess->cimserver_kill (0);
   
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
     cimserver_exitRC(rc);          if (kill_rc == -1)
           {
               _cimServerProcess->cimserver_exitRC (2);
           }
           _cimServerProcess->cimserver_exitRC (1);
 #endif #endif
     exit(rc);  
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \
   || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_SOLARIS) \
   || defined (PEGASUS_OS_VMS)
           if (kill_rc != -1)
           {
               //l10n - TODO
               Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",
                   "Shutdown timeout expired.  Forced shutdown initiated.");
               MessageLoaderParms parms
                   ("src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",
                   "Shutdown timeout expired.  Forced shutdown initiated.");
               cout << MessageLoader::getMessage(parms) << endl;
               exit (0);
           }
   #endif
       }
 } }
  
 void shutdownCIMOM(Uint32 timeoutValue) void shutdownCIMOM(Uint32 timeoutValue)
Line 344 
Line 461 
         //         //
         client.setTimeout(2000);         client.setTimeout(2000);
     }     }
     catch(Exception& e)      catch(Exception&)
     {     {
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
         //l10n         //l10n
Line 355 
Line 472 
                     "Unable to connect to CIM Server.  CIM Server may not be running." );                     "Unable to connect to CIM Server.  CIM Server may not be running." );
         // The server job may still be active but not responding.         // The server job may still be active but not responding.
         // Kill the job if it exists.         // Kill the job if it exists.
         if(cimserver_kill() == -1)      if(_cimServerProcess->cimserver_kill(0) == -1)
            cimserver_exit(2);         _cimServerProcess->cimserver_exitRC(2);
         cimserver_exit(1);      _cimServerProcess->cimserver_exitRC(1);
 #else #else
         //l10n         //l10n
         //PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);         //PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);
Line 365 
Line 482 
         MessageLoaderParms parms("src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",         MessageLoaderParms parms("src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",
                                                          "Unable to connect to CIM Server.\nCIM Server may not be running.\n");                                                          "Unable to connect to CIM Server.\nCIM Server may not be running.\n");
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);
           exit(1);
 #endif #endif
         cimserver_exit(1);  
     }     }
  
     try     try
Line 413 
Line 530 
                     //"Failed to shutdown server: $0", "The repository may be empty.");                     //"Failed to shutdown server: $0", "The repository may be empty.");
                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                         "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",                         "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",
                     "Failed to shutdown server: The repository may be empty.");              "Error in server shutdown: The repository may be empty.");
         }         }
         else         else
         {         {
Line 422 
Line 539 
                         //"Failed to shutdown server: $0", e.getMessage());                         //"Failed to shutdown server: $0", e.getMessage());
                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                         "src.Server.cimserver.SHUTDOWN_FAILED",                         "src.Server.cimserver.SHUTDOWN_FAILED",
                         "Failed to shutdown server: $0", e.getMessage());              "Error in server shutdown: $0", e.getMessage());
         }         }
         // Kill the server job.         // Kill the server job.
         if(cimserver_kill() == -1)      if(_cimServerProcess->cimserver_kill(0) == -1)
            cimserver_exit(2);         _cimServerProcess->cimserver_exitRC(2);
 #else #else
         //l10n          //l10n - TODO
         //PEGASUS_STD(cerr) << "Failed to shutdown server: ";  
         MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",         MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",
                                                          "Failed to shutdown server: ");                                   "Error in server shutdown: ");
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);
         if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)         if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)
         {         {
             //PEGASUS_STD(cerr) << "The repository may be empty.";              //
             //PEGASUS_STD(cerr) << PEGASUS_STD(endl);              // Repository may be empty.
               //
               //l10n - TODO
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",
                   "Error in server shutdown: The repository may be empty.");
             MessageLoaderParms parms("src.Server.cimserver.REPOSITORY_EMPTY",             MessageLoaderParms parms("src.Server.cimserver.REPOSITORY_EMPTY",
                                                                  "The repository may be empty.");                                                                  "The repository may be empty.");
                 PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);                 PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
         }         }
         else         else
         {         {
               //l10n - TODO
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.SHUTDOWN_FAILED",
                   "Error in server shutdown: $0", e.getMessage());
             PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);             PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);
         }         }
 #endif  
         cimserver_exit(1);  
  
       // Kill the cimserver process
       if (_cimServerProcess->cimserver_kill(0) == 0)
           {
               //l10n - TODO
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.SERVER_FORCED_SHUTDOWN",
               "Forced shutdown initiated.");
               MessageLoaderParms parms("src.Server.cimserver.SERVER_FORCED_SHUTDOWN",
                                        "Forced shutdown initiated.");
               PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
     }     }
     catch(Exception& e)          exit(1);
   #endif
       }
       catch(Exception&)
     {     {
         //         //
         // This may mean that the CIM Server has terminated, causing this         // This may mean that the CIM Server has terminated, causing this
Line 458 
Line 594 
         // (client timeout value) to terminate, causing this client to         // (client timeout value) to terminate, causing this client to
         // timeout with a "connection timeout" exception.         // timeout with a "connection timeout" exception.
         //         //
         // Check to see if CIM Server is still running.  If CIM Server          //  Wait until either the CIM Server has terminated, or the shutdown
         // is still running and the shutdown timeout has not expired,          //  timeout has expired.  If the timeout has expired and the CIM Server
         // loop and wait one second until either the CIM Server is          //  is still running, kill the cimserver process.
         // terminated or timeout expires.  If timeout expires and          //
         // the CIM Server is still running, kill the CIMServer process.          _waitForTerminationOrTimeout (timeoutValue - 2);
         //  
         Uint32 maxWaitTime = timeoutValue - 2;  
         Boolean running = isCIMServerRunning();  
         while ( running && maxWaitTime > 0 )  
         {  
             System::sleep(1);  
             running = isCIMServerRunning();  
             maxWaitTime = maxWaitTime - 1;  
         }  
   
         if (running)  
         {  
             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)  
             if (kill_rc != -1)  
             {  
                 //l10n  
                 //cout << "Shutdown timeout expired.  CIM Server process killed." << endl;  
                 MessageLoaderParms parms("src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",  
                                                                  "Shutdown timeout expired.  CIM Server process killed.");  
                 cout << MessageLoader::getMessage(parms) << endl;  
                 exit(0);  
             }  
 #endif  
         }  
     }     }
  
       //
       //  InvokeMethod succeeded.
       //  Wait until either the CIM Server has terminated, or the shutdown
       //  timeout has expired.  If the timeout has expired and the CIM Server
       //  is still running, kill the cimserver process.
       //
       _waitForTerminationOrTimeout (timeoutValue);
     return;     return;
 } }
  
Line 506 
Line 618 
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
     String pegasusHome  = String::EMPTY;     String pegasusHome  = String::EMPTY;
     String logsDirectory = String::EMPTY;  
     Boolean useSLP = false;  
     Boolean daemonOption = false;  
     Boolean shutdownOption = false;     Boolean shutdownOption = false;
     Uint32 timeoutValue  = 0;      Boolean debugOutputOption = false;
  
 //l10n //l10n
 // Set Message loading to process locale // Set Message loading to process locale
 MessageLoader::_useProcessLocale = true; MessageLoader::_useProcessLocale = true;
 //l10n //l10n
  
   //l10n
   #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)
   setlocale(LC_ALL, "");
   #endif
   
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
   
     VFYPTRS_INCDCL;               // VFYPTRS local variables
   
     // verify pointers
     #pragma exception_handler (qsyvp_excp_hndlr,qsyvp_excp_comm_area,\
       0,_C2_MH_ESCAPE)
       for( int arg_index = 1; arg_index < argc; arg_index++ ){
       VFYPTRS(VERIFY_SPP_NULL(argv[arg_index]));
       }
     #pragma disable_handler
   
     // Convert the args to ASCII     // Convert the args to ASCII
     for(Uint32 i = 0;i< argc;++i)     for(Uint32 i = 0;i< argc;++i)
     {     {
Line 528 
Line 653 
     pegasusHome = OS400_DEFAULT_PEGASUS_HOME;     pegasusHome = OS400_DEFAULT_PEGASUS_HOME;
 #endif #endif
  
   
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
     //     //
     // Get environment variables:     // Get environment variables:
Line 544 
Line 670 
         pegasusHome = home;         pegasusHome = home;
     }     }
 #else #else
     #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_USE_RELEASE_DIRS)
       pegasusHome = AIX_RELEASE_PEGASUS_HOME;
     #elif !defined(PEGASUS_USE_RELEASE_DIRS) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
     const char* tmp = getenv("PEGASUS_HOME");     const char* tmp = getenv("PEGASUS_HOME");
  
     if (tmp)     if (tmp)
Line 551 
Line 680 
         pegasusHome = tmp;         pegasusHome = tmp;
     }     }
 #endif #endif
   #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 )  
     {  
       cim_server_service(argc, argv);  
     }  
     else  
     {  
         // Get help, version, and shutdown options         // Get help, version, 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(String::equal(arg,"--help"))
               {
                       PrintHelp(argv[0]);
                       exit(0);
               }
               else if(String::equal(arg,"--version"))
               {
                   cout << _cimServerProcess->getCompleteVersion() << endl;
                   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 584 
Line 717 
                 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;  
 #else  
                     cout << PEGASUS_VERSION << endl;  
 #endif  
                     exit(0);                     exit(0);
                 }                 }
                 //                 //
Line 600 
Line 729 
                     PrintHelp(argv[0]);                     PrintHelp(argv[0]);
                     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 624 
Line 753 
                     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))
                 {                 {
                     System::bindVerbose = true;                      MessageLoaderParms parms(
                     //l10n                          "src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",
                     //cout << "Unsupported debug option, BIND_VERBOSE, enabled."                          "Unsupported debug output option is enabled.");
                          //<< endl;  
                     MessageLoaderParms parms("src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",  
                                                                  "Unsupported debug option, BIND_VERBOSE, enabled.");  
                         cout << MessageLoader::getMessage(parms) << endl;                         cout << MessageLoader::getMessage(parms) << endl;
   
                       debugOutputOption = true;
   
   #if defined(PEGASUS_OS_HPUX)
                       System::bindVerbose = true;
   #endif
   
                     // 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 650 
Line 781 
                         (strlen(option) == 1))                         (strlen(option) == 1))
                 {                 {
                     //                     //
                     // check to see if user is root  
                     //  
 #ifndef PEGASUS_OS_OS400  
                     if (!System::isPrivilegedUser(System::getEffectiveUserName()))  
                     {  
                         //l10n  
                         //cout << "You must have superuser privilege to run ";  
                         //cout << "cimserver." << endl;  
                         MessageLoaderParms parms("src.Server.cimserver.SUPERVISOR_PRIVILEGE_TO_RUN_SERVER",  
                                                                          "You must have superuser privilege to run cimserver.");  
   
                         cout << MessageLoader::getMessage(parms) << 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)
Line 686 
Line 800 
                     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))  
                   {  
                      //l10n  
                       //cout << "\nPegasus installed as NT Service";  
                       MessageLoaderParms parms("src.Server.cimserver.INSTALLED_NT_SERVICE",  
                                                "\nPegasus installed as NT Service");  
   
                       cout << MessageLoader::getMessage(parms) << endl;  
                       exit(0);  
                   }  
                   else                   else
                   {                      i++;
                       exit(0);  
                   }  
                 }  
                 else if (strcmp(option, OPTION_REMOVE) == 0)  
                 {  
                   //  
                   // Remove Pegasus as an NT service  
                   //  
                   char *opt_arg = NULL;  
                   if (i+1 < argc)  
                   {  
                     opt_arg = argv[i+1];  
                   }  
                   if(cimserver_remove_nt_service(opt_arg))  
                   {  
                       //l10n  
                       //cout << "\nPegasus removed as NT Service";  
                       MessageLoaderParms parms("src.Server.cimserver.REMOVED_NT_SERVICE",  
                                                "\nPegasus removed as NT Service");  
   
                       cout << MessageLoader::getMessage(parms) << endl;  
                       exit(0);  
                   }                   }
                   else                   else
                   {                  i++;
                       exit(0);  
                   }                   }
  
                 }  
                 else if (strcmp(option, OPTION_START) == 0)  
                 {  
                   //                   //
                   // Start as a 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_start_nt_service(opt_arg))  
                   {  
                       //l10n  
                       //cout << "\nPegasus started as NT Service";  
                       MessageLoaderParms parms("src.Server.cimserver.STARTED_NT_SERVICE",  
                                                "\nPegasus started as NT Service");  
  
                       cout << MessageLoader::getMessage(parms) << endl;  
                       exit(0);  
                   }  
                   else  
                   {  
                       exit(0);  
                   }  
                 }  
                 else if (strcmp(option, OPTION_STOP) == 0)  
                 {  
                   //                   //
                   // Stop as a NT service      // Do the platform specific run
                   //                   //
                   char *opt_arg = NULL;  
                   if (i+1 < argc)  
                   {  
                     opt_arg = argv[i+1];  
                   }  
                   if(cimserver_stop_nt_service(opt_arg))  
                   {  
                       //l10n  
                       //cout << "\nPegasus stopped as NT Service";  
                       MessageLoaderParms parms("src.Server.cimserver.STOPPED_NT_SERVICE",  
                                                "\nPegasus stopped as NT Service");  
  
                       cout << MessageLoader::getMessage(parms) << endl;      return _cimServerProcess->platform_run(
                       exit(0);          argc, argv, shutdownOption, debugOutputOption);
                   }                   }
                   else  
   void CIMServerProcess::cimserver_stop()
                   {                   {
                       exit(0);      _cimServer->shutdownSignal();
                   }  
                 }  
 #endif  
                 else  
                     i++;  
             }  
             else  
                 i++;  
         }  
     }     }
  
     //     //
     // Set the value for pegasusHome property  // The main, common, running code
   //
   // NOTE: Do NOT call exit().  Use return(), otherwise some platforms
   // will fail to shutdown properly/cleanly.
   //
   // TODO: Current change minimal for platform "service" shutdown bug fixes.
   // Perhaps further extract out common stuff and put into main(), put
   // daemon stuff into platform specific platform_run(), etc.
   // Note: make sure to not put error handling stuff that platform
   // specific runs may need to deal with better (instead of exit(), etc).
     //     //
     ConfigManager::setPegasusHome(pegasusHome);  
   int CIMServerProcess::cimserver_run(
       int argc,
       char** argv,
       Boolean shutdownOption,
       Boolean debugOutputOption)
   {
       String logsDirectory = String::EMPTY;
       Boolean daemonOption = false;
  
     //     //
     // Get an instance of the Config Manager.     // Get an instance of the Config Manager.
     //     //
     configManager = ConfigManager::getInstance();     configManager = ConfigManager::getInstance();
       configManager->useConfigFiles = true;
   
   #ifdef PEGASUS_OS_OS400
       // In a special startup case for IBM OS400, when the server is
       // automatically started when the machine starts up the config
       // file cannot be read because of access restrictions for the
       // user starting the server.  In this case, we need to skip
       // reading the config options and therefore any use of the config
       // manager also.  To make this determinations we will check to see
       // if the daemon flag is set to true.  If so, then there will be a
       // series of checks to bracket all the calls to the configManager
       // which would otherwise fail.  All this will only be done for
       // IBM OS400.
   
       Boolean os400StartupOption = false;
       // loop through args to check for daemon=true
       for (int i=1; i < argc; i++)
         if (strcmp(argv[i], "daemon=true") == 0)
         {
           os400StartupOption = true;
           daemonOption = true;
         }
   
       if (!os400StartupOption)
       {
           // If this is the server job, then set the job
           // to save the job log.
           system ("QSYS/CHGJOB JOB(*) LOG(4 00 *SECLVL)");
       }
   #endif
  
     //     //
     // Get options (from command line and from configuration file); this     // Get options (from command line and from configuration file); this
Line 815 
Line 889 
     //     //
     try     try
     {     {
         GetOptions(configManager, argc, argv, pegasusHome);  #ifdef PEGASUS_OS_OS400
       if (os400StartupOption == false)
   #endif
           GetOptions(configManager, argc, argv);
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
 #ifdef PEGASUS_OS_OS400          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,              "src.Server.cimserver.SERVER_NOT_STARTED",
                         "$0: $1",argv[0] ,e.getMessage());              "cimserver not started:  $0", e.getMessage());
 #else  
         cerr << argv[0] << ": " << e.getMessage() << endl;  #if !defined(PEGASUS_OS_OS400)
           MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
               "cimserver not started: $0", e.getMessage());
   
           PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)
               << PEGASUS_STD(endl);
 #endif #endif
         exit(1);  
           return(1);
     }     }
  
 // l10n // l10n
         // Set the home directory, msg sub-dir, into the MessageLoader.         // Set the home directory, msg sub-dir, into the MessageLoader.
         // This will be the default directory where the resource bundles         // This will be the default directory where the resource bundles
         // are found.         // are found.
         String messagesDir = String::EMPTY;      MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
 #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM          ConfigManager::getInstance()->getCurrentValue("messageDir")));
         messagesDir = OS400_DEFAULT_MESSAGE_SOURCE;  
 #else  #ifdef PEGASUS_OS_OS400
         messagesDir = ConfigManager::getHomedPath("msg");      // Still need to declare and set the connection variables.
 #endif      // Will initialize to false since they are fixed at false for OS400.
         MessageLoader::setPegasusMsgHome(messagesDir);  
  
       // NOTE:  OS400 is a LOCAL_DOMAIN_SOCKET, so a few lines down
       // the test will not be compiled in.  If OS400 ever turns off that
       // define, then we will need to change this code path to insure that
       // one of the variables is true.
       Boolean enableHttpConnection = false;
       Boolean enableHttpsConnection = false;
       Boolean enableSSLExportClientVerification = false;
   
       if (os400StartupOption == false)
       {
         enableHttpConnection = String::equal(
             configManager->getCurrentValue("enableHttpConnection"), "true");
         enableHttpsConnection = String::equal(
             configManager->getCurrentValue("enableHttpsConnection"), "true");
         enableSSLExportClientVerification = String::equal(
             configManager->getCurrentValue("enableSSLExportClientVerification"), "true");
       }
   #else
     Boolean enableHttpConnection = String::equal(     Boolean enableHttpConnection = String::equal(
         configManager->getCurrentValue("enableHttpConnection"), "true");         configManager->getCurrentValue("enableHttpConnection"), "true");
     Boolean enableHttpsConnection = String::equal(     Boolean enableHttpsConnection = String::equal(
         configManager->getCurrentValue("enableHttpsConnection"), "true");         configManager->getCurrentValue("enableHttpsConnection"), "true");
       Boolean enableSSLExportClientVerification = String::equal(
           configManager->getCurrentValue("enableSSLExportClientVerification"), "true");
   #endif
  
     // Make sure at least one connection is enabled     // Make sure at least one connection is enabled
 #ifndef PEGASUS_LOCAL_DOMAIN_SOCKET  #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
     if (!enableHttpConnection && !enableHttpsConnection)     if (!enableHttpConnection && !enableHttpsConnection)
     {     {
         //l10n         //l10n
Line 861 
Line 964 
         MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",         MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
                                                          "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");                                                          "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
         exit(1);          return(1);
     }     }
 #endif #endif
  
Line 876 
Line 979 
             daemonOption = true;             daemonOption = true;
         }         }
  
   #ifdef PEGASUS_OS_OS400
       if (os400StartupOption == false)
       {
   #endif
         // Get the log file directory definition.         // Get the log file directory definition.
         // We put String into Cstring because         // We put String into Cstring because
         // Directory functions only handle Cstring.         // Directory functions only handle Cstring.
         // ATTN-KS: create String based directory functions.         // ATTN-KS: create String based directory functions.
   #if !defined(PEGASUS_USE_SYSLOGS)
                   // When using syslog facility. No files anymore.
         logsDirectory = configManager->getCurrentValue("logdir");         logsDirectory = configManager->getCurrentValue("logdir");
         logsDirectory =         logsDirectory =
             ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));             ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));
   #endif
   #ifdef PEGASUS_OS_OS400
       }  // end if (os400StartupOption == false)
   #endif
  
         // Set up the Logger. This does not open the logs         // Set up the Logger. This does not open the logs
         // Might be more logical to clean before set.         // Might be more logical to clean before set.
         // ATTN: Need tool to completely disable logging.         // ATTN: Need tool to completely disable logging.
  
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \ #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \
 !defined(PEGASUS_OS_OS400)  !defined(PEGASUS_OS_OS400) && !defined(PEGASUS_USE_SYSLOGS)
         Logger::setHomeDirectory(logsDirectory);         Logger::setHomeDirectory(logsDirectory);
 #endif #endif
  
Line 901 
Line 1013 
         {         {
             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);             shutdownCIMOM(timeoutValue);
  
Line 912 
Line 1024 
                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
                         "src.Server.cimserver.SERVER_STOPPED",                         "src.Server.cimserver.SERVER_STOPPED",
                         "CIM Server stopped.");                         "CIM Server stopped.");
               cimserver_exitRC(0);
 #else #else
                         //l10n                         //l10n
             //cout << "CIM Server stopped." << endl;             //cout << "CIM Server stopped." << endl;
             MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",             MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",
                                                          "$0 Server stopped.",                                       "CIM Server stopped.");
                                                          "CIM");  
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
               return(0);
 #endif #endif
             cimserver_exit(0);  
         }         }
  
   #if defined(PEGASUS_DEBUG)
         // 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) && \  
 !defined(PEGASUS_OS_OS400)  
         //l10n         //l10n
         //cout << "Logs Directory = " << logsDirectory << endl;         //cout << "Logs Directory = " << logsDirectory << endl;
   #if !defined(PEGASUS_USE_SYSLOGS)
         MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",         MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",
                                              "Logs Directory = ");                                              "Logs Directory = ");
         cout << MessageLoader::getMessage(parms) << logsDirectory << endl;         cout << MessageLoader::getMessage(parms) << logsDirectory << endl;
 #endif #endif
   #endif
         if (String::equal(configManager->getCurrentValue("slp"), "true"))  
         {  
             useSLP =  true;  
         }  
     }     }
     catch (UnrecognizedConfigProperty e)      catch (UnrecognizedConfigProperty& e)
     {     {
  
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
Line 958 
Line 1067 
 #endif #endif
     }     }
  
     Uint32 portNumberHttps;      // Bug 2148 - Here is the order of operations for determining the server HTTP and HTTPS ports.
     Uint32 portNumberHttp;      // 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.
   
       Uint32 portNumberHttps=0;
       Uint32 portNumberHttp=0;
       Uint32 portNumberExportHttps=0;
  
     if (enableHttpsConnection)     if (enableHttpsConnection)
     {     {
         String httpsPort = configManager->getCurrentValue("httpsPort");         String httpsPort = configManager->getCurrentValue("httpsPort");
         CString portString = httpsPort.getCString();          if (httpsPort == String::EMPTY)
         char* end = 0;          {
         Uint32 port = strtol(portString, &end, 10);  
         assert(end != 0 && *end == '\0');  
   
         //         //
         // Look up the WBEM-HTTPS port number         // Look up the WBEM-HTTPS port number
         //         //
         portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, port);              portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);
   
           } else
           {
               //
               // user-specified
               //
               CString portString = httpsPort.getCString();
               char* end = 0;
               portNumberHttps = strtol(portString, &end, 10);
               if(!(end != 0 && *end == '\0'))
               {
                   InvalidPropertyValue e("httpsPort", httpsPort);
                   Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                 "src.Server.cimserver.SERVER_NOT_STARTED",
                                 "cimserver not started:  $0", e.getMessage());
   #if !defined(PEGASUS_OS_OS400)
                   MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
                                            "cimserver not started: $0", e.getMessage());
                   PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)
                                     << PEGASUS_STD(endl);
   #endif
                   exit(1);
               }
           }
     }     }
  
     if (enableHttpConnection)     if (enableHttpConnection)
     {     {
         String httpPort = configManager->getCurrentValue("httpPort");         String httpPort = configManager->getCurrentValue("httpPort");
           if (httpPort == String::EMPTY)
           {
               //
               // Look up the WBEM-HTTP port number
               //
               portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);
   
           } else
           {
               //
               // user-specified
               //
         CString portString = httpPort.getCString();         CString portString = httpPort.getCString();
         char* end = 0;         char* end = 0;
         Uint32 port = strtol(portString, &end, 10);              portNumberHttp = strtol(portString, &end, 10);
         assert(end != 0 && *end == '\0');              if(!(end != 0 && *end == '\0'))
               {
                   InvalidPropertyValue e("httpPort", httpPort);
                   Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                 "src.Server.cimserver.SERVER_NOT_STARTED",
                                 "cimserver not started:  $0", e.getMessage());
   #if !defined(PEGASUS_OS_OS400)
                   MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
                                                "cimserver not started: $0", e.getMessage());
                   PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)
                                     << PEGASUS_STD(endl);
   #endif
                   exit(1);
               }
           }
       }
  
   
       if (enableSSLExportClientVerification)
       {
         //         //
         // Look up the WBEM-HTTP port number          // No config property is looked up to get the default port number.
           // Lookup the port defined in /etc/services for the service name
           // wbem-exp-https and bind to that port. If the service is  not defined
           // then log a warning message and do not start the cimserver.
         //         //
         portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME, port);          Uint32 port = 0;
     }  
           portNumberExportHttps = System::lookupPort(WBEM_EXPORT_HTTPS_SERVICE_NAME, port);
   
           if (portNumberExportHttps == 0)
           {
               Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                   "src.Server.cimserver.EXPORT_HTTPS_PORT_NOT_DEFINED",
                   "Port not defined for the service wbem-exp-https. CIMServer will not be started.");
   
               MessageLoaderParms parms("src.Server.cimserver.EXPORT_HTTPS_PORT_NOT_DEFINED",
                   "Port not defined for the service wbem-exp-https. CIMServer will not be started.");
   
               cerr << MessageLoader::getMessage(parms) << endl;
  
               return(1);
           }
       }
   #if defined(PEGASUS_DEBUG)
     // Put out startup up message.     // Put out startup up message.
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \      cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getCompleteVersion() << endl;
 !defined(PEGASUS_OS_OS400)  
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;  
     //l10n     //l10n
     //cout << "Built " << __DATE__ << " " << __TIME__ << endl;     //cout << "Built " << __DATE__ << " " << __TIME__ << endl;
     //cout <<"Starting..."     //cout <<"Starting..."
Line 1000 
Line 1185 
                                                  "Built $0 $1\nStarting...",                                                  "Built $0 $1\nStarting...",
                                                  __DATE__,                                                  __DATE__,
                                                  __TIME__);                                                  __TIME__);
     cout << MessageLoader::getMessage(parms)  
                  << (useSLP ? " SLP reg. " : " No SLP ")  
                  << endl;  
 #endif #endif
  
 //l10n //l10n
Line 1010 
Line 1192 
 MessageLoader::_useProcessLocale = false; MessageLoader::_useProcessLocale = false;
 //l10n //l10n
  
       // Get the parent's PID before forking
       _cimServerProcess->set_parent_pid(System::getPID());
   
     // do we need to run as a daemon ?     // do we need to run as a daemon ?
     if (daemonOption)     if (daemonOption)
     {     {
         if(-1 == cimserver_fork())          if(-1 == _cimServerProcess->cimserver_fork())
 #ifndef PEGASUS_OS_OS400 #ifndef PEGASUS_OS_OS400
         {         {
             exit(-1);          return(-1);
         }         }
 #else #else
         {         {
Line 1033 
Line 1218 
 // l10n // l10n
     // Now we are after the fork...     // Now we are after the fork...
     // Create a dummy Thread object that can be used to store the     // Create a dummy Thread object that can be used to store the
     // AcceptLanguages object for CIM requests that are serviced      // AcceptLanguageList object for CIM requests that are serviced
     // by this thread (initial thread of server).  Need to do this     // by this thread (initial thread of server).  Need to do this
     // because this thread is not in a ThreadPool, but is used     // because this thread is not in a ThreadPool, but is used
     // to service CIM requests.     // to service CIM requests.
     // The run function for the dummy Thread should never be called,     // The run function for the dummy Thread should never be called,
     Thread *dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);      dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);
     Thread::setCurrent(dummyInitialThread);     Thread::setCurrent(dummyInitialThread);
     AcceptLanguages default_al = AcceptLanguages::getDefaultAcceptLanguages();      AcceptLanguageList default_al;
     Thread::setLanguages(new AcceptLanguages(default_al));      try{
            default_al = LanguageParser::getDefaultAcceptLanguages();
            Thread::setLanguages(new AcceptLanguageList(default_al));
       }catch(InvalidAcceptLanguageHeader& e){
             Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                     "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
                     "Could not convert the system process locale into a valid AcceptLanguage format.");
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                e.getMessage());
       }
   
  
  
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
Line 1055 
Line 1250 
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                   "src.Server.cimserver.SERVER_FAILED_TO_INITIALIZE",                                   "src.Server.cimserver.SERVER_FAILED_TO_INITIALIZE",
                           "CIM Server failed to initialize");                           "CIM Server failed to initialize");
         exit(-1);      return(-1);
     }     }
 #endif #endif
  
   #ifndef PEGASUS_OS_TYPE_WINDOWS
       umask(S_IRWXG|S_IRWXO);
   #endif
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  
     umask(S_IWGRP|S_IWOTH);  #if defined(PEGASUS_OS_TYPE_UNIX)
     //
     // CRITICAL SECTION BEGIN
     //
     // This is the beginning of the critical section regarding the
     // access to pidfile (file to indicate that the cimserver has started).
     // Sometimes, when 2 or more cimserver processes are started at the same
     // time, they can't detect the concurrent process execution because the
     // logic fails when pidfile is accessed concurrently.
   
     FILE *startupLockFile;
   
     if ((startupLockFile = fopen(ConfigManager::getHomedPath(
             CIMSERVER_LOCK_FILE).getCString(), "w")) != 0)
     {
         lockf(fileno(startupLockFile), F_LOCK, 0);
     }
   #endif
   
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \
   || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \
   || defined(PEGASUS_OS_SOLARIS) || defined (PEGASUS_OS_VMS)
  
     //     //
     // check if CIMServer is already running     // check if CIMServer is already running
     // if CIMServer is already running, print message and     // if CIMServer is already running, print message and
     // notify parent process (if there is a parent process) to terminate     // notify parent process (if there is a parent process) to terminate
     //     //
     if(isCIMServerRunning())      if(_cimServerProcess->isCIMServerRunning())
     {     {
         //l10n         //l10n
                 //cout << "Unable to start CIMServer." << endl;                 //cout << "Unable to start CIMServer." << endl;
                 //cout << "CIMServer is already running." << endl;                 //cout << "CIMServer is already running." << endl;
                 MessageLoaderParms parms("src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",                 MessageLoaderParms parms("src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
                                          "Unable to start CIMServer.\nCIMServer is already running.");                                          "Unable to start CIMServer.\nCIMServer is already running.");
       PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
  
         //         //
         // 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)
                 notify_parent(1);                  _cimServerProcess->notify_parent(1);
  
         exit(1);          return(1);
     }     }
  
 #endif #endif
Line 1090 
Line 1310 
     // try loop to bind the address, and run the server     // try loop to bind the address, and run the server
     try     try
     {     {
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)  
         char slp_address[32];  
         slp_client *discovery = new slp_client() ;;  
         String serviceURL;  
         serviceURL.assign("service:cim.pegasus://");  
         String host_name = slp_get_host_name();  
         serviceURL.append(host_name);  
         serviceURL.append(":");  
         // ATTN: Fix this to work for multiple connections  
         sprintf(slp_address, "%u",  
                 enableHttpConnection ? portNumberHttp : portNumberHttps);  
         serviceURL.append(slp_address);  
 #endif  
   
         Monitor monitor(true);  
         //monitor_2 monitor;  
   
         CIMServer server(&monitor);  
  
       _monitor  = new Monitor();
       //PEP#222
       //CIMServer server(&monitor);
       //CimserverHolder cimserverHolder( &server );
       _cimServer = new CIMServer(_monitor);
  
  
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
             server.addAcceptor(false, portNumberHttp, false);              _cimServer->addAcceptor(false, portNumberHttp, false, false);
             //l10n             //l10n
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                         //"Listening on HTTP port $0.", portNumberHttp);                         //"Listening on HTTP port $0.", portNumberHttp);
Line 1124 
Line 1331 
         }         }
         if (enableHttpsConnection)         if (enableHttpsConnection)
         {         {
             server.addAcceptor(false, portNumberHttps, true);              _cimServer->addAcceptor(false, portNumberHttps, true, false);
             //l10n             //l10n
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                         //"Listening on HTTPS port $0.", portNumberHttps);                         //"Listening on HTTPS port $0.", portNumberHttps);
Line 1132 
Line 1339 
                                         "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.", portNumberHttps);
         }         }
 #ifdef PEGASUS_LOCAL_DOMAIN_SOCKET          if (enableSSLExportClientVerification)
         server.addAcceptor(true, 0, false);          {
               _cimServer->addAcceptor(false, portNumberExportHttps, true, true);
   
               Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   "src.Server.cimserver.LISTENING_ON_EXPORT_HTTPS_PORT",
                   "Listening on Export HTTPS port $0.", portNumberExportHttps);
           }
   
   #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
           _cimServer->addAcceptor(true, 0, false, false);
         //l10n         //l10n
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                     //"Listening on local connection socket.");                     //"Listening on local connection socket.");
Line 1142 
Line 1358 
                       "Listening on local connection socket.");                       "Listening on local connection socket.");
 #endif #endif
  
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && !defined(PEGASUS_OS_OS400)  #if defined(PEGASUS_DEBUG)
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
             //l10n             //l10n
Line 1159 
Line 1375 
                                      "Listening on HTTPS port $0.", portNumberHttps);                                      "Listening on HTTPS port $0.", portNumberHttps);
                 cout << MessageLoader::getMessage(parms) << endl;                 cout << MessageLoader::getMessage(parms) << endl;
         }         }
 # ifdef PEGASUS_LOCAL_DOMAIN_SOCKET          if (enableSSLExportClientVerification)
           {
               MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_EXPORT_HTTPS_PORT",
                   "Listening on Export HTTPS port $0.", portNumberExportHttps);
   
               cout << MessageLoader::getMessage(parms) << endl;
           }
   
   # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
         //l10n         //l10n
         //cout << "Listening on local connection socket" << endl;         //cout << "Listening on local connection socket" << endl;
         MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",         MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",
Line 1169 
Line 1393 
 #endif #endif
  
         // bind throws an exception if the bind fails         // bind throws an exception if the bind fails
         server.bind();          try {
              _cimServer->bind();
           } catch (const BindFailedException &e)
           {
   #ifdef PEGASUS_DEBUG
           MessageLoaderParms parms("src.Server.cimserver.BIND_FAILED",
                    "Could not bind: $0.", e.getMessage());
           cout << MessageLoader::getMessage(parms) << endl;
   #endif
           Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
               "src.Server.cimserver.BIND.FAILED",
               "Could not bind:  $0", e.getMessage());
  
              deleteCIMServer();
              return 1;
           }
         // 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 there is cimserver ready to serve CIM requests.         // so user knows that there is cimserver ready to serve CIM requests.
         if (daemonOption)         if (daemonOption)
                 notify_parent(0);          _cimServerProcess->notify_parent(0);
  
         time_t last = 0;         time_t last = 0;
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) \
       || defined(PEGASUS_OS_AIX) || defined(PEGASUS_OS_SOLARIS) \
       || defined(PEGASUS_OS_VMS)
         //         //
         // create a file to indicate that the cimserver has started and         // create a file to indicate that the cimserver has started and
         // save the process id of the cimserver process in the file         // save the process id of the cimserver process in the file
         //         //
         // remove the old file if it exists         // remove the old file if it exists
         System::removeFile(CIMSERVER_START_FILE);          System::removeFile(_cimServerProcess->getPIDFileName());
  
         // open the file         // open the file
         FILE *pid_file = fopen(CIMSERVER_START_FILE, "w");          FILE *pid_file = fopen(_cimServerProcess->getPIDFileName(), "w");
  
         if (pid_file)         if (pid_file)
         {         {
             // save the pid in the file             // save the pid in the file
             fprintf(pid_file, "%ld\n", (long)server_pid);              fprintf(pid_file, "%ld\n", _cimServerProcess->get_server_pid());
             fclose(pid_file);             fclose(pid_file);
         }         }
 #endif #endif
  
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \  #if defined(PEGASUS_DEBUG)
 !defined(PEGASUS_OS_OS400)  
         cout << "Started. " << endl;         cout << "Started. " << endl;
 #endif #endif
  
   #if defined(PEGASUS_OS_TYPE_UNIX)
       //
       // CRITICAL SECTION END
       //
       // Here is the unlock of file 'lock_file'. It closes the
       // the critical section that guarantees the non concurrent access to
       // pid file (file to indicate that the cimserver has started).
       //
   
       if (startupLockFile)
       {
          lockf(fileno(startupLockFile), F_ULOCK, 0);
          fclose(startupLockFile);
       }
   #endif
   
   
         // Put server started message to the logger         // Put server started message to the logger
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
         //l10n              Logger::INFORMATION,
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                     //"Started $0 version $1.",  
                     //PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);  
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                                 "src.Server.cimserver.STARTED_VERSION",                                 "src.Server.cimserver.STARTED_VERSION",
                     "Started $0 version $1.",                     "Started $0 version $1.",
                     PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);                        _cimServerProcess->getProductName(), _cimServerProcess->getCompleteVersion());
 #else  
                 //l10n  
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                     //"Started $0 version $1.",  
                     //PEGASUS_NAME, PEGASUS_VERSION);  
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                                 "src.Server.cimserver.STARTED_VERSION",  
                     "Started $0 version $1.",  
                     PEGASUS_NAME, PEGASUS_VERSION);  
 #endif  
  
   #if defined(PEGASUS_OS_TYPE_UNIX)
           if (daemonOption && !debugOutputOption)
           {
               // Direct standard input, output, and error to /dev/null,
               // since we are running as a daemon.
               close(0);
               open("/dev/null", O_RDONLY);
               close(1);
               open("/dev/null", O_RDWR);
               close(2);
               open("/dev/null", O_RDWR);
           }
   #endif
  
         //         //
         // 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)  
           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();        _cimServer->runForever();
           }  
 #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)  
         //l10n  
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
             //"$0 stopped.", PLATFORM_PRODUCT_NAME);  
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                 "src.Server.cimserver.STOPPED",  
             "$0 stopped.", PLATFORM_PRODUCT_NAME);  
 #else  
                 //l10n  
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
             //"$0 stopped.", PEGASUS_NAME);  
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
                 "src.Server.cimserver.STOPPED",  
             "$0 stopped.", PEGASUS_NAME);  
 #endif  
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)          // Put server shutdown message to the logger
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
               Logger::INFORMATION, "src.Server.cimserver.STOPPED",
               "$0 stopped.", _cimServerProcess->getProductName());
   
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) \
   || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \
   || defined(PEGASUS_OS_SOLARIS) || defined(PEGASUS_OS_VMS)
         //         //
         // close the file created at startup time to indicate that the          //  Note: do not remove the PID file created at startup time, since
         // cimserver has terminated normally.          //  shutdown is not complete until the CIMServer destructor completes.
         //         //
         FileSystem::removeFile(CIMSERVER_START_FILE);  
 #endif #endif
     }     }
     catch(Exception& e)     catch(Exception& e)
Line 1301 
Line 1531 
         // 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)
                 notify_parent(1);                  _cimServerProcess->notify_parent(1);
  
           deleteCIMServer();
         return 1;         return 1;
     }     }
  
       deleteCIMServer();
     return 0;     return 0;
 } }
   
   
   
   

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