/*

* 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: Class for imps sub session.

*

*

*/

// INCLUDE FILES

#include    "impsserver.h"

#include    "impsutils.h"

#include    "impssession.h"

#include    "impsfields.h"

#include    "impserrors.h"

#include    "impstimer.h"

#include    "impssdatautils.h"

#include    "impspacked.h"

#include    "impssubsession.h"

#include    "impstdataaccessor.h"

#include    "impsmessageinterpreterapi.h"

#include    "impsliterals.h"

#include    "ImpsVariantAPI.h"

#ifdef _FAKE_RESPONSE

#include   "impssrvtestutils.h"

#endif

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

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

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

// might leave.

//

CImpsSubSession::CImpsSubSession(  )

        :   iEventList( _FOFF( CWvEvent, iLink ) ),  //lint !e413

        iRequestList( _FOFF( CRequest, iLink ) ), //lint !e413

        iStatusObserver( EFalse ),

        iDetailedError( EFalse ),

        iLastEvent( EImpsMessageNone ),

        iExpiryTime( 0 )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: CREATE subses=%d" ), ( TInt )this );

#endif

    }

// Destructor

// Session destructor calls this

CImpsSubSession::~CImpsSubSession()

    {

    DeleteAllRequests();

    DeleteAllEvents();

    delete iVariant;

    // complete event msg

    CompleteEventMsg( KErrCancel );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: DELETE subses=%d" ), ( TInt )this );

#endif

    }

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

// CImpsSubSession::NewL()

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

CImpsSubSession* CImpsSubSession::NewL(

    CImpsSession* aSession,

    TImpsEventType aType,

    const RMessage2 aMessage )

    {

    CImpsSubSession*  self = new ( ELeave ) CImpsSubSession();

    // CleanupStack::PushL( self );

    // Close method has to be called since this is derived from CObject.

    CleanupClosePushL( *self );

    self->ConstructL( aSession, aType, aMessage );

    CleanupStack::Pop();

    return self;

    }

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

// CImpsSubSession::ConstructL()

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

void CImpsSubSession::ConstructL(

    CImpsSession* aSession,

    TImpsEventType aType,

    const RMessage2 aMessage )

    {

    iServiceType = aType;

    iSession = aSession;

    TInt msg = aMessage.Function();

    // get bit mask in an upper byte

    TInt flags = ( msg >> 16 );

    iOOMErr.Reset();

#ifdef _FAKE_RESPONSE

    // **********************************

    // MODULE TEST for auxiliary classes

    TImpsSrvTestUtils::TestOOMList();

    // **********************************

#endif

    iHandleNew = ( flags & KImpsReqHandleNew ) ? ETrue : EFalse;

    iVariant = CImpsVariant::NewLC( );

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

    // default value used ubtil client request to change it.

    iExpiryTime = Server()->ExpirySeconds( iServiceType );

    }

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

// CImpsSubSession::Unregister()

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

void CImpsSubSession::Unregister()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: Unregister subses=%d h=%d type=%d" ),

                            ( TInt )this, Handle(), ( TInt )iServiceType );

#endif

    iCanceled = ETrue;

    DeleteAllRequests();

    // Complete new message observer

    CompleteEventMsg( KErrCancel );

    ( void ) DeleteAllEvents();

    }

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

// CImpsSubSession::DeleteSub()

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

void CImpsSubSession::DeleteSub()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: DeleteSub subses=%d type=%d" ), ( TInt )this, ( TInt )iServiceType );

#endif

    // Calculate new expiry timer value

    Server()->ResetExpiryTimer( iExpiryTime );

    // Delete this entity

    RMessage2 myMsg( Message() );

    iSession->DeleteSubSession( myMsg.Int3() );

    }

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

// CImpsSubSession::AssignIdL()

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

void CImpsSubSession::AssignIdL( TImpsSessIdent aCSP )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: AssignIdL subses=%d" ), ( TInt )this );

#endif

    // create an event for each orphan message

    CImpsFields* msg = NULL;

    msg = Server()->NextOrphanLC( iSession->ApplicationId(), iServiceType, aCSP );

    while ( msg )

        {

        SendEvent( msg, 0, EImpsServNone, EImpsMessageNone );

        CleanupStack::PopAndDestroy();

        msg = Server()->NextOrphanLC( iSession->ApplicationId(), iServiceType, aCSP );

        }

    }

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

// CImpsSubSession::HandleAllOrphans()

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

void CImpsSubSession::HandleAllOrphans( TImpsSessIdent aCSP )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: HandleAllOrphans subses=%d" ), ( TInt )this );

#endif

    TInt err = KErrNone;

    TRAP( err, AssignIdL( aCSP ) );

    }

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

