/*
* Copyright (c) 2010 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:  Secure connections test application
*
*/

#include "tlsconnection.h"
#include <e32debug.h>
#include <SecureSocket.h>
#include <ssl_internal.h>       // KSolInetSSL, KSoSSLDomainName

_LIT( KData, "GET index.html" );
_LIT( KSecureProtocol, "TLS1.0" );
_LIT( KCommDBIapId, "IAP\\Id" );
_LIT8( KNewLine, "\n" );

const TInt KRecvBufferLength = 0x4000;
const TInt KOneSecondInMicroseconds = 1000000;


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

// ---------------------------------------------------------
// CTlsConnection::NewL
// ---------------------------------------------------------
//
CTlsConnection* CTlsConnection::NewL( MTlsConnectionObserver& aObs )
    {
    RDebug::Print( _L("CTlsConnection::NewL()") );
    CTlsConnection* self = new ( ELeave ) CTlsConnection( aObs );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CTlsConnection::~CTlsConnection()
// -----------------------------------------------------------------------------
//
CTlsConnection::~CTlsConnection()
    {
    RDebug::Print( _L("CTlsConnection::~CTlsConnection()") );
    Cancel();
    iDelayTimer.Close();
    CloseSession();
    delete iSendBuffer;
    delete iSendBufPtr;
    }

// -----------------------------------------------------------------------------
// CTlsConnection::ConnectL()
// -----------------------------------------------------------------------------
//
void CTlsConnection::ConnectL( const TDesC& aHostName, TInt aPort, TInt aDelay )
    {
    RDebug::Print( _L("CTlsConnection::Connect() host '%S', port %d, delay %d"),
        &aHostName, aPort, aDelay );
    CloseConnection();

    // Parameters
    if( iHostName )
        {
        delete iHostName;
        iHostName = NULL;
        }
    iHostName = aHostName.AllocL();
    iPort = aPort;
    iDelay = aDelay;

    // Save host name in 8-bit form for server certificate checking
    if( iHostNameForCertCheck )
        {
        delete iHostNameForCertCheck;
        iHostNameForCertCheck = NULL;
        }
    iHostNameForCertCheck = HBufC8::NewL( aHostName.Length() );
    TPtr8 ptr( iHostNameForCertCheck->Des() );
    ptr.Copy( aHostName );

    // Convert send data to 8-bit and add newline at the end
    if( iSendBuffer || iSendBufPtr )
        {
        delete iSendBuffer;
        iSendBuffer = NULL;
        delete iSendBufPtr;
        iSendBufPtr = NULL;
        }
    iSendBuffer = HBufC8::NewL( KData().Length() + 1 );
    iSendBufPtr = new( ELeave ) TPtr8( iSendBuffer->Des() );
    iSendBufPtr->Copy( KData );
    iSendBufPtr->Append( KNewLine );

    // Connect
    RDebug::Printf( "CTlsConnection::ConnectL iConnection.Open" );
    User::LeaveIfError( iConnection.Open( iSockServer ) );
    RDebug::Printf( "CTlsConnection::ConnectL iConnPref.SetDirection" );
    iConnPref.SetDirection( ECommDbConnectionDirectionOutgoing );
    if( iCurrentIap )
        {
        // uses the same IAP as before
        RDebug::Printf( "CTlsConnection::ConnectL SetIapId(%d)", iCurrentIap );
        iConnPref.SetIapId( iCurrentIap );
        iConnPref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
        }
    else
        {
        // not defined, prompts the IAP from user
        RDebug::Printf( "CTlsConnection::ConnectL ECommDbDialogPrefPrompt" );
        iConnPref.SetDialogPreference( ECommDbDialogPrefPrompt );
        }
    StateChange( EConnectingNetwork );
    RDebug::Printf( "CTlsConnection::ConnectL iConnection.Start" );
    iConnection.Start( iConnPref, iStatus );
    SetActive();
    RDebug::Printf( "CTlsConnection::ConnectL end" );
    }

// -----------------------------------------------------------------------------
// CTlsConnection::Disconnect()
// -----------------------------------------------------------------------------
//
void CTlsConnection::Disconnect()
    {
    Cancel();
    CloseConnection();
    StateChange( EDisconnected );
    }

// -----------------------------------------------------------------------------
// CTlsConnection::RunL
// -----------------------------------------------------------------------------
//
void CTlsConnection::RunL()
    {
    if( iState == EReading && ( iStatus.Int() == KErrEof || iStatus.Int() == KErrSSLAlertCloseNotify ) )
        {
        RDebug::Printf( "CTlsConnection::RunL: EReading, EOF: iStatus = %d", iStatus.Int() );
        StateChange( EAllDone );
        }
    else if( iStatus.Int() == KErrNone )
        {
        switch ( iState )
            {
            case EConnectingNetwork:
                RDebug::Printf( "CTlsConnection::RunL: EConnectingNetwork" );
                if( !iCurrentIap )
                    {
                    iConnection.GetIntSetting( KCommDBIapId, iCurrentIap );
                    }
                if( iDelay )
                    {
                    TTimeIntervalMicroSeconds32 delay( iDelay * KOneSecondInMicroseconds );
                    iDelayTimer.After( iStatus, delay );
                    StateChange( EOpeningDelay );
                    }
                else
                    {
                    iConnection.ProgressNotification( iProgress, iStatus );
                    StateChange( EResolvingHostName );
                    }
                SetActive();
                break;

            case EOpeningDelay:
                iConnection.ProgressNotification( iProgress, iStatus );
                StateChange( EResolvingHostName );
                SetActive();
                break;

            case EResolvingHostName:
                {
                RDebug::Printf( "CTlsConnection::RunL: EResolvingHostName" );
                TInt err = iHostResolver.Open( iSockServer, KAfInet, KProtocolInetUdp, iConnection );
                User::LeaveIfError( err );
                iHostResolver.GetByName( *iHostName, iNameEntry, iStatus );
                StateChange( EConnectingServer );
                SetActive();
                }
                break;

            case EConnectingServer:
                {
                iRemoteAddr.SetFamily( KAfInet );
                iRemoteAddr = TInetAddr( iNameEntry().iAddr );
                iRemoteAddr.SetPort( iPort );

                RDebug::Printf( "CTlsConnection::RunL: EConnectingServer" );
                TInt err = iSocket.Open( iSockServer, KAfInet, KSockStream, KProtocolInetTcp, iConnection );
                RDebug::Printf( "CTlsConnection::RunL: iSocket.Open ret %d", err );
                User::LeaveIfError( err );
                iSocket.Connect( iRemoteAddr, iStatus );
                StateChange( EHandshaking );
                SetActive();
                }
                break;

            case EHandshaking:
                {
                RDebug::Printf( "CTlsConnection::RunL: EHandshaking" );
                if( iSecureSocket )
                    {
                    delete iSecureSocket;
                    iSecureSocket = NULL;
                    }
                iSecureSocket = CSecureSocket::NewL( iSocket, KSecureProtocol );
                iSecureSocket->SetDialogMode( EDialogModeAttended );
                // Server name must be set, otherwise CCTSecurityDialogsAO fails with KErrArgument
                iSecureSocket->SetOpt( KSoSSLDomainName, KSolInetSSL, *iHostNameForCertCheck );
                iSecureSocket->StartClientHandshake( iStatus );
                StateChange( EConnecting );
                SetActive();
                }
                break;

            case EConnecting:
                {
                RDebug::Printf( "CTlsConnection::RunL: EConnecting" );
                // Check if connection is closed
                const TInt stage( iProgress().iStage );
                if( stage == KConnectionClosed || stage == KLinkLayerClosed )
                    {
                    StateChange( EDisconnected );
                    }
                else
                    {
                    iConnection.ProgressNotification( iProgress, iStatus );
                    StateChange( ESending );
                    SetActive();
                    }
                }
                break;

            case ESending:
                RDebug::Printf( "CTlsConnection::RunL: ESending" );
                iSecureSocket->Send( *iSendBufPtr, iStatus, iSendLength );
                StateChange( EReading );
                SetActive();
                break;

            case EReading:
                iTotalRecvCount += iRecvLength();
                RDebug::Printf( "CTlsConnection::RunL: EReading, read %d bytes", iTotalRecvCount );
                iObserver.HandleTransferData( iRecvBuffer->Des(), iTotalRecvCount );

                iRecvBufPtr->Zero();
                iSecureSocket->RecvOneOrMore( *iRecvBufPtr, iStatus, iRecvLength );
                SetActive();
                break;

            default:
                break;
            }
        }
    else
        {
        RDebug::Printf( "CTlsConnection::RunL: ERROR iStatus %d", iStatus.Int() );
        CloseConnection();
        StateChange( EDisconnected, iStatus.Int() );
        }
    }

// ---------------------------------------------------------------------------
// CTlsConnection::DoCancel()
// ---------------------------------------------------------------------------
//
void CTlsConnection::DoCancel()
    {
    RDebug::Printf( "CTlsConnection::DoCancel(), iState=%d", iState );

    switch( iState )
        {
        case EConnectingNetwork:
            iConnection.Stop();
            break;

        case EOpeningDelay:
            iDelayTimer.Cancel();
            iConnection.Stop();
            break;

        case EResolvingHostName:
            iConnection.CancelProgressNotification();
            iConnection.Stop();
            break;

        case EConnectingServer:
            iHostResolver.Cancel();
            iConnection.Stop();
            break;

        case EHandshaking:
            iSocket.CancelConnect();
            iConnection.Stop();
            break;

        case EConnecting:
            if( iSecureSocket )
                {
                iSecureSocket->CancelHandshake();
                delete iSecureSocket;
                iSecureSocket = NULL;
                }
            iSocket.Close();
            iConnection.Stop();
            break;

        case ESending:
            if( iSecureSocket )
                {
                iSecureSocket->CancelSend();
                delete iSecureSocket;
                iSecureSocket = NULL;
                }
            iSocket.Close();
            iConnection.Stop();
            break;

        case EReading:
            if( iSecureSocket )
                {
                iSecureSocket->CancelRecv();
                delete iSecureSocket;
                iSecureSocket = NULL;
                }
            iSocket.Close();
            iConnection.Stop();
            break;

        case EAllDone:
        case EIdle:
        case EDisconnected:
        default:
            break;
        }

    StateChange( EDisconnected );
    }


// -----------------------------------------------------------------------------
// CTlsConnection::RunError()
// -----------------------------------------------------------------------------
//
TInt CTlsConnection::RunError( TInt aError )
    {
    RDebug::Printf( "CTlsConnection::RunError, aError: %d", aError );
    CloseConnection();
    StateChange( EDisconnected, aError );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CTlsConnection::CTlsConnection()
// -----------------------------------------------------------------------------
//
CTlsConnection::CTlsConnection( MTlsConnectionObserver& aObs ) :
        CActive( CActive::EPriorityStandard ), iObserver( aObs ), iState( ENotInitialized )
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CTlsConnection::ConstructL()
// -----------------------------------------------------------------------------
//
void CTlsConnection::ConstructL()
    {
    RDebug::Printf( "CTlsConnection::ConstructL begin" );

    User::LeaveIfError( iDelayTimer.CreateLocal() );
    RDebug::Printf( "CTlsConnection::ConstructL iSockServer" );
    User::LeaveIfError( iSockServer.Connect() );
    RDebug::Printf( "CTlsConnection::ConstructL iConnection" );
    User::LeaveIfError( iConnection.Open( iSockServer ) );
    RDebug::Printf( "CTlsConnection::ConstructL buffers" );
    iRecvBuffer = HBufC8::NewL( KRecvBufferLength );
    iRecvBufPtr = new( ELeave ) TPtr8( iRecvBuffer->Des() );
    StateChange( EIdle );

    RDebug::Printf( "CTlsConnection::ConstructL end" );
    }

// ---------------------------------------------------------------------------
// CTlsConnection::CloseConnection()
// ---------------------------------------------------------------------------
//
void CTlsConnection::CloseConnection()
    {
    RDebug::Printf( "CTlsConnection::CloseConnection begin" );
    if( iSecureSocket )
        {
        delete iSecureSocket;
        iSecureSocket = NULL;
        }
    iSocket.Close();
    iHostResolver.Close();
    if( iConnection.SubSessionHandle() )
        {
        if( iState >= EConnectingNetwork )
            {
            TInt err = iConnection.Stop();
            if( err != KErrNone )
                {
                RDebug::Printf( "iConnection.Stop() failed: %d", err );
                }
            }
        iConnection.Close();
        }
    RDebug::Printf( "CTlsConnection::CloseConnection end" );
    }

// ---------------------------------------------------------------------------
// CTlsConnection::CloseSession()
// ---------------------------------------------------------------------------
//
void CTlsConnection::CloseSession()
    {
    RDebug::Printf( "CTlsConnection::CloseSession" );
    CloseConnection();
    iSockServer.Close();
    delete iHostName;
    iHostName = NULL;
    delete iHostNameForCertCheck;
    iHostNameForCertCheck = NULL;
    delete iRecvBuffer;
    iRecvBuffer = NULL;
    delete iRecvBufPtr;
    iRecvBufPtr = NULL;
    StateChange( EDisconnected );
    }

// -----------------------------------------------------------------------------
// CTlsConnection::StateChange()
// -----------------------------------------------------------------------------
//
void CTlsConnection::StateChange( TTlsConnectionState aNewState, TInt aError )
    {
    RDebug::Printf( "CTlsConnection::StateChange, aNewState=%d, aError=%d", aNewState, aError );
    if( aNewState != iState && iState != EAllDone )
        {
        iState = aNewState;
        iObserver.HandleNetworkEvent( aNewState, aError );
        }
    }

// ---------------------------------------------------------------------------
// CTlsConnection::ReadL()
// ---------------------------------------------------------------------------
//
void CTlsConnection::ReadL()
    {
    RDebug::Printf( "CTlsConnection::ReadL(), iState=%d", iState );

    TPtr8 recvBuffer = iRecvBuffer->Des();
    recvBuffer.Zero();
    iSecureSocket->RecvOneOrMore( recvBuffer, iStatus, iRecvLength );
    SetActive();
    }