(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.199 and 1.217

version 1.199, 2007/05/25 18:35:21 version 1.217, 2008/03/05 22:27:38
Line 45 
Line 45 
 // //
 // cimserver daemon=false // cimserver daemon=false
 // //
 // The daemon config property has no effect on windows operation.  // The daemon config property has no effect on windows operation or when
   // privilege separation is enabled.
 // //
 // To shutdown pegasus, use the -s option: // To shutdown pegasus, use the -s option:
 // //
Line 83 
Line 84 
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/PegasusAssert.h> #include <Pegasus/Common/PegasusAssert.h>
 #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 96 
 #include <Service/ServerShutdownClient.h> #include <Service/ServerShutdownClient.h>
 #include <Service/ServerRunStatus.h> #include <Service/ServerRunStatus.h>
  
 #if defined(PEGASUS_OS_OS400)  
 #  include "vfyptrs.cinc"  
 #  include "OS400ConvertChar.h"  
 #endif  
   
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
   #include <Pegasus/Common/SetFileDescriptorToEBCDICEncoding.h>
 #include <Service/ARM_zOS.h> #include <Service/ARM_zOS.h>
 # ifdef PEGASUS_ZOS_SECURITY # ifdef PEGASUS_ZOS_SECURITY
 // This include file will not be provided in the OpenGroup CVS for now. // This include file will not be provided in the OpenGroup CVS for now.
Line 111 
Line 107 
 #endif #endif
  
 #if defined(PEGASUS_OS_TYPE_UNIX) #if defined(PEGASUS_OS_TYPE_UNIX)
 # if defined(PEGASUS_OS_OS400)  
 #  include <unistd.cleinc>  
 # else  
 #  include <unistd.h> #  include <unistd.h>
 # endif  
 # include <sys/types.h> # include <sys/types.h>
 # include <sys/stat.h> # include <sys/stat.h>
 # include <fcntl.h> # include <fcntl.h>
Line 129 
Line 121 
  
 #include <Pegasus/Common/Executor.h> #include <Pegasus/Common/Executor.h>
  
   #ifdef PEGASUS_OS_PASE
   # include <ILEWrapper/ILEUtilities2.h>
   # include <ILEWrapper/qumemultiutil.h>
   #endif
   
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 141 
Line 138 
 #define PEGASUS_SERVICE_DESCRIPTION "Pegasus CIM Object Manager Service"; #define PEGASUS_SERVICE_DESCRIPTION "Pegasus CIM Object Manager Service";
 #endif #endif
  
   #ifdef PEGASUS_OS_PASE
   #include <as400_protos.h> //for _SETCCSID
   #endif
   
 class CIMServerProcess : public ServerProcess class CIMServerProcess : public ServerProcess
 { {
 public: public:
  
     CIMServerProcess(void)      CIMServerProcess()
     {     {
         cimserver_set_process(this);         cimserver_set_process(this);
     }     }
  
     virtual ~CIMServerProcess(void)      virtual ~CIMServerProcess()
     {     {
     }     }
  
Line 190 
Line 191 
         return PEGASUS_PROCESS_NAME;         return PEGASUS_PROCESS_NAME;
     }     }
  
     //defined in Constants.h  
     virtual const char* getPIDFileName() const  
     {  
         return PEGASUS_CIMSERVER_START_FILE;  
     }  
   
     int cimserver_run(     int cimserver_run(
         int argc,         int argc,
         char** argv,         char** argv,
         Boolean shutdownOption,         Boolean shutdownOption,
         Boolean debugOutputOption);         Boolean debugOutputOption);
  
     void cimserver_stop(void);      void cimserver_stop();
 }; };
  
 ServerRunStatus _serverRunStatus( ServerRunStatus _serverRunStatus(
     PEGASUS_PROCESS_NAME, PEGASUS_CIMSERVER_START_FILE);     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;  
 static Thread* dummyInitialThread = 0; static Thread* dummyInitialThread = 0;
   
 // //
 //  The command name. //  The command name.
 // //
Line 238 
Line 233 
  
 static const char OPTION_DEBUGOUTPUT = 'X'; static const char OPTION_DEBUGOUTPUT = 'X';
  
 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.
  
Line 291 
Line 282 
     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 ("                      by appending [name]\n");     usage.append ("                      by appending [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 ("                      by appending [name]\n");     usage.append ("                      by appending [name]\n");
     usage.append ("    -start [name]   - starts pegasus as a Windows 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 ("                      by appending [name]\n");     usage.append ("                      by appending [name]\n");
     usage.append ("    -stop [name]    - stops pegasus as a Windows 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");     usage.append ("                      default CIM Server Service Name\n");
     usage.append ("                      by appending [name]\n\n");     usage.append ("                      by appending [name]\n\n");
 #endif #endif
     usage.append ("  configProperty=value\n");     usage.append ("  configProperty=value\n");
     usage.append ("                    - sets CIM Server configuration property\n");      usage.append("                    - sets CIM Server configuration "
           "property\n");
  
     cout << endl;     cout << endl;
     cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getCompleteVersion() << endl;      cout << _cimServerProcess->getProductName() << " " <<
           _cimServerProcess->getCompleteVersion() << 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 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  
     }  
     delete _monitor;  
    if (dummyInitialThread)    if (dummyInitialThread)
    {    {
         Thread::clearLanguages();         Thread::clearLanguages();
Line 351 
Line 342 
    }    }
 } }
  
 // l10n  
 // //
 // Dummy function for the Thread object associated with the initial thread. // Dummy function for the Thread object associated with the initial thread.
 // Since the initial thread is used to process CIM requests, this is // Since the initial thread is used to process CIM requests, this is
