/*

* Copyright (c) 2002-2005 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: Class for Imps session.

*

*

*/

// INCLUDE FILES

#include    "impsserver.h"

#include    "impsutils.h"

#include    "impssession.h"

#include    "impsfields.h"

#include    "impserrors.h"

#include    "impstimer.h"

#include    "impssubsession.h"

#include    "ImpsVariantAPI.h"

#include    "impspacked.h"

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

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

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

// might leave.

//

CImpsSession::CImpsSession( RMessage2& aMsg )

        :     CSession2(),

        iCanceled( EFalse ),

        iMessageCompleted( EFalse ),

        iMsgR( aMsg )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Session: NEW session sess=%d" ), ( TInt )this );

#endif

    }

// Destructor

// RHandleBase::Close() causes this destructor to be called

CImpsSession::~CImpsSession()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Session: DELETE session sess=%d" ), ( TInt )this );

#endif

    // Check if destructor is called by CServer2 class in failed

    // entity creation or in other case. iContainer is the last

    // member created is CreateL() so it can be used for this purpose.

    TBool wasComplete = iContainer ? ETrue : EFalse;

    // This is here to close CSP session if client is deleted

    // without calling close method.

    CloseSession();

    TImpsSessIdent csp( SID(), SAP(), UserId() );

    Server()->CloseSession( csp, wasComplete );

    delete iApplicationId;

    delete iSID;

    delete iSAP;

    delete iUserId;

    delete iStream;

    delete iFields;

    }

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

// CImpsSession::CreateL()

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

// This overloads the base class implementation

void CImpsSession::CreateL( )

    {

    iFields = CImpsFields::NewL();

    // create new object index

    iSubSessions = CObjectIx::NewL();

    // initialize the object container using the object container index in the server.

    iContainer = Server()->NewContainerL();

    }

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

// CImpsSession::DispatchMessageL()

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

void CImpsSession::DispatchMessageL( const RMessage2& aMessage )

    {

    TInt nbrSess = 0;

    TUint flag = 0;

    iMsgR = aMessage;

    if ( iCanceled )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "Session: already CANCELED aMsg=%d" ),

                                aMessage.Function() );

#endif

        CompleteMe( KErrCancel );

        return;

        }

    // Set ETrue at the same time as Message().Complete() takes place

    iMessageCompleted = EFalse;

    TInt msg = aMessage.Function();

    // stripp off bit mask in an upper word

    msg = msg & 0x0FFFF;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Session: DispatchMessageL msg=%d sess=%d" ), msg, ( TInt )this );

