/*
* Copyright (c) 2003 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:  Smart card server
*
*/



// INCLUDE FILES
#include    "ScardBase.h"
#include    "ScardClsv.h"
#include    "ScardServerBase.h"
#include    "ScardServer.h"
#include    "WimTrace.h"

// MODULE DATA STRUCTURES
struct TThreadParameter
    {
    RSemaphore  iSemaphore;
    TInt        iPanicCode;
    };

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

// -----------------------------------------------------------------------------
// CScardServer::CScardServer
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CScardServer::CScardServer()
    : CServer2( EPriorityStandard )
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::CScardServer|Begin"));
    }

// -----------------------------------------------------------------------------
// CScardServer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CScardServer::ConstructL()
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::ConstructL|Begin"));
    iNotifyRegistry = CScardNotifyRegistry::NewL( this );
    iControlRegistry = CScardAccessControlRegistry::NewL( this );
    iReaderFactoryRegistry = CScardReaderRegistry::NewL( this );
    iResourceRegistry = CScardResourceRegistry::NewL( this );
    iConnectionRegistry = CScardConnectionRegistry::NewL( this );
    }

// -----------------------------------------------------------------------------
// CScardServer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CScardServer* CScardServer::NewL()
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::NewL|Begin"));
    CScardServer* self = new( ELeave ) CScardServer;
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    TPtrC tempName;
    tempName.Set( KScardServerName );
    HBufC* pName = tempName.Alloc();
    //Again these panics EPR
    __ASSERT_ALWAYS( pName,
        PanicServer( KScServerPanicSvrCreateServer ) );
    
    self->iName = pName; // Ownership moves

    // Start the server
    TPtr name = self->iName->Des();     
    TInt r = self->Start( name );
    __ASSERT_ALWAYS( r == KErrNone,
        PanicServer( KScServerPanicSvrCreateServer ) );

    return self;
    }

    
// Destructor
CScardServer::~CScardServer()
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::~CScardServer|Begin"));
    delete iNotifyRegistry;
    delete iControlRegistry;
    delete iReaderFactoryRegistry;
    delete iResourceRegistry;
    delete iConnectionRegistry;
    }


// -----------------------------------------------------------------------------
// CScardServer::PanicServer
// Panics the server
// -----------------------------------------------------------------------------
//
void CScardServer::PanicServer( const TInt aPanic )
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::PanicServer|Begin"));
    User::Panic( _L( "ScardServer" ), aPanic );
    }

// -----------------------------------------------------------------------------
// CScardServer::NewSessionL
// Create a new client session for this server.
// -----------------------------------------------------------------------------
//
CSession2* CScardServer::NewSessionL(
    const TVersion& aVersion, const RMessage2& /*aMessage*/ ) const
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::NewSessionL|Begin"));
    // check version is ok
    TVersion v( KScardServMajorVersionNumber, KScardServMinorVersionNumber, 
        KScardServBuildVersionNumber );
    if ( !User::QueryVersionSupported( v, aVersion ) )
        {
        User::Leave( KErrNotSupported );
        }

    // make new session
    return CScardSession::NewL( const_cast< CScardServer* >( this ) );
    }

// -----------------------------------------------------------------------------
// CScardServer::ThreadFunction
// Start active scheduler and do other new thread things
// -----------------------------------------------------------------------------
//
GLDEF_C TInt CScardServer::ThreadFunction( TAny* aStarted )
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::ThreadFunction|Begin"));
    //  convert argument to initial data
    TThreadParameter& data = *(static_cast< TThreadParameter* >( aStarted ) );
    RSemaphore& started = data.iSemaphore;

    data.iPanicCode = KErrNone;
    
    // create cleanup stack
    if ( !CTrapCleanup::New() )
        {
        data.iPanicCode = KScServerPanicCreateTrapCleanup;
        started.Signal();
        PanicServer( KScServerPanicCreateTrapCleanup );
        }

    // construct and install active scheduler
    if ( !CActiveScheduler::Current() ) //Check if scheduler already started
        {
        CActiveScheduler* scheduler = new CActiveScheduler;
        if ( !scheduler )
            {
            data.iPanicCode = KScServerPanicMainSchedulerError;
            started.Signal();
            PanicServer( KScServerPanicMainSchedulerError );
            }
        CActiveScheduler::Install( scheduler );
        }
    // construct server, an active object
    TRAPD( err, CScardServer::NewL() );

    if ( err )
        {
        data.iPanicCode = KScServerPanicSvrCreateServer;
        started.Signal();
        PanicServer( KScServerPanicSvrCreateServer );
        }

    // signal everything has started
    started.Signal(); // now started ok

    // start handling requests
    CActiveScheduler::Start();
    return KErrNone;
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// StartThread Starts the server thread.
// Returns: TInt:   error code
// -----------------------------------------------------------------------------
//
EXPORT_C TInt StartThread()
    {
    _WIMTRACE(_L("WIM|Scard|CScardServer::StartThread|Begin"));
    TInt res = KErrNone;

    // check server not already started
    TFindServer findSCardServer( KScardServerName );
    TFullName name;
    if ( findSCardServer.Next( name ) != KErrNone )
        {
        // create server thread
        RThread thread;
        TThreadParameter threadData;
        threadData.iSemaphore.CreateLocal( 0 );

        res = thread.Create(
            KScardServerName, // name of thread
            CScardServer::ThreadFunction, // thread function
            KDefaultStackSize,
            KDefaultMinHeapSize,
            KDefaultMaxHeapSize,
            &threadData // parameter to thread function
            );

        //  If creation was successful, try starting the server
        if ( res == KErrNone )
            {
            // now start thread
            thread.SetPriority( EPriorityNormal ); // set its priority
            thread.Resume(); // kick it into life
            threadData.iSemaphore.Wait(); // wait until it's got going

            if ( threadData.iPanicCode )   
                {
                //  The server did not start properly
                thread.Kill( threadData.iPanicCode );
                res = threadData.iPanicCode; // set the response
                return res;
                }

            // tidy up
            thread.Close(); // no longer interested in that thread
            }
        else
            {
            thread.Close();         
            }

        threadData.iSemaphore.Close(); // or semaphore
        }

    // all well
    return res;
    }

//  End of File