/*

* Copyright (c) 2002 - 2007 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:  OMA DRM rights parser

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32math.h>

#include <apmstd.h>

#include <utf.h>

#include <stringpool.h>

#include <xml/parserfeature.h>

#include "DrmRights.h"

#include "DcfCommon.h"

#include "DrmRightsParser.h"

#include "DrmRightsClient.h"

#include "hash.h"

#include "base64.h"

#include "DRMPermission.h"

#include "DRMConstraint.h"

#include "DRMClockClient.h"

// MODULE DATA STRUCTURES

enum TElementEnum

    {

    ERights = 0,

    EContext,

    EVersion,

    EUid,

    EAgreement,

    EAsset,

    EInherit,

    EDigest,

    EDigestMethod,

    EDigestValue,

    EKeyInfo,

    EEncryptedKey,

    EEncryptionMethod,

    ECipherData,

    ECipherValue,

    ERetreivalMethod,

    EPermission,

    EPlay,

    EDisplay,

    EPrint,

    EExecute,

    EConstraint,

    ECount,

    ETimedCount,

    EDateTime,

    EStart,

    EEnd,

    EInterval,

    EAccumulated,

    EIndividual,

    EExport,

    ESystem,

    EKeyValue,

    EId,

    EIdRef,

    EProperty,

    ESoftware,

    EContainer,

#ifdef RD_DRM_METERING

    ERequirement,

    ETracked,

#endif

    ELast,

    };

struct TElements

    {

    const TText8* iString;

    TInt iNumber;

    };

NONSHARABLE_CLASS( CDrmRightsParser::CParsedAsset ): public CBase

    {

public:

    static CParsedAsset* NewL();

    ~CParsedAsset();

    void ConstructL();

private:

    CParsedAsset();

public:

    HBufC8* iUid;

    TBuf8< KDCFKeySize > iKey;

    TBuf8< KProtectedDCFKeySize > iProtectedKey;

    TBuf8< KDCFKeySize > iAuthenticationSeed;

    TBuf8< KProtectedDCFKeySize > iProtectedAuthSeed;

    TBuf8< SHA1_HASH > iDigest;

    HBufC8* iId;

    HBufC8* iIdRef;

    HBufC8* iInherit;

    };

// Note the class CDrmRightsParser::CParsedPermission maps to

// OMA DRM2 permission container element <permission>

// CDRMConstraint reperesents indivdual permissions as constraint container

// (except Toplevel constraint really represents

//  constraint container <constraint>)

NONSHARABLE_CLASS( CDrmRightsParser::CParsedPermission ): public CBase

    {

public:

    static CParsedPermission* NewL();

    ~CParsedPermission();

    // Removes invalidated permissions, and marks the total permission invalid,

    // if all constraint containers are invalid, or toplevel container

    // is invalid

    void RemoveInvalidL();

    // Sets current constraint and updates available rights ( iAvailableRights )

    void SetCurrentConstraint ( TRightsType aCurrentConstraint );

    RPointerArray< CParsedAsset > iAssets;

    TUint8 iAvailableRights;

    CDRMConstraint *iTopLevel;

    CDRMConstraint *iPlay;

    CDRMConstraint *iDisplay;

    CDRMConstraint *iPrint;

    CDRMConstraint *iExecute;

    CDRMConstraint *iExport;

    //2.1 addition:

    // URL to send HTTP GET on expiration of permission

    HBufC8* iOnExpiredUrl;

    // if constraint has unknown tags, this is ored with iCurrentConstraint

    TUint8 iInvalidConstraints;

    // maintained during parsing. possible values: TRightsType enumerations

    TUint8 iCurrentConstraint;

    // if top level constraint is invalid or all other constraints ate invalid

    // permission will become invalid

    TBool iInvalid;

    // count of not_owned_assets, (updated in transform...)

    TInt iNotOwned;

private:

    CParsedPermission();

    void ConstructL();

    void ResetConstraintL( CDRMConstraint*& aConstraint );

    };

NONSHARABLE_CLASS( CDrmRightsParser::CParsedRightsObject ): public CBase

    {

public:

    CParsedRightsObject();

    ~CParsedRightsObject();

    // Removes invalidated permission containers

    // (of type CParsedPermission ), and marks the whole rights object

    // invalid, if all permission containers are invalid

    void RemoveInvalid();

    HBufC8* iRightsObjectId;

    RPointerArray< CParsedAsset > iAssets;

    RPointerArray< CParsedPermission > iPermissions;

    CParsedAsset* iCurrentAsset;

    CParsedPermission* iCurrentPermission;

    CDRMConstraint* iCurrentConstraint;

    TBool iKeyIsCek;

    TBool iInvalid;

    };

// CONSTANTS

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

// LOCAL CONSTANTS AND MACROS

const TInt KParserChunkSize = 512;

const TInt KMaxElementNesting = 24;

// 15 minutes per time zone, 60 seconds per minute

const TInt KSecondsPerTimeZone = 900;

const TInt KMinuteInMicroseconds = 60000000;

const TInt KTimeZoneIncrement = 15;

_LIT8( KXmlParserMimeType, "text/xml" );

_LIT8( KWbxmlParserMimeType, "text/wbxml" );

_LIT8( KSchemaAttribute, "schema" );

_LIT8( KSchemeAttribute, "scheme" );

_LIT8( KSchemaSymbianSid, "symbiansid" );

_LIT8( KSchemaSymbianVid, "symbianvid" );

_LIT8( KTimerAttribute, "timer" );

_LIT8( KIdAttribute, "id" );

_LIT8( KIdAttrUpperCase, "Id" );

_LIT8( KIdRefAttribute, "idref" );

_LIT8( KAuthSeed, "authSeed" );

// OMA DRM 2.1 additions

_LIT8( KOnExpiredUrlAttribute, "onExpiredURL" ); //requested on premission expiry if present

#ifdef RD_DRM_METERING

_LIT8( KTimedAttribute, "timed" );

_LIT8( KContentAccessGrantedAttribute, "contentAccessGranted" );

_LIT8( KContentAccessGrantedValueTrue, "true" );

#endif // RD_DRM_METERING

static const TElements KElements[] =

    {

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

    { _S8( "context" ),            EContext },

    { _S8( "version" ),            EVersion },

    { _S8( "uid" ),                EUid },

    { _S8( "agreement" ),          EAgreement },

    { _S8( "asset" ),              EAsset },

    { _S8( "inherit" ),            EInherit },

    { _S8( "digest" ),             EDigest },

    { _S8( "DigestMethod" ),       EDigestMethod },

    { _S8( "DigestValue" ),        EDigestValue },

    { _S8( "KeyInfo" ),            EKeyInfo },

    { _S8( "EncryptedKey" ),       EEncryptedKey },

    { _S8( "EncryptionMethod" ),   EEncryptionMethod },

    { _S8( "CipherData" ),         ECipherData },

    { _S8( "CipherValue" ),        ECipherValue },

    { _S8( "RetrievalMethod" ),    ERetreivalMethod },

    { _S8( "permission" ),         EPermission },

    { _S8( "play" ),               ::EPlay },

    { _S8( "display" ),            ::EDisplay },

    { _S8( "execute" ),            ::EExecute },

    { _S8( "print" ),              ::EPrint },

    { _S8( "constraint" ),         EConstraint },

    { _S8( "count" ),              ECount },

    { _S8( "timed-count" ),        ETimedCount },

    { _S8( "datetime" ),           EDateTime },

    { _S8( "start" ),              EStart },

    { _S8( "end" ),                EEnd },

    { _S8( "interval" ),           EInterval },

    { _S8( "accumulated" ),        EAccumulated },

    { _S8( "individual" ),         EIndividual },

    { _S8( "export" ),             EExport },

    { _S8( "system" ),             ESystem },

    { _S8( "KeyValue" ),           EKeyValue },

    { _S8( "software" ),           ESoftware },

    { _S8( "property" ),           EProperty },

    { _S8( "container" ),          EContainer },

#ifdef RD_DRM_METERING

    { _S8( "requirement" ),        ERequirement },

    { _S8( "tracked" ),            ETracked },

#endif //RD_DRM_METERING

    };

enum TParserStackState

    {

    EUnknownState = -1,

    ERoUidState = 0,

    ETopLevelConstraintState,

    EDisplayConstraintState,

    EPlayConstraintState,

    EPrintConstraintState,

    EExecuteConstraintState,

    EDateTimeStartState,

    EDateTimeEndState,

    EIntervalState,

    ECountState,

    ETimedCountState,

    EIndividualState,

    EAgreementAssetState,

    EPermissionAssetState,

    EAssetUidState,

    EAssetDigestState,

    EAssetKeyState,

    EEncryptedKeyState,

    EAssetInheritUidState,

    EPermissionState,

    ESoftwareState,

    EAccumulatedState,

    EKeyInfoState,

    ESystemState,

    EExportConstraintState,

#ifdef RD_DRM_METERING

    ETrackRequirementState,

#endif // RD_DRM_METERING

    };

struct TStackState

    {

    TParserStackState iState;

    TElementEnum iStack[ KMaxElementNesting ];

    };

// Keep these sorted by the number of elements in the stack

static const TStackState KParserStackStates[] =

    {

    // 5 elements

    { EEncryptedKeyState, { ECipherValue, ECipherData, EEncryptedKey,

                          EKeyInfo, EAsset, ELast } },

    // 4 elements

    { EAssetInheritUidState, { EUid, EContext, EInherit, EAsset, ELast } },

    { EPermissionAssetState, { EAsset, EPermission, EAgreement, ::ERights,

                             ELast } },

    { ESoftwareState, { EProperty, EContext, ESoftware, EContainer, ELast } },

    // 3 elements

    { EAgreementAssetState, { EAsset, EAgreement, ::ERights, ELast } },

    { EIndividualState, { EUid, EContext, EIndividual, ELast } },

    { ESystemState, { EUid, EContext, ESystem, ELast } },

    { ERoUidState, { EUid, EContext, ::ERights, ELast } },

    { EAssetUidState, { EUid, EContext, EAsset, ELast } },

    { EAssetDigestState, { EDigestValue, EDigest, EAsset, ELast } },

    { EAssetKeyState, { EKeyValue, EKeyInfo, EAsset, ELast } },

    // 2 elements

    { EKeyInfoState, { EKeyInfo, EAsset, ELast } },

    { ETopLevelConstraintState, { EConstraint, EPermission, ELast } },

    { EDisplayConstraintState, { ::EDisplay, EPermission, ELast } },

    { EPlayConstraintState, { ::EPlay, EPermission, ELast } },

    { EPrintConstraintState, { ::EPrint, EPermission, ELast } },

    { EExecuteConstraintState, { ::EExecute, EPermission, ELast } },

    { EExportConstraintState, { EExport, EPermission, ELast } },

#ifdef RD_DRM_METERING

    { ETrackRequirementState, { ETracked, ERequirement, ELast } },

#endif // RD_DRM_METERING

    //1 element

    { EDateTimeStartState, { EStart, ELast } },

    { EDateTimeEndState, { EEnd, ELast } },

    { EIntervalState, { EInterval, ELast } },

    { ECountState, { ECount, ELast } },

    { ETimedCountState, { ETimedCount, ELast } },

    { EAccumulatedState, { EAccumulated, ELast } },

    { EPermissionState, { EPermission, ELast } },

    };

// LOCAL FUNCTION PROTOTYPES

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

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

// CDrmRightsParser::ValidateDay

// Returns ETrue if the day is valid

//         EFalse if the day is not valid

//

// If the month is January, March, May, July, August, October, December

// - Check that the day is between 1 and 31

// If the month is April, June, September, November

// - Check that the day is between 1 and 30

// If the month is February

// - Check that the day is between 1 and 29,

// - if it is 29 check that the following conditions are met in that order:

//   * The year is dividable by 400 it's valid

//   * The year is dividable by 100 it is not valid

//   * The year is dividable by 4 it is valid

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

//

TBool CDrmRightsParser::ValidateDay( TInt aYear, TMonth aMonth, TInt aDay )

    {

    TBool retVal = ETrue;

    switch ( aMonth )

        {

        case EJanuary:

        case EMarch:

        case EMay:

        case EJuly:

        case EAugust:

        case EOctober:

        case EDecember:

            {

            if ( aDay < 0 || aDay > 30 )

                {

                retVal = EFalse;

                }

            }

            break;

        case EApril:

        case EJune:

        case ESeptember:

        case ENovember:

            {

            if ( aDay < 0 || aDay > 29 )

                {

                retVal = EFalse;

                }

            }

            break;

        case EFebruary:

            {

            if ( aDay < 0 || aDay > 28 )

                {

                retVal = EFalse;

                }

            else

                {

                // If we are at day 29, it is possible that it is valid:

                if ( aDay == 28 )

                    {

                    // if the year is dividable by 400 it is valid

                    if ( ( aYear % 400 ) )

                        {

                        // if the year is dividable by 100 it is not valid

                        if ( aYear % 100 )

                            {

                            // if the year is dividable by 4 it is valid

                            if ( aYear % 4 )

                                {

                                retVal = EFalse;

                                }

                            }

                        else

                            {

                            retVal = EFalse;

                            }

                        }

                    }

                }

            }

            break;

        default:

            retVal = EFalse;

            break;

        }

    return retVal;

    }

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

// CDrmRightsParser::ValidTimeValues

// Returns ETrue if the time values are valid

//         EFalse if any of them are valid

// Checks done as per symbian documentations

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

//

TBool CDrmRightsParser::ValidTimeValues( TInt aYear, TMonth aMonth,

        TInt aDay, TInt aHour,

        TInt aMinute, TInt aSecond,

        TInt aMicrosecond )

    {

    // No check for Year

    // check Month

    if ( aMonth < EJanuary || aMonth > EDecember )

        {

        return EFalse;

        }

    // check Day

    if ( !ValidateDay( aYear, aMonth, aDay ) )

        {

        return EFalse;

        }

    // check Hour

    if ( aHour < 0 || aHour > 23 )

        {

        return EFalse;

        }

    // check Minute

    if ( aMinute < 0 || aMinute > 59 )

        {

        return EFalse;

        }

    // check Second

    if ( aSecond < 0 || aSecond > 59 )

        {

        return EFalse;

        }

    // check Microsecond

    if ( aMicrosecond < 0 || aMicrosecond > 9999999 )

        {

        return EFalse;

        }

    return ETrue;

    };

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

// CDrmRightsParser::ParseRelTime

// Parses a ISO8601 relative time string

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

//

TTime CDrmRightsParser::ParseRelTimeL( TDesC8& aRelTimeString )

    {

    TLex8 lex;

    TInt year( 0 );

    TInt month( 0 );

    TInt day( 0 );

    TInt hour( 0 );

    TInt minute( 0 );

    TInt second( 0 );

    TTime r;

    TTimeIntervalSeconds offset( 0 );

    lex = aRelTimeString;

    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 );

    // The time needs to be validated before

    if ( !ValidTimeValues( year, static_cast< TMonth >( month - 1 ), day - 1,

                hour, minute, second, 0 ) )

        {

        User::Leave( KErrArgument );

        }

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

                hour, minute, second, 0 ) );