OW_CIMServer.cpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2001-2004 Vintela, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*  - Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistributions in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the documentation
*    and/or other materials provided with the distribution.
*
*  - Neither the name of Vintela, Inc. nor the names of its
*    contributors may be used to endorse or promote products derived from this
*    software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Vintela, Inc. OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/

#include "OW_config.h"
#include "OW_CIMServer.hpp"
#include "OW_CIMValueCast.hpp"
#include "OW_ConfigOpts.hpp"
#include "OW_Format.hpp"
#include "OW_WQLIFC.hpp"
#include "OW_Assertion.hpp"
#include "OW_CIMParamValue.hpp"
#include "OW_CIMRepository.hpp"
#include "OW_NoSuchProviderException.hpp"
#include "OW_CIMValue.hpp"
#include "OW_CIMProperty.hpp"
#include "OW_CIMQualifierType.hpp"
#include "OW_CIMQualifier.hpp"
#include "OW_CIMMethod.hpp"
#include "OW_CIMParameter.hpp"
#include "OW_CIMObjectPath.hpp"
#include "OW_CIMInstance.hpp"
#include "OW_OperationContext.hpp"
#include "OW_MutexLock.hpp"
#include "OW_UserInfo.hpp"
#include "OW_ResultHandlers.hpp"
#include "OW_AuthorizerManager.hpp" 
#include "OW_ProviderEnvironmentIFC.hpp"
#include "OW_ProviderManager.hpp"
#include "OW_ServiceIFCNames.hpp"

#include <iterator>

namespace OW_NAMESPACE
{

using namespace WBEMFlags;

namespace
{
   const String COMPONENT_NAME("ow.owcimomd.CIMServer");
   const char* const DEPRECATED__NamespaceClassName = "__Namespace";

   class AuthorizerEnabler
   {
   public:
      AuthorizerEnabler(const AuthorizerManagerRef& authorizerMgr,
         OperationContext& context, bool turnOff=false)
      : m_authorizerMgr(authorizerMgr)
      , m_context(context)
      {
         if (turnOff)
         {
            m_authorizerMgr->turnOff(m_context);
         }
      }

      ~AuthorizerEnabler()
      {
         m_authorizerMgr->turnOn(m_context);
      }

   private:
      AuthorizerManagerRef m_authorizerMgr;
      OperationContext& m_context;
   };

   class ClonedCIMServerProviderEnvironment : public ProviderEnvironmentIFC
   {
   public:
      ClonedCIMServerProviderEnvironment(
         const ServiceEnvironmentIFCRef& env)
         : m_env(env)
      {}
      virtual String getConfigItem(const String &name,
         const String& defRetVal="") const
      {
         return m_env->getConfigItem(name, defRetVal);
      }
      virtual StringArray getMultiConfigItem(const String &itemName, 
         const StringArray& defRetVal, const char* tokenizeSeparator = 0) const
      {
         return m_env->getMultiConfigItem(itemName, defRetVal, tokenizeSeparator);
      }
      virtual CIMOMHandleIFCRef getCIMOMHandle() const
      {
         return m_env->getCIMOMHandle(m_context,
            ServiceEnvironmentIFC::E_USE_PROVIDERS);
      }
      
      virtual CIMOMHandleIFCRef getRepositoryCIMOMHandle() const
      {
         return m_env->getCIMOMHandle(m_context,
            ServiceEnvironmentIFC::E_BYPASS_PROVIDERS);
      }
      
      virtual RepositoryIFCRef getRepository() const
      {
         return m_env->getRepository();
      }
      virtual LoggerRef getLogger() const
      {
         return m_env->getLogger(COMPONENT_NAME);
      }
      virtual LoggerRef getLogger(const String& componentName) const
      {
         return m_env->getLogger(componentName);
      }
      virtual String getUserName() const
      {
         return m_context.getUserInfo().getUserName();
      }
      virtual OperationContext& getOperationContext()
      {
         return m_context;
      }
      virtual ProviderEnvironmentIFCRef clone() const
      {
         return ProviderEnvironmentIFCRef(new ClonedCIMServerProviderEnvironment(m_env));
      }
   private:
      mutable OperationContext m_context;
      ServiceEnvironmentIFCRef m_env;
   };

