/*

* Copyright (c) 2003-2009 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:  Server startup and initialization

*

*/

// INCLUDE FILES

#include    "WimServer.h"

#include    "WimSession.h"

#include    "WimSig.h"

#include    "WimSessionRegistry.h"

#include    "WimTrustSettingsStore.h"

#include    "WimDefs.h"

#include    "WimTrace.h"

#include    "WimUtilityFuncs.h"

#include    "WimCallbackImpl.h"

#include    <s32file.h>         // UserSvr

#include    "WimCertInfo.h"

#include    "Wimi.h"            // WIMI definitions

#include    "WimSatRefreshObserver.h"

#include    "WimBTSapObserver.h"

#include    <e32property.h>     // RProperty

#include    <PSVariables.h>     // Property values

#ifdef WIMSERVER_SHUTDOWN

const TInt KServerShutdownDelay = 0x200000; 

#endif

// Initialize static variables. These variables are static because static

// callback functions in CWimCallBack.

CWimServer* CWimServer::iWimServer = NULL;

TInt CWimServer::iWimStatus = KErrNone;

TBool CWimServer::iWimInitialized = EFalse;

// ============================= LOCAL FUNCTIONS ===============================

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

// StartServer

// Server startup method. Creates active scheduler for the server.

// Returns: TInt: error code

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

//

static void StartServerL()

    {

    _WIMTRACE(_L("WIM | WIMServer | StartServer | Enter"));

    User::LeaveIfError( User::RenameThread( KWIMServerName ) );

    _WIMTRACE(_L("WIM | WIMServer | StartServer | Create AS"));

    CActiveScheduler* s = new(ELeave) CActiveScheduler;

    CleanupStack::PushL( s );    

    CActiveScheduler::Install( s );

    _WIMTRACE(_L("WIM | WIMServer | StartServer | Create server"));

    CWimServer::NewL();

    _WIMTRACE(_L("WIM | WIMServer | StartServer | Notify client"));

    // Notify Client that server has starter

    RProcess::Rendezvous( KErrNone );       

    _WIMTRACE(_L("WIM | WIMServer | StartServer | Start ActiveScheduler"));

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( s );

    }

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

// E32Main

// Server entry point

// Returns: TInt: error code

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

//

GLDEF_C TInt E32Main()

    {

    __UHEAP_MARK;

    _WIMTRACE(_L("WIM | WIMServer | E32Main | Begin"));

    CTrapCleanup* cleanup=CTrapCleanup::New();

    TInt r=KErrNoMemory;

    if ( cleanup )

        {

        TRAP( r, StartServerL() );

        delete cleanup;

        }

    _WIMTRACE(_L("WIM | WIMServer | E32Main Memory leak checking line"));    

    __UHEAP_MARKEND;    

    _WIMTRACE(_L("WIM | WIMServer | E32Main Memory checking passed"));

    return r;

    }

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

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

// CWimServer::CWimServer

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

// might leave.

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

//

CWimServer::CWimServer( TInt aPriority )

    : CPolicyServer( aPriority, wimPolicy, ESharableSessions )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::CWimServer | Begin"));

    }

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

// CWimServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWimServer::ConstructL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::ConstructL | Begin"));

    StartL( KWIMServerName );

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::ConstructL | StartL"));

    iWimServer = this;

    InitializeCallbackFunctions();  // Initialize WIMI callback functions

    iWimSessionRegistry = CWimSessionRegistry::NewL();

    iWimTrustSettingsStore = CWimTrustSettingsStore::NewL();

    iWimTimer = CWimTimer::NewL( this );

#ifdef WIMSERVER_SHUTDOWN    

    iShutdown.ConstructL();

    iShutdown.Start();

#endif    

     _WIMTRACE(_L("WIM | WIMServer | CWimServer::ConstructL | End"));

    }

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

// CWimServer::NewL

// Two-phased constructor.

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

//

CWimServer* CWimServer::NewL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::NewL | Begin"));

    CWimServer* self = new( ELeave ) CWimServer( EPriorityHigh );

    CleanupStack::PushL( self );

    self->ConstructL() ;

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWimServer::~CWimServer()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::~CWimServer | Begin"));

    if ( iRefreshObserver )

        {

        delete iRefreshObserver;

        iRefreshObserver = NULL;

        }

    if ( iBTSapObserver )

        {

        delete iBTSapObserver;

        iBTSapObserver = NULL;

        }

    // Call close down request only if WIM is initialized

    if ( iWimInitialized )

        {

        WIMI_CloseDownReq();

        _WIMTRACE(_L("WIM | WIMServer | CWimServer::~CWimServer | WIMI_CloseDownReq"));

        }

    //iWimTrustSettingsStore->CloseD();

    delete iWimTrustSettingsStore;

    delete iWimSessionRegistry;

    delete iWimTimer;

    CWimCallBack::DeletegApdu();

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::~CWimServer | delete iWimSessionRegistry"));

    }

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

// CWimServer::WimInitialize

// Initialize WIMI API, fetches WIM data to WIMI.

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

//

