/*

* Copyright (c) 2002 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:  Implementation of CPushMtmFetchOperation.

*

*/

// INCLUDE FILES

#include "PushMtmFetchOperation.h"

#include "PushContentHandlerPanic.h"

#include "PushMtmLog.h"

#include <CSLPushMsgEntry.h>

#include <Uri8.h>

#include <SysUtil.h>

#include <CookieFilterInterface.h>

#include <uaproffilter_interface.h>

#include <CommDbConnPref.h>

#include <cdbcols.h>

#include <BrowserUiSDKCRKeys.h>

#include "PushMtmPrivateCRKeys.h"

#include <centralrepository.h> 

#include <commdb.h>

#include <ApDataHandler.h>

#include <ApAccessPointItem.h>

#include <ApUtils.h>

#include <ApSelect.h>

#include <HttpFilterAcceptHeaderInterface.h>

#include <HttpFilterIopInterface.h>

#include <HttpFilterCommonStringsExt.h>

#include <DeflateFilterInterface.h>

#include <FeatMgr.h>

// ================= MACROS =======================

#ifdef _DEBUG

    /// Guard "debug-only" argument name with this (expands to argument).

    #define DEBUG_ONLY( argName ) argName

#else /* not defined _DEBUG */

    /// Guard "debug-only" argument name with this (expands to nothing).

    #define DEBUG_ONLY( argName )

#endif /* def _DEBUG */

// ================= LOCAL CONSTANTS =======================

_LIT8( KHttpProtString, "HTTP/TCP" );

_LIT8( KUserAgent, "Push MTM" );

/// Base HTTP error code. See Extended Error Handling UI Specification!

LOCAL_C const TInt KPushMtmHttpErrorBase = -25000;

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

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

// CPushMtmFetchOperation::NewL

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

//

CPushMtmFetchOperation* CPushMtmFetchOperation::NewL

                                    (

                                        const TDesC& aRequestedUrl, 

                                        TRequestStatus& aObserverRequestStatus 

                                    )

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::NewL")

    CPushMtmFetchOperation* op = 

        new (ELeave) CPushMtmFetchOperation( aObserverRequestStatus );

    CleanupStack::PushL( op );

    op->ConstructL( aRequestedUrl );

    CleanupStack::Pop( op ); // op

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::NewL")

    return op;

    }

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

// CPushMtmFetchOperation::~CPushMtmFetchOperation

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

//

CPushMtmFetchOperation::~CPushMtmFetchOperation()

    {

    Cancel();

    delete ( iCacheMgr );

    delete iCacheSupply;

    iHttpTrans.Close();

    iHttpSess.Close();

    iConn.Close();

    iSockServ.Close();

    delete iRequestedUrl;

    delete iSourceUri;

    delete iBody;

    FeatureManager::UnInitializeLib();

    }

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

// CPushMtmFetchOperation::StartL

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

//

void CPushMtmFetchOperation::StartL()

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::StartL")

    Cancel();

    iResult = KErrNone;

    iState = EInit;

	SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::StartL")

    }

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

// CPushMtmFetchOperation::CPushMtmFetchOperation

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

//

CPushMtmFetchOperation::CPushMtmFetchOperation

                        ( TRequestStatus& aObserverRequestStatus ) 

:   CActive( EPriorityStandard ), 

    iObserver( aObserverRequestStatus ),

    iState( EInit ),

    iResult( KErrNone )

    {

    CActiveScheduler::Add( this );

    }

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

// CPushMtmFetchOperation::ConstructL

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

//

void CPushMtmFetchOperation::ConstructL( const TDesC& aRequestedUrl )

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::ConstructL")

    iRequestedUrl = HBufC8::NewMaxL( aRequestedUrl.Length() );

    iRequestedUrl->Des().Copy( aRequestedUrl );

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::ConstructL")

    }

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

// CPushMtmFetchOperation::GetDefaultInetAccessPointL

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

//

