cimmessageserializer.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/XmlWriter.h>
#include <Pegasus/Common/OperationContextInternal.h>

#include "CIMMessageSerializer.h"

PEGASUS_NAMESPACE_BEGIN

void CIMMessageSerializer::serialize(Buffer& out, CIMMessage* cimMessage)
{
    if (cimMessage == 0)
    {
        // No message to serialize
        return;
    }

    // ATTN: Need to serialize the Message class members?

    XmlWriter::append(out, "<PGMESSAGE ID=\"");
    XmlWriter::append(out, cimMessage->messageId);
    XmlWriter::append(out, "\" TYPE=\"");
    XmlWriter::append(out, cimMessage->getType());
    XmlWriter::append(out, "\">");

#ifndef PEGASUS_DISABLE_PERFINST
    // Serialize the statistics data

    XmlWriter::appendValueElement(
        out, cimMessage->getServerStartTime());
    XmlWriter::appendValueElement(
        out, cimMessage->getProviderTime());
#endif

    XmlWriter::appendValueElement(out, cimMessage->isComplete());
    XmlWriter::appendValueElement(out, cimMessage->getIndex());

    _serializeOperationContext(out, cimMessage->operationContext);

    CIMRequestMessage* cimReqMessage;
    cimReqMessage = dynamic_cast<CIMRequestMessage*>(cimMessage);

    CIMResponseMessage* cimRespMessage;
    cimRespMessage = dynamic_cast<CIMResponseMessage*>(cimMessage);

    if (cimReqMessage)
    {
        _serializeCIMRequestMessage(out, cimReqMessage);
    }
    else
    {
        PEGASUS_ASSERT(cimRespMessage != 0);
        _serializeCIMResponseMessage(out, cimRespMessage);
    }

    XmlWriter::append(out, "</PGMESSAGE>");
}

