/*

* Copyright (c) 2003 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:  Proxy filter

*

*/

// INCLUDE FILES

#include <http.h>

#include <es_sock.h>

#include <cdbstore.h>

#include <commdbconnpref.h>

// User Includes

#include "HttpFilterProxy.h"

#include "httpfiltercommonstringsext.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

void PanicHttpFiltersProxy(TInt aErr = 0);

// CONSTANTS

const TInt KProxyOrderOffset = 20;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

// LocalHostCheckL

// If the host is a local host, then remove the proxy property. Returns ETrue

// if the transaction request URI was for a localhost.

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

//

TBool LocalHostCheckL(RHTTPTransaction& aTransaction, RStringPool& aStringPool)

    {

    _LIT8(KLoopbackIPv4Url, "http://127.0.0.1"); 

    RHTTPRequest request = aTransaction.Request();

    TUriC8 uri = request.URI();

    TUriParser8 parserLoopBack;

    parserLoopBack.Parse(KLoopbackIPv4Url());

    TInt match = parserLoopBack.Compare(uri, EUriHost);

    if (KErrNone != match)

        {

        _LIT8(KLocalHostUrl, "http://localhost"); 

        // try another compare - compare against the "localhost".

        TUriParser8 parserLocalHost;

        parserLocalHost.Parse(KLocalHostUrl());

        match = parserLocalHost.Compare(uri, EUriHost);

        if (KErrNone == match) 

            {

            _LIT8(KLoopbackIPv4, "127.0.0.1"); 

            // "localhost" resolves to "::1", manually, replace with "127.0.0.1"

            CUri8* newUri = CUri8::NewLC(uri);

            newUri->SetComponentL(KLoopbackIPv4(), EUriHost);

            request.SetURIL(newUri->Uri());

            CleanupStack::PopAndDestroy(newUri);

            }

        }

    if (KErrNone == match)

        {

        // request is for localhost, explicitly state that this transaction

        // must not be sent to proxy.

    	RStringF proxyUsageStrF = aStringPool.StringF(HTTP::EProxyUsage, 

                                                      RHTTPSession::GetTable());

    	RStringF dontUseProxyStrF = aStringPool.StringF(HTTP::EDoNotUseProxy, 

                                                        RHTTPSession::GetTable());	

        aTransaction.PropertySet().RemoveProperty(proxyUsageStrF);

        aTransaction.PropertySet().SetPropertyL(proxyUsageStrF, dontUseProxyStrF);

    	//RStringF proxyAddrStrF = aStringPool.StringF(HTTP::EProxyAddress, 

        //                                             RHTTPSession::GetTable());

        //aTransaction.PropertySet().RemoveProperty(proxyAddrStrF);

        return ETrue;                                                          

        }

    return EFalse;

    }

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

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

// CHttpFilterProxy::CHttpFilterProxy

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

// might leave.

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

//

CHttpFilterProxy::CHttpFilterProxy(RHTTPSession* aSession)

{

    __ASSERT_DEBUG(aSession != NULL, PanicHttpFiltersProxy());

    iSession      = aSession;

}

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

// CHttpFilterProxy::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpFilterProxy::ConstructL()

