/*

* Copyright (c) 2007 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:  Implementation of CHTTPFilterGBA

*

*/

#include <http/rhttptransaction.h>

#include <http/rhttpheaders.h>

#include <http/rhttpresponse.h>

#include <httperr.h>

#include <httpstringconstants.h>

#include <imcvcodc.h>      //for base64 en/decoding

#include "HTTPFilterGBA.h"

#include "GbaCommon.h"

#include <bautils.h>

#include <e32math.h>

#include <hash.h>

#include <e32const.h>

#include "GBALogger.h"

//Constants

const TInt KStatusTextLength512 = 512;

const TInt KB64KeySize = 64;

const TInt KIntegerConstant8 = 8;

const TInt KIntegerConstant32 = 32;

const TInt KIntegerConstant33 = 33;

// Length of a digest hash when represented in hex

const TInt KHashLength = 32;

// Length of a digest hash before converting to hex.

const TInt KRawHashLength = 16;

// Length of nonce-count

const TInt KNonceCountLength = 8;

_LIT8( KUserAgentProductToken,"3gpp-gba");

_LIT8(K3GPPRealmString,"3GPP-Bootstrapping@");

_LIT8( KMd5AlgorithmStr, "MD5" );

_LIT8( KMd5SessAlgorithmStr, "MD5-sess" );

_LIT8( KQopAuthStr, "auth" );

_LIT8( KQopAuthIntStr, "auth-int" );

_LIT8( KAuthenticationInfoStr, "Authentication-Info" );

_LIT8( KColon, ":" );

_LIT8( KDefaultProtocolAlg, "\x01\x00\x00\x00\x02");

_LIT(KGBAHttpFilter, "HTTP FILTER GBA");

// format for output of data/time values

#if defined (_DEBUG) && defined (_LOGGING)

_LIT(KDateFormat,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S.%C%:3");

#endif

void PanicGBAHttpFilters(TInt aErr = 0)

{

    User::Panic(KGBAHttpFilter, aErr);

}

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

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

// CHTTPFilterGBA::CHTTPFilterGBA

// Constructor

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

//

CHTTPFilterGBA::CHTTPFilterGBA()

		: iBootstrapCount(0),iHaveGbaBootstrapCredentials(EFalse)

{

}

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

// CHTTPFilterGBA::InstallFilterL

// Initialize the filter and register it to sesssion's filter collection

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

//

CEComFilter* CHTTPFilterGBA::InstallFilterL(TAny* aParams)

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::CHTTPFilterGBA++"));

	__ASSERT_DEBUG(aParams != NULL, PanicGBAHttpFilters());

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

	CHTTPFilterGBA* filter = new (ELeave) CHTTPFilterGBA();

	CleanupStack::PushL(filter);

	filter->ConstructL(*session);

	CleanupStack::Pop(filter);

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::CHTTPFilterGBA--"));

	return filter;

}

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

// CHTTPFilterGBA::ConstructL

// Memory and resource allocation, leaves

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

//

void CHTTPFilterGBA::ConstructL(RHTTPSession aSession)

