/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

// USER INCLUDE

#include "blacklistserver.h"

#include "blacklistcommon.h"

#include "blacklistsession.h"

#include "blacklistitem.h"

#include "harvesterlog.h"

#include "mdssqliteconnection.h"

#include "mdcserializationbuffer.h"

// Security policy

const TUint KServerPolicyRangeCount = 6;

// Database file without the drive letter

_LIT( KBlacklistDatabaseFile, ":[2001B2EB]blacklistdb.sq" );

const TInt KServerPolicyRanges[KServerPolicyRangeCount] =

    {

    EBlacklistAdd,

    EBlacklistRemove,

    EBlacklistRemoveFromDB,

    EGetBlacklistData,

    EBlacklistCloseDB,

    EMaxService    

    };

const TUint8 KServerPolicyElementsIndex[KServerPolicyRangeCount] =

    {

    CPolicyServer::ECustomCheck, // EBlacklistAdd   

    CPolicyServer::ECustomCheck, // EBlacklistRemove

    CPolicyServer::ECustomCheck, // EBlacklistRemoveFromDB   

    CPolicyServer::ECustomCheck, // EGetBlacklistData   

    CPolicyServer::ECustomCheck, // EBlacklistCloseDB

    CPolicyServer::ECustomCheck  // EMaxService  

    };

const CPolicyServer::TPolicy KServerPolicy =

    {

    CPolicyServer::EAlwaysPass, // specifies all connect attempts should pass

    KServerPolicyRangeCount,                   

    KServerPolicyRanges,

    KServerPolicyElementsIndex,

    NULL

    };

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

// CBlacklistServer::CustomSecurityCheckL()

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

//

CPolicyServer::TCustomResult CBlacklistServer::CustomSecurityCheckL(

        const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/ )

	{

    WRITELOG( "CBlacklistServer::CustomSecurityCheckL - begin" );

    CPolicyServer::TCustomResult securityCheckResult = EFail;

    switch ( aMsg.Function() )

    	{

    	case EBlacklistAdd:

    	case EBlacklistRemove:

    	case EBlacklistRemoveFromDB:

    	case EGetBlacklistData:

    	case EBlacklistCloseDB:

    	case EMaxService:

		    {

            if( aMsg.HasCapability( ECapabilityWriteDeviceData ) )

                {

                securityCheckResult = EPass;

                }

    		}

            break;

        default:

            {

            securityCheckResult = EFail;

            }

   	    }

    WRITELOG( "CBlacklistServer::CustomSecurityCheckL - end" );

    return securityCheckResult;

	}

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

// CBlacklistServer::CustomFailureActionL()

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

//

CPolicyServer::TCustomResult CBlacklistServer::CustomFailureActionL(

        const RMessage2& /*aMsg*/, TInt /*aAction*/, const TSecurityInfo& /*aMissing*/ )

	{

    WRITELOG( "CBlacklistServer::CustomFailureActionL" );

    // Not used

    return EFail;

	}

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

// CBlacklistServer::NewL()

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

//

CBlacklistServer* CBlacklistServer::NewL()

    {

    WRITELOG( "CBlacklistServer::NewL - begin" );

    CBlacklistServer* self = NewLC();

    CleanupStack::Pop( self );

    WRITELOG( "CBlacklistServer::NewL - end" );

    return self;

    }

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

// CBlacklistServer::NewLC()

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

//

