/*

* 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 the License "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 class CFavouritesSession

*      

*

*/

// INCLUDE FILES

#include "FavouritesSrvDb.h"

#include "FavouritesSrvDbNotifier.h"

#include "FavouritesSrvDbIncremental.h"

#include "FavouritesSrvStream.h"

#include "FavouritesSrvFile.h"

#include "FavouritesSrvBuf.h"

#include "FavouritesBuf.h"

#include "FavouritesFilter.h"

#include "FavouritesSrvSession.h"

#include "FavouritesSrvSessionEntry.h"

#include "FavouritesDef.h"

#include "FavouritesMsg.h"

#include "FavouritesItemImplList.h"

#include "FavouritesUtil.h"

#include "UidMap.h"

#include <utf.h>

// CONSTANTS

/// Object list granularity.

LOCAL_D const TInt KFavouritesSrvSessionObjectGranularity = 4;

/// Uid list granularity.

LOCAL_D const TInt KFavouritesSrvSessionUidListGranularity = 4;

/// Granularity of AP map in RFS.

LOCAL_D const TInt KApMapGranularity = 4;

// Secure policy ID of the Faveng database files.

LOCAL_D const TUint KUidFavengDbPolicy = 0x101FD685;

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

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

// CFavouritesSession::NewL

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

//

CFavouritesSession* CFavouritesSession::NewL()

    {

    CFavouritesSession* sess = new (ELeave) CFavouritesSession();

    CleanupStack::PushL( sess );

    sess->ConstructL();

    CleanupStack::Pop();

    return sess;

    }

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

// CFavouritesSession::~CFavouritesSession

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

//

CFavouritesSession::~CFavouritesSession()

    {

    // Free all entries in reverse order:

    // Files -> Streams -> Incrementals -> Notifiers -> Databases.

    for ( TInt type = TFavouritesSessionEntry::EFile;

          type > TFavouritesSessionEntry::ENone;

          type--

        )

        {

        for ( TInt i = 0; i < iNumEntries; i++ )

            {

            if ( STATIC_CAST( TInt, iEntries[i].Type() ) == type )

                {

                iEntries[i].Release();

                }

            }

        }

    delete iEntries;

    iEntries = NULL;    // Safety code.

    iNumEntries = 0;    // Safety code.

    // In the case of -Secure Backup is in progress- 

    // the ActiveScheduler is not active the server does not exists at this point.

    if(CActiveScheduler::Current() != NULL)

    	{

    	FLOG(( _L("Server().SessionClosed()") ));

    	Server().SessionClosed();

    	}

    else

    	{

    	FLOG(( _L("CActiveScheduler::Current() == NULL") ));

    	}

    iDbs.Close();

    iFs.Close();

    }

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

// CFavouritesSession::CFavouritesSession

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

//

CFavouritesSession::CFavouritesSession()

: iEntries( NULL ), iNumEntries( 0 ), iChkNum( 1 )

    {

    }

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

// CFavouritesSession::ConstructL

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

//

void CFavouritesSession::ConstructL()

    {

    User::LeaveIfError( iFs.Connect() );

    User::LeaveIfError( iFs.SetSessionToPrivate( EDriveC ) );

    User::LeaveIfError( iDbs.Connect() );

       }

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

// CFavouritesSession::CountResources

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

//

TInt CFavouritesSession::CountResources()

    {

    TInt cnt( 0 );

    for ( TInt i = 0; i < iNumEntries; i++ )

        {

        if ( iEntries[i].Type() != TFavouritesSessionEntry::ENone )

            {

            cnt++;

            }

        }

    return cnt;

    }

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

// CFavouritesSession::ServiceL

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

//