#endif

    // current CSP indetification

    TImpsSessIdent csp( SID(), SAP(), UserId() );

    switch ( msg )

        {

        case EImpsServAssign:

            AssignIdL();

            // Notice that in this case there is subsession specific part too.

            // So, do not return yet.

            break;

        case EImpsAccessRegister2:

            // NewSubSessionL will check SHUTTING_DOWN state of server and

            // leaves when necessary

            NewSubSessionL( EImpsEventServerLogin, aMessage );

            return;

        case EImpsImRegister:

            NewSubSessionL( EImpsEventMessage, aMessage );

            return;

        case EImpsFundRegister:

            NewSubSessionL( EImpsEventCommon, aMessage );

            return;

        case EImpsGroupRegister:

            NewSubSessionL( EImpsEventGroup, aMessage );

            return;

        case EImpsServPureRegister:

            {

            NewSubSessionL( EImpsEventPresencePure, aMessage );

            }

        return;

        case EImpsServIsLogged:

            // This has to return positive value is CSP is found

            // and it has got SID.

            if ( IsThisLogged() )

                {

                CompleteMe( KErrNone );

                }

            else

                {

                CompleteMe( KImpsErrorNotLogged );

                }

            return;

        case EImpsServNbrSessions:

            nbrSess = NbrOfSessionsL( );

            CompleteMe( nbrSess );

            return;

        case EImpsServServices:

#ifndef _NO_IMPS_LOGGING_

            CImpsClientLogger::Log( _L( "Session: EImpsServServices" ) );

#endif

            CurrentServicesL();

            return;

        case EImpsServPush:

            // multi-csp supported, i.e. CIR given for every CSP session

            // until sessoin cookie matches

            if ( Server()->IsShuttingDown() )

                {

                User::Leave( KImpsErrorShuttingDown );

                }

            PushMessageL();

            iCIRSess = ETrue;

            return;

        case EImpsServBuffSizeReq:

            CompleteMe( IsThisLogged() ? Server()->BufferSize() : 0 );

            return;

        case EImpsServCloseAll:		// close all sessions

            Server()->LogoutAll();

            CompleteMe( KErrNone );

            return;

        }

    // subsession specific requests

    TInt myHandle = aMessage.Int3( );

    CImpsSubSession* sub = ConnectionFromHandle( myHandle );

    if ( !sub )

        {

        PanicClient( EImpsBadRequest );

        return;

        }

    TBool reactive( EFalse );

    switch ( msg )

        {

        case EImpsServAssign:

            sub->AssignIdL( csp );

            return;

            // completion of request made in ServiceL

        case EImpsServReactiveLogin:

            reactive = ETrue;

        case EImpsServWVLogin:

            if ( Server()->IsShuttingDown() )

                {

                User::Leave( KImpsErrorShuttingDown );

                }

            if ( !Server()->IsConAllowed() )

                {

                User::Leave( KImpsErrorTerminalOffLine );

                }

            // multi: check if this session is already logged in.

            if ( IsThisLogged() )

                {

                User::Leave( KImpsErrorAlreadyLogged );

                }

            iLogoutTID = KNullDesC;

            sub->LoginL( reactive );

            return;

            // case EImpsServWVLogoutOne:

        case EImpsServWVLogout:

            if ( Server()->IsShuttingDown() )

                {

                User::Leave( KImpsErrorShuttingDown );

                }

            if ( !IsThisActive() )

                {

                User::Leave( KImpsErrorNotLogged );

                }

            iLogoutTID = KNullDesC;

            iLogoutTID = sub->LogoutL( csp, EFalse );

            // The following is needed if no force logout

            // and a shared CSP exists.

            CompleteMe( KErrNone );

            return;

        case EImpsServWVSendOnly:

        case EImpsServBlock:

        case EImpsServGroup:

        case EImpsServPres:

        case EImpsServFundSearch:

        case EImpsServFundInvite:

            if ( Server()->IsShuttingDown() )

                {

                User::Leave( KImpsErrorShuttingDown );

                }

            // multi: check if this handle is logged

            if ( !IsThisLogged() )

                {

                User::Leave( KImpsErrorNotLogged );

                }

            else if ( !Server()->IsConAllowed() )

                {

                User::Leave( KImpsErrorTerminalOffLine );

                }

            sub->SendPrimitiveL( aMessage.Function(), csp );

            return;

        case EImpsServNextEvent:

            sub->NextEventL( aMessage );

            // This is completed later

            iMessageCompleted = ETrue;

            return;

        case EImpsServEventBody:

            sub->SendEventBodyL( aMessage );

            // This is completed later

            iMessageCompleted = ETrue;

            return;

        case EImpsServCloseSub:

#ifndef _NO_IMPS_LOGGING_

            CImpsClientLogger::Log( _L( "Session: EImpsServCloseSub" ) );

#endif

            sub->Unregister();

            // remove subsession type

            flag = sub->Type();

            iTypes = ( iTypes & ~flag );

            CompleteMe( KErrNone );

            return;

        case EImpsServDeleteSub:

            // remove subsession entity

#ifndef _NO_IMPS_LOGGING_

            CImpsClientLogger::Log( _L( "Session: EImpsServDeleteSub" ) );

#endif

            sub->DeleteSub();

            CompleteMe( KErrNone );

            return;

        case EImpsServGetBlocked:

            if ( Server()->IsShuttingDown() )

                {

                User::Leave( KImpsErrorShuttingDown );

                }

            // multi: check if this handle is logged in

            if ( !IsThisLogged() )

                {

                User::Leave( KImpsErrorNotLogged );

                }

            else if ( !Server()->IsConAllowed() )

                {

                User::Leave( KImpsErrorTerminalOffLine );

                }

            sub->SendGetBlockedL( csp );

            return;

        case EImpsServStatusReg:

            sub->SetStatusObserver( ETrue );

            CompleteMe( KErrNone );

            return;

        case EImpsServStatusUnreg:

            sub->SetStatusObserver( EFalse );

            CompleteMe( KErrNone );

            return;

        case EImpsServDetailedReg:

            sub->SetDetailedError( ETrue );

            CompleteMe( KErrNone );

            return;

        case EImpsServDetailedUnreg:

            sub->SetDetailedError( EFalse );

            CompleteMe( KErrNone );

            return;

        case EImpsServCspVersion:

            CompleteMe( Server()->CspVersion() );

            return;

        case EImpsServCancelLogin:	// cancel ongoing login

            if ( Server()->IsShuttingDown() )

                {

                User::Leave( KImpsErrorShuttingDown );

                }

            // Call logout with cancel parameter.

            ( void )sub->LogoutL( csp, ETrue );

            return;

        case EImpsServCancelTrans:	// cancel transaction

            // If the specified request is not found then just complete the current request.

            if ( !sub->CancelTrans( aMessage, csp ) )

                {

                CompleteMe( KErrNone );

                }

            else

                {

                // Complete with cancel if operation is cancelled

                CompleteMe( KErrCancel );

                }

            return;

        case EImpsServSetExpiry:

            sub->SetExpiryTime( aMessage );

            CompleteMe( KErrNone );

            return;

        default:

            PanicClient( EImpsBadRequest );

            return;

        }

    }

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

