1 /*

     2 * Copyright (c) 2005-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:  Encapsulated all sync operations

    15 *

    16 */

    17 

    18 

    19 #include "rsfwsyncoperations.h"

    20 #include "rsfwrfemessagerequest.h"

    21 #include "rsfwvolumetable.h"

    22 #include "rsfwvolume.h"

    23 #include "rsfwfileengine.h"

    24 #include "rsfwfiletable.h"

    25 #include "rsfwfileentry.h"

    26 #include "rsfwrfesession.h"

    27 #include "rsfwinterface.h"

    28 #include "rsfwcontrol.h"

    29 #include "mdebug.h"

    30 

    31    

    32 // ----------------------------------------------------------------------------

    33 // TRFeSynCRsfwRfeRequest::DoRequestL

    34 // wrapper for all sync requests

    35 // ----------------------------------------------------------------------------

    36 // 

    37 void TRFeSynCRsfwRfeRequest::DoRequestL(CRsfwRfeRequest* aRequest) 

    38     {

    39     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

    40     request->Session()->Volume()->DispatchL(request->iInArgs,

    41                                             request->iOutArgs);

    42     }

    43 

    44 // ----------------------------------------------------------------------------

    45 // TRFeDismountVolumeId::DoRequestL

    46 // dismount a previously mounted volume by volume ID

    47 // ----------------------------------------------------------------------------

    48 //  

    49 void TRFeDismountVolumeId::DoRequestL(CRsfwRfeRequest* aRequest)

    50     {

    51     DEBUGSTRING(("TRFeDismountVolumeId::DoRequestL"));

    52     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

    53     TInt volumeId = reinterpret_cast<TInt>(request->Message().Ptr0());

    54     DEBUGSTRING(("EDismount: volume %d", volumeId));

    55     request->Session()->Volume()->DismountByVolumeIdL(volumeId, ETrue);

    56     // This is called from the fileserver main thread.

    57     // Therefore, we should return quickly.

    58     }

    59     

    60 // ----------------------------------------------------------------------------

    61 // TRFeDismountByDriveLetter::DoRequestL

    62 // dismount a previously mounted volume by drive letter

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

    64 //   

    65 void TRFeDismountByDriveLetter::DoRequestL(CRsfwRfeRequest* aRequest)

    66     {

    67     DEBUGSTRING(("TRFeDismountByDriveLetter::DoRequestL"));

    68     // Dismount a volume by drive letter

    69     // synchronous request

    70     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

    71     TChar driveLetter = reinterpret_cast<TInt>(request->Message().Ptr0());

    72     DEBUGSTRING(("EDismountByDriveLetter: '%c'", TUint(driveLetter)));

    73     request->Session()->Volume()->DismountByDriveLetterL(driveLetter, ETrue); 

    74     }

    75 

    76 

    77 // ----------------------------------------------------------------------------

    78 // TRFeGetMountList::DoRequestL

    79 // get a list of currently active mounts

    80 // ----------------------------------------------------------------------------

    81 //      

    82 void TRFeGetMountList::DoRequestL(CRsfwRfeRequest* aRequest)

    83     {

    84     DEBUGSTRING(("TRFeGetMountList::DoRequestL"));

    85     // synchronous request

    86     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

    87     TDriveList mountList;

    88     request->Session()->Volume()->GetMountList(mountList);

    89     TPckg<TDriveList> p(mountList);

    90     request->Message().WriteL(0, p);

    91     DEBUGSTRING8(("EGetMountList: '%S'", &mountList));

    92     }

    93 

    94 

    95 // ----------------------------------------------------------------------------

    96 // TRFeGetMountInfo::DoRequestL

    97 // get information about a specific mount

    98 // ----------------------------------------------------------------------------

    99 //        

   100 void TRFeGetMountInfo::DoRequestL(CRsfwRfeRequest* aRequest)

   101     {

   102     DEBUGSTRING(("TRFeGetMountInfo::DoRequestL"));

   103     // synchronous request

   104     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

   105     TRsfwMountInfo* mountInfo = new (ELeave) TRsfwMountInfo;

   106     CleanupStack::PushL(mountInfo);

   107     mountInfo->iMountConfig.iDriveLetter = 

   108         reinterpret_cast<TInt>(request->Message().Ptr0());

   109     TInt err = request->Session()->Volume()->GetMountInfo(*mountInfo);

   110     DEBUGSTRING(("EGetMountInfo for '%c' (err=%d)",

   111                  TUint(mountInfo->iMountConfig.iDriveLetter),

   112                  err));

   113     if (err != KErrNone)

   114         {

   115         mountInfo->iMountConfig.iUri.Zero();

   116         }

   117     TPckg<TRsfwMountInfo> mountInfoPackage(*mountInfo);

   118     request->Message().WriteL(1, mountInfoPackage);

   119     CleanupStack::PopAndDestroy(mountInfo);

   120     }  

   121     

   122     

   123 // ----------------------------------------------------------------------------

   124 // TRFeWriteData::DoRequestL

   125 // get permission to write certain amount of data

   126 // ----------------------------------------------------------------------------

   127 //    

   128 void TRFeWriteData::DoRequestL(CRsfwRfeRequest* aRequest) 

   129     {

   130     DEBUGSTRING(("TRFeWriteData::DoRequestL"));

   131     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

   132     TRfeWriteDataInArgs* inArgs =

   133         static_cast<TRfeWriteDataInArgs*>(request->iInArgs);

   134     TRfeWriteDataOutArgs* outArgs =

   135         static_cast<TRfeWriteDataOutArgs*>(request->iOutArgs);

   136     outArgs->iOkToWrite =

   137         request->iVolumeTable->EnsureCacheCanBeAddedL(inArgs->iBytes); 

   138         

   139     if (outArgs->iOkToWrite)  

   140         {

   141         // make sure "dirty bit" is on (file has uncommited modifications)

   142         CRsfwFileEntry* entry= 

   143             request->iVolume->iFileEngine->iFileTable->Lookup(inArgs->iFid);

   144         if (entry) 

   145             {

   146             entry->SetOpenedForWriting(ETrue);

   147             request->iVolume->iFileEngine->iFileTable->SaveMetaDataDelta();

   148             }

   149         // if writing has been cancelled, we have to inform the file server plugin

   150         if (entry->IsCancelled()) 

   151             {

   152             User::Leave(KErrCancel);

   153             }

   154         

   155         }

   156     }

   157 

   158 void TRFeDirectoryRefresh::DoRequestL(CRsfwRfeRequest* aRequest) 

   159     {

   160     DEBUGSTRING(("TRFeDirectoryRefresh::DoRequestL"));

   161     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

   162     HBufC* refreshBuf = HBufC::NewLC(KMaxPath);

   163     TPtr refPtr = refreshBuf->Des();

   164     request->Message().ReadL(0, refPtr);

   165     User::LeaveIfError(request->Session()->Volume()->PurgeFromCache(refPtr));

   166     CleanupStack::PopAndDestroy(refreshBuf);

   167     }

   168 

   169 

   170 void TRFeCancelAll::DoRequestL(CRsfwRfeRequest* aRequest)

   171     {

   172     DEBUGSTRING(("TRFeCancelAll::DoRequestL"));

   173     CRsfwRfeMessageRequest* request = (CRsfwRfeMessageRequest*) aRequest;

   174     HBufC* fileBuf = HBufC::NewLC(KMaxPath);

   175     TPtr filePtr = fileBuf->Des();

   176     request->Message().ReadL(0, filePtr);

   177     User::LeaveIfError(request->Session()->Volume()->CancelTransferL(filePtr));

   178     CleanupStack::PopAndDestroy(fileBuf);

   179     }

   180