// Copyright (c) 2001-2009 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:
//

#include <e32std.h>
#include "redirect.h"
#include <uri8.h>
#include <delimitedpath8.h>
#include <delimitedquery8.h>
#include <http/rhttptransaction.h>
#include <http/rhttpheaders.h>
#include <httpstringconstants.h>
#include <httperr.h>
#include "corefilterspanic.h"
#include <escapeutils.h>

const TInt KRedirectLimit = 8; // Maximum level of redirection to stop infinite circular redirection

CRedirectFilter::CRedirectFilter(RHTTPSession aSession)
		: iSession(aSession), iStringTable(RHTTPSession::GetTable())
	{
	}

CEComFilter* CRedirectFilter::InstallFilterL(TAny* aSession)
	{
	RHTTPSession* session = REINTERPRET_CAST(RHTTPSession*, aSession);
	CRedirectFilter* filter = new (ELeave) CRedirectFilter(*session);
	CleanupStack::PushL(filter);
	filter->ConstructL(*session);
	CleanupStack::Pop(filter); 
	return filter;
	}

void CRedirectFilter::ConstructL(RHTTPSession aSession)
	{
	iStringPool = aSession.StringPool();
	// Register the filter. 

	// 301 Moved Permanently
	aSession.FilterCollection().AddFilterL(*this, THTTPEvent::EGotResponseHeaders, RStringF(), 
										   301, EStatusCodeHandler, iStringPool.StringF(HTTP::ERedirect,iStringTable));
	// 302 Found (deprecated, same as 307)
	aSession.FilterCollection().AddFilterL(*this, THTTPEvent::EGotResponseHeaders, RStringF(), 
										   302, EStatusCodeHandler, iStringPool.StringF(HTTP::ERedirect,iStringTable));
	// 303 See other
	aSession.FilterCollection().AddFilterL(*this, THTTPEvent::EGotResponseHeaders, RStringF(), 
										   303, EStatusCodeHandler, iStringPool.StringF(HTTP::ERedirect,iStringTable));
	// 307 Moved Temporarily
	aSession.FilterCollection().AddFilterL(*this, THTTPEvent::EGotResponseHeaders, RStringF(), 
										   307, EStatusCodeHandler, iStringPool.StringF(HTTP::ERedirect,iStringTable));
	
	// Exceptional Cases which require special handling

	// 305 Use Proxy
	aSession.FilterCollection().AddFilterL(*this, THTTPEvent::EGotResponseHeaders, RStringF(), 
										   305, EStatusCodeHandler, iStringPool.StringF(HTTP::ERedirect,iStringTable));

	// 304 This should be entirely handled by the client as it is only used in conditional get cases, so only the client
	// would know what to do
	}

CRedirectFilter::~CRedirectFilter()
	{
	// If we've been destroyed from the cleanup stack during creation
	// of the object, it might still be loaded. So check. (Normaly the
	// delete is initiated by the 'delete this' in MHFUnload)
	if (iLoadCount)
		{
		// As we're already in a destructor, MHFUnload must not delete us again
		iLoadCount = -1;
		iSession.FilterCollection().
			RemoveFilter(iStringPool.StringF(HTTP::ERedirect,iStringTable));
		}
	}

void CRedirectFilter::MHFLoad(RHTTPSession, THTTPFilterHandle)
	{
	++iLoadCount;
	}

void CRedirectFilter::MHFUnload(RHTTPSession /*aSession*/, THTTPFilterHandle)
	{
	if (--iLoadCount)
		return;

	delete this;
	}

void CRedirectFilter::MHFRunL(RHTTPTransaction aTransaction, 
									const THTTPEvent& /*aEvent*/)
	{
	
	switch (aTransaction.Response().StatusCode())
		{
	case 301:
		HandleRedirectL(aTransaction,THTTPEvent::ERedirectedPermanently);
		break;
	case 302:
	case 303:
	case 307:
		HandleRedirectL(aTransaction,THTTPEvent::ERedirectedTemporarily);
		break;
	case 305: 
		HandleUseProxyL(aTransaction);
		break;
	default:
		break;
		}
	}

TInt CRedirectFilter::MHFRunError(TInt /*aError*/, 
										RHTTPTransaction aTransaction,
										const THTTPEvent& /*aEvent*/)
	{
	// If anything left, we've run out of memory or something
	// similarly catastrophic has gone wrong.
	aTransaction.Fail();
	return KErrNone;
	}

void CRedirectFilter::MHFSessionRunL(const THTTPSessionEvent& /*aEvent*/)
	{
	}

