The fix - allocate response handler from heap and store for the life of the indication enablement

The important lines for enabling a new subscription are 32 and 58.

The important line for disabling an existing subscription is 136.

 void ProviderManagerService::handleEnableIndicationsRequest(
    AsyncOpNode *op, const Message * message) throw()
 {
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, 
 		    "ProviderManagerService:: handleEnableIndicationsRequest");
    CIMEnableIndicationsRequestMessage * request =
       dynamic_cast<CIMEnableIndicationsRequestMessage *>(
 	 const_cast<Message *>(message));
 
    AsyncRequest *async = 
       static_cast<AsyncRequest *>(op->_request.next(0));
 
    PEGASUS_ASSERT(request != 0 && async != 0 );
 
    CIMEnableIndicationsResponseMessage * response =
       new CIMEnableIndicationsResponseMessage(
 	 request->messageId,
 	 CIMException(),
 	 request->queueIds.copyAndPop());
 
    PEGASUS_ASSERT(response != 0);
 
    // preserve message key
    response->setKey(request->getKey());
 
    response->dest = request->queueIds.top();
 
    // Allocate the response handler from the heap using new (). 
    // Otherwise it will go out of scope and the indication, which 
    // happens later, will go off into outer space...
 
    EnableIndicationsResponseHandler *handler = 
       new EnableIndicationsResponseHandler(request, response, this);
 
    try
    {
       // get the provider file name and logical name
       Triad<String, String, String> triad =
 	 _getProviderRegPair(request->provider, request->providerModule);
 
       // get cached or load new provider module
       Provider provider =
 	 providerManager.getProvider(triad.first, triad.second, triad.third);
 
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Calling provider.enableIndications: " + 
 		       provider.getName());
        
       provider.enableIndications(*handler);
 
       // if no exception, store the handler so it is persistent for as 
       // long as the provider has indications enabled. 
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Storing indication handler for " + provider.getName());
        
 
       // keep indication handlers in a hash table keyed by the provider. 
       _insertEntry(provider, handler);
    }
    catch(CIMException & e)
    {
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Exception: " + e.getMessage());
       response->cimException = CIMException(e);
    }
    catch(Exception & e)
    {
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Exception: " + e.getMessage());
       response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");
    }
    catch(...)
    {
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Exception: Unknown");
       response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");
    }
        
    AsyncLegacyOperationResult *async_result =
       new AsyncLegacyOperationResult(
 	 async->getKey(),
 	 async->getRouting(),
 	 op,
 	 response);
 
    _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
    PEG_METHOD_EXIT();
 }
 
 void ProviderManagerService::handleDisableIndicationsRequest(
    AsyncOpNode *op, const Message * message) throw()
 {
    PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, 
 		    "ProviderManagerService::handleDisableIndicationsRequest");
    CIMDisableIndicationsRequestMessage * request =
       dynamic_cast<CIMDisableIndicationsRequestMessage *>(
 	 const_cast<Message *>(message));
 
    AsyncRequest *async = static_cast<AsyncRequest *>(op->_request.next(0));
 
    PEGASUS_ASSERT(request != 0 && async != 0 );
 
    CIMDisableIndicationsResponseMessage * response =
       new CIMDisableIndicationsResponseMessage(
 	 request->messageId,
 	 CIMException(),
 	 request->queueIds.copyAndPop());
 
    PEGASUS_ASSERT(response != 0);
 
    // preserve message key
    response->setKey(request->getKey());
 
    OperationResponseHandler<CIMIndication> handler(request, response);
    try
    {
       // get the provider file name and logical name
       Triad<String, String, String> triad =
 	 _getProviderRegPair(request->provider, request->providerModule);
 
       // get cached or load new provider module
       Provider provider =
 	 providerManager.getProvider(triad.first, triad.second, triad.third);
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Calling provider.disableIndications: " + 
 		       provider.getName());
 	
       provider.disableIndications();
 
       // Now that indications are disabled we can extract and remove the 
       // indication response handler 
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Removing and Destroying indication handler for " + 
 		       provider.getName());
 	
       delete _removeEntry(_generateKey(provider));
    }
 
    catch(CIMException & e)
    {
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Exception: " + e.getMessage());
       response->cimException = CIMException(e);
    }
    catch(Exception & e)
    {
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Exception: " + e.getMessage());
       response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error");
    }
    catch(...)
    {
       PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 
 		       "Exception: Unknown");
       response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error");
    }
 
    AsyncLegacyOperationResult *async_result =
       new AsyncLegacyOperationResult(
 	 async->getKey(),
 	 async->getRouting(),
 	 op,
 	 response);
 
    _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
    PEG_METHOD_EXIT();
 }

The fix - copy the messages passed to the response handler.

The lines that implement the fix are 14 and 15 and 102 and 103.

