/*

* Copyright (c) 2002-2008 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:  Http interface for RoapHandler

*

*/

// INCLUDE FILES

#include <stringpool.h>

#include <http/thttphdrval.h>

#include "RoapHttpHandler.h"

#include "RoapObserver.h"

#include "RoapDef.h"

#include "RoapLog.h"

//#include <CookieFilterInterface.h>

//#include <uaproffilter_interface.h>

//#include <HttpFilterProxyInterface.h>

#include <httpfilteriopinterface.h>

using namespace Roap;

// ================= CONSTANTS ======================

// The time out value in HTTP, 30 sec

LOCAL_D const TInt KRoapTimeoutValue = 60000000;

_LIT8( KTestUserName, "iopvf" );

_LIT8( KTestPassword, "r72005" );

/*

_LIT8( KTestUserName, "moria" );

_LIT8( KTestPassword, "mellon" );

*/

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

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

// CRoapHttpHandler::NewL()

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

//

CRoapHttpHandler* CRoapHttpHandler::NewL()

    {

    CRoapHttpHandler* handler = new ( ELeave ) CRoapHttpHandler();

    CleanupStack::PushL( handler );

    handler->ConstructL();

    CleanupStack::Pop( handler );

    return handler;

    }

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

// CRoapHttpHandler::~CHttpLoader()

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

//

CRoapHttpHandler::~CRoapHttpHandler()

    {

    Cancel();

    iSession.Close(); // iSession also closes iTransaction

    delete iRequestBody;

    delete iUri;

    delete iBoundary;

    delete iConnection;

    delete iTimeout;

    }

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

// CRoapHttpHandler::ConstructL()

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

//

void CRoapHttpHandler::ConstructL()

    {

    LOG( _L("CRoapHttpHandler::ConstructL") );

    iConnection = CRoapConnection::NewL();

    iTimeout = CPeriodic::NewL( CActive::EPriorityUserInput );

    }

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

// CRoapHttpHandler::CreateConnectionL()

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

//

void CRoapHttpHandler::CreateConnectionL( TRequestStatus* aStatus )

    {

    LOG( _L("CRoapHttpHandler::CreateConnectionL") );

    __ASSERT_ALWAYS( iState == EInit || iState == EReady, \

                                            User::Invariant() );

    __ASSERT_ALWAYS( iConnection, User::Invariant() );

    TUint32 ap;

    if ( iConnection->IsConnected( ap ) )

        {

        // Already connected

        User::RequestComplete( iParentStatus, KErrAlreadyExists );

        iParentStatus = NULL;

        return;

        }

    if ( iObserver && !iObserver->ConnectionConfL() )

        {

        User::Leave( KErrCancel );

        }

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    iState = EStart;

    TRequestStatus* ownStatus = &iStatus;

    *ownStatus = KRequestPending;

    SetActive();

    User::RequestComplete( ownStatus, KErrNone );

    }

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

// CRoapHttpHandler::IsConnectedL()

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

//

void CRoapHttpHandler::SetObserver( MRoapObserver* aRoapObserver )

    {

    LOG( _L("CRoapHttpHandler::SetObserver") );

    iObserver = aRoapObserver;

    }

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

// CRoapHttpHandler::CreateConnectionL()

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

//

void CRoapHttpHandler::DoTransactionL(

            CRoapResponse& aResponse,

            TDesC8& aReqBody,

            TRequestStatus* aStatus )

    {

    LOG( _L("CRoapHttpHandler::DoTransactionL1") );

    __ASSERT_ALWAYS( iState == EReady, User::Invariant() );

    __ASSERT_ALWAYS( !iRequestBody, User::Invariant() );

    iRequestBody = aReqBody.AllocL();

    iResponse = &aResponse;

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    iState = ERequest;

    TRequestStatus* ownStatus = &iStatus;

    *ownStatus = KRequestPending;

    SetActive();

    User::RequestComplete( ownStatus, KErrNone );

    }

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

// CRoapHttpHandler::SetUrlL()

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

//

void CRoapHttpHandler::SetUrlL( TDesC8& aUrl )

    {

    LOG( _L("CRoapHttpHandler::SetUrlL") );

    delete iUri;

    iUri = NULL;

    iUri = aUrl.AllocL();

    }

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

// CRoapHttpHandler::DoCancel()

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

//

