(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.203 and 1.224

version 1.203, 2007/06/22 17:35:53 version 1.224, 2008/11/11 04:59:56
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 85 
Line 86 
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
   #include <Pegasus/Common/StringConversion.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/LanguageParser.h> #include <Pegasus/Common/LanguageParser.h>
Line 95 
Line 97 
 #include <Service/ServerShutdownClient.h> #include <Service/ServerShutdownClient.h>
 #include <Service/ServerRunStatus.h> #include <Service/ServerRunStatus.h>
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
   #include <Pegasus/Common/SetFileDescriptorToEBCDICEncoding.h>
 #include <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 119 
Line 122 
  
 #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 131 
Line 139 
 #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:
Line 428 
Line 440 
     // Set Message loading to process locale     // Set Message loading to process locale
     MessageLoader::_useProcessLocale = true;     MessageLoader::_useProcessLocale = true;
  
   #ifdef PEGASUS_OS_ZOS
       // Direct standard input to /dev/null,
       close(STDIN_FILENO);
       open("/dev/null", O_RDONLY);
   
       if ( setEBCDICEncoding(STDOUT_FILENO)==-1 ||
            setEBCDICEncoding(STDERR_FILENO)==-1 )
       {
          PEG_TRACE_CSTRING(TRC_SERVER,Tracer::LEVEL1,
              "Coud not set stdout or stderr to EBCDIC encoding.");
       }
       // Need to initialize timezone information in the
       // initial processing thread (IPT)
       tzset();
   #endif
   
 #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES) #if defined(PEGASUS_OS_AIX) && defined(PEGASUS_HAS_MESSAGES)
     setlocale(LC_ALL, "");     setlocale(LC_ALL, "");
 #endif #endif
Line 438 
Line 466 
     //     //
 # 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_OS_PASE)
       const char *tmp = getenv("PEGASUS_HOME");
       pegasusHome = (tmp == 0) ? PASE_DEFAULT_PEGASUS_HOME : tmp;
 # elif !defined(PEGASUS_USE_RELEASE_DIRS) || \ # elif !defined(PEGASUS_USE_RELEASE_DIRS) || \
     defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)      defined(PEGASUS_OS_ZOS)
     const char* tmp = getenv("PEGASUS_HOME");     const char* tmp = getenv("PEGASUS_HOME");
  
     if (tmp)     if (tmp)
Line 479 
Line 510 
         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 502 
Line 535 
                     strlen(option) == 1)                     strlen(option) == 1)
                 {                 {
                     cout << _cimServerProcess->getCompleteVersion() << endl;                     cout << _cimServerProcess->getCompleteVersion() << endl;
                       Executor::daemonizeExecutor();
                     exit(0);                     exit(0);
                 }                 }
                 //                 //
