/*

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

	// System includes

#include <http/thttphdrval.h>

#include <uri8.h>

	// User includes

#include "CookieArray.h"

#include "CookieCommonConstants.h"

#include "CookieLogger.h"

#include "CookieServerPanic.h"

// CONSTANTS

const TUint KCookieAttributeSeparator = ',';	// comma

_LIT8( KCookieSecureScheme, "https" );

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

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

// CCookieArray::CCookieArray

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

//

CCookieArray::CCookieArray() : iCookies( KCookieStandardGranularity )

	{

    CLOG( ( ECookieArray, 0, _L( "" ) ) );

    CLOG( ( ECookieArray, 0, _L( "*****************" ) ) );

    CLOG( ( ECookieArray, 0,

					_L( "CCookieArray::CCookieArray" ) ) );

	}

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

// CCookieArray::~CCookieArray

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

//

CCookieArray::~CCookieArray()

	{

	iCookies.ResetAndDestroy();

	iCookies.Close();

    CLOG( ( ECookieArray, 0,

					_L( "CCookieArray::~CCookieArray ") ) );

    CLOG( ( ECookieArray, 0, _L( "*****************" ) ) );

	}

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

// CCookieArray::AddL

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

//

void CCookieArray::AddL( const CCookie* aCookie, const TDesC8& aRequestUri )

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::AddL" ) ) );

    if ( ValidCookieL( *aCookie, aRequestUri ) )

		{

        MakeRoomIfNeeded( aCookie->Size( EFalse ) );

		User::LeaveIfError( iCookies.Append( aCookie ) );

		}

	else

		{

		User::Leave( KErrCorrupt );

		}

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::AddL" ) ) );

	}

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

// CCookieArray::MakeRoomForInsertIfNeededL

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

//

void CCookieArray::MakeRoomForInsertIfNeededL( const CCookie* aCookie, const TDesC8& aRequestUri, TInt& aIndex  )

    {

    if( ValidCookieL( *aCookie, aRequestUri ))

    	{

    	TUint32 size = aCookie->Size( EFalse );

	    TUint32 count( Count() );

	    TUint32 totalsize( 0 );

	    for ( TUint32 i=0; i<count; i++ )

	        {

	        totalsize += At( i )->Size( ETrue );

	        }

	    while ( ( ( totalsize + size ) > KCookieMaxFileLength ) && Count() )

	        {

	        totalsize-= At( 0 )->Size( ETrue );	        	          

	        aIndex--;

	        Remove( 0 );

	        if( aIndex < 0) //The insert point in the array is no longer invalid.

	                        //return without making more room. 

	            break;	            

	        };

	    }

	else

		{

		User::Leave( KErrCorrupt );

		}    

    }

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

// CCookieArray::InsertL

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

//

void CCookieArray::InsertL( const CCookie* aCookie, const TInt aIndex )

	{	

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::InsertL" ) ) );

    User::LeaveIfError( iCookies.Insert( aCookie, aIndex ) );

	CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::InsertL" ) ) );

	}

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

// CCookieArray::Remove

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

//

void CCookieArray::Remove( TInt aIndex )

    {

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::Remove" ) ) );

    __ASSERT_DEBUG(

        ( (aIndex>=0) && (aIndex<iCookies.Count()) ),

        PanicServer( EArrayIndexOutOfRange ) );

    delete iCookies[ aIndex ];

    iCookies.Remove( aIndex );

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::Remove" ) ) );

    }

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

// CCookieArray::ClearAllCookies

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

//

TInt CCookieArray::ClearAllCookies()

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::ClearAllCookies" ) ) );

	TInt count = iCookies.Count();

	iCookies.ResetAndDestroy();

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::ClearAllCookies returned %d" ), count ) );

	return count;

	}

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

// CCookieArray::CompareCookies

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

//

/*

TInt CCookieArray::CompareCookies( CCookie const & aFirstCookie,

								  CCookie const & aSecondCooke )

	{

	// TBD : the order of the cookies (i.e. which is the first and which

	// is the second) may be unpredictable (I guess, it is). This may have

	// serious impact on the sorting/searching algorithm. TO BE CONSIDERED!!!

	// TBD2 : IMPORTANT!!! Perhaps we should use different TLinearOrder methods

	// depending on whether we want to insert a new element into the array or

	// to find a particular element in the array.

	TInt result;

	TPtrC8 firstPathAttr;

	TPtrC8 secondPathAttr;

	if ( GetFoldedCookieAttr( aFirstCookie, CCookie::EPath, firstPathAttr ) &&

		 GetFoldedCookieAttr( aSecondCooke, CCookie::EPath, secondPathAttr ) )

		{

		// TODO : use PathMatch method here

		result = -1;

		}

	else

		{

		// First, there should be no problem with filling the two attribs,

		// because if they happen to be empty (or missing) in the HTTP request

		// header, then a default value must be assigned to them.

		// Second, if we happen to be here, then we say : the first cookie is

		// less than the second, in other words, the first precedes the second.

		result = -1;

		}

	// if the paths are equal, we have to continue with checking the domain

	// attributes

	if ( !result )

		{

		TPtrC8 firstDomainAttr;

		TPtrC8 secondDomainAttr;

		if ( GetFoldedCookieAttr( aFirstCookie, CCookie::EDomain,

												firstDomainAttr ) &&

			GetFoldedCookieAttr( aSecondCooke, CCookie::EDomain,

												secondDomainAttr ) )

			{

			// TODO : use DomainMatch method here

			}

		}

	else

		{

		// First, there should be no problem with filling the two attribs,

		// because if they happen to be empty (or missing) in the HTTP request

		// header, then a default value must be assigned to them.

		// Second, if we happen to be here, then we say : the first cookie is

		// less than the second, in other words, the first precedes the second.

		result = -1;

		}

	return result;

	}

*/

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

