/*

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

*

*/

// INCLUDE FILES

#include "HttpCacheHandler.h"

#include "HttpCacheEntry.h"

#include "HttpCacheLookupTable.h"

#include "HttpCacheStreamHandler.h"

#include "HttpCacheUtil.h"

#include "HttpCacheEvictionHandler.h"

#include "HttpCacheObserver.h"

#include "HttpCacheFileWriteHandler.h"

#include <http/RHTTPTransaction.h>

#include <http/rhttpsession.h>

#include <http/rhttpheaders.h>

#include <HttpStringConstants.h>

#include <httperr.h>

#include <s32file.h>

#include <s32mem.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

//#define __USE_VALIDATION_FILES__

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

void PanicCacheHandler(

    TInt aError)

    {

    _LIT(KCachePanic, "cacheHandler Panic");

    User::Panic( KCachePanic, aError );

    }

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

THttpCachePostponeParameters::THttpCachePostponeParameters()

    {

    iEnabled = ETrue;               // Postpone enabled always

    iFreeRamThreshold = 6*1024*1024;    // 6MB free required

    iImmediateWriteThreshold = 0;   // Items below this size always written immediately

    iWriteTimeout = 30000000;        // 45s timeout

    }

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

// CHttpCacheHandler::CHttpCacheHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CHttpCacheHandler::CHttpCacheHandler( TInt aSize )

    : iSize( aSize )

    {

    }

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

// CHttpCacheHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpCacheHandler::ConstructL(

    const TDesC& aDirectory,

    const TDesC& aIndexFile,

    TInt aCriticalLevel,

    const THttpCachePostponeParameters& aPostpone)

    {

    User::LeaveIfError(iRfs.Connect());

    //

    iIndexFile = aIndexFile.AllocL();

    //

    iDirectory = aDirectory.AllocL();

    //1. Set up top-level cache directory if it doesn't exist.

    TEntry entry;

    TInt err( KErrNone );

    if ( iRfs.Entry(iDirectory->Des(), entry) != KErrNone )

        {

        err = iRfs.MkDirAll( iDirectory->Des() );

        }

    //2. Create subdirectories to store header/body files

    if ( err == KErrNone || err == KErrAlreadyExists ) { //harmless errors

        __ASSERT_DEBUG ( (iDirectory->Des().LocateReverse( KPathDelimiter ) == (iDirectory->Des().Length() - 1)),

                PanicCacheHandler( KErrCorrupt ) ); // We assume that iDirectory is terminated by a forward slash

        HBufC* subDir = HBufC::NewL(KMaxPath); // Base cache dir + subdir name + another delimiter

        _LIT(KFormat,"%S%x%c");

        for ( TUint i = 0; i < KCacheSubdirCount; i++ )

            {

            TPtrC ptr ( iDirectory->Des() );

            subDir->Des().Format( KFormat, &ptr, i, KPathDelimiter );

            TInt err2 = iRfs.MkDir( subDir->Des() );

            __ASSERT_DEBUG ( (err2 == KErrNone || err2 == KErrAlreadyExists), PanicCacheHandler( err2 ) );

            }

        delete subDir;

        //end cache dir + subdir creation

    } else {

        User::Leave(err);

    }

    // set path for the entries

    iRfs.SetSessionPath( aDirectory );

    //

    iEvictionHandler = CHttpCacheEvictionHandler::NewL();

    //

    iStreamHandler = CHttpCacheStreamHandler::NewL( iDirectory->Des(), aCriticalLevel, iRfs );

    //

    if ( aPostpone.iEnabled )

        {

        iPostponeHandler = CHttpCacheFileWriteHandler::NewL(this, iStreamHandler, iRfs, aPostpone);

        }

    //

    iLookupTable = CHttpCacheLookupTable::NewL( *iEvictionHandler, *iStreamHandler );

    TRAP( err, OpenLookupTableL() );

    if ( err != KErrNone )

        {

        // failed to open the lookup table, delete the old one and start again.

        delete iLookupTable;

        iLookupTable = NULL;

        iLookupTable = CHttpCacheLookupTable::NewL( *iEvictionHandler, *iStreamHandler );

        }

    //

    iHttpCacheObserver = CHttpCacheObserver::NewL(iDirectory, iIndexFile, this);

    iHttpCacheObserver->StartObserver();

    }

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

// CHttpCacheHandler::NewL

// Two-phased constructor.

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

//