This is a fix that, in my opinion, should be generally applied to all response handlers.

 ////////////////////-*-c++-*-///////////////////////////////////////////
 class EnableIndicationsResponseHandler : 
    public OperationResponseHandler<CIMIndication>
 {
    public:
       EnableIndicationsResponseHandler(
 	 CIMEnableIndicationsRequestMessage * request,
 	 CIMEnableIndicationsResponseMessage * response,
 	 MessageQueueService * source,
 	 MessageQueueService * target = 0)
 	 : OperationResponseHandler<CIMIndication>(request, response),
 	   _source(source),
 	   _target(target),
 	   _request_copy(*request),
 	   _response_copy(*response)
       {
         PEGASUS_ASSERT(_source != 0);
 
         // get indication service
         if(_target == 0)
         {
             Array<Uint32> serviceIds;
 
             _source->find_services(
 	       PEGASUS_QUEUENAME_ESERVER_INDICATIONSERVICE, 
 	       0, 0, &serviceIds);
 
             PEGASUS_ASSERT(serviceIds.size() != 0);
 
             _target = dynamic_cast<MessageQueueService *>(
 	       MessageQueue::lookup(serviceIds[0]));
 
             PEGASUS_ASSERT(_target != 0);
         }
     }
 
     virtual void deliver(const CIMIndication & cimIndication)
     {
         OperationContext context;
 
         deliver(context, cimIndication);
     }
 
     virtual void deliver(const OperationContext & context, 
 			 const CIMIndication & cimIndication)
     {
         // ATTN: temporarily convert indication to instance
         CIMInstance cimInstance(cimIndication);
 
         // create message
         CIMProcessIndicationRequestMessage * request =
             new CIMProcessIndicationRequestMessage(
 	       _request_copy.messageId,
             cimInstance.getPath().getNameSpace(),
             cimInstance,
             QueueIdStack(_target->getQueueId(), _source->getQueueId()));
 
         // send message
         // <<< Wed Apr 10 21:04:00 2002 mdd >>>
         // AsyncOpNode * op = _source->get_op();
 
         AsyncLegacyOperationStart * asyncRequest =
             new AsyncLegacyOperationStart(
             _source->get_next_xid(),
             0,
             _target->getQueueId(),
             request,
             _target->getQueueId());
 
         PEGASUS_ASSERT(asyncRequest != 0);
 
         //AsyncReply * asyncReply = _source->SendWait(asyncRequest);
         // <<< Wed Apr 10 21:04:50 2002 mdd >>>
         _source->SendForget(asyncRequest);
         //PEGASUS_ASSERT(asyncReply != 0);
 
         //  Chip - receiver of the request should delete it
         //delete asyncRequest;
         // <<< Wed Apr 10 21:05:10 2002 mdd >>>
     }
 
     virtual void deliver(const Array<CIMIndication> & cimIndications)
     {
         OperationContext context;
 
         deliver(context, cimIndications);
     }
 
     virtual void deliver(const OperationContext & context, 
 			 const Array<CIMIndication> & cimIndications)
     {
         for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)
         {
             deliver(context, cimIndications[i]);
         }
     }
 
    protected:
       MessageQueueService * _source;
       MessageQueueService * _target;
    private:
       CIMEnableIndicationsRequestMessage _request_copy;
       CIMEnableIndicationsResponseMessage _response_copy;
 };

