/*

* 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>

#include <uri8.h>

	// User includes

#include "cookie.h"

#include "CookieLogger.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" );

#ifdef __TEST_COOKIE_LOG__

static void LogCookieAttribute( const CCookie& aCookie, const RStringPool& aPool, TInt aId, const TDesC8& aTextName, CCookie::TCookieAttributeName aAttributeName )

    {

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

    THTTPHdrVal fieldVal;

    const TInt attribErr = aCookie.Attribute( aAttributeName, fieldVal );

    if ( attribErr == KErrNone )

        {

        switch ( fieldVal.Type() )

            {

        case THTTPHdrVal::KTIntVal:

            CLOG( ( ECookie, 0, _L8( "{%3d}  [Int]  %S = (%d)"), aId, &aTextName, fieldVal.Int() ) );

            break;

        case THTTPHdrVal::KStrFVal:

            {

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

            const TDesC8& fieldValDesC = fieldValStr.DesC();

            CLOG( ( ECookie, 0, _L8( "{%3d}  [StrF] %S = (%S)"), aId, &aTextName, &fieldValDesC ) );

            }

            break;

        case THTTPHdrVal::KStrVal:

            {

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

            const TDesC8& fieldValDesC = fieldValStr.DesC();

            CLOG( ( ECookie, 0, _L8( "{%3d}  [Str]  %S = (%S)"), aId, &aTextName, &fieldValDesC ) );

            }

            break;

        case THTTPHdrVal::KDateVal:

            {

            TDateTime date = fieldVal.DateTime();

            TBuf<40> dateTimeString;

            TTime t( date );

            TRAP_IGNORE( t.FormatL( dateTimeString, KDateFormat ) );

            TBuf8<40> dateTimeString8;

            dateTimeString8.Copy( dateTimeString );

            CLOG( ( ECookie, 0, _L8( "{%3d}  [Date] %S = (%S)"), aId, &aTextName, &dateTimeString8 ) );

            } 

            break;

        default:

            CLOG(( ECookie, 0, _L8("{%3d}  [????] %S = (%d)"), aId, &aTextName, fieldVal.Type() ));

            break;

            }

        }

    else

        {

        //CLOG( ( ECookie, 0, _L8( "{%3d}  LogCookie - absent: %S"), aId, &aTextName ) );

        }

    }

#endif

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

// CCookie::Log

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

//

void CCookie::Log( TInt aAssociatedId ) const

    {

	TInt associateId = aAssociatedId;

	CLOG( ( ECookie, 0, _L( "-> CCookie::Log() - Associate Id:%d"), associateId ) );

#ifdef __TEST_COOKIE_LOG__

    const TInt count = iAttributes.Count();

    CLOG( ( ECookie, 0, _L( "-> CCookie::Log() - %d attributes..."), count ) );

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

        {

        // Calculating/fetching size is enough to generate usable logs

        const TCookieAttribute& attrib = iAttributes[ i ];

        const TInt size = attrib.Size();

        }

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Name"), CCookie::EName );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Value"), CCookie::EValue );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Domain"), CCookie::EDomain );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Path"), CCookie::EPath );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Date"), CCookie::EDate );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Version"), CCookie::EVersion );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Expires"), CCookie::EExpires );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("MaxAge"), CCookie::EMaxAge );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Discard"), CCookie::EDiscard );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Port"), CCookie::EPort );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Secure"), CCookie::ESecure );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Comment"), CCookie::EComment );

    LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Comment URI"), CCookie::ECommentURI );

    CLOG( ( ECookie, 0, _L( "{%3d}         fromCookie2: %d, fromNetscapeVersion: %d"), aAssociatedId, FromCookie2(), FromNetscapeVersion() ) );

    CLOG( ( ECookie, 0, _L( "{%3d}         expired: %d, persists: %d, unknownVer: %d"), aAssociatedId, Expired(), Persistent(), IsUnknownVersion() ) );

    CLOG( ( ECookie, 0, _L( "<- CCookie::Log() - %d attributes..."), count ) );

#endif

    }

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

// 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::NewL

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

//

    {

    CCookie* self = new(ELeave) CCookie( aCopy.iStringPool );

    CleanupStack::PushL( self );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCookie::~CCookie

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

//

EXPORT_C CCookie::~CCookie()

	{

	// go through each attribute closing any attribute strings	

	TInt numAttributes = iAttributes.Count();

	Log();

	CLOG( ( ECookie, 0, _L( "-> CCookie::~CCookie - this: 0x%08x, numAttributes: %d"), this, numAttributes ) );

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

		{

		iAttributes[ii].Close();

		}

	iAttributes.Close();

	CLOG( ( ECookie, 0, _L( "<- CCookie::~CCookie - this: 0x%08x, count: %d"), this, numAttributes ) );

	}

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

// CCookie::AddDefaultPathL

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

//

void CCookie::AddDefaultPathL( const TUriC8& aUri )

	{

	CLOG( ( ECookie, 0, _L( "-> CCookie::AddDefaultPathL") ) );

	// 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();

    CLOG( ( ECookie, 0, _L( "<- CCookie::AddDefaultPathL") ) );

	}

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

// CCookie::AddToRequestL

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

//

EXPORT_C void CCookie::AddToRequestL( RHTTPHeaders aRequestHeaders,

									 TInt aPartIndex ) const

	{

	CLOG( ( ECookie, 0, _L( "-> CCookie::AddToRequestL") ) );

	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

		{

		CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - version is missing! - iSetCookie2: %d"), iSetCookie2 ) );

		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?

			CLOG( ( ECookie, 0, _L( "<- CCookie::AddToRequestL - KErrCorrupt!") ) );

			User::Leave( KErrCorrupt );

			}

		}

	CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding name...") ) );

	// 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 );

	CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding value...") ) );

	// 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 )

        {

        CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding domain...") ) );

		aRequestHeaders.SetParamL( cookieString,

								iStringPool.StringF( HTTP::EDomain,

													commonStringTable ),

								hVal,

								aPartIndex );

        }

	// Writing out Path attribute

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

        {

        CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding path...") ) );

		aRequestHeaders.SetParamL( cookieString,

								iStringPool.StringF( HTTP::EPath,

													commonStringTable ),

								hVal,

								aPartIndex );

        }

	// Writing out Port attribute

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

        {

        CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding port...") ) );

		aRequestHeaders.SetParamL( cookieString,

								iStringPool.StringF( HTTP::ECookiePort,

													commonStringTable ),

								hVal,

								aPartIndex );

        }

	CLOG( ( ECookie, 0, _L( "<- CCookie::AddToRequestL") ) );

	}

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

// CCookie::Attribute

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

//

EXPORT_C TInt CCookie::Attribute

							( CCookie::TCookieAttributeName aAttributeName,

								THTTPHdrVal& aAttributeVal) const

	{

	CLOG( ( ECookie, 0, _L( "-> CCookie::Attribute") ) );

	TCookieAttribute attribute;

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

		{

		aAttributeVal = attribute.Value();

		CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute") ) );

		return KErrNone;

		}

	CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute") ) );

	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

	{

	CLOG( ( ECookie, 0, _L( "-> CCookie::Attribute ") ) );

	TCookieAttribute attribute;

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

		{

		aAttributeVal = attribute.Value();

		aDefaulted = attribute.Defaulted();

		CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute KErrNone") ) );

		return KErrNone;

		}

	CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute KErrNotFound") ) );

	return KErrNotFound;

	}

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

// CCookie::SetAttribute

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

//

TInt CCookie::SetAttribute(  TCookieAttributeName aAttributeName,

							const THTTPHdrVal& aAttributeVal,

							TBool aDefaulted )

{

    CLOG( ( ECookie, 0, _L( "-> CCookie::SetAttribute") ) );

	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();

			}

		}

	CLOG( ( ECookie, 0, _L( "<- CCookie::SetAttribute result: %d"),result ) );

	return result;

}

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

// CCookie::CopyFromL

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

//

    {

    CLOG( ( ECookie, 0, _L( "-> CCookie::CopyFromL ") ) );

    THTTPHdrVal attributevalue;

    TBool defaulted( EFalse );

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

        {

        if ( attributevalue.Type() != THTTPHdrVal::KStrVal )

             {

             RString correctedStringType = iStringPool.OpenStringL( attributevalue.StrF().DesC() );

             attributevalue.SetStr( correctedStringType );

             SetAttribute( EName, attributevalue, defaulted );

             correctedStringType.Close();

             const TPtrC8 pVal( attributevalue.Str().DesC() );

             CLOG( ( ECookie, 0, _L8( "CCookie::CopyFromL - attribute EName Value : %S" ), &pVal ) );

             }

        else 

            {

            SetAttribute( EName, attributevalue, defaulted );    

            }

        }

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

        {

         if ( attributevalue.Type() != THTTPHdrVal::KStrVal )

            {

            RString correctedStringType = iStringPool.OpenStringL( attributevalue.StrF().DesC() );

            attributevalue.SetStr( correctedStringType );

            SetAttribute( EValue, attributevalue, defaulted );

            correctedStringType.Close();

            const TPtrC8 pVal( attributevalue.Str().DesC() );

            CLOG( ( ECookie, 0, _L8( "CCookie::CopyFromL - attribute EValue value: %S" ), &pVal ) );

            }

         else

             {

             }

        }

        {

        }

        {

        }

        {

        }

        {