TBool CPushMtmFetchOperation::GetDefaultInetAccessPointL

                              ( TUint32& aIapId ) const

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::GetDefaultInetAccessPointL")

    // Try to find the default AP.

    // The Browser may stores the default AP in the shared data.

    CRepository* repository = CRepository::NewL( KCRUidBrowser );

    CleanupStack::PushL( repository );

    TInt wapApId;

    User::LeaveIfError

        ( repository->Get( KBrowserDefaultAccessPoint, wapApId ) );

    TUint32 wapApId32( wapApId );

    TUint32 iapId32( 0 );

    CleanupStack::PopAndDestroy( repository );

    repository = 0;

    CCommsDatabase* commsDb = CCommsDatabase::NewL( EDatabaseTypeIAP );

    CleanupStack::PushL( commsDb );

    CApDataHandler* apDataHandler = CApDataHandler::NewLC( *commsDb );

    CApAccessPointItem* apItem = CApAccessPointItem::NewLC();

    TRAPD( err, apDataHandler->AccessPointDataL( wapApId32, *apItem ) );

    CApUtils* apUtils = CApUtils::NewLC( *commsDb );

    TBool wapApFound( EFalse );

    TBool iapFound( EFalse );

    PUSHLOG_WRITE_FORMAT("  err: <%d>",err)

    if ( err == KErrNone )

        {

        wapApFound = ETrue;

        }

    else // err != KErrNone

        {

        // The first valid access point has to be selected if exists

        CApSelect* apSelect = CApSelect::NewLC

                                            (

                                                *commsDb, 

                                                KEApIspTypeAll, 

                                                EApBearerTypeAll, 

                                                KEApSortNameAscending

                                            );

        if ( apSelect->MoveToFirst() )

            {

            wapApFound = ETrue;

            wapApId32 = apSelect->Uid();

            }

        CleanupStack::PopAndDestroy( apSelect ); // apSelect

        }

    if ( wapApFound )

        {

        // Get the IAP ID from the WAP AP ID.

#ifndef __SERIES60_WSP

        iapId32 = 0;

        TRAPD( errTransl, iapId32 = apUtils->IapIdFromWapIdL( wapApId32 ) );

        PUSHLOG_WRITE_FORMAT("  IapIdFromWapIdL errTransl: <%d>",errTransl)

        if ( errTransl == KErrNone )

            {

            iapFound = ETrue;

            }

#else

        iapId32 = wapApId32;

        iapFound = ETrue;

#endif // __SERIES60_WSP

        }

    CleanupStack::PopAndDestroy( 4 ); // apUtils, apItem, 

                                            // apDataHandler, commsDb

    if ( iapFound )

        {

        aIapId = iapId32;

        }

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::GetDefaultInetAccessPointL")

    return iapFound;

    }

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

// CPushMtmFetchOperation::InitializeL

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

//