void CWimServer::WimInitialize( const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimInitialize | Begin"));

    // Create observer for bluetooth sap event.

    // This is checked every time we enter here.

    if ( !iBTSapObserver )

        {

        TRAPD( err, iBTSapObserver = CWimBTSapObserver::NewL());

        if ( KErrNone != err )

            {

            // creation failed

            iBTSapObserver = NULL; // to be sure

            _WIMTRACE(_L("WIM|CWimServer::WimInitialize | BT Sap observer NOT created."));

            }

        }

    // If BT SAP observer exists, start it

    if ( iBTSapObserver )

        {

        iBTSapObserver->Start(); //If already started, this doesn't start again

        }

    // Get state of smart card

    TInt simState = CWimUtilityFuncs::SimState();

    // Check whether state of Smart Card is OK and whether BT SAP is connected

    if ( simState != KErrNone ) // Card is not OK

        {

        SetWimInitialized( EFalse, simState );

        iWimStatus = simState;

        aMessage.Complete( iWimStatus );

        }

    else // Smart Card is ready

        {

        // Initialize WIMI if not yet done

        // iWimInitialized is set in callback function InitOKResp()

        if ( !iWimInitialized )

            {

            TInt initStatus = CWimUtilityFuncs::MapWIMError(

                                      WIMI_InitializeReq( &iWimCallBack ) );

            _WIMTRACE2(_L("WIM|WIMServer|CWimServer::WimInitialize|initStatus=%d"), initStatus );

            // In case WIMI_InitializeReq returs error

            // iWimStatus may not be set

            if ( initStatus != KErrNone )

                {

                SetWimInitialized( EFalse, initStatus  );

                iWimStatus = KErrNotReady;

                }

            }

        else // WIMI already initialized

            {

            _WIMTRACE(_L("WIM|WIMServer|CWimServer::WimInitialize|Wim already initialized"));

            iWimStatus = KErrNone;

            }

        // Create observer for SAT refresh event.

        // This is checked every time we enter here. It may have failed before

        // because SAT Server wasn't started.

        if ( !iRefreshObserver )

            {

            TRAPD( err, iRefreshObserver = CWimSatRefreshObserver::NewL());

            if ( KErrNone != err )

                {

                // creation failed

                iRefreshObserver = NULL; // to be sure

                _WIMTRACE(_L("WIM|CWimServer::WimInitialize | SAT Refresh observer NOT created."));

                }

            }

        aMessage.Complete( iWimStatus );

        }

    }

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

// CWimServer::SetWimInitialized

// Set iWimInitialized flag

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

//

void CWimServer::SetWimInitialized( TBool aInitialized, TInt aStatus )

    {

    _WIMTRACE2(_L("WIM|WIMServer|CWimServer::SetWimInitialized|Value=%d"), aInitialized);

    iWimInitialized = aInitialized;

    if ( !aInitialized )

        {

        iWimStatus = aStatus;

        }

    }

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

// CWimServer::NewSessionL

// Creates a new sharable session.

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

//

CSession2* CWimServer::NewSessionL(

    const TVersion& aVersion,

    const RMessage2& /*aMessage*/ ) const

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::NewSessionL | Begin"));

    TVersion v( KWIMServMajorVersionNumber, KWIMServMinorVersionNumber,

        KWIMServBuildVersionNumber );

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

        {

        User::Leave( KErrNotSupported );

        }

    CWimSession* wimSession;

    wimSession = CWimSession::NewL( ( CWimServer* )this );

    iWimSessionRegistry->AddSessionL( wimSession );

    return wimSession;

    }

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

// CWimServer::InitializeCallbackFunctions

// WIMI API callback initialization.

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

//

void CWimServer::InitializeCallbackFunctions()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimSession::InitializeCallbackFunctions | Begin"));

    _WIMTRACE2(_L("WIM | WIMServer | CWimSession::InitializeCallbackFunctions | iWimCallBack = %d"), iWimCallBack );

    iWimCallBack.InitOkResp = CWimCallBack::InitOkResp;

    iWimCallBack.CloseDownResp = CWimCallBack::CloseDownResp;

    iWimCallBack.SignResp = CWimCallBack::SignResp;

    iWimCallBack.CertificateResp = CWimCallBack::CertificateResp;

    iWimCallBack.CertificateDeleteResp = CWimCallBack::CertificateDeleteResp;

    iWimCallBack.CertificateStoreResp = CWimCallBack::CertificateStoreResp;

    iWimCallBack.VerifyPINResp = CWimCallBack::VerifyPINResp;

    iWimCallBack.ChangePINResp = CWimCallBack::ChangePINResp;

    iWimCallBack.UnblockPINResp = CWimCallBack::UnblockPINResp;

    iWimCallBack.EnablePINResp = CWimCallBack::EnablePINResp;

    iWimCallBack.CardInsertedResp = CWimCallBack::CardInsertedResp;

    iWimCallBack.Open = CWimCallBack::Open;

    iWimCallBack.Close = CWimCallBack::Close;

    iWimCallBack.APDUReq = CWimCallBack::APDUReq;

    iWimCallBack.GetATRReq = CWimCallBack::GetATRReq;

    iWimCallBack.GetReaderListReq = CWimCallBack::GetReaderListReq;

    iWimCallBack.ReadSimFileReq = CWimCallBack::ReadSimFileReq;

    iWimCallBack.ProvSCFileResp = CWimCallBack::OmaProvisioningResp;

     _WIMTRACE(_L("WIM | WIMServer | CWimSession::InitializeCallbackFunctions | END"));

    }

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