   class CIMServerProviderEnvironment : public ProviderEnvironmentIFC
   {
   public:
      CIMServerProviderEnvironment(OperationContext& context,
         const ServiceEnvironmentIFCRef& env)
         : m_context(context)
         , m_env(env)
      {}
      virtual String getConfigItem(const String &name,
         const String& defRetVal="") const
      {
         return m_env->getConfigItem(name, defRetVal);
      }
      virtual StringArray getMultiConfigItem(const String &itemName, 
         const StringArray& defRetVal, const char* tokenizeSeparator = 0) const
      {
         return m_env->getMultiConfigItem(itemName, defRetVal, tokenizeSeparator);
      }
      virtual CIMOMHandleIFCRef getCIMOMHandle() const
      {
         return m_env->getCIMOMHandle(m_context,
            ServiceEnvironmentIFC::E_USE_PROVIDERS,
            ServiceEnvironmentIFC::E_NO_LOCKING);
      }
      
      virtual CIMOMHandleIFCRef getRepositoryCIMOMHandle() const
      {
         return m_env->getCIMOMHandle(m_context,
            ServiceEnvironmentIFC::E_BYPASS_PROVIDERS,
            ServiceEnvironmentIFC::E_NO_LOCKING);
      }
      
      virtual RepositoryIFCRef getRepository() const
      {
         return m_env->getRepository();
      }
      virtual LoggerRef getLogger() const
      {
         return m_env->getLogger(COMPONENT_NAME);
      }
      virtual LoggerRef getLogger(const String& componentName) const
      {
         return m_env->getLogger(componentName);
      }
      virtual String getUserName() const
      {
         return m_context.getUserInfo().getUserName();
      }
      virtual OperationContext& getOperationContext()
      {
         return m_context;
      }
      virtual ProviderEnvironmentIFCRef clone() const
      {
         return ProviderEnvironmentIFCRef(new ClonedCIMServerProviderEnvironment(m_env));
      }
   private:
      OperationContext& m_context;
      ServiceEnvironmentIFCRef m_env;
   };

   inline ProviderEnvironmentIFCRef createProvEnvRef(OperationContext& context,
      const ServiceEnvironmentIFCRef& env)
   {
      return ProviderEnvironmentIFCRef(new CIMServerProviderEnvironment(context, env));
   }

   inline void logOperation(const LoggerRef& lgr, const OperationContext& context, const char* operation, const String& ns, const String& objectName = String())
   {
      // avoid the overhead of formatting the message if we're not going to log this.
      ELogLevel level = lgr->getLogLevel();
      if (level == E_DEBUG_LEVEL || level == E_INFO_LEVEL)
      {
         String userString;
         String user = context.getStringDataWithDefault(OperationContext::USER_NAME);
         if (!user.empty())
         {
            userString = " for user: " + user;
         }
         String optObjectName;
         if (!objectName.empty())
         {
            optObjectName = ':' + objectName;
         }
         OW_LOG_INFO(lgr, Format("CIMServer doing operation: %1 on %2%3%4", operation, ns, optObjectName, userString));
      }
   }
}

CIMServer::CIMServer(const ServiceEnvironmentIFCRef& env,
   const ProviderManagerRef& provManager,
   const RepositoryIFCRef& cimRepository,
   const AuthorizerManagerRef& authorizerMgr)
   : RepositoryIFC()
   , m_provManager(provManager)
   , m_nsClass_Namespace(CIMNULL)
   , m_env(env)
   , m_cimRepository(cimRepository)
   , m_realRepository(dynamic_pointer_cast<CIMRepository>(m_cimRepository))
   , m_authorizerMgr(authorizerMgr)
   , m_logger(env->getLogger(COMPONENT_NAME))
{
}
CIMServer::~CIMServer()
{
   try
   {
      close();
   }
   catch (...)
   {
      // don't let exceptions escape
   }
}
void
CIMServer::open(const String& path)
{
}
void
CIMServer::close()
{
}

String
CIMServer::getName() const
{
   return ServiceIFCNames::CIMServer;
}

StringArray
CIMServer::getDependencies() const
{
   StringArray rv;
   rv.push_back(ServiceIFCNames::AuthorizerManager);
   rv.push_back(ServiceIFCNames::CIMRepository);
   rv.push_back(ServiceIFCNames::ProviderManager);
   return rv;
}

void
CIMServer::init(const ServiceEnvironmentIFCRef& env)
{
   // not much to do here, the ctor already did it all.
}

void
CIMServer::shutdown()
{
   m_provManager = 0;
   m_env = 0;
   m_cimRepository = 0;
   m_realRepository = 0;
   m_authorizerMgr = 0;
}
void
CIMServer::_checkNameSpaceAccess(OperationContext& context, const String& ns,
   Authorizer2IFC::EAccessType acType)
{
   if (!m_authorizerMgr->allowAccessToNameSpace(m_env, ns, acType,
      context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Access to namespace %1 is not allowed", ns).c_str());
   }
}
#if !defined(OW_DISABLE_INSTANCE_MANIPULATION) && !defined(OW_DISABLE_NAMESPACE_MANIPULATION)

void
CIMServer::createNameSpace(const String& ns,
   OperationContext& context)
{
   if (!m_authorizerMgr->allowCreateNameSpace(
      m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Creation of namespace %1 is not allowed",
            ns).c_str());
   }

   logOperation(m_logger, context, "createNameSpace", ns);
   m_cimRepository->createNameSpace(ns,context);
}
void
CIMServer::deleteNameSpace(const String& ns,
   OperationContext& context)
{
   if (!m_authorizerMgr->allowDeleteNameSpace(
      m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Deletion of namespace %1 is not allowed",
            ns).c_str());
   }

