/*

* Copyright (c) 2002 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:  Implementation of class CPEngStorageServer

*

*/

//  Include Files

#include <e32svr.h>

#include <badesca.h>

#include <s32mem.h>

#include "CPEngStorageServer.h"

#include "CPEngStorageSession.h"

#include "CPEngStorageFolder.h"

#include "PEngStorageServerCommon.h"

#include "TPEngServerParams.h"

#include "CPEngHandlerListenEvents.h"

#include "PEngInternalGlobalConsts.h"

#include "CPEngTimer.h"

#include "CPEngActiveScheduler.h"

// Session Slot utility

#include "CPEngSessionSlotId.h"

#include "CPEngSessionSlotState.h"

#include "CPEngSessionSlotEvent.h"

#include "RObjectArray.h"

// Hash Tool

#include "PEngHashTool.h"

// Debug Prints

#include "PresenceDebugPrint.h"

// CONSTANTS

// Init size of the buffer for client server communications

static const TInt KBufferInitSize = 100;

// Static data for Capability check configuration

static const TInt KPEngStoreServRangeCount = 2;

/**

 * Ranges for the Request values

 * All requests will fall in one range

 */

static const TInt PEngStoreServRanges[ KPEngStoreServRangeCount ] =

    {

    // Range from EMainSessShutdownServer to EFolderSubSessNotifyChangedSIDs

    0,

    // range is from EHighestStoreServerRequest request to KMaxInt

    EHighestStoreServerRequest

    };

/**

 * Element indexes for the defined ranges

 * we have only one range and for it is defined only one Element

 */

static const TUint8 KPEngStoreServElementsIndex[ KPEngStoreServRangeCount ] =

    {

    // First element in the element array will be applied for this range

    0,

    // Not supported will be applied for this range

    CPolicyServer::ENotSupported

    };

// Policy elements

static const CPolicyServer::TPolicyElement KPEngStoreServElements[] =

    {

        {

        _INIT_SECURITY_POLICY_C2( ECapabilityReadUserData,

        ECapabilityWriteUserData ),

        CPolicyServer::EFailClient

        }

    };

static const CPolicyServer::TPolicy KPEngServerPolicy =

    {

    // The index into Elements,that is used to check a connection attempt

    0,

    // Number of ranges in the iRanges array

    KPEngStoreServRangeCount,

    // A pointer to an array of ordered ranges of request numbers

    PEngStoreServRanges,

    // A pointer to an array of TUint8 values specifying

    // the appropriate action to take for each range in iRanges

    KPEngStoreServElementsIndex,

    // A pointer to an array of distinct policy elements

    KPEngStoreServElements

    };

// MACROS

#define RETURN_IF_ERROR( aError )\

    if( aError != KErrNone )\

        {\

        return aError;\

        }

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

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

// CPEngStorageServer::CPEngStorageServer

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

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

//

CPEngStorageServer::CPEngStorageServer( TInt aPriority )

        : CPolicyServer( aPriority, KPEngServerPolicy ),

        iRunning( EFalse )

    {

    }

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

// CPEngStorageServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEngStorageServer::ConstructL()

    {

    StartL( KStorageServerName );

    iBuff16.CreateL( KBufferInitSize );

    iBuff8.CreateL( KBufferInitSize );

    // create container collection

    iContainerIx = CObjectConIx::NewL();

    iSubSessionCnt = iContainerIx->CreateL();

    iFoldersCnt = iContainerIx->CreateL();

    iObserversCnt = iContainerIx->CreateL();

    // set up file system enviroment

    User::LeaveIfError( iFs.Connect() );// connect to file server

    // set session to the private folder

    TInt err( iFs.CreatePrivatePath( EDriveC ) );

    if ( err != KErrAlreadyExists )

        {

        User::LeaveIfError( err );

        }

    User::LeaveIfError( iFs.SetSessionToPrivate( EDriveC ) );

    TFileName name;

    iFs.SessionPath( name );

    name.Append( KPEngStorageTempFolder );

    iTempFolder = name.AllocL();

    // make sure we have Storage folder, flush it first and then created

    CFileMan* fileMan = CFileMan::NewL( iFs );

    CleanupStack::PushL( fileMan );

    fileMan->RmDir( *iTempFolder );

    // ignore errors

    iFs.Delete( *iTempFolder );

    CleanupStack::PopAndDestroy(); // fileMan

    // try to create temp folder

    TInt er ( iFs.MkDirAll( *iTempFolder ) );

    if ( er != KErrAlreadyExists )

        {

        User::LeaveIfError( er );

        }

    }

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

// CPEngStorageServer::NewLC

// Two-phased constructor.

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

//

CPEngStorageServer* CPEngStorageServer::NewL( TInt aPriority )

    {

    CPEngStorageServer* self = CPEngStorageServer::NewLC( aPriority );

    CleanupStack::Pop();

    return self;

    }

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