// CImpsSubSession::DeleteAllEvents()

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

TInt CImpsSubSession::DeleteAllEvents(  )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: DeleteAllEvents subses=%d" ), ( TInt )this );

#endif

    TInt ret = 0;

    // Reset OOM_LIST too

    iOOMErr.Reset();

    // Delete all buffered events from this client,

    TDblQueIter<CWvEvent> rIter( iEventList );

    rIter.SetToFirst();

    while ( rIter )

        {

        CWvEvent* event = rIter;

        rIter++;

        if ( event->iSent )

            {

            ret++;

            }

        event->Destroy();

        }

    return ret;

    }

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

// CImpsSubSession::DeleteAllRequests()

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

void CImpsSubSession::DeleteAllRequests(  )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: DeleteAllRequests" ) );

#endif

    // Delete all buffered requests from this client.

    TDblQueIter<CRequest> rIter( iRequestList );

    rIter.SetToFirst();

    while ( rIter )

        {

        CRequest* requ = rIter;

        rIter++;

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SubSession: DeleteAllRequests TID=%S" ), &( requ->iTID ) );

#endif

        requ->Destroy();

        }

    }

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

// CImpsSubSession::LoginL()

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

void CImpsSubSession::LoginL( TBool aReactive )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: LoginL begins reactive=%d subses=%d" ),

                            aReactive, ( TInt )this );

#endif

    // OPID

    RMessage2 myMsg( Message() );

    TInt opId = myMsg.Int1();

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: Login opid=%d" ), opId );

#endif

    // Read PACKED ARRAY

    CDesCArrayFlat* tempArr = new ( ELeave )CDesCArrayFlat( 7 );

    CleanupStack::PushL( tempArr );   // << tempArr

    HBufC8* stream = *StreamBufAddr();

    if ( iSession->ReadBuffer8L( 0, stream ) )

        {

        HBufC8** stream2 = StreamBufAddr();

        *stream2 = stream;

        }

    TImpsPackedEntity packedMessage( stream );

    const TUint8* pS = stream->Ptr();

    packedMessage.DoUnpackArrayL( pS, tempArr );

    __ASSERT_DEBUG(

        tempArr->MdcaCount() == 7,

        User::Panic( KImpsPanicCategory,

                     EImpsCorrupted ) );

    TPtrC tid;

    TPtrC tempUser = tempArr->MdcaPoint( 0 );

    TPtrC tempPassword = tempArr->MdcaPoint( 1 );

    TPtrC tempCliId = tempArr->MdcaPoint( 2 );

    TPtrC tempSAP = tempArr->MdcaPoint( 3 );

    TPtrC key1 = tempArr->MdcaPoint( 4 );

    TPtrC key2 = tempArr->MdcaPoint( 5 );

    TPtrC ap = tempArr->MdcaPoint( 6 );

    // convert AP back

    TLex lex;

    TUint32 myAp;

    lex.Assign( ap );

    lex.Val( myAp, EDecimal );

    // Multi: update session's user-id and SAP.

    iSession->SetUserIdL( tempUser );

    iSession->SetSAPL( tempSAP );

    TImpsSessIdent csp( KNullDesC, tempSAP, tempUser );

    TPtrC p;

    if ( Server()->IsLogged( csp, &p ) )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SubSession: CSP already logged ín subses=%d" ), ( TInt )this );

#endif

        // check password: if it does not match then return an error.

        if ( p.CompareF( tempPassword ) )

            {

            User::Leave( KImpsErrorUnauthorized );

            }

        // Update session SID and other CSP identification data.

        iSession->ModifySIDL( Server()->SID( csp ) );

        iSession->SetSAPL( tempSAP );

        iSession->SetUserIdL( tempUser );

        // multi: Share existing CSP session

        // Send callback reponse to a client

        // Complete the open asyncronous request first and

        // after that send login event (callback).

        iSession->CompleteMe( KErrNone );

        SendLoginEvent( KErrNone, opId );

        if ( Server()->IsNegotiated( csp ) )

            {

            // On-line event too if CSP is negotiated.

            // Must sent via Session to all subsessions

            iSession->SendEvent( EInternal_ON_LINE );

            // Check orphan messages because of IM subsessions

            // may be registered before login request,

            // Create an event for each orphan message

            Server()->HandleAllOrphans();

            }

        tempArr->Reset();

        CleanupStack::PopAndDestroy( 1 );   // >> tempArr

        return;

        }

    // Save login expiry time and give it to CSP session too.

    TTime loginExpiry = Server()->ExpiryTime( iExpiryTime );

    tid.Set( Server()->LoginL( tempUser, tempPassword, tempCliId,

                               tempSAP, myAp, key1, key2, this, loginExpiry, aReactive ) );

    tempArr->Reset();

    CleanupStack::PopAndDestroy( 1 );   // >> tempArr

    // Update request queue

    // Add request into queue

    CRequest* request = new ( ELeave ) CRequest(

        tid,    // tid

        opId,   // op-id

        EImpsServWVLogin,

        loginExpiry,

        EImpsLoginReq

    );

    iRequestList.AddLast( *request );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: LoginL ends TID=%S" ), &tid );