   logOperation(m_logger, context, "deleteNameSpace", ns);
   m_cimRepository->deleteNameSpace(ns,context);
}
#endif // #ifndef OW_DISABLE_INSTANCE_MANIPULATION

void
CIMServer::enumNameSpace(StringResultHandlerIFC& result,
   OperationContext& context)
{
   if (!m_authorizerMgr->allowEnumNameSpace(
      m_env, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         "Enumeration of namespaces is not allowed");
   }

   // Don't need to check ACLs, since this is a result of calling enumInstances.
   logOperation(m_logger, context, "enumNameSpace", String());
   m_cimRepository->enumNameSpace(result,context);
}
CIMQualifierType
CIMServer::getQualifierType(const String& ns,
   const String& qualifierName,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_READ);

   if (!m_authorizerMgr->allowReadSchema(m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Read of qualifier %1 is not allowed",
            qualifierName).c_str());
   }

   logOperation(m_logger, context, "GetQualifier", ns, qualifierName);
   return m_cimRepository->getQualifierType(ns,qualifierName,context);
}
#ifndef OW_DISABLE_QUALIFIER_DECLARATION

void
CIMServer::enumQualifierTypes(
   const String& ns,
   CIMQualifierTypeResultHandlerIFC& result,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_READ);

   if (!m_authorizerMgr->allowReadSchema(m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         "Enumeration of qualifiers is not allowed");
   }

   logOperation(m_logger, context, "EnumerateQualifiers", ns);
   m_cimRepository->enumQualifierTypes(ns,result,context);
}
void
CIMServer::deleteQualifierType(const String& ns, const String& qualName,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_WRITE);

   if (!m_authorizerMgr->allowWriteSchema(m_env, ns,
      Authorizer2IFC::E_DELETE, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Deletion of qualifier %1 is not allowed",
            qualName).c_str());
   }

   logOperation(m_logger, context, "DeleteQualifier", ns, qualName);
   m_cimRepository->deleteQualifierType(ns,qualName,context);
}
void
CIMServer::setQualifierType(
   const String& ns,
   const CIMQualifierType& qt, OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_WRITE);

   if (!m_authorizerMgr->allowWriteSchema(m_env, ns,
      Authorizer2IFC::E_MODIFY, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Modification of qualifier %1 is not allowed",
            qt.getName()).c_str());
   }

   logOperation(m_logger, context, "SetQualifier", ns, qt.getName());
   m_cimRepository->setQualifierType(ns,qt,context);
}
#endif // #ifndef OW_DISABLE_QUALIFIER_DECLARATION

CIMClass
CIMServer::getClass(
   const String& ns, const String& className, ELocalOnlyFlag localOnly,
   EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
   const StringArray* propertyList, OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_READ);

   if (!m_authorizerMgr->allowReadSchema(m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Read of class %1 is not allowed", className).c_str());
   }

   logOperation(m_logger, context, "GetClass", ns, className);
   CIMClass theClass = _getNameSpaceClass(className);
   if (!theClass)
   {
      theClass = m_cimRepository->getClass(ns,className,localOnly,
         includeQualifiers,includeClassOrigin,propertyList,context);
   }
   return theClass;
}
CIMClass
CIMServer::_instGetClass(const String& ns, const CIMName& className,
   ELocalOnlyFlag localOnly,
   EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
   const StringArray* propertyList, OperationContext& context)
{
   CIMClass theClass = _getNameSpaceClass(className);
   if (!theClass)
   {
      try
      {
         theClass = m_cimRepository->getClass(ns,className.toString(),localOnly,
            includeQualifiers,includeClassOrigin,propertyList,context);
      }
      catch (CIMException& e)
      {
         if (e.getErrNo() == CIMException::NOT_FOUND)
         {
            e.setErrNo(CIMException::INVALID_CLASS);
         }
         throw e;
      }
   }
   return theClass;
}
#ifndef OW_DISABLE_SCHEMA_MANIPULATION

