/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  ROAP response parser

*

*/

// INCLUDE FILES

#include <e32base.h>

#include "DeviceHello.h"

#include "JoinDomainReq.h"

#include "JoinDomainResp.h"

#include "LeaveDomainReq.h"

#include "LeaveDomainResp.h"

#ifdef RD_DRM_METERING

#include "MeteringReportReq.h"

#include "MeteringReportResp.h"

#include "MeteringReportRespParser.h"

#endif

#include "RIHello.h"

#include "RegistrationReq.h"

#include "RegistrationResp.h"

#include "RightsReq.h"

#include "RightsResp.h"

#include "RoapTrigger.h"

#include "RoapMessage.h"

#include "RoapParser.h"

#include "RespParser.h"

#include "JoinDomainRespParser.h"

#include "LeaveDomainRespParser.h"

#include "RIHelloParser.h"

#include "RegistrationRespParser.h"

#include "RightsRespParser.h"

#include "RoapTriggerParser.h"

#include "RoapLog.h"

using namespace Roap;

// LOCAL CONSTANTS AND MACROS

#define ELEMENT_COUNT(x) static_cast<TInt>((sizeof(x) / sizeof (x[0])))

const TInt KParserChunkSize = 512;

const TInt KRoapElementCount = ELast;

const TInt KMaxElementNesting = 24;

struct TRoapElements

    {

    const TText8* iString;

    TInt iNumber;

    };

struct TStackState

    {

    TParserStackState iState;

    TRoapElementEnum iStack[KMaxElementNesting];

    };

static const TRoapElements KStatusValues[] =

    {

    {_S8("Success"), ESuccess},

    {_S8("UnknownError"), EUnknownError},

    {_S8("Abort"), EAbort},

    {_S8("NotSupported"), ENotSupported},

    {_S8("AccessDenied"), Roap::EAccessDenied},

    {_S8("NotFound"), ENotFound},

    {_S8("MalformedRequest"), EMalformedRequest},

    {_S8("UnknownRequest"), EUnknownRequest},

    {_S8("UnknownCriticalExtension"), EUnknownCriticalExtension},

    {_S8("UnsupportedVersion"), EUnsupportedVersion},

    {_S8("UnsupportedAlgorithm"), EUnsupportedAlgorithm},

    {_S8("NoCertificateChain"), ENoCertificateChain},

    {_S8("InvalidCertificateChain"), EInvalidCertificateChain},

    {_S8("TrustedRootCertificateNotPresent"), ETrustedRootCertificateNotPresent},

    {_S8("SignatureError"), ESignatureError},

    {_S8("DeviceTimeError"), EDeviceTimeError},

    {_S8("NotRegistered"), ENotRegistered},

    {_S8("InvalidDCFHash"), EInvalidDCFHash},

    {_S8("InvalidDomain"), EInvalidDomain},

    {_S8("DomainFull"), EDomainFull},

    {_S8("MalformedMeteringReport"), EMalformedMeteringReport},

    {_S8("UnableToDecryptMeteringReport"), EUnableToDecryptMeteringReport},

    {_S8("UnableToValidateMeteringReportMAC"), EUnableToValidateMeteringReportMAC},

    };