TInt CRedirectFilter::MHFSessionRunError(TInt aError, const THTTPSessionEvent& /*aEvent*/)
	{
	return aError;
	}

void CRedirectFilter::HandleRedirectL(RHTTPTransaction aTransaction, THTTPEvent::TTransactionWarning aWarningEvent)
	{

	TInt redirectCount = 0;
	RStringPool p = aTransaction.Session().StringPool();

	// see if this transaction has been redirected before
	THTTPHdrVal redirectCountProperty;
	if (aTransaction.PropertySet().Property(p.StringF(HTTP::ERedirectCount,iStringTable), 
											redirectCountProperty))
		{
		__ASSERT_DEBUG(redirectCountProperty.Type() == THTTPHdrVal::KTIntVal, 
			TFCoreFiltersPanic::Panic(TFCoreFiltersPanic::EInvalidRedirectCountProperty));
		redirectCount = redirectCountProperty.Int();
		__ASSERT_DEBUG(redirectCount > 0, TFCoreFiltersPanic::Panic(TFCoreFiltersPanic::EInvalidRedirectCountProperty));
		}

	TInt maxNumberOfRedirects = KRedirectLimit;
	THTTPHdrVal maxRedirect;
	if (aTransaction.Session().ConnectionInfo().Property(p.StringF(HTTP::EMaxRedirect,iStringTable), maxRedirect))
		{
		__ASSERT_DEBUG(maxRedirect.Type() == THTTPHdrVal::KTIntVal, 
			TFCoreFiltersPanic::Panic(TFCoreFiltersPanic::EInvalidMaxRedirectProperty));
		maxNumberOfRedirects = maxRedirect.Int();
		__ASSERT_DEBUG(maxNumberOfRedirects > 0, 
			TFCoreFiltersPanic::Panic(TFCoreFiltersPanic::EInvalidMaxRedirectProperty));
		}


	// Only redirect a certain number of times, and update the redirect count property of the transaction
	if (++redirectCount <= maxNumberOfRedirects)
		{
		aTransaction.PropertySet().SetPropertyL(p.StringF(HTTP::ERedirectCount,iStringTable), redirectCount);

		RStringF location = p.StringF(HTTP::ELocation,iStringTable);
		RHTTPHeaders responseHeaders(aTransaction.Response().GetHeaderCollection());
		THTTPHdrVal locationValue;
		
		TInt err = responseHeaders.GetField(location, 0, locationValue);
		if (err == KErrNotFound) // location not present when redirected
			aTransaction.SendEventL(KErrHttpRedirectNoLocationField,THTTPEvent::EIncoming,THTTPFilterHandle::ECurrentFilter);
		else 
			{
			User::LeaveIfError(err); 
			RHTTPRequest request = aTransaction.Request();
			RHTTPHeaders requestHeaders(request.GetHeaderCollection());
			requestHeaders.RemoveField(p.StringF(HTTP::EHost,iStringTable));
			TUriParser8 uriParser;
			uriParser.Parse( locationValue.StrF().DesC()  );
			SetRedirectUriL( request, uriParser );
			aTransaction.Cancel();

			
			// 10.3.2 301 Moved Permanently:
			// The requested resource has been assigned a new permanent URI and any future references to this resource
			// SHOULD use one of the returned URIs. If the 301 status code is received in response to a request
			// other than GET or HEAD, the user agent MUST NOT automatically redirect the request unless it can be confirmed
			// by the user, since this might change the conditions under which the request was issued.
			 
			// 10.3.8 307 Temporary Redirect:
			// The requested resource resides temporarily under a different URI. Since the redirection MAY be 
			// altered on occasion, the client SHOULD continue to use the Request-URI for future requests. 
			// This responseis only cacheable if indicated by a Cache-Control or Expires header field.
			
			// If the returned status code is 301 or 302 or 307 and the requested method is GET or HEAD,then the transaction 
			// is simply submitted. If not then the filter sends the client an event - ERedirectRequiresConfirmation
			// Then Client has to make the decision either to submit the transaction with the
			// new redirected URI or to close the transaction.
			
			TInt method = aTransaction.Request().Method().Index(iStringTable);
			TInt statusCode = aTransaction.Response().StatusCode();

			if( (statusCode == 301 || statusCode == 307) && 
									!((method==HTTP::EGET) || (method==HTTP::EHEAD)) )
				{
				aTransaction.SendEventL(THTTPEvent::ERedirectRequiresConfirmation,THTTPEvent::EIncoming,THTTPFilterHandle::ECurrentFilter);
				}
			else
				{
				// 10.3.3 302 Found:
				// The requested resource resides temporarily under a different URI. 
				// Since the redirection might be altered on occasion, the client 
				// SHOULD continue to use the Request-URI for future requests. This 
				// response is only cacheable if indicated by a Cache-Control or 
				// Expires header field.
				// Note: RFC 1945 and RFC 2068 specify that the client is not allowed
				// to change the method on the redirected request.  However, most
				// existing user agent implementations treat 302 as if it were a 303
				// response, performing a GET on the Location field-value regardless
				// of the original request method. The status codes 303 and 307 have
				// been added for servers that wish to make unambiguously clear which
				// kind of reaction is expected of the client.


				// 10.3.4 303 See Other
				// The response to the request can be found under a different URI and
                // SHOULD be retrieved using a GET method on that resource.
				// The different URI SHOULD be given by the Location field in the
                // response. Unless the request method was HEAD, the entity of the
                // response SHOULD contain a short hypertext note with a hyperlink to
                // the new URI(s).
				if ( statusCode == 302 || statusCode == 303 )
					{
						requestHeaders.RemoveField(p.StringF(HTTP::EContentLength,iStringTable));
						requestHeaders.RemoveField(p.StringF(HTTP::EContentType,iStringTable));
						aTransaction.Request().RemoveBody();
						aTransaction.Response().RemoveBody();
						request.SetMethod(p.StringF(HTTP::EGET, iStringTable));
					}
				aTransaction.SendEventL(aWarningEvent,THTTPEvent::EIncoming,THTTPFilterHandle::ECurrentFilter);
				aTransaction.SubmitL();
				}
			}
		}
	else // Possible circular redirection so pass on an error to the user
		{
		aTransaction.SendEventL(KErrHttpRedirectExceededLimit,THTTPEvent::EIncoming,THTTPFilterHandle::ECurrentFilter);
		}

	}


