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

Diff for /pegasus/src/WMIMapper/WMIServer/cimserver.cpp between version 1.28 and 1.41

version 1.28, 2007/04/03 18:51:02 version 1.41, 2008/12/01 17:52:04
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  // Permission is hereby granted, free of charge, to any person obtaining a
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  // copy of this software and associated documentation files (the "Software"),
 // EMC Corporation; Symantec Corporation; The Open Group.  // to deal in the Software without restriction, including without limitation
 //  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // and/or sell copies of the Software, and to permit persons to whom the
 // of this software and associated documentation files (the "Software"), to  // Software is furnished to do so, subject to the following conditions:
 // deal in the Software without restriction, including without limitation the  //
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // The above copyright notice and this permission notice shall be included
 // sell copies of the Software, and to permit persons to whom the Software is  // in all copies or substantial portions of the Software.
 // furnished to do so, subject to the following conditions:  //
 //  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  //////////////////////////////////////////////////////////////////////////
 // //
 //%/////////////////////////////////////////////////////////////////////////////  //%////////////////////////////////////////////////////////////////////////////
  
  
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
Line 76 
Line 74 
 // 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  
 //  
 ////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
  
  
Line 85 
Line 81 
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <iostream> #include <iostream>
 #include <Pegasus/Common/PegasusAssert.h> #include <Pegasus/Common/PegasusAssert.h>
 #include <cstdlib>  
 #include <fstream> #include <fstream>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Monitor.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>
Line 96 
Line 90 
 #include <Pegasus/Common/LanguageParser.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/Server/CIMServer.h>
 #include <Service/ServerProcess.h> #include <Service/ServerProcess.h>
   #include <Service/ServerShutdownClient.h>
 #if defined(PEGASUS_OS_OS400)  #include <Service/ServerRunStatus.h>
 #  include "vfyptrs.cinc"  
 #  include "OS400ConvertChar.h"  
 #endif  
  
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 #define PEGASUS_PROCESS_NAME "WMI Mapper";  #define PEGASUS_PROCESS_NAME "WMI Mapper"
  
 //Windows service variables are not defined elsewhere in the product //Windows service variables are not defined elsewhere in the product
 //enable ability to override these //enable ability to override these
Line 159 
Line 149 
         return PEGASUS_PROCESS_NAME;         return PEGASUS_PROCESS_NAME;
     }     }
  
     //defined in Constants.h      int cimserver_run(
     virtual const char* getPIDFileName() const          int argc,
     {          char** argv,
         return PEGASUS_CIMSERVER_START_FILE;          Boolean shutdownOption,
     }          Boolean debugOutputOption);
   
     int cimserver_run(int argc, char** argv, bool shutdownOption);  
  
     void cimserver_stop(void);     void cimserver_stop(void);
 }; };
  
   ServerRunStatus _serverRunStatus(
       PEGASUS_PROCESS_NAME, PEGASUS_CIMSERVER_START_FILE);
 AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess()); AutoPtr<CIMServerProcess> _cimServerProcess(new CIMServerProcess());
 static CIMServer* _cimServer = 0; static CIMServer* _cimServer = 0;
 static Monitor* _monitor = 0;  
  
 // //
 //  The command name. //  The command name.
