/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 HttpCacheUtil

*

*/

// INCLUDE FILES

#include "HttpCacheUtil.h"

#include <http/rhttpheaders.h>

#include <http/RHTTPTransaction.h>

#include <http.h>

#include <stdlib.h>

#include <string.h>

#include <stringpool.h>

#include <flogger.h>

#include "TInternetdate.h"

#include "httpfiltercommonstringsext.h"

#include "HttpCacheEntry.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

_LIT8( KHttpNewLine, "\r\n" );

// if you change it here, change in HeadersToBufferL too

_LIT8( KHttpFieldSeparator, ": " );

_LIT8( KHttpValueSep, "," );

const TInt KMaxHeaderStrLen = 1024;

_LIT8( KHttpContentType, "Content-Type" );

#ifdef __CACHELOG__

_LIT( KDateString,"%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B");

_LIT( KHttpCacheGeneralFileName, "cachehandler.txt" );

_LIT( KHttpCacheHashFileName, "hash.txt" );

const TInt KCurrentLogLevel = 0;

#endif // __CACHELOG__

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

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

// HttpCacheUtil::SetEntryOnTransL

//

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

//

void HttpCacheUtil::SetEntryOnTransL(

    CHttpCacheEntry& aEntry,

    RHTTPTransaction& aTrans,

    RStringF& aCacheEntryStr )

    {

    RHTTPTransactionPropertySet propSet = aTrans.PropertySet();

    // set transaction property with the event handler callback functions' pointer

    THTTPHdrVal tokenVal = (TInt)(CHttpCacheEntry*)&aEntry;

    aTrans.PropertySet().RemoveProperty( aCacheEntryStr );

    aTrans.PropertySet().SetPropertyL( aCacheEntryStr, tokenVal );

    }

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

// HttpCacheUtil::EntryOnTransL

//

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

//

CHttpCacheEntry* HttpCacheUtil::EntryOnTransL(

    RHTTPTransaction& aTrans,

    RStringF& aCacheEntryStr )

    {

    //

    CHttpCacheEntry* entry = NULL;

    //

    THTTPHdrVal entryPtr;

    RHTTPTransactionPropertySet propSet = aTrans.PropertySet();

    // this is a transaction, already forwarded to download manager

    if( propSet.Property( aCacheEntryStr, entryPtr ) )

        {

        entry = REINTERPRET_CAST( CHttpCacheEntry*, entryPtr.Int() );

        }

    return entry;

    }

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

// HttpCacheUtil::HeadersToBufferLC

//

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

//

HBufC8* HttpCacheUtil::HeadersToBufferLC(

    RHTTPHeaders& aHttpHeaders,

    RStringPool& aStrP )

    {

    // Get an iterator for the collection of response headers

    HBufC8* headerString = HBufC8::NewL( KMaxHeaderStrLen );

    TPtr8 headerPtr( headerString->Des() );

    TInt newLength( 0 );

    THTTPHdrFieldIter it = aHttpHeaders.Fields();

    while( it.AtEnd() == EFalse )

        {

        TPtrC8 rawData;

        // Get name of next header field

        RStringTokenF fieldName = it();

        RStringF fieldNameStr = aStrP.StringF( fieldName );

        aHttpHeaders.GetRawField( fieldNameStr, rawData );

        newLength+=( fieldNameStr.DesC().Length() + KHttpFieldSeparator().Length() + rawData.Length() +

            KHttpNewLine().Length() );

        if( headerPtr.MaxLength() < newLength )

            {

            // realloc

            HBufC8* temp = HBufC8::New( newLength + KMaxHeaderStrLen );

            if( !temp )

                {

                delete headerString;

                User::LeaveNoMemory();

                }

            temp->Des().Copy( headerPtr );

            delete headerString;

            headerString = temp;

            headerPtr.Set( headerString->Des() );

            }

        // append

        headerPtr.Append( fieldNameStr.DesC() );

        headerPtr.Append( KHttpFieldSeparator );

        headerPtr.Append( rawData );

        headerPtr.Append( KHttpNewLine );

        ++it;

        }

    CleanupStack::PushL( headerString );

    return headerString;

    }

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

// HttpCacheUtil::BufferToHeadersL

//

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

//

