/*

* Copyright (c) 2002 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 class CCookie

*               

*

*/

// INCLUDE FILES

	// System includes

#include <httpstringconstants.h>

#include <http/rhttpheaders.h>

#include <http/rhttpsession.h>

	// User includes

#include "cookie.h"

#include "CookieCommonConstants.h"

const TUint8 KDayOfWeekSeparator    = ',';

// const TUint8 KTimeSeparator         = ':';

_LIT8 ( KUT, "UT" );

_LIT8 ( KGMT, "GMT" );

_LIT8 ( KEST, "EST" );

_LIT8 ( KEDT, "EDT" );

_LIT8 ( KCST, "CST" );

_LIT8 ( KCDT, "CDT" );

_LIT8 ( KMST, "MST" );

_LIT8 ( KMDT, "MDT" );

_LIT8 ( KPST, "PST" );

_LIT8 ( KPDT, "PDT" );

const TUint8 KLocalTimeZoneSeparator1        = '+';

const TUint8 KLocalTimeZoneSeparator2        = '-';

const TInt KDateTokenCount = 3;

const TInt KTimeTokenCount = 3;

const TInt KAsciiTokenCount = 4;

_LIT8( KLocalSeparators, " -");

_LIT8( KLocalTimeSeparator, ":");

_LIT8( KLocalMonthNames, "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec" );

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

// CCookie::NewL

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

//

EXPORT_C CCookie* CCookie::NewL( RHTTPHeaders aRequestHeaders, TInt aPartIndex,

								RStringF aFieldName, RStringPool aStringPool,

								const TUriC8& aUri )

	{

	CCookie* self = new (ELeave) CCookie( aStringPool );

	CleanupStack::PushL( self );

	self->ConstructL( aRequestHeaders, aPartIndex, aFieldName, aUri );

	CleanupStack::Pop();	// self

	return self;

	}

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

// CCookie::NewL

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

//

EXPORT_C CCookie* CCookie::NewL( RStringPool aStringPool )

	{

	return new (ELeave) CCookie( aStringPool );

	}

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

// CCookie::~CCookie

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

//

EXPORT_C CCookie::~CCookie()

	{

	// go through each attribute closing any attribute strings	

	TInt numAttributes = iAttributes.Count();

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

		{

		iAttributes[ii].Close();

		}

	iAttributes.Close();

	}

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

// CCookie::AddDefaultPathL

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

//

void CCookie::AddDefaultPathL( const TUriC8& aUri )

	{

	// RFC2965 : Defaults to the path of the request URL that generated the

	// Set-Cookie2 response, up to and including the right-most /.

	// Note : there is a contradiction as we must not include the right-most /

	// per RFC2109, which is obsolete. Decision : we support RFC2965.

	const TUint8 KCookiePathSeparator = '/';

	TPtrC8 requestPath;

	if ( aUri.IsPresent( EUriPath ) )

		{

		requestPath.Set( aUri.Extract( EUriPath ) );

		TInt sepPos = requestPath.LocateReverse( KCookiePathSeparator );

		// if / is not the last character

		if ( 0 <= sepPos && ( ( sepPos + 1 != requestPath.Length() ) ) )

			{

			// then remove characters after the right-most /

			requestPath.Set( requestPath.Left( sepPos + 1 ) );

			}

		}

	else

		{

		requestPath.Set( &KCookiePathSeparator,

						sizeof( KCookiePathSeparator ) );

		}

    RStringF defPath = iStringPool.OpenFStringL( requestPath );

    THTTPHdrVal defPathVal( defPath );

	SetAttribute( EPath, defPathVal, ETrue );// ignore the result 

    defPath.Close();

	}

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

// CCookie::AddToRequestL

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

//

