(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.34 and 1.34.2.10

version 1.34, 2001/07/17 00:49:05 version 1.34.2.10, 2001/12/05 23:21:02
Line 26 
Line 26 
 // //
 // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org) // Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)
 // //
   // Modified By: Nag Boranna (nagaraja_boranna@hp.com)
   //
   // Modified By: Jenny Yu (jenny_yu@hp.com)
   //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
  
Line 39 
Line 43 
 // //
 // The -d option has no effect on windows operation. // The -d option has no effect on windows operation.
 // //
   // To shutdown pegasus, use the -s option:
   //
   // cimserver -s [-f] [-T timeout_value]
   //
 // To run pegasus as an NT service, there are FOUR  different possibilities: // To run pegasus as an NT service, there are FOUR  different possibilities:
 // //
 // To INSTALL the Pegasus service, // To INSTALL the Pegasus service,
Line 66 
Line 74 
  
  
 #include <iostream> #include <iostream>
   #include <cassert>
 #include <cstdlib> #include <cstdlib>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Selector.h>  #include <Pegasus/Common/Monitor.h>
 #include <Pegasus/Common/OptionManager.h>  
 #include <Pegasus/Server/CIMServer.h> #include <Pegasus/Server/CIMServer.h>
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
 #include <Pegasus/Protocol/Handler.h> #include <Pegasus/Protocol/Handler.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
   #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Config/ConfigManager.h>
   #include <Pegasus/Client/CIMClient.h>
   #include <Pegasus/Common/HTTPConnector.h>
   #include <Pegasus/Server/ShutdownService.h>
   #ifndef PEGASUS_OS_ZOS
 #include <slp/slp.h> #include <slp/slp.h>
   #endif
  
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
Line 90 
Line 104 
 PEGASUS_USING_PEGASUS; PEGASUS_USING_PEGASUS;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
   //
   //  The command name.
   //
   static const char COMMAND_NAME []    = "cimserver";
   
   //
   //  The constant defining usage string.
   //
   static const char USAGE []           = "Usage: ";
   
   /**
   Constants representing the command line options.
   */
   static const char OPTION_VERSION     = 'v';
   
   static const char OPTION_HELP        = 'h';
   
   static const char OPTION_HOME        = 'D';
   
   static const char OPTION_SHUTDOWN    = 's';
   
   static const char OPTION_FORCE       = 'f';
   
   static const char OPTION_TIMEOUT     = 'T';
   
   static const String NAMESPACE = "root/cimv2";
   static const String CLASSNAME_SHUTDOWNSERVICE = "PG_ShutdownService";
   static const String PROPERTY_TIMEOUT = "timeout";
   
   ConfigManager*    configManager;
   
 void GetEnvironmentVariables( void GetEnvironmentVariables(
     const char* arg0,     const char* arg0,
     String& pegasusHome)     String& pegasusHome)
Line 108 
Line 153 
     FileSystem::translateSlashes(pegasusHome);     FileSystem::translateSlashes(pegasusHome);
 } }
  
   void SetEnvironmentVariables(
       const char* arg0)
   {
       cout << "PEGASUS_HOME is now " << arg0 << endl;
   
       String str = "PEGASUS_HOME=";
       str += arg0;
       char* tmp = str.allocateCString();
       putenv(tmp);
   
       // Note: don't delete tmp! putenv() uses it.
   }
   
 /** 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 option manager.      and sets up the options from that table using the config manager.
 */ */
 void GetOptions( void GetOptions(
     OptionManager& om,      ConfigManager* cm,
     int& argc,     int& argc,
     char** argv,     char** argv,
     const String& pegasusHome)     const String& pegasusHome)
 { {
     static struct OptionRow optionsTable[] =      String currentFile = pegasusHome + "/" + CURRENT_CONFIG_FILE;
     {      String plannedFile = pegasusHome + "/" + PLANNED_CONFIG_FILE;
         {"home", "/etc/pegasus", false, Option::STRING, 0, 0, "D",  
                     "Sets the pegasus home directory"},  
         {"port", "5988", false, Option::WHOLE_NUMBER, 0, 0, "port",  
                         "specifies port number to listen on" },  
         {"trace", "false", false, Option::BOOLEAN, 0, 0, "t",  
                         "turns on trace of Client IO to console "},  
         {"logtrace", "false", false, Option::BOOLEAN, 0, 0, "l",  
                         "Turns on trace of Client IO to trace log "},  
         {"options", "false", false, Option::BOOLEAN, 0, 0, "options",  
                         " Displays the settings of the Options "},  
         {"severity", "ALL", false, Option::STRING, 0, 0, "s",  
   
                     "Sets the severity level that will be logged "},  
         {"logs", "ALL", false, Option::STRING, 0, 0, "X",  
                         "Not Used "},  
         {"daemon", "false", false, Option::BOOLEAN, 0, 0, "d",  
             "Detach Pegasus from the console and run it in the background "},  
         {"logdir", "./logs", false, Option::STRING, 0, 0, "logdir",  
                         "Directory for log files"},  
         {"cleanlogs", "false", false, Option::BOOLEAN, 0, 0, "clean",  
                         "Clears the log files at startup"},  
         {"version", "false", false, Option::BOOLEAN, 0, 0, "v",  
                         "Displays Pegasus Version "},  
         {"help", "false", false, Option::BOOLEAN, 0, 0, "h",  
                     "Prints help message with command line options "},  
         {"install", "false", false, Option::BOOLEAN, 0, 0, "install",  
                     "Installs Pegasus as a Windows NT Service "},  
         {"remove", "false", false, Option::BOOLEAN, 0, 0, "remove",  
                     "Removes Pegasus as a Windows NT Service "},  
         {"debug", "false", false, Option::BOOLEAN, 0, 0, "d",  
                         "Not Used "},  
         {"slp", "false", false, Option::BOOLEAN, 0, 0, "slp",  
                         "Register Pegasus as a Service with SLP"}  
     };  
     const Uint32 NUM_OPTIONS = sizeof(optionsTable) / sizeof(optionsTable[0]);  
   
     om.registerOptions(optionsTable, NUM_OPTIONS);  
   
     String configFile = pegasusHome + "/testclient.conf";  
   
     cout << "Config file from " << configFile << endl;  
   
     if (FileSystem::exists(configFile))  
         om.mergeFile(configFile);  
     if(argc && argv != NULL)  
       om.mergeCommandLine(argc, argv);  
  
     om.checkRequiredOptions();      try
       {
           cm->mergeConfigFiles(currentFile, plannedFile);
  
           cm->mergeCommandLine(argc, argv);
       }
       catch (NoSuchFile nsf)
       {
           throw nsf;
       }
       catch (FileNotReadable fnr)
       {
           throw fnr;
       }
       catch (CannotRenameFile ftrf)
       {
           throw ftrf;
       }
       catch (ConfigFileSyntaxError cfse)
       {
           throw cfse;
       }
       catch(UnrecognizedConfigProperty ucp)
       {
           throw ucp;
       }
       catch(InvalidPropertyValue ipv)
       {
           throw ipv;
       }
 } }
  
 /* PrintHelp - This is temporary until we expand the options manager to allow /* PrintHelp - This is temporary until we expand the options manager to allow
Line 176 
Line 216 
 */ */
 void PrintHelp(const char* arg0) void PrintHelp(const char* arg0)
 { {
     cout << '\n';      /**
           Build the usage string for the config command.
       */
       String usage = String (USAGE);
       usage.append (COMMAND_NAME);
       usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");
       usage.append ("  options\n");
       usage.append ("    -v          - displays pegasus version number\n");
       usage.append ("    -h          - prints this help message\n");
       usage.append ("    -D [home]   - sets pegasus home directory\n");
       usage.append ("    -t          - turns tracing on\n");
       usage.append ("    -t          - turns on trace of client IO to console\n");
       usage.append ("    -l          - turns on trace of client IO to trace file\n");
       usage.append ("    -d          - runs pegasus as a daemon\n");
       usage.append ("    -s [-f] [-T timeout] \n");
       usage.append ("                - shuts down pegasus\n");
       usage.append ("    -cleanlogs  - clears the log files at startup\n");
       usage.append ("    -install    - installs pegasus as a Windows NT Service\n");
       usage.append ("    -remove     - removes pegasus as a Windows NT Service\n");
       usage.append ("    -slp        - registers pegasus as a service with SLP\n\n");
   
       usage.append ("  configProperty=value\n");
       usage.append ("    port=nnnn            - sets port number to listen on\n");
       usage.append ("    home=/pegasus/bin    - sets pegasus home directory\n");
       usage.append ("    logdir=/pegasus/logs - directory for log files\n");
   
       cout << endl;
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;
     cout << '\n';  
     cout << "Usage: " << arg0 << endl;  
     cout << endl;     cout << endl;
       cout << usage << endl;
 } }
  
   void shutdownCIMOM(Boolean forceOption, String timeoutStr)
   {
       //
       // Create CIMClient object
       //
       Monitor* monitor = new Monitor;
       HTTPConnector* httpConnector = new HTTPConnector(monitor);
       CIMClient client(monitor, httpConnector);
   
       //
       // Get the port number
       //
       String portNumberStr = configManager->getCurrentValue("port");
   
       String hostStr = System::getHostName();
       hostStr.append(":");
       hostStr.append(portNumberStr);
   
       //
       // open connection to CIMOM
       //
       try
       {
           client.connect(hostStr.allocateCString());
       }
       catch(Exception& e)
       {
           PEGASUS_STD(cerr) << "Failed to connect to server: " << e.getMessage() << PEGASUS_STD(endl);
           exit(1);
       }
   
       try
       {
           //
           // construct CIMReference
           //
           String referenceStr = "//";
           referenceStr.append(hostStr);
           referenceStr.append("/root/cimv2:PG_ShutdownService");
           CIMReference reference(referenceStr);
   
           //
           // issue the invokeMethod request on the shutdown method
           //
           Array<CIMParamValue> inParams;
           Array<CIMParamValue> outParams;
   
           if (forceOption)
           {
               inParams.append(CIMParamValue(
                   CIMParameter("force", CIMType::STRING),
                   CIMValue("TRUE")));
           }
           else
           {
               inParams.append(CIMParamValue(
                   CIMParameter("force", CIMType::STRING),
                   CIMValue("FALSE")));
           }
   
           inParams.append(CIMParamValue(
               CIMParameter("timeout", CIMType::STRING),
               CIMValue(timeoutStr)));
   
           CIMValue retValue = client.invokeMethod(
               NAMESPACE,
               reference,
               "shutdown",
               inParams,
               outParams);
       }
       catch(Exception& e)
       {
           PEGASUS_STD(cerr) << "Failed to shutdown server: " << e.getMessage() << PEGASUS_STD(endl);
           exit(1);
       }
   
       return;
   }
   
   
 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
 //  MAIN //  MAIN
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
       String pegasusHome  = String::EMPTY;
       Boolean pegasusIOTrace = false;
       Boolean pegasusIOLog = false;
       String portOption = String::EMPTY;
       String logsDirectory = String::EMPTY;
       Boolean useSLP = false;
       Boolean daemonOption = false;
       Boolean shutdownOption = false;
       Boolean forceOption = false;
       Boolean timeoutOption = false;
       String  timeoutStr  = String::EMPTY;
       long timeoutValue  = 0;
   
     // on Windows NT if there are no command-line options, run as a service     // on Windows NT if there are no command-line options, run as a service
  
     if (argc == 1 )     if (argc == 1 )
       {
       cim_server_service(argc, argv) ;       cim_server_service(argc, argv) ;
       }
       else
       {
           // Get help, version and home options
  
     // Get environment variables          for (int i = 1; i < argc; )
           {
               const char* arg = argv[i];
  
     String pegasusHome;              // Check for -option
               if (*arg == '-')
               {
                   // Get the option
                   const char* option = arg + 1;
  
     for (int i=0; i < argc; i++) {                  //
         if (!strcmp(argv[i],"-D")) {                  // Check to see if user asked for the version (-v option):
                   //
                   if (*option == OPTION_VERSION)
                   {
                       cout << PEGASUS_VERSION << endl;
                       exit(0);
                   }
                   //
                   // Check to see if user asked for help (-h option):
                   //
                   else if (*option == OPTION_HELP)
                   {
                       PrintHelp(argv[0]);
                       exit(0);
                   }
                   else if (*option == OPTION_HOME)
                   {
                       if (i + 1 < argc)
                       {
                           pegasusHome.assign(argv[i + 1]);
                           SetEnvironmentVariables(argv[i + 1]);
                       }
                       else
                       {
                           cout << "Missing argument for option -" << option << endl;
                           exit(0);
                       }
   
                       memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
                       argc -= 2;
                   }
                   //
                   // Check to see if user asked for shutdown (-s option):
                   //
                   else if (*option == OPTION_SHUTDOWN)
                   {
                       //
                       // Check to see if shutdown has already been specified:
                       //
                       if (shutdownOption)
                       {
                           cout << "Duplicate shutdown option specified." << endl;
                           exit(0);
                       }
                       shutdownOption = true;
   
                       // remove the option from the command line
                       memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                       argc--;
                   }
                   else if (*option == OPTION_FORCE)
                   {
                       //
                       // Check to see if shutdown has been specified:
                       //
                       if (!shutdownOption)
                       {
                           cout << "Invalid option -" << option << endl;
                           exit(0);
                       }
   
                       //
                       // Check to see if force has already been specified:
                       //
                       if (forceOption)
                       {
                           cout << "Duplicate force option specified." << endl;
                           exit(0);
                       }
   
                       forceOption = true;
   
                       // remove the option from the command line
                       memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                       argc--;
                   }
                   else if (*option == OPTION_TIMEOUT)
                   {
                       //
                       // Check to see if shutdown has been specified:
                       //
                       if (!shutdownOption)
                       {
                           cout << "Invalid option -" << option << endl;
                           exit(0);
                       }
   
                       if (timeoutOption)
                       {
                           cout << "Duplicate timeout option specified." << endl;
                           exit(0);
                       }
   
                       timeoutOption = true;
   
                       if (i + 1 < argc)
                       {
                           // get timeout value
                           timeoutStr.assign(argv[i + 1]);
   
                           // validate timeout value string
                           char* tmp = timeoutStr.allocateCString();
                           char* end = 0;
                           timeoutValue  = strtol(tmp, &end, 10);
   
                           if (!end || *end != '\0')
                           {
                               cout << "invalid timeout value specified: ";
                               cout << timeoutStr << endl;
                               delete [] tmp;
                               exit(0);
                           }
                       }
                       else
                       {
                           cout << "Missing argument for option -";
                           cout << option << endl;
                           exit(0);
                       }
   
                       // remove the option from the command line
                       memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
                       argc -= 2;
                   }
                   else
                       i++;
               }
               else
             i++;             i++;
             if (i < argc) pegasusHome = argv[i];  
             break;  
         }         }
     }     }
   
     if (pegasusHome.size() == 0)     if (pegasusHome.size() == 0)
         GetEnvironmentVariables(argv[0], pegasusHome);         GetEnvironmentVariables(argv[0], pegasusHome);
  
       //
       // Get an instance of the Config Manager.
       //
       configManager = ConfigManager::getInstance();
   
       //
     // 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 fromt he command     // removes corresponding options and their arguments fromt he command
     // line.     // line.
       //
     OptionManager om;  
   
     try     try
     {     {
         GetOptions(om, argc, argv, pegasusHome);          GetOptions(configManager, argc, argv, pegasusHome);
         // om.print();  
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
Line 224 
Line 523 
         exit(1);         exit(1);
     }     }
  
     // At this point, all options should have been extracted; print an  
     // error if there are any remaining:  
  
     if (argc != 1)      try
     {     {
         cerr << argv[0] << ": unrecognized options: ";          //
   
         for (int i = 1; i < argc; i++)  
             cerr << argv[i] << ' ';  
         cout << endl;  
         exit(1);  
     }  
   
     // Check to see if we should (can) install as a NT service     // Check to see if we should (can) install as a NT service
           //
  
     String installOption;          if (String::equal(configManager->getCurrentValue("install"), "true"))
     if(om.lookupValue("install", installOption) && installOption == "true")  
       {       {
         if( 0 != cimserver_install_nt_service( pegasusHome ))         if( 0 != cimserver_install_nt_service( pegasusHome ))
               {
           cout << "\nPegasus installed as NT Service";           cout << "\nPegasus installed as NT Service";
         exit(0);         exit(0);
       }       }
           }
  
           //
     // Check to see if we should (can) remove Pegasus as an NT service     // Check to see if we should (can) remove Pegasus as an NT service
           //
  
     String removeOption;          if (String::equal(configManager->getCurrentValue("remove"), "true"))
     if(om.lookupValue("remove", removeOption) && removeOption == "true")  
       {       {
         if( 0 != cimserver_remove_nt_service() )         if( 0 != cimserver_remove_nt_service() )
               {
           cout << "\nPegasus removed as NT Service";           cout << "\nPegasus removed as NT Service";
         exit(0);         exit(0);
               }
       }       }
  
     // Check to see if user asked for the version (-v otpion):          //
           // Check to see if we should Pegasus as a daemon
     String versionOption;          //
  
     if (om.lookupValue("version", versionOption) && versionOption == "true")          if (String::equal(configManager->getCurrentValue("daemon"), "true"))
     {     {
         cerr << PEGASUS_VERSION << endl;              daemonOption = true;
         exit(0);  
     }     }
  
     // Check to see if user asked for help (-h otpion):          //
     String helpOption;          // Check to see if we need to shutdown CIMOM
           //
     if (om.lookupValue("help", helpOption) && helpOption == "true")          if (shutdownOption)
     {     {
         PrintHelp(argv[0]);              //
         om.printHelp();              // if timeout was specified, validate the timeout value
               //
               if (timeoutOption)
               {
                   Boolean valid = configManager->validatePropertyValue(
                                                PROPERTY_TIMEOUT,
                                                timeoutStr);
                   if (!valid)
                   {
                       cout << "Invalid timeout value specified: " << timeoutValue;
                       cout << endl;
                       exit(1);
                   }
               }
   
               shutdownCIMOM(forceOption, timeoutStr);
               cout << "Pegasus CIM Server terminated." << endl;
         exit(0);         exit(0);
     }     }
  
           //
           // Grab the port option:
           //
   
           portOption = configManager->getCurrentValue("port");
   
           //
     // Check the trace options and set global variable     // Check the trace options and set global variable
     Boolean pegasusIOTrace = false;          //
     if (om.valueEquals("trace", "true"))  
           if (String::equal(configManager->getCurrentValue("trace"), "true"))
     {     {
         Handler::setMessageTrace(true);         Handler::setMessageTrace(true);
         pegasusIOTrace = true;         pegasusIOTrace = true;
               cout << "Trace Set" << endl;
     }     }
           //
           // Check the log trace options and set global variable
           //
  
     Boolean pegasusIOLog = false;          if (String::equal(configManager->getCurrentValue("logtrace"), "true"))
     if (om.valueEquals("logtrace", "true"))  
     {     {
         Handler::setMessageLogTrace(true);         Handler::setMessageLogTrace(true);
         pegasusIOLog = true;         pegasusIOLog = true;
     }     }
  
     // Grab the port otpion:  
   
     String portOption;  
     om.lookupValue("port", portOption);  
   
     // Get the log file directory definition.     // Get the log file directory definition.
     // We put String into Cstring because     // We put String into Cstring because
     // Directory functions only handle Cstring.     // Directory functions only handle Cstring.
     // ATTN-KS: create String based directory functions.     // ATTN-KS: create String based directory functions.
     String logsDirectory;  
     om.lookupValue("logdir", logsDirectory);          logsDirectory = configManager->getCurrentValue("logdir");
  
     // Set up the Logger. This does not open the logs     // Set up the Logger. This does not open the logs
     // Might be more logical to clean before set.     // Might be more logical to clean before set.
     // ATTN: Need tool to completely disable logging.     // ATTN: Need tool to completely disable logging.
   
     Logger::setHomeDirectory(logsDirectory);     Logger::setHomeDirectory(logsDirectory);
  
     if (om.valueEquals("cleanlogs", "true"))          if (String::equal(configManager->getCurrentValue("cleanlogs"), "true"))
     {     {
         Logger::clean(logsDirectory);;         Logger::clean(logsDirectory);;
     }     }
  
     // Option to Display the options table.  Primarily  
     // a diagnostic tool.  
     if (om.valueEquals("options", "true"))  
         om.print();  
   
     // Leave this in until people get familiar with the logs.     // Leave this in until people get familiar with the logs.
     cout << "Logs Directory = " << logsDirectory << endl;     cout << "Logs Directory = " << logsDirectory << endl;
  
     Boolean useSLP = (om.valueEquals("slp", "true")) ? true: false;          if (String::equal(configManager->getCurrentValue("slp"), "true"))
           {
               useSLP =  true;
           }
       }
       catch (UnrecognizedConfigProperty e)
       {
           cout << "Error: " << e.getMessage() << endl;
       }
  
     char* address = portOption.allocateCString();     char* address = portOption.allocateCString();
  
