/*

* Copyright (c) 2002-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: Classes for IM server and Conn.

*

*

*/

// INCLUDE FILES

#include    <e32math.h>

#include    <ecom/ecom.h>

#include    "impsserver.h"

#include    "impssession.h"

#include    "impssubsession.h"

#include    "impsfields.h"

#include    "impsutils.h"

#include    "impserrors.h"

#include    "impstimer.h"

#include    "impsservices.h"

#include    "impscommonenums.h"

#include    "impssdatautils.h"

#include    "impsmessageinterpreterapi.h"

#include    "ImpsVariantAPI.h"

#include    "impscspsession.h"

#include    "impsorphans.h"

#include    "impstoffobserver.h"

#include    "WVEngineInternalCRKeys.h"

#include    "impsserversecuritypolicy.h"

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

// CONSTANTS

// Shutdown idle wait time in seconds

const TInt KImpsShutdownTime = 0;

// Overhead estimate for XML message : total - transaction content

const TInt KImpsBufOverhead = 100;

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

void CImpsScheduler::Error( TInt anError ) const

    {

    // This is just for compiler to avoid warning

    TInt err = anError;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Scheduler: error=%d" ), anError );

#endif

    // This is just for another compiler to avoid warning

    anError = err;

    }

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

// CLASS CImpsConn

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

CImpsConn::CImpsConn( MImpsCSPSession* aSess ) :

        iSess( aSess ), iRemover( NULL )

    {}

CImpsConn::~CImpsConn()

    {

    }   //lint !e1540 iSess freed in Destroy

// Two-phased constructor.

CImpsConn* CImpsConn::NewL( MImpsCSPSession* aSess, CImpsServer& aServer )

    {

    CImpsConn* self = new ( ELeave ) CImpsConn( aSess );

    CleanupStack::PushL( self );

    self->ConstructL( aServer );

    CleanupStack::Pop();

    return self;

    }

// Two-phased constructor.

// It creates an active object to destroy CSP session asynchronously later.

// It's better to create it now to avoid OOM errors in CSP closing.

void CImpsConn::ConstructL( CImpsServer& aServer )

    {

    iRemover = new ( ELeave ) CImpsCSPDestroyer(

        aServer, *iSess, CActive::EPriorityUserInput + 1 );

    }

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

// CImpsConn::Destroy

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

void CImpsConn::Destroy()

    {

    iRemover->Cancel();

    delete iRemover;

    iSess->Destroy();

    delete ( CImpsCSPSession* )iSess;

    iSess = NULL;

    iLink.Deque();

    delete this;

    }

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

// CImpsConn::Sess

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

MImpsCSPSession* CImpsConn::Sess()

    {

    return iSess;

    }

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

// CImpsConn::DeleteCSPAsynch

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

void CImpsConn::DeleteCSPAsynch()

    {

    // iRemover cannot be NULL since it's created in contructor

    if ( iRemover->IsActive() )

        {

        // asynchronous request already runnig, nothing to do

        return;

        }

    iRemover->DeleteCSPAsynch( );

    }

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

// CImpsConn::MatchCSP

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

TBool CImpsConn::MatchCSP( TImpsSessIdent aCSP )

    {

    if ( ( aCSP.UserId().Compare( iSess->UserId() ) ) ||

         ( aCSP.SAP().Compare( iSess->SAP() ) ) )

        // Notice: no need for this

        // ( aCSP.SID().Length() && aCSP.SID().Compare( iSess->SID() )))

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CLASS CImpsCSPDestroyer

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

CImpsCSPDestroyer::CImpsCSPDestroyer(

    CImpsServer& aServer, MImpsCSPSession& aSess, TInt aPriority )

        : CActive( aPriority ),

        iServer( aServer ),

        iSess( aSess ),

        iCanceled ( EFalse )

    {

    // Add this to the scheduler

    CActiveScheduler::Add( this );

    }

CImpsCSPDestroyer::~CImpsCSPDestroyer()

    {

    Cancel();

    }

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

// CImpsCSPDestroyer::DeleteCSPAsynch

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

void CImpsCSPDestroyer::DeleteCSPAsynch(  )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCSPDestroyer: DeleteCSPAsynch" ) );

#endif

    // This yields the control to the server thread active scheduler

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        iCanceled = EFalse;

        TRequestStatus* s = &iStatus;

        User::RequestComplete( s, KErrNone );

        }

    }

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

