/*

* Copyright (c) 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: Tcp CirWatcher

*

*

*/

// INCLUDE FILES

#include <ecom/ecom.h>

#include <f32file.h>

#ifdef _DEBUG

#include <flogger.h>

#endif

#include <msgconnmanagerapi.h>

#include <msgbearerObscallback.h>

#include "TcpCirWatcher.h"

#include "CirWatcherDefines.h"

#include "TcpCirWatcherTimer.h"

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

//

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

// CTcpCirWatcher::CTcpCirWatcher

//

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

//

CTcpCirWatcher::CTcpCirWatcher( const TInt aPingInterval,

                                MImpsCirReceiver& aCirReceiver,

                                MMsgConnManager& aConnManager ) :

        iPingInterval( aPingInterval ),

        iCirReceiver( aCirReceiver ),

        iConnectionManager( aConnManager ),

        iClientRequestPending( EFalse ),

        iWatcherStatus( EImpsCIRWatcherIdle ),

        iLastGoodWatcherStatus( EImpsCIRWatcherUnknown )

    {

    }

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

// CTcpCirWatcher::FinishConstructL

//

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

//

CTcpCirWatcher* CTcpCirWatcher::NewL( TTcpWatcherParameters* aParameters )

    {

    CTcpCirWatcher* self = new ( ELeave ) CTcpCirWatcher( aParameters->iPingInterval,

                                                          aParameters->iCirReceiver,

                                                          aParameters->iConnManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CImpsConnectionMonitor::ConstructL

//

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

//

void CTcpCirWatcher::ConstructL()

    {

#ifdef _DEBUG

    DeleteLogFileL();

#endif

    iWatcherTimer = CTcpCirWatcherTimer::NewL( this );

    CActiveScheduler::Add( this );

    }

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

// CTcpCirWatcher::~CTcpCirWatcher

// Destructor

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

//

CTcpCirWatcher::~CTcpCirWatcher()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::~CTcpCirWatcher()" ) );

#endif

    Cancel();

    delete iPacket;

    delete iWatcherTimer;

    delete iCSPSessionID;

    delete iSocketSendBuffer;

    delete iAddressBuffer;

    iTCPCIRSocket.Close();

#ifdef _DEBUG

    WriteToLog( _L8( "  Destructor ended" ) );

#endif

    }

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

// CTcpCirWatcher::DeleteLogFileL()

//

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

//

void CTcpCirWatcher::DeleteLogFileL()

    {

    RFs session;

    User::LeaveIfError( session.Connect() );

    CFileMan* manager = CFileMan::NewL( session );

    manager->Delete( _L( "C:\\Logs\\ImpsTcpWatcher\\*.*" ) );

    session.Close();

    delete manager;

    manager = NULL;

    }

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

// CTcpCirWatcher::SetPingInterval

//

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

//

void CTcpCirWatcher::SetPingInterval( const TInt aPingInterval )

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::SetPingInterval()  Interval: %d" ), aPingInterval );

#endif

    if ( aPingInterval > 0 )

        iPingInterval = aPingInterval;

    }

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

// CTcpCirWatcher::StartTCPWatcherL

//

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

//