Line 360 
Line 350 
 // //
 ThreadReturnType PEGASUS_THREAD_CDECL dummyThreadFunc(void *parm) ThreadReturnType PEGASUS_THREAD_CDECL dummyThreadFunc(void *parm)
 { {
    return((ThreadReturnType)0);      return (ThreadReturnType)0;
 } }
  
 #ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION #ifdef PEGASUS_ENABLE_PRIVILEGE_SEPARATION
Line 446 
Line 436 
     Boolean shutdownOption = false;     Boolean shutdownOption = false;
     Boolean debugOutputOption = false;     Boolean debugOutputOption = false;
  
 //l10n  
 // Set Message loading to process locale // Set Message loading to process locale
 MessageLoader::_useProcessLocale = true; MessageLoader::_useProcessLocale = true;
 //l10n  
   
 //l10n  
 #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)  
 setlocale(LC_ALL, "");  
 #endif  
   
 #ifdef PEGASUS_OS_OS400  
  
   VFYPTRS_INCDCL;               // VFYPTRS local variables  #ifdef PEGASUS_OS_ZOS
       // Direct standard input to /dev/null,
   // verify pointers      close(STDIN_FILENO);
   #pragma exception_handler (qsyvp_excp_hndlr,qsyvp_excp_comm_area,\      open("/dev/null", O_RDONLY);
     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      if ( setEBCDICEncoding(STDOUT_FILENO)==-1 ||
     for(Uint32 i = 0;i< argc;++i)           setEBCDICEncoding(STDERR_FILENO)==-1 )
     {     {
     EtoA(argv[i]);         PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL4,
              "Coud not set stdout or stderr to EBCDIC encoding.");
     }     }
       // Need to initialize timezone information in the
     // Initialize Pegasus home to the shipped OS/400 directory.      // initial processing thread (IPT)
     pegasusHome = OS400_DEFAULT_PEGASUS_HOME;      tzset();
 #endif #endif
  
   #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)
       setlocale(LC_ALL, "");
   #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) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  # elif defined(PEGASUS_OS_PASE)
       const char *tmp = getenv("PEGASUS_HOME");
       pegasusHome = (tmp == 0) ? PASE_DEFAULT_PEGASUS_HOME : tmp;
   # elif !defined(PEGASUS_USE_RELEASE_DIRS) || \
       defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
     const char* tmp = getenv("PEGASUS_HOME");     const char* tmp = getenv("PEGASUS_HOME");
  
     if (tmp)     if (tmp)