void CPushMtmFetchOperation::InitializeL()

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::InitializeL")

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

    PUSHLOG_WRITE("CPushMtmFetchOperation iSockServ.Connect() OK")

    User::LeaveIfError( iConn.Open( iSockServ ) );

    PUSHLOG_WRITE("CPushMtmFetchOperation iConn.Open() OK")

    // Open the HTTP session.

    iHttpSess.OpenL( KHttpProtString );

    PUSHLOG_WRITE("CPushMtmFetchOperation iHttpSess.OpenL OK")

    // Set our Socket Server handle and Connection as session properties.

    iHttpSess.ConnectionInfo().SetPropertyL

        (

            StringF( HTTP::EHttpSocketServ ),

            THTTPHdrVal( iSockServ.Handle() )

        );

    PUSHLOG_WRITE("CPushMtmFetchOperation EHttpSocketServ set")

    iHttpSess.ConnectionInfo().SetPropertyL

        (

            StringF( HTTP::EHttpSocketConnection ),

            THTTPHdrVal( REINTERPRET_CAST( TInt, &iConn ) )

        );

    PUSHLOG_WRITE("CPushMtmFetchOperation EHttpSocketConnection set")

    // Open different string tables to the session. These are required 

    // by the Accept Header Filter.

    iHttpSess.StringPool().OpenL( HttpFilterCommonStringsExt::GetTable() );

    PUSHLOG_WRITE("CPushMtmFetchOperation table 1 opened");

    iHttpSess.StringPool().OpenL( HttpFilterCommonStringsExt::GetLanguageTable() );

    PUSHLOG_WRITE("CPushMtmFetchOperation table 2 opened");

    // Install the very same set of filters that BrowserEngine installs.

    // The following filters must not be installed:

    // - Authentication Filter, because the fetch operation and the push mtm 

    //   subsystem does not support credentials.

    // - Conn Handler Filter, because the fetch operation let it to the HTTP 

    //   core framework to create connection - it just sets the acces point.

    // Install UAProf filter.

    CHttpUAProfFilterInterface::InstallFilterL( iHttpSess );

    PUSHLOG_WRITE(" UAProf installed")

    // Install cookie filter.

    CHttpCookieFilter::InstallFilterL( iHttpSess );

    PUSHLOG_WRITE(" Cookie filter installed")

    // Create cache manager

    FeatureManager::InitializeLibL();

    iCacheMgr = CHttpCacheManager::NewL();

    PUSHLOG_WRITE(" Cache Manager installed")

    // Install Accept Header Filter.

    CHttpFilterAcceptHeaderInterface::InstallFilterL( iHttpSess );

    PUSHLOG_WRITE(" Accept Header Filter installed")

    // Install IOP Filter.

    CHttpFilterIopInterface::InstallFilterL( iHttpSess, iopOptionHostHeader );

    PUSHLOG_WRITE(" IOP Filter installed")

    // Install Deflate Filter.

    CHttpDeflateFilter::InstallFilterL( iHttpSess );

    PUSHLOG_WRITE(" Deflate Filter installed");

    TUint32 defIapId( 0 );

    TBool defIapIdFound = EFalse;

    TCommDbConnPref commPrefs;

#ifndef __WINS__

    // Use Browser default AP & comms db:

    defIapIdFound = GetDefaultInetAccessPointL( defIapId );

    PUSHLOG_WRITE_FORMAT("  defIapIdFound: <%d>",(TInt)defIapIdFound)

    PUSHLOG_WRITE_FORMAT("  defIapId:      <%d>",defIapId)

    commPrefs.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

    if ( defIapIdFound )

        {

        commPrefs.SetIapId( defIapId );

        }

#else // __WINS__

    // Prompt the user to select access point

    commPrefs.SetDialogPreference( ECommDbDialogPrefPrompt );

#endif // __WINS__

    iState = EStartRequest;

    iStatus = KRequestPending;

    SetActive();

    iConn.Start( commPrefs, iStatus );

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::InitializeL")

    }

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

// CPushMtmFetchOperation::StartRequestL

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

//

void CPushMtmFetchOperation::StartRequestL()

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::StartRequestL")

    // Create the transaction.

    CreateTransactionL();

    CheckCacheL();

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::StartRequestL")

    }

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

// CPushMtmFetchOperation::CheckCacheL

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

//

void CPushMtmFetchOperation::CheckCacheL()

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::CheckCacheL")

    iCacheSupply = CPushMtmCacheSupply::NewL(iCacheMgr, this);

    TInt ret = iCacheSupply->StartRequestL();

    iStatus = KRequestPending;

	SetActive();

    if (ret != KErrNone) // Not in cache

        {

        iState = ERequest;

        iCachedResponse = ETrue;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone);

        }

    else

        {

        iState = EDone;

        iCachedResponse = EFalse;

        }

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::CheckCacheL")

    }

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

// CPushMtmFetchOperation::RequestL

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

//

void CPushMtmFetchOperation::RequestL()

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::RequestL")

    iState = EDone;

    iStatus = KRequestPending;

	SetActive();

    SubmitTransactionL();

    // Do not call InvokeRun(). Let MHFRunL to handle the request.

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::RequestL")

    }

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

// CPushMtmFetchOperation::Done

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

//

void CPushMtmFetchOperation::Done()

    {

    PUSHLOG_WRITE_FORMAT("CPushMtmFetchOperation::Done iResult: <%d>",iResult);

    delete iRequestedUrl;

    iRequestedUrl = NULL;

    // Notify parent.

    TRequestStatus* status = &iObserver;

    User::RequestComplete( status, iResult );

//  iState = EInit;

    }

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