void CFavouritesSession::ServiceL( const RMessage2& aMessage )

    {

	// Set received message in server so it can be used in cleanup when

    // server panics.

	Server().ReceivedMessage( aMessage );

    TInt ret( KErrNone );

    TFavouritesMsg msg( aMessage.Function() );

    if ( msg.IsNull() )

        {

        // Null handle -> session function.

        switch ( msg.Function() )

            {

            // Session functions.

            case EFavengResourceMarkStart:

                {

                ResourceCountMarkStart();

                break;

                }

            case EFavengResourceMarkEnd:

                {

                ResourceCountMarkEnd( aMessage );

                break;

                }

            case EFavengResourceCount:

                {

                ret = CountResources();

                break;

                }

            case EFavengDeleteDatabase:

                {

                TBuf<KFavouritesMaxName> name;

                TInt len = aMessage.GetDesLength( 0 );

                if ( len < 1 || len > KFavouritesMaxName )

                    {

                    User::Leave( KErrBadName );

                    }

                name.SetLength( len );

                aMessage.ReadL( 0, name );

                DatabaseDirL( name, iParse );

                TRAPD( err, DeleteDirL( iParse ) );

                // Map KErrPathNotFound error to KErrNotFound.

                if ( err == KErrPathNotFound )

                    {

                    err = KErrNotFound;

                    }

                User::LeaveIfError( err );

                break;

                }

            case EFavengSetHeapFailure:

                {

                User::__DbgSetAllocFail

                    (

                    RAllocator::EUser,

                    STATIC_CAST( RAllocator::TAllocFail, aMessage.Int0() ),

                    aMessage.Int1()

                    );

                break;

                }

            case EFavengOpenDatabase:

                {

                // Fixed for Bug id - JJUN-78RARE (FAVENGSRV crashes under IPC attack)

                // When client sends 8 bit descriptor input and favourite server always 

                // will attempt  on 16 bit RMessage2 read/write. So server will leave with 

                // KErrBadDescriptor and hence crash occurs. To avoid this crash,favourite 

                // server will attempt to  read/write on 8bit descriptor.

                HBufC *buf = HBufC::NewLC(KFavouritesMaxName);

                TPtr name(buf->Des());

                TInt len = aMessage.GetDesLength( 0 );

                if ( len < 1 || len > KFavouritesMaxName )

                    {

                    User::Leave( KErrBadName );

                    }

                name.SetLength( len );

                TInt err =  aMessage.Read( 0, name );

                if ( KErrBadDescriptor == err)   // Mismatch between 8 bit and 16 bit descriptors

	            {

            	    HBufC8 *buf8 = HBufC8::NewLC(KFavouritesMaxName);

            	    TPtr8 name8(buf8->Des());

                	name8.SetLength( len );

                	aMessage.ReadL( 0, name8 );

                	CnvUtfConverter::ConvertToUnicodeFromUtf8(name,name8);

                	CleanupStack::PopAndDestroy(/*buf8*/);

                }

                else

                {

                	User::LeaveIfError(err);

                }

                DatabaseDirL( name, iParse );

                TFavouritesHandle h = NewHandleL();

                Entry( h ) = *(CFavouritesSrvDb::NewL

                    ( iFs, iDbs, iParse.FullName(), name ));

                ret = h;

                CleanupStack::PopAndDestroy(/*buf*/);

                break;

                }

            case EFavengOpenStream:

                {

                ret = NewStreamL( *(HFavouritesSrvBuf::NewL()), aMessage );

                break;

                }

            default:

                {

                ret = KErrNotSupported;

                break;

                }

            }

        }

    else

        {

        // Object based functions.

        TFavouritesSessionEntry& e = EntryL( msg );

        switch( msg.Function() )

            {

            // Favourites Engine functions.

            case EFavengClose:

                {

                e.Release();

                break;

                };

            case EFavengIsDamaged:

                {

                ret = e.Database().IsDamagedL();

                break;

                }

            case EFavengRecover:

                {

                e.Database().RecoverL();

                break;

                }

            case EFavengCompact:

                {

                e.Database().CompactL();

                break;

                }

            case EFavengSize:

                {

                TPckgBuf<RDbDatabase::TSize> size;

                size() = e.Database().Size();

                aMessage.WriteL( 0, size );

                break;

                }

            case EFavengUpdateStats:

                {

                e.Database().UpdateStatsL();

                break;

                }

            case EFavengBegin:

                {

                if ( e.Database().InTransaction() )

                    {

                    Server().PanicClient( EFavouritesNestedTransaction );

                    }

                else

                    {

                    e.Database().BeginL( (TBool)aMessage.Int0() );

                    }

                break;

                }

            case EFavengCommit:

                {

                if ( e.Database().InTransaction() )

                    {

                    e.Database().CommitL();

                    }

                else

                    {

                    Server().PanicClient( EFavouritesNoTransaction );

                    }

                break;

                }

            case EFavengRollback:

                {

                if ( e.Database().InTransaction() )

                    {

                    e.Database().Rollback();

                    }

                else

                    {

                    Server().PanicClient( EFavouritesNoTransaction );

                    }

                break;

                }

            case EFavengGet:

                {

                RWriteStream stream( HFavouritesSrvBuf::NewLC() );

                CFavouritesItemImpl* item = CFavouritesItemImpl::NewLC();

                e.Database().GetL( aMessage.Int0(), *item );

                item->ExternalizeL( stream );

                stream.CommitL();

                CleanupStack::PopAndDestroy( item );

                CleanupStack::Pop();    // Stream buf; will be taken by stream.

                ret = NewStreamL( *(stream.Sink()), aMessage );

                break;

                }

            case EFavengGetAll:

                {

                TPckgBuf<TFavouritesFilter> filter;

                aMessage.ReadL( 0, filter );

                RWriteStream stream( HFavouritesSrvBuf::NewLC() );

                CFavouritesItemImplList* list =

                    new (ELeave) CFavouritesItemImplList();

                CleanupStack::PushL( list );

                e.Database().GetAllL( *list, filter() );

                list->ExternalizeL( stream );

                stream.CommitL();

                CleanupStack::PopAndDestroy( list );

                CleanupStack::Pop();    // Stream buf; will be taken by stream.

                ret = NewStreamL( *(stream.Sink()), aMessage );

                break;

                }

            case EFavengGetUids:

                {

                TPckgBuf<TFavouritesFilter> filter;

                aMessage.ReadL( 0, filter );

                RWriteStream stream( HFavouritesSrvBuf::NewLC() );

                CArrayFixFlat<TInt>* list = new (ELeave) CArrayFixFlat<TInt>

                    ( KFavouritesSrvSessionUidListGranularity );

                CleanupStack::PushL( list );

                e.Database().GetUidsL( *list, filter() );

                FavouritesUtil::ExternalizeL( *list, stream );

                stream.CommitL();

                CleanupStack::PopAndDestroy( list );

                CleanupStack::Pop();    // Stream buf; will be taken by stream.

                ret = NewStreamL( *(stream.Sink()), aMessage );

                break;

                }

            case EFavengPreferredUid:

                {

                TPckgBuf<TInt> uid;

                uid() = e.Database().PreferredUidL( aMessage.Int0() );

                aMessage.WriteL( 1, uid );

                break;

                }

            case EFavengDelete:

                {

                e.Database().DeleteL( aMessage.Int0() );

                break;

                }

            case EFavengUpdate:

                {

                MStreamBuf& buf = EntryL( TFavouritesHandle

                    ( aMessage.Int0() ) ).Stream().Host();

                RReadStream rs( &buf );

                CFavouritesItemImpl* item = CFavouritesItemImpl::NewLC();

                item->InternalizeL( rs );

                e.Database().UpdateL

                    ( *item, aMessage.Int1(), aMessage.Int2() );

                RWriteStream ws( &buf );

                item->ExternalizeUpdateDeltaL( ws );

                ws.CommitL();

                CleanupStack::PopAndDestroy( item );

                break;

                }

            case EFavengAdd:

                {

                MStreamBuf& buf = EntryL( TFavouritesHandle

                    ( aMessage.Int0() ) ).Stream().Host();

                RReadStream rs( &buf );

                CFavouritesItemImpl* item = CFavouritesItemImpl::NewLC();

                item->InternalizeL( rs );

                e.Database().AddL( *item, aMessage.Int1() );

                RWriteStream ws( &buf );

                item->ExternalizeUpdateDeltaL( ws );

                ws.CommitL();

                CleanupStack::PopAndDestroy( item );

                break;

                }

            case EFavengSetSpecialItem:

                {

                MStreamBuf& buf = EntryL( TFavouritesHandle

                    ( aMessage.Int0() ) ).Stream().Host();

                RReadStream rs( &buf );

                CFavouritesItemImpl* item = CFavouritesItemImpl::NewLC();

                item->InternalizeL( rs );

                e.Database().SetSpecialItemL( *item, aMessage.Int1() );

                RWriteStream ws( &buf );

                item->ExternalizeUpdateDeltaL( ws );

                ws.CommitL();

                CleanupStack::PopAndDestroy( item );

                break;

                }

            case EFavengSetFactoryItem:

                {

                e.Database().SetFactoryItemL

                                        ( aMessage.Int0(), aMessage.Int1() );

                break;

                }

            case EFavengSetReadOnly:

                {

                e.Database().SetReadOnlyL

                                        ( aMessage.Int0(), aMessage.Int1() );

                break;

                }

            case EFavengSetModified:

                {

                e.Database().SetModifiedL( aMessage.Int0(),

                    TTime( MAKE_TINT64( aMessage.Int1(), aMessage.Int2() ) ) );

                break;

                }

            case EFavengSetPreferredUid:

                {

                e.Database().SetPreferredUidL

                                        ( aMessage.Int0(), aMessage.Int1() );

                break;

                }

            case EFavengItemExists:

                {

                ret = e.Database().ItemExistsL( aMessage.Int0() );

                break;

                }

            case EFavengFolderExists:

                {

                ret = e.Database().FolderExistsL( aMessage.Int0() );

                break;

                }

            case EFavengCount:

                {

                TPckgBuf<TFavouritesFilter> filter;

                aMessage.ReadL( 0, filter );

                ret = e.Database().CountL( filter() );

                break;

                }

            case EFavengSetData:

                {

                MStreamBuf& buf = EntryL( TFavouritesHandle

                    ( aMessage.Int0() ) ).Stream().Host();

                e.Database().SetDataL( aMessage.Int1(), buf );

                break;

                }

            case EFavengGetData:

                {

                RWriteStream stream( HFavouritesSrvBuf::NewLC() );

                e.Database().GetDataL

                    ( aMessage.Int0(), *(stream.Sink()) );

                stream.CommitL();

                CleanupStack::Pop();    // Stream buf; will be taken by stream.

                ret = NewStreamL( *(stream.Sink()), aMessage );

                break;

                }

            case EFavengSetBrowserData: