/*

* Copyright (c) 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:  WMDRM Server implementation

*

*/

#include <ezlib.h>

#include <e32math.h>

#include <symmetric.h>

#include <bacntf.h>

#include <random.h>

#include "wmdrmkeystorage.h"

#include "slotdata.h"

#include "wmdrmserver.h"

#include "slotdatacache.h"

#include "slotenumeratorcache.h"

#include "wmdrmdb.h"

#define _LOGGING_FILE L"wmdrmserver.txt"

#include "flogger.h"

#include "logfn.h"

#ifdef __WINSCW__

_LIT8( KDummyKey, "0123456789012345" );

#endif

CSlotData* CSlotData::NewL( 

    CWmDrmServer* aServer, 

    const TDesC8& aStore,

    const TDesC8& aNamespace,

    const TDesC8& aHashKey,

    const TDesC8& aUniqueKey )

    {

    LOGFN( "CSlotData::NewL" );

    CSlotData* self = new (ELeave) CSlotData( aServer,

                                              aStore,

                                              aNamespace,

                                              aHashKey,

                                              aUniqueKey );

    return self;

    }

CSlotData::CSlotData( 

    CWmDrmServer* aServer, 

    const TDesC8& aStore,

    const TDesC8& aNamespace,

    const TDesC8& aHashKey,

    const TDesC8& aUniqueKey ) : iServer( aServer ),

                                 iDirty( EFalse ),

                                 iExists( ETrue ),

                                 iReferences( 0 )

    {

    LOGFN( "CSlotData::CSlotData" );

    iStore.Copy( aStore );

    iNamespace.Copy( aNamespace );

    LOG( iNamespace );

    iHashKey.Copy( aHashKey );

    LOG( iHashKey );

    iUniqueKey.Copy( aUniqueKey );

    LOG( iUniqueKey );

    }

CSlotData::~CSlotData()

    {

    LOGFN( "CSlotData::~CSlotData" );

    //FlushL();

    iData.Close();

    }

void CSlotData::CreateL( TInt& aInitialSize )

    {

    LOGFN( "CSlotData::CreateL" );

    LOG2( "Size: %d", aInitialSize );

    LOG1( "*** Create record" );

    if ( aInitialSize > KMaxSlotSize )

        {

        User::Leave( KErrArgument );

        }

	iServer->Db()->CreateRecordL( iStore, iNamespace, iHashKey, iUniqueKey, aInitialSize );

    iData.Close();

    iData.CreateL( aInitialSize );

    iData.SetLength( iData.MaxLength() );

    iData.FillZ();

    iDirty = ETrue;

    iExists = ETrue;

    iOpen = ETrue;

	iServer->EnumeratorCache()->AddEntryL( iStore, iNamespace, iHashKey, iUniqueKey );

    //FlushL();

    }