void CRoapHttpHandler::DoCancel()

    {

    LOG( _L("CRoapHttpHandler::DoCancel") );

    switch ( iState )

        {

        case EStart:

        case EConnect:

            {

            iConnection->Cancel();

            break;

            }

        case EComplete:

            {

            iTransaction.Close();

            SelfComplete( iError );

            break;

            }

        default:

            {

            break;

            }

        }

    iError = KErrCancel;

    Complete();

    }

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

// CRoapHttpHandler::RunL()

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

//

void CRoapHttpHandler::RunL()

    {

    LOG( _L("CRoapHttpHandler::RunL") );

    User::LeaveIfError( iStatus.Int() );

    switch ( iState )

        {

        case EStart:

            {

            ConnectL();

            break;

            }

        case EConnect:

            {

            CreateSessionL();

            break;

            }

        case ERequest:

            {

            DoTransactionL();

            break;

            }

        case EComplete:

            {

            TUint32 ap;

            iState = iConnection->IsConnected( ap ) ? EReady : EInit;

            Complete();

            break;

            }

        case EInit:

        default:

            {

            break;

            }

        }

    }

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

// CRoapHttpHandler::RunError()

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

//

TInt CRoapHttpHandler::RunError( TInt aError )

    {

    LOG( _L("CRoapHttpHandler::RunError") );

    iError = aError;

    TUint32 ap;

    iState = iConnection->IsConnected( ap ) ? EReady : EInit;

    Complete();

    return KErrNone;

    }

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

// CRoapHttpHandler::ConnectL()

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

//

void CRoapHttpHandler::ConnectL()

    {

    LOG( _L("CRoapHttpHandler::ConnectL") );

    __ASSERT_ALWAYS( iState == EStart, User::Invariant() );

    iConnection->ConnectL ( iPreferredIap, &iStatus );

    iState = EConnect;

    iError = KErrNone;

    SetActive();

    }

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

// CRoapHttpHandler::SetPreferredIap()

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

void CRoapHttpHandler::SetPreferredIap( TUint32 aPreferredIap )

    {

    LOG( _L("CRoapHttpHandler::SetPreferredIap") );

    iPreferredIap = aPreferredIap;

    }

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

// CRoapHttpHandler::CreateSessionL()

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

//

void CRoapHttpHandler::CreateSessionL()

    {

    LOG( _L("CRoapHttpHandler::CreateSessionL") );

    __ASSERT_ALWAYS( iState == EConnect, User::Invariant() );

    TUint32 ap;

    if ( !iConnection->IsConnected( ap ) )

        {

        User::Leave( KErrRoapGeneral );

        }

    iSession.Close();

    iSession.OpenL();

    RStringPool strPool = iSession.StringPool();

    // Remove first session properties just in case.

    RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();

    // Clear RConnection and Socket Server instances

    connInfo.RemoveProperty(strPool.StringF(HTTP::EHttpSocketServ,RHTTPSession::GetTable()));

    connInfo.RemoveProperty(strPool.StringF(HTTP::EHttpSocketConnection,RHTTPSession::GetTable()));

    THTTPHdrVal proxyUsage(strPool.StringF(HTTP::EUseProxy,RHTTPSession::GetTable()));

    connInfo.RemoveProperty(strPool.StringF(HTTP::EProxyUsage,RHTTPSession::GetTable()));

    connInfo.RemoveProperty(strPool.StringF(HTTP::EProxyAddress,RHTTPSession::GetTable()));

    connInfo.SetPropertyL

        (

        strPool.StringF( HTTP::EHttpSocketServ, RHTTPSession::GetTable() ),

        THTTPHdrVal( iConnection->SocketServ().Handle() )

        );

    connInfo.SetPropertyL

        (

        strPool.StringF( HTTP::EHttpSocketConnection, RHTTPSession::GetTable() ),

        THTTPHdrVal( REINTERPRET_CAST( TInt, &iConnection->Conn() ) )

        );

    InstallHttpFiltersL();

    // Complete requests

    iState = EReady;

    SelfComplete( iError );

    // Notify CRoapEngBase

    Complete();

    }

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

// CRoapHttpHandler::InstallHttpFilters()

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

//

void CRoapHttpHandler::InstallHttpFiltersL()

    {

    LOG( _L("CRoapHttpHandler::InstallHttpFiltersL") );

 // CHttpUAProfFilterInterface::InstallFilterL( iSession );

 // CHttpCookieFilter::InstallFilterL( iSession );

    InstallAuthenticationL( iSession );

 // CHttpFilterProxyInterface::InstallFilterL( iSession );

    // This filter adds port number to HTTP header Host

    // on HTTP(S) CONNECT via proxy.

    // Note: the filter is for interoperability, since some WAP GWs

    // do not work with Host header not having port number.

    CHttpFilterIopInterface::InstallFilterL( iSession, iopOptionHostHeader );

    }

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