CBlacklistServer* CBlacklistServer::NewLC()

    {

    WRITELOG( "CBlacklistServer::NewLC - begin" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    WRITELOG( "CBlacklistServer::NewLC - end" );

    return self;

    }

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

// CBlacklistServer::CBlacklistServer()

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

//

CBlacklistServer::CBlacklistServer() : 

    CPolicyServer( CActive::EPriorityStandard, KServerPolicy, ESharableSessions )

    {

    }

void CBlacklistServer::ConstructL()

    {

    WRITELOG( "CBlacklistServer::ConstructL - begin" );

    if ( error != KErrNone )

        {

        __ASSERT_DEBUG( EFalse, User::Panic( KBlacklistServerName, error ));

        }

    iSqLiteConnection = CMdSSqLiteConnection::NewL();

    WRITELOG( "CBlacklistServer::ConstructL - end" );

    }

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

// CBlacklistServer::~CBlacklistServer()

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

//

CBlacklistServer::~CBlacklistServer()

    {

    WRITELOG( "CBlacklistServer::~CBlacklistServer - begin" );

    if ( iDatabaseOpen )

        {

        if( iSqLiteConnection )

            {

            iSqLiteConnection->CloseDb();

            }

        }

    iBlacklistMemoryTable.ResetAndDestroy();

    iBlacklistMemoryTable.Close();

    const TInt KRowCountRemovedItems = iBufferedRemoveItems.Count();

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

    	{

    	iBufferedRemoveItems[i]->Close();

    	}

    iBufferedRemoveItems.ResetAndDestroy();

    iBufferedRemoveItems.Close();  	

    const TInt KRowCountAddedItems = iBufferedAddedItems.Count();

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

    	{

    	iBufferedAddedItems[i]->Close();

    	}

   	iBufferedAddedItems.ResetAndDestroy();

    iBufferedAddedItems.Close();  	

   	iBlacklistServerChunk.Close();

    delete iSqLiteConnection;

    WRITELOG( "CBlacklistServer::~CBlacklistServer - end" );

    }

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

// Closes database connection.

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

//

void CBlacklistServer::CloseDB()

    {

    WRITELOG( "CBlacklistServer::CloseDB - begin" );

    if ( iDatabaseOpen )

        {

        iSqLiteConnection->CloseDb();

        iDatabaseOpen = EFalse;

        }

    WRITELOG( "CBlacklistServer::CloseDB - end" );

    }

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

// CBlacklistServer::ExeMainL()

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

//

void CBlacklistServer::ExeMainL()

    {

    WRITELOG( "CBlacklistServer::ExeMainL - begin" );

    // Install active scheduler

    CActiveScheduler* scheduler = new( ELeave ) CActiveScheduler;

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    CBlacklistServer::NewLC();

    User::LeaveIfError( User::RenameThread( KBlacklistServerName ) );

    RProcess::Rendezvous( KErrNone );

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( 2, scheduler );  

    WRITELOG( "CBlacklistServer::ExeMainL - end" );

    }

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

// TInt E32Main()

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

//

TInt E32Main()

    {

    WRITELOG( "CBlacklistServer::E32Main - begin" );

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TRAPD( error, CBlacklistServer::ExeMainL() );

    __ASSERT_ALWAYS( !error, User::Panic( KBlacklistServerName, error ) );

    delete cleanup;

    __UHEAP_MARKEND;

    WRITELOG( "CBlacklistServer::E32Main - end" );

    return 0;

    }

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

//  CBlacklistServer::OpenDatabaseL()

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

//

void CBlacklistServer::OpenDatabaseL()

    {

    WRITELOG( "CBlacklistServer::OpenDatabaseL - begin" );

    if ( iDatabaseOpen )

        {

        return; 

        }

    HBufC* databasePath = HBufC::NewLC( KMaxFileName );

    TPtr pathPtr = databasePath->Des();

    pathPtr.Append( PathInfo::PhoneMemoryRootPath()[0] );

    pathPtr.Append( KBlacklistDatabaseFile );

    iSqLiteConnection->OpenDbL( pathPtr );

    iDatabaseOpen = ETrue; 

    CleanupStack::PopAndDestroy( databasePath );

    // Add or remove operations when DB connection was off  

    if ( iDBUpdateNeeded )

        {

        CommitBufferedItemsL();        

        }

    if ( !TableExistsL() )

        {

        CreateBlacklistTableL();

        }

    LoadDatabaseToMemoryL();

    // serialize it for client

    SerializeToSharedMemoryL();

    WRITELOG( "CBlacklistServer::OpenDatabaseL - end" );

    }

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

// CBlacklistServer::SerializeToSharedMemoryL()

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

//

void CBlacklistServer::SerializeToSharedMemoryL()

	{

    WRITELOG( "CBlacklistServer::SerializeToSharedMemoryL - begin" );

	TUint32 bufferSize = 0;

	TUint32 blacklistMemoryTableCount = iBlacklistMemoryTable.Count();

    // First add size for item count

    bufferSize += CMdCSerializationBuffer::KRequiredSizeForTUint32;

    // Add size for items

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

		{

		bufferSize += iBlacklistMemoryTable[i]->RequiredBufferSize();

		}

	// create chunk

	iBlacklistServerChunk.Close();

	iHandle++;

	HBufC* name = HBufC::NewLC( KBlacklistChunkName.iTypeLength + KMaxUintValueLength );

   	*name = KBlacklistChunkName;

	name->Des().AppendNum( iHandle );

	User::LeaveIfError( iBlacklistServerChunk.CreateGlobal( *name, bufferSize, bufferSize ) );

	CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( iBlacklistServerChunk.Base(), bufferSize );

	// first inser table count

	buffer->InsertL( blacklistMemoryTableCount );

	// then items

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

	    {

   	    // add modified and media id field

   	    buffer->InsertL( iBlacklistMemoryTable[i]->Modified() );

   	    buffer->InsertL( iBlacklistMemoryTable[i]->MediaId() );

		// add uri

       	const TDesC& uri =  *iBlacklistMemoryTable[i]->Uri();

	    HBufC* lcUri = HBufC::NewLC( uri.Length() );

		lcUri->Des().Append( uri );

		buffer->InsertL( *lcUri );

		CleanupStack::PopAndDestroy( lcUri ); 

        lcUri = NULL;

        }

	CleanupStack::PopAndDestroy( 2, name );

	// No need to keep these items anymore

	iBlacklistMemoryTable.ResetAndDestroy();

    WRITELOG( "CBlacklistServer::SerializeToSharedMemoryL - end" );

	}

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

// CBlacklistServer::Handle() 

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

//

TInt CBlacklistServer::MemoryHandle()

    {

    WRITELOG( "CBlacklistServer::MemoryHandle" );

    return iHandle;

    }

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

// CBlacklistServer::LoadDatabaseToMemoryL()

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

//

void CBlacklistServer::LoadDatabaseToMemoryL()

    {

    WRITELOG( "CBlacklistServer::LoadDatabaseToMemoryL - begin" );

    iBlacklistMemoryTable.ResetAndDestroy();

    RMdsStatement statement;

    CleanupClosePushL( statement );

    RRowData emptyRowData;

    CleanupClosePushL( emptyRowData );

    iSqLiteConnection->ExecuteQueryL( KMdsBlacklistCache, statement, emptyRowData );

    TPtrC ptr = TPtrC( (TUint16*)0, 0 );

    TInt64 modified = 0;

    TUint32 mediaId = 0;

    RRowData result;

    CleanupClosePushL( result );

    result.AppendL( TColumn( ptr ) );

    result.AppendL( TColumn( mediaId ) );

    result.AppendL( TColumn( modified ) );

    while ( iSqLiteConnection->NextRowL( statement, result ) )

        {

        result.Column( 0 ).Get( ptr );      

        result.Column( 1 ).Get( mediaId );

        result.Column( 2 ).Get( modified );

        AddToMemoryTableL( modified, ptr, mediaId );

        result.Column( 0 ).Free();

        }

    CleanupStack::PopAndDestroy( &result );        

    CleanupStack::PopAndDestroy( &emptyRowData ); 

    CleanupStack::PopAndDestroy( &statement ); 

    WRITELOG( "CBlacklistServer::LoadDatabaseToMemoryL - end" );

    }

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

// CBlacklistServer::CreateBlacklistTableL()

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

//

void CBlacklistServer::CreateBlacklistTableL()

    {

    WRITELOG( "CBlacklistServer::CreateBlacklistTableL - begin" );

    RRowData emptyRowData;

    CleanupClosePushL( emptyRowData );

    iSqLiteConnection->ExecuteL( KDropBlacklistTable, emptyRowData );

    iSqLiteConnection->ExecuteL( KCreateBlacklistTable, emptyRowData );

	CleanupStack::PopAndDestroy( &emptyRowData );

    WRITELOG( "CBlacklistServer::CreateBlacklistTableL - end" );

    }

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

// CBlacklistServer::AddToMemoryTableL

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

//

void CBlacklistServer::AddToMemoryTableL( const TInt64& aModified,

        const TDesC& aUri, const TUint32 aMediaId )

    {

    WRITELOG( "CBlacklistServer::AddToMemoryTableL - begin" );

    CBlacklistItem* item = CBlacklistItem::NewL( aModified, aUri, aMediaId );

    const TInt err = iBlacklistMemoryTable.Append( item ); // ownership is transferred

    if ( err != KErrNone )

        {

        delete item;

        }

    WRITELOG( "CBlacklistServer::AddToMemoryTableL - end" );

    }

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

// CBlacklistServer::RemoveFromMemoryTable()

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

//

void CBlacklistServer::RemoveFromMemoryTable( const TDesC& aUri,

        const TUint32 aMediaId )

    {

    WRITELOG( "CBlacklistServer::RemoveFromMemoryTable - begin" );

    if ( index >= 0 )

        {

        CBlacklistItem * item = iBlacklistMemoryTable[index];

        delete item;

        iBlacklistMemoryTable.Remove( index );

        }

    WRITELOG( "CBlacklistServer::RemoveFromMemoryTable - end" );

    }

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

// CBlacklistServer::GetMemoryTableIndex()

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

//

TInt CBlacklistServer::GetMemoryTableIndex( const TDesC& aUri, TUint32 aMediaId )

    {

    WRITELOG( "CBlacklistServer::GetMemoryTableIndex - begin" );

    for ( TInt i( 0 ); i < iBlacklistMemoryTable.Count(); ++i )

        {

        if ( iBlacklistMemoryTable[i]->Compare( aUri, aMediaId ) )

            {

            return i;

            }

        }

    WRITELOG( "CBlacklistServer::GetMemoryTableIndex - end" );

    return KErrNotFound;

    }

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

// CBlacklistServer::TableExistsL()

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

//

TBool CBlacklistServer::TableExistsL()

    {

    WRITELOG( "CBlacklistServer::TableExistsL - begin" );

    RMdsStatement validationQuery;

    CleanupClosePushL( validationQuery );

    RRowData emptyRowData;

    CleanupClosePushL( emptyRowData );

    TRAPD( err, iSqLiteConnection->ExecuteQueryL(

    		KMdsBlacklistCheckTableExistence, validationQuery, emptyRowData ) );

	validationQuery.Close();

	CleanupStack::PopAndDestroy( &emptyRowData ); // emptyRowData

	CleanupStack::PopAndDestroy( &validationQuery ); // validationQuery

    WRITELOG( "CBlacklistServer::TableExistsL - end" );

    return ( err == KErrNone );