// CPEngStorageServer::NewLC

// Two-phased constructor.

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

//

CPEngStorageServer* CPEngStorageServer::NewLC(  TInt aPriority )

    {

    CPEngStorageServer* self = new( ELeave ) CPEngStorageServer( aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

CPEngStorageServer::~CPEngStorageServer()

    {

    // clean all containers from the objects in it

    // close all elements of the array

    if ( iFoldersCnt )

        {

        for ( TInt x( iFoldersCnt->Count() - 1 ) ; x >= 0  ; --x )

            {

            ( *iFoldersCnt )[ x ]->Close();

            }

        }

    // close all elements of the array

    if ( iObserversCnt )

        {

        for ( TInt y( iObserversCnt->Count() - 1 ) ; y >= 0  ; --y )

            {

            ( *iObserversCnt )[ y ]->Close();

            }

        }

    // all containers are deleted with the collection

    delete iContainerIx;

    // clean file enviroment

    iFs.Close();

    delete iTempFolder;

    // shut down plugin server

    delete iTimeOut;

    iBuff16.Close();

    iBuff8.Close();

    }

// =============================================================================

// =============== Functions from base class ===================================

// =============================================================================

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

// CPEngStorageServer::ExecuteServerL()

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

//

TInt CPEngStorageServer::ExecuteServerL( TPEngServerParams& aParams )

    {

    //Renaming must be done as early as possible

    aParams.RenameMainThread( KStorageServerName );

    TInt res( KErrNone );

    // start scheduler and server

    CPEngActiveScheduler* pA = new( ELeave )CPEngActiveScheduler;

    CleanupStack::PushL( pA );

    CPEngActiveScheduler::Install( pA );

    //If exe server, call RunServerL directly.

    TRAP( res, RunServerL( aParams ) );

    CPEngActiveScheduler::Install( NULL );

    CleanupStack::PopAndDestroy();//pA

    return res;

    }

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

// CPEngStorageServer::StopServer()

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

//

void CPEngStorageServer::StopServer()

    {

    if ( iRunning )

        {

        CPEngActiveScheduler::Stop();

        }

    iRunning = EFalse;

    }

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

// CPEngStorageServer::RunServerL()

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

//

void CPEngStorageServer::RunServerL( TPEngServerParams& aParams )

    {

    PENG_DP( D_PENG_LIT( "CPEngStorageServer::RunServerL()" ) );

    //One instance of server must be allocated here.

    CPEngStorageServer* server = CPEngStorageServer::NewLC( KServerPriority );

    //must die if can't signal client

    aParams.Signal();

    // start fielding requests from clients

    //Thread is ended when CPEngActiveScheduler::Stop is called.

    server->StartServer();

    CleanupStack::PopAndDestroy();//server

    // finished

    }

// =============================================================================

// =============== Functions from the MPEngStorageServer class =================

// =============================================================================

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

// CPEngStorageServer::AddSubSessionL()

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

//

void CPEngStorageServer::AddSubSessionL(

    CObject& aSubSession )

    {

    iSubSessionCnt->AddL( &aSubSession );

    }

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

// CPEngStorageServer::RemoveSubSessionL()

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

//

void CPEngStorageServer::RemoveSubSessionL(

    CObject& aSubSession )

    {

    iSubSessionCnt->Remove( & aSubSession );

    }

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

// CPEngStorageServer::RegisterGlobEventListenerL()

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

//

void CPEngStorageServer::RegisterGlobEventListenerL(

    const RPEngMessage& /* aMessage */,

    TUint32 aSessionId )

    {

    CPEngHandlerListenEvents* reqHandler = FindRequestHandler( aSessionId ,

                                                               EMainSessListenGlobalEvents );

    if ( reqHandler )

        {

        // this handler already exists, not allowed by multiple

        User::Leave( KErrAlreadyExists );

        }

    // create new handler

    reqHandler = CPEngHandlerListenEvents::NewLC( aSessionId );

    iObserversCnt->AddL( reqHandler );

    CleanupStack::Pop(); // newHandler

    }

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

// CPEngStorageServer::CancelRequestL()

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

//

void CPEngStorageServer::CancelRequestL(

    const RPEngMessage& aMessage,

    TUint32 aSessionId )

    {

    CPEngRequestHandler* reqHandler = FindRequestHandler( aSessionId,

                                                          static_cast<TPEngStorageServerMessages> ( aMessage.Int0() ) );

    // ignore if such a request does not exists

    if ( reqHandler )

        {

        reqHandler->CancelRequestD();

        }

    }

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

// CPEngStorageServer::CancelRequestL()

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

//

void CPEngStorageServer::CancelAllSessionRequests(

    TUint32 aSessionId )

    {

    for ( TInt x( iObserversCnt->Count() - 1 ) ;  x >= 0  ; --x )

        {

        CPEngRequestHandler* handler = static_cast<CPEngRequestHandler*>( ( *iObserversCnt )[ x ] );

        if ( handler->SessionId() == aSessionId )

            {

            handler->CancelRequestD();

            }

        }

    }

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

// CPEngStorageServer::ReloadAsynchronousScoutL()

// Reload Asynchronous scout of the async observer

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

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

//

void CPEngStorageServer::ReloadAsynchronousScoutL(

    const RPEngMessage& aMessage,

    TUint32 aSessionId )

    {

    CPEngRequestHandler* reqHandler = FindRequestHandler( aSessionId,

                                                          static_cast<TPEngStorageServerMessages> ( aMessage.Int0() ) );

    if ( !reqHandler )

        {

        // there is not such a request to be reloaded

        User::Leave( KErrArgument );

        }

    reqHandler->ReloadScoutWithNewMessageL( aMessage );

    }

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

// CPEngStorageServer::CreateSessionFolderL()

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

//

void CPEngStorageServer::CreateSessionFolderL(

    const RPEngMessage& aMessage )

    {

    CPEngSessionSlotId* sessId = TranslateSessionIdLC( aMessage );

    CPEngSessionSlotState* state = NULL;

    CPEngStorageFolder* folder = NULL;

    HBufC* stateFile = NULL;

    // load state

    TInt cleanUp ( LoadSessionStateLCX( *sessId, ETrue,

                                        state, folder, stateFile ) );

    // update state with the new application ID

    aMessage.ReadOneDescriptorL( KMessageSlot1, iBuff16 );

    // also create session slot global event for notification

    CPEngSessionSlotEvent* globEvent =  PackGlobEventLC( *state,

                                                         EPEngEventNWSessionSlotCreated,

                                                         iBuff16 );

    TPtr stateFileName( stateFile->Des() );

    UpdateSessionSltStateL( folder, *state, *globEvent, stateFileName );

    // notify about event

    globEvent->PackEventL( iBuff8 );

    NotifyGlobalEvent( iBuff8 );

    // clean globEvent, (state), stateFile, sessId

    CleanupStack::PopAndDestroy( 2 + cleanUp );

    }

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

// CPEngStorageServer::RemoveSessionFolderL()

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

//

void CPEngStorageServer::RemoveSessionFolderL(

    const RPEngMessage& aMessage )

    {

    CPEngSessionSlotId* sessId = TranslateSessionIdLC( aMessage );

    CPEngSessionSlotState* state = NULL;

    CPEngStorageFolder* folder = NULL;

    HBufC* stateFile = NULL;

    // load state

    TInt cleanUp ( LoadSessionStateLCX( *sessId,

                                        EFalse,

                                        state,

                                        folder,

                                        stateFile ) );

    if ( folder )

        {

        // folder is active, refuse any deletion

        User::Leave( KErrInUse );

        }

    // remove registered ID from the session

    aMessage.ReadOneDescriptorL( KMessageSlot1, iBuff16 );

    // also create session slot global event for notification

    CPEngSessionSlotEvent* globEvent =  PackGlobEventLC(

                                            *state,

                                            EPEngEventNWSessionSlotRemoved,

                                            iBuff16 );

    TPtr stateFileName( stateFile->Des() );

    UpdateSessionSltStateL( folder, *state, *globEvent, stateFileName );

    // notify about event

    globEvent->PackEventL( iBuff8 );

    NotifyGlobalEvent( iBuff8 );

    // clean globEvent, (state), stateFile, sessId

    CleanupStack::PopAndDestroy( 2 + cleanUp );

    }

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

// CPEngStorageServer::SessionStateL()

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

//

void CPEngStorageServer::SessionStateL(

    const RPEngMessage& aMessage )

    {

    CPEngSessionSlotId* sessId = TranslateSessionIdLC( aMessage );

    CPEngStorageFolder* folder = FindStorageFolder( *sessId );

    CPEngSessionSlotState* state = NULL;

    if ( folder )

        {

        state = &( folder->SessionSlotState() );

        }

    else

        {

        HBufC* stateFile = NULL;

        state = ReadSessionStatePermanentLC( *sessId, stateFile );

        }

    state->PackDataL( EPureState, iBuff8 );

    TInt err( aMessage.WriteOneDescriptor( KMessageSlot1, iBuff8 ) );

    if ( err == KErrOverflow )

        {

        User::Leave( iBuff8.Length() );

        }

    User::LeaveIfError( err );

    if ( !folder )

        {

        CleanupStack::PopAndDestroy( 2 ); // state, stateFile

        }

    CleanupStack::PopAndDestroy(); // sessId

    }

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

// CPEngStorageServer::AllSessionStatesL()