/*

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

*

*/

// INCLUDE FILES

#include "HttpCacheHandler.h"

#include "HttpCacheUtil.h"

#include "HttpCacheFileWriteHandler.h"

#include <CenRepNotifyHandler.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <centralrepository.h>

#include <FeatMgr.h>

#include <http/RHTTPTransaction.h>

#include <SysUtilDomainCRKeys.h>

#include <eikenv.h>

#include <f32file.h>

#include <e32hashtab.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// kbyte

const TUint KDefaultCacheSize = 1048576; // 1MB = 1024*1024

const TUint KDefaultOperatorCacheSize = 300*1024; // 300KB

_LIT( KDefaultCacheDrive, "c");

_LIT( KDefaultCacheDir, "c:\\system\\cache\\");

_LIT( KDefaultOperatorCacheDir, "c:\\system\\cache\\");

_LIT( KDefaultVssCacheDir, "c:\\system\\cache\\vss\\");

_LIT( KDefaultIndexFile, "index.dat" );

_LIT( KDefaultOpIndexFile, "index_op.dat" );

_LIT( KDefaultVSSIndexFile, "index_vss.dat" );

_LIT( KIndexFileExtension, ".dat" );

_LIT( KCrashCheck, "browser.val");

_LIT( KValidationFileExtension, ".val" );

_LIT8( KVSSHeaderFieldName, "X-Vodafone-Content" );

_LIT8( KVSSHeaderFieldValue, "Portal" );

// default override string, browser gets 2MB, widgetUI gets 1MB, OVI Store gets 1MB : max 4MB.

_LIT( KDefaultOverrideString, "10008D39;1;2048;C;10282822;1;1024;C;102829A0;1;1024;C" );

// MACROS

#define KUIDBROWSERNG 0x10008D39

#define KUIDWIDGETUI 0x10282822

#define KUIDBROWSERCACHECLEANER 0x20026777

#define KUIDOPERATORMENU 0x100039CE

#define KUIDOVISTORE 0x102829A0

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

TBool IsBrowser()

    {

    RProcess process;

    TSecureId secId = process.SecureId();

    TUint32 secIdInt = secId;

    return ( secIdInt == KUIDBROWSERNG );

    }

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

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

// CHttpCacheManager::CHttpCacheManager

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

// might leave.

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

//

CHttpCacheManager::CHttpCacheManager():iCacheFolder( KDefaultCacheDir )

    {

    }

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

// CHttpCacheManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpCacheManager::ConstructL()

    {

#ifdef __CACHELOG__

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

    HttpCacheUtil::WriteLog( 0, _L("| Creating new CHttpCacheManager Instance |"), (TInt)this);

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

#endif

    CreateCacheHandlersL();

#ifdef __CACHELOG__

    HttpCacheUtil::WriteLog( 0, _L("Created cache handlers"), (TInt)this);

#endif

    // read offline mode

    if( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

        {

        // check if connection is not allowed and

        // come up with a listerner on the offline setting

        TInt connAllowed( 1 );

        iOfflineRepository = CRepository::NewL( KCRUidCoreApplicationUIs );

        iOfflineRepository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed );

        iOfflineMode = !connAllowed;

        iOfflineNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iOfflineRepository,

            CCenRepNotifyHandler::EIntKey, (TUint32)KCoreAppUIsNetworkConnectionAllowed );

        iOfflineNotifyHandler->StartListeningL();

        }

    }

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

// CHttpCacheManager::NewL

// Two-phased constructor.

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

//

