1 /*

     2 * Copyright (c) 2003-2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Operation independent remote file handling functions

    15 *

    16 */

    17 

    18 

    19 #include <apgcli.h>

    20 #include <bautils.h>

    21 

    22 #include "rsfwfileentry.h"

    23 #include "rsfwfiletable.h"

    24 #include "rsfwvolumetable.h"

    25 #include "rsfwvolume.h"

    26 #include "rsfwrfestatemachine.h"

    27 #include "rsfwinterface.h"

    28 #include "rsfwcontrol.h"

    29 #include "rsfwremoteaccess.h"

    30 #include "rsfwfileengine.h"

    31 #include "rsfwrfeserver.h"

    32 #include "rsfwlockmanager.h"

    33 #include "mdebug.h"

    34 #include "rsfwdirent.h"

    35 #include "rsfwdirentattr.h"

    36 #include "rsfwinterface.h"

    37 

    38 // ----------------------------------------------------------------------------

    39 // CRsfwFileEngine::NewL

    40 // ----------------------------------------------------------------------------

    41 //

    42 CRsfwFileEngine* CRsfwFileEngine::NewL(CRsfwVolume* aVolume)

    43     {

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

    45     CleanupStack::Pop(self);

    46     return self;

    47     }

    48 

    49 // ----------------------------------------------------------------------------

    50 // CRsfwFileEngine::NewLC

    51 // ----------------------------------------------------------------------------

    52 //

    53 CRsfwFileEngine* CRsfwFileEngine::NewLC(CRsfwVolume* aVolume)

    54     {

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

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

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

    58     CleanupStack::PushL(self);

    59     self->ConstructL(aVolume);

    60     return self;

    61     }

    62 

    63 // ----------------------------------------------------------------------------

    64 // CRsfwFileEngine::ConstructL

    65 // ----------------------------------------------------------------------------

    66 //

    67 void CRsfwFileEngine::ConstructL(CRsfwVolume* aVolume)

    68     {

    69     iRemoteAccess = NULL;

    70     iRootFid = NULL;

    71     iRootFep = NULL;

    72     iVolume = aVolume;

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

    74     iConnectionState = KMountNotConnected;

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

    76     iInactivityTimeout =

    77        iVolume->iMountInfo.iMountConfig.iInactivityTimeout * 1000000;

    78     PrepareCacheL();

    79     // Create file table

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

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

    82     			EConstructingServerStructs));

    83     SetupRootL(iVolume->iVolumeTable->iPermanence);

    84     }

    85 

    86 // ----------------------------------------------------------------------------

    87 // CRsfwFileEngine::~CRsfwFileEngine

    88 // ----------------------------------------------------------------------------

    89 //

    90 CRsfwFileEngine::~CRsfwFileEngine()

    91     {

    92     DEBUGSTRING(("CRsfwFileEngine destructor"));

    93     delete iFileTable;

    94     delete iRemoteAccess;

    95     delete iLockManager;

    96     StopInactivityTimer();

    97     delete iInactivityTimer;

    98     }

    99 

   100 // ----------------------------------------------------------------------------

   101 // CRsfwFileEngine::DispatchL

   102 // we should only come here with some synchronous requests

   103 // ----------------------------------------------------------------------------

   104 //

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

   106     {

   107 

   108     switch(aIn.iOpCode)

   109         {

   110     case EFsIoctl:

   111         DEBUGSTRING(("IOCTL"));

   112         DoIoctlL(static_cast<TRfeIoctlInArgs&>(aIn),

   113                  aOut);

   114         break;

   115 

   116     case EFsRoot:

   117         DEBUGSTRING(("ROOT"));

   118         DoRootL(static_cast<TRfeRootInArgs&>(aIn),

   119                 static_cast<TRfeRootOutArgs&>(aOut));

   120         break;

   121 

   122     case ESetAttr:

   123         DEBUGSTRING(("SETATTR"));

   124         DoSetAttrL(static_cast<TRfeSetAttrInArgs&>(aIn),

   125                    aOut);

   126         break;

   127 

   128     default:

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

   130         User::Leave(KErrArgument);

   131         break;

   132         }

   133     }

   134 

   135 // ----------------------------------------------------------------------------

   136 // CRsfwFileEngine::FullNameLC

   137 // ----------------------------------------------------------------------------

   138 //

   139 HBufC* CRsfwFileEngine::FullNameLC(CRsfwFileEntry& aFe)

   140     {

   141     HBufC* fn = aFe.FullNameLC();

   142     return fn;

   143     }

   144 

   145 // ----------------------------------------------------------------------------

   146 // CRsfwFileEngine::FullNameL

   147 // ----------------------------------------------------------------------------

   148 //

   149 HBufC* CRsfwFileEngine::FullNameL(CRsfwFileEntry& aFe)

   150     {

   151     HBufC* fn = FullNameLC(aFe);

   152     CleanupStack::Pop(fn);

   153     return fn;

   154     }

   155 

   156 // ----------------------------------------------------------------------------

   157 // CRsfwFileEngine::SetupAttributes

   158 // ----------------------------------------------------------------------------

   159 //

   160 void CRsfwFileEngine::SetupAttributes(CRsfwFileEntry& aFe)

   161     {

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

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

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

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

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

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

   168 

   169     TUint att;

   170 

   171     // Assume that the file type has already been setup

   172     if (aFe.Type() == KNodeTypeDir)

   173         {

   174         att = KEntryAttDir;

   175         }

   176     else

   177         {

   178         att = 0;

   179         }

   180 

   181     TTime time;

   182     if (aFe.IsCached())

   183         {

   184         TDesC* cacheNamep = aFe.CacheFileName();

   185         RFile f;

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

   187             {

   188             // attribute bits

   189             TUint a;

   190             f.Att(a);

   191 

   192             att |= a & KEntryAttReadOnly;

   193 

   194             if (aFe.Type() == KNodeTypeDir)

   195                 {

   196                 aFe.SetSize(0);

   197                 }

   198             else

   199                 {

   200                 if (aFe.IsFullyCached())

   201                     {

   202                     // size

   203                     TInt siz;

   204                     f.Size(siz);

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

   206                     aFe.SetSize(siz);

   207                     aFe.SetCachedSize(siz);

   208                     }

   209                 else

   210                 	{

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

   212                 	// file is not fully cached

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

   214                 	}

   215                 }

   216             // modification time

   217             f.Modified(time);

   218 

   219             f.Close();

   220             aFe.iUseCachedData = ETrue;

   221           }

   222         else 

   223           {

   224           // No cache

   225           aFe.SetSize(0);

   226           time.HomeTime();        

   227           }

   228         

   229         }

   230     else

   231         {

   232         // No cache

   233         aFe.SetSize(0);

   234         time.HomeTime();

   235         }

   236 

   237     aFe.SetAtt(att);

   238 

   239     aFe.SetModified(time);

   240     aFe.SetAttribValidationTime();

   241     }

   242 

   243 // ----------------------------------------------------------------------------

   244 // CRsfwFileEngine::MakeDirectoryEntry

   245 // ----------------------------------------------------------------------------

   246 //

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

   248     {

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

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

   251     aDirEnt.Clear();

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

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

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

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

   256     aDirEnt.iAttr.iUid3 = aFe.iUid;

   257     }

   258 

   259 // ----------------------------------------------------------------------------

   260 // CRsfwFileEngine::UpdateDirectoryContainerL

   261 // ----------------------------------------------------------------------------

   262 //

   263 void CRsfwFileEngine::UpdateDirectoryContainerL(CRsfwFileEntry& aFe)

   264     {

   265     // Construct the directory container based on

   266     // file table information

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

   268 

   269     TDesC* cacheNamep = aFe.CacheFileName();

   270     if (!cacheNamep)

   271         {

   272         // There was no prior cache.

   273         DEBUGSTRING(("Cache missing!"));

   274         User::Leave(KErrGeneral);

   275         }

   276 

   277     RFile f;

   278     CleanupClosePushL(f);

   279     User::LeaveIfError(f.Replace(iFs,

   280                                  *cacheNamep,

   281                                  EFileShareAny | EFileWrite));

   282     RFileWriteStream fStream(f);

   283     CleanupClosePushL(fStream);

   284 

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

   286     TInt i;

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

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

   289         {   // pessimistic estimate

   290         User::Leave(KErrDiskFull);

   291         }

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

   293         {

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

   295         TDirEnt dirEnt;

   296         MakeDirectoryEntry(*kidFep, dirEnt);

   297         dirEnt.ExternalizeL(fStream);      

   298         }

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

   300 

   301     aFe.ResetLocallyDirty();

   302     }

   303 

   304 // ----------------------------------------------------------------------------

   305 // CRsfwFileEngine::DataChanged

   306 // ----------------------------------------------------------------------------

   307 //

   308 TInt CRsfwFileEngine::DataChanged(const CRsfwDirEntAttr& aOldAttr,

   309                               const CRsfwDirEntAttr& aNewAttr)

   310     {

   311     // Based on attributes or metadata in general,

   312     // tell whether the actual data, if cached,

   313     // should be updated

   314     if (aOldAttr.Att() == KEntryAttDir)

   315         {

   316         // use Last Modified (a weak entity tag)

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

   318             {

   319             return EFalse;

   320             }

   321         else

   322             {

   323             return ETrue;

   324             }

   325         }

   326     else

   327         {

   328         // use ETags if available

   329         // a strong entity tag

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

   331             {

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

   333                 {

   334                 return EFalse;

   335                 }

   336             else

   337                 {

   338                 return ETrue;

   339                 }

   340             }

   341 

   342         // use Last Modified (a weak entity tag)

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

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

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

   346             {

   347             return EFalse;

   348             }

   349         else

   350             {

   351             return ETrue;

   352             }

   353         }

   354     }

   355 

   356 // ----------------------------------------------------------------------------

   357 // CRsfwFileEngine::UseCachedData

   358 // ----------------------------------------------------------------------------

   359 //

   360 TBool CRsfwFileEngine::UseCachedData(CRsfwFileEntry& aFe)

   361     {

   362     if (!Disconnected())

   363         {

   364         return aFe.UseCachedData();

   365         }

   366     else

   367         {

   368         return ETrue;

   369         }

   370     }

   371 

   372 // ----------------------------------------------------------------------------

   373 // CRsfwFileEngine::UseCachedAttributes

   374 // ----------------------------------------------------------------------------

   375 //

   376 TBool CRsfwFileEngine::UseCachedAttributes(CRsfwFileEntry& aFe)

   377     {

   378       if (!Disconnected())

   379         {

   380         if (aFe.Type() == KNodeTypeDir)

   381 			{

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

   383 				IsCachedAttrStillValid(aFe.iAttribValidation);

   384 			}

   385 		else

   386 			{ // file

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

   388 				IsCachedDataStillValid(aFe.iAttribValidation);

   389 

   390 			}

   391         }

   392     else

   393         {

   394         return ETrue;

   395         }

   396     }

   397 

   398 // ----------------------------------------------------------------------------

   399 // CRsfwFileEngine::GetAttributesL

   400 // ----------------------------------------------------------------------------

   401 //

   402 void CRsfwFileEngine::GetAttributesL(CRsfwFileEntry& aFe,

   403                                  CRsfwDirEntAttr*& aAttr,

   404                                  TUint aNodeType,

   405                                  CRsfwRfeStateMachine* aCaller)

   406     {

   407     // Gets attributes for File Entry aFe.

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

   409     // fetches the attributes from the server*/

   410     DEBUGSTRING(("GetAttributesL"));

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

   412         {

   413         // Nothing to do

   414 

   415         if (aFe.IsOpenedForWriting())

   416             {

   417             // update attributes when we are writing to the file

   418             DEBUGSTRING(("volatile attributes"));

   419             SetupAttributes(aFe);

   420             }

   421         else

   422             {

   423             DEBUGSTRING(("using cached attributes"));

   424             }

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

   426         }

   427     else

   428         {

   429         // Refresh attributes

   430         UpdateAttributesL(aFe, aAttr, aNodeType, aCaller);

   431         }

   432     }

   433 

   434 // ----------------------------------------------------------------------------

   435 // CRsfwFileEngine::UpdateAttributesL

   436 // ----------------------------------------------------------------------------

   437 //

   438 void CRsfwFileEngine::UpdateAttributesL(CRsfwFileEntry& aFe,

   439                                     CRsfwDirEntAttr*& aAttr,

   440                                     TUint aNodeType,

   441                                     MRsfwRemoteAccessResponseHandler* aCaller)

   442     {

   443     // UpdateAttributes doesn't attempt to use cached attributes

   444     HBufC* path = FullNameLC(aFe);

   445     TPtr p = path->Des();

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

   447 

   448 

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

   450 

   451     CleanupStack::PopAndDestroy(path); // path

   452     }

   453 

   454 // ----------------------------------------------------------------------------

   455 // CRsfwFileEngine::UpdateAttributesL

   456 // ----------------------------------------------------------------------------

   457 //

   458 void CRsfwFileEngine::UpdateAttributesL(TDesC& aPath,

   459                                     TDesC& aName,

   460                                     CRsfwDirEntAttr*& aAttr,

   461                                     TUint aNodeType,

   462                                     MRsfwRemoteAccessResponseHandler* aCaller)

   463     {

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

   465     TPtr pnPtr = pn->Des();

   466 

   467     if (aPath.Length())

   468         {

   469         pnPtr.Copy(aPath);

   470         pnPtr.Append('/');

   471         }

   472     pnPtr.Append(aName);

   473 

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

   475 

   476    	UpdateAttributesL(pnPtr, aAttr, aNodeType, aCaller);

   477 

   478     CleanupStack::PopAndDestroy(pn);

   479     }

   480 

   481 // ----------------------------------------------------------------------------

   482 // CRsfwFileEngine::UpdateAttributesL

   483 // ----------------------------------------------------------------------------

   484 //

   485 void CRsfwFileEngine::UpdateAttributesL(TDesC& aFullPath,

   486                                     CRsfwDirEntAttr*& aAttr,

   487                                     TUint aNodeType,

   488                                     MRsfwRemoteAccessResponseHandler* aCaller)

   489 	{

   490 

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

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

   493 	// directory attributes

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

   495 	 (iLastFailedLookup == aFullPath) &&

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

   497 				IsCachedAttrStillValid(iLookupTime)))

   498     	{

   499     	if (aNodeType == KNodeTypeDir)

   500             {

   501             aCaller->HandleRemoteAccessResponse(0, KErrPathNotFound);

   502             }

   503         else if (aNodeType == KNodeTypeFile)

   504             {

   505             aCaller->HandleRemoteAccessResponse(0, KErrNotFound);

   506             }

   507         return;

   508 

   509     	}

   510 

   511 	if (!Disconnected())

   512         {

   513         if (aNodeType == KNodeTypeDir)

   514             {

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

   516             }

   517         else if (aNodeType == KNodeTypeFile)

   518             {

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

   520             }

   521         }

   522     else

   523         {

   524         User::Leave(KErrNotFound);

   525         }

   526 

   527 	}

   528 

   529 // ----------------------------------------------------------------------------

   530 // CRsfwFileEngine::CreateContainerFileL

   531 // ----------------------------------------------------------------------------

   532 //

   533 void CRsfwFileEngine::CreateContainerFileL(CRsfwFileEntry& aFe)

   534     {

   535     // Create a container file for the Fid.

   536     // If the cache file already exists, it will be deleted

   537 

   538     RFile f;

   539     HBufC* cachePath = HBufC::NewMaxLC(KMaxPath);

   540     TPtr pathPtr = cachePath->Des();

   541     BuildContainerPathL(aFe, pathPtr);

   542 

   543     TInt err = f.Replace(iFs, *cachePath, EFileShareAny | EFileWrite);

   544     f.Close();

   545     if (err != KErrNone)

   546         {

   547         DEBUGSTRING(("Error when creating container file! err=%d", err));

   548         User::Leave(KErrGeneral);

   549         }  

   550     aFe.SetCacheFileName(cachePath);

   551     CleanupStack::PopAndDestroy(cachePath);

   552     }

   553 

   554 // ----------------------------------------------------------------------------

   555 // CRsfwFileEngine::FetchAndCacheL

   556 // ----------------------------------------------------------------------------

   557 //

   558 TUint CRsfwFileEngine::FetchAndCacheL(CRsfwFileEntry& aFe,

   559                                   TInt aFirstByte,

   560                                   TInt* aLength,

   561                                   RPointerArray<CRsfwDirEnt>* aDirEntsp,

   562                                   CRsfwRfeStateMachine* aCaller)

   563     {

   564     // Fetch a file from the remote store and decrypt it if necessary.

   565     // The assumption is that the file has not yet been fetched

   566     // or has been cached up to the byte indicated by (aFe.iCachedSize - 1)

   567     // and filling the cache will continue linearly

   568     // i.e. aFirstByte = 0 || aFirstByte = aFe.iCachedSize

   569     // Access modules can fetch more than requested, so aLastByte might change.

   570 

   571     DEBUGSTRING(("Fetch fid %d, bytes %d - %d",

   572                  aFe.Fid().iNodeId,

   573                  aFirstByte,

   574                  aFirstByte + *aLength));

   575 

   576     TUint transactionId = 0;

   577     RFile f;

   578     HBufC* fullName = NULL;

   579     HBufC* cacheName = HBufC::NewMaxLC(KMaxPath);

   580     TPtr cachePtr = cacheName->Des();

   581     TInt err;

   582     

   583     TInt usedCache = iVolume->iVolumeTable->TotalCachedSize();

   584 

   585     // This much will be added to the cache by this fetch

   586     if (!iVolume->iVolumeTable->EnsureCacheCanBeAddedL(*aLength))

   587         {

   588         User::Leave(KErrDiskFull);

   589         }

   590 

   591     if (!Disconnected())

   592         {

   593         if (aFe.CacheFileName())

   594             {

   595             // modify an existing cachefile ...

   596             cachePtr = *(aFe.CacheFileName());

   597 

   598             if (aFe.Type() == KNodeTypeFile)

   599                 {

   600                 // If the cache file exists,

   601                 // we will just continue filling it...

   602                 err = f.Open(iFs, *cacheName, EFileShareAny | EFileWrite);

   603                 if (err)

   604                     {

   605                     User::LeaveIfError(f.Replace(iFs,

   606                                                  *cacheName,

   607                                                  EFileShareAny | EFileWrite));

   608                     }

   609                 }

   610             else

   611                 {

   612                 User::LeaveIfError(f.Replace(iFs,

   613                                              *cacheName,

   614                                              EFileShareAny | EFileWrite));

   615                 }      

   616             }

   617         else

   618             {

   619             // create a new cache file

   620             CreateContainerFileL(aFe, cachePtr, f);

   621             }

   622 

   623         CleanupClosePushL(f);

   624         fullName = FullNameLC(aFe);

   625         if (aFe.Type() == KNodeTypeDir)

   626             {

   627             transactionId = GetDirectoryL(aFe,

   628                                           *fullName,

   629                                           f,

   630                                           aDirEntsp,

   631                                           aCaller);

   632             }

   633         else if (aFe.Type() == KNodeTypeFile)

   634             {

   635             f.Close();

   636             transactionId = RemoteAccessL()->GetFileL(*fullName,

   637                                                       *cacheName,

   638                                                       aFirstByte,

   639                                                       aLength,

   640                                                       0,

   641                                                       aCaller);

   642             }

   643 

   644         // fullName, f (duplicate close in the case of files)

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

   646         }

   647     CleanupStack::PopAndDestroy(cacheName);    

   648     return transactionId;

   649     }

   650 

   651 // ----------------------------------------------------------------------------

   652 // CRsfwFileEngine::RequestConnectionStateL

   653 // ----------------------------------------------------------------------------

   654 //

   655 TUint CRsfwFileEngine::RequestConnectionStateL(TUint aConnectionState,

   656                                            CRsfwRfeStateMachine* aCaller)

   657     {

   658     DEBUGSTRING16(("CRsfwFileEngine::RequestConnectionStateL %d", aConnectionState));

   659     DEBUGSTRING16(("current connection state is %d", iConnectionState));

   660     TUint transactionId = 0;

   661     if (aConnectionState != iConnectionState)

   662         {

   663         switch (aConnectionState)

   664             {

   665         case KMountNotConnected:

   666             DisconnectL();

   667             break;

   668         case KMountStronglyConnected:

   669             transactionId = ConnectL(ETrue, aCaller);

   670             break;

   671 

   672         default:

   673             break;

   674             }

   675         }

   676     // else does not do anything (if iConnectionState == aConnectionState)    

   677     return transactionId;

   678     }

   679 

   680 // ----------------------------------------------------------------------------

   681 // CRsfwFileEngine::EnteredConnectionStateL

   682 // ----------------------------------------------------------------------------

   683 //

   684 void CRsfwFileEngine::EnteredConnectionStateL(TUint aConnectionState,

   685                                           TBool aRequested)

   686     {

   687     DEBUGSTRING16(("CRsfwFileEngine::EnteredConnectionStateL %d", aConnectionState));

   688     DEBUGSTRING16(("current connection state is %d", iConnectionState));

   689     if (aConnectionState != iConnectionState)

   690         {

   691         iConnectionState = aConnectionState;

   692         iVolume->ConnectionStateChanged(iConnectionState);

   693 

   694         switch (aConnectionState)

   695             {

   696         case KMountNotConnected:

   697             if (!aRequested)

   698                 {

   699                 iRemoteAccess->Cancel(0);

   700                 }

   701             break;

   702 

   703         case KMountStronglyConnected:

   704             if (aRequested)

   705                 {

   706                 if (iLockManager)

   707                     {

   708                     iLockManager->PopulateExternalLockTokenCacheL(iRootFep);

   709                     }

   710                 }

   711             break;

   712 

   713         default:

   714             break;

   715             }

   716         }

   717     }

   718 

   719 // ----------------------------------------------------------------------------

   720 // CRsfwFileEngine::ConnectionState

   721 // ----------------------------------------------------------------------------

   722 //

   723 TUint CRsfwFileEngine::ConnectionState()

   724     {

   725     return iConnectionState;

   726     }

   727 

   728 // ----------------------------------------------------------------------------

   729 // CRsfwFileEngine::LockManager

   730 // ----------------------------------------------------------------------------

   731 //

   732 CRsfwLockManager* CRsfwFileEngine::LockManager()

   733     {

   734     return iLockManager;

   735     }

   736 

   737 // ----------------------------------------------------------------------------

   738 // CRsfwFileEngine::SetPermanenceL

   739 // ----------------------------------------------------------------------------

   740 //

   741 void CRsfwFileEngine::SetPermanenceL(TBool aPermanence)

   742     {

   743     iFileTable->SetPermanenceL(aPermanence);

   744     }

   745 

   746 // ----------------------------------------------------------------------------

   747 // CRsfwFileEngine::Disconnected

   748 // ----------------------------------------------------------------------------

   749 //

   750 TBool CRsfwFileEngine::Disconnected()

   751     {

   752     return (iConnectionState == KMountNotConnected);

   753     }

   754 

   755 // ----------------------------------------------------------------------------

   756 // CRsfwFileEngine::WriteDisconnected

   757 // ----------------------------------------------------------------------------

   758 //

   759 TBool CRsfwFileEngine::WriteDisconnected()

   760     {

   761     // This also encompasses disconnected mode

   762     return (iConnectionState != KMountStronglyConnected);

   763     }

   764 

   765 // ----------------------------------------------------------------------------

   766 // CRsfwFileEngine::AddToCacheL

   767 // ----------------------------------------------------------------------------

   768 //

   769 TInt CRsfwFileEngine::AddToCacheL(CRsfwFileEntry& aFe,

   770                               RPointerArray<CRsfwDirEnt>* aDirEnts,

   771                               CRsfwFileEngine *aFileEngine,

   772                               TUint cachedSize)

   773     {

   774     // returns the size of the cached data

   775     RFs fs = CRsfwRfeServer::Env()->iFs;

   776     TInt err;

   777     TInt kidsCount = 0;

   778     TInt containerSize = cachedSize;

   779     // holds true for files, will be overwritten for directories

   780 

   781     if (aFe.Type() == KNodeTypeDir)

   782         {

   783         // *********** originally from CRsfwFileEngine::GetDirectoryL()

   784         // **********************************************************

   785         // Unmark and mark kids only when getdirectory returns KErrNone

   786         // otherwise (i.e. KErrUpdateNotRequired) let's just keep

   787         // the cached kids...

   788         aFe.UnmarkKids();

   789 

   790         RApaLsSession lsSession;

   791         User::LeaveIfError(lsSession.Connect());

   792         CleanupClosePushL(lsSession);

   793 

   794         RFileWriteStream fStream;

   795         // Dump to the local cache

   796         User::LeaveIfError(

   797             fStream.Open(fs,

   798                          *(aFe.CacheFileName()),

   799                          EFileWrite | EFileShareAny));

   800         CleanupClosePushL(fStream);

   801 

   802         containerSize = fStream.Sink()->SizeL();

   803         TInt i;

   804         TLex lex;

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

   806             {

   807 		    CRsfwDirEnt* d = (*aDirEnts)[i];

   808             TUid appUid;

   809             // For each TDirEnt we just read...

   810             // ... if the server returned content-type

   811             if (d->Attr()->MimeType() && d->Attr()->MimeType()->Length())

   812                 {

   813                 err = lsSession.AppForDataType(*(d->Attr()->MimeType()),

   814                                                appUid);

   815                 if (err == KErrNone)

   816                     {

   817                     d->Attr()->SetUid(appUid);

   818                     }

   819                 }

   820 

   821             d->Attr()->SetAttFlags(KEntryAttRemote);

   822             CRsfwFileEntry* kidFep = aFe.FindKidByName(*d->Name());

   823             if (kidFep)

   824                 {

   825                 // We already know this kid

   826                 // However we must check whether the kid has been modified

   827                 CRsfwDirEntAttr* oldAttr = CRsfwDirEntAttr::NewLC();

   828                 kidFep->GetAttributesL(*oldAttr);

   829                 if (DataChanged(*oldAttr, *d->Attr()))

   830                     {

   831                     kidFep->RemoveCacheFile();

   832                     }

   833                 CleanupStack::PopAndDestroy(oldAttr);

   834                 if (kidFep->IsFullyCached())

   835                     {

   836                     // Mark the kid as cached

   837                     d->Attr()->ResetAttFlags(KEntryAttRemote);

   838                     }

   839                  // as this entry is "used", move it to the back of metadata LRU list

   840                  iVolume->iVolumeTable->MoveToTheBackOfMetadataLRUPriorityListL(kidFep);

   841                 }

   842 

   843             // As a side effect,

   844             // insert this kid into the file table and

   845             // set its attributes

   846             if (!kidFep)

   847                 {

   848                 if (!iVolume->iVolumeTable->EnsureMetadataCanBeAddedL(&aFe))

   849                     {

   850                     User::Leave(KErrNoMemory);

   851                     }

   852                 kidFep = CRsfwFileEntry::NewL(*d->Name(), &aFe);

   853                 // Attach the new kid

   854                 aFileEngine->iFileTable->AddL(kidFep);

   855                 aFe.AddKid(*kidFep);

   856                 }

   857 

   858             kidFep->Mark();

   859             

   860             // set attributes if getting directory listing also supports getting file attributes

   861             if (DirectoryListingContainsFileMetadata()) 

   862                 {

   863                 kidFep->SetAttributesL(*d->Attr(), ETrue);

   864                 }

   865              else 

   866                 {

   867                 kidFep->SetAttributesL(*d->Attr(), EFalse);

   868                 }

   869 

   870             TDirEnt dirEnt;

   871             MakeDirectoryEntry(*kidFep, dirEnt);

   872             dirEnt.ExternalizeL(fStream);

   873             kidsCount++;

   874             }

   875 

   876         aFe.DropUnmarkedKidsL();

   877 

   878         containerSize = fStream.Sink()->SizeL();

   879         // assumes that this fetch will write the whole directory,

   880         

   881         // i.e. there is no partial fetching for the directories

   882         if(!iFileTable->Volume()->iVolumeTable->

   883            EnsureCacheCanBeAddedL(containerSize))

   884             {

   885             User::Leave(KErrDiskFull);

   886             }

   887         fStream.CommitL();

   888 

   889         CleanupStack::PopAndDestroy(2, &lsSession); // fStream, lsSession

   890 

   891         // if the directory appeared to be childless add it to metadata LRU list

   892         if ( aDirEnts->Count() == 0 )

   893             {

   894             iVolume->iVolumeTable->AddToMetadataLRUPriorityListL(&aFe, ECachePriorityNormal);

   895             }

   896 

   897         }// if directory

   898 

   899     // assumes the files are cached in continuos chunks,

   900     // i.e. always cached up to the last byte fetched

   901     aFe.SetCachedSize(containerSize);

   902 

   903     aFe.SetCached(ETrue);

   904 

   905     // We have to update locally dirty bit for the parent container

   906     if (aFe.Parent())

   907         {

   908         aFe.Parent()->SetLocallyDirty();

   909         }

   910     // But the object itself cannot be remotely dirty any more

   911     aFe.ResetRemotelyDirty();

   912 

   913     // *** from CRsfwFileEngine::DoFetch ***

   914     if (aFe.Type() == KNodeTypeDir)

   915         {

   916         // the reason why kidsCount may be different than aFe.Kids.Count is that for big directories

   917         // some kids could have been removed when adding the others to memory. this is due to memory management cap.

   918         // however this should not happen so often

   919         aFe.KidsCount() == kidsCount ? aFe.iUseCachedData = ETrue : aFe.iUseCachedData = EFalse;

   920         }

   921     else

   922         {

   923         aFe.iUseCachedData = ETrue;

   924         }

   925 

   926     return containerSize;

   927     }

   928 

   929 // ----------------------------------------------------------------------------

   930 // CRsfwFileEngine::RemoteAccessL

   931 // ----------------------------------------------------------------------------

   932 //

   933 CRsfwRemoteAccess* CRsfwFileEngine::RemoteAccessL()

   934     {

   935     DEBUGSTRING(("CRsfwFileEngine::RemoteAccessL"));

   936     if (!iRemoteAccess)

   937         {

   938         User::Leave(KErrNotReady);

   939         }

   940 

   941     // Prevent the inactivity timer from triggering

   942     // in the middle of a remote access operation

   943     StopInactivityTimer();

   944 

   945     return iRemoteAccess;

   946     }

   947 

   948 // ----------------------------------------------------------------------------

   949 // CRsfwFileEngine::OperationCompleted

   950 // ----------------------------------------------------------------------------

   951 //

   952 void CRsfwFileEngine::OperationCompleted()

   953     {

   954     DEBUGSTRING(("File engine operation completed"));

   955     if (iVolume->iVolumeTable->iPermanence)

   956         {

   957         iFileTable->SaveMetaDataDelta();

   958         }

   959         

   960     if (iLockManager && (iLockManager->LockedCount() == 0))

   961         {

   962         // Start timer only if we don't have files open for writing

   963         StartInactivityTimer();

   964         }

   965 

   966     iVolume->OperationCompleted();

   967     }

   968 

   969 // ----------------------------------------------------------------------------

   970 // CRsfwFileEngine::CancelTransaction

   971 // ----------------------------------------------------------------------------

   972 //

   973 void CRsfwFileEngine::CancelTransaction(TUint iTransactionId)

   974     {

   975     DEBUGSTRING(("CRsfwFileEngine::CancelTransactionL"));

   976     if (iRemoteAccess) 

   977         {

   978         iRemoteAccess->Cancel(iTransactionId);

   979         }

   980 

   981     }

   982 

   983 // ----------------------------------------------------------------------------

   984 // CRsfwFileEngine::CancelTransaction

   985 // ----------------------------------------------------------------------------

   986 //

   987 void CRsfwFileEngine::CancelTransactionL(TDesC& aPathName)

   988     {

   989     DEBUGSTRING(("CRsfwFileEngine::CancelTransactionL"));

   990     TPtrC testPtr;

   991     testPtr.Set(aPathName.Right(aPathName.Length() - 3));

   992     HBufC* cancelPath = HBufC::NewLC(KMaxPath);

   993     TPtr cancelPathPtr = cancelPath->Des();

   994     // change '\\' to '/' so the path matches

   995     TLex parser(testPtr);

   996     TChar theChar;

   997     

   998     for (int i = 0; i < testPtr.Length(); i++)

   999         {

  1000         theChar = parser.Get();

  1001         if (theChar == 0) 

  1002             {

  1003             break;

  1004             }

  1005         // assumes that the input string always has "\\" and not just "\"

  1006         // this is true as the input is a file path

  1007         if (theChar != '\\') 

  1008             {

  1009             cancelPathPtr.Append(theChar);

  1010             }

  1011         else 

  1012             {

  1013             cancelPathPtr.Append('/');

  1014             }        

  1015         }

  1016     

  1017     if (iRemoteAccess) 

  1018         {

  1019         iRemoteAccess->Cancel(*cancelPath);

  1020         }

  1021         

  1022     CleanupStack::PopAndDestroy(cancelPath);    

  1023     

  1024     }

  1025 

  1026     

  1027 

  1028     

  1029 // ----------------------------------------------------------------------------

  1030 // CRsfwFileEngine::SetFailedLookup

  1031 // Caches the last failed lookup result

  1032 // ----------------------------------------------------------------------------

  1033 //

  1034 void CRsfwFileEngine::SetFailedLookup(TDesC& aPath, TDesC& aKidName)

  1035 	{

  1036 	iLastFailedLookup = aPath;

  1037 	iLastFailedLookup.Append('/');

  1038 	iLastFailedLookup.Append(aKidName);

  1039 	iLookupTime.HomeTime();

  1040 	DEBUGSTRING16(("SetFailedLookup: %S", &iLastFailedLookup));

  1041 	}

  1042 

  1043 // ----------------------------------------------------------------------------

  1044 // CRsfwFileEngine::ResetFailedLookup

  1045 // Clears the last failed lookup result

  1046 // ----------------------------------------------------------------------------

  1047 //

  1048 void CRsfwFileEngine::ResetFailedLookup()

  1049 	{

  1050 	DEBUGSTRING16(("ResetFailedLookup: %S", &iLastFailedLookup));

  1051 	iLastFailedLookup.Zero();

  1052 	}

  1053 

  1054 // ----------------------------------------------------------------------------

  1055 // CRsfwFileEngine::Volume

  1056 // ----------------------------------------------------------------------------

  1057 //

  1058 CRsfwVolume* CRsfwFileEngine::Volume()

  1059     {

  1060     return iVolume;

  1061     }

  1062 

  1063 // ----------------------------------------------------------------------------

  1064 // CRsfwFileEngine::PrepareCacheL

  1065 // ----------------------------------------------------------------------------

  1066 //

  1067 void CRsfwFileEngine::PrepareCacheL()

  1068     {

  1069     // make sure the file cache (of this volume) exists

  1070     iCacheRoot.Copy(CRsfwRfeServer::Env()->iCacheRoot);

  1071     iCacheRoot.Append('C');

  1072     iCacheRoot.AppendNum(iVolume->iMountInfo.iMountStatus.iVolumeId);

  1073     iCacheRoot.Append('\\');

  1074     

  1075     if (! BaflUtils::FileExists(iFs, iCacheRoot))

  1076         {

  1077         // There was no prior cache directory

  1078         TInt err = iFs.MkDirAll(iCacheRoot);

  1079         DEBUGSTRING(("Cache directory created with err=%d", err));

  1080         User::LeaveIfError(err);

  1081         }

  1082     }

  1083 

  1084 // ----------------------------------------------------------------------------

  1085 // CRsfwFileEngine::GetDirectoryL

  1086 // ----------------------------------------------------------------------------

  1087 //

  1088 TUint CRsfwFileEngine::GetDirectoryL(CRsfwFileEntry& /*aFe*/,

  1089                                  TDesC& aFullName,

  1090                                  RFile& /*aF*/,

  1091                                  RPointerArray<CRsfwDirEnt>* aDirEntsp,

  1092                                  MRsfwRemoteAccessResponseHandler* aCaller)

  1093     {

  1094     return RemoteAccessL()->GetDirectoryL(aFullName, *aDirEntsp, aCaller);

  1095     }

  1096 

  1097 // ----------------------------------------------------------------------------

  1098 // CRsfwFileEngine::BuildContainerPathL

  1099 // ----------------------------------------------------------------------------

  1100 //

  1101 void CRsfwFileEngine::BuildContainerPathL(CRsfwFileEntry& aFe, TDes& aPath)

  1102     {

  1103     if (aPath.MaxLength() < (aPath.Length() + iCacheRoot.Length()))

  1104         {

  1105         aPath.Copy(iCacheRoot);

  1106         }

  1107     else 

  1108         {

  1109         User::Leave(KErrOverflow);

  1110         }

  1111 

  1112     ApplyMultiDirCacheL(aPath);

  1113     // This filename tagging based on container type is just for convenience

  1114     if (aFe.Type() == KNodeTypeFile)

  1115         {

  1116         aPath.Append('F');

  1117         }

  1118     else

  1119         {

  1120         aPath.Append('D');

  1121         }

  1122     aPath.AppendNum((TInt)aFe.Fid().iNodeId);

  1123     }

  1124 

  1125 // ----------------------------------------------------------------------------

  1126 // CRsfwFileEngine::ApplyMultiDirCachePathL

  1127 // Due to Symbian performance problems with huge directories, items will not

  1128 // be stored in one directory in the cache.

  1129 // Now instead one dir like:

  1130 // C:\system\data\rsfw_cache\C16

  1131 // there will be dirs like:

  1132 // C:\system\data\rsfw_cache\C16\M0

  1133 // C:\system\data\rsfw_cache\C16\M1

  1134 // ... and so on