//
// _serializeCIMRequestMessage
//
void CIMMessageSerializer::_serializeCIMRequestMessage(
    Buffer& out,
    CIMRequestMessage* cimMessage)
{
    PEGASUS_ASSERT(cimMessage != 0);

    XmlWriter::append(out, "<PGREQ>");

    _serializeQueueIdStack(out, cimMessage->queueIds);

    CIMOperationRequestMessage* cimOpReqMessage;
    cimOpReqMessage = dynamic_cast<CIMOperationRequestMessage*>(cimMessage);

    CIMIndicationRequestMessage* cimIndReqMessage;
    cimIndReqMessage = dynamic_cast<CIMIndicationRequestMessage*>(cimMessage);

    if (cimOpReqMessage)
    {
        XmlWriter::append(out, "<PGOPREQ>\n");

        _serializeUserInfo(
            out, cimOpReqMessage->authType, cimOpReqMessage->userName);
        _serializeCIMNamespaceName(out, cimOpReqMessage->nameSpace);
        _serializeCIMName(out, cimOpReqMessage->className);

        // Encode cimOpReqMessage->providerType as an integer
        XmlWriter::appendValueElement(out, cimOpReqMessage->providerType);

        switch (cimMessage->getType())
        {
        // 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:
            _serializeCIMGetInstanceRequestMessage(
                out, (CIMGetInstanceRequestMessage*)cimMessage);
            break;
        case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
            _serializeCIMDeleteInstanceRequestMessage(
                out, (CIMDeleteInstanceRequestMessage*)cimMessage);
            break;
        case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
            _serializeCIMCreateInstanceRequestMessage(
                out, (CIMCreateInstanceRequestMessage*)cimMessage);
            break;
        case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
            _serializeCIMModifyInstanceRequestMessage(
                out, (CIMModifyInstanceRequestMessage*)cimMessage);
            break;
        case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
            _serializeCIMEnumerateInstancesRequestMessage(
                out, (CIMEnumerateInstancesRequestMessage*)cimMessage);
            break;
        case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
            _serializeCIMEnumerateInstanceNamesRequestMessage(
                out, (CIMEnumerateInstanceNamesRequestMessage*)cimMessage);
            break;
        case CIM_EXEC_QUERY_REQUEST_MESSAGE:
            _serializeCIMExecQueryRequestMessage(
                out, (CIMExecQueryRequestMessage*)cimMessage);
            break;

        // Property operations
        case CIM_GET_PROPERTY_REQUEST_MESSAGE:
            _serializeCIMGetPropertyRequestMessage(
                out, (CIMGetPropertyRequestMessage*)cimMessage);
            break;
        case CIM_SET_PROPERTY_REQUEST_MESSAGE:
            _serializeCIMSetPropertyRequestMessage(
                out, (CIMSetPropertyRequestMessage*)cimMessage);
            break;

        // Association operations
        case CIM_ASSOCIATORS_REQUEST_MESSAGE:
            _serializeCIMAssociatorsRequestMessage(
                out, (CIMAssociatorsRequestMessage*)cimMessage);
            break;
        case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
            _serializeCIMAssociatorNamesRequestMessage(
                out, (CIMAssociatorNamesRequestMessage*)cimMessage);
            break;
        case CIM_REFERENCES_REQUEST_MESSAGE:
            _serializeCIMReferencesRequestMessage(
                out, (CIMReferencesRequestMessage*)cimMessage);
            break;
        case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
            _serializeCIMReferenceNamesRequestMessage(
                out, (CIMReferenceNamesRequestMessage*)cimMessage);
            break;

        // Method operations
        case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
            _serializeCIMInvokeMethodRequestMessage(
                out, (CIMInvokeMethodRequestMessage*)cimMessage);
            break;

        default:
            PEGASUS_ASSERT(0);
        }

        XmlWriter::append(out, "</PGOPREQ>");
    }
    else if (cimIndReqMessage)
    {
        XmlWriter::append(out, "<PGINDREQ>");

        _serializeUserInfo(
            out, cimIndReqMessage->authType, cimIndReqMessage->userName);

        switch (cimMessage->getType())
        {
        case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
            _serializeCIMCreateSubscriptionRequestMessage(
                out, (CIMCreateSubscriptionRequestMessage*)cimMessage);
            break;
        case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
            _serializeCIMModifySubscriptionRequestMessage(
                out, (CIMModifySubscriptionRequestMessage*)cimMessage);
            break;
        case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
            _serializeCIMDeleteSubscriptionRequestMessage(
                out, (CIMDeleteSubscriptionRequestMessage*)cimMessage);
            break;
        default:
            PEGASUS_ASSERT(0);
        }

        XmlWriter::append(out, "</PGINDREQ>");
    }
    else    // Other message types
    {
        XmlWriter::append(out, "<PGOTHERREQ>");

        switch (cimMessage->getType())
        {
        case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
            _serializeCIMExportIndicationRequestMessage(
                out, (CIMExportIndicationRequestMessage*)cimMessage);
            break;
        case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
            _serializeCIMProcessIndicationRequestMessage(
                out, (CIMProcessIndicationRequestMessage*)cimMessage);
            break;
        //case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //_serializeCIMNotifyProviderRegistrationRequestMessage(
            //    out,
            //    (CIMNotifyProviderRegistrationRequestMessage*)cimMessage);
            break;
        //case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //_serializeCIMNotifyProviderTerminationRequestMessage(
            //    out, (CIMNotifyProviderTerminationRequestMessage*)cimMessage);
            break;
        //case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //_serializeCIMHandleIndicationRequestMessage(
            //    out, (CIMHandleIndicationRequestMessage*)cimMessage);
            break;
        case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
            _serializeCIMDisableModuleRequestMessage(
                out, (CIMDisableModuleRequestMessage*)cimMessage);
            break;
        case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
            _serializeCIMEnableModuleRequestMessage(
                out, (CIMEnableModuleRequestMessage*)cimMessage);
            break;
        //case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //_serializeCIMNotifyProviderEnableRequestMessage(
            //    out, (CIMNotifyProviderEnableRequestMessage*)cimMessage);
            break;
        //case CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE:
            // ATTN: No need to serialize this yet
            //_serializeCIMNotifyProviderFailRequestMessage(
            //    out, (CIMNotifyProviderFailRequestMessage*)cimMessage);
            //break;
        case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
            _serializeCIMStopAllProvidersRequestMessage(
                out, (CIMStopAllProvidersRequestMessage*)cimMessage);
            break;
        case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
            _serializeCIMInitializeProviderRequestMessage(
                out, (CIMInitializeProviderRequestMessage*)cimMessage);
            break;
        case CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE:
            _serializeCIMInitializeProviderAgentRequestMessage(
                out, (CIMInitializeProviderAgentRequestMessage*)cimMessage);
            break;

        case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:
            _serializeCIMNotifyConfigChangeRequestMessage(
                out, (CIMNotifyConfigChangeRequestMessage*)cimMessage);
            break;

        case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
            _serializeCIMSubscriptionInitCompleteRequestMessage(
                out,
                (CIMSubscriptionInitCompleteRequestMessage *)
                cimMessage);
            break;

        default:
            PEGASUS_ASSERT(0);
        }

        XmlWriter::append(out, "</PGOTHERREQ>");
    }

    XmlWriter::append(out, "</PGREQ>");
}