// CImpsSession::NewSubSessionL

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

// Create a new connection; pass back its handle via the message

// Ensures the object is cleaned up on failure

void CImpsSession::NewSubSessionL(

    TImpsEventType aType,

    const RMessage2& aMessage )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Session: NewSubSessionL sess=%d" ), TInt( this ) );

#endif

    // Reject request if server is SHUTTING_DOWN

    if ( Server()->IsShuttingDown() )

        {

        User::Leave( KImpsErrorShuttingDown );

        }

    CImpsSubSession* sub = CImpsSubSession::NewL( this, aType, aMessage );

    CleanupClosePushL( *sub );

    iContainer->AddL( sub );

    // Add subsession to object index, this returns unique handle

    TInt handle = iSubSessions->AddL( sub );

    // write the handle to client

    TPckg<TInt> handlePckg( handle );

    TRAPD( res, aMessage.WriteL( 3, handlePckg ) );

    if ( res != KErrNone )

        {

        // Removing sub from object index will

        // cause Close() to be called on sub, and that calls destructor

        CleanupStack::Pop();

        iSubSessions->Remove( handle );

        PanicClient( EImpsCorrupted );

        User::Leave( res );

        }

    sub->SetHandle( handle );

    // notch up another resource

    iResourceCount++;

    // update iTypes bit Mask

    iTypes = iTypes | aType;

    CleanupStack::Pop( );

    }

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

// CImpsSession::ConnectionFromHandle()

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

CImpsSubSession* CImpsSession::ConnectionFromHandle( TUint aHandle )

    {

    CImpsSubSession* sub = ( CImpsSubSession* )iSubSessions->At( aHandle );

    return sub;

    }

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

// CImpsSession::DeleteSubSession

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

void CImpsSession::DeleteSubSession( TUint aHandle )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "Session: DeleteSubSession sess=%d" ), ( TInt )this );

#endif

    // panic if bad handle

    CImpsSubSession* sub = ConnectionFromHandle( aHandle );

    if ( sub == NULL )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "Session: PANIC" ) );

#endif

        PanicClient( EImpsCorrupted );

        }

    // remove subsession

    iSubSessions->Remove( aHandle );

    // decrement resource count

    iResourceCount--;

#ifndef _NO_IMPS_LOGGING_

    TInt count = iSubSessions->ActiveCount();

    CImpsClientLogger::Log( _L( "Session: DeleteSubSession nbrsub=%d %d subses=%d" ),

                            count, iResourceCount,  ( TInt )sub );

#endif

    }

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

// CImpsSession::MatchSession

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

TBool CImpsSession::MatchSession( TImpsSessIdent aCSP )

    {

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

    // Notice: comment

    // extra stuff for debugging

    /*

    TPtrC pp1 = aCSP.SAP();

    TPtrC pp2 = aCSP.UserId();

    TPtrC pp3 = aCSP.SID();

    TPtrC ppa = SAP();

    TPtrC ppb = UserId();

    TPtrC ppc = SID();

    CImpsClientLogger::Log(_L("Session: MatchSession aCSP sap=%S user=%S sid=%S"), &pp1, &pp2, &pp3);

    CImpsClientLogger::Log(_L("Session: MatchSession this sap=%S user=%S sid=%S"), &ppa, &ppb, &ppc);

    */

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

    // The current session-id must match if it is non-zero

    if ( aCSP.SID().Length() > 0 &&

         SID().Length() > 0 &&

         aCSP.SID().CompareF( SID() ) )

        {

        return EFalse;

        }

    // Also user-id and SAP address must match

    else if ( !( SAP().CompareF( aCSP.SAP() ) ) &&

              !( UserId().CompareF( aCSP.UserId() ) ) )

        {

#ifndef _NO_IMPS_LOGGING_

        TPtrC p1 = SAP();

        TPtrC p2 = UserId();

        TPtrC p3 = aCSP.SID();

        CImpsClientLogger::Log( _L( "Session: MatchSession MATCH sess=%d sap=%S user=%S sid=%S" ),

                                ( TInt )this,  &p1, &p2, &p3 );

#endif

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CImpsSession::SendEvent()

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

void CImpsSession::SendEvent(

    CImpsFields *aFields,

    TInt aOpId,

    TImpsServRequest aRequestType,

    TImpsMessageType aReqMsgType,

    TUint aHandle )

    {

    // It is possible that the cancel request from client is not

    // complete and this session entity is still waiting deletion.

    if ( iCanceled )

        {

        return;