/*

* 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:  Remote File Engine session manager

*

*/

// INCLUDE FILES

#include <e32cons.h>

#include <e32std.h>

#include <e32svr.h>

#include <e32std.h>

#include <f32file.h>

#include "rsfwcommon.h"

#include "rsfwinterface.h"

#include "rsfwrfesession.h"

#include "rsfwremoteaccess.h"

#include "mdebug.h"

#include "rsfwrfeserver.h"

#include "rsfwrfemessagerequest.h"

#include "rsfwrequestallocator.h"

#include "rsfwrfeoperation.h"

#include "rsfwrfesyncoperation.h"

#include "rsfwrfeasyncoperation.h"

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

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

// CRsfwRfeSession::NewL

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

//

CRsfwRfeSession* CRsfwRfeSession::NewL(CRsfwRfeServer& aServer)

    {

    CRsfwRfeSession* self = CRsfwRfeSession::NewLC(aServer);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwRfeSession::NewLC

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

//

CRsfwRfeSession* CRsfwRfeSession::NewLC(CRsfwRfeServer& aServer)

    {

    // the following debug print crashes easily with USER 24:

 //   DEBUGSTRING(("CRsfwRfeSession::NewLC"));

    CRsfwRfeSession* self;

    self = new (ELeave) CRsfwRfeSession(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CRsfwRfeSession::CRsfwRfeSession

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

//

CRsfwRfeSession::CRsfwRfeSession(CRsfwRfeServer& aServer) :

    CSession2(),

    iRfeServer(aServer)

    {

    // Implementation not required

    }

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

// CRsfwRfeSession::ConstructL

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

//

void CRsfwRfeSession::ConstructL()

    {

    iVolumes = iRfeServer.iVolumes;

    iRfeServer.IncrementSessions();

    for (int i = 0; i < KDefaultMessageSlots; i++ ) 

        {

        iMessageRequests[i] = NULL;

        }

    }

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

// CRsfwRfeSession::~CRsfwRfeSession

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

//

CRsfwRfeSession::~CRsfwRfeSession()

    {

    // When the sessions are shared we don't know which

    // volumes can be freed at session shutdown 

    iRfeServer.DecrementSessions();

    }

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

// CRsfwRfeSession::DisconnectL

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

//

void CRsfwRfeSession::Disconnect(const RMessage2& aMessage)

    {

    // in all messages pending completion for this session

    // mark the session as NULL so that we do not try to complete them later

    for (int i = 0 ; i <KDefaultMessageSlots ; i++)

        {

        CRsfwRfeMessageRequest* mesrequest = iMessageRequests[i];

        if (mesrequest)

            {

            mesrequest->SetSession(NULL);

            }

        }

    CSession2::Disconnect(aMessage);   

    }

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

// CRsfwRfeSession::ServiceL

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

//

void CRsfwRfeSession::ServiceL(const RMessage2& aMessage)

    {  

    DEBUGSTRING16(("CRsfwRfeSession::ServiceL(), function %d", aMessage.Function()));

    iRfeServer.ServiceRequested();

    if(aMessage.Function() >= EMaxRfeOperations)

        {

        aMessage.Complete(KErrNotSupported);

        return;

        }

    CRsfwRfeMessageRequest* pR = NULL;

    pR=RsfwRequestAllocator::GetMessageRequest(aMessage, this);

    if (!pR)

        {

        aMessage.Complete(KErrNoMemory);

        return;

        }

    SetToMessageRequestArray(pR);

    // if volume was not found and this was a file system request

    // (not a mounting request), we have completed now with

    // KErrNotReady

    if (pR->iMessageCompleted) 

        {

        delete pR;

        return;

        }

    CRsfwRfeOperation* pO = NULL;

    pO = GetOperation(pR, aMessage.Function());

    if(!pO)

        { 

        delete pR;

        aMessage.Complete(KErrNoMemory);

        return;

        }

    // Request will take ownership of the operation

    pR->SetOperation(pO);   

    pR->Dispatch();

    }

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

// CRsfwRfeSession::SetToMessageRequestArray

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

//

void CRsfwRfeSession::SetToMessageRequestArray(CRsfwRfeMessageRequest* aMessageRequest)

    {  

    // set message request to the message request array

    for (int i = 0; i < KDefaultMessageSlots; i++) 

        {

        if (iMessageRequests[i] == NULL) 

            {

            // completely unused slot

            iMessageRequests[i] = aMessageRequest;

            break;

            }

        }

    }

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

// CRsfwRfeSession::RemoveFromMessageRequestArray

// call by request prior to self-destruction

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

//

void CRsfwRfeSession::RemoveFromMessageRequestArray(CRsfwRfeMessageRequest* aMessageRequest)

    {  

    // set message request to the message request array

    for (int i = 0; i < KDefaultMessageSlots; i++) 

        {

        if (iMessageRequests[i] == aMessageRequest) 

            {

            iMessageRequests[i] = NULL;

            }

        }

    }

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

// CRsfwRfeSession::Volume

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

//

CRsfwVolumeTable* CRsfwRfeSession::Volume() 

    {

    return iVolumes;

    }

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

// CRsfwRfeSession::Server

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

//

CRsfwRfeServer* CRsfwRfeSession::Server() 

    {

    return &iRfeServer;

    }

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

// CRsfwRfeSession::GetOperation

// Sets operations to be synchronous or asynhronous

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

//

CRsfwRfeOperation* CRsfwRfeSession::GetOperation(CRsfwRfeRequest* aRequest, TInt aOpCode)

    {

    CRsfwRfeOperation* pO = NULL;

    switch (aOpCode)

        {

    case EDismountByVolumeId:

    case EDismountByDriveLetter:

    case EGetMountList:

    case EGetMountInfo:

    case EFsRoot:

    case EOkToWrite:

    case ESetAttr:

    case EFsIoctl:

    case EDirRefresh:

    case ECancelAll:

        pO = RsfwRequestAllocator::GetSyncOperation(aRequest, aOpCode);

        break;

    case EMount:

    case EMountByDriveLetter:

    case ESetMountConnectionState:

    case ERenameReplace:        

    case EOpenByPath:

    case EFetch:

    case EFetchData:

    case ELookUp:

    case EGetAttr:

    case EMkDir:

    case ERemoveDir:

    case ERemove:

    case ECreateFile:

    case EClose:

    case EFlush:

        pO = RsfwRequestAllocator::GetAsyncOperation(aRequest, aOpCode);

        break;

    default:

       __ASSERT_DEBUG(FALSE, User::Panic(KRfeServer, EUndefinedRequest));

        // if this happens even in release build

        // pO will stay NULL and the request is completed with KErrNoMemory...

        }

    return pO; 

    }

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

// CRsfwRfeSession::PanicClient

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

//

#ifdef NONSHARABLE_SESSION

void CRsfwRfeSession::PanicClient(TInt aPanic) const

    {

    // Note: this panics the client thread, not server

    Panic(KRfeServer, aPanic);

    }

#endif

// End of File