Line 203 
Line 192 
 static const char OPTION_BINDVERBOSE = 'X'; static const char OPTION_BINDVERBOSE = 'X';
 #endif #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)
 { {
     try  
     {  
         cm->mergeConfigFiles();         cm->mergeConfigFiles();
   
         cm->mergeCommandLine(argc, argv);         cm->mergeCommandLine(argc, argv);
     }     }
     catch (NoSuchFile&)  
     {  
         throw;  
     }  
     catch (FileNotReadable&)  
     {  
         throw;  
     }  
     catch (CannotRenameFile&)  
     {  
         throw;  
     }  
     catch (ConfigFileSyntaxError&)  
     {  
         throw;  
     }  
     catch(UnrecognizedConfigProperty&)  
     {  
         throw;  
     }  
     catch(InvalidPropertyValue&)  
     {  
         throw;  
     }  
     catch (CannotOpenFile&)  
     {  
         throw;  
     }  
 }  
  
 /* PrintHelp - This is temporary until we expand the options manager to allow /* PrintHelp - This is temporary until we expand the options manager to allow
    options help to be defined with the OptionRow entries and presented from    options help to be defined with the OptionRow entries and presented from
Line 268 
Line 225 
     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 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 Service\n");      usage.append ("    -remove [name]  - removes 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 ("    -start [name]   - starts pegasus as a Windows Service\n");      usage.append ("    -start [name]   - starts 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 ("    -stop [name]    - stops pegasus as a Windows Service\n");      usage.append ("    -stop [name]    - stops 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\n");     usage.append ("                      default CIM Server Service 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;
     cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getVersion() << endl;      cout << _cimServerProcess->getProductName() << " " <<
           _cimServerProcess->getVersion() << endl;
     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_USE_RELEASE_DIRS) #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 << 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.  // This needs to be called at various points in the code depending on the
 //We need to delete the _cimServer reference on exit in order for the destructors to get called.  // platform and error conditions. We need to delete the _cimServer
   // reference on exit in order for the destructors to get called.
 void deleteCIMServer() void deleteCIMServer()
 { {
     if (_cimServer)  
     {  
         delete _cimServer;         delete _cimServer;
         _cimServer = 0;         _cimServer = 0;
     }     }
  
         if (_monitor)  
         {  
                 delete _monitor;  
         }  
 }  
   
 // 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 326 
Line 287 
    return((ThreadReturnType)0);    return((ThreadReturnType)0);
 } }
  
 void shutdownCIMOM(Uint32 timeoutValue)  
 {  
     //  
     // Create CIMClient object  
     //  
     CIMClient client;  
   
     //  
     // Get local host name  
     //  
     String hostStr = System::getHostName();  
   
     //  
     // open connection to CIMOM  
     //  
     try  
     {  
         client.connectLocal();  
   
         //  
         // set client timeout to 2 seconds  
         //  
         client.setTimeout(2000);  
     }  
     catch(Exception&)  
     {  
 #ifdef PEGASUS_OS_OS400  
     //l10n  
     //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Unable to connect to CIM Server.  CIM Server may not be running." );  
     Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             "src.Server.cimserver.UNABLE_CONNECT_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.  
     // Kill the job if it exists.  
     if(_cimServerProcess->cimserver_kill(0) == -1)  
        _cimServerProcess->cimserver_exitRC(2);  
     _cimServerProcess->cimserver_exitRC(1);  
 #else  
         //l10n  
         //PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);  
         //PEGASUS_STD(cerr) << "CIM Server may not be running." << PEGASUS_STD(endl);  
         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");  
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);  
         exit(1);  
 #endif  
     }  
   
     try  
     {  
         //  
         // construct CIMObjectPath  
         //  
         String referenceStr = "//";  
         referenceStr.append(hostStr);  
         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  
         //  
         Array<CIMParamValue> inParams;  
         Array<CIMParamValue> outParams;  
   
         // set force option to true for now  
         inParams.append(CIMParamValue("force",  
             CIMValue(Boolean(true))));  
   
         inParams.append(CIMParamValue("timeout",  
             CIMValue(Uint32(timeoutValue))));  
   
         CIMValue retValue = client.invokeMethod(  
             PEGASUS_NAMESPACENAME_SHUTDOWN,  
             reference,  
             "shutdown",  
             inParams,  
             outParams);  
     }  
     catch(CIMException& e)  
     {  
 #ifdef PEGASUS_OS_OS400  
   
     if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)  
     {  
         //l10n  
         //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Failed to shutdown server: $0", "The repository may be empty.");  
         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.");  
     }  
     else  
     {  
         //l10n  
         //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Failed to shutdown server: $0", e.getMessage());  
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             "src.Server.cimserver.SHUTDOWN_FAILED",  
             "Error in server shutdown: $0", e.getMessage());  
     }  
     // Kill the server job.  
     if(_cimServerProcess->cimserver_kill(0) == -1)  
        _cimServerProcess->cimserver_exitRC(2);  
 #else  
         //l10n - TODO  
         MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",  
                                  "Error in server shutdown: ");  
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);  
         if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)  
         {  
             //  
             // 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",  
                                      "The repository may be empty.");  
             PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);  
         }  
         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);  
         }  
   
     // 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);  
         }  
         exit(1);  
 #endif  
     }  
     catch(Exception&)  
     {  
         //  
         // This may mean that the CIM Server has terminated, causing this  
         // client to get a "Empty HTTP response message" exception.  It may  
         // also mean that the CIM Server is taking longer than 2 seconds  
         // (client timeout value) to terminate, causing this client to  
         // 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 = _cimServerProcess->isCIMServerRunning();  
         while ( running && maxWaitTime > 0 )  
         {  
             System::sleep(1);  
             running = _cimServerProcess->isCIMServerRunning();  
             maxWaitTime = maxWaitTime - 1;  
         }  
   
         if (running)  
         {  
        int kill_rc = _cimServerProcess->cimserver_kill(0);  
   
 #ifdef PEGASUS_OS_OS400  
         if(kill_rc == -1)  
         _cimServerProcess->cimserver_exitRC(2);  
         _cimServerProcess->cimserver_exitRC(1);  
 #endif  
   
 #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  
         }  
     }  
   
     return;  
 }  
   
  
 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
 //  MAIN //  MAIN
Line 537 
Line 295 
 { {
     String pegasusHome;     String pegasusHome;
     Boolean shutdownOption = false;     Boolean shutdownOption = false;
       Boolean debugOutputOption = false;
  
 //l10n //l10n
 // Set Message loading to process locale // Set Message loading to process locale
Line 548 
Line 307 
 setlocale(LC_ALL, ""); setlocale(LC_ALL, "");
 #endif #endif
  
 #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  
     for(Uint32 i = 0;i< argc;++i)  
     {  
     EtoA(argv[i]);  
     }  
   
     // Initialize Pegasus home to the shipped OS/400 directory.  
     pegasusHome = OS400_DEFAULT_PEGASUS_HOME;  
 #endif  
   
   
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
     //     //
     // Get environment variables:     // Get environment variables:
     //     //
 #ifdef PEGASUS_OS_OS400  
 #pragma convert(37)  
     const char* tmp = getenv("PEGASUS_HOME");  
 #pragma convert(0)  
     char home[256] = {0};  
     if (tmp && strlen(tmp) < 256)  
     {  
     strcpy(home, tmp);  
     EtoA(home);  
     pegasusHome = home;  
     }  
 #else  
   #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_USE_RELEASE_DIRS)   #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_USE_RELEASE_DIRS)
     pegasusHome = AIX_RELEASE_PEGASUS_HOME;     pegasusHome = AIX_RELEASE_PEGASUS_HOME;
   #elif !defined(PEGASUS_USE_RELEASE_DIRS)   #elif !defined(PEGASUS_USE_RELEASE_DIRS)
Line 597 
Line 321 
         pegasusHome = tmp;         pegasusHome = tmp;
     }     }
   #endif   #endif
 #endif  
  
     FileSystem::translateSlashes(pegasusHome);     FileSystem::translateSlashes(pegasusHome);
 #else #else
Line 656 
Line 379 
                     }                     }
                     else                     else
                     {                     {
                         //l10n  
                         //cout << "Missing argument for option -" << option << endl;  
                         String opt(option);                         String opt(option);
                         MessageLoaderParms parms("src.Server.cimserver.MISSING_ARGUMENT",                          MessageLoaderParms parms(
                               "src.Server.cimserver.MISSING_ARGUMENT",
                                          "Missing argument for option -$0",                                          "Missing argument for option -$0",
                                          opt);                                          opt);
                         cout << MessageLoader::getMessage(parms) << endl;                         cout << MessageLoader::getMessage(parms) << endl;
                         exit(0);                         exit(0);
                     }                     }
  
                     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
Line 678 
Line 401 
                         (strlen(option) == 1))                         (strlen(option) == 1))
                 {                 {
             System::bindVerbose = true;             System::bindVerbose = true;
                     //l10n  
                     //cout << "Unsupported debug option, BIND_VERBOSE, enabled."                      MessageLoaderParms parms(
                          //<< endl;                          "src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",
                     MessageLoaderParms parms("src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",  
                                          "Unsupported debug option, BIND_VERBOSE, enabled.");                                          "Unsupported debug option, BIND_VERBOSE, enabled.");
                     cout << MessageLoader::getMessage(parms) << endl;                     cout << MessageLoader::getMessage(parms) << endl;
                     // remove the option from the command line                     // remove the option from the command line
Line 700 
Line 422 
                     //                     //
                     if (shutdownOption)                     if (shutdownOption)
                     {                     {
                         //l10n                          MessageLoaderParms parms(
                         //cout << "Duplicate shutdown option specified." << endl;                              "src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",
                         MessageLoaderParms parms("src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",  
                                                  "Duplicate shutdown option specified.");                                                  "Duplicate shutdown option specified.");
  
                         cout << MessageLoader::getMessage(parms) << endl;                         cout << MessageLoader::getMessage(parms) << endl;
Line 731 
Line 452 
     // Do the plaform specific run     // Do the plaform specific run
     //     //
  
     return _cimServerProcess->platform_run( argc, argv, shutdownOption );      return _cimServerProcess->platform_run(
           argc, argv, shutdownOption, debugOutputOption);
 } }
  
 void CIMServerProcess::cimserver_stop() void CIMServerProcess::cimserver_stop()
Line 752 
Line 474 
 // specific runs may need to deal with bettter (instead of exit(), etc). // specific runs may need to deal with bettter (instead of exit(), etc).
 // //
  
 int CIMServerProcess::cimserver_run( int argc, char** argv, Boolean shutdownOption )  int CIMServerProcess::cimserver_run(
       int argc,
       char** argv,
       Boolean shutdownOption,
       Boolean debugOutputOption)
 { {
     String logsDirectory;     String logsDirectory;
     Boolean daemonOption = false;     Boolean daemonOption = false;
Line 760 
Line 486 
     //     //
     // Get an instance of the Config Manager.     // Get an instance of the Config Manager.
     //     //
     configManager = ConfigManager::getInstance();      ConfigManager* configManager = ConfigManager::getInstance();
     configManager->useConfigFiles = true;     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;  
       }  
 #endif  
   
     //     //
     // 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 792 
Line 496 
     //     //
     try     try
     {     {
 #ifdef PEGASUS_OS_OS400  
     if (os400StartupOption == false)  
 #endif  
         GetOptions(configManager, argc, argv);         GetOptions(configManager, argc, argv);
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
         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",         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
             "cimserver not started: $0", e.getMessage());             "cimserver not started: $0", e.getMessage());
  
         PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             << PEGASUS_STD(endl);              parms);
 #endif  
           PEGASUS_STD(cerr) << argv[0] << ": " <<
               MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
  
         return(1);         return(1);
     }     }
Line 821 
Line 519 
     MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(     MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
         ConfigManager::getInstance()->getCurrentValue("messageDir")));         ConfigManager::getInstance()->getCurrentValue("messageDir")));
  
 #ifdef PEGASUS_OS_OS400  
     // Still need to declare and set the connection variables.  
     // Will initialize to false since they are fixed at false for OS400.  
   
     // 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;  
   
     if (os400StartupOption == false)  
     {  
       enableHttpConnection = ConfigManager::parseBooleanValue(  
           configManager->getCurrentValue("enableHttpConnection"));  
       enableHttpsConnection = ConfigManager::parseBooleanValue(  
           configManager->getCurrentValue("enableHttpsConnection"));  
     }  
 #else  
     Boolean enableHttpConnection = ConfigManager::parseBooleanValue(     Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
         configManager->getCurrentValue("enableHttpConnection"));         configManager->getCurrentValue("enableHttpConnection"));
     Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(     Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
         configManager->getCurrentValue("enableHttpsConnection"));         configManager->getCurrentValue("enableHttpsConnection"));
 #endif  
  
     // Make sure at least one connection is enabled     // Make sure at least one connection is enabled
 #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
     if (!enableHttpConnection && !enableHttpsConnection)     if (!enableHttpConnection && !enableHttpsConnection)
     {     {
         //l10n          MessageLoaderParms parms(
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,  
             //"Neither HTTP nor HTTPS connection is enabled.  "  
             //"CIMServer will not be started.");  
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,  
             "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",             "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.");
         //cerr << "Neither HTTP nor HTTPS connection is enabled.  "          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
             //"CIMServer will not be started." << endl;              parms);
         MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",  
                                  "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");  
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
         return(1);          return 1;
     }     }
 #endif #endif
  
Line 875 
Line 547 
         daemonOption = ConfigManager::parseBooleanValue(         daemonOption = ConfigManager::parseBooleanValue(
             configManager->getCurrentValue("daemon"));             configManager->getCurrentValue("daemon"));
  
 #ifdef PEGASUS_OS_OS400  
     if (os400StartupOption == false)  
     {  
 #endif  
         // 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 =         logsDirectory =
         ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));         ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));
 #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)  
         Logger::setHomeDirectory(logsDirectory);         Logger::setHomeDirectory(logsDirectory);
 #endif #endif
  
Line 907 
Line 565 
         {         {
             String configTimeout =             String configTimeout =
                 configManager->getCurrentValue("shutdownTimeout");                 configManager->getCurrentValue("shutdownTimeout");
             Uint32 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(
         //l10n  
         //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,  
             //"CIM Server stopped.");  
         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  
             //l10n  
             //cout << "CIM Server stopped." << endl;  
             MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",  
                                      "CIM Server stopped.");  
  
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
             return(0);             return(0);
 #endif  
         }         }
  
 #if defined(PEGASUS_DEBUG)  #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.
         //l10n  
         //cout << "Logs Directory = " << logsDirectory << endl;  
         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;
Line 941 
Line 588 
     }     }
     catch (UnrecognizedConfigProperty& e)     catch (UnrecognizedConfigProperty& e)
     {     {
   
 #ifdef PEGASUS_OS_OS400  
     //l10n  
     //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"Error: $0",e.getMessage());  
     Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             "src.Server.cimserver.ERROR",  
             "Error: $0",e.getMessage());  
 #else  
     //l10n     //l10n
     //cout << "Error: " << e.getMessage() << endl;     //cout << "Error: " << e.getMessage() << endl;
     MessageLoaderParms parms("src.Server.cimserver.ERROR",     MessageLoaderParms parms("src.Server.cimserver.ERROR",
                              "Error: $0",                              "Error: $0",
                              e.getMessage());                              e.getMessage());
     cout << MessageLoader::getMessage(parms) << endl;     cout << MessageLoader::getMessage(parms) << endl;
 #endif  
     }     }
  
     // Bug 2148 - Here is the order of operations for determining the server HTTP and HTTPS ports.      // Bug 2148 - Here is the order of operations for determining the server
       // HTTP and HTTPS ports.
     // 1) If the user explicitly specified a port, use it.     // 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.      // 2) If the user did not specify a port, get the port from the
     // 3) If no value is specified in the services file, use the IANA WBEM default port.      //    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     // 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.      // An empty string from the ConfigManager implies that the user did
       // not specify a port.
  
     Uint32 portNumberHttps=0;     Uint32 portNumberHttps=0;
     Uint32 portNumberHttp=0;     Uint32 portNumberHttp=0;
Line 978 
Line 619 
             //             //
             // Look up the WBEM-HTTPS port number             // Look up the WBEM-HTTPS port number
             //             //
             portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);              portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME,
                   WBEM_DEFAULT_HTTPS_PORT);
  
         } else         } else
         {         {
Line 1005 
Line 647 
             //             //
             // Look up the WBEM-HTTP port number             // Look up the WBEM-HTTP port number
             //             //
             portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);              portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME,
                   WBEM_DEFAULT_HTTP_PORT);
  
         } else         } else
         {         {
Line 1026 
Line 669 
  
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
     // Put out startup up message.     // Put out startup up message.
     cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getVersion() << endl;      cout << _cimServerProcess->getProductName() << " " <<
     //l10n          _cimServerProcess->getVersion() << endl;
     //cout << "Built " << __DATE__ << " " << __TIME__ << endl;  
     //cout <<"Starting..."  
     MessageLoaderParms parms("src.Server.cimserver.STARTUP_MESSAGE",  
                              "Built $0 $1\nStarting...",  
                              __DATE__,  
                              __TIME__);  
 #endif #endif
  
 //l10n  
 // reset message loading to NON-process locale // reset message loading to NON-process locale
 MessageLoader::_useProcessLocale = false; MessageLoader::_useProcessLocale = false;
 //l10n  
  
     // Get the parent's PID before forking     // Get the parent's PID before forking
     _cimServerProcess->set_parent_pid(System::getPID());      _serverRunStatus.setParentPid(System::getPID());
  
     // do we need to run as a daemon ?     // do we need to run as a daemon ?
     if (daemonOption)     if (daemonOption)
     {     {
         if(-1 == _cimServerProcess->cimserver_fork())         if(-1 == _cimServerProcess->cimserver_fork())
 #ifndef PEGASUS_OS_OS400  
     {     {
         return(-1);         return(-1);
     }     }
 #else  
     {  
             return(-1);  
     }  
     else  
     {  
         return(0);  
     }  
 #endif  
   
     }     }
  
 // l10n // l10n
Line 1074 
Line 698 
     // 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);     Thread *dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);
     Thread::setCurrent(dummyInitialThread);     Thread::setCurrent(dummyInitialThread);
     AcceptLanguageList default_al;      try
     try{      {
          default_al = LanguageParser::getDefaultAcceptLanguages();           Thread::setLanguages(LanguageParser::getDefaultAcceptLanguages());
          Thread::setLanguages(new AcceptLanguageList(default_al));      }
     }catch(InvalidAcceptLanguageHeader& e){      catch(InvalidAcceptLanguageHeader& e)
       {
           Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,           Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                 MessageLoaderParms(
                   "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",                   "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
                   "Could not convert the system process locale into a valid AcceptLanguage format.");                    "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,
                              e.getMessage());                              e.getMessage());
     }     }
  
   
   
 #ifdef PEGASUS_OS_OS400  
     // Special server initialization code for OS/400.  
     if (cimserver_initialize() != 0)  
     {  
     // do some logging here!  
     //l10n  
     //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
             //"CIM Server failed to initialize");  
     Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,  
                   "src.Server.cimserver.SERVER_FAILED_TO_INITIALIZE",  
                   "CIM Server failed to initialize");  
     return(-1);  
     }  
 #endif  
   
   
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \ #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \
 || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \  || defined(PEGASUS_OS_ZOS) || defined(PEGASUS_OS_AIX) \
 || defined(PEGASUS_OS_SOLARIS) || defined (PEGASUS_OS_VMS) || defined(PEGASUS_OS_SOLARIS) || defined (PEGASUS_OS_VMS)
     umask(S_IWGRP|S_IWOTH);     umask(S_IWGRP|S_IWOTH);
  
Line 1114 
Line 723 
     // 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(_cimServerProcess->isCIMServerRunning())      if (_serverRunStatus.isServerRunning())
     {     {
     //l10n          MessageLoaderParms parms(
         //cout << "Unable to start CIMServer." << endl;              "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
         //cout << "CIMServer is already running." << endl;  
         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);          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)
           {
                 _cimServerProcess->notify_parent(1);                 _cimServerProcess->notify_parent(1);
           }
  
         return(1);          return 1;
     }     }
  
 #endif #endif
Line 1137 
Line 747 
     // try loop to bind the address, and run the server     // try loop to bind the address, and run the server
     try     try
     {     {
           _cimServer = new CIMServer();
     _monitor  = new Monitor();  
     //PEP#222  
     //CIMServer server(&monitor);  
     //CimserverHolder cimserverHolder( &server );  
     _cimServer = new CIMServer(_monitor);  
  
  
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
             _cimServer->addAcceptor(false, portNumberHttp, false, false);  #ifdef PEGASUS_ENABLE_IPV6
             //l10n              _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                  portNumberHttp, false);
                         //"Listening on HTTP port $0.", portNumberHttp);  #endif
   
   #if !defined (PEGASUS_ENABLE_IPV6) || defined (PEGASUS_OS_TYPE_WINDOWS)
               _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                   portNumberHttp, false);
   #endif
  
             Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              Logger::put_l(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   MessageLoaderParms(
                             "src.Server.cimserver.LISTENING_ON_HTTP_PORT",                             "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                             "Listening on HTTP port $0.", portNumberHttp);                      "Listening on HTTP port $0.", portNumberHttp));
         }         }
   
         if (enableHttpsConnection)         if (enableHttpsConnection)
         {         {
             _cimServer->addAcceptor(false, portNumberHttps, true, false);  #ifdef PEGASUS_ENABLE_IPV6
             //l10n              _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                  portNumberHttps, true);
                         //"Listening on HTTPS port $0.", portNumberHttps);  #endif
             Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,  
   #if !defined (PEGASUS_ENABLE_IPV6) || defined (PEGASUS_OS_TYPE_WINDOWS)
               _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                   portNumberHttps, true);
   #endif
   
               Logger::put_l(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   MessageLoaderParms(
                             "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));
         }         }
  
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
         _cimServer->addAcceptor(true, 0, false, false);          _cimServer->addAcceptor(HTTPAcceptor::LOCAL_CONNECTION, 0, false);
         //l10n  
         //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,          Logger::put_l(
                     //"Listening on local connection socket.");              Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              MessageLoaderParms(
               "src.Server.cimserver.LISTENING_ON_LOCAL",               "src.Server.cimserver.LISTENING_ON_LOCAL",
               "Listening on local connection socket.");                  "Listening on local connection socket."));
 #endif #endif
  
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
             //l10n              MessageLoaderParms parms(
             //cout << "Listening on HTTP port " << portNumberHttp << endl;                  "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
       MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTP_PORT",  
                    "Listening on HTTP port $0.", portNumberHttp);                    "Listening on HTTP port $0.", portNumberHttp);
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
         }         }
         if (enableHttpsConnection)         if (enableHttpsConnection)
         {         {
             //l10n              MessageLoaderParms parms(
             //cout << "Listening on HTTPS port " << portNumberHttps << endl;                  "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
             MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTPS_PORT",  
                      "Listening on HTTPS port $0.", portNumberHttps);                      "Listening on HTTPS port $0.", portNumberHttps);
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
         }         }
  
 # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
         //l10n          MessageLoaderParms parms(
         //cout << "Listening on local connection socket" << endl;              "src.Server.cimserver.LISTENING_ON_LOCAL",
         MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",  
                  "Listening on local connection socket.");                  "Listening on local connection socket.");
         cout << MessageLoader::getMessage(parms) << endl;         cout << MessageLoader::getMessage(parms) << endl;
 # endif # endif
 #endif #endif
  
         // bind throws an exception if the bind fails         // bind throws an exception if the bind fails
         try {  
            _cimServer->bind();            _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)
           {
         _cimServerProcess->notify_parent(0);         _cimServerProcess->notify_parent(0);
           }
  
     time_t last = 0;  #if defined(PEGASUS_OS_HPUX) || \
       defined(PEGASUS_OS_LINUX) || \
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_OS_LINUX) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) \      defined(PEGASUS_OS_ZOS) || \
     || defined(PEGASUS_OS_AIX) || defined(PEGASUS_OS_SOLARIS) \      defined(PEGASUS_OS_AIX) || \
     || defined(PEGASUS_OS_VMS)      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          _serverRunStatus.setServerRunning();
         System::removeFile(_cimServerProcess->getPIDFileName());  
   
         // open the file  
         FILE *pid_file = fopen(_cimServerProcess->getPIDFileName(), "w");  
   
         if (pid_file)  
         {  
             // save the pid in the file  
             fprintf(pid_file, "%ld\n", _cimServerProcess->get_server_pid());  
             fclose(pid_file);  
         }  
 #endif #endif
  
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
Line 1256 
Line 852 
         // Put server started message to the logger         // Put server started message to the logger
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
             Logger::INFORMATION,             Logger::INFORMATION,
               MessageLoaderParms(
             "src.Server.cimserver.STARTED_VERSION",             "src.Server.cimserver.STARTED_VERSION",
             "Started $0 version $1.",             "Started $0 version $1.",
             _cimServerProcess->getProductName(), _cimServerProcess->getVersion());                  _cimServerProcess->getProductName(),
                   _cimServerProcess->getVersion()));
  
         //         //
         // Loop to call CIMServer's runForever() method until CIMServer         // Loop to call CIMServer's runForever() method until CIMServer
Line 1277 
Line 875 
  
         // Put server shutdown message to the logger         // Put server shutdown message to the logger
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
             Logger::INFORMATION, "src.Server.cimserver.STOPPED",              Logger::INFORMATION,
             "$0 stopped.", _cimServerProcess->getProductName());              MessageLoaderParms(
                   "src.Server.cimserver.STOPPED",
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \                  "$0 stopped.", _cimServerProcess->getProductName()));
 || 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  
         // cimserver has terminated normally.  
         //  
         FileSystem::removeFile(_cimServerProcess->getPIDFileName());  
 #endif  
     }     }
     catch(Exception& e)     catch(Exception& e)
     {     {
           MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
     //l10n              "cimserver not started: $0", e.getMessage());
     //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             //"Error: $0", e.getMessage());              parms);
     Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,          cerr << MessageLoader::getMessage(parms) << endl;
             "src.Server.cimserver.ERROR",  
             "Error: $0", e.getMessage());  
   
 #ifndef PEGASUS_OS_OS400  
     //l10n  
     //PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);  
     MessageLoaderParms parms("src.Server.cimserver.ERROR",  
                              "Error: $0", e.getMessage());  
     PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);  
   
 #endif  
  
     //     //
         // notify parent process (if there is a parent process) to terminate         // notify parent process (if there is a parent process) to terminate
Line 1323 
Line 902 
     return 0;     return 0;
 } }
  
   
   
   

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