// CCookieArray::Count

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

//

TInt CCookieArray::Count() const

	{

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::Count" ) ) );

	return iCookies.Count();

	}

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

// CCookieArray::DomainMatch

// Examples :

//	1.) x.y.com domain-matches .y.com

//	2.) x.y.com does NOT domain-match y.com

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

//

TBool CCookieArray::DomainMatch( const TDesC8& aDomain1,

                                 const TDesC8& aDomain2,

                                 const TBool aAllowedDot /* = EFalse */ ) const

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::DomainMatch" ) ) );

    TBool result;

    TPtrC8 domain2noQuotes( CCookie::RemoveQuotes( aDomain2 ) );

    // domain2noQuotes should not be NULL or length == zero

    if ( domain2noQuotes.Length() == 0 ) 

	{

		result = EFalse;

	}

	else

	{		

		// match "b.com" with ".b.com", not stricly by spec but thats what other browsers do

	    TPtrC8 d2( domain2noQuotes );

	    if ( domain2noQuotes.Length()>1 && domain2noQuotes[ 0 ] == '.' )

	        {

	        d2.Set(domain2noQuotes.Ptr()+1, domain2noQuotes.Length()-1);

	        }

	    if ( aDomain1.Length() == d2.Length() )

			{

	        result = ( !aDomain1.CompareF( d2 ) ? ETrue : EFalse );

			}

	    else if ( domain2noQuotes.Length() < aDomain1.Length() )

	        {

	        // Considering aDomain1 as "x.y.com", leftDomainFraction will be "x"

	        TPtrC8 leftDomainFraction( aDomain1.Left( aDomain1.Length() -

	                                                                        domain2noQuotes.Length() ) );

	        // Considering aDomain1 as "x.y.com", rightDomainFraction will be

	        // ".y.com"

	        TPtrC8 rightDomainFraction( aDomain1.Right( domain2noQuotes.Length() ) );

	        // x.y.com matches both .y.com and y.com, thats what other browsers do

	        TBool dot = rightDomainFraction[0] == KCookieDomainSeparator ||

	            leftDomainFraction[leftDomainFraction.Length()-1] == KCookieDomainSeparator;

	        if ( dot && !rightDomainFraction.CompareF( domain2noQuotes ) )

	            {

	            result = aAllowedDot || // if dot is allowed doesn't care about them

	                (leftDomainFraction.Locate( KCookieDomainSeparator ) == KErrNotFound );

	            }

	        else

	            {

	            result = EFalse;

	            }

	        }

		else

			{

			result = EFalse;

			}

	}

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::DomainMatch" ) ) );

    return result;

	}

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

// CCookieArray::EffectiveHostNameL

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

//

TBool CCookieArray::EffectiveHostNameL( const TDesC8& aHostName,

									   HBufC8*& aEffectiveHostName ) const

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::EffectiveHostName" ) ) );

	TBool hostNameChanged = EFalse;

	TBuf8<sizeof(KCookieDomainSeparator)> separator;

    separator.Append( KCookieDomainSeparator );

	if ( aHostName.Find( separator ) == KErrNotFound )

		{

		HBufC8* newHostName = HBufC8::NewL( aHostName.Length() +

							KCookieLocalHostNamePostfix().Length() );

		TPtr8 newHostNameDes( newHostName->Des() );

		newHostNameDes.Copy( aHostName );

		newHostNameDes.Append( KCookieLocalHostNamePostfix() );

		aEffectiveHostName = newHostName;

		hostNameChanged = ETrue;

		}

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::EffectiveHostName" ) ) );

	return hostNameChanged;

	}

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

// CCookieArray::GetCookies

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

//