// CPushMtmFetchOperation::CreateTransactionL

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

//

void CPushMtmFetchOperation::CreateTransactionL()

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::CreateTransactionL")

    __ASSERT_DEBUG( iRequestedUrl, 

                    ContHandPanic( EPushContHandPanNotInitUrl ) );

    // Create the transaction.

    TUriParser8 uri;

    User::LeaveIfError( uri.Parse( *iRequestedUrl ) );

    iHttpTrans = 

        iHttpSess.OpenTransactionL( uri, *this, StringF( HTTP::EGET ) );

    PUSHLOG_WRITE("CPushMtmFetchOperation OpenTransactionL OK")

    // Set request headers.

    RHTTPHeaders hdr = iHttpTrans.Request().GetHeaderCollection();

    SetHeaderL( hdr, HTTP::EUserAgent, KUserAgent );

    SetHeaderL( hdr, HTTP::EAccept, HTTP::EAnyAny );

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::CreateTransactionL")

    }

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

// CPushMtmFetchOperation::SubmitTransactionL

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

//

void CPushMtmFetchOperation::SubmitTransactionL()

    {

    iHttpTrans.SubmitL();

    PUSHLOG_WRITE("CPushMtmFetchOperation iHttpTrans.SubmitL OK")

    }

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

// CPushMtmFetchOperation::HandleResponseHeadersL

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

//

void CPushMtmFetchOperation::HandleResponseHeadersL( RHTTPResponse aResponse )

    {

    PUSHLOG_ENTERFN("CPushMtmFetchOperation::HandleResponseHeadersL")

    TInt httpCode = aResponse.StatusCode();

    PUSHLOG_WRITE_FORMAT(" HttpStatus: %d",httpCode)

#ifdef __TEST_LOG__

    LogHeadersL( aResponse.GetHeaderCollection() );

#endif // __TEST_LOG__

    if ( HTTPStatus::IsSuccessful( httpCode ) && 

         ( httpCode != HTTPStatus::ENoContent ) )

        {

        // Successful GET.

        PUSHLOG_WRITE(" Successful GET")

        // Get content type.

        iDataType = TDataType

            ( GetContentTypeL( aResponse.GetHeaderCollection() ) );

        // Get source URI.

        HBufC8* buf = GetSourceUriL( iHttpTrans ).AllocL();

        PUSHLOG_WRITE(" Source URI got")

        delete iSourceUri;

        iSourceUri = buf;

        // No error:

        iResult = KErrNone;

        }

    else

        {

        // See Extended Error Handling UI Specification!

        iResult = KPushMtmHttpErrorBase - httpCode;

        PUSHLOG_WRITE_FORMAT(" iResult: <%d>",iResult)

        }

    PUSHLOG_LEAVEFN("CPushMtmFetchOperation::HandleResponseHeadersL")

    }

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

// CPushMtmFetchOperation::VersionRetryL

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

//

TBool CPushMtmFetchOperation::VersionRetryL()

    {

    TBool retryDone( EFalse );

    // Check what http version we are using.

    THTTPHdrVal val;

    TBool exists = iHttpSess.ConnectionInfo().Property

        (

        StringF( HTTP::EHTTPVersion ), 

        val

        );

    if ( exists && TInt( val ) == HTTP::EHttp11 )

        {

        // Currently using HTTP/1.1. Cancel transaction and resubmit it using

        // HTTP/1.0.

        iHttpTrans.Cancel();

        iHttpSess.ConnectionInfo().SetPropertyL

            (

            StringF( HTTP::EHTTPVersion ),

            THTTPHdrVal( StringF( HTTP::EHttp10 ) )

            );

        SubmitTransactionL();

        retryDone = ETrue;

        }

    return retryDone;

    }

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

// CPushMtmFetchOperation::AppendResponse

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

//

TInt CPushMtmFetchOperation::AppendResponse( const TDesC8& aDataChunk )