void CTcpCirWatcher::StartTCPWatcherL( TRequestStatus& aStatus,

                                       const TUint aServerPort,

                                       const TDesC& aServerAddress,

                                       const TDesC8& aCSPSessionID )

    {

#ifdef _DEBUG

    HBufC8* id = HBufC8::NewL( aCSPSessionID.Length() );

    TPtr8 idPtr( id->Des() );

    idPtr.Copy( aCSPSessionID );

    TBuf8<200> eightBuf;

    eightBuf.Copy( aServerAddress );

    WriteToLog( _L8( "CTcpCirWatcher::StartTCPWatcher()" ) );

    WriteToLog( _L8( "  Server:     %S" ), &eightBuf );

    WriteToLog( _L8( "  Port:       %d" ), aServerPort );

    WriteToLog( _L8( "  Session ID: %S" ), &idPtr );

    delete id;

    id = NULL;

#endif

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    if ( iWatcherStatus == EImpsCIRWatcherIdle )

        {

        Reset();

        SetConnectionDetailsL( aServerAddress, aCSPSessionID, aServerPort );

        if ( iConnectionManager.Status() )

            {

            iClientRequestPending = ETrue;

            iConnectionManager.AddEventSubscriberL( this );

            //Might be DNS name, must make sure we get an IP address

            User::LeaveIfError( iHostResolver.Open( iConnectionManager.SocketSession(),

                                                    KAfInet, KProtocolInetUdp,

                                                    iConnectionManager.Connection() ) );

            iHostResolver.GetByName( *iAddressBuffer, iHostAddressDnsEntry, iStatus );

            iWatcherStatus = EImpsCIRWatcherAwaitingDNS;

            SetActive();

#ifdef _DEBUG

            WriteToLog( _L8( "  Waiting for host resolver to complete" ) );

#endif

            }

        else

            {

#ifdef _DEBUG

            WriteToLog( _L8( "  Bearer is not ready, complete with KErrCouldNotConnect." ) );

#endif

            User::RequestComplete( iClientStatus, KErrCouldNotConnect );

            }

        }

    else

        {

#ifdef _DEBUG

        WriteToLog( _L8( "  Watcher is not ready, complete with KErrNotReady." ) );

#endif

        User::RequestComplete( iClientStatus, KErrNotReady );

        }

    }

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

// CTcpCirWatcher::SetConnectionDetails

//

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

//

void CTcpCirWatcher::SetConnectionDetailsL( const TDesC& aServerAddress,

                                            const TDesC8& aCSPSessionID,

                                            const TUint aServerPort )

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::SetConnectionDetails" ) );

#endif

    iServerPort = aServerPort;

    iCSPSessionID = HBufC8::NewL( aCSPSessionID.Length() );

    iCSPSessionID->Des().Copy( aCSPSessionID );

    iAddressBuffer = HBufC::NewL( aServerAddress.Length() );

    iAddressBuffer->Des().Copy( aServerAddress );

    }

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

// CTcpCirWatcher::Reset

//

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

//

void CTcpCirWatcher::Reset()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::Reset()" ) );

#endif

    delete iCSPSessionID;

    iCSPSessionID = NULL;

    delete iAddressBuffer;

    iAddressBuffer = NULL;

    iPingRetries = 0;

    iConnRetries = 0;

    }

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

// CTcpCirWatcher::StopTCPWatcher

// Destructor

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

//

void CTcpCirWatcher::StopTCPWatcher()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "StopTCPWatcher()" ) );

#endif

    if ( iWatcherStatus == EImpsCIRWatcherAwaitingDNS )

        {

#ifdef _DEBUG

        WriteToLog( _L8( "  Status is EImpsCIRWatcherAwaitingDNS, cancel resolver" ) );

#endif

        iHostResolver.Cancel();

        //If the client requests another start inside the scheduler

        //loop that completes the previous Start() request, the second

        //request will fail with KErrNotReady, since this component must

        //wait for the host resolver to return in RunL(). The method will

        //alter the state of this component to EImpsCIRWatcherIdle.

        //iClientRequestPending = EFalse;

        //iWatcherStatus = EImpsCIRWatcherStopping;

        //User::RequestComplete( iClientStatus, KErrCancel );

#ifdef _DEBUG

        WriteToLog( _L8( "  Resolver cancelled, request not completed" ) );

#endif

        }

    else

        {

        if ( iWatcherStatus != KImpsCIRWatcherStopping &&

             iWatcherStatus != EImpsCIRWatcherIdle )

            {

            iWatcherTimer->Cancel();

            if ( iConnectionManager.NumberOfActiveConns() > 0 )

                {

                // Socket Connection is getting disconnected and closed when Ending the PacketDataConnection

                // if active connection is not exists not required to cancel.

                iTCPCIRSocket.CancelAll();

                }

            if ( iClientRequestPending &&

                 ( iWatcherStatus == EImpsCIRWatcherConnectingTCPSocket ||

                   iWatcherStatus == EImpsCIRWatcherSendingHELOMessage ||

                   iWatcherStatus == EImpsCIRWatcherReceivingHELOResponse ) )

                {

#ifdef _DEBUG

                WriteToLog( _L8( "  A request is pending, complete with KErrCancel" ) );

#endif

                User::RequestComplete( iClientStatus, KErrCancel );

                iWatcherStatus = EImpsCIRWatcherIdle;

                }

            else

                iWatcherStatus = EImpsCIRWatcherStopping;

            iConnectionManager.RemoveEventSubscriber( this );

            }

        else

            {

#ifdef _DEBUG

            WriteToLog( _L8( "  Status is %d" ), iWatcherStatus );

#endif

            }

        }

    }

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

