(file) Return to ProviderRegistrationProvider.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ControlProviders / ProviderRegistrationProvider

Diff for /pegasus/src/Pegasus/ControlProviders/ProviderRegistrationProvider/ProviderRegistrationProvider.cpp between version 1.37 and 1.104

version 1.37, 2002/09/19 16:17:36 version 1.104, 2008/06/24 18:12:08
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // 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 20 
Line 28 
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //============================================================================== //==============================================================================
 //  
 // Author: Yi Zhou (yi_zhou@hp.com)  
 //  
 // Modified By: Chip Vincent (cvincent@us.ibm.com)  
 //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)  
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (carolann_graves@hp.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "ProviderRegistrationProvider.h" #include "ProviderRegistrationProvider.h"
Line 37 
Line 36 
 #include <Pegasus/Common/XmlWriter.h> #include <Pegasus/Common/XmlWriter.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
 #include <Pegasus/Common/OperationContext.h>  #include <Pegasus/Common/OperationContextInternal.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
   #include <Pegasus/Common/MessageLoader.h> //l10n
   #include <Pegasus/Common/Constants.h>
   #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/CIMNameUnchecked.h>
  
 PEGASUS_NAMESPACE_BEGIN  #include <Pegasus/Server/ProviderRegistrationManager/ProviderManagerMap.h>
   
 /**  
    The name of the operational status property  
 */  
 static const CIMName _PROPERTY_OPERATIONALSTATUS  =  
     CIMName ("OperationalStatus");  
   
 /**  
    The name of the name property for PG_Provider class  
 */  
 static const CIMName _PROPERTY_PROVIDER_NAME  = CIMName ("Name");  
   
 /**  
    The name of the Name property for PG_ProviderModule class  
 */  
 static const CIMName _PROPERTY_PROVIDERMODULE_NAME  = CIMName ("Name");  
   
 /**  
    The name of the Vendor property for PG_ProviderModule class  
 */  
 static const CIMName _PROPERTY_VENDOR  = CIMName ("Vendor");  
   
 /**  
    The name of the Version property for PG_ProviderModule class  
 */  
 static const CIMName _PROPERTY_VERSION  = CIMName ("Version");  
   
 /**  
    The name of the interface type property for PG_ProviderModule class  
 */  
 static const CIMName _PROPERTY_INTERFACETYPE  = CIMName ("InterfaceType");  
   
 /**  
    The name of the interface version property for PG_ProviderModule class  
 */  
 static const CIMName _PROPERTY_INTERFACEVERSION  = CIMName ("InterfaceVersion");  
  
 /**  PEGASUS_NAMESPACE_BEGIN
    The name of the location property for PG_ProviderModule class  
 */  
 static const CIMName _PROPERTY_LOCATION  = CIMName ("Location");  
  
 /** /**
    The name of the CapabilityID property for provider capabilities class    The name of the CapabilityID property for provider capabilities class
Line 89 
Line 53 
 static const CIMName _PROPERTY_CAPABILITYID  = CIMName ("CapabilityID"); static const CIMName _PROPERTY_CAPABILITYID  = CIMName ("CapabilityID");
  
 /** /**
    The name of the provider module name  property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_PROVIDERMODULENAME  =  
     CIMName ("ProviderModuleName");  
   
 /**  
    The name of the provider name  property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_PROVIDERNAME  = CIMName ("ProviderName");  
   
 /**  
    The name of the classname property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_CLASSNAME  = CIMName ("ClassName");  
   
 /**  
    The name of the Namespace property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_NAMESPACES  = CIMName ("Namespaces");  
   
 /**  
    The name of the provider type  property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_PROVIDERTYPE  = CIMName ("ProviderType");  
   
 /**  
    The name of the supported properties property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_SUPPORTEDPROPERTIES  =  
     CIMName ("SupportedProperties");  
   
 /**  
    The name of the supported methods property for provider capabilities class  
 */  
 static const CIMName _PROPERTY_SUPPORTEDMETHODS  = CIMName ("SupportedMethods");  
   
 /**  
    Registered instance provider type  
 */  
 static const Uint16 _INSTANCE_PROVIDER    = 2;  
   
 /**  
    Registered association provider type  
 */  
 static const Uint16 _ASSOCIATION_PROVIDER    = 3;  
   
 /**  
    Registered indication provider type  
 */  
 static const Uint16 _INDICATION_PROVIDER    = 4;  
   
 /**  
    Registered method provider type  
 */  
 static const Uint16 _METHOD_PROVIDER    = 5;  
   
 /**  
    stopping provider method    stopping provider method
 */ */
 static const CIMName _STOP_PROVIDER     = CIMName ("Stop"); static const CIMName _STOP_PROVIDER     = CIMName ("Stop");
Line 155 
Line 62 
 */ */
 static const CIMName _START_PROVIDER   = CIMName ("Start"); static const CIMName _START_PROVIDER   = CIMName ("Start");
  
 /**  
    Provider status  
 */  
 static const Uint16 _MODULE_OK        = 2;  
   
 static const Uint16 _MODULE_STOPPING   = 9;  
   
 static const Uint16 _MODULE_STOPPED   = 10;  
   
 ProviderRegistrationProvider::ProviderRegistrationProvider( ProviderRegistrationProvider::ProviderRegistrationProvider(
     ProviderRegistrationManager * providerRegistrationManager)     ProviderRegistrationManager * providerRegistrationManager)
     :_id(peg_credential_types::PROVIDER)  
 { {
     _providerRegistrationManager = providerRegistrationManager;     _providerRegistrationManager = providerRegistrationManager;
  
     _controller = &(ModuleController::get_client_handle(_id, &_client_handle));      _controller = ModuleController::getModuleController();
     if(_client_handle == NULL)  
         throw UninitializedObjectException();  
 } }
  
 ProviderRegistrationProvider::~ProviderRegistrationProvider(void) ProviderRegistrationProvider::~ProviderRegistrationProvider(void)
 { {
     if (_providerRegistrationManager)  
     {  
         delete _providerRegistrationManager;  
     }  
   
     if (_client_handle)  
     {  
         delete _client_handle;  
     }  
   
 }  
   
 void ProviderRegistrationProvider::initialize(CIMOMHandle & cimom)  
 {  
     // This method should not be called because this is a control provider  
     // and is not dynamically loaded through the provider manager  
 }  
   
 void ProviderRegistrationProvider::terminate(void)  
 {  
 } }
  
 // get registered provider // get registered provider
Line 220 
Line 95 
  
     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
Line 231 
Line 107 
  
     CIMInstance instance;     CIMInstance instance;
  
     try      instance = _providerRegistrationManager->getInstance(
     {          instanceReference, includeQualifiers, includeClassOrigin, propertyList);
         instance = _providerRegistrationManager->getInstance(instanceReference);  
     }  
     catch(CIMException& e)  
     {  
         throw (e);  
     }  
  
     handler.deliver(instance);     handler.deliver(instance);
  
Line 266 
Line 136 
  
     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
Line 277 
Line 148 
  
     Array<CIMInstance> enumInstances;     Array<CIMInstance> enumInstances;
  
     try      enumInstances =
     {          _providerRegistrationManager->enumerateInstancesForClass(
         enumInstances = _providerRegistrationManager->enumerateInstances(classReference);              classReference,
     }              includeQualifiers,
     catch(CIMException& e)              includeClassOrigin,
     {              propertyList);
         throw (e);  
     }  
  
     handler.deliver(enumInstances);     handler.deliver(enumInstances);
  
Line 309 
Line 178 
  
     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
Line 321 
Line 191 
     Array<CIMObjectPath> enumInstanceNames;     Array<CIMObjectPath> enumInstanceNames;
  
     // get all instance names from repository     // get all instance names from repository
     try  
     {  
         enumInstanceNames =         enumInstanceNames =
             _providerRegistrationManager->enumerateInstanceNames(classReference);          _providerRegistrationManager->enumerateInstanceNamesForClass(
     }              classReference);
     catch(CIMException& e)  
     {  
         throw (e);  
     }  
  
     handler.deliver(enumInstanceNames);     handler.deliver(enumInstanceNames);
  
Line 360 
Line 224 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(
             "You must have superuser privilege to modify the registration.");              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_MODIFY_REGISTRATION",
               "You must have superuser privilege to modify the"
                   " registration."));
     }     }
   #endif
  
     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
