/*

* 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 "HttpCacheManager.h"

#include "HttpCacheEntry.h"

#include "HttpCacheLookupTable.h"

#include "HttpCacheStreamHandler.h"

#include "HttpCacheUtil.h"

#include "HttpCacheEvictionHandler.h"

#include "HttpCacheObserver.h"

#include <http/RHTTPTransaction.h>

#include <http/rhttpsession.h>

#include <http/rhttpheaders.h>

#include <HttpStringConstants.h>

#include <httperr.h>

#include <s32file.h>

#include <BrCtlDefs.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

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

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

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

    {

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

    //

    iIndexFile = aIndexFile.AllocL();

    //

    iDirectory = aDirectory.AllocL();

    //

    iEvictionHandler = CHttpCacheEvictionHandler::NewL();

    //

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

    //

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

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

    }

    OpenLookupTableL();

    //

    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)

    {

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

    CleanupStack::PushL( self );

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

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHttpCacheHandler::~CHttpCacheHandler()

    {

        TRAP_IGNORE( SaveLookupTableL() );

    //

    delete iHttpCacheObserver;

    //

    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 )

    {

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

    //

    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

            // attach entry to the stream

            if( iStreamHandler->AttachL( *entry ) )

                {

                entry->SetState( CHttpCacheEntry::ECacheRequesting );

                entry->Accessed();

                }

            else

                {

                // cleanup on the corrupt entry

                HandleCorruptEntry( *entry );

                entry = NULL;

                // item is not in cache

                status = KErrNotFound;

                }

            }

        // 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: do not use cache" ) );

        }

    if( status != KErrNone && entry )

        {

        //

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

        }

    else

        {

        //

        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 )

    {

    if (aTrans)

        HttpCacheUtil::WriteUrlToLog( 0, _L( "Request is closed" ), aTrans->Request().URI().UriDes() );

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

            iStreamHandler->Detach( *entry );

            }

        // transaction is closed without being completed

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

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

            {

            // remove uncompleted/destroyed entry

            iStreamHandler->Detach( *entry );

            HandleCorruptEntry( *entry );

            entry = NULL;

            aCacheEntry.iCacheEntry = NULL;

#ifdef __CACHELOG__

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

#endif

            }

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

            {

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

            // ResponseComplete has already been called

            // check if the stream is released

            __ASSERT_DEBUG( !iStreamHandler->Find( *entry ) , 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::WriteUrlToLog( 0, _L( "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::WriteUrlToLog( 0, _L( "item is already in the cache" ), entry->Url() );

#endif            

            //

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

                {

                // multiple incoming entries? doh.

#ifdef __CACHELOG__

                HttpCacheUtil::WriteLog( 0, _L( "MULTIPLE REQUEST!!!!!!!!!!!!!!!!!!!!!!!!!" ) );

#endif                

                // __ASSERT_DEBUG( EFalse, PanicCacheHandler( KErrCorrupt ) );

                // ignore this one and the first will proceed.

                entry = NULL;

                }

            }

        else

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLog( 0, _L( "create new cache item" ) );

#endif

            //Check adjustment of response time is required or not.

            AdjustResponseTime( aTrans );

            // hash it

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

            if( entry )

                {

                // protect this entry

                if( protectedEntry )

                    {

#ifdef __CACHELOG__

                    HttpCacheUtil::WriteLog( 0, _L( "this item is protected" ) );

#endif

                    //

                    entry->SetProtected();

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

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

                    // double expiration time

                    HttpCacheUtil::AdjustExpirationTimeL( responseHeaders, strP );

                    }

                }

            else

                {

                // no luck with the lookuptable

                __ASSERT_DEBUG( EFalse, PanicCacheHandler( KErrCorrupt ) );

                }

            }

        // save headers

        if( entry )

            {

            // attach it to the stream handler

            if( iStreamHandler->AttachL( *entry ) )

                {

                entry->SetState( CHttpCacheEntry::ECacheResponding );

                // 1. handle only 304 and 200

                // 2. check if either the header or the body ( or both ) need to be updated

                // 3. update the headers anyway in case of notmodified (304)

                // 4. remove the old body in case of bodyupdate

                TInt httpStatus( aTrans.Response().StatusCode() );

#ifdef __CACHELOG__

                HttpCacheUtil::WriteLog( 0, _L( "status code: " ), httpStatus );