cimmessagedeserializer.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/XmlReader.h>
#include <Pegasus/Common/OperationContextInternal.h>
#include <Pegasus/Common/System.h>

#include "CIMMessageDeserializer.h"

PEGASUS_NAMESPACE_BEGIN

CIMMessage* CIMMessageDeserializer::deserialize(char* buffer)
{
    if (buffer[0] == 0)
    {
        // No message to deserialize
        return 0;
    }

    XmlParser parser(buffer);
    XmlEntry entry;

    CIMMessage* message = 0;
    String messageID;
    String typeString;
    Uint32 type;
    CIMValue genericValue;
#ifndef PEGASUS_DISABLE_PERFINST
    Uint64 serverStartTimeMicroseconds;
    Uint64 providerTimeMicroseconds;
#endif
    Boolean isComplete;
    Uint32 index;
    OperationContext operationContext;

    XmlReader::expectStartTag(parser, entry, "PGMESSAGE");

    Boolean found = entry.getAttributeValue("ID", messageID);
    PEGASUS_ASSERT(found);

    found = entry.getAttributeValue("TYPE", typeString);
    PEGASUS_ASSERT(found);
    type = Uint32(atoi(typeString.getCString()));

#ifndef PEGASUS_DISABLE_PERFINST
    // Deserialize the performance statistics data

    XmlReader::getValueElement(parser, CIMTYPE_UINT64, genericValue);
    genericValue.get(serverStartTimeMicroseconds);
    XmlReader::getValueElement(parser, CIMTYPE_UINT64, genericValue);
    genericValue.get(providerTimeMicroseconds);
#endif

    XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
    genericValue.get(isComplete);

    XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
    genericValue.get(index);

    _deserializeOperationContext(parser, operationContext);

    if (XmlReader::testStartTag(parser, entry, "PGREQ"))
    {
        message = _deserializeCIMRequestMessage(parser, type);
        XmlReader::expectEndTag(parser, "PGREQ");
    }
    else
    {
        // CIMResponseMessage is the only other CIMMessage type defined
        Boolean found = XmlReader::testStartTag(parser, entry, "PGRESP");
        PEGASUS_ASSERT(found);
        message = _deserializeCIMResponseMessage(parser, type);
        XmlReader::expectEndTag(parser, "PGRESP");
    }

    XmlReader::expectEndTag(parser, "PGMESSAGE");

    message->messageId = messageID;
#ifndef PEGASUS_DISABLE_PERFINST
    message->setServerStartTime(serverStartTimeMicroseconds);
    message->setProviderTime(providerTimeMicroseconds);
#endif
    message->setComplete(isComplete);
    message->setIndex(index);
    message->operationContext = operationContext;

    return message;
}