TInt CSlotData::OpenL( TInt& aCurrentSize )

    {

    TInt r = KErrNone;

    RBuf8 compressedData;

    TUint32 uncompressedSize;

    TPckg<TUint32> pckg( uncompressedSize );

    RBuf8 encryptedData;

    CBufferedDecryptor* decryptor = NULL;

    CModeCBCDecryptor* cbcDecryptor = NULL;

    CAESDecryptor* aesDecryptor = NULL;

    CPaddingPKCS7* padding = NULL;

    TInt size;

    LOGFN( "CSlotData::OpenL" );

	LOG3( "Size: %d, data size: %d", aCurrentSize, iData.Length() );

	if ( !IsOpen() )

	    {

	    if ( iExists )

	        {

    	    LOG1( "*** Opening record" );

            TRAP( r, iServer->Db()->ReadRecordL( iStore, iNamespace, iHashKey, iUniqueKey ) );

    	    if ( !r )

    	        {

    	        TBuf8<KAESKeyLength> key;

    	        TBuf8<KAESKeyLength> iv;

                RBuf8 buffer;

                iServer->Db()->GetDataSizeL( size );

                LOG2( "Record size: %d", size );

                if( size <= 0 )

                    {

                    iServer->Db()->DeleteData();

                    iServer->Db()->DeleteRecordL( iStore, iNamespace, iHashKey, iUniqueKey );

                    User::Leave( KErrArgument );

                    }

                encryptedData.CreateL( size - sizeof( TUint32 ) - KAESKeyLength );

                encryptedData.CleanupClosePushL();

                compressedData.CreateL( size - sizeof( TUint32 ) - KAESKeyLength );

                compressedData.CleanupClosePushL();

                buffer.CreateL( size );

                buffer.CleanupClosePushL();

                iServer->Db()->ReadDataL( buffer );

                //LOGHEX( buffer.Ptr(), buffer.Size() );

                pckg.Copy( buffer.Left( sizeof( TUint32 ) ) );

                LOG2( "Uncompressed size: %d", uncompressedSize );

                iv.Copy( buffer.Mid ( sizeof( TUint32 ), KAESKeyLength ) );

                //LOGHEX( iv.Ptr(), iv.Size () );

                encryptedData.Copy( buffer.Right( size - sizeof( TUint32 ) - KAESKeyLength ) );

                //LOGHEX( encryptedData.Ptr(), encryptedData.Size() );

#ifdef __WINSCW__

                key.Copy( KDummyKey );

#else

                iServer->Cache()->iKeyStorage->GetDeviceSpecificKeyL( key );

#endif

                aesDecryptor = CAESDecryptor::NewL( key );

                CleanupStack::PushL( aesDecryptor );

                cbcDecryptor = CModeCBCDecryptor::NewL( aesDecryptor, iv );

                CleanupStack::Pop( aesDecryptor );

                CleanupStack::PushL( cbcDecryptor );

                padding = CPaddingPKCS7::NewL( KAESKeyLength );

                CleanupStack::PushL( padding );

                decryptor = CBufferedDecryptor::NewL( cbcDecryptor, padding );

                CleanupStack::Pop( 2, cbcDecryptor ); //padding, cbcDecryptor

                CleanupStack::PushL( decryptor );

                decryptor->ProcessFinalL( encryptedData, compressedData );

                iData.Close();

                iData.CreateMaxL( uncompressedSize );

                User::LeaveIfError( uncompress( const_cast<TUint8*>( iData.Ptr() ), &uncompressedSize, 

                                                                     compressedData.Ptr(), compressedData.Size() ) );

                CleanupStack::PopAndDestroy( 4, &encryptedData ); //decryptor, buffer, compressedData, encryptedData

                TRandom::RandomL( key );

                iOpen = ETrue;

                }

            else 

                {

                iExists = EFalse;

                if ( r == KErrPathNotFound )

                    {

                    r = KErrNotFound;

                    }

                }

            }

        else

            {

            r = KErrNotFound;

            }

        }

	else

	    {

	    LOG1( "Record already open" );

	    }

    aCurrentSize = iData.Length();

    return r;

    }

TInt CSlotData::Read( TInt aPosition, TDes8& aBuffer )

    {

    TInt r = KErrNone;

    TInt length;

    LOGFNR( "CSlotData::Read", r );

	if ( IsOpen() )

	    {

	    length = Min( aBuffer.MaxLength(), iData.Length() - aPosition );

	    LOG4( "Read %d bytes from %d, buffer size: %d", length, aPosition, aBuffer.MaxLength() );

        aBuffer.Copy( iData.Mid( aPosition, length ) );

//        LOGHEX( aBuffer.Ptr(), aBuffer.Size() );

        }

    else

        {

        r = KErrNotReady;

        iServer->Cache()->Release( this );

        }

    return r;

    }

TInt CSlotData::WriteL( TInt aPosition, const TDesC8& aBuffer )

    {

    TInt r = KErrNone;

	LOGFNR( "CSlotData::Write", r );

	if ( IsOpen() )

	    {

	    LOG3( "Write %d bytes at %d", aBuffer.Length(), aPosition );

//        LOGHEX( aBuffer.Ptr(), aBuffer.Size() );

	    if ( aBuffer.Length() + aPosition > iData.Length() )

	        {

	        iData.ReAllocL( aBuffer.Length() + aPosition );

	        iData.SetLength( iData.MaxLength() );

	        }

	    iData.Replace( aPosition, aBuffer.Length(), aBuffer );

	    iDirty = ETrue;

	    FlushL();

        }

    else

        {

        r = KErrNotReady;

        iServer->Cache()->Release( this );

        }

    return r;

    }