{

	iStringPool = iSession->StringPool();

	iConnInfo = iSession->ConnectionInfo();

	// Added to fix panic when Proxy filter is used outside the browser initiated HTTP Framework.

	iSession->StringPool().OpenL(HttpFilterCommonStringsExt::GetTable());

    // Register the filter for submit events,

    // Adds a filter to the session's filter queue.

    iSession->FilterCollection().AddFilterL(*this,   // The filter to add

                                            THTTPEvent::ESubmit,       // The event that triggers this filter

                                            RStringF(),                // The header whose presence triggers this filter, or KNullDesC to trigger on any header

                                            KAnyStatusCode,            // The status code that triggers this filter, or KAnyStatusCode to trigger on any status code

                                            ECache - KProxyOrderOffset,// The position of the filter in the queue

	// register for notification of KErrNotReady error codes

	// this allows us to re-start the connection if it fails

}

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

// Destructor

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

//

CHttpFilterProxy::~CHttpFilterProxy()

{

    // Cleanup strings.

    iProxyAddress.Close();

    iExceptions.Close();

/*

//  Closing RSocketServ is causing crash in SDK Applications. SDK Apps will have to close RSocketServ and RConnection after closing CHTTPSession.

//  It is not needed to close connection as soon as the CHttpConnectionManager close connection by

//  calling   CHttpConnectionManager::CloseConnection()

	if(iFilterOwnsConnection)

		{

		// Close ESOCK handles

		iConnection.Close();

		iSocketServ.Close();

		}

*/

}

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

// CHttpFilterProxy::InstallFilterL

// Two-phased constructor. This function replaces NewL.

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

//

CHttpFilterProxy* CHttpFilterProxy::InstallFilterL(TAny* aSession)

{

    __ASSERT_DEBUG(aSession != NULL, PanicHttpFiltersProxy());

    RHTTPSession* session = REINTERPRET_CAST(RHTTPSession*, aSession);

    CHttpFilterProxy* filter = new (ELeave) CHttpFilterProxy( session );

    CleanupStack::PushL(filter);

    filter->ConstructL();

    CleanupStack::Pop(filter);

    return filter;

}

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

// CHttpFilterProxy::MHFLoad

// Called when the filter is being added to the session's filter queue.

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

//

void CHttpFilterProxy::MHFLoad(RHTTPSession, THTTPFilterHandle)

{

    ++iLoadCount;

}

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

// CHttpFilterProxy::MHFUnload

// Called when the filter is being removed from a session's filter queue.

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

//

void CHttpFilterProxy::MHFUnload(RHTTPSession /*aSession*/, THTTPFilterHandle /*aFilterHandler*/)

{

    __ASSERT_DEBUG(iLoadCount >= 0, PanicHttpFiltersProxy());

    if (--iLoadCount)

    {

        return;

    }

    delete this;

}

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

// CHttpFilterProxy::MHFRunL

// Process a transaction event.

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

//

void CHttpFilterProxy::MHFRunL(RHTTPTransaction aTransaction,

                               const THTTPEvent& aEvent)

    {

    switch(aEvent.iStatus)

	    {

		case THTTPEvent::ESubmit:

		    {

            if (LocalHostCheckL(aTransaction, iStringPool))

                {

                return;

                }

			SetProxyL(aTransaction);

		    } 

            break;

		case KErrNotReady:

		    {

            if (LocalHostCheckL(aTransaction, iStringPool))

                {

                return;

                }

			if(iFilterOwnsConnection)

			    {

				// we must re-start the RConnection

		 		TInt err = iConnection.Start();

				if (err == KErrAlreadyExists)

				    {

					// the KErrNotReady must have come from elsewhere

					return;

				    }

				User::LeaveIfError(err);

				// re-submit the transaction

				aTransaction.Cancel();

				aTransaction.SubmitL();				

			    }

			break;

		    }

		default:

			break;

	    }

    }

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

// CHttpFilterProxy::MHFRunError

// Process an error that occured while processing the transaction.

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

//

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

                                   RHTTPTransaction aTransaction,

                                   const THTTPEvent& /*aEvent*/)

{

    // Cleanup strings.

    iProxyAddress.Close();

    iExceptions.Close();

    aTransaction.Fail();

    return KErrNone;

}

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

// CHttpFilterProxy::MHFSessionRunL

// Process a session event.

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

//

void CHttpFilterProxy::MHFSessionRunL(const THTTPSessionEvent& /*aEvent*/)

{

}

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

// CHttpFilterProxy::MHFSessionRunError

// Called when MHFRunL leaves from a session event.

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

//

TInt CHttpFilterProxy::MHFSessionRunError(TInt aError, const THTTPSessionEvent& /*aEvent*/)

{

    return aError;

}

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

// CHttpFilterProxy::SetProxyL

// Function to handle Submit events.

// Set proxy properties (EUseProxy and EProxyAddress) in order to get connected throught

// proxy when a new HTTP session will be in effect.  The Proxy data will be taken from

// the CommDb if a new connection has been used. If a proxy property has already been 

// set by a higher filter or by the client, then those settings are preferred over 

// CommsDB.

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

//

void CHttpFilterProxy::SetProxyL(const RHTTPTransaction aTransaction)

