cmpi_error.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 <Pegasus/Common/CIMError.h>
#include "CMPI_Version.h"

#include "CMPI_Error.h"
#include "CMPI_Ftabs.h"
#include "CMPI_String.h"

PEGASUS_USING_STD;
PEGASUS_NAMESPACE_BEGIN

extern "C" 
{

    CMPIError *newCMPIError(
        const char* owner, const char* msgID, const char * msg,
        const CMPIErrorSeverity sev, const CMPIErrorProbableCause pc, 
        const CMPIrc cimStatusCode)
    {
        CIMError::PerceivedSeverityEnum pgSev = (CIMError::PerceivedSeverityEnum)sev;
        CIMError::ProbableCauseEnum pgPc = (CIMError::ProbableCauseEnum)pc;
        CIMError::CIMStatusCodeEnum pgSc = (CIMError::CIMStatusCodeEnum)cimStatusCode;


        CIMError *cer=new CIMError(owner, msgID, msg, pgSev, pgPc, pgSc);
        return reinterpret_cast<CMPIError*>(new CMPI_Object(cer));
    }

    static CMPIError* errClone(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }
        CIMError* cErr=new CIMError(*cer);
        CMPI_Object* obj=new CMPI_Object(cErr);
        obj->unlink();
        CMPIError* neErr=reinterpret_cast<CMPIError*>(obj);
        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return neErr;
    }

    static CMPIStatus errRelease(CMPIError* eErr)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (cer)
        {
            delete cer;
            (reinterpret_cast<CMPI_Object*>(eErr))->unlinkAndDelete();
        }
        CMReturn(CMPI_RC_OK);
    }

    static CMPIErrorType errGetErrorType(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return UnknownErrorType;
        }

        CMPIBoolean notNull;
        CIMError::ErrorTypeEnum pgErrorType;

        try
        {
            notNull = cer->getErrorType(pgErrorType);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return UnknownErrorType;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return UnknownErrorType;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return (CMPIErrorType)pgErrorType;
    }

    static CMPIString* errGetOtherErrorType(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        String pgOtherErrorType;

        try
        {
            notNull = cer->getOtherErrorType(pgOtherErrorType);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return string2CMPIString(pgOtherErrorType);
    }

    static CMPIString* errGetOwningEntity(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        String pgOwningEntity;

        try
        {
            notNull = cer->getOwningEntity(pgOwningEntity);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return string2CMPIString(pgOwningEntity);
    }

    static CMPIString* errGetMessageID(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        String pgMessageID;

        try
        {
            notNull = cer->getMessageID(pgMessageID);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return string2CMPIString(pgMessageID);
    }

    static CMPIString* errGetMessage(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        String pgMessage;

        try
        {
            notNull = cer->getMessage(pgMessage);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return string2CMPIString(pgMessage);
    }

    static CMPIErrorSeverity errGetPerceivedSeverity(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return ErrorSevUnknown;
        }

        CMPIBoolean notNull;
        CIMError::PerceivedSeverityEnum pgPerceivedSeverity;

        try
        {
            notNull = cer->getPerceivedSeverity(pgPerceivedSeverity);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return ErrorSevUnknown;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return ErrorSevUnknown;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return (CMPIErrorSeverity)pgPerceivedSeverity;
    }

    static CMPIErrorProbableCause errGetProbableCause(
        const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return ErrorProbCauseUnknown;
        }

        CMPIBoolean notNull;
        CIMError::ProbableCauseEnum pgProbableCause;

        try
        {
            notNull = cer->getProbableCause(pgProbableCause);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return ErrorProbCauseUnknown;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return ErrorProbCauseUnknown;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return (CMPIErrorProbableCause)pgProbableCause;
    }

    static CMPIString* errGetProbableCauseDescription(
        const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        String pgProbCauseDesc;

        try
        {
            notNull = cer->getProbableCauseDescription(pgProbCauseDesc);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return string2CMPIString(pgProbCauseDesc);
    }

    static CMPIArray* errGetRecommendedActions(
        const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        Array<String> pgRecommendedActions;

        try
        {
            notNull = cer->getRecommendedActions(pgRecommendedActions);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        CMPIUint32 arrSize = pgRecommendedActions.size();
        CMPIData *dta=new CMPIData[arrSize+1];
        // first element reserved for type and size
        dta->type=CMPI_string;
        dta->value.uint32=arrSize;
        for (unsigned int i=1; i<=arrSize; i++) {
           dta[i].type=CMPI_string;
           dta[i].state=CMPI_goodValue;
           String s = pgRecommendedActions[i-1];
           dta[i].value.string=string2CMPIString(s);
        }
        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return reinterpret_cast<CMPIArray*>(new CMPI_Object(dta));
    }

    static CMPIString* errGetErrorSource(const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return NULL;
        }

        CMPIBoolean notNull;
        String pgErrorSource;

        try
        {
            notNull = cer->getErrorSource(pgErrorSource);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return NULL;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return NULL;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return string2CMPIString(pgErrorSource);
    }

    static CMPIErrorSrcFormat errGetErrorSourceFormat(
        const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
            return CMPIErrSrcUnknown;
        }

        CMPIBoolean notNull;
        CIMError::ErrorSourceFormatEnum pgErrorSourceFormat;

        try
        {
            notNull = cer->getErrorSourceFormat(pgErrorSourceFormat);
            if (!notNull)
            {
                if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
                return CMPIErrSrcUnknown;
            }
        }
        catch (...)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_FAILED);
            return CMPIErrSrcUnknown;
        }

        if (rc) CMSetStatus(rc,CMPI_RC_OK);
        return (CMPIErrorSrcFormat)pgErrorSourceFormat;
    }

    static CMPIString* errGetOtherErrorSourceFormat(
        const CMPIError* eErr, CMPIStatus* rc)
    {
        CIMError* cer=(CIMError*)eErr->hdl;
        if (!cer)
        {
            if (rc) CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);