// CImpsCSPDestroyer::DoCancel

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

void CImpsCSPDestroyer::DoCancel()

    {

    iCanceled = ETrue;

    }

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

// CImpsCSPDestroyer::RunL

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

void CImpsCSPDestroyer::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCSPDestroyer: RunL" ) );

#endif

    if ( iCanceled || iStatus.Int() != KErrNone )

        {

        return;

        }

    // Trigger a server thread to send a queued message

    iServer.DeleteCSP( &iSess );

    // It is extremely important that after the previous call this

    // method does nothing since DeleteCSP actully deletes the

    // current entity if this class!

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCSPDestroyer: RunL ends" ) );

#endif

    }

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

// CLASS CImpsServer

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

CImpsServer::CImpsServer()

        : CPolicyServer( EPriorityUserInput /*EPriorityHigh*/, KImpsServerPolicy ),

        iFs(),

        iSettings( ),

        iConAllowed( ETrue ),

        iCSPVersion( EImpsCspVersion11 ),

        iOperation( EImpsSrvNone ),

        iOrphans( NULL ),

        iCSPList( _FOFF( CImpsConn, iLink ) ), //lint !e413,

        iObserver( NULL ),

        iExpiryInterval( 0 )

    {

    }

// Create and start a new server.

CImpsServer* CImpsServer::New()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server: rel200614.4+" ) );

#endif

    CImpsServer* server = new CImpsServer();

    if ( server )

        {

        if ( server->Start( KImpsServerName ) != KErrNone )

            {

            delete server;

            server = NULL;

            }

        }

#ifdef _DEBUG

    if ( server && server->iFs.Connect() )

        {

        delete server;

        server = NULL;

        }

#endif // _DEBUG               

    return server;

    }

CImpsServer::~CImpsServer()

    {

    // deallocate all memory

    delete iSnd;

    delete iShutTimer;

    delete iExpiryTimer;

    delete iContainerIndex;

    delete iVariant;

    delete iOrphans;

    delete iObserver;

#ifdef _DEBUG

    // close file session

    iFs.Close();

#endif // _DEBUG      

    }

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

// CImpsServer::ConstructL()

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

void CImpsServer::ConstructL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server:ConstructL begins" ) );

#endif

    iContainerIndex = CObjectConIx::NewL();

    // Read static settings, use defaults if ini file not exist

    iSettings.ReadStaticSettings();

#ifdef _DEBUG

    TInt errx = KErrNone;

    TRAP( errx, iSettings.ReadIniFileL( iFs ) );

#endif

    iVariant = CImpsVariant::NewLC( );

    CleanupStack::Pop( ); // >> iVariant

    iSnd = CImpsFields::NewL();

    iShutTimer = new ( ELeave ) CImpsShutdownTimer( *this,

                                                    CActive::EPriorityUserInput + 1 );

    iExpiryTimer = new ( ELeave ) CImpsExpiryTimer( *this,

                                                    EImpsEventAll, CActive::EPriorityStandard );

    // Get the supported WV CSP version for all sessions

    GetCSPVersion();

    // local variation

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

    if ( iVariant->IsFeatureSupportedL( EImLauncher ) )

        {

        iOrphans = CImpsOrphans::NewL();

        }

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

    // Check terminal off line state

    iObserver = CImpsTOffObserver::NewL( *this );

    if ( !iObserver->CheckConnAllowed() )

        {

        SetConnAllowed( EFalse );

        }

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server:ConstructL ends" ) );

#endif

    }

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

// CImpsServer::NewSessionL()

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

CSession2* CImpsServer::NewSessionL(

    const TVersion &aVersion, const RMessage2& aMessage ) const

    {

    // check that we're the right version

    TVersion v( KImpsServMajorVersionNumber,

                KImpsServMinorVersionNumber,

                KImpsServBuildVersionNumber );

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

        {

        User::Leave( KErrNotSupported );

        }

    if ( iOperation == EImpsSrvShuttingDown )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "Server: NewSessionL in shut down ***" ) );

#endif

        User::Leave( KImpsErrorShuttingDown );

        }

    StopTimer();

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server: NewSessionL ends" ) );

#endif

    // make a new session

    RMessage2 msg = aMessage;

    return new( ELeave ) CImpsSession( msg );

    }

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

// CImpsServer::CloseSession()

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