Line 388 
Line 258 
     //     //
     if (propertyList.isNull())     if (propertyList.isNull())
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED, MessageLoaderParms(
             "Only can modify Namespaces, SupportedProperties, and SupportedMethods.");              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
               "CAN_ONLY_MODIFY_ERR",
               "Only can modify Namespaces, SupportedProperties,"
                   "and SupportedMethods."));
     }     }
  
     Array<CIMName> propertyArray = propertyList.getPropertyNameArray();     Array<CIMName> propertyArray = propertyList.getPropertyNameArray();
Line 407 
Line 281 
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     try      _providerRegistrationManager->modifyInstance(
     {          instanceReference, instanceObject, includeQualifiers, propertyArray);
         _providerRegistrationManager->modifyInstance(instanceReference,  
             instanceObject, includeQualifiers, propertyArray);  #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
     }      _sendUpdateCacheMessagetoInteropProvider(context);
     catch(CIMException& e)  #endif
     {  
         throw (e);  
     }  
  
     // complete processing the request     // complete processing the request
     handler.complete();     handler.complete();
Line 440 
Line 311 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, MessageLoaderParms(
             "You must have superuser privilege to register providers.");              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_REGISTER_PROVIDERS",
               "You must have superuser privilege to register providers."));
     }     }
   #endif
  
     CIMName className = instanceReference.getClassName();     CIMName className = instanceReference.getClassName();
     CIMNamespaceName nameSpace = instanceReference.getNameSpace();     CIMNamespaceName nameSpace = instanceReference.getNameSpace();
Line 462 
Line 338 
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
Line 481 
Line 358 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing Name which is required property in PG_ProviderModule class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_NAME_IN_PG_PROVIDERMODULE",
                       "Missing Name which is required property in "
                           "PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing Vendor which is required property in PG_ProviderModule class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_VENDOR_IN_PG_PROVIDERMODULE",
                       "Missing Vendor which is required property in"
                           " PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing Version which is required property in PG_ProviderModule class.");                  MessageLoaderParms(
         }                      "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
         if (instanceObject.findProperty(_PROPERTY_INTERFACETYPE) ==                          "MISSING_VERSION_IN_PG_PROVIDERMODULE",
             PEG_NOT_FOUND)                      "Missing Version which is required property in"
         {                          " PG_ProviderModule class."));
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,          }
                 "Missing InterfaceType which is required property in PG_ProviderModule class.");  
         }          Uint32 ifcTypeIndex =
               instanceObject.findProperty(_PROPERTY_INTERFACETYPE);
         if (instanceObject.findProperty(_PROPERTY_INTERFACEVERSION) ==          if (ifcTypeIndex == PEG_NOT_FOUND)
             PEG_NOT_FOUND)          {
         {              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,                  MessageLoaderParms(
                 "Missing InterfaceVersion which is required property in PG_ProviderModule class.");                      "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_INTERFACETYPE_IN_PG_PROVIDERMODULE",
                       "Missing InterfaceType which is required property in"
                           " PG_ProviderModule class."));
           }
           String ifcTypeString;
           instanceObject.getProperty(ifcTypeIndex).getValue().
               get(ifcTypeString);
   
           String ifcEmptyVersion;
           if (!ProviderManagerMap::instance().
                   isValidProvMgrIfc(ifcTypeString, ifcEmptyVersion))
           {
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                   MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "UNSUPPORTED_INTERFACETYPE_VALUE",
                   "Unsupported InterfaceType value: \"$0\"",ifcTypeString));
           }
   
           Uint32 ifcVersionIndex =
               instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);
           if (ifcVersionIndex == PEG_NOT_FOUND)
           {
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                   MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_INTERFACEVERSION_IN_PG_PROVIDERMODULE",
                       "Missing InterfaceVersion which is required property "
                           "in PG_ProviderModule class."));
           }
           String ifcVersionString;
           instanceObject.getProperty(ifcVersionIndex).getValue().
               get(ifcVersionString);
   
           if (!ProviderManagerMap::instance().isValidProvMgrIfc(
                       ifcTypeString, ifcVersionString))
           {
               String unsupported = "InterfaceVersion";
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                   MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "UNSUPPORTED_INTERFACEVERSION_VALUE",
                       "Unsupported InterfaceVersion value: \"$0\"",
                   ifcVersionString));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing Location which is required property in PG_ProviderModule class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_LOCATION_IN_PG_PROVIDERMODULE",
                       "Missing Location which is required property in"
                           " PG_ProviderModule class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==         if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             Array<Uint16> _operationalStatus;             Array<Uint16> _operationalStatus;
             _operationalStatus.append(_MODULE_OK);              _operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
             instance.addProperty (CIMProperty             instance.addProperty (CIMProperty
                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));                 (_PROPERTY_OPERATIONALSTATUS, _operationalStatus));
         }         }
   
           //
           // Validate the UserContext property
           //
           CIMValue userContextValue;
           Uint32 userContextIndex = instanceObject.findProperty(
               PEGASUS_PROPERTYNAME_MODULE_USERCONTEXT);
   
           if (userContextIndex != PEG_NOT_FOUND)
           {
               userContextValue =
                   instanceObject.getProperty(userContextIndex).getValue();
           }
   
           if (!userContextValue.isNull())
           {
               Uint16 userContext;
               userContextValue.get(userContext);
   
   #ifdef PEGASUS_DISABLE_PROV_USERCTXT
               if (userContext != PG_PROVMODULE_USERCTXT_CIMSERVER)
               {
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                       MessageLoaderParms(
                           "ControlProviders.ProviderRegistrationProvider."
                               "ProviderRegistrationProvider."
                               "USERCONTEXT_UNSUPPORTED",
                           "The UserContext property in the PG_ProviderModule "
                               "class is not supported."));
               }
   #else
               if (!((userContext == PG_PROVMODULE_USERCTXT_REQUESTOR) ||
   #ifndef PEGASUS_OS_ZOS
                     (userContext == PG_PROVMODULE_USERCTXT_CIMSERVER) ||
                     (userContext == PG_PROVMODULE_USERCTXT_PRIVILEGED) ||
   #endif
                     (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)))
               {
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                       MessageLoaderParms(
                           "ControlProviders.ProviderRegistrationProvider."
                               "ProviderRegistrationProvider."
                               "UNSUPPORTED_USERCONTEXT_VALUE",
                           "Unsupported UserContext value: \"$0\".",
                           userContext));
               }
   
               // DesignatedUserContext property is required when UserContext == 3
               if (userContext == PG_PROVMODULE_USERCTXT_DESIGNATED)
               {
                   Uint32 designatedUserIndex = instanceObject.findProperty(
                       PEGASUS_PROPERTYNAME_MODULE_DESIGNATEDUSER);
                   if ((designatedUserIndex == PEG_NOT_FOUND) ||
                       instanceObject.getProperty(designatedUserIndex).getValue()
                           .isNull())
                   {
                       throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                           MessageLoaderParms(
                               "ControlProviders.ProviderRegistrationProvider."
                                   "ProviderRegistrationProvider."
                                   "MISSING_DESIGNATEDUSER_IN_PG_PROVIDERMODULE",
                               "Missing DesignatedUserContext property in "
                                   "PG_ProviderModule instance."));
                   }
                   else
                   {
                       // Validate that DesignatedUserContext is of String type
                       String designatedUser;
                       instanceObject.getProperty(designatedUserIndex).getValue()
                           .get(designatedUser);
                   }
               }
   #endif
           }
     }     }
     else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))     else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
