/*

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

#include "HttpCacheHandler.h"

#include "HttpCacheUtil.h"

#include <CenRepNotifyHandler.h>

#include <HttpCacheManagerInternalCRKeys.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

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

_LIT( KDefaultIndexFile, "index.dat" );

_LIT( KDefaultOpIndexFile, "index_op.dat" );

_LIT( KDefaultVSSIndexFile, "index_vss.dat" );

_LIT( KIndexFileExtension, ".dat" );

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

_LIT8( KVSSHeaderFileldValue, "Portal" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

    {

    CreateCacheHandlersL();

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

    {

    delete iOfflineNotifyHandler;

    delete iOfflineRepository;

    delete iCache;

    delete iOperatorCache;

    delete iOpDomain;

    delete iphoneSpecificCache;

    delete iVSSWhiteList;

    }

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

// CHttpCacheManager::VSSRequestCheck

//

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

//

    {

    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 ( KVSSHeaderFileldName() );

        RStringF VSSnameStr = strP.OpenFStringL( nameStr );

        CleanupClosePushL<RStringF>( VSSnameStr);

        THTTPHdrVal tempVal;

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

            {

            TPtrC8 valueStr ( KVSSHeaderFileldValue() );

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

        __ASSERT_DEBUG( cache, User::Panic( _L("cacheHandler Panic"), KErrCorrupt ) );

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

                 {

                 }

                 else

                 {

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

                 }

            else

            {

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

    {

        {

            {

            //Modify the cache handler if VSS specific

            aCacheEntry.iCacheHandler = iphoneSpecificCache;

            }

            {

            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

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

    return numOfBytes;

    }

// Hash function for Symbian file paths: discards case first

static TUint32 FilepathHash(const TDesC& aDes)

{

    normalized.LowerCase();

    return DefaultHash::Des16( normalized );

}

static TBool FilepathIdent(const TDesC& aL, const TDesC& aR)

{

}

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

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

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

void CHttpCacheManager::RemoveOrphanedFilesL()

    {

    RPtrHashMap<TDesC, TInt> onDiskFilesMap(&FilepathHash, &FilepathIdent);

    CleanupClosePushL( onDiskFilesMap );

    //Pointers to the following TInt are used as VALUES in the HashMap...

    // so they must be in scope for the lifecycle of the HashMap.

    const TInt needsDelete( 1 );

    const TInt noDelete( 0 );

    RPointerArray<HBufC> cleanupList;

    CleanupResetAndDestroyPushL( cleanupList );

    RFs rfs = CCoeEnv::Static()->FsSession();

    CDirScan* scanner = CDirScan::NewLC( rfs );

    //Configure CDirScan to tell you all contents of a particular directory hierarchy

    scanner->SetScanDataL( iCacheFolder, KEntryAttNormal, ESortNone );

    CDir* matchingFiles( 0 );

    //Step 1. Find out all files on disk: by walking the directory hierarchy, one directory at a time

    for (;;)

        {

        scanner->NextL( matchingFiles );

        if ( !matchingFiles )

            break;

        //1b. Add any files found to the HashTable

        const TInt nMatches = matchingFiles->Count();

        for ( TInt i = 0; i < nMatches; i++ )

            {

                {

                HBufC* fullPath = HBufC::NewL( dir.Length() +  entry.iName.Length() );

                cleanupList.Append( fullPath ); //keep object safe for later destruction

                fullPath->Des().Append( dir );

                fullPath->Des().Append( entry.iName ); //a fully qualified file path

                onDiskFilesMap.Insert( fullPath, &needsDelete ); //add to the hash

                }

            }

        delete matchingFiles;

        } // End of step 1: adding all known files on disk to Map

    CleanupStack::PopAndDestroy( 1, scanner );

#ifdef __CACHELOG__

    {

    TPtrHashMapIter<TDesC, TInt> iter(onDiskFilesMap);

    const TDesC* key;

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

        {

        const TInt val = *(iter.CurrentValue());

        }

    }

#endif

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

    CleanupClosePushL( knownFiles );

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

    if (iCache)

    if (iOperatorCache)

        User::LeaveIfError( iOperatorCache->ListFiles( knownFiles ) );

    if (iphoneSpecificCache)

    //2a. HashTable lookup, and modification of flag

    for (TInt i = 0; i < knownFiles.Count(); i++)

        {

        //lookup filename

        TInt* ptr = onDiskFilesMap.Find( *(knownFiles[i]) );

        if (ptr)

            {

            // Reinsert into Map, this time with NO DELETE

            // Add the header file to HashMap

            cleanupList.Append( headerFile ); //keep for later destruction

            HttpCacheUtil::GetHeaderFileName( *(knownFiles[i]), ptr );

            onDiskFilesMap.Insert( headerFile, &noDelete ); // register Header files as NO DELETE

            }

        }

    CleanupStack::Pop( 1, &knownFiles );

    //Step 3. Delete all files on disk that don't belong to any of the Cache Handlers.

    CFileMan* fileMan = CFileMan::NewL( rfs );

    TPtrHashMapIter<TDesC, TInt> iter( onDiskFilesMap );

    const TDesC* key;

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

        {

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

        if ( value == 1 ) { // file needs deletion

            fileMan->Delete( *key );

        }

        }

    delete fileMan;