/*

* Copyright (c) 2002-2004 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:  Client side of Remote Storage FW API access functions.

 *

*/

// INCLUDE FILES

#include "rsfwsession.h"

#include "rsfwinterface.h"

#ifdef __WINS__

#include <e32math.h>

#endif

// CONSTANTS

// Number of message slots to reserve for this client server session.

// Since we only communicate synchronously here, we never have any

// outstanding asynchronous requests.

const TUint KDefaultMessageSlots = 4;

#ifdef __WINS__

const TUint KServerMinHeapSize =   0x1000;  //  4K

const TUint KServerMaxHeapSize = 0x100000;  // 64K

#endif

// ============================ MEMBER FUNCTIONS ==============================

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

// RRsfwSession::RRsfwSession

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

EXPORT_C RRsfwSession::RRsfwSession() : RSessionBase()

    {

    }

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

// RRsfwSession::Connect

// Connects to the framework by starting the server if neccessary and creating

// a session.

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::Connect()

    {

    const TInt KTryCount = 3;

    TInt err;

    TBool retry;

    TInt i = KTryCount;

    do

        {

        err = StartServer(KRfeServerName);

        if (err == KErrNone)

            {

            err = CreateSession(KRfeServerName,

                                Version(),

                                KDefaultMessageSlots);

            }

        retry = ((err == KErrNotFound) || (err == KErrServerTerminated));

        } while (retry && (++i <= KTryCount));

    return err;

    }

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

// RRsfwSession::Close

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

//

EXPORT_C void RRsfwSession::Close()

    {

    }

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

// RRsfwSession::Version

// Returns the version of Remote File Engine

// (other items were commented in a header).

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

//

EXPORT_C TVersion RRsfwSession::Version() const

    {

    return(TVersion(KRfeMajorVersionNumber,

                    KRfeMinorVersionNumber,

                    KRfeBuildVersionNumber));

    }

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

// RRsfwSession::MoveFids

// Sends the rename operation to Remote File Engine by putting the parameters

// into the shared memory chunk, sending the request and reading the result.

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::MoveFids(

    TFid aSourceFid,

    const TDesC& aSourceName,

    TFid aDestFid,

    const TDesC& aDestName,

    TBool aOverWrite) 

    {

    TRfeRenameInArgs* renameArgs = new TRfeRenameInArgs();

    if (!renameArgs) 

        {

        return KErrNoMemory;

        }

    //  TRfeRenameInArgs* writePtr = static_cast<TRfeRenameInArgs*>(iWritePtr);

    renameArgs->iOpCode = ERenameReplace;

    renameArgs->iFid = aSourceFid;

    renameArgs->iSrcName.Copy(aSourceName); 

    renameArgs->iDstFid = aDestFid;

    renameArgs->iDstName.Copy(aDestName);

    renameArgs->iOverWrite = aOverWrite;

    TPckg<TRfeRenameInArgs> pckgInArgs(*renameArgs);

    TInt result = SendRequest(ERenameReplace, aSourceFid.iVolumeId, 

                              TIpcArgs(&pckgInArgs));

    delete renameArgs;

    return result;

    }

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

// RRsfwSession::SetEntry

// (other items were commented in a header).

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

//    

EXPORT_C TInt RRsfwSession::SetEntry(

    const TFid aFid,

    const TTime& aTime,

    TUint aSetAttMask,

    TUint aClearAttMask)

    {  

    TRfeSetAttrInArgs* setEntryArgs = new TRfeSetAttrInArgs();

    if (!setEntryArgs) 

        {

        return KErrNoMemory;

        }

    setEntryArgs->iOpCode = ESetAttr;

    setEntryArgs->iFid = aFid;

    // default: no change

    setEntryArgs->iAttr.iAtt = 0; 

    setEntryArgs->iMask.iAtt = 0; 

    if (aSetAttMask & KEntryAttReadOnly)

        {

        // Set read-only

        setEntryArgs->iAttr.iAtt |= KEntryAttReadOnly;

        setEntryArgs->iMask.iAtt |= KEntryAttReadOnly;

        }

    if (aClearAttMask & KEntryAttReadOnly)

        {

        // Reset read-only

        setEntryArgs->iMask.iAtt |= KEntryAttReadOnly;

        }

    // Setting time

    setEntryArgs->iAttr.iModified = aTime;

    // Let's see - we will not want to do anything unless

    // the attributes convey something significant.

    TInt result = KErrNone;

    if (setEntryArgs->iMask.iAtt)

        {

        TPckg<TRfeSetAttrInArgs> pckgInArgs(*setEntryArgs);

        result = SendRequest(ESetAttr, aFid.iVolumeId, TIpcArgs(&pckgInArgs));

        }       

    delete setEntryArgs;   

    return result;

    }

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

// RRsfwSession::FlushCache

// Flushes the directory cache of a file or directory by putting the parameters