Line 536 
Line 550 
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_PROVIDERMODULENAME_IN_PG_PROVIDERCAPABILITIES",
                       "Missing ProviderModuleName which is required property in"
                           " PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              String missing = "ProviderName";
                 "Missing ProviderName which is required property in PG_ProviderCapabilities class.");              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                   MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_PROVIDERNAME_IN_PG_PROVIDERCAPABILITIES",
                       "Missing the required ProviderName property in "
                           "PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==         if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing CapabilityID which is required property in PG_ProviderCapabilities class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_CAPABILITYID_IN_PG_PROVIDERCAPABILITIES",
                       "Missing the required CapabilityID property in "
                           "PG_ProviderCapabilities class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)         if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing ClassName which is required property in PG_ProviderCapabilities class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_CLASSNAME_IN_PG_PROVIDERCAPABILITIES",
                       "Missing ClassName which is required property in"
                           " PG_ProviderCapabilities class."));
           }
   
           // Validate the Namespaces property
   
           Uint32 namespacesIndex =
               instanceObject.findProperty(_PROPERTY_NAMESPACES);
           Array<String> namespacesArray;
           if (namespacesIndex != PEG_NOT_FOUND)
           {
               CIMValue namespacesValue =
                   instanceObject.getProperty(namespacesIndex).getValue();
               if (!namespacesValue.isNull())
               {
                   namespacesValue.get(namespacesArray);
         }         }
           }
   
           if (namespacesArray.size() == 0)
           {
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                   MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_NAMESPACES_IN_PG_PROVIDERCAPABILITIES",
                       "Missing Namespaces which is required property in "
                           "PG_ProviderCapabilities class."));
           }
   
           // Validate the ProviderType property
   
           Uint32 providerTypeIndex =
               instanceObject.findProperty(_PROPERTY_PROVIDERTYPE);
           Array<Uint16> providerTypeArray;
           if (providerTypeIndex != PEG_NOT_FOUND)
           {
               CIMValue providerTypeValue =
                   instanceObject.getProperty(providerTypeIndex).getValue();
               if (!providerTypeValue.isNull())
               {
                   providerTypeValue.get(providerTypeArray);
               }
           }
   
           if (providerTypeArray.size() == 0)
           {
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                   MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_PROVIDERTYPE_IN_PG_PROVIDERCAPABILITIES",
                       "Missing ProviderType which is required property in "
                           "PG_ProviderCapabilities class."));
           }
   
           for (Uint32 i = 0; i < providerTypeArray.size(); i++)
           {
               if ((providerTypeArray[i] < 2) ||
   #ifdef PEGASUS_DISABLE_EXECQUERY
                   (providerTypeArray[i] > 6)
   #else
                   (providerTypeArray[i] > 7)
   #endif
                                             )
               {
                   throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
                       MessageLoaderParms(
                           "ControlProviders.ProviderRegistrationProvider."
                               "ProviderRegistrationProvider.UNSUPPORTED_"
                               "PROVIDERTYPE_IN_PG_PROVIDERCAPABILITIES",
                           "Unsupported ProviderType value \"$0\" in "
                               "PG_ProviderCapabilities instance.",
                           providerTypeArray[i]));
               }
           }
       }
       else if (className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES))
       {
           //
           // ProviderModuleName, ProviderName, CapabilityID, ProviderType,
           // and Destinations properties must be set
           //
   
           if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
               PEG_NOT_FOUND)
           {
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "MISSING_PROVIDER_MODULE_NAME_WHICH_IS_REQUIRED",
                   "Missing ProviderModuleName which is required property in"
                       " PG_ConsumerCapabilities class.");
   
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
           }
   
           if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==
               PEG_NOT_FOUND)
           {
  
         if (instanceObject.findProperty(_PROPERTY_NAMESPACES) == PEG_NOT_FOUND)              MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "MISSING_PROVIDER_NAME_WHICH_IS_REQUIRED",
                   "Missing ProviderName which is required property in"
                       " PG_ConsumerCapabilities class.");
   
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
           }
   
           if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==
               PEG_NOT_FOUND)
           {
   
               MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "MISSING_CAPABILITY_ID_WHICH_IS_REQUIRED",
                   "Missing the required CapabilityID property in "
                       "PG_ConsumerCapabilities class.");
   
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
           }
   
           if (instanceObject.findProperty
               (_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 "Missing Namespaces which is required property in PG_ProviderCapabilities class.");              MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "MISSING_PROVIDER_TYPE_WHICH_IS_REQUIRED",
                   "Missing ProviderType which is required property in"
                       " PG_ConsumerCapabilities class.");
   
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)          if (instanceObject.findProperty(_PROPERTY_INDICATIONDESTINATIONS) ==
               PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,  
                 "Missing ProviderType which is required property in PG_ProviderCapabilities class.");              MessageLoaderParms parms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "MISSING_DESTINATIONS_TYPE_WHICH_IS_REQUIRED",
                   "Missing Destinations which is required property in"
                       " PG_ConsumerCapabilities class.");
   
               throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, parms);
         }         }
     }     }
     else // PEGASUS_CLASSNAME_PROVIDER     else // PEGASUS_CLASSNAME_PROVIDER
