(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.44 and 1.109

version 1.44, 2002/05/03 18:15:13 version 1.109, 2003/09/15 14:32:25
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 31 
Line 32 
 // Modified By: Jenny Yu (jenny_yu@hp.com) // Modified By: Jenny Yu (jenny_yu@hp.com)
 // //
 // Modified By: Sushma Fernandes (sushma_fernandes@hp.com) // Modified By: Sushma Fernandes (sushma_fernandes@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                (carolann_graves@hp.com)
   //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
   //
   // Modified By: Dave Rosckes (rosckes@us.ibm.com)
   //
   // Modified By: Humberto Rivero (hurivero@us.ibm.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 39 
Line 47 
 // //
 // Notes on deamon operation (Unix) and service operation (Win 32): // Notes on deamon operation (Unix) and service operation (Win 32):
 // //
 // To run pegasus as a daemon on Unix platforms, use the -d option:  // To run pegasus as a daemon on Unix platforms:
   //
   // cimserver
 // //
 // cimserver -d  // To NOT run pegasus as a daemon on Unix platforms, set the daemon config
   // property to false:
 // //
 // The -d option has no effect on windows operation.  // cimserver daemon=false
   //
   // The daemon config property has no effect on windows operation.
 // //
 // To shutdown pegasus, use the -s option: // To shutdown pegasus, use the -s option:
 // //
 // cimserver -s [-f] [-T timeout_value]  // cimserver -s
 // //
 // To run pegasus as an NT service, there are FOUR  different possibilities: // To run pegasus as an NT service, there are FOUR  different possibilities:
 // //
Line 76 
Line 89 
  
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <Pegasus/Common/Constants.h>
 #include <iostream> #include <iostream>
 #include <cassert> #include <cassert>
 #include <cstdlib> #include <cstdlib>
   #include <fstream>
 #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/FileSystem.h>
 #include <Pegasus/Common/Monitor.h> #include <Pegasus/Common/Monitor.h>
 #include <Pegasus/Server/CIMServer.h> #include <Pegasus/Server/CIMServer.h>
Line 90 
Line 105 
 #include <Pegasus/Client/CIMClient.h> #include <Pegasus/Client/CIMClient.h>
 #include <Pegasus/Server/ShutdownService.h> #include <Pegasus/Server/ShutdownService.h>
 #include <Pegasus/Common/Destroyer.h> #include <Pegasus/Common/Destroyer.h>
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX)  #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)
 #include <slp/slp.h> #include <slp/slp.h>
 #endif #endif
  
Line 98 
Line 113 
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
 # include "cimserver_windows.cpp" # include "cimserver_windows.cpp"
 #elif defined(PEGASUS_OS_TYPE_UNIX) #elif defined(PEGASUS_OS_TYPE_UNIX)
   # if defined(PEGASUS_OS_OS400)
   #  include "OS400ConvertChar.h"
   #  include "cimserver_os400.cpp"
   # else
 # include "cimserver_unix.cpp" # include "cimserver_unix.cpp"
   #endif
 #else #else
 # error "Unsupported platform" # error "Unsupported platform"
 #endif #endif
Line 127 
Line 147 
  
 static const char OPTION_SHUTDOWN    = 's'; static const char OPTION_SHUTDOWN    = 's';
  
 static const char OPTION_FORCE       = 'f';  static const char OPTION_INSTALL[]   = "install";
   
   static const char OPTION_REMOVE[]   = "remove";
   
   static const char OPTION_START[]   = "start";
  
 static const char OPTION_TIMEOUT     = 'T';  static const char OPTION_STOP[]   = "stop";
   
   #if defined(PEGASUS_OS_HPUX)
   static const char OPTION_BINDVERBOSE = 'X';
   #endif
  
 static const String NAMESPACE = "root/PG_Internal";  static const String PROPERTY_TIMEOUT = "shutdownTimeout";
 static const String CLASSNAME_SHUTDOWNSERVICE = "PG_ShutdownService";  
 static const String PROPERTY_TIMEOUT = "operationTimeout";  
  
 ConfigManager*    configManager; ConfigManager*    configManager;
  
