/*

* Copyright (c) 2002-2005 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: subsession class for operations related to local access.

*

*

*/

#include <e32base.h>

#include <s32mem.h>

#include <epos_poslmdatabaseutility.h>

#include <epos_cposlmdiskutilities.h>

#include <epos_cposlmlocaldbaccess.h>

#include "epos_lmdebug.h"

#include "EPos_CPosLmServer.h"

#include "EPos_CPosLmOperationManager.h"

#include "EPos_PosLmServerCommon.h"

#include "EPos_LmServerGlobal.h"

#include "EPos_LandmarksServerPanics.h"

#include "EPos_CPosLmEventHandler.h"

#include "EPos_PosLmDatabaseManager.h"

#include "epos_cposlmindexmanager.h"

#include "EPos_CPosLmNameIndex.h"

#include "EPos_CPosLmActiveCompacter.h"

#include "EPos_CPosLmLocalAccessSubsession.h"

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

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

//

CPosLmLocalAccessSubsession::CPosLmLocalAccessSubsession(

    CPosLmServer* aLmServer) :

    CPosLmSubsessionBase(EPosLocalAccessSubsession, aLmServer)

    {

    }

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

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

//

void CPosLmLocalAccessSubsession::ConstructL()

    {

    }

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

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

//

CPosLmLocalAccessSubsession* CPosLmLocalAccessSubsession::NewLC(

    CPosLmServer* aLmServer)

    {

    CPosLmLocalAccessSubsession* self =

        new (ELeave) CPosLmLocalAccessSubsession(aLmServer);

    CleanupClosePushL(*self);

    self->ConstructL();

    return self;

    }

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

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

//

CPosLmLocalAccessSubsession::~CPosLmLocalAccessSubsession()

    {

    delete iCompacter;

    delete iDbAccess;

    delete iEventHandler;

    // release database

    iHasWriteLock = EFalse;

    iNoOfReadLocks = 0;

    if ( iUsingNameIndex && Server() && iDbUri )

        {

        Server()->IndexManager().RemoveIndexUser( *iDbUri );

        iUsingNameIndex = EFalse;

        }

    delete iDbUri;

    }

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

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

//

TBool CPosLmLocalAccessSubsession::HasWriteLock( const TDesC& aUri )

    {

    if (iHasWriteLock && aUri == *iDbUri)

        {

        return ETrue;

        }

    return EFalse;

    }

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

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

//

TBool CPosLmLocalAccessSubsession::HasAnyLock( const TDesC& aUri ) 

    {

    if ((iHasWriteLock || iNoOfReadLocks > 0) && aUri == *iDbUri)

        {

        return ETrue;

        }

    return EFalse;

    }

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

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

//

void CPosLmLocalAccessSubsession::HandleOperationEventL(

    TPosLmEvent aEvent,

    const TDesC& aUri,

    TBool aCheckUri)

    {

    // Check if the event is dedicated to the database, which this subsession is

    // connected to.

    if (!aCheckUri && iEventHandler && iDbUri ||

        iEventHandler && iDbUri && aUri.Compare(*iDbUri) == 0)

        {

        iEventHandler->HandleIncomingEventL(aEvent);

        }

    }

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

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

//

void CPosLmLocalAccessSubsession::CompleteOutstandingEventRequest(

    TInt aError)

    {

    if (iEventHandler)

        {

        iEventHandler->CompleteAnyOutStandingRequest(aError);

        }

    }

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

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

//

void CPosLmLocalAccessSubsession::ReleaseCompactLock()

    {

    delete iCompacter;

    iCompacter = NULL;

    iHasWriteLock = EFalse;

    }

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

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

//