Line 505 
Line 477 
         pegasusHome = tmp;         pegasusHome = tmp;
     }     }
   #endif   #endif
 #endif  
  
     FileSystem::translateSlashes(pegasusHome);     FileSystem::translateSlashes(pegasusHome);
 #else #else
Line 538 
Line 509 
         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"))              if (strcmp(arg, "--help") == 0)
             {             {
                     PrintHelp(argv[0]);                     PrintHelp(argv[0]);
                   Executor::daemonizeExecutor();
                     exit(0);                     exit(0);
             }             }
             else if(String::equal(arg,"--version"))              else if (strcmp(arg, "--version") == 0)
             {             {
                 cout << _cimServerProcess->getCompleteVersion() << endl;                 cout << _cimServerProcess->getCompleteVersion() << endl;
                   Executor::daemonizeExecutor();
                 exit(0);                 exit(0);
             }             }
             // Check for -option             // Check for -option
Line 561 
Line 534 
                     strlen(option) == 1)                     strlen(option) == 1)
                 {                 {
                     cout << _cimServerProcess->getCompleteVersion() << endl;                     cout << _cimServerProcess->getCompleteVersion() << endl;
                       Executor::daemonizeExecutor();
                     exit(0);                     exit(0);
                 }                 }
                 //                 //
Line 570 
Line 544 
                         (strlen(option) == 1))                         (strlen(option) == 1))
                 {                 {
                     PrintHelp(argv[0]);                     PrintHelp(argv[0]);
                       Executor::daemonizeExecutor();
                     exit(0);                     exit(0);
                 }                 }
 #if !defined(PEGASUS_USE_RELEASE_DIRS) #if !defined(PEGASUS_USE_RELEASE_DIRS)
Line 582 
Line 557 
                     }                     }
                     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(1);
                     }                     }
  
                     memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));                     memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
Line 628 
Line 602 
                     //                     //
                     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;
                         exit(0);                          exit(1);
                     }                     }
  
                     shutdownOption = true;                     shutdownOption = true;