Line 511 
Line 545 
                         (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 529 
Line 564 
                             "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 573 
Line 608 
                             "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 628 
Line 663 
 { {
     Boolean daemonOption = false;     Boolean daemonOption = false;
  
   #if defined (PEGASUS_OS_PASE) && !defined (PEGASUS_DEBUG)
       // PASE have itself regular for checking privileged user
       if (!System::isPrivilegedUser("*CURRENT  "))
       {
           MessageLoaderParms parms(
                   "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];
       // this function only can be found in PASE environment
       umeGetJobName(jobName, false);
       if (strncmp("QUMECIMOM ", jobName, 10) != 0
               && strncmp("QUMEENDCIM", jobName, 10) != 0)
       {
           MessageLoaderParms parms(
                   "src.Server.cimserver.NOT_OFFICIAL_START.PEGASUS_OS_PASE",
                   "cimserver can not be started by user.\nServer will not run.");
           cerr << MessageLoader::getMessage(parms) << endl;
           exit (1);
       }
   
       // Direct standard input, output, and error to /dev/null,
       // 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
   
     //     //
     // Get an instance of the Config Manager.     // Get an instance of the Config Manager.
     //     //
Line 651 
Line 717 
         MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(         MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
             ConfigManager::getInstance()->getCurrentValue("messageDir")));             ConfigManager::getInstance()->getCurrentValue("messageDir")));
  
         //  
         // Check to see if we should start Pegasus as a daemon  
         //  
         daemonOption = ConfigManager::parseBooleanValue(  
             configManager->getCurrentValue("daemon"));  
   
 #if !defined(PEGASUS_USE_SYSLOGS) #if !defined(PEGASUS_USE_SYSLOGS)
         String logsDirectory = ConfigManager::getHomedPath(         String logsDirectory = ConfigManager::getHomedPath(
             configManager->getCurrentValue("logdir"));             configManager->getCurrentValue("logdir"));
Line 666 
Line 726 
         Logger::setHomeDirectory(logsDirectory);         Logger::setHomeDirectory(logsDirectory);
 #endif #endif
  
   
   #ifdef PEGASUS_OS_PASE
           /* write job log to tell where pegasus log is.*/
           if(logsDirectory.size() > 0)
               // this function only can be found in PASE environment
               logPegasusDir2joblog(logsDirectory.getCString());
           else
               logPegasusDir2joblog(".");
   
           // set ccsid to unicode for entire job
           // ccsid is globolization mechanism in PASE environment
           if (_SETCCSID(1208) == -1)
           {
               MessageLoaderParms parms(
                       "src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",
                       "Failed to set CCSID, server will stop.");
               cerr << MessageLoader::getMessage(parms) << endl;
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::FATAL,
                       parms);
               exit (1);
           }
   
           char fullJobName[29];
           umeGetJobName(fullJobName, true);
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
                   Logger::INFORMATION,
                   MessageLoaderParms(
                       "src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",
                       "CIM Server's Job Name is: $0", fullJobName));
   #endif
   
   #ifdef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
           // Make sure at least one connection is enabled
   
           Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
               configManager->getCurrentValue("enableHttpConnection"));
           Boolean enableHttpsConnection = ConfigManager::parseBooleanValue(
               configManager->getCurrentValue("enableHttpsConnection"));
   
           if (!enableHttpConnection && !enableHttpsConnection)
           {
               MessageLoaderParms parms(
                   "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
                   "Neither HTTP nor HTTPS connection is enabled."
                       "  CIMServer will not be started.");
               Logger::put_l(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                   parms);
               cerr << MessageLoader::getMessage(parms) << endl;
               return 1;
           }
   #endif
   
           //
           // Check to see if we should start Pegasus as a daemon
           //
           daemonOption = ConfigManager::parseBooleanValue(
               configManager->getCurrentValue("daemon"));
   
           if ((Executor::detectExecutor() == 0) && (daemonOption == false))
           {
               MessageLoaderParms parms(
                   "src.Server.cimserver.PRIVSEP_REQUIRES_DAEMON",
                   "Warning: The configuration setting daemon=false is ignored "
                       "with privilege separation enabled.");
               cerr << MessageLoader::getMessage(parms) << endl;
               daemonOption = true;
           }
   
         //         //
         // Check to see if we need to shutdown CIMOM         // Check to see if we need to shutdown CIMOM
         //         //
Line 675 
Line 804 
                 configManager->getCurrentValue("shutdownTimeout");                 configManager->getCurrentValue("shutdownTimeout");
             Uint32 timeoutValue =             Uint32 timeoutValue =
                 strtol(configTimeout.getCString(), (char **)0, 10);                 strtol(configTimeout.getCString(), (char **)0, 10);
 #ifdef PEGASUS_SLP_REG_TIMEOUT  
             // To deregister Pegasus with SLP  
             unregisterPegasusFromSLP();  
 #endif  
  
             ServerShutdownClient serverShutdownClient(&_serverRunStatus);             ServerShutdownClient serverShutdownClient(&_serverRunStatus);
             serverShutdownClient.shutdown(timeoutValue);             serverShutdownClient.shutdown(timeoutValue);
