/*

* Copyright (c) 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:  XIMP Framework PSC server class

 *

*/

#include "ximpserverdefs.h"

#include "ximpserver.h"

#include "ximpserversessionadapter.h"

#include "ximptrace.h"

#include "ximpglobals.h"

#include "ximpoperationfactoryimp.h"

#include <ecom/ecom.h>

//Include PSC server namespace

using namespace NXIMPSrv;

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

// =============== PLATSEC POLICY CONFIGURATION =================

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

static const TInt KXIMPServerPlatSecRangeCount = 3;

static const TInt KXIMPServerPlatSecPolicyIndex0 = 0;

static const TInt KXIMPServerPlatSecPolicyIndex1 = 1;

//Ranges for the Request values

static const TInt KXIMPServerPlatSecRanges[ KXIMPServerPlatSecRangeCount ] =

    {

    0,

    NRequest::ECtxSsQueueBindOperation,

    NRequest::EOpCodeTop

    };

// Element indexes for the defined ranges

static const TUint8 KXIMPServerPlatSecElementsIndex[ KXIMPServerPlatSecRangeCount ] =

    {

    KXIMPServerPlatSecPolicyIndex0,

    KXIMPServerPlatSecPolicyIndex1,

    CPolicyServer::ENotSupported

    };

// Policy elements

static const CPolicyServer::TPolicyElement KXIMPServerPlatSecElements[] =

    {

        {

        // Policy 0, KXIMPServerPlatSecPolicyIndex0

        _INIT_SECURITY_POLICY_C3( ECapabilityReadUserData,

                                  ECapabilityWriteUserData,

                                  ECapabilityNetworkServices ),

        CPolicyServer::EFailClient

        },

        {

        // Policy 1, KXIMPServerPlatSecPolicyIndex1

        _INIT_SECURITY_POLICY_C4( ECapabilityReadDeviceData,

                                  ECapabilityReadUserData,

                                  ECapabilityWriteUserData,

                                  ECapabilityNetworkServices ),

        CPolicyServer::EFailClient

        }

    };

// The platsec policy

static const CPolicyServer::TPolicy KXIMPServerPlatSecPolicy =

    {

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

    KXIMPServerPlatSecPolicyIndex0,

    // Number of ranges in the iRanges array

    KXIMPServerPlatSecRangeCount,

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

    KXIMPServerPlatSecRanges,

    // A pointer to an array of TUint8 values specifying

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

    KXIMPServerPlatSecElementsIndex,

    // A pointer to an array of distinct policy elements

    KXIMPServerPlatSecElements

    };

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

// CXIMPServer::ExecuteL()

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

//

void CXIMPServer::ExecuteL()

    {

    // start scheduler

    CActiveScheduler* pA = new( ELeave )CActiveScheduler;

    CleanupStack::PushL( pA );

    CActiveScheduler::Install( pA );

    // create server

    CXIMPServer* server = CXIMPServer::NewLC();

    // rename our thread properly

    // first, find out the UID set by process starter

    TInt uid = 0;

    TInt ret = User::GetTIntParameter( NStartupParam::KProtocolUidIndex,

                                       uid );

    User::LeaveIfError( ret );

    // create the "!XIMPCtxSrv9bde667a" server name

    HBufC* serverName = HBufC::NewLC( NName::KSymbianServer().Length() +

                                      NStartupParam::KProtocolUidMaxLen +

                                      1 );

    serverName->Des().Copy( NName::KSymbianServer );

    serverName->Des().AppendNumFixedWidth( uid,

                                           EHex,

                                           NStartupParam::KProtocolUidMaxLen );

    // and set it

    User::RenameThread( *serverName );

    server->StartL( *serverName );

    CleanupStack::PopAndDestroy( serverName );

    //Signal client that we are started

    RProcess().Rendezvous( KErrNone );

    //Execute the server

    CActiveScheduler::Start(); // CSI: 3 #

    //Cleanup

    CleanupStack::PopAndDestroy( server );//server

    CleanupStack::PopAndDestroy( pA );

    CActiveScheduler::Install( NULL );

    }

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

// CXIMPServer::~CXIMPServer()

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

//

CXIMPServer::~CXIMPServer()

    {

    CXIMPGlobals::UninstallD();

    REComSession::FinalClose();

    #if _BullseyeCoverage

    cov_write();

    #endif    

    }

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

// CXIMPServer::CXIMPServer()

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

//

CXIMPServer::CXIMPServer()

    : CPolicyServer( CActive::EPriorityStandard, KXIMPServerPlatSecPolicy )

    {

    iSessionId = 1;   // start from 1. 0 reserved for host-originated operations

    }

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

// CXIMPServer::NewLC()

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

//

CXIMPServer* CXIMPServer::NewLC()

    {

    CXIMPServer* self = new( ELeave ) CXIMPServer;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CXIMPServer::ConstructL()

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

//

void CXIMPServer::ConstructL()

    {

    CXIMPOperationFactory* operationFactory = CXIMPOperationFactory::NewL();

    CleanupStack::PushL( operationFactory );

    CXIMPGlobals::InstallL( operationFactory, this );

    CleanupStack::Pop( operationFactory );

    iGlobals = CXIMPGlobals::Instance();

    }

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

// CXIMPServer::NewSessionL()

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

//

CSession2* CXIMPServer::NewSessionL( const TVersion &aVersion,

                                        const RMessage2& /* aMessage */ ) const

    {

    TVersion srvVersion( NVersion::KMajor,

                         NVersion::KMinor,

                         NVersion::KBuild );

    if( !User::QueryVersionSupported( aVersion, srvVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

    CXIMPServer* self = const_cast< CXIMPServer* >( this );

    self->iSessionId++;

    return CXIMPServerSessionAdapter::NewL( iSessionId, 

                                               *self );

    };

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

// CXIMPServer::SessionCreated()

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

//

void CXIMPServer::SessionCreated()

    {

    iSessionCount++;

    }

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

// CXIMPServer::SessionDied()

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

//

void CXIMPServer::SessionDied()

    {

    iSessionCount--;

    TryToStopScheduling();

    }

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

// CXIMPServer::AllHostsDied()

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

//

void CXIMPServer::AllHostsDied()

    {

    // all hosts have died.

    iAllHostsDied = ETrue;

    TryToStopScheduling();

    }

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

// CXIMPServer::AllHostsDied()

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

//

void CXIMPServer::TryToStopScheduling()

    {

    if( iSessionCount == 0 && iAllHostsDied )

        {

        CActiveScheduler::Stop(); // CSI: 4 #

        }    

    }

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

// CXIMPServer::TestListener()

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

//

MXIMPSrvTestListener* CXIMPServer::TestListener() const

    {

    return iTestListener;

    }

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

// CXIMPServer::RegisterTestListener()

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

//

void CXIMPServer::RegisterTestListener( MXIMPSrvTestListener* aTestSession )

    {

    iTestListener = aTestSession;

    }

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

// E32Main()

// ENTRY POINT

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

//

GLDEF_C TInt E32Main()

    {

    TRACE( _L("PSC Server E32Main - enter") );

    __UHEAP_MARK;

    CTrapCleanup* tc = CTrapCleanup::New();

    if( !tc )

        {

        return KErrNoMemory;

        }

    User::RenameThread( NName::KMainThread );

    TRAPD( err, CXIMPServer::ExecuteL() );

    delete tc;

    __UHEAP_MARKEND;

    TRACE_1( _L("PSC Server E32Main - exit: %d"), err );

    return err;

    }

//  END OF FILE