// CRoapHttpHandler::DoTransactionL()

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

//

void CRoapHttpHandler::DoTransactionL()

    {

    LOG( _L("CRoapHttpHandler::DoTransactionL2") );

    __ASSERT_ALWAYS( iState == ERequest, User::Invariant() );

    TUriParser8 uri;

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

    RStringF POST;

    POST = iSession.StringPool().StringF( HTTP::EPOST, RHTTPSession::GetTable() );

    iTransaction = iSession.OpenTransactionL( uri, *this, POST );

    // Set required headers

    RHTTPHeaders hdrs = iTransaction.Request().GetHeaderCollection();

    SetHeaderL(hdrs, HTTP::EAccept, _L8("*/*") ); // for testing

    SetHeaderL(hdrs, HTTP::EAccept, KRoapPDUType );

    SetHeaderL(hdrs, HTTP::EAccept, KMultipartRelatedType );

    SetHeaderL(hdrs, HTTP::EContentType, KRoapPDUType);

    iBytesReceived = 0;

    // Add request body

    MHTTPDataSupplier* ds = this;

    iTransaction.Request().SetBody(*ds);

    iTransaction.SubmitL();

    iState = EComplete;

    iStatus = KRequestPending;

    SetActive();

    iTimeout->Cancel();

    iTimeout->Start( KRoapTimeoutValue,

                     KRoapTimeoutValue,

                     TCallBack( StaticTimeOut,this ) );

    }

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

// CRoapHttpHandler::SetHeaderL()

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

//

void CRoapHttpHandler::SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue)

    {

    LOG( _L("CRoapHttpHandler::SetHeaderL") );

    RStringF valStr = iSession.StringPool().OpenFStringL(aHdrValue);

    THTTPHdrVal val(valStr);

    aHeaders.SetFieldL(iSession.StringPool().StringF(aHdrField,RHTTPSession::GetTable()), val);

    valStr.Close();

    }

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

// CRoapHttpHandler::Complete()

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

//

void CRoapHttpHandler::Complete()

    {

    LOG( _L("CRoapHttpHandler::Complete") );

    delete iRequestBody;

    iRequestBody = NULL;

    delete iUri;

    iUri = NULL;

    if ( iTimeout )

        {

        iTimeout->Cancel();

        }

    User::RequestComplete( iParentStatus, iError );

    iParentStatus = NULL;

    }

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

// CRoapHttpHandler::CRoapHttpHandler()

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

//

CRoapHttpHandler::CRoapHttpHandler(): CActive( CActive::EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CRoapHttpHandler::SelfComplete()

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

//

void CRoapHttpHandler::SelfComplete( TInt& aResult )

    {

    LOG( _L("CRoapHttpHandler::SelfComplete") );

    if ( iStatus == KRequestPending )

        {

        TRequestStatus* ownStatus = &iStatus;

        User::RequestComplete( ownStatus, aResult );

        }

    else

        {

        if ( aResult != KErrNone )

            {

            iStatus = aResult;

            }

        }

    }

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

// CRoapHttpHandler::MHFRunL()

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

//

void CRoapHttpHandler::MHFRunL( RHTTPTransaction  /* aTransaction */,

                                const THTTPEvent& aEvent )

    {

    LOG( _L("CRoapHttpHandler::MHFRunL") );

    // Restart timer

    iTimeout->Cancel();

    iTimeout->Start( KRoapTimeoutValue,

                     KRoapTimeoutValue,

                     TCallBack( StaticTimeOut,this ) );

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            LOG( _L("Got Response Headers!") );

            HandleResponseHeadersL( iTransaction.Response() );

            break;

            }

        case THTTPEvent::EGotResponseBodyData:

            {

            LOG( _L("Got Response Body Data!") );

            TInt ret( KErrNone );

            MHTTPDataSupplier* body = iTransaction.Response().Body();

            TPtrC8 ptr;

            body->GetNextDataPart( ptr );

            iBytesReceived += ptr.Length();

            if ( iResponse->iDataType == TDataType( KMultipartRelatedType ) )

                {

                ret = AppendMultipartData( ptr );

                }

            else

                {

                ret = AppendPduData( ptr );

                }

            if ( iObserver && iReportBytes )

                {

                iObserver->RoapProgressInfoL( KRoapProgressMax + iBytesReceived );