EXPORT_C void CCookie::AddToRequestL( RHTTPHeaders aRequestHeaders,

									 TInt aPartIndex ) const

	{

	const TStringTable& commonStringTable = RHTTPSession::GetTable();

	// We're writing out the "Cookie:" string

	RStringF cookieString =

					iStringPool.StringF( HTTP::ECookie, commonStringTable );

	aRequestHeaders.SetFieldL( cookieString, THTTPHdrVal() );

	THTTPHdrVal hVal;

	// We're writing out the Version attribute - it is a serious error if this

	// attribute is missing

	if ( Attribute( CCookie::EVersion, hVal ) == KErrNone )

		{

		aRequestHeaders.SetParamL( cookieString, 

							iStringPool.StringF( HTTP::EVersion,

												commonStringTable ),

							hVal,

							aPartIndex );

		}

	else

		{

		if ( iSetCookie2 )

			{

			// if this is a new-style cookie (it is from a Set-Cookie2 header),

			// then it must have a Version attribute.

			// TBD : or should we insert a '$Version=1' string instead?

			User::Leave( KErrCorrupt );

			}

		}

	// We're writing out the NAME attribute - it is a serious error if this

	// attribute is missing

	User::LeaveIfError( Attribute( CCookie::EName, hVal ) );

	aRequestHeaders.SetParamL( cookieString,

							iStringPool.StringF( HTTP::ECookieName,

												commonStringTable ), 

							hVal,

							aPartIndex );

	// We're writing out the VALUE attribute - it is a serious error if this

	// attribute is missing

	User::LeaveIfError( Attribute( CCookie::EValue, hVal ) );

	aRequestHeaders.SetParamL( cookieString,

							iStringPool.StringF( HTTP::ECookieValue,

												commonStringTable ),

							hVal,

							aPartIndex );

	// Writing out the rest : domain, path and port. These are not mandatory,

	// thus we do not leave if they are missing.

	// Writing out Domain attribute

	if ( Attribute( CCookie::EDomain, hVal ) == KErrNone && hVal.StrF().DesC().Length() > 0 )

        {

		aRequestHeaders.SetParamL( cookieString,

								iStringPool.StringF( HTTP::EDomain,

													commonStringTable ),

								hVal,

								aPartIndex );

        }

	// Writing out Path attribute

	if ( Attribute( CCookie::EPath, hVal ) == KErrNone )

        {

		aRequestHeaders.SetParamL( cookieString,

								iStringPool.StringF( HTTP::EPath,

													commonStringTable ),

								hVal,

								aPartIndex );

        }

	// Writing out Port attribute

	if ( Attribute( CCookie::EPort, hVal ) == KErrNone )

        {

		aRequestHeaders.SetParamL( cookieString,

								iStringPool.StringF( HTTP::ECookiePort,

													commonStringTable ),

								hVal,

								aPartIndex );

        }

	}

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

// CCookie::Attribute

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

//

EXPORT_C TInt CCookie::Attribute

							( CCookie::TCookieAttributeName aAttributeName,

								THTTPHdrVal& aAttributeVal) const

	{

	TCookieAttribute attribute;

	if ( FindAttribute( aAttributeName, attribute ) != KErrNotFound )

		{

		aAttributeVal = attribute.Value();

		return KErrNone;

		}

	return KErrNotFound;

	}

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

// CCookie::SetAttribute

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

//

EXPORT_C TInt CCookie::SetAttribute

							( CCookie::TCookieAttributeName aAttributeName, 

								const THTTPHdrVal& aAttributeVal )

	{

	return SetAttribute( aAttributeName, aAttributeVal, EFalse );

	}

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

// CCookie::Attribute

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

//

TInt CCookie::Attribute( TCookieAttributeName aAttributeName,

						 THTTPHdrVal& aAttributeVal,

						 TBool& aDefaulted ) const

	{

	TCookieAttribute attribute;

	if ( FindAttribute( aAttributeName, attribute ) != KErrNotFound )

		{

		aAttributeVal = attribute.Value();

		aDefaulted = attribute.Defaulted();

		return KErrNone;

		}

	return KErrNotFound;

	}

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

// CCookie::SetAttribute

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

//

TInt CCookie::SetAttribute(  TCookieAttributeName aAttributeName,

							const THTTPHdrVal& aAttributeVal,

							TBool aDefaulted )

{

	TInt result( KErrNone );

	TCookieAttribute attribute;

	TInt index = FindAttribute( aAttributeName, attribute );

	if ( index != KErrNotFound )

		{

		result = KErrAlreadyExists;

		}

	else

		{

		TCookieAttribute newAttribute( aAttributeName, 

									   aAttributeVal, aDefaulted );

		result = iAttributes.Append( newAttribute );

		if ( result == KErrNone )

			{

			iSize += ( KCookieAttributePrefixLength + newAttribute.Size() + 

                       KCookieAttributeDefaultedLength + 

                       KCookieAttributeFoundLength );

			}

		else

			{

			newAttribute.Close();

			}

		}

	return result;

}

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