CIMClass
CIMServer::deleteClass(const String& ns, const String& className,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_WRITE);

   if (!m_authorizerMgr->allowWriteSchema(m_env, ns,
      Authorizer2IFC::E_DELETE, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Deletion of class %1 is not allowed",
            className).c_str());
   }

   logOperation(m_logger, context, "DeleteClass", ns, className);
   return m_cimRepository->deleteClass(ns,className,context);
}
void
CIMServer::createClass(const String& ns, const CIMClass& cimClass,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_WRITE);

   if (!m_authorizerMgr->allowWriteSchema(m_env, ns,
      Authorizer2IFC::E_CREATE, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Creation of class %1 is not allowed",
            cimClass.getName()).c_str());
   }

   logOperation(m_logger, context, "GetClass", ns, cimClass.getName());
   if (cimClass.getName().equalsIgnoreCase(DEPRECATED__NamespaceClassName))
   {
      OW_THROWCIMMSG(CIMException::ALREADY_EXISTS,
         Format("Creation of class %1 is not allowed",
            cimClass.getName()).c_str());
   }
   m_cimRepository->createClass(ns,cimClass,context);
}
CIMClass
CIMServer::modifyClass(
   const String& ns,
   const CIMClass& cc,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_WRITE);

   if (!m_authorizerMgr->allowWriteSchema(m_env, ns,
      Authorizer2IFC::E_MODIFY, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         Format("Modification of class %1 is not allowed",
            cc.getName()).c_str());
   }

   logOperation(m_logger, context, "ModifyClass", ns, cc.getName());
   return m_cimRepository->modifyClass(ns,cc,context);
}
#endif // #ifndef OW_DISABLE_SCHEMA_MANIPULATION