void CImpsServer::CloseSession( TImpsSessIdent aCSP, TBool aComplete )

    {

#ifndef _NO_IMPS_LOGGING_

    TInt temp1 = NbrSessions( ETrue );

    TInt temp2 = NbrSessions( EFalse );

    CImpsClientLogger::Log( _L( "Server: CloseSession nbrses=%d-%d aComplete=%d" ), temp1, temp2, aComplete );

#endif

    // CServer2 calls CImpsSession's desctrutor if its consctrutor fails

    // but in that case NbrSessions() method does not see the failed entity.

    // Thus in case of failed session creation the limit is 0, otherwise 1,

    // i.e. the last client session to be closed starts the shut down timer.

    TInt limit = aComplete ? 1 : 0;

    MImpsCSPSession* ses = GetCSP( aCSP, ETrue );

    if ( !ses )

        {

        // If the last client session and no CSP sessions

        // then start final count down

        if ( NbrSessions( EFalse ) <= limit )

            {

            // There is nobody listening to expiry events

            iExpiryTimer->Stop( );

            if ( !NbrCSPs() )

                {

                // start the final count down

                iOperation = EImpsSrvFinish;

                iShutTimer->Start( KImpsShutdownTime );

                }

            }

        return;

        }

    // This is very last client session for the CSP connection.

    // Disconnect CSP session on behalf of applications in this case.

    TInt myCount = NbrSessions( EFalse, aCSP );

    if ( myCount == 1 )

        {

        TRAPD( errx, ( void )ses->LogoutL( EFalse ) );

        if ( !errx )

            {

            return;

            }

        }

    }

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

// CImpsServer::ThreadStart()

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

EXPORT_C TInt CImpsServer::ThreadStart( TImpsSignal& aSignal )

    {

    // naming the server thread after the server helps to debug panics

    RThread().RenameMe( KImpsServerExe );

    TInt err = KErrNone;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server: ThreadStart begins" ) );

    CImpsClientLogger::Log( _L( "Server: aSignal.iRate = %x" ), aSignal.iRate );

#endif

    __UHEAP_MARK;

    CTrapCleanup* cleanup = NULL;

    CImpsScheduler* scheduler = NULL;

    CImpsServer* server = NULL;

    cleanup = CTrapCleanup::New();

#ifdef _DEBUG

    TInt rate = aSignal.iRate;

    if ( rate > 0 )

        {

        TRAP( err, __UHEAP_SETFAIL( RHeap::EFailNext, rate ) );

        }

#endif

    scheduler = new CImpsScheduler;

    if ( cleanup && scheduler )

        {

        CImpsScheduler::Install( scheduler );

        server = CImpsServer::New();      // adds server in scheduler

        }

    if ( !cleanup || !scheduler || !server )

        {

        err = KErrNoMemory;

        }

    else

        {

        TRAP( err, server->ConstructL() );

        }

    if ( err )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "Server:ConstructL failed = %d" ), err );

#endif

        delete server;      //lint !e644 initialization ok

        delete cleanup;     //lint !e644 initialization ok

        delete scheduler;   //lint !e644 initialization ok

        }

    // signal that we've started

    RProcess::Rendezvous( err );

    // start fielding requests from clients

    if ( err == KErrNone )

        {

        CImpsScheduler::Start();

        // comes here when server shuts down

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "Server: Scheduler is STOPPED" ) );

#endif

        delete server;      //lint !e644 initialization ok

        delete scheduler;   //lint !e644 initialization ok

        delete cleanup;     //lint !e644 initialization ok

        }

#ifdef _DEBUG

    if ( rate > 0 )

        {

        TInt err2 = KErrNone;

        TRAP( err2, __UHEAP_SETFAIL( RHeap::ENone, 0 ) );

        }

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server: MEM TEST begins" ) );

#endif

    __UHEAP_MARKEND;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server: MEM TEST OK" ) );

#endif

#endif

    return( err );

    }

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

// CImpsServer::LoginL

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

TPtrC CImpsServer::LoginL(

    const TDesC& aUser,

    const TDesC& aPassword,

    const TDesC& aClientId,

    const TDesC& aSAP,

    TUint32 aAP,

    const TDesC& aKey1,

    const TDesC& aKey2,

    CImpsSubSession* /*aSub*/,

    const TTime aLoginExpiry,

    TBool aReactive )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Server: LoginL" ) );

#endif