Partial Fix: helper routines

 
 //%/////////////////////////////////////////////////////////////////
 // Take an association class and a name of one or the references. 
 // Return a CIMObjectPath that contains the instance of the referred 
 // to object. 
 ///////////////////////////////////////////////////////////////////
 Boolean eServerIndicationService::_get_object_path_from_association(
    const String & reference_name,
    const CIMInstance & association, 
    CIMObjectPath & path) const 
 {
    
    path.clear();
    try
    {
       CIMValue path_value = association.getProperty(
 	 association.findProperty(reference_name)).getValue();
       path_value.get(path);
    }
    catch(...)
    {
       return false;
    }
    
    return true;
 }
 
 //%/////////////////////////////////////////////////////////////////
 // Get all the name spaces in the repository. 
 // This should really be a static method that any class should be 
 // able to call
 ///////////////////////////////////////////////////////////////////
 void eServerIndicationService::_getNameSpaceNames (
    Array<String> & nameSpaceNames) const
 {
    
    PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
 		     "eServerIndicationService::__getNameSpaceNames");
    nameSpaceNames.clear();
    
    _repository->read_lock ();
    
    try
    {
       nameSpaceNames = _repository->enumerateNameSpaces ();
    }
    catch (Exception &)
    {
       _repository->read_unlock ();
       PEG_METHOD_EXIT ();
    }
    
    _repository->read_unlock ();
    
    PEG_METHOD_EXIT ();
 }
 
 //%/////////////////////////////////////////////////////////////////
 // Get all subscriptions that refer to a specific indication class
 // returns subscriptions in all name spaces. Calls lower-level
 // _getMatchingSubscriptions. 
 ///////////////////////////////////////////////////////////////////
 void eServerIndicationService::_getMatchingSubscriptions(
    const CIMInstance & indication,
    Array<CIMInstance> & subscriptions) const 
 {
    Array<String> nameSpaceNames;
    _getNameSpaceNames(nameSpaceNames);
    
    for(Uint8 i = 0; i < nameSpaceNames.size() ; ++i)
    {
       _getMatchingSubscriptions( nameSpaceNames[i],
 				 indication, 
 				 subscriptions);
    }
 }
 
 
 //%/////////////////////////////////////////////////////////////////
 // Get all subscriptions that refer to a specific indication class
 // for a specific name space. 
 ///////////////////////////////////////////////////////////////////
 void eServerIndicationService::_getMatchingSubscriptions(
    const String & nameSpaceName, 
    const CIMInstance & indication,
    Array<CIMInstance> & subscriptions) const
 {
    Array<CIMInstance> all_subscriptions;
    _getSubscriptions(nameSpaceName, all_subscriptions);
    
    String indication_class_name = indication.getClassName();
    CIMObjectPath compare_path;
    
 
    for(Uint8 x = 0; 
        x < all_subscriptions.size() ; 
        ++x, compare_path.clear())
    {
       _get_object_path_from_association("Indication_Class", 
 					all_subscriptions[x],
 					compare_path);
       if(compare_path.getClassName() == indication_class_name)
       {
 	 CIMObjectPath temp = all_subscriptions[x].getPath();
 	 temp.setNameSpace(nameSpaceName);
 	 all_subscriptions[x].setPath(temp);
 	 subscriptions.append(all_subscriptions[x]);
       }
     }
    return;
 }
 
 //%/////////////////////////////////////////////////////////////////
 // Get all subscriptions in the repository for a specific name space
 ///////////////////////////////////////////////////////////////////
 void eServerIndicationService::_getSubscriptions (
    const String & nameSpaceName, 
    Array <CIMInstance> & subscriptions) const
 {
    
 
    PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
 		     "eServerIndicationService::_getSubscriptions");
    
    //
    //  Get existing subscriptions in current namespace
    //
    _repository->read_lock ();
 
    try
    {
       subscriptions  = _repository->enumerateInstances
 	 (nameSpaceName, ESERVER_CLASSNAME_INDSUBSCRIPTION);
    }
    catch (CIMException e)
    {
       //
       //  Some namespaces may not include the subscription class
       //  In that case, just return no subscriptions
       //  Any other exception is an error
       //
       if (e.getCode () != CIM_ERR_INVALID_CLASS)
       {
 	 _repository->read_unlock ();
 	 PEG_METHOD_EXIT ();
       }
    }
 
    _repository->read_unlock ();
 
    PEG_METHOD_EXIT ();
 }