CHttpCacheHandler* CHttpCacheHandler::NewL(

    TInt aSize,

    const TDesC& aDirectory,

    const TDesC& aIndexFile,

    TInt aCriticalLevel,

    const THttpCachePostponeParameters& aPostpone)

    {

    CHttpCacheHandler* self = new( ELeave ) CHttpCacheHandler( aSize );

    CleanupStack::PushL( self );

    self->ConstructL( aDirectory, aIndexFile, aCriticalLevel, aPostpone );

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

CHttpCacheHandler::~CHttpCacheHandler()

    {

#ifndef __USE_VALIDATION_FILES__

    TRAP_IGNORE( SaveLookupTableL() );

#else

    TRAPD( err, SaveLookupTableL() );

    if ( err == KErrNone && iIndexFile )

        {

        TFileName validateFile;

        GenerateValidationFilename(validateFile, iIndexFile->Des());

        // we saved the index successfully, remove the validate file marker

        iRfs.Delete(validateFile);

        }

#endif

    //

    delete iHttpCacheObserver;

    // must delete before eviction handler

    delete iPostponeHandler;

    //

    if ( iEvictionHandler )

        {

        iEvictionHandler->RemoveAll();

        }

    //

    delete iLookupTable;

    //

    delete iEvictionHandler;

    //

    delete iStreamHandler;

    //

    delete iDirectory;

    //

    delete iIndexFile;

    //

    iRfs.Close();

    }

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

// CHttpCacheHandler::RequestL

//

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

//

TInt CHttpCacheHandler::RequestL(

    RHTTPTransaction& aTrans,

    TBrCtlDefs::TBrCtlCacheMode aCacheMode,

    THttpCacheEntry& aCacheEntry )

    {

#ifdef __CACHELOG__

    HttpCacheUtil::WriteUrlToLog( 0, _L( "request item" ), aTrans.Request().URI().UriDes() );

#endif

    TInt status( KErrNotFound );

    CHttpCacheEntry* entry = NULL;

    // 0. check if we need to check cache at all (protected vs no cache mode)

    // 1. check if the url is in the cache

    // 2. check if it is complete

    // 3. see if it is useable

    // use protected item on reload

    // currently not and do not use cache for post

    if ( aCacheMode != TBrCtlDefs::ECacheModeNoCache &&

         HttpCacheUtil::MethodFromStr( aTrans.Request().Method(), aTrans.Session().StringPool() ) != EMethodPost )

        {

        // If the cacheMode is noCache then it must ignore the cached entry.

        entry = iLookupTable->Find( aTrans.Request().URI().UriDes() );

        // check if the trailing slash is missing

        if ( !entry )

            {

            TUriC8 uri = aTrans.Request().URI();

            if ( uri.Extract( EUriPath ).Length() == 0 )

                {

                CUri8* fixeduri = CUri8::NewLC( uri );

                fixeduri->SetComponentL( _L8("/"), EUriPath );

                //

                entry = iLookupTable->Find( fixeduri->Uri().UriDes() );

                //

                CleanupStack::PopAndDestroy(); // fixeduri

                }

            }

        //

        if ( entry && entry->State() == CHttpCacheEntry::ECacheComplete )

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLog( 0, _L( "item is in the cache" ) );

#endif

            //

            status = CacheNeedsValidationL( *entry, aTrans, aCacheMode ) ? KErrNotReady : KErrNone;

            // entry could be invalidated at this point. check for status to make sure

            // the entry is still valid

            }

        // prepare stream for request

        if ( status == KErrNone )

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLog( 0, _L( "prepare item for sending" ) );

#endif

            // access the entry

            entry->SetState( CHttpCacheEntry::ECacheRequesting );

            entry->Accessed();

            }

        // cleanup

        if ( status == KErrNone && entry )

            {

            // save handler and entry so that

            // on next call we don't have to start a lookup again

            aCacheEntry.iCacheHandler = this;

            aCacheEntry.iCacheEntry = entry;

            }

        else

            {

            // cleanup response headers

            //

            // response is not in the cache, so remove all the response header fields

            // set by cache handler

            RHTTPHeaders responseHeaders = aTrans.Response().GetHeaderCollection();

            responseHeaders.RemoveAllFields();

            }

        }

#ifdef __CACHELOG__

    else

        {

        HttpCacheUtil::WriteLog( 0, _L( "reload or post: do not use cache" ) );

        }

    if ( status != KErrNone && entry )

        {

        HttpCacheUtil::WriteLog( 0, _L( "item needs validation" ) );

        }

    if ( !entry )

        {

        //

        HttpCacheUtil::WriteLog( 0, _L( "item is not in the cache" ) );

        }

#endif // __CACHELOG__

    return status;

    }

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

// CHttpCacheHandler::RequestHeadersL

//

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

//

TInt CHttpCacheHandler::RequestHeadersL(

    RHTTPTransaction& aTrans,

    THttpCacheEntry& aCacheEntry )

    {

    HttpCacheUtil::WriteUrlToLog( 0, _L( "request http headers" ), aTrans.Request().URI().UriDes() );

    //

    TInt status( KErrNotFound );

    CHttpCacheEntry* entry = aCacheEntry.iCacheEntry;

    //

    if ( entry && entry->State() == CHttpCacheEntry::ECacheRequesting )

        {

        // response headers should already have all the headers

        // as RequestL call adds them all.

        // no need to do much here

        // get header from file

        status = KErrNone;

#ifdef __CACHELOG__

        HttpCacheUtil::WriteLog( 0, _L( "sending http headers" ) );

#endif

        }

    return status;

    }

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

// CHttpCacheHandler::RequestNextChunkL

//

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

//