void CRedirectFilter::HandleUseProxyL(RHTTPTransaction aTransaction)
	{
	__START_PERFORMANCE_LOGGER();
	aTransaction.SendEventL(KErrHttpRedirectUseProxy,THTTPEvent::EIncoming,THTTPFilterHandle::ECurrentFilter);
     __END_PERFORMANCE_LOGGER(_L(",CValidationFilter::ValidateResponseStatusCode()"));
	}


void CRedirectFilter::EscapeEncodeUriL ( CUri8& aUri ) const
	{
	_LIT8 ( KCharsToEscape, " " );

	const TUriC8& uri ( aUri.Uri() );
	if ( uri.IsPresent ( EUriPath ) ) 
		{
		HBufC8* escapedPath = EscapeUtils::SpecificEscapeEncodeL ( uri.Extract ( EUriPath ), KCharsToEscape  );
		CleanupStack::PushL ( escapedPath );
		aUri.SetComponentL ( *escapedPath, EUriPath );
		CleanupStack::PopAndDestroy ( escapedPath );		
	    }
	
	if ( uri.IsPresent ( EUriQuery ) ) 
		{
		HBufC8* escapedQuery = EscapeUtils::SpecificEscapeEncodeL ( uri.Extract ( EUriQuery ), KCharsToEscape  );
		CleanupStack::PushL ( escapedQuery );
		aUri.SetComponentL ( *escapedQuery, EUriQuery );
		CleanupStack::PopAndDestroy ( escapedQuery );		
		}		
	}

void CRedirectFilter::SetRedirectUriL(RHTTPRequest aRequest, const TUriC8& aUri) const
	{
	 CUri8* newUri = NULL;

	if (aUri.IsPresent(EUriHost))
		{
		newUri = CUri8::NewLC ( aUri );
		}

	else // the location field contained a relative Uri.
		{
		newUri = CUri8::ResolveL(aRequest.URI(), aUri);
		CleanupStack::PushL(newUri);
		}
			EscapeEncodeUriL ( *newUri );	
	// Check for the fragment in the new uri.
	// need to append if the fragment is present in the initial uri and not present in the redirected.
	if ( aRequest.URI().IsPresent( EUriFragment ) && !newUri->Uri().IsPresent( EUriFragment ) )
		{
		newUri->SetComponentL ( aRequest.URI().Extract ( EUriFragment ), EUriFragment );
		}
	aRequest.SetURIL(newUri->Uri());
	CleanupStack::PopAndDestroy(newUri);
	}