Line 187 
Line 213 
     /**     /**
         Build the usage string for the config command.         Build the usage string for the config command.
     */     */
       /* l10n
     String usage = String (USAGE);     String usage = String (USAGE);
     usage.append (COMMAND_NAME);     usage.append (COMMAND_NAME);
     usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");     usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");
     usage.append ("  options\n");     usage.append ("  options\n");
     usage.append ("    -v          - displays pegasus version number\n");      usage.append ("    -v              - displays CIM Server version number\n");
     usage.append ("    -h          - prints this help message\n");     usage.append ("    -h          - prints this help message\n");
       usage.append ("    -s              - shuts down CIM Server\n");
   #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
     usage.append ("    -D [home]   - sets pegasus home directory\n");     usage.append ("    -D [home]   - sets pegasus home directory\n");
     usage.append ("    -t          - turns tracing on\n");  #endif
     usage.append ("    -t          - turns on trace of client IO to console\n");  #if defined(PEGASUS_OS_TYPE_WINDOWS)
     usage.append ("    -l          - turns on trace of client IO to trace file\n");      usage.append ("    -install [name] - installs pegasus as a Windows NT Service\n");
     usage.append ("    -d          - runs pegasus as a daemon\n");      usage.append ("                      [name] is optional and overrides the\n");
     usage.append ("    -s [-f] [-T timeout] \n");      usage.append ("                      default CIM Server Service Name\n");
     usage.append ("                - shuts down pegasus\n");      usage.append ("    -remove [name]  - removes pegasus as a Windows NT Service\n");
     usage.append ("    -cleanlogs  - clears the log files at startup\n");      usage.append ("                      [name] is optional and overrides the\n");
     usage.append ("    -install    - installs pegasus as a Windows NT Service\n");      usage.append ("                      default CIM Server Service Name\n");
     usage.append ("    -remove     - removes pegasus as a Windows NT Service\n");      usage.append ("    -start [name]   - starts pegasus as a Windows NT Service\n");
     usage.append ("    -slp        - registers pegasus as a service with SLP\n\n");      usage.append ("                      [name] is optional and overrides the\n");
     usage.append ("    -SSL        - uses SSL\n\n");      usage.append ("                      default CIM Server Service Name\n");
       usage.append ("    -stop [name]    - stops pegasus as a Windows NT Service\n");
       usage.append ("                      [name] is optional and overrides the\n");
       usage.append ("                      default CIM Server Service Name\n\n");
   #endif
     usage.append ("  configProperty=value\n");     usage.append ("  configProperty=value\n");
     usage.append ("    port=nnnn            - sets port number to listen on\n");      usage.append ("                    - sets CIM Server configuration property\n");
     usage.append ("    logdir=/pegasus/logs - directory for log files\n");  
  
     cout << endl;     cout << endl;
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
       cout << PLATFORM_PRODUCT_NAME << " " << PLATFORM_PRODUCT_VERSION << endl;
   #else
     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;     cout << PEGASUS_NAME << PEGASUS_VERSION << endl;
   #endif
     cout << endl;     cout << endl;
     cout << usage << endl;     cout << usage << endl;
       */
   
       String usage = String (USAGE);
       usage.append (COMMAND_NAME);
       usage.append (" [ [ options ] | [ configProperty=value, ... ] ]\n");
       usage.append ("  options\n");
       usage.append ("    -v              - displays CIM Server version number\n");
       usage.append ("    -h              - prints this help message\n");
       usage.append ("    -s              - shuts down CIM Server\n");
   #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
       //usage.append ("    -D [home]       - sets pegasus home directory\n");
       usage.append("$0");
   #endif
   #if defined(PEGASUS_OS_TYPE_WINDOWS)
       usage.append ("    -install [name] - installs pegasus as a Windows NT Service\n");
       usage.append ("                      [name] is optional and overrides the\n");
       usage.append ("                      default CIM Server Service Name\n");
       usage.append ("    -remove [name]  - removes pegasus as a Windows NT Service\n");
       usage.append ("                      [name] is optional and overrides the\n");
       usage.append ("                      default CIM Server Service Name\n");
       usage.append ("    -start [name]   - starts pegasus as a Windows NT Service\n");
       usage.append ("                      [name] is optional and overrides the\n");
       usage.append ("                      default CIM Server Service Name\n");
       usage.append ("    -stop [name]    - stops pegasus as a Windows NT Service\n");
       usage.append ("                      [name] is optional and overrides the\n");
       usage.append ("                      default CIM Server Service Name\n\n");
   #endif
       usage.append ("  configProperty=value\n");
       usage.append ("                    - sets CIM Server configuration property\n");
   
       cout << endl;
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
       cout << PLATFORM_PRODUCT_NAME << " " << PLATFORM_PRODUCT_VERSION << endl;
   #else
       cout << PEGASUS_NAME << PEGASUS_VERSION << endl;
   #endif
       cout << endl;
   
   #if defined(PEGASUS_OS_TYPE_WINDOWS)
       MessageLoaderParms parms("src.Server.cimserver.MENU.WINDOWS", usage);
   #elif defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
           MessageLoaderParms parms("src.Server.cimserver.MENU.HPUXLINUXIA64GNU", usage);
   #else
           MessageLoaderParms parms("src.Server.cimserver.MENU.STANDARD", usage);
   #endif
       //cout << usage << endl;
       cout << MessageLoader::getMessage(parms) << endl;
 } }
  
 void shutdownCIMOM(Boolean forceOption, Uint32 timeoutValue)  // l10n
   //
   // Dummy function for the Thread object associated with the initial thread.
   // Since the initial thread is used to process CIM requests, this is
   // needed to localize the exceptions thrown during CIM request processing.
   // Note: This function should never be called!
   //
   PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL dummyThreadFunc(void *parm)
   {
      return((PEGASUS_THREAD_RETURN)0);
   }
   
   //
   // cimserver_exit: platform specific exit routine calls
   //
   void cimserver_exit( int rc ){
   #ifdef PEGASUS_OS_OS400
       cimserver_exitRC(rc);
   #endif
       exit(rc);
   }
   
   void shutdownCIMOM(Uint32 timeoutValue)
 { {
     //     //
     // Create CIMClient object     // Create CIMClient object
Line 224 
Line 328 
     CIMClient client;     CIMClient client;
  
     //     //
     // Get the port number      // Get local host name
     //     //
     String portNumberStr = configManager->getCurrentValue("port");  
   
     String hostStr = System::getHostName();     String hostStr = System::getHostName();
     hostStr.append(":");  
     hostStr.append(portNumberStr);  
   
     // Put server shutdown message to the logger  
     Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,  
         "Shutdown $0 on port $1.", PEGASUS_NAME, portNumberStr);  
  
     //     //
     // open connection to CIMOM     // open connection to CIMOM
Line 242 
Line 338 
     try     try
     {     {
         client.connectLocal();         client.connectLocal();
   
           //
           // set client timeout to 2 seconds
           //
           client.setTimeout(2000);
     }     }
     catch(CIMClientException& e)      catch(Exception& e)
     {     {
         Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,  #ifdef PEGASUS_OS_OS400
             "Failed to connect to $0 $1.", PEGASUS_NAME, e.getMessage());          //l10n
           //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
         PEGASUS_STD(cerr) << "Failed to connect to server: " << e.getMessage() << PEGASUS_STD(endl);                      //"Unable to connect to CIM Server.  CIM Server may not be running." );
         exit(1);          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                           "src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",
                       "Unable to connect to CIM Server.  CIM Server may not be running." );
           // The server job may still be active but not responding.
           // Kill the job if it exists.
           if(cimserver_kill() == -1)
              cimserver_exit(2);
           cimserver_exit(1);
   #else
           //l10n
           //PEGASUS_STD(cerr) << "Unable to connect to CIM Server." << PEGASUS_STD(endl);
           //PEGASUS_STD(cerr) << "CIM Server may not be running." << PEGASUS_STD(endl);
           MessageLoaderParms parms("src.Server.cimserver.UNABLE_CONNECT_SERVER_MAY_NOT_BE_RUNNING",
                                                            "Unable to connect to CIM Server.\nCIM Server may not be running.\n");
           PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);
   #endif
           cimserver_exit(1);
     }     }
  
     try     try
     {     {
         //         //
         // construct CIMReference          // construct CIMObjectPath
         //         //
         String referenceStr = "//";         String referenceStr = "//";
         referenceStr.append(hostStr);         referenceStr.append(hostStr);
         referenceStr.append("/root/cimv2:PG_ShutdownService");          referenceStr.append("/");
         CIMReference reference(referenceStr);          referenceStr.append(PEGASUS_NAMESPACENAME_SHUTDOWN.getString());
           referenceStr.append(":");
           referenceStr.append(PEGASUS_CLASSNAME_SHUTDOWN.getString());
           CIMObjectPath reference(referenceStr);
  
         //         //
         // issue the invokeMethod request on the shutdown method         // issue the invokeMethod request on the shutdown method
Line 268 
Line 388 
         Array<CIMParamValue> inParams;         Array<CIMParamValue> inParams;
         Array<CIMParamValue> outParams;         Array<CIMParamValue> outParams;
  
           // set force option to true for now
         inParams.append(CIMParamValue("force",         inParams.append(CIMParamValue("force",
             CIMValue(Boolean(forceOption))));              CIMValue(Boolean(true))));
  
         inParams.append(CIMParamValue("timeout",         inParams.append(CIMParamValue("timeout",
             CIMValue(Uint32(timeoutValue))));             CIMValue(Uint32(timeoutValue))));
  
         CIMValue retValue = client.invokeMethod(         CIMValue retValue = client.invokeMethod(
             NAMESPACE,              PEGASUS_NAMESPACENAME_SHUTDOWN,
             reference,             reference,
             "shutdown",             "shutdown",
             inParams,             inParams,
             outParams);             outParams);
       }
       catch(CIMException& e)
       {
   #ifdef PEGASUS_OS_OS400
  
         // Put server shutdown message to the logger          if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)
         Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,          {
             "$0 terminated on port $1.", PEGASUS_NAME, portNumberStr);              //l10n
               //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                       //"Failed to shutdown server: $0", "The repository may be empty.");
                   Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                           "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",
                       "Error in server shutdown: The repository may be empty.");
     }     }
     catch(CIMClientCIMException& e)          else
     {     {
         PEGASUS_STD(cerr) << "Failed to shutdown server: " << e.getMessage() << PEGASUS_STD(endl);              //l10n
         exit(1);              //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                           //"Failed to shutdown server: $0", e.getMessage());
                   Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                           "src.Server.cimserver.SHUTDOWN_FAILED",
                           "Error in server shutdown: $0", e.getMessage());
           }
           // Kill the server job.
           if(cimserver_kill() == -1)
              cimserver_exit(2);
   #else
           //l10n - TODO
           MessageLoaderParms parms("src.Server.cimserver.SHUTDOWN_FAILED",
                                    "Error in server shutdown: ");
           PEGASUS_STD(cerr) << MessageLoader::getMessage(parms);
           if (e.getCode() == CIM_ERR_INVALID_NAMESPACE)
           {
               //
               // Repository may be empty.
               //
               //l10n - TODO
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.SHUTDOWN_FAILED_REPOSITORY_EMPTY",
                   "Error in server shutdown: The repository may be empty.");
               MessageLoaderParms parms("src.Server.cimserver.REPOSITORY_EMPTY",
                                        "The repository may be empty.");
               PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
     }     }
     catch(CIMClientException& e)          else
     {     {
         // this may mean the cimserver has been terminated              //l10n - TODO
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.SHUTDOWN_FAILED",
                   "Error in server shutdown: $0", e.getMessage());
               PEGASUS_STD(cerr) << e.getMessage() << PEGASUS_STD(endl);
           }
   
           // Kill the cimserver process
           if (cimserver_kill() == 0)
           {
               //l10n - TODO
               Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                   "src.Server.cimserver.SERVER_FORCED_SHUTDOWN",
                           "Forced shutdown initiated.");
               MessageLoaderParms parms("src.Server.cimserver.SERVER_FORCED_SHUTDOWN",
                                        "Forced shutdown initiated.");
               PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
           }
   #endif
           cimserver_exit(1);
   
     }     }
     catch(Exception& e)     catch(Exception& e)
     {     {
         PEGASUS_STD(cerr) << "Failed to shutdown server: " << e.getMessage() << PEGASUS_STD(endl);          //
         exit(1);          // This may mean that the CIM Server has terminated, causing this
           // client to get a "Empty HTTP response message" exception.  It may
           // also mean that the CIM Server is taking longer than 2 seconds
           // (client timeout value) to terminate, causing this client to
           // timeout with a "connection timeout" exception.
           //
           // Check to see if CIM Server is still running.  If CIM Server
           // is still running and the shutdown timeout has not expired,
           // loop and wait one second until either the CIM Server is
           // terminated or timeout expires.  If timeout expires and
           // the CIM Server is still running, kill the CIMServer process.
           //
           Uint32 maxWaitTime = timeoutValue - 2;
           Boolean running = isCIMServerRunning();
           while ( running && maxWaitTime > 0 )
           {
               System::sleep(1);
               running = isCIMServerRunning();
               maxWaitTime = maxWaitTime - 1;
           }
   
           if (running)
           {
               int kill_rc = cimserver_kill();
   #ifdef PEGASUS_OS_OS400
               if(kill_rc == -1)
                   cimserver_exit(2);
               cimserver_exit(1);
   #endif
   
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
               if (kill_rc != -1)
               {
                   //l10n - TODO
                   Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                       "src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",
                       "Shutdown timeout expired.  Forced shutdown initiated.");
                   MessageLoaderParms parms("src.Server.cimserver.TIMEOUT_EXPIRED_SERVER_KILLED",
                       "Shutdown timeout expired.  Forced shutdown initiated.");
                   cout << MessageLoader::getMessage(parms) << endl;
                   exit(0);
               }
   #endif
           }
     }     }
  
     return;     return;