Fix - only store pointers to dynamically allocated objects in hashtables - when those objects have a virtual base.

 // -*-c++-*-
 #ifndef PEGASUS_ARRAY_T
 template<class PEGASUS_ARRAY_T>
 #endif
 void Array<PEGASUS_ARRAY_T>::insert(Uint32 pos, 
 				    const PEGASUS_ARRAY_T* x, 
 				    Uint32 size)
 {
     if (pos > this->size())
         ThrowOutOfBounds();
 
     reserve(this->size() + size);
 
     Uint32 n = this->size() - pos;
 
     if (n)
         memmove(
             _data() + pos + size, 
 	    _data() + pos, 
 	    sizeof(PEGASUS_ARRAY_T) * n);
 
     CopyToRaw(_data() + pos, x, size);
     static_cast<ArrayRep<PEGASUS_ARRAY_T>*>(_rep)->size += size;
 }
 
 #ifndef PEGASUS_ARRAY_T
 template<class PEGASUS_ARRAY_T>
 #endif
 void Array<PEGASUS_ARRAY_T>::remove(Uint32 pos)
 {
     remove(pos, 1);
 }
 
 #ifndef PEGASUS_ARRAY_T
 template<class PEGASUS_ARRAY_T>
 #endif
 void Array<PEGASUS_ARRAY_T>::remove(Uint32 pos, Uint32 size)
 {
     if (pos + size - 1 > this->size())
         ThrowOutOfBounds();
 
     Destroy(_data() + pos, size);
 
     Uint32 rem = this->size() - (pos + size);
 
     if (rem)
         memmove(
             _data() + pos, 
 	    _data() + pos + size, 
 	    sizeof(PEGASUS_ARRAY_T) * rem);
 
     static_cast<ArrayRep<PEGASUS_ARRAY_T>*>(_rep)->size -= size;
 }

 
 ProviderModule *module;
 if( false  == _modules.lookup(*(parms->fileName), module) )
 {
    PEG_TRACE_STRING(TRC_PROVIDERMANAGER, 
 		    Tracer::LEVEL4,
 		    "Creating Provider Module " + 
 		    *(parms->fileName) );
 	    
    module = new ProviderModule(*(parms->fileName));
    _modules.insert((*parms->fileName), module);
 }
 else 
 {
    PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
 		    "Using Cached  Provider Module " + 
 		    *(parms->fileName) );
 }
 	 
 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
 		 "Loading/Linking Provider Module " + 
 		 *(parms->fileName) );
 CIMBaseProvider *base = module->load(*(parms->providerName));
 	    
 // create provider module
    
 MessageQueue * queue = MessageQueue::lookup(
    PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);
 PEGASUS_ASSERT(queue != 0);
 MessageQueueService * service = 
    dynamic_cast<MessageQueueService *>(queue);
 PEGASUS_ASSERT(service != 0);
 pr = new Provider(*(parms->providerName), module, base);
 if(0 == (pr->_cimom_handle =  new CIMOMHandle(service)))
    throw NullPointer();
 
 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, 
 		 "Loading Provider " +  pr->_name);
 	 
 PEGASUS_STD(cout) << "Loading Provider " << 
    pr->_name << PEGASUS_STD(endl);
 	 
 pr->initialize(*(pr->_cimom_handle));
 gettimeofday(&(pr->_timeout), NULL);
 _providers.insert(*(parms->providerName), pr);

 //%/////////////////////////////////////////////////////////////////////////////
 //
 // 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
 // of this software and associated documentation files (the "Software"), to
 // deal in the Software without restriction, including without limitation the
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // sell copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 //==============================================================================
 //
 // Author: Chip Vincent (cvincent@us.ibm.com)
 //
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 //
 //%/////////////////////////////////////////////////////////////////////////////
 
 #ifndef Pegasus_CIMIndicationConsumer_h
 #define Pegasus_CIMIndicationConsumer_h
 
 #include <Pegasus/Common/Config.h>
 #include <Pegasus/Provider/CIMBaseProvider.h>
 
 #include <Pegasus/Common/CIMInstance.h>
 
 PEGASUS_NAMESPACE_BEGIN
 
 /**
 This class defines the set of methods implemented by an indication consumer provider.
 A providers that derives from this class must implement all methods. The minimal method
 implementation simply throw the NotSupported exception.
 */
 class PEGASUS_PROVIDER_LINKAGE CIMIndicationConsumer : public virtual CIMBaseProvider
 {
 public:
     CIMIndicationConsumer(void);
     virtual ~CIMIndicationConsumer(void);
 
     /**
     @param contex contains security and locale information relevant for the lifetime
     of this operation.
 
     @param indication
 
     @param handler asynchronusly processes the results of this operation.
 
     @exception NotSupported
     @exception InvalidParameter
     */
     virtual void handleIndication(
 	const OperationContext & context,
 	const CIMInstance & indication,
 	ResponseHandler<void> & handler) = 0;
 
     // ATTN: The following method is only for testing purposes.
     virtual void handleIndication(
 	const OperationContext & context,
 	const String & url,
 	const CIMInstance& indicationInstance)
     {
     }
 };
 
 PEGASUS_NAMESPACE_END
 
 #endif

 //=================================================================
 // eServer_ProviderModule
 //
 // This schema is derived from PG_ProviderModule. It adds some 
 // qualifiers to support remote and out-of-proc providers.
 // It also defines some new provider types. 
 //
 //=================================================================
 
 // Named (meta) elements:
 // Class, Property, Method, Association, Reference, Property, Parameter, 
 // Indication, Schema, Trigger
 
 #pragma local ("en_US")
 
 Qualifier Remote : boolean = false , Scope(class, reference, property, method) ;
 Qualifier Out_of_Proc : boolean = false, Scope(class, reference, property, method);
 Qualifier Trusted : boolean = false, Scope(class, reference, property, method);
 Qualifier isURL : boolean = false, Scope(reference, property);
 
 //=================================================================
 // eServer_ProviderModule
 //=================================================================
 
 [Version("2.0.0."), Description("Derived from PG_ProviderModule "
 	"modified to support additional provider types and additional "
 	"provider qualifications. ")]
 class eServer_ProviderModule : PG_ProviderModule {
 	[Key, Override("Name"), Description("A human-readable name that uniquely "
 		"identifies the Provider Module, inherited from PG_ProviderModule.")]	
 	string Name;
 
 	[ Override("Location"), Description("The file path to the module. " 
 		" If the usURL qualifier is present, indicates that the "
 		"path is a URL. Otherwise the path is a string that represents "
 		" the location of the module in the local host's file system.") ]
 	string Location;
 
 	[ Override("InterfaceType"), Description ("The interface definition "
 	  	"supported by this module. Implies both a method signature and "
 		" a binary specification for linking to the module and executing its code. "
 		"In Pegasus 2.01 the InterfaceType also implies a specific "
 		"ProviderManagerService, although this link will be broken in the "
 		"future. "),
 		Values {"C++Default", "CMPI", "Java_Default", "Java_SNIA", 
 			"Java_Wbem_Services", "Perl", "Unix_Domain", 
 			"Named_Pipe", "WSDL_SOAP"}]
 	string InterfaceType;
 	
 	[ Description ("The host of the computer upon which this module resides. "
 	    	"For local providers this will be \"localhost\". For remote "
 		"providers this property should contain the DNS name of the "
 		"remote host. ") ]
 	string host;
 
 	[ Description ("The PGP Signature of the module's file. "
 		"The provider manager or any other module can use this "
 		" signature to determine the authenticity if the module " 
 		" and the integrity of the module's image. ")]
 	string pgp_Signature;
 
 };
 
 
 //=================================================================
 // eServer_Provider
 // 
 // Derived from the PG_Provider class. The operational status 
 // properties from PG_ProviderModule are present in the eServer_Provider
 // class. This is to recognize that providers may have operational 
 // states that are distinct from the states of their modules.
 //
 //=================================================================
 
 [ Version("2.0.0"), Description("eServer_Provider is derived from "
 	"PG_Provider. ") ]
 
 class eServer_Provider : PG_Provider {
 	[Key, Description("The scoping eServer_ProviderModule name. "
  		"Inherited as a propagated key from PG_Provider, having "
 		"the syntax PG_ProviderModule.name")]
 	string ProviderModuleName;
 	[Key, Override("Name"), Description("A human-readable name that:
 		"uniquely identifies the provider within the Provider Module." 
 		"Inherited from PG_Provider.")]
 	string Name;
       [Description ( 
         "   Indicates the current status(es) of the element. "
         "Various health and operational statuses are "
         "defined. Many of the enumeration's values are self-"
         "explanatory.  However, a few are not and are described "
         "in more detail. \"Stressed\" indicates that the element "
         "is functioning, but needs attention. Examples of "
         "\"Stressed\" states are overload, overheated, etc. "
         "\"Predictive Failure\" indicates that an element is "
         "functioning nominally but predicting a failure in the "
         "near future. \"In Service\" describes an element being "
         "configured, maintained, cleaned, or otherwise administered. "
         "\"No Contact\" indicates that the monitoring system "
         "has knowledge of this element, but has never been able to "
         "establish communications with it. \"Lost Communication\" "
         "indicates that the ManagedSystemElement is known to exist "
         "and has been contacted successfully in the past, but is "
         "currently unreachable. \"Stopped\" indicates that the "	
         "element is known to exist, is not operational (e.g., it "
         "is unable to provide service to users), but it has not "
         "failed. It has purposely been made non-operational. \n"
         "  OperationalStatus replaces the Status property on "
         "ManagedSystemElement to provide a consistent approach to "
         "enumerations, to address implementation needs for an "
         "array property, and to provide a migration path from today's "
         "environment to the future. This change was not made earlier "
         "since it required the DEPRECATED qualifier. Due to the "
         "widespread use of the existing Status property in "
         "management applications, it is strongly recommended that "
         "providers/instrumentation provide BOTH the Status and "
         "OperationalStatus properties. As always, Status (since it "
         "is single-valued) provides the primary status of the "
         "element."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", 
              "9", "10", "11", "12", "13"}, 
        Values {"Unknown", "Other", "OK", "Degraded", "Stressed",
              "Predictive Failure", "Error", "Non-Recoverable Error", 
              "Starting", "Stopping", "Stopped", "In Service", 
              "No Contact", "Lost Communication"}, 
        ModelCorrespondence {
         "CIM_ManagedSystemElement.OtherStatusDescription"} ] 
     uint16 OperationalStatus[];
       [Description (
         "A string describing the status - used when the "
         "OperationalStatus property is set to 1 (\"Other\")."), 
        ModelCorrespondence {
         "CIM_ManagedSystemElement.OperationalStatus"} ]
     string OtherStatusDescription;
 };
 
 
 //=================================================================
 // eServer_ProviderCapabilities
 // 
 // Derived from the PG_ProviderCapabilities class
 //
 //=================================================================
 
 	[Version ("2.0.0"), Description("An instance of ProviderCapabilities "
 	"describes a set of abilities for a specific provider.") ]
 class eServer_ProviderCapabilities : PG_ProviderCapabilities {
 	[Key, Description("The scoping eServer_ProviderModuleName. "
 	"Inherited as a Propagated key from PG_ProviderCapabilities, "
 	"having the syntax PG_Provider.ProviderModuleName") ]
    string ProviderModuleName;
 	[Key, Description("The scoping eServer_Provider Name."
 	"Inherited as a Propagated key from PG_ProviderCapabilities, "
 	"having the syntax PG_Provider.Name") ]
    string ProviderName;
 
 	[Key, Description("A value that uniquely identifies this "
 		" set of abilities for the designated Providers.") ]
    string CapabilityID;
 
 	[Override("ProviderType"), Description("ProviderType enumerates " 
 		" the specific method types that the provider supports. "),
 		ArrayType("Indexed"), 
 		ValueMap { "2", "3", "4", "5", "6" },
 		Values{ "Instance", "Association", "Indication", "Method", 
 			"Indication_Consumer" } ]
      uint16 ProviderType[];
 };
 	