{

    GBA_TRACE_DEBUG(("CHTTPFilterGBA::ConstructL++"));

	//......................................................................................

	//Unload GBA http filter from existing GBA and MBMS server's

	//This GBA http filter cannot be loaded from old GBA server (GBAServer) and it's 

	//Required to reject a filter loading request from a GBA server  on existing platforms

	//where GBA component is already built-in and the GBA server UID3 is 0x2000F868

	//Note- some s60 3.2 and 5.0 platforms already has GBA component as built in.

	//Reason: Ub interface should not have the User-Agent string "3gpp-gba"

    if( RProcess().SecureId() == TSecureId (0x2000F868))

    {

    	GBA_TRACE_DEBUG(("Not accessible from GBA Server++"));

        return;

    }

    //This GBA http filter cannot be loaded from MBMS server (MBMSServer) and it's 

    //Required to reject a filter loading request from a MBMS server

    //where MBMS component is already build-in[N96 platforms only] and the mbms server UID3 is 0x2001957B

    //Reason: Ub interface should not have the User-Agent string "3gpp-gba"

    if( RProcess().SecureId() == TSecureId (0x2001957B))

    {

        GBA_TRACE_DEBUG(("Not accessible from MBMS Server++"));

        return;

    } 

    //......................................................................................

   	iProtocolIdentifier.Copy(KDefaultProtocolAlg);

	iUICCLabel = KUSIM;

	iStringPool = aSession.StringPool();

	// register the filter

	RStringF filterName = iStringPool.OpenFStringL( KHTTPFilterGBAName );

	CleanupClosePushL( filterName );

    iOpaqueStr = iStringPool.StringF( HTTP::EOpaque, RHTTPSession::GetTable() );

    iNonceStr = iStringPool.StringF( HTTP::ENonce, RHTTPSession::GetTable() );

    iQopStr = iStringPool.StringF( HTTP::EQop, RHTTPSession::GetTable() );

    iStaleStr = iStringPool.StringF( HTTP::EStale, RHTTPSession::GetTable() );

    iMd5Str = iStringPool.OpenFStringL( KMd5AlgorithmStr );

    iMd5SessStr = iStringPool.OpenFStringL( KMd5SessAlgorithmStr );

    iQopAuthStr = iStringPool.OpenFStringL( KQopAuthStr );

    iAuthInfo = iStringPool.OpenFStringL( KAuthenticationInfoStr );

    iRealmStr = iStringPool.StringF( HTTP::ERealm, RHTTPSession::GetTable() );

    iUsernameStr = iStringPool.StringF( HTTP::EUsername, RHTTPSession::GetTable() );

    iPasswordStr = iStringPool.StringF( HTTP::EPassword, RHTTPSession::GetTable() );

	iUserAgent = iStringPool.OpenFStringL( KUserAgentProductToken );

    //Regsiter for THTTPEvent::ESubmit http event

    //The User-Agent string gets appended with "3gpp-gba" string, 

    //indicating client is gba capable to the application server.

    aSession.FilterCollection().AddFilterL( *this,

                                            THTTPEvent::ESubmit,

                                            RStringF(),

                                            KAnyStatusCode,

                                            EStatusCodeHandler,

                                            filterName);

    //Regsiter for THTTPEvent::EGotResponseHeaders http event with "Authentication-Info" header 

    //and HTTPStatus::EOk http status code,just to know if the credentials established are valid.

    aSession.FilterCollection().AddFilterL( *this,

                                            THTTPEvent::EGotResponseHeaders,

                                            iAuthInfo,

                                            HTTPStatus::EOk,

                                            EStatusCodeHandler,

                                            filterName );

    //Regsiter for THTTPEvent::EGotResponseHeaders http event with "WWW-Authenticate" header 

    //and HTTPStatus::EUnauthorized http status code

    //The priority for this is set to MHTTPFilter::EStatusCodeHandler - 1,

    //so the gba filter intercepts the transaction before the default 

    //http digest authentication filter(which has priority MHTTPFilter::EStatusCodeHandler).

    aSession.FilterCollection().AddFilterL( *this, 

											THTTPEvent::EGotResponseHeaders,	// Any transaction event

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

											HTTPStatus::EUnauthorized,

											MHTTPFilter::EStatusCodeHandler - 1,	  // Priority of filter

											filterName );						      // Name of filter

	CleanupStack::PopAndDestroy( &filterName );

	//Check if the "user agent" header field in http session headers has "3gpp-gba" string in it.

	//If it does n't have "3gpp-gba" string,append  it to the existing value.

    TBool found = EFalse;

    TPtrC8 rawFieldData;

    RHTTPHeaders sessionHeaders = aSession.RequestSessionHeadersL();

    RStringF sessionHeaderfieldname = aSession.StringPool().StringF( HTTP::EUserAgent, RHTTPSession::GetTable());

    sessionHeaders.GetRawField(sessionHeaderfieldname, rawFieldData);

    found = rawFieldData.Find(iUserAgent.DesC()) != KErrNotFound;

    if(!found)

        sessionHeaders.SetFieldL( sessionHeaderfieldname, iUserAgent );	    

    iMD5Calculator = CMD5::NewL();

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::ConstructL--"));

}

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

