/*

* Copyright (c) 2002 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 popupblocking

*

*

*/

// INCLUDES

#include <Uri16.h>

#include "BrowserPopupEngine.h"

#include <f32file.h>

#include "logger.h"

#include "BrowserUtil.h"

// CONSTANTS

_LIT( KWhiteListFileName, "bpopupwl.db" );

_LIT( KWhiteTmpFileName, "bpopwtmp.db" );

_LIT( KWhiteBkpFileName, "bpopbbkp.db" );

_LIT( KEndMark, "\n" );

const TInt KArrayGranularity = 10;

const TInt KCacheSize = 32;//The maximum size of the memory cache

const TInt KMaxDbSize = 16384;// (255/max length of the domain/+1/\n/)*64

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

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

// CBrowserPopupEngine::CBrowserPopupEngine()

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

//

CBrowserPopupEngine::CBrowserPopupEngine()

    {

    }

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

// CBrowserPopupEngine::~CBrowserPopupEngine

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

//

CBrowserPopupEngine::~CBrowserPopupEngine()

    {

    iWhiteListFile.Flush();

    iWhiteListFile.Close();

    iFs.Close();

    delete iCachedWhiteUrls;

    }

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

// CBrowserPopupEngine::NewLC

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

//

CBrowserPopupEngine* CBrowserPopupEngine::NewLC()

    {

    CBrowserPopupEngine* self = new (ELeave) CBrowserPopupEngine;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CBrowserPopupEngine::NewL

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

//

CBrowserPopupEngine* CBrowserPopupEngine::NewL()

    {

    CBrowserPopupEngine* self = new (ELeave) CBrowserPopupEngine;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CBrowserPopupEngine::ConstructL

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

//

void CBrowserPopupEngine::ConstructL()

    {

LOG_ENTERFN("CBrowserPopupEngine::ConstructL");

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

//open databases

    BROWSER_LOG( ( _L( "<-Popup engine-> RFs Connected." ) ) );

    OpenDatabaseL( &iWhiteListFile );

    BROWSER_LOG( ( _L( "<-Popup engine-> white file opened." ) ) );

//Create memory cache 

    iCachedWhiteUrls = new(ELeave) CDesCArrayFlat(KArrayGranularity);

    BROWSER_LOG( ( _L( "<-Popup engine-> Cache created." ) ) );

    iCachedWhiteUrls->Reset();

//Load some to memory cache

    LoadUrlsToCacheL( &iWhiteListFile, iCachedWhiteUrls, &iWhiteCacheNo);

    BROWSER_LOG( ( _L( "<-Popup engine-> Urls loaded to cache." ) ) );

    }

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

// CBrowserPopupEngine::OpenDatabaseL

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

//

void CBrowserPopupEngine::OpenDatabaseL(RFile* aFile)

    {

LOG_ENTERFN("CBrowserPopupEngine::OpenDatabaseL");

	__ASSERT_DEBUG( (aFile != NULL), Util::Panic( Util::EUninitializedData ));

    TInt err;

    RFile tmpFile;

    TPtrC fileNamePtr;

    TPtrC bkpFileNamePtr;

    TBuf<KMaxFileName> privatePath;

    TBuf<KMaxFileName> listFileName;

    TBuf<KMaxFileName> bkpFileName;

    TBuf<KMaxFileName> tmpFileName;

    iFs.PrivatePath( privatePath );

    listFileName.Copy( privatePath );

    listFileName.Append( KWhiteListFileName );

    bkpFileName.Copy( privatePath );

    bkpFileName.Append( KWhiteBkpFileName );

    tmpFileName.Copy( privatePath );

    tmpFileName.Append( KWhiteTmpFileName );

    err = aFile->Open( iFs, listFileName, EFileWrite | EFileStream | EFileShareExclusive );

    BROWSER_LOG( ( _L( "<-Popup engine-> File open error: %d" ), err ) );

    if ( err == KErrNotFound ) 

        {

        err = tmpFile.Open( iFs, bkpFileName, EFileWrite | EFileShareExclusive );

        if( err != KErrNone )

            {

            err = aFile->Create( iFs, listFileName, EFileWrite | EFileShareExclusive );

            BROWSER_LOG( ( _L( "<-Popup engine-> white file created." ) ) );

            }

        else 

            {

//check validity of tmp file if the last char is \n it is probably OK

            if( !CheckDbValidity( &tmpFile ) )

                {

                User::LeaveIfError( 

                    aFile->Create( iFs, listFileName, 

                        EFileWrite | EFileShareExclusive ) );

                }

            else

                {

//rename tmp to origin

                err = tmpFile.Rename( listFileName );

                if(err == KErrNone)

                    {

                    tmpFile.Close();

                    User::LeaveIfError(aFile->Open( iFs, listFileName, EFileWrite | EFileStream | EFileShareExclusive ) );

                    }

                else

                    {

                    User::LeaveIfError( 

                        aFile->Create( iFs, listFileName, 

                            EFileWrite | EFileShareExclusive ) );

                    }

                }

            }

        }

    else if ( err == KErrPathNotFound )

        {

        User::LeaveIfError( iFs.CreatePrivatePath( EDriveC ) );

        User::LeaveIfError(

            aFile->Create( iFs, listFileName, EFileWrite | EFileShareExclusive ) );

        }

    else if((err != KErrInUse)&&( err != KErrNone ))

        {

        User::Leave(err);

        }

    else if( !CheckDbValidity( aFile ) )

        {

//if the file is not valid delete it and create a new one

        aFile->Close();

        User::LeaveIfError( iFs.Delete( listFileName ) );

        User::LeaveIfError(

            aFile->Create( iFs, listFileName, EFileWrite | EFileShareExclusive ) );

        }

//delete tmp and bkp files if they exist

    iFs.Delete( tmpFileName );

    iFs.Delete( bkpFileName );

    }

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

// CBrowserPopupEngine::AddUrlToWhiteListL

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

//

void CBrowserPopupEngine::AddUrlToWhiteListL(const TDesC& aUrl)

    {

LOG_ENTERFN("CBrowserPopupEngine::AddUrlToWhiteListL");

    TUriParser16 urlParser;

    BROWSER_LOG( ( _L( "<-Popup engine-> url to add to white list : %S" ), &aUrl ) );

//check whether file allready exists in list

    /*if( IsUrlOnWhiteListL( aUrl ) )

        {

        RDebug::Print(_L("<-Popup engine-> url is in white cache allready.\n"));

        return;

        }*/

//get the domain from the url

    urlParser.Parse(aUrl);

    if( urlParser.IsSchemeValid() )

        {

//write domain to file

        HandleUrlOrderChangeL( &iWhiteListFile, urlParser.Extract( EUriHost), EFalse, ETrue );

//add domain to memory cache

        AddUrlToCacheL( iCachedWhiteUrls, urlParser.Extract( EUriHost) );

        }

    else

        {

        User::Leave( KErrBadName );

        }

    }

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

// CBrowserPopupEngine::IsUrlOnWhiteListL

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

//

TBool CBrowserPopupEngine::IsUrlOnWhiteListL(const TDesC& aUrl)

    {

LOG_ENTERFN("CBrowserPopupEngine::IsUrlOnWhiteListL");

    TUriParser16 urlParser;

    urlParser.Parse(aUrl);

    if( !urlParser.IsSchemeValid() )

        {

        User::Leave( KErrBadName );

        }

//look for URL in memory cache

    if( IsUrlInWhiteCacheL( urlParser.Extract( EUriHost) ) )

        {

        BROWSER_LOG( ( _L( "<-Popup engine-> url is in white cache." ) ) );

        HandleUrlOrderChangeL( &iWhiteListFile, urlParser.Extract( EUriHost), ETrue, ETrue );

        return ETrue;

        }

//look for URL in file

    if( IsUrlInWhiteFileL( urlParser.Extract( EUriHost) ) )

        {

        HandleUrlOrderChangeL( &iWhiteListFile, urlParser.Extract( EUriHost), ETrue, ETrue );

//if found and not in memory cache put it there

        AddUrlToCacheL( iCachedWhiteUrls, urlParser.Extract( EUriHost) );

        BROWSER_LOG( ( _L( "<-Popup engine-> url is in white file." ) ) );

        return ETrue;

        }

    BROWSER_LOG( ( _L( "<-Popup engine-> url is not on white list." ) ) );

    return EFalse;

    }

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

// CBrowserPopupEngine::IsUrlInWhiteCacheL

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

//

TBool CBrowserPopupEngine::IsUrlInWhiteCacheL(const TDesC& aUrl)

    {

    return IsUrlInCacheL( iCachedWhiteUrls, aUrl, iWhiteCacheNo );

    }

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

// CBrowserPopupEngine::IsUrlInWhiteFileL

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

//

TBool CBrowserPopupEngine::IsUrlInWhiteFileL(const TDesC& aUrl)

    {

    return IsUrlInFileL( &iWhiteListFile , aUrl );

    }

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

// CBrowserPopupEngine::IsUrlInFileL

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

//

TBool CBrowserPopupEngine::IsUrlInFileL(const RFile* aFile, const TDesC& aUrl)

    {

   	__ASSERT_DEBUG( (aFile != NULL), Util::Panic( Util::EUninitializedData ));

    HBufC8* line = HBufC8::NewL( 256 );

    CleanupStack::PushL( line );

    HBufC8* parturl = HBufC8::NewL( 256 );

    CleanupStack::PushL( parturl );

    TInt match = 1;

    TInt pos = 0;

    TInt result;

    TPtrC16 linePtr16;

    HBufC8* url8 = TDesC16ToHBufC8LC( aUrl );

    User::LeaveIfError( aFile->Seek( ESeekStart, pos ) );

    TPtr8 linePtr = line->Des();

    result = aFile->Read( linePtr );

    parturl->Des().Zero();

    while ( ( line->Des().Length() > 0 ) && ( result == KErrNone ) ) 

        {

        if(parturl->Des().Length() != 0 )

            {

            pos = linePtr.Locate( '\n' );

            parturl->Des().Append( linePtr.Left( pos ) );

            match = url8->Des().Compare( parturl->Des() );

            if( match == 0 )

                {

                CleanupStack::PopAndDestroy( 3 );

                return ETrue;

                }

            parturl->Des().Zero();

            }

        match = linePtr.Find( url8->Des() );

        if( match == KErrNotFound )

            {

            pos = linePtr.LocateReverse( '\n' );

            if(( linePtr.Length() != pos )&&( linePtr.Length() > 1 ))

                {

                parturl->Des().Append( linePtr.Mid( pos + 1, linePtr.Length() - pos - 1 ));

                }

            }

        else

            {

            CleanupStack::PopAndDestroy( 3 );

            return ETrue;

            }

        result = aFile->Read( linePtr, 256 );

        }

    CleanupStack::PopAndDestroy( 3 );

    User::LeaveIfError( result );

    return EFalse;

    }

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

// CBrowserPopupEngine::LoadUrlsToCacheL

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

//

void CBrowserPopupEngine::LoadUrlsToCacheL(const RFile* aFile, CDesCArrayFlat* aCacheArray, TInt* aLoadedUrlNo)

    {

LOG_ENTERFN( "PopupEngine::LoadUrlsToCacheL" );

	__ASSERT_DEBUG( (aFile != NULL), Util::Panic( Util::EUninitializedData ));

	__ASSERT_DEBUG( (aCacheArray != NULL), Util::Panic( Util::EUninitializedData ));

	__ASSERT_DEBUG( (aLoadedUrlNo != NULL), Util::Panic( Util::EUninitializedData ));

    TPtrC8 test;

    HBufC8* line = HBufC8::NewL( 256 );

    CleanupStack::PushL( line );

    HBufC8* parturl = HBufC8::NewL( 256  );

    CleanupStack::PushL( parturl );

    TInt result;

    TInt itemno = 0;

    TInt offset = 0;

    TInt prevOffset = 0;

    TPtr8 linePtr = line->Des();

    parturl->Des().Zero();

    User::LeaveIfError( aFile->Seek( ESeekStart, offset ) );

    result = aFile->Read( linePtr, 256 );

    while ( ( line->Des().Length() > 0 ) &&( result == KErrNone ) && ( itemno < KCacheSize )) 

        {

        offset = linePtr.Locate('\n' );

        if( parturl->Length() != 0 )

            {

            parturl->Des().Append( linePtr.Mid( prevOffset, offset ) );

            aCacheArray->AppendL(  *TDesC8ToHBufC16LC( parturl->Des() ) );

            CleanupStack::PopAndDestroy( );

            prevOffset = prevOffset + offset +1;

            itemno++;

            if( itemno == KCacheSize )

                {

                break;

                }

            offset = ( linePtr.Right( linePtr.Length() - prevOffset ) ).Locate('\n');

            }

        while(( offset != KErrNotFound ) && ( itemno < KCacheSize ))

            {

            aCacheArray->AppendL( *TDesC8ToHBufC16LC( linePtr.Mid( prevOffset, offset ) ) );

            CleanupStack::PopAndDestroy( );

            prevOffset = prevOffset + offset +1;

            itemno++;

            offset = ( linePtr.Right( linePtr.Length() - prevOffset ) ).Locate('\n' );

            }

        if( prevOffset != linePtr.Length() )

            {

            parturl->Des().Zero();

            parturl->Des().Append( linePtr.Right( linePtr.Length() - prevOffset ));

            }

        prevOffset = 0;

        result = aFile->Read( linePtr, 256 );

        }

    *aLoadedUrlNo = itemno;

    CleanupStack::PopAndDestroy( 2 );

    User::LeaveIfError( result );

    }

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

// CBrowserPopupEngine::IsUrlInCacheL

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

//

TBool CBrowserPopupEngine::IsUrlInCacheL( const CDesCArrayFlat* aCacheArray, const TDesC& aUrl, const TInt aLoadedurlno )

    {

LOG_ENTERFN("CBrowserPopupEngine::IsUrlInCacheL");

	__ASSERT_DEBUG( (aCacheArray != NULL), Util::Panic( Util::EUninitializedData ));

    TInt itemno=0;

    BROWSER_LOG( ( _L( "<-Popup engine-> url to find in cache : %S" ), &aUrl ) );

    while( ( itemno < aLoadedurlno ) && ( aUrl.Compare((*aCacheArray)[ itemno ]) != 0 ) )

        {

        itemno++;

        }

    if( itemno != aLoadedurlno )

        {

        BROWSER_LOG( ( _L( "<-Popup engine-> url found in cache" ) ) );

        return ETrue;

        }

    BROWSER_LOG( ( _L( "<-Popup engine-> url not found in cache" ) ) );

    return EFalse;

    }

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

// CBrowserPopupEngine::AddUrlToCacheL

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

//

void CBrowserPopupEngine::AddUrlToCacheL( CDesCArrayFlat* aCacheArray, const TDesC& aUrl )

    {

LOG_ENTERFN("CBrowserPopupEngine::AddUrlToCacheL");

	__ASSERT_DEBUG( (aCacheArray != NULL), Util::Panic( Util::EUninitializedData ));

    if( iWhiteCacheNo < KCacheSize )

        {

        aCacheArray->AppendL( aUrl );

        iWhiteCacheNo++;

        BROWSER_LOG( ( _L( "<-Popup engine-> url added to cache : %S" ), &aUrl ) );

        }

    else

        {

        BROWSER_LOG( ( _L( "<-Popup engine-> url not added to cache : %S" ), &aUrl ) );

        }

    }

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

// CBrowserPopupEngine::TDesC16ToTPtrC8

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

//

TPtrC8 CBrowserPopupEngine::TDesC16ToTPtrC8(const TDesC16 &aString)

    {

    TPtrC8 ptr8(reinterpret_cast<const TUint8*>(aString.Ptr()),(aString.Length()*2));

    return ptr8;

    }

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

// CBrowserPopupEngine::TDesC8ToTPtrC16

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

//

TPtrC16 CBrowserPopupEngine::TDesC8ToTPtrC16(const TDesC8 &aString)

    {

    TPtrC16 ptr16(reinterpret_cast<const TUint16*>(aString.Ptr()),(aString.Length()/2));

    return ptr16;

    }

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

// CBrowserPopupEngine::HandleUrlOrderChange

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

//

void CBrowserPopupEngine::HandleUrlOrderChangeL(RFile* aFile, const TDesC& aUrl, const TBool aExists,const TBool aToAdd )

    {

LOG_ENTERFN("CBrowserPopupEngine::HandleUrlOrderChangeL");

	__ASSERT_DEBUG( (aFile != NULL), Util::Panic( Util::EUninitializedData ));

    RFile tmpFile;

    TInt err, match;

    HBufC8* line = HBufC8::NewL( 256 );

    CleanupStack::PushL( line );

    HBufC8* parturl = HBufC8::NewL( 256 );

    CleanupStack::PushL( parturl );

    HBufC8* url8;

    parturl->Des().Zero();

    TPtr8 linePtr = line->Des();

    TPtrC8 linePtrOffset;

    TPtrC8 tmpPtr;

    TInt result;

    TInt pos = 0;

    TInt offset;

    TInt writtenSize = 0;

    TBuf<KMaxFileName> privatePath;

    TBuf<KMaxFileName> listFileName;

    TBuf<KMaxFileName> bkpFileName;

    TBuf<KMaxFileName> tmpFileName;

//set the filenames

    iFs.PrivatePath( privatePath );

    listFileName.Copy( privatePath );

    listFileName.Append( KWhiteListFileName );

    bkpFileName.Copy( privatePath );

    bkpFileName.Append( KWhiteBkpFileName );

    tmpFileName.Copy( privatePath );

    tmpFileName.Append( KWhiteTmpFileName );

//create a tmp file

    err = tmpFile.Create( iFs, tmpFileName, EFileWrite | EFileShareExclusive );

    if( err != KErrNone )

        {

        RDebug::Print(_L("Creation of tmp file failed.\n"));

        BROWSER_LOG( ( _L( "<-Popup engine-> Creation of tmp file failed." ) ) ); 

        User::LeaveIfError( err );

        }

//convert url to 8bit

    url8 = TDesC16ToHBufC8LC( aUrl );

//add url to tmp file

    if( aToAdd )

        {

//by url removal it is not needed to write the url

        tmpFile.Seek( ESeekStart, pos );

        tmpFile.Write( url8->Des() );

        tmpFile.Write( *TDesC16ToHBufC8LC( KEndMark )  );

        CleanupStack::PopAndDestroy();

        tmpFile.Flush();

        writtenSize = url8->Des().Size() + 1;

        }

//write all urls to tmp file except the if needed

    parturl->Des().Zero();

    User::LeaveIfError( aFile->Seek( ESeekStart, pos ) );

    result = aFile->Read( linePtr, 256 );

    linePtr.Set(line->Des());

    writtenSize += linePtr.Length();

    if ( aExists )

       {

       while ( ( line->Des().Length() > 0 ) &&( result == KErrNone ))

            {

            offset=0;

//if there was a part of an url check it too

            if( parturl->Length() != 0 )