Line 687 
Line 660 
     Boolean shutdownOption,     Boolean shutdownOption,
     Boolean debugOutputOption)     Boolean debugOutputOption)
 { {
     String logsDirectory;  
     Boolean daemonOption = false;     Boolean daemonOption = false;
  
     //  #if defined (PEGASUS_OS_PASE) && !defined (PEGASUS_DEBUG)
     // Get an instance of the Config Manager.      // PASE have itself regular for checking privileged user
     //      if (!System::isPrivilegedUser("*CURRENT  "))
     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;          MessageLoaderParms parms(
         daemonOption = true;                  "src.Server.cimserver.NO_AUTHORITY.PEGASUS_OS_PASE",
                   "The caller should be a privileged user,"
                   " or the server will not run.");
           cerr << MessageLoader::getMessage(parms) << endl;
           exit (1);
       }       }
       char jobName[11];
     if (!os400StartupOption)      // this function only can be found in PASE environment
       umeGetJobName(jobName, false);
       if (strncmp("QUMECIMOM ", jobName, 10) != 0
               && strncmp("QUMEENDCIM", jobName, 10) != 0)
     {     {
         // If this is the server job, then set the job          MessageLoaderParms parms(
         // to save the job log.                  "src.Server.cimserver.NOT_OFFICIAL_START.PEGASUS_OS_PASE",
         system ("QSYS/CHGJOB JOB(*) LOG(4 00 *SECLVL)");                  "cimserver can not be started by user.\nServer will not run.");
           cerr << MessageLoader::getMessage(parms) << endl;
           exit (1);
     }     }
   
       // Direct standard input, output, and error to /dev/null,
       // PASE run this job in background, any output in not allowed
       freopen("/dev/null", "r", stdin);
       freopen("/dev/null", "w", stdout);
       freopen("/dev/null", "w", stderr);
 #endif #endif
  
     //     //
     // Get options (from command line and from configuration file); this      // Get an instance of the Config Manager.
     // removes corresponding options and their arguments from the command  
     // line.  
     //     //
       ConfigManager* configManager = ConfigManager::getInstance();
       configManager->useConfigFiles = true;
   
     try     try
     {     {
 #ifdef PEGASUS_OS_OS400          //
     if (os400StartupOption == false)          // Get options (from command line and from configuration file); this
 #endif          // removes corresponding options and their arguments from the command
         // If current process is "cimserver -s" (shutdown option = true) the contents          // line.  NOTE: If shutdownOption=true, the contents of current config
         // of current config should not be overwriten by planned config          // file are not overwritten by the planned config file.
           //
         GetOptions(configManager, argc, argv, shutdownOption);         GetOptions(configManager, argc, argv, shutdownOption);
     }  
     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",  
             "cimserver not started: $0", e.getMessage());  
  
         PEGASUS_STD(cerr) << argv[0] << ": " << MessageLoader::getMessage(parms)          //
             << PEGASUS_STD(endl);          // Initialize the message home directory in the MessageLoader.
 #endif          // This is the default directory where the resource bundles are found.
           //
         return(1);  
     }  
   
 // l10n  
     // Set the home directory, msg sub-dir, into the MessageLoader.  
     // This will be the default directory where the resource bundles  
     // are found.  
     MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(     MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
         ConfigManager::getInstance()->getCurrentValue("messageDir")));         ConfigManager::getInstance()->getCurrentValue("messageDir")));
  
 #ifdef PEGASUS_OS_OS400  #ifdef PEGASUS_OS_PASE
     // Still need to declare and set the connection variables.      // set ccsid to unicode for entire job
     // Will initialize to false since they are fixed at false for OS400.      // ccsid is globolization mechanism in PASE environment
       if (_SETCCSID(1208) == -1)
     // 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(          MessageLoaderParms parms(
           configManager->getCurrentValue("enableHttpConnection"));                  "src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",
       enableHttpsConnection = ConfigManager::parseBooleanValue(                  "Failed to set CCSID, server will stop.");
           configManager->getCurrentValue("enableHttpsConnection"));          cerr << MessageLoader::getMessage(parms) << endl;
           Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::FATAL,
                   "src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",
                   "Failed to set CCSID, server will stop.\n");
           exit (1);
     }     }
 #else  
       char fullJobName[29];
       umeGetJobName(fullJobName, true);
       Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
               "src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",
               "CIM Server's Job Name is: $0", fullJobName);
   #endif
   
     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
Line 798 
Line 753 
             //"CIMServer will not be started.");             //"CIMServer will not be started.");
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,         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."
               "  CIMServer will not be started.");
         //cerr << "Neither HTTP nor HTTPS connection is enabled.  "         //cerr << "Neither HTTP nor HTTPS connection is enabled.  "
             //"CIMServer will not be started." << endl;             //"CIMServer will not be started." << endl;
         MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",          MessageLoaderParms parms(
                                  "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");                  "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
   
     try  
     {  
         //         //
         // Check to see if we should start Pegasus as a daemon         // Check to see if we should start Pegasus as a daemon
         //         //
   
         daemonOption = ConfigManager::parseBooleanValue(         daemonOption = ConfigManager::parseBooleanValue(
             configManager->getCurrentValue("daemon"));             configManager->getCurrentValue("daemon"));
  
 #ifdef PEGASUS_OS_OS400          if ((Executor::detectExecutor() == 0) && (daemonOption == false))
     if (os400StartupOption == false)  
     {     {
 #endif              MessageLoaderParms parms(
                   "src.Server.cimserver.PRIVSEP_REQUIRES_DAEMON",
                   "Warning: The configuration setting daemon=false is ignored "
                       "with privilege separation enabled.");
               cerr << MessageLoader::getMessage(parms) << endl;
               daemonOption = true;
           }
   
 #if !defined(PEGASUS_USE_SYSLOGS) #if !defined(PEGASUS_USE_SYSLOGS)
         logsDirectory =          String logsDirectory = ConfigManager::getHomedPath(
         ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));              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.  
   
 #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \  
 !defined(PEGASUS_OS_OS400) && !defined(PEGASUS_USE_SYSLOGS)  
         Logger::setHomeDirectory(logsDirectory);         Logger::setHomeDirectory(logsDirectory);
   
   # ifdef PEGASUS_OS_PASE
       /* write job log to tell where pegasus log is.*/
       if(logsDirectory.size() > 0)
           // this function only can be found in PASE environment
           logPegasusDir2joblog(logsDirectory.getCString());
       else
           logPegasusDir2joblog(".");
   # endif
 #endif #endif
  
         //         //