// CHTTPFilterGBA::~CHTTPFilterGBA

// Destructor

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

//

CHTTPFilterGBA::~CHTTPFilterGBA()

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::~CHTTPFilterGBA++"));

	CleanupAll();															

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::~CHTTPFilterGBA--"));

}

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

// CHTTPFilterGBA::MHFLoad

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

//

void CHTTPFilterGBA::MHFLoad(RHTTPSession, THTTPFilterHandle)

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFLoad"));

	++iLoadCount;

}

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

// CHTTPFilterGBA::MHFUnload

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

//

void CHTTPFilterGBA::MHFUnload(RHTTPSession , THTTPFilterHandle)

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFUnload++"));

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

	if (--iLoadCount)

	{

		return;

	}

	delete this;

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFUnload--"));

}

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

// CHTTPFilterGBA::MHFRunL

// See MHTTPFilterBase::MHFRunL 

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

//

void CHTTPFilterGBA::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFRunL++"));

	GBA_TRACE_DEBUG_NUM(("MHFRunL Event %d"), aEvent.iStatus );

	if (aEvent.iUID != KHTTPUid) 

		return;

	switch(aEvent.iStatus)

	{

		case THTTPEvent::ESubmit:

		{

			DoSubmitL(aTransaction);

		}

		break;

		case THTTPEvent::EGotResponseHeaders:

		{

			// Get HTTP status code from header (e.g. 200)

			RHTTPResponse resp = aTransaction.Response();

			TInt status = resp.StatusCode();

			GBA_TRACE_DEBUG_NUM(("MHFRunL staus code %d"), status );

			// Get status text (e.g. "OK")

			TBuf<KStatusTextLength512> statusText;

			statusText.Copy(resp.StatusText().DesC());

			GBA_TRACE_DEBUG(("status text:"));

			GBA_TRACE_DEBUG(statusText);

			CheckHeadersL( aTransaction );

		}

		break;

		case THTTPEvent::EGotResponseBodyData:

		{

            GBA_TRACE_DEBUG(("Event: EGotResponseBodyData"));

		}

		break;

		case THTTPEvent::EResponseComplete:

		{

            GBA_TRACE_DEBUG(("Event: EResponseComplete"));

			Cleanup( aTransaction );

		}

		break;

		case THTTPEvent::EFailed:

		{

            GBA_TRACE_DEBUG(("Event: EFailed"));			

			Cleanup( aTransaction );		

		}

		default: 

		{

            GBA_TRACE_DEBUG_NUM(("Unknow Event: ID - %d" ), aEvent.iStatus );

		}

		break;

	}

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFRunL--"));

}

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

// CHTTPFilterGBA::MHFRunError

// See MHTTPFilterBase::MHFRunError

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

//

TInt CHTTPFilterGBA::MHFRunError(TInt /*aError*/, RHTTPTransaction aTransaction, const THTTPEvent& )

{

    GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFRunError++"));

	TInt error = 0;

	// map aError to global error message

	// pass the errorcode forward

	THTTPEvent httpEvent(error);

	TRAP_IGNORE(aTransaction.SendEventL(httpEvent, THTTPEvent::EIncoming, THTTPFilterHandle::ECurrentFilter ));

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFRunError--"));

	return KErrNone;

}

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

// CHTTPFilterGBA::MHFSessionRunL

// See MHTTPFilterBase::MHFSessionRunL

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

//

void CHTTPFilterGBA::MHFSessionRunL(const THTTPSessionEvent& )