Line 577 
Line 749 
         //         //
         // Name and ProviderModuleName properties must be set         // Name and ProviderModuleName properties must be set
         //         //
         if (instanceObject.findProperty(_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)          if (instanceObject.findProperty
                   (_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing Name which is required property in PG_Provider class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_NAME_IN_PG_PROVIDER",
                       "Missing the required Name property in PG_Provider "
                           "class."));
         }         }
  
         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==         if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==
             PEG_NOT_FOUND)             PEG_NOT_FOUND)
         {         {
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "Missing ProviderModuleName which is required property in PG_Provider class.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "MISSING_PROVIDERMODULENAME_IN_PG_PROVIDER",
                       "Missing ProviderModuleName which is required property in "
                           "PG_Provider class."));
         }         }
     }     }
  
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     try      returnReference = _providerRegistrationManager->createInstance(
     {          instanceReference, instance);
         returnReference =  
             _providerRegistrationManager->createInstance(instanceReference, instance);  #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
     }      if(className.equal (PEGASUS_CLASSNAME_PROVIDER) ||
     catch(CIMException& e)         className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))
     {     {
         throw (e);          _sendUpdateCacheMessagetoInteropProvider(context);
     }     }
   #endif
  
     handler.deliver(returnReference);     handler.deliver(returnReference);
  
Line 628 
Line 812 
         userName = String::EMPTY;         userName = String::EMPTY;
     }     }
  
   #ifndef PEGASUS_OS_ZOS
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(
             "You must have superuser privilege to unregister providers.");              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_UNREGISTER_PROVIDERS",
               "You must have superuser privilege to unregister providers."));
     }     }
   #endif
  
     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))     if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
Line 640 
Line 829 
             instanceReference.getNameSpace().getString());             instanceReference.getNameSpace().getString());
     }     }
  
   
       AcceptLanguageList al;
       try
       {
           AcceptLanguageListContainer al_container =
                   (AcceptLanguageListContainer)context.get
                   (AcceptLanguageListContainer::NAME);
           al = al_container.getLanguages();
       }
       catch (...)
       {
           ;   // Leave AcceptLanguageList empty
       }
   
     CIMName className = instanceReference.getClassName();     CIMName className = instanceReference.getClassName();
  
     // ensure the class existing in the specified namespace     // ensure the class existing in the specified namespace
     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&     if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&        !className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&
          !className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&
        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))        !className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