// CTcpCirWatcher::WatcherStatus

//

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

//

TUint CTcpCirWatcher::WatcherStatus() const

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::WatcherStatus()" ) );

#endif

    return iWatcherStatus;

    }

#ifdef _DEBUG

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

// CTcpCirWatcher::WriteToLog

//

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

//

void CTcpCirWatcher::WriteToLog( TRefByValue<const TDesC8> aFmt, ... )

    {

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf8<KTcpLogBufferMaxSize> buf;

    buf.FormatList( aFmt, list );

    RFileLogger::Write( KTcpLogDir, KTcpWatcherLogFile, EFileLoggingModeAppend, buf );

    }

#endif

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

// CTcpCirWatcher::WaitForHELOResponse

//

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

//

void CTcpCirWatcher::WaitForHELOResponse()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::WaitForHELOResponse()" ) );

#endif

    iSocketReceiveBuffer.Zero();

    iStatus = KRequestPending;

    iWatcherStatus = EImpsCIRWatcherReceivingHELOResponse;

    iTCPCIRSocket.RecvOneOrMore( iSocketReceiveBuffer, 0, iStatus, iRecvLength );

    iWatcherTimer->ActivateTimer( 10000000, KWaitForHELOResponse );

    SetActive();

    }

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

// CTcpCirWatcher::ConnectTCPSocket

//

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

//

void CTcpCirWatcher::ConnectTCPSocketL()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::ConnectTCPSocket()  iConnRetries: %d" ), iConnRetries );

#endif

    iWatcherStatus = EImpsCIRWatcherConnectingTCPSocket;

    User::LeaveIfError( iTCPCIRSocket.Open( iConnectionManager.SocketSession(),

                                            KAfInet, KSockStream, KProtocolInetTcp,

                                            iConnectionManager.Connection() ) );

    if ( iConnRetries < KMaxNumberOfConnAttempts )

        {

        iTCPCIRSocket.Connect( iSocketAddress, iStatus );

        iConnRetries++;

        SetActive();

        iWatcherTimer->ActivateTimer( 20000000, KWaitForFirstConnectAttempt );

        }

    else

        {

        iTCPCIRSocket.Close();

        iCirReceiver.HandleErrorL( KErrCouldNotConnect, EImpsTcpCir );

        iWatcherStatus = EImpsCIRWatcherIdle;

        iConnectionManager.RemoveEventSubscriber( this );

#ifdef _DEBUG

        WriteToLog( _L8( "  Connect retry limit encountered, stop." ) );

#endif

        }

    }

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

// CTcpCirWatcher::SendHELOMessageL

//

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

//

void CTcpCirWatcher::SendHELOMessageL()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::SendHELOMessageL()" ) );

#endif

    iWatcherStatus = EImpsCIRWatcherSendingHELOMessage;

    delete iSocketSendBuffer;

    iSocketSendBuffer = NULL;

    iSocketSendBuffer = HBufC8::NewL( 7 + iCSPSessionID->Length() );

    iSocketSendBuffer->Des().Copy( KHELOMessage );

    iSocketSendBuffer->Des().Append( *iCSPSessionID );

    iSocketSendBuffer->Des().Append( KMessageTermination );

    iStatus = KRequestPending;

    iTCPCIRSocket.Write( iSocketSendBuffer->Des(), iStatus );

    iWatcherTimer->ActivateTimer( 10000000, KWaitForHELOSendAttempt );

    SetActive();

    }

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

// CTcpCirWatcher::SendPing

//

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

//

void CTcpCirWatcher::SendPingL()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::SendPing()  iPingRetries: %d/%d" ), iPingRetries, KMaxNumberOfPingAttempts );

