/*

* Copyright (c) 2004 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: Session for IMPS.

*

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    <e32math.h>

#include    "impsserver.h"

#include    "impssession.h"

#include    "impssubsession.h"

#include    "impscspsession.h"

#include    "impsfields.h"

#include    "impsutils.h"

#include    "impserrors.h"

#include    "impstimer.h"

#include    "impssendreceive.h"

#include    "impsservices.h"

#include    "impscommonenums.h"

#include    "impssdatautils.h"

#include    "impsmessageinterpreterapi.h"

#include    "impsdataaccessor.h"

#include    "impsdigestbytes.h"

#include    "impsvariant.h"

#include    "impsalivemanager.h"

#include    "impsactivecirmonitor.h"

#include    "ImpsVariantAPI.h"

#include    "impstidqueue.h"

#include    "impsactivecirmonitor.h"

#ifdef LOCAL_IMPS

#ifndef _FAKE_RESPONSE

#define _FAKE_RESPONSE

#endif

#endif

#ifdef _FAKE_RESPONSE

#include    "impssrvtestutils.h"

#endif

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

// CONSTANTS

// Adative polling policy time increment

const TInt KImpsPollIncrement = 10;

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

CImpsCSPSession::CImpsCSPSession( CImpsServer& aServer,

                                  TImpsSrvSettings& aSettings,

                                  RFs& aFs,

                                  CImpsVariant& aVariant,

                                  TImpsCspVersion aVer ):

        iServer( aServer ),

        iCSPVersion( aVer ),

        iFs( aFs ),

        iVariant( aVariant ),

        iTransactionList( _FOFF( CTransaction, iLink ) ), //lint !e413

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

        iCSPState( EImpsCSPIdle ),

        iPendingLogout( EFalse ),

        iAliveMgr( NULL ),

        iPollTime( KImpsPollTime ),

        iPollWasRequested( EFalse ),

        iUserId( NULL ),

        iIntStatus ( EInternal_NOT_LOGGED ),

        iMultiTrans( KImpsMultiTrans ),

        iNegoExpiry( ),

        iCirManager( NULL ),

        iLogoutTID( KNullDesC ),

        iConAllowed( ETrue ),

        iPendingAlive( EFalse ),

        iSAP( NULL ),

        iIAP( 0 ),

        iPollState( EImpsPollNone ),

        iPollInResume( 0 ),

        iPendingPDP( EImpsPDPPendNone ),    // PDP:

        iPendPDPLogout ( EFalse ), // PDP:

        iTidSapHistory( NULL ),

        iTidCliHistory( NULL ),

        iTcpCIRError( EFalse ),

        iCancelLogin ( EFalse )

    {

    iCSPSessionId = KNullDesC;

    iLogCID = KNullDesC;

    iTempTid = KNullDesC;

    iTempTid2 = KNullDesC;

    iMsg = EImpsMessageNone;

    iLoginPhase = 1;

    iKey1 = NULL;

    iKey2 = NULL;

    iSettings = aSettings;

    }

// Create and start a new server.

CImpsCSPSession* CImpsCSPSession::NewL( CImpsServer& aServer,

                                        TImpsSrvSettings& aSettings,

                                        RFs& aFs,

                                        CImpsVariant& aVariant,

                                        TImpsCspVersion aVer )

    {

#ifndef _NO_IMPS_LOGGING_

    if ( aVer == EImpsCspVersion11 )

        {

        CImpsClientLogger::Log( _L( "CSPSession: NewL rel200542.2+ WV 1.1" ) );

        }

    else

        {

        CImpsClientLogger::Log( _L( "CSPSession: NewL rel200542.2+ WV 1.2" ) );

        }

#endif

    CImpsCSPSession* self = new ( ELeave ) CImpsCSPSession( aServer,

                                                            aSettings, aFs, aVariant, aVer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CImpsCSPSession::~CImpsCSPSession()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: DESTRUCTOR csp=%d **" ), ( TInt )this );

#endif

    // deallocate all memory

    DeleteTransactions();

    DeleteRequests();

    delete iTransportOut;

    delete iCirManager;

    delete iReceiver2;

    delete iAllMessages;

    delete iRcv;

    delete iSnd;

    delete iIdleTimer;

    delete iAliveMgr;

    delete iSendQ;

    delete iTCPAddr;

    delete iLogPwd;

    delete iLogTid;

    delete iKey1;

    delete iKey2;

    delete iUserId;

    delete iSAP;

    if ( iDecoder )

        {

        iDecoder->Destroy();

        }

    if ( iEncoder )

        {

        iEncoder->Destroy();

        }

    delete iPDPIdleTimer;

    delete iPDPOpenTimer;

    delete iTidSapHistory;

    delete iTidCliHistory;

    }

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

// CImpsCSPSession::Destroy()

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

void CImpsCSPSession::Destroy()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: Destroy csp=%d" ), ( TInt )this );

#endif

    // You MUST delete ip-cir entity before conn-manager entity.

    // refer to ImpsIpCirWatcherApi.h.

    delete iCirManager;

    iCirManager = NULL;

    iReceiver2->Destroy();

    delete iReceiver2;

    iReceiver2 = NULL;

    }

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

// CImpsCSPSession::ConstructL()

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

void CImpsCSPSession::ConstructL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: ConstructL begins csp=%d **" ), ( TInt )this );

#endif

    iTransportOut = CBufFlat::NewL( KImpsStreamSize / 2 );

    iTransportOut->ResizeL( KImpsStreamSize );

    iDecoder = NewDecoderL( this );

    iEncoder = NewEncoderL();

    iTidSapHistory = CImpsTidQueue::NewL();

    iTidCliHistory = CImpsTidQueue::NewL();

    iSnd = CImpsFields::NewL();

    iRcv = CImpsFields::NewL();

    iIdleTimer = new ( ELeave ) CImpsIdleTimer( *this, CActive::EPriorityStandard );

    iPDPIdleTimer = new ( ELeave ) CImpsPDPIdleTimer( *this, CActive::EPriorityStandard );

    iPDPOpenTimer = new ( ELeave ) CImpsPDPOpenTimer( *this, CActive::EPriorityStandard );

    iAliveMgr = CImpsAliveManager::NewL( *this );

    iSendQ = new ( ELeave ) CImpsSendQueued( * this, CActive::EPriorityStandard );

    // Just initialize undefined address

    iTCPAddr = HBufC::NewL( 1 );

    *iTCPAddr = KNullDesC;

    TPtrC8 myMime = iEncoder->MimeType();

    iReceiver2 = CImpsSendReceive2::NewL(

                     iFs, *this, *iTransportOut, myMime );

#ifndef _NO_IMPS_LOGGING_

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

#endif

    }

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

// CImpsCSPSession::CloseAll()

// CImpsServer::CloseEngine calls this. TransportStatus handles the callback.

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

void CImpsCSPSession::CloseAll( )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: CloseAll %d csp=%d" ), ( TInt )this );

#endif

    NewState( EImpsCSPShuttingDown );

    if ( iIdleTimer )

        {

        iIdleTimer->Stop( );

        }

    iPollState = EImpsPollNone;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: iPollState %d" ), iPollState );

#endif

    if ( iAliveMgr )

        {

        iAliveMgr->StopTimer( );

        }

    if ( iSendQ )

        {

        iSendQ->Cancel( );

        }

    if ( iCirManager )

        {

        iCirManager->CloseCh( 0xF );

        delete iCirManager;

        iCirManager = NULL;

        }

    // Close the transport

    if ( iReceiver2 )

        {

        iReceiver2->CloseTr( );

        }

    // TransportStatus handles rest of shut down activities

    }

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

// CImpsCSPSession::ClosePDP

// called by - CImpsPDPIdleTimer

// ClosePDP method needed to close PDP-context.

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

void CImpsCSPSession::ClosePDP()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: ClosePDP" ) );

#endif

    if ( iPollState != EImpsPollCIR )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: ClosePDP IGNORED iPollState = %d****" ),

                                iPollState );

#endif

        return;

        }

    if ( IsPDPIdle() )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: ClosePDP PDP already IDLE ****" ) );

#endif

        if ( iCSPState == EImpsCSPOnLineIdleEnd )

            {

#ifndef _NO_IMPS_LOGGING_

            CImpsClientLogger::Log( _L( "CSPSession: ClosePDP -> EImpsPDPPendClose" ) );

#endif

            // set pending close request if PDP is opening

            iPendingPDP = EImpsPDPPendClose;

            }

        return;

        }

    NewState( EImpsCSPOnLineIdleStart );

    // This does not close WAP-SMS-CIR

    if ( iCirManager )

        {

        iCirManager->CloseCh( 0xF );

        delete iCirManager;

        iCirManager = NULL;

        }

    // Close the transport

    if ( iReceiver2 )

        {

        iReceiver2->ClosePDP( );

        }

    // TransportStatus handles rest of shut down activities

    }

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

// CImpsCSPSession::OpenPDP

// Called by LogoutL, SendAliveL, SendDataL, TransportStatus, SendAllQueued

// Called by CIRMessageL directly and by the CImpsPDPTimer class too.

// OpenPDP method needed to re-open PDP-context

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

TInt CImpsCSPSession::OpenPDP()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: OpenPDP" ) );

#endif

    if ( !IsPDPIdle() )

        {

        // Nothing to do

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: OpenPDP IGNORED - not idle" ) );

#endif

        return KErrAlreadyExists;

        }

    else if ( iCSPState == EImpsCSPOnLineIdleEnd )

        {

        // already opening

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: OpenPDP IGNORED - EImpsCSPOnLineIdleEnd" ) );

#endif

        return KErrNotReady;

        }

    else if ( iCSPState == EImpsCSPOnLineIdleStart )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: OpenPDP -> EImpsPDPPendOpen" ) );

#endif

        iPendingPDP = EImpsPDPPendOpen;

        return KErrNone;

        }

    NewState( EImpsCSPOnLineIdleEnd );

    TRAPD( errx, iReceiver2->OpenPDPL( SAP(), iIAP ) );

    if ( errx )

        {

        NewState( EImpsCSPOnLineIdle );

        // Does not matter which error code is returned. Used in Logout only

        // to start internal logout routines.

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: err: openpdp E1 ****" ) );

#endif

        return KErrGeneral;

        }

    return KErrNone;

    // TransportStatus/transportError handles rest of open activities

    }

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

// CImpsCSPSession::LoginL

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

TPtrC CImpsCSPSession::LoginL(

    const TDesC& aUser,

    const TDesC& aPassword,

    const TDesC& aClientId,

    const TDesC& aSAP,

    TUint32 aAP,

    const TDesC& aKey1,

    const TDesC& aKey2,

    TTime aLoginExpiry,

    TBool aReactive )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: LoginL state=%d csp=%d" ), iCSPState, ( TInt )this );

#endif

    // AOL Login

    if ( aKey1.Length() && aKey2.Length() )

        {

        // this should be the case anyway

        iSettings.iFourWayLogin = ETrue;

        delete iKey1;

        iKey1 = NULL;

        iKey1 = aKey1.AllocL();

        delete iKey2;

        iKey2 = NULL;

        iKey2 = aKey2.AllocL();

        }

    TPtrC tid ( KNullDesC );

    delete iSAP;

    iSAP = NULL;

    iSAP = aSAP.AllocL();

    iIAP = aAP;

    iPendingAlive = EFalse;

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CSPSession: iPendingAlive->F" ) );

#endif

    if ( iCSPState >= EImpsCSPLogged )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: err: Login when logged ***" ) );

#endif

        User::Leave( KImpsErrorAlreadyLogged );

        }

    else if ( iCSPState == EImpsCSPDisconnecting )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: err: Login when CSP logging out ***" ) );

#endif

        User::Leave(  KErrNotReady );

        }

    // Check that no active CSP session exists

    // This should not happen before login

    else if ( iReceiver2->NbrOfPending() >= KImpsMaxPending ||

              iCSPState == EImpsCSPLogging )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: err: Login when busy ***" ) );

#endif

        User::Leave( KErrNotReady );

        }

    // Close old connections if any in re-login case (wrong psw first time e.g.)

    // The pending logout response is handled above, not here.

    else if ( iReceiver2->isConnected() )

        {

        // These are for re-login without logout after an error response

        NewState( EImpsCSPIdle );

        iPollState = EImpsPollNone;

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CSPSession: iPollState %d" ), iPollState );

        CImpsClientLogger::Log( _L( "CSPSession: err: transport was connected ***" ) );

#endif

        iAliveMgr->StopTimer();

        iSendQ->Cancel();

        iIntStatus = EInternal_NOT_LOGGED;

        iReceiver2->CloseTr();

        User::Leave( KErrNotReady );

        }

    // aPassword cannot be NULL

    delete iLogPwd;

    iLogPwd = NULL;

    delete iUserId;

    iUserId = NULL;

    iLogPwd = aPassword.AllocL();

    iUserId = aUser.AllocL();

    iLogCID = aClientId;

    iLogoutTID = KNullDesC;

    iNegoExpiry = aLoginExpiry;

    iReactive = aReactive;

    TImpsSrvUtils::InitializeServices( iServices, iReactive );

    // Make a login request

    iSnd->Reset();

    tid.Set( GenerateTid() );

    iSnd->SetTidL( tid );

    iSnd->SetMessageType( EImpsLoginReq );

    // Session type is OUTBAND

    iSnd->SetSessionTypeL( EImpsOutband );

    TImpsDataAccessor myAccess( iSnd );

    CImpsKey* myKey = CImpsKey::NewLC();    // <<< myKey

    iAliveTime = iSettings.iAliveTime;

    if ( iSettings.iFourWayLogin == EFalse )

        {

        TImpsSDataUtils::CreateLoginReqL(

            myKey,

            &myAccess,

            aUser,

            iLogCID,

            LogPwd(),

            GenerateCookie(),

            iAliveTime );

        // set this, that response goes to the right place

        iLoginPhase = 2;

        }

    else

        {

        TImpsDigestSchema aSchema = EImpsMD5;

        TImpsSDataUtils::CreateLoginReqPhaseOneL(

            myKey,

            &myAccess,

            aUser,

            iLogCID,

            aSchema,

            GenerateCookie(),

            iAliveTime );