Line 347 
Line 666 
                 (useSLP ? " SLP on " : " SLP off "));                 (useSLP ? " SLP on " : " SLP off "));
  
 // do we need to run as a daemon ? // do we need to run as a daemon ?
     String daemonOption;      if (daemonOption)
     if(om.lookupValue("daemon", daemonOption) && daemonOption == "true")  
       {       {
         if(-1 == cimserver_fork())         if(-1 == cimserver_fork())
           exit(-1);           exit(-1);
       }       }
  
   
     // try loop to bind the address, and run the server     // try loop to bind the address, and run the server
     try     try
     {     {
   #ifndef PEGASUS_OS_ZOS
         slp_client *discovery = new slp_client() ;;         slp_client *discovery = new slp_client() ;;
         String serviceURL;         String serviceURL;
         serviceURL.assign("service:cim.pegasus://");         serviceURL.assign("service:cim.pegasus://");
Line 367 
Line 685 
         serviceURL += address;         serviceURL += address;
         char *url = serviceURL.allocateCString();         char *url = serviceURL.allocateCString();
         //      free(host_name);         //      free(host_name);
   #endif
  
         Selector selector;          Monitor monitor;
         CIMServer server(&selector, pegasusHome);          CIMServer server(&monitor, pegasusHome);
  
         // bind throws an exception of the bind fails         // bind throws an exception of the bind fails
         cout << "Binding to " << address << endl;         cout << "Binding to " << address << endl;
         server.bind(address);  
           char* end = 0;
           long portNumber = strtol(address, &end, 10);
           assert(end != 0 && *end == '\0');
           server.bind(portNumber);
   
         delete [] address;         delete [] address;
  
         time_t last = 0;         time_t last = 0;
         while( 1 )  
           //
           // Loop to call CIMServer's runForever() method until CIMServer
           // has been shutdown
           //
           while( !server.terminated() )
         {         {
   #ifndef PEGASUS_OS_ZOS
           if(useSLP  )           if(useSLP  )
           {           {
             if(  (time(NULL) - last ) > 60 )             if(  (time(NULL) - last ) > 60 )
             {             {
               if( discovery != NULL && url != NULL )               if( discovery != NULL && url != NULL )
                 discovery->srv_reg_all(url,                 discovery->srv_reg_all(url,
                                        "(namespace=root/cimv20)",                                         "(namespace=root/cimv2)",
                                        "service:cim.pegasus",                                        "service:cim.pegasus",
                                        "DEFAULT",                                        "DEFAULT",
                                        70) ;                                        70) ;
Line 394 
Line 724 
  
             discovery->service_listener();             discovery->service_listener();
           }           }
   #endif
           server.runForever();           server.runForever();
         }         }
  

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