TInt CSlotData::ResizeL( TInt aNewSize )

    {

    TInt r = KErrNone;

	LOGFNR( "CSlotData::Resize", r );

	if ( IsOpen() )

        {

    	LOG2( "New size: %d", aNewSize );

    	if ( aNewSize > iData.Size() )

    	    {

            iData.ReAllocL( aNewSize );

            }

        iData.SetLength( aNewSize );

        }

    else

        {

        r = KErrNotReady;

        iServer->Cache()->Release( this );

        }

    return r;

    }

TInt CSlotData::DeleteL()

    {

    TInt r = KErrNone;

	LOGFNR( "CSlotData::Delete", r );

	iServer->EnumeratorCache()->DeleteEntryL( iStore, iNamespace, iHashKey, iUniqueKey );

	r = iServer->Cache()->Delete( this );

	return r;

    }

TInt CSlotData::Size()

    {

    TInt r;

    LOGFNR( "CSlotData::Size", r );

	if ( IsOpen() )

	    {

	    r = iData.Length();

	    }

    else

        {

        r = KErrNotReady;

        iServer->Cache()->Release( this );

        }

	return r;

    }

void CSlotData::Close()

    {

    LOGFN( "CSlotData::Close" );

    iServer->Cache()->Release( this );

    }

void CSlotData::CloseFile()

    {

    LOGFN( "CSlotData::CloseFile" );

    iOpen = EFalse;

    }

void CSlotData::FlushL()

    {

    LOGFN( "CSlotData::FlushL" );

    __UHEAP_MARK;

	if ( IsOpen() && iDirty )

	    {

        TBuf8<KAESKeyLength> iv;

        TBuf8<KAESKeyLength> key;

        TInt size = iData.Size();

        RBuf8 compressedData;

        TUint32 compressedDataLen = size + size / 10 + 12;

        TUint8* compressedDataPtr;

        RBuf8 encryptedData;

        CBufferedEncryptor* encryptor = NULL;

        CModeCBCEncryptor* cbcEncryptor = NULL;

        CAESEncryptor* aesEncryptor = NULL;

        CPaddingPKCS7* padding = NULL;

        RBuf8 buffer;

        compressedData.CreateL( compressedDataLen );

        compressedData.CleanupClosePushL();

        compressedDataPtr = const_cast<TUint8*>( compressedData.Ptr() );

        User::LeaveIfError( compress( compressedDataPtr, &compressedDataLen, iData.Ptr(), size ) );

        compressedData.SetLength( compressedDataLen );

        encryptedData.CreateL( compressedData.Size() + 2 * KAESKeyLength );

        encryptedData.CleanupClosePushL();

        iv.SetLength( KAESKeyLength );

        TRandom::RandomL( iv );

#ifdef __WINSCW__

        key.Copy( KDummyKey );

#else

        iServer->Cache()->iKeyStorage->GetDeviceSpecificKeyL( key );

#endif

        aesEncryptor = CAESEncryptor::NewL( key );

        CleanupStack::PushL( aesEncryptor );

        cbcEncryptor = CModeCBCEncryptor::NewL( aesEncryptor, iv );

        CleanupStack::Pop( aesEncryptor );

        CleanupStack::PushL( cbcEncryptor );

        padding = CPaddingPKCS7::NewL( KAESKeyLength );

        CleanupStack::PushL( padding );

        encryptor = CBufferedEncryptor::NewL( cbcEncryptor, padding );

        CleanupStack::Pop( 2, cbcEncryptor ); //padding, cbcEncryptor

        CleanupStack::PushL( encryptor );

        encryptor->ProcessFinalL( compressedData, encryptedData );

        LOG1( "*** Write record" );

        LOG3( "Uncompressed size: %d, compresseded size: %d", size, encryptedData.Size() );

        buffer.CreateL( sizeof( TUint32 ) + iv.Size() + encryptedData.Size() );

        buffer.CleanupClosePushL();

        buffer.Append( TPckgC<TUint32>( size ) );

        buffer.Append( iv );

        buffer.Append( encryptedData );

        //LOGHEX( buffer.Ptr(), buffer.Size() );

        iServer->Db()->WriteDataL( iStore, iNamespace, iHashKey, iUniqueKey, buffer );

        iDirty = EFalse;

        TRandom::RandomL( key );

        CleanupStack::PopAndDestroy( 4, &compressedData ); //buffer, encryptor, encryptedData, compressedData

        }

    __UHEAP_MARKEND;        

    }

TBool CSlotData::IsOpen()

    {

    return iOpen;

    }