static const TRoapElements KRoapElements[ELast] =

    {

    {_S8("certificate"), ECertificate},

    {_S8("certificateChain"), ECertificateChain},

    {_S8("CipherData"), ECipherData},

    {_S8("CipherValue"), ECipherValue},

    {_S8("contentID"), Roap::EContentID},

    {_S8("dcfHash"), EDcfHash},

    {_S8("deviceDetails"), EDeviceDetails},

    {_S8("deviceID"), EDeviceID},

    {_S8("DigestValue"), EDigestValue},

    {_S8("dn"), EDomainName},

    {_S8("domainAlias"), EDomainAlias},

    {_S8("domainID"), EDomainID},

    {_S8("domainInfo"), EDomainInfo},

    {_S8("domainKey"), EDomainKey},

    {_S8("encKey"), EEncKey},

    {_S8("EncryptionMethod"), EEncryptionMethod},

    {_S8("extension"), EExtension},

    {_S8("extensions"), EExtensions},

    {_S8("hash"), EHash},

    {_S8("id"), EId},

    {_S8("identifier"), EIdentifier},

    {_S8("joinDomain"), EJoinDomain},

    {_S8("joinDomainResponse"), EJoinDomainResponse},

    {_S8("keyIdentifier"), EKeyIdentifier},

    {_S8("leaveDomain"), ELeaveDomain},

    {_S8("leaveDomainResponse"), ELeaveDomainResponse},

    {_S8("mac"), EMac},

    {_S8("manufacturer"), EManufacturer},

    {_S8("model"), EModel},

    {_S8("nonce"), ENonce},

    {_S8("notAfter"), ENotAfter},

    {_S8("ocspResponse"), EOcspResponse},

    {_S8("protectedRO"), EProtectedRO},

    {_S8("registrationRequest"), ERegistrationRequest},

    {_S8("registrationResponse"), ERegistrationResponse},

    {_S8("riAlias"), ERiAlias},

    {_S8("rights"), Roap::ERights},

    {_S8("riHello"), ERiHello},

    {_S8("riID"), ERiID},

    {_S8("riNonce"), ERiNonce},

    {_S8("riURL"), ERiURL},

    {_S8("ro"), ERo},

    {_S8("roAcquisition"), ERoAcquisition},

    {_S8("roapTrigger"), ERoapTrigger},

    {_S8("roapURL"), ERoapURL},

    {_S8("roID"), ERoID},

    {_S8("roInfo"), ERoInfo},

    {_S8("roResponse"), ERoResponse},

    {_S8("selectedAlgorithm"), ESelectedAlgorithm},

    {_S8("selectedVersion"), ESelectedVersion},

    {_S8("serverInfo"), EServerInfo},

    {_S8("signature"), ESignature},

    {_S8("SignatureValue"), ESignatureValue},

    {_S8("supportedAlgorithm"), ESupportedAlgorithm},

    {_S8("time"), ETime},

    {_S8("timeStamp"), ETimeStamp},

    {_S8("trustedAuthorities"), ETrustedAuthorities},

    {_S8("version"), EVersion},

    {_S8("X509SPKIHash"), EX509SPKIHash},

#ifdef RD_DRM_METERING

    {_S8("extendedTrigger"), EExtendedTriggerElement},

    {_S8("meteringReport"), EMeteringReportRequest},

    {_S8("meteringReportResponse"), EMeteringReportResponse},

    {_S8("prURL"), EPrUrl}

#endif

    };

// The stack states have to be sorted with descending length. The

// MatchStackState function searches for the first matching state.

static const TStackState KParserStackStates[] =

    {

    // 4 elements --------------------------------------------------------------

    {ERiIdRoResponseState, {EHash, EKeyIdentifier, ERiID, ERoResponse, ELast}},

    {ERiIdJoinDomainResponseState, {EHash, EKeyIdentifier, ERiID, EJoinDomainResponse, ELast}},

    // 3 elements --------------------------------------------------------------

#ifdef RD_DRM_METERING

    {EPostResponseUrlState, {EPrUrl, EExtension, EExtensions, ELast}},

#endif

    {EDeviceIdState, {EHash, EKeyIdentifier, EDeviceID, ELast}},

    {ETrustedAuthoritiesState, {EHash, EKeyIdentifier, ETrustedAuthorities, ELast}},

    {EPeerKeyIdentifierRIHelloState, {EIdentifier, EExtension, EExtensions, ELast}},

    {ETransactionIdState, {EId, EExtension, EExtensions, ELast}},

    {ETransactionIdContentIdState, {Roap::EContentID, EExtension, EExtensions, ELast}},

    {EWhiteListState, {EDomainName, EExtension, EExtensions, ELast}},

    {EDeviceDetailsState, {EDeviceDetails, EExtensions, ERiHello, ELast}},

    {ERiIdState, {EHash, EKeyIdentifier, ERiID, ELast}},

    {EEncKeyState, {ECipherValue, ECipherData, EEncKey, ELast}},

    {EDomainKeyEncryptionMethodState, {EEncryptionMethod, EEncKey, EDomainKey, ELast}},

    {EMacJoinDomainResponseState, {EMac, EDomainKey, EDomainInfo, ELast}},

    // 2 elements --------------------------------------------------------------

    {EDomainKeyEncKeyState, {EEncKey, EDomainKey, ELast}},

    {ECertificateState, {ECertificate, ECertificateChain, ELast}},

    {ESignatureRoResponseState, {ESignature, ERoResponse, ELast}},

    {EExtensionState, {EExtension, EExtensions, ELast}},

    // 1 element ---------------------------------------------------------------

    {ERiAliasState, {ERiAlias, ELast}},

    {EDomainAliasState, {EDomainAlias, ELast}},

    {ERiHelloState, {ERiHello, ELast}},

    {ESelectedVersionState, {ESelectedVersion, ELast}},

    {ERiNonceState, {ERiNonce, ELast}},

    {EOcspResponseState, {EOcspResponse, ELast}},

    {ERiUrlState, {ERiURL, ELast}},

    {ESignatureState, {ESignature, ELast}},

    {ERegistrationResponseState, {ERegistrationResponse, ELast}},

    {ERoResponseState, {ERoResponse, ELast}},

    {EJoinDomainResponseState, {EJoinDomainResponse, ELast}},

    {ELeaveDomainResponseState, {ELeaveDomainResponse, ELast}},

    {EDomainIdState, {EDomainID, ELast}},

    {ENonceState, {ENonce, ELast}},

    {ENotAfterState, {ENotAfter, ELast}},

    {EDomainKeyState, {EDomainKey, ELast}},

    {ERoapTriggerState, {ERoapTrigger, ELast}},

    {ERoapUrlState, {ERoapURL, ELast}},

    {ERegistrationRequestState, {ERegistrationRequest, ELast}},

    {ERoAcquisitionState, {ERoAcquisition, ELast}},

    {EJoinDomainState, {EJoinDomain, ELast}},

    {ELeaveDomainState, {ELeaveDomain, ELast}},

    {ERoIdState, {ERoID, ELast}},

    {EContentIdState, {Roap::EContentID, ELast}},

    {ESignatureValueState, {ESignatureValue, ELast}},

    {EDigestValueState, {EDigestValue, ELast}},

    {EServerInfoState, {EServerInfo, ELast}},

    {ESupportedAlgorithmState, {ESupportedAlgorithm, ELast}},

    {ESelectedAlgorithmState, {ESelectedAlgorithm, ELast}},

#ifdef RD_DRM_METERING

    {EExtendedTriggerElementState, {EExtendedTriggerElement, ELast}},

    {EMeteringReportRequestState, {EMeteringReportRequest, ELast}},

    {EMeteringReportResponseState, {EMeteringReportResponse, ELast}}

#endif

    };