{

	// do nothing

}

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

// CHTTPFilterGBA::MHFSessionRunL

// See MHTTPFilterBase::MHFSessionRunL

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

//

TInt CHTTPFilterGBA::MHFSessionRunError(TInt aError, const THTTPSessionEvent& )

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::MHFSessionRunError"));

	// session problem, need to close GBA engine

	return aError;

}

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

// CHTTPFilterGBA::DumpResponseHeadersL

// Dump the response headers to LOG file

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

//

#if defined (_DEBUG)

void CHTTPFilterGBA::DumpResponseHeadersL( RHTTPResponse& aResponse )

{

	GBA_TRACE_DEBUG("Dump the header...");

	RHTTPHeaders headers = aResponse.GetHeaderCollection();

	THTTPHdrFieldIter it = headers.Fields();

	while( it.AtEnd() == EFalse )

	{

        RStringTokenF fieldName = it();

        RStringF fieldNameStr = iStringPool.StringF (fieldName );

        THTTPHdrVal fieldVal;

        TInt fieldParts = 0; // For the case if next the call fails.

        TRAP_IGNORE( fieldParts =  headers.FieldPartsL( fieldNameStr ) );

		// dump the first part of  a  header field

		for ( TInt ii = 0; ii < fieldParts; ii++ )

		{	

			if( headers.GetField( fieldNameStr, ii, fieldVal ) == KErrNone )

			{

				const TDesC8& fieldNameDesC = fieldNameStr.DesC();

				GBA_TRACE_DEBUG(" : ");

                GBA_TRACE_DEBUG(fieldNameDesC);

				switch( fieldVal.Type() )

				{

				case THTTPHdrVal::KTIntVal:

					{

						GBA_TRACE_DEBUG_NUM(("%d"), fieldVal.Int() );

					}

					break;

				case THTTPHdrVal::KStrFVal:

					{

						RStringF fieldValStr = iStringPool.StringF( fieldVal.StrF() );

						const TDesC8& fieldValDesC = fieldValStr.DesC();

                        GBA_TRACE_DEBUG(fieldValDesC);

					}

					break;

				case THTTPHdrVal::KStrVal:

					{

						RString fieldValStr = iStringPool.String( fieldVal.Str() );

						const TDesC8& fieldValDesC = fieldValStr.DesC();

						GBA_TRACE_DEBUG(fieldValDesC);

					}

					break;

				case THTTPHdrVal::KDateVal:

					{

						TDateTime date = fieldVal.DateTime();

						TBuf<KStatusTextLength512> dateTimeString;

						TTime t( date );

						t.FormatL( dateTimeString, KDateFormat );

						TBuf8<KStatusTextLength512> dtStr;

						dtStr.Copy( dateTimeString.Left( 128 ) );

						GBA_TRACE_DEBUG(dtStr);

					}

					break;

				case THTTPHdrVal::KNoType:

				default:

					{

					GBA_TRACE_DEBUG("Unrecognized value type");

					}

					break;

				}

			}

		}

		++it;

	}

	GBA_TRACE_DEBUG("Header is Dumped already");

}

#endif

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

// CHTTPFilterGBA::CheckHeadersL

// Check HTTP headers and extract MIME type

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

// 

void CHTTPFilterGBA::CheckHeadersL(  RHTTPTransaction& aTrans )