void CPosLmLocalAccessSubsession::ServiceL(

    const RMessage2& aMessage)

    {

#if 0 // #ifdef _DEBUG

    RThread client;

    aMessage.Client( client );

    LOG3("LocalSession::ServiceL in: function %d (client SID 0x%X, thread 0x%X)",

        aMessage.Function(), aMessage.SecureId().iId, client.Id() );

#endif    

    switch (aMessage.Function())

        {

        case EPosLmServerRegisterSession:

            if (iDbUri)

                {

                PanicClient(aMessage, EPosClientHasAlreadyRegistered);

                return;

                }

            RegisterUriL(aMessage);

            break;

        case EPosLmServerInitializeSync:

        case EPosLmServerInitializeAsync:

        case EPosLmServerInitializeCancel:

        case EPosLmServerLangSwitchSync:

        case EPosLmServerLangSwitchAsync:

        case EPosLmServerLangSwitchCancel:

        case EPosLmServerRecoverSync:

        case EPosLmServerRecoverAsync:

        case EPosLmServerRecoverCancel:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            Server()->OperationManagerL(aMessage.Function())->AddRequestL(

                aMessage, *iDbUri, this);

            break;

        case EPosLmServerDbLock:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            DatabaseLockL(aMessage);

            break;

        case EPosLmServerIndexTransaction:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            HandleDataTransactionL(aMessage);

            break;

        case EPosLmServerReportLmEvent:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            ForwardEventToAllSessionsL(aMessage);

            break;

        case EPosLmServerUpdateNameIndex:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            HandleUpdateLandmarkIndexL( aMessage );

            break;

        case EPosLmServerListenForLmEvent:

            // No check of iDbUri needed here

            User::LeaveIfError(Server()->StartSettingsListenerIfNeeded());

            if (!iEventHandler)

                {

                iEventHandler = CPosLmEventHandler::NewL();

                }

            iEventHandler->HandleRequestForEventL(aMessage);

            break;

        case EPosLmServerCancelListenForLmEvent:

            // No check of iDbUri needed here

            delete iEventHandler;

            iEventHandler = NULL;

            LmServerGlobal::Complete(aMessage, KErrNone);

            break;

        case EPosLmServerCreateDefaultDb:

            // No check of iDbUri needed here

            CreateDefaultDatabaseL(aMessage);

            break;

        case EPosLmServerOpenNameIndex:

        case EPosLmServerCloseNameIndex:

            if ( !iDbUri )

                {

                PanicClient( aMessage, EPosClientHasNotRegistered );

                return;

                }

            HandleUseNameIndexL( aMessage );

            break;

        case EPosLmServerReadSortedIds:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            HandleReadSortedIdsL( aMessage );

            break;

        case EPosLmServerReadNameIndex:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            HandleReadSortedLandmarksL( aMessage );

            break;

        case EPosLmServerNameIndexStatus:

            if (!iDbUri)

                {

                PanicClient(aMessage, EPosClientHasNotRegistered);

                return;

                }

            HandleNameIndexStatusL( aMessage );

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

#if 0 // #ifdef _DEBUG

    LOG("LocalSession::ServiceL out");

#endif

    }

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

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

//

void CPosLmLocalAccessSubsession::RegisterUriL(

    const RMessage2& aMessage)

    {

    // Validate length of client message.

    TInt desLength = aMessage.GetDesLength(KPosLmServerUriArg);

    if (desLength < 0)

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        return;

        }

    // Read URI from client message.

    HBufC* dbUri = HBufC::NewLC(desLength);

    TPtr uriPtr = dbUri->Des();

    if (LmServerGlobal::Read(aMessage, KPosLmServerUriArg, uriPtr) != KErrNone)

        {

        CleanupStack::PopAndDestroy(dbUri);

        return;

        }

    // Lowercase the URI to be able to match different cases of the same URI.

    uriPtr.LowerCase();

    TInt err = PosLmDatabaseUtility::ValidateDatabaseUri(uriPtr);

    if (err == KErrArgument)

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        CleanupStack::PopAndDestroy(dbUri);

        return;

        }

    else

        {

        User::LeaveIfError(err);

        }

    // iDbUri is set last as it is used to validate if the uri has been

    // registered properly.

    CleanupStack::Pop(dbUri);

    iDbUri = dbUri;

    LmServerGlobal::Complete(aMessage, KErrNone);

    }

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

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

//

void CPosLmLocalAccessSubsession::DatabaseLockL(

    const RMessage2& aMessage)

    {

    TBool setLockOn = static_cast<TBool>(aMessage.Int0());

    TBool writeLock = static_cast<TBool>(aMessage.Int1());

    if (setLockOn)

        {

        if (!Server()->CanAcquireLock(writeLock, *iDbUri))

            {

            User::Leave(KErrLocked);

            }

        if (writeLock)

            {

            iHasWriteLock = ETrue;

            }

        else

            {

            iNoOfReadLocks++;

            }

        }

    else if (writeLock)

        {

        if (!iHasWriteLock)

            {

            PanicClient(aMessage, EPosLmDbNotLocked);

            return;

            }

        iHasWriteLock = EFalse;

        }

    else

        {

        if (iNoOfReadLocks == 0)

            {

            PanicClient(aMessage, EPosLmDbNotLocked);

            return;

            }

        iNoOfReadLocks--;

        }

    LmServerGlobal::Complete(aMessage, KErrNone);

    if (!setLockOn && writeLock) // releasing write lock

        {

        TRAP_IGNORE( CompactIfNeededL() );

        }

    }

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

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

