/*

* Copyright (c) 2009 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:   data struct for all volumes

*

*/

#include <sysutil.h>

#include <bautils.h>

#include <rsfwmountman.h>

#include <rsfwmountentry.h>

#include "rsfwvolumetable.h"

#include "rsfwvolume.h"

#include "rsfwinterface.h"

#include "rsfwmountstatemachine.h"

#include "rsfwfileentry.h"

#include "rsfwfiletable.h"

#include "rsfwconfig.h"

#include "rsfwfileengine.h"

#include "rsfwrfeserver.h"

#include "rsfwmountstore.h"

#include "rsfwwaitnotemanager.h"

#include "rsfwdormantmountloader.h"

#include "mdebug.h"

//CONSTANTS

_LIT(KRsfwLruFileName, "lru.dat");

_LIT(KRsfwRestorePendingMark, "rsfwmetadatarestorepending.dat");

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

// CRsfwVolumeTable::NewL

//

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

//

CRsfwVolumeTable* CRsfwVolumeTable::NewL(CRsfwRfeServer* aRfeServer,

                                 CRsfwConfig* aRsfwConfig)

    {

    CRsfwVolumeTable* self = new (ELeave) CRsfwVolumeTable;

    DEBUGSTRING(("CRsfwVolumeTable: in NewL 0x%x", self));

    CleanupStack::PushL(self);

    self->ConstructL(aRfeServer, aRsfwConfig);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwVolumeTable::RestoreDormantMountsL

//

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

//

void CRsfwVolumeTable::RestoreDormantMountsL() 

    {

    DEBUGSTRING(("CRsfwVolumeTable::RestoreDormantMountsL enter"));

    // Currently, we always enable persistence (used to be configurrable)

    iPermanence = ETrue;

    if (iPermanence)

        {

        // if restoring permanent state causes RFE panic, we must delete 

        // the old permanent metadata and skip restoring it

        // otherwise RFE will just crash every time

        // Strategy is to add a file that tells that the process is ongoing.

        // If it is not able to finish successfully, we can conclude that there was a crash

        // marker is deleted from CRsfwDormantMountLoader, when we have succesfully also checked for dirty files

        TBool internalize = CheckAndAddProcessStartMarker();

        if (internalize) 

            {

            WillLRUPriorityListBeInternalized();

            RestoreVolumesL();

            InternalizeLRUPriorityListL();

            }

        else 

            {

            CleanupCorruptedCacheL();

            }

        }

    iDormantMountRestorePending = EFalse;   

    DEBUGSTRING(("CRsfwVolumeTable::RestoreDormantMountsL exit"));

    }

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

// CRsfwVolumeTable::ConstructL

//

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

//

void CRsfwVolumeTable::ConstructL(CRsfwRfeServer* aRfeServer, CRsfwConfig* aRsfwConfig)

    {

    iRfeServer = aRfeServer;

    iRsfwConfig = aRsfwConfig;

    iAllEnginesIdle = ETrue;

    // set some local pointers for commonly used variable from CRsfwRfeServer::Env()

    iFs = CRsfwRfeServer::Env()->iFs;

    iCacheRoot = &(CRsfwRfeServer::Env()->iCacheRoot);

    TInt err = iRsfwConfig->Get(RsfwConfigKeys::KMaxCacheSize,

                                iMaxCacheSize);

    if (err != KErrNone)

        {

        iMaxCacheSize = KDefaultMaxCacheSize;

        }

    err = iRsfwConfig->Get(RsfwConfigKeys::KMaxEntryCount,

                           iMaxEntryCount);

    if (err != KErrNone)

        {

        iMaxEntryCount = KDefaultMaxEntryCount;

        }

    HBufC* confItem = HBufC::NewLC(KMaxRsfwConfItemLength);

    TPtr confItemPtr = confItem->Des();

    // global wait notes manager class

    // must be created before restoring  the volumes

    iWaitNoteManager = CRsfwWaitNoteManager::NewL();

    RestoreDormantMountsL();

    err = iRsfwConfig->Get(RsfwConfigKeys::KFileCacheValidity,

                           iFileCacheTimeout);

    if (err)

        {

        iFileCacheTimeout = KDefaultCacheValidity;

        }

    err = iRsfwConfig->Get(RsfwConfigKeys::KDirCacheValidity,

                           iDirCacheTimeout);

    if (err)

        {

        iDirCacheTimeout = KDefaultDirCacheValidity;

        }

    err = iRsfwConfig->Get(RsfwConfigKeys::KRecognizerLimit,

                           iRecognizerLimit);

    if (err)

        {

        iRecognizerLimit = KDefaultRecognizerLimit;

        }

    err = iRsfwConfig->Get(RsfwConfigKeys::KCachingMode, confItemPtr);

    if (err == KErrNone)

        {

        TLex lex(confItemPtr);

        TChar firstChar = lex.Get();

        firstChar.UpperCase();

        switch (firstChar)

            {

        case 'W':

            iCachingMode = EWholeFileCaching;

            break;

        case 'F':

            iCachingMode = EFullIfa;

            break;

        case 'M':

        default:

            iCachingMode = EMetadataIfa;

            break;

            }

        }

    else

        {

        // caching mode configuration entry not found

        iCachingMode = EMetadataIfa;

        }

    if (iCachingMode != EWholeFileCaching)

        {

        GetMimeTypeSpecificLimits();

        }

    err = iRsfwConfig->Get(RsfwConfigKeys::KInactivityTimeout,

                           iInactivityTimeout);

    if (err)

        {

        iInactivityTimeout = KDefaultInactivityTimeout;

        }

    CleanupStack::PopAndDestroy(confItem);

    iMountStore = CRsfwMountStore::NewL(NULL);

    RProperty::Define(KRfeServerSecureUid,

                      ERsfwPSKeyConnect,

                      RProperty::EByteArray,

                      KMaxDrives);

    iMountStateProperty.Attach(KRfeServerSecureUid,

                               ERsfwPSKeyConnect);

   // this restores the dormant mounts asynchrously shortly after the server has started

    iDormantMountLoader = CRsfwDormantMountLoader::NewL(this);

    iDormantMountRestorePending = ETrue;

    }

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

// CRsfwVolumeTable::~CRsfwVolumeTable

//

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

//

CRsfwVolumeTable::~CRsfwVolumeTable()

    {

    // save LRU list to the file

    ExternalizeLRUPriorityList();

    TInt i;

    DEBUGSTRING(("Deleting all volumes"));

    for (i = 0; i < KMaxVolumes; i++)

        {

        if (iVolumes[i])

            {

            delete iVolumes[i];

            }

        }

    delete iMountStore;

    iMountStateProperty.Close();

    if (iWaitNoteManager)

    	{

    	delete iWaitNoteManager;

    	}

    if (iDormantMountLoader)

    	{

    	delete iDormantMountLoader;

    	}    	

    }

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

// CRsfwVolumeTable::DispatchL

//

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

//

void CRsfwVolumeTable::DispatchL(TAny* aIp, TAny* aOp)

    {

    TRfeInArgs* ip = reinterpret_cast<TRfeInArgs*>(aIp);

    TRfeOutArgs* op = reinterpret_cast<TRfeOutArgs*>(aOp);

    CRsfwFileEngine* fileEngine = NULL;

    TInt volumeId;

    if(ip->iOpCode == EFsRoot)

        {

        volumeId = iLastVolumeId;

        // boot  - assume that ROOT

        // immediately follows after MountL()

        if (volumeId)

            {

            DEBUGSTRING(("Volume: acquired engine %d", volumeId));

            CRsfwVolume* volume = iVolumes[volumeId];

            if (volume)

                {

                fileEngine = volume->iFileEngine;

                }

            }

        }

    else

        {

        // iFid is always in the same position in the messages

        volumeId = static_cast<TRfeLookupInArgs*>(ip)->iFid.iVolumeId;

        CRsfwVolume* volume = VolumeByVolumeId(volumeId);

        if (volume)

            {

            fileEngine = volume->iFileEngine;

            }

        }

    if (fileEngine)

        {

        fileEngine->DispatchL(*ip, *op);

        }

    else

        {

        DEBUGSTRING(("Volume: no engine for %d", volumeId));

        User::Leave(KErrNotReady);

        }

    }

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

// CRsfwVolumeTable::VolumeIdByDriveLetter

//

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

//

TInt CRsfwVolumeTable::VolumeIdByDriveLetter(TChar aDriveLetter)

    {

    TInt driveNumber;

    iFs.CharToDrive(aDriveLetter, driveNumber);

    if (driveNumber < 0) // note that 0 = EDriveA is allowed

        {

        driveNumber = KErrNotFound;

        }

    return driveNumber;

    }

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

// CRsfwVolumeTable::VolumeByVolumeId

//

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

//

CRsfwVolume* CRsfwVolumeTable::VolumeByVolumeId(TInt aVolumeId)

    {

    if ((aVolumeId >= 0) && (aVolumeId < KMaxVolumes))

        {

        return iVolumes[aVolumeId];

        }

    return NULL;

    }

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

// CRsfwVolumeTable::VolumeByDriveLetter

//

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

//

CRsfwVolume* CRsfwVolumeTable::VolumeByDriveLetter(TChar aDriveLetter)

    {

    return VolumeByVolumeId(VolumeIdByDriveLetter(aDriveLetter));

    }

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

// CRsfwVolumeTable::RecoverVolumeL

//

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

//

TUint CRsfwVolumeTable::RecoverVolumeL(const TRsfwMountConfig& aMountConfig,

                                   CRsfwMountStateMachine* aCaller)

    {

    DEBUGSTRING(("Recovering volume"));

    TUint transactionId = 0;

    CRsfwVolume* volume = VolumeByVolumeId(aCaller->iVolumeId);

    if (volume)

        {

        aCaller->iVolume = volume;

        // set also fileengine pointer in the state machine,

        // so that the operation can be cancelled

        aCaller->SetFileEngine(volume->iFileEngine);

        if (User::UpperCase(

                aCaller->iVolume->iMountInfo.iMountConfig.iDriveLetter) ==

            User::UpperCase(aMountConfig.iDriveLetter))

            {

            if (aCaller->iVolume->iMountInfo.iMountConfig.iFlags &

                KMountFlagOffLine)

                {

                // We are working offline

                aCaller->iVolume->iMountInfo.iMountStatus.iConnectionState =

                    KMountNotConnected;

                }

            else

                {

                aCaller->iVolume->iMountInfo.iMountStatus.iConnectionState =

                    KMountStronglyConnected;

                }

            transactionId =

                aCaller->iVolume->iFileEngine->RequestConnectionStateL(

                    aCaller->iVolume->iMountInfo.iMountStatus.iConnectionState,

                    aCaller);

            }

        else

            {

            User::Leave(KErrArgument);

            }

        }

    else

        {

        User::Leave(KErrNotFound);

        }

    return transactionId;

    }

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

// CRsfwVolumeTable::MountState

//

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

//

TInt CRsfwVolumeTable::MountState(TChar aDriveLetter)

    {

    DEBUGSTRING(("Getting mount state"));

    TInt state;

    // Find the volume

    CRsfwVolume* volume = VolumeByDriveLetter(aDriveLetter);

    if (volume)

        {

        TRsfwMountInfo& mountInfo = volume->iMountInfo;

        DEBUGSTRING16(("mount '%S'in state %d",

                       &mountInfo.iMountConfig.iName,

                       mountInfo.iMountStatus.iMountState));

        state = mountInfo.iMountStatus.iMountState;

        }

    else

        {

        DEBUGSTRING(("mount not found"));

        state = 0; // define KMountStateNone=0 in RsfwControl.h

        }

    return state;

    }

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

// CRsfwVolumeTable::GetMountConfigL

//

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

//

TInt CRsfwVolumeTable::GetMountConfigL(TRsfwMountConfig& aMountConfig)

    {

    DEBUGSTRING16(("Getting mount config for name '%S', drive %c",

                   &aMountConfig.iName,

                   TUint(aMountConfig.iDriveLetter)));

    TInt err = KErrNone;

    const CRsfwMountEntry* entry =

        iMountStore->LookupEntryByDriveL(aMountConfig.iDriveLetter);

    if (!entry)

        {

        // Could not find by drive letter - retry with name

        entry = iMountStore->LookupEntryByNameL(aMountConfig.iName);

        }

    if (entry &&

        entry->Item(EMountEntryItemDrive) &&

        entry->Item(EMountEntryItemUri))

        {

        if (entry->Item(EMountEntryItemDrive)->Length())

            {

            TLex parse(*entry->Item(EMountEntryItemDrive));

            aMountConfig.iDriveLetter = parse.Get();

            if (entry->Item(EMountEntryItemName))

                {

                aMountConfig.iName.Copy(*entry->Item(EMountEntryItemName));

                }

            else

                {

                aMountConfig.iName.SetLength(0);

                }

            aMountConfig.iUri.Copy(*entry->Item(EMountEntryItemUri));

            if (entry->Item(EMountEntryItemUserName))

                {

                aMountConfig.iUserName.Copy(

                    *entry->Item(EMountEntryItemUserName));

                }

            else

                {

                aMountConfig.iUserName.SetLength(0);

                }

            if (entry->Item(EMountEntryItemPassword))

                {

                aMountConfig.iPassword.Copy(

                    *entry->Item(EMountEntryItemPassword));

                }

            else

                {

                aMountConfig.iPassword.SetLength(0);

                }

            if (entry->Item(EMountEntryItemIap))

                {

                aMountConfig.iAuxData.Copy(

                    *entry->Item(EMountEntryItemIap));

                }

            else

                {

                aMountConfig.iAuxData.SetLength(0);

                }

            TInt inactivityTimeout = iInactivityTimeout;

            if (entry->Item(EMountEntryItemInactivityTimeout))

                {

                TLex timeout(*entry->Item(EMountEntryItemInactivityTimeout));

                timeout.Val(inactivityTimeout);

                DEBUGSTRING(("Set inactivity timeout = %d",

                             inactivityTimeout));

                }

            aMountConfig.iInactivityTimeout = inactivityTimeout;

            aMountConfig.iFlags = 0;

            }

        else

            {

            err = KErrArgument;

            }

        }

    else

        {

        DEBUGSTRING(("mount configuration not found"));

        err = KErrNotFound;

        }

    return err;

    }

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

// CRsfwVolumeTable::RestoreVolumesL

//

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

//

void CRsfwVolumeTable::RestoreVolumesL()

    {

    DEBUGSTRING(("CRsfwVolumeTable::RestoreVolumesL"));

    // Load persistently stored volumes

    CDir* dirList;

    TInt err = iFs.GetDir(*iCacheRoot,

                         KEntryAttMaskSupported,

                         ESortByName,

                         dirList);

    CleanupStack::PushL(dirList);

    DEBUGSTRING(("GetDir for cacheRoot returned %d", err));

    if (err == KErrNone)

        {

        TInt i;

        for (i = 0; i < dirList->Count(); i++)

            {

            const TEntry& entry = (*dirList)[i];

            if (entry.iAtt & KEntryAttDir)

                {

                // The name of cache directories are C<volume_id>

                _LIT(KCacheMatch, "C*");

                if (entry.iName.Match(KCacheMatch) == 0)

                    {

                    TLex volumeAlpha(entry.iName.Mid(1));

                    TInt volumeId;