Line 845 
Line 806 
         {         {
             String configTimeout =             String configTimeout =
                 configManager->getCurrentValue("shutdownTimeout");                 configManager->getCurrentValue("shutdownTimeout");
             Uint32 timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);              Uint32 timeoutValue =
 // To deregister Pegasus with SLP                  strtol(configTimeout.getCString(), (char **)0, 10);
 #ifdef PEGASUS_SLP_REG_TIMEOUT  
             unregisterPegasusFromSLP();  
 #endif  
  
             ServerShutdownClient serverShutdownClient(&_serverRunStatus);             ServerShutdownClient serverShutdownClient(&_serverRunStatus);
             serverShutdownClient.shutdown(timeoutValue);             serverShutdownClient.shutdown(timeoutValue);
  
 #ifdef PEGASUS_OS_OS400  
         Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,  
             "src.Server.cimserver.SERVER_STOPPED",  
             "CIM Server stopped.");  
             cimserver_exitRC(0);  
 #else  
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.SERVER_STOPPED",                 "src.Server.cimserver.SERVER_STOPPED",
                 "CIM Server stopped.");                 "CIM Server stopped.");
  
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
             return(0);              return 0;
 #endif  
         }         }
  
 #if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS) #if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS)
Line 876 
Line 827 
         cout << MessageLoader::getMessage(parms) << logsDirectory << endl;         cout << MessageLoader::getMessage(parms) << logsDirectory << endl;
 #endif #endif
     }     }
     catch (UnrecognizedConfigProperty& e)      catch (Exception& e)
     {  
         // UnrecognizedConfigProperty is already translated  
         // thus, just output the message  
         Logger::put(Logger::ERROR_LOG,  
                     System::CIMSERVER,  
                     Logger::SEVERE,  
                     e.getMessage());  
 #ifndef PEGASUS_OS_OS400  
         cout << e.getMessage() << endl;  
 #endif  
     }  
     catch (Exception& ex)  
     {     {
         Logger::put(Logger::ERROR_LOG,          MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
                       System::CIMSERVER,              "cimserver not started: $0", e.getMessage());
                       Logger::SEVERE,          Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                       ex.getMessage());              MessageLoader::getMessage(parms));
 #ifndef PEGASUS_OS_OS400          cerr << MessageLoader::getMessage(parms) << endl;
         cout << ex.getMessage() << endl;  
 #endif          return 1;
         exit(1);  
     }     }
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY)
Line 906 
Line 844 
     startupEnableMSC();     startupEnableMSC();
 #endif #endif
  
     // 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.  
     // 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)  
     {  
         String httpsPort = configManager->getCurrentValue("httpsPort");  
         if (httpsPort == String::EMPTY)  
         {  
             //  
             // Look up the WBEM-HTTPS port number  
             //  
             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)  
     {  
         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();  
             char* end = 0;  
             portNumberHttp = strtol(portString, &end, 10);  
             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 defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
     // Put out startup up message.     // Put out startup up message.
     cout << _cimServerProcess->getProductName() << " " << _cimServerProcess->getCompleteVersion() << endl;      cout << _cimServerProcess->getProductName() << " " <<
     //l10n          _cimServerProcess->getCompleteVersion() << 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
     _serverRunStatus.setParentPid(System::getPID());     _serverRunStatus.setParentPid(System::getPID());
  
 // Do not fork when using privilege separation (executor will daemonize itself      // Do not fork when using privilege separation (executor will daemonize
 // later).      // itself later).
     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  
     // 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
     // AcceptLanguageList object for CIM requests that are serviced     // AcceptLanguageList object for CIM requests that are serviced
Line 1030 
Line 873 
     // The run function for the dummy Thread should never be called,     // The run function for the dummy Thread should never be called,
     dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);     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,
                   "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  
   
 #ifndef PEGASUS_OS_TYPE_WINDOWS #ifndef PEGASUS_OS_TYPE_WINDOWS
     umask(S_IRWXG|S_IRWXO);     umask(S_IRWXG|S_IRWXO);
 #endif #endif
  
       // Start up the CIM Server
  
       try
       {
 #if defined(PEGASUS_OS_TYPE_UNIX) #if defined(PEGASUS_OS_TYPE_UNIX)
   //   //
   // CRITICAL SECTION BEGIN          // Lock the CIMSERVER_LOCK_FILE during CIM Server start-up to prevent
           // concurrent writes to this file by multiple cimserver processes
           // starting at the same time.
   //   //
   // This is the beginning of the critical section regarding the          CString startupLockFileName = ConfigManager::getHomedPath(
   // access to pidfile (file to indicate that the cimserver has started).              PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();
   // 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.  
  
           // Make sure the start-up lock file exists
   FILE *startupLockFile;   FILE *startupLockFile;
           if ((startupLockFile = fopen(startupLockFileName, "w")) != 0)
   if ((startupLockFile = fopen(ConfigManager::getHomedPath(  
           CIMSERVER_LOCK_FILE).getCString(), "w")) != 0)  
   {   {
       lockf(fileno(startupLockFile), F_LOCK, 0);              fclose(startupLockFile);
   }   }
 #endif  
  
 #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) \          AutoFileLock fileLock(startupLockFileName);
 || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) || defined(PEGASUS_OS_AIX) \  #endif
 || defined(PEGASUS_OS_SOLARIS) || defined (PEGASUS_OS_VMS)  
  
   #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
     //     //
     // check if CIMServer is already running          // Check if a CIM Server is already running.  If so, print an error
     // if CIMServer is already running, print message and          // message and notify the parent process (if there is one) to terminate
     // notify parent process (if there is a parent process) to terminate  
     //     //
     if (_serverRunStatus.isServerRunning())     if (_serverRunStatus.isServerRunning())
     {     {
         MessageLoaderParms parms(         MessageLoaderParms parms(
             "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",             "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
             "Unable to start CIMServer. CIMServer is already running.");             "Unable to start CIMServer. CIMServer is already running.");
         PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) <<              Logger::put(
             PEGASUS_STD(endl);                  Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
         Logger::put(Logger::ERROR_LOG,System::CIMSERVER,Logger::INFORMATION,  
             MessageLoader::getMessage(parms));             MessageLoader::getMessage(parms));
               cerr << MessageLoader::getMessage(parms) << endl;
  
         //  
         // notify parent process (if there is a parent process) to terminate  
         //  
         if (daemonOption)         if (daemonOption)
         {         {
             _cimServerProcess->notify_parent(1);             _cimServerProcess->notify_parent(1);
Line 1113 
Line 937 
         return 1;         return 1;
     }     }
  
           //
           // Declare ourselves as the running CIM Server process, and write our
           // PID to the PID file.
           //
           _serverRunStatus.setServerRunning();
 #endif #endif
  
     // try loop to bind the address, and run the server          // Create and initialize the CIMServer object
     try  
     {  
         _monitor = new Monitor();  
         _cimServer = new CIMServer(_monitor);  
  
         if (enableHttpConnection)          _cimServer = new CIMServer();
         {  
             _cimServer->addAcceptor(false, portNumberHttp, false);  
  
             Logger::put_l(          Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              configManager->getCurrentValue("enableHttpConnection"));
                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",          Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
                 "Listening on HTTP port $0.", portNumberHttp);              configManager->getCurrentValue("enableHttpsConnection"));
         }  
  
         if (enableHttpsConnection)  #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
           // Make sure at least one connection is enabled
           if (!enableHttpConnection && !enableHttpsConnection)
         {         {
             _cimServer->addAcceptor(false, portNumberHttps, true);              MessageLoaderParms parms(
                   "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
             Logger::put_l(                  "Neither HTTP nor HTTPS connection is enabled.");
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,              throw Exception(parms);
                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",  
                 "Listening on HTTPS port $0.", portNumberHttps);  
         }         }
   #endif
  
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET          Boolean addIP6Acceptor = false;
         _cimServer->addAcceptor(true, 0, false);          Boolean addIP4Acceptor = false;
  
         Logger::put_l(  #ifdef PEGASUS_OS_TYPE_WINDOWS
             Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,          addIP4Acceptor = true;
             "src.Server.cimserver.LISTENING_ON_LOCAL",  
             "Listening on local connection socket.");  
 #endif #endif
  
   #ifdef PEGASUS_ENABLE_IPV6
           // If IPv6 stack is disabled swicth to IPv4 stack.
           if (System::isIPv6StackActive())
           {
               addIP6Acceptor = true;
           }
           else
           {
               MessageLoaderParms parms(
                   "src.Server.cimserver.IPV6_STACK_NOT_ACTIVE",
                   "IPv6 stack is not active, using IPv4 socket.");
               Logger::put(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   MessageLoader::getMessage(parms));
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
               cout << MessageLoader::getMessage(parms) << endl;
   #endif
           }
   #endif
           if (!addIP6Acceptor)
           {
               addIP4Acceptor = true;
           }
   
           // The server HTTP and HTTPS ports are determined via this algorithm:
           // 1) If the user explicitly specified a port, use it.
           // 2) If the user did not specify a port, get the port from the
           //    services file.
           // 3) If no value is specified in the services file, use the IANA WBEM
           //    default port.
           // Note that 2 and 3 are done within the System::lookupPort method
           // An empty string from the ConfigManager implies that the user did not
           // specify a port.
   
         if (enableHttpConnection)         if (enableHttpConnection)
         {         {
               Uint32 portNumberHttp = 0;
               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();
                   char* end = 0;
                   portNumberHttp = strtol(portString, &end, 10);
                   if (!(end != 0 && *end == '\0'))
                   {
                       throw InvalidPropertyValue("httpPort", httpPort);
                   }
               }
   
               if (addIP6Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
                       portNumberHttp, false);
               }
               if (addIP4Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                       portNumberHttp, false);
               }
   
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                 "Listening on HTTP port $0.", portNumberHttp);                 "Listening on HTTP port $0.", portNumberHttp);
               Logger::put(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   MessageLoader::getMessage(parms));
   #if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
   #endif
         }         }
   
         if (enableHttpsConnection)         if (enableHttpsConnection)
         {         {
               Uint32 portNumberHttps = 0;
               String httpsPort = configManager->getCurrentValue("httpsPort");
               if (httpsPort == String::EMPTY)
               {
                   //
                   // Look up the WBEM-HTTPS port number
                   //
                   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'))
                   {
                       throw InvalidPropertyValue("httpsPort", httpsPort);
                   }
               }
               if (addIP6Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
                       portNumberHttps, true);
               }
               if (addIP4Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                       portNumberHttps, true);
               }
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                 "Listening on HTTPS port $0.", portNumberHttps);                 "Listening on HTTPS port $0.", portNumberHttps);
               Logger::put(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   MessageLoader::getMessage(parms));
   #if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
   #endif
         }         }
  
 # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET # ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
           {
               _cimServer->addAcceptor(HTTPAcceptor::LOCAL_CONNECTION, 0, false);
   
         MessageLoaderParms parms(         MessageLoaderParms parms(
             "src.Server.cimserver.LISTENING_ON_LOCAL",             "src.Server.cimserver.LISTENING_ON_LOCAL",
             "Listening on local connection socket.");             "Listening on local connection socket.");
               Logger::put(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   MessageLoader::getMessage(parms));
   # if defined(PEGASUS_DEBUG)
         cout << MessageLoader::getMessage(parms) << endl;         cout << MessageLoader::getMessage(parms) << endl;
 # endif # endif
           }
 #endif #endif
  
         _cimServer->bind();         _cimServer->bind();