_LIT8(KParserMimeType, "text/xml");

_LIT8(KDomainKey, "domainKey");

_LIT8(KMac, "mac>");

_LIT8(KMacEnd, "</mac>");

// ============================ auto_handde helper class =======================

//Auto handle for easening handle release on exceptional exit situations

template<class T> class auto_handle

    {

    public:

    auto_handle() {}

    auto_handle(T aHandle) : iHandle( aHandle ) {}

    auto_handle( auto_handle<T>& aHandle) : iHandle( aHandle.release() ) {}

    ~auto_handle() { iHandle.Close(); }

    const T& operator()() const { return iHandle; }

    T& operator()() { return iHandle; }

    T get() const { return iHandle; }

    T release() { T temp = iHandle; iHandle = 0; return temp; }

    private:

    T iHandle;

    };

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CRoapParser::CRoapParser

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CRoapParser::CRoapParser():

    iParser(NULL),

    iResponseParser(NULL)

    {

    }

// -----------------------------------------------------------------------------

// CRoapParser::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CRoapParser::ConstructL()

    {

    TInt i;

    iParser = CParser::NewL(KParserMimeType, *this);

    for (i = 0; i < KRoapElementCount; i++)

        {

        TPtrC8 ptr(KRoapElements[i].iString, User::StringLength(

            KRoapElements[i].iString));

        iRoapElements[KRoapElements[i].iNumber] =

            iParser->StringPool().OpenStringL(ptr);

        }

    }

// -----------------------------------------------------------------------------