void HttpCacheUtil::BufferToHeadersL(

    const TDesC8& aHeaderStr,

    RHTTPHeaders& aHttpHeaders,

    RStringPool& aStrP )

    {

    // take header str line by line

    TInt sepPos( 0 );

    TInt lineEnd( 0 );

    TPtrC8 headerStr( aHeaderStr );

    while( lineEnd != KErrNotFound )

        {

        lineEnd = headerStr.Find( KHttpNewLine );

        sepPos = headerStr.Find( KHttpFieldSeparator );

        if( lineEnd != KErrNotFound && sepPos != KErrNotFound &&

            lineEnd > sepPos )

            {

            // ETag: "9be043c1-175-793-41419a44"

            TPtrC8 line( headerStr.Left( lineEnd ) );

            // ETag

            TPtrC8 key( line.Left( sepPos ) );

            // "9be043c1-175-793-41419a44"

            TInt sepEnd( sepPos + KHttpFieldSeparator().Length() );

            TPtrC8 value( line.Mid( sepEnd ) );

            // add it to the http header

            RStringF nameStr = aStrP.OpenFStringL( key );

            CleanupClosePushL( nameStr );

            // remove if exists

            THTTPHdrVal headerValue;

            if( aHttpHeaders.GetField( nameStr, 0, headerValue ) == KErrNone )

                {

                //

                aHttpHeaders.RemoveField( nameStr );

                }

            TRAPD( err, aHttpHeaders.SetRawFieldL( nameStr, value, KHttpValueSep ) );

            // leave OOM only

            if( err == KErrNoMemory )

                {

                User::Leave( err );

                }

            CleanupStack::PopAndDestroy(); // namestr

            // move string to the end of the line

            headerStr.Set( headerStr.Mid( lineEnd + KHttpNewLine().Length() ) );

            }

        }

    }

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

// HttpCacheUtil::BodyToBufferL

//

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

//

HBufC8* HttpCacheUtil::BodyToBufferL(

    MHTTPDataSupplier& aBodySupplier )

    {

    // get it from the transaction

    TPtrC8 ptr;

    aBodySupplier.GetNextDataPart( ptr );

    //

    return ptr.AllocL();

    }

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

// HttpCacheUtil::MergeHeadersLC

//

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

//

HBufC8* HttpCacheUtil::MergeHeadersLC(

    const TDesC8& aCachedHeaderStr,

    RHTTPHeaders& aResponseHeaders,

    RStringPool& aStrP )

    {

    // FYI: it uses the response header to merge

    // take header str line by line

    TInt sepPos( 0 );

    TInt lineEnd( 0 );

    TPtrC8 headerStr( aCachedHeaderStr );

    while( lineEnd != KErrNotFound )

        {

        lineEnd = headerStr.Find( KHttpNewLine );

        sepPos = headerStr.Find( KHttpFieldSeparator );

        if( lineEnd != KErrNotFound && sepPos != KErrNotFound &&

            lineEnd > sepPos )

            {

            // ETag: "9be043c1-175-793-41419a44"

            TPtrC8 line( headerStr.Left( lineEnd ) );

            // ETag

            TPtrC8 key( line.Left( sepPos ) );

            // "9be043c1-175-793-41419a44"

            TInt sepEnd( sepPos + KHttpFieldSeparator().Length() );

            TPtrC8 value( line.Mid( sepEnd ) );

            // add it to the http header

            RStringF nameStr = aStrP.OpenFStringL( key );

            CleanupClosePushL( nameStr );

            // avoid corrupted content type from the stack in case of 304

            if(key == KHttpContentType)

                {

                aResponseHeaders.RemoveField(nameStr);

                }

            THTTPHdrVal tempVal;

            // add this field unless it already exists

            if( aResponseHeaders.GetField( nameStr, 0, tempVal ) == KErrNotFound )

                {

                TRAPD( err, aResponseHeaders.SetRawFieldL( nameStr, value, KHttpValueSep ) );

                // leave OOM only

                if( err == KErrNoMemory )

                    {

                    User::Leave( err );

                    }

                }

            CleanupStack::PopAndDestroy(); // namestr

            // move string to the end of the line

            headerStr.Set( headerStr.Mid( lineEnd + KHttpNewLine().Length() ) );

            }

        }

    // we've got the merged headers, let's covert it to buffer

    return HeadersToBufferLC( aResponseHeaders, aStrP );

    }

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