#endif

    }

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

// CImpsSubSession::LogoutL()

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

TPtrC CImpsSubSession::LogoutL( TImpsSessIdent aCSP, TBool aCancel )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: LogoutL begins subses=%d" ), ( TInt )this );

#endif

    RMessage2 myMsg( Message() );

    TInt opId = myMsg.Int0();

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: Logout opid=%d" ), opId );

#endif

    TPtrC tid;

    // Login-cancel.

    if ( aCancel )

        {

        // Check that request still exists, if not then leave KErrNotFound

        TBool found( EFalse );

        TDblQueIter<CRequest> requestIter( iRequestList );

        requestIter.SetToFirst();

        while ( requestIter )

            {

            CRequest* request = requestIter;

            requestIter++;

            if ( request->iOpId == opId )

                {

                found = ETrue;

                break;

                }

            }

        if ( !found )

            {

            User::Leave( KErrNotFound );

            }

        }

    // Send logout request forward to CSP session entity

    TRAPD( errL, tid.Set( iSession->Server()->LogoutL( aCancel, aCSP ) ) );

    // If canceling login operation then client needs to get only one callback method call,

    // so do not save new CRequest entity then. The CSP session entity will call later

    // SendEvent to respond to the cancelled login operation if there is something

    // to cancel.

    if ( aCancel )

        {

        if ( errL )

            {

            // If the previous request leaves then there is nothing to cancel.

            // Therefore delete the login request entity now and verify that CSP entity

            // clear the particular transaction data,

            CancelTrans( myMsg, aCSP );

            User::Leave( errL );

            }

        // CSPSession will call back later and delete the request and send a response

        // event to cancel request when everyting is clear regarding cancel of login

        // transaction..

        return TPtrC();

        }

    if ( errL == KImpsErrorTerminalOffLine )

        {

        // Logout requested in such a situation where Logout request is

        // not needed nor not possible to be sent to SAP server.

        // We have to generate a response here

        // because of Logout must not fail in client API.

        SendLogoutEvent( KErrNone, opId );

        // Send NOT_LOGGED events to subhandles

        iSession->SendEvent( EInternal_NOT_LOGGED );

        return TPtrC();

        }

    else if ( errL )

        {

        // Unexpeted error situation

        User::Leave( errL );

        }

    // Add request into request queue

    CRequest* request = new ( ELeave ) CRequest(

        tid,

        opId,

        EImpsServWVLogout,

        Server()->ExpiryTime( iExpiryTime ),

        EImpsLogoutReq

    );

    iRequestList.AddLast( *request );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: LogoutL ends with tid=%S" ), &tid );

#endif

    return tid;

    }

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

// CImpsSubSession::Message()

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

// return message - get it from session

const RMessagePtr2 CImpsSubSession::Message() const

    {

    return iSession->Message();

    }

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

// CImpsSubSession::Server()

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

// return message - get it from session

CImpsServer* CImpsSubSession::Server()

    {

    return iSession->Server();

    }

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

// CImpsSubSession::DoSendStatusEvent()

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

void CImpsSubSession::DoSendStatusEvent( CWvEvent& aEvent )

    {

    // Status event is lighter than a regular event in a sense that

    // it does not write data to client thread, but updates iStatus

    // of the handler active object in a client thread only.

    if ( iEventMsg.IsNull() )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "SubSession: DoSendStatusEvent NULL MSG subses=%d" ),

                                ( TInt )this );

#endif

        return;

        }

    TInt newStatus = ConvertStatusCode( ( EImpsInternalStatus )aEvent.iAux );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SubSession: DoSendStatusEvent stat=%d subses=%d" ),

                            newStatus, ( TInt )this );

#endif

    CompleteEventMsg( newStatus );

    aEvent.iSent = ETrue;

    }

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

// CImpsSubSession::SendEvent()

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

void CImpsSubSession::SendEvent(

    CImpsFields *aFields,

    TInt aOpId,

    TImpsServRequest aRequestType,

    TImpsMessageType aReqMsgType )

    {

    TInt memErr = KErrNone;

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

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