// into the shared memory chunk and sending the request.

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::FlushCache(

    TFid& aFid)

    {

    TRfeIoctlInArgs* ioctlArgs = new TRfeIoctlInArgs();

    if (!ioctlArgs) 

        {

        return KErrNoMemory;

        }

    ioctlArgs->iOpCode = EFsIoctl;

    ioctlArgs->iFid = aFid;

    ioctlArgs->iCmd = ERemoteFsIoctlRefresh;

    ioctlArgs->iLen = 0;

    TPckg<TRfeIoctlInArgs> pckgInArgs(*ioctlArgs);

    TInt result = SendRequest(EFsIoctl, aFid.iVolumeId, TIpcArgs(&pckgInArgs));

    delete ioctlArgs;

    return result;

    }

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

// RRsfwSession::SetHighCachePriority

// Sets higher cache priority for a file by putting the parameters

// into the shared memory chunk and sending the request.

// This feature is not supported currently.

// Perhaps will be implemented in near future.

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::SetHighCachePriority(TFid& /* aFid */)

    {

    return KErrNotSupported;

    } 

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

// RRsfwSession::GetAttributes

// Sends GetAttr operation to Remote File Engine by putting the parameters

// into the shared memory chunk, sending the request and reading the result. 

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::GetAttributes(

    TFid aFileFid, 

    TEntry& aAttributes)

    {

    TRfeGetAttrInArgs* getattrArgs = new TRfeGetAttrInArgs();

    if (!getattrArgs) 

        {

        return KErrNoMemory;

        }

    TRfeGetAttrOutArgs* getattrOutArgs = new TRfeGetAttrOutArgs();

    if (!getattrOutArgs) 

        {

        return KErrNoMemory;

        }   

    getattrArgs->iOpCode = EGetAttr;

    getattrArgs->iFid = aFileFid;

    TPckg<TRfeGetAttrInArgs> pckgInArgs(*getattrArgs);

    TPckg<TRfeGetAttrOutArgs> pckgOutArgs(*getattrOutArgs);

    TInt result = SendRequest(EGetAttr, aFileFid.iVolumeId, 

                              TIpcArgs(&pckgInArgs, &pckgOutArgs));

    if (result == KErrNone) 

        {

        // Note that aAttributes.iType (the entry UID)

        // should only be set for a file whose

        // size is greater than or equal to sizeof(TCheckedUid).

        aAttributes.iAtt = getattrOutArgs->iAttr.iAtt;

        aAttributes.iSize = getattrOutArgs->iAttr.iSize;

        aAttributes.iModified = getattrOutArgs->iAttr.iModified;

        aAttributes.iType = KNullUid;       

        }

    delete getattrArgs;

    delete getattrOutArgs;

    return result;

    }

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

// RRsfwSession::OpenByPathL

// Sends OpenByPath operation to Remote File Engine by putting the parameters

// into the shared memory chunk, sending the request and reading the result. 

// Remote File Engine returns the path of the cache container file for this fid

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::OpenByPath(

    TFid aFid,

    TDes& aContainerPath,

    TDirEntAttr* aAttributes,

    TBool aTrueOpen)

    {

    TRfeOpenByPathInArgs* openbypathArgs = new TRfeOpenByPathInArgs();

    if (!openbypathArgs) 

        {

        return KErrNoMemory;

        }

    TRfeOpenByPathOutArgs* openbypathOutArgs = new TRfeOpenByPathOutArgs();

    if (!openbypathOutArgs) 

        {

        return KErrNoMemory;

        }

    openbypathArgs->iOpCode = EOpenByPath;

    openbypathArgs->iFid = aFid;

    // Flag field is used to pass attributes,

    // which indicate which lock should be obtained for the file

    if (aAttributes)

        {

        openbypathArgs->iFlags = aAttributes->iAtt;

        }

    else

        {

        openbypathArgs->iFlags = 0;

        }

    // tells whether the file is really opened or do we need it because 

    // ReadSection() was called... (in the latter case Symbian File Server 

    // does not open the file...) */

    openbypathArgs->iTrueOpen = aTrueOpen;

    TPckg<TRfeOpenByPathInArgs> pckgInArgs(*openbypathArgs);

    TPckg<TRfeOpenByPathOutArgs> pckgOutArgs(*openbypathOutArgs);

    TInt result = SendRequest(EOpenByPath, aFid.iVolumeId, TIpcArgs(&pckgInArgs, &pckgOutArgs));

    if (result == KErrNone) 

        {

        if (aAttributes)

            {

            *aAttributes = openbypathOutArgs->iAttr;

            }

        // Processing the response

        _LIT(KPathRedundancy, "\\.\\");

        TInt j = openbypathOutArgs->iPath.Find(KPathRedundancy);

        if (j != KErrNotFound)

            {

            TInt i = openbypathOutArgs->iPath.Length();

            TInt k;

            for (k = j; k + 2 < i; k++)

                {

                openbypathOutArgs->iPath[k] =

                    openbypathOutArgs->iPath[k + 2];

                }

            openbypathOutArgs->iPath.SetLength(i - 2);

            }

        const TInt maximumLength = aContainerPath.MaxLength();

        if (maximumLength >= openbypathOutArgs->iPath.Length())

            {

            aContainerPath.Copy(openbypathOutArgs->iPath);

            }

        else

            {

            aContainerPath.Copy(

                openbypathOutArgs->iPath.Left(maximumLength));

            }

        }

    delete openbypathArgs;

    delete openbypathOutArgs;

    return result;

    }

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