#endif

    if ( iPingRetries < KMaxNumberOfPingAttempts )

        {

        iWatcherStatus = EImpsCIRWatcherSendingPINGRequest;

        iTCPCIRSocket.Write( KImpsPingData, iStatus );

        iPingRetries++;

        SetActive();

        }

    else

        {

        //The server is down, close the socket and report error

        iTCPCIRSocket.Close();

        iCirReceiver.HandleErrorL( KErrDisconnected, EImpsTcpCir );

        iWatcherStatus = EImpsCIRWatcherIdle;

        iConnectionManager.RemoveEventSubscriber( this );

#ifdef _DEBUG

        WriteToLog( _L8( "  Ping retry limit encountered, stop." ) );

#endif

        }

    }

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

// CTcpCirWatcher::RunL

//

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

//

void CTcpCirWatcher::RunL()

    {

#ifdef _DEBUG

    WriteToLog( _L8( "CTcpCirWatcher::RunL(), iStatus: %d" ), iStatus );

#endif

    iWatcherTimer->Cancel();

    switch ( iWatcherStatus )

        {

        case EImpsCIRWatcherAwaitingDNS:

            if ( iStatus == KErrNone )

                {

                iSocketAddress = TInetAddr( iHostAddressDnsEntry().iAddr );

#ifdef _DEBUG

                TBuf<200> buffer;

                TBuf8<200> eightBuffer;

                iSocketAddress.Output( buffer );

                eightBuffer.Copy( buffer );

                WriteToLog( _L8( "  IP address resolved (%S), starting to connect." ), &eightBuffer );

#endif

                iSocketAddress.SetPort( iServerPort );

                iHostResolver.Close();

                ConnectTCPSocketL();

                }

            else

                {

#ifdef _DEBUG

                WriteToLog( _L8( "  IP address resolving failed, complete with %d." ), iStatus.Int() );

#endif

                iConnectionManager.RemoveEventSubscriber( this );

                User::RequestComplete( iClientStatus, iStatus.Int() );

                iWatcherStatus = EImpsCIRWatcherIdle;

                }

            break;

        default:

            if ( iStatus == KErrNone )

                HandleRequestCompletionL();

            else

                HandleErrorL( iStatus.Int() );

        }

    }

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

// CTcpCirWatcher::HandleRequestCompletionL

//

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

//

void CTcpCirWatcher::HandleRequestCompletionL()

    {

    switch ( iWatcherStatus )

        {

        case EImpsCIRWatcherConnectingTCPSocket:

#ifdef _DEBUG

            WriteToLog( _L8( "  TCP Socket is connected, starting to send HELO." ) );

#endif

            iConnRetries = 0;

            SendHELOMessageL();

            break;

        case EImpsCIRWatcherSendingHELOMessage:

#ifdef _DEBUG

            WriteToLog( _L8( "  HELO Message sent, waiting for response." ) );

#endif

            WaitForHELOResponse();

            break;

        case EImpsCIRWatcherReceivingHELOResponse:

#ifdef _DEBUG

            WriteToLog( _L8( "  Server responded with the message: %S" ), &iSocketReceiveBuffer );

#endif

            if ( iClientRequestPending )

                {

#ifdef _DEBUG

                WriteToLog( _L8( "  Completing request & starting to PING the server in %d second intervals." ), iPingInterval );

#endif

                User::RequestComplete( iClientStatus, KErrNone );

                iClientRequestPending = EFalse;

                }

            WaitForNextPing();

            break;

        case EImpsCIRWatcherSendingPINGRequest:

#ifdef _DEBUG

            WriteToLog( _L8( "  Ping sent succesfully, wait for response" ) );

#endif

            iWatcherStatus = EImpsCIRWatcherWaitingPINGResponse;

            iWatcherTimer->ActivateTimer( 5000000, KWaitForPingReply );

            ReceiveFromSocket();

            break;

        case EImpsCIRWatcherWaitingPINGResponse:

#ifdef _DEBUG

            WriteToLog( _L8( "  Server responded to ping with the message: %S" ), &iSocketReceiveBuffer );

#endif

            if ( iSocketReceiveBuffer.Find( KImpsPingResponseWVCI ) == 0 )