// HttpCacheUtil::AddHeaderLC

//

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

//

HBufC8* HttpCacheUtil::AddHeaderLC(

    const TDesC8& aName,

    const TDesC8& aValue,

    const TDesC8& aHeaders )

    {

    HBufC8* newHeaders = NULL;

    // first check if the header exists so

    // then all we need to do is to update the value

    TInt pos( aHeaders.FindF( aName ) );

    //

    newHeaders = HBufC8::NewLC( aHeaders.Length() + aName.Length() + KHttpFieldSeparator().Length() +

        aValue.Length() + KHttpNewLine().Length() );

    //

    if( pos != KErrNotFound )

        {

        // replace old header with this new one

        TPtr8 newHeadersPtr( newHeaders->Des() );

        // copy headers

        newHeadersPtr.Copy( aHeaders );

        // check what we need to replace

        TPtrC8 leftover( aHeaders.Mid( pos ) );

        // headers are terminated by \r\n

        TInt endPos( leftover.Find( KHttpNewLine ) );

        if( endPos != KErrNotFound )

            {

            // value pos

            TInt valuePos( pos + aName.Length() + KHttpFieldSeparator().Length() );

            newHeadersPtr.Replace( valuePos, pos + endPos - valuePos, aValue );

            }

        }

    else

        {

        // add new header

        // new header = old header\r\n aName: aValue\r\n

        TPtr8 newHeadersPtr( newHeaders->Des() );

        // old headers

        newHeadersPtr.Copy( aHeaders );

        // Cache Control

        newHeadersPtr.Append( aName );

        // :

        newHeadersPtr.Append( KHttpFieldSeparator );

        // max age=180

        newHeadersPtr.Append( aValue );

        // \r\n

        newHeadersPtr.Append( KHttpNewLine );

        }

    return newHeaders;

    }

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

// HttpCacheUtil::HeaderFieldFromBufferLC

//

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

//

HBufC8* HttpCacheUtil::HeaderFieldFromBufferLC(

    const TDesC8& aHeaders,

    const TDesC8& aKey )

    {

    HBufC8* value = NULL;

    //

    TInt pos( aHeaders.Find( aKey ) );

    if( pos != KErrNotFound )

        {

        // line: Cache-Control: max-age=180

        TPtrC8 linePtr = aHeaders.Mid( pos );

        // line end \r\n

        TInt lineEnd( linePtr.Find( KHttpNewLine ) );

        // separator :

        TInt sepPos( linePtr.Find( KHttpFieldSeparator ) );

        //

        if( sepPos != KErrNotFound )

            {

            // fix line end

            lineEnd = lineEnd == KErrNotFound ? linePtr.Length(): lineEnd;

            // max-age=180

            TInt valueLen( lineEnd - ( sepPos + KHttpFieldSeparator().Length() ) );

            value = HBufC8::NewLC( valueLen );

            value->Des().Copy( linePtr.Mid( sepPos + KHttpFieldSeparator().Length(), valueLen ) );

            }

        }

    return value;

    }

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

// HttpCacheUtil::MethodFromStr

//

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

//

TCacheLoadMethod HttpCacheUtil::MethodFromStr(

    RStringF aMethodStr,

    RStringPool aStrP )

    {

    if( aMethodStr == aStrP.StringF( HTTP::EGET, RHTTPSession::GetTable() ) )

        {

        return EMethodGet;

        }

    if( aMethodStr == aStrP.StringF(HTTP::ECONNECT, RHTTPSession::GetTable() ) )

        {

        return EMethodConnect;

        }

    if( aMethodStr == aStrP.StringF(HTTP::EDELETE, RHTTPSession::GetTable() ) )

        {

        return EMethodDelete;

        }

    if( aMethodStr == aStrP.StringF(HTTP::EHEAD, RHTTPSession::GetTable() ) )

        {

        return EMethodHead;

        }

    if( aMethodStr == aStrP.StringF(HTTP::EOPTIONS, RHTTPSession::GetTable() ) )

        {

        return EMethodOptions;

        }

    if( aMethodStr == aStrP.StringF(HTTP::EPUT, RHTTPSession::GetTable() ) )

        {

        return EMethodPut;

        }

    if( aMethodStr == aStrP.StringF(HTTP::EPOST, RHTTPSession::GetTable() ) )

        {

        return EMethodPost;

        }

    if( aMethodStr == aStrP.StringF(HTTP::ETRACE, RHTTPSession::GetTable() ) )

        {

        return EMethodTrace;

        }

    return EMethodGet;

    }

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

