/*

* Copyright (c) 2003-2006 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:  Operation independent remote file handling functions

*

*/

#include <apgcli.h>

#include <bautils.h>

#include "rsfwfileentry.h"

#include "rsfwfiletable.h"

#include "rsfwvolumetable.h"

#include "rsfwvolume.h"

#include "rsfwrfestatemachine.h"

#include "rsfwinterface.h"

#include "rsfwcontrol.h"

#include "rsfwremoteaccess.h"

#include "rsfwfileengine.h"

#include "rsfwrfeserver.h"

#include "rsfwlockmanager.h"

#include "mdebug.h"

#include "rsfwdirent.h"

#include "rsfwdirentattr.h"

#include "rsfwinterface.h"

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

// CRsfwFileEngine::NewL

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

//

CRsfwFileEngine* CRsfwFileEngine::NewL(CRsfwVolume* aVolume)

    {

    CRsfwFileEngine* self = CRsfwFileEngine::NewLC(aVolume);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwFileEngine::NewLC

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

//

CRsfwFileEngine* CRsfwFileEngine::NewLC(CRsfwVolume* aVolume)

    {

    DEBUGSTRING(("CRsfwFileEngine::NewLC"));

    CRsfwFileEngine* self = new (ELeave) CRsfwFileEngine();

    DEBUGSTRING(("CRsfwFileEngine: in NewLC 0x%x", self));

    CleanupStack::PushL(self);

    self->ConstructL(aVolume);

    return self;

    }

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

// CRsfwFileEngine::ConstructL

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

//

void CRsfwFileEngine::ConstructL(CRsfwVolume* aVolume)

    {

    iRemoteAccess = NULL;

    iRootFid = NULL;

    iRootFep = NULL;

    iVolume = aVolume;

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

    iConnectionState = KMountNotConnected;

    __ASSERT_ALWAYS(iVolume != NULL, User::Panic(KRfeServer, EConstructingServerStructs));

    iInactivityTimeout =

       iVolume->iMountInfo.iMountConfig.iInactivityTimeout * 1000000;

    PrepareCacheL();

    // Create file table

    iFileTable = CRsfwFileTable::NewL(aVolume, iCacheRoot);

    __ASSERT_ALWAYS(iVolume->iVolumeTable != NULL, User::Panic(KRfeServer, 

    			EConstructingServerStructs));

    SetupRootL(iVolume->iVolumeTable->iPermanence);

    }

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

// CRsfwFileEngine::~CRsfwFileEngine

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

//

CRsfwFileEngine::~CRsfwFileEngine()

    {

    DEBUGSTRING(("CRsfwFileEngine destructor"));

    delete iFileTable;

    delete iRemoteAccess;

    delete iLockManager;

    StopInactivityTimer();

    delete iInactivityTimer;

    }

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

// CRsfwFileEngine::DispatchL

// we should only come here with some synchronous requests

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

//

void CRsfwFileEngine::DispatchL(TRfeInArgs& aIn, TRfeOutArgs& aOut)

    {

    switch(aIn.iOpCode)

        {

    case EFsIoctl:

        DEBUGSTRING(("IOCTL"));

        DoIoctlL(static_cast<TRfeIoctlInArgs&>(aIn),

                 aOut);

        break;

    case EFsRoot:

        DEBUGSTRING(("ROOT"));

        DoRootL(static_cast<TRfeRootInArgs&>(aIn),

                static_cast<TRfeRootOutArgs&>(aOut));

        break;

    case ESetAttr:

        DEBUGSTRING(("SETATTR"));

        DoSetAttrL(static_cast<TRfeSetAttrInArgs&>(aIn),

                   aOut);

        break;

    default:

        DEBUGSTRING(("WHAT??? - %d", aIn.iOpCode));

        User::Leave(KErrArgument);

        break;

        }

    }

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

// CRsfwFileEngine::FullNameLC

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

//

HBufC* CRsfwFileEngine::FullNameLC(CRsfwFileEntry& aFe)

    {

    HBufC* fn = aFe.FullNameLC();

    return fn;

    }

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

// CRsfwFileEngine::FullNameL

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

//

HBufC* CRsfwFileEngine::FullNameL(CRsfwFileEntry& aFe)

    {

    HBufC* fn = FullNameLC(aFe);

    CleanupStack::Pop(fn);

    return fn;

    }

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

// CRsfwFileEngine::SetupAttributes

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

//

void CRsfwFileEngine::SetupAttributes(CRsfwFileEntry& aFe)

    {

    DEBUGSTRING(("CRsfwFileEngine::SetupAttributes"));

    // Construct the attributes for a newly created file or directory,

    // or a file that that was locally modified and just written to the server,

    // based on local knowledge of time and file size.

    // We assume that either the file is cached or it is an empty file.

    // We do not touch the local or protection attributes.

    TUint att;

    // Assume that the file type has already been setup

    if (aFe.Type() == KNodeTypeDir)

        {

        att = KEntryAttDir;

        }

    else

        {

        att = 0;

        }

    TTime time;

    if (aFe.IsCached())

        {

        TDesC* cacheNamep = aFe.CacheFileName();

        RFile f;

        if (f.Open(iFs, *cacheNamep, EFileShareAny) == KErrNone)

            {

            // attribute bits

            TUint a;

            f.Att(a);

            att |= a & KEntryAttReadOnly;

            if (aFe.Type() == KNodeTypeDir)

                {

                aFe.SetSize(0);

                }

            else

                {

                if (aFe.IsFullyCached())

                    {

                    // size

                    TInt siz;

                    f.Size(siz);

                    DEBUGSTRING(("File is fully cached, setting size to %d", siz));

                    aFe.SetSize(siz);

                    aFe.SetCachedSize(siz);

                    }

                else

                	{

                	DEBUGSTRING(("File is not fully cached, not touching the size"));

                	// file is not fully cached

                	// the size cannot be set from the local cache container	

                	}

                }

            // modification time

            f.Modified(time);

            f.Close();

            aFe.iUseCachedData = ETrue;

          }

        else 

          {

          // No cache

          aFe.SetSize(0);

          time.HomeTime();        

          }

        }

    else

        {

        // No cache

        aFe.SetSize(0);

        time.HomeTime();

        }

    aFe.SetAtt(att);

    aFe.SetModified(time);

    aFe.SetAttribValidationTime();

    }

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

// CRsfwFileEngine::MakeDirectoryEntry

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

//

void CRsfwFileEngine::MakeDirectoryEntry(CRsfwFileEntry& aFe, TDirEnt& aDirEnt)

    {

    DEBUGSTRING(("CRsfwFileEngine::MakeDirectoryEntry"));

    DEBUGSTRING16(("name %S, att %d, size %d", aFe.Name(), aFe.Att(), aFe.Size()));;

    aDirEnt.Clear();

    aDirEnt.iName.Copy(*aFe.Name());

    aDirEnt.iAttr.iAtt = aFe.Att();

    aDirEnt.iAttr.iSize = aFe.Size();

    aDirEnt.iAttr.iModified = aFe.Modified();

    aDirEnt.iAttr.iUid3 = aFe.iUid;

    }

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

// CRsfwFileEngine::UpdateDirectoryContainerL

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

//

void CRsfwFileEngine::UpdateDirectoryContainerL(CRsfwFileEntry& aFe)

    {

    // Construct the directory container based on

    // file table information

    DEBUGSTRING16(("Update directory container of %d (%S)", aFe.Fid().iNodeId, aFe.Name()));

    TDesC* cacheNamep = aFe.CacheFileName();

    if (!cacheNamep)

        {

        // There was no prior cache.

        DEBUGSTRING(("Cache missing!"));

        User::Leave(KErrGeneral);

        }

    RFile f;

    CleanupClosePushL(f);

    User::LeaveIfError(f.Replace(iFs,

                                 *cacheNamep,

                                 EFileShareAny | EFileWrite));

    RFileWriteStream fStream(f);

    CleanupClosePushL(fStream);

    RPointerArray<CRsfwFileEntry>* kidsp = aFe.Kids();

    TInt i;

    if (!(iVolume->iVolumeTable->EnsureCacheCanBeAddedL(

              sizeof(TEntry) * kidsp->Count())))      

        {   // pessimistic estimate

        User::Leave(KErrDiskFull);

        }

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

        {

        CRsfwFileEntry* kidFep = (*kidsp)[i];

        TDirEnt dirEnt;

        MakeDirectoryEntry(*kidFep, dirEnt);

        dirEnt.ExternalizeL(fStream);      

        }

    CleanupStack::PopAndDestroy(2, &f); // f

    aFe.ResetLocallyDirty();

    }

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

// CRsfwFileEngine::DataChanged

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

//

TInt CRsfwFileEngine::DataChanged(const CRsfwDirEntAttr& aOldAttr,

                              const CRsfwDirEntAttr& aNewAttr)

    {

    // Based on attributes or metadata in general,

    // tell whether the actual data, if cached,

    // should be updated

    if (aOldAttr.Att() == KEntryAttDir)

        {

        // use Last Modified (a weak entity tag)

        if (aOldAttr.Modified() == aNewAttr.Modified())

            {

            return EFalse;

            }

        else

            {

            return ETrue;

            }

        }

    else

        {

        // use ETags if available

        // a strong entity tag

        if (aOldAttr.ETag() && aNewAttr.ETag())

            {

            if (*aOldAttr.ETag() == *aNewAttr.ETag())

                {

                return EFalse;

                }

            else

                {

                return ETrue;

                }

            }

        // use Last Modified (a weak entity tag)

        // we assume it's file and compare also iSize...

        if ((aOldAttr.Modified() == aNewAttr.Modified()) &&

            (aOldAttr.Size() == aNewAttr.Size()))

            {

            return EFalse;

            }

        else

            {

            return ETrue;

            }

        }

    }

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

// CRsfwFileEngine::UseCachedData

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

//

TBool CRsfwFileEngine::UseCachedData(CRsfwFileEntry& aFe)

    {

    if (!Disconnected())

        {

        return aFe.UseCachedData();

        }

    else

        {

        return ETrue;

        }

    }

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

// CRsfwFileEngine::UseCachedAttributes

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

//

TBool CRsfwFileEngine::UseCachedAttributes(CRsfwFileEntry& aFe)

    {

      if (!Disconnected())

        {

        if (aFe.Type() == KNodeTypeDir)

			{

			return iFileTable->Volume()->iVolumeTable->

				IsCachedAttrStillValid(aFe.iAttribValidation);

			}

		else

			{ // file

			return iFileTable->Volume()->iVolumeTable->

				IsCachedDataStillValid(aFe.iAttribValidation);

			}

        }

    else

        {

        return ETrue;

        }

    }

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

// CRsfwFileEngine::GetAttributesL

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

//

void CRsfwFileEngine::GetAttributesL(CRsfwFileEntry& aFe,

                                 CRsfwDirEntAttr*& aAttr,

                                 TUint aNodeType,

                                 CRsfwRfeStateMachine* aCaller)

    {

    // Gets attributes for File Entry aFe.

    // Uses either cached attributes (if they are still deemed to be valid), or

    // fetches the attributes from the server*/

    DEBUGSTRING(("GetAttributesL"));

    if ((aFe.Type() == aNodeType) && UseCachedAttributes(aFe))

        {

        // Nothing to do

        if (aFe.IsOpenedForWriting())

            {

            // update attributes when we are writing to the file

            DEBUGSTRING(("volatile attributes"));

            SetupAttributes(aFe);

            }

        else

            {

            DEBUGSTRING(("using cached attributes"));

            }

        aCaller->HandleRemoteAccessResponse(0, KErrNone); // "file exists"

        }

    else

        {

        // Refresh attributes

        UpdateAttributesL(aFe, aAttr, aNodeType, aCaller);

        }

    }

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

// CRsfwFileEngine::UpdateAttributesL

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

//

void CRsfwFileEngine::UpdateAttributesL(CRsfwFileEntry& aFe,

                                    CRsfwDirEntAttr*& aAttr,

                                    TUint aNodeType,

                                    MRsfwRemoteAccessResponseHandler* aCaller)

    {

    // UpdateAttributes doesn't attempt to use cached attributes

    HBufC* path = FullNameLC(aFe);

    TPtr p = path->Des();

    DEBUGSTRING16(("UpdateAttributesL of '%S'", &p));

    UpdateAttributesL(*path, aAttr, aNodeType, aCaller);

    CleanupStack::PopAndDestroy(path); // path

    }

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

// CRsfwFileEngine::UpdateAttributesL

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

//

void CRsfwFileEngine::UpdateAttributesL(TDesC& aPath,

                                    TDesC& aName,

                                    CRsfwDirEntAttr*& aAttr,

                                    TUint aNodeType,

                                    MRsfwRemoteAccessResponseHandler* aCaller)

    {

    HBufC* pn = HBufC::NewLC(KMaxPath);

    TPtr pnPtr = pn->Des();

    if (aPath.Length())

        {

        pnPtr.Copy(aPath);

        pnPtr.Append('/');

        }

    pnPtr.Append(aName);

    DEBUGSTRING16(("UpdateKidAttributes of '%S'", &pnPtr));

   	UpdateAttributesL(pnPtr, aAttr, aNodeType, aCaller);

    CleanupStack::PopAndDestroy(pn);

    }

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

// CRsfwFileEngine::UpdateAttributesL

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

//

void CRsfwFileEngine::UpdateAttributesL(TDesC& aFullPath,

                                    CRsfwDirEntAttr*& aAttr,

                                    TUint aNodeType,

                                    MRsfwRemoteAccessResponseHandler* aCaller)

	{

	// If we have "recently" found out that this file/dir does NOT exist

	// we cache even this negative result. Time limit is cache expiry for

	// directory attributes

	 if ((aFullPath.Length() > 0) &&    // do not compare root folder (always exists)

	 (iLastFailedLookup == aFullPath) &&

	 	  (iFileTable->Volume()->iVolumeTable->

				IsCachedAttrStillValid(iLookupTime)))

    	{

    	if (aNodeType == KNodeTypeDir)

            {

            aCaller->HandleRemoteAccessResponse(0, KErrPathNotFound);

            }

        else if (aNodeType == KNodeTypeFile)

            {

            aCaller->HandleRemoteAccessResponse(0, KErrNotFound);

            }

        return;

    	}

	if (!Disconnected())

        {

        if (aNodeType == KNodeTypeDir)

            {

            RemoteAccessL()->GetDirectoryAttributesL(aFullPath, aAttr, aCaller);

            }

        else if (aNodeType == KNodeTypeFile)

            {

            RemoteAccessL()->GetFileAttributesL(aFullPath, aAttr, aCaller);

            }

        }

    else

        {

        User::Leave(KErrNotFound);

        }

	}