/*
* Copyright (c) 2004 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: Interface to BbB encryption.
*
*/
#ifndef CDRMMESSAGEPARSER_H
#define CDRMMESSAGEPARSER_H
// INCLUDES
#include <e32base.h>
#include <s32strm.h>
// CONSTANTS
// MACROS
// DATA TYPES
// FUNCTION PROTOTYPES
// FORWARD DECLARATIONS
class COma1DcfCreator;
class CDRMRights;
class RDRMRightsClient;
// CLASS DECLARATION
/**
* This class handles all DRM Message parsing and B64 decoding,
* and feeds the resulting data either to
* DRMAuthenticated::Encrypt[Initialize|Update|Finalize]L or writes the
* data directly to given output stream (DCF in DRM Message).
* The internal state iState is modified in quite many places in the
* class methods.
*
* @lib DRMAuthenticated.dll
* @since S60Rel2.5
*/
NONSHARABLE_CLASS(CDRMMessageParser): public CBase
{
public: // Constructors and destructor
enum TDRMMessageParserState
{
ESearchingBoundary = 0x00, // The first operation to do.
EGotBoundary = 0x01,
EReadingHeaderPart = 0x02,
EReadingRightsPart = 0x04,
EGotRightsPart = 0x08,
EReadingContentPart = 0x10,
EGotContentPart = 0x20,
EGotContentEncoding = 0x40,
EBase64 = 0x80,
EGotContentType = 0x100,
EDCFFile = 0x200,
EDCFURIModified = 0x400,
EDCFHeadersModified = 0x800,
EEncryptStreamOk = 0x1000,
EFLContent = 0x2000,
EAllDone = 0x4000,
EBroken = 0x8000
};
/**
* Two-phased constructor.
*/
IMPORT_C static CDRMMessageParser* NewL( void );
/**
* Destructor.
*/
IMPORT_C virtual ~CDRMMessageParser( void );
public: // New functions
/**
* InitializeMessageParserL
*
* @since 2.0
* DRM message Block-by-Block parser initialization method must be called
* once before ProcessMessageDataL can be called. All processed data is
* written to given write stream when calling ProcessMessageDataL and
* FinalizeMessageParserL methods.
*
* InitializeMessageParserL, ProcessMessageDataL and FinalizeMessageParserL
* use EncryptInitializeL, EncryptUpdateL and EncryptFinalizeL internally,
* so one instance of DRMAuthenticated can only process one encryption
* session at a time.
* @param aOutput Write stream where the processed data is written.
*/
IMPORT_C void InitializeMessageParserL(
RWriteStream& aOutput );
/**
* ProcessMessageDataL
*
* @since 2.0
* This method processes the given part of DRM message data. If
* there is some data to be returned (there might not always be),
* the processed data is written to the output stream.
* @param aMessageData Part of DRM message data to be processed.
*/
IMPORT_C void ProcessMessageDataL(
const TDesC8& aMessageData );
/**
* FinalizeMessageParserL
*
* @since 2.0
* This method finalizes the BbB parsing of DRM message. The method
* flushes the internal buffers returns any remaining processed data
* to output stream depending on the initialization. After calling this
* method the parser needs to
* be re-initialized in order to process more data.
*/
IMPORT_C void FinalizeMessageParserL();
/**
* ProcessMessage
*
* Takes a memory buffer containing a DRM message, splits the message
* into the contained parts and processes the parts. After completion
* of the function, the input buffer contains the DCF from the message,
* the Rights Object is saved to the rights database..
*
* @since 2.0
* @param aDRMMessage: In/out parameter containing the DRM message
* before the function call and the DCF after the function call
* @return EOk if the message has been processed successfully
*/
IMPORT_C TInt ProcessMessage(
HBufC8*& aDRMMessage);
/**
* ProcessRightsObject
*
* Takes a memory buffer containing a Rights Object and saves it to the
* rights database. Returns the detailed rights specification of the
* Rights Object.
*
* @since 2.0
* @param aRightsObject: Buffer containing the rights object
* @param aRightsDetail: Out parameter for the details of the rights
* in the rights object
* @return EOk if the rights object could be stored successfully
*/
IMPORT_C TInt ProcessRightsObject(
const TDesC8& aRightsObject,
RPointerArray<CDRMRights>& aRightsDetail);
/**
* Cleans up the internal storages in case of
* CleanupStack::PopAndDestroy()
*/
void Release( void );
public: // Functions from base classes
protected: // New functions
/**
* C++ default constructor.
*/
CDRMMessageParser( void );
protected: // Functions from base classes
private:
/**
* By default Symbian 2nd phase constructor is private.
*/
void ConstructL( void );
/**
* Processes the data from DRM Message body.
*/
void HandleContentDataL( void );
/**
* Processes the rights object data part from DRM Message.
*/
void HandleRightsDataL( void );
/**
* Tries to locate the boundary separator from the beginning of the
* message, and if a boundary is found, it is stored.
*/
void FindBoundaryL( void );
/**
* Parses the DRM Message header part.
*/
void ReadHeaderL( void );
/**
* Returns a single line from the message, ending to \n.
* @return Reference to a single line in the message.
*/
TPtrC8 GetLineL( void );
/**
* Extracts a MIME header value from the given line. Ignores
* possible parameters.
* @param aLine Line to be searched for the header value.
* @return Reference to the header value found.
*/
TPtrC8 HeaderValueL( const TDesC8& aLine );
/**
* Compresses the internal buffers discarding all already used
* data.
*/
void CompressInputBuffer( void );
/**
* Prepares the content data to be encrypted/processed, i.e.
* constructs a descriptor to iInputBuffer which can then be
* processed.
*/
void PrepareContentDataL( void );
/**
* Do base64 decoding to the given descriptor.
* @param aData in/out descriptor: after successful call, the
* descriptor contains base64 decoded data.
* @return How many base64 encoded bytes from aData was consumed.
*/
TInt HandleBase64DataL( TPtrC8& aData );
/**
* Extracts the endline characters from the given descriptor.
* @param aBuf A single line to be stripped from endline characters.
* The descriptor length is changed to corresponding value.
*/
void StripEndLineL( TPtrC8& aBuf );
/**
* Tells whether the given line is a boundary line, and if so, is it
* the final boundary marking the end of the message.
* @param aLine Line.
* @param aLast Out-parameter: if the line is a boundary line and this
* is the last boundary, aLast == ETrue after the call.
* @return Truth value.
*/
TBool IsBoundary( const TDesC8& aLine,
TBool& aLast ) const;
/**
* This method generates a FL rights object if the message being
* processed is a FL message. If the message is a CD message,
* no rights object. Saves the rights object into rights database.
*/
void HandleFlContentL( void );
/**
* Helper method for HandleFlContentL: saves the RO to the database.
* @param aCID Content-ID.
* @param aData rights data.
*/
void ProcessRightsDataL( const TDesC8& aCID,
const TDesC8& aData );
/**
* Writes the (base64 decoded) data to EncryptUpdateL or directly to
* the output stream. Modifies the content-type of DCF file in case
* "DCF inside DRM Message" case.
* @param aData Data to be encrypted / written to the stream.
*/
void ProcessContentDataL( TPtrC8& aData );
void EnsureFLRightsExistL( RDRMRightsClient& aClient, CDRMRights** aOutput );
/**
* Checks whether the given character is valid base64 encoded character.
* @param aChar Character to be checked.
* @return Truth value.
*/
TBool ValidB64CharL( const TUint8 aChar );
/**
* Sets an internal state bit.
* @param aBit New state bit to be enabled.
*/
void SetBit( TUint32 aBit );
/**
* Clears an internal state bit.
* @param aBit The state bit to be cleared.
*/
void ClearBit( TUint32 aBit );
/**
* Do cleanup operations & update internal state to indicate an
* error occured.
* @param aError Error code which is thrown. KErrNone does not leave.
*/
void SetBrokenStateL( const TInt aError );
void Reset();
void DoProcessMessageL( HBufC8*& aDRMMessage );
void DoProcessRightsObjectL( const TDesC8& aRightsObject,
RPointerArray<CDRMRights>& aRightsDetail );
void DeletePermission();
void InitDCFBufferL();
void CreateCDCIDL( HBufC8*& aCID );
TInt RetrieveFlRights();
void ProcessDCFDataL( TPtrC8& aData );
void FillDCFBufferL( TPtrC8& aData );
void CompressDCFBuffer( const TInt aHowMuch );
TBool FindDCFHeader( const TDesC8& aString,
TUint& aOffset,
TUint& aLength );
HBufC8* EncryptDCFFieldLC( const TDesC8& aOldHeader );
// Prohibit copy constructor if not deriving from CBase.
CDRMMessageParser( const CDRMMessageParser& );
// Prohibit assigment operator if not deriving from CBase.
CDRMMessageParser& operator=( const CDRMMessageParser& );
public: // Data
TBool iDoPop;
protected: // Data
private: // Data
// Given stream
RWriteStream iOutputStream;
COma1DcfCreator* iDcfCreator;
// CD rights object.
HBufC8* iRightsData;
CDRMRights* iRightsObject;
// Boundary obtained from the given data.
HBufC8* iBoundary;
// Content type from the given data.
HBufC8* iContentType;
// Temporary store for DCF data.
HBufC8* iDCFBuffer;
// Current internal state.
TUint32 iState;
// DCF header sizes.
TUint32 iDCFHeaderSize[ 2 ];
// Input cache & counter.
TPtr8 iInputBuffer;
TInt iUsedFromInput;
// Temporary storage & counter
TPtrC8 iInputData;
public: // Friend classes
protected: // Friend classes
private: // Friend classes
};
#endif // CDRMMESSAGEPARSER_H
// End of File