Line 702 
Line 827 
     {     {
         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
             "cimserver not started: $0", e.getMessage());             "cimserver not started: $0", e.getMessage());
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             MessageLoader::getMessage(parms));              parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
  
         return 1;         return 1;
     }     }
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY)  #if defined(PEGASUS_OS_ZOS) && defined(PEGASUS_ZOS_SECURITY)
     startupCheckBPXServer(true);     startupCheckBPXServer(true);
     startupCheckProfileCIMSERVclassWBEM();     startupCheckProfileCIMSERVclassWBEM();
     startupEnableMSC();     startupEnableMSC();
Line 744 
Line 869 
     // 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,
               MessageLoaderParms(
             "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",             "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
             "Could not convert the system process locale into a valid "             "Could not convert the system process locale into a valid "
                 "AcceptLanguage format.");                      "AcceptLanguage format."));
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             e.getMessage());             e.getMessage());
     }     }
Line 775 
Line 899 
         // starting at the same time.         // starting at the same time.
         //         //
         CString startupLockFileName = ConfigManager::getHomedPath(         CString startupLockFileName = ConfigManager::getHomedPath(
             CIMSERVER_LOCK_FILE).getCString();              PEGASUS_CIMSERVER_START_LOCK_FILE).getCString();
  
         // Make sure the start-up lock file exists         // Make sure the start-up lock file exists
         FILE* startupLockFile;         FILE* startupLockFile;