Line 311 
Line 528 
 int main(int argc, char** argv) int main(int argc, char** argv)
 { {
     String pegasusHome  = String::EMPTY;     String pegasusHome  = String::EMPTY;
     Boolean pegasusIOTrace = false;  
     Boolean pegasusIOLog = false;  
     String portOption = String::EMPTY;  
     String logsDirectory = String::EMPTY;     String logsDirectory = String::EMPTY;
     Boolean useSLP = false;     Boolean useSLP = false;
     Boolean useSSL = false;  
     Boolean daemonOption = false;     Boolean daemonOption = false;
     Boolean shutdownOption = false;     Boolean shutdownOption = false;
     Boolean forceOption = false;      Uint32 timeoutValue  = 0;
     Boolean timeoutOption = false;  
     String  timeoutStr  = String::EMPTY;  
     long timeoutValue  = 0;  
  
   //l10n
   // Set Message loading to process locale
   MessageLoader::_useProcessLocale = true;
   //l10n
   
   #ifdef PEGASUS_OS_OS400
       // Convert the args to ASCII
       for(Uint32 i = 0;i< argc;++i)
       {
           EtoA(argv[i]);
       }
   
       // Initialize Pegasus home to the shipped OS/400 directory.
       pegasusHome = OS400_DEFAULT_PEGASUS_HOME;
   #endif
   
   #ifndef PEGASUS_OS_TYPE_WINDOWS
     //     //
     // Get environment variables:     // Get environment variables:
     //     //
   #ifdef PEGASUS_OS_OS400
   #pragma convert(37)
       const char* tmp = getenv("PEGASUS_HOME");
   #pragma convert(0)
       char home[256] = {0};
       if (tmp && strlen(tmp) < 256)
       {
           strcpy(home, tmp);
           EtoA(home);
           pegasusHome = home;
       }
   #else
     const char* tmp = getenv("PEGASUS_HOME");     const char* tmp = getenv("PEGASUS_HOME");
  
     if (tmp)     if (tmp)
     {     {
         pegasusHome = tmp;         pegasusHome = tmp;
     }     }
   #endif
  
     FileSystem::translateSlashes(pegasusHome);     FileSystem::translateSlashes(pegasusHome);
   #else
  
     // windows only
     setHome(pegasusHome);
   #endif
     // 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 )
Line 344 
Line 588 
     }     }
     else     else
     {     {
         // Get help, version and home options          // Get help, version, and shutdown options
  
         for (int i = 1; i < argc; )         for (int i = 1; i < argc; )
         {         {
Line 359 
Line 603 
                 //                 //
                 // Check to see if user asked for the version (-v option):                 // Check to see if user asked for the version (-v option):
                 //                 //
                 if (*option == OPTION_VERSION)                  if (*option == OPTION_VERSION &&
                       strlen(option) == 1)
                 {                 {
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
                       cout << PLATFORM_PRODUCT_VERSION << endl;
   #else
                     cout << PEGASUS_VERSION << endl;                     cout << PEGASUS_VERSION << endl;
   #endif
                     exit(0);                     exit(0);
                 }                 }
                 //                 //
                 // Check to see if user asked for help (-h option):                 // Check to see if user asked for help (-h option):
                 //                 //
                 else if (*option == OPTION_HELP)                  else if (*option == OPTION_HELP &&
                           (strlen(option) == 1))
                 {                 {
                     PrintHelp(argv[0]);                     PrintHelp(argv[0]);
                     exit(0);                     exit(0);
                 }                 }
                 else if (*option == OPTION_HOME)  #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
                   else if (*option == OPTION_HOME &&
                           (strlen(option) == 1))
                 {                 {
                     if (i + 1 < argc)                     if (i + 1 < argc)
                     {                     {
Line 380 
Line 632 
                     }                     }
                     else                     else
                     {                     {
                         cout << "Missing argument for option -" << option << endl;                          //l10n
                           //cout << "Missing argument for option -" << option << endl;
                           String opt(option);
                           MessageLoaderParms parms("src.Server.cimserver.MISSING_ARGUMENT",
                                                                    "Missing argument for option -$0",
                                                                    opt);
                                   cout << MessageLoader::getMessage(parms) << endl;
                         exit(0);                         exit(0);
                     }                     }
  
                     memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));                     memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));
                     argc -= 2;                     argc -= 2;
                 }                 }
   #endif
   #if defined(PEGASUS_OS_HPUX)
                   //
                   // Check to see if user asked for the version (-X option):
                   //
                   if (*option == OPTION_BINDVERBOSE &&
                           (strlen(option) == 1))
                   {
                       System::bindVerbose = true;
                       //l10n
                       //cout << "Unsupported debug option, BIND_VERBOSE, enabled."
                            //<< endl;
                       MessageLoaderParms parms("src.Server.cimserver.UNSUPPORTED_DEBUG_OPTION",
                                                                    "Unsupported debug option, BIND_VERBOSE, enabled.");
                           cout << MessageLoader::getMessage(parms) << endl;
                       // remove the option from the command line
                       memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                       argc--;
                   }
   #endif
                 //                 //
                 // Check to see if user asked for shutdown (-s option):                 // Check to see if user asked for shutdown (-s option):
                 //                 //
                 else if (*option == OPTION_SHUTDOWN)                  else if (*option == OPTION_SHUTDOWN &&
                           (strlen(option) == 1))
                   {
                       //
                       // check to see if user is root
                       //
   #ifndef PEGASUS_OS_OS400
                       if (!System::isPrivilegedUser(System::getEffectiveUserName()))
                 {                 {
                           //l10n
                           //cout << "You must have superuser privilege to run ";
                           //cout << "cimserver." << endl;
                           MessageLoaderParms parms("src.Server.cimserver.SUPERVISOR_PRIVILEGE_TO_RUN_SERVER",
                                                                            "You must have superuser privilege to run cimserver.");
   
                           cout << MessageLoader::getMessage(parms) << endl;
                           exit(0);
                       }
   #endif
   
                     //                     //
                     // Check to see if shutdown has already been specified:                     // Check to see if shutdown has already been specified:
                     //                     //
                     if (shutdownOption)                     if (shutdownOption)
                     {                     {
                         cout << "Duplicate shutdown option specified." << endl;                          //l10n
                           //cout << "Duplicate shutdown option specified." << endl;
                           MessageLoaderParms parms("src.Server.cimserver.DUPLICATE_SHUTDOWN_OPTION",
                                                                            "Duplicate shutdown option specified.");
   
                           cout << MessageLoader::getMessage(parms) << endl;
                         exit(0);                         exit(0);
                     }                     }
   
                     shutdownOption = true;                     shutdownOption = true;
  
                     // remove the option from the command line                     // remove the option from the command line
                     memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));                     memmove(&argv[i], &argv[i + 1], (argc-i) * sizeof(char*));
                     argc--;                     argc--;
                 }                 }
                 else if (*option == OPTION_FORCE)  #ifdef PEGASUS_OS_TYPE_WINDOWS
                   else if (strcmp(option, OPTION_INSTALL) == 0)
                 {                 {
                     //                     //
                     // Check to see if shutdown has been specified:                    // Install as a NT service
                     //                     //
                     if (!shutdownOption)                    char *opt_arg = NULL;
                     if (i+1 < argc)
                     {                     {
                         cout << "Invalid option -" << option << endl;                      opt_arg = argv[i+1];
                         exit(0);  
                     }                     }
                     if(cimserver_install_nt_service(opt_arg))
                     {
                        //l10n
                         //cout << "\nPegasus installed as NT Service";
                         MessageLoaderParms parms("src.Server.cimserver.INSTALLED_NT_SERVICE",
                                                  "\nPegasus installed as NT Service");
  
                     //                        cout << MessageLoader::getMessage(parms) << endl;
                     // Check to see if force has already been specified:                        exit(0);
                     //                    }
                     if (forceOption)                    else
                     {                     {
                         cout << "Duplicate force option specified." << endl;  
                         exit(0);                         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)                  else if (strcmp(option, OPTION_REMOVE) == 0)
                 {                 {
                     //                     //
                     // Check to see if shutdown has been specified:                    // Remove Pegasus as an NT service
                     //                     //
                     if (!shutdownOption)                    char *opt_arg = NULL;
                     if (i+1 < argc)
                     {                     {
                         cout << "Invalid option -" << option << endl;                      opt_arg = argv[i+1];
                         exit(0);  
                     }                     }
                     if(cimserver_remove_nt_service(opt_arg))
                     {
                         //l10n
                         //cout << "\nPegasus removed as NT Service";
                         MessageLoaderParms parms("src.Server.cimserver.REMOVED_NT_SERVICE",
                                                  "\nPegasus removed as NT Service");
  
                     if (timeoutOption)                        cout << MessageLoader::getMessage(parms) << endl;
                         exit(0);
                     }
                     else
                     {                     {
                         cout << "Duplicate timeout option specified." << endl;  
                         exit(0);                         exit(0);
                     }                     }
  
                     timeoutOption = true;                  }
                   else if (strcmp(option, OPTION_START) == 0)
                   {
                     //
                     // Start as a NT service
                     //
                     char *opt_arg = NULL;
                     if (i + 1 < argc)                     if (i + 1 < argc)
                     {                     {
                         // get timeout value                      opt_arg = argv[i+1];
                         timeoutStr.assign(argv[i + 1]);                    }
                     if(cimserver_start_nt_service(opt_arg))
                         // validate timeout value string                    {
                         char* tmp = timeoutStr.allocateCString();                        //l10n
                         char* end = 0;                        //cout << "\nPegasus started as NT Service";
                         timeoutValue  = strtol(tmp, &end, 10);                        MessageLoaderParms parms("src.Server.cimserver.STARTED_NT_SERVICE",
                                                  "\nPegasus started as NT Service");
  
                         if (!end || *end != '\0')                        cout << MessageLoader::getMessage(parms) << endl;
                         exit(0);
                     }
                     else
                         {                         {
                             cout << "invalid timeout value specified: ";  
                             cout << timeoutStr << endl;  
                             delete [] tmp;  
                             exit(0);                             exit(0);
                         }                         }
                     }                     }
                   else if (strcmp(option, OPTION_STOP) == 0)
                   {
                     //
                     // Stop as a NT service
                     //
                     char *opt_arg = NULL;
                     if (i+1 < argc)
                     {
                       opt_arg = argv[i+1];
                     }
                     if(cimserver_stop_nt_service(opt_arg))
                     {
                         //l10n
                         //cout << "\nPegasus stopped as NT Service";
                         MessageLoaderParms parms("src.Server.cimserver.STOPPED_NT_SERVICE",
                                                  "\nPegasus stopped as NT Service");
   
                         cout << MessageLoader::getMessage(parms) << endl;
                         exit(0);
                     }
                     else                     else
                     {                     {
                         cout << "Missing argument for option -";  
                         cout << option << endl;  
                         exit(0);                         exit(0);
                     }                     }
   
                     // remove the option from the command line  
                     memmove(&argv[i], &argv[i + 2], (argc-i-1) * sizeof(char*));  
                     argc -= 2;  
                 }                 }
   #endif
                 else                 else
                     i++;                     i++;
             }             }
Line 509 
Line 841 
     }     }
     catch (Exception& e)     catch (Exception& e)
     {     {
   #ifdef PEGASUS_OS_OS400
           Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                           "$0: $1",argv[0] ,e.getMessage());
   #else
         cerr << argv[0] << ": " << e.getMessage() << endl;         cerr << argv[0] << ": " << e.getMessage() << endl;
   #endif
         exit(1);         exit(1);
     }     }
  
   // l10n
           // Set the home directory, msg sub-dir, into the MessageLoader.
           // This will be the default directory where the resource bundles
           // are found.
           String messagesDir = String::EMPTY;
   #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
           messagesDir = OS400_DEFAULT_MESSAGE_SOURCE;
   #else
           messagesDir = ConfigManager::getHomedPath("msg");
   #endif
           MessageLoader::setPegasusMsgHome(messagesDir);
  
     try      Boolean enableHttpConnection = String::equal(
     {          configManager->getCurrentValue("enableHttpConnection"), "true");
         //      Boolean enableHttpsConnection = String::equal(
         // Check to see if we should (can) install as a NT service          configManager->getCurrentValue("enableHttpsConnection"), "true");
         //  
       // Make sure at least one connection is enabled
         if (String::equal(configManager->getCurrentValue("install"), "true"))  #ifndef PEGASUS_LOCAL_DOMAIN_SOCKET
         {      if (!enableHttpConnection && !enableHttpsConnection)
             if( 0 != cimserver_install_nt_service( pegasusHome ))      {
             {          //l10n
                 cout << "\nPegasus installed as NT Service";          //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                 exit(0);              //"Neither HTTP nor HTTPS connection is enabled.  "
             }              //"CIMServer will not be started.");
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                   "src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
               "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");
           //cerr << "Neither HTTP nor HTTPS connection is enabled.  "
               //"CIMServer will not be started." << endl;
           MessageLoaderParms parms("src.Server.cimserver.HTTP_NOT_ENABLED_SERVER_NOT_STARTING",
                                                            "Neither HTTP nor HTTPS connection is enabled.  CIMServer will not be started.");
           cerr << MessageLoader::getMessage(parms) << endl;
           exit(1);
         }         }
   #endif
  
         //      try
         // Check to see if we should (can) remove Pegasus as an NT service  
         //  
   
         if (String::equal(configManager->getCurrentValue("remove"), "true"))  
         {  
             if( 0 != cimserver_remove_nt_service() )  
             {             {
                 cout << "\nPegasus removed as NT Service";  
                 exit(0);  
             }  
         }  
   
         //         //
         // Check to see if we should Pegasus as a daemon         // Check to see if we should Pegasus as a daemon
         //         //
Line 551 
Line 898 
             daemonOption = true;             daemonOption = true;
         }         }
  
         //  
         // Check the log trace options and set global variable  
         //  
   
         if (String::equal(configManager->getCurrentValue("logtrace"), "true"))  
         {  
             pegasusIOLog = true;  
         }  
   
         // 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.