Line 1180 
Line 1121 
         // 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)
         {         {
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)  
             Executor::daemonizeExecutor();  
 #else  
             _cimServerProcess->notify_parent(0);             _cimServerProcess->notify_parent(0);
 #endif  
         }         }
  
 #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  
         // save the process id of the cimserver process in the file  
         //  
         _serverRunStatus.setServerRunning();  
 #endif  
   
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
     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
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
             Logger::INFORMATION,             Logger::INFORMATION,
Line 1231 
Line 1141 
         {         {
             // Direct standard input, output, and error to /dev/null,             // Direct standard input, output, and error to /dev/null,
             // since we are running as a daemon.             // since we are running as a daemon.
             close(0);              close(STDIN_FILENO);
             open("/dev/null", O_RDONLY);             open("/dev/null", O_RDONLY);
             close(1);              close(STDOUT_FILENO);
             open("/dev/null", O_RDWR);             open("/dev/null", O_RDWR);
             close(2);              close(STDERR_FILENO);
             open("/dev/null", O_RDWR);             open("/dev/null", O_RDWR);
         }         }
 #endif #endif
       }
       catch (Exception& e)
       {
           MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
               "cimserver not started: $0", e.getMessage());
           Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
               MessageLoader::getMessage(parms));
           cerr << MessageLoader::getMessage(parms) << endl;
   
           //
           // notify parent process (if there is a parent process) to terminate
           //
           if (daemonOption)
               _cimServerProcess->notify_parent(1);
  
           deleteCIMServer();
           return 1;
       }
   
       // Run the main CIM Server loop
   
       try
       {
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
  
         // ARM is a z/OS internal restart facility.         // ARM is a z/OS internal restart facility.
Line 1253 
Line 1185 
  
 #endif #endif
  
           // In case we don't want to reregister to SLP
           // (i.e. PEGASUS_SLP_REG_TIMEOUT not set) after CIM Server startup,
           // the SLP Provider is started only once,
           // right short before entering the runForever loop which then can handle
           // the invokeMethod call against the SLP provider
           // function startSLPProvider() does create a separate thread to process
           // so code continues to go into the forever loop before executing any
           // requests against the CIM Server
   #ifdef PEGASUS_ENABLE_SLP
   # ifndef PEGASUS_SLP_REG_TIMEOUT
           _cimServer->startSLPProvider();
   # endif
   #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( !_cimServer->terminated() )     while( !_cimServer->terminated() )
     {     {
   
       _cimServer->runForever();       _cimServer->runForever();
   
     }     }
  
         //         //
         // normal termination         // normal termination
         //         //
   
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
  
         // ARM is a z/OS internal restart facility.         // ARM is a z/OS internal restart facility.
Line 1281 
Line 1225 
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
             Logger::INFORMATION, "src.Server.cimserver.STOPPED",             Logger::INFORMATION, "src.Server.cimserver.STOPPED",
             "$0 stopped.", _cimServerProcess->getProductName());             "$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)  
         //  
         //  Note: do not remove the PID file created at startup time, since  
         //  shutdown is not complete until the CIMServer destructor completes.  
         //  
 #endif  
     }  
     catch(BindFailedException& 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",  
             "cimserver not started: $0", e.getMessage());  
   
         cerr << MessageLoader::getMessage(parms) << endl;  
 #endif  
   
     //  
         // notify parent process (if there is a parent process) to terminate  
         //  
         if (daemonOption)  
                 _cimServerProcess->notify_parent(1);  
   
         deleteCIMServer();  
         return 1;  
     }     }
     catch(Exception& e)     catch(Exception& e)
     {     {
     Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,          MessageLoaderParms parms(
             "src.Server.cimserver.ERROR",             "src.Server.cimserver.ERROR",
             "Error: $0", e.getMessage());              "Error: $0",
 #ifndef PEGASUS_OS_OS400              e.getMessage());
     MessageLoaderParms parms("src.Server.cimserver.ERROR",          Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                              "Error: $0", e.getMessage());              MessageLoader::getMessage(parms));
     PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);          cerr << MessageLoader::getMessage(parms) << endl;
 #endif  
         //  
         // notify parent process (if there is a parent process) to terminate  
         //  
         if (daemonOption)  
                 _cimServerProcess->notify_parent(1);  
  
         deleteCIMServer();         deleteCIMServer();
         return 1;         return 1;

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