/*

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

*

*

*/

#include <implementationproxy.h>

#include <uri8.h> 

#include "ictshttphandler.h"

#include "ictsengine.h"

#include "am_debug.h"

// CONSTANTS

_LIT8( KHeaderName, "X-Nokia-WLAN-Connectivity-Test" );

_LIT8( KHeaderValue, "true" );

_LIT8( KHttpPrefix, "http://" );

const TInt KMovedPermanently = 301;

const TInt KFound = 302;

const TInt KSeeOther = 303;

const TInt KTemporaryRedirect = 307;

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

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

// CIctsHttpHandler::CIctsHttpHandler

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

// might leave.

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

//

CIctsHttpHandler::CIctsHttpHandler( CIctsEngine& aOwner,

                                    TInt aHttpResponseTime ) :

CTimer( EPriorityLow ), iOwner( aOwner ),

iHttpResponseTime( aHttpResponseTime ), iAttachDone( EFalse )

    {

     CActiveScheduler::Add( this );

    }

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

// CIctsHttpHandler::ConstructL

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

//

void CIctsHttpHandler::ConstructL()

    {

    DEBUG("CIctsHttpHandler::ConstructL()");

    // Open channel to Socket Server

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

    // Open connection

    User::LeaveIfError( iConnection.Open(iSocketServ) );

    CTimer::ConstructL();

    }

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

// CIctsHttpHandler::NewL

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

//

CIctsHttpHandler* CIctsHttpHandler::NewL( CIctsEngine& aOwner, 

                                            TInt aHttpResponseTime )

    {

    DEBUG("CIctsHttpHandler::NewL()");

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIctsHttpHandler::~CIctsHttpHandler

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

//

CIctsHttpHandler::~CIctsHttpHandler()

    {

    DEBUG("CIctsHttpHandler::~CIctsHttpHandler()");

    RHTTPTransaction notActive;

    if ( iHttpTransaction != notActive )

        {

        iHttpTransaction.Close();

        }

    iHttpSession.Close();

    CTimer::Cancel();

    iConnection.Close();

    iSocketServ.Close();

    DEBUG("CIctsHttpHandler::~CIctsHttpHandler() Done");

    }

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

// CIctsHttpHandler::SetHttpConnectionInfoL

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

//

void CIctsHttpHandler::SetHttpConnectionInfoL( RConnection& aConnection, 

                                RSocketServ& aSocketServ)

    {

    DEBUG("CIctsHttpHandler::SetHttpConnectionInfoL");

    TInt result;

    TBuf<16> serviceType;

    TUint32 serviceId;

    TBuf<100> query;

    TUint connCount;

    iHttpSession.Close();

    iHttpSession.OpenL();

    RStringPool strPool = iHttpSession.StringPool();

    // Remove first session properties just in case.

    RHTTPConnectionInfo connInfo = iHttpSession.ConnectionInfo();

    // Clear RConnection and Socket Server instances

    // Clear the proxy settings

    // RConnection has been started, set proxy (if defined) and RConnection and

    // Socket Server session properties.

    // Proxy

    // Get service and service type for this connection

    //

    _LIT(string, "%s\\%s");

    // RConnection and Socket Server

    // Now bind the HTTP session with the socket server connection

    connInfo.SetPropertyL ( 

    connInfo.SetPropertyL ( 

    }

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

// CIctsHttpHandler::SendHttpRequestL

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

//    

TInt CIctsHttpHandler::SendHttpRequestL( TDesC8& aIPAddress, 

                                     TUint32 aIapID, 

                                     TUint32 aNetworkId )

    {

    DEBUG("CIctsHttpHandler::SendHttpRequestL");

    // Cancel possibly outstanding request for polling reasons.

    CTimer::Cancel();

    TConnectionInfo info;

    TPckg< TConnectionInfo > pckgInfo( info );

    info.iIapId = aIapID;

    info.iNetId = aNetworkId;

    TInt err( KErrNone );

    if ( !iAttachDone )

        {

        DEBUG1("CIctsHttpHandler::SendHttpRequestL attach: %d", err);

        }

    if ( KErrNone == err )

        {

        iAttachDone = ETrue;

        SetHttpConnectionInfoL( iConnection, iSocketServ );

        // Remove redirect filter

        RStringPool stringPool = iHttpSession.StringPool();

        RStringPool strPool = iHttpSession.StringPool();

        TBuf8<KMaxIpLength> ip;

        TBool httpExists = CheckHttp( aIPAddress );

        if ( !httpExists )        

            {

            ip.Copy( KHttpPrefix );

            }

        ip.Append( aIPAddress );

        // Parse string to URI

        TUriParser8 uri; 

        uri.Parse(ip);

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

        RStringF headerStrName = strPool.OpenFStringL( KHeaderName() );

        CleanupClosePushL( headerStrName );

        RStringF headerStrValue = strPool.OpenFStringL( KHeaderValue() );

        CleanupClosePushL( headerStrValue );

        THTTPHdrVal headerValue( headerStrValue );

        hdr.SetFieldL( headerStrName, headerValue );

        CleanupStack::PopAndDestroy( &headerStrValue );

        CleanupStack::PopAndDestroy( &headerStrName );

        iHttpTransaction.SubmitL();

        DEBUG("CIctsHttpHandler::SendHttpGetL SubmitL() done");

        CTimer::After( iHttpResponseTime );

        }

    return err;

    }  

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

// CIctsHttpHandler::CancelHttpRequestL

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

//    

void CIctsHttpHandler::CancelHttpRequestL()

    {

    DEBUG("CIctsHttpHandler::CancelHttpRequestL()");

    CTimer::Cancel();

    RHTTPTransaction notActive;

    if ( iHttpTransaction != notActive )

        {

        iHttpTransaction.Close();

        }

    }

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

// CIctsHttpHandler::RunL

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

//

void CIctsHttpHandler::RunL()

    {

    DEBUG("CIctsHttpHandler::RunL()");

    RHTTPTransaction notActive;

    if ( iHttpTransaction != notActive )

        {

        iHttpTransaction.Close();

        }

    iString = KNullDesC;

    iOwner.HttpEventL( ETimeout, iString );

    }

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

// CIctsHttpHandler::MHFRunL

//

// Inherited from MHTTPTransactionCallback

// Called by framework to pass transaction events.

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

//   

    {

    switch (aEvent.iStatus) 

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            DEBUG("CIctsHttpHandler::THTTPEvent::EGotResponseHeaders");

            }

            break;

        case THTTPEvent::ESucceeded:

            {

            CTimer::Cancel();

            iOwner.HttpEventL( EConnectionOk, iString );

            iString = KNullDesC;

            }

            break;

        case THTTPEvent::EFailed:

            {

            CTimer::Cancel();

            }

            break;

        default:

            {

            } 

            break;

        }

    }

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

// CIctsHttpHandler::MHFRunError

//

// Inherited from MHTTPTransactionCallback

// Called by framework to pass transaction error.

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

//   

TInt CIctsHttpHandler::MHFRunError( TInt /*aError*/, 

                                RHTTPTransaction /*aTransaction*/, 

                                const THTTPEvent& /*aEvent*/)

    {

    DEBUG("CIctsHttpHandler::MHFRunError");

    return KErrNone;

    }

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

// CIctsHttpHandler::CheckHttp

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

TBool CIctsHttpHandler::CheckHttp( TDesC8& aIPAddress )

    {

    // The "http://" prefix is expected to be at the beginning of the URI.

    return ( 0 == aIPAddress.Find( KHttpPrefix ) );

    }

//  End of File