Line 573 
Line 911 
         // Might be more logical to clean before set.         // Might be more logical to clean before set.
         // ATTN: Need tool to completely disable logging.         // ATTN: Need tool to completely disable logging.
  
   #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \
   !defined(PEGASUS_OS_OS400)
         Logger::setHomeDirectory(logsDirectory);         Logger::setHomeDirectory(logsDirectory);
   #endif
  
         //         //
         // Check to see if we need to shutdown CIMOM         // Check to see if we need to shutdown CIMOM
         //         //
         if (shutdownOption)         if (shutdownOption)
         {         {
             //              String configTimeout =
             // if timeout was specified, validate the timeout value                  configManager->getCurrentValue("shutdownTimeout");
             //              timeoutValue = strtol(configTimeout.getCString(), (char **)0, 10);
             if (timeoutOption)  
             {              shutdownCIMOM(timeoutValue);
                 Boolean valid = configManager->validatePropertyValue(  
                                              PROPERTY_TIMEOUT,  #ifdef PEGASUS_OS_OS400
                                              timeoutStr);              //l10n
                 if (!valid)              //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
                           //"CIM Server stopped.");
                   Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
                           "src.Server.cimserver.SERVER_STOPPED",
                           "CIM Server stopped.");
   #else
                           //l10n
               //cout << "CIM Server stopped." << endl;
               MessageLoaderParms parms("src.Server.cimserver.SERVER_STOPPED",
                                                            "CIM Server stopped.");
   
               cout << MessageLoader::getMessage(parms) << endl;
   #endif
               cimserver_exit(0);
           }
   
           // Leave this in until people get familiar with the logs.
   #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \
   !defined(PEGASUS_OS_OS400)
           //l10n
           //cout << "Logs Directory = " << logsDirectory << endl;
           MessageLoaderParms parms("src.Server.cimserver.LOGS_DIRECTORY",
                                                "Logs Directory = ");
           cout << MessageLoader::getMessage(parms) << logsDirectory << endl;
   #endif
   
           if (String::equal(configManager->getCurrentValue("slp"), "true"))
                 {                 {
                     cout << "Invalid timeout value specified: " << timeoutValue;              useSLP =  true;
                     cout << endl;  
                     exit(1);  
                 }                 }
             }             }
       catch (UnrecognizedConfigProperty e)
       {
  
             shutdownCIMOM(forceOption, timeoutValue);  #ifdef PEGASUS_OS_OS400
             cout << "Pegasus CIM Server terminated." << endl;          //l10n
             exit(0);          //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                       //"Error: $0",e.getMessage());
           Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                           "src.Server.cimserver.ERROR",
                       "Error: $0",e.getMessage());
   #else
           //l10n
           //cout << "Error: " << e.getMessage() << endl;
           MessageLoaderParms parms("src.Server.cimserver.ERROR",
                                                            "Error: $0",
                                                            e.getMessage());
           cout << MessageLoader::getMessage(parms) << endl;
   #endif
         }         }
  
         //      Uint32 portNumberHttps;
         // Grab the port option:      Uint32 portNumberHttp;
         //  
  
         portOption = configManager->getCurrentValue("port");      if (enableHttpsConnection)
       {
           String httpsPort = configManager->getCurrentValue("httpsPort");
           CString portString = httpsPort.getCString();
           char* end = 0;
           Uint32 port = strtol(portString, &end, 10);
           assert(end != 0 && *end == '\0');
  
         //         //
         // Check the trace options and set global variable          // Look up the WBEM-HTTPS port number
         //         //
           portNumberHttps = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, port);
       }
  
         if (String::equal(configManager->getCurrentValue("trace"), "true"))      if (enableHttpConnection)
         {         {
             pegasusIOTrace = true;          String httpPort = configManager->getCurrentValue("httpPort");
             cout << "Trace Set" << endl;          CString portString = httpPort.getCString();
           char* end = 0;
           Uint32 port = strtol(portString, &end, 10);
           assert(end != 0 && *end == '\0');
   
           //
           // Look up the WBEM-HTTP port number
           //
           portNumberHttp = System::lookupPort(WBEM_HTTP_SERVICE_NAME, port);
         }         }
  
         // Leave this in until people get familiar with the logs.      // Put out startup up message.
         cout << "Logs Directory = " << logsDirectory << endl;  #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \
   !defined(PEGASUS_OS_OS400)
       cout << PEGASUS_NAME << PEGASUS_VERSION << endl;
       //l10n
       //cout << "Built " << __DATE__ << " " << __TIME__ << endl;
       //cout <<"Starting..."
       MessageLoaderParms parms("src.Server.cimserver.STARTUP_MESSAGE",
                                                    "Built $0 $1\nStarting...",
                                                    __DATE__,
                                                    __TIME__);
       cout << MessageLoader::getMessage(parms)
                    << (useSLP ? " SLP reg. " : " No SLP ")
                    << endl;
   #endif
   
   //l10n
   // reset message loading to NON-process locale
   MessageLoader::_useProcessLocale = false;
   //l10n
  
         if (String::equal(configManager->getCurrentValue("cleanlogs"), "true"))      // do we need to run as a daemon ?
       if (daemonOption)
         {         {
             Logger::clean(logsDirectory);;          if(-1 == cimserver_fork())
   #ifndef PEGASUS_OS_OS400
           {
               exit(-1);
         }         }
   #else
         if (String::equal(configManager->getCurrentValue("slp"), "true"))  
         {         {
             useSLP =  true;              return(-1);
         }         }
           else
         if (String::equal(configManager->getCurrentValue("SSL"), "true"))  
         {         {
             useSSL =  true;              return(0);
         }         }
   #endif
   
     }     }
     catch (UnrecognizedConfigProperty e)  
     {  // l10n
         cout << "Error: " << e.getMessage() << endl;      // Now we are after the fork...
       // Create a dummy Thread object that can be used to store the
       // AcceptLanguages object for CIM requests that are serviced
       // by this thread (initial thread of server).  Need to do this
       // because this thread is not in a ThreadPool, but is used
       // to service CIM requests.
       // The run function for the dummy Thread should never be called,
       Thread *dummyInitialThread = new Thread(dummyThreadFunc, NULL, false);
       Thread::setCurrent(dummyInitialThread);
       AcceptLanguages default_al;
       try{
            default_al = AcceptLanguages::getDefaultAcceptLanguages();
            Thread::setLanguages(new AcceptLanguages(default_al));
       }catch(InvalidAcceptLanguageHeader e){
             Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                     "src.Server.cimserver.FAILED_TO_SET_PROCESS_LOCALE",
                             "Could not convert the system process locale into a valid AcceptLanguage format.");
                     Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                                    e.getMessage());
     }     }
  
     char* address = portOption.allocateCString();  
  
     // Put out startup up message.  
     cout << PEGASUS_NAME << PEGASUS_VERSION <<  
          " on port " << address << endl;  
     cout << "Built " << __DATE__ << " " << __TIME__ << endl;  
     cout <<"Started..."  
          << (pegasusIOTrace ? " Tracing to Display ": " ")  
          << (pegasusIOLog ? " Tracing to Log ": " ")  
          << (useSLP ? " SLP reg. " : " No SLP ")  
          << (useSSL ? " Use SSL " : " No SSL ")  
         << endl;  
  
     // Put server start message to the logger  #ifdef PEGASUS_OS_OS400
     Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,      // Special server initialization code for OS/400.
         "Start $0 $1 port $2 $3 $4 $5",      if (cimserver_initialize() != 0)
                 PEGASUS_NAME,      {
                 PEGASUS_VERSION,          // do some logging here!
                 address,          //l10n
                 (pegasusIOTrace ? " Tracing": " "),          //Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                 (useSLP ? " SLP on " : " SLP off "),                      //"CIM Server failed to initialize");
                 (useSSL ? " Use SSL " : " No SSL "));          Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE,
                                     "src.Server.cimserver.SERVER_FAILED_TO_INITIALIZE",
                             "CIM Server failed to initialize");
           exit(-1);
       }
   #endif
  
     // do we need to run as a daemon ?  
     if (daemonOption)  #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
       umask(S_IWGRP|S_IWOTH);
   
       //
       // check if CIMServer is already running
       // if CIMServer is already running, print message and
       // notify parent process (if there is a parent process) to terminate
       //
       if(isCIMServerRunning())
     {     {
         if(-1 == cimserver_fork())          //l10n
           exit(-1);                  //cout << "Unable to start CIMServer." << endl;
                   //cout << "CIMServer is already running." << endl;
                   MessageLoaderParms parms("src.Server.cimserver.UNABLE_TO_START_SERVER_ALREADY_RUNNING",
                                            "Unable to start CIMServer.\nCIMServer is already running.");
           PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
   
           //
           // notify parent process (if there is a parent process) to terminate
           //
           if (daemonOption)
                   notify_parent(1);
   
           exit(1);
     }     }
  
   #endif
   
     // try loop to bind the address, and run the server     // try loop to bind the address, and run the server
     try     try
     {     {
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX)  #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)
           char slp_address[32];
         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://");
         String host_name = slp_get_host_name();         String host_name = slp_get_host_name();
         serviceURL += host_name;          serviceURL.append(host_name);
         serviceURL += ":";          serviceURL.append(":");
         serviceURL += address;          // ATTN: Fix this to work for multiple connections
         char *url = serviceURL.allocateCString();          sprintf(slp_address, "%u",
         //      free(host_name);                  enableHttpConnection ? portNumberHttp : portNumberHttps);
           serviceURL.append(slp_address);
 #endif #endif
  
         Monitor monitor;          Monitor monitor(true);
         CIMServer server(&monitor, useSSL);          //monitor_2 monitor;
  
         // bind throws an exception if the bind fails          CIMServer server(&monitor);
   
   
   
           if (enableHttpConnection)
           {
               server.addAcceptor(false, portNumberHttp, false);
               //l10n
               //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                           //"Listening on HTTP port $0.", portNumberHttp);
   
               Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                                           "src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                                   "Listening on HTTP port $0.", portNumberHttp);
           }
           if (enableHttpsConnection)
           {
               server.addAcceptor(false, portNumberHttps, true);
               //l10n
               //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                           //"Listening on HTTPS port $0.", portNumberHttps);
               Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                                           "src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                                   "Listening on HTTPS port $0.", portNumberHttps);
           }
 #ifdef PEGASUS_LOCAL_DOMAIN_SOCKET #ifdef PEGASUS_LOCAL_DOMAIN_SOCKET
         cout << "Binding to domain socket" << endl;          server.addAcceptor(true, 0, false);
 #else          //l10n
         cout << "Binding to " << address << endl;          //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                       //"Listening on local connection socket.");
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                         "src.Server.cimserver.LISTENING_ON_LOCAL",
                         "Listening on local connection socket.");
 #endif #endif
  
         char* end = 0;  #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && !defined(PEGASUS_OS_OS400)
         long portNumber = strtol(address, &end, 10);          if (enableHttpConnection)
         assert(end != 0 && *end == '\0');          {
         server.bind(portNumber);              //l10n
               //cout << "Listening on HTTP port " << portNumberHttp << endl;
             MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTP_PORT",
                                      "Listening on HTTP port $0.", portNumberHttp);
                   cout << MessageLoader::getMessage(parms) << endl;
           }
           if (enableHttpsConnection)
           {
               //l10n
               //cout << "Listening on HTTPS port " << portNumberHttps << endl;
               MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_HTTPS_PORT",
                                        "Listening on HTTPS port $0.", portNumberHttps);
                   cout << MessageLoader::getMessage(parms) << endl;
           }
   # ifdef PEGASUS_LOCAL_DOMAIN_SOCKET
           //l10n
           //cout << "Listening on local connection socket" << endl;
           MessageLoaderParms parms("src.Server.cimserver.LISTENING_ON_LOCAL",
                                    "Listening on local connection socket.");
           cout << MessageLoader::getMessage(parms) << endl;
   # endif
   #endif
  
         delete [] address;          // bind throws an exception if the bind fails
           server.bind();
   
           // notify parent process (if there is a parent process) to terminate
           // so user knows that there is cimserver ready to serve CIM requests.
           if (daemonOption)
                   notify_parent(0);
  
         time_t last = 0;         time_t last = 0;
  
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
           //
           // create a file to indicate that the cimserver has started and
           // save the process id of the cimserver process in the file
           //
           // remove the old file if it exists
           System::removeFile(CIMSERVER_START_FILE);
   
           // open the file
           FILE *pid_file = fopen(CIMSERVER_START_FILE, "w");
   
           if (pid_file)
           {
               // save the pid in the file
               fprintf(pid_file, "%ld\n", (long)server_pid);
               fclose(pid_file);
           }
   #endif
   
   #if !defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_LINUX_IA64_GNU) && \
   !defined(PEGASUS_OS_OS400)
           cout << "Started. " << endl;
   #endif
   
           // Put server started message to the logger
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
           //l10n
           //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                       //"Started $0 version $1.",
                       //PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                                   "src.Server.cimserver.STARTED_VERSION",
                       "Started $0 version $1.",
                       PLATFORM_PRODUCT_NAME, PLATFORM_PRODUCT_VERSION);
   #else
                   //l10n
           //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                       //"Started $0 version $1.",
                       //PEGASUS_NAME, PEGASUS_VERSION);
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                                   "src.Server.cimserver.STARTED_VERSION",
                       "Started $0 version $1.",
                       PEGASUS_NAME, PEGASUS_VERSION);
   #endif
   
   
         //         //
         // Loop to call CIMServer's runForever() method until CIMServer         // Loop to call CIMServer's runForever() method until CIMServer
         // has been shutdown         // has been shutdown
         //         //
         while( !server.terminated() )         while( !server.terminated() )
         {         {
 #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX)  #if !defined(PEGASUS_OS_ZOS) && ! defined(PEGASUS_OS_HPUX) && ! defined(PEGASUS_NO_SLP)
           if(useSLP  )           if(useSLP  )
           {           {
             if(  (time(NULL) - last ) > 60 )             if(  (time(NULL) - last ) > 60 )
             {             {
               if( discovery != NULL && url != NULL )                if( discovery != NULL && serviceURL.size() )
                 discovery->srv_reg_all(url,                  discovery->srv_reg_all(serviceURL.getCString(),
                                        "(namespace=root/cimv2)",                                        "(namespace=root/cimv2)",
                                        "service:cim.pegasus",                                        "service:cim.pegasus",
                                        "DEFAULT",                                        "DEFAULT",
Line 730 
Line 1283 
           server.runForever();           server.runForever();
         }         }
  
         // This statement is unrechable!  
         //         //
         // Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,          // normal termination
         //   "Normal Termination");          //
           // Put server shutdown message to the logger
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_IA64_GNU)
           //l10n
           //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
               //"$0 stopped.", PLATFORM_PRODUCT_NAME);
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   "src.Server.cimserver.STOPPED",
               "$0 stopped.", PLATFORM_PRODUCT_NAME);
   #else
                   //l10n
           //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
               //"$0 stopped.", PEGASUS_NAME);
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION,
                   "src.Server.cimserver.STOPPED",
               "$0 stopped.", PEGASUS_NAME);
   #endif
   
   #if defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU) || defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
           //
           // close the file created at startup time to indicate that the
           // cimserver has terminated normally.
           //
           FileSystem::removeFile(CIMSERVER_START_FILE);
   #endif
     }     }
     catch(Exception& e)     catch(Exception& e)
     {     {
         Logger::put(Logger::STANDARD_LOG, "CIMServer", Logger::INFORMATION,  
             "Abnormal Termination $0", e.getMessage());  
  
         PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);          //l10n
           //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                       //"Error: $0", e.getMessage());
           Logger::put_l(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                           "src.Server.cimserver.ERROR",
                       "Error: $0", e.getMessage());
   
   #ifndef PEGASUS_OS_OS400
           //l10n
           //PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);
           MessageLoaderParms parms("src.Server.cimserver.ERROR",
                                                            "Error: $0", e.getMessage());
           PEGASUS_STD(cerr) << MessageLoader::getMessage(parms) << PEGASUS_STD(endl);
   
   #endif
   
           //
           // notify parent process (if there is a parent process) to terminate
           //
           if (daemonOption)
                   notify_parent(1);
   
           return 1;
     }     }
  
     return 0;     return 0;

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