{

    THTTPHdrVal isNewConn, proxyAddress;

    // If connection has been disconnected the user could change Access Point, so let's

    // check if a new connection has been used.

    TBool ret = iConnInfo.Property (iStringPool.StringF(HttpFilterCommonStringsExt::EHttpNewConnFlag,

                                   HttpFilterCommonStringsExt::GetTable()), isNewConn);

    if (ret && isNewConn.Type() == THTTPHdrVal::KTIntVal && (isNewConn.Int() == 1))

    {

        iUsage = EFalse;

        // Read proxy info from the CommDB

        ReadProxyInfoL(iStringPool,

                       iUsage,

                       iProxyAddress,

                       iExceptions);

    }

    else

    {

        TBool useProxy( ETrue );

        THTTPHdrVal proxyUsageVal;

	    // Is the property for proxy usage set?

        TBool hasUsageValue = iConnInfo.Property(iStringPool.StringF(HTTP::EProxyUsage,

                            RHTTPSession::GetTable()), proxyUsageVal);

        // If the property is set, is it EUseProxy

        if (hasUsageValue)

        {

        useProxy = ( proxyUsageVal.StrF().Index(RHTTPSession::GetTable()) == HTTP::EUseProxy);

        }

        // Use proxy if the property value is EUseProxy or no property is set.

        if (useProxy || !hasUsageValue)

        {

            THTTPHdrVal proxyAddressVal;

            TBool hasValue = iConnInfo.Property(iStringPool.StringF(HTTP::EProxyAddress,

                                               RHTTPSession::GetTable()), proxyAddressVal);

            if (!hasValue)

            {

                // The proxyAddress has not been set, so Read proxy info from the CommDB

                ReadProxyInfoL(iStringPool,

                               iUsage,

                               iProxyAddress,

                               iExceptions);

            }

            else

            {

                // Now get the proxy address...

                iProxyAddress = proxyAddressVal.StrF().Copy();

                iUsage = ETrue;

            }

        }

//      }

    }

    // We should not use proxy if the uri matches to one of exceptions from the exception list

    // In this case the Origing server will be used

    ExcptionsCompare(aTransaction);

    // Respect proxy settings already defined by client or higher HTTP filter

    THTTPHdrVal proxyUsage;  // Check if property present or not present, not the value.

    if ( !iConnInfo.Property(iStringPool.StringF(HTTP::EProxyUsage,

                            RHTTPSession::GetTable()), proxyUsage)) 

   	{ 

		// Set the proxy address and proxy Usage

		proxyAddress = THTTPHdrVal(iProxyAddress);

		iConnInfo.RemoveProperty(iStringPool.StringF(HTTP::EProxyAddress,

		                        RHTTPSession::GetTable()));

		iConnInfo.SetPropertyL(iStringPool.StringF(HTTP::EProxyAddress,

		                      RHTTPSession::GetTable()), proxyAddress);

		iConnInfo.RemoveProperty(iStringPool.StringF(HTTP::EProxyUsage,

		                        RHTTPSession::GetTable()));

		if (iUsage)

		{

		    iConnInfo.SetPropertyL(iStringPool.StringF(HTTP::EProxyUsage,

		                          RHTTPSession::GetTable()), iStringPool.StringF(HTTP::EUseProxy,

		                                  RHTTPSession::GetTable()));

		}

		else

		{

		    iConnInfo.SetPropertyL(iStringPool.StringF(HTTP::EProxyUsage,

		                          RHTTPSession::GetTable()), iStringPool.StringF(HTTP::EDoNotUseProxy,

		                                  RHTTPSession::GetTable()));

		}

   	}  

    // Cleanup strings.

    iProxyAddress.Close();

    iExceptions.Close();

}

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

// CHttpFilterProxy::ReadProxyInfoL

// Purpose:	Reads the Proxy information from the comms database.

// Gives the Proxy usage, a proxy address (<proxy name>:<proxy port>),

// and proxy exceptions through the output arguments.

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

//

void CHttpFilterProxy::ReadProxyInfoL(const RStringPool aStringPool,

                                      TBool&      aUsage,

                                      RStringF&   aProxyAddress,

                                      RStringF&   aExceptions)