EXPORT_C CHttpCacheManager* CHttpCacheManager::NewL()

    {

    CHttpCacheManager* self = new( ELeave ) CHttpCacheManager();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

CHttpCacheManager::~CHttpCacheManager()

    {

#ifdef __CACHELOG__

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

    HttpCacheUtil::WriteLog( 0, _L("| Destroying CHttpCacheManager Instance | "), (TInt)this);

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

#endif

    if( IsBrowser() )    // only enabled in browser

        {

        // delete crashcheck.dat file

        RFs rfs;

        rfs.Connect();

        rfs.SetSessionPath( iCacheFolder );

        rfs.Delete(KCrashCheck());

        rfs.Close();

        }

    delete iOfflineNotifyHandler;

    delete iOfflineRepository;

    delete iCache;

    delete iOperatorCache;

    delete iOpDomain;

    delete iphoneSpecificCache;

    delete iVSSWhiteList;

    delete iFileWriteHandler;

    }

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

// CHttpCacheManager::VSSRequestCheck

//

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

//

TBool CHttpCacheManager::VSSRequestCheckL( const RHTTPTransaction& aTrans,

                                           const RHTTPHeaders& aHttpHeader,

                                           const TDesC8& aUrl )

    {

    TBool VSSTransaction ( EFalse );

    if ( iVSSCacheEnabled && HttpCacheUtil::VSSCacheContent( aUrl, iVSSWhiteList ) )

        {

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

#ifdef __CACHELOG__

        RHTTPHeaders headers ( aHttpHeader );

        HBufC8* responseHeaderStr8 = HttpCacheUtil::HeadersToBufferLC( headers, strP );

        HBufC* responseHeaderStr;

        if( responseHeaderStr8 )

            {

            responseHeaderStr = HBufC::NewL( responseHeaderStr8->Length() );

            responseHeaderStr->Des().Copy( responseHeaderStr8->Des() );

            CleanupStack::PopAndDestroy(); //  responseHeaderStr8;

            TPtrC headerStr( responseHeaderStr->Des() );

            HttpCacheUtil::WriteLog( 0, _L("========== VSS Header Start =========\n") );

            HttpCacheUtil::WriteLog( 0, responseHeaderStr->Des() );

            HttpCacheUtil::WriteLog( 0, _L("========== VSS Header End =========\n") );

            delete responseHeaderStr;

            }

#endif

        TPtrC8 nameStr ( KVSSHeaderFieldName() );

        RStringF VSSnameStr = strP.OpenFStringL( nameStr );

        CleanupClosePushL<RStringF>( VSSnameStr);

        THTTPHdrVal tempVal;

        if ( aHttpHeader.GetField( VSSnameStr, 0, tempVal ) == KErrNone )

            {

            TPtrC8 valueStr ( KVSSHeaderFieldValue() );

            RStringF VSSValueStr = strP.OpenFStringL( valueStr );

            CleanupClosePushL<RStringF>( VSSValueStr );

            if ( tempVal == VSSValueStr )

                {

                VSSTransaction      = ETrue;

                }

            CleanupStack::PopAndDestroy(); // VSSValueStr

            }

        CleanupStack::PopAndDestroy(); // VSSnameStr

        } //end if( iVSSCacheEnabled && HttpCacheUtil::VSSCacheContent( aUrl, iVSSWhiteList ) )

    return VSSTransaction;

    }

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

// CHttpCacheManager::RequestL

//

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

//

EXPORT_C TInt CHttpCacheManager::RequestL(

    RHTTPTransaction& aTrans,

    TBrCtlDefs::TBrCtlCacheMode aCacheMode,

    THttpCacheEntry& aCacheEntry )

    {

    //

    TInt status( KErrNotFound );

    if( iCacheEnabled || iVSSCacheEnabled )

        {

        CHttpCacheHandler* cache = CacheHandler( aTrans.Request().URI().UriDes(), NULL ) ;

        // adjust cache mode in case of offline operation

        if( iOfflineMode )

            {

            aCacheMode = TBrCtlDefs::ECacheModeOnlyCache;

            }

        //

        if( cache )

            {

            status = cache->RequestL( aTrans, aCacheMode, aCacheEntry );

            // save cache handler even if the entry is not in the cache

            // so that when the response comes back, we do not need to

            // check the url

             if( status == KErrNotFound && iVSSCacheEnabled )

                {

                 status = iphoneSpecificCache->RequestL( aTrans, aCacheMode, aCacheEntry );

                 if( (status  == KErrNotReady) || (status == KErrNone ) )

                 {

                 aCacheEntry.iCacheHandler = iphoneSpecificCache;

                 }

                 else

                 {

                 // No entry found in any cache. Default to normal cache

                 aCacheEntry.iCacheHandler = cache;

                 }

                }

            else

            {

            aCacheEntry.iCacheHandler = cache;

            }

           } //end if( cache )

        }//end  if( iCacheEnabled || iVSSCacheEnabled )

    return status;

    }

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

// CHttpCacheManager::RequestHeadersL

//

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

//

EXPORT_C TInt CHttpCacheManager::RequestHeadersL(

    RHTTPTransaction& aTrans,

    THttpCacheEntry& aCacheEntry )

    {

    TInt status( KErrNotFound );

    if( ( iCacheEnabled || iVSSCacheEnabled ) && aCacheEntry.iCacheHandler )

        {

        status = aCacheEntry.iCacheHandler->RequestHeadersL( aTrans, aCacheEntry );

        }

    return status;

    }

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

// CHttpCacheManager::RequestNextChunkL

//

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

//

EXPORT_C HBufC8* CHttpCacheManager::RequestNextChunkL(

    RHTTPTransaction& aTrans,

    TBool& aLastChunk,

    THttpCacheEntry& aCacheEntry )

    {

    HBufC8* bodyStr = NULL;

    if( ( iCacheEnabled || iVSSCacheEnabled ) && aCacheEntry.iCacheHandler )

        {

        bodyStr = aCacheEntry.iCacheHandler->RequestNextChunkL( aTrans, aLastChunk, aCacheEntry );

        }

    return bodyStr;

    }

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

// CHttpCacheManager::RequestClosed

//

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

//

EXPORT_C void CHttpCacheManager::RequestClosed(

    RHTTPTransaction* aTrans,

    THttpCacheEntry& aCacheEntry )

    {

    if( ( iCacheEnabled || iVSSCacheEnabled ) && aCacheEntry.iCacheHandler )

        {

        aCacheEntry.iCacheHandler->RequestClosed( aTrans, aCacheEntry );

        }

    }

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

// CHttpCacheManager::ReceivedResponseHeadersL

//

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

//

EXPORT_C void CHttpCacheManager::ReceivedResponseHeadersL(

  RHTTPTransaction& aTrans,

    THttpCacheEntry& aCacheEntry )

    {

    if ( iCacheEnabled || iVSSCacheEnabled )

        {

        if ( iVSSCacheEnabled &&

             VSSRequestCheckL( aTrans, aTrans.Response().GetHeaderCollection(),

                               aTrans.Request().URI().UriDes() ) )

            {

            //Modify the cache handler if VSS specific

            aCacheEntry.iCacheHandler = iphoneSpecificCache;

            }

        if ( aCacheEntry.iCacheHandler )

            {

            aCacheEntry.iCacheHandler->ReceivedResponseHeadersL( aTrans, aCacheEntry );

            }

        }

    }

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

// CHttpCacheManager::ReceivedResponseBodyDataL

//

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

//

EXPORT_C void CHttpCacheManager::ReceivedResponseBodyDataL(

  RHTTPTransaction& aTrans,

    MHTTPDataSupplier& aBodyDataSupplier,

    THttpCacheEntry& aCacheEntry )

    {

    if( ( iCacheEnabled || iVSSCacheEnabled ) && aCacheEntry.iCacheHandler )

        {

        aCacheEntry.iCacheHandler->ReceivedResponseBodyDataL( aTrans, aBodyDataSupplier, aCacheEntry );

        }

    }

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

// CHttpCacheManager::ResponseComplete

//

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

//

EXPORT_C void CHttpCacheManager::ResponseComplete(

    RHTTPTransaction& aTrans,

    THttpCacheEntry& aCacheEntry )

    {

    if( ( iCacheEnabled || iVSSCacheEnabled ) && aCacheEntry.iCacheHandler )

        {

        aCacheEntry.iCacheHandler->ResponseComplete( aTrans, aCacheEntry );

        }

    }

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

// CHttpCacheManager::RemoveAllL

// Removes all files from HTTP cache. Also tries to remove orphaned files,

// i.e files found on disk, but not registered in the cache's lookup table

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

//

EXPORT_C TInt CHttpCacheManager::RemoveAllL()

    {

    TInt numOfBytes( 0 );

    // do not remove op cache

    if( iCacheEnabled )

        {

        numOfBytes = iCache->RemoveAllL();

        }

    //failure here is not mission critical

    TRAP_IGNORE( RemoveOrphanedFilesL() );

    return numOfBytes;

    }

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

// CHttpCacheManager::RemoveOrphanedFilesL

// Removes header/body files that exist on the file-system, but are not known to the in-memory Cache lookup table(s)

// We do this because cache performance degrades substantially if there are too many files in a Symbian FAT32 directory.

// Browser crash or out-of-battery situations may cause SaveLookuptable() to be not called, leading to such "orphaned files".

// Due to high file-server interaction, don't call this method from performance critical code.

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

void CHttpCacheManager::RemoveOrphanedFilesL()

    {

    // Only proceed if we are running the browser configuration, otherwise we will accidentally

    // remove content we shouldn't.

    // get our SID.

    if( !IsBrowser() )

        return;

    // Step 1. Get map of disk content

    RFs rfs;

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

    CleanupClosePushL( rfs );

    // Map that contains pointers to fully-qualified file paths as Keys, and "to be deleted flag" as Value.

    // Initially we mark everything as a candidate for deletion.

    CHttpCacheFileHash *onDiskFilesMap = NULL;

    HttpCacheUtil::GenerateCacheContentHashMapL( onDiskFilesMap, rfs, iCacheFolder, KCacheFileNeedsDelete );

    CleanupStack::PushL( onDiskFilesMap );

    // mark everything in the cache as no delete needed.

    MarkAllCacheContentAsNoDelete( onDiskFilesMap );

    // tell any other clients that we are about to remove their cached content

    WipeAllOtherIndexFilesL( onDiskFilesMap, rfs );

    // delete any remaining marked files

    DeleteMarkedFilesL( onDiskFilesMap, rfs );

    CleanupStack::PopAndDestroy(1, onDiskFilesMap );

    CleanupStack::PopAndDestroy(1, &rfs );

    }

void CHttpCacheManager::MarkAllCacheContentAsNoDelete( CHttpCacheFileHash* aOnDiskFilesMap )

    {

    //Step 2. Get list of known (non-orphaned) files in each Cache's in-memory lookup table. Flag them as DO NOT DELETE

    //Ask CacheHandlers to add their KNOWN files to this array. No ownership transfer occurs.

    //Don't go ahead if any of the cache handlers choke to insure correct deletion of files.

    if( iCache )

        iCache->ValidateCacheEntriesL(aOnDiskFilesMap);

    if( iOperatorCache )

        iOperatorCache->ValidateCacheEntriesL(aOnDiskFilesMap);

    if( iphoneSpecificCache )

        iphoneSpecificCache->ValidateCacheEntriesL(aOnDiskFilesMap);

    }

void CHttpCacheManager::GenerateEmptyIndexFileL(const TDesC& aIndexFile, RFs& aRfs )

    {

    // Going to remove non-web client cache files in OrphanedFilesL call,

    // Signal to these clients by emptying (or creating) an 'empty' index file

    // do this before we start cleaning up files, to lessen the chances that any

    // of the files are in use when we're trying to delete them.

    // 'adopt' code from httpcachelookuptable for dealing with indexes.

    // save entries to index.dat

    RFileWriteStream writeStream;

    TInt ret = KErrNone;

    TInt tryCount = 0;

    for (tryCount = 0; tryCount < 5; tryCount++) 

        {

        ret = writeStream.Replace( aRfs, aIndexFile, EFileWrite );

        if (ret == KErrInUse)

            {

            // When the cache is full, it takes 65 - 85 miliseconds to write the index.

            // So wait 50 miliseconds and try again

            User::After(50000);

            }

        else

            {

            break;

            }

        }

    if( ret == KErrNone )

        {

        CleanupClosePushL( writeStream );

        writeStream.WriteInt32L( KCacheVersionNumber );

        writeStream.WriteInt32L( 0 ); // no entries in the index.

        writeStream.CommitL();

        CleanupStack::PopAndDestroy(); // writeStream

        }

    }

void CHttpCacheManager::WipeAllOtherIndexFilesL( CHttpCacheFileHash* aOnDiskFilesMap, RFs& aRfs )

    {

    // look through hashmap for any .dat files which don't belong to the instantiated caches and overwrite them with blank ones.

    THttpCacheFileHashIter iter( aOnDiskFilesMap->HashMap() );

    const TDesC* key;

    while ((key = iter.NextKey()) != 0)

        {

        const TFileInfo* value ( (iter.CurrentValue()) );

        if( value->iUserInt == KCacheFileNeedsDelete )

            {

            TPtrC ext( key->Right(KIndexFileExtension().Length()) );