// CCookie::CopyFromL

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

//

void CCookie::CopyFromL( const CCookie& aCopyFrom  )

    {

	THTTPHdrVal attributevalue;

    TBool aDefaulted( EFalse );

    if ( aCopyFrom.Attribute( EName, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EName, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EValue, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EValue, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EComment, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EComment, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( ECommentURI, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( ECommentURI, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EDiscard, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EDiscard, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EDomain, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EDomain, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EMaxAge, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EMaxAge, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EPath, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EPath, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EPort, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EPort, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( ESecure, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( ESecure, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EVersion, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EVersion, attributevalue, aDefaulted );

        }

	if ( aCopyFrom.Attribute( EExpires, attributevalue, aDefaulted ) != KErrNotFound )

        {

        SetAttribute( EExpires, attributevalue, aDefaulted );

        }

    SetCookie2( aCopyFrom.FromCookie2() );

    }

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

// CCookie::StringPool

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

//

RStringPool CCookie::StringPool()

    {

    return iStringPool;

    }

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

// CCookie::Expired

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

//

TBool CCookie::Expired() const

	{

    // the cookie has expired if:

    // 1. it's Age > Max-Age

    // 2. current_date > expires

    // Expires is in Netscape cookie only !!!

    TBool retval( EFalse );

	THTTPHdrVal attrVal;

    TInt err( KErrNone );

	if ( FromNetscapeVersion() && ( Attribute( CCookie::EExpires, attrVal ) == KErrNone ))

        {

	    if ( attrVal.Type() == THTTPHdrVal::KDateVal )

		    {

            TDateTime expires;

		    expires = attrVal.DateTime();

            TTime Expirytime( expires );

            TTime NowTime;

            NowTime.UniversalTime();

            if ( Expirytime <= NowTime )

                { // EXPIRED !!!!

                retval = ETrue;

                }

            }

        else

            {

		    if ( attrVal.Type() == THTTPHdrVal::KStrFVal )

                {

                TRAP_IGNORE( retval = ExpiredNetscapeL( attrVal ) );

                // The only real error is KErrNoMemory, 

                // so we simply ignore the error here

                }

            }

		}

    else

        {

        if ( Attribute( CCookie::EMaxAge, attrVal ) == KErrNone )

            {

            TInt MaxAge(0);

            if ( attrVal.Type() == THTTPHdrVal::KTIntVal )

                {

                MaxAge = attrVal.Int();

                }

            else

                {

                TPtrC8 MaxAgePtr=CCookie::RemoveQuotes( attrVal.StrF().DesC() );

                TLex8 lex( MaxAgePtr );

                err = lex.Val( MaxAge );

                }

            if ( err == KErrNone )

                {

                        // it's Age > Max-Age?

                        // Age = ( now_time - EDate )

                        // TTime.SecondsFrom(TTime)

                        // UniversalTime.SecondsFrom( EDate_time ): real age

                        TTime NowTime;

                        NowTime.UniversalTime();

                        TTimeIntervalSeconds CurrAgeInterval;

                        err = NowTime.SecondsFrom( iReceivedTime, CurrAgeInterval );

                        // now compare to specified Max-Age

                        if ( MaxAge <= CurrAgeInterval.Int() )

                            { // EXPIRED !!!!

                            retval = ETrue;

                            }

                }

			}

		}

	return retval;

	}

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

// CCookie::RemoveQuotes

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

//

 TPtrC8 CCookie::RemoveQuotes( const TDesC8& aDes ) 

	{

	TInt firstChar = 0;					// position of the first character

	TInt lastChar = aDes.Length() - 1;	// position of the last character

	TPtrC8 result;

	if ( lastChar < 0 )	// that is, aDes has a length of zero

		{

		result.Set( aDes );	// the result is the same

		}

	else

		{

		TUint8 quotationMark = '"';

		if ( aDes[ firstChar ] == quotationMark )

			{

			firstChar++;

			}

		if ( aDes[ lastChar ] == quotationMark )

			{

			lastChar--;

			}

		if ( lastChar < firstChar )

			{

			result.Set( KNullDesC8() );

			}

		else

			{

			result.Set( aDes.Mid( firstChar, lastChar - firstChar + 1 ) );

			}

		}

    return result;

	}

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

// CCookie::ExpiredNetscapeL