(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.200 and 1.214

version 1.200, 2007/06/05 10:22:40 version 1.214, 2008/01/11 19:44:50
Line 83 
Line 83 
 #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 97 
Line 96 
 #include <Service/ServerRunStatus.h> #include <Service/ServerRunStatus.h>
  
 #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 120 
Line 120 
  
 #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 132 
Line 137 
 #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 181 
Line 190 
         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 229 
Line 232 
  
 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 282 
Line 281 
     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 342 
Line 341 
    }    }
 } }
  
 // 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 351 
Line 349 
 // //
 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 437 
Line 435 
     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  #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::LEVEL4,
              "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 453 
Line 464 
     //     //
   #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 537 
Line 552 
                     }                     }
                     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;
Line 583 
Line 597 
                     //                     //
                     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 642 
Line 655 
     Boolean shutdownOption,     Boolean shutdownOption,
     Boolean debugOutputOption)     Boolean debugOutputOption)
 { {
     String logsDirectory;  
     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.
     //     //
     configManager = ConfigManager::getInstance();      ConfigManager* configManager = ConfigManager::getInstance();
     configManager->useConfigFiles = true;     configManager->useConfigFiles = true;
  
       try
       {
     //     //
     // Get options (from command line and from configuration file); this     // Get options (from command line and from configuration file); this
     // removes corresponding options and their arguments from the command     // removes corresponding options and their arguments from the command
     // line.          // line.  NOTE: If shutdownOption=true, the contents of current config
           // file are not overwritten by the planned config file.
     //     //
     try  
     {  
         // If current process is "cimserver -s" (shutdown option = true) the contents  
         // of current config should not be overwriten by planned config  
         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());  
   
         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.
           // This is the default directory where the resource bundles are found.
           //
           MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(
               ConfigManager::getInstance()->getCurrentValue("messageDir")));
  
         return(1);  #ifdef PEGASUS_OS_PASE
       // 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,
                   "src.Server.cimserver.SET_CCSID_ERROR.PEGASUS_OS_PASE",
                   "Failed to set CCSID, server will stop.\n");
           exit (1);
     }     }
  
 // l10n      char fullJobName[29];
     // Set the home directory, msg sub-dir, into the MessageLoader.      umeGetJobName(fullJobName, true);
     // This will be the default directory where the resource bundles      Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
     // are found.              "src.Server.cimserver.SERVER_JOB_NAME.PEGASUS_OS_PASE",
     MessageLoader::setPegasusMsgHome(ConfigManager::getHomedPath(              "CIM Server's Job Name is: $0", fullJobName);
         ConfigManager::getInstance()->getCurrentValue("messageDir")));  #endif
  
     Boolean enableHttpConnection = ConfigManager::parseBooleanValue(     Boolean enableHttpConnection = ConfigManager::parseBooleanValue(
         configManager->getCurrentValue("enableHttpConnection"));         configManager->getCurrentValue("enableHttpConnection"));
Line 699 
Line 748 
             //"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"));
  
 #if !defined(PEGASUS_USE_SYSLOGS) #if !defined(PEGASUS_USE_SYSLOGS)
         logsDirectory =          String logsDirectory = ConfigManager::getHomedPath(
         ConfigManager::getHomedPath(configManager->getCurrentValue("logdir"));              configManager->getCurrentValue("logdir"));
 #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_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 739 
Line 791 
         {         {
             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);
Line 753 
Line 802 
                 "CIM Server stopped.");                 "CIM Server stopped.");
  
             cout << MessageLoader::getMessage(parms) << endl;             cout << MessageLoader::getMessage(parms) << endl;
             return(0);              return 0;
         }         }
  
 #if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS) #if defined(PEGASUS_DEBUG) && !defined(PEGASUS_USE_SYSLOGS)
Line 763 
Line 812 
         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());  
         cout << e.getMessage() << endl;  
     }  
     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));
         cout << ex.getMessage() << endl;          cerr << MessageLoader::getMessage(parms) << endl;
         exit(1);  
           return 1;
     }     }
  
 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY) #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM) && defined(PEGASUS_ZOS_SECURITY)
Line 789 
Line 829 
     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());  
                 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);  
                 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());  
                 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);  
                 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())
             return(-1);              return -1;
         else  
             return(0);  
     }     }
  
 // 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 905 
Line 858 
     // 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());
     }     }
Line 921 
Line 876 
     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 971 
Line 922 
         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 1038 
Line 1106 
         // 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 1089 
Line 1126 
         {         {
             // 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 1117 
Line 1176 
         //         //
     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 1139 
Line 1197 
         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());  
         MessageLoaderParms parms("src.Server.cimserver.SERVER_NOT_STARTED",  
             "cimserver not started: $0", e.getMessage());  
   
         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;  
     }     }
     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",
     MessageLoaderParms parms("src.Server.cimserver.ERROR",              e.getMessage());
                              "Error: $0", e.getMessage());          Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
     PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);              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();         deleteCIMServer();
         return 1;         return 1;

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