Line 654 
Line 858 
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
  
     try      String moduleName;
     {      Boolean moduleFound = false;
         _providerRegistrationManager->deleteInstance(instanceReference);      Array<CIMKeyBinding> keys = instanceReference.getKeyBindings();
     }  
     catch(CIMException& e)  
     {  
         throw (e);  
     }  
  
     // complete processing the request      //
     handler.complete();      // disable provider before delete provider
 }      // registration if the class is PG_Provider
       //
       if (className.equal (PEGASUS_CLASSNAME_PROVIDER))
       {
           // get module name from reference
  
 // Block a provider, unblock a provider, and stop a provider          for(Uint32 i=0; i<keys.size() ; i++)
 void ProviderRegistrationProvider::invokeMethod(  
     const OperationContext & context,  
     const CIMObjectPath & objectReference,  
     const CIMName & methodName,  
     const Array<CIMParamValue> & inParameters,  
     MethodResultResponseHandler & handler)  
 { {
     // get userName and only privileged user can execute this operation              if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULENAME))
     String userName;  
     try  
     {     {
         IdentityContainer container = context.get(IdentityContainer::NAME);                  moduleName = keys[i].getValue();
         userName = container.getUserName();                  moduleFound = true;
     }     }
     catch (...)          }
   
           // if _PROPERTY_PROVIDERMODULENAME key not found
           if( !moduleFound)
     {     {
         userName = String::EMPTY;              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                       MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider."
                       "ProviderRegistrationProvider."
                       "PROVIDERMODULENAME_KEY_NOT_FOUND",
                   "key ProviderModuleName was not found"));
     }     }
  
     if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))          //
           // disable the provider
           //
           Sint16 ret_value = _disableModule(
               instanceReference, moduleName, true, al);
   
           //
           // if the provider disable failed
           //
           if (ret_value == -1)
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
             "You must have superuser privilege to disable or enable providers.");                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "DISABLE_PROVIDER_FAILED",
                       "disable the provider failed."));
     }     }
  
     if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))          //
           // The provider disable failed since there are pending requests
           //
           if (ret_value == -2)
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
             objectReference.getNameSpace().getString());                  MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "DISABLE_PROVIDER_FAILED_PROVIDER_BUSY",
                       "disable the provider failed: Provider is busy."));
           }
     }     }
  
     String moduleName;      //
     Boolean moduleFound = false;      // disable provider module before remove provider registration
       // if the class is PG_ProviderModule
       //
  
       if (className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
       {
     // get module name from reference     // get module name from reference
     Array<CIMKeyBinding> keys = objectReference.getKeyBindings();  
  
     for(Uint32 i=0; i<keys.size() ; i++)     for(Uint32 i=0; i<keys.size() ; i++)
     {     {
Line 717 
Line 944 
     // if _PROPERTY_PROVIDERMODULE_NAME key not found     // if _PROPERTY_PROVIDERMODULE_NAME key not found
     if( !moduleFound)     if( !moduleFound)
     {     {
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
                 "key Name was not found");                  MessageLoaderParms(
                   "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                   "key Name was not found"));
     }     }
  
     //     //
     // get module status          // disable the provider module
     //     //
     Array<Uint16> _OperationalStatus =          Sint16 ret_value = _disableModule(
         _providerRegistrationManager->getProviderModuleStatus( moduleName);              instanceReference, moduleName, false, al);
   
     // get module instance  
     CIMInstance mInstance = _providerRegistrationManager->getInstance(objectReference);  
   
     handler.processing();  
   
     Sint16 ret_value;  
  
     if(methodName.equal(_STOP_PROVIDER))          //
           // if the provider module disable failed
           //
           if (ret_value == -1)
     {     {
         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
         {                  MessageLoaderParms(
             // retValue equals 1 if module is already disabled                      "ControlProviders.ProviderRegistrationProvider."
             if (_OperationalStatus[i] == _MODULE_STOPPED ||                          "ProviderRegistrationProvider."
                 _OperationalStatus[i] == _MODULE_STOPPING)                          "DISABLE_PROVIDER_MODULE_FAILED",
             {                      "disable the provider module failed."));
                 ret_value = 1;  
                 CIMValue retValue(ret_value);  
                 handler.deliver(retValue);  
                 handler.complete();  
                 return;  
             }  
         }         }
  
         CIMInstance instance;          //
         Array<CIMInstance> instances;          // The provider module disable failed since there are
         String _moduleName;          // pending requests
           //
         // get all provider instances which have same module name as moduleName          if (ret_value == -2)
         CIMObjectPath providerRef(objectReference.getHost(),  
                                  objectReference.getNameSpace(),  
                                  PEGASUS_CLASSNAME_PROVIDER,  
                                  objectReference.getKeyBindings());  
         Array<CIMInstance> namedInstances;  
         namedInstances = _providerRegistrationManager->enumerateInstances(providerRef);  
         for(Uint32 i = 0, n=namedInstances.size(); i < n; i++)  
         {  
             instance = namedInstances[i];  
             instance.getProperty(instance.findProperty  
             (_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);  
             if (String::equalNoCase(_moduleName, moduleName))  
             {             {
                 instances.append(instance);              throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
                   MessageLoaderParms(
                       "ControlProviders.ProviderRegistrationProvider."
                           "ProviderRegistrationProvider."
                           "DISABLE_PROVIDER_MODULE_FAILED_PROVIDER_BUSY",
                       "disable the provider module failed: Provider is busy."));
             }             }
   
         }         }
  
         //      _providerRegistrationManager->deleteInstance(instanceReference);
         // get provider manager service  
         //  
         MessageQueueService * _service = _getProviderManagerService();  
  
         if (_service != NULL)  #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
       if(className.equal (PEGASUS_CLASSNAME_PROVIDER) ||
          className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) ||
          className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))
         {         {
             // create CIMDisableModuleRequestMessage          _sendUpdateCacheMessagetoInteropProvider(context);
             CIMDisableModuleRequestMessage * disable_req =      }
                 new CIMDisableModuleRequestMessage(  #endif
                     XmlWriter::getNextMessageId (),      // complete processing the request
                     mInstance,      handler.complete();
                     instances,  }
                     QueueIdStack(_service->getQueueId()));  
   
             Array<Uint16> _opStatus =  
                 _sendDisableMessageToProviderManager(disable_req);  
  
             for (Uint32 i = 0; i<_opStatus.size(); i++)  // Block a provider, unblock a provider, and stop a provider
   void ProviderRegistrationProvider::invokeMethod(
       const OperationContext & context,
       const CIMObjectPath & objectReference,
       const CIMName & methodName,
       const Array<CIMParamValue> & inParameters,
       MethodResultResponseHandler & handler)
             {             {
                 if (_opStatus[i] == _MODULE_STOPPED)      // get userName and only privileged user can execute this operation
       String userName;
       try
                 {                 {
                     // module was disabled successfully          IdentityContainer container = context.get(IdentityContainer::NAME);
                     ret_value = 0;          userName = container.getUserName();
                     CIMValue retValue(ret_value);  
                     handler.deliver(retValue);  
                     handler.complete();  
   
                     // send termination message to subscription service  
                     _sendTerminationMessageToSubscription(objectReference, moduleName);  
                     return;  
                 }  
             }             }
       catch (...)
       {
           userName = String::EMPTY;
         }         }
  
         // disable failed  #ifndef PEGASUS_OS_ZOS
         ret_value = -1;      if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))
         CIMValue retValue(ret_value);      {
         handler.deliver(retValue);          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,
         handler.complete();              MessageLoaderParms(
         return;              "ControlProviders.ProviderRegistrationProvider."
                   "ProviderRegistrationProvider."
                   "SUPERUSER_PRIVILEGE_REQUIRED_DISABLE_ENABLE_PROVIDERS",
               "You must have superuser privilege to disable or enable"
                   " providers."));
     }     }
     else if(methodName.equal(_START_PROVIDER))  #endif
   
       if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))
     {     {
         for (Uint32 i = 0; i<_OperationalStatus.size(); i++)          throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
               objectReference.getNameSpace().getString());
       }
   
   
       // l10n
       // Get the client's list of preferred languages for the response
       AcceptLanguageList al;
       try
         {         {
             // retValue equals 1 if module is already enabled          AcceptLanguageListContainer al_container =
             if (_OperationalStatus[i] == _MODULE_OK)                  (AcceptLanguageListContainer)context.get
                   (AcceptLanguageListContainer::NAME);
           al = al_container.getLanguages();
       }
       catch (...)
             {             {
                 ret_value = 1;          ;   // Leave AcceptLanguageList empty
                 CIMValue retValue(ret_value);  
                 handler.deliver(retValue);  
                 handler.complete();  
                 return;  
             }             }
  
             // retValue equals 2 if module is stopping      String moduleName;
             // at this stage, module can not be started      Boolean moduleFound = false;
             if (_OperationalStatus[i] == _MODULE_STOPPING)  
       // get module name from reference
       Array<CIMKeyBinding> keys = objectReference.getKeyBindings();
   
       for(Uint32 i=0; i<keys.size() ; i++)
             {             {
                 ret_value = 2;          if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULE_NAME))
                 CIMValue retValue(ret_value);          {
                 handler.deliver(retValue);              moduleName = keys[i].getValue();
                 handler.complete();              moduleFound = true;
                 return;  
             }             }
         }         }
  
         //      // if _PROPERTY_PROVIDERMODULE_NAME key not found
         // get provider manager service      if( !moduleFound)
         //  
         MessageQueueService * _service = _getProviderManagerService();  
   
         if (_service != NULL)  
         {         {
             // create CIMEnableModuleRequestMessage          throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER,
             CIMEnableModuleRequestMessage * enable_req =              MessageLoaderParms(
                 new CIMEnableModuleRequestMessage(                  "ControlProviders.ProviderRegistrationProvider."
                     XmlWriter::getNextMessageId (),                      "ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",
                     mInstance,                  "key Name was not found"));
                     QueueIdStack(_service->getQueueId()));      }
  
             Array<Uint16> _opStatus;      handler.processing();
             _opStatus = _sendEnableMessageToProviderManager(enable_req);  
  
             for (Uint32 i = 0; i<_opStatus.size(); i++)      Sint16 ret_value;
             {  
                 if (_opStatus[i] == _MODULE_OK)      if (methodName.equal(_STOP_PROVIDER))
                 {                 {
                     // module was enabled successfully          // disable module
                     ret_value = 0;          ret_value = _disableModule(objectReference, moduleName, false, al);
                     CIMValue retValue(ret_value);  
                     handler.deliver(retValue);  
                     handler.complete();  
                     return;  
                 }                 }
       else if (methodName.equal(_START_PROVIDER))
       {
           // enable module
           ret_value = _enableModule(objectReference, moduleName, al);
             }             }
       else
       {
           throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE,
               String::EMPTY);
         }         }
   #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
       _sendUpdateCacheMessagetoInteropProvider(context);
   #endif
  
         // enable failed  
         ret_value = -1;  
         CIMValue retValue(ret_value);         CIMValue retValue(ret_value);
         handler.deliver(retValue);         handler.deliver(retValue);
         handler.complete();         handler.complete();
         return;  
     }  
     else  
     {  
         throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);  
     }  
 } }
  
 // get provider manager service // get provider manager service
 MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService() MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService()
 { {
     MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);      MessageQueue * queue =
           MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);
     MessageQueueService * _service = dynamic_cast<MessageQueueService *>(queue);     MessageQueueService * _service = dynamic_cast<MessageQueueService *>(queue);
  
     return(_service);     return(_service);
 } }
  
 ProviderRegistrationProvider & ProviderRegistrationProvider::operator=(const ProviderRegistrationProvider & handle)  ProviderRegistrationProvider & ProviderRegistrationProvider::operator=
       (const ProviderRegistrationProvider & handle)
 { {
     if(this == &handle)     if(this == &handle)
     {     {
Line 904 
Line 1128 
     return(*this);     return(*this);
 } }
  
 Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager(  Array<Uint16>
       ProviderRegistrationProvider::_sendDisableMessageToProviderManager(
         CIMDisableModuleRequestMessage * disable_req)         CIMDisableModuleRequestMessage * disable_req)
 { {
     MessageQueueService * _service = _getProviderManagerService();     MessageQueueService * _service = _getProviderManagerService();
     Uint32 _queueId = _service->getQueueId();     Uint32 _queueId = _service->getQueueId();
  
     callback_data *cb_data = new callback_data(this);  
   
     // create request envelope     // create request envelope
     AsyncLegacyOperationStart * asyncRequest =     AsyncLegacyOperationStart * asyncRequest =
         new AsyncLegacyOperationStart (         new AsyncLegacyOperationStart (
             _service->get_next_xid(),  
             NULL,             NULL,
             _queueId,             _queueId,
             disable_req,             disable_req,
             _queueId);             _queueId);
  
     AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,      AsyncReply * asyncReply =
                                                           _queueId,          _controller->ClientSendWait(_queueId, asyncRequest);
                                                           asyncRequest);  
     CIMDisableModuleResponseMessage * response =     CIMDisableModuleResponseMessage * response =
         reinterpret_cast<CIMDisableModuleResponseMessage *>(         reinterpret_cast<CIMDisableModuleResponseMessage *>(
              (static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());               (dynamic_cast<AsyncLegacyOperationResult
                     *>(asyncReply))->get_result());
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)     if (response->cimException.getCode() != CIM_ERR_SUCCESS)
     {     {
         CIMException e = response->cimException;         CIMException e = response->cimException;
         delete asyncRequest;         delete asyncRequest;
         delete asyncReply;         delete asyncReply;
         delete response;         delete response;
         throw (e);          throw e;
     }     }
  
     Array<Uint16> operationalStatus = response->operationalStatus;     Array<Uint16> operationalStatus = response->operationalStatus;
Line 951 
Line 1173 
     MessageQueueService * _service = _getProviderManagerService();     MessageQueueService * _service = _getProviderManagerService();
     Uint32 _queueId = _service->getQueueId();     Uint32 _queueId = _service->getQueueId();
  
     callback_data *cb_data = new callback_data(this);  
   
     // create request envelope     // create request envelope
     AsyncLegacyOperationStart * asyncRequest =     AsyncLegacyOperationStart * asyncRequest =
         new AsyncLegacyOperationStart (         new AsyncLegacyOperationStart (
             _service->get_next_xid(),  
             NULL,             NULL,
             _queueId,             _queueId,
             enable_req,             enable_req,
             _queueId);             _queueId);
  
     AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,      AsyncReply * asyncReply =
                                                           _queueId,          _controller->ClientSendWait(_queueId, asyncRequest);
                                                           asyncRequest);  
     CIMEnableModuleResponseMessage * response =     CIMEnableModuleResponseMessage * response =
         reinterpret_cast<CIMEnableModuleResponseMessage *>(         reinterpret_cast<CIMEnableModuleResponseMessage *>(
              (static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());               (dynamic_cast<AsyncLegacyOperationResult
                     *>(asyncReply))->get_result());
     if (response->cimException.getCode() != CIM_ERR_SUCCESS)     if (response->cimException.getCode() != CIM_ERR_SUCCESS)
     {     {
         CIMException e = response->cimException;         CIMException e = response->cimException;
Line 988 
Line 1207 
  
 // send termination message to subscription service // send termination message to subscription service
 void ProviderRegistrationProvider::_sendTerminationMessageToSubscription( void ProviderRegistrationProvider::_sendTerminationMessageToSubscription(
     const CIMObjectPath & ref, const String & moduleName)      const CIMObjectPath & ref, const String & moduleName,
       const Boolean disableProviderOnly,
       const AcceptLanguageList & al)
 { {
     CIMInstance instance;     CIMInstance instance;
     String _moduleName;     String _moduleName;
     Array<CIMInstance> instances;     Array<CIMInstance> instances;
  
       if (!disableProviderOnly)
       {
     CIMObjectPath reference("", PEGASUS_NAMESPACENAME_INTEROP,     CIMObjectPath reference("", PEGASUS_NAMESPACENAME_INTEROP,
         PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());         PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());
  
     // get all registered providers          Array<CIMObjectPath> instanceNames =
     Array<CIMInstance> enumInstances =              _providerRegistrationManager->enumerateInstanceNamesForClass(
         _providerRegistrationManager->enumerateInstances(reference);                  reference);
  
     // find all the instances which have same module name as moduleName     // find all the instances which have same module name as moduleName
     for (Uint32 i = 0, n=enumInstances.size(); i < n; i++)          for (Uint32 i = 0, n=instanceNames.size(); i < n; i++)
     {     {
         instance = enumInstances[i];  
   
         //         //
         // get provider module name              // get provider module name from reference
         //         //
         instance.getProperty(instance.findProperty  
         (_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);              Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
               for(Uint32 j=0; j < keys.size(); j++)
               {
                   if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                   {
                       _moduleName = keys[j].getValue();
                   }
               }
  
         if (String::equalNoCase(moduleName, _moduleName))         if (String::equalNoCase(moduleName, _moduleName))
         {         {
                   reference.setKeyBindings(keys);
                   instance = _providerRegistrationManager->getInstance(reference);
                   //
                   // if the provider is indication provider
                   //
                   if (_isIndicationProvider(moduleName, instance))
                   {
                       instances.append(instance);
                   }
               }
           }
       }
       else
       {
           instance = _providerRegistrationManager->getInstance(ref);
   
           //
           // if the provider is indication provider
           //
           if (_isIndicationProvider(moduleName, instance))
           {
             instances.append(instance);             instances.append(instance);
         }         }
     }     }
Line 1033 
Line 1283 
                 instances,                 instances,
                 QueueIdStack(_service->getQueueId()));                 QueueIdStack(_service->getQueueId()));
  
           // l10n
           termination_req->operationContext.set(AcceptLanguageListContainer(al));
   
         // create request envelope         // create request envelope
         AsyncLegacyOperationStart * asyncRequest =          AsyncLegacyOperationStart asyncRequest(
             new AsyncLegacyOperationStart (  
                 _service->get_next_xid(),  
                 NULL,                 NULL,
                 _queueId,                 _queueId,
                 termination_req,                 termination_req,
                 _queueId);                 _queueId);
  
         if( false  == _controller->ClientSendForget(          AutoPtr <AsyncReply> asyncReply(
                            *_client_handle,              _controller->ClientSendWait(_queueId, &asyncRequest));
                            _queueId,  
                            asyncRequest))          AutoPtr <CIMNotifyProviderTerminationResponseMessage> response
               (reinterpret_cast <CIMNotifyProviderTerminationResponseMessage *>
               ((dynamic_cast <AsyncLegacyOperationResult *>
               (asyncReply.get ()))->get_result ()));
   
           if (response->cimException.getCode () != CIM_ERR_SUCCESS)
         {         {
             delete asyncRequest;              CIMException e = response->cimException;
             throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);              throw e;
         }         }
     }     }
 } }
Line 1064 
Line 1320 
     return(_service);     return(_service);
 } }
  
   // disable provider module, return 0 if module is disabled successfully,
   // return 1 if module is already disabled, return -2 if module can not be
   // disabled since there are pending requests, otherwise, return -1
   Sint16 ProviderRegistrationProvider::_disableModule(
       const CIMObjectPath & objectReference,
       const String & moduleName,
       Boolean disableProviderOnly,
       const AcceptLanguageList & al)
   {
           //
           // get module status
           //
           Array<Uint16> _OperationalStatus =
               _providerRegistrationManager->getProviderModuleStatus( moduleName);
   
           for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
           {
               // retValue equals 1 if module is already disabled
               if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPED ||
                   _OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPING)
               {
                   return (1);
               }
           }
   
           CIMInstance instance;
           Array<CIMInstance> instances;
           CIMInstance mInstance;
           String _moduleName;
           CIMObjectPath providerRef;
           Boolean indProvider = false;
           Array<Boolean> indicationProviders;
   
           // disable a provider module or delete a provider module
           if (!disableProviderOnly)
           {
               providerRef = CIMObjectPath(objectReference.getHost(),
                                    objectReference.getNameSpace(),
                                    PEGASUS_CLASSNAME_PROVIDER,
                                    objectReference.getKeyBindings());
   
               // get module instance
               mInstance =
                   _providerRegistrationManager->getInstance(objectReference);
   
           }
           else // disable a provider
           {
               // get module instance
               Array <CIMKeyBinding> moduleKeyBindings;
               moduleKeyBindings.append (CIMKeyBinding
                   (_PROPERTY_PROVIDERMODULE_NAME, moduleName,
                    CIMKeyBinding::STRING));
   
               CIMObjectPath moduleRef(objectReference.getHost(),
                                       objectReference.getNameSpace(),
                                       PEGASUS_CLASSNAME_PROVIDERMODULE,
                                       moduleKeyBindings);
   
               mInstance =
                   _providerRegistrationManager->getInstance(moduleRef);
           }
   
           if (!disableProviderOnly)
           {
               // get all provider instances which have same module name as
               // moduleName
               Array<CIMObjectPath> instanceNames =
                   _providerRegistrationManager->enumerateInstanceNamesForClass(
                       providerRef);
   
               for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
               {
                   //
                   // get provider module name from reference
                   //
   
                   Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
                   for(Uint32 j=0; j < keys.size(); j++)
                   {
                       if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                       {
                           _moduleName = keys[j].getValue();
                       }
                   }
   
                   if (String::equalNoCase(_moduleName, moduleName))
                   {
                       providerRef.setKeyBindings(keys);
                       instance = _providerRegistrationManager->getInstance
                           (providerRef);
                       if (_isIndicationProvider(moduleName, instance))
                       {
                           indProvider = true;
                           indicationProviders.append(true);
                       }
                       else
                       {
                           indicationProviders.append(false);
                       }
                       instances.append(instance);
                   }
   
               }
           }
           else
           {
               instance =
                   _providerRegistrationManager->getInstance(objectReference);
               if (_isIndicationProvider(moduleName, instance))
               {
                   indProvider = true;
                   indicationProviders.append(true);
               }
               else
               {
                   indicationProviders.append(false);
               }
   
               instances.append(instance);
           }
   
           //
           // get provider manager service
           //
           MessageQueueService * _service = _getProviderManagerService();
   
           if (_service != NULL)
           {
               // create CIMDisableModuleRequestMessage
               CIMDisableModuleRequestMessage * disable_req =
                   new CIMDisableModuleRequestMessage(
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       instances,
                       disableProviderOnly,
                       indicationProviders,
                       QueueIdStack(_service->getQueueId()));
                   // l10n
                   disable_req->operationContext.set
                       (AcceptLanguageListContainer(al));;
   
               Array<Uint16> _opStatus =
                   _sendDisableMessageToProviderManager(disable_req);
   
               if (!disableProviderOnly) // disable provider module
               {
                   for (Uint32 i = 0; i<_opStatus.size(); i++)
                   {
                       // module was disabled successfully
                       if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPED)
                       {
                           if (indProvider)
                           {
                               // send termination message to subscription service
                               _sendTerminationMessageToSubscription(
                                   objectReference, moduleName, false, al);
                           }
                           return (0);
                       }
   
                       // module is not disabled since there are pending
                       // requests for the providers in the module
                       if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)
                       {
                           return (-2);
                       }
                   }
               }
               else // disable provider
               {
                   if (indProvider)
                   {
                       _sendTerminationMessageToSubscription(objectReference,
                           moduleName, true, al);
                   }
                   return (0);
               }
           }
   
           // disable failed
           return (-1);
   }
   
   // enable provider module
   // return 0 if module is enabled successfully,
   // return 1 if module is already enabled,
   // return 2 if module can not be enabled since module is stopping,
   // otherwise, return -1
   Sint16 ProviderRegistrationProvider::_enableModule(
       const CIMObjectPath & moduleRef,
       const String & moduleName,
       const AcceptLanguageList & al)
   {
           //
           // get module status
           //
           Array<Uint16> _OperationalStatus =
               _providerRegistrationManager->getProviderModuleStatus( moduleName);
   
           for (Uint32 i = 0; i<_OperationalStatus.size(); i++)
           {
               // retValue equals 1 if module is already enabled
               if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)
               {
                   return (1);
               }
   
               // retValue equals 2 if module is stopping
               // at this stage, module can not be started
               if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPING)
               {
                   return (2);
               }
           }
   
           // get module instance
           CIMInstance mInstance =
               _providerRegistrationManager->getInstance(moduleRef);
   
           //
           // get provider manager service
           //
           MessageQueueService * _service = _getProviderManagerService();
           Boolean enabled = false;
   
           if (_service != NULL)
           {
               // create CIMEnableModuleRequestMessage
               CIMEnableModuleRequestMessage * enable_req =
                   new CIMEnableModuleRequestMessage(
                       XmlWriter::getNextMessageId (),
                       mInstance,
                       QueueIdStack(_service->getQueueId()));
   
               enable_req->operationContext.set(AcceptLanguageListContainer(al));
   
               Array<Uint16> _opStatus;
               _opStatus = _sendEnableMessageToProviderManager(enable_req);
   
               for (Uint32 i = 0; i<_opStatus.size(); i++)
               {
                   // module is enabled successfully
                   if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)
                   {
                       enabled = true;
                   }
               }
           }
   
           if (enabled)
           {
               //
               // Since module is enabled, need get updated module instance
               //
               CIMInstance updatedModuleInstance =
                   _providerRegistrationManager->getInstance(moduleRef);
   
               //
               // The module is enabled, need to send enable message to
               // subscription service if the provider is an indication provider
               //
   
               CIMObjectPath providerRef = CIMObjectPath(String::EMPTY,
                                       moduleRef.getNameSpace(),
                                       PEGASUS_CLASSNAME_PROVIDER,
                                       Array<CIMKeyBinding>());
   
               //
               // get all provider instances which have same module name as
               // moduleName
               //
               Array<CIMObjectPath> instanceNames =
                   _providerRegistrationManager->enumerateInstanceNamesForClass(
                       providerRef);
               CIMInstance pInstance;
               String _moduleName;
               String _providerName;
               Array<CIMInstance> capInstances;
   
               for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
               {
   
                   Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
                   for(Uint32 j=0; j < keys.size(); j++)
                   {
                       //
                       // get provider module name from reference
                       //
                       if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                       {
                           _moduleName = keys[j].getValue();
                       }
   
                       //
                       // get provider name from reference
                       //
                       if(keys[j].getName().equal (_PROPERTY_PROVIDER_NAME))
                       {
                           _providerName = keys[j].getValue();
                       }
                   }
   
                   if (String::equalNoCase(_moduleName, moduleName))
                   {
                       providerRef.setKeyBindings(keys);
                       pInstance = _providerRegistrationManager->getInstance
                           (providerRef);
                       //
                       // get all the indication capability instances which
                       // belongs to this provider
                       //
                       capInstances = _getIndicationCapInstances(
                                      moduleName, pInstance, providerRef);
   
                       //
                       // if there are indication capability instances
                       //
                       if (capInstances.size() != 0)
                       {
                           _sendEnableMessageToSubscription(updatedModuleInstance,
                                                            pInstance,
                                                            capInstances,
                                                            al);
                       }
                   }
               }
               return (0);
           }
   
   
           // enable failed
           return (-1);
   }
   
   // send enable message to indication service
   void ProviderRegistrationProvider::_sendEnableMessageToSubscription(
       const CIMInstance & mInstance,
       const CIMInstance & pInstance,
       const Array<CIMInstance> & capInstances,
       const AcceptLanguageList & al)
   {
       //
       // get indication server queueId
       //
       MessageQueueService * _service = _getIndicationService();
   
       if (_service != NULL)
       {
           Uint32 _queueId = _service->getQueueId();
   
           CIMNotifyProviderEnableRequestMessage * enable_req =
                   new CIMNotifyProviderEnableRequestMessage (
                       XmlWriter::getNextMessageId (),
                       capInstances,
                       QueueIdStack(_service->getQueueId()));
   
           enable_req->operationContext.set(AcceptLanguageListContainer(al));
       enable_req->operationContext.insert(ProviderIdContainer
                                           (mInstance,pInstance));
   
           // create request envelope
           AsyncLegacyOperationStart * asyncRequest =
               new AsyncLegacyOperationStart (
                   NULL,
                   _queueId,
                   enable_req,
                   _queueId);
   
           AsyncReply * asyncReply =
               _controller->ClientSendWait(_queueId, asyncRequest);
   
           CIMNotifyProviderEnableResponseMessage * response =
               reinterpret_cast<CIMNotifyProviderEnableResponseMessage *>(
                   (dynamic_cast<AsyncLegacyOperationResult *>
                       (asyncReply))->get_result());
   
           if (response->cimException.getCode() != CIM_ERR_SUCCESS)
           {
               CIMException e = response->cimException;
               delete asyncRequest;
               delete asyncReply;
               delete response;
               throw e;
           }
   
           delete asyncRequest;
           delete asyncReply;
           delete response;
       }
   }
   
   // If provider is an indication provider, return true,
   // otherwise, return false
   Boolean ProviderRegistrationProvider::_isIndicationProvider(
       const String & moduleName,
       const CIMInstance & instance)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(_PROPERTY_PROVIDER_NAME);
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       return (_providerRegistrationManager->isIndicationProvider(
               moduleName, providerName));
   }
   
   //
   // get all the capability instances whose provider type is indication
   //
   Array<CIMInstance> ProviderRegistrationProvider::_getIndicationCapInstances(
       const String & moduleName,
       const CIMInstance & instance,
       const CIMObjectPath & providerRef)
   {
       // get provider name
       String providerName;
       Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));
       if (pos != PEG_NOT_FOUND)
       {
           instance.getProperty(pos).getValue().get(providerName);
       }
   
       CIMObjectPath capabilityRef;
   
       capabilityRef = CIMObjectPath(providerRef.getHost(),
                                     providerRef.getNameSpace(),
                                     PEGASUS_CLASSNAME_PROVIDERCAPABILITIES,
                                     providerRef.getKeyBindings());
   
       // get all Capabilities instances
       Array<CIMObjectPath> instanceNames =
           _providerRegistrationManager->enumerateInstanceNamesForClass(
               capabilityRef);
   
       String _moduleName, _providerName;
       CIMInstance capInstance;
       Array<Uint16> providerTypes;
       Array<CIMInstance> indCapInstances = 0;
       for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)
       {
           Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
   
           for(Uint32 j=0; j < keys.size(); j++)
           {
                if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))
                {
                     _moduleName = keys[j].getValue();
                }
   
                if(keys[j].getName().equal (_PROPERTY_PROVIDERNAME))
                {
                     _providerName = keys[j].getValue();
                }
           }
   
          //
          // if capability instance has same module name as moduleName
          // and same provider name as providerName, get provider type
          //
          if(String::equal(_moduleName, moduleName) &&
             String::equal(_providerName, providerName))
          {
               capInstance = _providerRegistrationManager->getInstance
                                   (instanceNames[i]);
   
               Uint32 pos = capInstance.findProperty(
                   CIMName (_PROPERTY_PROVIDERTYPE));
               if (pos != PEG_NOT_FOUND)
               {
                   capInstance.getProperty(pos).getValue().get(providerTypes);
   
                   for (Uint32 k=0; k < providerTypes.size(); k++)
                   {
                       //
                       // if provider type of the instance is indication,
                       // append the instance
                       //
                       if (providerTypes[k] == _INDICATION_PROVIDER)
                       {
                           indCapInstances.append(capInstance);
                       }
                   }
               }
           }
       }
   
       return (indCapInstances);
   }
   
   #ifdef PEGASUS_ENABLE_INTEROP_PROVIDER
   void ProviderRegistrationProvider::_sendUpdateCacheMessagetoInteropProvider(
       const OperationContext & context)
   {
       String referenceStr("//", 2);
       referenceStr.append(System::getHostName());
       referenceStr.append("/");
       referenceStr.append(PEGASUS_NAMESPACENAME_INTEROP.getString());
       referenceStr.append(":");
       referenceStr.append(
           PEGASUS_CLASSNAME_PG_PROVIDERPROFILECAPABILITIES.getString());
       CIMObjectPath reference(referenceStr);
   
       Array<CIMParamValue> inParams;
       Array<CIMParamValue> outParams;
   
       try
       {
           AutoMutex mtx(_updateMtx);
           _cimomHandle.invokeMethod(
               context,
               PEGASUS_NAMESPACENAME_INTEROP,
               reference,
               CIMNameUnchecked("updateCache"),
               inParams,
               outParams);
       }
       catch(const Exception &e)
       {
           PEG_TRACE_STRING(
               TRC_CONTROLPROVIDER,
               Tracer::LEVEL1,
               "Exception caught while invoking InteropProvider 'updateCache'"
                   " method: " + e.getMessage());
       }
       catch(...)
       {
           PEG_TRACE_CSTRING(
               TRC_CONTROLPROVIDER,
               Tracer::LEVEL1,
               "Unknown error occurred while"
                   " invoking InteropProvider 'updateCache' method.");
       }
   }
   #endif
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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