/*

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

// Symbian 2nd phase constructor can leave.

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

//

void CHttpCacheHandler::ConstructL(

    const TDesC& aDirectory,

    const TDesC& aIndexFile,

    {

    //

    iIndexFile = aIndexFile.AllocL();

    //

    iDirectory = aDirectory.AllocL();

    TEntry entry;

    TInt err( KErrNone );

        {

        }

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

            {

            }

        delete subDir;

        //end cache dir + subdir creation

    } else {

        User::Leave(err);

    }

    //

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

    iHttpCacheObserver->StartObserver();

    }

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

// CHttpCacheHandler::NewL

// Two-phased constructor.

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

//

CHttpCacheHandler* CHttpCacheHandler::NewL(

    TInt aSize,

    const TDesC& aDirectory,

    const TDesC& aIndexFile,

    {

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

    CleanupStack::PushL( self );

    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 )

    {

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

            {

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

                {

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

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

                //

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

                //

                CleanupStack::PopAndDestroy(); // fixeduri

                }

            }

        //

            {

#ifdef __CACHELOG__

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

            //

            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

            {

#ifdef __CACHELOG__

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

#endif

            }

        // cleanup

            {

            // 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( "item needs validation" ) );

        }

        {

        //

        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;

    //

        {

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

        }

    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;

    //

        {

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