{

    // Let's find Internet Access point ID (ServiceId) in use from the RConnection associated with the HTTP framework

    THTTPHdrVal connValue;

    TUint32     serviceId;

    TUint pushCount = 0;

    RConnection* connPtr = NULL;

	THTTPHdrVal		iapId;

	TCommDbConnPref pref;

    TBool hasValue = iConnInfo.Property (aStringPool.StringF(HTTP::EHttpSocketConnection, RHTTPSession::GetTable()),

                     connValue);

    if (hasValue && connValue.Type() == THTTPHdrVal::KTIntVal)

    {

        connPtr = REINTERPRET_CAST(RConnection*, connValue.Int());

	}

	else

	{

		// Connect to ESOCK and open connection handle

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

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

		TBool ret = iConnInfo.Property (aStringPool.StringF(HttpFilterCommonStringsExt::EAccessPointID, HttpFilterCommonStringsExt::GetTable()),

                     iapId);

		if (ret && (iapId.Type() == THTTPHdrVal::KTIntVal) && (iapId.Int() != 0) )

			{

			 pref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

			 pref.SetIapId( iapId.Int() );

			 //pref.SetBearerSet( ECommDbBearerGPRS );

			 pref.SetDirection(ECommDbConnectionDirectionOutgoing);

			 TInt err = iConnection.Start(pref);

			 if ( err != KErrNone )

				User::LeaveIfError(iConnection.Start());

			}

		else

			{

			// start the connection - note that this thread will be blocked until the connection is established.

			User::LeaveIfError(iConnection.Start());

			}

		connPtr = &iConnection;

		// set the ESOCK handles as session properties after successful connection

		iConnInfo.SetPropertyL(aStringPool.StringF(HTTP::EHttpSocketServ, RHTTPSession::GetTable()), iSocketServ.Handle());

		iConnInfo.SetPropertyL(aStringPool.StringF(HTTP::EHttpSocketConnection, RHTTPSession::GetTable()), reinterpret_cast<TInt>(&iConnection));

		iFilterOwnsConnection = ETrue;

	}

    // Retrieve the service Id  from the RConnection ; "<table name>/<field name>

    User::LeaveIfError(connPtr->GetIntSetting(_L("IAP\\IAPService"), serviceId));

    // Retrieve the service Type  from the RConnection

    HBufC* serviceType16 = HBufC::NewL(KCommsDbSvrMaxFieldLength);

    CleanupStack::PushL(serviceType16);

    pushCount++;

    TPtr serviceTypePtr16 = serviceType16->Des();

    User::LeaveIfError(connPtr->GetDesSetting(_L("IAP\\IAPServiceType"), serviceTypePtr16));

    // Open the Comms DB with the IAP style

    CCommsDatabase* db=CCommsDatabase::NewL(EDatabaseTypeUnspecified);

    CleanupStack::PushL(db);

    pushCount++;

    // Opens a view on records in the Proxies table with a specified range of service types and service IDs.

    // Proxies records are included that have matching service types and IDs.

    // When the use of the view object is complete, it should be popped from the cleanup stack, and deleted.

    CCommsDbTableView* pView = db->OpenViewOnProxyRecordLC(serviceId, serviceTypePtr16);

    pushCount++;

    TInt err = pView->GotoFirstRecord();

	aUsage = ETrue;

	// if there is some other DB error.

	if ( err != KErrNotFound && err != KErrNone )

		{

        User::LeaveIfError( err );

		}

    if ( err == KErrNotFound )

		{// setting to EFalse because proxy table view does not exisit, was not created during Access point creation?

		aUsage = EFalse;

		}

	else

		// no need to keep going as not Proxy will be used. 

		{

		// Read the proxy usage flag from the selected Proxy record.

		pView->ReadBoolL(TPtrC(PROXY_USE_PROXY_SERVER), aUsage);

		// COntinue only if the proxy usage flag is set

		if (aUsage)

			{

			// Read the server name specified in the selected Proxy record.

			// The proxyAddress will be build based on the serverName and the port number

			// separated with ':'

			HBufC* serverName = pView->ReadLongTextLC(TPtrC(PROXY_SERVER_NAME));

			pushCount++;

			TPtr serverNamePtr16 = serverName->Des();

			serverNamePtr16.Trim();

			// Continue only if we have a proxy name

			if (serverNamePtr16.Length() > 0 && serverNamePtr16.Ptr() != NULL)

				{

				// Read the port number specified in the selected Proxy record

				TUint32 portNumber = 8080;      // default port number

				TInt length = 1;                // add 1 for the separator ':'