HBufC8* CHttpCacheHandler::RequestNextChunkL(

    RHTTPTransaction& aTrans,

    TBool& aLastChunk,

    THttpCacheEntry& aCacheEntry )

    {

    (void)aTrans; //suppress compiler and PC-lint warnings

    //

    HBufC8* bodyStr = NULL;

    CHttpCacheEntry* entry = aCacheEntry.iCacheEntry;

    //

    if ( entry && entry->State() == CHttpCacheEntry::ECacheRequesting )

        {

        // get next chunk

        bodyStr = iStreamHandler->NextChunkL( *entry, aLastChunk );

        }

    return bodyStr;

    }

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

// CHttpCacheHandler::RequestClosed

//

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

//

void CHttpCacheHandler::RequestClosed(

    RHTTPTransaction* aTrans,

    THttpCacheEntry& aCacheEntry )

    {

#ifdef __CACHELOG__

    if ( aTrans )

        HttpCacheUtil::WriteUrlToLog( 0, _L( "CHttpCacheHandler::RequestClosed on url =" ), aTrans->Request().URI().UriDes() );

#endif

    // Fine, make sure transaction is moved to the complete list

    CHttpCacheEntry* entry = aCacheEntry.iCacheEntry;

    if ( entry )

        {

        // normal close on a request - when the content is loaded from the cache

        if ( entry->State() == CHttpCacheEntry::ECacheRequesting )

            {

            entry->SetState( CHttpCacheEntry::ECacheComplete );

            }

        // transaction is closed without being completed

        else if ( entry->State() == CHttpCacheEntry::ECacheResponding ||

                  entry->State() == CHttpCacheEntry::ECacheDestroyed )

            {

            // remove uncompleted/destroyed entry

            DeleteCacheEntry( *entry );

            entry = NULL;

            aCacheEntry.iCacheEntry = NULL;

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLog( 0, _L( "CHttpCacheHandler::RequestClosed - uncompleted entry" ) );

#endif

            }

        else if ( entry->State() == CHttpCacheEntry::ECacheComplete )

            {

            // normal close on the request - when the content is saved to the cache

            // ResponseComplete has already been called

            // check if the stream is released

            // __ASSERT_DEBUG( !entry->CacheFilesOpened() ) , PanicCacheHandler( KErrCorrupt ) );

            }

        else

            {

            __ASSERT_DEBUG( EFalse , PanicCacheHandler( KErrCorrupt ) );

            }

        }

    }

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

// CHttpCacheHandler::AdjustResponseTime

//

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

//

void CHttpCacheHandler::AdjustResponseTime(RHTTPTransaction& aTrans)

    {

    RStringF fieldName;

    THTTPHdrVal dateValue;

    TDateTime date;

    TTime now;

    TInt err;

    TTime serverResponseTime;

    RHTTPHeaders respHeaders = aTrans.Response().GetHeaderCollection();

    RStringPool strP = aTrans.Session().StringPool();

    // Get the current time. All internet dates are GMT

    now.UniversalTime();

    // Get the date from the headers. Compare this with the response

    // GMT time. If the server time is wrong then adjust the time here.

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

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

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

        {

        serverResponseTime = 0;

        }

    else

        {

        serverResponseTime = TTime( dateValue.DateTime() );

        }

    // Implies some thing wrong with with origin server time.

    if ( now < serverResponseTime )

        {

#ifdef __CACHELOG__

        HttpCacheUtil::WriteLog( 0, _L( "Response time is less than GMT time" ) );

#endif

        // Remove the field first. It is must otherwise raw field

        // data is not modified. The cache data is written from the

        // raw field data.

        if( respHeaders.RemoveField(fieldName) == KErrNone )

            {

            dateValue.SetDateTime( now.DateTime() );

            TRAP_IGNORE( respHeaders.SetFieldL( fieldName, dateValue ) );

            }

        }

    }

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

// CHttpCacheHandler::ReceivedResponseHeadersL

//

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

//

void CHttpCacheHandler::ReceivedResponseHeadersL(

    RHTTPTransaction& aTrans,

    THttpCacheEntry& aCacheEntry )

    {

#ifdef __CACHELOG__

    HttpCacheUtil::WriteLog( 0, _L("---> CHttpCacheHandler::ReceivedResponseHeadersL"), 0);

    HttpCacheUtil::WriteUrlToLog( 0, _L( "CHttpCacheHandler::ReceivedResponseHeadersL - received http headers" ), aTrans.Request().URI().UriDes() );

#endif

    TBool protectedEntry( EFalse );

    // check if the item is cacheable

    // no item should be bigger than the 1/3 of the cache size

    if ( HttpCacheUtil::IsCacheable( aTrans, ( iSize / 3 ), protectedEntry ) )

        {

        // check if the entry is already in the cache

        CHttpCacheEntry* entry = iLookupTable->Find( aTrans.Request().URI().UriDes() );

        if ( entry )

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                       _L("CHttpCacheHandler::ReceivedResponseHeadersL"),

                                       entry->Filename(),

                                       entry->Url(),

                                       entry->BodySize(),

                                       ELogEntrySize );

#endif

            if ( entry->State() != CHttpCacheEntry::ECacheComplete )

                {

                // multiple incoming entries doh.

#ifdef __CACHELOG__