Line 797 
Line 921 
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",                 "src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
                 "Unable to start CIMServer. CIMServer is already running.");                 "Unable to start CIMServer. CIMServer is already running.");
             Logger::put(              Logger::put_l(
                 Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
             cerr << MessageLoader::getMessage(parms) << endl;             cerr << MessageLoader::getMessage(parms) << endl;
  
             if (daemonOption)             if (daemonOption)
Line 837 
Line 961 
         }         }
 #endif #endif
  
           Boolean addIP6Acceptor = false;
           Boolean addIP4Acceptor = false;
   
   #ifdef PEGASUS_OS_TYPE_WINDOWS
           addIP4Acceptor = true;
   #endif
   
   #ifdef PEGASUS_ENABLE_IPV6
           // If IPv6 stack is disabled swicth to IPv4 stack.
           if (System::isIPv6StackActive())
           {
               addIP6Acceptor = true;
           }
           else
           {
               MessageLoaderParms parms(
                   "src.Server.cimserver.IPV6_STACK_NOT_ACTIVE",
                   "IPv6 stack is not active, using IPv4 socket.");
               Logger::put_l(
                   Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   parms);
   #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:         // The server HTTP and HTTPS ports are determined via this algorithm:
         // 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         // 2) If the user did not specify a port, get the port from the
Line 873 
Line 1028 
                 }                 }
             }             }
  
             _cimServer->addAcceptor(false, portNumberHttp, false);              if (addIP6Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
                       portNumberHttp, false);
               }
               if (addIP4Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                       portNumberHttp, false);
               }
  
               char scratchBuffer[22];
               Uint32 n;
               const char * portNumberHttpStr = Uint32ToString(
                   scratchBuffer, portNumberHttp, n);
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",                 "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                 "Listening on HTTP port $0.", portNumberHttp);                  "Listening on HTTP port $0.", portNumberHttpStr);
             Logger::put(              Logger::put_l(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
 #endif #endif
Line 911 
Line 1079 
                     throw InvalidPropertyValue("httpsPort", httpsPort);                     throw InvalidPropertyValue("httpsPort", httpsPort);
                 }                 }
             }             }
               if (addIP6Acceptor)
             _cimServer->addAcceptor(false, portNumberHttps, true);              {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV6_CONNECTION,
                       portNumberHttps, true);
               }
               if (addIP4Acceptor)
               {
                   _cimServer->addAcceptor(HTTPAcceptor::IPV4_CONNECTION,
                       portNumberHttps, true);
               }
               char scratchBuffer[22];
               Uint32 n;
               const char * portNumberHttpsStr = Uint32ToString(
                   scratchBuffer, portNumberHttps, n);
             MessageLoaderParms parms(             MessageLoaderParms parms(
                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",                 "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                 "Listening on HTTPS port $0.", portNumberHttps);                  "Listening on HTTPS port $0.", portNumberHttpsStr);
             Logger::put(              Logger::put_l(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
 #if defined(PEGASUS_DEBUG) #if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
 #endif #endif
Line 927 
Line 1106 
  
 #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET #ifndef PEGASUS_DISABLE_LOCAL_DOMAIN_SOCKET
         {         {
             _cimServer->addAcceptor(true, 0, false);              _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::put_l(
                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,                 Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                 MessageLoader::getMessage(parms));                  parms);
 # if defined(PEGASUS_DEBUG) # if defined(PEGASUS_DEBUG)
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
 # endif # endif
Line 947 
Line 1126 
         // 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_DEBUG) #if defined(PEGASUS_DEBUG)
Line 961 
Line 1136 
         // Put server started message to the logger         // Put server started message to the logger
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,
             Logger::INFORMATION,             Logger::INFORMATION,
               MessageLoaderParms(
             "src.Server.cimserver.STARTED_VERSION",             "src.Server.cimserver.STARTED_VERSION",
             "Started $0 version $1.",             "Started $0 version $1.",
             _cimServerProcess->getProductName(),             _cimServerProcess->getProductName(),
             _cimServerProcess->getCompleteVersion());                  _cimServerProcess->getCompleteVersion()));
  
 #if defined(PEGASUS_OS_TYPE_UNIX) && !defined(PEGASUS_OS_ZOS) #if defined(PEGASUS_OS_TYPE_UNIX) && !defined(PEGASUS_OS_ZOS)
         if (daemonOption && !debugOutputOption)         if (daemonOption && !debugOutputOption)
         {         {
             // 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
Line 984 
Line 1160 
     {     {
         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",
             "cimserver not started: $0", e.getMessage());             "cimserver not started: $0", e.getMessage());
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
             MessageLoader::getMessage(parms));              parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
  
         //         //
Line 1002 
Line 1178 
  
     try     try
     {     {
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
  
         // ARM is a z/OS internal restart facility.         // ARM is a z/OS internal restart facility.
         // This is a z/OS specific change.         // This is a z/OS specific change.
Line 1015 
Line 1191 
  
 #endif #endif
  
   #ifdef PEGASUS_ENABLE_SLP
           _cimServer->startSLPProvider();
   #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
Line 1028 
Line 1207 
         // normal termination         // normal termination
         //         //
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  #if defined(PEGASUS_OS_ZOS)
  
         // ARM is a z/OS internal restart facility.         // ARM is a z/OS internal restart facility.
         // This is a z/OS specific change.         // This is a z/OS specific change.
Line 1039 
Line 1218 
 #endif #endif
  
         // Put server shutdown message to the logger         // Put server shutdown message to the logger
         Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER,          Logger::put_l(
             Logger::INFORMATION, "src.Server.cimserver.STOPPED",              Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
             "$0 stopped.", _cimServerProcess->getProductName());              MessageLoaderParms(
                   "src.Server.cimserver.STOPPED",
                   "$0 stopped.", _cimServerProcess->getProductName()));
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
Line 1049 
Line 1230 
             "src.Server.cimserver.ERROR",             "src.Server.cimserver.ERROR",
             "Error: $0",             "Error: $0",
             e.getMessage());             e.getMessage());
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,          Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
             MessageLoader::getMessage(parms));              parms);
         cerr << MessageLoader::getMessage(parms) << endl;         cerr << MessageLoader::getMessage(parms) << endl;
  
         deleteCIMServer();         deleteCIMServer();

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