//
// _deserializeCIMRequestMessage
//
CIMRequestMessage* CIMMessageDeserializer::_deserializeCIMRequestMessage(
    XmlParser& parser,
    Uint32 type)
{
    CIMRequestMessage* message = 0;
    XmlEntry entry;
    QueueIdStack queueIdStack;

    _deserializeQueueIdStack(parser, queueIdStack);

    if (XmlReader::testStartTag(parser, entry, "PGOPREQ"))
    {
        CIMOperationRequestMessage* cimOpReqMessage = 0;
        CIMValue genericValue;
        String authType;
        String userName;
        CIMNamespaceName nameSpace;
        CIMName className;
        Uint32 providerType;

        _deserializeUserInfo(parser, authType, userName);
        _deserializeCIMNamespaceName(parser, nameSpace);
        _deserializeCIMName(parser, className);

        // Decode cimMessage->providerType
        XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
        genericValue.get(providerType);

        switch (type)
        {
        // A provider cannot implement these operation types, so the
        // serialization of these messages is not implemented.
        //case CIM_GET_CLASS_REQUEST_MESSAGE:
        //case CIM_DELETE_CLASS_REQUEST_MESSAGE:
        //case CIM_CREATE_CLASS_REQUEST_MESSAGE:
        //case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
        //case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
        //case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
        //case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
        //case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
        //case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
        //case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:

        // Instance operations
        case CIM_GET_INSTANCE_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMGetInstanceRequestMessage(parser);
            break;
        case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMDeleteInstanceRequestMessage(parser);
            break;
        case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMCreateInstanceRequestMessage(parser);
            break;
        case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMModifyInstanceRequestMessage(parser);
            break;
        case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMEnumerateInstancesRequestMessage(parser);
            break;
        case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMEnumerateInstanceNamesRequestMessage(parser);
            break;
        case CIM_EXEC_QUERY_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMExecQueryRequestMessage(parser);
            break;

        // Property operations
        case CIM_GET_PROPERTY_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMGetPropertyRequestMessage(parser);
            break;
        case CIM_SET_PROPERTY_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMSetPropertyRequestMessage(parser);
            break;

        // Association operations
        case CIM_ASSOCIATORS_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMAssociatorsRequestMessage(parser);
            break;
        case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMAssociatorNamesRequestMessage(parser);
            break;
        case CIM_REFERENCES_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMReferencesRequestMessage(parser);
            break;
        case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
            cimOpReqMessage =
                _deserializeCIMReferenceNamesRequestMessage(parser);
            break;

        // Method operations
        case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
            cimOpReqMessage = _deserializeCIMInvokeMethodRequestMessage(parser);
            break;
        }
        PEGASUS_ASSERT(cimOpReqMessage != 0);

        XmlReader::expectEndTag(parser, "PGOPREQ");

        cimOpReqMessage->authType = authType;
        cimOpReqMessage->userName = userName;
        cimOpReqMessage->nameSpace = CIMNamespaceName(nameSpace);
        cimOpReqMessage->className = className;
        cimOpReqMessage->providerType = providerType;

        message = cimOpReqMessage;
    }
    else if (XmlReader::testStartTag(parser, entry, "PGINDREQ"))
    {
        String authType;
        String userName;

        _deserializeUserInfo(parser, authType, userName);

        CIMIndicationRequestMessage* cimIndReqMessage = 0;
        switch (type)
        {
        case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
            cimIndReqMessage =
                _deserializeCIMCreateSubscriptionRequestMessage(parser);
            break;
        case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
            cimIndReqMessage =
                _deserializeCIMModifySubscriptionRequestMessage(parser);
            break;
        case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
            cimIndReqMessage =
                _deserializeCIMDeleteSubscriptionRequestMessage(parser);
            break;
        }
        PEGASUS_ASSERT(cimIndReqMessage != 0);

        XmlReader::expectEndTag(parser, "PGINDREQ");

        cimIndReqMessage->authType = authType;
        cimIndReqMessage->userName = userName;

        message = cimIndReqMessage;
    }
    else    // Other message types
    {
        XmlReader::expectStartTag(parser, entry, "PGOTHERREQ");

        switch (type)
        {
        case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
            message = _deserializeCIMExportIndicationRequestMessage(parser);
            break;
        case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
            message = _deserializeCIMProcessIndicationRequestMessage(parser);
            break;
        //case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //message =
            //  _deserializeCIMNotifyProviderRegistrationRequestMessage(parser);
            break;
        //case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //message =
            //  _deserializeCIMNotifyProviderTerminationRequestMessage(parser);
            break;
        //case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //message = _deserializeCIMHandleIndicationRequestMessage(parser);
            break;
        case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
            message = _deserializeCIMDisableModuleRequestMessage(parser);
            break;
        case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
            message = _deserializeCIMEnableModuleRequestMessage(parser);
            break;
        //case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //message =
            //    _deserializeCIMNotifyProviderEnableRequestMessage(parser);
            break;
        //case CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE:
            // ATTN: No need to deserialize this yet
            //message = _deserializeCIMNotifyProviderFailRequestMessage(parser);
            //break;
        case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
            message = _deserializeCIMStopAllProvidersRequestMessage(parser);
            break;
        case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
            message = _deserializeCIMInitializeProviderRequestMessage(parser);
            break;
        case CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE:
            message =
                _deserializeCIMInitializeProviderAgentRequestMessage(parser);
            break;
        case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:
            message = _deserializeCIMNotifyConfigChangeRequestMessage(parser);
            break;
        case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
            message =
                _deserializeCIMSubscriptionInitCompleteRequestMessage
                    (parser);
            break;
        }
        PEGASUS_ASSERT(message != 0);

        XmlReader::expectEndTag(parser, "PGOTHERREQ");
    }

    message->queueIds = queueIdStack;

    return message;
}

//
// _deserializeCIMResponseMessage
//
CIMResponseMessage* CIMMessageDeserializer::_deserializeCIMResponseMessage(
    XmlParser& parser,
    Uint32 type)
{
    CIMResponseMessage* message = 0;
    QueueIdStack queueIdStack;
    CIMException cimException;

    _deserializeQueueIdStack(parser, queueIdStack);
    _deserializeCIMException(parser, cimException);

    switch (type)
    {
        //
        // CIM Operation Response Messages
        //

        // A provider cannot implement these operation types, so the
        // serialization of these messages is not implemented.
        //case CIM_GET_CLASS_RESPONSE_MESSAGE:
        //case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
        //case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
        //case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
        //case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
        //case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
        //case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
        //case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
        //case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
        //case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:

        // Instance operations
        case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
            message = _deserializeCIMGetInstanceResponseMessage(parser);
            break;
        case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
            message = _deserializeCIMDeleteInstanceResponseMessage(parser);
            break;
        case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
            message = _deserializeCIMCreateInstanceResponseMessage(parser);
            break;
        case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
            message = _deserializeCIMModifyInstanceResponseMessage(parser);
            break;
        case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
            message = _deserializeCIMEnumerateInstancesResponseMessage(parser);
            break;
        case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
            message =
                _deserializeCIMEnumerateInstanceNamesResponseMessage(parser);
            break;
        case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
            message = _deserializeCIMExecQueryResponseMessage(parser);
            break;

        // Property operations
        case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
            message = _deserializeCIMGetPropertyResponseMessage(parser);
            break;
        case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
            message = _deserializeCIMSetPropertyResponseMessage(parser);
            break;

        // Association operations
        case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
            message = _deserializeCIMAssociatorsResponseMessage(parser);
            break;
        case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
            message = _deserializeCIMAssociatorNamesResponseMessage(parser);
            break;
        case CIM_REFERENCES_RESPONSE_MESSAGE:
            message = _deserializeCIMReferencesResponseMessage(parser);
            break;
        case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
            message = _deserializeCIMReferenceNamesResponseMessage(parser);
            break;

        // Method operations
        case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
            message = _deserializeCIMInvokeMethodResponseMessage(parser);
            break;

        //
        // CIM Indication Response Messages
        //

        case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE:
            message = _deserializeCIMCreateSubscriptionResponseMessage(parser);
            break;
        case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE:
            message = _deserializeCIMModifySubscriptionResponseMessage(parser);
            break;
        case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE:
            message = _deserializeCIMDeleteSubscriptionResponseMessage(parser);
            break;

        //
        // Other CIM Response Messages
        //