/*

* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  ?Description

*

*/

// INCLUDE FILES

#include "HttpClientApp.h"

#include "HttpClientAppInstance.h"

#include "HttpDownload.h"

#include "HttpConnHandler.h"

#include "HttpDownloadManagerServerEngine.h"

#include "FileExt.h"

#include "HttpDownloadMgrLogger.h"

#include <in_sock.h>

#include <CommDbConnPref.h>

#include <httpfilterauthenticationinterface.h>

#include <uaproffilter_interface.h>

#include <httpfiltercommonstringsext.h>

#include <cdblen.h>

//#include <deflatefilterinterface.h>

#include <cookiefilterinterface.h>

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

const TInt KShutDownTimer = 60*1000000;  //60 sec - Updated to 60 secs as part of error fix JSIN-7JSE6H

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// CHttpConnShutdownTimer::NewL

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

//

CHttpConnShutdownTimer* CHttpConnShutdownTimer::NewL( MShutdownObserver* aObserver )

    {

	CHttpConnShutdownTimer* self = new (ELeave) CHttpConnShutdownTimer( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self ); // self

	return self;

    }

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

// CHttpConnShutdownTimer::CHttpConnShutdownTimer

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

//

CHttpConnShutdownTimer::CHttpConnShutdownTimer( MShutdownObserver* aObserver )

    :CActive( EPriorityStandard )

    ,iObserver( aObserver )

    {

    CLOG_WRITE_1( "Shutdown_timer(0x%x)", this);

    }

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

// CHttpConnShutdownTimer::~CHttpConnShutdownTimer

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

//

CHttpConnShutdownTimer::~CHttpConnShutdownTimer()

    {

    Cancel();

    iTimer.Close();

    CLOG_WRITE_1( "Shutdown destroyed (0x%x)", this);

    }

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

// CHttpConnShutdownTimer::ConstructL

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

//

void CHttpConnShutdownTimer::ConstructL()

    {

    User::LeaveIfError( iTimer.CreateLocal() );

    CActiveScheduler::Add( this );

    }

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

// CHttpConnShutdownTimer::Start

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

//

void CHttpConnShutdownTimer::Start( TInt aTimeOut )

    {

    CLOG_WRITE("Shutdown timer started");

    if( IsActive() )

        {

        return;

        }

    iTimer.After( iStatus, aTimeOut );

    SetActive();

    }

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

// CHttpConnShutdownTimer::DoCancel

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

//

void CHttpConnShutdownTimer::DoCancel()

    {

    iTimer.Cancel();

    CLOG_WRITE("Shutdown timer canceled");

    }

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

// CHttpConnShutdownTimer::RunL

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

// 

void CHttpConnShutdownTimer::RunL()

    {

    LOGGER_ENTERFN("CHttpConnShutdownTimer::RunL()");

    iObserver->ShutDown();

    }

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

// CHttpConnStageNotifier::CHttpConnStageNotifier

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

// might leave.

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

//

CHttpConnStageNotifier::CHttpConnStageNotifier( CHttpConnHandler* aConnHandler )

    :CActive( EPriorityStandard )

    ,iConnHandler( aConnHandler )

    {

    CLOG_WRITE_1( "Stage notifier created (0x%x)", this );

    }

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

// CHttpConnStageNotifier::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpConnStageNotifier::ConstructL()

    {

    CActiveScheduler::Add( this );

    }

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

// CHttpConnStageNotifier::NewL

// Two-phased constructor.

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

//