void
CIMServer::enumClasses(const String& ns,
      const String& className,
      CIMClassResultHandlerIFC& result,
      EDeepFlag deep, ELocalOnlyFlag localOnly, EIncludeQualifiersFlag includeQualifiers,
      EIncludeClassOriginFlag includeClassOrigin, OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_READ);

   if (!m_authorizerMgr->allowReadSchema(m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         "Enumeration of classes is not allowed");
   }

   logOperation(m_logger, context, "EnumerateClasses", ns, className);
   m_cimRepository->enumClasses(ns,className,result,deep,localOnly,
      includeQualifiers,includeClassOrigin,context);
}
void
CIMServer::enumClassNames(
   const String& ns,
   const String& className,
   StringResultHandlerIFC& result,
   EDeepFlag deep, OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_READ);

   if (!m_authorizerMgr->allowReadSchema(m_env, ns, context))
   {
      OW_THROWCIMMSG(CIMException::ACCESS_DENIED,
         "Enumeration of class names is not allowed");
   }

   logOperation(m_logger, context, "EnumerateClassNames", ns, className);
   m_cimRepository->enumClassNames(ns,className,result,deep,context);
}
namespace
{
   class InstNameEnumerator : public CIMClassResultHandlerIFC
   {
   public:
      InstNameEnumerator(
         const String& ns_,
         CIMObjectPathResultHandlerIFC& result_,
         OperationContext& context_,
         const ServiceEnvironmentIFCRef& env_,
         CIMServer* server_)
         : ns(ns_)
         , result(result_)
         , context(context_)
         , m_env(env_)
         , server(server_)
      {}
   protected:
      virtual void doHandle(const CIMClass &cc)
      {
         LoggerRef lgr(m_env->getLogger(COMPONENT_NAME));
         if (lgr->getLogLevel() == E_DEBUG_LEVEL)
         {
            OW_LOG_DEBUG(lgr, Format("CIMServer InstNameEnumerator enumerated derived instance names: %1:%2", ns,
               cc.getName()));
         }
         server->_getCIMInstanceNames(ns, cc.getName(), cc, result, context);
      }
   private:
      String ns;
      CIMObjectPathResultHandlerIFC& result;
      OperationContext& context;
      const ServiceEnvironmentIFCRef& m_env;
      CIMServer* server;
   };
}
void
CIMServer::enumInstanceNames(
   const String& ns,
   const String& className,
   CIMObjectPathResultHandlerIFC& result,
   EDeepFlag deep,
   OperationContext& context)
{
   _checkNameSpaceAccess(context, ns, Authorizer2IFC::E_READ);

   logOperation(m_logger, context, "EnumerateInstanceNames", ns, className);

   InstNameEnumerator ie(ns, result, context, m_env, this);
   CIMClass theClass = _instGetClass(ns, className,E_NOT_LOCAL_ONLY,
      E_INCLUDE_QUALIFIERS,E_INCLUDE_CLASS_ORIGIN,0,context);
   ie.handle(theClass);
   // If this is the namespace class then just return now
   if (className.equalsIgnoreCase(DEPRECATED__NamespaceClassName)
      || !deep)
   {
      return;
   }
   else
   {
      // TODO: measure whether it would be faster to use
      // enumClassNames + getClass() here.
      m_cimRepository->enumClasses(ns,className,ie,deep,E_NOT_LOCAL_ONLY,
         E_INCLUDE_QUALIFIERS,E_INCLUDE_CLASS_ORIGIN,context);
   }
}
// PRIVATE
void
CIMServer::_getCIMInstanceNames(const String& ns, const CIMName& className,
   const CIMClass& theClass, CIMObjectPathResultHandlerIFC& result,
   OperationContext& context)
{
   InstanceProviderIFCRef instancep = _getInstanceProvider(ns, theClass, context);
   if (instancep)
   {
      instancep->enumInstanceNames(createProvEnvRef(context, m_env),
         ns, className.toString(), result, theClass);
   }
   else
   {
      m_cimRepository->enumInstanceNames(ns,className.toString(),result,E_SHALLOW,context);
   }
}
namespace
{
   class InstEnumerator : public CIMClassResultHandlerIFC
   {
   public:
      InstEnumerator(
         const String& ns_,
         CIMInstanceResultHandlerIFC& result_,
         OperationContext& context_,
         const ServiceEnvironmentIFCRef& env_,
         CIMServer* server_,
         EDeepFlag deep_,
         ELocalOnlyFlag localOnly_,
         EIncludeQualifiersFlag includeQualifiers_,
         EIncludeClassOriginFlag includeClassOrigin_,
         const StringArray* propertyList_,
         const CIMClass& theTopClass_)
         : ns(ns_)
         , result(result_)
         , context(context_)
         , m_env(env_)
         , server(server_)
         , deep(deep_)
         , localOnly(localOnly_)
         , includeQualifiers(includeQualifiers_)
         , includeClassOrigin(includeClassOrigin_)
         , propertyList(propertyList_)
         , theTopClass(theTopClass_)
      {}
   protected:
      virtual void doHandle(const CIMClass &cc)
      {
         LoggerRef lgr(m_env->getLogger(COMPONENT_NAME));
         if (lgr->getLogLevel() == E_DEBUG_LEVEL)
         {
            OW_LOG_DEBUG(lgr, Format("CIMServer InstEnumerator Enumerating"
               " derived instance names: %1:%2", ns, cc.getName()));
         }
         server->_getCIMInstances(ns, cc.getName(), theTopClass, cc,
            result, localOnly, deep, includeQualifiers,
            includeClassOrigin, propertyList, context);
      }
   private:
      String ns;
      CIMInstanceResultHandlerIFC& result;
      OperationContext& context;
      const ServiceEnvironmentIFCRef& m_env;
      CIMServer* server;
      EDeepFlag deep;
      ELocalOnlyFlag localOnly;
      EIncludeQualifiersFlag includeQualifiers;
      EIncludeClassOriginFlag includeClassOrigin;
      const StringArray* propertyList;
      const CIMClass& theTopClass;
   };
}

void
CIMServer::enumInstances(
   const String& ns,
   const String& className,
   CIMInstanceResultHandlerIFC& result, EDeepFlag deep,
   ELocalOnlyFlag localOnly, EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
   const StringArray* propertyList, EEnumSubclassesFlag enumSubclasses,
   OperationContext&am