{

	GBA_TRACE_DEBUG(("CHTTPFilterGBA::CheckHeadersL++"));

	// read the header data and check the MIME type here	

	// check the status and body

	RHTTPResponse response = aTrans.Response();

	TInt status = response.StatusCode();

	#if defined (_DEBUG)

	DumpResponseHeadersL( response );

	#endif

	THTTPHdrVal fieldVal;

	// check if status == 401 and realm is 3GPP then we need to bootstrap, if we are already bootstrappign this is the second call

	if(  status == HTTPStatus::EUnauthorized )

	{

	    TInt headerPart = FindHeaderPartToUseL(aTrans);

        if( headerPart == KErrNotFound )

            return;

	    THTTPHdrVal headerVal;

        TInt cred = KErrNotFound;

	    if( aTrans.PropertySet().Property( iRealmStr, headerVal ) )

	    	cred = DFindCredentials( headerVal, aTrans.Request().URI() );

	    RStringF wwwAuthHeader = iStringPool.StringF(HTTP::EWWWAuthenticate,RHTTPSession::GetTable());

	    RHTTPHeaders headers(aTrans.Response().GetHeaderCollection());

	    RString realm;

	    THTTPHdrVal hdrVal;

	    if (!headers.GetParam(wwwAuthHeader, iStringPool.StringF(HTTP::ERealm,RHTTPSession::GetTable()), 

				  hdrVal, headerPart))

	    {

			realm = hdrVal;

			const TDesC8& val = realm.DesC();

			if(val.FindF(K3GPPRealmString) == 0)

			{

				GBA_TRACE_DEBUG(("3GPP-Bootstrapping realm detected...\n"));

	            THTTPHdrVal authTypeParam;

	            if ( headers.GetField( wwwAuthHeader, headerPart, authTypeParam ) == KErrNone )

	                // we need to store realm, opaque, nonce and qop values to

	                // use them when resubmitting the request

	                {

	                THTTPHdrVal algorithmVal;

	                THTTPHdrVal nonceVal;

	                THTTPHdrVal realmVal;

	                THTTPHdrVal opaqueVal;

	                THTTPHdrVal staleVal;

	                TInt algVal( EAlgUnknown );

	                TInt authVal( EQopNone );

	                aTrans.PropertySet().RemoveProperty( iNonceStr );

	                aTrans.PropertySet().RemoveProperty( iRealmStr );

	                aTrans.PropertySet().RemoveProperty( iOpaqueStr );

	                aTrans.PropertySet().RemoveProperty( iQopStr );

	                aTrans.PropertySet().RemoveProperty( iStaleStr );

	                if( !headers.GetParam( wwwAuthHeader, 

	                                      iStringPool.StringF( HTTP::EAlgorithm, 

	                                                      RHTTPSession::GetTable() ), 

	                                      algorithmVal, 

	                                      headerPart ) )

	                    {

	                    if( !algorithmVal.Str().DesC().CompareF( iMd5Str.DesC() ) )

	                        {

	                        algVal = EAlgMd5;

	                        }

	                    else if( !algorithmVal.Str().DesC().CompareF( iMd5SessStr.DesC() ) )

	                        {

	                        algVal = EAlgMd5Sess;

	                        }

	                    }

	                authVal = CheckQop( headers, wwwAuthHeader, headerPart );

	                headers.GetParam( wwwAuthHeader, iNonceStr, nonceVal, headerPart );

	                headers.GetParam( wwwAuthHeader, iRealmStr, realmVal, headerPart );

	                headers.GetParam( wwwAuthHeader, iOpaqueStr, opaqueVal, headerPart );

	                headers.GetParam( wwwAuthHeader, iStaleStr, staleVal, headerPart );

	                if( ( authVal & EQopAuth || authVal == EQopNone )

	                    && nonceVal.Type() == THTTPHdrVal::KStrVal

	                    && realmVal.Type() == THTTPHdrVal::KStrVal )

	                    {

	                    aTrans.PropertySet().SetPropertyL( iNonceStr, nonceVal );

	                    aTrans.PropertySet().SetPropertyL( iRealmStr, realmVal );

	                    // Opaque

	                    if( opaqueVal.Type() == THTTPHdrVal::KStrVal )

	                        {

	                        aTrans.PropertySet().SetPropertyL( iOpaqueStr, opaqueVal );

	                        }

	                    // Qop

	                    aTrans.PropertySet().SetPropertyL( iQopStr, authVal );

	                    // Algorithm