//
// _serializeCIMResponseMessage
//
void CIMMessageSerializer::_serializeCIMResponseMessage(
    Buffer& out,
    CIMResponseMessage* cimMessage)
{
    PEGASUS_ASSERT(cimMessage != 0);

    XmlWriter::append(out, "<PGRESP>\n");

    _serializeQueueIdStack(out, cimMessage->queueIds);
    _serializeCIMException(out, cimMessage->cimException);

    switch (cimMessage->getType())
    {
        //
        // 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:
            _serializeCIMGetInstanceResponseMessage(
                out, (CIMGetInstanceResponseMessage*)cimMessage);
            break;
        case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
            _serializeCIMDeleteInstanceResponseMessage(
                out, (CIMDeleteInstanceResponseMessage*)cimMessage);
            break;
        case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
            _serializeCIMCreateInstanceResponseMessage(
                out, (CIMCreateInstanceResponseMessage*)cimMessage);
            break;
        case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
            _serializeCIMModifyInstanceResponseMessage(
                out, (CIMModifyInstanceResponseMessage*)cimMessage);
            break;
        case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
            _serializeCIMEnumerateInstancesResponseMessage(
                out, (CIMEnumerateInstancesResponseMessage*)cimMessage);
            break;
        case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
            _serializeCIMEnumerateInstanceNamesResponseMessage(
                out, (CIMEnumerateInstanceNamesResponseMessage*)cimMessage);
            break;
        case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
            _serializeCIMExecQueryResponseMessage(
                out, (CIMExecQueryResponseMessage*)cimMessage);
            break;

        // Property operations
        case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
            _serializeCIMGetPropertyResponseMessage(
                out, (CIMGetPropertyResponseMessage*)cimMessage);
            break;
        case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
            _serializeCIMSetPropertyResponseMessage(
                out, (CIMSetPropertyResponseMessage*)cimMessage);
            break;

        // Association operations
        case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
            _serializeCIMAssociatorsResponseMessage(
                out, (CIMAssociatorsResponseMessage*)cimMessage);
            break;
        case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
            _serializeCIMAssociatorNamesResponseMessage(
                out, (CIMAssociatorNamesResponseMessage*)cimMessage);
            break;
        case CIM_REFERENCES_RESPONSE_MESSAGE:
            _serializeCIMReferencesResponseMessage(
                out, (CIMReferencesResponseMessage*)cimMessage);
            break;
        case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
            _serializeCIMReferenceNamesResponseMessage(