CHttpConnStageNotifier* 

                CHttpConnStageNotifier::NewL( CHttpConnHandler* aConnHandler )

    {

    CHttpConnStageNotifier* self = 

                            new( ELeave ) CHttpConnStageNotifier( aConnHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHttpConnStageNotifier::~CHttpConnStageNotifier()

    {

    Cancel();

    CLOG_WRITE_1( "Stage notifier destroy: (0x%x)", this );

    }

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

// CHttpConnStageNotifier::Start

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpConnStageNotifier::Start()

    {

    LOGGER_ENTERFN( "Start" );

    if( IsActive() )

        // Already observed

        {

        return;

        }

    iConnHandler->Connection().ProgressNotification( iProgressBuf, iStatus );

    SetActive();

    }

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

// CHttpConnHandler::DoCancel

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpConnStageNotifier::DoCancel()

    {

    if( iConnHandler->Connection().SubSessionHandle() )

        {

        iConnHandler->Connection().CancelProgressNotification();

        }

    }

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

// CHttpConnHandler::RunL

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpConnStageNotifier::RunL()

    {

    if( iStatus == KErrNone )

        {

        TInt stage = iProgressBuf().iStage;

        iConnHandler->ConnectionStageChanged( stage );

        if( stage > KConnectionUninitialised )

            // connection is still alive

            {

            iConnHandler->Connection().ProgressNotification( iProgressBuf, iStatus );

            SetActive();

            }

        }

    else

        {

        iConnHandler->ConnectionError( iStatus.Int() );

        }

    }

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

// CHttpConnHandler::CHttpConnHandler

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

// might leave.

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

//

CHttpConnHandler::CHttpConnHandler( CHttpClientApp* aClientApp )

    : CActive( EPriorityStandard )

    , iClientApp( aClientApp )

    {

    CLOG_CREATE;

    }

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

// CHttpConnHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpConnHandler::ConstructL()

    {

    CLOG_NAME_2( _L("CHttpConnHandler_%x_c%x"), iClientApp->AppUid(), (TInt)this );

    LOGGER_ENTERFN( "ConstructL" );

    CActiveScheduler::Add( this );

    iConnNotif = CHttpConnStageNotifier::NewL( this );

    CLOG_ATTACH( iConnNotif, this );

    iShutDown = CHttpConnShutdownTimer::NewL( this );

    CLOG_ATTACH( iShutDown, this );

    iHttpSession.OpenL();

    CLOG_WRITE8( "Session open" );

    InitSessionL();

    }

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

// CHttpConnHandler::NewL

// Two-phased constructor.

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

//

CHttpConnHandler* CHttpConnHandler::NewL( CHttpClientApp* aClientApp )

    {

    CHttpConnHandler* self = new( ELeave ) CHttpConnHandler( aClientApp );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHttpConnHandler::~CHttpConnHandler()

    {

    if( IsActive() )

        {

        Cancel();

        }

    ShutDown( ETrue );

    iHttpSession.Close();

    delete iConnNotif;

    delete iShutDown;

    CLOG_CLOSE;

    }

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

// CHttpConnHandler::ConnectL

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpConnHandler::ConnectL()

    {

    LOGGER_ENTERFN( "ConnectL" );

    TBool doComplete( ETrue );

    iShutDown->Cancel();

    if( !iConnection.SubSessionHandle() )

        // only the first connection request does this initialization

        {

        CLOG_WRITE( "No subsession" );

        // forget the previous notifier

        if( iConnName )

            {

            CLOG_WRITE_1("ConnName set: [%S]", iConnName);

            TName connName;

            connName.Copy( *iConnName );

            User::LeaveIfError( iConnection.Open( iClientApp->Engine()->SocketServ(), connName ) );

            CLOG_WRITE( "connection open" );

            TNifProgress progress;

            iConnection.Progress( progress );

            iConnStage = progress.iStage;

            CLOG_WRITE_1("Stage: %d", iConnStage);

            UpdateIapId();

            }

        else

            {

            User::LeaveIfError( iConnection.Open( iClientApp->Engine()->SocketServ() ) );

            CLOG_WRITE8_1( "Start: %d", iIapId );

            if( iIapId )

                {

                iPref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

                iPref.SetIapId( iIapId );

                }

            else

                {

                iPref.SetDialogPreference( ECommDbDialogPrefPrompt );

                }

            iConnection.Start( iPref, iStatus );

            // RConnection will complete us.

            doComplete = EFalse;

            }

        iConnNotif->Start();

        iNewConnection = ETrue;

        }

    CLOG_WRITE_1( "stage: %d", iConnStage );

    if( !IsActive() )

        {

        CLOG_WRITE( "Not active" );

        SetActive();

        CLOG_WRITE_1( "doComplete: %d", doComplete );

        if( doComplete )

            {

            TRequestStatus* dummy = &iStatus;

            User::RequestComplete( dummy, KErrNone );

            }

        }

    }

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

// CHttpConnHandler::Disconnect

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpConnHandler::Disconnect( TBool aAtOnce, CHttpDownload* aDownload )

    {

    LOGGER_ENTERFN( "Disconnect()" );

    CLOG_WRITE8_1( "Exit: %d", aAtOnce );

    // to remove this download from the referenced ones

    if( aDownload )

        {

        aDownload->SetConnHandler( NULL );

        }

    TInt refs = Referencies();

    CLOG_WRITE8_1( "aAtOnce: %d", aAtOnce );

    CLOG_WRITE8_1( "refs: %d", refs );

    if( aAtOnce || (!refs && !iConnName) )

        // no more reference to this connection -> real disconnect

        // but only if the connection name was not set from outside

        // In that case only CHttpClientAppInstance::Disconnect can

        // disconnect (it uses aAtOnce ETrue).

        {

        CLOG_WRITE_1( "conn handle: %d", iConnection.SubSessionHandle() );

        CLOG_WRITE_1( "stage: %d", iConnStage );

        if( !aAtOnce 

            && iConnection.SubSessionHandle() 

            && iConnStage == KLinkLayerOpen )

            {

			CLOG_WRITE_1( "ShutDown->Start: atOnce=%d", aAtOnce );

			iConnStage = KConnectionStartingClose;

            iShutDown->Start( KShutDownTimer );

            }

        else

            {

            ShutDown();

            }

        }

    }

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

// CHttpConnHandler::IapId

// ?implementation_description

// (other items were commented in a header).

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

//

TUint32 CHttpConnHandler::IapId() const

    {

    return iIapId;

    }

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

// CHttpConnHandler::ClientAppInst

// ?implementation_description

// (other items were commented in a header).

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

//

CHttpClientApp* CHttpConnHandler::ClientApp() const

    {

    return iClientApp;

    }

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

// CHttpConnHandler::ClientAppInst

// ?implementation_description

// (other items were commented in a header).

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

//

CHttpClientAppInstance* CHttpConnHandler::ClientAppInst() const

    {

    return iClientInst;

    }

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

// CHttpConnHandler::Session

// ?implementation_description

// (other items were commented in a header).

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

//

RHTTPSession& CHttpConnHandler::Session()

    {

    return iHttpSession;

    }

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

// CHttpConnHandler::Connection

// ?implementation_description

// (other items were commented in a header).

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

//

RConnection& CHttpConnHandler::Connection()

    {

    return iConnection;

    }

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

// CHttpConnHandler::ConnectionNameL

// ?implementation_description

// (other items were commented in a header).

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

//

HBufC* CHttpConnHandler::ConnectionNameL( TBool& aDelete )

    {

    if( iConnName )

        {

        aDelete = EFalse;

        return iConnName;

        }

    else if( iConnection.SubSessionHandle() )

        {

        TName connName;

        aDelete = ETrue;