/*

* Copyright (c) 2005 - 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:  Implementation of a parser for protected OMA DRM rights

 *

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32math.h>

#include <apmstd.h>

#include <utf.h>

#include <stringpool.h>

#include <xml/ParserFeature.h>

#ifdef _DEBUG

#include <flogger.h>

#endif // _DEBUG

#include "base64.h"

#include "DcfCommon.h"

#include "DrmRightsParser.h"

#include "DrmProtectedRoParser.h"

#include "DrmRightsClient.h"

#include "hash.h"

#include "DRMCommon.h"

#include "OmaCrypto.h"

#include "CmlaCrypto.h"

#include "DrmPermission.h"

#include "RoapMessage.h"

#include "DcfRep.h"

#include "DcfEntry.h"

#include "Oma2Dcf.h"

using namespace Roap;

using namespace Xml;

// MODULE DATA STRUCTURES

NONSHARABLE_CLASS(CDrmProtectedRoParser::CParsedProtectedRo): public CBase

    {

public:

    static CParsedProtectedRo* NewL();

    ~CParsedProtectedRo();

protected:

    CParsedProtectedRo();

public:

    TKeyTransportScheme iTransportScheme;

    HBufC8* iKey;

    TBool iDomainRo;

    HBufC8* iId;

    HBufC8* iRiUrl;

    HBufC8* iDomainId;

    HBufC8* iRightsIssuerId;

    TTime iTimeStamp;

    HBufC8* iMac;

    HBufC8* iMacDigest;

    };

enum TElementEnum

    {

    EProtectedRo = 0,

    ERo,

    EDomainRo,

    EId,

    EStateful,

    EVersion,

    ERiId,

    EKeyIdentifier,

    EHash,

    ETimeStamp,

    EEncKey,

    EEncryptionMethod,

    EKeyInfo,

    EX509SPKIHash,

    ECipherData,

    ECipherValue,

    EMac,

    ESignedInfo,

    ECanonicalizationMethod,

    ESignatureMethod,

    EReference,

    EDigestMethod,

    EDigestValue,

    ESignatureValue,

    ERetreivalMethod,

    ERoapDomainId,

    EDomainIdentifier,

    ERoapDomainIdentifier,

    ERoResponse,

    ELast,

    };

enum TParserStackState

    {

    ERoState,

    ECipherValueState,

    EDomainIdentifierState,

    EEncryptionMethodState,

    ERightsIssuerIdState,

    ETimeStampState,

    EMacValueState,

    EMacDigestValueState,

    EUnknownState = -1,

    };

struct TElements

    {

    const TText8* iString;

    TInt iNumber;

    };

// MACROS

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

#ifdef _DEBUG

_LIT(KParseLogDir, "DRM");

_LIT(KParseLogFile, "Parse.log");

#define DEBUGLOG( a ) { _LIT(KDebugString, a); RFileLogger::Write( KParseLogDir(), KParseLogFile(), EFileLoggingModeAppend, KDebugString() ); }

#define DEBUGLOGHEX( ptr, len ) RFileLogger::HexDump( KParseLogDir(), KParseLogFile(), EFileLoggingModeAppend, _S(""), _S(""), ptr, len );

#else

#define DEBUGLOG( a )

#define DEBUGLOGHEX( ptr, len )

#endif // _DEBUG

// LOCAL CONSTANTS AND MACROS

const TInt KParserChunkSize = 512;

const TInt KMaxElementNesting = 24;

const TInt KMaxElementLen = 80;

_LIT8(KXmlParserMimeType, "text/xml");

_LIT8(KIdAttr, "id");

_LIT8(KDomainRoAttr, "domainRO");

_LIT8(KRiUrlAttr, "riURL");

_LIT8(KAlgorithmAttr, "Algorithm");

_LIT8(KProtectedRoElement, "protectedRO");

_LIT8(KRoapPrefix, "roap:");

_LIT8(KStartElementStart, "<");

_LIT8(KEndElementStart, "</");

_LIT8(KRoElement, "roap:ro");

_LIT8( KElementEnd, ">" );

_LIT8(KQualifiedProtectedRo, "roap:protectedRO");

_LIT8(KSignedInfoElement, "ds:SignedInfo");

_LIT8(KRoapXmlNs, " xmlns:roap=\"urn:oma:bac:dldrm:roap-1.0\"");

_LIT8(KRoapXmlNsUri, "urn:oma:bac:dldrm:roap-1.0");

_LIT8(KMacStart, "<mac");

static const TElements KElements[] =

    {

        {

        _S8("roResponse"), ERoResponse

        },

        {

        _S8("protectedRo"), EProtectedRo

        },

        {

        _S8("ro"), ERo

        },

        {

        _S8("domainRo"), EDomainRo

        },

        {

        _S8("id"), EId

        },

        {

        _S8("stateful"), EStateful

        },

        {

        _S8("version"), EVersion

        },

        {

        _S8("riID"), ERiId

        },

        {

        _S8("keyIdentifier"), EKeyIdentifier

        },

        {

        _S8("hash"), EHash

        },

        {

        _S8("timeStamp"), ETimeStamp

        },

        {

        _S8("encKey"), EEncKey

        },

        {

        _S8("EncryptionMethod"), EEncryptionMethod

        },

        {

        _S8("KeyInfo"), EKeyInfo

        },

        {

        _S8("roap:X509SPKIHash"), EX509SPKIHash

        },

        {

        _S8("CipherData"), ECipherData

        },

        {

        _S8("CipherValue"), ECipherValue

        },

        {

        _S8("mac"), EMac

        },

        {

        _S8("SignedInfo"), ESignedInfo

        },

        {

        _S8("CanonicalizationMethod"), ECanonicalizationMethod

        },

        {

        _S8("SignatureMethod"), ESignatureMethod

        },

        {

        _S8("Reference"), EReference

        },

        {

        _S8("DigestMethod"), EDigestMethod

        },

        {

        _S8("DigestValue"), EDigestValue

        },

        {

        _S8("SignatureValue"), ESignatureValue

        },

        {

        _S8("RetreivalMethod"), ERetreivalMethod

        },

        {

        _S8("domainID"), ERoapDomainId

        },

        {

        _S8("DomainIdentifier"), EDomainIdentifier

        },

        {

        _S8("roap:DomainIdentifier"), ERoapDomainIdentifier

        }

    };

struct TStackState

    {

    TParserStackState iState;

    TElementEnum iStack[KMaxElementNesting];

    };

static const TStackState KParserStackStates[] =

    {

        {

        ERightsIssuerIdState,

            {

            EHash, EKeyIdentifier, ERiId, ERo, ELast

            }

        },

        {

        EDomainIdentifierState,

            {

            ERoapDomainId, EKeyInfo, EEncKey, ERo, ELast

            }

        },

        {

        EDomainIdentifierState,

            {

            EDomainIdentifier, EKeyInfo, EEncKey, ERo, ELast

            }

        },

        {

        EDomainIdentifierState,

            {

            ERoapDomainIdentifier, EKeyInfo, EEncKey, ERo, ELast

            }

        },

        {

        ECipherValueState,

            {

            ECipherValue, ECipherData, EEncKey, ERo, ELast

            }

        },

        {

        EEncryptionMethodState,

            {

            EEncryptionMethod, EEncKey, ERo, ELast

            }

        },

        {

        ETimeStampState,

            {

            ETimeStamp, ERo, ELast

            }

        },

        {

        EMacValueState,

            {

            ESignatureValue, EMac, ELast

            }

        },

        {

        EMacDigestValueState,

            {

            EDigestValue, EReference, ESignedInfo, EMac, ELast

            }

        },

        {

        ERoState,

            {

            ERo, ELast

            }

        }

    };

// LOCAL FUNCTION PROTOTYPES

TTime Iso8601ToTime(TDesC8& aTimeString);

// ============================= LOCAL FUNCTIONS ===============================

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

// Iso8601ToTime

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

//

TTime Iso8601ToTime(TDesC8& aTimeString)

    {

    TLex8 lex;

    TInt year = 0;

    TInt month = 0;

    TInt day = 0;

    TInt hour = 0;

    TInt minute = 0;

    TInt second = 0;

    TTime r = Time::NullTTime();

    TLocale l;

    TTimeIntervalSeconds offset(l.UniversalTimeOffset());

    if (aTimeString.Length() > 0)

        {

        lex = aTimeString;

        lex.Val(year);

        lex.Inc();

        lex.Val(month);

        lex.Inc();

        lex.Val(day);

        lex.Inc();

        lex.Val(hour);

        lex.Inc();

        lex.Val(minute);

        lex.Inc();

        lex.Val(second);

        r = TTime(TDateTime(year, static_cast<TMonth>(month - 1), day - 1,

                hour, minute, second, 0));

        if (lex.Get() != 'Z')

            {

            r += offset;

            }

        }

    return r;

    }

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

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

// CDrmProtectedRo::NewL

// Allocate a new protected RO object

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

//

CDrmProtectedRoParser::CParsedProtectedRo* CDrmProtectedRoParser::CParsedProtectedRo::NewL()

    {

    CParsedProtectedRo* self = new(ELeave) CParsedProtectedRo;

    return self;

    }

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

// CParsedProtectedRo::~CParsedProtectedRo

// Release all data

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

//

CDrmProtectedRoParser::CParsedProtectedRo::~CParsedProtectedRo()

    {

    delete iKey;

    delete iId;

    delete iRiUrl;

    delete iDomainId;

    delete iRightsIssuerId;

    delete iMac;

    delete iMacDigest;

    }

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

// CParsedProtectedRo::CParsedProtectedRo

// Initialize all member data

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

//

CDrmProtectedRoParser::CParsedProtectedRo::CParsedProtectedRo() :

    iTransportScheme(EOma), iKey(NULL), iDomainRo(EFalse), iId(NULL),

            iRiUrl(NULL), iDomainId(NULL), iRightsIssuerId(NULL), iMac(NULL)

    {

    }

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

// CDrmProtectedRoParser::CDrmProtectedRoParser

// Reset all member variables

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

//

CDrmProtectedRoParser::CDrmProtectedRoParser() :

    iParser(NULL), iRights(NULL), iContent(NULL)

    {

    }

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

// CDrmProtectedRoParser::ConstructL

// Initialize the string pool elements

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

//

void CDrmProtectedRoParser::ConstructL()

    {

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

    for (TInt i = 0; i < ELEMENT_COUNT(KElements); i++)

        {

        TPtrC8 ptr(KElements[i].iString,

                User::StringLength(KElements[i].iString));

        iElements[KElements[i].iNumber] = iParser->StringPool().OpenStringL(ptr);

        }

    }

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

// CDrmProtectedRoParser::NewL

// Two-phased constructor.

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

//

EXPORT_C CDrmProtectedRoParser* CDrmProtectedRoParser::NewL()

    {

    CDrmProtectedRoParser* self = new(ELeave) CDrmProtectedRoParser;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CDrmProtectedRoParser::~CDrmProtectedRoParser

// Release the allocated strings

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

//

EXPORT_C CDrmProtectedRoParser::~CDrmProtectedRoParser()

    {

    for (TInt i = 0; i < ELEMENT_COUNT(KElements); i++)

        {

        iElements[KElements[i].iNumber].Close();

        }

    delete iParser;

    delete iRights;

    delete iContent;

    }

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

// CDrmProtectedRoParser::ParseL

// Parses one <protectedRo> element

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

//

void CDrmProtectedRoParser::ParseL(const TDesC8& aProtectedRo,

        CParsedProtectedRo*& aResultRights)

    {

    TInt i( 0 );

    iElementStackDepth = 0;

    delete iRights;

    delete iContent;

    iContent = NULL;

    iRights = NULL;

    iRights = CParsedProtectedRo::NewL();

    iParser->ParseBeginL();

    i = aProtectedRo.Find( KRoapXmlNsUri );

    if ( i == KErrNotFound )

        {

        // Feed in the ROAP XML namespace declaration

        i = aProtectedRo.Find(KProtectedRoElement);

        if ( i == KErrNotFound )

            {

            User::Leave(KErrCorrupt);

            }

        i += KProtectedRoElement().Length();

        iParser->ParseL( aProtectedRo.Left( i ) );

        iParser->ParseL( KRoapXmlNs() );

        }

    else

        {

        i = 0;

        }

    while ( i < aProtectedRo.Length() )

        {

        TInt n( Min( aProtectedRo.Length() - i, KParserChunkSize ) );

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

        i += n;

        }

    iParser->ParseEndL();

    aResultRights = iRights;

    iRights = NULL;

    }

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

// CDrmProtectedRoParser::GetRiUrlL

// Parse the RO and return the RI URL

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

//

EXPORT_C HBufC8* CDrmProtectedRoParser::GetRiUrlL(

        const TDesC8& aProtectedRo)

    {

    TInt i( 0 );

    HBufC8* r( NULL );

    iElementStackDepth = 0;

    delete iRights;

    delete iContent;

    iRights = NULL;

    iContent = NULL;

    iRights = CParsedProtectedRo::NewL();