httpexportresponsedecoder.cpp

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

        PEG_METHOD_EXIT();
        return;
    }

    //
    // Calculate the beginning of the content from the message size and
    // the content length
    //
    content = (char *) httpMessage->message.getData() +
        httpMessage->message.size() - contentLength;

    //
    // Expect CIMExport HTTP header value MethodResponse
    //
    if (!String::equalNoCase(cimExport, "MethodResponse"))
    {
        MessageLoaderParms mlParms(
            "ExportClient.CIMExportResponseDecoder.EXPECTED_METHODRESPONSE",
            "Received CIMExport HTTP header value \"$0\", "
            "expected \"MethodResponse\"", cimExport);
        String mlString(MessageLoader::getMessage(mlParms));

        AutoPtr<CIMClientMalformedHTTPException> malformedHTTPException(
            new CIMClientMalformedHTTPException(mlString));

        AutoPtr<ClientExceptionMessage> response(
            new ClientExceptionMessage(malformedHTTPException.get()));

        malformedHTTPException.release();
        response->setCloseConnect(cimReconnect);
        exceptionMessage = response.release();
        valid = false;

        PEG_METHOD_EXIT();
        return; 
    }

    PEG_METHOD_EXIT();
}

void HTTPExportResponseDecoder::decodeExportResponse(
    char* content,
    Boolean cimReconnect,
    Message*& responseMessage)
{
    PEG_METHOD_ENTER (TRC_EXPORT_CLIENT,
        "HTTPExportResponseDecoder::decodeExportResponse()");

    AutoPtr<Message> response;

    //
    // Create and initialize XML parser:
    //
    XmlParser parser((char*)content);
    XmlEntry entry;

    try
    {
        //
        // Process <?xml ... >
        //
        const char* xmlVersion = 0;
        const char* xmlEncoding = 0;
        XmlReader::getXmlDeclaration(parser, xmlVersion, xmlEncoding);

        //
        // Process <CIM ... >
        //
        const char* cimVersion = 0;
        const char* dtdVersion = 0;
        XmlReader::getCimStartTag(parser, cimVersion, dtdVersion);

        //
        // Expect <MESSAGE ... >
        //
        String messageId;
        String protocolVersion;
        if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
        {
            MessageLoaderParms mlParms(
                "ExportClient.CIMExportResponseDecoder."
                    "EXPECTED_MESSAGE_ELEMENT",
                "expected MESSAGE element");
            String mlString(MessageLoader::getMessage(mlParms));

            PEG_METHOD_EXIT();
            throw XmlValidationError(parser.getLine(), mlString);
        }

        //
        // Check for unsupported protocol version
        //
        if (!String::equalNoCase(protocolVersion, "1.0"))
        {
            MessageLoaderParms mlParms(
                "ExportClient.CIMExportResponseDecoder.UNSUPPORTED_PROTOCOL",
                "Received unsupported protocol version \"$0\", expected \"$1\"",
                protocolVersion, "1.0");
                String mlString(MessageLoader::getMessage(mlParms));

            AutoPtr<CIMClientResponseException> responseException(
                new CIMClientResponseException(mlString));

            AutoPtr<ClientExceptionMessage> response(
                new ClientExceptionMessage(responseException.get()));

            responseException.release();
            response->setCloseConnect(cimReconnect);
            responseMessage = response.release();

            PEG_METHOD_EXIT();
            return;
        }

        //
        // Expect <SIMPLEEXPRSP ... >
        //
        XmlReader::expectStartTag(parser, entry, "SIMPLEEXPRSP");

        //
        // Expect <EXPMETHODRESPONSE ... >
        //
        const char* expMethodResponseName = 0;
        Boolean isEmptyTag = false;

        if (XmlReader::getEMethodResponseStartTag(
            parser, expMethodResponseName, isEmptyTag))
        {
            if (System::strcasecmp(expMethodResponseName, "ExportIndication")
                == 0)
            {
                response.reset(_decodeExportIndicationResponse(
                    parser, messageId, isEmptyTag));
            }
            else
            {
                //
                //  Unrecognized ExpMethodResponse name attribute
                //
                MessageLoaderParms mlParms(
                    "ExportClient.CIMExportResponseDecoder."
                        "UNRECOGNIZED_EXPMETHRSP",
                    "Unrecognized ExpMethodResponse name \"$0\"",
                    expMethodResponseName);
                String mlString(MessageLoader::getMessage(mlParms));
   
                PEG_METHOD_EXIT();
                throw XmlValidationError(parser.getLine(), mlString);
            }

            //
            // Handle end tag:
            //
            if (!isEmptyTag)
            {
                XmlReader::expectEndTag(parser, "EXPMETHODRESPONSE");
            }
        }
        else
        {
            //
            //  Expected ExpMethodResponse element
            //
            MessageLoaderParms mlParms(
                "ExportClient.CIMExportResponseDecoder."
                    "EXPECTED_EXPMETHODRESPONSE_ELEMENT",
                "expected EXPMETHODRESPONSE element");
            String mlString(MessageLoader::getMessage(mlParms));
  
            PEG_METHOD_EXIT();
            throw XmlValidationError(parser.getLine(), mlString);
        }

        //
        // Handle end tags:
        //
        XmlReader::expectEndTag(parser, "SIMPLEEXPRSP");
        XmlReader::expectEndTag(parser, "MESSAGE");
        XmlReader::expectEndTag(parser, "CIM");
    }
    catch (XmlException& x)
    {
        response.reset(new ClientExceptionMessage(
            new CIMClientXmlException(x.getMessage())));
    }
    catch (Exception& x)
    {
        response.reset(new ClientExceptionMessage(
            new CIMClientResponseException(x.getMessage())));
    }

    //
    //  Note: Ignore any ContentLanguage set in the export response
    //

    response->setCloseConnect(cimReconnect);
    responseMessage = response.release();

    PEG_METHOD_EXIT();
}

CIMExportIndicationResponseMessage*
HTTPExportResponseDecoder::_decodeExportIndicationResponse(
    XmlParser& parser,
    const String& messageId,
    Boolean isEmptyExpMethodResponseTag)
{
    PEG_METHOD_ENTER (TRC_EXPORT_CLIENT,
        "HTTPExportResponseDecoder::_decodeExportIndicationResponse()");
    XmlEntry entry;
    CIMException cimException;

    if (!isEmptyExpMethodResponseTag)
    {
        if (XmlReader::getErrorElement(parser, cimException))
        {
            PEG_METHOD_EXIT();
            return(new CIMExportIndicationResponseMessage(
                messageId,
                cimException,
                QueueIdStack()));
        }

        if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
        {
            if (entry.type != XmlEntry::EMPTY_TAG)
            {
                XmlReader::expectEndTag(parser, "IRETURNVALUE");
            }
        }
    }

    PEG_METHOD_EXIT();
    return(new CIMExportIndicationResponseMessage(
        messageId,
        cimException,
        QueueIdStack()));
}

PEGASUS_NAMESPACE_END