TInt CCookieArray::GetCookies( const TDesC8& aRequestUri,

							   RPointerArray<CCookie>& aCookies )

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::GetCookies for an URI" ) ) );

	TUriParser8 uriParser;

	TInt err = uriParser.Parse( aRequestUri );

	if ( !err )

		{

        // first get the details of the current requestUri,

        // that is, Domain, Path and port

		TPtrC8 requestPath( uriParser.IsPresent( EUriPath ) ?

							uriParser.Extract( EUriPath ) : KNullDesC8() );

		TPtrC8 requestDomain( uriParser.IsPresent( EUriHost ) ?

							uriParser.Extract( EUriHost ) : KNullDesC8() );

		TPtrC8 requestPort( uriParser.IsPresent( EUriPort ) ?

				uriParser.Extract( EUriPort ) : KCookieDefaultRequestPort() );

		TPtrC8 requestScheme( uriParser.IsPresent( EUriScheme ) ?

							uriParser.Extract( EUriScheme ) : KNullDesC8() );

		// now check the existing cookies

        // remove expired ones first, if there are any

        RemoveExpired();

        // and finally, find the cookies...

        TInt count = iCookies.Count();

		for ( TInt i = 0; i < count && err == KErrNone; i++ )

			{

			// Does the cookie have Path attribute?

			TPtrC8 cookiePath;

			if ( !GetFoldedCookieAttr( *iCookies[i],

										CCookie::EPath,

										cookiePath ) )

				{

				continue;

				}

			// Does the cookie have Domain attribute?

			TPtrC8 cookieDomain;

			if ( !GetFoldedCookieAttr( *iCookies[i],

										CCookie::EDomain,

										cookieDomain ) )

				{

				continue;

				}

			TPtrC8 cookiePort;

			GetFoldedCookiePortAttr( *iCookies[i], cookiePort );

			if ( PathMatch( requestPath, cookiePath ) &&

                DomainMatch( requestDomain, cookieDomain, ETrue ) &&

				PortMatch( requestPort, cookiePort ) &&

				SecureMatch( requestScheme, *iCookies[i] ) )

				{

				err = aCookies.Append( iCookies[i] );

				}

			}

        aCookies.Sort( TLinearOrder<CCookie> (CCookieArray::CompareCookiesPath) );

		}

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::GetCookies  for an URI" ) ) );

	return err;

	}

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

// CCookieArray::GetCookies

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

//

TInt CCookieArray::GetCookies( RPointerArray<CCookie>& aCookieArray )

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::GetCookies" ) ) );

	TInt err = KErrNone;

    // Remove expired ones first, if there is any...

    RemoveExpired();

	TInt count = iCookies.Count();

	for ( TInt i = 0; i < count && err == KErrNone; i++ )

		{

		err = aCookieArray.Append( iCookies[i] );

		}

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::GetCookies" ) ) );

    return err;

	}

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

// CCookieArray::operator[]

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

//

const CCookie* CCookieArray::operator[](TInt aIndex) const

    {

    return iCookies[aIndex];

    }

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

// CCookieArray::At

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

//

const CCookie* CCookieArray::At(TInt aIndex) const

    {

    return iCookies[ aIndex ];

    }

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

// CCookieArray::DoesAlreadyExists

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

//

TBool CCookieArray::DoesAlreadyExists( const CCookie* aCookie,

                                       TInt& aIndex ) const

    {

    CLOG( ( ECookieArray, 0,

			_L( "->CCookieArray::DoesAlreadyExists" ) ) );

    TBool  result( EFalse );

    TInt i(0);

    TInt count( iCookies.Count() );

    for( i = 0; i< count; i++ )

        {

        // first check their names, case-sensitive

        if ( CompareAttribute( aCookie, iCookies[ i ],

                               CCookie::EName, EFalse ) == 0 )

            {

            // their NAME-s are EQUAL

            // now shall check their DOMAIN, case-insensitive (F)

            if ( CompareAttribute( aCookie, iCookies[ i ],

                                   CCookie::EDomain, ETrue ) == 0 )

                {

                // their DOMAIN is matching

                // now check Path, case-sensitive

                if ( CompareAttribute( aCookie, iCookies[ i ],

                                       CCookie::EPath, EFalse ) == 0 )

                    { // their path is the same, too

                    // so it already exists, should OVERWRITE!!!!!!!!

                    result = ETrue;

                    aIndex = i;

                    }

                }

            }

        }

    CLOG( ( ECookieArray, 0,

			_L( "<- CCookieArray::DoesAlreadyExists" ) ) );

    return result;

    }

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

// CCookieArray::CookieArray

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

//

RPointerArray<CCookie>& CCookieArray::CookieArray()

    {

    return iCookies;

    }

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

// CCookieArray::GetFoldedCookieAttr

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

//

TBool CCookieArray::GetFoldedCookieAttr( const CCookie& aCookie,

										 CCookie::TCookieAttributeName aAttr,

										 TPtrC8& aAttrDes ) const

	{

    CLOG( ( ECookieArray, 0,

			_L( "-> CCookieArray::GetFoldedCookieAttr" ) ) );

	TBool result = EFalse;

	THTTPHdrVal attrVal;

	if ( aCookie.Attribute( aAttr, attrVal ) == KErrNone )