// CWimServer::PanicServer

// Panics the server.

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

//

void CWimServer::PanicServer( TWimServerPanic aPanic )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::PanicServer | Begin"));

    // Set server state to EWimServerNotRunning

    TInt retVal = RProperty::Set( KUidSystemCategory,

                                  KWimServerUid.iUid,

                                  EWimServerNotRunning );

    retVal = retVal; // To prevent warning

    User::Panic( KWIMServerName, aPanic );

    }

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

// CWimServer::Server

// Return static iServer

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

//

CWimServer* CWimServer::Server()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::Server | Begin"));

    return CWimServer::iWimServer;

    }

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

// CWimServer::WimSessionRegistry

// Get pointer to WimSessionRegistry

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

//

CWimSessionRegistry* CWimServer::WimSessionRegistry()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimSessionRegistry | Begin"));

    return iWimSessionRegistry;

    }

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

// CWimServer::GetSessions

// Return all sessions of server

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

//

void CWimServer::GetSessionsL( RArray<CWimSession*>& aSessions ) const

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::GetSessionsL | Begin"));

    iWimSessionRegistry->GetSessionsL( aSessions );

    }

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

// CWimServer::WimTrustSettingsStore

// Return TrustSettingsStore pointer

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

//

CWimTrustSettingsStore* CWimServer::WimTrustSettingsStore()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimTrustSettingsStore | Begin"));

    return iWimTrustSettingsStore;

    }

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

// CWimServer::CustomSecurityCheckL

// Custom policy check for requests of certain WimServer services.Called by

// framework.

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

//

    CPolicyServer::TCustomResult

CWimServer::CustomSecurityCheckL( const RMessage2& aMsg,

                                  TInt& /*aAction*/,

                                  TSecurityInfo& /*aMissing*/ )

    {

    _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL | Begin, heap=%d"),

               User::CountAllocCells());

    WIMI_STAT callStatus;

    TUint8 usage( 255 ); // init stg unused

    // Set initial return value to failed

    CPolicyServer::TCustomResult test( EFail );

    TInt function = aMsg.Function();

    _WIMTRACE4(_L("CWimServer::CustomSecurityCheckL: SID=%d,VID=%d, Function=%d"),

               aMsg.SecureId().iId, aMsg.VendorId().iId, function);

    switch ( function )

        {

        case EGetWIMCertDetails:

            {

            //Leave the capability checking to Certificate Handler object

            test = EPass;

            break;

            }

        case EGetCertExtras:

            {

            // Int2 contains usage of required cert

            TWimEntryType certEntryType = ( TWimEntryType ) aMsg.Int2();

            switch ( certEntryType )

                {

                case EWimEntryTypeCA:

                    {

                    // CA cert reading does not require caps

                    _WIMTRACE(_L("CWimServer::CustomSecurityCheckL: CA cert read req, OK"));

                    test = EPass;

                    break;

                    }

                case EWimEntryTypePersonal: //lint -fallthrough

                case EWimEntryTypeAll:

                    {

                    // User cert reading requires caps

                    test = CheckReadCapsForUsage( aMsg, WIMI_CU_Client );

                    break;

                    }

                default:

                    {

                    test = EFail;

                    break;

                    }

                }

            break;

            }

        case EStoreCertificate:

            {

            ResolveStoreCertReqL( aMsg, usage );

            test = CheckWriteCapsForUsage( aMsg, usage );

            break;

            }

        case ERemoveCertificate:

            {

            callStatus = ResolveRemoveCertReqL( aMsg, usage );

            if ( WIMI_Ok == callStatus )

                {

                test = CheckWriteCapsForUsage( aMsg, usage );

                }

            break;

            }

        case ESignTextReq:

            {

            test = CheckReadCapsForUsage( aMsg, WIMI_CU_Client );

            break;

            }

        case ESetApplicability:         //lint -fallthrough

        case ESetTrust:                 //lint -fallthrough

        case ESetDefaultTrustSettings:  //lint -fallthrough

        case ERemoveTrustSettings:

            {

            if ( ResolveTrustModficationReqL( aMsg, usage ))

                {

                test = CheckWriteCapsForUsage( aMsg, usage );

                }

            break;

            }

        case EExportPublicKey:

            {

            ResolveExportPublicReqL( aMsg, usage );

            test = CheckReadCapsForUsage( aMsg, usage );

            break;

            }

        default:

            {

            _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL: UNKNOWN FUNCTION %d"),

                        function);

            // Inconsistent policy, should not be here. Panic.

            PanicServer( EWimIncorrectPolicy );

            break;

            }

        } // switch ( function )

    _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL: Result=%d"), test);

    _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL | End, heap=%d"),

               User::CountAllocCells());

    return test;

    }

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

// CWimServer::ResolveCertUsage

// Resolves usage (CA/User) for a certificate.