cmpiimpl.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// 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
// 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.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#include "CmpiInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiResult.h"
#include "CmpiDateTime.h"

#include "CmpiBaseMI.h"
#include "CmpiInstanceMI.h"
#include "CmpiAssociationMI.h"
#include "CmpiMethodMI.h"
#include "CmpiPropertyMI.h"
#include "CmpiIndicationMI.h"

#include "CmpiData.h"
#include "CmpiCharData.h"
#include "CmpiBooleanData.h"


#ifdef CMPI_STANDALONE
# define PEGASUS_USING_STD using namespace std
#else
#  include <Pegasus/Common/Config.h>
#endif

PEGASUS_USING_STD;

//---------------------------------------------------
//--
//	C to C++ base provider function drivers
//--
//---------------------------------------------------

CmpiBaseMI::CmpiBaseMI(const CmpiBroker& mbp, const CmpiContext& ctx)
{
  broker = new CmpiBroker(mbp);
}

CmpiBaseMI::~CmpiBaseMI()
{
  delete broker;
}

CMPIStatus CmpiBaseMI::driveBaseCleanup
      (void* vi, const CMPIContext* eCtx, CMPIBoolean b) {
  try {
   CMPIInstanceMI *mi=( CMPIInstanceMI*)vi;
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiStatus rc(CMPI_RC_OK);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*>(mi->hdl);
   if (cmi->isUnloadable()) {
     if (cmi->getProviderBase() && cmi->getProviderBase()->decUseCount()==0) {
       cmi->getProviderBase()->setBaseMI(0);
       cmi->setProviderBase(0);
       rc=cmi->cleanup(ctx);
       delete cmi;
     }
   } else {
     rc = CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   }
   return rc.status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

void CmpiBaseMI::setProviderBase(CmpiProviderBase* base)
{
  providerBase=base;
  CmpiProviderBase::setBroker(broker->getEnc());
}

CmpiProviderBase* CmpiBaseMI::getProviderBase()
{
  return providerBase;
}

CmpiStatus CmpiBaseMI::initialize(const CmpiContext& ctx) {
   return CmpiStatus(CMPI_RC_OK);
}

CmpiStatus CmpiBaseMI::cleanup(CmpiContext& ctx) {
#ifdef PEGASUS_DEBUG
    cerr << "cleaning up provider" << endl;
#endif
   return CmpiStatus(CMPI_RC_OK);
}

int CmpiBaseMI::isUnloadable() const {
   return 1;
}

//---------------------------------------------------
//--
//	C to C++ instance provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiInstanceMI::driveEnumInstanceNames
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->enumInstanceNames(ctx,rslt,cop).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiInstanceMI::driveEnumInstances
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop, const char* *properties)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->enumInstances
      (ctx,rslt,cop,properties).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiInstanceMI::driveGetInstance
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop, const char* *properties)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->getInstance
      (ctx,rslt,cop,properties).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiInstanceMI::driveCreateInstance
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop, const CMPIInstance* eInst)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiInstance inst(eInst);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->createInstance
      (ctx,rslt,cop,inst).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiInstanceMI::driveSetInstance
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop, const CMPIInstance* eInst, 
    const char* *properties)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiInstance inst(eInst);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->setInstance
      (ctx,rslt,cop,inst,(const char**)properties).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiInstanceMI::driveDeleteInstance
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->deleteInstance
      (ctx,rslt,cop).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif

    return stat.status();
  }
}

CMPIStatus CmpiInstanceMI::driveExecQuery
   (CMPIInstanceMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop, const char* language ,const char* query)
{
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiInstanceMI* imi = dynamic_cast<CmpiInstanceMI*>(cmi);
   return imi->execQuery
    (ctx,rslt,cop,language,query).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}


//---------------------------------------------------
//--
//	Default Instance provider functions
//--
//---------------------------------------------------

CmpiInstanceMI::CmpiInstanceMI(const CmpiBroker &mbp, const CmpiContext& ctx)
   : CmpiBaseMI (mbp,ctx) {
}

CmpiStatus CmpiInstanceMI::enumInstanceNames
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::enumInstances
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
	       const char* *properties){
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::getInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
	       const char* *properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::createInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
               const CmpiInstance& inst) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::setInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
              const  CmpiInstance& inst, const char* *properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::deleteInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::execQuery
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
               const char* language, const char* query) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}


//---------------------------------------------------
//--
//	C to C++ association provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiAssociationMI::driveAssociators
      (CMPIAssociationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPIObjectPath* eOp, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole, const char** properties) {
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eOp);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiAssociationMI* ami = dynamic_cast<CmpiAssociationMI*>(cmi);
   return ami->associators
      (ctx,rslt,cop,
       (const char*)assocClass,resultClass,
       role,resultRole,(const char**)properties).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiAssociationMI::driveAssociatorNames
      (CMPIAssociationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPIObjectPath* eOp, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole) {
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eOp);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiAssociationMI* ami = dynamic_cast<CmpiAssociationMI*>(cmi);
   return ami->associatorNames
      (ctx,rslt,cop,
       assocClass,resultClass,
       role,resultRole).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiAssociationMI::driveReferences
      (CMPIAssociationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPIObjectPath* eOp, const char* resultClass, const char* role ,
       const char** properties) {
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eOp);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiAssociationMI* ami = dynamic_cast<CmpiAssociationMI*>(cmi);
   return ami->references
      (ctx,rslt,cop,
       resultClass,role,(const char**)properties).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiAssociationMI::driveReferenceNames
      (CMPIAssociationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPIObjectPath* eOp, const char* resultClass, const char* role) {
  try {
   CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   CmpiObjectPath cop((CMPIObjectPath*)eOp);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiAssociationMI* ami = dynamic_cast<CmpiAssociationMI*>(cmi);
   return ami->referenceNames
      (ctx,rslt,cop,
       resultClass,role).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}


//---------------------------------------------------
//--
//	Default Association provider functions
//--
//---------------------------------------------------

CmpiAssociationMI::CmpiAssociationMI(const CmpiBroker &mbp, const CmpiContext& ctx)
    : CmpiBaseMI (mbp,ctx) {
}

CmpiStatus CmpiAssociationMI::associators
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole, const char** properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiAssociationMI::associatorNames
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiAssociationMI::references
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* resultClass, const char* role ,
       const char** properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiAssociationMI::referenceNames
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* resultClass, const char* role) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}


//---------------------------------------------------
//--
//	C to C++ method provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiMethodMI::driveInvokeMethod
   (CMPIMethodMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
    const CMPIObjectPath* eCop, const char* methodName,
    const CMPIArgs* eIn, CMPIArgs* eOut)
{
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   const CmpiArgs in((CMPIArgs*)eIn);
   CmpiArgs out(eOut);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);