//

void CPosLmLocalAccessSubsession::HandleDataTransactionL( const RMessage2& aMessage )

    {

    if ( Server()->IndexManager().Find( *iDbUri ) >= 0 )

        {

        CPosLmNameIndex& index = Server()->IndexManager().Index( *iDbUri );

        User::LeaveIfError( index.Status() );

        switch( aMessage.Int0() )

            {

            case EPosLmServerTransactionStart:

                index.StartTransaction();

                break;

            case EPosLmServerTransactionCommit:

                index.CommitTransaction();

                break;

            case EPosLmServerTransactionRollback:

                index.RollbackTransaction();

                break;

            default:

                PanicClient( aMessage, EPosUnableToReadOrWriteDataToClient );

            }

        }

    LmServerGlobal::Complete( aMessage, KErrNone );

    }

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

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

//

void CPosLmLocalAccessSubsession::ForwardEventToAllSessionsL(

    const RMessage2& aMessage)

    {

    TPckgBuf<TPosLmEvent> event;

    TInt desLength = aMessage.GetDesLength(KPosLmServerEventArg);

    if (desLength != event.Length())

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        return;

        }

    if (LmServerGlobal::Read(aMessage, KPosLmServerEventArg, event) != KErrNone)

        {

        return;

        }

    // Validate that the event type is a valid enum value.

    TPosLmEventType eventType = event().iEventType;

    if (!(eventType == EPosLmEventUnknownChanges ||

        eventType == EPosLmEventNewDefaultDatabaseLocation ||

        eventType == EPosLmEventMediaRemoved ||

        (eventType >= EPosLmEventLandmarkUnknownChanges &&

        eventType <= EPosLmEventLandmarkUpdated) ||

        (eventType >= EPosLmEventCategoryUnknownChanges &&

        eventType <= EPosLmEventCategoryUpdated)))

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        return;

        }

    Server()->ForwardEventToAllSessionsL(event(), *iDbUri, ETrue);

    LmServerGlobal::Complete(aMessage, KErrNone);

    }

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

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

//

void CPosLmLocalAccessSubsession::CreateDefaultDatabaseL(

    const RMessage2& aMessage)

    {

    TInt desLength = aMessage.GetDesLength(KPosLmServerUriArg);

    if (desLength < 0)

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        return;

        }

    HBufC* msgUri = HBufC::NewLC(desLength);

    TPtr uriPtr = msgUri->Des();

    if (LmServerGlobal::Read(aMessage, KPosLmServerUriArg, uriPtr) == KErrNone)

        {

        HBufC* uri = PosLmDatabaseUtility::CreateDatabaseUriL(*msgUri);

        CleanupStack::PushL(uri);

        // To remove a warning, the event must be default constructed.

        TPosLmDatabaseEvent event =

            {

            EPosLmDbDatabaseRegistered,

            {0,0,0,0,0,0,0,0}

            };

        CheckDiskSizeL(*uri);

        TPckgBuf<TBool> replaceDb;

        desLength = aMessage.GetDesLength(KPosLmServerDbReplaceArg);

        if (desLength != replaceDb.Length())

            {

            PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

            CleanupStack::PopAndDestroy(2, msgUri);

            return;

            }

        if (LmServerGlobal::Read(

            aMessage, KPosLmServerDbReplaceArg, replaceDb) != KErrNone)

            {

            CleanupStack::PopAndDestroy(2, msgUri);

            return;

            }

        PosLmDatabaseManager::CreateDatabaseL(uri->Des(), ETrue, replaceDb());

        Server()->ForwardEventToAllSessionsL(event, uri->Des());

        LmServerGlobal::Complete(aMessage, KErrNone);

        CleanupStack::PopAndDestroy(uri);

        }

    CleanupStack::PopAndDestroy(msgUri);

    }

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

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

//

void CPosLmLocalAccessSubsession::CheckDiskSizeL(

    const TDesC& aUri)

    {

    CPosLmDiskUtilities* diskUtilities = CPosLmDiskUtilities::NewL();

    CleanupStack::PushL(diskUtilities);

    diskUtilities->DiskSpaceBelowCriticalLevelL(

        diskUtilities->EstimatedDiskSizeOfEmptyDatabase(),

        (aUri)[KPosLocalDbFileProtocol().Length()]);

    CleanupStack::PopAndDestroy(diskUtilities);

    }

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

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

//

void CPosLmLocalAccessSubsession::CompactIfNeededL()

    {