Here is one of the new routines I wrote for the ProviderRegistrationManager. There are several others.

 Boolean ProviderRegistrationManager::lookupConsumerProvider(
     const String & nameSpace, 
     const String & className,
     CIMInstance & provider,
     CIMInstance & providerModule)
 {
     String providerName;
     String providerModuleName;
 
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
 		     "ProviderRegistrationManager::lookupConsumerProvider");
     
     ProviderRegistrationTable* providerCapability = 0;
     ProviderRegistrationTable* _provider= 0;
     ProviderRegistrationTable* _providerModule = 0;
     
     //
     // create the key by using nameSpace, className, and providerType
     //
     String capabilityKey = _generateKey(nameSpace, className, CONSUMER_PROVIDER);
     PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
 		     "\nnameSpace = " + nameSpace + "; className = " +
 			className +  "; capabilityKey = " + capabilityKey);
 
     try
     {
         // 
         // get provider capability instance from the table
         //
         if (!_registrationTable->table.lookup(
                   capabilityKey, providerCapability))
         {
             PEG_METHOD_EXIT();
             throw CIMException(CIM_ERR_FAILED, CAPABILITY_NOT_REGISTERED);
         }
 
         Array<CIMInstance> instances = providerCapability->getInstances();
 
         Uint32 pos = instances[0].findProperty(_PROPERTY_PROVIDERNAME);
 
         if (pos == PEG_NOT_FOUND)
         {
             PEG_METHOD_EXIT();
     	    throw CIMException(CIM_ERR_FAILED, 
 		"Missing ProviderName which is key in PG_ProviderCapabilities class.");
         }
 
         //
         // get provider name
         //
         instances[0].getProperty(pos).getValue().get(providerName);
 
         //
         // get provider module name
         //
         Uint32 pos2 = instances[0].findProperty(_PROPERTY_PROVIDERMODULENAME);
         if (pos2 == PEG_NOT_FOUND)
         {
 	   
             PEG_METHOD_EXIT();
     	    throw CIMException(CIM_ERR_FAILED, 
 		"Missing ProviderModuleName which is key in PG_ProviderCapabilities class.");
         }
 
         instances[0].getProperty(pos2).getValue().get(providerModuleName);
 
 	//
 	// create the key by using providerModuleName and providerName
 	//
 	String _providerKey = _generateKey(providerModuleName, providerName);
 
 	//
 	// create the key by using providerModuleName and MODULE_KEY
 	//
 	String _moduleKey = _generateKey(providerModuleName, MODULE_KEY);
 
         // 
         // get provider instance from the table 
         //
         if (!_registrationTable->table.lookup(_providerKey, _provider))
         {
             PEG_METHOD_EXIT();
 	    throw CIMException(CIM_ERR_FAILED, PROVIDER_NOT_FOUND);
         }
 
         Array<CIMInstance> providerInstances = _provider->getInstances();
         provider = providerInstances[0];
 
         // 
         // get provider module instance from the table 
         //
         if (!_registrationTable->table.lookup(_moduleKey, _providerModule))
         {
             PEG_METHOD_EXIT();
 	    throw CIMException(CIM_ERR_FAILED, MODULE_NOT_FOUND);
         }
 
         Array<CIMInstance> providerModuleInstances = _providerModule->getInstances();
         providerModule = providerModuleInstances[0];
     
     }
     catch(CIMException & exception)
     {
 	Tracer::traceCIMException(TRC_PROVIDERMANAGER, Tracer::LEVEL4, exception);
 	PEG_METHOD_EXIT();
 	return (false);
     }
 
     PEG_METHOD_EXIT();
     return (true);
 }

 instance of eServer_ProviderModule
 {
 	Name = "ProcessIndicationProvider";
 	Location = "ProcessIndicationProvider";
 	Vendor = "Pegasus Community";
 	Version = "2.0.0";
 	InterfaceType = "C++Default";
 	InterfaceVersion = "2.0.0";
 	host = "localhost";
 	OperationalStatus = {2};
 };
 	
 instance of eServer_Provider
 {
 	ProviderModuleName = "ProcessIndicationProvider";
 	Name = "eServer_ProcessIndicationProvider";
 	OperationalStatus = {2};
 };
 
 instance of eServer_ProviderCapabilities
 {
 	ProviderModuleName = "ProcessIndicationProvider";
 	ProviderName = "eServer_ProcessIndicationProvider";
 	CapabilityID = "1";
 	ClassName = "CIM_ProcessIndication";
 	Namespaces = {"root/PG_Interop"};
 	ProviderType = { 4 }; // indication
 	SupportedProperties = NULL;
 	SupportedMethods = NULL;
 };
 
 
 instance of eServer_Provider
 {
 	ProviderModuleName = "ProcessIndicationProvider";
 	Name = "eServer_ProcessIndicationConsumer";
 	OperationalStatus = {2};
 };
 
 instance of eServer_ProviderCapabilities
 {
 	ProviderModuleName = "ProcessIndicationProvider";
 	ProviderName = "eServer_ProcessIndicationConsumer";
 	CapabilityID = "2";
 	ClassName = "eServer_ProcessIndicationConsumer";
 	Namespaces = {"root/PG_Interop"};
 	ProviderType = { 6 }; // consumer
 	SupportedProperties = NULL;
 	SupportedMethods = NULL;
 };
 
 
 instance of eServer_IndicationSubscription
 {
 	Indication_Class  = "CIM_ProcessIndication";
 	Handler = "eServer_ProcessIndicationConsumer";
 };

 
 
 void ProcessIndicationProvider::enableIndications (
     ResponseHandler <CIMIndication> & handler)
 {
    cout << "eServer_ProcessIndicationProvider: enableIndications" << endl;
 
    _enable_disable.lock(pegasus_thread_self());
    if(_indications_enabled.value())
    {
       _enable_disable.unlock();
       return;
    }
    _response_handler = &handler;
    _response_handler->processing ();   
    _indications_enabled = 1;
    _indication_thread.run();
    _enable_disable.unlock();
    
 }
 
 void ProcessIndicationProvider::disableIndications (void)
 {
    cout << "eServer_ProcessIndicationProvider: disableIndications" << endl;
    _enable_disable.lock(pegasus_thread_self());
    
    if(_indications_enabled.value() == 0 )
    {
       _enable_disable.unlock();
       return;
    }
 
    _indications_enabled = 0;
    _response_handler = 0;
    _indication_thread.join();
    _enable_disable.unlock();
 
 }
       

 
 PEGASUS_THREAD_RETURN 
 PEGASUS_THREAD_CDECL 
 ProcessIndicationProvider::_monitor(void *parm)
 {
    PEGASUS_ASSERT(parm != 0);
    
    Thread *th = static_cast<Thread *>(parm);
    ProcessIndicationProvider *myself = 
       static_cast<ProcessIndicationProvider *>(th->get_parm());
 
    while(true)
    {
       pegasus_sleep(1000);
       try
       {
 	 myself->_enable_disable.try_lock(pegasus_thread_self());
       }
       catch(...)
       {
 	 if(myself->_indications_enabled.value() == 0  || 
              myself->_response_handler == 0 )
 	    exit_thread((PEGASUS_THREAD_RETURN)0);
 	 else
 	    continue;
       }
       try
       {
 	 
 	 CIMInstance indicationInstance ("root/PG_Interop:CIM_ProcessIndication");
 	 
 	 indicationInstance.addProperty
 	    (CIMProperty ("IndicationTime", CIMValue (CIMDateTime ())));
 	 
 	 indicationInstance.addProperty
 	    (CIMProperty ("IndicationIdentifier", "ProcessIndication01"));
 	 
 	 Array <String> correlatedIndications;
 	 indicationInstance.addProperty (
                  CIMProperty ("CorrelatedIndications", 
 		 CIMValue (correlatedIndications)));
 	 
 	 CIMIndication cimIndication (indicationInstance);
 	 
 	 myself->_response_handler->deliver (cimIndication);
 	 
       }
       catch(...)
       {
 	
       }
       myself->_enable_disable.unlock();
    }
    exit_thread((PEGASUS_THREAD_RETURN)0);
    return(PEGASUS_THREAD_RETURN)0;
 }

 
 
 extern "C" PEGASUS_EXPORT CIMBaseProvider * PegasusCreateProvider
     (const String & providerName)
 {
    
     if ((String::equalNoCase (providerName, "ProcessIndicationProvider")) ||
         (String::equalNoCase (providerName, "ProcessIndicationProvider2")) || 
 	(String::equalNoCase (providerName, "eServer_ProcessIndicationProvider")))
     {
 	return (new ProcessIndicationProvider ());
     }
     if(String::equalNoCase(providerName, "eServer_ProcessIndicationConsumer"))
     {
        return new ProcessIndicationConsumer();
     }
 
     return (0);
 }

 
 
 void ProcessIndicationConsumer::handleIndication(
       const OperationContext & context, 
       const CIMInstance & indication,
       ResponseHandler<void> & handler)
 {
    
    CIMInstance indication_copy = indication.clone();
    PEGASUS_STD(cout) << 
       "Indication Consumer: recieved indication of class: " << 
       indication_copy.getClassName() << PEGASUS_STD(endl);
     
 }

 
 virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)
 {
      // ATTN: temporarily convert indication to instance
      CIMInstance cimInstance(cimIndication);
 
      // create message
      CIMProcessIndicationRequestMessage * request =
          new CIMProcessIndicationRequestMessage(
            _request_copy.messageId,
            cimInstance.getPath().getNameSpace(),
            cimInstance,
            QueueIdStack(_target->getQueueId(), _source->getQueueId()));
 
      AsyncLegacyOperationStart * asyncRequest =
          new AsyncLegacyOperationStart(
          _source->get_next_xid(),
          0,
          _target->getQueueId(),
          request,
          _target->getQueueId());
 
     PEGASUS_ASSERT(asyncRequest != 0);
 
      _source->SendForget(asyncRequest);
 }

 
 void eServerIndicationService::_handleProcessIndicationRequest(
       const Message *message)
 {
    PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,
 		     "eServerIndicationService::_handleProcessIndicationRequest");
 
    CIMProcessIndicationRequestMessage* request =
       (CIMProcessIndicationRequestMessage*) message;
    
    CIMException cimException;
 
    CIMProcessIndicationResponseMessage* response =
       new CIMProcessIndicationResponseMessage(
 	 request->messageId,
 	 cimException,
 	 request->queueIds.copyAndPop());
    try 
    {
       /* get each name space */
       Array<String> nameSpaceNames;
       _getNameSpaceNames(nameSpaceNames);
 
       Array<CIMInstance> subscriptions;
       CIMInstance indication = request->indicationInstance.clone();
 
       _getMatchingSubscriptions(indication, subscriptions);
 
       // keep this super simple
       // always deliver all properties of the indication class to the consumer
       // every subscription has one indication class and one consumer
       // the consumer is responsible for filtering and multiplexing
 
       Array<CIMObjectPath> absent_consumers;
 
       _deliverIndication(subscriptions, 
 			 indication,
 			 absent_consumers);
    
    }
    catch(CIMException & e)
    {
       response->cimException = e;
    }
    catch(Exception & e)
    {
       response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
 						     e.getMessage());
    }
    catch(...)
    {
    response->cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 
 						  "Internal Error");
    }
    _enqueueResponse(request, response);
 
    PEG_METHOD_EXIT();
 }

 
 // will return true if ONE subscription is successful. 
 // e.g., if one out of three subscriptions results in a 
 // successful delivery, will return true. if zero are 
 // successful, returns false. 
 // consumers that are absent; i.e., not found by the provider registration 
 // manager are returned in the absent_consumer
 Boolean  eServerIndicationService::_deliverIndication(
    const Array<CIMInstance> & subscriptions, 
    const CIMInstance & indication,
    Array<CIMObjectPath> & absent_consumers)
 {
    
    PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, 
       "eServerIndicationService::_deliverIndication");
    CIMObjectPath consumer;
    CIMInstance provider, providerModule;   
    Boolean ccode = false;
    try 
    {
       for(Uint8 i = 0 ; i < subscriptions.size(); ++i, consumer.clear())
       {
 	 if(true == _get_object_path_from_association("Handler", 
 						      subscriptions[i],
 						      consumer))
 	 {
 
 	    // get the name space 
 	    if(true == _providerRegManager->lookupConsumerProvider(
 		  subscriptions[i].getPath().getNameSpace(),
 		  consumer.getClassName(),
 		  provider, 
 		  providerModule))
 	    {
 	       
 	       CIMConsumeIndicationRequestMessage *request = 
 		  new CIMConsumeIndicationRequestMessage(
 		     XmlWriter::getNextMessageId (),
 		     indication.getPath().getNameSpace(), 
 		     indication, 
 		     provider, 
 		     providerModule, 
 		     QueueIdStack(_providerManager, _queueId));
 	    
 	       AsyncOpNode *op = get_op();
 	    
 	       AsyncLegacyOperationStart *async_req  = 
 		  new AsyncLegacyOperationStart(
 		     get_next_xid(), 
 		     op, 
 		     _providerManager, 
 		     request, 
 		     _queueId);
 	       try 
 	       {
 		  if( false == SendForget(async_req) )
 		  {
 		     async_req = static_cast<AsyncLegacyOperationStart *>(op->get_request());
 		     if(async_req)
 			delete async_req->get_action();
 		     delete async_req;
 		     delete op;
 		     // the consumer may not truly be absent, but we couldn't get 
 		     // the message to him. Maybe the service can do something 
 		     // with this information. 
 		     absent_consumers.append(consumer);
 		  }
 		  else 
 		  {
 		     ccode = true;
 		  }
 	       }
 	       catch(...)
 	       {
 
 		  async_req = static_cast<AsyncLegacyOperationStart *>(op->get_request());
 		  if(async_req)
 		     delete async_req->get_action();
 		  delete async_req;
 		  delete op;
 		  // the consumer may not truly be absent, but we couldn't get 
 		  // the message to him. Maybe the service can do something 
 		  // with this information. 
 		  absent_consumers.append(consumer);
 	       }
 	    } // handler is registered as a consumer provider 
 	    else 
 	    {
 	       absent_consumers.append(consumer);
 	    }
 	 
 	 } // found the handler path 
       } // for each subscription
    } // try 
    catch(...)
    {
       throw;
    }
    
    // each subscription contains a reference to a provider 
    // that can handle the subscription. extract the handler
    // instance from the reference 
    PEG_METHOD_EXIT();
    return ccode;
 }