// HttpCacheUtil::ProtectedEntry

//

// Returns true if the entry is protected

//

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

//

TBool HttpCacheUtil::ProtectedEntry(

    RHTTPHeaders& aHttpHeaders,

    RStringPool& aStrP )

    {

    TBool protectedEntry( EFalse );

    //

    THTTPHdrVal contType;

    RStringF fieldName = aStrP.StringF( HTTP::EContentType, RHTTPSession::GetTable() );

    //

    if( aHttpHeaders.GetField( fieldName, 0, contType ) == KErrNone )

        {

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

            {

            RStringF fieldValStr = aStrP.StringF( contType.StrF() );

            // css and javascrip are protected entries

            protectedEntry = fieldValStr.DesC().Find( _L8("text/css") ) != KErrNotFound ||

                fieldValStr.DesC().Find( _L8("javascript") ) != KErrNotFound;

            }

        }

    return protectedEntry;

    }

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

// HttpCacheUtil::CacheTimeIsFresh

//

// Returns true if the entry is fresh.

//

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

//

TBool HttpCacheUtil::CacheTimeIsFresh(

    const RHTTPHeaders& aRequestHeaders,

    const RHTTPHeaders& aCachedHeaders,

    RStringPool aStrP )

    {

    TInt status( KErrNone );

    TBool isFresh( EFalse );

    TInt64 freshness;

    TInt64 age;

    TInt64 maxAge;

    TInt64 minFresh;

    TInt64 maxStale;

    TTime cachedRequestTime;

    TTime cachedResponseTime;

    TTime date;

    TInt err;

    THTTPHdrVal dateValue;

    RStringF fieldName;

    // Get the date from the headers

    fieldName = aStrP.StringF( HTTP::EDate, RHTTPSession::GetTable() );

    err = aCachedHeaders.GetField( fieldName, 0, dateValue );

    if( err == KErrNotFound || dateValue.Type() != THTTPHdrVal::KDateVal )

        {

        date = 0;

        }

    else

        {

        date = TTime( dateValue.DateTime() );

        }

    cachedRequestTime = date;

    cachedResponseTime = date;

    // Get Max Age header. If maxAge = 0, then must revalidate.

    status = GetCacheControls( aCachedHeaders, &maxAge, NULL, NULL, NULL, NULL, NULL, aStrP );

    if( status == KErrNone &&  maxAge == 0 )

        {

        return EFalse; //Must revalidate

        }

    // Get the freshness and age of the cachedHeaders

    freshness = Freshness( aCachedHeaders, cachedResponseTime, aStrP );

    age = Age( aCachedHeaders, cachedRequestTime, cachedResponseTime, aStrP );

#ifdef __CACHELOG__

        TBuf<50> dateString;

        TTime fr( freshness );

        TRAP(err, fr.FormatL( dateString, KDateString ) );

        if ( err == KErrNone ) {

            HttpCacheUtil::WriteLog( 0, _L( "freshness" ) );

            HttpCacheUtil::WriteLog( 0, dateString );

            }

        TTime ca( age );

        TRAP( err, ca.FormatL( dateString, KDateString ) );

        if ( err == KErrNone ) {

            HttpCacheUtil::WriteLog( 0, _L( "age" ) );

            HttpCacheUtil::WriteLog( 0, dateString );

            }

#endif // __CACHELOG__

    // Get useful cache-control directives from the requestHeaders

    status = GetCacheControls( aRequestHeaders, &maxAge, &minFresh, &maxStale, NULL, NULL, NULL, aStrP );

    if( status == KErrNone )

        {

        // Above values for maxAge, minFresh and maxStale are in seconds

        // Convert to micro seconds before using it.

        // If maxStale is present it means that it is willing to

        // accept a response maxStale seconds after it expires.  To

        // allow this freshness is extended by maxStale seconds.