// CRoapParser::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CRoapParser* CRoapParser::NewL()

    {

    CRoapParser* self = new( ELeave ) CRoapParser;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CRoapParser::~CRoapParser()

    {

    TInt i;

    for (i = 0; i < ELEMENT_COUNT(KRoapElements); i++)

        {

        iRoapElements[KRoapElements[i].iNumber].Close();

        }

    delete iParser;

    delete iContent;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseMeteringRespL

// -----------------------------------------------------------------------------

//

#ifndef RD_DRM_METERING

CMeteringResp* CRoapParser::ParseMeteringRespL( const TDesC8& /*aMessage*/ )

    {

    return NULL;

    }

#else

CMeteringResp* CRoapParser::ParseMeteringRespL( const TDesC8& aMessage )

    {

    LOG( _L("CRoapParser::ParseMeteringRespL") );

    CMeteringResp* r = CMeteringResp::NewL();

    CleanupStack::PushL(r);

    TMeteringRespParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    CleanupStack::Pop(r);

    return r;

    }

#endif

// -----------------------------------------------------------------------------

// CRoapParser::ParseJoinDomainRespL

// -----------------------------------------------------------------------------

//

CJoinDomainResp* CRoapParser::ParseJoinDomainRespL(

    const TDesC8& aMessage, RPointerArray<HBufC8>& aDomainKeyElements)

    {

    LOG( _L("CRoapParser::ParseJoinDomainRespL") );

    CJoinDomainResp* r = CJoinDomainResp::NewL();

    CleanupStack::PushL(r);

    TJoinDomainRespParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    if ( r->iStatus == ESuccess )

        {

        User::LeaveIfError(

            ExtractDomainKeyElements(aMessage, aDomainKeyElements));

        }

    CleanupStack::Pop(r);

    return r;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseLeaveDomainRespL

// -----------------------------------------------------------------------------

//

CLeaveDomainResp* CRoapParser::ParseLeaveDomainRespL(

    const TDesC8& aMessage)

    {

    LOG( _L("CRoapParser::ParseLeaveDomainRespL") );

    CLeaveDomainResp* r = CLeaveDomainResp::NewL();

    CleanupStack::PushL(r);

    TLeaveDomainRespParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    CleanupStack::Pop(r);

    return r;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseRegistrationResp

// -----------------------------------------------------------------------------

//

CRegistrationResp* CRoapParser::ParseRegistrationRespL(

    const TDesC8& aMessage)

    {

    LOG( _L("CRoapParser::ParseRegistrationRespL") );

    CRegistrationResp* r = CRegistrationResp::NewL();

    CleanupStack::PushL(r);

    TRegistrationRespParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    CleanupStack::Pop(r);

    return r;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseRightsRespL

// -----------------------------------------------------------------------------

//

CRightsResp* CRoapParser::ParseRightsRespL(

    const TDesC8& aMessage)

    {

    LOG( _L("CRoapParser::ParseRightsRespL") );

    CRightsResp* r = CRightsResp::NewL();

    CleanupStack::PushL(r);

    TRightsRespParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    CleanupStack::Pop(r);

    return r;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseRIHelloL

// -----------------------------------------------------------------------------

//

CRIHello* CRoapParser::ParseRIHelloL(

    const TDesC8& aMessage)

    {

    LOG( _L("CRoapParser::ParseRIHelloL") );

    CRIHello* r = CRIHello::NewL();

    CleanupStack::PushL(r);

    TRIHelloParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    CleanupStack::Pop(r);

    return r;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseRoapTriggerL

// -----------------------------------------------------------------------------

//

CRoapTrigger* CRoapParser::ParseRoapTriggerL(

    const TDesC8& aMessage)

    {

    LOG( _L("CRoapParser::ParseRoapTriggerL") );

    CRoapTrigger* r = CRoapTrigger::NewL();

    CleanupStack::PushL(r);

    TRoapTriggerParser p(r);

    iResponseParser = &p;

    ParseL(aMessage);

    CleanupStack::Pop(r);

    return r;

    }

// -----------------------------------------------------------------------------

// CRoapParser::ParseL

// -----------------------------------------------------------------------------

//

void CRoapParser::ParseL(

    const TDesC8& aMessage)

    {

    TInt i;

    TInt n;

    iElementStackDepth = 0;

    delete iContent;

    iContent = NULL;

    iParser->ParseBeginL();

    i = 0;

    while (i < aMessage.Length())

        {

        n = Min(aMessage.Length() - i, KParserChunkSize);

        iParser->ParseL(aMessage.Mid(i, n));

        i += n;

        }

    iParser->ParseEndL();

    }

// -----------------------------------------------------------------------------

// CRoapParser::OnStartDocumentL

// -----------------------------------------------------------------------------

//

void CRoapParser::OnStartDocumentL(

    const RDocumentParameters& /*aDocParam*/,

    TInt /*aErrorCode*/)

    {

    }

// -----------------------------------------------------------------------------

// CRoapParser::OnEndDocumentL

// -----------------------------------------------------------------------------

//

void CRoapParser::OnEndDocumentL(

    TInt /*aErrorCode*/)

    {

    }

// -----------------------------------------------------------------------------

// CRoapParser::OnStartElementL

// -----------------------------------------------------------------------------

//

void CRoapParser::OnStartElementL(

    const RTagInfo& aElement,

    const RAttributeArray& aAttributes,

    TInt /*aErrorCode*/)

    {

    TInt i;

    TInt state;

    if (iContent)

        {

        delete iContent;

        iContent = NULL;

        iContent = HBufC8::NewL(0);

        }

    for (i = 0; i < KRoapElementCount; i++)

        {

        if (aElement.LocalName() == iRoapElements[i])

            {

            iElementStack[iElementStackDepth] =

                static_cast<TRoapElementEnum>(i);

            iElementStackDepth++;

            state = MatchStackState();

            iResponseParser->OnStartElementL(*this, state, aElement,

                aAttributes);

            if (iElementStackDepth == KMaxElementNesting)

                {

                User::Leave(EXmlUnexpectedState);

                }