// RRsfwSession::RfeInit

// Gets the fid of the root of the mount for Remote File Engine by putting the 

// parameters into the shared memory chunk, sending the request and reading 

// the result.  

// This allows us to get other fids by lookup(). 

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::RfeInit(TFid& aRootFid)

    {

    TRfeRootInArgs* rootArgs = new TRfeRootInArgs();

    if (!rootArgs) 

        {

        return KErrNoMemory;

        }

    TRfeRootOutArgs* rootOutArgs = new TRfeRootOutArgs();

    if (!rootOutArgs) 

        {

        return KErrNoMemory;

        }

    rootArgs->iOpCode = EFsRoot;

    rootArgs->iFid.iVolumeId = 0;

    rootArgs->iFid.iNodeId = 0;

    TPckg<TRfeRootInArgs> pckgInArgs(*rootArgs);

    TPckg<TRfeRootOutArgs> pckgOutArgs(*rootOutArgs);

    TInt result = SendRequest(EFsRoot, aRootFid.iVolumeId, 

                              TIpcArgs(&pckgInArgs, &pckgOutArgs));

    if (result == KErrNone) 

        {

        aRootFid  = rootOutArgs->iFid;

        }

    delete rootArgs;

    delete rootOutArgs;

    return result;    

    }

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

// RRsfwSession::MakeDirectoryL

// Sends MkDir operation to Remote File Engine by putting the parameters

// into the shared memory chunk, sending the request and reading the result. 

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::MakeDirectory(

    TFid aParentFid, 

    const TDesC& aDirName)

    {

    TRfeMkdirInArgs* mkdirArgs = new TRfeMkdirInArgs();

    if (!mkdirArgs) 

        {

        return KErrNoMemory;

        }   

    mkdirArgs->iOpCode = EMkDir;

    mkdirArgs->iFid = aParentFid;

    mkdirArgs->iEntry.iName.Copy(aDirName);

    mkdirArgs->iEntry.iAttr.iAtt = 0; // not read only

    TPckg<TRfeMkdirInArgs> pckgInArgs(*mkdirArgs);

    TInt result = SendRequest(EMkDir,

                              aParentFid.iVolumeId,

                              TIpcArgs(&pckgInArgs));

    delete mkdirArgs;

    return result;

    }

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

// RRsfwSession::RemoveDirectoryL

// Sends Remove Directory operation to Remote File Engine by putting the 

// parameters into the shared memory chunk, sending the request and reading 

// the result. 

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::RemoveDirectory(

    TFid aParentFid, 

    const TDesC& aDirName)

    {

    TRfeRmdirInArgs* rmdirArgs = new TRfeRmdirInArgs();

    if (!rmdirArgs) 

        {

        return KErrNoMemory;

        }

    rmdirArgs->iOpCode = ERemoveDir;

    rmdirArgs->iFid = aParentFid;

    rmdirArgs->iName.Copy(aDirName);

    TPckg<TRfeRmdirInArgs> pckgInArgs(*rmdirArgs);

    TInt result = SendRequest(ERemoveDir,

                              aParentFid.iVolumeId,

                              TIpcArgs(&pckgInArgs));

    delete rmdirArgs;

    return result;

    }

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

// RRsfwSession::CreateFileL

// Sends Create File operation to Remote File Engine by putting the parameters

// into the shared memory chunk, sending the request and reading the result.

// (other items were commented in a header).

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

//

EXPORT_C TInt RRsfwSession::CreateFile(

    TFid aParentFid,

    const TDesC& aFileName,

    TUint aMode,

    TUint aExcl,

    TFid& aNewFid)

    {

    TRfeCreateInArgs* createArgs = new TRfeCreateInArgs();

    if (!createArgs) 

        {

        return KErrNoMemory;

        }

    TRfeCreateOutArgs* createOutArgs = new TRfeCreateOutArgs();

    if (!createOutArgs) 

        {

        return KErrNoMemory;

        }

    createArgs->iOpCode = ECreateFile;

    createArgs->iFid = aParentFid;

    createArgs->iEntry.iName.Copy(aFileName);

    if (aMode & EFileWrite)

        {

        createArgs->iEntry.iAttr.iAtt = 0;

        }

    else

        {

        createArgs->iEntry.iAttr.iAtt = KEntryAttReadOnly;

        }

    createArgs->iEntry.iAttr.iSize = 0;

    createArgs->iEntry.iAttr.iModified = 0;

    createArgs->iExcl = aExcl;

    TPckg<TRfeCreateInArgs> pckgInArgs(*createArgs);

    TPckg<TRfeCreateOutArgs> pckgOutArgs(*createOutArgs);

    TInt result = SendRequest(ECreateFile,

                              aParentFid.iVolumeId,

                              TIpcArgs(&pckgInArgs, &pckgOutArgs));

    if (result == KErrNone) 

        {

        aNewFid = createOutArgs->iFid;

        }

    delete createArgs;

    delete createOutArgs;   

    return result;

    }